Test del programma, JUnit. Verifica del codice Java con JUnit - Tutorial Java Knowledge Test

Alla ricerca di problemi di test per i programmatori java, mi sono imbattuto in un sito interessante (gli utenti Avast non vanno, viene rilevato un Trojan di scripting, il resto probabilmente può) - http://www.betterprogrammer.com. Controlla le qualifiche dei programmatori Java nel modo più semplice, ma automatico: offrendo di scrivere diverse funzioni (metodi) di complessità crescente e copiare il codice nella TextArea. Inoltre, il motore del sito fa qualcosa con le attività (non diversamente da un test unitario), calcola un certo indice di qualificazione secondo i criteri "velocità-qualità" e assegna il voto finale in questa forma:

Poi iniziano le domande. Io stesso ho programmato in Java per la seconda volta nella mia vita (e quindi ho solo ribollito su compiti difficili), quindi l'82% in questo test corrisponde al livello programmatore non Java... Quanto dovrebbero essere reclutati Java Junior, Java Programmer e ancor di più Java Senior ?! Quale risultato aspettarsi presente programmatore java - 90, 95, 99? E infine, cosa succede se il "programmatore" ottiene meno di 82, ma fa comunque domanda per un qualche tipo di lavoro ?!

Java è un linguaggio di programmazione orientato agli oggetti e fortemente tipizzato sviluppato da Sun Microsystems nel 1991. Il linguaggio era originariamente chiamato Oak ed era destinato alla programmazione dell'elettronica di consumo, ma è stato successivamente ribattezzato Java. Il rilascio ufficiale di Java nel 1995 si è rivelato un grande successo e poco dopo Java ha assunto una posizione di rilievo come strumento di sviluppo di applicazioni server.

Al giorno d'oggi Java è utilizzato in tutte le aree dello sviluppo software - applicazioni server, applicazioni desktop, strumenti, applicazioni web - tutte sviluppate utilizzando Java e le relative tecnologie.

Destinatari del test Java

Il test Java contiene domande a cui la maggior parte degli sviluppatori con esperienza di programmazione Java minima conosce le risposte. Il test sarà utile a molti, comprese le persone che non hanno molta esperienza con Java e vogliono ottenere una comprensione minima dei concetti di base di questo popolare linguaggio di programmazione. Inoltre, questo test può essere utile per gli studenti che studiano Java, per consolidare le conoscenze acquisite nelle università o come risultato di un lavoro indipendente.

Prerequisiti del test Java

Si presume che prima di sostenere il test Java Fundamentals, si conoscano già i concetti di base come "variabile", "ciclo", "metodo" e si conosca la sintassi dei costrutti del linguaggio di base. Se questo non è il caso, ti consigliamo di familiarizzare prima con le basi di Java leggendo il corso introduttivo.

Struttura di test Java

Il test Java - Fundamentals copre i seguenti argomenti:

Puoi leggere di più sugli argomenti delle domande del test di seguito:

• Oggetti e classi: le domande su questo argomento trattano concetti quali classe, istanza di classe (oggetto), costruttori, metodi e campi di classe.
• Sintassi: le domande in questa sezione metteranno alla prova la tua conoscenza di parole chiave del linguaggio, operatori, tipi di base (primitive, String), costrutti di controllo (if-else, while, for) e comprensione della gestione delle eccezioni (Exception).
• Altro: questa sezione contiene domande riguardanti concetti di base, termini e abbreviazioni, convenzioni per la denominazione di classi, variabili e metodi. Questa sezione copre anche i file (.java, .class, .jar) e i pacchetti, il ciclo di vita degli oggetti e la garbage collection.

L'esecuzione di un test Java in linea ti aiuta a testare e consolidare la tua conoscenza dei fondamenti di Java e ti porta anche a sostenere i test più avanzati dalla sezione dei test Java.

Ci auguriamo che trovi questo test utile e divertente.

