Zur Prüfung der Gleichwertigkeit von Karten in Golang?

Ich habe einen table-driven test Fall wie diesem:

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

Könnte ich prüfen, ob die Längen identisch sind, und schreiben Sie eine Schleife, die überprüft, ob alle Schlüssel-Wert-paar ist die gleiche. Aber dann habe ich, dies zu schreiben, noch einmal überprüfen, wenn ich es benutzen will, für eine andere Art von Karte (sagen map[string]string).

Was ich am Ende tun, ist, konvertierte ich die Karten auf Streicher und den Vergleich von strings:

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 string-Darstellungen von gleichwertigen Karten sind die gleichen, die scheint, um wahr zu sein in diesem Fall (wenn die keys sind die gleichen, dann werden Sie hash den gleichen Wert, so dass Ihre Bestellungen werden die gleichen sein). Gibt es einen besseren Weg, dies zu tun? Was ist die idiomatische Methode zum vergleichen von zwei Karten in table-driven-tests?

Äh, Nein: Die Reihenfolge der Iteration einer Karte nicht garantiert werden vorhersehbar: "Die iteration, um über die Karten ist nicht festgelegt und ist nicht garantiert das gleiche von einer zur nächsten iteration. ...".
Darüber hinaus wird für Karten von bestimmten Größen Gehen wird absichtlich in zufälliger Reihenfolge. Es ist sehr ratsam, nicht davon abhängen, dass um.
Versucht, zu vergleichen eine Karte ist ein design-Fehler in Ihrem Programm.
Beachten Sie, dass mit go 1.12 (Feb. 2019), Karten sind jetzt gedruckt in den Schlüssel-sortiert, um Leichtigkeit Tests. Siehe meine Antwort unten

InformationsquelleAutor andras | 2013-08-13

124

