Wie teste ich die Äquivalenz von Karten in Golang?

Ich habe einen tischgesteuerten Testfall wie diesen:

func CountWords(s string) map[string]int

func TestCountWords(t *testing.T) {
  var tests = []struct {
    input string
    want map[string]int
  }{
    {"foo", map[string]int{"foo":1}},
    {"foo bar foo", map[string]int{"foo":2,"bar":1}},
  }
  for i, c := range tests {
    got := CountWords(c.input)
    // TODO test whether c.want == got
  }
}

Ich könnte überprüfen, ob die Längen gleich sind, und eine Schleife schreiben, die prüft, ob jedes Schlüssel-Wert-Paar gleich ist. Aber dann muss ich diesen Scheck noch einmal schreiben, wenn ich ihn für einen anderen Kartentyp verwenden möchte (sagen wir map[string]string).

Am Ende habe ich die Maps in Strings konvertiert und die Strings verglichen:

func checkAsStrings(a,b interface{}) bool {
  return fmt.Sprintf("%v", a) != fmt.Sprintf("%v", b) 
}

//...
if checkAsStrings(got, c.want) {
  t.Errorf("Case #%v: Wanted: %v, got: %v", i, c.want, got)
}

Dies setzt voraus, dass die Zeichenfolgendarstellungen äquivalenter Karten identisch sind, was in diesem Fall der Fall zu sein scheint (wenn die Schlüssel gleich sind, haben sie den gleichen Wert, sodass ihre Reihenfolge gleich ist). Gibt es einen besseren Weg, dies zu tun? Was ist die idiomatische Methode, um zwei Karten in tabellengesteuerten Tests zu vergleichen?

In der Go-Bibliothek sind Sie bereits vertreten. Mach das:

import "reflect"
// m1 and m2 are the maps we want to compare
eq := reflect.DeepEqual(m1, m2)
if eq {
    fmt.Println("They're equal.")
} else {
    fmt.Println("They're unequal.")
}

Wenn Sie sich den Quellcode für reflect.DeepEqualden MapFall ansehen , werden Sie feststellen, dass zuerst überprüft wird, ob beide Karten Null sind, und dann überprüft wird, ob sie dieselbe Länge haben, bevor schließlich überprüft wird, ob sie denselben Satz von (Schlüssel, Wert) Paare.

Da reflect.DeepEqualein Schnittstellentyp verwendet wird, funktioniert er auf jeder gültigen Karte ( map[string]bool, map[struct{}]interface{}usw.). Beachten Sie, dass dies auch für Nicht-Kartenwerte funktioniert. Achten Sie also darauf, dass es sich bei der Übergabe tatsächlich um zwei Karten handelt. Wenn Sie zwei Ganzzahlen übergeben, wird Ihnen gerne mitgeteilt, ob sie gleich sind.

Was ist die idiomatische Methode, um zwei Karten in tabellengesteuerten Tests zu vergleichen?

Sie haben das Projekt go-test/deepzu helfen.

Aber: Dies sollte mit Go 1.12 (Februar 2019) nativ einfacher sein : Siehe Versionshinweise .

fmt.Sprint(map1) == fmt.Sprint(map2)

fmt

Karten werden jetzt in schlüsselsortierter Reihenfolge gedruckt, um das Testen zu vereinfachen .

Die Bestellregeln sind:

• Wenn zutreffend, vergleicht Null niedrig
• Ints, Floats und Strings werden nach sortiert <
• NaN vergleicht weniger als Nicht-NaN-Floats
• boolvergleicht falsevorhertrue
• Komplex vergleicht real, dann imaginär
• Zeiger vergleichen nach Maschinenadresse
• Kanalwerte werden nach Maschinenadresse verglichen
• Strukturen vergleichen nacheinander jedes Feld
• Arrays vergleichen nacheinander jedes Element
• Schnittstellenwerte werden zuerst verglichen, indem reflect.Typeder konkrete Typ beschrieben wird, und dann anhand des konkreten Werts, wie in den vorherigen Regeln beschrieben.

Beim Drucken von Karten wurden zuvor nichtreflexive Schlüsselwerte wie NaN als angezeigt <nil>. Ab dieser Version werden die richtigen Werte gedruckt.

Quellen:

