JUnit parte I

JUnit :: o cómo amar el validador JavaRush

Brevemente sobre por qué necesitamos esta bestia. JUnit es un marco para probar automáticamente su código bueno o no tan bueno . Puedes decir: - ¿Por qué necesito este swing? Puedo probar fácil y simplemente mi buen código Java. Puedes escribir muchas letras introductorias, pero no soy gran poeta, pongámonos manos a la obra...

Crear un objeto

Y entonces, para probar algo, primero necesitamos un objeto de prueba. Tenemos una tarea por delante.

1. Necesitamos un objeto que almacene información sobre el Usuario.
   
   1. ID: debe contarse en el orden en que se agregó el nuevo usuario.
   2. Nombre de usuario.
   3. Su edad.
   4. Género Masculino Femenino)

2. Es necesario prever el almacenamiento de una lista de usuarios.

3. La clase debe poder hacerlo.

   1. Generar una lista de todos los usuarios.
   2. Generar una lista de usuarios por género (MASCULINO/FEMENINO).
   3. Devuelve el número de usuarios en la lista general y calcula el número en función del sexo del usuario.
   4. Calcule el monto total por edad del usuario y también tenga en cuenta el sexo.
   5. Calcula la edad media, tanto global como por sexo.

Y entonces, comencemos a crear un objeto... Creemos una clase Java Userque contendrá campos:

private int id;
private String name;
private int age;
private Sex sex;

Esto es suficiente para almacenar datos del usuario, veamos qué más se necesita para la tarea. Necesitamos almacenar de alguna manera a todos los usuarios, hagamos un campo estático en nuestra clase allUsers, creo que está bien si es así.Map<Integer, User>

private static Map<Integer, User> allUsers;

También necesitamos de alguna manera asignar un número de secuencia a los usuarios, creemos un campo de contador estático que, al crear un nuevo usuario, le asignará un número de secuencia Id .

private static int countId = 0;

Entonces, parece que hemos ordenado los campos, escribamos un constructor para nuestro objeto y captadores para los campos id,,,, . No hay nada complicado con heterae, pidamos ayuda a IDEA , ella nunca se negará y haremos que el constructor sea un poco complicado. El diseñador podrá hacerlo. Inicialice los campos, verifique si existe dicho objeto en , si no existe tal objeto, luego aumente nuestro contador y agréguelo a la lista de todos los usuarios. Y también inicialice el campo si aún no se ha inicializado. Para facilitar la búsqueda de objetos idénticos, redefiniremos los métodos y , nuevamente pediremos ayuda a nuestra querida IDEA y compararemos por campos , , . Además, creemos un método privado que comprobará si dicho objeto está en la lista. nameagesexallUserscountId++allUsers equals()hashCode()nameagesexhasUser()

@Override
public boolean equals(Object o) {
    if (this == o) return true;
    if (o == null || getClass() != o.getClass()) return false;
    User user = (User) o;
    return age == user.age &&
            Objects.equals(name, user.name) &&
            sex == user.sex;
}

@Override
public int hashCode() {

    return Objects.hash(name, age, sex);
}

Al final terminé con un diseñador como este.

public User(String name, int age, Sex sex) {
    if (allUsers == null){
        allUsers = new HashMap<>();
    }

    this.name = name;
    this.age = age;
    this.sex = sex;

    if (!hasUser()){
        countId++;
        this.id = countId;
        allUsers.put(id, this);
    }
}

y un método de ayuda privado

private boolean hasUser(){
    for (User user : allUsers.values()){
        if (user.equals(this) && user.hashCode() == this.hashCode()){
            return true;
        }
    }
    return false;
}

y también redefinirtoString()

@Override
public String toString() {
    return "User{" +
            "id=" + id +
            ", name='" + name + '\'' +
            ", age=" + age +
            ", sex=" + sex +
            '}';
}

Ahora es el momento de implementar la lógica de los métodos requeridos. Dado que la lógica funcionará principalmente con campos estáticos, también haremos que los métodos sean estáticos; no son necesarios para los objetos.

1. Generar una lista de todos los usuarios.
2. Generar una lista de usuarios por género (MASCULINO/FEMENINO).

Los puntos a y b se pueden manejar bien mediante un método getAllUsers()que devolverá una lista de todos Usery un método sobrecargado getAllUsers(Sex sex)que devolverá una lista, dependiendo del parámetro pasado Sex.

