Che cosa è JUnit?
cherami
JUnit è un open source del framework di test Java utilizzato per scrivere ed eseguire test ripetibili.Lui è un sistema di unit testing framework xUnit per un'istanza (per il linguaggio Java).Esso include le seguenti caratteristiche:
1, per i test risultati attesi della affermazione (affermazione)
2, per la condivisione di strumenti comuni di dati di test di prova
3, per la convenienza dell 'organizzazione e il funzionamento del test della suite di test
4, la grafica e test runner di testo
JUnit è stato originariamente sviluppato da Erich Gamma (GoF One) e Kent Beck (xp e uno dei pionieri refactoring) preparato.
Va notato che JUnit è generalmente utilizzato per i test unitari, e quindi hanno bisogno di comprendere la struttura interna del codice in fase di test (i cosiddetti test white-box), l'altro è JUnit programmazione xp e refactoring (refactoring) è stato fortemente raccomandatostrumenti, unit testing automatico in quanto le circostanze può aumentare notevolmente l'efficienza di sviluppo, ma in realtà è la scrittura di codice di prova prende un sacco di tempo e fatica, quindi i vantaggi dell'utilizzo di questa roba Dove si trova?Io credo che è questo:
1, per la programmazione xp, chiede che le prove di scrittura prima di scrivere codice, che può costringere a pensare correttamente prima di scrivere il codice nel codice (metodi) della funzione e della logica, o scrivere il codice è instabile, quindi è necessario pur mantenendo lacodice di test e l'attuale codice, questo carico di lavoro aumenterà in modo significativo.Pertanto, in programmazione XP, il processo di base è questa: l'idea - "scrivere il codice test -" per scrivere codice - "test e prove di scrittura e la scrittura di codice sono incrementali, e scrivere un piccolo test che il codice nella preparazione del futuroSe vengono riscontrati problemi più blocchi possono essere ricondotte al problema, ridurre la difficoltà di correggere l'errore restituito
2, per la ricostruzione, i suoi benefici e la programmazione xp è simile, perché la ricostruzione è anche necessario per modificare un piccolo test, richiede meno tempo a causa di errori di ritorno.
3, per non due situazioni sopra descritte, quando sviluppiamo l'uso appropriato di scrivere test JUnit è necessario, perché la prova generale, abbiamo anche bisogno di scrivere codice, non potrà utilizzare il JUnit originale, se si sta usando JUnit, ma anche controInterface (metodi) per preparare codice di prova ridurrà i futuri lavori di manutenzione, come le modifiche all'interno del metodo dopo (questo è equivalente a lavori di ricostruzione.)affermazione Junit perché c'è un'altra funzione, se i risultati dei test non passano il test ci dirà che non passa, perché, e se la precedente prassi generale è quello di scrivere del codice di prova è quello di guardare la loro produzione, e quindi di determinare da sé i risultati ottenuti con il correttoutilizzando JUnit vantaggio è che questo risultato è corretto giudicare al completo, abbiamo solo bisogno di vedere le cose il diritto di dirci se i risultati possono, in generale, migliorerà notevolmente l'efficienza.
JUnit Getting Started
Per cherami
Installazione di JUnit
L'installazione è molto semplice, in primo luogo il seguente indirizzo per scaricare un nuovo pacchetto zip:
http://download.sourceforge.net/junit/
Dopo aver scaricato, estratto nella directory preferita, il presupposto è JUNIT_HOME, quindi JUNIT_HOME junit.jar quadro del pacchetto di aggiunte al sistema variabile di ambiente CLASSPATH, per l'ambiente IDE, la necessità di un maggiore utilizzo del progetto di JUnitlib, le sue diverse impostazioni IDE sono impostazioni diverse, dove non c'è molto da dire.
Come utilizzare JUnit per scrivere i test?
L'esempio più semplice:
1, creare una sottoclasse di TestCase:
pacchetto junitfaq;
import java.util .*;
importazione junit.framework .*;
public class SimpleTest estende TestCase {
pubblico SimpleTest (String name) {
super (nome);
}
2, scrivere un metodo di prova affermare i risultati attesi:
void testEmptyCollection pubblico () {
Raccolta collezione = new ArrayList ();
assertTrue (collection.isEmpty ());
}
Nota: test JUnit approccio è consigliato come l'inizio del metodo da testare, in modo che questi metodi possono essere trovati automaticamente dal test.
3, scrivere una suite () metodo, che utilizza la reflection per creare dinamicamente un metodo che contiene tutte le suite di test testXxxx:
pubblico suite statico Test () {
nuovo ritorno TestSuite (SimpleTest.class);
}
4, scrivere un metodo main () per eseguire il dispositivo in modalità testo per facilitare il funzionamento del test:
public static void main (String args []) {
junit.textui.TestRunner.run (suite ());
}
}
5, eseguire il test:
Esegui in modalità testo:
java junitfaq.SimpleTest
Attraverso i risultati del test sono le seguenti:
.
Tempo: 0
OK (1 test)
Time ha detto che la prova sul numero di piccoli punti, e se la prova appare OK.In caso contrario, il punto di piccolo dietro la F marcato, indica che il test non è riuscito.
Ciascuno dei risultati dei test dovrebbero essere OK, allora per spiegare la prova è riuscita, in caso di insuccesso le informazioni saranno immediatamente seguire le istruzioni rivisto.
rapporto di prova JUnit se non avrà successo, distinguere tra guasti (guasti) e di errori (errori).Il fallimento è il codice nel metodo fallisce a causa di affermare, e l'errore è causato dal codice anormali, come ArrayIndexOutOfBoundsException.
Graficamente eseguire:
java junit.swingui.TestRunner junitfaq.SimpleTest
I risultati dei test tramite l'interfaccia grafica della barra verde in parte.
Questi sono il campione più semplici, la prova effettiva, ci prova la funzione di una classe è spesso necessario eseguire alcune operazioni comuni, dopo il completamento della distruzione delle risorse necessarie (ad esempio le connessioni di rete, connessioni a database, chiudere i file apertiecc), classe TestCase ci fornisce un metodo di installazione e tearDown metodi, metodo di installazione per verificare il contenuto in preparazione del metodo della sottoclasse TestCase prima di ogni testXxxx verrà eseguito, e metodi tearDown dei contenuti dopo la fine di ogni metodo verrà eseguito testXxxx.Il codice di inizializzazione condiviso solo, ma elimina anche la potenziale interazione tra un codice di prova.
migliori pratiche di JUnit
Martin Fowler ha detto: "Quando si tenta di stampare alcune informazioni di debug o di un'espressione, scrivere del codice di prova per sostituire i metodi tradizionali." All'inizio, vi accorgerete che hai sempre voglia di creare qualche nuovo apparecchio, e la provaprogrammazione sembra rallentare se.Poco dopo, però, vi accorgerete che si ripete l 'impianto stesso, e il nuovo test è di solito solo prevede l'aggiunta di un nuovo metodo di prova.
Si può scrivere un sacco di codice di prova, ma presto scopre che si prevede solo una piccola parte del test è veramente utile.Hai bisogno di prova è la prova che avrà esito negativo, che si pensa non mancherà di tali test, o pensi che dovrebbero fallire la prova del successo.
Come abbiamo detto prima prova è un processo senza soluzione di continuità.Una volta che hai una prova, è necessario assicurarsi che il loro lavoro è stato quello di testare il vostro lavoro con l'aggiunta di nuovo codice.Non passano ogni pochi giorni o il giorno dell'ultima prova, si dovrebbe eseguire questo codice di test.Questo investimento è molto piccolo, ma può lavorare per garantire che si ottiene codice affidabile.Ridurre il tasso di ripresa, si avrà più tempo per scrivere codice funzionante.
Non pensate che la pressione, non scrivere il codice di prova.Anziché scrivere il codice di prova gradualmente ridurre lo stress, devono essere testati con la scrittura del codice, si ha l'esatto comportamento della comprensione della classe.Sarai più veloce di scrivere codice per lavorare in modo efficiente.
Ecco alcune competenze specifiche in scrittura di codice di prova o di buone pratiche:
1. Non utilizzare il costruttore inizializza TestCase Fixture, ma piuttosto usare il setup () e tearDown () metodo.
2. Non fate affidamento sugli o assumere che l'ordine di prove, perché il metodo di test JUnit usando Vector salvato.Così diverse piattaforme saranno in un ordine diverso, rimuovere con metodi di prova del vettore.
3. Per evitare gli effetti collaterali di preparazione di un TestCase.Ad esempio: se le prove successive e dipende dai dati specifica operazione, non presenta i dati delle transazioni.Semplicemente rotolare su di essa.
4. Quando si eredita una classe di test, ricordarsi di chiamare il setup superclasse () e tearDown () metodo.
5. Metterà alla prova il codice e il codice a lavorare insieme, allo stesso tempo di compilazione e di aggiornamento.(Utilizzo del Ant JUnit doveva supportare l'attività.)
6. Le classi di test e metodi di prova dovrebbe avere uno schema coerente di denominazione.Se il nome della classe operaia con il test per formare il nome della classe di test.
7. Al fine di assicurare che il test è indipendente dal tempo, non fare affidamento su dati obsoleti utilizzati per il test.Ha portato alla successiva manutenzione del processo è difficile da riprodurre la prova.
8. Se state scrivendo software per il mercato internazionale, la preparazione del test da considerare quando fattori internazionali.Native Locale non solo per il test.
9. Per quanto possibile per fornire l'utilizzo di JUnit per far valere / non il metodo e il metodo di gestione delle eccezioni può rendere il codice più conciso.
10. La prova di essere il più piccolo possibile, l'attuazione di velocità.
Combinazione di JUnit e formica
cherami Links
formica fornisce due target: JUnit e junitreport
Eseguire tutti i casi di test, e generare report in formato HTML
Per effettuare le seguenti operazioni:
1. Directory ANT_HOMElib sul junit.jar
. 2 Modificare build.xml, aggiungere il seguente:
name="report" property value="report" target / name="junitreport" depends="clean, compile" printsummary JUnit = "on" forchetta = "vero "haltonfailure =" "failureproperty =" false "showoutput =" tests.failed " vero classpath refid="myclasspath"/ formatter type="xml"/ batchtest adir = "$ {report}" fileset dir="${build}" include name="**/*Test.*"/ /set di file / batchtest / JUnit junitreport dir="${report}" todir="${report}" fileset include name = "TEST-*. xml "/ / set di file report format="frames" todir="${report}"/ / junitreport fallire se =" tests.failed "; --------------------------------------------------------- Uno o più test fallito, controllare il rapporto per il dettaglio ... --------------------------------------------------------- / non / target
Esegui questo obiettivo, formica verrà eseguito ogni TestCase
Directory nella relazione c'è un sacco di test *. xml e alcune pagine
Aprire la directory index.html report si può vedere una molto intuitivo rapporti di prova eseguito in un colpo d'occhio.