JUnit :: oder wie man den JavaRush-Validator liebt
Erstellen Sie ein Objekt
Um also etwas zu testen, brauchen wir zunächst ein Testobjekt. Wir haben eine Aufgabe vor uns.- Wir benötigen ein Objekt, das Informationen über den Benutzer speichert.
- ID – muss in der Reihenfolge gezählt werden, in der der neue Benutzer hinzugefügt wurde.
- Benutzername.
- Sein Alter.
- Geschlecht Männlich Weiblich)
-
Es ist erforderlich, eine Benutzerliste zu speichern.
-
Die Klasse muss dazu in der Lage sein.
- Erstellen Sie eine Liste aller Benutzer.
- Erstellen Sie eine Liste der Benutzer nach Geschlecht (MÄNNLICH/WEIBLICH).
- Geben Sie die Anzahl der Benutzer in der allgemeinen Liste zurück und berechnen Sie die Anzahl basierend auf dem Geschlecht des Benutzers.
- Berechnen Sie den Gesamtbetrag nach Benutzeralter und berücksichtigen Sie auch das Geschlecht.
- Berechnen Sie das Durchschnittsalter insgesamt und nach Geschlecht.
User, die Felder enthält:
private int id;
private String name;
private int age;
private Sex sex;allUsers. Ich denke, es ist in Ordnung, wenn das der Fall istMap<Integer, User>
private static Map<Integer, User> allUsers;Id Wir müssen Benutzern auch irgendwie eine Sequenznummer zuweisen. Erstellen wir ein statisches Zählerfeld, das beim Erstellen eines neuen Benutzers dem Benutzer eine Sequenznummer zuweist .
private static int countId = 0;id, name, age, sex. Bei Heterae gibt es nichts Kompliziertes. Bitten wir IDEA um Hilfe , sie wird niemals ablehnen, und wir werden den Konstruktor ein wenig knifflig machen. Der Designer wird dazu in der Lage sein. Initialisieren Sie die Felder, prüfen Sie, ob ein solches Objekt vorhanden ist allUsers. Wenn kein solches Objekt vorhanden ist, erhöhen Sie unseren Zähler countId++und fügen Sie es zur Liste aller Benutzer hinzu. Und initialisieren Sie auch das Feld, allUsers wenn es noch nicht initialisiert wurde. Um die Suche nach identischen Objekten zu vereinfachen, werden wir die Methoden neu definieren equals()und erneut unsere geliebte IDEAhashCode() um Hilfe bitten und anhand der Felder , , vergleichen . Erstellen wir außerdem eine private Methode , die prüft, ob ein solches Objekt in der Liste enthalten ist. 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);
}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 +
'}';
}- Erstellen Sie eine Liste aller Benutzer.
- Erstellen Sie eine Liste der Benutzer nach Geschlecht (MÄNNLICH/WEIBLICH).
-
Geben Sie die Anzahl der Benutzer in der allgemeinen Liste zurück und berechnen Sie die Anzahl basierend auf dem Geschlecht des Benutzers.
public static int getHowManyUsers(){ return allUsers.size(); } public static int getHowManyUsers(Sex sex){ return getAllUsers(sex).size(); } -
Berechnen Sie den Gesamtbetrag nach Benutzeralter und berücksichtigen Sie auch das Geschlecht. Lassen Sie uns Methoden für diese Aufgabe erstellen.
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; } -
Berechnen Sie das Durchschnittsalter insgesamt und nach Geschlecht.
public static int getAverageAgeOfAllUsers(){ return getAllAgeUsers() / getHowManyUsers(); } public static int getAverageAgeOfAllUsers(Sex sex){ return getAllAgeUsers(sex) / getHowManyUsers(sex); }Großartig, wir haben das benötigte Objekt und sein Verhalten beschrieben. Jetzt können wir zu JUnit übergehen , aber zuerst zeige ich Ihnen, wie ein einfacher Test aussehen wird, wenn wir ihn in main durchführen .
public static void main(String[] args) { new User(„Eugen“, 35, Sex.MALE); new User("Yachthafen", 34, Sex.FEMALE); new User(„Alina“, 7, Sex.FEMALE); System.out.println("Alle Nutzer:"); User.getAllUsers().forEach(System.out::println); System.out.println(„Alle Benutzer: MÄNNLICH“); User.getAllUsers(Sex.MALE).forEach(System.out::println); System.out.println(„Alle Benutzer: WEIBLICH“); User.getAllUsers(Sex.FEMALE).forEach(System.out::println); System.out.println("================================================"); System.out.println(" Alle Nutzer: " + User.getHowManyUsers()); System.out.println(„alle MÄNNLICHEN Benutzer:“ + User.getHowManyUsers(Sex.MALE)); System.out.println(„alle WEIBLICHEN Benutzer:“ + User.getHowManyUsers(Sex.FEMALE)); System.out.println("================================================"); System.out.println(„Gesamtalter aller Benutzer:“ + User.getAllAgeUsers()); System.out.println(„Gesamtalter aller MÄNNLICHEN Nutzer:“ + User.getAllAgeUsers(Sex.MALE)); System.out.println(„Gesamtalter aller WEIBLICHEN Nutzer:“ + User.getAllAgeUsers(Sex.FEMALE)); System.out.println("================================================"); System.out.println(„Durchschnittsalter aller Nutzer:“ + User.getAverageAgeOfAllUsers()); System.out.println(„Durchschnittsalter aller MÄNNLICHEN Nutzer:“ + User.getAverageAgeOfAllUsers(Sex.MALE)); System.out.println(„Durchschnittsalter aller WEIBLICHEN Nutzer:“ + User.getAverageAgeOfAllUsers(Sex.FEMALE)); System.out.println("================================================"); }Die Ausgabe an die Konsole sieht in etwa so aus, und dann vergleichen wir, ob wir einen normalen Betrieb haben. Wir können natürlich tiefer gehen, eine Vergleichslogik schreiben und sehen, was unsere Berechnung aussagt, auch wenn wir nicht sicher sein werden, ob wir in der Lage waren, für alles zu sorgen.
//output Все пользователи: User{id=1, name=„Eugen“, age=35, sex=MALE} User{id=2, name='Yachthafen', age=34, sex=FEMALE} User{id=3, name=„Alina“, age=7, sex=FEMALE} Все пользователи: MALE User{id=1, name=„Eugen“, age=35, sex=MALE} Все пользователи: FEMALE User{id=2, name='Yachthafen', 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 0Wir sind mit diesem Ergebnis nicht zufrieden, da wir nach den Haupttests JUnit benötigen .
Die Punkte a und b können gut von einer Methode verarbeitet werden getAllUsers(), die eine Liste aller zurückgibt User, und einer überladenen Methode getAllUsers(Sex sex), die abhängig vom übergebenen Parameter eine Liste zurückgibt 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;
}
So verbinden Sie JUnit mit einem Projekt
Es stellt sich die Frage, wie man es mit dem Projekt verbindet. Für diejenigen, die es wissen: Ich werde die Option mit Maven nicht wählen , da dies eine völlig andere Geschichte ist. ;) Öffnen Sie die Projektstruktur Strg + Alt + Umschalt + S -> Bibliotheken -> klicken Sie auf + (Neue Projektbibliothek) -> wählen Sie aus Maven aus,
dann sehen wir ein solches Fenster, geben Sie „junit:junit:4.12“ in die Suchleiste ein , warte, bis es gefunden wird -> OK! -> Okay! 
Sie sollten dieses Ergebnis erhalten. 
Klicken Sie auf OK. Herzlichen Glückwunsch. JUnit wurde dem Projekt hinzugefügt. Lass uns weitermachen. Jetzt müssen wir Tests für unsere Java-Klasse erstellen, den Cursor auf den Namen der Klasse setzen User -> Alt + Eingabetaste drücken -> Test erstellen auswählen. Wir sollten ein Fenster sehen, in dem wir die JUnit4-Bibliothek auswählen müssen -> die Methoden auswählen, die wir testen möchten -> OK. 
Die Idee selbst wird eine Klasse erstellen UserTest. Dies ist die Klasse, in der wir unseren Code mit Tests abdecken. Lass uns anfangen:
Unser erster @Test
Lassen Sie uns unsere erste @Test- Methode erstellengetAllUsers()– dies ist eine Methode, die alle Benutzer zurückgeben sollte. Der Test wird in etwa so aussehen:
@Test
public void getAllUsers() {
// Testdaten erstellen
User user = new User(„Eugen“, 35, Sex.MALE);
User user1 = new User("Yachthafen", 34, Sex.FEMALE);
User user2 = new User(„Alina“, 7, Sex.FEMALE);
//Erstelle eine erwartete Liste und fülle sie mit den Daten unserer Methode
List<User> expected = User.getAllUsers();
//Erstelle eine tatsächliche Liste und füge Daten zum Vergleich ein
//was wir von der Methode erwarten
List<User> actual = new ArrayList<>();
actual.add(user);
actual.add(user1);
actual.add(user2);
//Führen Sie den Test aus, wenn die erwartete und die tatsächliche Liste nicht übereinstimmen
//Der Test schlägt fehl. Lesen Sie die Testergebnisse in der Konsole
Assert.assertEquals(expected, actual);
}expected in der wir die Benutzer platzieren, deren Methode zu uns zurückkehren wird getAllUsers()-> erstellen eine Liste actual , in der wir die Benutzer platzieren, von denen wir annehmen, dass die getAllUsers()Methode Assert.assertEquals(actual, erwartet) verwendet wird verwendet und wir geben die geprüften und aktuellen Listen an diese weiter. Diese Methode testet die Objekte in den bereitgestellten Listen und gibt das Testergebnis zurück. Die Methode vergleicht alle Felder von Objekten und geht bei Vererbung sogar die Felder der übergeordneten Objekte durch. Lassen Sie uns den ersten Test durchführen ... 
Der Test wurde erfolgreich abgeschlossen. Versuchen wir nun, den Test zum Scheitern zu bringen. Dazu müssen wir eine der Testlisten ändern. Dazu kommentieren wir die Hinzufügung eines Benutzers zur Liste aus actual.
@Test
public void getAllUsers() {
// Testdaten erstellen
User user = new User(„Eugen“, 35, Sex.MALE);
User user1 = new User("Yachthafen", 34, Sex.FEMALE);
User user2 = new User(„Alina“, 7, Sex.FEMALE);
//Erstelle eine erwartete Liste und fülle sie mit den Daten unserer Methode
List<User> expected = User.getAllUsers();
//Erstelle eine tatsächliche Liste und füge Daten zum Vergleich ein
//was wir von der Methode erwarten
List<User> actual = new ArrayList<>();
actual.add(user);
actual.add(user1);
//actual.add(user2);
//Führen Sie den Test aus, wenn die erwartete und die tatsächliche Liste nicht übereinstimmen
//Der Test schlägt fehl. Lesen Sie die Testergebnisse in der Konsole
Assert.assertEquals(expected, actual);
}
Jetzt können wir uns ein wenig mit der Ursache für das Scheitern des Tests befassen. Hier sehen wir, dass die überprüfte Liste mehr Benutzer enthält als die aktuelle. Dies ist der Grund für das Scheitern. Können wir das im Großen und Ganzen überprüfen? JUnit : main = 1 : 0. Mal sehen, wie der Test aussieht, wenn er völlig unterschiedliche Objekte enthält, machen wir es so:
@Test
public void getAllUsers() {
// Testdaten erstellen
User user = new User(„Eugen“, 35, Sex.MALE);
User user1 = new User("Yachthafen", 34, Sex.FEMALE);
User user2 = new User(„Alina“, 7, Sex.FEMALE);
//Erstelle eine erwartete Liste und fülle sie mit den Daten unserer Methode
List<User> expected = User.getAllUsers();
//Erstelle eine tatsächliche Liste und füge Daten zum Vergleich ein
//was wir von der Methode erwarten
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));
//Führen Sie den Test aus, wenn die erwartete und die tatsächliche Liste nicht übereinstimmen
//Der Test schlägt fehl. Lesen Sie die Testergebnisse in der Konsole
Assert.assertEquals(expected, actual);
}
Hier können Sie sofort erkennen, dass in den verglichenen Listen unterschiedliche Benutzer vorhanden sind. Wir können auch auf <Klicken, um den Unterschied anzuzeigen> klicken. Wir erhalten ein Fenster, in dem wir im Detail sehen können, welche Daten wir haben Problem mit. IDEA hebt alle Bereiche hervor, in denen es Unterschiede gibt. 
mainkann das passieren? - Nein. JUnit : main = 2 : 0 Nun, machen wir weiter, wir haben noch eine Menge Methoden, die mit Tests abgedeckt werden müssen), aber warten Sie, es wird nicht schlecht sein zu prüfen, ob die Methode zu uns getAllUsers()zurückkehrt , denn das ist was wir mit vom Validator abgefangenen JavaRush-null Aufgaben machen). Machen wir das, es geht um drei Kopeken...
@Test
public void getAllUsers_NO_NULL() {
//Prüfung auf Null hinzufügen
List<User> expected = User.getAllUsers();
Assert.assertNotNull(expected);
}null;) Lassen Sie uns nun diesen Test durchführen und sehen, was er uns zeigt. Und es wird ein Fehler angezeigt, wie???? Wie könnte hier ein Testfehler gemacht werden))) 
Und hier können wir die ersten Früchte der Abdeckung unseres Codes mit Tests ernten. Wie Sie sich erinnern, allUsers haben wir das Feld im Konstruktor initialisiert, was bedeutet, dass getAllUsers()wir beim Aufruf der Methode auf ein Objekt verweisen, das noch nicht initialisiert wurde. Lassen Sie uns es bearbeiten, die Initialisierung aus dem Konstruktor entfernen und dies beim Deklarieren des Felds tun.
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);
}
}
Ich glaube nicht, dass es einfach sein wird, NPEs in main zu fangen. Ich denke, Sie werden mir zustimmen, dass die Anzahl JUnit: main = 3: 0 ist. Dann werde ich alle Methoden mit Tests abdecken und Ihnen zeigen, wie es aussehen wird ... Jetzt sieht unsere Testklasse so aus:
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() {
// Testdaten erstellen
User user = new User(„Eugen“, 35, Sex.MALE);
User user1 = new User("Yachthafen", 34, Sex.FEMALE);
User user2 = new User(„Alina“, 7, Sex.FEMALE);
//Erstelle eine erwartete Liste und fülle sie mit den Daten unserer Methode
List<User> expected = User.getAllUsers();
//Erstelle eine tatsächliche Liste und füge Daten zum Vergleich ein
//was wir von der Methode erwarten
List<User> actual = new ArrayList<>();
actual.add(user);
actual.add(user1);
actual.add(user2);
//Führen Sie den Test aus, wenn die erwartete und die tatsächliche Liste nicht übereinstimmen
//Der Test schlägt fehl. Lesen Sie die Testergebnisse in der Konsole
Assert.assertEquals(expected, actual);
}
@Test
public void getAllUsers_NO_NULL() {
//Prüfung auf Null hinzufügen
List<User> expected = User.getAllUsers();
Assert.assertNotNull(expected);
}
@Test
public void getAllUsers_MALE() {
User user = new User(„Eugen“, 35, Sex.MALE);
User user1 = new User("Yachthafen", 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() {
//Prüfung auf Null hinzufügen
List<User> expected = User.getAllUsers(Sex.MALE);
Assert.assertNotNull(expected);
}
@Test
public void getAllUsers_FEMALE() {
User user = new User(„Eugen“, 35, Sex.MALE);
User user1 = new User("Yachthafen", 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() {
//Prüfung auf Null hinzufügen
List<User> expected = User.getAllUsers(Sex.FEMALE);
Assert.assertNotNull(expected);
}
@Test
public void getHowManyUsers() {
User user = new User(„Eugen“, 35, Sex.MALE);
User user1 = new User("Yachthafen", 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(„Eugen“, 35, Sex.MALE);
User user1 = new User("Yachthafen", 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(„Eugen“, 35, Sex.MALE);
User user1 = new User("Yachthafen", 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(„Eugen“, 35, Sex.MALE);
User user1 = new User("Yachthafen", 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(„Eugen“, 35, Sex.MALE);
User user1 = new User("Yachthafen", 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(„Eugen“, 35, Sex.MALE);
User user1 = new User("Yachthafen", 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: Die Annotation @Beforegibt an, dass die Methode vor jeder getesteten Methode ausgeführt wird @Test. So sieht unsere Testklasse mit Annotation nun aus @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(„Eugen“, 35, Sex.MALE);
user1 = new User("Yachthafen", 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() {
//Prüfung auf Null hinzufügen
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() {
//Prüfung auf Null hinzufügen
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 миллисекунд.Assertzur Überprüfung:
fail(String) – указывает на то что бы тестовый метод завалился при этом выводя текстовое сообщение.
assertTrue([message], boolean condition) – проверяет, что логическое Zustand истинно.
assertsEquals([String message], expected, actual) – проверяет, что два значения совпадают.
Примечание: для массивов проверяются ссылки, а не содержание массивов.
assertNull([message], object) – проверяет, что ein Objekt является пустым null.
assertNotNull([message], object) – проверяет, что ein Objekt не является пустым null.
assertSame([String], expected, actual) – проверяет, что обе переменные относятся к одному ein Objektу.
assertNotSame([String], expected, actual) – проверяет, что обе переменные относятся к разным ein Objektам.<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
GO TO FULL VERSION