[GO] Implementieren Sie einen tabellengesteuerten Test in Java

Dieser Eintrag ist für GMO Ad Marketing Adventskalender 2018 (Https://qiita.com/advent-calendar/2018/gmo-am) [12/09] Artikel. Dies ist das erste GMO-Werbemarketing, das am Adventskalender teilnimmt.

Einführung

In der Go-Sprache ist es üblich, Testcode in Form eines tabellengesteuerten Tests zu schreiben. Das Wort "Go-ness" wird unter Go-Ingenieuren häufig verwendet. Der Quellcode muss immer wie Go geschrieben sein. Ich denke, es gibt einige Unklarheiten im Wort Go-ness, Der tischgesteuerte Test ist eine der Einzigartigkeiten von Go. Dieses Mal werde ich ein Beispiel für die Einführung von Go-ness in Java vorstellen.

Was ist ein tabellengesteuerter Test?

Der tabellengesteuerte Test wird auf den folgenden Seiten beschrieben. https://github.com/golang/go/wiki/TableDrivenTests

In Table Driven Test wird ein Testfall durch eine Struktur dargestellt, die zur Ausführung des Tests in einer Schleife ausgeführt wird. Dieses Mal habe ich zur Erklärung einen Teiltest von [pow.go] erstellt (https://golang.org/src/math/pow.go).

package main

import (
	"testing"
	"math"
)

func TestPow(t *testing.T) {
	for _, tt := range []struct {
		name     string
		x        float64
		y        float64
		expected float64
	}{
		{"Pow(2,1)", 2, 1, 2},
		{"Pow(2,2)", 2, 2, 4},
		{"Pow(2,3)", 2, 3, 8},
		{"Pow(2,0)", 2, 0, 1},
		{"Pow(2,-1)", 2, -1, 0.5},
		{"Pow(0,2)", 0, 2, 0},
		{"Pow(2,+Inf)", 2, math.Inf(0), math.Inf(0)},
		{"Pow(2,-Inf)", 2, math.Inf(-1), 0},
		{"Pow(+Inf,2)", math.Inf(0), 2, math.Inf(0)},
		{"Pow(-Inf,2)", math.Inf(-1), 2, math.Inf(0)},
	} {
		t.Run(tt.name, func(t *testing.T) {
			result := math.Pow(tt.x, tt.y)
			if result != tt.expected {
				t.Errorf("expected: %v, result: %v", tt.expected, result)
			}
		})
	}
}

In diesem Beispiel definiert die Struktur den Testnamen, die Methodenargumente und die erwarteten Werte. Wenn Sie so schreiben, was jeder Wert darstellt Es macht es auch einfacher zu sehen, was Sie testen.

In Java implementierter tabellengesteuerter Test

Verwenden Sie die in JUnit 5 hinzugefügten Funktionen, um den tabellengesteuerten Test in Java zu implementieren.

Diesmal habe ich einen Pow-Test für die Mathe-Klasse erstellt. In diesem Beispiel wird lombok verwendet, um den Quellcode einfach zu halten.

import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.experimental.Accessors;
import org.junit.jupiter.api.*;

import java.util.stream.Stream;

import static org.junit.jupiter.api.Assertions.assertEquals;

class MathTest {

    @Nested
    static class Pow {

        @AllArgsConstructor
        @Getter
        @Accessors(fluent = true)
        static class TestCase {
            private String name;
            private double x;
            private double y;
            private double expected;
        }

        @TestFactory
        Stream<DynamicNode> testPow() {
            return Stream.of(
                    new TestCase("pow(2,1)", 2, 1, 2),
                    new TestCase("pow(2,2)", 2, 2, 4),
                    new TestCase("pow(2,3)", 2, 3, 8),
                    new TestCase("pow(2,0)", 2, 0, 1),
                    new TestCase("pow(2,-1)", 2, -1, 0.5),
                    new TestCase("pow(2,+Inf)", 2, Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY),
                    new TestCase("pow(2,-Inf)", 2, Double.NEGATIVE_INFINITY, 0),
                    new TestCase("pow(+Inf,2)", Double.POSITIVE_INFINITY, 2, Double.POSITIVE_INFINITY),
                    new TestCase("pow(-Inf,2)", Double.NEGATIVE_INFINITY, 2, Double.POSITIVE_INFINITY)
            ).map(testCase -> DynamicTest.dynamicTest(
                    testCase.name(),
                    () -> {
                        double result = Math.pow(testCase.x(), testCase.y());
                        assertEquals(testCase.expected(), result);
                    })
            );
        }
    }

}

In JUnit 5 können Sie eine innere Klasse mit `` `@ Nested``` definieren, um Tests zu verschachteln. In diesem Beispiel wird der Test durch eine innere Klasse namens Pow definiert.

In Pow definieren wir eine innere Klasse namens TestCase. Die TestCase-Felder definieren den Testnamen, die Argumente, die an die Methode übergeben werden sollen, und das erwartete Ergebnis. Der in jedem Testfall verwendete Wert wird im TestCase-Konstruktor übergeben.

Wenn Sie hier eine Klasse wie Tuple verwenden, Es ist schwer zu sagen, was jeder Wert, den Sie an Tuple übergeben, darstellt. Indem Sie den Testfall in einer inneren Klasse wie im Beispiel haben Sie können einem benannten Feld einen Wert zuordnen.

Wir verwenden die neuen dynamischen Tests von JUnit 5 (https://junit.org/junit5/docs/current/user-guide/#writing-tests-dynamic-tests), um die Tests auszuführen. @testfactoryDurch Anhängen an eine Methode, die einen dynamischen Knotenstrom, eine Sammlung usw. zurückgibt. Sie können den Test dynamisch ausführen.

Zusammenfassung

Durch die Kombination der Funktionen von JUnit 5 mit der Güte der Go-Sprache Ich konnte einen gut lesbaren Test in Java schreiben. Es wäre großartig, wenn wir weiterhin die guten Seiten anderer Sprachen wie Go-ness in Java integrieren könnten.

GVO-Adventskalender 2018, der bis Weihnachten dauert Bleib dran für mehr Beiträge!

■ Techblog von Ingenieuren ist jetzt verfügbar! https://techblog.gmo-ap.jp/ ■ Angeblich sind Seitenblogs und Jobs für die Öffentlichkeit zugänglich! ~ https://www.wantedly.com/projects/199431 ■ Seite zur Einstellung von Ingenieuren - Klicken Sie hier, um Informationen zu Wohlfahrt und verschiedenen Systemen zu erhalten. https://www.gmo-ap.jp/engineer/ ■ Rekrutierung eines Praktikanten als Ingenieur! -Erleben Sie die Entwicklungssite mit einem bezahlten Praktikanten- https://hrmos.co/pages/gmo-ap/jobs/0000027