Come testare l'equivalenza delle mappe a Golang?

Ho un test case basato su tabelle come questo:

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

Potrei controllare se le lunghezze sono le stesse e scrivere un ciclo che controlla se ogni coppia chiave-valore è la stessa. Ma poi devo scrivere di nuovo questo controllo quando voglio usarlo per un altro tipo di mappa (diciamomap[string]string ).

Quello che ho finito per fare è che ho convertito le mappe in stringhe e ho confrontato le stringhe:

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

Ciò presuppone che le rappresentazioni di stringa delle mappe equivalenti siano le stesse, il che sembra essere vero in questo caso (se le chiavi sono le stesse, hanno lo stesso valore, quindi i loro ordini saranno gli stessi). C'è un modo migliore per farlo? Qual è il modo idiomatico per confrontare due mappe nei test basati su tabelle?

La libreria Go ti ha già coperto. Fai questo:

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.")
}

Se guardi il codice sorgente di reflect.DeepEqualsMap caso di, vedrai che prima controlla se entrambe le mappe sono nulle, poi controlla se hanno la stessa lunghezza prima di verificare infine se hanno lo stesso set di (key, valore) coppie.

Poiché reflect.DeepEqualaccetta un tipo di interfaccia, funzionerà su qualsiasi mappa valida ( map[string]bool, map[struct{}]interface{}, ecc.). Nota che funzionerà anche su valori non mappa, quindi fai attenzione che ciò che stai passando ad esso sono in realtà due mappe. Se gli passi due numeri interi, ti dirà felicemente se sono uguali.

Qual è il modo idiomatico per confrontare due mappe nei test guidati da tabelle?

Hai il progetto go-test/deepda aiutare.

Ma: questo dovrebbe essere più semplice con Go 1.12 (febbraio 2019) in modo nativo : vedere le note di rilascio .

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

fmt

Le mappe vengono ora stampate in ordine di chiave per facilitare i test .

Le regole di ordinazione sono:

• Quando applicabile, zero confronta basso
• int, float e stringhe ordina per <
• NaN confronta meno di float non NaN
• boolconfronta falseprimatrue
• Complesso confronta reale, quindi immaginario
• I puntatori vengono confrontati in base all'indirizzo macchina
• I valori dei canali vengono confrontati in base all'indirizzo macchina
• Le strutture confrontano ogni campo a turno
• Gli array confrontano ogni elemento a turno
• I valori dell'interfaccia vengono confrontati prima reflect.Typedescrivendo il tipo di calcestruzzo e poi in base al valore concreto come descritto nelle regole precedenti.

Durante la stampa di mappe, i valori chiave non riflessivi come NaN venivano precedentemente visualizzati come <nil>. A partire da questa versione, vengono stampati i valori corretti.

Fonti:

• golang/gonumero 21095 ,
• Tweet (idea originale per quella patch: ᴊᴀᴍᴇꜱ ᴊᴜꜱᴛ ᴊᴀᴍᴇꜱ ( purpleidea)
• CL 142737 :

Il CL aggiunge: ( CL sta per "Change List" )

Per fare ciò, aggiungiamo un pacchetto alla radice,internal/fmtsort che implementa un meccanismo generale per ordinare le chiavi della mappa indipendentemente dal loro tipo.

Questo è un po 'disordinato e probabilmente lento, ma la stampa formattata delle mappe non è mai stata veloce ed è già sempre guidata dalla riflessione.

Il nuovo pacchetto è interno perché non vogliamo che tutti lo usino per ordinare le cose. È lento, non generale e adatto solo per il sottoinsieme di tipi che possono essere chiavi di mappa.

Usa anche il pacchetto in text/template, che aveva già una versione più debole di questo meccanismo.

Puoi vedere quello usato in src/fmt/print.go#printValue(): case reflect.Map:

Questo è quello che farei (codice non testato):

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
}

Disclaimer : non correlato amap[string]int ma correlata al test dell'equivalenza delle mappe in Go, che è il titolo della domanda

Se si dispone di una mappa di un tipo di puntatore (come map[*string]int), non si desidera utilizzare riflettere.DeepEqual perché restituirà false.

Infine, se la chiave è un tipo che contiene un puntatore non esportato, come time.Time, allora Reflect.DeepEqual su tale mappa può anche restituire false .

Utilizza il metodo "Diff" di github.com/google/go-cmp/cmp :

Codice:

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

Produzione:

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

Utilizza invece cmp ( https://github.com/google/go-cmp ):

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

Non riesce ancora quando l '"ordine" della mappa nell'output atteso non è quello restituito dalla funzione. Tuttavia, cmpè ancora in grado di indicare dove sia l'incongruenza.

Per riferimento, ho trovato questo tweet:

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

"L'utilizzo di Reflect.DeepEqual nei test è spesso una cattiva idea, ecco perché abbiamo aperto http://github.com/google/go-cmp " - Joe Tsai

Modo più semplice:

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

Esempio:

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

Una delle opzioni è correggere rng:

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