Merge pull request into develop from feature/student-search

app/src/main/java/ru/project/finder/StudentOccurrenceIndexFinder.java

@@ -0,0 +1,125 @@
+package ru.project.finder;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+public class StudentOccurrenceIndexFinder
+{
+    public int[] findOccurrences(MyList<Student> students, Student target) {
+        if (students == null) {
+            throw new IllegalArgumentException();
+        }
+        if (target == null) {
+            throw new IllegalArgumentException();
+        }
+        if (students.isEmpty()) {
+            return new int[0];
+        }
+        int size = students.size();
+        int threadCount = calculateThreadCount(size);
+        int chunkSize = countChunkSize(size, threadCount);
+
+        ExecutorService executor = Executors.newFixedThreadPool(threadCount);
+        MyList<Future<MyList<Integer>>> futures = new MyLinkedList<>();
+
+        for (int i = 0; i < threadCount; i++) {
+            int fromIndex = i * chunkSize;
+            int toIndex = Math.min(fromIndex + chunkSize, size);
+
+            if (fromIndex >= toIndex) {
+                break;
+            }
+
+            final int start = fromIndex;
+            final int end = toIndex;
+
+            Future<MyList<Integer>> future = executor.submit(() -> {
+                return findInRange(students, target, start, end);
+            });
+            futures.add(future);
+        }
+        MyList<Integer> allIndices = new MyLinkedList<>();
+        try {
+            for (int i = 0; i < futures.size(); i++) {
+                Future<MyList<Integer>> future = futures.get(i);
+                MyList<Integer> partialResult = future.get();
+
+                if (partialResult != null) {
+                    for (int j = 0; j < partialResult.size(); j++) {
+                        allIndices.add(partialResult.get(j));
+                    }
+                }
+            }
+        } catch (Exception e) {
+            throw new RuntimeException("Ошибка при поиске", e);
+        } finally {
+            executor.shutdown();
+        }
+
+        sortList(allIndices);
+
+        int[] resultArray = new int[allIndices.size()];
+        for (int i = 0; i < allIndices.size(); i++) {
+            resultArray[i] = allIndices.get(i);
+        }
+
+        return resultArray;
+    }
+
+    private void sortList(MyList<Integer> list) {
+        if (list.size() <= 1) return;
+
+        MyList<Integer> sorted = new MyLinkedList<>();
+
+        for (int i = 0; i < list.size(); i++) {
+            int value = list.get(i);
+            int insertIndex = 0;
+            while (insertIndex < sorted.size()) {
+                if (sorted.get(insertIndex) > value) {
+                    break;
+                }
+                insertIndex++;
+            }
+
+            MyList<Integer> temp = new MyLinkedList<>();
+            for (int k = 0; k < insertIndex; k++) {
+                temp.add(sorted.get(k));
+            }
+            temp.add(value);
+            for (int k = insertIndex; k < sorted.size(); k++) {
+                temp.add(sorted.get(k));
+            }
+            sorted = temp;
+        }
+
+        while (!list.isEmpty()) {
+            list.remove(0);
+        }
+
+        for (int i = 0; i < sorted.size(); i++) {
+            list.add(sorted.get(i));
+        }
+    }
+
+    private int calculateThreadCount(int size) {
+        int processors = Runtime.getRuntime().availableProcessors();
+        return Math.min(processors, size);
+    }
+
+    private int countChunkSize(int size, int threadCount) {
+        if (threadCount == 0) return 0;
+        return (size + threadCount - 1) / threadCount;
+    }
+
+    private MyList<Integer> findInRange(MyList<Student> students, Student target, int fromIndex, int toIndex) {
+        MyList<Integer> foundIndices = new MyLinkedList<>();
+
+        for (int i = fromIndex; i < toIndex; i++) {
+            Student current = students.get(i);
+            if (current != null && current.equals(target)) {
+                foundIndices.add(i);
+            }
+        }
+
+        return foundIndices;
+    }
+}

app/src/main/java/ru/project/search/AverageGradeRangeCriteria.java

@@ -0,0 +1,22 @@
+package ru.project.search;
+
+import ru.project.student.Student;
+
+public class AverageGradeRangeCriteria implements StudentSearchCriteria {
+    private final double min;
+    private final double max;
+
+    public AverageGradeRangeCriteria(double min, double max) {
+        if (min > max) {
+            throw new IllegalArgumentException("Min grade must be <= max grade");
+        }
+        this.min = min;
+        this.max = max;
+    }
+
+    @Override
+    public boolean matches(Student student) {
+        double grade = student.getAverageGrade();
+        return grade >= min && grade <= max;
+    }
+}

app/src/main/java/ru/project/search/CompositeStudentSearchCriteria.java