public static List<User> getAllUsers(){
    return new ArrayList<>(allUsers.values());
}

public static List<User> getAllUsers(Sex sex){
    List<User> listAllUsers = new ArrayList<>();
    for (User user : allUsers.values()){
        if (user.sex == sex){
            listAllUsers.add(user);
        }
    }
    return listAllUsers;
}




3. Devuelve el número de usuarios en la lista general y calcula el número en función del sexo del usuario.

   public static int getHowManyUsers(){
       return allUsers.size();
   }
   
   public static int getHowManyUsers(Sex sex){
       return getAllUsers(sex).size();
   }




4. Calcule el monto total por edad del usuario y también tenga en cuenta el sexo. Creemos métodos para esta tarea.

   public static int getAllAgeUsers(){
       int countAge = 0;
       for (User user : allUsers.values()){
           countAge += user.age;
       }
       return countAge;
   }
   
   public static int getAllAgeUsers(Sex sex){
       int countAge = 0;
       for (User user : getAllUsers(sex)){
           countAge += user.age;
       }
       return countAge;
   }




5. Calcula la edad media, tanto global como por sexo.

   public static int getAverageAgeOfAllUsers(){
       return getAllAgeUsers() / getHowManyUsers();
   }
   
   public static int getAverageAgeOfAllUsers(Sex sex){
       return getAllAgeUsers(sex) / getHowManyUsers(sex);
   }

   Genial, hemos descrito el objeto requerido y su comportamiento. Ahora podemos pasar a JUnit , pero primero les mostraré cómo se verá una prueba simple si la hacemos en main .

   public static void main(String[] args) {
       new User("Eugenio", 35, Sex.MALE);
       new User("Puerto pequeño", 34, Sex.FEMALE);
       new User("alina", 7, Sex.FEMALE);
   
   
       System.out.println("Todos los usuarios:");
       User.getAllUsers().forEach(System.out::println);
       System.out.println("Todos los usuarios: HOMBRES");
       User.getAllUsers(Sex.MALE).forEach(System.out::println);
       System.out.println("Todos los usuarios: FEMENINO");
       User.getAllUsers(Sex.FEMALE).forEach(System.out::println);
       System.out.println("================================================");
       System.out.println(" todos los usuarios: " + User.getHowManyUsers());
       System.out.println(" todos los usuarios MASCULINOS: " + User.getHowManyUsers(Sex.MALE));
       System.out.println("todas las usuarias FEMENINAS: " + User.getHowManyUsers(Sex.FEMALE));
       System.out.println("================================================");
       System.out.println(" edad total de todos los usuarios: " + User.getAllAgeUsers());
       System.out.println(" edad total de todos los usuarios MASCULINOS: " + User.getAllAgeUsers(Sex.MALE));
       System.out.println("edad total de todas las usuarias FEMENINAS: " + User.getAllAgeUsers(Sex.FEMALE));
       System.out.println("================================================");
       System.out.println(" edad promedio de todos los usuarios: " + User.getAverageAgeOfAllUsers());
       System.out.println(" edad promedio de todos los usuarios MASCULINOS: " + User.getAverageAgeOfAllUsers(Sex.MALE));
       System.out.println("edad promedio de todas las usuarias FEMENINAS: " + User.getAverageAgeOfAllUsers(Sex.FEMALE));
       System.out.println("================================================");
   }

   La salida a la consola se verá así y luego compararemos si obtuvimos un funcionamiento normal. Por supuesto, podemos profundizar más, escribir una lógica de comparación y ver qué dice nuestro cálculo, aunque no estemos seguros de haber podido prever todo.

   //output
   Все пользователи:
   User{id=1, name='Eugenio', age=35, sex=MALE}
   User{id=2, name='Puerto pequeño', age=34, sex=FEMALE}
   User{id=3, name='alina', age=7, sex=FEMALE}
   Все пользователи: MALE
   User{id=1, name='Eugenio', age=35, sex=MALE}
   Все пользователи: FEMALE
   User{id=2, name='Puerto pequeño', age=34, sex=FEMALE}
   User{id=3, name='alina', age=7, sex=FEMALE}
   ================================================
          всех пользователей: 3
     всех пользователей MALE: 1
   всех пользователей FEMALE: 2
   ================================================
          общий возраст всех пользователей: 76
     общий возраст всех пользователей MALE: 35
   общий возраст всех пользователей FEMALE: 41
   ================================================
          средний возраст всех пользователей: 25
     средний возраст всех пользователей MALE: 35
   средний возраст всех пользователей FEMALE: 20
   ================================================
   
   Process finished with exit code 0

   No estamos contentos con este resultado, abajo con las pruebas principales , necesitamos JUnit .

