diff --git a/src/Main.java b/src/Main.java
index 40ebbc4..18818d4 100644
--- a/src/Main.java
+++ b/src/Main.java
@@ -6,7 +6,6 @@
 import manager.TaskManager;
 import manager.TaskManagerType;
 
-import java.util.ArrayList;
 import java.util.List;
 
 public class Main {
@@ -20,12 +19,18 @@ public static void main(String[] args) {
         printListAll();
 
         testSubtasks();
+
+        printHistory();
+
         testEpics();
-        testTasks();
 
-        printListAll();
+        printHistory();
+
+        testTasks();
 
         printHistory();
+
+        printListAll();
     }
 
     /// Ввести исходные данные
@@ -52,21 +57,21 @@ static void insertStartData() {
                 "Найти девушку для знакомства",
                 "Использовать различные способы поиска, для ускорения процесса"
         ));
-        Subtask subtask1 = manager.setSubTask(new Subtask(
+        Subtask subtask1 = manager.setSubtask(new Subtask(
                 null,
                 "Поиск на сайтах знакомств",
                 null,
                 null,
                 epic1.getId()
         ));
-        Subtask subtask2 = manager.setSubTask(new Subtask(
+        Subtask subtask2 = manager.setSubtask(new Subtask(
                 null,
                 "Поиск через знакомых",
                 null,
                 null,
                 epic1.getId()
                 ));
-        Subtask subtask3 = manager.setSubTask(new Subtask(
+        Subtask subtask3 = manager.setSubtask(new Subtask(
                 null,
                 "Поиск в литературном клубе",
                 null,
@@ -79,7 +84,7 @@ static void insertStartData() {
                 "Оптимизировать поиск девушки",
                 "Получить результат быстрее и с меньшими затратами"
                 ));
-        Subtask subtask4 = manager.setSubTask(new Subtask(
+        Subtask subtask4 = manager.setSubtask(new Subtask(
                 null,
                 "Выбрать наиболее оптимальный способ поиска",
                 null,
@@ -92,21 +97,21 @@ static void insertStartData() {
                 "Создать систему оценки способов поиска",
                 "Без статистики не обойтись"
                 ));
-        Subtask subtask5 = manager.setSubTask(new Subtask(
+        Subtask subtask5 = manager.setSubtask(new Subtask(
                 null,
                 "Задать параметры системы оценки",
                 "Возможно бальная система",
                 null,
                 epic3.getId()
                 ));
-        Subtask subtask6 = manager.setSubTask(new Subtask(
+        Subtask subtask6 = manager.setSubtask(new Subtask(
                 null,
                 "Собрать статистику способов",
                 null,
                 null,
                 epic3.getId()
         ));
-        Subtask subtask7 = manager.setSubTask(new Subtask(
+        Subtask subtask7 = manager.setSubtask(new Subtask(
                 null,
                 "Провести статистическое исследование",
                 null,
@@ -126,6 +131,7 @@ static void printHistory() {
             System.out.println(stringBuilder);
             i++;
         }
+        System.out.println("\n" + "-".repeat(20) + "\n");
     }
 
     /// Вывести все данные
diff --git a/src/data/Epic.java b/src/data/Epic.java
index ef80580..fa3d923 100644
--- a/src/data/Epic.java
+++ b/src/data/Epic.java
@@ -24,7 +24,7 @@ public void addSubtaskId(Integer subtaskId) {
     }
 
     /// Удаление всех ID подзадач
-    public void removeAllSubTaskIds() {
+    public void removeAllSubtaskIds() {
         subtaskIds.clear();
     }
 
diff --git a/src/manager/HistoryManager.java b/src/manager/HistoryManager.java
index 1301361..52a2ea3 100644
--- a/src/manager/HistoryManager.java
+++ b/src/manager/HistoryManager.java
@@ -4,9 +4,11 @@
 
 import java.util.List;
 
-public interface HistoryManager<T> {
+public interface HistoryManager {
 
-    List<T> getHistory();
+    void add(Task task);
 
-    void add(Task taskObject);
+    void remove(int id);
+
+    List<Task> getHistory();
 }
diff --git a/src/manager/InMemoryHistoryManager.java b/src/manager/InMemoryHistoryManager.java
index 8f7a5ff..0956c52 100644
--- a/src/manager/InMemoryHistoryManager.java
+++ b/src/manager/InMemoryHistoryManager.java
@@ -2,24 +2,118 @@
 
 import data.Task;
 
-import java.util.ArrayList;
-import java.util.List;
+import java.util.*;
 
-public class InMemoryHistoryManager<T> implements HistoryManager<T> {
+public class InMemoryHistoryManager implements HistoryManager {
 
-    private final int maxSize = 10;
-    private final List<Task> history = new ArrayList<>(maxSize);
+    private Node first;
+    private Node last;
+
+    private final Map<Integer, Node> idToNode = new HashMap<>();
 
     @Override
-    public List<T> getHistory() {
-        return new ArrayList<>((ArrayList<? extends T>) history);
+    public List<Task> getHistory() {
+        return getTasks();
     }
 
     @Override
-    public void add(Task taskObject) {
-        if (history.size() == maxSize) {
-            history.removeFirst();
+    public void add(Task task) {
+        int taskId = task.getId();
+
+        if (idToNode.containsKey(taskId)) {
+            removeNode(idToNode.get(taskId));
+        }
+        linkLast(task);
+    }
+
+    @Override
+    public void remove(int id) {
+        if (idToNode.containsKey(id)) {
+            removeNode(idToNode.get(id));
+        }
+    }
+
+    private void linkLast(Task task) {
+        Node newLastNode;
+
+        if (idToNode.isEmpty()) {
+            newLastNode = new Node(null, task, null);
+            idToNode.put(task.getId(), newLastNode);
+            first = newLastNode;
+            last = newLastNode;
+        } else if (last == first) {
+            newLastNode = new Node(first, task, null);
+            last = newLastNode;
+            first.next = newLastNode;
+        } else {
+            newLastNode = new Node(last, task, null);
+            last.next = newLastNode;
+            last = newLastNode;
+        }
+
+        idToNode.put(task.getId(), newLastNode);
+    }
+
+    private ArrayList<Task> getTasks() {
+        ArrayList<Task> tasks = new ArrayList<>();
+
+        if (first == null) {
+            return tasks;
+        }
+
+        Node node = first;
+        while (node.next != null) {
+            tasks.add(node.data);
+            node = node.next;
+        }
+        tasks.add(node.data);
+
+        return tasks;
+    }
+
+    private void removeNode(Node node) {
+
+        int taskId = node.data.getId();
+
+        if (node.prev == null & node.next == null) {
+            first = null;
+            last = null;
+        } else if (node.prev == null) {
+            first = node.next;
+            first.prev = null;
+        } else if (node.next == null) {
+            last = node.prev;
+            last.next = null;
+        } else {
+            node.prev.next = node.next;
+            node.next.prev = node.prev;
+        }
+
+        idToNode.remove(taskId);
+    }
+
+    static class Node {
+
+        public Node prev;
+        public Task data;
+        public Node next;
+
+        public Node(Node prev, Task data, Node next) {
+            this.data = data;
+            this.next = next;
+            this.prev = prev;
+        }
+
+        @Override
+        public boolean equals(Object o) {
+            if (o == null || getClass() != o.getClass()) return false;
+            Node node = (Node) o;
+            return Objects.equals(data, node.data);
+        }
+
+        @Override
+        public int hashCode() {
+            return Objects.hashCode(data);
         }
-        history.add(taskObject);
     }
 }
diff --git a/src/manager/InMemoryTaskManager.java b/src/manager/InMemoryTaskManager.java
index d391b73..4d17c72 100644
--- a/src/manager/InMemoryTaskManager.java
+++ b/src/manager/InMemoryTaskManager.java
@@ -7,6 +7,7 @@
 
 import java.util.ArrayList;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
 
 class InMemoryTaskManager implements TaskManager {
@@ -21,7 +22,7 @@ class InMemoryTaskManager implements TaskManager {
     private final Map<Integer, Subtask> idToSubtask = new HashMap<>();
 
     /// Менеджер истории просмотров
-    HistoryManager<? extends Task> historyManager = Managers.getHistoryManager();
+    HistoryManager historyManager = Managers.getHistoryManager();
 
     /// Счетчик ID
     int counter = 1;
@@ -31,7 +32,7 @@ private int generateNewId() {
         return counter++;
     }
 
-    /// Внесение задачи в хранилище по объекту *
+    /// Внесение задачи в хранилище по объекту
     @Override
     public Task setTask(Task newTask) {
         newTask.setId(generateNewId());
@@ -41,7 +42,7 @@ public Task setTask(Task newTask) {
         return newTask;
     }
 
-    /// Внесение эпика в хранилище по объекту *
+    /// Внесение эпика в хранилище по объекту
     @Override
     public Epic setEpic(Epic newEpic) {
         newEpic.setId(generateNewId());
@@ -53,9 +54,9 @@ public Epic setEpic(Epic newEpic) {
         return newEpic;
     }
 
-    /// Внесение подзадачи в хранилище по объекту *
+    /// Внесение подзадачи в хранилище по объекту
     @Override
-    public Subtask setSubTask(Subtask newSubtask) {
+    public Subtask setSubtask(Subtask newSubtask) {
         Integer epicId = newSubtask.getEpicId();
         if (epicId == null || idToEpic.get(epicId) == null) {
             return null;
@@ -81,7 +82,7 @@ public Subtask setSubTask(Subtask newSubtask) {
         return newSubtask;
     }
 
-    /// Получение задачи по ID *
+    /// Получение задачи по ID
     @Override
     public Task getTask(int taskID) {
         Task task = idToTask.getOrDefault(taskID, null);
@@ -95,10 +96,10 @@ public Task getTask(int taskID) {
                 task.getStatus()
         );
         historyManager.add(newTask);
-        return task;
+        return newTask;
     }
 
-    /// Получение эпика по ID *
+    /// Получение эпика по ID
     @Override
     public Epic getEpic(int epicID) {
         Epic epic = idToEpic.getOrDefault(epicID, null);
@@ -110,14 +111,15 @@ public Epic getEpic(int epicID) {
                 epic.getTitle(),
                 epic.getDescription()
         );
+        newEpic.setStatus(epic.getStatus());
         for (int subtaskId : epic.getSubtaskIds()) {
             newEpic.addSubtaskId(subtaskId);
         }
         historyManager.add(newEpic);
-        return epic;
+        return newEpic;
     }
 
-    /// Получение подзадачи по ID *
+    /// Получение подзадачи по ID
     @Override
     public Subtask getSubtask(int subTaskID) {
         Subtask subtask = idToSubtask.getOrDefault(subTaskID, null);
@@ -132,28 +134,28 @@ public Subtask getSubtask(int subTaskID) {
                 subtask.getEpicId()
         );
         historyManager.add(newSubtask);
-        return subtask;
+        return newSubtask;
     }
 
-    /// Получение списка всех задач в виде объекта *
+    /// Получение списка всех задач в виде объекта
     @Override
     public ArrayList<Task> getAllTasks() {
         return new ArrayList<>(idToTask.values());
     }
 
-    /// Получение списка всех эпиков в виде объекта *
+    /// Получение списка всех эпиков в виде объекта
     @Override
     public ArrayList<Epic> getAllEpics() {
         return new ArrayList<>(idToEpic.values());
     }
 
-    /// Получение списка всех подзадач в виде объекта *
+    /// Получение списка всех подзадач в виде объекта
     @Override
     public ArrayList<Subtask> getAllSubtasks() {
         return new ArrayList<>(idToSubtask.values());
     }
 
-    /// Получение списка всех подзадач эпика в виде объекта *
+    /// Получение списка всех подзадач эпика в виде объекта
     @Override
     public ArrayList<Subtask> getAllSubTasksByEpic(int epicId) {
         if (!idToEpic.containsKey(epicId)) {
@@ -173,7 +175,7 @@ public ArrayList<Subtask> getAllSubTasksByEpic(int epicId) {
         return resultSubtasks;
     }
 
-    /// Обновление задачи по объекту *
+    /// Обновление задачи по объекту
     @Override
     public Task updateTask(Task newTask) {
         Integer id = newTask.getId();
@@ -204,7 +206,7 @@ public Task updateTask(Task newTask) {
         return newTask;
     }
 
-    /// Обновление эпика по объекту *
+    /// Обновление эпика по объекту
     @Override
     public Epic updateEpic(Epic newEpic) {
         Integer id = newEpic.getId();
@@ -228,7 +230,7 @@ public Epic updateEpic(Epic newEpic) {
         return oldEpic;
     }
 
-    /// Обновление подзадачи по объекту *
+    /// Обновление подзадачи по объекту
     @Override
     public Subtask updateSubtask(Subtask newSubtask) {
         Integer id = newSubtask.getId();
@@ -259,17 +261,18 @@ public Subtask updateSubtask(Subtask newSubtask) {
         return oldSubtask;
     }
 
-    /// Удаление задачи по ID *
+    /// Удаление задачи по ID
     @Override
     public boolean removeTask(int taskId) {
         if (!idToTask.containsKey(taskId)) {
             return false;
         }
         idToTask.remove(taskId);
+        historyManager.remove(taskId);
         return true;
     }
 
-    /// Удаление эпика по ID *
+    /// Удаление эпика по ID
     @Override
     public boolean removeEpic(int epicId) {
         if (!idToEpic.containsKey(epicId)) {
@@ -277,6 +280,7 @@ public boolean removeEpic(int epicId) {
         }
         removeAllSubtasksByEpic(epicId);
         idToEpic.remove(epicId);
+        historyManager.remove(epicId);
         return true;
     }
 
@@ -292,6 +296,7 @@ public boolean removeSubtask(int subtaskId) {
         idToSubtask.remove(subtaskId);
         epic.removeSubtaskId(subtaskId);
         updateEpicsStatus(epicId);
+        historyManager.remove(subtaskId);
         return true;
     }
 
@@ -304,38 +309,53 @@ public void removeAllSubtasksByEpic(int epicId) {
         Epic epic = idToEpic.get(epicId);
         for (int subtaskId : epic.getSubtaskIds()) {
             idToSubtask.remove(subtaskId);
+            historyManager.remove(subtaskId);
         }
-        epic.removeAllSubTaskIds();
+        epic.removeAllSubtaskIds();
         updateEpicsStatus(epicId);
     }
 
-    /// Удаление всех задач *
+    /// Удаление всех задач
     @Override
     public void removeAllTasks() {
+        for (int taskId : idToTask.keySet()) {
+            historyManager.remove(taskId);
+        }
         idToTask.clear();
     }
 
-    /// Удаление всех эпиков *
+    /// Удаление всех эпиков
     @Override
     public void removeAllEpics() {
+        for (int epicId : idToEpic.keySet()) {
+            historyManager.remove(epicId);
+        }
         idToEpic.clear();
+
+        for (int subtaskId : idToSubtask.keySet()) {
+            historyManager.remove(subtaskId);
+        }
         idToSubtask.clear();
     }
 
-    /// Удаление всех подзадач *
+    /// Удаление всех подзадач
     @Override
     public void removeAllSubTasks() {
+        for (int subtaskId : idToSubtask.keySet()) {
+            historyManager.remove(subtaskId);
+        }
         idToSubtask.clear();
+
         for (Epic epic : idToEpic.values()) {
-            epic.removeAllSubTaskIds();
+            epic.removeAllSubtaskIds();
             updateEpicsStatus(epic.getId());
         }
     }
 
-    ///  Получить последние 10 задач
+    ///  Получить список с историей
     @Override
-    public ArrayList<? extends Task> getHistory() {
-        return (ArrayList<? extends Task>) historyManager.getHistory();
+    public List<Task> getHistory() {
+        return historyManager.getHistory();
     }
 
     /// Обновление статуса эпика
diff --git a/src/manager/Managers.java b/src/manager/Managers.java
index 2dc366c..0c3705c 100644
--- a/src/manager/Managers.java
+++ b/src/manager/Managers.java
@@ -17,7 +17,7 @@ public static TaskManager getTaskManager(TaskManagerType type) {
         }
     }
 
-    public static <T> HistoryManager<T> getHistoryManager() {
-        return new InMemoryHistoryManager<>();
+    public static HistoryManager getHistoryManager() {
+        return new InMemoryHistoryManager();
     }
 }
diff --git a/src/manager/TaskManager.java b/src/manager/TaskManager.java
index c8b88c4..d03e891 100644
--- a/src/manager/TaskManager.java
+++ b/src/manager/TaskManager.java
@@ -12,7 +12,7 @@ public interface TaskManager {
 
     Epic setEpic(Epic newEpic);
 
-    Subtask setSubTask(Subtask newSubtask);
+    Subtask setSubtask(Subtask newSubtask);
 
     Task getTask(int taskID);
 
diff --git a/test/data/EpicTest.java b/test/data/EpicTest.java
index 028d07a..475b368 100644
--- a/test/data/EpicTest.java
+++ b/test/data/EpicTest.java
@@ -53,7 +53,7 @@ void shouldReturnFalseAfterOneSubtasksRemovedAndGets() {
 
     @Test
     void shouldBeEmptyAfterRemoveAllSubtasks() {
-        epic.removeAllSubTaskIds();
+        epic.removeAllSubtaskIds();
         assertEquals("[]", epic.getSubtaskIds().toString(),
                 "Эпик не удаляет все подзадачи одной командой."
                 );
diff --git a/test/manager/HistoryManagerTest.java b/test/manager/HistoryManagerTest.java
index e655024..b060ebf 100644
--- a/test/manager/HistoryManagerTest.java
+++ b/test/manager/HistoryManagerTest.java
@@ -5,6 +5,8 @@
 import data.Subtask;
 import data.Status;
 
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 
 import java.util.ArrayList;
@@ -14,31 +16,70 @@
 
 public class HistoryManagerTest<T> {
 
-    @Test
-    void add() {
-        HistoryManager<T> historyManager = new InMemoryHistoryManager<>();
+    static HistoryManager historyManager;
+    static List<Task> history;
 
+    @BeforeEach
+    void beforeEach() {
+        historyManager = new InMemoryHistoryManager();
         Task task = new Task(1, "Hello", "World", Status.DONE);
-
         historyManager.add(task);
-
         historyManager.add(new Epic(2, "Hello", "World"));
-
         historyManager.add(new Subtask(3, "Hello", "World", Status.DONE, 2));
+        historyManager.add(new Task(1, "Goodbye", "World", Status.IN_PROGRESS));
+        history = historyManager.getHistory();
+
+        historyManager.remove(4);
+    }
+
+    @Test
+    void shouldReturnEmptyListWhenHistoryIsEmpty() {
+        HistoryManager hm = new InMemoryHistoryManager();
+        hm.add(new Subtask(1, null, null, null, 2));
+        hm.remove(1);
+        assertEquals("[]", hm.getHistory().toString(),
+                "Пустая история не выдает пустой лист");
+    }
 
-        List<T> history = historyManager.getHistory();
+    @Test
+    void shouldReturnNotNullWhenGetHistory() {
         assertNotNull(history, "История не возвращается.");
+    }
+
+    @Test
+    void shouldReturnHistorySizeEqualsThree() {
         assertEquals(3, history.size(), "История содержит неверное количество элементов.");
+    }
+
+    @Test
+    void shouldReturnLastElementWithIdThree() {
+        historyManager.remove(1);
+        int elementId = historyManager.getHistory().getLast().getId();
+        assertEquals(3, elementId,
+                "Неверная перелинковка нодов при удалении");
+    }
 
-        for (int i = 4; i <= 11; i++) {
+    @Test
+    void shouldWorkInLessThanOneTenthOfMillisecond() {
+
+        for (int i = 4; i <= 10_000; i++) {
             historyManager.add(new Task(i, null, null));
         }
-        history = historyManager.getHistory();
 
-        assertEquals(10, history.size(),
-                "История имеет неправильное ограничение на максимальное количество элементов");
+        int historySize = historyManager.getHistory().size();
+        int idToRemove = 5039;
+        final long startTime = System.nanoTime();
+        historyManager.remove(idToRemove);
+        final long endTime = System.nanoTime();
+
+        final long resultTime = endTime - startTime;
+
+        System.out.println("Удаление " + idToRemove + "-го элемента из " + historySize
+                + " элементов за " + resultTime +  " мкс.");
 
-        assertNotSame(history.getFirst(), task,
-                "История не удаляет самый старый элемент при добавлении одиннадцатого элемента");
+        assertTrue(resultTime <= 100_000,
+                "Удаление одного элемента из истории с 10_000 элементов занимает больше 0,1 миллисекунд"
+                        + "\n this test not working with coverage"
+                );
     }
 }
diff --git a/test/manager/TaskManagerTest.java b/test/manager/TaskManagerTest.java
index e330655..a1ec34d 100644
--- a/test/manager/TaskManagerTest.java
+++ b/test/manager/TaskManagerTest.java
@@ -29,10 +29,10 @@ public class TaskManagerTest<T extends Task> {
 
     static List<Subtask> subtasks;
 
-    void updateTaskHistory(ArrayList<T> history) {
+    void updateTaskHistory(List<Task> history) {
         manager.getTask(taskId);
         history.clear();
-        history.addAll((ArrayList<? extends T>) manager.getHistory());
+        history.addAll(manager.getHistory());
     }
 
     @BeforeEach
@@ -75,7 +75,7 @@ void beforeEach() {
         epicId = manager.setEpic(epic).getId();
 
         // Добавить первую подзадачу в созданный эпик
-        manager.setSubTask(new Subtask(
+        manager.setSubtask(new Subtask(
                 777,
                 "This is first Subtask",
                 "This is description of first Subtask",
@@ -84,7 +84,7 @@ void beforeEach() {
         ));
 
         // Добавить вторую подзадачу в созданный эпик
-        manager.setSubTask(new Subtask(
+        manager.setSubtask(new Subtask(
                 null,
                 "This is second Subtask",
                 "This is description of second Subtask",
@@ -93,7 +93,7 @@ void beforeEach() {
         ));
 
         // Добавить третью подзадачу в созданный эпик
-        manager.setSubTask(new Subtask(
+        manager.setSubtask(new Subtask(
                 null,
                 "This is third Subtask",
                 "This is description of third Subtask",
@@ -142,7 +142,7 @@ void shouldBeEqualsCreatedTaskAndTaskOfListAllTasks() {
 
     @Test
     void shouldBeOneElementOfHistoryList() {
-        ArrayList<T> history = (ArrayList<T>) manager.getHistory();
+        List<Task> history = new ArrayList<>(manager.getHistory());
         assertEquals(3, history.size(), "Неверное количество задач в истории.");
     }
 
@@ -154,25 +154,27 @@ void shouldBeEqualsCreatedTaskAndTaskOfHistoryList() {
 
     @Test
     void shouldBeTwoElementOfHistoryListAfterUpdateAndGet() {
-        ArrayList<T> history = (ArrayList<T>) manager.getHistory();
+        List<Task> history = new ArrayList<>(manager.getHistory());
         updateTaskHistory(history);
-        assertEquals(4, history.size(), "Неверное количество задач в истории.");
+        assertEquals(3, history.size(), "Неверное количество задач в истории.");
     }
 
     @Test
     void shouldBeStatusEqualsOfCreatedTaskAndFirstTaskOfHistoryListAfterUpdateAndGet() {
-        ArrayList<T> history = (ArrayList<T>) manager.getHistory();
+        manager.updateTask(new Task(1, null, null, Status.NEW));
+        List<Task> history = new ArrayList<>(manager.getHistory());
         updateTaskHistory(history);
-        assertEquals(task.getStatus(), history.getFirst().getStatus(),
-                "Статус созданной задачи не соответствует статусу первой задачи из истории."
+        Task testedTask = manager.getTask(1);
+        assertEquals(testedTask.getStatus(), history.getLast().getStatus(),
+                "Статус созданной задачи не соответствует статусу последней задачи из истории."
         );
     }
 
     @Test
     void shouldBeStatusEqualsOfSavedTaskAndLastTaskOfHistoryListAfterUpdateAndGet() {
-        ArrayList<T> history = (ArrayList<T>) manager.getHistory();
+        List<Task> history = new ArrayList<>(manager.getHistory());
         updateTaskHistory(history);
-        assertEquals(savedTask.getStatus(), history.getLast().getStatus(),
+        assertEquals(manager.getTask(1).getStatus(), history.getLast().getStatus(),
                 "Статус сохраненной задачи не соответствует статусу последней задачи из истории."
         );
     }
@@ -205,7 +207,15 @@ void shouldBeEqualsCreatedEpicAndTaskOfListAllEpics() {
     @Test
     void shouldUpdateEpicTitleWhenUpdateEpic() {
         manager.updateEpic(new Epic(2, "HelloWorld!", null));
-        assertEquals("HelloWorld!", savedEpic.getTitle(), "Менеджер неправильно обновляет эпик.");
+        assertEquals("HelloWorld!", manager.getEpic(2).getTitle(), "Менеджер неправильно обновляет эпик.");
+    }
+
+    @Test
+    void shouldReturnTwoAfterSetNewIdOfCashedEpic() {
+        manager.getEpic(2).setId(3);
+        int testEpicId = manager.getAllEpics().getLast().getId();
+        assertEquals(2, testEpicId,
+                "Изменение эпика через сеттер влияет на эпик хранящийся в менеджере");
     }
 
     @Test
@@ -216,7 +226,8 @@ void shouldBeNotNullListSubtasksOfSavedEpic() {
     @Test
     void shouldBeTwoSubtaskIdsContainsOfSavedEpicAfterRemoveSubtask() {
         manager.removeSubtask(3);
-        assertEquals(1, savedEpic.getSubtaskIds().size(),
+        Epic testedEpic = manager.getEpic(2);
+        assertEquals(1, testedEpic.getSubtaskIds().size(),
                 "Сохраненный эпик возвращает неверное количество идентификаторов подзадач " +
                         "после удаления подзадачи.");
     }
@@ -224,7 +235,8 @@ void shouldBeTwoSubtaskIdsContainsOfSavedEpicAfterRemoveSubtask() {
     @Test
     void shouldBeIsEmptySubtaskListAfterRemoveAllSubtasks() {
         manager.removeAllSubtasksByEpic(epicId);
-        assertEquals("[]", savedEpic.getSubtaskIds().toString(),
+        Epic testedEpic = manager.getEpic(epicId);
+        assertEquals("[]", testedEpic.getSubtaskIds().toString(),
                 "Список идентификаторов подзадач эпика должен быть пуст после удаления всех подзадач эпика.");
     }
 
@@ -233,9 +245,19 @@ void shouldContainsTwoElementsInSubtasksList() {
         assertEquals(2, subtasks.size(), "Список всех подзадач возвращает не верное количество.");
     }
 
+    @Test
+    void shouldReturnStatusNewWhenAllSubtasksInStatusesNull() {
+        manager.setSubtask(new Subtask(null, null, null, null, 2));
+        manager.setSubtask(new Subtask(null, null, null, null, 2));
+        manager.removeSubtask(3);
+        manager.removeSubtask(4);
+        assertEquals(Status.NEW, manager.getEpic(2).getStatus(),
+                "Эпик не выставляет статус NEW когда все подзадачи в статусе null");
+    }
+
     @Test
     void shouldReturnNullWhenAddingSubtaskWithMissingId() {
-        manager.setSubTask(new Subtask(null, "Hello", "World", null, 777));
+        manager.setSubtask(new Subtask(null, "Hello", "World", null, 777));
         assertEquals(2, subtasks.size(), "Подзадача добавляется в несуществующий эпик.");
     }
 
@@ -250,13 +272,27 @@ void shouldEqualsTwoWhenRemoveAllSubtaskWithMissingEpicId() {
     @Test
     void shouldTwoWhenGetAllSubtasksByEpic() {
         assertEquals(2, manager.getAllSubTasksByEpic(2).size(),
-                "Менеджер возвращает не верное количество задач при вызове ");
+                "Менеджер возвращает не верное количество подзадач при вызове всех подзадач эпика");
+    }
+
+    @Test
+    void shouldReturnThreeAndFourWhenGetAllSubtasksIdsByEpic() {
+        Epic testEpic = manager.getEpic(2);
+        assertEquals(3, testEpic.getSubtaskIds().getFirst());
+        assertEquals(4, testEpic.getSubtaskIds().getLast(),
+                "Внутри эпиков остаются неактуальные id подзадач.");
+    }
+
+    @Test
+    void shouldReturnNullWhenTryingToGetAllSubtasks() {
+        assertNull( manager.getAllSubTasksByEpic(100),
+                "Менеджер не возвращает null при попытке получения всех подзадач несуществующего эпика");
     }
 
     @Test
     void shouldUpdateEpicStatusWhenAllHimSubtasksIsDone() {
         manager.updateSubtask(new Subtask(3, null, null, Status.DONE, null));
-        assertEquals(Status.DONE, savedEpic.getStatus(),
+        assertEquals(Status.DONE, manager.getAllEpics().getLast().getStatus(),
                 "Статус эпика не обновляется когда все его подзадачи завершены");
     }
 
@@ -288,7 +324,8 @@ void shouldReturnEmptyAfterRemoveAllSubtasks() {
     @Test
     void shouldReturnEpicStatusNewAfterRemoveAllSubtasks() {
         manager.removeAllSubTasks();
-        assertEquals(Status.NEW, manager.getEpic(2).getStatus(),
+        Epic testedEpic = manager.getEpic(2);
+        assertEquals(Status.NEW, testedEpic.getStatus(),
                 "Менеджер не присваивает эпикам статус NEW после очистки главного хранилища подзадач.");
     }
 
@@ -298,4 +335,39 @@ void shouldReturnNullAfterRemoveAllEpics() {
         assertEquals("[]", manager.getAllSubtasks().toString(),
                 "Менеджер не очищает хранилище подзадач после очистки хранилища эпиков.");
     }
+
+    @Test
+    void shouldReturnTwoWhenAllTasksIsDeleted() {
+        manager.removeAllTasks();
+        assertEquals(2, manager.getHistory().getFirst().getId(),
+                "При удалении всех задач они не удаляются из истории"
+                );
+    }
+
+    @Test
+    void shouldReturnListWithOneElementWhenAllEpicsIsDeleted() {
+        manager.removeAllEpics();
+        assertEquals(1, manager.getHistory().size(),
+                "При удалении всех эпиков эпики не удаляются из истории с их подзадачами"
+        );
+    }
+
+    @Test
+    void shouldReturnTwoWhenAllSubtasksIsDeleted() {
+        manager.removeAllSubTasks();
+        assertEquals(2, manager.getHistory().size(),
+                "При удалении всех подзадач они не удаляются из истории"
+        );
+    }
+
+    @Test
+    void shouldReturnTwoWhenAllSubtasksByEpicIsDeleted() {
+        manager.setEpic(new Epic(null, null, null));
+        manager.setSubtask(new Subtask(null, null, null, null, 5));
+        manager.getSubtask(6);
+        manager.removeAllSubtasksByEpic(2);
+        assertEquals(3, manager.getHistory().size(),
+                "При удалении всех подзадач эпика они не удаляются из истории"
+        );
+    }
 }