JUnit Δοκιμές @Before @BeforeClass Annotation

⚡ Έξυπνη Σύνοψη

JUnit είναι το πιο ευρέως χρησιμοποιούμενο πλαίσιο δοκιμών μονάδων για Java, και οι σχολιασμοί των δοκιμαστικών στοιχείων του ελέγχουν ακριβώς τι συμβαίνει πριν και μετά την εκτέλεση κάθε δοκιμαστικής μεθόδου μέσα σε μια δοκιμαστική κλάση.

  • 🔘 Αναπόσπαστο εξάρτημα: Ένα δοκιμαστικό εξάρτημα είναι το σταθερό πλαίσιο αντικειμένων και πόρων στο οποίο εκτελείται μια δοκιμαστική περίπτωση.
  • ☑️ Ρύθμιση: Η συνάρτηση @Before εκτελείται πριν από κάθε μέθοδο δοκιμής, ενώ η συνάρτηση @BeforeClass εκτελείται μία φορά πριν από ολόκληρη την κλάση.
  • Teardown: Η συνάρτηση @After εκτελείται μετά από κάθε δοκιμή, ακόμα και όταν η δοκιμή καταλήγει σε σφάλμα ή ένας ισχυρισμός αποτυγχάνει.
  • 🧪 Παραγγελία: Η υπερκλάση @Before εκτελείται πρώτη, έπειτα η υποκλάση @Before, το @Test και έπειτα κάθε @After.
  • Δρομέας: JUnitΗ συνάρτηση Core.runClasses() εκτελεί κλάσεις δοκιμών και επιστρέφει ένα αντικείμενο Result που περιέχει κάθε αποτυχία.
  • 📊 JUnit 5: Τα @Before, @After, @BeforeClass και @AfterClass γίνονται @BeforeEach, @AfterEach, @BeforeAll και @AfterAll.

JUnit δοκιμαστικό εξάρτημα με σχολιασμούς @Before και @BeforeClass

JUnit είναι η πιο δημοφιλής μονάδα Δοκιμές πλαίσιο σε Java. Συνιστάται ρητά για Δοκιμή μονάδας. JUnit δεν απαιτεί διακομιστή για τη δοκιμή μιας διαδικτυακής εφαρμογής, γεγονός που καθιστά τη διαδικασία δοκιμής γρήγορη.

The JUnit Το πλαίσιο επιτρέπει επίσης τη γρήγορη και εύκολη δημιουργία δοκιμαστικών περιπτώσεων και δεδομένων δοκιμών. ο org.junit Το πακέτο αποτελείται από πολλές διεπαφές και κλάσεις για JUnit δοκιμές, όπως Test, Assert, After και Before. Το ευρύτερο JUnit Η οικογένεια χτίζει πάνω σε αυτά τα ίδια δομικά στοιχεία.

Τι είναι ένα δοκιμαστικό εξάρτημα;

Πριν κατανοήσουμε τι είναι ένα δοκιμαστικό εξάρτημα, ας μελετήσουμε τον παρακάτω κώδικα.

Αυτός ο κώδικας έχει σχεδιαστεί για να εκτελεί δύο δοκιμαστικές περιπτώσεις σε ένα απλό αρχείο.

public class OutputFileTest {
    private File output; 
    output = new File(...);
    output.delete(); 
public void testFile1(){
        //Code to verify Test Case 1
}
    output.delete();
    output = new File(...);
public void testFile2(){
        //Code to verify Test Case 2
}
 output.delete(); 
}

Λίγα θέματα εδώ

  • Ο κώδικας δεν είναι αναγνώσιμος.
  • Ο κώδικας δεν είναι εύκολο να διατηρηθεί.
  • Όταν η δοκιμαστική σουίτα είναι πολύπλοκη, ο κώδικας μπορεί να περιέχει λογικά ζητήματα.

Συγκρίνετε τον ίδιο κωδικό χρησιμοποιώντας JUnit.

public class OutputFileTest		
{
    private File output; 
    @Before public void createOutputFile() 
    { 
       output = new File(...);
    }
  
	@After public void deleteOutputFile() 
    {
        output.delete(); 
    } 
     