Ulteriore sviluppo del test Java

Il test Java viene costantemente aggiornato con nuove domande.

Nel prossimo futuro, il team di Quizful ha in programma di creare test Java di livello esperto. Forse il test Java Puzzlers verrà ancora creato, ma sfortunatamente si sta riempiendo molto lentamente di domande.

Se hai commenti sulle domande del test, assicurati di scriverci. In bocca al lupo.

I test non sono sempre divertenti e interessanti. Questo processo è solitamente piuttosto lungo e talvolta pieno di lavoro monotono. Sembra che non molto tempo fa i programmatori usassero l'output standard o il debugger per testare le classi java.

In questo articolo, descriverò la libreria JUnit 4, che semplifica e automatizza notevolmente il processo di scrittura dei test.

Per dimostrare le funzionalità di base di JUnit Framework, scriveremo una classe primitiva nel linguaggio Java e la prenderemo in giro. Questa classe avrà due metodi: trovare il fattoriale di un numero non negativo e la somma di due numeri. Inoltre, l'istanza della classe conterrà un contatore di chiamate al metodo.

Classe pubblica MathFunc (chiamate int; public int getCalls () (chiamate di ritorno;) fattoriale lungo pubblico (int numero) (chiama ++; if (numero 1) (for (int i \u003d 1; i

Ora scriviamo test unitari. Per fare ciò, creeremo una classe con una serie di metodi di test. Naturalmente, la classe può contenere anche normali metodi di supporto. Affinché il test runner possa determinare chi è chi, i metodi di test devono essere annotati con @Test.

Un'annotazione può avere i seguenti parametri:

• previsto - indica il tipo di eccezione che verrà lanciata dal metodo (vedi esempio sotto);
• timeout - dopo il quale tempo, in millisecondi, per interrompere l'esecuzione del test e considerarlo non riuscito.

Se vuoi indicare che un determinato test deve essere saltato, contrassegnalo con l'annotazione @Ignore. Sebbene sia possibile rimuovere semplicemente l'annotazione @Test.

Succede che hai bisogno di un contesto per eseguire ogni scenario di test, ad esempio istanze di classi pre-create. E dopo l'esecuzione, è necessario rilasciare le risorse riservate. In questo caso, sono necessarie le annotazioni @Before e @After. Il metodo contrassegnato con @Before verrà eseguito prima di ogni test case e il metodo contrassegnato con @After verrà eseguito dopo ogni test case.

Se è necessario inizializzare e rilasciare le risorse solo una volta, rispettivamente prima e dopo tutti i test, utilizzare un paio di annotazioni @BeforeClass e @AfterClass.

Ed ecco la stessa classe di test con diversi casi di test:

Public class MathFuncTest (private MathFunc math; @Before public void init () (math \u003d new MathFunc ();) @After public void tearDown () (math \u003d null;) @Test public void calls () (assertEquals (0, math .getCalls ()); math.factorial (1); assertEquals (1, math.getCalls ()); math.factorial (1); assertEquals (2, math.getCalls ());) @Test public void factorial () (assertTrue (math.factorial (0) \u003d\u003d 1); assertTrue (math.factorial (1) \u003d\u003d 1); assertTrue (math.factorial (5) \u003d\u003d 120);) @Test (previsto \u003d IllegalArgumentException.class) public void factorialNegative () (math.factorial (-1);) @Ignore @Test public void todo () (assertTrue (math.plus (1, 1) \u003d\u003d 3);))

Il metodo delle chiamate verifica la correttezza del contatore delle chiamate. Il metodo fattoriale verifica che il fattoriale sia calcolato correttamente per alcuni valori standard. Il metodo factorialNegative verifica che venga generata un'eccezione IllegalArgumentException per i valori fattoriali negativi. Il metodo todo verrà ignorato. Prova a rimuovere l'annotazione @Ignore durante la sperimentazione con il tuo codice.

Il metodo assertTrue controlla se il risultato dell'espressione è corretto. Alcuni altri metodi che potrebbero tornare utili:

• assertEquals: il risultato atteso e il risultato ricevuto sono gli stessi;
• assertNull - l'espressione restituisce null;
• assertNotNull - il risultato dell'espressione non è nullo;
• assertSame - gli oggetti attesi e ricevuti sono lo stesso oggetto.
• fail - il metodo genera un'eccezione AssertionError - aggiungila dove l'esecuzione del programma non dovrebbe raggiungere.

Nel nostro mondo moderno, gli IDE sanno come trovare ed eseguire semplicemente i test in un progetto. Ma cosa succede se si desidera avviarli manualmente utilizzando il codice del programma. Per fare questo, puoi usare il Runner: ci sono versioni testuali - junit.textui.TestRunner, versioni grafiche - junit.swingui.TestRunner, junit.awtui.TestRunner.

Ma un metodo leggermente più moderno consiste nell'usare la classe JUnitCore. Aggiungi il seguente metodo principale alla classe MathFuncTest:

Public static void main (String args) genera un'eccezione (JUnitCore runner \u003d new JUnitCore (); Result result \u003d runner.run (MathFuncTest.class); System.out.println ("run tests:" + result.getRunCount ()); System.out.println ("test non riusciti:" + result.getFailureCount ()); System.out.println ("test ignorati:" + result.getIgnoreCount ()); System.out.println ("successo:" + risultato .ha avuto successo ());)

E il risultato dell'esecuzione:

Esegui test: 3 test falliti: 0 test ignorati: 1 successo: vero

Nelle versioni precedenti di JUnit, per scrivere una classe di prova, era necessario creare un erede di junit.framework.TestCase. Quindi è stato necessario definire un costruttore che prende come parametro String - il nome del metodo - e lo passa alla classe genitore. Ogni metodo di prova doveva iniziare con il prefisso di prova. I metodi setUp e tearDown sono stati utilizzati per inizializzare e rilasciare le risorse. Insomma, orrore. Bene, ora è tutto semplice, sì.

È tutto per oggi. Sono sicuro che JUnit Framework ti aiuterà molto. Commenti e domande sull'articolo sono i benvenuti.

JUnit è una libreria per i programmi Java di unit test. Creato da Kent Beck ed Eric Gamma, JUnit appartiene alla famiglia di framework cross-language xUnit, originata da SUnit for Smalltalk di Kent Beck. JUnit ha generato un ecosistema di estensioni: JMock, EasyMock, DbUnit, HttpUnit e altre ancora.

Biblioteca JUnit è stato portato in altri linguaggi tra cui PHP (PHPUnit), C # (NUnit), Python (PyUnit), Fortran (fUnit), Delphi (DUnit), Free Pascal (FPCUnit), Perl (Test :: Unit), C ++ (CPPUnit) , Flex (FlexUnit), JavaScript (JSUnit).

JUnit È un framework Java per testare, ovvero testare singole parti di codice, come metodi o classi. L'esperienza acquisita con JUnit è importante nello sviluppo di concetti di test del software.

Esempio di prova JUnit

Importa org.junit.Test; import junit.framework.Assert; public class MathTest (@Test public void testEquals () (Assert.assertEquals (4, 2 + 2); Assert.assertTrue (4 \u003d\u003d 2 + 2);) @Test public void testNotEquals () (Assert.assertFalse (5 \u003d \u003d 2 + 2);))

La necessità di utilizzare JUnit

JUnit ti consente di verificare rapidamente che il tuo codice funzioni in qualsiasi momento. Se il programma non è molto semplice e include molte classi e metodi, potrebbe essere necessario molto tempo per testarlo. Naturalmente, questo processo è automatizzato meglio. Utilizzando JUnit consente di controllare il codice del programma senza sforzi significativi e non richiede molto tempo.

Test unitari le classi e le funzioni sono una sorta di documentazione di ciò che ci si aspetta come risultato della loro esecuzione. E non solo documentazione, ma documentazione che può controllare automaticamente il codice per la conformità con le funzioni presentate. Questo è conveniente e spesso i test vengono sviluppati sia insieme che prima dell'implementazione delle classi. Test Driven Development è una tecnologia estremamente popolare per la creazione di software serio.

Tipi di test e posizione dei test JUnit nella classificazione

Il test del software può essere suddiviso in due tipi:

• prova della scatola nera;
• test della scatola bianca.

Quando si testa un programma come una scatola nera, la struttura interna dell'applicazione non viene presa in considerazione. Tutto ciò che conta è la funzionalità che l'applicazione deve fornire. Quando si testa un programma come una scatola bianca, viene presa in considerazione la struttura interna, ad es. classe e metodi. Inoltre, il test può essere suddiviso in quattro livelli:

• unit test - test di singole sezioni del codice;
• test di integrazione: test dell'interazione e collaborazione dei componenti;
• test del sistema: test dell'intero sistema nel suo complesso;
• test di accettazione - il test finale del sistema finito per la conformità ai requisiti.

Il test unitario è per definizione test white box.

Lo unit test viene utilizzato in due versioni: JUnit 3 e JUnit 4. Consideriamo entrambe le versioni, poiché i progetti più vecchi utilizzano ancora la versione 3, che supporta Java 1.4.

JUnità 3

Per creare un test, è necessario ereditare la classe di test TestCase, sovrascrivere i metodi setUp e tearDown, se necessario e, cosa più importante, sviluppare metodi di test i cui nomi dovrebbero iniziare con l'abbreviazione "test". Quando viene eseguito un test, viene prima creata un'istanza della classe di test (per ogni test nella classe, un'istanza separata della classe), quindi viene eseguito il metodo setUp, viene avviato il test stesso e infine viene eseguito il metodo tearDown. Se uno qualsiasi dei metodi genera un'eccezione, il test viene considerato non riuscito.

Nota: i metodi di test devono essere public void, possono essere statici.

I test consistono nell'esecuzione di un codice e nel controllo. I controlli vengono eseguiti più spesso utilizzando la classe Asserire sebbene a volte venga utilizzata la parola chiave assert.

Ad esempio, considera un'utilità di stringa che include metodi per il controllo di una stringa vuota e che rappresenta una sequenza di byte come stringa esadecimale:

La classe pubblica JUnit3StringUtilsTest estende TestCase (private final Map toHexStringData \u003d new HashMap (); protected void setUp () genera un'eccezione (toHexStringData.put ("", nuovo byte); toHexStringData.put ("01020d112d7f", nuovo byte (1,2 13,17,45,127)); toHexStringData.put ("00fff21180", nuovo byte (0, -1, -14,17, -128)); // ...) protected void tearDown () genera un'eccezione (toHexStringData. clear ();) public void testToHexString () (for (Iterator iterator \u003d toHexStringData.keySet (). iterator (); iterator.hasNext ();) (stringa finale prevista \u003d (String) iterator.next (); byte finale testData \u003d (byte) toHexStringData.get (atteso); stringa finale effettiva \u003d StringUtils.toHexString (testData); assertEquals (atteso, effettivo);)) // ...)

Funzionalità aggiuntive, TestSuite

JUnit 3 ha diverse funzionalità aggiuntive. Ad esempio, puoi raggruppare i test. Per fare ciò, devi usare la classe TestSuite:

La classe pubblica JUnit3StringUtilsTestSuite estende TestSuite (public JUnit3StringUtilsTestSuite () (addTestSuite (StringUtilsJUnit3Test.class); addTestSuite (OtherTest1.class); addTestSuite (OtherTest) .class);

È possibile ripetere più volte l'esecuzione del test. Per questo, viene utilizzato RepeatedTest:

La classe pubblica JUnit3StringUtilsRepeatedTest estende RepeatedTest (public JUnit3StringUtilsRepeatedTest () (super (new JUnit3StringUtilsTest (), 100);))

Ereditando la classe di test da ExceptionTestCase, puoi controllare il codice per la generazione di un'eccezione:

La classe pubblica JUnit3StringUtilsExceptionTest estende ExceptionTestCase (public JUnit3StringUtilsExceptionTest (final String name) (super (name, NullPointerException.class);) public void testToHexString () (StringUtils.toHexString (null);))

Come puoi vedere dagli esempi, tutto è abbastanza semplice e niente di superfluo: un minimo di codice per i test di JUnit.

JUnit 4

JUnit 4 aggiunge il supporto per nuove funzionalità da Java 5.0; i test possono essere dichiarati utilizzando annotazioni. Allo stesso tempo, c'è la retrocompatibilità con la versione precedente del framework. Quasi tutti gli esempi precedenti funzioneranno in JUnit 4, ad eccezione di RepeatedTest, che manca nella nuova versione.

Quali modifiche sono state apportate in JUnit 4? Consideriamo lo stesso esempio, ma utilizzando le nuove funzionalità:

La classe pubblica JUnit4StringUtilsTest estende Assert (private final Map toHexStringData \u003d nuova HashMap (); @Before public static void setUpToHexStringData () (toHexStringData.put ("", nuovo byte); toHexStringData.put ("01020d112d7f", nuovo byte (1,2,13,17,45,127)); toHexStringData.put80 ("00fff211d7f" , nuovo byte (0, -1, -14,17, -128)); // ...) @After public static void tearDownToHexStringData () (toHexStringData.clear ();) @Test public void testToHexString () (per (Map.Entry entry: toHexStringData.entrySet ()) (byte finale testData \u003d entry.getValue (); stringa finale prevista \u003d entry.getKey (); stringa finale effettiva \u003d StringUtils.toHexString (testData); assertEquals (atteso, effettivo);)))

Cosa è cambiato in JUnit 4?

• Per semplificare il lavoro, puoi ereditare dalla classe Asseriresebbene questo sia facoltativo.
• annotazione @Prima denota metodi da chiamare prima di eseguire i test. I metodi dovrebbero essere vuoto pubblico... Qui è dove vengono solitamente posizionati i preset per il test, nel nostro caso questa è la generazione dei dati di test (method setUpToHexStringData).
• Può usare l'annotazione @Prima della lezione, che indica i metodi che verranno chiamati prima di creare un'istanza della classe di test; metodi dovrebbero essere vuoto statico pubblico... Ha senso utilizzare questa annotazione (metodo) per i test nel caso in cui la classe contenga più test utilizzando diversi preset, o quando più test utilizzano gli stessi dati, in modo da non perdere tempo a crearli per ogni test.
• annotazione @Dopo indica i metodi da chiamare dopo l'esecuzione dei test. I metodi dovrebbero essere vuoto pubblico... È qui che vengono collocate le operazioni per liberare risorse dopo il test; nel nostro caso, cancellando i dati del test (method tearDownToHexStringData).
• annotazione @Dopo la lezione significativamente correlato a @Prima della lezionema esegue i metodi dopo aver testato la classe. Come con @Prima della lezione, i metodi dovrebbero essere vuoto statico pubblico.
• annotazione @Test denota metodi di prova. Come prima, questi metodi dovrebbero essere vuoto pubblico... Gli stessi controlli vengono inseriti qui. Inoltre, questa annotazione può utilizzare due parametri, previsto - specifica l'eccezione prevista e il timeout - specifica il tempo dopo il quale il test viene considerato non riuscito.

Esempi di utilizzo di annotazioni con parametri, JUnit Test:

@Test (previsto \u003d NullPointerException.class) public void testToHexStringWrong () (StringUtils.toHexString (null);) @Test (timeout \u003d 1000) public void infinity () (while (true);)

Ignora l'esecuzione del test, JUnit Ignore

Se uno dei test deve essere disabilitato per qualsiasi motivo serio, ad esempio, il test fallisce continuamente. La correzione del test può essere posticipata fino a un futuro luminoso annotando @Ignorare... Se metti questa annotazione su una classe, tutti i test in quella classe saranno disabilitati.

@Ignore @Test (timeout \u003d 1000) public void infinity () (while (true);)

Regole di degustazione, JUnit Rule

JUnit consente di utilizzare regole definite dallo sviluppatore prima e dopo l'esecuzione del test, che estendono la funzionalità. Ad esempio, esistono regole integrate per impostare un timeout per un test (Timeout), per impostare eccezioni previste (ExpectedException), per lavorare con file temporanei (TemporaryFolder), ecc.

Per dichiarare una regola, devi creare pubblico non statico un campo di tipo derivato da MethodRule e annotarlo con una parola chiave Regola.

Classe pubblica JUnitOtherTest (@Rule public final TemporaryFolder folder \u003d new TemporaryFolder (); @Rule public final Timeout timeout \u003d new Timeout (1000); @Rule public final ExpectedException generata \u003d ExpectedException.none (); @Ignore @Test public void anotherInfinity ( ) (while (true);) @Test public void testFileWriting () genera IOException (final File log \u003d folder.newFile ("debug.log"); final FileWriter logWriter \u003d new FileWriter (log); logWriter.append ("Hello, "); logWriter.append (" World !!! "); logWriter.flush (); logWriter.close ();) @Test public void testExpectedException () genera IOException (thrown.expect (NullPointerException.class); StringUtils.toHexString (nullo);))

Suite di prova, JUnit Suite, SuiteClasses

L'esecuzione del test può essere configurata utilizzando l'annotazione @Corri con... Le classi di test che contengono metodi di test possono essere combinate in suite di test (Suite). Ad esempio, sono state create due classi di test degli oggetti: TestFilter, TestConnect. Queste due classi di test possono essere combinate in una classe di test TestWidgets.java:

Pacchetto com.objects; import org.junit.runner.RunWith; import org.junit.runners.Suite; @RunWith (Suite.class) @ Suite.SuiteClasses ((TestFilter.class, TestConnect.class)) classe pubblica TestWidgets ()

L'annotazione @SuiteClasses viene utilizzata per configurare i test da eseguire, incluse le classi di test.

Categorie astratte

annotazione Categorie ti permette di combinare i test in categorie (gruppi). Per fare ciò, il test definisce una categoria @Categoria, dopodiché vengono configurate le categorie di test di avvio nella Suite. Potrebbe assomigliare a questo:

Classe pubblica JUnitStringUtilsCategoriesTest extends Assert (// ... @Category (Unit.class) @Test public void testIsEmpty () (// ...) // ...) @RunWith (Categories.class) @ Categories.IncludeCategory ( Unit.class) @ Suite.SuiteClasses ((JUnitOtherTest.class, JUnitStringUtilsCategoriesTest.class)) classe pubblica JUnitTestSuite ()

Abstract, JUnit parametrizzato

annotazione Parametrizzato consente di utilizzare test parametrizzati. Per fare ciò, viene dichiarato un metodo statico nella classe di test che restituisce un elenco di dati che verranno utilizzati come argomenti al costruttore della classe.

@RunWith (Parameterized.class) classe pubblica JUnitStringUtilsParameterizedTest estende Assert (privato finale CharSequence testData; privato finale booleano previsto; pubblico JUnitStringUtilsParameterizedTest (finale CharSequence testData, finale booleano previsto) (this.test.expectedTest \u003d testData previsto \u003d atteso public void testIsEmpty () (final boolean actual \u003d StringUtils.isEmpty (testData); assertEquals (expected, actual);) @ Parameterized.Parameters public static List