test: reorganize and update collection tests

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

@@ -1,15 +0,0 @@
-package ru.project;
-
-import static org.junit.jupiter.api.Assertions.assertTrue;
-
-import org.junit.jupiter.api.Test;
-
-/** Unit test for simple App. */
-public class AppTest {
-
-  /** Rigorous Test :-) */
-  @Test
-  public void shouldAnswerWithTrue() {
-    assertTrue(true);
-  }
-}

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

@@ -1,63 +0,0 @@
-package ru.test.maven.spring;
-import org.junit.jupiter.api.Test;
-import static org.junit.jupiter.api.Assertions.*;
-import java.util.Set;
-import java.util.stream.Collector;
-import java.util.stream.IntStream;
-import java.util.Collections;
-public class MyListCollectorTest
-{
-    private final MyListCollector<Integer> collector = new MyListCollector<>();
-
-    @Test
-    void shouldTestCollectInOrderSequential() {
-        MyList<Integer> result = IntStream.range(0, 10)
-                .boxed()
-                .collect(MyCollectors.toMyList());
-
-        assertEquals(10, result.size());
-        for (int i = 0; i < result.size(); i++) {
-            assertEquals(i, (int) result.get(i));
-        }
-
-    }
-
-    @Test
-    void shouldTestCollectInOrderParallel() {
-        MyList<Integer> result = IntStream.range(0, 100)
-                .parallel()
-                .boxed()
-                .collect(MyCollectors.toMyList());
-
-        assertEquals(100, result.size());
-        for (int i = 0; i < result.size(); i++) {
-            assertEquals(i, (int) result.get(i));
-        }
-    }
-
-    @Test
-    void shouldTestHandleEmptyStream() {
-        MyList<Integer> result = IntStream.empty()
-                .boxed()
-                .collect(MyCollectors.toMyList());
-
-        assertTrue(result.isEmpty());
-
-    }
-    @Test
-    void shouldTestNotUseStandardList() {
-        MyList<String> result = IntStream.range(0, 5)
-                .mapToObj(i -> "item" + i)
-                .collect(MyCollectors.toMyList());
-
-        assertInstanceOf(MyList.class, result);
-        assertFalse(result instanceof java.util.List);
-    }
-    @Test
-    void shouldTestHaveCorrectCharacteristics() {
-        Set<Collector.Characteristics> characteristics = collector.characteristics();
-        assertTrue(characteristics.contains(java.util.stream.Collector.Characteristics.IDENTITY_FINISH));
-        assertFalse(characteristics.contains(java.util.stream.Collector.Characteristics.UNORDERED));
-    }
-
-}

app/src/test/java/ru/project/collection/MyLinkedListTest.java

@@ -1,130 +1,138 @@
-package ru.test.maven.spring;
+package ru.project.collection;
-import org.junit.jupiter.api.Test;
+
 import static org.junit.jupiter.api.Assertions.*;
