Zadanko z dziedziczenia interfejsów

interface IMyClass {
  // zwraca studenta o podanym name lub null
  IStudent findByName(String name);
  // zwraca studenta o podanym surname lub null
  IStudent findBySurname(String surname);
  //zwraca liczbę studentów
  int count();
}

public class MyClass implements IMyClass {
  private List<IStudent> students;
}

interface IStudent {
  String getName();
  String getSurname();
}

interface ICreateStudent extends IStudent {
  List<IStudent> getStudents();
}

findByName(String name) {
 for IStudent student in students
if student.getName equals name
    return student;
else 
   return null;
}

package net.forprogrammers;

import java.util.List;
import java.util.function.Predicate;

public class MyClass implements IMyClass {

    private List<IStudent> students;

    public MyClass(ICreateStudent iCreateStudent) {

        this.students = iCreateStudent.getStudents();
    }

    @Override
    public IStudent findByName(String name) {

        Predicate<IStudent> byName = s -> s.getName().equals(name);

        return getStudent(byName);
    }

    @Override
    public IStudent findBySurname(String surname) {

        Predicate<IStudent> bySurname = s -> s.getSurname().equals(surname);

        return getStudent(bySurname);
    }

    @Override
    public int count() {

        return students.size();
    }

    private IStudent getStudent(Predicate<IStudent> criterion) {

        return this.students
                .stream()
                .filter(criterion)
                .findAny()
                .orElse(null);
    }
}

package net.forprogrammers;

import org.junit.Before;
import org.junit.Ignore;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.mockito.Mockito;

import static org.junit.Assert.*;
import static org.hamcrest.Matchers.*;

import java.util.Arrays;
import java.util.Collection;
import java.util.List;

@RunWith(Parameterized.class)
public class MyClassTest {

    @Parameterized.Parameter(value = 0)
    public static String name;
    @Parameterized.Parameter(value = 1)
    public static String surname;
    @Parameterized.Parameter(value = 2)
    public static IStudent student;

    private static String sAName = "Adam";
    private static String sBName = "Barbara";
    private static String sASurname = "Ant";
    private static String sBSurname = "Brown";
    private static IStudent studentA = Mockito.mock(IStudent.class);
    private static IStudent studentB = Mockito.mock(IStudent.class);

    private MyClass sut;
    private ICreateStudent createStudent;

    @Parameterized.Parameters
    public static Collection<Object[]> data() {

        return Arrays.asList(new Object[][]{
                {sAName, sASurname, studentA},
                {sBName, sBSurname, studentB}
        });
    }

    @Before
    public void setUp() throws Exception {

        createStudent = Mockito.mock(ICreateStudent.class);

        List<IStudent> students = Arrays.asList(studentA, studentB);

        Mockito
                .when(studentA.getName())
                .thenReturn(sAName);

        Mockito
                .when(studentB.getName())
                .thenReturn(sBName);

        Mockito
                .when(studentA.getSurname())
                .thenReturn(sASurname);
        Mockito
                .when(studentB.getSurname())
                .thenReturn(sBSurname);

        Mockito
                .when(createStudent.getStudents())
                .thenReturn(students);

        sut = new MyClass(createStudent);
    }

    @Test
    public void shouldDoFindingByName() {

        IStudent byName = sut.findByName(name);
        assertThat(byName.getName(), is(equalTo(student.getName())));
    }

    @Test
    public void shouldfindingBySurname() {

        IStudent bySurname = sut.findBySurname(surname);
        assertThat(bySurname.getSurname(), is(equalTo(student.getSurname())));
    }

    @Ignore
    @Test
    public void shouldCreateStudents() {

        Mockito
                .verify(createStudent, Mockito.times(1))
                .getStudents();

        List<IStudent> students = createStudent.getStudents();
        assertThat(students.size(), is(2));

        assertThat(students.get(0).getName(), is(sAName));
        assertThat(students.get(1).getName(), is(sBName));
        assertThat(students.get(0).getSurname(), is(sASurname));
        assertThat(students.get(1).getSurname(), is(sBSurname));

        assertThat(studentA, is(not(equalTo(null))));
        assertThat(studentB, is(not(equalTo(null))));
    }

    @Test
    public void shouldReturnNullWhenStudentDoesntExist() {

        IStudent byName = sut.findByName("Joe");
        assertThat(byName, is(equalTo(null)));

        IStudent bySurname = sut.findBySurname("Doe");
        assertThat(bySurname, is(equalTo(null)));
    }
}