diff --git a/files/Task.txt b/files/Task.txt
index b8137ec..24a570a 100644
--- a/files/Task.txt
+++ b/files/Task.txt
@@ -1,4 +1,5 @@
-id,type,name,status,description,epic
-1,TASK,Task001,NEW,Description,Task,
-2,EPIC,Epic001,NEW,Description,Epic,
-3,SUBTASK,Subtask001,NEW,Description,Subtask,2
+id,type,name,status,description,class,epicId,startTime,duration,endTime
+1,TASK,Task001,NEW,Description,Task,Null,2024-02-02T11:00,60,2024-02-02T12:00
+2,EPIC,Epic001,NEW,Description,Epic,2,2025-01-01T10:00,140,2025-01-01T12:30
+3,SUBTASK,Subtask001,NEW,Description,Subtask,2,2025-01-01T10:00,70,2025-01-01T11:10
+4,SUBTASK,Subtask002,NEW,Description,Subtask,2,2025-01-01T11:20,70,2025-01-01T12:30
diff --git a/src/exceptions/TaskValidationException.java b/src/exceptions/TaskValidationException.java
new file mode 100644
index 0000000..7b353ec
--- /dev/null
+++ b/src/exceptions/TaskValidationException.java
@@ -0,0 +1,7 @@
+package exceptions;
+
+public class TaskValidationException extends RuntimeException {
+    public TaskValidationException(String message) {
+        super(message);
+    }
+}
diff --git a/src/managers/FileBackedTaskManager.java b/src/managers/FileBackedTaskManager.java
index c1562ff..7dd3743 100644
--- a/src/managers/FileBackedTaskManager.java
+++ b/src/managers/FileBackedTaskManager.java
@@ -3,6 +3,8 @@
 import exceptions.ManagerSaveException;
 import tasks.*;
 import java.io.*;
