Add JUnit tests for Task and TaskManager

src/main/java/seedu/address/model/task/TaskManager.java

@@ -28,6 +28,7 @@ public TaskManager() {
      */
     public TaskManager(ReadOnlyTaskManager toBeCopied) {
         this();
+        requireNonNull(toBeCopied);
         resetData(toBeCopied);
     }
 
@@ -61,6 +62,7 @@ public void setTasks(List<Task> taskList) {
     public void addTask(Task task) {
         requireNonNull(task);
         tasks.add(task);
+        sort();
     }
 
     public Task deleteTask(int index) {

src/test/java/seedu/address/logic/commands/AddTaskCommandTest.java

@@ -75,7 +75,11 @@ public void equalsTest() {
     }
 
     @Test
-    void testToString() {
+    void toStringMethod() {
+        Task toAdd = new TaskBuilder().build();
+        AddTaskCommand addTaskCommand = new AddTaskCommand(toAdd);
+        String expected = AddTaskCommand.class.getCanonicalName() + "{taskToAdd=" + toAdd + "}";
+        assertEquals(expected, addTaskCommand.toString());
     }
 
     /**

src/test/java/seedu/address/model/task/TaskManagerTest.java

@@ -0,0 +1,59 @@
+package seedu.address.model.task;
+
+import org.junit.jupiter.api.Test;
+import seedu.address.model.task.exceptions.DuplicateTaskException;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static seedu.address.testutil.TypicalTasks.ASSIGNMENT;
+import static seedu.address.testutil.TypicalTasks.HYDRATION;
+
+class TaskManagerTest {
+    private final TaskManager taskManager = new TaskManager();
+
+    @Test
+    public void constructor() {
+        assertEquals(new TaskList().asUnmodifiableList(), taskManager.getTaskList());
+    }
+
+    @Test
+    public void deleteTask_emptyTaskList_throwsIndexOutOfBoundsException() {
+        assertThrows(IndexOutOfBoundsException.class, () -> taskManager.deleteTask(1));
+    }
+
+    @Test
+    public void addTask_emptyTaskList_success() {
+        taskManager.addTask(ASSIGNMENT);
+        assertTrue(taskManager.getTaskList().contains(ASSIGNMENT));
+    }
+
+    @Test
+    public void addTask_duplicateTask_throwsDuplicateTaskException() {
+        taskManager.addTask(ASSIGNMENT);
+        assertThrows(DuplicateTaskException.class, () -> taskManager.addTask(ASSIGNMENT));
+    }
+
+    @Test
+    public void deleteTask_taskFound_success() {
+        taskManager.addTask(ASSIGNMENT);
+        assertEquals(ASSIGNMENT, taskManager.deleteTask(1));
+    }
+
+    @Test
+    public void equalsMethod() {
+        taskManager.addTask(ASSIGNMENT);
+        TaskManager equivalentTaskManager = new TaskManager();
+        equivalentTaskManager.addTask(ASSIGNMENT);
+        TaskManager emptyTaskManager = new TaskManager();
+        TaskManager differentTaskManager = new TaskManager();
+        differentTaskManager.addTask(HYDRATION);
+        Object notTaskManager = new Object();
+
+        assertTrue(taskManager.equals(taskManager));
+
+        assertTrue(taskManager.equals(equivalentTaskManager));
+
+        assertFalse(taskManager.equals(emptyTaskManager));
+
+        assertFalse(taskManager.equals(notTaskManager));
+    }
+}

src/test/java/seedu/address/model/task/TaskTest.java

@@ -0,0 +1,140 @@
+package seedu.address.model.task;
+
+import org.junit.jupiter.api.Test;
+
+import java.time.LocalDateTime;
+import java.util.Comparator;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static seedu.address.model.task.Task.DATE_TIME_STRING_FORMATTER;
+import static seedu.address.testutil.Assert.assertThrows;
+
+class TaskTest {
+    private static final String VALID_DESCRIPTION_STRING = "Eat Nuts";
+    private static final TaskDescription VALID_TASK_DESCRIPTION = new TaskDescription(VALID_DESCRIPTION_STRING);
+    private static final Deadline VALID_DEADLINE = new Deadline("2023-02-11 14:00");
+    private static final LocalDateTime VALID_DEADLINE_DATETIME =
+            LocalDateTime.parse("2023-02-11 14:00", DATE_TIME_STRING_FORMATTER);
+
+    @Test
+    public void constructorTest() {
+        assertThrows(NullPointerException.class, () -> new Task((String) null, VALID_DEADLINE_DATETIME));
+
+        assertThrows(NullPointerException.class, () -> new Task((TaskDescription) null, VALID_DEADLINE));
+
+        Task taskWithNoDeadline = new Task(VALID_TASK_DESCRIPTION, new Deadline((String) null));
+
+        assertEquals(taskWithNoDeadline, new Task(VALID_DESCRIPTION_STRING, null));
+    }
+
+    @Test
+    public void getDescriptionTest() {
+        Task testTask = new Task(VALID_DESCRIPTION_STRING, VALID_DEADLINE_DATETIME);
+        assertEquals(VALID_TASK_DESCRIPTION, testTask.getDescription());
+        assertNotEquals(VALID_DESCRIPTION_STRING, testTask.getDescription());
+    }
+
+    @Test
+    public void getDescriptionStringTest() {
+        Task testTask = new Task(VALID_TASK_DESCRIPTION, VALID_DEADLINE);
+        assertEquals(VALID_DESCRIPTION_STRING, testTask.getDescriptionString());
+    }
+
+    @Test
+    public void getDeadlineTest() {
+        Task testTask = new Task(VALID_DESCRIPTION_STRING, VALID_DEADLINE_DATETIME);
+        assertEquals(VALID_DEADLINE, testTask.getDeadline());
+        Task testTask2 = new Task(VALID_DESCRIPTION_STRING, null);
+        assertEquals(new Deadline((String) null), testTask2.getDeadline());
+    }
+
+    @Test
+    public void getDeadlineStringTest() {
+        Task testTask = new Task(VALID_TASK_DESCRIPTION, VALID_DEADLINE);
+        assertEquals("2023-02-11 14:00", testTask.getDeadlineString());
+
+        Task testTask2 = new Task(VALID_DESCRIPTION_STRING, null);
+        assertEquals("-", testTask2.getDeadlineString());
+    }
+
+    @Test
+    public void equalsMethod() {
+        Task testTask = new Task(VALID_DESCRIPTION_STRING, VALID_DEADLINE_DATETIME);
+        Task equivalentTask = new Task(VALID_TASK_DESCRIPTION, VALID_DEADLINE);
+        Task nonEquivalentTask = new Task(VALID_DESCRIPTION_STRING, null);
+        Task differentDescription = new Task("Eat Fruits", VALID_DEADLINE_DATETIME);
+        Object notTask = new Object();
+
+        assertTrue(testTask.equals(testTask));
+
+        assertTrue(testTask.equals(equivalentTask));
+
+        assertFalse(testTask.equals(nonEquivalentTask));
+
+        assertFalse(testTask.equals(differentDescription));
+
+        assertFalse(testTask.equals(notTask));
+    }
+
+    @Test
+    public void toStringMethod() {
+        Task testTask = new Task(VALID_TASK_DESCRIPTION, VALID_DEADLINE);
+        String expected = Task.class.getCanonicalName() + "{description=" + VALID_TASK_DESCRIPTION + ", deadline="
+                + VALID_DEADLINE + "}";
+        assertEquals(expected, testTask.toString());
+    }
+
+    @Test
+    public void deadlineComparatorTest() {
+        Comparator<Task> comparator = new Task.TaskDeadlineComparator();
+
+        Task testTask = new Task(VALID_DESCRIPTION_STRING, VALID_DEADLINE_DATETIME);
+        Task sameTask = new Task(VALID_TASK_DESCRIPTION, VALID_DEADLINE);
+        Task taskWithNoDeadline = new Task(VALID_DESCRIPTION_STRING, null);
+        Task differentDescription = new Task("Eat Fruits", VALID_DEADLINE_DATETIME);
+        Task laterDeadline = new Task(VALID_DESCRIPTION_STRING,
+                LocalDateTime.parse("2023-02-11 15:00", DATE_TIME_STRING_FORMATTER));
+
+        assertEquals(0, comparator.compare(testTask, sameTask));
+        assertEquals(-1, comparator.compare(testTask, taskWithNoDeadline));
+        assertEquals(1, comparator.compare(taskWithNoDeadline, testTask));
+        assertTrue(comparator.compare(testTask, differentDescription) > 0);
+        assertTrue(comparator.compare(differentDescription, testTask) < 0);
+        assertEquals(-1, comparator.compare(testTask, laterDeadline));
+        assertEquals(1, comparator.compare(laterDeadline, testTask));
+    }
+
+    @Test
+    public void descriptionComparatorTest() {
+        Comparator<Task> comparator = new Task.TaskDescriptorComparator();
+
+        Task testTask = new Task(VALID_DESCRIPTION_STRING, VALID_DEADLINE_DATETIME);
+        Task sameTask = new Task(VALID_TASK_DESCRIPTION, VALID_DEADLINE);
+        Task taskWithNoDeadline = new Task(VALID_DESCRIPTION_STRING, null);
+        Task differentDescription = new Task("Eat Fruits", VALID_DEADLINE_DATETIME);
+        Task laterDeadline = new Task(VALID_DESCRIPTION_STRING,
+                LocalDateTime.parse("2023-02-11 15:00", DATE_TIME_STRING_FORMATTER));
+
+        assertEquals(0, comparator.compare(testTask, sameTask));
+
+        assertEquals(0, comparator.compare(testTask, taskWithNoDeadline));
+
+        assertTrue(comparator.compare(testTask, differentDescription) > 0);
+        assertTrue(comparator.compare(differentDescription, testTask) < 0);
+
+        assertEquals(0, comparator.compare(testTask, laterDeadline));
+    }
+
+    @Test
+    public void deadlineComparatorEqualsTest() {
+        assertTrue(new Task.TaskDeadlineComparator().equals(new Task.TaskDeadlineComparator()));
+    }
+
+    @Test
+    public void descriptionComparatorEqualsTest() {
+        assertTrue(new Task.TaskDescriptorComparator().equals(new Task.TaskDescriptorComparator()));
+    }
+}