• golang/goAusgabe 21095 ,
• Tweet (ursprüngliche Idee für diesen Patch: ᴊᴀᴍᴇꜱ ᴊᴜꜱᴛ ᴊᴀᴍᴇꜱ ( purpleidea)
• CL 142737 :

Der CL fügt hinzu: ( CL steht für "Change List" )

Dazu fügen wir im Stammverzeichnis ein Paket hinzuinternal/fmtsort , das einen allgemeinen Mechanismus zum Sortieren von Kartenschlüsseln unabhängig von ihrem Typ implementiert.

Dies ist ein wenig chaotisch und wahrscheinlich langsam, aber das formatierte Drucken von Karten war noch nie schnell und ist bereits immer reflexionsgetrieben.

Das neue Paket ist intern, weil wir wirklich nicht wollen, dass jeder, der dies verwendet, Dinge sortiert. Es ist langsam, nicht allgemein und nur für die Teilmenge der Typen geeignet, bei denen es sich um Kartenschlüssel handeln kann.

Verwenden Sie auch das Paket in text/template, das bereits eine schwächere Version dieses Mechanismus hatte.

Sie können sehen, dass in verwendet src/fmt/print.go#printValue(): case reflect.Map:

Folgendes würde ich tun (ungetesteter Code):

func eq(a, b map[string]int) bool {
        if len(a) != len(b) {
                return false
        }

        for k, v := range a {
                if w, ok := b[k]; !ok || v != w {
                        return false
                }
        }

        return true
}

Haftungsausschluss : Nicht im map[string]intZusammenhang mit dem Testen der Äquivalenz von Karten in Go, dem Titel der Frage

Wenn Sie eine Karte eines Zeigertyp (wie haben map[*string]int), dann Sie haben nicht wollen reflect.DeepEqual verwenden , weil es falsch zurück.

Wenn der Schlüssel ein Typ ist, der einen nicht exportierten Zeiger enthält, wie z. B. time.Time, reflektieren Sie. DepepEqual auf einer solchen Karte kann auch false zurückgeben .

Verwenden Sie die "Diff" -Methode von github.com/google/go-cmp/cmp :

Code:

// Let got be the hypothetical value obtained from some logic under test
// and want be the expected golden data.
got, want := MakeGatewayInfo()

if diff := cmp.Diff(want, got); diff != "" {
    t.Errorf("MakeGatewayInfo() mismatch (-want +got):\n%s", diff)
}

Ausgabe:

MakeGatewayInfo() mismatch (-want +got):
  cmp_test.Gateway{
    SSID:      "CoffeeShopWiFi",
-   IPAddress: s"192.168.0.2",
+   IPAddress: s"192.168.0.1",
    NetMask:   net.IPMask{0xff, 0xff, 0x00, 0x00},
    Clients: []cmp_test.Client{
        ... // 2 identical elements
        {Hostname: "macchiato", IPAddress: s"192.168.0.153", LastSeen: s"2009-11-10 23:39:43 +0000 UTC"},
        {Hostname: "espresso", IPAddress: s"192.168.0.121"},
        {
            Hostname:  "latte",
-           IPAddress: s"192.168.0.221",
+           IPAddress: s"192.168.0.219",
            LastSeen:  s"2009-11-10 23:00:23 +0000 UTC",
        },
+       {
+           Hostname:  "americano",
+           IPAddress: s"192.168.0.188",
+           LastSeen:  s"2009-11-10 23:03:05 +0000 UTC",
+       },
    },
  }

Einfachster Weg:

    assert.InDeltaMapValues(t, got, want, 0.0, "Word count wrong. Got %v, want %v", got, want)

Beispiel:

import (
    "github.com/stretchr/testify/assert"
    "testing"
)

func TestCountWords(t *testing.T) {
    got := CountWords("hola hola que tal")

    want := map[string]int{
        "hola": 2,
        "que": 1,
        "tal": 1,
    }

    assert.InDeltaMapValues(t, got, want, 0.0, "Word count wrong. Got %v, want %v", got, want)
}

Verwenden Sie stattdessen cmp ( https://github.com/google/go-cmp ):

if !cmp.Equal(src, expectedSearchSource) {
    t.Errorf("Wrong object received, got=%s", cmp.Diff(expectedSearchSource, src))
}

Es schlägt immer noch fehl, wenn die "Reihenfolge" der Karte in Ihrer erwarteten Ausgabe nicht dem entspricht, was Ihre Funktion zurückgibt. Kann cmpjedoch immer noch darauf hinweisen, wo die Inkonsistenz liegt.

Als Referenz habe ich diesen Tweet gefunden:

https://twitter.com/francesc/status/885630175668346880?lang=de

"Die Verwendung von Reflect.DeepEqual in Tests ist oft eine schlechte Idee. Deshalb öffnen wir http://github.com/google/go-cmp " - Joe Tsai

Eine der Optionen ist das Beheben von rng:

rand.Reader = mathRand.New(mathRand.NewSource(0xDEADBEEF))