    @Test public void testFile1() 
    {
       // code for test case objective
    } 
	@Test public void testFile2() 
    {
       // code for test case objective
    }
}

Ο κώδικας είναι πολύ πιο ευανάγνωστος και συντηρήσιμος. Η παραπάνω δομή κώδικα είναι μια δοκιμαστικό εξάρτημα.

Ένα εξάρτημα δοκιμής είναι ένα πλαίσιο όπου α JUnit Δοκιμαστική θήκη τρέχει. Συνήθως, τα εξαρτήματα δοκιμής περιλαμβάνουν:

  • Αντικείμενα ή πόροι που είναι διαθέσιμοι για κάθε δοκιμαστική περίπτωση.
  • Απαιτούμενες δραστηριότητες που καθιστούν διαθέσιμα αυτά τα αντικείμενα και τους πόρους.
  • Αυτές οι δραστηριότητες είναι
    1. κατανομή (setup)
    2. αποκατανομή (teardown).

Ρύθμιση και Teardown

Τα εξαρτήματα έχουν σημασία επειδή JUnit τρέχει αυτά τα άγκιστρα σε κάθε δοκιμή.

  • Συνήθως, υπάρχουν μερικές επαναλαμβανόμενες εργασίες που πρέπει να γίνουν πριν από κάθε δοκιμαστική περίπτωση. Παράδειγμα: δημιουργήστε μια σύνδεση βάσης δεδομένων.
  • Ομοίως, στο τέλος κάθε δοκιμαστικής περίπτωσης, μπορεί να υπάρχουν μερικές επαναλαμβανόμενες εργασίες. Παράδειγμα: για εκκαθάριση μόλις ολοκληρωθεί η εκτέλεση της δοκιμής.
  • JUnit Παρέχει σχόλια που βοηθούν στην εγκατάσταση και την αποσυναρμολόγηση. Διασφαλίζει ότι οι πόροι απελευθερώνονται και το σύστημα δοκιμών βρίσκεται σε κατάσταση ετοιμότητας για την επόμενη δοκιμαστική περίπτωση.

Αυτοί JUnit Οι σχολιασμοί συζητούνται παρακάτω.

Ρύθμιση

@Πριν σχολιασμός σε JUnit χρησιμοποιείται σε μια μέθοδο που περιέχει Java κώδικας που θα εκτελείται πριν από κάθε περίπτωση δοκιμής, δηλαδή, εκτελείται πριν από κάθε εκτέλεση δοκιμής.

Teardown (ανεξάρτητα από την ετυμηγορία)

@Μετά η σχολίαση χρησιμοποιείται σε μια μέθοδο που περιέχει Java κώδικα που θα εκτελείται μετά από κάθε δοκιμαστική περίπτωση. Αυτές οι μέθοδοι θα εκτελούνται ακόμα και αν προκύψουν εξαιρέσεις στην δοκιμαστική περίπτωση ή σε περίπτωση αποτυχιών διεκδίκησης.

Σημείωση:

  • Επιτρέπεται να υπάρχει οποιοσδήποτε αριθμός σχολιασμών που αναφέρονται παραπάνω.
  • Όλες οι μέθοδοι που σχολιάζονται με @Πριν in JUnit θα εκτελούνται πριν από κάθε δοκιμαστική περίπτωση, αλλά μπορούν να εκτελούνται με οποιαδήποτε σειρά.
  • Μπορείτε να κληρονομήσετε τις μεθόδους @Before και @After από μια υπερκλάση. Η εκτέλεση έχει ως εξής και είναι μια τυπική διαδικασία εκτέλεσης στο JUnit.
  1. Εκτελέστε το JUnit @Before μέθοδοι στην υπερτάξη
  2. Εκτελέστε τις μεθόδους @Before σε αυτήν την κλάση
  3. Εκτελέστε μια μέθοδο @Test σε αυτήν την κλάση
  4. Εκτελέστε τις μεθόδους @After σε αυτήν την κλάση
  5. Εκτελέστε τις μεθόδους @After στην υπερκλάση