+import java.time.Duration;
+import java.time.LocalDateTime;
 
 public class FileBackedTaskManager extends InMemoryTaskManager {
     private final File tasks;
@@ -14,7 +16,7 @@ public FileBackedTaskManager(File file) {
     public void save() {
         try (BufferedWriter writer = new BufferedWriter(new FileWriter(tasks))) {
             if (tasks.length() == 0) { //прописываем первую строку
-                writer.write("id,type,name,status,description,epic\n");
+                writer.write("id,type,name,status,description,class,epicId,startTime,duration,endTime\n");
             }
             for (Task task : getTaskList()) {
                 writer.write(toString(task));
@@ -67,7 +69,18 @@ public String toString(Task task) {
         stringBuilder.append(task.getDescription() + ",");
         stringBuilder.append(task.getClass().getSimpleName() + ",");
         if (task.getClass() == Subtask.class) {
-            stringBuilder.append(((Subtask) task).getEpicId());
+            stringBuilder.append(((Subtask) task).getEpicId() + ",");
+        } else if (task.getClass() == Epic.class) {
+            stringBuilder.append(task.getId() + ",");
+        } else {
+            stringBuilder.append("Null,");
+        }
+        if (task.getStartTime() != null && task.getEndTime() != null && task.getDuration() != null) {
+            stringBuilder.append(task.getStartTime() + ",");
+            stringBuilder.append(task.getDuration().toMinutes() + ",");
+            stringBuilder.append(task.getEndTime());
+        } else {
+            stringBuilder.append("Null,Null,Null");
         }
         return stringBuilder.toString();
     }
@@ -77,14 +90,26 @@ public static Task fromString(String value) {
 
         if (TaskType.valueOf(str[1]) == (TaskType.TASK)) {
             Task task = new Task(str[2], str[4], TaskStatus.valueOf(str[3]));
+            if (str[8] == null || str[7] == null) {
+                task.setDuration(Duration.ofMinutes(Integer.parseInt(str[8])));
+                task.setStartTime(LocalDateTime.parse(str[7]));
+            }
             task.setId(Integer.parseInt(str[0]));
             return task;
         } else if (TaskType.valueOf(str[1]) == (TaskType.EPIC)) {
             Epic task = new Epic(str[2], str[4], TaskStatus.valueOf(str[3]));
+            if (str[8] == null || str[7] == null) {
+                task.setDuration(Duration.ofMinutes(Integer.parseInt(str[8])));
+                task.setStartTime(LocalDateTime.parse(str[7]));
+            }
             task.setId(Integer.parseInt(str[0]));
             return task;
         } else {
             Subtask task = new Subtask(str[2], str[4], Integer.parseInt(str[6]), TaskStatus.valueOf(str[3]));
+            if (str[8] == null || str[7] == null) {
+                task.setDuration(Duration.ofMinutes(Integer.parseInt(str[8])));
+                task.setStartTime(LocalDateTime.parse(str[7]));
+            }
             task.setId(Integer.parseInt(str[0]));
             return task;
         }
@@ -129,12 +154,17 @@ public void updateEpic(Epic epic) {
     public static void main(String[] args) {
         File file = new File("files/Task.txt");
         FileBackedTaskManager fileBackedTaskManager = new FileBackedTaskManager(file);
-        Task task001 = new Task("Task001", "Description", TaskStatus.NEW);
+        Task task001 = new Task("Task001", "Description", TaskStatus.NEW,
+                Duration.ofMinutes(60), LocalDateTime.of(2024, 2, 2, 11, 0));
         fileBackedTaskManager.addTask(task001);
         Epic epic001 = new Epic("Epic001", "Description",TaskStatus.NEW);
         fileBackedTaskManager.addEpic(epic001);
-        Subtask subtask001 = new Subtask("Subtask001", "Description", epic001.getId(), TaskStatus.NEW);
+        Subtask subtask001 = new Subtask("Subtask001", "Description", epic001.getId(), TaskStatus.NEW,
+                Duration.ofMinutes(70), LocalDateTime.of(2025, 1, 1, 10, 0));
         fileBackedTaskManager.addSubtask(subtask001);
+        Subtask subtask002 = new Subtask("Subtask002", "Description", epic001.getId(), TaskStatus.NEW,
+                Duration.ofMinutes(70), LocalDateTime.of(2025, 1, 1, 11, 20));
+        fileBackedTaskManager.addSubtask(subtask002);
         fileBackedTaskManager.deleteAllEpic();
         fileBackedTaskManager.deleteAllSubtask();
         fileBackedTaskManager.deleteTaskList();
diff --git a/src/managers/InMemoryTaskManager.java b/src/managers/InMemoryTaskManager.java
index 6275519..bf4470a 100644
--- a/src/managers/InMemoryTaskManager.java
+++ b/src/managers/InMemoryTaskManager.java
@@ -1,21 +1,22 @@
 package managers;
 
+import exceptions.TaskValidationException;
 import tasks.Epic;
 import tasks.Subtask;
 import tasks.Task;
 import tasks.TaskStatus;
 
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
+import java.time.Duration;
+import java.time.LocalDateTime;
+import java.util.*;
+import java.util.stream.Collectors;
 
 public class InMemoryTaskManager implements TaskManager {
     private int idCounter = 0;
     protected final Map<Integer, Task> taskList = new HashMap<>();
     protected final Map<Integer, Epic> epicList = new HashMap<>();
     protected final Map<Integer, Subtask> subtaskList = new HashMap<>();
-
+    protected final Set<Task> prioritizedTasks = new TreeSet<>(Comparator.comparing(Task::getStartTime));
     private final HistoryManager historyManager = Managers.getDefaultHistory();
 
     @Override
@@ -29,14 +30,15 @@ public ArrayList<Epic> getEpicList() {
     }
 
     @Override
-    public ArrayList<Subtask> getEpicSubtask(Integer epicId) { //Выводит список подзадач эпика
-        ArrayList<Subtask> currentEpic = new ArrayList<>();
-        for (Subtask subtask : subtaskList.values()) {
-            if (subtask.getEpicId() == epicId) {
-                currentEpic.add(subtask);
-            }
+    public List<Subtask> getEpicSubtask(Integer epicId) { //Выводит список подзадач эпика
+        Epic epic = epicList.get(epicId);
+        if (epic == null) {
+            return null;
         }
-        return currentEpic;
+        List<Subtask> epicSub = getAllSubtask();
+        return epicSub.stream()
+                .filter(subtask -> subtask.getEpicId() == epicId)
+                .collect(Collectors.toList());
     }
 
     @Override
@@ -48,6 +50,7 @@ public ArrayList<Subtask> getAllSubtask() {
     public void deleteTaskList() {
         for (Integer id : taskList.keySet()) {
             historyManager.remove(id);
+            delete(taskList.get(id));
         }
         taskList.clear();
     }
@@ -56,10 +59,11 @@ public void deleteTaskList() {
     public void deleteAllSubtask() {
         for (Integer id : subtaskList.keySet()) {
             historyManager.remove(id);
+            delete(subtaskList.get(id));
         }
         subtaskList.clear();
         for (Epic epic : epicList.values()) { //идем по списку эпиков
-            checkStatus(epic);
+            updateEpic(epic);
         }
     }
 
@@ -67,10 +71,12 @@ public void deleteAllSubtask() {
     public void deleteAllEpic() {
         for (Integer id : epicList.keySet()) {
             historyManager.remove(id);
+            delete(epicList.get(id));
         }
         epicList.clear();
         for (Integer id : subtaskList.keySet()) {
             historyManager.remove(id);
+            delete(subtaskList.get(id));
         }
         subtaskList.clear();
     }
@@ -81,19 +87,22 @@ public void deleteEpicSubtask(Epic epic) { //удаление подзадача
         for (Subtask subtask : subtaskList.values()) {
             if (subtask.getEpicId() == epic.getId()) {
                 idToRemove.add(subtask.getId());
+                delete(subtask);
             }
         }
         for (Integer key : idToRemove) {
             subtaskList.remove(key);
             historyManager.remove(key);
         }
-        checkStatus(epic);
+        updateEpic(epic);
     }
 
     @Override
     public void removeTaskForId(Integer id) {
         taskList.remove(id);
+        delete(taskList.get(id));
         historyManager.remove(id);
+
     }
 
     @Override
@@ -104,6 +113,7 @@ public void removeEpicForId(Integer id) {
         for (Subtask subtask : subtaskList.values()) { //ищем подзадачи по id удаляемого эпика
             if (subtask.getEpicId() == id) {
                 idToRemove.add(subtask.getId());
+                delete(subtask);
             }
         }
         for (Integer key : idToRemove) {
@@ -116,8 +126,10 @@ public void removeEpicForId(Integer id) {
     public void removeSubtaskForId(Integer id) {
         int epicId = subtaskList.get(id).getEpicId();
         subtaskList.remove(id);
+        delete(subtaskList.get(id));
         checkStatus(epicList.get(epicId));//проверяем статус эпика из которого удалили подзадачу
         historyManager.remove(id);
+        updateEpic(epicList.get(epicId));
     }
 
     @Override
@@ -143,6 +155,7 @@ public void addTask(Task task) {
         idCounter++;
         task.setId(idCounter);
         taskList.put(task.getId(), task);
+        add(task);
     }
 
     @Override
@@ -159,7 +172,8 @@ public void addSubtask(Subtask subtask) {
         subtask.setId(idCounter);
         int currentEpicId = subtask.getEpicId();
         subtaskList.put(subtask.getId(), subtask);
-        checkStatus(epicList.get(currentEpicId)); //проверка статуса эпика после добавления подзадачи
+        add(subtask);
+        updateEpic(epicList.get(currentEpicId));
     }
 
     @Override
@@ -175,8 +189,11 @@ public void updateSubtask(Subtask subtask) {
 
         oldSubtask.setTitle(subtask.getTitle());
         oldSubtask.setDescription(subtask.getDescription());
+
+        delete(oldSubtask);
         subtaskList.put(id, oldSubtask);
-        checkStatus(epicList.get(epicId)); //проверка статуса эпика
+        add(oldSubtask);
+        updateEpic(epicList.get(epicId));
     }
 
     @Override
@@ -188,6 +205,8 @@ public void updateEpic(Epic epic) {
         oldEpic.setDescription(epic.getDescription());
 
         epicList.put(id, oldEpic);
+        checkStatus(epic);
+        updateEpicDuration(epic);
     }
 
     public void checkStatus(Epic epic) {
@@ -228,4 +247,59 @@ public List<Task> getHistory() {
     public void deleteHistory() {
         historyManager.deleteHistory();
     }
+
+    public List<Task> getPrioritizedTasks() {
+        return new ArrayList<>(prioritizedTasks);
+    }
+
+    public void updateEpicDuration(Epic epic) {
+        List<Subtask> sub = getEpicSubtask(epic.getId());
+        sub.stream()
+                .filter(subtask -> subtask.getStartTime() != null)
+                .forEachOrdered(subtask -> {
+                    if (epic.getStartTime() == null || epic.getStartTime().isAfter(subtask.getStartTime())) {
+                        epic.setStartTime(subtask.getStartTime());
+                    }
+                    if (epic.getEndTime() == null || epic.getEndTime().isBefore(subtask.getEndTime())) {
+                        epic.setEndTime(subtask.getEndTime());
+                    }
+                });
+        Duration totalDuration = sub.stream()
+                .filter(subtask -> subtask.getStartTime() != null)
+                .map(Subtask::getDuration)
+                .reduce(Duration.ZERO, Duration::plus);
+
+        epic.setDuration(totalDuration);
+    }
+
+    public boolean isCrossed(Task task1, Task task2) {
+        LocalDateTime start1 = task1.getStartTime();
+        LocalDateTime end1 = task1.getEndTime();
+
+        LocalDateTime start2 = task2.getStartTime();
+        LocalDateTime end2 = task2.getEndTime();
+        boolean notCrossed = start1.isAfter(end2) || start2.isAfter(end1);
+        return !notCrossed;
+    }
+
+    private void add(Task newTask) {
+        if (newTask.getStartTime() == null) {
+            return;
+        }
+        prioritizedTasks.stream()
+                .filter(task -> isCrossed(newTask, task))
+                .findFirst()
+                .ifPresentOrElse(
+                        task -> {
+                            String message = "Задача пересекается с задачей с id: " + task.getId() + " с началом: "
+                                    + task.getStartTime() + " и концом: " + task.getEndTime();
+                            throw new TaskValidationException(message);
+                        },
+                        () -> prioritizedTasks.add(newTask)
+                );
+    }
+
+    private void delete(Task task) {
+        prioritizedTasks.remove(task);
+    }
 }
\ No newline at end of file
diff --git a/src/tasks/Epic.java b/src/tasks/Epic.java
index 4691ef2..f4ac60e 100644
--- a/src/tasks/Epic.java
+++ b/src/tasks/Epic.java
@@ -1,6 +1,10 @@
 package tasks;
 
+import java.time.LocalDateTime;
+
 public class Epic extends Task {
+    private LocalDateTime endTime;
+
     public Epic(String title, String description, TaskStatus status) {
         super(title, description, status);
     }
@@ -19,4 +23,13 @@ public String toString() {
                 ", status=" + getStatus() +
                 '}';
     }
+
+    @Override
+    public LocalDateTime getEndTime() {
+        return endTime;
+    }
+
+    public void setEndTime(LocalDateTime endTime) {
+        this.endTime = endTime;
+    }
 }
\ No newline at end of file
diff --git a/src/tasks/Subtask.java b/src/tasks/Subtask.java
index be7d695..3ce4c1c 100644
--- a/src/tasks/Subtask.java
+++ b/src/tasks/Subtask.java
@@ -1,5 +1,8 @@
 package tasks;
 
+import java.time.Duration;
+import java.time.LocalDateTime;
+
 public class Subtask extends Task {
     private final int epicId;
 
@@ -8,6 +11,12 @@ public Subtask(String title, String description, int epicId, TaskStatus status)
         this.epicId = epicId;
     }
 
+    public Subtask(String title, String description, int epicId, TaskStatus status,
+                   Duration duration, LocalDateTime startTime) {
+        super(title, description, status, duration, startTime);
+        this.epicId = epicId;
+    }
+
     public int getEpicId() {
         return epicId;
     }
diff --git a/src/tasks/Task.java b/src/tasks/Task.java
index 6850f7a..b36413d 100644
--- a/src/tasks/Task.java
+++ b/src/tasks/Task.java
@@ -1,10 +1,15 @@
 package tasks;
 
+import java.time.Duration;
+import java.time.LocalDateTime;
+
 public class Task {
     private String title;
     private String description;
     private int id;
     private TaskStatus status;
+    private Duration duration = Duration.ZERO;
+    private LocalDateTime startTime;
 
     public Task(String title, String description, TaskStatus status) {
         this.title = title;
@@ -12,11 +17,22 @@ public Task(String title, String description, TaskStatus status) {
         this.status = status;
     }
 
+    public Task(String title, String description, TaskStatus status,
+                Duration duration, LocalDateTime startTime) {
+        this.title = title;
+        this.description = description;
+        this.status = status;
+        this.duration = duration;
+        this.startTime = startTime;
+    }
+
     public Task(Task task) {
         this.id = task.id;
         this.title = task.title;
         this.description = task.description;
         this.status = task.status;
+        this.duration = task.duration;
+        this.startTime = task.startTime;
     }
 
     public TaskStatus getStatus() {
@@ -64,4 +80,24 @@ public void setTitle(String title) {
     public void setDescription(String description) {
         this.description = description;
     }
+
+    public LocalDateTime getEndTime() {
+        return startTime.plus(duration);
+    }
+
+    public LocalDateTime getStartTime() {
+        return startTime;
+    }
+
+    public Duration getDuration() {
+        return duration;
+    }
+
+    public void setDuration(Duration duration) {
+        this.duration = duration;
+    }
+
+    public void setStartTime(LocalDateTime startTime) {
+        this.startTime = startTime;
+    }
 }
diff --git a/test/managers/FileBackedTaskManagerTest.java b/test/managers/FileBackedTaskManagerTest.java
index 43bb1a8..1601e05 100644
--- a/test/managers/FileBackedTaskManagerTest.java
+++ b/test/managers/FileBackedTaskManagerTest.java
@@ -1,6 +1,5 @@
 package managers;
 
-import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
 import tasks.Task;
@@ -12,13 +11,13 @@
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
-public class FileBackedTaskManagerTest {
+class FileBackedTaskManagerTest extends TaskManagerTest<FileBackedTaskManager> {
 
     File temp;
     FileBackedTaskManager taskManager;
 
-    @BeforeEach
-    public void createHistoryManager() {
+    @Override
+    protected FileBackedTaskManager createTaskManager() {
         {
             try {
                 temp = File.createTempFile("Test", ".txt");
@@ -27,29 +26,30 @@ public void createHistoryManager() {
             }
         }
         taskManager = new FileBackedTaskManager(temp);
+        return taskManager;
     }
 
     @Test
     @DisplayName("Сохранение пустого файла")
-    public void saveFile() {
+    public void testSaveFile() {
         taskManager.save();
         assertTrue(temp.exists());
     }
 
     @Test
     @DisplayName("Сохранение файлов")
-    public void saveTasksToFile() {
-        Task task001 = new Task ("Task001", "Description", TaskStatus.NEW);
-        taskManager.addTask(task001);
-        Task task002 = new Task ("Task002", "Description", TaskStatus.IN_PROGRESS);
-        taskManager.addTask(task002);
+    public void testSaveTasksToFile() {
+        task1 = new Task ("Task001", "Description", TaskStatus.NEW);
+        taskManager.addTask(task1);
+        task2 = new Task ("Task002", "Description", TaskStatus.IN_PROGRESS);
+        taskManager.addTask(task2);
         assertTrue(temp.exists());
         assertTrue(temp.length() > 0);
     }
 
     @Test
     @DisplayName("Загрузка файлов")
-    public void loadFile() {
+    public void testLoadFile() {
         FileBackedTaskManager taskManager1 = FileBackedTaskManager.loadFromFile(temp);
         assertEquals(taskManager1.getTaskList().size(), taskManager.getTaskList().size());
     }
diff --git a/test/managers/InMemoryHistoryManagerTest.java b/test/managers/InMemoryHistoryManagerTest.java
index d1f7883..82c977f 100644
--- a/test/managers/InMemoryHistoryManagerTest.java
+++ b/test/managers/InMemoryHistoryManagerTest.java
@@ -1,6 +1,5 @@
 package managers;
 
-import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
diff --git a/test/managers/InMemoryTaskManagerTest.java b/test/managers/InMemoryTaskManagerTest.java
index 26f5718..9f4b510 100644
--- a/test/managers/InMemoryTaskManagerTest.java
+++ b/test/managers/InMemoryTaskManagerTest.java
@@ -1,31 +1,50 @@
 package managers;
 
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
 import tasks.Epic;
-import tasks.Task;
+import tasks.Subtask;
 import tasks.TaskStatus;
 
 import static org.junit.jupiter.api.Assertions.*;
 
-class InMemoryTaskManagerTest {
+class InMemoryTaskManagerTest extends TaskManagerTest<InMemoryTaskManager> {
 
-    TaskManager taskManager;
-
-    @BeforeEach
-    public void createTaskManager() {
-        taskManager = Managers.getDefault();
+    @Override
+    protected InMemoryTaskManager createTaskManager() {
+        return new InMemoryTaskManager();
     }
 
     @Test
-    @DisplayName("Проверка присвоения разных id")
-    public void getDifferentTypes() {
-        Task task = new Task("Таск", "Тело таска", TaskStatus.NEW);
-        taskManager.addTask(task);
-        Epic epic = new Epic("Эпик", "Тело эпика",TaskStatus.NEW);
+    public void testEpicStatus() {
+        epic = new Epic("Эпик", "Тело эпика",TaskStatus.NEW);
         taskManager.addEpic(epic);
-        assertEquals(1, taskManager.getTaskForId(1).getId(), "Задача с этим id не найдена");
-        assertEquals(2, taskManager.getEpicForId(2).getId(), "Задача с этим id не найдена");
+        subtask1 = new Subtask("Sub1", "Description", epic.getId(), TaskStatus.NEW);
+        subtask2 = new Subtask("Sub2", "Description", epic.getId(), TaskStatus.NEW);
+
+        taskManager.addSubtask(subtask1);
+        taskManager.addSubtask(subtask2);
+
+        assertEquals(TaskStatus.NEW, epic.getStatus());
+
+        subtask1.setStatus(TaskStatus.DONE);
+        taskManager.updateSubtask(subtask1);
+        subtask2.setStatus(TaskStatus.DONE);
+        taskManager.updateSubtask(subtask2);
+
+        assertEquals(TaskStatus.DONE, epic.getStatus());
+
+        subtask1.setStatus(TaskStatus.IN_PROGRESS);
+        taskManager.updateSubtask(subtask1);
+        subtask2.setStatus(TaskStatus.IN_PROGRESS);
+        taskManager.updateSubtask(subtask2);
+
+        assertEquals(TaskStatus.IN_PROGRESS, epic.getStatus());
+
+        subtask1.setStatus(TaskStatus.NEW);
+        taskManager.updateSubtask(subtask1);
+        subtask2.setStatus(TaskStatus.DONE);
+        taskManager.updateSubtask(subtask2);
+
+        assertEquals(TaskStatus.IN_PROGRESS, epic.getStatus());
     }
 }
\ No newline at end of file
diff --git a/test/managers/TaskManagerTest.java b/test/managers/TaskManagerTest.java
new file mode 100644
index 0000000..a74cbda
--- /dev/null
+++ b/test/managers/TaskManagerTest.java
@@ -0,0 +1,139 @@
+package managers;
+
+import exceptions.TaskValidationException;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import tasks.Epic;
+import tasks.Subtask;
+import tasks.Task;
+import tasks.TaskStatus;
+
+import java.time.Duration;
+import java.time.LocalDateTime;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+public abstract class TaskManagerTest<T extends TaskManager> {
+    protected T taskManager;
+    protected Epic epic;
+    protected Subtask subtask1;
+    protected Subtask subtask2;
+    protected Task task1;
+    protected Task task2;
+
+    protected abstract T createTaskManager();
+
+    @BeforeEach
+    void setUp() {
+        taskManager = createTaskManager();
+    }
+
+    @Test
+    @DisplayName("Создание задачи")
+    void testCreateTask() {
+        task1 = new Task("Переезд", "переезд в другой город", TaskStatus.NEW);
+        taskManager.addTask(task1);
+        assertNotNull(task1.getId());
+        assertEquals(task1, taskManager.getTaskForId(task1.getId()));
+        assertTrue(taskManager.getTaskList().contains(task1));
+    }
+
+    @Test
+    @DisplayName("Создание эпика и подзадачи")
+    void testCreateEpicAndSub() {
+        epic = new Epic("Epic001", "Description",TaskStatus.NEW);
+        taskManager.addEpic(epic);
+        subtask1 = new Subtask("Subtask001", "Description", epic.getId(), TaskStatus.NEW,
+                Duration.ofMinutes(70), LocalDateTime.of(2025, 1, 1, 10, 0));
+        taskManager.addSubtask(subtask1);
+        assertNotNull(epic.getId());
+        assertNotNull(subtask1.getId());
+        assertTrue(taskManager.getEpicList().contains(epic));
+        assertTrue(taskManager.getAllSubtask().contains(subtask1));
+    }
+
+    @Test
+    @DisplayName("Проверка удаления задачи")
+    void testDeleteTask() {
+        task1 = new Task("Переезд", "переезд в другой город", TaskStatus.NEW);
+        taskManager.addTask(task1);
+        taskManager.removeTaskForId(task1.getId());
+        assertFalse(taskManager.getTaskList().contains(task1));
+    }
+
+    @Test
+    @DisplayName("Проверка получения эпика и подзадач")
+    void testGetEpicSubtasks() {
+        epic = new Epic("Epic001", "Description",TaskStatus.NEW);
+        taskManager.addEpic(epic);
+        subtask1 = new Subtask("Subtask001", "Description", epic.getId(), TaskStatus.NEW,
+                Duration.ofMinutes(70), LocalDateTime.of(2025, 1, 1, 10, 0));
+        subtask2 = new Subtask("Subtask002", "Description", epic.getId(), TaskStatus.NEW,
+                Duration.ofMinutes(70), LocalDateTime.of(2025, 1, 1, 11, 20));
+        taskManager.addSubtask(subtask1);
+        taskManager.addSubtask(subtask2);
+
+        List<Subtask> epicSubtasks = taskManager.getEpicSubtask(epic.getId());
+        assertEquals(2, epicSubtasks.size());
+        assertTrue(epicSubtasks.contains(subtask1));
+        assertTrue(epicSubtasks.contains(subtask2));
+    }
+
+    @Test
+    @DisplayName("Проверка присвоения разных id")
+    void testGetDifferentTypesId() {
+        task1 = new Task("Переезд", "переезд в другой город", TaskStatus.NEW);
+        taskManager.addTask(task1);
+        task2 = new Task("Переезд", "переезд в другой город", TaskStatus.NEW);
+        taskManager.addTask(task2);
+        assertEquals(1, taskManager.getTaskForId(1).getId(), "Задача с этим id не найдена");
+        assertEquals(2, taskManager.getTaskForId(2).getId(), "Задача с этим id не найдена");
+    }
+
+    @Test
+    @DisplayName("Проверка что задачи без даты не конфликтуют")
+    void testTasksWithoutTimeDoNotConflict() {
+        task1 = new Task("Task 1", "Description", TaskStatus.NEW, null, null);
+        task2 = new Task("Task 2", "Description", TaskStatus.NEW, null, null);
+
+        assertDoesNotThrow(() -> {
+            taskManager.addTask(task1);
+            taskManager.addTask(task2);
+        });
+    }
+
+    @Test
+    @DisplayName("Проверка условия когда задачи не пересекаются")
+    void testNotCrossedDates() {
+        epic = new Epic("Epic001", "Description",TaskStatus.NEW);
+        taskManager.addEpic(epic);
+        subtask1 = new Subtask("Subtask001", "Description", epic.getId(), TaskStatus.NEW,
+                Duration.ofMinutes(70), LocalDateTime.of(2025, 1, 1, 10, 0));
+        subtask2 = new Subtask("Subtask002", "Description", epic.getId(), TaskStatus.NEW,
+                Duration.ofMinutes(70), LocalDateTime.of(2025, 1, 1, 11, 20));
+
+        assertDoesNotThrow(() -> {
+            taskManager.addSubtask(subtask1);
+            taskManager.addSubtask(subtask2);
+        });
+    }
+
+    @Test
+    @DisplayName("Проверка когда задачи пересекаются")
+    void testIsCrossedDates() {
+        epic = new Epic("Epic001", "Description",TaskStatus.NEW);
+        taskManager.addEpic(epic);
+        subtask1 = new Subtask("Subtask001", "Description", epic.getId(), TaskStatus.NEW,
+                Duration.ofMinutes(70), LocalDateTime.of(2025, 1, 1, 11, 0));
+        subtask2 = new Subtask("Subtask002", "Description", epic.getId(), TaskStatus.NEW,
+                Duration.ofMinutes(70), LocalDateTime.of(2025, 1, 1, 11, 20));
+
+        taskManager.addSubtask(subtask1);
+
+        assertThrows(TaskValidationException.class, () -> {
+            taskManager.addSubtask(subtask2);
+        });
+    }
+}
\ No newline at end of file
diff --git a/test/tasks/EpicTest.java b/test/tasks/EpicTest.java
index 51682dd..27c315f 100644
--- a/test/tasks/EpicTest.java
+++ b/test/tasks/EpicTest.java
@@ -21,7 +21,7 @@ public void createTaskManager() {
 
     @Test
     @DisplayName("Добавление эпика")
-    void addNewEpic() {
+    void testAddNewEpic() {
         Epic epic = new Epic("Эпик", "Тело эпика",TaskStatus.NEW);
         taskManager.addEpic(epic);
         final int epicId = epic.getId();
diff --git a/test/tasks/SubtaskTest.java b/test/tasks/SubtaskTest.java
index f78f15c..8f58dbf 100644
--- a/test/tasks/SubtaskTest.java
+++ b/test/tasks/SubtaskTest.java
@@ -21,7 +21,7 @@ public void createTaskManager() {
 
     @Test
     @DisplayName("Добавление подзадачи")
-    void addNewSubtask() {
+    void testAddNewSubtask() {
         Epic epic = new Epic("Эпик", "Тело эпика",TaskStatus.NEW);
         taskManager.addEpic(epic);
         Subtask subtask = new Subtask("подзадача", "тело", epic.getId(), TaskStatus.NEW);
diff --git a/test/tasks/TaskTest.java b/test/tasks/TaskTest.java
index 3e9f27f..4603537 100644
--- a/test/tasks/TaskTest.java
+++ b/test/tasks/TaskTest.java
@@ -1,6 +1,5 @@
 package tasks;
 
-import managers.HistoryManager;
 import managers.Managers;
 import managers.TaskManager;
 import org.junit.jupiter.api.BeforeEach;
@@ -22,7 +21,7 @@ public void createTaskManager() {
 
     @Test
     @DisplayName("Добавление задачи")
-    void addNewTask() {
+    void testAddNewTask() {
         Task task = new Task("Таск", "Тело таска",TaskStatus.NEW);
         taskManager.addTask(task);
         final int taskId = task.getId();