Wenn Spock ' s @Shared annotation sollte bevorzugt über ein statisches Feld?

Gibt es nicht viel hinzuzufügen, die ganze Frage ist im Titel.

Betrachten Sie diese zwei Instanzen der Klasse Foo verwendet ein Spock-Spezifikation.

@Shared Foo foo1 = new Foo()

static Foo foo2 = new Foo()

Insgesamt, ich weiß, die Idee hinter @Shared Anmerkung, aber ich denke, es ist besser, die Sprache zu verwenden, die features, welche in diesem Fall wäre static Feld.

Gibt es bestimmte Fälle, in denen die eine der anderen vorgezogen oder ist es eher eine Frage des Geschmacks?

Afaik sind Sie genauso effektiv funktionell, aber @Shared besser zeigt Sie Ihre Absicht

InformationsquelleAutor topr | 2016-03-10

13

Spock ist alles über Ausdruckskraft und Klarheit.

Statische ist ein Java-Schlüsselwort, das zeigt nur die Interna der Klasse (in diesem Feld ist die gleiche für alle Instanzen)

@Freigegebenen ist ein Spock-feature, das sagt dem Leser, dass diese variable ist für alle die gleiche Funktion Methoden. Es ist eine Anweisung, die speziell für das Gerät testen und lässt den unit-test mehr klar für den Leser.

Das gleiche kann gesagt werden für die Haupt-Spock-Blöcke. Wenn Sie denken es Sie nicht wirklich etwas ändern am code.
```
public void myScenario(){
  int a = 2 + 3;
  assertEquals(5,a);
}

public void "simple addition scenario"(){
  when: "I add two numbers"
    int a = 2 +3

  then: "I expect the correct result"
  a == 5
}
```
Sowohl unit-tests genau das tun die gleiche Sache technisch. Den zweiten aber zeigt sich deutlich die Absicht. Die , wenn: und dann: Beschriftungen nicht wirklich etwas tun mit dem anderer code als der Klärung seiner Absichten.

Also zu summieren, @Freigegebenen macht der test mehr lesbar. (Siehe auch @Ausgabe, @Title etc., Sie existieren für den gleichen Zweck)
- Gut, es gibt leichte Unterschied in mit und nicht mit der 'then' block. Behauptet implizit auf jeder nicht-leere Zeile in einen solchen block. Aber vereinbart, die am meisten Wert kommt in der Lesbarkeit. Danke für die Antwort, ich bin bis stimmberechtigten es aber zu warten, ein bisschen mehr zu sehen, wenn alle anderen erscheinen. Ich bin daran interessiert zu sehen, ob es irgendwelche anderen no 'syntaktischen Zucker' Grund, lieber @gemeinsam über statische (oder Umgekehrt).
InformationsquelleAutor kazanaki

Im Gegensatz zu JUnit, wo Sie haben, um zu erklären Feld variable statische und Wert zuweisen, um es in

@BeforeClass
public static void setupClass()

damit es initialisiert wurde, nur einmal pro test-suite (nicht jede Methode), in der Spock können Sie mit Instanz-Feld, variable und kommentieren es mit @Shared.

Betrachten Sie das folgende Beispiel:

class SharedTestSpec extends spock.lang.Specification {

    @Shared
    def shared = shared()

    def shared() {
        "I came from ${this.class.simpleName}"
    }

    def 'Test one'() {
        given:
            println("test one, shared: $shared")
        expect: true
    }

    def 'Test two'() {
        given:
            println("test two, shared: $shared")
        expect: true

    }
}

class SubclassSpec extends SharedTestSpec {

    @Override
    def shared() {
        println("They've got me!")
        "I came from ${this.class.simpleName}"
    }
}

Läuft SubclassSpec gibt Ihnen die folgende Ausgabe:

test one, shared: I came from SubclassSpec
test two, shared: I came from SubclassSpec
They've got me!

Kann nicht erklären, der Druckauftrag zwar an, aber das ist aufgrund AST.

Interessant, danke. In der Summe beider Antworten: @Shared macht Spezifikation besser lesbar und ermöglicht es nutzt eine Instanz-basierten Methoden (wie überschreiben).

InformationsquelleAutor Valya

Als vollständiger Ansatz, hier ein Beispiel-test-mit-Ausgänge:

@Unroll
class BasicSpec extends Specification {

    int initializedVariable

    int globalVariable = 200

    static int STATIC_VARIABLE = 300

    @Shared
    int sharedVariable = 400

    void setup() {
        initializedVariable = 100
    }

    void 'no changes'() {
        expect:
            printVariables()
            /*
            initializedVariable: 100
            globalVariable: 200
            STATIC_VARIABLE: 300
            sharedVariable: 400
             */
    }

    void 'change values'() {
        setup:
            initializedVariable = 1100
            globalVariable = 1200
            STATIC_VARIABLE = 1300
            sharedVariable = 1400

        expect:
            printVariables()
            /*
            initializedVariable: 1100
            globalVariable: 1200
            STATIC_VARIABLE: 1300
            sharedVariable: 1400
             */
    }

    void 'print values again'() {
        expect:
            printVariables()
            /*
            initializedVariable: 100
            globalVariable: 200
            STATIC_VARIABLE: 1300
            sharedVariable: 1400
             */
    }

    private void printVariables() {
        println "initializedVariable: $initializedVariable"
        println "globalVariable: $globalVariable"
        println "STATIC_VARIABLE: $STATIC_VARIABLE"
        println "sharedVariable: $sharedVariable\n"
    }
}

Das überraschende für mich ist, dass sowohl die variable in der Klasse setup() - Methode ALS AUCH der globalen, instanzierte variable wieder auf jede Prüfung (vermutlich, weil die Klasse neu instanziert für jeden Testfall). Mittlerweile, die static und die @Shared Variablen wie erwartet arbeiten. Als Ergebnis, die zwei letzteren sind auch in der Lage, auf die zugegriffen werden, die in where Klauseln, die ausgeführt werden, bevor einige der anderen, die, die aufgeführt sind, vor der in jedem Fall testen.

Instanz-Variablen sind instantiiert für jede @Test Fall, kein Wunder, das gleiche gilt für JUnit. Können Sie erläutern, wie der Letzte Satz? Ich verstehe es nicht.

InformationsquelleAutor Igor

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.