libgo/go/go/printer/testdata/slow.golden

   1 // Copyright 2011 The Go Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style
   3 // license that can be found in the LICENSE file.
   4
   5 package deepequal_test
   6
   7 import (
   8         "testing"
   9         "google3/spam/archer/frontend/deepequal"
  10 )
  11
  12 func TestTwoNilValues(t *testing.T) {
  13         if err := deepequal.Check(nil, nil); err != nil {
  14                 t.Errorf("expected nil, saw %v", err)
  15         }
  16 }
  17
  18 type Foo struct {
  19         bar     *Bar
  20         bang    *Bar
  21 }
  22
  23 type Bar struct {
  24         baz     *Baz
  25         foo     []*Foo
  26 }
  27
  28 type Baz struct {
  29         entries         map[int]interface{}
  30         whatever        string
  31 }
  32
  33 func newFoo() *Foo {
  34         return &Foo{bar: &Bar{baz: &Baz{
  35                 entries: map[int]interface{}{
  36                         42:     &Foo{},
  37                         21:     &Bar{},
  38                         11:     &Baz{whatever: "it's just a test"}}}},
  39                 bang: &Bar{foo: []*Foo{
  40                         &Foo{bar: &Bar{baz: &Baz{
  41                                 entries: map[int]interface{}{
  42                                         43:     &Foo{},
  43                                         22:     &Bar{},
  44                                         13:     &Baz{whatever: "this is nuts"}}}},
  45                                 bang: &Bar{foo: []*Foo{
  46                                         &Foo{bar: &Bar{baz: &Baz{
  47                                                 entries: map[int]interface{}{
  48                                                         61:     &Foo{},
  49                                                         71:     &Bar{},
  50                                                         11:     &Baz{whatever: "no, it's Go"}}}},
  51                                                 bang: &Bar{foo: []*Foo{
  52                                                         &Foo{bar: &Bar{baz: &Baz{
  53                                                                 entries: map[int]interface{}{
  54                                                                         0:      &Foo{},
  55                                                                         -2:     &Bar{},
  56                                                                         -11:    &Baz{whatever: "we need to go deeper"}}}},
  57                                                                 bang: &Bar{foo: []*Foo{
  58                                                                         &Foo{bar: &Bar{baz: &Baz{
  59                                                                                 entries: map[int]interface{}{
  60                                                                                         -2:     &Foo{},
  61                                                                                         -5:     &Bar{},
  62                                                                                         -7:     &Baz{whatever: "are you serious?"}}}},
  63                                                                                 bang:   &Bar{foo: []*Foo{}}},
  64                                                                         &Foo{bar: &Bar{baz: &Baz{
  65                                                                                 entries: map[int]interface{}{
  66                                                                                         -100:   &Foo{},
  67                                                                                         50:     &Bar{},
  68                                                                                         20:     &Baz{whatever: "na, not really ..."}}}},
  69                                                                                 bang:   &Bar{foo: []*Foo{}}}}}}}}},
  70                                         &Foo{bar: &Bar{baz: &Baz{
  71                                                 entries: map[int]interface{}{
  72                                                         2:      &Foo{},
  73                                                         1:      &Bar{},
  74                                                         -1:     &Baz{whatever: "... it's just a test."}}}},
  75                                                 bang:   &Bar{foo: []*Foo{}}}}}}}}}
  76 }
  77
  78 func TestElaborate(t *testing.T) {
  79         a := newFoo()
  80         b := newFoo()
  81
  82         if err := deepequal.Check(a, b); err != nil {
  83                 t.Errorf("expected nil, saw %v", err)
  84         }
  85 }