diff options
author | Russ Cox <rsc@golang.org> | 2011-09-26 19:35:21 -0400 |
---|---|---|
committer | Russ Cox <rsc@golang.org> | 2011-09-26 19:35:21 -0400 |
commit | ca2e62225e091affc59bf49e867438f490fcd839 (patch) | |
tree | 5be411aac2e6e2375ca698b6dae5e0eece8709a9 /test/cmp.go | |
parent | 8f5623ae8618b247a89cfe548fc55ee306105a5a (diff) | |
download | go-ca2e62225e091affc59bf49e867438f490fcd839.tar.gz |
test: silence/coalesce some tests
Add copyright notice to nilptr.go.
R=golang-dev, r
CC=golang-dev
http://codereview.appspot.com/5139048
Diffstat (limited to 'test/cmp.go')
-rw-r--r-- | test/cmp.go | 170 |
1 files changed, 170 insertions, 0 deletions
diff --git a/test/cmp.go b/test/cmp.go new file mode 100644 index 000000000..570487db6 --- /dev/null +++ b/test/cmp.go @@ -0,0 +1,170 @@ +// $G $D/$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 "unsafe" + +func use(bool) {} + +func stringptr(s string) uintptr { return *(*uintptr)(unsafe.Pointer(&s)) } + +func isfalse(b bool) { + if b { + // stack will explain where + panic("wanted false, got true") + } +} + +func istrue(b bool) { + if !b { + // stack will explain where + panic("wanted true, got false") + } +} + +type T *int + +func main() { + var a []int + var b map[string]int + + var c string = "hello" + var d string = "hel" // try to get different pointer + d = d + "lo" + if stringptr(c) == stringptr(d) { + panic("compiler too smart -- got same string") + } + + var e = make(chan int) + + var ia interface{} = a + var ib interface{} = b + var ic interface{} = c + var id interface{} = d + var ie interface{} = e + + // these comparisons are okay because + // string compare is okay and the others + // are comparisons where the types differ. + isfalse(ia == ib) + isfalse(ia == ic) + isfalse(ia == id) + isfalse(ib == ic) + isfalse(ib == id) + istrue(ic == id) + istrue(ie == ie) + + // these are okay because one side of the + // comparison need only be assignable to the other. + isfalse(a == ib) + isfalse(a == ic) + isfalse(a == id) + isfalse(b == ic) + isfalse(b == id) + istrue(c == id) + istrue(e == ie) + + isfalse(ia == b) + isfalse(ia == c) + isfalse(ia == d) + isfalse(ib == c) + isfalse(ib == d) + istrue(ic == d) + istrue(ie == e) + + // 6g used to let this go through as true. + var g uint64 = 123 + var h int64 = 123 + var ig interface{} = g + var ih interface{} = h + isfalse(ig == ih) + + // map of interface should use == on interface values, + // not memory. + // TODO: should m[c], m[d] be valid here? + var m = make(map[interface{}]int) + m[ic] = 1 + m[id] = 2 + if m[ic] != 2 { + println("m[ic] = ", m[ic]) + panic("bad m[ic]") + } + + // non-interface comparisons + { + c := make(chan int) + c1 := (<-chan int)(c) + c2 := (chan<- int)(c) + istrue(c == c1) + istrue(c == c2) + istrue(c1 == c) + istrue(c2 == c) + + d := make(chan int) + isfalse(c == d) + isfalse(d == c) + isfalse(d == c1) + isfalse(d == c2) + isfalse(c1 == d) + isfalse(c2 == d) + } + + // named types vs not + { + var x = new(int) + var y T + var z T = x + + isfalse(x == y) + istrue(x == z) + isfalse(y == z) + + isfalse(y == x) + istrue(z == x) + isfalse(z == y) + } + + shouldPanic(p1) + shouldPanic(p2) + shouldPanic(p3) + shouldPanic(p4) +} + +func p1() { + var a []int + var ia interface{} = a + use(ia == ia) +} + +func p2() { + var b []int + var ib interface{} = b + use(ib == ib) +} + +func p3() { + var a []int + var ia interface{} = a + var m = make(map[interface{}] int) + m[ia] = 1 +} + +func p4() { + var b []int + var ib interface{} = b + var m = make(map[interface{}] int) + m[ib] = 1 +} + +func shouldPanic(f func()) { + defer func() { + if recover() == nil { + panic("function should panic") + } + }() + f() +} |