refactor: unify code style and fix minor merge issues

app/src/main/java/ru/project/sorting/BubbleSortStrategy.java

@@ -1,24 +1,24 @@
 package ru.project.sorting;
 
-import ru.project.list.MyList;
 import java.util.Comparator;
+import ru.project.collection.MyList;
 
 public class BubbleSortStrategy<T> implements SortStrategy<T> {
 
-    @Override
+  @Override
-    public void sort(MyList<T> list, Comparator<T> comparator) {
+  public void sort(MyList<T> list, Comparator<T> comparator) {
-        if (list == null || list.size() <= 1) {
+    if (list == null || list.size() <= 1) {
-            return;
+      return;
-        }
-        int n = list.size();
-        for (int i = 0; i < n - 1; i++) {
-            for (int j = 0; j < n - i - 1; j++) {
-                if (comparator.compare(list.get(j), list.get(j + 1)) > 0) {
-                    T temp = list.get(j);
-                    list.set(j, list.get(j + 1));
-                    list.set(j + 1, temp);
-                }
-            }
-        }
     }
-}
+    int n = list.size();
+    for (int i = 0; i < n - 1; i++) {
+      for (int j = 0; j < n - i - 1; j++) {
+        if (comparator.compare(list.get(j), list.get(j + 1)) > 0) {
+          T temp = list.get(j);
+          list.set(j, list.get(j + 1));
+          list.set(j + 1, temp);
+        }
+      }
+    }
+  }
+}

app/src/main/java/ru/project/sorting/EvenOnlyMergeSortStrategy.java

@@ -1,84 +1,84 @@
 package ru.project.sorting;
 
-import ru.project.list.MyList;
 import java.util.ArrayList;
 import java.util.Comparator;
 import java.util.List;
 import java.util.function.ToIntFunction;