Go-Bibliothek bereits hat Sie bedeckt. Tun Sie dies:
```
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 man sich die source code für reflect.DeepEqual's Map Fall, wirst du sehen, dass zuerst überprüft wird, ob beide Karten sind gleich null, dann prüft Sie, ob Sie die gleiche Länge haben, bevor Sie schließlich überprüfen, um zu sehen, wenn Sie die gleiche Menge von (Schlüssel, Wert) - Paaren.

Weil reflect.DeepEqual nimmt ein interface-Typ ist, wird es auf keiner gültigen Karte (map[string]bool, map[struct{}]interface{}, etc). Beachten Sie, dass es funktioniert auch auf nicht-map-Werte, also seien Sie vorsichtig, dass das, was Sie sind vorbei, es sind wirklich zwei Karten. Wenn Sie übergeben Sie zwei ganze zahlen an, es wird fröhlich erzählen Sie, ob Sie gleich sind.
- Genial, das ist genau das, was ich suchte. Ich denke mal, so jnml wurde gesagt, dass es nicht so performant, aber wen kümmert das in einem Testfall.
- Ja, wenn Sie jemals wollen, dass diese für eine Produktion unter Anwendung würde ich auf jeden Fall gehen Sie mit einer selbst geschriebenen Funktion, wenn möglich, doch auf jeden Fall funktioniert der trick, wenn die Leistung ist kein Problem.
- Sie sollten auch check out gocheck. So einfach wie c.Assert(m1, DeepEquals, m2). Was ist schön ist, dass es bricht den test und sagt Ihnen, was Sie haben und was Sie erwartet in der Ausgabe.
- Es ist erwähnenswert, dass DeepEqual auch erfordert, dass die REIHENFOLGE der slices gleich.
- Dokumentation für DeepEqual.
InformationsquelleAutor joshlf
10

Dies ist, was ich tun würde (code ungetestet):
```
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
}
```
- OK, aber ich habe eine anderen test-Fall, wo ich vergleichen möchten Instanzen map[string]float64. eq funktioniert nur für map[string]int Karten. Sollte ich implementieren Sie eine version des eq - Funktion jedes mal, wenn ich vergleichen will-Instanzen eine neue Art von map?
- 11 SLOCs. Ich würde "kopieren-einfügen" spezialisieren, die es in kürzerer Zeit, als es dauert, danach zu Fragen. Obwohl, viele andere verwenden würden, "spiegeln", das gleiche zu tun, aber das ist viel schlechteren performance.
- nicht erwarten, die Karten werden in der gleichen Reihenfolge? Die gehen garantiert nicht unter "Iteration, um" auf blog.golang.org/go-maps-in-action
- Nein, denn wir Durchlaufen nur durch a.
InformationsquelleAutor zzzz
8

Was ist die idiomatische Methode zum vergleichen von zwei Karten in table-driven-tests?

Haben Sie das Projekt go-test/deep zu helfen.

Aber: dies sollte einfacher sein, mit Gehen 1.12 (Februar 2019) nativ: Siehe release notes.
fmt

Karten sind jetzt gedruckt in den Schlüssel-sortiert, um Leichtigkeit Tests.

Die Bestellung Regeln sind:
- Wenn anwendbar, nil vergleicht low
- ints, floats und strings bestellen von <
- NaN vergleicht, weniger als die nicht-NaN schwebt
- bool vergleicht false vor true
- Komplexe vergleicht real, imaginären
- Zeiger vergleichen Sie mit der Maschine-Adresse
- - Kanal-Werte zu vergleichen, durch die Maschine-Adresse
- Structs vergleichen Sie jedes Feld wiederum
- Arrays vergleichen Sie jedes element wiederum
- - Schnittstelle-Werte zunächst von reflect.Type beschreibt den konkreten Typ, und dann durch konkrete Wert wie im vorherigen Regeln.
Beim ausdrucken von maps, nicht-reflexive wichtige Werte wie NaN wurden zuvor dargestellt . Ab diesem release die richtigen Werte ausgedruckt werden.
Quellen:
- golang/gehen Problem 21095,
- Tweet (ursprüngliche Idee für diesen patch: ᴊᴀᴍᴇꜱ ᴊᴜꜱᴛ ᴊᴀᴍᴇꜱ (purpleidea)
- CL 142737:
CL-fügt: (CL steht für "Change-Liste")

Um dies zu tun, fügen wir ein Paket an der Wurzel, interne/fmtsort, implementiert einen Allgemeinen Mechanismus für die Sortierung von Karte, Schlüssel, unabhängig von Ihrem Typ.

Dies ist ein wenig chaotisch und wahrscheinlich langsam, aber formatiert drucken von Karten hat nie schnell und ist schon immer die Reflexion getrieben.

Dem neuen Paket, ist die interne, weil wir wirklich nicht möchten, dass jeder mit diesem, die Dinge zu Sortieren. Es ist langsam, nicht allgemein, und nur geeignet für die Teilmenge der Typen, die sein ansehen Schlüssel.

Auch das Paket für text/template, die bereits eine schwächere version dieses Mechanismus.

Können Sie sehen, dass in src/fmt/drucken.go#

InformationsquelleAutor VonC
4

Haftungsausschluss: unabhängig von map[string]int allerdings in Bezug auf die Prüfung der Gleichwertigkeit von maps in Go, das ist der Titel der Frage

Wenn Sie eine Karte von einem Zeiger-Typ (wie map[*string]int), dann jedoch nicht verwenden möchten, zu reflektieren.DeepEqual, weil es den Wert false zurück.

Schließlich, wenn der Schlüssel ist ein Typ, der enthält eine unexported Zeiger, wie die Zeit.Zeit, dann reflektieren.DeepEqual auf solch einer Karte kann auch false zurückgeben.

InformationsquelleAutor Carl

Inspiriert von diese Antwort, benutze ich zum testen die Gleichwertigkeit der Karten in Golang:

import (
    "reflect"
)

func TestContinuationTokenHash(t *testing.T) {
    expected := []string{"35303a6235633862633138616131326331613030356565393061336664653966613733",
        "3130303a6235633862633138616131326331613030356565393061336664653966613733",
        "3135303a6235633862633138616131326331613030356565393061336664653966613733",
        "null"}
    actual := continuationTokenRecursion("null")
    if !reflect.DeepEqual(expected, actual) {
        t.Errorf("Maps not equal. Expected %s, but was %s.", expected, actual)
    }
}

https://github.com/030/nexus3-cli

InformationsquelleAutor 030

-1

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",
+       },
    },
  }

InformationsquelleAutor Jonas Felber

-6

Eine der Optionen ist die rng-fix:
```
rand.Reader = mathRand.New(mathRand.NewSource(0xDEADBEEF))
```
- Pflege zu erklären, die downvote?
- Entschuldigen Sie mich, aber wie lautet Ihre Antwort auf diese Frage beziehen?
- golang intern verwendet rng, mischen Sie die Reihenfolge der Einträge in einer Karte. Wenn du die rng-fix erhalten Sie einen vorhersehbaren Bestellung für Testzwecke.
- Es spielt? Warum!? Ich bin ja nicht unbedingt bestreiten, dass es vielleicht (ich habe keine Ahnung) ich weiß nur nicht sehen, warum es wäre.
- Ich arbeite nicht auf Golang, so dass ich kann nicht erklären, Ihre Argumentation, aber das ist eine bestätigte Verhalten zumindest als der v1.9. Allerdings sah ich einige Erklärungen entlang der Linien von "wir wollen durchsetzen, dass Sie können nicht davon abhängen, ob die Bestellung in Karten, da sollte man nicht".
InformationsquelleAutor Grozz

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.