go/test/cmp.go

// $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()
}