Aufzeichnung der Zeit, die es dauert JUnit-tests ausführen

Ich möchte aufzeichnen, wie lange es dauert, mein JUnit-test ausgeführt werden, die programmgesteuert. Ich habe eine große Anzahl von tests in verschiedenen test-Klassen, und ich möchte, um herauszufinden, wie lange jede einzelne test-Methode ausgeführt.

Ich ändern kann, die Vererbung von Struktur oder kommentieren von Methoden anders, aber ich möchte vermeiden, fügen Sie code hinzu, der innerhalb der test-Methode selbst und auch im vorher - /nachher-Methoden, die verwendet werden, um setup-test von business-Logik.

Beabsichtigen Sie, diese laufen in einem build-tool, beispielsweise Maven? Oder wollen Sie Eclipse oder ähnliches?

InformationsquelleAutor oneself | 2013-07-09

Könnten Sie die JUnit-Stoppuhr-Regel und überschreiben Sie die Methoden in der JUnit-API-Dokumentation und die Zeit gedruckt auf Konsole oder log-Datei für jeden test nur durch, darunter eine Zeile code in jede einzelne test-case-Klasse.

Erstellen Sie Ihre Kunden StopWatch-Klasse (Probe)

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

Haben eine ParentTestClass erstellte Zeile und jedes der test-Klasse, erbt die übergeordneten test-Klasse:

public class ParentTestCase {


@Rule
public MyJUnitStopWatch stopwatch = new MyJUnitStopWatch();

}

Kind-Klassen erbt Eltern. Keine andere änderung in Kind-Klassen oder vor oder nach Methoden.

public class TestUniqueCharacterString extends ParentTestCase {    

    private String uniqueChars = null;

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

    @Test
    public void testMyUniqueCharacterMethod(){


        UniqueCharacteString.doesStringHaveUniqueCharacters(uniqueChars);
    }

Oder

Fügen Sie dieser Zeile in jedem der Test-Klasse

@Rule
public MyJUnitStopWatch stopwatch = new MyJUnitStopWatch();

Probe-Test-Klasse:

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 API Referenz:

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

Beispiel-Ausgabe

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

Es wird auch zeigen, Zeit für Fehler und ausgelassenen Testfälle.

InformationsquelleAutor javaJavaJava

7

Versuchen mit @Before und @After.
Eine Methode annotiert mit @Before oder @After ausgeführt wird, bevor oder nachdem die Probe.
```
    @Before
    public void start() {
        start = System.currentTimeMillis();
    }

    @After
    public void end() {
        System.out.println(System.currentTimeMillis() - start);
    }
```
- Danke, aber ich möchte vermeiden, dass diese zu jedem test-Klasse in meinem Projekt. Gibt es eine Möglichkeit, fügen Sie diese an einem Ort?
- Aus einer übergeordneten test-Fall mit diesen beiden Methoden, und für jede test-Klasse, erweitern die übergeordneten test-Fall.
- Wenn der test hat seine eigenen vor/nach Methoden, wie kann ich werden, garantiert, dass die timing-Methoden ausführen würde, die unmittelbar vor und nach dem test? Ansonsten hätte ich vielleicht auch die Zeit Messen, die es dauert, den test vor/nach Methoden zu führen.
- Wenn ja, sollten Sie erstellen Sie Ihre eigenen timing-Funktion. Sie müssen auslösen und stoppen Sie die timing-Funktion durch sich selbst.
InformationsquelleAutor Heejin

Sie können auch eine @ - Regel und instanziieren Sie die TestWatcher Klasse. Das ist was für mich gearbeitet. Dieser wird in einer Klasse definiert, erstreckt TestCase.

public class CompositeWithTeardownDBUnitTest extends DBTestCase {

DBTestCase extends TestCase

code-snippet 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");

    }
};

Und die JUnit-test-Klassen nur erweitern diese Klasse CompositeWithTeardownDBUnitTest.

InformationsquelleAutor user3663214

Erstellen Sie Ihre eigenen TestWatcher Umsetzung, die fängt jeder test-Methode ausgeführt. Mit Guave Stoppuhr können Sie die Zeit Messen, die für jeden 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));
    }
};

Und fügen Sie JUnit @Rule annotation mit Ihren TimeTestWatcher für jede test-Klasse:

public class YourTest {

    @Rule
    public TimeTestWatcher watcher = new TimeTestWatcher();

    @Test
    public void testXXX() {}

    @Test
    public void testYYY() {}
}

InformationsquelleAutor jlogics

Zusätzlich zu den bestehenden Antworten, können Sie eine Regel für test-name zusammen mit Before und After Methoden, um display-Methode, die Namen auf-log. Wie diese:

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

Ausgabe:

Test foobar nahm 1828 ms

InformationsquelleAutor Utku Özdemir

0

Könnten Sie eine JUnit-Regel, die aufzeichnen würde, die Zeit zwischen vor/nach anrufen. Diese Regel kann verwendet werden als eine Instanz und/oder Klasse Regel bekommen Sie die Zeit, die für jede einzelne test-Methode sowie für jede test-Klasse.

InformationsquelleAutor cjstehno

Wenn Sie mit @Before und @After Annotationen und beachten Sie die junit-testcase start-und Endzeit. Dann finden Sie die Differenz von zwei timestamps sollten geben Sie den testcase-Ausführung. So etwas wie dieses:

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

InformationsquelleAutor Juned Ahsan

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.