test: reorganize Student tests and fix duplicate test file

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

@@ -55,8 +55,6 @@ public class Student {
         return new Student(this.groupNumber, this.averageGrade, recordBookNumber);
     }
 
-    }
-
     public static double getMaxAverageGrade() {
         return MAX_AVERAGE_GRADE;
     }

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

@@ -1,139 +0,0 @@
-package ru.project.student;
-
-import org.junit.jupiter.api.Test;
-import static org.junit.jupiter.api.Assertions.*;
-
-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 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 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 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 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());
-
-        assertEquals("A12", original.getGroupNumber());
-    }
-
-    @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());
-
-        assertEquals(4.5, original.getAverageGrade());
-    }
-
-    @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());
-
-        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 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 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());
-
-        assertNotEquals(s1, s3);
-        assertNotEquals(s1, s4);
-        assertNotEquals(s1, s5);
-        assertNotEquals(s1, null);
-        assertNotEquals(s1, "some string");
-    }
-}

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

@@ -2,167 +2,144 @@ 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;
 
 
 class StudentTest {
-    @Test
-    void shouldCreateValidStudent() {
-        Student student = new StudentBuilder()
-                .setGroupNumber("101")
-                .setAverageGrade(4.5)
-                .setRecordBookNumber("12345")
-                .build();
 
-        assertEquals("101", student.getGroupNumber());
+    @Test
+    void testValidStudentCreation() {
+        Student student = new Student("A12", 4.5, 12345);
+        assertEquals("A12", student.getGroupNumber());
         assertEquals(4.5, student.getAverageGrade());
-        assertEquals("12345", student.getRecordBookNumber());
+        assertEquals(12345, student.getRecordBookNumber());
     }
 
     @Test
-    void shouldThrowExceptionWhenGroupNumberIsEmpty() {
+    void testValidGroupNumbers() {
-        assertThrows(IllegalArgumentException.class, () -> {
+        assertDoesNotThrow(() -> new Student("A12", 4.5, 1));
-            new StudentBuilder()
+        assertDoesNotThrow(() -> new Student("B32", 4.5, 1));
-                    .setGroupNumber("")
+        assertDoesNotThrow(() -> new Student("Z00", 4.5, 1));
-                    .setAverageGrade(4.5)
-                    .setRecordBookNumber("12345")
-                    .build();
-        });
     }
 
     @Test
-    void shouldThrowExceptionWhenAverageGradeIsGreaterThanFive() {
+    void testInvalidGroupNumbers() {
-        assertThrows(IllegalArgumentException.class, () -> {
+        assertThrows(IllegalArgumentException.class, () -> new Student("a12", 4.5, 1));
-            new StudentBuilder()
+        assertThrows(IllegalArgumentException.class, () -> new Student("A1", 4.5, 1));
-                    .setGroupNumber("101")
+        assertThrows(IllegalArgumentException.class, () -> new Student("A123", 4.5, 1));
-                    .setAverageGrade(6.0)
+        assertThrows(IllegalArgumentException.class, () -> new Student("AA1", 4.5, 1));
-                    .setRecordBookNumber("12345")
+        assertThrows(IllegalArgumentException.class, () -> new Student("а1А", 4.5, 1));
-                    .build();
+        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 shouldThrowExceptionWhenAverageGradeIsLessThanZero() {
+    void testValidAverageGrades() {
-        assertThrows(IllegalArgumentException.class, () -> {
+        assertDoesNotThrow(() -> new Student("A12", 0.0, 1));
-            new StudentBuilder()
+        assertDoesNotThrow(() -> new Student("A12", 5.0, 1));
-                    .setGroupNumber("101")
-                    .setAverageGrade(-1.0)
-                    .setRecordBookNumber("12345")
-                    .build();
-        });
     }
 
     @Test
-    void shouldCreateStudentWhenAverageGradeIsZero() {
+    void testInvalidAverageGrades() {
-        Student student = new StudentBuilder()
+        assertThrows(IllegalArgumentException.class, () -> new Student("A12", -1.0, 1));
-                .setGroupNumber("101")
+        assertThrows(IllegalArgumentException.class, () -> new Student("A12", 6.0, 1));
-                .setAverageGrade(0.0)
-                .setRecordBookNumber("12345")
-                .build();
-
-        assertEquals(0.0, student.getAverageGrade());
     }
 
     @Test
-    void shouldCreateStudentWhenAverageGradeIsFive() {
+    void testValidRecordBookNumbers() {
-        Student student = new StudentBuilder()
+        assertDoesNotThrow(() -> new Student("A12", 4.5, 1));
-                .setGroupNumber("101")
+        assertDoesNotThrow(() -> new Student("A12", 4.5, 12345));
-                .setAverageGrade(5.0)
-                .setRecordBookNumber("12345")
-                .build();
-
-        assertEquals(5.0, student.getAverageGrade());
     }
 
     @Test
-    void shouldThrowExceptionWhenRecordBookNumberIsEmpty() {
+    void testInvalidRecordBookNumbers() {
-        assertThrows(IllegalArgumentException.class, () -> {
+        assertThrows(IllegalArgumentException.class, () -> new Student("A12", 4.5, 0));
-            new StudentBuilder()
+        assertThrows(IllegalArgumentException.class, () -> new Student("A12", 4.5, -1));
-                    .setGroupNumber("101")
-                    .setAverageGrade(4.5)
-                    .setRecordBookNumber("")
-                    .build();
-        });
     }
 
     @Test
-    void shouldThrowExceptionWhenGroupNumberIsNull() {
+    void testWithGroupNumber() {
-        assertThrows(IllegalArgumentException.class, () -> {
+        Student original = new Student("A12", 4.5, 12345);
-            new StudentBuilder()
+        Student updated = original.withGroupNumber("B32");
-                    .setGroupNumber(null)
+
-                    .setAverageGrade(4.5)
+        assertNotSame(original, updated);
-                    .setRecordBookNumber("12345")
+        assertEquals("B32", updated.getGroupNumber());
-                    .build();
+        assertEquals(4.5, updated.getAverageGrade());
-        });
+        assertEquals(12345, updated.getRecordBookNumber());
+
+        assertEquals("A12", original.getGroupNumber());
     }
 
     @Test
-    void shouldThrowExceptionWhenGroupNumberIsBlank() {
+    void testWithAverageGrade() {
-        assertThrows(IllegalArgumentException.class, () -> {
+        Student original = new Student("A12", 4.5, 12345);
-            new StudentBuilder()
+        Student updated = original.withAverageGrade(4.8);
-                    .setGroupNumber("   ")
+
-                    .setAverageGrade(4.5)
+        assertNotSame(original, updated);
-                    .setRecordBookNumber("12345")
+        assertEquals(4.8, updated.getAverageGrade());
-                    .build();
+        assertEquals("A12", updated.getGroupNumber());
-        });
+        assertEquals(12345, updated.getRecordBookNumber());
+
+        assertEquals(4.5, original.getAverageGrade());
     }
 
     @Test
-    void shouldThrowExceptionWhenRecordBookNumberIsNull() {
+    void testWithRecordBookNumber() {
-        assertThrows(IllegalArgumentException.class, () -> {
+        Student original = new Student("A12", 4.5, 12345);
-            new StudentBuilder()
+        Student updated = original.withRecordBookNumber(99999);
-                    .setGroupNumber("101")
+
-                    .setAverageGrade(4.5)
+        assertNotSame(original, updated);
-                    .setRecordBookNumber(null)
+        assertEquals(99999, updated.getRecordBookNumber());
-                    .build();
+        assertEquals("A12", updated.getGroupNumber());
-        });
+        assertEquals(4.5, updated.getAverageGrade());
+
+        assertEquals(12345, original.getRecordBookNumber());
     }
 
     @Test
-    void shouldThrowExceptionWhenRecordBookNumberIsBlank() {
+    void testWithInvalidGroupNumber() {
-        assertThrows(IllegalArgumentException.class, () -> {
+        Student original = new Student("A12", 4.5, 12345);
-            new StudentBuilder()
+        assertThrows(IllegalArgumentException.class,
-                    .setGroupNumber("101")
+                () -> original.withGroupNumber("a12"));
-                    .setAverageGrade(4.5)
+        assertEquals("A12", original.getGroupNumber()); // не изменился
-                    .setRecordBookNumber("   ")
-                    .build();
-        });
     }
 
     @Test
-    void shouldReturnTrueWhenStudentsAreEqual() {
+    void testWithInvalidAverageGrade() {
-        Student student1 = new StudentBuilder()
+        Student original = new Student("A12", 4.5, 12345);
-                .setGroupNumber("101")
+        assertThrows(IllegalArgumentException.class,
-                .setAverageGrade(4.5)
+                () -> original.withAverageGrade(6.0));
-                .setRecordBookNumber("12345")
+        assertEquals(4.5, original.getAverageGrade());
-                .build();
-
-        Student student2 = new StudentBuilder()
-                .setGroupNumber("101")
-                .setAverageGrade(4.5)
-                .setRecordBookNumber("12345")
-                .build();
-
-        assertEquals(student1, student2);
-        assertEquals(student1.hashCode(), student2.hashCode());
     }
 
     @Test
-    void shouldReturnFalseWhenStudentsAreDifferent() {
+    void testWithInvalidRecordBookNumber() {
-        Student student1 = new StudentBuilder()
+        Student original = new Student("A12", 4.5, 12345);
-                .setGroupNumber("101")
+        assertThrows(IllegalArgumentException.class,
-                .setAverageGrade(4.5)
+                () -> original.withRecordBookNumber(0));
-                .setRecordBookNumber("12345")
+        assertEquals(12345, original.getRecordBookNumber());
-                .build();
+    }
 
-        Student student2 = new StudentBuilder()
+    @Test
-                .setGroupNumber("102")
+    void testEqualsAndHashCode() {
-                .setAverageGrade(4.5)
+        Student s1 = new Student("A12", 4.5, 12345);
-                .setRecordBookNumber("12345")
+        Student s2 = new Student("A12", 4.5, 12345);
-                .build();
+        Student s3 = new Student("B32", 4.5, 12345);
+        Student s4 = new Student("A12", 4.8, 12345);
+        Student s5 = new Student("A12", 4.5, 99999);
 
-        assertNotEquals(student1, student2);
+        assertEquals(s1, s2);
+        assertEquals(s1.hashCode(), s2.hashCode());
+
+        assertNotEquals(s1, s3);
+        assertNotEquals(s1, s4);
+        assertNotEquals(s1, s5);
+        assertNotEquals(s1, null);
+        assertNotEquals(s1, "some string");
     }
 }