Deterministic sorting for all map key types.

render/render_test.go

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package render
 
 import (
         "bytes"
         "fmt"
         "reflect"
@@ skipping 185 matching lines @@
         // Output: Render test:
         // fmt.Printf:    render.testStruct{S:"hello", V:(*map[string]int)(0x600dd065), I:42}
         // render.Render: render.testStruct{S:"hello", V:(*map[string]int){"bar":1, "foo":0}, I:render.customType(42)}
 }
 
 var pointerRE = regexp.MustCompile(`\(0x[a-f0-9]+\)`)
 
 func sanitizePointer(s string) string {
         return pointerRE.ReplaceAllString(s, "(0x600dd065)")
 }
+
+type chanList []chan int
+
+func (c chanList) Len() int      { return len(c) }
+func (c chanList) Swap(i, j int) { c[i], c[j] = c[j], c[i] }
+func (c chanList) Less(i, j int) bool {
+        return reflect.ValueOf(c[i]).Pointer() < reflect.ValueOf(c[j]).Pointer()
+}
+
+func TestMapSortRendering(t *testing.T) {
+        type namedMapType map[int]struct{ a int }
+        type mapKey struct{ a, b int }
+
+        chans := make(chanList, 5)
+        for i := range chans {
+                chans[i] = make(chan int)
+        }
+
+        tcs := []struct {
+                in     interface{}
+                expect string
+        }{
+                {
+                        map[uint32]struct{}{1: {}, 2: {}, 3: {}, 4: {}, 5: {}, 6: {}, 7: {}, 8: {}},
+                        "map[uint32]struct {}{1:{}, 2:{}, 3:{}, 4:{}, 5:{}, 6:{}, 7:{}, 8:{}}",
+                },
+                {
+                        map[int8]struct{}{1: {}, 2: {}, 3: {}, 4: {}, 5: {}, 6: {}, 7: {}, 8: {}},
+                        "map[int8]struct {}{1:{}, 2:{}, 3:{}, 4:{}, 5:{}, 6:{}, 7:{}, 8:{}}",
+                },
+                {
+                        map[uintptr]struct{}{1: {}, 2: {}, 3: {}, 4: {}, 5: {}, 6: {}, 7: {}, 8: {}},
+                        "map[uintptr]struct {}{1:{}, 2:{}, 3:{}, 4:{}, 5:{}, 6:{}, 7:{}, 8:{}}",
+                },
+                {
+                        namedMapType{10: struct{ a int }{20}},
+                        "render.namedMapType{10:struct { a int }{20}}",
+                },
+                {
+                        map[mapKey]struct{}{mapKey{3, 1}: {}, mapKey{1, 3}: {}, mapKey{1, 2}: {}, mapKey{2, 1}: {}},
+                        "map[render.mapKey]struct {}{render.mapKey{a:1, b:2}:{}, render.mapKey{a:1, b:3}:{}, render.mapKey{a:2, b:1}:{}, render.mapKey{a:3, b:1}:{}}",
+                },
+                {
+                        map[float64]struct{}{10.5: {}, 10.15: {}, 1203: {}, 1: {}, 2: {}},
+                        "map[float64]struct {}{1:{}, 2:{}, 10.15:{}, 10.5:{}, 1203:{}}",
+                },
+                {
+                        map[bool]struct{}{true: {}, false: {}},
+                        "map[bool]struct {}{false:{}, true:{}}",
+                },
+                {
+                        map[interface{}]struct{}{1: {}, 2: {}, 3: {}, "foo": {}},
+                        `map[interface{}]struct {}{1:{}, 2:{}, 3:{}, "foo":{}}`,
+                },
+                {
+                        map[complex64]struct{}{1 + 2i: {}, 2 + 1i: {}, 3 + 1i: {}, 1 + 3i: {}},
+                        "map[complex64]struct {}{(1+2i):{}, (1+3i):{}, (2+1i):{}, (3+1i):{}}",
+                },
+                {
+                        map[chan int]string{nil: "a", chans[0]: "b", chans[1]: "c", chans[2]: "d", chans[3]: "e", chans[4]: "f"},
+                        `map[(chan int)]string{(chan int)(PTR):"a", (chan int)(PTR):"b", (chan int)(PTR):"c", (chan int)(PTR):"d", (chan int)(PTR):"e", (chan int)(PTR):"f"}`,
+                },
+        }
+
+        for _, tc := range tcs {
+                assertRendersLike(t, reflect.TypeOf(tc.in).Name(), tc.in, tc.expect)
+        }
+}