@@ -0,0 +1,51 @@
+package ru.project.search;
+
+import ru.project.student.Student;
+import java.util.ArrayList;
+import java.util.List;
+
+public class CompositeStudentSearchCriteria implements StudentSearchCriteria {
+    private final SearchOperation operation;
+    private final List<StudentSearchCriteria> criteriaList = new ArrayList<>();
+
+    public CompositeStudentSearchCriteria(SearchOperation operation) {
+        if (operation == null) {
+            throw new IllegalArgumentException("Operation must not be null");
+        }
+        this.operation = operation;
+    }
+
+    public void add(StudentSearchCriteria criteria) {
+        if (criteria == null) {
+            throw new IllegalArgumentException("Criteria must not be null");
+        }
+        criteriaList.add(criteria);
+    }
+
+    public void remove(StudentSearchCriteria criteria) {
+        criteriaList.remove(criteria);
+    }
+
+    @Override
+    public boolean matches(Student student) {
+        if (criteriaList.isEmpty()) {
+            return operation == SearchOperation.INTERSECTION;
+        }
+
+        if (operation == SearchOperation.UNION) {
+            for (StudentSearchCriteria c : criteriaList) {
+                if (c.matches(student)) {
+                    return true;
+                }
+            }
+            return false;
+        } else {
+            for (StudentSearchCriteria c : criteriaList) {
+                if (!c.matches(student)) {
+                    return false;
+                }
+            }
+            return true;
+        }
+    }
+}

app/src/main/java/ru/project/search/GroupNumberRangeCriteria.java

@@ -0,0 +1,25 @@
+package ru.project.search;
+
+import ru.project.student.Student;
+
+public class GroupNumberRangeCriteria implements StudentSearchCriteria {
+    private final String min;
+    private final String max;
+
+    public GroupNumberRangeCriteria(String min, String max) {
+        if (min == null || max == null) {
+            throw new IllegalArgumentException("Min and max must not be null");
+        }
+        if (min.compareTo(max) > 0) {
+            throw new IllegalArgumentException("Min group must be <= max group");
+        }
+        this.min = min;
+        this.max = max;
+    }
+
+    @Override
+    public boolean matches(Student student) {
+        String group = student.getGroupNumber();
+        return group.compareTo(min) >= 0 && group.compareTo(max) <= 0;
+    }
+}

app/src/main/java/ru/project/search/RecordBookNumberRangeCriteria.java

@@ -0,0 +1,22 @@
+package ru.project.search;
+
+import ru.project.student.Student;
+
+public class RecordBookNumberRangeCriteria implements StudentSearchCriteria {
+    private final int min;
+    private final int max;
+
+    public RecordBookNumberRangeCriteria(int min, int max) {
+        if (min > max) {
+            throw new IllegalArgumentException("Min record number must be <= max");
+        }
+        this.min = min;
+        this.max = max;
+    }
+
+    @Override
+    public boolean matches(Student student) {
+        int number = student.getRecordBookNumber();
+        return number >= min && number <= max;
+    }
+}

app/src/main/java/ru/project/search/SearchOperation.java

@@ -0,0 +1,6 @@
+package ru.project.search;
+
+public enum SearchOperation {
+    UNION,
+    INTERSECTION
+}

app/src/main/java/ru/project/search/StudentSearchCriteria.java

@@ -0,0 +1,7 @@
+package ru.project.search;
+
+import ru.project.student.Student;
+
+public interface StudentSearchCriteria {
+    boolean matches(Student student);
+}

app/src/main/java/ru/project/search/StudentSearchService.java

@@ -0,0 +1,30 @@
+package ru.project.search;
+
+import ru.project.list.MyList;
+import ru.project.list.MyLinkedList;
+import ru.project.student.Student;
+
+public class StudentSearchService {
+    private final StudentSearchCriteria criteria;
+
+    public StudentSearchService(StudentSearchCriteria criteria) {
+        if (criteria == null) {
+            throw new IllegalArgumentException("Criteria must not be null");
+        }
+        this.criteria = criteria;
+    }
+
+    public MyList<Student> find(MyList<Student> students) {
+        if (students == null) {
+            return new MyLinkedList<>();
+        }
+        MyList<Student> result = new MyLinkedList<>();
+        for (int i = 0; i < students.size(); i++) {
+            Student s = students.get(i);
+            if (criteria.matches(s)) {
+                result.add(s);
+            }
+        }
+        return result;
+    }
+}

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

