URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [gcc/] [testsuite/] [go.test/] [test/] [map.go] - Blame information for rev 700

Details | Compare with Previous | View Log


// $G $F.go && $L $F.$A && ./$A.out
 
// 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.
 
package main
 
import (
        "fmt"
        "strconv"
)
 
const count = 100
 
func P(a []string) string {
        s := "{"
        for i := 0; i < len(a); i++ {
                if i > 0 {
                        s += ","
                }
                s += `"` + a[i] + `"`
        }
        s += "}"
        return s
}
 
func main() {
        // Test a map literal.
        mlit := map[string]int{"0": 0, "1": 1, "2": 2, "3": 3, "4": 4}
        for i := 0; i < len(mlit); i++ {
                s := string([]byte{byte(i) + '0'})
                if mlit[s] != i {
                        fmt.Printf("mlit[%s] = %d\n", s, mlit[s])
                }
        }
 
        mib := make(map[int]bool)
        mii := make(map[int]int)
        mfi := make(map[float32]int)
        mif := make(map[int]float32)
        msi := make(map[string]int)
        mis := make(map[int]string)
        mss := make(map[string]string)
        mspa := make(map[string][]string)
        // BUG need an interface map both ways too
 
        type T struct {
                i int64 // can't use string here; struct values are only compared at the top level
                f float32
        }
        mipT := make(map[int]*T)
        mpTi := make(map[*T]int)
        mit := make(map[int]T)
        //      mti := make(map[T] int)
 
        type M map[int]int
        mipM := make(map[int]M)
 
        var apT [2 * count]*T
 
        for i := 0; i < count; i++ {
                s := strconv.Itoa(i)
                s10 := strconv.Itoa(i * 10)
                f := float32(i)
                t := T{int64(i), f}
                apT[i] = new(T)
                apT[i].i = int64(i)
                apT[i].f = f
                apT[2*i] = new(T) // need twice as many entries as we use, for the nonexistence check
                apT[2*i].i = int64(i)
                apT[2*i].f = f
                m := M{i: i + 1}
                mib[i] = (i != 0)
                mii[i] = 10 * i
                mfi[float32(i)] = 10 * i
                mif[i] = 10.0 * f
                mis[i] = s
                msi[s] = i
                mss[s] = s10
                mss[s] = s10
                as := make([]string, 2)
                as[0] = s10
                as[1] = s10
                mspa[s] = as
                mipT[i] = apT[i]
                mpTi[apT[i]] = i
                mipM[i] = m
                mit[i] = t
                //      mti[t] = i
        }
 
        // test len
        if len(mib) != count {
                fmt.Printf("len(mib) = %d\n", len(mib))
        }
        if len(mii) != count {
                fmt.Printf("len(mii) = %d\n", len(mii))
        }
        if len(mfi) != count {
                fmt.Printf("len(mfi) = %d\n", len(mfi))
        }
        if len(mif) != count {
                fmt.Printf("len(mif) = %d\n", len(mif))
        }
        if len(msi) != count {
                fmt.Printf("len(msi) = %d\n", len(msi))
        }
        if len(mis) != count {
                fmt.Printf("len(mis) = %d\n", len(mis))
        }
        if len(mss) != count {
                fmt.Printf("len(mss) = %d\n", len(mss))
        }
        if len(mspa) != count {
                fmt.Printf("len(mspa) = %d\n", len(mspa))
        }
        if len(mipT) != count {
                fmt.Printf("len(mipT) = %d\n", len(mipT))
        }
        if len(mpTi) != count {
                fmt.Printf("len(mpTi) = %d\n", len(mpTi))
        }
        //      if len(mti) != count {
        //              fmt.Printf("len(mti) = %d\n", len(mti))
        //      }
        if len(mipM) != count {
                fmt.Printf("len(mipM) = %d\n", len(mipM))
        }
        //      if len(mti) != count {
        //              fmt.Printf("len(mti) = %d\n", len(mti))
        //      }
        if len(mit) != count {
                fmt.Printf("len(mit) = %d\n", len(mit))
        }
 
        // test construction directly
        for i := 0; i < count; i++ {
                s := strconv.Itoa(i)
                s10 := strconv.Itoa(i * 10)
                f := float32(i)
                // BUG m := M(i, i+1)
                if mib[i] != (i != 0) {
                        fmt.Printf("mib[%d] = %t\n", i, mib[i])
                }
                if mii[i] != 10*i {
                        fmt.Printf("mii[%d] = %d\n", i, mii[i])
                }
                if mfi[f] != 10*i {
                        fmt.Printf("mfi[%d] = %d\n", i, mfi[f])
                }
                if mif[i] != 10.0*f {
                        fmt.Printf("mif[%d] = %g\n", i, mif[i])
                }
                if mis[i] != s {
                        fmt.Printf("mis[%d] = %s\n", i, mis[i])
                }
                if msi[s] != i {
                        fmt.Printf("msi[%s] = %d\n", s, msi[s])
                }
                if mss[s] != s10 {
                        fmt.Printf("mss[%s] = %g\n", s, mss[s])
                }
                for j := 0; j < len(mspa[s]); j++ {
                        if mspa[s][j] != s10 {
                                fmt.Printf("mspa[%s][%d] = %s\n", s, j, mspa[s][j])
                        }
                }
                if mipT[i].i != int64(i) || mipT[i].f != f {
                        fmt.Printf("mipT[%d] = %v\n", i, mipT[i])
                }
                if mpTi[apT[i]] != i {
                        fmt.Printf("mpTi[apT[%d]] = %d\n", i, mpTi[apT[i]])
                }
                //      if(mti[t] != i) {
                //              fmt.Printf("mti[%s] = %s\n", s, mti[t])
                //      }
                if mipM[i][i] != i+1 {
                        fmt.Printf("mipM[%d][%d] = %d\n", i, i, mipM[i][i])
                }
                //      if(mti[t] != i) {
                //              fmt.Printf("mti[%v] = %d\n", t, mti[t])
                //      }
                if mit[i].i != int64(i) || mit[i].f != f {
                        fmt.Printf("mit[%d] = {%d %g}\n", i, mit[i].i, mit[i].f)
                }
        }
 
        // test existence with tuple check
        // failed lookups yield a false value for the boolean.
        for i := 0; i < count; i++ {
                s := strconv.Itoa(i)
                f := float32(i)
                {
                        _, b := mib[i]
                        if !b {
                                fmt.Printf("tuple existence decl: mib[%d]\n", i)
                        }
                        _, b = mib[i]
                        if !b {
                                fmt.Printf("tuple existence assign: mib[%d]\n", i)
                        }
                }
                {
                        _, b := mii[i]
                        if !b {
                                fmt.Printf("tuple existence decl: mii[%d]\n", i)
                        }
                        _, b = mii[i]
                        if !b {
                                fmt.Printf("tuple existence assign: mii[%d]\n", i)
                        }
                }
                {
                        _, b := mfi[f]
                        if !b {
                                fmt.Printf("tuple existence decl: mfi[%d]\n", i)
                        }
                        _, b = mfi[f]
                        if !b {
                                fmt.Printf("tuple existence assign: mfi[%d]\n", i)
                        }
                }
                {
                        _, b := mif[i]
                        if !b {
                                fmt.Printf("tuple existence decl: mif[%d]\n", i)
                        }
                        _, b = mif[i]
                        if !b {
                                fmt.Printf("tuple existence assign: mif[%d]\n", i)
                        }
                }
                {
                        _, b := mis[i]
                        if !b {
                                fmt.Printf("tuple existence decl: mis[%d]\n", i)
                        }
                        _, b = mis[i]
                        if !b {
                                fmt.Printf("tuple existence assign: mis[%d]\n", i)
                        }
                }
                {
                        _, b := msi[s]
                        if !b {
                                fmt.Printf("tuple existence decl: msi[%d]\n", i)
                        }
                        _, b = msi[s]
                        if !b {
                                fmt.Printf("tuple existence assign: msi[%d]\n", i)
                        }
                }
                {
                        _, b := mss[s]
                        if !b {
                                fmt.Printf("tuple existence decl: mss[%d]\n", i)
                        }
                        _, b = mss[s]
                        if !b {
                                fmt.Printf("tuple existence assign: mss[%d]\n", i)
                        }
                }
                {
                        _, b := mspa[s]
                        if !b {
                                fmt.Printf("tuple existence decl: mspa[%d]\n", i)
                        }
                        _, b = mspa[s]
                        if !b {
                                fmt.Printf("tuple existence assign: mspa[%d]\n", i)
                        }
                }
                {
                        _, b := mipT[i]
                        if !b {
                                fmt.Printf("tuple existence decl: mipT[%d]\n", i)
                        }
                        _, b = mipT[i]
                        if !b {
                                fmt.Printf("tuple existence assign: mipT[%d]\n", i)
                        }
                }
                {
                        _, b := mpTi[apT[i]]
                        if !b {
                                fmt.Printf("tuple existence decl: mpTi[apT[%d]]\n", i)
                        }
                        _, b = mpTi[apT[i]]
                        if !b {
                                fmt.Printf("tuple existence assign: mpTi[apT[%d]]\n", i)
                        }
                }
                {
                        _, b := mipM[i]
                        if !b {
                                fmt.Printf("tuple existence decl: mipM[%d]\n", i)
                        }
                        _, b = mipM[i]
                        if !b {
                                fmt.Printf("tuple existence assign: mipM[%d]\n", i)
                        }
                }
                {
                        _, b := mit[i]
                        if !b {
                                fmt.Printf("tuple existence decl: mit[%d]\n", i)
                        }
                        _, b = mit[i]
                        if !b {
                                fmt.Printf("tuple existence assign: mit[%d]\n", i)
                        }
                }
                //              {
                //                      _, b := mti[t]
                //                      if !b {
                //                              fmt.Printf("tuple existence decl: mti[%d]\n", i)
                //                      }
                //                      _, b = mti[t]
                //                      if !b {
                //                              fmt.Printf("tuple existence assign: mti[%d]\n", i)
                //                      }
                //              }
        }
 
        // test nonexistence with tuple check
        // failed lookups yield a false value for the boolean.
        for i := count; i < 2*count; i++ {
                s := strconv.Itoa(i)
                f := float32(i)
                {
                        _, b := mib[i]
                        if b {
                                fmt.Printf("tuple nonexistence decl: mib[%d]", i)
                        }
                        _, b = mib[i]
                        if b {
                                fmt.Printf("tuple nonexistence assign: mib[%d]", i)
                        }
                }
                {
                        _, b := mii[i]
                        if b {
                                fmt.Printf("tuple nonexistence decl: mii[%d]", i)
                        }
                        _, b = mii[i]
                        if b {
                                fmt.Printf("tuple nonexistence assign: mii[%d]", i)
                        }
                }
                {
                        _, b := mfi[f]
                        if b {
                                fmt.Printf("tuple nonexistence decl: mfi[%d]", i)
                        }
                        _, b = mfi[f]
                        if b {
                                fmt.Printf("tuple nonexistence assign: mfi[%d]", i)
                        }
                }
                {
                        _, b := mif[i]
                        if b {
                                fmt.Printf("tuple nonexistence decl: mif[%d]", i)
                        }
                        _, b = mif[i]
                        if b {
                                fmt.Printf("tuple nonexistence assign: mif[%d]", i)
                        }
                }
                {
                        _, b := mis[i]
                        if b {
                                fmt.Printf("tuple nonexistence decl: mis[%d]", i)
                        }
                        _, b = mis[i]
                        if b {
                                fmt.Printf("tuple nonexistence assign: mis[%d]", i)
                        }
                }
                {
                        _, b := msi[s]
                        if b {
                                fmt.Printf("tuple nonexistence decl: msi[%d]", i)
                        }
                        _, b = msi[s]
                        if b {
                                fmt.Printf("tuple nonexistence assign: msi[%d]", i)
                        }
                }
                {
                        _, b := mss[s]
                        if b {
                                fmt.Printf("tuple nonexistence decl: mss[%d]", i)
                        }
                        _, b = mss[s]
                        if b {
                                fmt.Printf("tuple nonexistence assign: mss[%d]", i)
                        }
                }
                {
                        _, b := mspa[s]
                        if b {
                                fmt.Printf("tuple nonexistence decl: mspa[%d]", i)
                        }
                        _, b = mspa[s]
                        if b {
                                fmt.Printf("tuple nonexistence assign: mspa[%d]", i)
                        }
                }
                {
                        _, b := mipT[i]
                        if b {
                                fmt.Printf("tuple nonexistence decl: mipT[%d]", i)
                        }
                        _, b = mipT[i]
                        if b {
                                fmt.Printf("tuple nonexistence assign: mipT[%d]", i)
                        }
                }
                {
                        _, b := mpTi[apT[i]]
                        if b {
                                fmt.Printf("tuple nonexistence decl: mpTi[apt[%d]]", i)
                        }
                        _, b = mpTi[apT[i]]
                        if b {
                                fmt.Printf("tuple nonexistence assign: mpTi[apT[%d]]", i)
                        }
                }
                {
                        _, b := mipM[i]
                        if b {
                                fmt.Printf("tuple nonexistence decl: mipM[%d]", i)
                        }
                        _, b = mipM[i]
                        if b {
                                fmt.Printf("tuple nonexistence assign: mipM[%d]", i)
                        }
                }
                //              {
                //                      _, b := mti[t]
                //                      if b {
                //                              fmt.Printf("tuple nonexistence decl: mti[%d]", i)
                //                      }
                //                      _, b = mti[t]
                //                      if b {
                //                              fmt.Printf("tuple nonexistence assign: mti[%d]", i)
                //                      }
                //              }
                {
                        _, b := mit[i]
                        if b {
                                fmt.Printf("tuple nonexistence decl: mit[%d]", i)
                        }
                        _, b = mit[i]
                        if b {
                                fmt.Printf("tuple nonexistence assign: mit[%d]", i)
                        }
                }
        }
 
        // tests for structured map element updates
        for i := 0; i < count; i++ {
                s := strconv.Itoa(i)
                mspa[s][i%2] = "deleted"
                if mspa[s][i%2] != "deleted" {
                        fmt.Printf("update mspa[%s][%d] = %s\n", s, i%2, mspa[s][i%2])
                }
 
                mipT[i].i += 1
                if mipT[i].i != int64(i)+1 {
                        fmt.Printf("update mipT[%d].i = %d\n", i, mipT[i].i)
                }
                mipT[i].f = float32(i + 1)
                if mipT[i].f != float32(i+1) {
                        fmt.Printf("update mipT[%d].f = %g\n", i, mipT[i].f)
                }
 
                mipM[i][i]++
                if mipM[i][i] != (i+1)+1 {
                        fmt.Printf("update mipM[%d][%d] = %i\n", i, i, mipM[i][i])
                }
        }
 
        // test range on nil map
        var mnil map[string]int
        for _, _ = range mnil {
                panic("range mnil")
        }
}

