Better rendering for implicit types.

render/render_test.go

-// Copyright 2015 Google Inc. All rights reserved.
+// 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"
         "regexp"
         "runtime"
         "testing"
 )
 
 func init() {
         // For testing purposes, pointers will render as "PTR" so that they are
         // deterministic.
         renderPointer = func(buf *bytes.Buffer, p uintptr) {
                 buf.WriteString("PTR")
@@ skipping 54 matching lines @@
                 }, `[]*render.testStruct{(*render.testStruct){Name:"foo", I:interface{}(nil), m:""}, ` +
                         `(*render.testStruct){Name:"bar", I:interface{}(nil), m:""}}`},
                 {myStringSlice{"foo", "bar"}, `render.myStringSlice{"foo", "bar"}`},
                 {myStringMap{"foo": "bar"}, `render.myStringMap{"foo":"bar"}`},
                 {myIntType(12), `render.myIntType(12)`},
                 {&mit, `(*render.myIntType)(42)`},
                 {myStringType("foo"), `render.myStringType("foo")`},
                 {struct {
                         a int
                         b string
-                }{123, "foo"}, `struct { a int; b string }{a:123, b:"foo"}`},
+                }{123, "foo"}, `struct { a int; b string }{123, "foo"}`},
                 {[]string{"foo", "foo", "bar", "baz", "qux", "qux"},
                         `[]string{"foo", "foo", "bar", "baz", "qux", "qux"}`},
                 {[...]int{1, 2, 3}, `[3]int{1, 2, 3}`},
                 {map[string]bool{
                         "foo": true,
                         "bar": false,
                 }, `map[string]bool{"bar":false, "foo":true}`},
                 {map[int]string{1: "foo", 2: "bar"}, `map[int]string{1:"foo", 2:"bar"}`},
                 {uint32(1337), `1337`},
                 {3.14, `3.14`},
@@ skipping 31 matching lines @@
 }
 
 func TestRenderRecursiveMap(t *testing.T) {
         m := map[string]interface{}{}
         foo := "foo"
         m["foo"] = m
         m["bar"] = [](*string){&foo, &foo}
         v := []map[string]interface{}{m, m}
 
         assertRendersLike(t, "Recursive map", v,
-                `[]map[string]interface{}{map[string]interface{}{`+
+                `[]map[string]interface{}{{`+
                         `"bar":[]*string{(*string)("foo"), (*string)("foo")}, `+
-                        `"foo":<REC(map[string]interface{})>}, `+
-                        `map[string]interface{}{`+
+                        `"foo":<REC(map[string]interface{})>}, {`+
                         `"bar":[]*string{(*string)("foo"), (*string)("foo")}, `+
                         `"foo":<REC(map[string]interface{})>}}`)
 }
 
+func TestRenderImplicitType(t *testing.T) {
+        type namedStruct struct{ a, b int }
+        type namedInt int
+
+        tcs := []struct {
+                in     interface{}
+                expect string
+        }{
+                {
+                        []struct{ a, b int }{{1, 2}},
+                        "[]struct { a int; b int }{{1, 2}}",
+                },
+                {
+                        map[string]struct{ a, b int }{"hi": {1, 2}},
+                        `map[string]struct { a int; b int }{"hi":{1, 2}}`,
+                },
+                {
+                        map[namedInt]struct{}{10: {}},
+                        `map[render.namedInt]struct {}{10:{}}`,
+                },
+                {
+                        struct{ a, b int }{1, 2},
+                        `struct { a int; b int }{1, 2}`,
+                },
+                {
+                        namedStruct{1, 2},
+                        "render.namedStruct{a:1, b:2}",
+                },
+        }
+
+        for _, tc := range tcs {
+                assertRendersLike(t, reflect.TypeOf(tc.in).String(), tc.in, tc.expect)
+        }
+}
+
 func ExampleInReadme() {
         type customType int
         type testStruct struct {
                 S string
                 V *map[string]int
                 I interface{}
         }
 
         a := testStruct{
                 S: "hello",
                 V: &map[string]int{"foo": 0, "bar": 1},
                 I: customType(42),
         }
 
         fmt.Println("Render test:")
         fmt.Printf("fmt.Printf:    %s\n", sanitizePointer(fmt.Sprintf("%#v", a)))
         fmt.Printf("render.Render: %s\n", Render(a))
         // 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)")
 }