@@ -0,0 +1,134 @@
+package ru.project.finder;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+public class StudentOccurrenceIndexFinderTest
+{
+    private StudentOccurrenceIndexFinder finder;
+    private MyList<Student> students;
+
+    @BeforeEach
+    void setUp() {
+        finder = new StudentOccurrenceIndexFinder();
+        students = new MyLinkedList<>();
+    }
+
+    @Test
+    void shouldTesfindOccurrences_emptyList_returnsEmptyArray() {
+        int[] result = finder.findOccurrences(students, new Student("A12", 4.5, 1));
+        assertEquals(0, result.length);
+    }
+    @Test
+    void shouldTesfindOccurrences_noMatches_returnsEmptyArray() {
+        students.add(new Student("A12", 4.0, 101));
+        students.add(new Student("B23", 3.5, 102));
+        Student target = new Student("C34", 4.8, 103); // такого нет
+
+        int[] result = finder.findOccurrences(students, target);
+        assertEquals(0, result.length);
+    }
+    @Test
+    void shouldTesfindOccurrences_singleMatch_returnsCorrectIndex() {
+        students.add(new Student("A12", 4.0, 101));
+        students.add(new Student("B23", 3.5, 102)); // target здесь
+        students.add(new Student("C34", 4.8, 103));
+
+        Student target = new Student("B23", 3.5, 102);
+        int[] result = finder.findOccurrences(students, target);
+
+        assertEquals(1, result.length);
+        assertEquals(1, result[0]);
+    }
+    @Test
+    void shouldTesfindOccurrences_multipleMatches_returnsAllIndicesSorted() {
+        // индексы: 0, 2, 4 — должны вернуться в порядке возрастания
+        students.add(new Student("A12", 4.5, 101)); // match
+        students.add(new Student("B23", 3.8, 102));
+        students.add(new Student("A12", 4.5, 101)); // match
+        students.add(new Student("C34", 4.0, 103));
+        students.add(new Student("A12", 4.5, 101)); // match
+
+        Student target = new Student("A12", 4.5, 101);
+        int[] result = finder.findOccurrences(students, target);
+
+        assertEquals(3, result.length);
+        assertArrayEquals(new int[]{0, 2, 4}, result);
+    }
+
+    @Test
+    void shouldTesfindOccurrences_allElementsMatch_returnsAllIndices() {
+        Student s = new Student("X99", 5.0, 999);
+        students.add(s);
+        students.add(s);
+        students.add(s);
+
+        int[] result = finder.findOccurrences(students, s);
+        assertEquals(3, result.length);
+        assertArrayEquals(new int[]{0, 1, 2}, result);
+    }
+
+    @Test
+    void shouldTesfindOccurrences_differentAverageGrade_noMatch() {
+        students.add(new Student("A12", 4.50, 101));
+        Student target = new Student("A12", 4.51, 101); // отличается балл
+
+        int[] result = finder.findOccurrences(students, target);
+        assertEquals(0, result.length);
+    }
+
+    @Test
+    void shouldTesfindOccurrences_differentGroupNumber_noMatch() {
+        students.add(new Student("A12", 4.5, 101));
+        Student target = new Student("B12", 4.5, 101); // другая группа
+
+        int[] result = finder.findOccurrences(students, target);
+        assertEquals(0, result.length);
+    }
+
+    @Test
+    void shouldTesfindOccurrences_differentRecordBookNumber_noMatch() {
+        students.add(new Student("A12", 4.5, 101));
+        Student target = new Student("A12", 4.5, 102); // другой номер зачетки
+
+        int[] result = finder.findOccurrences(students, target);
+        assertEquals(0, result.length);
+    }
+
+
+    @Test
+    void shouldTesfindOccurrences_nullList_throwsException() {
+        Student target = new Student("A12", 4.5, 101);
+        assertThrows(IllegalArgumentException.class, () -> finder.findOccurrences(null, target));
+    }
+
+
+    @Test
+    void shouldTesfindOccurrences_nullTarget_throwsException() {
+        assertThrows(IllegalArgumentException.class, () -> finder.findOccurrences(students, null));
+    }
+    @Test
+    void shouldTesfindOccurrences_resultIsSorted() {
+        String[] validGroups = {"A00", "A01", "B12", "C99", "X55"};
+
+        for (int i = 0; i < 50; i++) {
+            String group = validGroups[i % validGroups.length];
+            double grade = (3.0 + (i % 3)) / 2.0;
+            if (i % 3 == 0) {
+
+                students.add(new Student("A12", 4.5, 101));
+            } else {
+                students.add(new Student(group, grade, 200 + i));
+            }
+        }
+        Student target = new Student("A12", 4.5, 101);
+        int[] result = finder.findOccurrences(students, target);
+
+
+        for (int i = 1; i < result.length; i++) {
+            assertTrue(result[i] > result[i - 1], "Результат должен быть отсортирован");
+        }
+    }
+}

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

@@ -0,0 +1,314 @@
+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.*;
+
+class StudentSearchTest {
+
+    @Test
+    void testGroupNumberRangeMatchesInside() {
+        StudentSearchCriteria criteria = new GroupNumberRangeCriteria("A10", "C30");
+        Student student = new Student("B20", 4.5, 123);
+        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));
+        }
+
+        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());
+    }
+}