Record de temps qu'il faut JUnit tests à exécuter

Vous pouvez utiliser JUnit Chronomètre de la règle et de redéfinir ses méthodes prévues dans la JUnit documentation de l'API et le temps imprimé sur console ou un fichier journal pour chaque test, en incluant une ligne de code dans chacun de vos cas de test de la classe.

1. Créer votre Client Chronomètre classe (Échantillon)

   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. Ont un ParentTestClass créé avec de ligne et de chaque de votre classe de test hériter du parent de la classe de test:

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

Classes enfant hérite de parent. Aucun autre changement dans les classes Enfant, avant ou après les méthodes.

public class TestUniqueCharacterString extends ParentTestCase {    

    private String uniqueChars = null;

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

    @Test
    public void testMyUniqueCharacterMethod(){


        UniqueCharacteString.doesStringHaveUniqueCharacters(uniqueChars);
    }

Ou

1. Inclure cette ligne dans chaque classe de Test

   @Rule
   public MyJUnitStopWatch stopwatch = new MyJUnitStopWatch();

   Échantillon De La Classe De Test:

   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 référence de l'API:

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

Exemple De Sortie

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

Il sera également le moment de l'émission de l'échec et ignorées des cas de test.

OriginalL'auteur javaJavaJava

Vous pouvez également créer un @à la Règle et instancier le TestWatcher classe. C'est ce qui a fonctionné pour moi. Ce qui est défini dans une classe qui étend la classe TestCase.

public class CompositeWithTeardownDBUnitTest extends DBTestCase {

DBTestCase extends TestCase

extrait de code dans 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");

    }
};

Et le test JUnit classes d'étendre cette classe CompositeWithTeardownDBUnitTest.

OriginalL'auteur user3663214

En plus les réponses existantes, vous pouvez utiliser une règle pour le nom de test avec Before et After méthodes pour afficher le nom de la méthode sur le log. Comme ceci:

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

Sera de sortie:

Test foobar a pris 1828 ms

OriginalL'auteur Utku Özdemir

Si vous utilisez @Before et @Après les annotations et de noter les cas de test junit de début et de fin des temps. Puis la recherche de la différence de deux horodateurs devrait vous donner le cas de test temps d'exécution. Quelque chose comme ceci:

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

OriginalL'auteur Juned Ahsan