// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Use of public API is ok.

package main

import (
	"iter"
	"unique"
)

func seq(yield func(int) bool) {
	yield(123)
}

var s = "hello"

func main() {
	h := unique.Make(s)
	next, stop := iter.Pull(seq)
	defer stop()
	println(h.Value())
	println(next())
	println(next())

// Linkname coroswitch is not allowed, even if iter.Pull
// is instantiated in the same package.

package main

import (
	"iter"
	"unsafe"
)

func seq(yield func(int) bool) {
	yield(123)
}

func main() {
	next, stop := iter.Pull(seq)
	next()
	stop()
	coroswitch(nil)
}

//go:linkname coroswitch runtime.coroswitch

      %control = tf_executor.island {
        "tf.StatefulPartitionedCall"(%arg0) <{config = "", config_proto = "", executor_type = "", f = @partitioned}> : (tensor<*x!tf_type.resource>) -> ()
        tf_executor.yield
      }
      tf_executor.fetch %control : !tf_executor.control
    }
    return
  }

func (*T) PM() {}
func (T) M()   {}

func test() {
	for range T.M { // ERROR "cannot range over T.M \(value of type func\(T\)\): func must be func\(yield func\(...\) bool\): argument is not func"
	}
	for range (*T).PM { // ERROR "cannot range over \(\*T\).PM \(value of type func\(\*T\)\): func must be func\(yield func\(...\) bool\): argument is not func"
	}

      %3 = "tf_device.cluster"() ({
        %4 = "tf.B"(%2) : (tensor<?xi32>) -> tensor<?xi32>
        tf_device.return %4 : tensor<?xi32>
      }) {} : () -> tensor<?xi32>

      // CHECK: tf_executor.yield %[[CLUSTER_OUTPUT]]
      tf_executor.yield %3 : tensor<?xi32>
    }
    tf_executor.fetch %1#0 : tensor<?xi32>
  }
  func.return %0 : tensor<?xi32>
}

// CHECK: func private @[[CLUSTER]]

				break
			}
			iterChans[0] <- i
		}
	}()
	wg.Wait()

	// End of traced execution.
	trace.Stop()
}

func pullRange(n int) intIter {
	next, stop := iter.Pull(func(yield func(v int) bool) {
		for i := range n {
			yield(i)
		}
	})
	return intIter{next: next, stop: stop}
}

type intIter struct {
	next func() (int, bool)
	stop func()

// CHECK-NEXT:   %[[MY_CUSTOM:.*]] = "tf.MyCustomOp"(%arg1, %arg2) {fused_activation_function = "RELU", int_attr = 2 : i32} : (tensor<4xf32>, tensor<4xf32>) -> tensor<4xf32>
// CHECK-NEXT:   "tfl.yield"(%[[MY_CUSTOM]]) : (tensor<4xf32>) -> ()
// CHECK-NEXT: }) {fused_activation_function = "RELU", int_attr = 2 : i32} : (tensor<4xf32>, tensor<4xf32>) -> tensor<4xf32>
// CHECK-NEXT: %[[CUSTOM_2:.*]] = "tfl.custom_tf"(%[[MUL]], %[[CST]]) ({

			}
			ev++
			cnt++
		}
		if cnt != size {
			t.Errorf("read %d values expected %d", cnt, size)
		}
	}
}

func testSeq(yield func(int) bool) {
	for i := 0; i < 10; i += 2 {
		if !yield(i) {
			return
		}
	}
}

var testSeqResult = []int{0, 2, 4, 6, 8}

func TestAppendSeq(t *testing.T) {
	s := AppendSeq([]int{1, 2}, testSeq)

    var startIndex = 0
    while (true) {
        val endIndex = indexOf(delimiter, startIndex) + 1
        if (endIndex == 0) break
        yield(substring(startIndex, endIndex))
        startIndex = endIndex
    }
    if (startIndex <= lastIndex) {
        yield(substring(startIndex))
    }

			t.Errorf("Values(%v) = %v, want %v", m, got, want)
		}
	}
}

func TestInsert(t *testing.T) {
	got := map[int]int{
		1: 1,
		2: 1,
	}
	Insert(got, func(yield func(int, int) bool) {
		for i := 0; i < 10; i += 2 {
			if !yield(i, i+1) {
				return
			}
		}
	})

	want := map[int]int{
		1: 1,
		2: 1,
	}
	for i, v := range map[int]int{
		0: 1,
		2: 3,
		4: 5,
		6: 7,
		8: 9,