Cómo conectar JUnit a un proyecto

Surge la pregunta de cómo conectarlo al proyecto. Para aquellos que lo saben, no elegiré la opción con Maven , ya que esta es una historia completamente diferente. ;) Abra la estructura del proyecto Ctrl + Alt + Shift + S -> Bibliotecas -> haga clic en + (Nueva biblioteca de proyectos) -> seleccione de Maven, luego vemos dicha ventana, ingrese "junit:junit:4.12" en la barra de búsqueda , espera hasta que encuentre -> ¡OK! -> ¡Está bien! Debería obtener este resultado. Haga clic en Aceptar. Felicitaciones. JUnit se ha agregado al proyecto. Vamonos. Ahora necesitamos crear pruebas para nuestra clase Java, coloque el cursor en el nombre de la clase User -> presione Alt + Enter -> seleccione crear prueba. Deberíamos ver una ventana en la que debemos seleccionar la biblioteca JUnit4 -> seleccionar los métodos que vamos a probar -> Aceptar La idea en sí creará una clase UserTest, esta es la clase en la que cubriremos nuestro código con pruebas. Empecemos:

Nuestro primer @Test

Creemos nuestro primer método @TestgetAllUsers() : este es un método que debería devolver todos los usuarios. La prueba se verá así:

@Test
public void getAllUsers() {
    // crear datos de prueba
    User user = new User("Eugenio", 35, Sex.MALE);
    User user1 = new User("Puerto pequeño", 34, Sex.FEMALE);
    User user2 = new User("alina", 7, Sex.FEMALE);

    //crea una lista esperada y rellénala con los datos de nuestro método
    List<User> expected = User.getAllUsers();

    //crear lista real poner datos en ella para comparar
    //lo que esperamos que devuelva el método
    List<User> actual = new ArrayList<>();
    actual.add(user);
    actual.add(user1);
    actual.add(user2);

    //ejecutar la prueba si la lista esperada y real no son iguales
    //la prueba fallará, lea los resultados de la prueba en la consola
    Assert.assertEquals(expected, actual);
}

Aquí creamos varios usuarios de prueba -> creamos una lista expected en la que colocaremos los usuarios cuyo método volverá a nosotros getAllUsers()-> creamos una lista actual en la que colocaremos los usuarios cuyos asumimos que el getAllUsers()método Assert.assertEquals(actual, esperado) se utilizará y le pasaremos las listas, inspeccionadas y vigentes. Este método probará los objetos en las listas proporcionadas y devolverá el resultado de la prueba. El método comparará todos los campos de los objetos, incluso pasando por los campos de los padres si hay herencia. Ejecutemos la primera prueba... La prueba se completó con éxito. Ahora intentemos que la prueba falle, para ello necesitamos cambiar una de las listas de prueba, lo haremos comentando la adición de un usuario a la lista actual.

@Test
public void getAllUsers() {
    // crear datos de prueba
    User user = new User("Eugenio", 35, Sex.MALE);
    User user1 = new User("Puerto pequeño", 34, Sex.FEMALE);
    User user2 = new User("alina", 7, Sex.FEMALE);

    //crea una lista esperada y rellénala con los datos de nuestro método
    List<User> expected = User.getAllUsers();

    //crear lista real poner datos en ella para comparar
    //lo que esperamos que devuelva el método
    List<User> actual = new ArrayList<>();
    actual.add(user);
    actual.add(user1);
    //actual.add(user2);

    //ejecutar la prueba si la lista esperada y real no son iguales
    //la prueba fallará, lea los resultados de la prueba en la consola
    Assert.assertEquals(expected, actual);
}

ejecutamos la prueba y vemos lo siguiente: Ahora podemos ver un poco el motivo del fallo de la prueba. Aquí vemos que hay más usuarios en la lista inspeccionada que en la actual. Ésta es la razón del fracaso. ¿Podemos comprobar esto en principal? JUnit: main = 1: 0. Veamos cómo se verá la prueba si contiene objetos completamente diferentes, hagámoslo así:

@Test
public void getAllUsers() {
    // crear datos de prueba
    User user = new User("Eugenio", 35, Sex.MALE);
    User user1 = new User("Puerto pequeño", 34, Sex.FEMALE);
    User user2 = new User("alina", 7, Sex.FEMALE);

    //crea una lista esperada y rellénala con los datos de nuestro método
    List<User> expected = User.getAllUsers();

    //crear lista real poner datos en ella para comparar
    //lo que esperamos que devuelva el método
    List<User> actual = new ArrayList<>();
    actual.add(new User("User1", 1, Sex.MALE));
    actual.add(new User("User2", 2, Sex.FEMALE));
    actual.add(new User("User3", 3, Sex.MALE));

    //ejecutar la prueba si la lista esperada y real no son iguales
    //la prueba fallará, lea los resultados de la prueba en la consola
    Assert.assertEquals(expected, actual);
}

Esto es lo que estará en la consola: aquí inmediatamente podrás ver que hay diferentes usuarios en las listas comparadas, también podemos hacer clic en <Haz clic para ver la diferencia> nos saldrá una ventana donde podremos ver en detalle qué datos tenemos problema con. IDEA resaltará todos los campos donde haya diferencias. main¿puede pasar esto? - No. JUnit : main = 2 : 0 Bueno, sigamos adelante, todavía tenemos un montón de métodos que deben cubrirse con pruebas), pero espera, no estará mal comprobar si el método volverá a getAllUsers()nosotros , porque eso es qué hacemos con nulllas tareas JavaRush capturadas por el validador). Hagamos esto, es cuestión de tres kopeks...

@Test
public void getAllUsers_NO_NULL() {
    //añadir verificación de nulo
    List<User> expected = User.getAllUsers();
    Assert.assertNotNull(expected);
}

Sí, sí, así es aproximadamente como el validador detecta nuestro código de mierdanull ;) Ahora ejecutemos esta prueba y veamos qué nos muestra. Y mostrará un error, ¿cómo? ¿Cómo se pudo cometer un error de prueba aquí?))) Y aquí podemos cosechar los primeros frutos de cubrir nuestro código con pruebas. Como recuerdas, allUsers inicializamos el campo en el constructor, lo que significa que al llamar al método getAllUsers(), nos referiremos a un objeto que aún no ha sido inicializado. Editémoslo, eliminemos la inicialización del constructor y hagámoslo al declarar el campo.

private static Map<Integer, User> allUsers = new HashMap<>();

    public User(String name, int age, Sex sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;

        if (!hasUser()) {
            countId++;
            this.id = countId;
            allUsers.put(id, this);
        }
    }

Hagamos la prueba, ahora todo está bien. No creo que sea fácil detectar NPE en main, creo que estarás de acuerdo en que el recuento es JUnit: main = 3: 0 Luego cubriré todos los métodos con pruebas y te dejaré ver cómo se verá. ... Ahora nuestra clase de prueba se ve así:

package user;

import org.junit.Assert;
import org.junit.Test;

import java.util.ArrayList;
import java.util.List;

import static org.junit.Assert.*;

public class UserTest {

    @Test
    public void getAllUsers() {
        // crear datos de prueba
        User user = new User("Eugenio", 35, Sex.MALE);
        User user1 = new User("Puerto pequeño", 34, Sex.FEMALE);
        User user2 = new User("alina", 7, Sex.FEMALE);

        //crea una lista esperada y rellénala con los datos de nuestro método
        List<User> expected = User.getAllUsers();

        //crear lista real poner datos en ella para comparar
        //lo que esperamos que devuelva el método
        List<User> actual = new ArrayList<>();
        actual.add(user);
        actual.add(user1);
        actual.add(user2);

        //ejecutar la prueba si la lista esperada y real no son iguales
        //la prueba fallará, lea los resultados de la prueba en la consola
        Assert.assertEquals(expected, actual);
    }

    @Test
    public void getAllUsers_NO_NULL() {
        //añadir verificación de nulo
        List<User> expected = User.getAllUsers();
        Assert.assertNotNull(expected);
    }

    @Test
    public void getAllUsers_MALE() {
        User user = new User("Eugenio", 35, Sex.MALE);
        User user1 = new User("Puerto pequeño", 34, Sex.FEMALE);
        User user2 = new User("alina", 7, Sex.FEMALE);

        List<User> expected = User.getAllUsers(Sex.MALE);

        List<User> actual = new ArrayList<>();
        actual.add(user);

        Assert.assertEquals(expected, actual);
    }