JUnit Σημείωση 5: αυτές οι σημειώσεις είναι JUnit 4 (org.junit). JUnit 5 τα μετονόμασαν σε org.junit.jupiter.api, και το JUnit Ο κώδικας 4 παρακάτω εξακολουθεί να εκτελείται με την vintage μηχανή.

JUnit 4 σχολιασμός JUnit 5 (Δίας) ισοδύναμο Τρέχει
@Πριν @ΠρινΚάθε Πριν από κάθε μέθοδο δοκιμής
@Μετά @AfterEach Μετά από κάθε μέθοδο δοκιμής
@Πριν το μάθημα @ΠρινΌλα Μία φορά μπροστά σε όλη την τάξη
@Μετά το μάθημα @AfterAll Μία φορά μετά από όλο το μάθημα
@Αγνοώ @Ανάπηρος Παραλείπει το σχολιασμένο τεστ

Παράδειγμα: Δημιουργία κλάσης με αρχείο ως δοκιμαστικό εξάρτημα

public class OutputFileTest		
{
    private File output; 
    @Before	public void createOutputFile() 
    { 
       output = new File(...);
    }
  
	@After public void deleteOutputFile() 
    {
        output.delete(); 
    } 
     
    @Test public void testFile1() 
    {
       // code for test case objective
    } 
	@Test public void testFile2() 
    {
       // code for test case objective
    }
}

Στο παραπάνω παράδειγμα, η αλυσίδα εκτέλεσης θα έχει ως εξής. Το διάγραμμα tracΥπάρχει ένας κύκλος δημιουργίας-δοκιμής-διαγραφής ανά μέθοδο δοκιμής.

JUnit Η εκτέλεση @Πριν και @Μετά αλυσιδώνεται γύρω από δύο μεθόδους δοκιμών

  1. createOutputFile()
  2. testFile1()
  3. deleteOutputFile()
  4. createOutputFile()
  5. testFile2()
  6. deleteOutputFile()

Υπόθεση:

Η συνάρτηση testFile1() εκτελείται πριν από την συνάρτηση testFile2(), κάτι που δεν είναι εγγυημένο.

Ρύθμιση μόνο μία φορά

  • Είναι δυνατό να εκτελεστεί μια μέθοδος μόνο μία φορά για ολόκληρη την κλάση δοκιμής πριν από την εκτέλεση οποιουδήποτε από τους ελέγχους και πριν από οποιαδήποτε @Πριν μέθοδος(ες).
  • Η «μόνο μία φορά εγκατάσταση» είναι χρήσιμη για την εκκίνηση διακομιστών, το άνοιγμα επικοινωνιών και παρόμοιες εργασίες. Είναι χρονοβόρο το κλείσιμο και το εκ νέου άνοιγμα πόρων για κάθε δοκιμή.
  • Αυτό μπορεί να γίνει χρησιμοποιώντας τον σχολιασμό @Πριν το μάθημα in JUnit.
@BeforeClass public static void Method_Name() {	
    // class setup code here	
 }	

Η μέθοδος πρέπει να είναι δημόσιο στατικό κενό, Επειδή JUnit το καλεί πριν υπάρξει οποιαδήποτε δοκιμαστική παρουσία.

Καταστρέψτε μόνο μια φορά

  • Παρόμοια με τη ρύθμιση "μόνο μία φορά", διατίθεται και μια μέθοδος καθαρισμού "μόνο μία φορά". Εκτελείται μετά από όλες τις μεθόδους δοκιμής και @Μετά έχουν εκτελεστεί σχολιασμοί.
  • Είναι χρήσιμο για τη διακοπήping διακομιστές και κλείσιμο συνδέσεων επικοινωνίας.
  • Αυτό μπορεί να γίνει χρησιμοποιώντας το @Μετά το μάθημα σχόλιο.
 @AfterClass public static void Method_Name()	
 {	
    // class cleanup code here	
 }	

JUnit Δοκιμαστικές Σουίτες

Με τα κατάλληλα φωτιστικά, οι σχετικές κλάσεις δοκιμών συνήθως ομαδοποιούνται και ξεκινούν μαζί.

