JUnit חלק א'

JUnit :: או איך לאהוב את אימות JavaRush

בקצרה על למה אנחנו צריכים את החיה הזו? JUnit היא מסגרת לבדיקה אוטומטית של הקוד הטוב או הלא כל כך טוב שלך . אתה יכול לומר: - למה אני צריך את הנדנדה הזו, אני יכול בקלות ובפשטות לבדוק את קוד ה-Java הטוב שלי. אתה יכול לכתוב הרבה מילות מבוא, אבל אני לא ממש משורר, בוא ניגש לעניינים...

צור אובייקט

ולכן, כדי לבדוק משהו, אנחנו צריכים קודם כל אובייקט בדיקה. יש לנו משימה לפנינו.

1. אנחנו צריכים אובייקט שיאחסן מידע על המשתמש.
   
   1. זיהוי - יש לספור לפי סדר הוספת המשתמש החדש.
   2. שם משתמש.
   3. הגיל שלו.
   4. מין זכר נקבה)

2. יש צורך לספק אחסון של רשימת משתמשים.

3. הכיתה חייבת להיות מסוגלת.

   1. צור רשימה של כל המשתמשים.
   2. צור רשימה של משתמשים לפי מין (זכר/נקבה).
   3. החזר את מספר המשתמשים ברשימה הכללית, וחשב את המספר לפי מינו של המשתמש.
   4. חשבו את הסכום הכולל לפי גיל המשתמש, וקחו בחשבון גם את המגדר.
   5. חשב את הגיל הממוצע, הן הכולל והן לפי מגדר.

וכך, בואו נתחיל ליצור אובייקט... בואו ניצור מחלקה של Java Userשתכיל שדות:

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

זה מספיק כדי לאחסן נתוני משתמש, בואו נראה מה עוד דרוש למשימה. אנחנו צריכים איכשהו לאחסן את כל המשתמשים, בואו נעשה שדה סטטי בכיתה שלנו allUsers, אני חושב שזה בסדר אם זהMap<Integer, User>

private static Map<Integer, User> allUsers;

אנחנו גם צריכים איכשהו להקצות מספר רצף למשתמשים, בואו ניצור שדה מונה סטטי, אשר בעת יצירת משתמש חדש, יקצה מספר רצף Id למשתמש.

private static int countId = 0;

אז נראה שסידרנו את השדות, בואו נכתוב בנאי עבור האובייקט שלנו, וגטרים עבור השדות id, name, age, sex. אין שום דבר מסובך עם הטרה, בוא נבקש עזרה מ-IDEA , היא לעולם לא תסרב, ואנחנו נעשה את הבנאי קצת מסובך. המעצב יוכל. אתחול השדות, בדוק אם יש אובייקט כזה ב allUsers, אם אין אובייקט כזה, אז הגדל את המונה שלנו countId++והוסף אותו לרשימת כל המשתמשים. וגם אתחול השדה allUsers אם הוא עדיין לא אתחול. לנוחות חיפוש חפצים זהים, נגדיר מחדש את השיטות equals()ושוב hashCode()נבקש עזרה מה- IDEA האהוב שלנו ונשווה לפי שדות name, age, sex. בנוסף, בואו ניצור שיטה פרטית hasUser()שתבדוק האם אובייקט כזה נמצא ברשימה.

@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 +
            '}';
}

עכשיו הגיע הזמן ליישם את ההיגיון של השיטות הנדרשות. מכיוון שהלוגיקה תעבוד בעיקר עם שדות סטטיים, נהפוך את השיטות גם לסטטיות, הן אינן נחוצות עבור אובייקטים.

1. צור רשימה של כל המשתמשים.
2. צור רשימה של משתמשים לפי מין (זכר/נקבה).

ניתן לטפל היטב בנקודות a ו- b על ידי שיטה getAllUsers()שתחזיר רשימה של כולם User, ושיטה עמוסה getAllUsers(Sex sex)שתחזיר רשימה, בהתאם לפרמטר שעבר 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. החזר את מספר המשתמשים ברשימה הכללית, וחשב את המספר לפי מינו של המשתמש.

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




4. חשבו את הסכום הכולל לפי גיל המשתמש, וקחו בחשבון גם את המגדר. בואו ניצור שיטות למשימה זו.

   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. חשב את הגיל הממוצע, הן הכולל והן לפי מגדר.

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

   נהדר, תיארנו את החפץ הנדרש ואת התנהגותו. עכשיו אנחנו יכולים לעבור ל- JUnit , אבל קודם אראה לכם איך תיראה בדיקה פשוטה אם נעשה אותה ב- 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("================================================");
   }

   הפלט לקונסולה ייראה בערך כך, ואז נשווה אם יש לנו פעולה רגילה. אפשר כמובן להעמיק, לכתוב היגיון השוואה ולראות מה אומר החישוב שלנו, למרות שלא נהיה בטוחים שהצלחנו לספק הכל.

   //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 0

   אנחנו לא מרוצים מהתוצאה הזו, עם הבדיקות העיקריות , אנחנו צריכים JUnit .

כיצד לחבר את JUnit לפרויקט

נשאלת השאלה כיצד לחבר אותו לפרויקט. למי שיודע, אני לא אקח את האופציה עם Maven , מכיוון שזה סיפור אחר לגמרי. ;) פתחו את מבנה הפרויקט Ctrl + Alt + Shift + S -> ספריות -> לחצו + (ספריית פרויקטים חדשה) -> בחרו מ-Maven, ואז אנו רואים חלון כזה, הזינו "junit:junit:4.12" בשורת החיפוש , המתן עד שהוא ימצא -> בסדר! -> בסדר! אתה אמור לקבל את התוצאה הזו לחץ על אישור, כל הכבוד JUnit נוספה לפרויקט. בוא נמשיך הלאה. עכשיו אנחנו צריכים ליצור מבחנים עבור מחלקה Java שלנו, לשים את הסמן על שם המחלקה User -> הקש Alt + Enter -> בחר create Test. אנחנו אמורים לראות חלון בו אנחנו צריכים לבחור את ספריית JUnit4 -> לבחור את השיטות שאנחנו הולכים לבדוק -> אישור הרעיון עצמו יצור מחלקה UserTest, זו המחלקה שבה נכסה את הקוד שלנו בבדיקות. בואו נתחיל:

ה @מבחן הראשון שלנו

בואו ניצור את שיטת ה-@TestgetAllUsers() הראשונה שלנו - זו שיטה שאמורה להחזיר את כל המשתמשים. הבדיקה תיראה בערך כך:

@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 בה נמקם את המשתמשים שהשיטה שלהם תחזור אלינו getAllUsers()-> יוצרים רשימה actual בה נציב את המשתמשים שאנו מניחים getAllUsers()ששיטת Assert.assertEquals(actual, expected) ישמש ונעביר אליו את הרשימות, הבדוקות והעדכניות. שיטה זו תבדוק את האובייקטים ברשימות המסופקות ותחזיר את תוצאת הבדיקה. השיטה תשווה את כל תחומי החפצים, אפילו עוברת בשדות ההורים אם יש ירושה. בואו נריץ את הבדיקה הראשונה... הבדיקה הושלמה בהצלחה. כעת ננסה לגרום לבדיקה להיכשל, לשם כך עלינו לשנות את אחת מרשימות הבדיקות, נעשה זאת על ידי הערה על הוספת משתמש אחד לרשימה 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);
}

אנו מריצים את הבדיקה ורואים את הדברים הבאים: כעת אנו יכולים להסתכל מעט על הסיבה לכישלון הבדיקה. כאן אנו רואים שיש יותר משתמשים ברשימה שנבדקה מאשר ברשימה הנוכחית. זו הסיבה לכישלון. האם נוכל לבדוק את זה בראשית? JUnit : main = 1 : 0. בוא נראה איך הבדיקה תיראה אם ​​היא מכילה אובייקטים שונים לגמרי, בוא נעשה זאת כך:

@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);
}

זה מה שיופיע בקונסולה: כאן אתה יכול לראות מיד שיש משתמשים שונים ברשימות ההשוואה, נוכל גם ללחוץ על <לחץ כדי לראות הבדל> נקבל חלון שבו נוכל לראות בפירוט איזה נתונים יש לנו בעיה עם. IDEA ידגיש את כל השדות שבהם יש הבדלים. mainהאם זה יכול לקרות? - לא. JUnit : main = 2 : 0 ובכן, בוא נמשיך הלאה, עדיין יש לנו חבורה של שיטות שצריך לכסות בבדיקות), אבל רגע, לא יהיה רע לבדוק אם השיטה תחזור getAllUsers()אלינו , כי זה מה אנחנו עושים עם nullמשימות JavaRush שנתפסו על ידי המאמת). בוא נעשה את זה, זה עניין של שלוש קופיקות...

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

כן, כן, זה בערך הדרך שבה המאמת תופס את הקוד המחורבןnull שלנו ;) עכשיו בואו נריץ את המבחן הזה ונראה מה הוא מראה לנו. וזה יראה שגיאה, איך???? איך אפשר לעשות שגיאת בדיקה כאן))) וכאן נוכל לקצור את הפירות הראשונים של כיסוי הקוד שלנו בבדיקות. כזכור, allUsers אתחול השדה בקונסטרוקטור, כלומר בעת קריאה למתודה getAllUsers()נתייחס לאובייקט שעדיין לא אותחל. בואו נערוך את זה, נסיר את האתחול מהקונסטרוקטור, ונעשה זאת בעת הכרזה על השדה.

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);
        }
    }

בוא נריץ את הבדיקה, עכשיו הכל בסדר. אני לא חושב שזה יהיה קל לתפוס NPEs ב-main, אני חושב שתסכים שהספירה היא JUnit: main = 3: 0 ואז אני אכסה את כל השיטות בבדיקות, ואתן לך לראות איך זה ייראה ... כעת כיתת המבחן שלנו נראית כך:

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- ההערה @Beforeמציינת שהשיטה תבוצע לפני כל שיטה שנבדקה @Test. כך תיראה כעת כיתת המבחן שלנו עם הערות @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);
    }
}

ובכן, מה איתכם, זה כבר יותר כיף וקל יותר לקריאה ;) הנה רשימה של הערות עבור JUnit, בהחלט קל יותר לחיות איתם.

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

שיטות עיקריות Assertלבדיקה:

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м.

כך נוכל להוסיף תלות של JUnit 4.12 ב-Maven

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

המשך כאן -> JUnit חלק II