code review 7313062: exp/ssa/interp: (#6 of 5): test interpretation of SSA f...

test/range.go

 // 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 'for range' construct.
 
 package main
 
@@ skipping 37 matching lines @@
         s := 0
         nmake = 0
         for _, v := range makeslice() {
                 s += v
         }
         if nmake != 1 {
                 println("range called makeslice", nmake, "times")
                 panic("fail")
         }
         if s != 15 {
-                println("wrong sum ranging over makeslice")
+                println("wrong sum ranging over makeslice", s)
                 panic("fail")
         }
-        
+
         x := []int{10, 20}
         y := []int{99}
         i := 1
         for i, x[i] = range y {
                 break
         }
         if i != 0 || x[0] != 10 || x[1] != 99 {
                 println("wrong parallel assignment", i, x[0], x[1])
                 panic("fail")
         }
 }
 
 func testslice1() {
         s := 0
         nmake = 0
         for i := range makeslice() {
                 s += i
         }
         if nmake != 1 {
                 println("range called makeslice", nmake, "times")
                 panic("fail")
         }
         if s != 10 {
-                println("wrong sum ranging over makeslice")
+                println("wrong sum ranging over makeslice", s)
                 panic("fail")
         }
 }
 
 // test that range over array only evaluates
 // the expression after "range" once.
 
 func makearray() [5]int {
         nmake++
         return [5]int{1, 2, 3, 4, 5}
 }
 
 func testarray() {
         s := 0
         nmake = 0
         for _, v := range makearray() {
                 s += v
         }
         if nmake != 1 {
                 println("range called makearray", nmake, "times")
                 panic("fail")
         }
         if s != 15 {
-                println("wrong sum ranging over makearray")
+                println("wrong sum ranging over makearray", s)
                 panic("fail")
         }
 }
 
 func testarray1() {
         s := 0
         nmake = 0
         for i := range makearray() {
                 s += i
         }
         if nmake != 1 {
                 println("range called makearray", nmake, "times")
                 panic("fail")
         }
         if s != 10 {
-                println("wrong sum ranging over makearray")
+                println("wrong sum ranging over makearray", s)
                 panic("fail")
         }
 }
 
 func makearrayptr() *[5]int {
         nmake++
         return &[5]int{1, 2, 3, 4, 5}
 }
 
 func testarrayptr() {
@@ skipping 12 matching lines @@
         s := 0
         nmake = 0
         for _, v := range makearrayptr() {
                 s += v
         }
         if nmake != 1 {
                 println("range called makearrayptr", nmake, "times")
                 panic("fail")
         }
         if s != 15 {
-                println("wrong sum ranging over makearrayptr")
+                println("wrong sum ranging over makearrayptr", s)
                 panic("fail")
         }
 }
 
 func testarrayptr1() {
         s := 0
         nmake = 0
         for i := range makearrayptr() {
                 s += i
         }
-        if nmake != 1 {
+        // Non-evaluation of the range expression is permitted for arrays.

[iant, 2013/02/11 16:56:55]

We have to be clear about whether the range expression is evaluated or not. 
There shouldn't be any "is permitted" for something like that.  Please break
this out into a separate CL, and let's test for precisely the number of
executions.

[adonovan, 2013/02/11 20:59:20]

Changes to the spec wording are being discussed in CL 
https://codereview.appspot.com/7307083/, and once the dust has settled that CL
ought to add assertions to this test.  (Changes to the SSA builder may be
necessary too.)

I've moved the (non-semantic) println changes to
https://codereview.appspot.com/7306087.

+        if nmake != 1 && nmake != 0 {
                 println("range called makearrayptr", nmake, "times")
                 panic("fail")
         }
         if s != 10 {
-                println("wrong sum ranging over makearrayptr")
+                println("wrong sum ranging over makearrayptr", s)
                 panic("fail")
         }
 }
 
 // test that range over string only evaluates
 // the expression after "range" once.
 
 func makestring() string {
         nmake++
         return "abcd☺"
 }
 
 func teststring() {
         var s rune
         nmake = 0
         for _, v := range makestring() {
                 s += v
         }
         if nmake != 1 {
                 println("range called makestring", nmake, "times")
                 panic("fail")
         }
         if s != 'a'+'b'+'c'+'d'+'☺' {
-                println("wrong sum ranging over makestring")
+                println("wrong sum ranging over makestring", s)
                 panic("fail")
         }
 }
 
 func teststring1() {
         s := 0
         nmake = 0
         for i := range makestring() {
                 s += i
         }
         if nmake != 1 {
                 println("range called makestring", nmake, "times")
                 panic("fail")
         }
         if s != 10 {
-                println("wrong sum ranging over makestring")
+                println("wrong sum ranging over makestring", s)
                 panic("fail")
         }
 }
 
 // test that range over map only evaluates
 // the expression after "range" once.
 
 func makemap() map[int]int {
         nmake++
         return map[int]int{0: 'a', 1: 'b', 2: 'c', 3: 'd', 4: '☺'}
 }
 
 func testmap() {
         s := 0
         nmake = 0
         for _, v := range makemap() {
                 s += v
         }
         if nmake != 1 {
                 println("range called makemap", nmake, "times")
                 panic("fail")
         }
         if s != 'a'+'b'+'c'+'d'+'☺' {
-                println("wrong sum ranging over makemap")
+                println("wrong sum ranging over makemap", s)
                 panic("fail")
         }
 }
 
 func testmap1() {
         s := 0
         nmake = 0
         for i := range makemap() {
                 s += i
         }
         if nmake != 1 {
                 println("range called makemap", nmake, "times")
                 panic("fail")
         }
         if s != 10 {
-                println("wrong sum ranging over makemap")
+                println("wrong sum ranging over makemap", s)
                 panic("fail")
         }
 }
 
 // test that range evaluates the index and value expressions
 // exactly once per iteration.
 
 var ncalls = 0
 
 func getvar(p *int) *int {
@@ skipping 36 matching lines @@
         testarrayptr()
         testarrayptr1()
         testslice()
         testslice1()
         teststring()
         teststring1()
         testmap()
         testmap1()
         testcalls()
 }