JavaRush /جاوا بلاگ /Random-UR /JUnit حصہ I

سطح

28 February 2021
36 views
0 comments

JUnit حصہ I

JUnit :: یا JavaRush validator سے کیسے پیار کریں۔

مختصراً ہمیں اس جانور کی ضرورت کیوں ہے؟ JUnit آپ کے اچھے یا غیر اچھے کوڈ کو خود بخود جانچنے کا ایک فریم ورک ہے۔ آپ کہہ سکتے ہیں: - مجھے اس جھولے کی ضرورت کیوں ہے، میں اپنے اچھے جاوا کوڈ کو آسانی سے اور آسانی سے جانچ سکتا ہوں۔ آپ بہت سارے تعارفی اشعار لکھ سکتے ہیں، لیکن میں زیادہ شاعر نہیں ہوں، آئیے کاروبار پر اترتے ہیں...

ایک آبجیکٹ بنائیں

اور اس طرح، کسی چیز کو جانچنے کے لیے، ہمیں پہلے ایک ٹیسٹ آبجیکٹ کی ضرورت ہوتی ہے۔ ہمارے سامنے ایک کام ہے۔

ہمیں ایک ایسی چیز کی ضرورت ہے جو صارف کے بارے میں معلومات کو محفوظ کرے۔
1. آئی ڈی - کو اس ترتیب میں شمار کیا جانا چاہیے جس میں نئے صارف کو شامل کیا گیا تھا۔
2. صارف نام
3. اسکی عمر.
4. جنس (مرد/عورت)
صارفین کی فہرست کا ذخیرہ فراہم کرنا ضروری ہے۔
کلاس کو قابل ہونا چاہئے۔
1. تمام صارفین کی فہرست بنائیں۔
2. جنس کے لحاظ سے صارفین کی فہرست بنائیں (MALE/FEMALE)۔
3. عام فہرست میں صارفین کی تعداد لوٹائیں، اور صارف کی جنس کی بنیاد پر تعداد کا حساب لگائیں۔
4. صارف کی عمر کے لحاظ سے کل رقم کا حساب لگائیں، اور جنس کو بھی مدنظر رکھیں۔
5. مجموعی اور جنس کے لحاظ سے اوسط عمر کا حساب لگائیں۔

اور اس طرح، آئیے ایک آبجیکٹ بنانا شروع کریں... آئیے ایک جاوا کلاس بنائیں 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. sexheterae کے ساتھ کچھ بھی پیچیدہ نہیں ہے، آئیے IDEA سے مدد طلب کریں ، وہ کبھی انکار نہیں کرے گی، اور ہم کنسٹرکٹر کو تھوڑا مشکل بنائیں گے۔ ڈیزائنر کرنے کے قابل ہو جائے گا. فیلڈز کو شروع کریں، چیک کریں کہ آیا میں ایسی کوئی چیز موجود ہے allUsers، اگر ایسی کوئی چیز نہیں ہے، تو ہمارے کاؤنٹر کو بڑھائیں countId++اور اسے تمام صارفین کی فہرست میں شامل کریں۔ اور فیلڈ کو بھی شروع کریں allUsers اگر اسے ابھی تک شروع نہیں کیا گیا ہے۔ ایک جیسی اشیاء کو تلاش کرنے کی سہولت کے لیے ، ہم طریقوں کی از سر نو وضاحت کریں گے equals()اور ، دوبارہ ہم اپنے پیارے IDEAhashCode() سے مدد طلب کریں گے اور فیلڈز کے لحاظ سے موازنہ کریں گے ۔ اس کے علاوہ، آئیے ایک پرائیویٹ طریقہ بنائیں جو یہ چیک کرے گا کہ آیا ایسی چیز فہرست میں ہے یا نہیں۔ 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 +
            '}';
}

اب وقت آگیا ہے کہ مطلوبہ طریقوں کی منطق کو لاگو کیا جائے۔ چونکہ منطق بنیادی طور پر جامد فیلڈز کے ساتھ کام کرے گی، اس لیے ہم طریقوں کو بھی جامد بنائیں گے؛ اشیاء کے لیے ان کی ضرورت نہیں ہے۔

تمام صارفین کی فہرست بنائیں۔
جنس کے لحاظ سے صارفین کی فہرست بنائیں (MALE/FEMALE)۔

پوائنٹس 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;
}

عام فہرست میں صارفین کی تعداد لوٹائیں، اور صارف کی جنس کی بنیاد پر تعداد کا حساب لگائیں۔

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

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

صارف کی عمر کے لحاظ سے کل رقم کا حساب لگائیں، اور جنس کو بھی مدنظر رکھیں۔ آئیے اس کام کے لیے طریقے بناتے ہیں۔

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

مجموعی اور جنس کے لحاظ سے اوسط عمر کا حساب لگائیں۔

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

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

بہت اچھا، ہم نے مطلوبہ چیز اور اس کے رویے کو بیان کیا ہے۔ اب ہم JUnit کی طرف بڑھ سکتے ہیں ، لیکن پہلے میں آپ کو دکھاؤں گا کہ اگر ہم اسے مین میں کرتے ہیں تو ایک سادہ ٹیسٹ کیسا نظر آئے گا ۔

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 حصہ I - 2

پھر ہمیں ایسی ونڈو نظر آتی ہے، سرچ بار میں "junit:junit:4.12" درج کریں۔ ، انتظار کریں جب تک یہ نہیں مل جاتا -> ٹھیک ہے! -> ٹھیک ہے! JUnit حصہ I - 3

