Your line manager has instructed you to write unit tests to determine the code coverage in the student management application. You are required to create a test package within the application you created in Section A, which will contain the required unit tests.
You are required to write the following unit tests:
TestSaveStudent(): To supply the student ID, name, age, email, and course to the save student method. The test will determine whether the correct student will be saved to memory.
TestSearchStudent (): To supply the student id to the search student method. The test will determine that the correct student details have been returned.
TestSearchStudent_StudentNotFound(): To supply an incorrect student ID to the search student method. The test will determine that no student was found.
TestDeleteStudent(): supply the student ID to the delete student method. The test will determine that the student has been successfully deleted.
TestDeleteStudent_StudentNotFound(): To supply an incorrect student ID to the delete student method. The test will determine that no student could be found to delete.
TestStudentAge_StudentAgeValid():To supply a valid student age to the student age method. The test will determine that the student’s age is valid.
TestStudentAge_StudentAgeInvalid():To supply an invalid student age to the student age method. The test will determine that the student’s age is less than 16.
TestStudentAge_StudentAgeInvalidCharacter():To supply an invalid character to the student age method. The test will determine that the student age supplied is not a number.
In java
, the unit tests can be written using a testing framework such as JUnit. Here's an example of how the tests can be written:
```java
import org.junit.Test;
import static org.junit.Assert.*;
public class StudentManagementApplicationTest {
@Test
public void testSaveStudent() {
// Create an instance of the application
StudentManagementApplication application = new StudentManagementApplication();
// Create a student with test data
Student student = new Student("123", "John Doe", 20, "johndoe", "Computer Science");
// Save the student
application.saveStudent(student);
// Retrieve the saved student
Student savedStudent = application.searchStudent("123");
// Assert that the saved student matches the input student
assertEquals(student, savedStudent);
}
@Test
public void testSearchStudent() {
// Create an instance of the application
StudentManagementApplication application = new StudentManagementApplication();
// Create a student with test data
Student student = new Student("123", "John Doe", 20, "johndoe", "Computer Science");
// Save the student
application.saveStudent(student);
// Search for the student
Student searchedStudent = application.searchStudent("123");
// Assert that the searched student matches the input student
assertEquals(student, searchedStudent);
}
@Test
public void testSearchStudent_StudentNotFound() {
// Create an instance of the application
StudentManagementApplication application = new StudentManagementApplication();
// Search for a student with an invalid ID
Student searchedStudent = application.searchStudent("456");
// Assert that no student is found
assertNull(searchedStudent);
}
@Test
public void testDeleteStudent() {
// Create an instance of the application
StudentManagementApplication application = new StudentManagementApplication();
// Create a student with test data
Student student = new Student("123", "John Doe", 20, "johndoe", "Computer Science");
// Save the student
application.saveStudent(student);
// Delete the student
application.deleteStudent("123");
// Search for the deleted student
Student searchedStudent = application.searchStudent("123");
// Assert that no student is found
assertNull(searchedStudent);
}
@Test
public void testDeleteStudent_StudentNotFound() {
// Create an instance of the application
StudentManagementApplication application = new StudentManagementApplication();
// Delete a student with an invalid ID
application.deleteStudent("456");
// No assertion needed as the method should not throw an exception
}
@Test
public void testStudentAge_StudentAgeValid() {
// Create an instance of the application
StudentManagementApplication application = new StudentManagementApplication();
// Create a student with test data
Student student = new Student("123", "John Doe", 20, "johndoe", "Computer Science");
// Save the student
application.saveStudent(student);
// Check the student's age
boolean isValidAge = application.isStudentAgeValid("123");
// Assert that the student's age is valid
assertTrue(isValidAge);
}
@Test
public void testStudentAge_StudentAgeInvalid() {
// Create an instance of the application
StudentManagementApplication application = new StudentManagementApplication();
// Create a student with test data
Student student = new Student("123", "John Doe", 15, "johndoe", "Computer Science");
// Save the student
application.saveStudent(student);
// Check the student's age
boolean isValidAge = application.isStudentAgeValid("123");
// Assert that the student's age is invalid
assertFalse(isValidAge);
}
@Test
public void testStudentAge_StudentAgeInvalidCharacter() {
// Create an instance of the application
StudentManagementApplication application = new StudentManagementApplication();
// Check the age of a student with an invalid ID
boolean isValidAge = application.isStudentAgeValid("456");
// Assert that the student's age is invalid
assertFalse(isValidAge);
}
}
```
Make sure to import the necessary classes (`import junit.framework.TestCase;`) and adjust the code to match the structure and functionality of your student management application.
To create the required unit tests in Java, follow these steps:
1. Open your student management application project in your preferred Java IDE (Integrated Development Environment), such as Eclipse or IntelliJ.
2. Create a new package for the test cases. In your application project structure, right-click on the source folder (usually named "src" or "source") and choose "New" -> "Package". Name the package "tests" (or any suitable name).
3. Inside the "tests" package, create a new Java class for the unit tests. Right-click on the package and choose "New" -> "Class". Name the class "StudentManagementTests" (or any suitable name).
4. In the "StudentManagementTests" class, add the necessary import statements at the top of the file:
```java
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;
```
5. Add the test methods to the "StudentManagementTests" class, following the naming and requirements provided:
```java
public class StudentManagementTests {
@Test
public void testSaveStudent() {
// Write the test logic here
}
@Test
public void testSearchStudent() {
// Write the test logic here
}
@Test
public void testSearchStudent_StudentNotFound() {
// Write the test logic here
}
@Test
public void testDeleteStudent() {
// Write the test logic here
}
@Test
public void testDeleteStudent_StudentNotFound() {
// Write the test logic here
}
@Test
public void testStudentAge_StudentAgeValid() {
// Write the test logic here
}
@Test
public void testStudentAge_StudentAgeInvalid() {
// Write the test logic here
}
@Test
public void testStudentAge_StudentAgeInvalidCharacter() {
// Write the test logic here
}
}
```
6. Implement the test logic inside each test method. Here is an example for the first test method, "testSaveStudent":
```java
@Test
public void testSaveStudent() {
// Arrange
StudentManagement studentManagement = new StudentManagement();
int studentId = 1;
String studentName = "John Doe";
int age = 20;
String email = "johndoe";
String course = "Computer Science";
// Act
studentManagement.saveStudent(studentId, studentName, age, email, course);
// Assert
Student savedStudent = studentManagement.searchStudent(studentId);
assertNotNull(savedStudent);
assertEquals(studentId, savedStudent.getId());
assertEquals(studentName, savedStudent.getName());
assertEquals(age, savedStudent.getAge());
assertEquals(email, savedStudent.getEmail());
assertEquals(course, savedStudent.getCourse());
}
```
7. Repeat the above steps for each of the remaining test methods, implementing the test logic accordingly.
8. Once you have written all the unit tests, save the "StudentManagementTests" class.
9. To run the tests, right-click inside the "StudentManagementTests" class and choose "Run As" -> "JUnit Test" (or use the equivalent shortcut).
10. The test results will be displayed in the IDE's "JUnit" or "Test Results" tab. You should see whether each test passed or failed, along with any error or failure messages.
By following these steps, you should be able to create the required unit tests for your student management application in Java.
To create the required unit tests in Java, you will need to follow these steps:
1. Create a new package within your student management application to store the unit tests. You can name it something like "test" or "unit_tests".
2. Within the "test" package, create a new Java class file for each of the unit tests you need to write. Name the class files according to the names provided in the requirements. For example, you can have a class called "TestSaveStudent" for the first unit test.
3. Import the necessary classes and packages that are needed for writing unit tests. Depending on your project structure and dependencies, you may need to include additional libraries or testing frameworks such as JUnit or TestNG.
4. In each unit test class, create a method for each individual test case. For example, in the "TestSaveStudent" class, create a method called "testSaveStudent" to test the save student functionality.
5. Within each test method, write the necessary code to set up the test scenario, invoke the relevant methods from your student management application, and validate the expected results.
6. Use assertions to check the correctness of the test results. Assertions are typically provided by testing frameworks like JUnit. For example, you can use assertions to verify that the correct student is saved or that the student details are returned correctly.
7. Repeat the process for each unit test case specified in the requirements, creating a new method in the respective test class for each test case.
8. Once you have completed writing all the unit tests, you can execute them to determine the code coverage. Code coverage refers to the extent to which your tests exercise your code. There are various tools available for measuring code coverage, such as JaCoCo, Emma, or IntelliJ IDEA's built-in coverage tools.
By following these steps, you should be able to write the required unit tests and measure the code coverage in your student management application.