Browse

Tools

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [gcc/] [testsuite/] [go.test/] [test/] [map.go] - Blame information for rev 700

Line No.	Rev	Author	Line
1	700	jeremybenn	`// $G $F.go && $L $F.$A && ./$A.out`
2
3			`// Copyright 2009 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			`package main`
8
9			`import (`
10			`"fmt"`
11			`"strconv"`
12			`)`
13
14			`const count = 100`
15
16			`func P(a []string) string {`
17			`s := "{"`
18			`for i := 0; i < len(a); i++ {`
19			`if i > 0 {`
20			`s += ","`
21			`}`
22			s += `"` + a[i] + `"`
23			`}`
24			`s += "}"`
25			`return s`
26			`}`
27
28			`func main() {`
29			`// Test a map literal.`
30			`mlit := map[string]int{"0": 0, "1": 1, "2": 2, "3": 3, "4": 4}`
31			`for i := 0; i < len(mlit); i++ {`
32			`s := string([]byte{byte(i) + '0'})`
33			`if mlit[s] != i {`
34			`fmt.Printf("mlit[%s] = %d\n", s, mlit[s])`
35			`}`
36			`}`
37
38			`mib := make(map[int]bool)`
39			`mii := make(map[int]int)`
40			`mfi := make(map[float32]int)`
41			`mif := make(map[int]float32)`
42			`msi := make(map[string]int)`
43			`mis := make(map[int]string)`
44			`mss := make(map[string]string)`
45			`mspa := make(map[string][]string)`
46			`// BUG need an interface map both ways too`
47
48			`type T struct {`
49			`i int64 // can't use string here; struct values are only compared at the top level`
50			`f float32`
51			`}`
52			`mipT := make(map[int]*T)`
53			`mpTi := make(map[*T]int)`
54			`mit := make(map[int]T)`
55			`// mti := make(map[T] int)`
56
57			`type M map[int]int`
58			`mipM := make(map[int]M)`
59
60			`var apT [2 * count]*T`
61
62			`for i := 0; i < count; i++ {`
63			`s := strconv.Itoa(i)`
64			`s10 := strconv.Itoa(i * 10)`
65			`f := float32(i)`
66			`t := T{int64(i), f}`
67			`apT[i] = new(T)`
68			`apT[i].i = int64(i)`
69			`apT[i].f = f`
70			`apT[2*i] = new(T) // need twice as many entries as we use, for the nonexistence check`
71			`apT[2*i].i = int64(i)`
72			`apT[2*i].f = f`
73			`m := M{i: i + 1}`
74			`mib[i] = (i != 0)`
75			`mii[i] = 10 * i`
76			`mfi[float32(i)] = 10 * i`
77			`mif[i] = 10.0 * f`
78			`mis[i] = s`
79			`msi[s] = i`
80			`mss[s] = s10`
81			`mss[s] = s10`
82			`as := make([]string, 2)`
83			`as[0] = s10`
84			`as[1] = s10`
85			`mspa[s] = as`
86			`mipT[i] = apT[i]`
87			`mpTi[apT[i]] = i`
88			`mipM[i] = m`
89			`mit[i] = t`
90			`// mti[t] = i`
91			`}`
92
93			`// test len`
94			`if len(mib) != count {`
95			`fmt.Printf("len(mib) = %d\n", len(mib))`
96			`}`
97			`if len(mii) != count {`
98			`fmt.Printf("len(mii) = %d\n", len(mii))`
99			`}`
100			`if len(mfi) != count {`
101			`fmt.Printf("len(mfi) = %d\n", len(mfi))`
102			`}`
103			`if len(mif) != count {`
104			`fmt.Printf("len(mif) = %d\n", len(mif))`
105			`}`
106			`if len(msi) != count {`
107			`fmt.Printf("len(msi) = %d\n", len(msi))`
108			`}`
109			`if len(mis) != count {`
110			`fmt.Printf("len(mis) = %d\n", len(mis))`
111			`}`
112			`if len(mss) != count {`
113			`fmt.Printf("len(mss) = %d\n", len(mss))`
114			`}`
115			`if len(mspa) != count {`
116			`fmt.Printf("len(mspa) = %d\n", len(mspa))`
117			`}`
118			`if len(mipT) != count {`
119			`fmt.Printf("len(mipT) = %d\n", len(mipT))`
120			`}`
121			`if len(mpTi) != count {`
122			`fmt.Printf("len(mpTi) = %d\n", len(mpTi))`
123			`}`
124			`// if len(mti) != count {`
125			`// fmt.Printf("len(mti) = %d\n", len(mti))`
126			`// }`
127			`if len(mipM) != count {`
128			`fmt.Printf("len(mipM) = %d\n", len(mipM))`
129			`}`
130			`// if len(mti) != count {`
131			`// fmt.Printf("len(mti) = %d\n", len(mti))`
132			`// }`
133			`if len(mit) != count {`
134			`fmt.Printf("len(mit) = %d\n", len(mit))`
135			`}`
136
137			`// test construction directly`
138			`for i := 0; i < count; i++ {`
139			`s := strconv.Itoa(i)`
140			`s10 := strconv.Itoa(i * 10)`
141			`f := float32(i)`
142			`// BUG m := M(i, i+1)`
143			`if mib[i] != (i != 0) {`
144			`fmt.Printf("mib[%d] = %t\n", i, mib[i])`
145			`}`
146			`if mii[i] != 10*i {`
147			`fmt.Printf("mii[%d] = %d\n", i, mii[i])`
148			`}`
149			`if mfi[f] != 10*i {`
150			`fmt.Printf("mfi[%d] = %d\n", i, mfi[f])`
151			`}`
152			`if mif[i] != 10.0*f {`
153			`fmt.Printf("mif[%d] = %g\n", i, mif[i])`
154			`}`
155			`if mis[i] != s {`
156			`fmt.Printf("mis[%d] = %s\n", i, mis[i])`
157			`}`
158			`if msi[s] != i {`
159			`fmt.Printf("msi[%s] = %d\n", s, msi[s])`
160			`}`
161			`if mss[s] != s10 {`
162			`fmt.Printf("mss[%s] = %g\n", s, mss[s])`
163			`}`
164			`for j := 0; j < len(mspa[s]); j++ {`
165			`if mspa[s][j] != s10 {`
166			`fmt.Printf("mspa[%s][%d] = %s\n", s, j, mspa[s][j])`
167			`}`
168			`}`
169			`if mipT[i].i != int64(i) \|\| mipT[i].f != f {`
170			`fmt.Printf("mipT[%d] = %v\n", i, mipT[i])`
171			`}`
172			`if mpTi[apT[i]] != i {`
173			`fmt.Printf("mpTi[apT[%d]] = %d\n", i, mpTi[apT[i]])`
174			`}`
175			`// if(mti[t] != i) {`
176			`// fmt.Printf("mti[%s] = %s\n", s, mti[t])`
177			`// }`
178			`if mipM[i][i] != i+1 {`
179			`fmt.Printf("mipM[%d][%d] = %d\n", i, i, mipM[i][i])`
180			`}`
181			`// if(mti[t] != i) {`
182			`// fmt.Printf("mti[%v] = %d\n", t, mti[t])`
183			`// }`
184			`if mit[i].i != int64(i) \|\| mit[i].f != f {`
185			`fmt.Printf("mit[%d] = {%d %g}\n", i, mit[i].i, mit[i].f)`
186			`}`
187			`}`
188
189			`// test existence with tuple check`
190			`// failed lookups yield a false value for the boolean.`
191			`for i := 0; i < count; i++ {`
192			`s := strconv.Itoa(i)`
193			`f := float32(i)`
194			`{`
195			`_, b := mib[i]`
196			`if !b {`
197			`fmt.Printf("tuple existence decl: mib[%d]\n", i)`
198			`}`
199			`_, b = mib[i]`
200			`if !b {`
201			`fmt.Printf("tuple existence assign: mib[%d]\n", i)`
202			`}`
203			`}`
204			`{`
205			`_, b := mii[i]`
206			`if !b {`
207			`fmt.Printf("tuple existence decl: mii[%d]\n", i)`
208			`}`
209			`_, b = mii[i]`
210			`if !b {`
211			`fmt.Printf("tuple existence assign: mii[%d]\n", i)`
212			`}`
213			`}`
214			`{`
215			`_, b := mfi[f]`
216			`if !b {`
217			`fmt.Printf("tuple existence decl: mfi[%d]\n", i)`
218			`}`
219			`_, b = mfi[f]`
220			`if !b {`
221			`fmt.Printf("tuple existence assign: mfi[%d]\n", i)`
222			`}`
223			`}`
224			`{`
225			`_, b := mif[i]`
226			`if !b {`
227			`fmt.Printf("tuple existence decl: mif[%d]\n", i)`
228			`}`
229			`_, b = mif[i]`
230			`if !b {`
231			`fmt.Printf("tuple existence assign: mif[%d]\n", i)`
232			`}`
233			`}`
234			`{`
235			`_, b := mis[i]`
236			`if !b {`
237			`fmt.Printf("tuple existence decl: mis[%d]\n", i)`
238			`}`
239			`_, b = mis[i]`
240			`if !b {`
241			`fmt.Printf("tuple existence assign: mis[%d]\n", i)`
242			`}`
243			`}`
244			`{`
245			`_, b := msi[s]`
246			`if !b {`
247			`fmt.Printf("tuple existence decl: msi[%d]\n", i)`
248			`}`
249			`_, b = msi[s]`
250			`if !b {`
251			`fmt.Printf("tuple existence assign: msi[%d]\n", i)`
252			`}`
253			`}`
254			`{`
255			`_, b := mss[s]`
256			`if !b {`
257			`fmt.Printf("tuple existence decl: mss[%d]\n", i)`
258			`}`
259			`_, b = mss[s]`
260			`if !b {`
261			`fmt.Printf("tuple existence assign: mss[%d]\n", i)`
262			`}`
263			`}`
264			`{`
265			`_, b := mspa[s]`
266			`if !b {`
267			`fmt.Printf("tuple existence decl: mspa[%d]\n", i)`
268			`}`
269			`_, b = mspa[s]`
270			`if !b {`
271			`fmt.Printf("tuple existence assign: mspa[%d]\n", i)`
272			`}`
273			`}`
274			`{`
275			`_, b := mipT[i]`
276			`if !b {`
277			`fmt.Printf("tuple existence decl: mipT[%d]\n", i)`
278			`}`
279			`_, b = mipT[i]`
280			`if !b {`
281			`fmt.Printf("tuple existence assign: mipT[%d]\n", i)`
282			`}`
283			`}`
284			`{`
285			`_, b := mpTi[apT[i]]`
286			`if !b {`
287			`fmt.Printf("tuple existence decl: mpTi[apT[%d]]\n", i)`
288			`}`
289			`_, b = mpTi[apT[i]]`
290			`if !b {`
291			`fmt.Printf("tuple existence assign: mpTi[apT[%d]]\n", i)`
292			`}`
293			`}`
294			`{`
295			`_, b := mipM[i]`
296			`if !b {`
297			`fmt.Printf("tuple existence decl: mipM[%d]\n", i)`
298			`}`
299			`_, b = mipM[i]`
300			`if !b {`
301			`fmt.Printf("tuple existence assign: mipM[%d]\n", i)`
302			`}`
303			`}`
304			`{`
305			`_, b := mit[i]`
306			`if !b {`
307			`fmt.Printf("tuple existence decl: mit[%d]\n", i)`
308			`}`
309			`_, b = mit[i]`
310			`if !b {`
311			`fmt.Printf("tuple existence assign: mit[%d]\n", i)`
312			`}`
313			`}`
314			`// {`
315			`// _, b := mti[t]`
316			`// if !b {`
317			`// fmt.Printf("tuple existence decl: mti[%d]\n", i)`
318			`// }`
319			`// _, b = mti[t]`
320			`// if !b {`
321			`// fmt.Printf("tuple existence assign: mti[%d]\n", i)`
322			`// }`
323			`// }`
324			`}`
325
326			`// test nonexistence with tuple check`
327			`// failed lookups yield a false value for the boolean.`
328			`for i := count; i < 2*count; i++ {`
329			`s := strconv.Itoa(i)`
330			`f := float32(i)`
331			`{`
332			`_, b := mib[i]`
333			`if b {`
334			`fmt.Printf("tuple nonexistence decl: mib[%d]", i)`
335			`}`
336			`_, b = mib[i]`
337			`if b {`
338			`fmt.Printf("tuple nonexistence assign: mib[%d]", i)`
339			`}`
340			`}`
341			`{`
342			`_, b := mii[i]`
343			`if b {`
344			`fmt.Printf("tuple nonexistence decl: mii[%d]", i)`
345			`}`
346			`_, b = mii[i]`
347			`if b {`
348			`fmt.Printf("tuple nonexistence assign: mii[%d]", i)`
349			`}`
350			`}`
351			`{`
352			`_, b := mfi[f]`
353			`if b {`
354			`fmt.Printf("tuple nonexistence decl: mfi[%d]", i)`
355			`}`
356			`_, b = mfi[f]`
357			`if b {`
358			`fmt.Printf("tuple nonexistence assign: mfi[%d]", i)`
359			`}`
360			`}`
361			`{`
362			`_, b := mif[i]`
363			`if b {`
364			`fmt.Printf("tuple nonexistence decl: mif[%d]", i)`
365			`}`
366			`_, b = mif[i]`
367			`if b {`
368			`fmt.Printf("tuple nonexistence assign: mif[%d]", i)`
369			`}`
370			`}`
371			`{`
372			`_, b := mis[i]`
373			`if b {`
374			`fmt.Printf("tuple nonexistence decl: mis[%d]", i)`
375			`}`
376			`_, b = mis[i]`
377			`if b {`
378			`fmt.Printf("tuple nonexistence assign: mis[%d]", i)`
379			`}`
380			`}`
381			`{`
382			`_, b := msi[s]`
383			`if b {`
384			`fmt.Printf("tuple nonexistence decl: msi[%d]", i)`
385			`}`
386			`_, b = msi[s]`
387			`if b {`
388			`fmt.Printf("tuple nonexistence assign: msi[%d]", i)`
389			`}`
390			`}`
391			`{`
392			`_, b := mss[s]`
393			`if b {`
394			`fmt.Printf("tuple nonexistence decl: mss[%d]", i)`
395			`}`
396			`_, b = mss[s]`
397			`if b {`
398			`fmt.Printf("tuple nonexistence assign: mss[%d]", i)`
399			`}`
400			`}`
401			`{`
402			`_, b := mspa[s]`
403			`if b {`
404			`fmt.Printf("tuple nonexistence decl: mspa[%d]", i)`
405			`}`
406			`_, b = mspa[s]`
407			`if b {`
408			`fmt.Printf("tuple nonexistence assign: mspa[%d]", i)`
409			`}`
410			`}`
411			`{`
412			`_, b := mipT[i]`
413			`if b {`
414			`fmt.Printf("tuple nonexistence decl: mipT[%d]", i)`
415			`}`
416			`_, b = mipT[i]`
417			`if b {`
418			`fmt.Printf("tuple nonexistence assign: mipT[%d]", i)`
419			`}`
420			`}`
421			`{`
422			`_, b := mpTi[apT[i]]`
423			`if b {`
424			`fmt.Printf("tuple nonexistence decl: mpTi[apt[%d]]", i)`
425			`}`
426			`_, b = mpTi[apT[i]]`
427			`if b {`
428			`fmt.Printf("tuple nonexistence assign: mpTi[apT[%d]]", i)`
429			`}`
430			`}`
431			`{`
432			`_, b := mipM[i]`
433			`if b {`
434			`fmt.Printf("tuple nonexistence decl: mipM[%d]", i)`
435			`}`
436			`_, b = mipM[i]`
437			`if b {`
438			`fmt.Printf("tuple nonexistence assign: mipM[%d]", i)`
439			`}`
440			`}`
441			`// {`
442			`// _, b := mti[t]`
443			`// if b {`
444			`// fmt.Printf("tuple nonexistence decl: mti[%d]", i)`
445			`// }`
446			`// _, b = mti[t]`
447			`// if b {`
448			`// fmt.Printf("tuple nonexistence assign: mti[%d]", i)`
449			`// }`
450			`// }`
451			`{`
452			`_, b := mit[i]`
453			`if b {`
454			`fmt.Printf("tuple nonexistence decl: mit[%d]", i)`
455			`}`
456			`_, b = mit[i]`
457			`if b {`
458			`fmt.Printf("tuple nonexistence assign: mit[%d]", i)`
459			`}`
460			`}`
461			`}`
462
463			`// tests for structured map element updates`
464			`for i := 0; i < count; i++ {`
465			`s := strconv.Itoa(i)`
466			`mspa[s][i%2] = "deleted"`
467			`if mspa[s][i%2] != "deleted" {`
468			`fmt.Printf("update mspa[%s][%d] = %s\n", s, i%2, mspa[s][i%2])`
469			`}`
470
471			`mipT[i].i += 1`
472			`if mipT[i].i != int64(i)+1 {`
473			`fmt.Printf("update mipT[%d].i = %d\n", i, mipT[i].i)`
474			`}`
475			`mipT[i].f = float32(i + 1)`
476			`if mipT[i].f != float32(i+1) {`
477			`fmt.Printf("update mipT[%d].f = %g\n", i, mipT[i].f)`
478			`}`
479
480			`mipM[i][i]++`
481			`if mipM[i][i] != (i+1)+1 {`
482			`fmt.Printf("update mipM[%d][%d] = %i\n", i, i, mipM[i][i])`
483			`}`
484			`}`
485
486			`// test range on nil map`
487			`var mnil map[string]int`
488			`for _, _ = range mnil {`
489			`panic("range mnil")`
490			`}`
491			`}`