JUnit :: ou comment aimer le validateur JavaRush
Créer un objet
Et donc, pour tester quelque chose, nous avons d’abord besoin d’un objet de test. Nous avons une tâche devant nous.- Nous avons besoin d'un objet qui stockera des informations sur l'utilisateur.
- Id - doit être compté dans l'ordre dans lequel le nouvel utilisateur a été ajouté.
- Nom d'utilisateur.
- Son age.
- Genre Homme Femme)
-
Il est nécessaire de prévoir le stockage d'une liste d'utilisateurs.
-
La classe doit en être capable.
- Générez une liste de tous les utilisateurs.
- Générez une liste d'utilisateurs par sexe (MALE/FEMALE).
- Renvoyez le nombre d'utilisateurs dans la liste générale et calculez le nombre en fonction du sexe de l'utilisateur.
- Calculez le montant total en fonction de l'âge de l'utilisateur et tenez également compte du sexe.
- Calculez l’âge moyen, globalement et par sexe.
Userqui contiendra des champs :
private int id;
private String name;
private int age;
private Sex sex;allUsers, je pense que ce n'est pas grave si c'est le casMap<Integer, User>
private static Map<Integer, User> allUsers;Id à l'utilisateur.
private static int countId = 0;id, name, age, sex. Il n'y a rien de compliqué avec les hétéros, demandons de l'aide à IDEA , elle ne refusera jamais, et nous rendrons le constructeur un peu délicat. Le concepteur le pourra. Initialisez les champs, vérifiez s'il existe un tel objet dans allUsers, s'il n'y en a pas, puis augmentez notre compteur countId++et ajoutez-le à la liste de tous les utilisateurs. Et initialisez également le champ allUsers s'il n'a pas encore été initialisé. Pour faciliter la recherche d'objets identiques, nous redéfinirons les méthodes equals()et hashCode(), encore une fois, nous demanderons de l'aide à notre bien-aimée IDEA et comparerons par champs name, age, sex. De plus, créons une méthode privée hasUser()qui vérifiera si un tel objet est dans la liste.
@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);
}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);
}
}private boolean hasUser(){
for (User user : allUsers.values()){
if (user.equals(this) && user.hashCode() == this.hashCode()){
return true;
}
}
return false;
}toString()
@Override
public String toString() {
return "User{" +
"id=" + id +
", name='" + name + '\'' +
", age=" + age +
", sex=" + sex +
'}';
}- Générez une liste de tous les utilisateurs.
- Générez une liste d'utilisateurs par sexe (MALE/FEMALE).
-
Renvoyez le nombre d'utilisateurs dans la liste générale et calculez le nombre en fonction du sexe de l'utilisateur.
public static int getHowManyUsers(){ return allUsers.size(); } public static int getHowManyUsers(Sex sex){ return getAllUsers(sex).size(); } -
Calculez le montant total en fonction de l'âge de l'utilisateur et tenez également compte du sexe. Créons des méthodes pour cette tâche.
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; } -
Calculez l’âge moyen, globalement et par sexe.
public static int getAverageAgeOfAllUsers(){ return getAllAgeUsers() / getHowManyUsers(); } public static int getAverageAgeOfAllUsers(Sex sex){ return getAllAgeUsers(sex) / getHowManyUsers(sex); }Super, nous avons décrit l'objet recherché et son comportement. Nous pouvons maintenant passer à JUnit , mais je vais d'abord vous montrer à quoi ressemblera un test simple si nous le faisons dans main .
public static void main(String[] args) { new User("Eugene", 35, Sex.MALE); new User("Marina", 34, Sex.FEMALE); new User("Alina", 7, Sex.FEMALE); System.out.println("All users:"); User.getAllUsers().forEach(System.out::println); System.out.println("All users: MALE"); User.getAllUsers(Sex.MALE).forEach(System.out::println); System.out.println("All users: FEMALE"); User.getAllUsers(Sex.FEMALE).forEach(System.out::println); System.out.println("================================================"); System.out.println(" all users: " + User.getHowManyUsers()); System.out.println(" all MALE users: " + User.getHowManyUsers(Sex.MALE)); System.out.println("all FEMALE users: " + User.getHowManyUsers(Sex.FEMALE)); System.out.println("================================================"); System.out.println(" total age of all users: " + User.getAllAgeUsers()); System.out.println(" total age of all MALE users: " + User.getAllAgeUsers(Sex.MALE)); System.out.println("total age of all FEMALE users: " + User.getAllAgeUsers(Sex.FEMALE)); System.out.println("================================================"); System.out.println(" average age of all users: " + User.getAverageAgeOfAllUsers()); System.out.println(" average age of all MALE users: " + User.getAverageAgeOfAllUsers(Sex.MALE)); System.out.println("average age of all FEMALE users: " + User.getAverageAgeOfAllUsers(Sex.FEMALE)); System.out.println("================================================"); }La sortie vers la console ressemblera à ceci, puis nous comparerons si nous avons obtenu un fonctionnement normal. Nous pouvons bien sûr aller plus loin, écrire une logique de comparaison et voir ce que dit notre calcul, même si nous ne serons pas sûrs d’avoir pu tout prévoir.
//output Все пользователи: User{id=1, name='Eugene', age=35, sex=MALE} User{id=2, name='Marina', age=34, sex=FEMALE} User{id=3, name='Alina', age=7, sex=FEMALE} Все пользователи: MALE User{id=1, name='Eugene', age=35, sex=MALE} Все пользователи: FEMALE User{id=2, name='Marina', 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 0Nous ne sommes pas satisfaits de ce résultat, avec les tests principaux , nous avons besoin de JUnit .
Les points a et b peuvent être bien gérés par une méthode getAllUsers()qui renverra une liste de tous Useret une méthode surchargée getAllUsers(Sex sex)qui renverra une liste, en fonction du paramètre passé 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;
}
Comment connecter JUnit à un projet
La question se pose de savoir comment le connecter au projet. Pour les connaisseurs, je ne prendrai pas l’option avec Maven , car c’est une toute autre histoire. ;) Ouvrez la structure du projet Ctrl + Alt + Shift + S -> Bibliothèques -> cliquez sur + (Nouvelle bibliothèque de projet) -> sélectionnez dans Maven,
puis nous voyons une telle fenêtre, entrez « junit:junit:4.12 » dans la barre de recherche , attendez qu'il trouve -> OK ! -> D'accord ! 
Vous devriez obtenir ce résultat 
Cliquez sur OK, félicitations, JUnit a été ajouté au projet. Allons-nous en. Nous devons maintenant créer des tests pour notre classe Java, placez le curseur sur le nom de la classe User -> appuyez sur Alt + Entrée -> sélectionnez Créer un test. Nous devrions voir une fenêtre dans laquelle nous devons sélectionner la bibliothèque JUnit4 -> sélectionner les méthodes que nous allons tester -> OK 
L'idée elle-même créera une classe UserTest, c'est la classe dans laquelle nous couvrirons notre code avec des tests. Commençons:
Notre premier @Test
Créons notre première méthode @TestgetAllUsers() - c'est une méthode qui devrait renvoyer tous les utilisateurs. Le test ressemblera à ceci :
@Test
public void getAllUsers() {
// create test data
User user = new User("Eugene", 35, Sex.MALE);
User user1 = new User("Marina", 34, Sex.FEMALE);
User user2 = new User("Alina", 7, Sex.FEMALE);
//create an expected list and fill it with the data of our method
List<User> expected = User.getAllUsers();
//create actual list put data in it for comparison
//what we expect the method to return
List<User> actual = new ArrayList<>();
actual.add(user);
actual.add(user1);
actual.add(user2);
//run the test if the list expected and actual are not equal
//the test will fail, read the test results in the console
Assert.assertEquals(expected, actual);
}expected dans laquelle nous placerons les utilisateurs dont la méthode nous reviendra getAllUsers()-> créons une liste actual dans laquelle nous placerons les utilisateurs dont nous supposons que la getAllUsers()méthode Assert.assertEquals (réelle, attendue) sera utilisé et nous lui transmettrons les listes, inspectées et à jour. Cette méthode testera les objets dans les listes fournies et renverra le résultat du test. La méthode comparera tous les champs des objets, même en passant par les champs des parents s'il y a héritage. Lançons le premier test... 
Le test s'est terminé avec succès. Essayons maintenant de faire échouer le test, pour cela nous devons modifier l'une des listes de tests, nous le ferons en commentant l'ajout d'un utilisateur à la liste actual.
@Test
public void getAllUsers() {
// create test data
User user = new User("Eugene", 35, Sex.MALE);
User user1 = new User("Marina", 34, Sex.FEMALE);
User user2 = new User("Alina", 7, Sex.FEMALE);
//create an expected list and fill it with the data of our method
List<User> expected = User.getAllUsers();
//create actual list put data in it for comparison
//what we expect the method to return
List<User> actual = new ArrayList<>();
actual.add(user);
actual.add(user1);
//actual.add(user2);
//run the test if the list expected and actual are not equal
//the test will fail, read the test results in the console
Assert.assertEquals(expected, actual);
}
Nous pouvons maintenant examiner un peu la raison de l'échec du test. Ici, nous voyons qu'il y a plus d'utilisateurs dans la liste inspectée que dans la liste actuelle. C'est la raison de l'échec. Pouvons-nous vérifier cela en principal ? JUnit : main = 1 : 0. Voyons à quoi ressemblera le test s'il contient des objets complètement différents, faisons-le comme ceci :
@Test
public void getAllUsers() {
// create test data
User user = new User("Eugene", 35, Sex.MALE);
User user1 = new User("Marina", 34, Sex.FEMALE);
User user2 = new User("Alina", 7, Sex.FEMALE);
//create an expected list and fill it with the data of our method
List<User> expected = User.getAllUsers();
//create actual list put data in it for comparison
//what we expect the method to return
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));
//run the test if the list expected and actual are not equal
//the test will fail, read the test results in the console
Assert.assertEquals(expected, actual);
}
ici vous pouvez immédiatement voir qu'il y a différents utilisateurs dans les listes comparées, nous pouvons également cliquer sur <Cliquez pour voir la différence> nous obtiendrons une fenêtre où nous pourrons voir en détail quelles données nous avons problème avec. IDEA mettra en évidence tous les domaines où il existe des différences. 
mainest-ce que cela peut arriver ? - Non. JUnit : main = 2 : 0 Bon, passons à autre chose, nous avons encore un tas de méthodes qui doivent être couvertes par des tests), mais attendez, ce ne sera pas mal de vérifier si la méthode nous getAllUsers()reviendra , car c'est ce que nous faisons avec nullles tâches JavaRush capturées par le validateur). Faisons-le, c'est une question de trois kopecks...
@Test
public void getAllUsers_NO_NULL() {
//add check for null
List<User> expected = User.getAllUsers();
Assert.assertNotNull(expected);
}null ;) Lançons maintenant ce test et voyons ce qu'il nous montre. Et il affichera une erreur, comment ???? Comment une erreur de test pourrait-elle être commise ici))) 
Et ici, nous pouvons récolter les premiers fruits de la couverture de notre code avec des tests. Comme vous vous en souvenez, allUsers nous avons initialisé le champ dans le constructeur, ce qui signifie que lors de l'appel de la méthode getAllUsers(), nous ferons référence à un objet qui n'a pas encore été initialisé. Modifions-le, supprimons l'initialisation du constructeur et faisons-le lors de la déclaration du champ.
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);
}
}
Je ne pense pas qu'il sera facile d'attraper les NPE dans main, je pense que vous conviendrez que le décompte est JUnit: main = 3 : 0 Ensuite, je couvrirai toutes les méthodes avec des tests et vous laisserai voir à quoi cela ressemblera ... Maintenant, notre classe de test ressemble à ceci :
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() {
// create test data
User user = new User("Eugene", 35, Sex.MALE);
User user1 = new User("Marina", 34, Sex.FEMALE);
User user2 = new User("Alina", 7, Sex.FEMALE);
//create an expected list and fill it with the data of our method
List<User> expected = User.getAllUsers();
//create actual list put data in it for comparison
//what we expect the method to return
List<User> actual = new ArrayList<>();
actual.add(user);
actual.add(user1);
actual.add(user2);
//run the test if the list expected and actual are not equal
//the test will fail, read the test results in the console
Assert.assertEquals(expected, actual);
}
@Test
public void getAllUsers_NO_NULL() {
//add check for null
List<User> expected = User.getAllUsers();
Assert.assertNotNull(expected);
}
@Test
public void getAllUsers_MALE() {
User user = new User("Eugene", 35, Sex.MALE);
User user1 = new User("Marina", 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() {
//add check for null
List<User> expected = User.getAllUsers(Sex.MALE);
Assert.assertNotNull(expected);
}
@Test
public void getAllUsers_FEMALE() {
User user = new User("Eugene", 35, Sex.MALE);
User user1 = new User("Marina", 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() {
//add check for null
List<User> expected = User.getAllUsers(Sex.FEMALE);
Assert.assertNotNull(expected);
}
@Test
public void getHowManyUsers() {
User user = new User("Eugene", 35, Sex.MALE);
User user1 = new User("Marina", 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("Eugene", 35, Sex.MALE);
User user1 = new User("Marina", 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("Eugene", 35, Sex.MALE);
User user1 = new User("Marina", 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("Eugene", 35, Sex.MALE);
User user1 = new User("Marina", 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("Eugene", 35, Sex.MALE);
User user1 = new User("Marina", 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("Eugene", 35, Sex.MALE);
User user1 = new User("Marina", 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);
}
}@Before- L'annotation @Beforeindique que la méthode sera exécutée avant chaque méthode testée @Test. Voici à quoi ressemblera désormais notre classe de test avec annotation@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("Eugene", 35, Sex.MALE);
user1 = new User("Marina", 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() {
//add check for null
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() {
//add check for null
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);
}
}@Test – определяет что метод method() является тестовым.
@Before – указывает на то, что метод будет выполнятся перед каждым тестируемым методом @Test.
@After – указывает на то что метод будет выполнятся после каждого тестируемого метода @Test
@BeforeClass – указывает на то, что метод будет выполнятся в начале всех тестов,
а точней в момент запуска тестов(перед всеми тестами @Test).
@AfterClass – указывает на то, что метод будет выполнятся после всех тестов.
@Ignore – говорит, что метод будет проигнорирован в момент проведения тестирования.
(expected = Exception.class) – указывает на то, что в данном тестовом методе
вы преднамеренно ожидаете Exception.
(timeout = 100) – указывает, что тестируемый метод не должен занимать больше чем 100 миллисекунд.Assertpour vérifier :
fail(String) – указывает на то что бы тестовый метод завалился при этом выводя текстовое сообщение.
assertTrue([message], boolean condition) – проверяет, что логическое condition истинно.
assertsEquals([String message], expected, actual) – проверяет, что два значения совпадают.
Примечание: для массивов проверяются ссылки, а не содержание массивов.
assertNull([message], object) – проверяет, что an object является пустым null.
assertNotNull([message], object) – проверяет, что an object не является пустым null.
assertSame([String], expected, actual) – проверяет, что обе переменные относятся к одному an objectу.
assertNotSame([String], expected, actual) – проверяет, что обе переменные относятся к разным an objectм.<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
GO TO FULL VERSION