Αν θέλουμε να εκτελέσουμε πολλαπλές δοκιμές με συγκεκριμένη σειρά, αυτό μπορεί να γίνει συνδυάζοντας όλες τις δοκιμές σε ένα μέρος. Αυτό το μέρος ονομάζεται σουίτα δοκιμών. Περισσότερες λεπτομέρειες σχετικά με τον τρόπο εκτέλεσης των σουιτών δοκιμών και τον τρόπο χρήσης τους στο JUnit καλύπτονται σε αυτό φροντιστήριο.

JUnit Δοκιμαστικός Δρομέας

JUnit παρέχει ένα εργαλείο για την εκτέλεση των δοκιμών σας.

  • JUnitπυρήνας Η κλάση χρησιμοποιείται για την εκτέλεση αυτών των δοκιμών.
  • Μια μέθοδος που ονομάζεται runClasses παρέχονται από org.junit.runner.JUnitπυρήνας χρησιμοποιείται για την εκτέλεση μιας ή περισσότερων δοκιμαστικών κλάσεων.
  • Ο τύπος επιστροφής αυτής της μεθόδου είναι ο Αποτέλεσμα αντικείμενο (org.junit.runner.Αποτέλεσμα), το οποίο χρησιμοποιείται για την πρόσβαση σε πληροφορίες σχετικά με τις δοκιμές. Δείτε το ακόλουθο παράδειγμα κώδικα για μεγαλύτερη σαφήνεια.
public class Test {				
			public static void main(String[] args) {									
       		Result result = JUnitCore.runClasses(CreateAndSetName.class);					
			for (Failure failure : result.getFailures()) {							
         		System.out.println(failure.toString());					
      }		
      System.out.println(result.wasSuccessful());					
   }		
}      

Στον παραπάνω κώδικα, το αντικείμενο "result" υποβάλλεται σε επεξεργασία για να λάβει αποτυχίες και επιτυχημένα αποτελέσματα των δοκιμαστικών περιπτώσεων που εκτελούμε. Βοηθητικά προγράμματα όπως επιβεβαιώσω ίσα να αναδείξω αυτές τις αποτυχίες, ενώ @Αγνοώ παραλείπει μια εξέταση.

JUnit Σημείωση 5: JUnitπυρήνας είναι το JUnit 4 δρομείς. JUnit 5 το αντικαθιστά με το JUnit Πλατφόρμα προωθητής API, που συνήθως ξεκινά από το IDE, Gradle ή Maven Surefire.

Όνομα JUnit Πρόγραμμα

Καλή γνώση του SDLC, Java προγραμματισμού και τα βασικά του δοκιμές λογισμικού η διαδικασία βοηθά στην κατανόηση ενός JUnit πρόγραμμα, όπως και η γνώση του πώς δοκιμές μονάδας διαφέρουν από τις δοκιμές ολοκλήρωσης.

Ας κατανοήσουμε τον έλεγχο μονάδων χρησιμοποιώντας ένα ζωντανό παράδειγμα. Πρέπει να δημιουργήσουμε μια κλάση δοκιμών με μια μέθοδο δοκιμής σχολιασμένη με @Δοκιμή όπως δίνεται παρακάτω:

MyFirstClassTest.java

package guru99.JUnit;		

import static org.junit.Assert.*;				

import org.junit.Test;		

public class MyFirstClassTest {				

    @Test		
    public void myFirstMethod(){					
        String str= "JUnit is working fine";					
        assertEquals("JUnit is working fine",str);					
    }
}		

TestRunner.java

Για να εκτελέσουμε τη μέθοδο δοκιμής μας (παραπάνω), πρέπει να δημιουργήσουμε έναν δοκιμαστικό εκτελέστη. Στον δοκιμαστικό εκτελέστη πρέπει να προσθέσουμε την κλάση δοκιμής ως παράμετρο στο JUnitΗ μέθοδος runClasses() του Core. Θα επιστρέψει το αποτέλεσμα της δοκιμής, με βάση το αν η δοκιμή είναι επιτυχής ή όχι.

Για περισσότερες λεπτομέρειες σχετικά με αυτό, δείτε τον παρακάτω κώδικα:

package guru99.JUnit;		

import org.junit.runner.JUnitCore;		
import org.junit.runner.Result;		
import org.junit.runner.notification.Failure;		