نتیجہ اس طرح نظر آنا چاہئے JUnit حصہ I - 4

OK پر کلک کریں، مبارک ہو JUnit کو پروجیکٹ میں شامل کر دیا گیا ہے۔ آئیے آگے بڑھیں۔ اب ہمیں اپنی جاوا کلاس کے لیے ٹیسٹ بنانے کی ضرورت ہے، کلاس کے نام پر کرسر لگائیں User -> Alt + Enter دبائیں -> Create Test کو منتخب کریں۔ ہمیں ایک ونڈو نظر آنی چاہئے جس میں ہمیں JUnit4 لائبریری کو منتخب کرنے کی ضرورت ہے -> وہ طریقے منتخب کریں جن کی ہم جانچ کرنے جارہے ہیں -> OK JUnit حصہ I - 5

آئیڈیا خود ایک کلاس بنائے گا UserTest، یہ وہ کلاس ہے جس میں ہم اپنے کوڈ کو ٹیسٹ کے ساتھ کور کریں گے۔ آو شروع کریں:

ہمارا پہلا @ ٹیسٹ

آئیے اپنا پہلا @Test طریقہ بنائیں getAllUsers()- یہ ایک ایسا طریقہ ہے جس سے تمام صارفین کو واپس آنا چاہیے۔ ٹیسٹ کچھ اس طرح نظر آئے گا:

@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.asserEquals(اصل، متوقع) طریقہ استعمال کیا جائے گا اور ہم اس کو فہرستیں، معائنہ اور موجودہ بھیجیں گے۔ یہ طریقہ فراہم کردہ فہرستوں میں اشیاء کی جانچ کرے گا اور ٹیسٹ کا نتیجہ واپس کرے گا۔ یہ طریقہ اشیاء کے تمام شعبوں کا موازنہ کرے گا، یہاں تک کہ اگر وراثت ہے تو والدین کے شعبوں سے گزرنا۔ آئیے پہلا ٹیسٹ چلائیں... JUnit حصہ I - 6

ٹیسٹ کامیابی سے مکمل ہو گیا۔ اب آئیے ٹیسٹ کو ناکام بنانے کی کوشش کریں، اس کے لیے ہمیں ٹیسٹ لسٹوں میں سے ایک کو تبدیل کرنا ہوگا، ہم اس فہرست میں ایک صارف کے اضافے پر تبصرہ کرکے کریں گے 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 حصہ I - 7

اب ہم ٹیسٹ میں ناکامی کی وجہ کو تھوڑا سا دیکھ سکتے ہیں۔ یہاں ہم دیکھتے ہیں کہ معائنہ شدہ فہرست میں موجودہ فہرست سے زیادہ صارفین ہیں۔ یہ ناکامی کی وجہ ہے۔ کیا ہم اسے بنیادی طور پر چیک کر سکتے ہیں؟ 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);
}

کنسول میں یہی ہوگا: JUnit حصہ I - 8

یہاں آپ فوری طور پر دیکھ سکتے ہیں کہ مقابلے کی فہرستوں میں مختلف صارفین ہیں، ہم فرق دیکھنے کے لیے <Click پر بھی کلک کر سکتے ہیں> ہمیں ایک ونڈو ملے گی جہاں ہم تفصیل سے دیکھ سکیں گے کہ ہمارے پاس کون سا ڈیٹا ہے۔ کے ساتھ مسئلہ. IDEA تمام شعبوں کو نمایاں کرے گا جہاں اختلافات ہیں۔ JUnit حصہ I - 9

mainکیا یہ ہو سکتا ہے؟ - نہیں. JUnit : main = 2 : 0 ٹھیک ہے، آئیے آگے بڑھتے ہیں، ہمارے پاس ابھی بھی بہت سے طریقے موجود ہیں جن کو ٹیسٹ کرنے کی ضرورت ہے)، لیکن انتظار کریں، یہ دیکھنا برا نہیں ہوگا کہ آیا یہ طریقہ ہمارے پاس getAllUsers()واپس آئے گا، کیونکہ یہ ہے۔ ہم جاوا رشnull ٹاسک کے ساتھ کیا کرتے ہیں جو تصدیق کنندہ کے ذریعہ پکڑے گئے ہیں)۔ چلو یہ کرتے ہیں، یہ تین کوپکس کا معاملہ ہے ...

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

ہاں، ہاں، یہ تقریباً اس طرح ہے کہ تصدیق کنندہ ہمارے ~~شٹی~~ کوڈ کو کیسے پکڑتا ہے null؛) اب آئیے اس ٹیسٹ کو چلائیں اور دیکھیں کہ یہ ہمیں کیا دکھاتا ہے۔ اور یہ ایک غلطی دکھائے گا، کیسے؟؟؟؟ یہاں ٹیسٹ کی غلطی کیسے کی جا سکتی ہے))) JUnit حصہ I - 10

اور یہاں ہم اپنے کوڈ کو ٹیسٹ کے ساتھ ڈھانپنے کا پہلا پھل حاصل کر سکتے ہیں۔ جیسا کہ آپ کو یاد ہے، 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);
        }
    }

آئیے ٹیسٹ چلائیں، اب سب کچھ ٹھیک ہے۔ JUnit حصہ I - 11

مجھے نہیں لگتا کہ مین میں این پی ای کو پکڑنا آسان ہو گا، مجھے لگتا ہے کہ آپ اس بات سے اتفاق کریں گے کہ گنتی 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 انحصار شامل کرسکتے ہیں۔

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

یہاں جاری -> JUnit حصہ II

تبصرے

TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION