cmd/compile/internal/inline: score call sites exposed by inlines

[gostls13.git] / test / bigalg.go

diff --git a/test/bigalg.go b/test/bigalg.go
index 31ce222d612a7fd8d361bc4163428d2ff2e705bf..60e822942e2826367093350db4346f6556224c34 100644 (file)
--- a/test/bigalg.go
+++ b/test/bigalg.go
@@ -1,41 +1,46 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // 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.
 
+// Test the internal "algorithms" for objects larger than a word: hashing, equality etc.
+
 package main
 
 type T struct {
-       a float64;
-       b int64;
-       c string;
-       d byte;
+       a float64
+       b int64
+       c string
+       d byte
 }
 
-var a = []int{ 1, 2, 3 }
-var NIL []int;
+var a = []int{1, 2, 3}
+var NIL []int
 
 func arraycmptest() {
        if NIL != nil {
-               println("fail1:", NIL, "!= nil");
+               println("fail1:", NIL, "!= nil")
+               panic("bigalg")
        }
        if nil != NIL {
-               println("fail2: nil !=", NIL);
+               println("fail2: nil !=", NIL)
+               panic("bigalg")
        }
        if a == nil || nil == a {
-               println("fail3:", a, "== nil");
+               println("fail3:", a, "== nil")
+               panic("bigalg")
        }
 }
 
 func SameArray(a, b []int) bool {
        if len(a) != len(b) || cap(a) != cap(b) {
-               return false;
+               return false
        }
        if len(a) > 0 && &a[0] != &b[0] {
-               return false;
+               return false
        }
-       return true;
+       return true
 }
 
 var t = T{1.5, 123, "hello", 255}
@@ -43,16 +48,18 @@ var mt = make(map[int]T)
 var ma = make(map[int][]int)
 
 func maptest() {
-       mt[0] = t;
-       t1 := mt[0];
+       mt[0] = t
+       t1 := mt[0]
        if t1.a != t.a || t1.b != t.b || t1.c != t.c || t1.d != t.d {
-               println("fail: map val struct", t1.a, t1.b, t1.c, t1.d);
+               println("fail: map val struct", t1.a, t1.b, t1.c, t1.d)
+               panic("bigalg")
        }
 
-       ma[1] = a;
-       a1 := ma[1];
+       ma[1] = a
+       a1 := ma[1]
        if !SameArray(a, a1) {
-               println("fail: map val array", a, a1);
+               println("fail: map val array", a, a1)
+               panic("bigalg")
        }
 }
 
@@ -60,58 +67,64 @@ var ct = make(chan T)
 var ca = make(chan []int)
 
 func send() {
-       ct <- t;
-       ca <- a;
+       ct <- t
+       ca <- a
 }
 
 func chantest() {
-       go send();
+       go send()
 
-       t1 := <-ct;
+       t1 := <-ct
        if t1.a != t.a || t1.b != t.b || t1.c != t.c || t1.d != t.d {
-               println("fail: map val struct", t1.a, t1.b, t1.c, t1.d);
+               println("fail: map val struct", t1.a, t1.b, t1.c, t1.d)
+               panic("bigalg")
        }
 
-       a1 := <-ca;
+       a1 := <-ca
        if !SameArray(a, a1) {
-               println("fail: map val array", a, a1);
+               println("fail: map val array", a, a1)
+               panic("bigalg")
        }
 }
 
-type E struct { }
+type E struct{}
+
 var e E
 
 func interfacetest() {
-       var i interface{};
+       var i interface{}
 
-       i = a;
-       a1 := i.([]int);
+       i = a
+       a1 := i.([]int)
        if !SameArray(a, a1) {
-               println("interface <-> []int", a, a1);
+               println("interface <-> []int", a, a1)
+               panic("bigalg")
        }
-       pa := new([]int);
-       *pa = a;
-       i = pa;
-       a1 = *i.(*[]int);
+       pa := new([]int)
+       *pa = a
+       i = pa
+       a1 = *i.(*[]int)
        if !SameArray(a, a1) {
-               println("interface <-> *[]int", a, a1);
+               println("interface <-> *[]int", a, a1)
+               panic("bigalg")
        }
 
-       i = t;
-       t1 := i.(T);
+       i = t
+       t1 := i.(T)
        if t1.a != t.a || t1.b != t.b || t1.c != t.c || t1.d != t.d {
-               println("interface <-> struct", t1.a, t1.b, t1.c, t1.d);
+               println("interface <-> struct", t1.a, t1.b, t1.c, t1.d)
+               panic("bigalg")
        }
 
-       i = e;
-       e1 := i.(E);
+       i = e
+       e1 := i.(E)
        // nothing to check; just verify it doesn't crash
-       _ = e1;
+       _ = e1
 }
 
 func main() {
-       arraycmptest();
-       maptest();
-       chantest();
-       interfacetest();
+       arraycmptest()
+       maptest()
+       chantest()
+       interfacetest()
 }