+import ru.project.collection.MyList;
 
 public class EvenOnlyMergeSortStrategy<T> implements SortStrategy<T> {
 
-    private final ToIntFunction<T> valueExtractor;
+  private final ToIntFunction<T> valueExtractor;
 
-    public EvenOnlyMergeSortStrategy(ToIntFunction<T> valueExtractor) {
+  public EvenOnlyMergeSortStrategy(ToIntFunction<T> valueExtractor) {
-        this.valueExtractor = valueExtractor;
+    this.valueExtractor = valueExtractor;
+  }
+
+  @Override
+  public void sort(MyList<T> list, Comparator<T> comparator) {
+    if (list == null || list.size() <= 1) {
+      return;
     }
 
-    @Override
+    List<Integer> evenIndices = new ArrayList<>();
-    public void sort(MyList<T> list, Comparator<T> comparator) {
+    List<T> evenElements = new ArrayList<>();
-        if (list == null || list.size() <= 1) {
-            return;
-        }
 
-        List<Integer> evenIndices = new ArrayList<>();
+    for (int i = 0; i < list.size(); i++) {
-        List<T> evenElements = new ArrayList<>();
+      T element = list.get(i);
-
+      int value = valueExtractor.applyAsInt(element);
-        for (int i = 0; i < list.size(); i++) {
+      if (value % 2 == 0) {
-            T element = list.get(i);
+        evenIndices.add(i);
-            int value = valueExtractor.applyAsInt(element);
+        evenElements.add(element);
-            if (value % 2 == 0) {
+      }
-                evenIndices.add(i);
-                evenElements.add(element);
-            }
-        }
-
-        if (evenElements.size() <= 1) {
-            return;
-        }
-
-        List<T> sortedEven = mergeSort(evenElements, comparator);
-
-        for (int j = 0; j < evenIndices.size(); j++) {
-            list.set(evenIndices.get(j), sortedEven.get(j));
-        }
     }
 
-    private List<T> mergeSort(List<T> list, Comparator<T> comparator) {
+    if (evenElements.size() <= 1) {
-        if (list.size() <= 1) {
+      return;
-            return list;
-        }
-
-        int mid = list.size() / 2;
-        List<T> left = mergeSort(list.subList(0, mid), comparator);
-        List<T> right = mergeSort(list.subList(mid, list.size()), comparator);
-
-        return merge(left, right, comparator);
     }
 
-    private List<T> merge(List<T> left, List<T> right, Comparator<T> comparator) {
+    List<T> sortedEven = mergeSort(evenElements, comparator);
-        List<T> result = new ArrayList<>();
-        int i = 0, j = 0;
 
-        while (i < left.size() && j < right.size()) {
+    for (int j = 0; j < evenIndices.size(); j++) {
-            if (comparator.compare(left.get(i), right.get(j)) <= 0) {
+      list.set(evenIndices.get(j), sortedEven.get(j));
-                result.add(left.get(i));
-                i++;
-            } else {
-                result.add(right.get(j));
-                j++;
-            }
-        }
-
-        while (i < left.size()) {
-            result.add(left.get(i));
-            i++;
-        }
-
-        while (j < right.size()) {
-            result.add(right.get(j));
-            j++;
-        }
-
-        return result;
     }
-}
+  }
+
+  private List<T> mergeSort(List<T> list, Comparator<T> comparator) {
+    if (list.size() <= 1) {
+      return list;
+    }
+
+    int mid = list.size() / 2;
+    List<T> left = mergeSort(list.subList(0, mid), comparator);
+    List<T> right = mergeSort(list.subList(mid, list.size()), comparator);
+
+    return merge(left, right, comparator);
+  }
+
+  private List<T> merge(List<T> left, List<T> right, Comparator<T> comparator) {
+    List<T> result = new ArrayList<>();
+    int i = 0, j = 0;
+
+    while (i < left.size() && j < right.size()) {
+      if (comparator.compare(left.get(i), right.get(j)) <= 0) {
+        result.add(left.get(i));
+        i++;
+      } else {
+        result.add(right.get(j));
+        j++;
+      }
+    }
+
+    while (i < left.size()) {
+      result.add(left.get(i));
+      i++;
+    }
+
+    while (j < right.size()) {
+      result.add(right.get(j));
+      j++;
+    }
+
+    return result;
+  }
+}

app/src/main/java/ru/project/sorting/EvenOnlySortStrategy.java

@@ -1,94 +1,89 @@
 package ru.project.sorting;
 
-import ru.project.collection.MyLinkedList;
-import ru.project.collection.MyList;
-
 import java.util.Comparator;
 import java.util.function.ToIntFunction;
+import ru.project.collection.MyLinkedList;
+import ru.project.collection.MyList;
 
 public class EvenOnlySortStrategy<T> implements SortStrategy<T> {
 
-    private SortStrategy<T> sortStrategy;
+  private SortStrategy<T> sortStrategy;
-    private ToIntFunction<T> valueExtractor;
+  private ToIntFunction<T> valueExtractor;
 
-    public EvenOnlySortStrategy() {
+  public EvenOnlySortStrategy() {}
+
+  public EvenOnlySortStrategy(SortStrategy<T> sortStrategy) {
+    setSortStrategy(sortStrategy);
+  }
+
+  public EvenOnlySortStrategy(SortStrategy<T> sortStrategy, ToIntFunction<T> valueExtractor) {
+    setSortStrategy(sortStrategy);
+    setValueExtractor(valueExtractor);
+  }
+
+  public void setSortStrategy(SortStrategy<T> sortStrategy) {
+    if (sortStrategy == null) {
+      throw new IllegalArgumentException("Sort strategy must not be null");
     }
 
-    public EvenOnlySortStrategy(SortStrategy<T> sortStrategy) {
+    this.sortStrategy = sortStrategy;
-        setSortStrategy(sortStrategy);
+  }
+
+  public void setValueExtractor(ToIntFunction<T> valueExtractor) {
+    if (valueExtractor == null) {
+      throw new IllegalArgumentException("Value extractor must not be null");
     }
 
-    public EvenOnlySortStrategy(
+    this.valueExtractor = valueExtractor;
-            SortStrategy<T> sortStrategy,
+  }
-            ToIntFunction<T> valueExtractor
+
-    ) {
+  @Override
-        setSortStrategy(sortStrategy);
+  public void sort(MyList<T> list, Comparator<T> comparator) {
-        setValueExtractor(valueExtractor);
+    if (sortStrategy == null) {
+      throw new IllegalStateException("Sort strategy is not set");
     }
 
-    public void setSortStrategy(SortStrategy<T> sortStrategy) {
+    if (valueExtractor == null) {
-        if (sortStrategy == null) {
+      throw new IllegalStateException("Value extractor is not set");
-            throw new IllegalArgumentException("Sort strategy must not be null");
-        }
-
-        this.sortStrategy = sortStrategy;
     }
 
-    public void setValueExtractor(ToIntFunction<T> valueExtractor) {
+    if (list == null || list.size() <= 1) {
-        if (valueExtractor == null) {
+      return;
-            throw new IllegalArgumentException("Value extractor must not be null");
-        }
-
-        this.valueExtractor = valueExtractor;
     }
 
-    @Override
+    int evenCount = 0;
-    public void sort(MyList<T> list, Comparator<T> comparator) {
-        if (sortStrategy == null) {
-            throw new IllegalStateException("Sort strategy is not set");
-        }
 
-        if (valueExtractor == null) {
+    for (int i = 0; i < list.size(); i++) {
-            throw new IllegalStateException("Value extractor is not set");
+      T element = list.get(i);
-        }
 
-        if (list == null || list.size() <= 1) {
+      if (valueExtractor.applyAsInt(element) % 2 == 0) {
-            return;
+        evenCount++;
-        }
+      }
-
-        int evenCount = 0;
-
-        for (int i = 0; i < list.size(); i++) {
-            T element = list.get(i);
-
-            if (valueExtractor.applyAsInt(element) % 2 == 0) {
-                evenCount++;
-            }
-        }
-
-        if (evenCount <= 1) {
-            return;
-        }
-
-        MyList<T> evenElements = new MyLinkedList<>();
-        int[] evenIndexes = new int[evenCount];
-
-        int evenIndex = 0;
-
-        for (int i = 0; i < list.size(); i++) {
-            T element = list.get(i);
-
-            if (valueExtractor.applyAsInt(element) % 2 == 0) {
-                evenElements.add(element);
-                evenIndexes[evenIndex] = i;
-                evenIndex++;
-            }
-        }
-
-        sortStrategy.sort(evenElements, comparator);
-
-        for (int i = 0; i < evenIndexes.length; i++) {
-            list.set(evenIndexes[i], evenElements.get(i));
-        }
     }
-}
+
+    if (evenCount <= 1) {
+      return;
+    }
+
+    MyList<T> evenElements = new MyLinkedList<>();
+    int[] evenIndexes = new int[evenCount];
+
+    int evenIndex = 0;
+
+    for (int i = 0; i < list.size(); i++) {
+      T element = list.get(i);
+
+      if (valueExtractor.applyAsInt(element) % 2 == 0) {
+        evenElements.add(element);
+        evenIndexes[evenIndex] = i;
+        evenIndex++;
+      }
+    }
+
+    sortStrategy.sort(evenElements, comparator);
+
+    for (int i = 0; i < evenIndexes.length; i++) {
+      list.set(evenIndexes[i], evenElements.get(i));
+    }
+  }
+}

app/src/main/java/ru/project/sorting/MergeSortStrategy.java

@@ -1,67 +1,66 @@
 package ru.project.sorting;
 
-import ru.project.collection.MyList;
-
 import java.util.Comparator;
+import ru.project.collection.MyList;
 
 public class MergeSortStrategy<T> implements SortStrategy<T> {
 
-    @Override
+  @Override
-    public void sort(MyList<T> list, Comparator<T> comparator) {
+  public void sort(MyList<T> list, Comparator<T> comparator) {
-        if (list == null || list.size() <= 1) {
+    if (list == null || list.size() <= 1) {
-            return;
+      return;
-        }
+    }
-        mergeSort(list, 0, list.size() - 1, comparator);
+    mergeSort(list, 0, list.size() - 1, comparator);
+  }
+
+  private void mergeSort(MyList<T> list, int left, int right, Comparator<T> comparator) {
+    if (left >= right) {
+      return;
+    }
+    int mid = (left + right) / 2;
+    mergeSort(list, left, mid, comparator);
+    mergeSort(list, mid + 1, right, comparator);
+    merge(list, left, mid, right, comparator);
+  }
+
+  private void merge(MyList<T> list, int left, int mid, int right, Comparator<T> comparator) {
+    int leftSize = mid - left + 1;
+    int rightSize = right - mid;
+
+    @SuppressWarnings("unchecked")
+    T[] leftArray = (T[]) new Object[leftSize];
+    @SuppressWarnings("unchecked")
+    T[] rightArray = (T[]) new Object[rightSize];
+
+    for (int i = 0; i < leftSize; i++) {
+      leftArray[i] = list.get(left + i);
+    }
+    for (int j = 0; j < rightSize; j++) {
+      rightArray[j] = list.get(mid + 1 + j);
     }
 
-    private void mergeSort(MyList<T> list, int left, int right, Comparator<T> comparator) {
+    int i = 0, j = 0, k = left;
-        if (left >= right) {
+
-            return;
+    while (i < leftSize && j < rightSize) {
-        }
+      if (comparator.compare(leftArray[i], rightArray[j]) <= 0) {
-        int mid = (left + right) / 2;
+        list.set(k, leftArray[i]);
-        mergeSort(list, left, mid, comparator);
+        i++;
-        mergeSort(list, mid + 1, right, comparator);
+      } else {
-        merge(list, left, mid, right, comparator);
+        list.set(k, rightArray[j]);
+        j++;
+      }
+      k++;
     }
 
-    private void merge(MyList<T> list, int left, int mid, int right, Comparator<T> comparator) {
+    while (i < leftSize) {
-        int leftSize = mid - left + 1;
+      list.set(k, leftArray[i]);
-        int rightSize = right - mid;
+      i++;
-
+      k++;
-        @SuppressWarnings("unchecked")
-        T[] leftArray = (T[]) new Object[leftSize];
-        @SuppressWarnings("unchecked")
-        T[] rightArray = (T[]) new Object[rightSize];
-
-        for (int i = 0; i < leftSize; i++) {
-            leftArray[i] = list.get(left + i);
-        }
-        for (int j = 0; j < rightSize; j++) {
-            rightArray[j] = list.get(mid + 1 + j);
-        }
-
-        int i = 0, j = 0, k = left;
-
-        while (i < leftSize && j < rightSize) {
-            if (comparator.compare(leftArray[i], rightArray[j]) <= 0) {
-                list.set(k, leftArray[i]);
-                i++;
-            } else {
-                list.set(k, rightArray[j]);
-                j++;
-            }
-            k++;
-        }
-
-        while (i < leftSize) {
-            list.set(k, leftArray[i]);
-            i++;
-            k++;
-        }
-        while (j < rightSize) {
-            list.set(k, rightArray[j]);
-            j++;
-            k++;
-        }
     }
-}
+    while (j < rightSize) {
+      list.set(k, rightArray[j]);
+      j++;
+      k++;
+    }
+  }
+}

app/src/main/java/ru/project/sorting/SortStrategy.java

@@ -1,9 +1,8 @@
 package ru.project.sorting;
 
+import java.util.Comparator;
 import ru.project.collection.MyList;
 
-import java.util.Comparator;
-
 public interface SortStrategy<T> {
-    void sort(MyList<T> list, Comparator<T> comparator);
+  void sort(MyList<T> list, Comparator<T> comparator);
-}
+}

app/src/main/java/ru/project/sorting/StudentAverageGradeComparator.java

@@ -1,12 +1,12 @@
 package ru.project.sorting;
 
-import ru.project.student.Student;
 import java.util.Comparator;
+import ru.project.student.Student;
 
 public class StudentAverageGradeComparator implements Comparator<Student> {
 
-    @Override
+  @Override
-    public int compare(Student s1, Student s2) {
+  public int compare(Student s1, Student s2) {
-        return Double.compare(s1.getAverageGrade(), s2.getAverageGrade());
+    return Double.compare(s1.getAverageGrade(), s2.getAverageGrade());
-    }
+  }
-}
+}

app/src/main/java/ru/project/sorting/StudentGroupComparator.java

@@ -1,12 +1,12 @@
 package ru.project.sorting;
 
-import ru.project.student.Student;
 import java.util.Comparator;
+import ru.project.student.Student;
 
 public class StudentGroupComparator implements Comparator<Student> {
 
-    @Override
+  @Override
-    public int compare(Student s1, Student s2) {
+  public int compare(Student s1, Student s2) {
-        return s1.getGroupNumber().compareTo(s2.getGroupNumber());
+    return s1.getGroupNumber().compareTo(s2.getGroupNumber());
-    }
+  }
 }

app/src/main/java/ru/project/sorting/StudentRecordBookComparator.java

@@ -1,12 +1,12 @@
 package ru.project.sorting;
 
-import ru.project.student.Student;
 import java.util.Comparator;
+import ru.project.student.Student;
 
 public class StudentRecordBookComparator implements Comparator<Student> {
 
-    @Override
+  @Override
-    public int compare(Student s1, Student s2) {
+  public int compare(Student s1, Student s2) {
-        return Integer.compare(s1.getRecordBookNumber(), s2.getRecordBookNumber());
+    return Integer.compare(s1.getRecordBookNumber(), s2.getRecordBookNumber());
-    }
+  }
-}
+}

app/src/main/java/ru/project/student/Student.java

@@ -54,6 +54,10 @@ public class Student {
     return new Student(this.groupNumber, averageGrade, this.recordBookNumber);
   }
 
+  public Student withRecordBookNumber(int recordBookNumber) {
+    return new Student(this.groupNumber, this.averageGrade, recordBookNumber);
+  }
+
   public static double getMinAverageGrade() {
     return MIN_AVERAGE_GRADE;
   }

app/src/test/java/ru/project/AppTest.java

@@ -4,16 +4,12 @@ import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import org.junit.jupiter.api.Test;
 
-/**
+/** Unit test for simple App. */
- * Unit test for simple App.
- */
 public class AppTest {
 
-    /**
+  /** Rigorous Test :-) */
-     * Rigorous Test :-)
+  @Test
-     */
+  public void shouldAnswerWithTrue() {
-    @Test
+    assertTrue(true);
-    public void shouldAnswerWithTrue() {
+  }
-        assertTrue(true);
-    }
 }

app/src/test/java/ru/project/Sorting/SortStrategyTest.java

@@ -1,163 +0,0 @@
-package ru.project.sorting;
-
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Test;
-import ru.project.list.MyList;
-import ru.project.list.MyLinkedList;
-import ru.project.student.Student;
-
-import java.util.Comparator;
-
-import static org.junit.jupiter.api.Assertions.*;
-
-class SortStrategyTest {
-
-    private MyList<Student> students;
-    private final Comparator<Student> groupComparator = new StudentGroupComparator();
-    private final Comparator<Student> gradeComparator = new StudentAverageGradeComparator();
-    private final Comparator<Student> recordComparator = new StudentRecordBookComparator();
-
-    @BeforeEach
-    void setUp() {
-        students = new MyLinkedList<>();
-        students.add(new Student("A12", 4.5, 12345));
-        students.add(new Student("B32", 3.8, 12346));
-        students.add(new Student("Z00", 4.9, 12347));
-        students.add(new Student("A12", 4.2, 12348));
-        students.add(new Student("B32", 5.0, 12349));
-    }
-
-    @Test
-    void testMergeSortByGroupNumber() {
-        SortStrategy<Student> strategy = new MergeSortStrategy<>();
-        strategy.sort(students, groupComparator);
-        assertOrder(students, "A12", "A12", "B32", "B32", "Z00");
-    }
-
-    @Test
-    void testMergeSortByAverageGrade() {
-        SortStrategy<Student> strategy = new MergeSortStrategy<>();
-        strategy.sort(students, gradeComparator);
-        assertOrder(students, 3.8, 4.2, 4.5, 4.9, 5.0);
-    }
-
-    @Test
-    void testMergeSortByRecordBookNumber() {
-        SortStrategy<Student> strategy = new MergeSortStrategy<>();
-        strategy.sort(students, recordComparator);
-        assertOrder(students, 12345, 12346, 12347, 12348, 12349);
-    }
-
-    @Test
-    void testBubbleSortByGroupNumber() {
-        SortStrategy<Student> strategy = new BubbleSortStrategy<>();
-        strategy.sort(students, groupComparator);
-        assertOrder(students, "A12", "A12", "B32", "B32", "Z00");
-    }
-
-    @Test
-    void testBubbleSortByAverageGrade() {
-        SortStrategy<Student> strategy = new BubbleSortStrategy<>();
-        strategy.sort(students, gradeComparator);
-        assertOrder(students, 3.8, 4.2, 4.5, 4.9, 5.0);
-    }
-
-    @Test
-    void testBubbleSortByRecordBookNumber() {
-        SortStrategy<Student> strategy = new BubbleSortStrategy<>();
-        strategy.sort(students, recordComparator);
-        assertOrder(students, 12345, 12346, 12347, 12348, 12349);
-    }
-
-    @Test
-    void testEvenOnlySortByRecordBookNumber() {
-        MyList<Student> list = new MyLinkedList<>();
-        list.add(new Student("A01", 4.5, 7));
-        list.add(new Student("A02", 4.5, 8));
-        list.add(new Student("A03", 4.5, 3));
-        list.add(new Student("A04", 4.5, 2));
-        list.add(new Student("A05", 4.5, 5));
-        list.add(new Student("A06", 4.5, 4));
-
-        EvenOnlyMergeSortStrategy<Student> strategy =
-                new EvenOnlyMergeSortStrategy<>(Student::getRecordBookNumber);
-        strategy.sort(list, Comparator.comparingInt(Student::getRecordBookNumber));
-
-        int[] expected = {7, 2, 3, 4, 5, 8};
-        for (int i = 0; i < list.size(); i++) {
-            assertEquals(expected[i], list.get(i).getRecordBookNumber());
-        }
-    }
-
-    @Test
-    void testEvenOnlyWithNoEvenElements() {
-        MyList<Student> list = new MyLinkedList<>();
-        list.add(new Student("A01", 4.5, 1));
-        list.add(new Student("A02", 4.5, 3));
-        list.add(new Student("A03", 4.5, 5));
-
-        EvenOnlyMergeSortStrategy<Student> strategy =
-                new EvenOnlyMergeSortStrategy<>(Student::getRecordBookNumber);
-        strategy.sort(list, Comparator.comparingInt(Student::getRecordBookNumber));
-
-        int[] expected = {1, 3, 5};
-        for (int i = 0; i < list.size(); i++) {
-            assertEquals(expected[i], list.get(i).getRecordBookNumber());
-        }
-    }
-
-    @Test
-    void testEvenOnlyWithAllEvenElements() {
-        MyList<Student> list = new MyLinkedList<>();
-        list.add(new Student("A01", 4.5, 4));
-        list.add(new Student("A02", 4.5, 2));
-        list.add(new Student("A03", 4.5, 6));
-
-        EvenOnlyMergeSortStrategy<Student> strategy =
-                new EvenOnlyMergeSortStrategy<>(Student::getRecordBookNumber);
-        strategy.sort(list, Comparator.comparingInt(Student::getRecordBookNumber));
-
-        int[] expected = {2, 4, 6};
-        for (int i = 0; i < list.size(); i++) {
-            assertEquals(expected[i], list.get(i).getRecordBookNumber());
-        }
-    }
-
-    @Test
-    void testSortEmptyList() {
-        MyList<Student> empty = new MyLinkedList<>();
-        SortStrategy<Student> strategy = new MergeSortStrategy<>();
-        strategy.sort(empty, groupComparator);
-        assertEquals(0, empty.size());
-    }
-
-    @Test
-    void testSortSingleElement() {
-        MyList<Student> single = new MyLinkedList<>();
-        single.add(new Student("A12", 4.5, 12345));
-        SortStrategy<Student> strategy = new MergeSortStrategy<>();
-        strategy.sort(single, groupComparator);
-        assertEquals(1, single.size());
-    }
-
-    private void assertOrder(MyList<Student> list, String... groups) {
-        assertEquals(groups.length, list.size());
-        for (int i = 0; i < groups.length; i++) {
-            assertEquals(groups[i], list.get(i).getGroupNumber());
-        }
-    }
-
-    private void assertOrder(MyList<Student> list, double... grades) {
-        assertEquals(grades.length, list.size());
-        for (int i = 0; i < grades.length; i++) {
-            assertEquals(grades[i], list.get(i).getAverageGrade(), 0.001);
-        }
-    }
-
-    private void assertOrder(MyList<Student> list, int... records) {
-        assertEquals(records.length, list.size());
-        for (int i = 0; i < records.length; i++) {
-            assertEquals(records[i], list.get(i).getRecordBookNumber());
-        }
-    }
-}

app/src/test/java/ru/project/sorting/EvenOnlySortStrategyTest.java

@@ -1,301 +1,286 @@
 package ru.project.sorting;
 
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertSame;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.util.Comparator;
 import org.junit.jupiter.api.Test;
 import ru.project.collection.MyLinkedList;
 import ru.project.collection.MyList;
 import ru.project.student.Student;
 
-import static org.junit.jupiter.api.Assertions.assertSame;
-
-import java.util.Comparator;
-
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertThrows;
-import static org.junit.jupiter.api.Assertions.assertTrue;
-
 class EvenOnlySortStrategyTest {
 
-    @Test
+  @Test
-    void shouldHandleEmptyList() {
+  void shouldHandleEmptyList() {
-        MyList<Integer> list = new MyLinkedList<>();
+    MyList<Integer> list = new MyLinkedList<>();
 
-        EvenOnlySortStrategy<Integer> strategy =
+    EvenOnlySortStrategy<Integer> strategy =
-                new EvenOnlySortStrategy<>(
+        new EvenOnlySortStrategy<>(new MergeSortStrategy<>(), value -> value);
-                        new MergeSortStrategy<>(),
-                        value -> value
-                );
 
-        strategy.sort(list, Integer::compare);
+    strategy.sort(list, Integer::compare);
 
-        assertEquals(0, list.size());
+    assertEquals(0, list.size());
+  }
+
+  @Test
+  void shouldKeepSingleEvenElementUnchanged() {
+    MyList<Integer> list = new MyLinkedList<>();
+    list.add(4);
+
+    EvenOnlySortStrategy<Integer> strategy =
+        new EvenOnlySortStrategy<>(new MergeSortStrategy<>(), value -> value);
+
+    strategy.sort(list, Integer::compare);
+
+    assertEquals(4, list.get(0));
+    assertEquals(1, list.size());
+  }
+
+  @Test
+  void shouldKeepSingleOddElementUnchanged() {
+    MyList<Integer> list = new MyLinkedList<>();
+    list.add(7);
+
+    EvenOnlySortStrategy<Integer> strategy =
+        new EvenOnlySortStrategy<>(new MergeSortStrategy<>(), value -> value);
+
+    strategy.sort(list, Integer::compare);
+
+    assertEquals(7, list.get(0));
+    assertEquals(1, list.size());
+  }
+
+  @Test
+  void shouldHandleDuplicateEvenValues() {
+    MyList<Integer> list = new MyLinkedList<>();
+
+    list.add(8);
+    list.add(4);
+    list.add(8);
+    list.add(2);
+    list.add(4);
+
+    EvenOnlySortStrategy<Integer> strategy =
+        new EvenOnlySortStrategy<>(new MergeSortStrategy<>(), value -> value);
+
+    strategy.sort(list, Integer::compare);
+
+    assertEquals(2, list.get(0));
+    assertEquals(4, list.get(1));
+    assertEquals(4, list.get(2));
+    assertEquals(8, list.get(3));
+    assertEquals(8, list.get(4));
+  }
+
+  @Test
+  void shouldKeepOddStudentObjectsAtSameIndexes() {
+    Student oddFirst = new Student("A01", 4.0, 7);
+    Student evenFirst = new Student("A02", 4.0, 8);
+    Student oddSecond = new Student("A03", 4.0, 3);
+    Student evenSecond = new Student("A04", 4.0, 2);
+    Student oddThird = new Student("A05", 4.0, 5);
+    Student evenThird = new Student("A06", 4.0, 4);
+
+    MyList<Student> students = new MyLinkedList<>();
+
+    students.add(oddFirst);
+    students.add(evenFirst);
+    students.add(oddSecond);
+    students.add(evenSecond);
+    students.add(oddThird);
+    students.add(evenThird);
+
+    EvenOnlySortStrategy<Student> strategy =
+        new EvenOnlySortStrategy<>(new MergeSortStrategy<>(), Student::getRecordBookNumber);
+
+    strategy.sort(students, new StudentRecordBookComparator());
+
+    assertSame(oddFirst, students.get(0));
+    assertSame(oddSecond, students.get(2));
+    assertSame(oddThird, students.get(4));
+
+    assertEquals(2, students.get(1).getRecordBookNumber());
+    assertEquals(4, students.get(3).getRecordBookNumber());
+    assertEquals(8, students.get(5).getRecordBookNumber());
+  }
+
+  @Test
+  void shouldSortWhenStrategyPassedThroughConstructor() {
+    MyList<Integer> list = new MyLinkedList<>();
+
+    list.add(8);
+    list.add(2);
+    list.add(4);
+
+    EvenOnlySortStrategy<Integer> strategy = new EvenOnlySortStrategy<>(new MergeSortStrategy<>());
+
+    strategy.setValueExtractor(value -> value);
+
+    strategy.sort(list, Integer::compare);
+
+    assertEquals(2, list.get(0));
+    assertEquals(4, list.get(1));
+    assertEquals(8, list.get(2));
+  }
+
+  @Test
+  void shouldSortOnlyEvenElements() {
+    MyList<Student> students = new MyLinkedList<>();
+
+    students.add(new Student("A01", 4.0, 7));
+    students.add(new Student("A02", 4.0, 8));
+    students.add(new Student("A03", 4.0, 3));
+    students.add(new Student("A04", 4.0, 2));
+    students.add(new Student("A05", 4.0, 5));
+    students.add(new Student("A06", 4.0, 4));
+
+    EvenOnlySortStrategy<Student> strategy =
+        new EvenOnlySortStrategy<>(new MergeSortStrategy<>(), Student::getRecordBookNumber);
+
+    strategy.sort(students, new StudentRecordBookComparator());
+
+    assertEquals(7, students.get(0).getRecordBookNumber());
+    assertEquals(2, students.get(1).getRecordBookNumber());
+    assertEquals(3, students.get(2).getRecordBookNumber());
+    assertEquals(4, students.get(3).getRecordBookNumber());
+    assertEquals(5, students.get(4).getRecordBookNumber());
+    assertEquals(8, students.get(5).getRecordBookNumber());
+
+    assertEquals(6, students.size());
+  }
+
+  @Test
+  void shouldSortAllEvenElements() {
+    MyList<Integer> list = new MyLinkedList<>();
+
+    list.add(8);
+    list.add(2);
+    list.add(6);
+    list.add(4);
+
+    EvenOnlySortStrategy<Integer> strategy =
+        new EvenOnlySortStrategy<>(new MergeSortStrategy<>(), value -> value);
+
+    strategy.sort(list, Integer::compare);
+
+    assertEquals(2, list.get(0));
+    assertEquals(4, list.get(1));
+    assertEquals(6, list.get(2));
+    assertEquals(8, list.get(3));
+  }
+
+  @Test
+  void shouldKeepOddElementsUnchanged() {
+    MyList<Integer> list = new MyLinkedList<>();
+
+    list.add(7);
+    list.add(3);
+    list.add(5);
+    list.add(1);
+
+    EvenOnlySortStrategy<Integer> strategy =
+        new EvenOnlySortStrategy<>(new MergeSortStrategy<>(), value -> value);
+
+    strategy.sort(list, Integer::compare);
+
+    assertEquals(7, list.get(0));
+    assertEquals(3, list.get(1));
+    assertEquals(5, list.get(2));
+    assertEquals(1, list.get(3));
+  }
+
+  @Test
+  void shouldThrowWhenSortStrategyIsNotSet() {
+    EvenOnlySortStrategy<Integer> strategy = new EvenOnlySortStrategy<>();
+
+    strategy.setValueExtractor(value -> value);
+
+    MyList<Integer> list = new MyLinkedList<>();
+    list.add(2);
+    list.add(4);
+
+    assertThrows(IllegalStateException.class, () -> strategy.sort(list, Integer::compare));
+  }
+
+  @Test
+  void shouldRejectNullSortStrategy() {
+    EvenOnlySortStrategy<Integer> strategy = new EvenOnlySortStrategy<>();
+
+    assertThrows(IllegalArgumentException.class, () -> strategy.setSortStrategy(null));
+  }
+
+  @Test
+  void shouldDelegateSortingToProvidedStrategy() {
+    MyList<Integer> list = new MyLinkedList<>();
+
+    list.add(7);
+    list.add(8);
+    list.add(3);
+    list.add(2);
+
+    RecordingSortStrategy recordingStrategy = new RecordingSortStrategy();
+
+    EvenOnlySortStrategy<Integer> strategy =
+        new EvenOnlySortStrategy<>(recordingStrategy, value -> value);
+
+    strategy.sort(list, Integer::compare);
+
+    assertTrue(recordingStrategy.wasCalled);
+    assertEquals(2, recordingStrategy.receivedSize);
+    assertEquals(8, recordingStrategy.firstReceivedElement);
+    assertEquals(2, recordingStrategy.secondReceivedElement);
+  }
+
+  @Test
+  void shouldUseNewStrategyAfterReplacement() {
+    RecordingSortStrategy firstStrategy = new RecordingSortStrategy();
+
+    RecordingSortStrategy secondStrategy = new RecordingSortStrategy();
+
+    EvenOnlySortStrategy<Integer> strategy =
+        new EvenOnlySortStrategy<>(firstStrategy, value -> value);
+
+    MyList<Integer> firstList = new MyLinkedList<>();
+    firstList.add(4);
+    firstList.add(2);
+
+    strategy.sort(firstList, Integer::compare);
+
+    assertTrue(firstStrategy.wasCalled);
+
+    strategy.setSortStrategy(secondStrategy);
+
+    MyList<Integer> secondList = new MyLinkedList<>();
+    secondList.add(8);
+    secondList.add(6);
+
+    strategy.sort(secondList, Integer::compare);
+
+    assertTrue(secondStrategy.wasCalled);
+  }
+
+  private static class RecordingSortStrategy implements SortStrategy<Integer> {
+
+    private boolean wasCalled;
+    private int receivedSize;
+    private Integer firstReceivedElement;
+    private Integer secondReceivedElement;
+
+    @Override
+    public void sort(MyList<Integer> list, Comparator<Integer> comparator) {
+      wasCalled = true;
+      receivedSize = list.size();
+
+      if (list.size() > 0) {
+        firstReceivedElement = list.get(0);
+      }
+
+      if (list.size() > 1) {
+        secondReceivedElement = list.get(1);
+      }
     }
-
+  }
-    @Test
+}
-    void shouldKeepSingleEvenElementUnchanged() {
-        MyList<Integer> list = new MyLinkedList<>();
-        list.add(4);
-
-        EvenOnlySortStrategy<Integer> strategy =
-                new EvenOnlySortStrategy<>(
-                        new MergeSortStrategy<>(),
-                        value -> value
-                );
-
-        strategy.sort(list, Integer::compare);
-
-        assertEquals(4, list.get(0));
-        assertEquals(1, list.size());
-    }
-
-    @Test
-    void shouldKeepSingleOddElementUnchanged() {
-        MyList<Integer> list = new MyLinkedList<>();
-        list.add(7);
-
-        EvenOnlySortStrategy<Integer> strategy =
-                new EvenOnlySortStrategy<>(
-                        new MergeSortStrategy<>(),
-                        value -> value
-                );
-
-        strategy.sort(list, Integer::compare);
-
-        assertEquals(7, list.get(0));
-        assertEquals(1, list.size());
-    }
-
-    @Test
-    void shouldHandleDuplicateEvenValues() {
-        MyList<Integer> list = new MyLinkedList<>();
-
-        list.add(8);
-        list.add(4);
-        list.add(8);
-        list.add(2);
-        list.add(4);
-
-        EvenOnlySortStrategy<Integer> strategy =
-                new EvenOnlySortStrategy<>(
-                        new MergeSortStrategy<>(),
-                        value -> value
-                );
-
-        strategy.sort(list, Integer::compare);
-
-        assertEquals(2, list.get(0));
-        assertEquals(4, list.get(1));
-        assertEquals(4, list.get(2));
-        assertEquals(8, list.get(3));
-        assertEquals(8, list.get(4));
-    }
-
-    @Test
-    void shouldKeepOddStudentObjectsAtSameIndexes() {
-        Student oddFirst = new Student("A01", 4.0, 7);
-        Student evenFirst = new Student("A02", 4.0, 8);
-        Student oddSecond = new Student("A03", 4.0, 3);
-        Student evenSecond = new Student("A04", 4.0, 2);
-        Student oddThird = new Student("A05", 4.0, 5);
-        Student evenThird = new Student("A06", 4.0, 4);
-
-        MyList<Student> students = new MyLinkedList<>();
-
-        students.add(oddFirst);
-        students.add(evenFirst);
-        students.add(oddSecond);
-        students.add(evenSecond);
-        students.add(oddThird);
-        students.add(evenThird);
-
-        EvenOnlySortStrategy<Student> strategy =
-                new EvenOnlySortStrategy<>(
-                        new MergeSortStrategy<>(),
-                        Student::getRecordBookNumber
-                );
-
-        strategy.sort(students, new StudentRecordBookComparator());
-
-        assertSame(oddFirst, students.get(0));
-        assertSame(oddSecond, students.get(2));
-        assertSame(oddThird, students.get(4));
-
-        assertEquals(2, students.get(1).getRecordBookNumber());
-        assertEquals(4, students.get(3).getRecordBookNumber());
-        assertEquals(8, students.get(5).getRecordBookNumber());
-    }
-
-    @Test
-    void shouldSortWhenStrategyPassedThroughConstructor() {
-        MyList<Integer> list = new MyLinkedList<>();
-
-        list.add(8);
-        list.add(2);
-        list.add(4);
-
-        EvenOnlySortStrategy<Integer> strategy =
-                new EvenOnlySortStrategy<>(
-                        new MergeSortStrategy<>()
-                );
-
-        strategy.setValueExtractor(value -> value);
-
-        strategy.sort(list, Integer::compare);
-
-        assertEquals(2, list.get(0));
-        assertEquals(4, list.get(1));
-        assertEquals(8, list.get(2));
-    }
-
-    @Test
-    void shouldSortOnlyEvenElements() {
-        MyList<Student> students = new MyLinkedList<>();
-
-        students.add(new Student("A01", 4.0, 7));
-        students.add(new Student("A02", 4.0, 8));
-        students.add(new Student("A03", 4.0, 3));
-        students.add(new Student("A04", 4.0, 2));
-        students.add(new Student("A05", 4.0, 5));
-        students.add(new Student("A06", 4.0, 4));
-
-        EvenOnlySortStrategy<Student> strategy = new EvenOnlySortStrategy<>(new MergeSortStrategy<>(), Student::getRecordBookNumber);
-
-        strategy.sort(students, new StudentRecordBookComparator());
-
-        assertEquals(7, students.get(0).getRecordBookNumber());
-        assertEquals(2, students.get(1).getRecordBookNumber());
-        assertEquals(3, students.get(2).getRecordBookNumber());
-        assertEquals(4, students.get(3).getRecordBookNumber());
-        assertEquals(5, students.get(4).getRecordBookNumber());
-        assertEquals(8, students.get(5).getRecordBookNumber());
-
-        assertEquals(6, students.size());
-    }
-
-    @Test
-    void shouldSortAllEvenElements() {
-        MyList<Integer> list = new MyLinkedList<>();
-
-        list.add(8);
-        list.add(2);
-        list.add(6);
-        list.add(4);
-
-        EvenOnlySortStrategy<Integer> strategy = new EvenOnlySortStrategy<>(new MergeSortStrategy<>(), value -> value);
-
-        strategy.sort(list, Integer::compare);
-
-        assertEquals(2, list.get(0));
-        assertEquals(4, list.get(1));
-        assertEquals(6, list.get(2));
-        assertEquals(8, list.get(3));
-    }
-
-    @Test
-    void shouldKeepOddElementsUnchanged() {
-        MyList<Integer> list = new MyLinkedList<>();
-
-        list.add(7);
-        list.add(3);
-        list.add(5);
-        list.add(1);
-
-        EvenOnlySortStrategy<Integer> strategy = new EvenOnlySortStrategy<>(new MergeSortStrategy<>(), value -> value);
-
-        strategy.sort(list, Integer::compare);
-
-        assertEquals(7, list.get(0));
-        assertEquals(3, list.get(1));
-        assertEquals(5, list.get(2));
-        assertEquals(1, list.get(3));
-    }
-
-    @Test
-    void shouldThrowWhenSortStrategyIsNotSet() {
-        EvenOnlySortStrategy<Integer> strategy = new EvenOnlySortStrategy<>();
-
-        strategy.setValueExtractor(value -> value);
-
-        MyList<Integer> list = new MyLinkedList<>();
-        list.add(2);
-        list.add(4);
-
-        assertThrows(IllegalStateException.class, () -> strategy.sort(list, Integer::compare));
-    }
-
-    @Test
-    void shouldRejectNullSortStrategy() {
-        EvenOnlySortStrategy<Integer> strategy = new EvenOnlySortStrategy<>();
-
-        assertThrows(IllegalArgumentException.class, () -> strategy.setSortStrategy(null));
-    }
-
-    @Test
-    void shouldDelegateSortingToProvidedStrategy() {
-        MyList<Integer> list = new MyLinkedList<>();
-
-        list.add(7);
-        list.add(8);
-        list.add(3);
-        list.add(2);
-
-        RecordingSortStrategy recordingStrategy = new RecordingSortStrategy();
-
-        EvenOnlySortStrategy<Integer> strategy = new EvenOnlySortStrategy<>(recordingStrategy, value -> value);
-
-        strategy.sort(list, Integer::compare);
-
-        assertTrue(recordingStrategy.wasCalled);
-        assertEquals(2, recordingStrategy.receivedSize);
-        assertEquals(8, recordingStrategy.firstReceivedElement);
-        assertEquals(2, recordingStrategy.secondReceivedElement);
-    }
-
-    @Test
-    void shouldUseNewStrategyAfterReplacement() {
-        RecordingSortStrategy firstStrategy = new RecordingSortStrategy();
-
-        RecordingSortStrategy secondStrategy = new RecordingSortStrategy();
-
-        EvenOnlySortStrategy<Integer> strategy = new EvenOnlySortStrategy<>(firstStrategy, value -> value);
-
-        MyList<Integer> firstList = new MyLinkedList<>();
-        firstList.add(4);
-        firstList.add(2);
-
-        strategy.sort(firstList, Integer::compare);
-
-        assertTrue(firstStrategy.wasCalled);
-
-        strategy.setSortStrategy(secondStrategy);
-
-        MyList<Integer> secondList = new MyLinkedList<>();
-        secondList.add(8);
-        secondList.add(6);
-
-        strategy.sort(secondList, Integer::compare);
-
-        assertTrue(secondStrategy.wasCalled);
-    }
-
-    private static class RecordingSortStrategy implements SortStrategy<Integer> {
-
-        private boolean wasCalled;
-        private int receivedSize;
-        private Integer firstReceivedElement;
-        private Integer secondReceivedElement;
-
-        @Override
-        public void sort(MyList<Integer> list, Comparator<Integer> comparator) {
-            wasCalled = true;
-            receivedSize = list.size();
-
-            if (list.size() > 0) {
-                firstReceivedElement = list.get(0);
-            }
-
-            if (list.size() > 1) {
-                secondReceivedElement = list.get(1);
-            }
-        }
-    }
-}

app/src/test/java/ru/project/sorting/SortStrategyTest.java

@@ -0,0 +1,162 @@
+package ru.project.sorting;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import java.util.Comparator;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import ru.project.collection.MyLinkedList;
+import ru.project.collection.MyList;
+import ru.project.student.Student;
+
+class SortStrategyTest {
+
+  private MyList<Student> students;
+  private final Comparator<Student> groupComparator = new StudentGroupComparator();
+  private final Comparator<Student> gradeComparator = new StudentAverageGradeComparator();
+  private final Comparator<Student> recordComparator = new StudentRecordBookComparator();
+
+  @BeforeEach
+  void setUp() {
+    students = new MyLinkedList<>();
+    students.add(new Student("A12", 4.5, 12345));
+    students.add(new Student("B32", 3.8, 12346));
+    students.add(new Student("Z00", 4.9, 12347));
+    students.add(new Student("A12", 4.2, 12348));
+    students.add(new Student("B32", 5.0, 12349));
+  }
+
+  @Test
+  void testMergeSortByGroupNumber() {
+    SortStrategy<Student> strategy = new MergeSortStrategy<>();
+    strategy.sort(students, groupComparator);
+    assertOrder(students, "A12", "A12", "B32", "B32", "Z00");
+  }
+
+  @Test
+  void testMergeSortByAverageGrade() {
+    SortStrategy<Student> strategy = new MergeSortStrategy<>();
+    strategy.sort(students, gradeComparator);
+    assertOrder(students, 3.8, 4.2, 4.5, 4.9, 5.0);
+  }
+
+  @Test
+  void testMergeSortByRecordBookNumber() {
+    SortStrategy<Student> strategy = new MergeSortStrategy<>();
+    strategy.sort(students, recordComparator);
+    assertOrder(students, 12345, 12346, 12347, 12348, 12349);
+  }
+
+  @Test
+  void testBubbleSortByGroupNumber() {
+    SortStrategy<Student> strategy = new BubbleSortStrategy<>();
+    strategy.sort(students, groupComparator);
+    assertOrder(students, "A12", "A12", "B32", "B32", "Z00");
+  }
+
+  @Test
+  void testBubbleSortByAverageGrade() {
+    SortStrategy<Student> strategy = new BubbleSortStrategy<>();
+    strategy.sort(students, gradeComparator);
+    assertOrder(students, 3.8, 4.2, 4.5, 4.9, 5.0);
+  }
+
+  @Test
+  void testBubbleSortByRecordBookNumber() {
+    SortStrategy<Student> strategy = new BubbleSortStrategy<>();
+    strategy.sort(students, recordComparator);
+    assertOrder(students, 12345, 12346, 12347, 12348, 12349);
+  }
+
+  @Test
+  void testEvenOnlySortByRecordBookNumber() {
+    MyList<Student> list = new MyLinkedList<>();
+    list.add(new Student("A01", 4.5, 7));
+    list.add(new Student("A02", 4.5, 8));
+    list.add(new Student("A03", 4.5, 3));
+    list.add(new Student("A04", 4.5, 2));
+    list.add(new Student("A05", 4.5, 5));
+    list.add(new Student("A06", 4.5, 4));
+
+    EvenOnlyMergeSortStrategy<Student> strategy =
+        new EvenOnlyMergeSortStrategy<>(Student::getRecordBookNumber);
+    strategy.sort(list, Comparator.comparingInt(Student::getRecordBookNumber));
+
+    int[] expected = {7, 2, 3, 4, 5, 8};
+    for (int i = 0; i < list.size(); i++) {
+      assertEquals(expected[i], list.get(i).getRecordBookNumber());
+    }
+  }
+
+  @Test
+  void testEvenOnlyWithNoEvenElements() {
+    MyList<Student> list = new MyLinkedList<>();
+    list.add(new Student("A01", 4.5, 1));
+    list.add(new Student("A02", 4.5, 3));
+    list.add(new Student("A03", 4.5, 5));
+
+    EvenOnlyMergeSortStrategy<Student> strategy =
+        new EvenOnlyMergeSortStrategy<>(Student::getRecordBookNumber);
+    strategy.sort(list, Comparator.comparingInt(Student::getRecordBookNumber));
+
+    int[] expected = {1, 3, 5};
+    for (int i = 0; i < list.size(); i++) {
+      assertEquals(expected[i], list.get(i).getRecordBookNumber());
+    }
+  }
+
+  @Test
+  void testEvenOnlyWithAllEvenElements() {
+    MyList<Student> list = new MyLinkedList<>();
+    list.add(new Student("A01", 4.5, 4));
+    list.add(new Student("A02", 4.5, 2));
+    list.add(new Student("A03", 4.5, 6));
+
+    EvenOnlyMergeSortStrategy<Student> strategy =
+        new EvenOnlyMergeSortStrategy<>(Student::getRecordBookNumber);
+    strategy.sort(list, Comparator.comparingInt(Student::getRecordBookNumber));
+
+    int[] expected = {2, 4, 6};
+    for (int i = 0; i < list.size(); i++) {
+      assertEquals(expected[i], list.get(i).getRecordBookNumber());
+    }
+  }
+
+  @Test
+  void testSortEmptyList() {
+    MyList<Student> empty = new MyLinkedList<>();
+    SortStrategy<Student> strategy = new MergeSortStrategy<>();
+    strategy.sort(empty, groupComparator);
+    assertEquals(0, empty.size());
+  }
+
+  @Test
+  void testSortSingleElement() {
+    MyList<Student> single = new MyLinkedList<>();
+    single.add(new Student("A12", 4.5, 12345));
+    SortStrategy<Student> strategy = new MergeSortStrategy<>();
+    strategy.sort(single, groupComparator);
+    assertEquals(1, single.size());
+  }
+
+  private void assertOrder(MyList<Student> list, String... groups) {
+    assertEquals(groups.length, list.size());
+    for (int i = 0; i < groups.length; i++) {
+      assertEquals(groups[i], list.get(i).getGroupNumber());
+    }
+  }
+
+  private void assertOrder(MyList<Student> list, double... grades) {
+    assertEquals(grades.length, list.size());
+    for (int i = 0; i < grades.length; i++) {
+      assertEquals(grades[i], list.get(i).getAverageGrade(), 0.001);
+    }
+  }
+
+  private void assertOrder(MyList<Student> list, int... records) {
+    assertEquals(records.length, list.size());
+    for (int i = 0; i < records.length; i++) {
+      assertEquals(records[i], list.get(i).getRecordBookNumber());
+    }
+  }
+}

app/src/test/java/ru/project/student/StudentTest.java

@@ -1,145 +1,141 @@
 package ru.project.student;
 
-import org.junit.jupiter.api.Test;
-
 import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
 import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertNotEquals;
 import static org.junit.jupiter.api.Assertions.assertNotSame;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 
+import org.junit.jupiter.api.Test;
 
 class StudentTest {
 
-    @Test
+  @Test
-    void testValidStudentCreation() {
+  void testValidStudentCreation() {
-        Student student = new Student("A12", 4.5, 12345);
+    Student student = new Student("A12", 4.5, 12345);
-        assertEquals("A12", student.getGroupNumber());
+    assertEquals("A12", student.getGroupNumber());
-        assertEquals(4.5, student.getAverageGrade());
+    assertEquals(4.5, student.getAverageGrade());
-        assertEquals(12345, student.getRecordBookNumber());
+    assertEquals(12345, student.getRecordBookNumber());
-    }
+  }
 
-    @Test
+  @Test
-    void testValidGroupNumbers() {
+  void testValidGroupNumbers() {
-        assertDoesNotThrow(() -> new Student("A12", 4.5, 1));
+    assertDoesNotThrow(() -> new Student("A12", 4.5, 1));
-        assertDoesNotThrow(() -> new Student("B32", 4.5, 1));
+    assertDoesNotThrow(() -> new Student("B32", 4.5, 1));
-        assertDoesNotThrow(() -> new Student("Z00", 4.5, 1));
+    assertDoesNotThrow(() -> new Student("Z00", 4.5, 1));
-    }
+  }
 
-    @Test
+  @Test
-    void testInvalidGroupNumbers() {
+  void testInvalidGroupNumbers() {
-        assertThrows(IllegalArgumentException.class, () -> new Student("a12", 4.5, 1));
+    assertThrows(IllegalArgumentException.class, () -> new Student("a12", 4.5, 1));
-        assertThrows(IllegalArgumentException.class, () -> new Student("A1", 4.5, 1));
+    assertThrows(IllegalArgumentException.class, () -> new Student("A1", 4.5, 1));
-        assertThrows(IllegalArgumentException.class, () -> new Student("A123", 4.5, 1));
+    assertThrows(IllegalArgumentException.class, () -> new Student("A123", 4.5, 1));
-        assertThrows(IllegalArgumentException.class, () -> new Student("AA1", 4.5, 1));
+    assertThrows(IllegalArgumentException.class, () -> new Student("AA1", 4.5, 1));
-        assertThrows(IllegalArgumentException.class, () -> new Student("а1А", 4.5, 1));
+    assertThrows(IllegalArgumentException.class, () -> new Student("а1А", 4.5, 1));
-        assertThrows(IllegalArgumentException.class, () -> new Student("аа!!а123", 4.5, 1));
+    assertThrows(IllegalArgumentException.class, () -> new Student("аа!!а123", 4.5, 1));
-        assertThrows(IllegalArgumentException.class, () -> new Student("23фи!12", 4.5, 1));
+    assertThrows(IllegalArgumentException.class, () -> new Student("23фи!12", 4.5, 1));
-        assertThrows(IllegalArgumentException.class, () -> new Student("№№###*()", 4.5, 1));
+    assertThrows(IllegalArgumentException.class, () -> new Student("№№###*()", 4.5, 1));
-    }
+  }
 
-    @Test
+  @Test
-    void testValidAverageGrades() {
+  void testValidAverageGrades() {
-        assertDoesNotThrow(() -> new Student("A12", 0.0, 1));
+    assertDoesNotThrow(() -> new Student("A12", 0.0, 1));
-        assertDoesNotThrow(() -> new Student("A12", 5.0, 1));
+    assertDoesNotThrow(() -> new Student("A12", 5.0, 1));
-    }
+  }
 
-    @Test
+  @Test
-    void testInvalidAverageGrades() {
+  void testInvalidAverageGrades() {
-        assertThrows(IllegalArgumentException.class, () -> new Student("A12", -1.0, 1));
+    assertThrows(IllegalArgumentException.class, () -> new Student("A12", -1.0, 1));
-        assertThrows(IllegalArgumentException.class, () -> new Student("A12", 6.0, 1));
+    assertThrows(IllegalArgumentException.class, () -> new Student("A12", 6.0, 1));
-    }
+  }
 
-    @Test
+  @Test
-    void testValidRecordBookNumbers() {
+  void testValidRecordBookNumbers() {
-        assertDoesNotThrow(() -> new Student("A12", 4.5, 1));
+    assertDoesNotThrow(() -> new Student("A12", 4.5, 1));
-        assertDoesNotThrow(() -> new Student("A12", 4.5, 12345));
+    assertDoesNotThrow(() -> new Student("A12", 4.5, 12345));
-    }
+  }
 
-    @Test
+  @Test
-    void testInvalidRecordBookNumbers() {
+  void testInvalidRecordBookNumbers() {
-        assertThrows(IllegalArgumentException.class, () -> new Student("A12", 4.5, 0));
+    assertThrows(IllegalArgumentException.class, () -> new Student("A12", 4.5, 0));
-        assertThrows(IllegalArgumentException.class, () -> new Student("A12", 4.5, -1));
+    assertThrows(IllegalArgumentException.class, () -> new Student("A12", 4.5, -1));
-    }
+  }
 
-    @Test
+  @Test
-    void testWithGroupNumber() {
+  void testWithGroupNumber() {
-        Student original = new Student("A12", 4.5, 12345);
+    Student original = new Student("A12", 4.5, 12345);
-        Student updated = original.withGroupNumber("B32");
+    Student updated = original.withGroupNumber("B32");
 
-        assertNotSame(original, updated);
+    assertNotSame(original, updated);
-        assertEquals("B32", updated.getGroupNumber());
+    assertEquals("B32", updated.getGroupNumber());
-        assertEquals(4.5, updated.getAverageGrade());
+    assertEquals(4.5, updated.getAverageGrade());
-        assertEquals(12345, updated.getRecordBookNumber());
+    assertEquals(12345, updated.getRecordBookNumber());
 
-        assertEquals("A12", original.getGroupNumber());
+    assertEquals("A12", original.getGroupNumber());
-    }
+  }
 
-    @Test
+  @Test
-    void testWithAverageGrade() {
+  void testWithAverageGrade() {
-        Student original = new Student("A12", 4.5, 12345);
+    Student original = new Student("A12", 4.5, 12345);
-        Student updated = original.withAverageGrade(4.8);
+    Student updated = original.withAverageGrade(4.8);
 
-        assertNotSame(original, updated);
+    assertNotSame(original, updated);
-        assertEquals(4.8, updated.getAverageGrade());
+    assertEquals(4.8, updated.getAverageGrade());
-        assertEquals("A12", updated.getGroupNumber());
+    assertEquals("A12", updated.getGroupNumber());
-        assertEquals(12345, updated.getRecordBookNumber());
+    assertEquals(12345, updated.getRecordBookNumber());
 
-        assertEquals(4.5, original.getAverageGrade());
+    assertEquals(4.5, original.getAverageGrade());
-    }
+  }
 
-    @Test
+  @Test
-    void testWithRecordBookNumber() {
+  void testWithRecordBookNumber() {
-        Student original = new Student("A12", 4.5, 12345);
+    Student original = new Student("A12", 4.5, 12345);
-        Student updated = original.withRecordBookNumber(99999);
+    Student updated = original.withRecordBookNumber(99999);
 
-        assertNotSame(original, updated);
+    assertNotSame(original, updated);
-        assertEquals(99999, updated.getRecordBookNumber());
+    assertEquals(99999, updated.getRecordBookNumber());
-        assertEquals("A12", updated.getGroupNumber());
+    assertEquals("A12", updated.getGroupNumber());
-        assertEquals(4.5, updated.getAverageGrade());
+    assertEquals(4.5, updated.getAverageGrade());
 
-        assertEquals(12345, original.getRecordBookNumber());
+    assertEquals(12345, original.getRecordBookNumber());
-    }
+  }
 
-    @Test
+  @Test
-    void testWithInvalidGroupNumber() {
+  void testWithInvalidGroupNumber() {
-        Student original = new Student("A12", 4.5, 12345);
+    Student original = new Student("A12", 4.5, 12345);
-        assertThrows(IllegalArgumentException.class,
+    assertThrows(IllegalArgumentException.class, () -> original.withGroupNumber("a12"));
-                () -> original.withGroupNumber("a12"));
+    assertEquals("A12", original.getGroupNumber()); // не изменился
-        assertEquals("A12", original.getGroupNumber()); // не изменился
+  }
-    }
 
-    @Test
+  @Test
-    void testWithInvalidAverageGrade() {
+  void testWithInvalidAverageGrade() {
-        Student original = new Student("A12", 4.5, 12345);
+    Student original = new Student("A12", 4.5, 12345);
-        assertThrows(IllegalArgumentException.class,
+    assertThrows(IllegalArgumentException.class, () -> original.withAverageGrade(6.0));
-                () -> original.withAverageGrade(6.0));
+    assertEquals(4.5, original.getAverageGrade());
-        assertEquals(4.5, original.getAverageGrade());
+  }
-    }
 
-    @Test
+  @Test
-    void testWithInvalidRecordBookNumber() {
+  void testWithInvalidRecordBookNumber() {
-        Student original = new Student("A12", 4.5, 12345);
+    Student original = new Student("A12", 4.5, 12345);
-        assertThrows(IllegalArgumentException.class,
+    assertThrows(IllegalArgumentException.class, () -> original.withRecordBookNumber(0));
-                () -> original.withRecordBookNumber(0));
+    assertEquals(12345, original.getRecordBookNumber());
-        assertEquals(12345, original.getRecordBookNumber());
+  }
-    }
 
-    @Test
+  @Test
-    void testEqualsAndHashCode() {
+  void testEqualsAndHashCode() {
-        Student s1 = new Student("A12", 4.5, 12345);
+    Student s1 = new Student("A12", 4.5, 12345);
-        Student s2 = new Student("A12", 4.5, 12345);
+    Student s2 = new Student("A12", 4.5, 12345);
-        Student s3 = new Student("B32", 4.5, 12345);
+    Student s3 = new Student("B32", 4.5, 12345);
-        Student s4 = new Student("A12", 4.8, 12345);
+    Student s4 = new Student("A12", 4.8, 12345);
-        Student s5 = new Student("A12", 4.5, 99999);
+    Student s5 = new Student("A12", 4.5, 99999);
 
-        assertEquals(s1, s2);
+    assertEquals(s1, s2);
-        assertEquals(s1.hashCode(), s2.hashCode());
+    assertEquals(s1.hashCode(), s2.hashCode());
 
-        assertNotEquals(s1, s3);
+    assertNotEquals(s1, s3);
-        assertNotEquals(s1, s4);
+    assertNotEquals(s1, s4);
-        assertNotEquals(s1, s5);
+    assertNotEquals(s1, s5);
-        assertNotEquals(s1, null);
+    assertNotEquals(s1, null);
-        assertNotEquals(s1, "some string");
+    assertNotEquals(s1, "some string");
-    }
+  }
 }