Moueed Ali

src/main/java/com/booleanuk/core/Task.java

@@ -0,0 +1,16 @@
+package com.booleanuk.core;
+
+public class Task {
+
+    String name;
+    boolean status;
+
+    public Task (String name) {
+        this.name = name;
+        this.status = false; // every new tasks default status is false/incomplete
+    }
+
+    void changeStatus(boolean status) {
+        this.status = status;
+    }
+}

src/main/java/com/booleanuk/core/TodoList.java

@@ -1,5 +1,79 @@
 package com.booleanuk.core;
 
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
 public class TodoList {
+    List<Task> taskList = new ArrayList<>();
+
+    public boolean addTask(Task tsk) {
+       if (taskList.contains(tsk)) { return false;}
+       else {taskList.add(tsk); return true;}
+    }
+
+
+    public List<Task> viewAllTasks() {
+        return taskList;
+    }
+
+    public boolean changeStatusOfTasks(Task tsk, boolean newStatus) {
+        for (Task t: taskList) {
+            if (t == tsk && t.status != newStatus) {
+                t.status = newStatus;
+                return true;
+            }
+        }
+        return newStatus;
+    }
+
+    public ArrayList<Task> getIncompleteTasks() {
+        ArrayList<Task> incompleteTasks = new ArrayList<>();
+        for (Task t : taskList) {
+            if (t.status == false) {
+                incompleteTasks.add(t);
+            }
+        }
+
+        return incompleteTasks;
+    }
+
+    public ArrayList<Task> getCompleteTask() {
+        ArrayList<Task> incompleteTasks = new ArrayList<>();
+        for (Task t : taskList) {
+            if (t.status == true) {
+                incompleteTasks.add(t);
+            }
+        }
+
+        return incompleteTasks;
+    }
+
+    public String checkIfTaskExists(Task tsk) {
+        if (!taskList.contains(tsk)) {return "Task does not exist";}
+        return "Task exists";
+    }
+
+    public boolean removeTask(Task tsk) {
+        if (taskList.contains(tsk)) {
+            taskList.remove(tsk);
+            return true;
+        }
+        return false;
+    }
+
+    public List<Task> ascOrder() {
+        List<Task> orderedList = new ArrayList<>(List.copyOf(this.taskList));
+
+        orderedList.sort((a, b) -> {return a.name.compareTo(b.name);});
+        return  orderedList;
+    }
+
+    public List<Task> descOrder() {
+        List<Task> orderedList = new ArrayList<>(List.copyOf(this.taskList));
+
+        orderedList.sort((a, b) -> {return b.name.compareTo(a.name);});
+        return  orderedList;
+    }
 
 }

src/main/java/com/booleanuk/domain-model.md

@@ -0,0 +1,41 @@
+# Supermarket
+
+---
++ I want to add tasks to my todo list.
++ I want to see all the tasks in my todo list.
++ I want to change the status of a task between incomplete and complete.
++ I want to be able to get only the complete tasks.
++ I want to be able to get only the incomplete tasks.
++ I want to search for a task and receive a message that says it wasn't found if it doesn't exist.
++ I want to remove tasks from my list.
++ I want to see all the tasks in my list ordered alphabetically in ascending order.
++ I want to see all the tasks in my list ordered alphabetically in descending order.
+---
+| Classes  | Members        | Methods                                 | Scenario                 | Output                               | 
+|----------|----------------|-----------------------------------------|--------------------------|--------------------------------------|
+| TodoList |                | addTasks(Task task)                     | valid parameter          | task added to list of tasks          |
+|          |                |                                         | invalid parameter (null) | no task added                        |
+|          |                | seeAllTasks()                           |                          | return all tasks                     |
+|          |                | changeStatus(Task task, boolean status) | valid parameter          | status changed on given task         |
+|          |                |                                         | invalid parameter (null) | no change made                       |
+|          |                | getTaskBasedOnStatus(String status)     | status = complete        | return all complete tasks            |
+|          |                |                                         | status = incomplete      | return all incomplete tasks          |
+|          |                | searchForTask(Task task)                | task in map              | return that task was found           |
+|          |                |                                         | task not in map          | return that task was not found       |
+|          |                | removeTask(Task task)                   | if task in map           | remove task from map                 |
+|          |                |                                         | if not in map            | nothing happens                      |
+|          |                | orderAllTaskAscOrder()                  |                          | returns all task in ascending order  |
+|          |                | orderAllTasksDescOrder()                |                          | returns all task in descending order |
+| Tasks    | boolean status |                                         |                          |                                      |
+|          | String name    |                                         |                          |                                      |
+|          |                | changeStatus()                          | status is true           | member status becomes true           |
+|          |                | changeStatus()                          | status is false          | member status becomes false          |
+
+
+
+
+
+
+
+
+

src/test/java/com/booleanuk/core/TodoListTest.java

@@ -3,11 +3,157 @@
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
 