    @Test
    public void getAllUsers_MALE_NO_NULL() {
        //añadir verificación de nulo
        List<User> expected = User.getAllUsers(Sex.MALE);
        Assert.assertNotNull(expected);
    }

    @Test
    public void getAllUsers_FEMALE() {
        User user = new User("Eugenio", 35, Sex.MALE);
        User user1 = new User("Puerto pequeño", 34, Sex.FEMALE);
        User user2 = new User("alina", 7, Sex.FEMALE);

        List<User> expected = User.getAllUsers(Sex.FEMALE);

        List<User> actual = new ArrayList<>();
        actual.add(user1);
        actual.add(user2);

        Assert.assertEquals(expected, actual);
    }

    @Test
    public void getAllUsers_FEMALE_NO_NULL() {
        //añadir verificación de nulo
        List<User> expected = User.getAllUsers(Sex.FEMALE);
        Assert.assertNotNull(expected);
    }

    @Test
    public void getHowManyUsers() {
        User user = new User("Eugenio", 35, Sex.MALE);
        User user1 = new User("Puerto pequeño", 34, Sex.FEMALE);
        User user2 = new User("alina", 7, Sex.FEMALE);

        int expected = User.getHowManyUsers();

        int actual = 3;

        Assert.assertEquals(expected, actual);
    }

    @Test
    public void getHowManyUsers_MALE() {
        User user = new User("Eugenio", 35, Sex.MALE);
        User user1 = new User("Puerto pequeño", 34, Sex.FEMALE);
        User user2 = new User("alina", 7, Sex.FEMALE);

        int expected = User.getHowManyUsers(Sex.MALE);

        int actual = 1;

        Assert.assertEquals(expected, actual);
    }

    @Test
    public void getHowManyUsers_FEMALE() {
        User user = new User("Eugenio", 35, Sex.MALE);
        User user1 = new User("Puerto pequeño", 34, Sex.FEMALE);
        User user2 = new User("alina", 7, Sex.FEMALE);

        int expected = User.getHowManyUsers(Sex.FEMALE);

        int actual = 2;

        Assert.assertEquals(expected, actual);
    }

    @Test
    public void getAllAgeUsers() {
        User user = new User("Eugenio", 35, Sex.MALE);
        User user1 = new User("Puerto pequeño", 34, Sex.FEMALE);
        User user2 = new User("alina", 7, Sex.FEMALE);

        int expected = User.getAllAgeUsers();

        int actual = 35 + 34 + 7;

        Assert.assertEquals(expected, actual);
    }

    @Test
    public void getAllAgeUsers_MALE() {
        User user = new User("Eugenio", 35, Sex.MALE);
        User user1 = new User("Puerto pequeño", 34, Sex.FEMALE);
        User user2 = new User("alina", 7, Sex.FEMALE);

        int expected = User.getAllAgeUsers(Sex.MALE);

        int actual = 35;

        Assert.assertEquals(expected, actual);
    }

    @Test
    public void getAllAgeUsers_FEMALE() {
        User user = new User("Eugenio", 35, Sex.MALE);
        User user1 = new User("Puerto pequeño", 34, Sex.FEMALE);
        User user2 = new User("alina", 7, Sex.FEMALE);

        int expected = User.getAllAgeUsers(Sex.FEMALE);

        int actual = 34 + 7;

        Assert.assertEquals(expected, actual);
    }
}

Sí, resultó que no es pequeño, pero lo que sucederá cuando se trabaje con proyectos grandes. ¿Qué se puede reducir aquí? Después de evaluar todo, puede ver que creamos datos de prueba en cada prueba, y aquí las anotaciones vienen en nuestra ayuda. Tomemos @Before: la anotación @Beforeindica que el método se ejecutará antes de cada método probado @Test. Así es como se verá ahora nuestra clase de prueba con anotaciones @Before:

package user;

import org.junit.Assert;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;

import java.util.ArrayList;
import java.util.List;

import static org.junit.Assert.*;

public class UserTest {
    private User user;
    private User user1;
    private User user2;

    @Before
    public void setUp() throws Exception {
        user = new User("Eugenio", 35, Sex.MALE);
        user1 = new User("Puerto pequeño", 34, Sex.FEMALE);
        user2 = new User("alina", 7, Sex.FEMALE);
    }

