Mockito 3 Wanted but not invoked

I am trying to learn Mockito 3, I have looked almost all the results in google search, but couldn't find the working solution.
I am calling processStudent in a test case which on the basis of input internally calls another method saveStudent or saveNullStudent.

 public String processStudent(String student) {
    System.out.println("StudentService.processStudent: it will process Student = " + student);
    String StudentRes;
    if (Objects.isNull(student)) {
        StudentRes = saveNullStudent(student);
        return StudentRes;
    } else {
        StudentRes = saveStudent(student);
        return StudentRes;
    }
}

public String saveNullStudent(String student) {
    System.out.println("StudentService.saveNullStudent: it will process then save Student = " + student);
    return student;
}

public String saveStudent(String student) {
    System.out.println("StudentService.saveStudent: it will process then save Student = " + student);
    return student;
}

I need to test both the cases so my Test case is

 @Test
void saveStudentWithMockTest() {
    StudentService StudentService = mock(StudentService.class);
    StudentService.processStudent("studentA");
    verify(StudentService, times(1)).saveStudent("studentA");
}

@Test
void saveStudentWithNullMockTest() {
    StudentService StudentService = mock(StudentService.class);
    StudentService.processStudent(null);
    verify(StudentService, times(1)).saveNullStudent(null);
}

but I am getting

Wanted but not invoked:
studentService.saveNullStudent(null);
-> at StudentServiceTest.saveStudentWithNullMockTest(StudentServiceTest.java:21)

However, there was exactly 1 interaction with this mock:
studentService.processStudent(null);
-> at StudentServiceTest.saveStudentWithNullMockTest(StudentServiceTest.java:20)

Gradle file

dependencies {
    testImplementation('org.junit.jupiter:junit-jupiter:5.6.2')
    testCompile 'org.mockito:mockito-junit-jupiter:3.4.4'
}

I don't understand, isn't this is what mockito is for?

the whole point of this test case is not for a unit test but to test the behavior of processStudent method that as per input data if the value is null then saveNullStudent method is called or else saveStudent method is called.

what I am doing wrong?

You call the processStudent on a mock object, this means, that the original code is not used. Therefore the save method is not invoked.

You need to change the mock, so the real method is invoked by using thenCallRealMethod().

In your first test you have to add a line like:

when(StudentService.processStudent("studentA")).thenCallRealMethod()

In the second test it is similar, but with another parameter.
Maybe the syntax is not 100% correct, because I am writing this without any IDE support, but I think you get the idea.

You should learn what a mock object is first. Then the solution will make more sense.

You should only mock the dependencies of the class that you want to test. By which I mean, if the StudentService class has any global variables like other service or repository classes those are the classes that you should mock. The StudentService class itself should be real. A better test in your case would be to check the output of the processStudent method for both test cases. Eg:

import org.junit.Test;

import static org.assertj.core.api.Assertions.assertThat;

public class StudentServiceTest {

	private final StudentService studentService = new StudentService();

	@Test
	public void saveStudentWithMockTest() {
		String result = studentService.processStudent("studentA");

		assertThat(result).isEqualToIgnoringCase("studentA");
	}

	@Test
	public void saveStudentWithNullMockTest() {
		String result = studentService.processStudent(null);

		assertThat(result).isNull();
	}

}