From 109be507377fe7f6e8819ac94041d3fdcdf6fd2f Mon Sep 17 00:00:00 2001
From: Daniel Baumann <daniel.baumann@progress-linux.org>
Date: Sun, 28 Apr 2024 15:18:25 +0200
Subject: Adding upstream version 1.19.8.

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
---
 test/range.go | 494 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 494 insertions(+)
 create mode 100644 test/range.go

(limited to 'test/range.go')

diff --git a/test/range.go b/test/range.go
new file mode 100644
index 0000000..3da7d17
--- /dev/null
+++ b/test/range.go
@@ -0,0 +1,494 @@
+// 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
+
+// test range over channels
+
+func gen(c chan int, lo, hi int) {
+	for i := lo; i <= hi; i++ {
+		c <- i
+	}
+	close(c)
+}
+
+func seq(lo, hi int) chan int {
+	c := make(chan int)
+	go gen(c, lo, hi)
+	return c
+}
+
+const alphabet = "abcdefghijklmnopqrstuvwxyz"
+
+func testblankvars() {
+	n := 0
+	for range alphabet {
+		n++
+	}
+	if n != 26 {
+		println("for range: wrong count", n, "want 26")
+		panic("fail")
+	}
+	n = 0
+	for _ = range alphabet {
+		n++
+	}
+	if n != 26 {
+		println("for _ = range: wrong count", n, "want 26")
+		panic("fail")
+	}
+	n = 0
+	for _, _ = range alphabet {
+		n++
+	}
+	if n != 26 {
+		println("for _, _ = range: wrong count", n, "want 26")
+		panic("fail")
+	}
+	s := 0
+	for i, _ := range alphabet {
+		s += i
+	}
+	if s != 325 {
+		println("for i, _ := range: wrong sum", s, "want 325")
+		panic("fail")
+	}
+	r := rune(0)
+	for _, v := range alphabet {
+		r += v
+	}
+	if r != 2847 {
+		println("for _, v := range: wrong sum", r, "want 2847")
+		panic("fail")
+	}
+}
+
+func testchan() {
+	s := ""
+	for i := range seq('a', 'z') {
+		s += string(i)
+	}
+	if s != alphabet {
+		println("Wanted lowercase alphabet; got", s)
+		panic("fail")
+	}
+	n := 0
+	for range seq('a', 'z') {
+		n++
+	}
+	if n != 26 {
+		println("testchan wrong count", n, "want 26")
+		panic("fail")
+	}
+}
+
+// test that range over slice only evaluates
+// the expression after "range" once.
+
+var nmake = 0
+
+func makeslice() []int {
+	nmake++
+	return []int{1, 2, 3, 4, 5}
+}
+
+func testslice() {
+	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", 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", s)
+		panic("fail")
+	}
+}
+
+func testslice2() {
+	n := 0
+	nmake = 0
+	for range makeslice() {
+		n++
+	}
+	if nmake != 1 {
+		println("range called makeslice", nmake, "times")
+		panic("fail")
+	}
+	if n != 5 {
+		println("wrong count ranging over makeslice", n)
+		panic("fail")
+	}
+}
+
+// test that range over []byte(string) only evaluates
+// the expression after "range" once.
+
+func makenumstring() string {
+	nmake++
+	return "\x01\x02\x03\x04\x05"
+}
+
+func testslice3() {
+	s := byte(0)
+	nmake = 0
+	for _, v := range []byte(makenumstring()) {
+		s += v
+	}
+	if nmake != 1 {
+		println("range called makenumstring", nmake, "times")
+		panic("fail")
+	}
+	if s != 15 {
+		println("wrong sum ranging over []byte(makenumstring)", 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", 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", s)
+		panic("fail")
+	}
+}
+
+func testarray2() {
+	n := 0
+	nmake = 0
+	for range makearray() {
+		n++
+	}
+	if nmake != 1 {
+		println("range called makearray", nmake, "times")
+		panic("fail")
+	}
+	if n != 5 {
+		println("wrong count ranging over makearray", n)
+		panic("fail")
+	}
+}
+
+func makearrayptr() *[5]int {
+	nmake++
+	return &[5]int{1, 2, 3, 4, 5}
+}
+
+func testarrayptr() {
+	nmake = 0
+	x := len(makearrayptr())
+	if x != 5 || nmake != 1 {
+		println("len called makearrayptr", nmake, "times and got len", x)
+		panic("fail")
+	}
+	nmake = 0
+	x = cap(makearrayptr())
+	if x != 5 || nmake != 1 {
+		println("cap called makearrayptr", nmake, "times and got len", x)
+		panic("fail")
+	}
+	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", s)
+		panic("fail")
+	}
+}
+
+func testarrayptr1() {
+	s := 0
+	nmake = 0
+	for i := range makearrayptr() {
+		s += i
+	}
+	if nmake != 1 {
+		println("range called makearrayptr", nmake, "times")
+		panic("fail")
+	}
+	if s != 10 {
+		println("wrong sum ranging over makearrayptr", s)
+		panic("fail")
+	}
+}
+
+func testarrayptr2() {
+	n := 0
+	nmake = 0
+	for range makearrayptr() {
+		n++
+	}
+	if nmake != 1 {
+		println("range called makearrayptr", nmake, "times")
+		panic("fail")
+	}
+	if n != 5 {
+		println("wrong count ranging over makearrayptr", n)
+		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", s)
+		panic("fail")
+	}
+
+	x := []rune{'a', 'b'}
+	i := 1
+	for i, x[i] = range "c" {
+		break
+	}
+	if i != 0 || x[0] != 'a' || x[1] != 'c' {
+		println("wrong parallel assignment", i, x[0], x[1])
+		panic("fail")
+	}
+
+	y := []int{1, 2, 3}
+	r := rune(1)
+	for y[r], r = range "\x02" {
+		break
+	}
+	if r != 2 || y[0] != 1 || y[1] != 0 || y[2] != 3 {
+		println("wrong parallel assignment", r, y[0], y[1], y[2])
+		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", s)
+		panic("fail")
+	}
+}
+
+func teststring2() {
+	n := 0
+	nmake = 0
+	for range makestring() {
+		n++
+	}
+	if nmake != 1 {
+		println("range called makestring", nmake, "times")
+		panic("fail")
+	}
+	if n != 5 {
+		println("wrong count ranging over makestring", n)
+		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", 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", s)
+		panic("fail")
+	}
+}
+
+func testmap2() {
+	n := 0
+	nmake = 0
+	for range makemap() {
+		n++
+	}
+	if nmake != 1 {
+		println("range called makemap", nmake, "times")
+		panic("fail")
+	}
+	if n != 5 {
+		println("wrong count ranging over makemap", n)
+		panic("fail")
+	}
+}
+
+// test that range evaluates the index and value expressions
+// exactly once per iteration.
+
+var ncalls = 0
+
+func getvar(p *int) *int {
+	ncalls++
+	return p
+}
+
+func testcalls() {
+	var i, v int
+	si := 0
+	sv := 0
+	for *getvar(&i), *getvar(&v) = range [2]int{1, 2} {
+		si += i
+		sv += v
+	}
+	if ncalls != 4 {
+		println("wrong number of calls:", ncalls, "!= 4")
+		panic("fail")
+	}
+	if si != 1 || sv != 3 {
+		println("wrong sum in testcalls", si, sv)
+		panic("fail")
+	}
+
+	ncalls = 0
+	for *getvar(&i), *getvar(&v) = range [0]int{} {
+		println("loop ran on empty array")
+		panic("fail")
+	}
+	if ncalls != 0 {
+		println("wrong number of calls:", ncalls, "!= 0")
+		panic("fail")
+	}
+}
+
+func main() {
+	testblankvars()
+	testchan()
+	testarray()
+	testarray1()
+	testarray2()
+	testarrayptr()
+	testarrayptr1()
+	testarrayptr2()
+	testslice()
+	testslice1()
+	testslice2()
+	testslice3()
+	teststring()
+	teststring1()
+	teststring2()
+	testmap()
+	testmap1()
+	testmap2()
+	testcalls()
+}
-- 
cgit v1.2.3