    @Test
    public void getAllUsers() {
        List<User> expected = User.getAllUsers();

        List<User> actual = new ArrayList<>();
        actual.add(user);
        actual.add(user1);
        actual.add(user2);

        Assert.assertEquals(expected, actual);
    }

    @Test
    public void getAllUsers_NO_NULL() {
        List<User> expected = User.getAllUsers();
        Assert.assertNotNull(expected);
    }

    @Test
    public void getAllUsers_MALE() {
        List<User> expected = User.getAllUsers(Sex.MALE);

        List<User> actual = new ArrayList<>();
        actual.add(user);

        Assert.assertEquals(expected, actual);
    }

    @Test
    public void getAllUsers_MALE_NO_NULL() {
        //añadir verificación de nulo
        List<User> expected = User.getAllUsers(Sex.MALE);
        Assert.assertNotNull(expected);
    }

    @Test
    public void getAllUsers_FEMALE() {
        List<User> expected = User.getAllUsers(Sex.FEMALE);

        List<User> actual = new ArrayList<>();
        actual.add(user1);
        actual.add(user2);

        Assert.assertEquals(expected, actual);
    }

    @Test
    public void getAllUsers_FEMALE_NO_NULL() {
        //añadir verificación de nulo
        List<User> expected = User.getAllUsers(Sex.FEMALE);
        Assert.assertNotNull(expected);
    }

    @Test
    public void getHowManyUsers() {
        int expected = User.getHowManyUsers();

        int actual = 3;

        Assert.assertEquals(expected, actual);
    }

    @Test
    public void getHowManyUsers_MALE() {
        int expected = User.getHowManyUsers(Sex.MALE);

        int actual = 1;

        Assert.assertEquals(expected, actual);
    }

    @Test
    public void getHowManyUsers_FEMALE() {
        int expected = User.getHowManyUsers(Sex.FEMALE);

        int actual = 2;

        Assert.assertEquals(expected, actual);
    }

    @Test
    public void getAllAgeUsers() {
        int expected = User.getAllAgeUsers();

        int actual = 35 + 34 + 7;

        Assert.assertEquals(expected, actual);
    }

    @Test
    public void getAllAgeUsers_MALE() {
        int expected = User.getAllAgeUsers(Sex.MALE);

        int actual = 35;

        Assert.assertEquals(expected, actual);
    }

    @Test
    public void getAllAgeUsers_FEMALE() {
        int expected = User.getAllAgeUsers(Sex.FEMALE);

        int actual = 34 + 7;

        Assert.assertEquals(expected, actual);
    }
}

Bueno, ¿y tú? Ya es más divertido y fácil de leer ;) Aquí hay una lista de anotaciones para JUnit; definitivamente es más fácil vivir con ellas.

@Test – определяет что метод method() является тестовым.
@Before – указывает на то, что метод будет выполнятся перед каждым тестируемым методом @Test.
@After – указывает на то что метод будет выполнятся после каждого тестируемого метода @Test
@BeforeClass – указывает на то, что метод будет выполнятся в начале всех тестов,
а точней в момент запуска тестов(перед всеми тестами @Test).
@AfterClass – указывает на то, что метод будет выполнятся после всех тестов.
@Ignore – говорит, что метод будет проигнорирован в момент проведения тестирования.
(expected = Exception.class) – указывает на то, что в данном тестовом методе
вы преднамеренно ожидаете Exception.
(timeout = 100) – указывает, что тестируемый метод не должен занимать больше чем 100 миллисекунд.

Métodos de clase principal Assertpara verificar:

fail(String) – указывает на то что бы тестовый метод завалился при этом выводя текстовое сообщение.
assertTrue([message], boolean condition) – проверяет, что логическое condición истинно.
assertsEquals([String message], expected, actual) – проверяет, что два значения совпадают.
Примечание: для массивов проверяются ссылки, а не содержание массивов.
assertNull([message], object) – проверяет, что un objeto является пустым null.
assertNotNull([message], object) – проверяет, что un objeto не является пустым null.
assertSame([String], expected, actual) – проверяет, что обе переменные относятся к одному un objetoу.
assertNotSame([String], expected, actual) – проверяет, что обе переменные относятся к разным un objetoам.

Así es como podemos agregar la dependencia JUnit 4.12 en Maven

<dependency>
  <groupId>junit</groupId>
  <artifactId>junit</artifactId>
  <version>4.12</version>
  <scope>test</scope>
</dependency>

continúa aquí -> JUnit parte II