Tempo di registrazione necessario per eseguire i test JUnit

Question

Desidero registrare quanto tempo impiega il mio test JUnit per l'esecuzione a livello di codice. Ho un gran numero di test in varie classi di test e vorrei sapere per quanto tempo ciascun metodo di test richiede di essere eseguito.

Posso modificare la struttura di ereditarietà o annotare i metodi in modo diverso, ma vorrei evitare di dover aggiungere codice all'interno del metodo di prova stesso e anche nei metodi prima/dopo che vengono utilizzati per impostare la logica di business del test.

Answer 1

È possibile creare un JUnit Rule che registra l'intervallo di tempo tra prima/dopo le chiamate. Questa regola può essere utilizzata come regola di istanza e/o classe per ottenere il tempo per ogni singolo metodo di test e per ogni classe di test.

Answer 2

Se si utilizza @Before e @After annotazioni e si noti l'inizio e la fine del testcase dell'unità junit. Quindi trovare la differenza di due timestamp dovrebbe darti il ​​tempo di esecuzione del testcase. Qualcosa del genere:

public class Example { 

    long startTime; 
    long endTime; 

    @Before public void recordStartTime() { 
     startTime = System.currentTimeMillis(); 
    } 
    @Test public void testSomething() { 
      //test method 
    } 
    @After public void recordEndAndExecutionTime() { 
     endTime = System.currentTimeMillis(); 
     System.out.println("Last testcase exection time in millisecond : " + (endTime - startTime)); 
    } 
} 

Answer 3

Prova a utilizzare @ Prima e @ Dopo. Un metodo annotato con @Before o @After viene eseguito prima o dopo il test.

Answer 4

È inoltre possibile creare un @Rule e creare un'istanza della classe TestWatcher. Questo è ciò che ha funzionato per me. Questo viene definito in una classe che estende TestCase.

public class CompositeWithTeardownDBUnitTest extends DBTestCase { 

DBTestCase estende TestCase

frammento di codice in CompositeWithTeardownDBUnitTest

@Rule 
public TestRule watcher = new TestWatcher() { 

    protected void starting(Description description) { 
     timeStart = System.currentTimeMillis(); 
     cal = Calendar.getInstance(); 
     System.out 
       .println("==========================================================================="); 
     System.out.println("Test: " + description.getMethodName()); 
     System.out.println("Start Time: " + dateFormat.format(cal.getTime())); 
     System.out 
       .println("==========================================================================="); 
    } 

    protected void finished(Description description) { 
     timeEnd = System.currentTimeMillis(); 
     double seconds = (timeEnd-timeStart)/1000.0; 
     System.out 
     .println("\n==========================================================================="); 
     System.out 
     .println("Test completed - ran in: "+new DecimalFormat("0.000").format(seconds)+" sec"); 
     System.out 
     .println("===========================================================================\n"); 

    } 
}; 

E le classi di test JUnit solo estendono questa classe CompositeWithTeardownDBUnitTest.

Answer 5

Oltre alle risposte esistenti, è possibile utilizzare una regola per il nome del test insieme ai metodi Before e After per visualizzare il nome del metodo nel registro. Come questo:

public class ImageSavingTest { 
    @Rule 
    public TestName name = new TestName(); 

    private long start; 

    @Before 
    public void start() { 
     start = System.currentTimeMillis(); 
    } 

    @After 
    public void end() { 
     System.out.println("Test " + name.getMethodName() + " took " + (System.currentTimeMillis() - start) + " ms"); 
    } 

    @Test 
    public void foobar() { 
     // test code here 
    } 
} 

Will uscita:

foobar prova ha preso 1828 ms

Answer 6

Crea il tuo TestWatcher implementazione che cattura ogni metodo di test in esecuzione. Utilizzando Guava Stopwatch si può misurare il tempo per ogni test:

public class TimeTestWatcher extends TestWatcher { 
    private Stopwatch stopwatch = Stopwatch.createUnstarted(); 

    protected void starting(Description description) { 
     stopwatch.start(); 
    } 

    protected void finished(Description description) { 
     stopwatch.stop(); 

     String testName = description.getMethodName(); 
     long elapsed = stopwatch.elapsed(TimeUnit.MILLISECONDS); 
     System.out.println(String.format("Test %s took %d ms.", testName, elapsed)); 
    } 
}; 

E quindi aggiungere JUnit @Rule annotazione con il vostro TimeTestWatcher per ciascuna classe di test:

public class YourTest { 

