refactor: unify code style and fix minor merge issues
This commit is contained in:
@@ -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
|
||||
public void sort(MyList<T> list, Comparator<T> 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<T> list, Comparator<T> 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);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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) {
|
||||
this.valueExtractor = valueExtractor;
|
||||
public EvenOnlyMergeSortStrategy(ToIntFunction<T> valueExtractor) {
|
||||
this.valueExtractor = valueExtractor;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void sort(MyList<T> list, Comparator<T> comparator) {
|
||||
if (list == null || list.size() <= 1) {
|
||||
return;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void sort(MyList<T> list, Comparator<T> comparator) {
|
||||
if (list == null || list.size() <= 1) {
|
||||
return;
|
||||
}
|
||||
List<Integer> evenIndices = new ArrayList<>();
|
||||
List<T> evenElements = new ArrayList<>();
|
||||
|
||||
List<Integer> evenIndices = new ArrayList<>();
|
||||
List<T> 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<T> 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<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);
|
||||
if (evenElements.size() <= 1) {
|
||||
return;
|
||||
}
|
||||
|
||||
private List<T> merge(List<T> left, List<T> right, Comparator<T> comparator) {
|
||||
List<T> result = new ArrayList<>();
|
||||
int i = 0, j = 0;
|
||||
List<T> 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));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
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;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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 ToIntFunction<T> valueExtractor;
|
||||
private SortStrategy<T> sortStrategy;
|
||||
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) {
|
||||
setSortStrategy(sortStrategy);
|
||||
this.sortStrategy = sortStrategy;
|
||||
}
|
||||
|
||||
public void setValueExtractor(ToIntFunction<T> valueExtractor) {
|
||||
if (valueExtractor == null) {
|
||||
throw new IllegalArgumentException("Value extractor must not be null");
|
||||
}
|
||||
|
||||
public EvenOnlySortStrategy(
|
||||
SortStrategy<T> sortStrategy,
|
||||
ToIntFunction<T> valueExtractor
|
||||
) {
|
||||
setSortStrategy(sortStrategy);
|
||||
setValueExtractor(valueExtractor);
|
||||
this.valueExtractor = valueExtractor;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void sort(MyList<T> list, Comparator<T> comparator) {
|
||||
if (sortStrategy == null) {
|
||||
throw new IllegalStateException("Sort strategy is not set");
|
||||
}
|
||||
|
||||
public void setSortStrategy(SortStrategy<T> 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<T> 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<T> list, Comparator<T> 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<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 (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));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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
|
||||
public void sort(MyList<T> list, Comparator<T> comparator) {
|
||||
if (list == null || list.size() <= 1) {
|
||||
return;
|
||||
}
|
||||
mergeSort(list, 0, list.size() - 1, comparator);
|
||||
@Override
|
||||
public void sort(MyList<T> list, Comparator<T> comparator) {
|
||||
if (list == null || list.size() <= 1) {
|
||||
return;
|
||||
}
|
||||
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) {
|
||||
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<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);
|
||||
}
|
||||
|
||||
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++;
|
||||
}
|
||||
}
|
||||
while (j < rightSize) {
|
||||
list.set(k, rightArray[j]);
|
||||
j++;
|
||||
k++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
|
||||
@@ -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
|
||||
public int compare(Student s1, Student s2) {
|
||||
return Double.compare(s1.getAverageGrade(), s2.getAverageGrade());
|
||||
}
|
||||
}
|
||||
@Override
|
||||
public int compare(Student s1, Student s2) {
|
||||
return Double.compare(s1.getAverageGrade(), s2.getAverageGrade());
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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
|
||||
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());
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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
|
||||
public int compare(Student s1, Student s2) {
|
||||
return Integer.compare(s1.getRecordBookNumber(), s2.getRecordBookNumber());
|
||||
}
|
||||
}
|
||||
@Override
|
||||
public int compare(Student s1, Student s2) {
|
||||
return Integer.compare(s1.getRecordBookNumber(), s2.getRecordBookNumber());
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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());
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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<Integer> list = new MyLinkedList<>();
|
||||
@Test
|
||||
void shouldHandleEmptyList() {
|
||||
MyList<Integer> list = new MyLinkedList<>();
|
||||
|
||||
EvenOnlySortStrategy<Integer> strategy =
|
||||
new EvenOnlySortStrategy<>(
|
||||
new MergeSortStrategy<>(),
|
||||
value -> value
|
||||
);
|
||||
EvenOnlySortStrategy<Integer> 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<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);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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());
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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");
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user