1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
|
// Copyright 2009 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.
// Deep equality test via reflection
package reflect
import "reflect"
// Tests for deep equality using reflected types. The map argument tracks
// comparisons that have already been seen, which allows short circuiting on
// recursive types.
func deepValueEqual(v1, v2 Value, visited map[Addr]Addr) bool {
if v1.Kind() != v2.Kind() {
return false;
}
// Short circuit if references are identical or already seen
addr1 := v1.Addr();
addr2 := v2.Addr();
if addr1 == addr2 {
return true;
}
if vaddr, ok := visited[addr1]; ok && vaddr == addr2 {
return true;
}
visited[addr1] = addr2;
switch v1.Kind() {
case ArrayKind:
arr1 := v1.(ArrayValue);
arr2 := v2.(ArrayValue);
if arr1.IsSlice() != arr2.IsSlice() || arr1.Len() != arr2.Len() {
return false;
}
for i := 0; i < arr1.Len(); i++ {
if !deepValueEqual(arr1.Elem(i), arr2.Elem(i), visited) {
return false;
}
}
return true;
case InterfaceKind:
return deepValueEqual(NewValue(v1.(InterfaceValue).Get()),
NewValue(v2.(InterfaceValue).Get()), visited);
case MapKind:
// TODO(dnadasi): Implement this fully once MapValue is implemented
return v1.Interface() == v2.Interface();
case PtrKind:
return deepValueEqual(v1.(PtrValue).Sub(), v2.(PtrValue).Sub(), visited);
case StructKind:
struct1 := v1.(StructValue);
struct2 := v2.(StructValue);
if struct1.Len() != struct2.Len() {
return false;
}
for i := 0; i < struct1.Len(); i++ {
if !deepValueEqual(struct1.Field(i), struct2.Field(i), visited) {
return false;
}
}
return true;
default:
// Normal equality suffices
return v1.Interface() == v2.Interface();
}
panic("Not reached");
}
// DeepEqual tests for deep equality. It uses normal == equality where possible
// but will scan members of arrays, slices, and fields of structs. It correctly
// handles recursive types. Until reflection supports maps, maps are equal iff
// they are identical.
func DeepEqual(a1, a2 interface{}) bool {
v1 := NewValue(a1);
v2 := NewValue(a2);
if !equalType(v1.Type(), v2.Type()) {
return false;
}
return deepValueEqual(v1, v2, make(map[Addr]Addr));
}
|