    @Rule 
    public TimeTestWatcher watcher = new TimeTestWatcher(); 

    @Test 
    public void testXXX() {} 

    @Test 
    public void testYYY() {} 
} 

Answer 7

è possibile utilizzare la regola JUnit cronometro e sovrascrivere i suoi metodi come previsto nella documentazione dell'API JUnit e avere l'ora stampata su console o file di registro per ogni test includendo solo una riga di codice in ciascuna delle singole classi di test case.

1. Create il vostro cliente di classe cronometro (esempio fornito)

   import java.util.concurrent.TimeUnit; 
   import org.junit.AssumptionViolatedException; 
   import org.junit.rules.Stopwatch; 
   import org.junit.runner.Description; 
   
   public class MyJUnitStopWatch extends Stopwatch{ 
   
   private static void logInfo(Description description, String status, long nanos) { 
       String testName = description.getMethodName(); 
       System.out.println(String.format("Test %s %s, spent %d microseconds", 
              testName, status, TimeUnit.NANOSECONDS.toMicros(nanos))); 
   } 
   
   @Override 
       protected void succeeded(long nanos, Description description) { 
        logInfo(description, "succeeded", nanos); 
       } 
   
       @Override 
       protected void failed(long nanos, Throwable e, Description description) { 
        logInfo(description, "failed", nanos); 
       } 
   
       @Override 
       protected void skipped(long nanos, AssumptionViolatedException e, Description description) { 
        logInfo(description, "skipped", nanos); 
       } 
   
       @Override 
       protected void finished(long nanos, Description description) { 
        logInfo(description, "finished", nanos); 
       }  
   } 
   

2. Avere un ParentTestClass creata con quella linea e ciascuna della vostra classe di test ereditare la classe sperimentale progenitore:

   public class ParentTestCase { 
   
   
   @Rule 
   public MyJUnitStopWatch stopwatch = new MyJUnitStopWatch(); 
   
   } 
   

Le classi figlio ereditano il genitore. Nessun altro cambiamento nelle classi Child o prima o dopo i metodi.

public class TestUniqueCharacterString extends ParentTestCase {  

    private String uniqueChars = null; 

    @Before 
    public void before(){ 
     uniqueChars = "abcdefghijklmnopqrstuvwxyzabcdefghijklmnop"; 
    } 

    @Test 
    public void testMyUniqueCharacterMethod(){ 


     UniqueCharacteString.doesStringHaveUniqueCharacters(uniqueChars); 
    } 

O

3. Includere questa linea in ciascuna della vostra classe Test

   @Rule 
   public MyJUnitStopWatch stopwatch = new MyJUnitStopWatch(); 
   

   campione Classe di prova:

   import org.junit.After; 
   import org.junit.Before; 
   import org.junit.Rule; 
   import org.junit.Test; 
   
   
   
   public class TestUniqueCharacterString {  
   
   @Rule 
   public MyJUnitStopWatch stopwatch = new MyJUnitStopWatch(); 
   
   private String uniqueChars = null; 
   
   @Before 
   public void before(){ 
       uniqueChars = "abcdefghijklmnopqrstuvwxyzabcdefghijklmnop"; 
   } 
   
   @Test 
   public void testMyUniqueCharacterMethod(){ 
   
   
       UniqueCharacteString.doesStringHaveUniqueCharacters(uniqueChars); 
   } 
   
   @Test 
   public void testGoodIsUniqueMethod(){ 
        UniqueCharacteString.isUniqueCharacs(uniqueChars); 
   } 
   
   @Test 
   public void testGoodIsUniqueMethodWithoutArray(){ 
       UniqueCharacteString.isUniqueCharsWithoutArray(uniqueChars); 
   } 
   
   @After 
   public void after(){ 
       uniqueChars = ""; 
   }  
   } 
   

JUnit riferimento API:

http://junit.org/apidocs/org/junit/rules/Stopwatch.html

Esempio di output

Test testMyUniqueCharacterMethod succeeded, spent 3250 microseconds 
Test testMyUniqueCharacterMethod finished, spent 3250 microseconds 
Test testGoodIsUniqueMethod succeeded, spent 70 microseconds 
Test testGoodIsUniqueMethod finished, spent 70 microseconds 
Test testGoodIsUniqueMethodWithoutArray succeeded, spent 54 microseconds 
Test testGoodIsUniqueMethodWithoutArray finished, spent 54 microseconds 

Inoltre mostrerà il tempo per casi di test falliti e saltato.