+import java.sql.SQLOutput;
+import java.util.ArrayList;
+import java.util.List;
+
 class TodoListTest {
     @Test
-    public void exampleTest() {
-        String hello = "Hello";
-        Assertions.assertEquals("Hello", hello);
-        Assertions.assertNotEquals("Goodbye", hello);
+    public void testChangeOfStatus() {
+        Task task1 = new Task("Clean");
+
+        task1.changeStatus(false);
+        Assertions.assertEquals(false, task1.status);
+        task1.changeStatus(true);
+        Assertions.assertEquals(true, task1.status);
+    }
+
+    @Test
+    public void testIfTaskIsAddedSuccessfully() {
+        Task task1 = new Task("Wash");
+        TodoList lst = new TodoList();
+
+        Task task2 = new Task("Clean");
+        lst.addTask(task2);
+
+        Assertions.assertEquals(true, lst.addTask(task1));
+        Assertions.assertEquals(false, lst.addTask(task1));
+        Assertions.assertEquals(false, lst.addTask(task2));
+    }
+
+    @Test
+    public void testToSeeAllTasksInList() {
+        Task task1 = new Task("Clean");
+        Task task2 = new Task("Wash");
+
+        TodoList lst = new TodoList();
+        lst.addTask(task1);
+        lst.addTask(task2);
+
+        ArrayList<Task> equalList = new ArrayList<>();
+        equalList.add(task1);
+        equalList.add(task2);
+
+        Assertions.assertIterableEquals(equalList,lst.viewAllTasks());
+    }
+
+    @Test
+    public void testChangeStatusOfTask() {
+        Task task1 = new Task("Clean");
+        Task task2 = new Task("Wash");
+
+        TodoList lst = new TodoList();
+        lst.addTask(task1);
+        lst.addTask(task2);
+
+        lst.changeStatusOfTasks(task1, true);
+        lst.changeStatusOfTasks(task2, false);
+
+        Assertions.assertEquals(true, lst.taskList.getFirst().status);
+        Assertions.assertEquals(false, lst.taskList.getLast().status);
+    }
+
+    @Test
+    public void testRetrieveAllIncompleteTasks() {
+        Task task1 = new Task("Clean");
+        Task task2 = new Task("Wash");
+
+        TodoList lst = new TodoList();
+        lst.addTask(task1);
+        lst.addTask(task2);
+
+        lst.changeStatusOfTasks(task1, false);
+        lst.changeStatusOfTasks(task2, true);
+
+        Assertions.assertNotEquals(lst.viewAllTasks(), lst.getIncompleteTasks());
+    }
+
+    @Test
+    public void testRetrieveAllCompleteTasks() {
+        Task task1 = new Task("Clean");
+        Task task2 = new Task("Wash");
+
+        TodoList lst = new TodoList();
+        lst.addTask(task1);
+        lst.addTask(task2);
+
+        lst.changeStatusOfTasks(task1, true);
+        lst.changeStatusOfTasks(task2, true);
+
+        Assertions.assertEquals(lst.viewAllTasks(), lst.getCompleteTask());
+    }
+
+    @Test
+    public void testIfTaskExists() {
+        Task task1 = new Task("Clean");
+        Task task2 = new Task("Wash");
+        TodoList lst = new TodoList();
+        lst.addTask(task1);
+        String exists = "Task exists";
+        String notExists = "Task does not exists";
+
+        Assertions.assertEquals(exists, lst.checkIfTaskExists(task1));
+        Assertions.assertNotEquals(notExists, lst.checkIfTaskExists(task2));
+    }
+
+    @Test
+    public void testRemoveTaskFromList() {
+        Task task1 = new Task("Clean");
+        Task task2 = new Task("Wash");
+        TodoList lst = new TodoList();
+        lst.addTask(task1);
+        lst.addTask(task2);
+
+        ArrayList<Task> equalList = new ArrayList<>();
+        equalList.add(task1);
+        equalList.add(task2);
+
+        Assertions.assertEquals(equalList, lst.viewAllTasks());
+
+        lst.removeTask(task2);
+        Assertions.assertNotEquals(equalList, lst.viewAllTasks());
+    }
+
+    @Test
+    public void testAscSorted() {
+        Task task1 = new Task("aa");
+        Task task2 = new Task ("ab");
+
+        TodoList lst = new TodoList();
+        lst.addTask(task2);
+        lst.addTask(task1);
+        List<Task> sorted = lst.ascOrder();
+
+        Assertions.assertEquals(task2, sorted.getLast());
+        Assertions.assertEquals(task1, sorted.getFirst());
+        Assertions.assertNotEquals(task2, sorted.getFirst());
+        Assertions.assertNotEquals(task1, sorted.getLast());
+
+    }
+
+    @Test
+    public void testDescSorted() {
+        Task task1 = new Task("aa");
+        Task task2 = new Task ("ab");
+
+        TodoList lst = new TodoList();
+        lst.addTask(task1);
+        lst.addTask(task2);
+        List<Task> sorted = lst.descOrder();
+
+        Assertions.assertEquals(task2, sorted.getFirst());
+        Assertions.assertNotEquals(task2, sorted.getLast());
+        Assertions.assertEquals(task1, sorted.getLast());
+        Assertions.assertNotEquals(task1, sorted.getFirst());
     }
 }