← Back to branch summary

~ubuntu-branches/ubuntu/saucy/golang/saucy

« back to all changes in this revision

Viewing changes to test/fixedbugs/issue4585.go

  • Committer: Package Import Robot
  • Author(s): Adam Conrad
  • Date: 2013-07-08 05:52:37 UTC
  • mfrom: (29.1.1 sid)
  • Revision ID: package-import@ubuntu.com-20130708055237-at01839e0hp8z3ni
Tags: 2:1.1-1ubuntu1
016-armhf-elf-header.patch: Use correct ELF header for armhf binaries.

Show diffs side-by-side

added added

removed removed

Lines of Context:
test/fixedbugs/issue4585.go
 
1
// run
 
2
 
 
3
// Copyright 2013 The Go Authors.  All rights reserved.
 
4
// Use of this source code is governed by a BSD-style
 
5
// license that can be found in the LICENSE file.
 
6
 
 
7
// Issue 4585: comparisons and hashes process blank
 
8
// fields and padding in structs.
 
9
 
 
10
package main
 
11
 
 
12
import "unsafe"
 
13
 
 
14
// T is a structure with padding.
 
15
type T struct {
 
16
        A     int16
 
17
        B     int64
 
18
        C     int16
 
19
        D     int64
 
20
        Dummy [64]byte
 
21
}
 
22
 
 
23
// U is a structure with a blank field
 
24
type U struct {
 
25
        A, _, B int
 
26
        Dummy   [64]byte
 
27
}
 
28
 
 
29
// USmall is like U but the frontend will inline comparison
 
30
// instead of calling the generated eq function.
 
31
type USmall struct {
 
32
        A, _, B int32
 
33
}
 
34
 
 
35
// V has padding but not on the first field.
 
36
type V struct {
 
37
        A1, A2, A3 int32
 
38
        B          int16
 
39
        C          int32
 
40
}
 
41
 
 
42
// W has padding at the end.
 
43
type W struct {
 
44
        A1, A2, A3 int32
 
45
        B          int32
 
46
        C          int8
 
47
}
 
48
 
 
49
func test1() {
 
50
        var a, b U
 
51
        m := make(map[U]int)
 
52
        copy((*[16]byte)(unsafe.Pointer(&a))[:], "hello world!")
 
53
        a.A, a.B = 1, 2
 
54
        b.A, b.B = 1, 2
 
55
        if a != b {
 
56
                panic("broken equality: a != b")
 
57
        }
 
58
 
 
59
        m[a] = 1
 
60
        m[b] = 2
 
61
        if len(m) == 2 {
 
62
                panic("broken hash: len(m) == 2")
 
63
        }
 
64
        if m[a] != 2 {
 
65
                panic("m[a] != 2")
 
66
        }
 
67
}
 
68
 
 
69
func test2() {
 
70
        var a, b T
 
71
        m := make(map[T]int)
 
72
 
 
73
        copy((*[16]byte)(unsafe.Pointer(&a))[:], "hello world!")
 
74
        a.A, a.B, a.C, a.D = 1, 2, 3, 4
 
75
        b.A, b.B, b.C, b.D = 1, 2, 3, 4
 
76
 
 
77
        if a != b {
 
78
                panic("broken equality: a != b")
 
79
        }
 
80
 
 
81
        m[a] = 1
 
82
        m[b] = 2
 
83
        if len(m) == 2 {
 
84
                panic("broken hash: len(m) == 2")
 
85
        }
 
86
        if m[a] != 2 {
 
87
                panic("m[a] != 2")
 
88
        }
 
89
}
 
90
 
 
91
func test3() {
 
92
        var a, b USmall
 
93
        copy((*[12]byte)(unsafe.Pointer(&a))[:], "hello world!")
 
94
        a.A, a.B = 1, 2
 
95
        b.A, b.B = 1, 2
 
96
        if a != b {
 
97
                panic("broken equality: a != b")
 
98
        }
 
99
}
 
100
 
 
101
func test4() {
 
102
        var a, b V
 
103
        m := make(map[V]int)
 
104
 
 
105
        copy((*[20]byte)(unsafe.Pointer(&a))[:], "Hello World, Gopher!")
 
106
        a.A1, a.A2, a.A3, a.B, a.C = 1, 2, 3, 4, 5
 
107
        b.A1, b.A2, b.A3, b.B, b.C = 1, 2, 3, 4, 5
 
108
 
 
109
        if a != b {
 
110
                panic("broken equality: a != b")
 
111
        }
 
112
 
 
113
        m[a] = 1
 
114
        m[b] = 2
 
115
        if len(m) == 2 {
 
116
                panic("broken hash: len(m) == 2")
 
117
        }
 
118
        if m[a] != 2 {
 
119
                panic("m[a] != 2")
 
120
        }
 
121
}
 
122
 
 
123
func test5() {
 
124
        var a, b W
 
125
        m := make(map[W]int)
 
126
 
 
127
        copy((*[20]byte)(unsafe.Pointer(&a))[:], "Hello World, Gopher!")
 
128
        a.A1, a.A2, a.A3, a.B, a.C = 1, 2, 3, 4, 5
 
129
        b.A1, b.A2, b.A3, b.B, b.C = 1, 2, 3, 4, 5
 
130
 
 
131
        if a != b {
 
132
                panic("broken equality: a != b")
 
133
        }
 
134
 
 
135
        m[a] = 1
 
136
        m[b] = 2
 
137
        if len(m) == 2 {
 
138
                panic("broken hash: len(m) == 2")
 
139
        }
 
140
        if m[a] != 2 {
 
141
                panic("m[a] != 2")
 
142
        }
 
143
}
 
144
 
 
145
func main() {
 
146
        test1()
 
147
        test2()
 
148
        test3()
 
149
        test4()
 
150
        test5()
 
151
}