public class TestRunner {				
			public static void main(String[] args) {									
            Result result = JUnitCore.runClasses(MyFirstClassTest.class);					
			for (Failure failure : result.getFailures()) {							
              System.out.println(failure.toString());					
      }		
      System.out.println("Result=="+result.wasSuccessful());							
   }		
}      	

Παραγωγή

Μια φορά TestRunner.java εκτελεί τις μεθόδους δοκιμής μας και λαμβάνουμε ως αποτέλεσμα είτε αποτυχημένο είτε επιτυχές. Παρακάτω θα βρείτε την εξήγηση της εξόδου:

  1. Σε αυτό το παράδειγμα, μετά την εκτέλεση MyFirstClassTest.java, η δοκιμή έχει περάσει και το αποτέλεσμα είναι πράσινο.
  2. Αν είχε αποτύχει, θα είχε δείξει το αποτέλεσμα με κόκκινο χρώμα και η αποτυχία μπορεί να παρατηρηθεί στην αποτυχία. tracε. Δείτε το JUnit Γραφικό περιβάλλον χρήστη παρακάτω:

Eclipse JUnit προβολή που δείχνει μια πράσινη μπάρα διέλευσης για το MyFirstClassTest

Συχνές Ερωτήσεις

JUnit δημιουργεί μια νέα παρουσία της κλάσης δοκιμής για κάθε μέθοδο δοκιμής, επομένως δεν υπάρχει παρουσία όταν πρέπει να εκτελεστεί κώδικας σε επίπεδο κλάσης. Η δήλωση της μεθόδου ως στατική επιτρέπει JUnit επικαλεστείτε το απευθείας.

Όχι. Η σειρά των μεθόδων είναι σκόπιμα απροσδιόριστη. JUnit 4 προσφορές @FixMethodOrder και JUnit Το 5 προσφέρει @TestMethodOrder, αλλά ανάλογα με την παραγγελία σηματοδοτεί συζευγμένες δοκιμές.

Η μέθοδος δοκιμής δεν καλείται ποτέ και αναφέρεται ως σφάλμα, όχι ως αποτυχία. Οποιαδήποτε μέθοδος @After εξακολουθεί να εκτελείται, επομένως ο καθαρισμός πρέπει να ανέχεται ένα μερικώς κατασκευασμένο εξάρτημα.

Τα νέα έργα θα πρέπει να προσθέσουν το JUnit 5 συνολικά τεχνουργήματα org.junit.jupiter:junit-jupiter. Ομάδες που κατέχουν κληρονομιά JUnit 4 σουίτες προσθέτουν junit-vintage-engine, ώστε και οι δύο να λειτουργούν σε μία πλατφόρμα.

Ένα fixture είναι ολόκληρο το προετοιμασμένο πλαίσιο γύρω από μια δοκιμή, συμπεριλαμβανομένων πραγματικών αρχείων ή συνδέσεων. Ένα mock είναι ένας συνεργάτης αναπλήρωσης με σεναριακή συμπεριφορά, που συχνά δημιουργείται από το fixture.

Ναι, μέσω του @BeforeClass στο JUnit 4 ή @BeforeAll σε JUnit 5. Τα κοινόχρηστα εξαρτήματα είναι ταχύτερα αλλά παρουσιάζουν διαρροή, επομένως κρατήστε τα για ακριβούς πόρους μόνο για ανάγνωση.

Οι βοηθοί τεχνητής νοημοσύνης διαβάζουν μια κλάση, συμπεραίνουν τους συνεργάτες που χρειάζεται και συντάσσουν τη ρύθμιση @Before με το αντίστοιχο @After cleanup. Πάντα να ελέγχετε μόνοι σας τους δημιουργημένους ισχυρισμούς.

GitHub Copilot δημιουργεί μια κλάση δοκιμής από μια υπογραφή μεθόδου, συμπεριλαμβανομένων των σχολιασμών κύκλου ζωής. Συχνά έχει ως προεπιλογή την JUnit 4 εισαγωγές, οπότε επιβεβαιώστε ότι το πακέτο ταιριάζει με τον κινητήρα σας.

Συνοψίστε αυτήν την ανάρτηση με: