From e20820b78f8009f78f2a8acd69d1237f65b2dee3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=92=D0=BE=D0=BB=D0=BE=D0=B4=D0=B8=D0=BD=20=D0=93=D0=B5?= =?UTF-8?q?=D1=80=D0=BC=D0=B0=D0=BD?= Date: Sun, 30 Aug 2026 13:03:23 +0400 Subject: [PATCH] refactor: unify code style and fix minor merge issues --- .../project/sorting/BubbleSortStrategy.java | 34 +- .../sorting/EvenOnlyMergeSortStrategy.java | 130 ++-- .../project/sorting/EvenOnlySortStrategy.java | 141 +++-- .../ru/project/sorting/MergeSortStrategy.java | 111 ++-- .../java/ru/project/sorting/SortStrategy.java | 7 +- .../StudentAverageGradeComparator.java | 12 +- .../sorting/StudentGroupComparator.java | 10 +- .../sorting/StudentRecordBookComparator.java | 12 +- .../main/java/ru/project/student/Student.java | 4 + app/src/test/java/ru/project/AppTest.java | 16 +- .../ru/project/Sorting/SortStrategyTest.java | 163 ----- .../sorting/EvenOnlySortStrategyTest.java | 561 +++++++++--------- .../ru/project/sorting/SortStrategyTest.java | 162 +++++ .../java/ru/project/student/StudentTest.java | 222 ++++--- 14 files changed, 779 insertions(+), 806 deletions(-) delete mode 100644 app/src/test/java/ru/project/Sorting/SortStrategyTest.java create mode 100644 app/src/test/java/ru/project/sorting/SortStrategyTest.java diff --git a/app/src/main/java/ru/project/sorting/BubbleSortStrategy.java b/app/src/main/java/ru/project/sorting/BubbleSortStrategy.java index 38172db..3c482eb 100644 --- a/app/src/main/java/ru/project/sorting/BubbleSortStrategy.java +++ b/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 implements SortStrategy { - @Override - public void sort(MyList list, Comparator comparator) { - if (list == null || list.size() <= 1) { - 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); - } - } - } + @Override + public void sort(MyList list, Comparator comparator) { + if (list == null || list.size() <= 1) { + return; } -} \ No newline at end of file + 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); + } + } + } + } +} diff --git a/app/src/main/java/ru/project/sorting/EvenOnlyMergeSortStrategy.java b/app/src/main/java/ru/project/sorting/EvenOnlyMergeSortStrategy.java index dea539e..021a70e 100644 --- a/app/src/main/java/ru/project/sorting/EvenOnlyMergeSortStrategy.java +++ b/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 implements SortStrategy { - private final ToIntFunction valueExtractor; + private final ToIntFunction valueExtractor; - public EvenOnlyMergeSortStrategy(ToIntFunction valueExtractor) { - this.valueExtractor = valueExtractor; + public EvenOnlyMergeSortStrategy(ToIntFunction valueExtractor) { + this.valueExtractor = valueExtractor; + } + + @Override + public void sort(MyList list, Comparator comparator) { + if (list == null || list.size() <= 1) { + return; } - @Override - public void sort(MyList list, Comparator comparator) { - if (list == null || list.size() <= 1) { - return; - } + List evenIndices = new ArrayList<>(); + List evenElements = new ArrayList<>(); - List evenIndices = new ArrayList<>(); - List evenElements = new ArrayList<>(); - - for (int i = 0; i < list.size(); i++) { - T element = list.get(i); - int value = valueExtractor.applyAsInt(element); - if (value % 2 == 0) { - evenIndices.add(i); - evenElements.add(element); - } - } - - if (evenElements.size() <= 1) { - return; - } - - List sortedEven = mergeSort(evenElements, comparator); - - for (int j = 0; j < evenIndices.size(); j++) { - list.set(evenIndices.get(j), sortedEven.get(j)); - } + for (int i = 0; i < list.size(); i++) { + T element = list.get(i); + int value = valueExtractor.applyAsInt(element); + if (value % 2 == 0) { + evenIndices.add(i); + evenElements.add(element); + } } - private List mergeSort(List list, Comparator comparator) { - if (list.size() <= 1) { - return list; - } - - int mid = list.size() / 2; - List left = mergeSort(list.subList(0, mid), comparator); - List right = mergeSort(list.subList(mid, list.size()), comparator); - - return merge(left, right, comparator); + if (evenElements.size() <= 1) { + return; } - private List merge(List left, List right, Comparator comparator) { - List result = new ArrayList<>(); - int i = 0, j = 0; + List sortedEven = mergeSort(evenElements, comparator); - 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; + for (int j = 0; j < evenIndices.size(); j++) { + list.set(evenIndices.get(j), sortedEven.get(j)); } -} \ No newline at end of file + } + + private List mergeSort(List list, Comparator comparator) { + if (list.size() <= 1) { + return list; + } + + int mid = list.size() / 2; + List left = mergeSort(list.subList(0, mid), comparator); + List right = mergeSort(list.subList(mid, list.size()), comparator); + + return merge(left, right, comparator); + } + + private List merge(List left, List right, Comparator comparator) { + List 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; + } +} diff --git a/app/src/main/java/ru/project/sorting/EvenOnlySortStrategy.java b/app/src/main/java/ru/project/sorting/EvenOnlySortStrategy.java index 32349c1..8d179ec 100644 --- a/app/src/main/java/ru/project/sorting/EvenOnlySortStrategy.java +++ b/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 implements SortStrategy { - private SortStrategy sortStrategy; - private ToIntFunction valueExtractor; + private SortStrategy sortStrategy; + private ToIntFunction valueExtractor; - public EvenOnlySortStrategy() { + public EvenOnlySortStrategy() {} + + public EvenOnlySortStrategy(SortStrategy sortStrategy) { + setSortStrategy(sortStrategy); + } + + public EvenOnlySortStrategy(SortStrategy sortStrategy, ToIntFunction valueExtractor) { + setSortStrategy(sortStrategy); + setValueExtractor(valueExtractor); + } + + public void setSortStrategy(SortStrategy sortStrategy) { + if (sortStrategy == null) { + throw new IllegalArgumentException("Sort strategy must not be null"); } - public EvenOnlySortStrategy(SortStrategy sortStrategy) { - setSortStrategy(sortStrategy); + this.sortStrategy = sortStrategy; + } + + public void setValueExtractor(ToIntFunction valueExtractor) { + if (valueExtractor == null) { + throw new IllegalArgumentException("Value extractor must not be null"); } - public EvenOnlySortStrategy( - SortStrategy sortStrategy, - ToIntFunction valueExtractor - ) { - setSortStrategy(sortStrategy); - setValueExtractor(valueExtractor); + this.valueExtractor = valueExtractor; + } + + @Override + public void sort(MyList list, Comparator comparator) { + if (sortStrategy == null) { + throw new IllegalStateException("Sort strategy is not set"); } - public void setSortStrategy(SortStrategy sortStrategy) { - if (sortStrategy == null) { - throw new IllegalArgumentException("Sort strategy must not be null"); - } - - this.sortStrategy = sortStrategy; + if (valueExtractor == null) { + throw new IllegalStateException("Value extractor is not set"); } - public void setValueExtractor(ToIntFunction valueExtractor) { - if (valueExtractor == null) { - throw new IllegalArgumentException("Value extractor must not be null"); - } - - this.valueExtractor = valueExtractor; + if (list == null || list.size() <= 1) { + return; } - @Override - public void sort(MyList list, Comparator comparator) { - if (sortStrategy == null) { - throw new IllegalStateException("Sort strategy is not set"); - } + int evenCount = 0; - if (valueExtractor == null) { - throw new IllegalStateException("Value extractor is not set"); - } + for (int i = 0; i < list.size(); i++) { + T element = list.get(i); - if (list == null || list.size() <= 1) { - return; - } - - 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 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 (valueExtractor.applyAsInt(element) % 2 == 0) { + evenCount++; + } } -} \ No newline at end of file + + if (evenCount <= 1) { + return; + } + + MyList 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)); + } + } +} diff --git a/app/src/main/java/ru/project/sorting/MergeSortStrategy.java b/app/src/main/java/ru/project/sorting/MergeSortStrategy.java index 598f754..420adee 100644 --- a/app/src/main/java/ru/project/sorting/MergeSortStrategy.java +++ b/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 implements SortStrategy { - @Override - public void sort(MyList list, Comparator comparator) { - if (list == null || list.size() <= 1) { - return; - } - mergeSort(list, 0, list.size() - 1, comparator); + @Override + public void sort(MyList list, Comparator comparator) { + if (list == null || list.size() <= 1) { + return; + } + mergeSort(list, 0, list.size() - 1, comparator); + } + + private void mergeSort(MyList list, int left, int right, Comparator 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 list, int left, int mid, int right, Comparator 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 list, int left, int right, Comparator 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); + 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++; } - private void merge(MyList list, int left, int mid, int right, Comparator 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); - } - - 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 (i < leftSize) { + list.set(k, leftArray[i]); + i++; + k++; } -} \ No newline at end of file + while (j < rightSize) { + list.set(k, rightArray[j]); + j++; + k++; + } + } +} diff --git a/app/src/main/java/ru/project/sorting/SortStrategy.java b/app/src/main/java/ru/project/sorting/SortStrategy.java index 059d908..b9946e8 100644 --- a/app/src/main/java/ru/project/sorting/SortStrategy.java +++ b/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 { - void sort(MyList list, Comparator comparator); -} \ No newline at end of file + void sort(MyList list, Comparator comparator); +} diff --git a/app/src/main/java/ru/project/sorting/StudentAverageGradeComparator.java b/app/src/main/java/ru/project/sorting/StudentAverageGradeComparator.java index fea72f6..3553976 100644 --- a/app/src/main/java/ru/project/sorting/StudentAverageGradeComparator.java +++ b/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 { - @Override - public int compare(Student s1, Student s2) { - return Double.compare(s1.getAverageGrade(), s2.getAverageGrade()); - } -} \ No newline at end of file + @Override + public int compare(Student s1, Student s2) { + return Double.compare(s1.getAverageGrade(), s2.getAverageGrade()); + } +} diff --git a/app/src/main/java/ru/project/sorting/StudentGroupComparator.java b/app/src/main/java/ru/project/sorting/StudentGroupComparator.java index 75cae82..9278e81 100644 --- a/app/src/main/java/ru/project/sorting/StudentGroupComparator.java +++ b/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 { - @Override - public int compare(Student s1, Student s2) { - return s1.getGroupNumber().compareTo(s2.getGroupNumber()); - } + @Override + public int compare(Student s1, Student s2) { + return s1.getGroupNumber().compareTo(s2.getGroupNumber()); + } } diff --git a/app/src/main/java/ru/project/sorting/StudentRecordBookComparator.java b/app/src/main/java/ru/project/sorting/StudentRecordBookComparator.java index 0e4a714..ce65a5b 100644 --- a/app/src/main/java/ru/project/sorting/StudentRecordBookComparator.java +++ b/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 { - @Override - public int compare(Student s1, Student s2) { - return Integer.compare(s1.getRecordBookNumber(), s2.getRecordBookNumber()); - } -} \ No newline at end of file + @Override + public int compare(Student s1, Student s2) { + return Integer.compare(s1.getRecordBookNumber(), s2.getRecordBookNumber()); + } +} diff --git a/app/src/main/java/ru/project/student/Student.java b/app/src/main/java/ru/project/student/Student.java index f4cd7fc..111e559 100644 --- a/app/src/main/java/ru/project/student/Student.java +++ b/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; } diff --git a/app/src/test/java/ru/project/AppTest.java b/app/src/test/java/ru/project/AppTest.java index c79d156..44a05ef 100644 --- a/app/src/test/java/ru/project/AppTest.java +++ b/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 :-) - */ - @Test - public void shouldAnswerWithTrue() { - assertTrue(true); - } + /** Rigorous Test :-) */ + @Test + public void shouldAnswerWithTrue() { + assertTrue(true); + } } diff --git a/app/src/test/java/ru/project/Sorting/SortStrategyTest.java b/app/src/test/java/ru/project/Sorting/SortStrategyTest.java deleted file mode 100644 index 6e0472c..0000000 --- a/app/src/test/java/ru/project/Sorting/SortStrategyTest.java +++ /dev/null @@ -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 students; - private final Comparator groupComparator = new StudentGroupComparator(); - private final Comparator gradeComparator = new StudentAverageGradeComparator(); - private final Comparator 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 strategy = new MergeSortStrategy<>(); - strategy.sort(students, groupComparator); - assertOrder(students, "A12", "A12", "B32", "B32", "Z00"); - } - - @Test - void testMergeSortByAverageGrade() { - SortStrategy strategy = new MergeSortStrategy<>(); - strategy.sort(students, gradeComparator); - assertOrder(students, 3.8, 4.2, 4.5, 4.9, 5.0); - } - - @Test - void testMergeSortByRecordBookNumber() { - SortStrategy strategy = new MergeSortStrategy<>(); - strategy.sort(students, recordComparator); - assertOrder(students, 12345, 12346, 12347, 12348, 12349); - } - - @Test - void testBubbleSortByGroupNumber() { - SortStrategy strategy = new BubbleSortStrategy<>(); - strategy.sort(students, groupComparator); - assertOrder(students, "A12", "A12", "B32", "B32", "Z00"); - } - - @Test - void testBubbleSortByAverageGrade() { - SortStrategy strategy = new BubbleSortStrategy<>(); - strategy.sort(students, gradeComparator); - assertOrder(students, 3.8, 4.2, 4.5, 4.9, 5.0); - } - - @Test - void testBubbleSortByRecordBookNumber() { - SortStrategy strategy = new BubbleSortStrategy<>(); - strategy.sort(students, recordComparator); - assertOrder(students, 12345, 12346, 12347, 12348, 12349); - } - - @Test - void testEvenOnlySortByRecordBookNumber() { - MyList 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 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 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 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 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 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 empty = new MyLinkedList<>(); - SortStrategy strategy = new MergeSortStrategy<>(); - strategy.sort(empty, groupComparator); - assertEquals(0, empty.size()); - } - - @Test - void testSortSingleElement() { - MyList single = new MyLinkedList<>(); - single.add(new Student("A12", 4.5, 12345)); - SortStrategy strategy = new MergeSortStrategy<>(); - strategy.sort(single, groupComparator); - assertEquals(1, single.size()); - } - - private void assertOrder(MyList 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 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 list, int... records) { - assertEquals(records.length, list.size()); - for (int i = 0; i < records.length; i++) { - assertEquals(records[i], list.get(i).getRecordBookNumber()); - } - } -} \ No newline at end of file diff --git a/app/src/test/java/ru/project/sorting/EvenOnlySortStrategyTest.java b/app/src/test/java/ru/project/sorting/EvenOnlySortStrategyTest.java index 8d482bd..daccad5 100644 --- a/app/src/test/java/ru/project/sorting/EvenOnlySortStrategyTest.java +++ b/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 - void shouldHandleEmptyList() { - MyList list = new MyLinkedList<>(); + @Test + void shouldHandleEmptyList() { + MyList list = new MyLinkedList<>(); - EvenOnlySortStrategy strategy = - new EvenOnlySortStrategy<>( - new MergeSortStrategy<>(), - value -> value - ); + EvenOnlySortStrategy strategy = + new EvenOnlySortStrategy<>(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 list = new MyLinkedList<>(); + list.add(4); + + EvenOnlySortStrategy 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 list = new MyLinkedList<>(); + list.add(7); + + EvenOnlySortStrategy 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 list = new MyLinkedList<>(); + + list.add(8); + list.add(4); + list.add(8); + list.add(2); + list.add(4); + + EvenOnlySortStrategy 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 students = new MyLinkedList<>(); + + students.add(oddFirst); + students.add(evenFirst); + students.add(oddSecond); + students.add(evenSecond); + students.add(oddThird); + students.add(evenThird); + + EvenOnlySortStrategy 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 list = new MyLinkedList<>(); + + list.add(8); + list.add(2); + list.add(4); + + EvenOnlySortStrategy 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 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 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 list = new MyLinkedList<>(); + + list.add(8); + list.add(2); + list.add(6); + list.add(4); + + EvenOnlySortStrategy 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 list = new MyLinkedList<>(); + + list.add(7); + list.add(3); + list.add(5); + list.add(1); + + EvenOnlySortStrategy 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 strategy = new EvenOnlySortStrategy<>(); + + strategy.setValueExtractor(value -> value); + + MyList list = new MyLinkedList<>(); + list.add(2); + list.add(4); + + assertThrows(IllegalStateException.class, () -> strategy.sort(list, Integer::compare)); + } + + @Test + void shouldRejectNullSortStrategy() { + EvenOnlySortStrategy strategy = new EvenOnlySortStrategy<>(); + + assertThrows(IllegalArgumentException.class, () -> strategy.setSortStrategy(null)); + } + + @Test + void shouldDelegateSortingToProvidedStrategy() { + MyList list = new MyLinkedList<>(); + + list.add(7); + list.add(8); + list.add(3); + list.add(2); + + RecordingSortStrategy recordingStrategy = new RecordingSortStrategy(); + + EvenOnlySortStrategy 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 strategy = + new EvenOnlySortStrategy<>(firstStrategy, value -> value); + + MyList firstList = new MyLinkedList<>(); + firstList.add(4); + firstList.add(2); + + strategy.sort(firstList, Integer::compare); + + assertTrue(firstStrategy.wasCalled); + + strategy.setSortStrategy(secondStrategy); + + MyList secondList = new MyLinkedList<>(); + secondList.add(8); + secondList.add(6); + + strategy.sort(secondList, Integer::compare); + + assertTrue(secondStrategy.wasCalled); + } + + private static class RecordingSortStrategy implements SortStrategy { + + private boolean wasCalled; + private int receivedSize; + private Integer firstReceivedElement; + private Integer secondReceivedElement; + + @Override + public void sort(MyList list, Comparator 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 list = new MyLinkedList<>(); - list.add(4); - - EvenOnlySortStrategy 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 list = new MyLinkedList<>(); - list.add(7); - - EvenOnlySortStrategy 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 list = new MyLinkedList<>(); - - list.add(8); - list.add(4); - list.add(8); - list.add(2); - list.add(4); - - EvenOnlySortStrategy 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 students = new MyLinkedList<>(); - - students.add(oddFirst); - students.add(evenFirst); - students.add(oddSecond); - students.add(evenSecond); - students.add(oddThird); - students.add(evenThird); - - EvenOnlySortStrategy 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 list = new MyLinkedList<>(); - - list.add(8); - list.add(2); - list.add(4); - - EvenOnlySortStrategy 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 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 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 list = new MyLinkedList<>(); - - list.add(8); - list.add(2); - list.add(6); - list.add(4); - - EvenOnlySortStrategy 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 list = new MyLinkedList<>(); - - list.add(7); - list.add(3); - list.add(5); - list.add(1); - - EvenOnlySortStrategy 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 strategy = new EvenOnlySortStrategy<>(); - - strategy.setValueExtractor(value -> value); - - MyList list = new MyLinkedList<>(); - list.add(2); - list.add(4); - - assertThrows(IllegalStateException.class, () -> strategy.sort(list, Integer::compare)); - } - - @Test - void shouldRejectNullSortStrategy() { - EvenOnlySortStrategy strategy = new EvenOnlySortStrategy<>(); - - assertThrows(IllegalArgumentException.class, () -> strategy.setSortStrategy(null)); - } - - @Test - void shouldDelegateSortingToProvidedStrategy() { - MyList list = new MyLinkedList<>(); - - list.add(7); - list.add(8); - list.add(3); - list.add(2); - - RecordingSortStrategy recordingStrategy = new RecordingSortStrategy(); - - EvenOnlySortStrategy 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 strategy = new EvenOnlySortStrategy<>(firstStrategy, value -> value); - - MyList firstList = new MyLinkedList<>(); - firstList.add(4); - firstList.add(2); - - strategy.sort(firstList, Integer::compare); - - assertTrue(firstStrategy.wasCalled); - - strategy.setSortStrategy(secondStrategy); - - MyList secondList = new MyLinkedList<>(); - secondList.add(8); - secondList.add(6); - - strategy.sort(secondList, Integer::compare); - - assertTrue(secondStrategy.wasCalled); - } - - private static class RecordingSortStrategy implements SortStrategy { - - private boolean wasCalled; - private int receivedSize; - private Integer firstReceivedElement; - private Integer secondReceivedElement; - - @Override - public void sort(MyList list, Comparator comparator) { - wasCalled = true; - receivedSize = list.size(); - - if (list.size() > 0) { - firstReceivedElement = list.get(0); - } - - if (list.size() > 1) { - secondReceivedElement = list.get(1); - } - } - } -} \ No newline at end of file + } +} diff --git a/app/src/test/java/ru/project/sorting/SortStrategyTest.java b/app/src/test/java/ru/project/sorting/SortStrategyTest.java new file mode 100644 index 0000000..7a6724c --- /dev/null +++ b/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 students; + private final Comparator groupComparator = new StudentGroupComparator(); + private final Comparator gradeComparator = new StudentAverageGradeComparator(); + private final Comparator 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 strategy = new MergeSortStrategy<>(); + strategy.sort(students, groupComparator); + assertOrder(students, "A12", "A12", "B32", "B32", "Z00"); + } + + @Test + void testMergeSortByAverageGrade() { + SortStrategy strategy = new MergeSortStrategy<>(); + strategy.sort(students, gradeComparator); + assertOrder(students, 3.8, 4.2, 4.5, 4.9, 5.0); + } + + @Test + void testMergeSortByRecordBookNumber() { + SortStrategy strategy = new MergeSortStrategy<>(); + strategy.sort(students, recordComparator); + assertOrder(students, 12345, 12346, 12347, 12348, 12349); + } + + @Test + void testBubbleSortByGroupNumber() { + SortStrategy strategy = new BubbleSortStrategy<>(); + strategy.sort(students, groupComparator); + assertOrder(students, "A12", "A12", "B32", "B32", "Z00"); + } + + @Test + void testBubbleSortByAverageGrade() { + SortStrategy strategy = new BubbleSortStrategy<>(); + strategy.sort(students, gradeComparator); + assertOrder(students, 3.8, 4.2, 4.5, 4.9, 5.0); + } + + @Test + void testBubbleSortByRecordBookNumber() { + SortStrategy strategy = new BubbleSortStrategy<>(); + strategy.sort(students, recordComparator); + assertOrder(students, 12345, 12346, 12347, 12348, 12349); + } + + @Test + void testEvenOnlySortByRecordBookNumber() { + MyList 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 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 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 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 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 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 empty = new MyLinkedList<>(); + SortStrategy strategy = new MergeSortStrategy<>(); + strategy.sort(empty, groupComparator); + assertEquals(0, empty.size()); + } + + @Test + void testSortSingleElement() { + MyList single = new MyLinkedList<>(); + single.add(new Student("A12", 4.5, 12345)); + SortStrategy strategy = new MergeSortStrategy<>(); + strategy.sort(single, groupComparator); + assertEquals(1, single.size()); + } + + private void assertOrder(MyList 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 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 list, int... records) { + assertEquals(records.length, list.size()); + for (int i = 0; i < records.length; i++) { + assertEquals(records[i], list.get(i).getRecordBookNumber()); + } + } +} diff --git a/app/src/test/java/ru/project/student/StudentTest.java b/app/src/test/java/ru/project/student/StudentTest.java index 09cf2e7..a51e251 100644 --- a/app/src/test/java/ru/project/student/StudentTest.java +++ b/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 - void testValidStudentCreation() { - Student student = new Student("A12", 4.5, 12345); - assertEquals("A12", student.getGroupNumber()); - assertEquals(4.5, student.getAverageGrade()); - assertEquals(12345, student.getRecordBookNumber()); - } + @Test + void testValidStudentCreation() { + Student student = new Student("A12", 4.5, 12345); + assertEquals("A12", student.getGroupNumber()); + assertEquals(4.5, student.getAverageGrade()); + assertEquals(12345, student.getRecordBookNumber()); + } - @Test - void testValidGroupNumbers() { - assertDoesNotThrow(() -> new Student("A12", 4.5, 1)); - assertDoesNotThrow(() -> new Student("B32", 4.5, 1)); - assertDoesNotThrow(() -> new Student("Z00", 4.5, 1)); - } + @Test + void testValidGroupNumbers() { + assertDoesNotThrow(() -> new Student("A12", 4.5, 1)); + assertDoesNotThrow(() -> new Student("B32", 4.5, 1)); + assertDoesNotThrow(() -> new Student("Z00", 4.5, 1)); + } - @Test - void testInvalidGroupNumbers() { - assertThrows(IllegalArgumentException.class, () -> new Student("a12", 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("AA1", 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("23фи!12", 4.5, 1)); - assertThrows(IllegalArgumentException.class, () -> new Student("№№###*()", 4.5, 1)); - } + @Test + void testInvalidGroupNumbers() { + assertThrows(IllegalArgumentException.class, () -> new Student("a12", 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("AA1", 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("23фи!12", 4.5, 1)); + assertThrows(IllegalArgumentException.class, () -> new Student("№№###*()", 4.5, 1)); + } - @Test - void testValidAverageGrades() { - assertDoesNotThrow(() -> new Student("A12", 0.0, 1)); - assertDoesNotThrow(() -> new Student("A12", 5.0, 1)); - } + @Test + void testValidAverageGrades() { + assertDoesNotThrow(() -> new Student("A12", 0.0, 1)); + assertDoesNotThrow(() -> new Student("A12", 5.0, 1)); + } - @Test - void testInvalidAverageGrades() { - assertThrows(IllegalArgumentException.class, () -> new Student("A12", -1.0, 1)); - assertThrows(IllegalArgumentException.class, () -> new Student("A12", 6.0, 1)); - } + @Test + void testInvalidAverageGrades() { + assertThrows(IllegalArgumentException.class, () -> new Student("A12", -1.0, 1)); + assertThrows(IllegalArgumentException.class, () -> new Student("A12", 6.0, 1)); + } - @Test - void testValidRecordBookNumbers() { - assertDoesNotThrow(() -> new Student("A12", 4.5, 1)); - assertDoesNotThrow(() -> new Student("A12", 4.5, 12345)); - } + @Test + void testValidRecordBookNumbers() { + assertDoesNotThrow(() -> new Student("A12", 4.5, 1)); + assertDoesNotThrow(() -> new Student("A12", 4.5, 12345)); + } - @Test - void testInvalidRecordBookNumbers() { - assertThrows(IllegalArgumentException.class, () -> new Student("A12", 4.5, 0)); - assertThrows(IllegalArgumentException.class, () -> new Student("A12", 4.5, -1)); - } + @Test + void testInvalidRecordBookNumbers() { + assertThrows(IllegalArgumentException.class, () -> new Student("A12", 4.5, 0)); + assertThrows(IllegalArgumentException.class, () -> new Student("A12", 4.5, -1)); + } - @Test - void testWithGroupNumber() { - Student original = new Student("A12", 4.5, 12345); - Student updated = original.withGroupNumber("B32"); + @Test + void testWithGroupNumber() { + Student original = new Student("A12", 4.5, 12345); + Student updated = original.withGroupNumber("B32"); - assertNotSame(original, updated); - assertEquals("B32", updated.getGroupNumber()); - assertEquals(4.5, updated.getAverageGrade()); - assertEquals(12345, updated.getRecordBookNumber()); + assertNotSame(original, updated); + assertEquals("B32", updated.getGroupNumber()); + assertEquals(4.5, updated.getAverageGrade()); + assertEquals(12345, updated.getRecordBookNumber()); - assertEquals("A12", original.getGroupNumber()); - } + assertEquals("A12", original.getGroupNumber()); + } - @Test - void testWithAverageGrade() { - Student original = new Student("A12", 4.5, 12345); - Student updated = original.withAverageGrade(4.8); + @Test + void testWithAverageGrade() { + Student original = new Student("A12", 4.5, 12345); + Student updated = original.withAverageGrade(4.8); - assertNotSame(original, updated); - assertEquals(4.8, updated.getAverageGrade()); - assertEquals("A12", updated.getGroupNumber()); - assertEquals(12345, updated.getRecordBookNumber()); + assertNotSame(original, updated); + assertEquals(4.8, updated.getAverageGrade()); + assertEquals("A12", updated.getGroupNumber()); + assertEquals(12345, updated.getRecordBookNumber()); - assertEquals(4.5, original.getAverageGrade()); - } + assertEquals(4.5, original.getAverageGrade()); + } - @Test - void testWithRecordBookNumber() { - Student original = new Student("A12", 4.5, 12345); - Student updated = original.withRecordBookNumber(99999); + @Test + void testWithRecordBookNumber() { + Student original = new Student("A12", 4.5, 12345); + Student updated = original.withRecordBookNumber(99999); - assertNotSame(original, updated); - assertEquals(99999, updated.getRecordBookNumber()); - assertEquals("A12", updated.getGroupNumber()); - assertEquals(4.5, updated.getAverageGrade()); + assertNotSame(original, updated); + assertEquals(99999, updated.getRecordBookNumber()); + assertEquals("A12", updated.getGroupNumber()); + assertEquals(4.5, updated.getAverageGrade()); - assertEquals(12345, original.getRecordBookNumber()); - } + assertEquals(12345, original.getRecordBookNumber()); + } - @Test - void testWithInvalidGroupNumber() { - Student original = new Student("A12", 4.5, 12345); - assertThrows(IllegalArgumentException.class, - () -> original.withGroupNumber("a12")); - assertEquals("A12", original.getGroupNumber()); // не изменился - } + @Test + void testWithInvalidGroupNumber() { + Student original = new Student("A12", 4.5, 12345); + assertThrows(IllegalArgumentException.class, () -> original.withGroupNumber("a12")); + assertEquals("A12", original.getGroupNumber()); // не изменился + } - @Test - void testWithInvalidAverageGrade() { - Student original = new Student("A12", 4.5, 12345); - assertThrows(IllegalArgumentException.class, - () -> original.withAverageGrade(6.0)); - assertEquals(4.5, original.getAverageGrade()); - } + @Test + void testWithInvalidAverageGrade() { + Student original = new Student("A12", 4.5, 12345); + assertThrows(IllegalArgumentException.class, () -> original.withAverageGrade(6.0)); + assertEquals(4.5, original.getAverageGrade()); + } - @Test - void testWithInvalidRecordBookNumber() { - Student original = new Student("A12", 4.5, 12345); - assertThrows(IllegalArgumentException.class, - () -> original.withRecordBookNumber(0)); - assertEquals(12345, original.getRecordBookNumber()); - } + @Test + void testWithInvalidRecordBookNumber() { + Student original = new Student("A12", 4.5, 12345); + assertThrows(IllegalArgumentException.class, () -> original.withRecordBookNumber(0)); + assertEquals(12345, original.getRecordBookNumber()); + } - @Test - void testEqualsAndHashCode() { - Student s1 = new Student("A12", 4.5, 12345); - Student s2 = new Student("A12", 4.5, 12345); - Student s3 = new Student("B32", 4.5, 12345); - Student s4 = new Student("A12", 4.8, 12345); - Student s5 = new Student("A12", 4.5, 99999); + @Test + void testEqualsAndHashCode() { + Student s1 = new Student("A12", 4.5, 12345); + Student s2 = new Student("A12", 4.5, 12345); + Student s3 = new Student("B32", 4.5, 12345); + Student s4 = new Student("A12", 4.8, 12345); + Student s5 = new Student("A12", 4.5, 99999); - assertEquals(s1, s2); - assertEquals(s1.hashCode(), s2.hashCode()); + assertEquals(s1, s2); + assertEquals(s1.hashCode(), s2.hashCode()); - assertNotEquals(s1, s3); - assertNotEquals(s1, s4); - assertNotEquals(s1, s5); - assertNotEquals(s1, null); - assertNotEquals(s1, "some string"); - } + assertNotEquals(s1, s3); + assertNotEquals(s1, s4); + assertNotEquals(s1, s5); + assertNotEquals(s1, null); + assertNotEquals(s1, "some string"); + } }