Subversion Repositories openrisc

// Copyright 2011 The Go 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 deepequal_test

import (
        "testing"
        "google3/spam/archer/frontend/deepequal"
)

func TestTwoNilValues(t *testing.T) {
        if err := deepequal.Check(nil, nil); err != nil {
                t.Errorf("expected nil, saw %v", err)
        }
}

type Foo struct {
        bar     *Bar
        bang    *Bar
}

type Bar struct {
        baz     *Baz
        foo     []*Foo
}

type Baz struct {
        entries         map[int]interface{}
        whatever        string
}

func newFoo() *Foo {
        return &Foo{bar: &Bar{baz: &Baz{
                entries: map[int]interface{}{
                        42:     &Foo{},
                        21:     &Bar{},
                        11:     &Baz{whatever: "it's just a test"}}}},
                bang: &Bar{foo: []*Foo{
                        &Foo{bar: &Bar{baz: &Baz{
                                entries: map[int]interface{}{
                                        43:     &Foo{},
                                        22:     &Bar{},
                                        13:     &Baz{whatever: "this is nuts"}}}},
                                bang: &Bar{foo: []*Foo{
                                        &Foo{bar: &Bar{baz: &Baz{
                                                entries: map[int]interface{}{
                                                        61:     &Foo{},
                                                        71:     &Bar{},
                                                        11:     &Baz{whatever: "no, it's Go"}}}},
                                                bang: &Bar{foo: []*Foo{
                                                        &Foo{bar: &Bar{baz: &Baz{
                                                                entries: map[int]interface{}{
                                                                        0:      &Foo{},
                                                                        -2:     &Bar{},
                                                                        -11:    &Baz{whatever: "we need to go deeper"}}}},
                                                                bang: &Bar{foo: []*Foo{
                                                                        &Foo{bar: &Bar{baz: &Baz{
                                                                                entries: map[int]interface{}{
                                                                                        -2:     &Foo{},
                                                                                        -5:     &Bar{},
                                                                                        -7:     &Baz{whatever: "are you serious?"}}}},
                                                                                bang:   &Bar{foo: []*Foo{}}},
                                                                        &Foo{bar: &Bar{baz: &Baz{
                                                                                entries: map[int]interface{}{
                                                                                        -100:   &Foo{},
                                                                                        50:     &Bar{},
                                                                                        20:     &Baz{whatever: "na, not really ..."}}}},
                                                                                bang:   &Bar{foo: []*Foo{}}}}}}}}},
                                        &Foo{bar: &Bar{baz: &Baz{
                                                entries: map[int]interface{}{
                                                        2:      &Foo{},
                                                        1:      &Bar{},
                                                        -1:     &Baz{whatever: "... it's just a test."}}}},
                                                bang:   &Bar{foo: []*Foo{}}}}}}}}}
}

func TestElaborate(t *testing.T) {
        a := newFoo()
        b := newFoo()

        if err := deepequal.Check(a, b); err != nil {
                t.Errorf("expected nil, saw %v", err)
        }
}