-public class MyLinkedListTest
-{
-    @Test
-    public void shouldTestAdd() {
-        MyLinkedList<Integer> list = new MyLinkedList<>();
-        list.add(10);
-        list.add(20);
-        list.add(30);
 
-        assertEquals(10, list.get(0));
+import org.junit.jupiter.api.Test;
-        assertEquals(20, list.get(1));
-        assertEquals(30, list.get(2));
-    }
-    @Test
-    public void shouldTestGet()
-    {
-        MyLinkedList<Integer> list = new MyLinkedList<>();
-        list.add(10);
-        assertEquals(10, list.get(0));
-    }
-    @Test
-    public void shouldTestRemove() {
-        MyLinkedList<Integer> list = new MyLinkedList<>();
-        list.add(10);
-        list.add(20);
-        list.add(30);
-        list.remove(0);
 
-        assertEquals(2, list.size());
+public class MyLinkedListTest {
-        assertEquals(20, list.get(0));
+  @Test
-        assertEquals(30, list.get(1));
+  public void shouldTestAdd() {
-    }
+    MyLinkedList<Integer> list = new MyLinkedList<>();
-    @Test
+    list.add(10);
-    void shouldTestSet() {
+    list.add(20);
-        MyLinkedList<String> list = new MyLinkedList<>();
+    list.add(30);
-        list.add("A");
-        list.add("B");
-        list.add("C");
 
-        String oldValue = list.set(1, "Z");
+    assertEquals(10, list.get(0));
+    assertEquals(20, list.get(1));
+    assertEquals(30, list.get(2));
+  }
 
-        assertEquals("B", oldValue);
+  @Test
-        assertEquals("Z", list.get(1));
+  public void shouldTestGet() {
-        assertEquals(3, list.size());
+    MyLinkedList<Integer> list = new MyLinkedList<>();
+    list.add(10);
+    assertEquals(10, list.get(0));
+  }
 
-    }
+  @Test
-    @Test
+  public void shouldTestRemove() {
-    void shouldTestSize()
+    MyLinkedList<Integer> list = new MyLinkedList<>();
-    {
+    list.add(10);
-        MyLinkedList<Integer> list = new MyLinkedList<>();
+    list.add(20);
-        list.add(1);
+    list.add(30);
-        list.add(2);
+    list.remove(0);
-        list.add(3);
-        assertEquals(3, list.size());
-    }
-    @Test
-    void shouldTestisEmpty()
-    {
-        MyLinkedList<Integer> list = new MyLinkedList<>();
-        assertTrue(list.isEmpty());
-    }
-    @Test
-    void shouldTestGet_OutOfBounds_ThrowsException() {
-        MyLinkedList<Integer> list = new MyLinkedList<>();
-        list.add(1);
 
-        assertThrows(IllegalArgumentException.class, () -> list.get(-1));
+    assertEquals(2, list.size());
-        assertThrows(IllegalArgumentException.class, () -> list.get(1));   // index == size
+    assertEquals(20, list.get(0));
-        assertThrows(IllegalArgumentException.class, () -> list.get(5));   // index > size
+    assertEquals(30, list.get(1));
-    }
+  }
-    @Test
-    void shouldTestSet_OutOfBounds_ThrowsException() {
-        MyLinkedList<Integer> list = new MyLinkedList<>();
-        list.add(1);
 
-        assertThrows(IllegalArgumentException.class, () -> list.set(-1, 99));
+  @Test
-        assertThrows(IllegalArgumentException.class, () -> list.set(1, 99));
+  void shouldTestSet() {
-    }
+    MyLinkedList<String> list = new MyLinkedList<>();
-    @Test
+    list.add("A");
-    void shouldTestRemove_IndexGreaterThanSize_ThrowsException() {
+    list.add("B");
-        MyLinkedList<String> list = new MyLinkedList<>();
+    list.add("C");
-        list.add("man");
-        assertThrows(IndexOutOfBoundsException.class, () -> list.remove(5));
-    }
-    @Test
-    void shouldTestRemove_NegativeIndex_ThrowsException() {
-        MyLinkedList<String> list = new MyLinkedList<>();
-        list.add("1");
-        list.add("2");
 
-        assertThrows(IndexOutOfBoundsException.class, () -> list.remove(-1));
+    String oldValue = list.set(1, "Z");
-    }
-    @Test
-    void shouldTestaddAll_nonEmptySource_toEmptyList_addsAllElementsInOrder() {
-        MyList<String> list = new MyLinkedList<>();
-        MyList<String> source = new MyLinkedList<>();
-        source.add("A");
-        source.add("B");
-        source.add("C");
 
-        list.addAll(source);
+    assertEquals("B", oldValue);
+    assertEquals("Z", list.get(1));
+    assertEquals(3, list.size());
+  }
 
-        assertEquals(3, list.size());
+  @Test
-        assertEquals("A", list.get(0));
+  void shouldTestSize() {
-        assertEquals("B", list.get(1));
+    MyLinkedList<Integer> list = new MyLinkedList<>();
-        assertEquals("C", list.get(2));
+    list.add(1);
-    }
+    list.add(2);
+    list.add(3);
+    assertEquals(3, list.size());
+  }
 
-    @Test
+  @Test
-    void shouldTestaddAll_toNonEmptyList_appendsAtEnd() {
+  void shouldTestisEmpty() {
-        MyList<String> list = new MyLinkedList<>();
+    MyLinkedList<Integer> list = new MyLinkedList<>();
-        list.add("X");
+    assertTrue(list.isEmpty());
-        list.add("Y");
+  }
 
-        MyList<String> source = new MyLinkedList<>();
+  @Test
-        source.add("A");
+  void shouldTestGet_OutOfBounds_ThrowsException() {
-        source.add("B");
+    MyLinkedList<Integer> list = new MyLinkedList<>();
+    list.add(1);
 
-        list.addAll(source);
+    assertThrows(IllegalArgumentException.class, () -> list.get(-1));
+    assertThrows(IllegalArgumentException.class, () -> list.get(1)); // index == size
+    assertThrows(IllegalArgumentException.class, () -> list.get(5)); // index > size
+  }
 
-        assertEquals(4, list.size());
+  @Test
-        assertEquals("X", list.get(0));
+  void shouldTestSet_OutOfBounds_ThrowsException() {
-        assertEquals("Y", list.get(1));
+    MyLinkedList<Integer> list = new MyLinkedList<>();
-        assertEquals("A", list.get(2));
+    list.add(1);
-        assertEquals("B", list.get(3));
+
-    }
+    assertThrows(IllegalArgumentException.class, () -> list.set(-1, 99));
+    assertThrows(IllegalArgumentException.class, () -> list.set(1, 99));
+  }
+
+  @Test
+  void shouldTestRemove_IndexGreaterThanSize_ThrowsException() {
+    MyLinkedList<String> list = new MyLinkedList<>();
+    list.add("man");
+    assertThrows(IndexOutOfBoundsException.class, () -> list.remove(5));
+  }
+
+  @Test
+  void shouldTestRemove_NegativeIndex_ThrowsException() {
+    MyLinkedList<String> list = new MyLinkedList<>();
+    list.add("1");
+    list.add("2");
+
+    assertThrows(IndexOutOfBoundsException.class, () -> list.remove(-1));
+  }
+
+  @Test
+  void shouldTestaddAll_nonEmptySource_toEmptyList_addsAllElementsInOrder() {
+    MyList<String> list = new MyLinkedList<>();
+    MyList<String> source = new MyLinkedList<>();
+    source.add("A");
+    source.add("B");
+    source.add("C");
+
+    list.addAll(source);
+
+    assertEquals(3, list.size());
+    assertEquals("A", list.get(0));
+    assertEquals("B", list.get(1));
+    assertEquals("C", list.get(2));
+  }
+
+  @Test
+  void shouldTestaddAll_toNonEmptyList_appendsAtEnd() {
+    MyList<String> list = new MyLinkedList<>();
+    list.add("X");
+    list.add("Y");
+
+    MyList<String> source = new MyLinkedList<>();
+    source.add("A");
+    source.add("B");
+
+    list.addAll(source);
+
+    assertEquals(4, list.size());
+    assertEquals("X", list.get(0));
+    assertEquals("Y", list.get(1));
+    assertEquals("A", list.get(2));
+    assertEquals("B", list.get(3));
+  }
 }

app/src/test/java/ru/project/collectors/MyListCollectorTest.java

@@ -1,64 +1,58 @@
-package ru.test.maven.spring;
+package ru.project.collectors;
-import org.junit.jupiter.api.Test;
+
 import static org.junit.jupiter.api.Assertions.*;
+
 import java.util.Set;
 import java.util.stream.Collector;
 import java.util.stream.IntStream;
-import java.util.Collections;
+import org.junit.jupiter.api.Test;
+import ru.project.collection.MyList;
 
-public class MyListCollectorTest
+public class MyListCollectorTest {
-{
+  private final MyListCollector<Integer> collector = new MyListCollector<>();
-    private final MyListCollector<Integer> collector = new MyListCollector<>();
 
-    @Test
+  @Test
-    void shouldTestCollectInOrderSequential() {
+  void shouldTestCollectInOrderSequential() {
-        MyList<Integer> result = IntStream.range(0, 10)
+    MyList<Integer> result = IntStream.range(0, 10).boxed().collect(MyCollectors.toMyList());
-                .boxed()
-                .collect(MyCollectors.toMyList());
-
-        assertEquals(10, result.size());
-        for (int i = 0; i < result.size(); i++) {
-            assertEquals(i, (int) result.get(i));
-        }
 
+    assertEquals(10, result.size());
+    for (int i = 0; i < result.size(); i++) {
+      assertEquals(i, (int) result.get(i));
     }
+  }
 
-    @Test
+  @Test
-    void shouldTestCollectInOrderParallel() {
+  void shouldTestCollectInOrderParallel() {
-        MyList<Integer> result = IntStream.range(0, 100)
+    MyList<Integer> result =
-                .parallel()
+        IntStream.range(0, 100).parallel().boxed().collect(MyCollectors.toMyList());
-                .boxed()
-                .collect(MyCollectors.toMyList());
 
-        assertEquals(100, result.size());
+    assertEquals(100, result.size());
-        for (int i = 0; i < result.size(); i++) {
+    for (int i = 0; i < result.size(); i++) {
-            assertEquals(i, (int) result.get(i));
+      assertEquals(i, (int) result.get(i));
-        }
     }
+  }
 
-    @Test
+  @Test
-    void shouldTestHandleEmptyStream() {
+  void shouldTestHandleEmptyStream() {
-        MyList<Integer> result = IntStream.empty()
+    MyList<Integer> result = IntStream.empty().boxed().collect(MyCollectors.toMyList());
-                .boxed()
-                .collect(MyCollectors.toMyList());
 
-        assertTrue(result.isEmpty());
+    assertTrue(result.isEmpty());
+  }
 
-    }
+  @Test
-    @Test
+  void shouldTestNotUseStandardList() {
-    void shouldTestNotUseStandardList() {
+    MyList<String> result =
-        MyList<String> result = IntStream.range(0, 5)
+        IntStream.range(0, 5).mapToObj(i -> "item" + i).collect(MyCollectors.toMyList());
-                .mapToObj(i -> "item" + i)
-                .collect(MyCollectors.toMyList());
 
-        assertInstanceOf(MyList.class, result);
+    assertInstanceOf(MyList.class, result);
-        assertFalse(result instanceof java.util.List);
+    assertFalse(result instanceof java.util.List);
-    }
+  }
-    @Test
-    void shouldTestHaveCorrectCharacteristics() {
-        Set<Collector.Characteristics> characteristics = collector.characteristics();
-        assertTrue(characteristics.contains(java.util.stream.Collector.Characteristics.IDENTITY_FINISH));
-        assertFalse(characteristics.contains(java.util.stream.Collector.Characteristics.UNORDERED));
-    }
 
+  @Test
+  void shouldTestHaveCorrectCharacteristics() {
+    Set<Collector.Characteristics> characteristics = collector.characteristics();
+    assertTrue(
+        characteristics.contains(java.util.stream.Collector.Characteristics.IDENTITY_FINISH));
+    assertFalse(characteristics.contains(java.util.stream.Collector.Characteristics.UNORDERED));
+  }
 }

app/src/test/java/ru/project/finder/StudentOccurrenceIndexFinderTest.java

@@ -3,6 +3,10 @@ package ru.project.finder;
 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;
+
 import static org.junit.jupiter.api.Assertions.*;
 
 public class StudentOccurrenceIndexFinderTest

app/src/test/java/ru/project/search/StudentSearchTest.java

@@ -1,314 +1,317 @@
 package ru.project.search;
 
-import org.junit.jupiter.api.Test;
-import ru.project.list.MyList;
-import ru.project.list.MyLinkedList;
-import ru.project.student.Student;
-
 import static org.junit.jupiter.api.Assertions.*;
 
+import org.junit.jupiter.api.Test;
+import ru.project.collection.MyLinkedList;
+import ru.project.collection.MyList;
+import ru.project.student.Student;
+
 class StudentSearchTest {
 
-    @Test
+  @Test
-    void testGroupNumberRangeMatchesInside() {
+  void testGroupNumberRangeMatchesInside() {
-        StudentSearchCriteria criteria = new GroupNumberRangeCriteria("A10", "C30");
+    StudentSearchCriteria criteria = new GroupNumberRangeCriteria("A10", "C30");
-        Student student = new Student("B20", 4.5, 123);
+    Student student = new Student("B20", 4.5, 123);
-        assertTrue(criteria.matches(student));
+    assertTrue(criteria.matches(student));
+  }
+
+  @Test
+  void testGroupNumberRangeMatchesLowerBoundary() {
+    StudentSearchCriteria criteria = new GroupNumberRangeCriteria("A10", "C30");
+    Student student = new Student("A10", 4.5, 123);
+    assertTrue(criteria.matches(student));
+  }
+
+  @Test
+  void testGroupNumberRangeMatchesUpperBoundary() {
+    StudentSearchCriteria criteria = new GroupNumberRangeCriteria("A10", "C30");
+    Student student = new Student("C30", 4.5, 123);
+    assertTrue(criteria.matches(student));
+  }
+
+  @Test
+  void testGroupNumberRangeDoesNotMatchOutside() {
+    StudentSearchCriteria criteria = new GroupNumberRangeCriteria("A10", "C30");
+    Student student = new Student("D00", 4.5, 123);
+    assertFalse(criteria.matches(student));
+  }
+
+  @Test
+  void testGroupNumberRangeInvalidMinMaxThrowsException() {
+    assertThrows(IllegalArgumentException.class, () -> new GroupNumberRangeCriteria("C30", "A10"));
+  }
+
+  @Test
+  void testGroupNumberRangeNullValuesThrowsException() {
+    assertThrows(IllegalArgumentException.class, () -> new GroupNumberRangeCriteria(null, "A10"));
+    assertThrows(IllegalArgumentException.class, () -> new GroupNumberRangeCriteria("A10", null));
+  }
+
+  @Test
+  void testAverageGradeRangeMatchesInside() {
+    StudentSearchCriteria criteria = new AverageGradeRangeCriteria(4.0, 5.0);
+    Student student = new Student("A12", 4.5, 123);
+    assertTrue(criteria.matches(student));
+  }
+
+  @Test
+  void testAverageGradeRangeMatchesLowerBoundary() {
+    StudentSearchCriteria criteria = new AverageGradeRangeCriteria(4.0, 5.0);
+    Student student = new Student("A12", 4.0, 123);
+    assertTrue(criteria.matches(student));
+  }
+
+  @Test
+  void testAverageGradeRangeMatchesUpperBoundary() {
+    StudentSearchCriteria criteria = new AverageGradeRangeCriteria(4.0, 5.0);
+    Student student = new Student("A12", 5.0, 123);
+    assertTrue(criteria.matches(student));
+  }
+
+  @Test
+  void testAverageGradeRangeDoesNotMatchBelow() {
+    StudentSearchCriteria criteria = new AverageGradeRangeCriteria(4.0, 5.0);
+    Student student = new Student("A12", 3.9, 123);
+    assertFalse(criteria.matches(student));
+  }
+
+  @Test
+  void testAverageGradeRangeDoesNotMatchAbove() {
+    StudentSearchCriteria criteria = new AverageGradeRangeCriteria(4.0, 5.0);
+    Student student = new Student("A12", 5.1, 123);
+    assertFalse(criteria.matches(student));
+  }
+
+  @Test
+  void testAverageGradeRangeInvalidMinMaxThrowsException() {
+    assertThrows(IllegalArgumentException.class, () -> new AverageGradeRangeCriteria(5.0, 4.0));
+  }
+
+  @Test
+  void testRecordBookNumberRangeMatchesInside() {
+    StudentSearchCriteria criteria = new RecordBookNumberRangeCriteria(100, 200);
+    Student student = new Student("A12", 4.5, 150);
+    assertTrue(criteria.matches(student));
+  }
+
+  @Test
+  void testRecordBookNumberRangeMatchesLowerBoundary() {
+    StudentSearchCriteria criteria = new RecordBookNumberRangeCriteria(100, 200);
+    Student student = new Student("A12", 4.5, 100);
+    assertTrue(criteria.matches(student));
+  }
+
+  @Test
+  void testRecordBookNumberRangeMatchesUpperBoundary() {
+    StudentSearchCriteria criteria = new RecordBookNumberRangeCriteria(100, 200);
+    Student student = new Student("A12", 4.5, 200);
+    assertTrue(criteria.matches(student));
+  }
+
+  @Test
+  void testRecordBookNumberRangeDoesNotMatchBelow() {
+    StudentSearchCriteria criteria = new RecordBookNumberRangeCriteria(100, 200);
+    Student student = new Student("A12", 4.5, 99);
+    assertFalse(criteria.matches(student));
+  }
+
+  @Test
+  void testRecordBookNumberRangeDoesNotMatchAbove() {
+    StudentSearchCriteria criteria = new RecordBookNumberRangeCriteria(100, 200);
+    Student student = new Student("A12", 4.5, 201);
+    assertFalse(criteria.matches(student));
+  }
+
+  @Test
+  void testRecordBookNumberRangeInvalidMinMaxThrowsException() {
+    assertThrows(IllegalArgumentException.class, () -> new RecordBookNumberRangeCriteria(200, 100));
+  }
+
+  @Test
+  void testCompositeIntersectionEmptyReturnsTrue() {
+    CompositeStudentSearchCriteria composite =
+        new CompositeStudentSearchCriteria(SearchOperation.INTERSECTION);
+    Student student = new Student("A12", 4.5, 123);
+    assertTrue(composite.matches(student));
+  }
+
+  @Test
+  void testCompositeUnionEmptyReturnsFalse() {
+    CompositeStudentSearchCriteria composite =
+        new CompositeStudentSearchCriteria(SearchOperation.UNION);
+    Student student = new Student("A12", 4.5, 123);
+    assertFalse(composite.matches(student));
+  }
+
+  @Test
+  void testCompositeIntersectionAllTrue() {
+    CompositeStudentSearchCriteria composite =
+        new CompositeStudentSearchCriteria(SearchOperation.INTERSECTION);
+    composite.add(new GroupNumberRangeCriteria("A10", "C30"));
+    composite.add(new AverageGradeRangeCriteria(4.0, 5.0));
+    Student student = new Student("B20", 4.5, 123);
+    assertTrue(composite.matches(student));
+  }
+
+  @Test
+  void testCompositeIntersectionOneFalse() {
+    CompositeStudentSearchCriteria composite =
+        new CompositeStudentSearchCriteria(SearchOperation.INTERSECTION);
+    composite.add(new GroupNumberRangeCriteria("A10", "C30"));
+    composite.add(new AverageGradeRangeCriteria(4.0, 5.0));
+    Student student = new Student("B20", 3.5, 123);
+    assertFalse(composite.matches(student));
+  }
+
+  @Test
+  void testCompositeUnionOneTrue() {
+    CompositeStudentSearchCriteria composite =
+        new CompositeStudentSearchCriteria(SearchOperation.UNION);
+    composite.add(new GroupNumberRangeCriteria("A10", "C30"));
+    composite.add(new AverageGradeRangeCriteria(4.0, 5.0));
+    Student student = new Student("D00", 4.5, 123);
+    assertTrue(composite.matches(student));
+  }
+
+  @Test
+  void testCompositeUnionAllFalse() {
+    CompositeStudentSearchCriteria composite =
+        new CompositeStudentSearchCriteria(SearchOperation.UNION);
+    composite.add(new GroupNumberRangeCriteria("A10", "C30"));
+    composite.add(new AverageGradeRangeCriteria(4.0, 5.0));
+    Student student = new Student("D00", 3.5, 123);
+    assertFalse(composite.matches(student));
+  }
+
+  @Test
+  void testCompositeWithNestedComposite() {
+    CompositeStudentSearchCriteria outer =
+        new CompositeStudentSearchCriteria(SearchOperation.INTERSECTION);
+    outer.add(new GroupNumberRangeCriteria("A10", "C30"));
+
+    CompositeStudentSearchCriteria inner =
+        new CompositeStudentSearchCriteria(SearchOperation.UNION);
+    inner.add(new AverageGradeRangeCriteria(4.0, 5.0));
+    inner.add(new RecordBookNumberRangeCriteria(100, 200));
+
+    outer.add(inner);
+
+    Student student = new Student("B20", 4.5, 150);
+    assertTrue(outer.matches(student));
+    student = new Student("B20", 3.5, 150);
+    assertFalse(outer.matches(student));
+    student = new Student("D00", 4.5, 150);
+    assertFalse(outer.matches(student));
+  }
+
+  @Test
+  void testSearchServiceWithSingleCriteria() {
+    MyList<Student> students = new MyLinkedList<>();
+    students.add(new Student("A10", 4.5, 1));
+    students.add(new Student("B20", 3.8, 2));
+    students.add(new Student("C30", 4.9, 3));
+
+    StudentSearchCriteria criteria = new AverageGradeRangeCriteria(4.0, 5.0);
+    StudentSearchService service = new StudentSearchService(criteria);
+    MyList<Student> result = service.find(students);
+
+    assertEquals(2, result.size());
+    assertEquals("A10", result.get(0).getGroupNumber());
+    assertEquals("C30", result.get(1).getGroupNumber());
+  }
+
+  @Test
+  void testSearchServiceEmptyResult() {
+    MyList<Student> students = new MyLinkedList<>();
+    students.add(new Student("A10", 3.5, 1));
+    students.add(new Student("B20", 3.8, 2));
+
+    StudentSearchCriteria criteria = new AverageGradeRangeCriteria(4.0, 5.0);
+    StudentSearchService service = new StudentSearchService(criteria);
+    MyList<Student> result = service.find(students);
+
+    assertEquals(0, result.size());
+  }
+
+  @Test
+  void testSearchServiceEmptyCollection() {
+    MyList<Student> students = new MyLinkedList<>();
+    StudentSearchCriteria criteria = new AverageGradeRangeCriteria(4.0, 5.0);
+    StudentSearchService service = new StudentSearchService(criteria);
+    MyList<Student> result = service.find(students);
+    assertEquals(0, result.size());
+  }
+
+  @Test
+  void testSearchServicePreservesOrder() {
+    MyList<Student> students = new MyLinkedList<>();
+    students.add(new Student("Z00", 4.5, 1));
+    students.add(new Student("A10", 4.5, 2));
+    students.add(new Student("M30", 4.5, 3));
+
+    StudentSearchCriteria criteria = new AverageGradeRangeCriteria(4.0, 5.0);
+    StudentSearchService service = new StudentSearchService(criteria);
+    MyList<Student> result = service.find(students);
+
+    assertEquals(3, result.size());
+    assertEquals("Z00", result.get(0).getGroupNumber());
+    assertEquals("A10", result.get(1).getGroupNumber());
+    assertEquals("M30", result.get(2).getGroupNumber());
+  }
+
+  @Test
+  void testSearchServiceDoesNotModifyOriginal() {
+    MyList<Student> original = new MyLinkedList<>();
+    original.add(new Student("A10", 4.5, 1));
+    original.add(new Student("B20", 3.8, 2));
+
+    MyList<Student> copy = new MyLinkedList<>();
+    for (int i = 0; i < original.size(); i++) {
+      copy.add(original.get(i));
     }
 
-    @Test
+    StudentSearchCriteria criteria = new AverageGradeRangeCriteria(4.0, 5.0);
-    void testGroupNumberRangeMatchesLowerBoundary() {
+    StudentSearchService service = new StudentSearchService(criteria);
-        StudentSearchCriteria criteria = new GroupNumberRangeCriteria("A10", "C30");
+    service.find(original);
-        Student student = new Student("A10", 4.5, 123);
+
-        assertTrue(criteria.matches(student));
+    assertEquals(copy.size(), original.size());
+    for (int i = 0; i < copy.size(); i++) {
+      assertEquals(copy.get(i).getGroupNumber(), original.get(i).getGroupNumber());
     }
+  }
 
-    @Test
+  @Test
-    void testGroupNumberRangeMatchesUpperBoundary() {
+  void testSearchServiceWithNullCriteriaThrowsException() {
-        StudentSearchCriteria criteria = new GroupNumberRangeCriteria("A10", "C30");
+    assertThrows(IllegalArgumentException.class, () -> new StudentSearchService(null));
-        Student student = new Student("C30", 4.5, 123);
+  }
-        assertTrue(criteria.matches(student));
-    }
 
-    @Test
+  @Test
-    void testGroupNumberRangeDoesNotMatchOutside() {
+  void testSearchServiceWithCompositeCriteria() {
-        StudentSearchCriteria criteria = new GroupNumberRangeCriteria("A10", "C30");
+    MyList<Student> students = new MyLinkedList<>();
-        Student student = new Student("D00", 4.5, 123);
+    students.add(new Student("A10", 4.5, 1));
-        assertFalse(criteria.matches(student));
+    students.add(new Student("B20", 4.5, 2));
-    }
+    students.add(new Student("C30", 3.5, 3));
 
-    @Test
+    CompositeStudentSearchCriteria composite =
-    void testGroupNumberRangeInvalidMinMaxThrowsException() {
+        new CompositeStudentSearchCriteria(SearchOperation.INTERSECTION);
-        assertThrows(IllegalArgumentException.class,
+    composite.add(new GroupNumberRangeCriteria("A10", "B20"));
-                () -> new GroupNumberRangeCriteria("C30", "A10"));
+    composite.add(new AverageGradeRangeCriteria(4.0, 5.0));
-    }
 
-    @Test
+    StudentSearchService service = new StudentSearchService(composite);
-    void testGroupNumberRangeNullValuesThrowsException() {
+    MyList<Student> result = service.find(students);
-        assertThrows(IllegalArgumentException.class,
-                () -> new GroupNumberRangeCriteria(null, "A10"));
-        assertThrows(IllegalArgumentException.class,
-                () -> new GroupNumberRangeCriteria("A10", null));
-    }
 
-    @Test
+    assertEquals(2, result.size());
-    void testAverageGradeRangeMatchesInside() {
+    assertEquals("A10", result.get(0).getGroupNumber());
-        StudentSearchCriteria criteria = new AverageGradeRangeCriteria(4.0, 5.0);
+    assertEquals("B20", result.get(1).getGroupNumber());
-        Student student = new Student("A12", 4.5, 123);
+  }
-        assertTrue(criteria.matches(student));
-    }
 
-    @Test
+  @Test
-    void testAverageGradeRangeMatchesLowerBoundary() {
+  void testSearchServiceWithNullStudentListReturnsEmpty() {
-        StudentSearchCriteria criteria = new AverageGradeRangeCriteria(4.0, 5.0);
+    StudentSearchCriteria criteria = new AverageGradeRangeCriteria(4.0, 5.0);
-        Student student = new Student("A12", 4.0, 123);
+    StudentSearchService service = new StudentSearchService(criteria);
-        assertTrue(criteria.matches(student));
+    MyList<Student> result = service.find(null);
-    }
+    assertNotNull(result);
-
+    assertEquals(0, result.size());
-    @Test
+  }
-    void testAverageGradeRangeMatchesUpperBoundary() {
+}
-        StudentSearchCriteria criteria = new AverageGradeRangeCriteria(4.0, 5.0);
-        Student student = new Student("A12", 5.0, 123);
-        assertTrue(criteria.matches(student));
-    }
-
-    @Test
-    void testAverageGradeRangeDoesNotMatchBelow() {
-        StudentSearchCriteria criteria = new AverageGradeRangeCriteria(4.0, 5.0);
-        Student student = new Student("A12", 3.9, 123);
-        assertFalse(criteria.matches(student));
-    }
-
-    @Test
-    void testAverageGradeRangeDoesNotMatchAbove() {
-        StudentSearchCriteria criteria = new AverageGradeRangeCriteria(4.0, 5.0);
-        Student student = new Student("A12", 5.1, 123);
-        assertFalse(criteria.matches(student));
-    }
-
-    @Test
-    void testAverageGradeRangeInvalidMinMaxThrowsException() {
-        assertThrows(IllegalArgumentException.class,
-                () -> new AverageGradeRangeCriteria(5.0, 4.0));
-    }
-
-    @Test
-    void testRecordBookNumberRangeMatchesInside() {
-        StudentSearchCriteria criteria = new RecordBookNumberRangeCriteria(100, 200);
-        Student student = new Student("A12", 4.5, 150);
-        assertTrue(criteria.matches(student));
-    }
-
-    @Test
-    void testRecordBookNumberRangeMatchesLowerBoundary() {
-        StudentSearchCriteria criteria = new RecordBookNumberRangeCriteria(100, 200);
-        Student student = new Student("A12", 4.5, 100);
-        assertTrue(criteria.matches(student));
-    }
-
-    @Test
-    void testRecordBookNumberRangeMatchesUpperBoundary() {
-        StudentSearchCriteria criteria = new RecordBookNumberRangeCriteria(100, 200);
-        Student student = new Student("A12", 4.5, 200);
-        assertTrue(criteria.matches(student));
-    }
-
-    @Test
-    void testRecordBookNumberRangeDoesNotMatchBelow() {
-        StudentSearchCriteria criteria = new RecordBookNumberRangeCriteria(100, 200);
-        Student student = new Student("A12", 4.5, 99);
-        assertFalse(criteria.matches(student));
-    }
-
-    @Test
-    void testRecordBookNumberRangeDoesNotMatchAbove() {
-        StudentSearchCriteria criteria = new RecordBookNumberRangeCriteria(100, 200);
-        Student student = new Student("A12", 4.5, 201);
-        assertFalse(criteria.matches(student));
-    }
-
-    @Test
-    void testRecordBookNumberRangeInvalidMinMaxThrowsException() {
-        assertThrows(IllegalArgumentException.class,
-                () -> new RecordBookNumberRangeCriteria(200, 100));
-    }
-
-    @Test
-    void testCompositeIntersectionEmptyReturnsTrue() {
-        CompositeStudentSearchCriteria composite = new CompositeStudentSearchCriteria(SearchOperation.INTERSECTION);
-        Student student = new Student("A12", 4.5, 123);
-        assertTrue(composite.matches(student));
-    }
-
-    @Test
-    void testCompositeUnionEmptyReturnsFalse() {
-        CompositeStudentSearchCriteria composite = new CompositeStudentSearchCriteria(SearchOperation.UNION);
-        Student student = new Student("A12", 4.5, 123);
-        assertFalse(composite.matches(student));
-    }
-
-    @Test
-    void testCompositeIntersectionAllTrue() {
-        CompositeStudentSearchCriteria composite = new CompositeStudentSearchCriteria(SearchOperation.INTERSECTION);
-        composite.add(new GroupNumberRangeCriteria("A10", "C30"));
-        composite.add(new AverageGradeRangeCriteria(4.0, 5.0));
-        Student student = new Student("B20", 4.5, 123);
-        assertTrue(composite.matches(student));
-    }
-
-    @Test
-    void testCompositeIntersectionOneFalse() {
-        CompositeStudentSearchCriteria composite = new CompositeStudentSearchCriteria(SearchOperation.INTERSECTION);
-        composite.add(new GroupNumberRangeCriteria("A10", "C30"));
-        composite.add(new AverageGradeRangeCriteria(4.0, 5.0));
-        Student student = new Student("B20", 3.5, 123);
-        assertFalse(composite.matches(student));
-    }
-
-    @Test
-    void testCompositeUnionOneTrue() {
-        CompositeStudentSearchCriteria composite = new CompositeStudentSearchCriteria(SearchOperation.UNION);
-        composite.add(new GroupNumberRangeCriteria("A10", "C30"));
-        composite.add(new AverageGradeRangeCriteria(4.0, 5.0));
-        Student student = new Student("D00", 4.5, 123);
-        assertTrue(composite.matches(student));
-    }
-
-    @Test
-    void testCompositeUnionAllFalse() {
-        CompositeStudentSearchCriteria composite = new CompositeStudentSearchCriteria(SearchOperation.UNION);
-        composite.add(new GroupNumberRangeCriteria("A10", "C30"));
-        composite.add(new AverageGradeRangeCriteria(4.0, 5.0));
-        Student student = new Student("D00", 3.5, 123);
-        assertFalse(composite.matches(student));
-    }
-
-    @Test
-    void testCompositeWithNestedComposite() {
-        CompositeStudentSearchCriteria outer = new CompositeStudentSearchCriteria(SearchOperation.INTERSECTION);
-        outer.add(new GroupNumberRangeCriteria("A10", "C30"));
-
-        CompositeStudentSearchCriteria inner = new CompositeStudentSearchCriteria(SearchOperation.UNION);
-        inner.add(new AverageGradeRangeCriteria(4.0, 5.0));
-        inner.add(new RecordBookNumberRangeCriteria(100, 200));
-
-        outer.add(inner);
-
-        Student student = new Student("B20", 4.5, 150);
-        assertTrue(outer.matches(student));
-        student = new Student("B20", 3.5, 150);
-        assertFalse(outer.matches(student));
-        student = new Student("D00", 4.5, 150);
-        assertFalse(outer.matches(student));
-    }
-
-    @Test
-    void testSearchServiceWithSingleCriteria() {
-        MyList<Student> students = new MyLinkedList<>();
-        students.add(new Student("A10", 4.5, 1));
-        students.add(new Student("B20", 3.8, 2));
-        students.add(new Student("C30", 4.9, 3));
-
-        StudentSearchCriteria criteria = new AverageGradeRangeCriteria(4.0, 5.0);
-        StudentSearchService service = new StudentSearchService(criteria);
-        MyList<Student> result = service.find(students);
-
-        assertEquals(2, result.size());
-        assertEquals("A10", result.get(0).getGroupNumber());
-        assertEquals("C30", result.get(1).getGroupNumber());
-    }
-
-    @Test
-    void testSearchServiceEmptyResult() {
-        MyList<Student> students = new MyLinkedList<>();
-        students.add(new Student("A10", 3.5, 1));
-        students.add(new Student("B20", 3.8, 2));
-
-        StudentSearchCriteria criteria = new AverageGradeRangeCriteria(4.0, 5.0);
-        StudentSearchService service = new StudentSearchService(criteria);
-        MyList<Student> result = service.find(students);
-
-        assertEquals(0, result.size());
-    }
-
-    @Test
-    void testSearchServiceEmptyCollection() {
-        MyList<Student> students = new MyLinkedList<>();
-        StudentSearchCriteria criteria = new AverageGradeRangeCriteria(4.0, 5.0);
-        StudentSearchService service = new StudentSearchService(criteria);
-        MyList<Student> result = service.find(students);
-        assertEquals(0, result.size());
-    }
-
-    @Test
-    void testSearchServicePreservesOrder() {
-        MyList<Student> students = new MyLinkedList<>();
-        students.add(new Student("Z00", 4.5, 1));
-        students.add(new Student("A10", 4.5, 2));
-        students.add(new Student("M30", 4.5, 3));
-
-        StudentSearchCriteria criteria = new AverageGradeRangeCriteria(4.0, 5.0);
-        StudentSearchService service = new StudentSearchService(criteria);
-        MyList<Student> result = service.find(students);
-
-        assertEquals(3, result.size());
-        assertEquals("Z00", result.get(0).getGroupNumber());
-        assertEquals("A10", result.get(1).getGroupNumber());
-        assertEquals("M30", result.get(2).getGroupNumber());
-    }
-
-    @Test
-    void testSearchServiceDoesNotModifyOriginal() {
-        MyList<Student> original = new MyLinkedList<>();
-        original.add(new Student("A10", 4.5, 1));
-        original.add(new Student("B20", 3.8, 2));
-
-        MyList<Student> copy = new MyLinkedList<>();
-        for (int i = 0; i < original.size(); i++) {
-            copy.add(original.get(i));
-        }
-
-        StudentSearchCriteria criteria = new AverageGradeRangeCriteria(4.0, 5.0);
-        StudentSearchService service = new StudentSearchService(criteria);
-        service.find(original);
-
-        assertEquals(copy.size(), original.size());
-        for (int i = 0; i < copy.size(); i++) {
-            assertEquals(copy.get(i).getGroupNumber(), original.get(i).getGroupNumber());
-        }
-    }
-
-    @Test
-    void testSearchServiceWithNullCriteriaThrowsException() {
-        assertThrows(IllegalArgumentException.class,
-                () -> new StudentSearchService(null));
-    }
-
-    @Test
-    void testSearchServiceWithCompositeCriteria() {
-        MyList<Student> students = new MyLinkedList<>();
-        students.add(new Student("A10", 4.5, 1));
-        students.add(new Student("B20", 4.5, 2));
-        students.add(new Student("C30", 3.5, 3));
-
-        CompositeStudentSearchCriteria composite = new CompositeStudentSearchCriteria(SearchOperation.INTERSECTION);
-        composite.add(new GroupNumberRangeCriteria("A10", "B20"));
-        composite.add(new AverageGradeRangeCriteria(4.0, 5.0));
-
-        StudentSearchService service = new StudentSearchService(composite);
-        MyList<Student> result = service.find(students);
-
-        assertEquals(2, result.size());
-        assertEquals("A10", result.get(0).getGroupNumber());
-        assertEquals("B20", result.get(1).getGroupNumber());
-    }
-
-    @Test
-    void testSearchServiceWithNullStudentListReturnsEmpty() {
-        StudentSearchCriteria criteria = new AverageGradeRangeCriteria(4.0, 5.0);
-        StudentSearchService service = new StudentSearchService(criteria);
-        MyList<Student> result = service.find(null);
-        assertNotNull(result);
-        assertEquals(0, result.size());
-    }
-}