गोलंग में नक्शों की समानता का परीक्षण कैसे करें?

Question 1

मेरे पास इस तरह एक टेबल-संचालित परीक्षण मामला है:

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

मैं जाँच सकता है कि क्या लंबाई समान है और एक लूप लिखें जो यह जांचता है कि क्या प्रत्येक कुंजी-मान जोड़ी समान है। लेकिन फिर मुझे इस चेक को फिर से लिखना होगा जब मैं इसे दूसरे प्रकार के नक्शे (कहना map[string]string) के लिए उपयोग करना चाहता हूं ।

मैंने जो किया वह समाप्त कर दिया, मैंने नक्शे को तार में बदल दिया और तार की तुलना की:

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

यह मानता है कि समतुल्य मानचित्रों के स्ट्रिंग निरूपण समान होते हैं, जो इस मामले में सही प्रतीत होते हैं (यदि कुंजियाँ समान हैं तो उनके पास समान मान है, इसलिए उनके आदेश समान होंगे)। क्या ऐसा करने के लिए इससे अच्छा तरीका है? टेबल-चालित परीक्षणों में दो मानचित्रों की तुलना करने के लिए मुहावरेदार तरीका क्या है?

Question 2

गो लाइब्रेरी आपको पहले ही कवर कर चुकी है। यह करो:

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

यदि आप 's केस के सोर्स कोड को देखते हैं, तो आप देखेंगे कि यह पहले चेक करता है कि क्या दोनों मैप्स nil हैं, फिर यह चेक करता है कि क्या उनके पास एक ही लेंथ है या नहीं, यह देखने के लिए कि क्या उनके पास एक ही सेट है (की, मूल्य) जोड़े।reflect.DeepEqualMap

क्योंकि reflect.DeepEqualएक इंटरफ़ेस प्रकार लेता है, यह किसी भी मान्य मानचित्र ( map[string]bool, map[struct{}]interface{}, आदि) पर काम करेगा । ध्यान दें कि यह गैर-मानचित्र मानों पर भी काम करेगा, इसलिए सावधान रहें कि आप जो पास कर रहे हैं वह वास्तव में दो नक्शे हैं। यदि आप इसे दो पूर्णांक पास करते हैं, तो यह आपको खुशी से बताएगा कि क्या वे समान हैं।

Question 3

टेबल-चालित परीक्षणों में दो मानचित्रों की तुलना करने के लिए मुहावरेदार तरीका क्या है?

आपके पास go-test/deepमदद करने के लिए परियोजना है।

लेकिन: यह गो 1.12 (फरवरी 2019) मूल रूप से आसान होना चाहिए : जारी नोट देखें ।

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

fmt

परीक्षण को आसान बनाने के लिए मानचित्र अब मुख्य-क्रमबद्ध क्रम में मुद्रित होते हैं ।

आदेश देने के नियम हैं:

लागू होने पर, शून्य कम तुलना करता है

इन्टस, फ्लोट्स और स्ट्रिंग्स ऑर्डर द्वारा <

NaN की तुलना गैर-NaN फ़्लोट्स से कम है

boolfalseपहले की तुलनाtrue

कॉम्प्लेक्स असली, फिर काल्पनिक की तुलना करता है

पॉइंटर्स मशीन के पते से तुलना करते हैं

चैनल मान मशीन के पते से तुलना करते हैं

संरचनाएं बदले में प्रत्येक क्षेत्र की तुलना करती हैं

Arrays बदले में प्रत्येक तत्व की तुलना करते हैं

पिछले मानों reflect.Typeमें बताए गए ठोस प्रकार और फिर ठोस मूल्य का वर्णन करके इंटरफ़ेस मान पहले तुलना करते हैं।

मैप्स को प्रिंट करते समय, NaN जैसे गैर-रिफ्लेक्सिव प्रमुख मान पहले प्रदर्शित किए गए थे <nil>। इस रिलीज के रूप में, सही मूल्य मुद्रित होते हैं।

सूत्रों का कहना है:

golang/go21095 जारी करें ,
ट्वीट (उस पैच के लिए मूल विचार: ᴊᴀᴍᴇꜱ original purpleidea) ( )
सीएल 142737 :

सीएल जोड़ता है: ( सीएल का अर्थ है "परिवर्तन सूची" )

ऐसा करने के लिए, हम रूट पर एक पैकेजinternal/fmtsort जोड़ते हैं , जो कि उनके प्रकार की परवाह किए बिना मानचित्र कुंजियों को छांटने के लिए एक सामान्य तंत्र को लागू करता है।

यह थोड़ा गड़बड़ है और शायद धीमा है, लेकिन नक्शों की स्वरूपित छपाई कभी तेज नहीं रही है और पहले से ही हमेशा प्रतिबिंब-चालित है।

नया पैकेज आंतरिक है क्योंकि हम वास्तव में हर किसी को चीजों को क्रमबद्ध करने के लिए इसका उपयोग नहीं करना चाहते हैं। यह धीमा है, सामान्य नहीं है, और केवल उन प्रकारों के सबसेट के लिए उपयुक्त है जो मानचित्र कुंजी हो सकते हैं।

पैकेज का भी उपयोग करें text/template, जिसमें पहले से ही इस तंत्र का कमजोर संस्करण था।

आप देख सकते हैं कि में इस्तेमाल किया src/fmt/print.go#printValue(): case reflect.Map:

Question 4

यह वही है जो मैं करूंगा (अनकहा कोड):

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
}

Question 5

अस्वीकरण : map[string]intगो में नक्शों की समानता के परीक्षण से संबंधित लेकिन संबंधित, जो प्रश्न का शीर्षक है

आप एक सूचक प्रकार का एक नक्शा है, तो (जैसे map[*string]int), तो आप करते नहीं reflect.DeepEqual उपयोग करना चाहते हैं , क्योंकि यह अवास्तविक लौटाते हैं।

अंत में, यदि कुंजी एक प्रकार है जिसमें समय-समय की तरह एक अस्पष्ट सूचक होता है, तो प्रतिबिंबित करें। इस तरह के मानचित्र पर डीपक्वेल भी गलत वापस आ सकता है ।

Question 6

Github.com/google/go-cmp/cmp की "डिफ" विधि का उपयोग करें :

कोड:

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

आउटपुट:

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

Question 7

सबसे सरल तरीका:

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

उदाहरण:

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

Question 8

इसके बजाय cmp ( https://github.com/google/go-cmp ) का उपयोग करें:

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

यह तब भी विफल रहता है जब आपके अपेक्षित आउटपुट में "ऑर्डर" का नक्शा आपके फ़ंक्शन को वापस नहीं करता है। हालाँकि, cmpअभी भी इंगित करने में सक्षम है कि असंगति कहाँ है।

संदर्भ के लिए, मैंने यह ट्वीट पाया है:

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

"प्रतिबिंबित का उपयोग करना। परीक्षणों में डीपक्वेल अक्सर एक बुरा विचार है, यही कारण है कि हम http://github.com/google/go-cmp खोलते हैं " - जो त्साइ

Question 9

विकल्पों में से एक rng को ठीक करना है:

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