tf_executor.yield
    }
    %island2 = tf_executor.island(%island1) {
      "tf.NoOp"() : () -> ()
      tf_executor.yield
    }
    %island3 = tf_executor.island(%island2) {
      "tf.NoOp"() : () -> ()
      tf_executor.yield
    }
    %island4:2 = tf_executor.island(%island3) {

  "tfl.if"(%arg0) (
  {
    // then
    ^bb0:
     "tfl.yield"() : () -> ()
  },
  {
    // else
   ^bb0:
    "tfl.yield"() : () -> ()
  }) : (tensor<1xi1>) -> ()
  func.return
}
// CHECK-NEXT: %[[CONTROL:.*]] = tfl.control_node controls "tfl.if"
// CHECK-NEXT: "tfl.yield"() : () -> ()
// CHECK-NEXT: }, {
// CHECK-NEXT: "tfl.yield"() : () -> ()
// CHECK-NEXT: }) : (tensor<1xi1>) -> ()
// CHECK-NEXT: return

        removedNodes.empty

        where:
        vfsSpec << onlyDirectChildren(NO_COMMON_PREFIX + SAME_PATH + CHILD_IS_PREFIX)
    }

    def "querying the snapshot for non-existent child #vfsSpec.searchedPath yields a missing file (#vfsSpec)"() {
        setupTest(vfsSpec)

        when:
        FileSystemLocationSnapshot foundSnapshot = initialRoot.getSnapshot(searchedPath, CASE_SENSITIVE).get() as FileSystemLocationSnapshot

	return nil
}

func iterSimple(yield func(int) bool) {
	for range 3 {
		if !yield(5) {
			return
		}
	}
}

func iterNested(yield func(int) bool) {
	next, stop := iter.Pull(iterSimple)
	for {
		v, ok := next()
		if ok {
			if !yield(v) {
				stop()
			}
		} else {
			return
		}
	}
}

func iterLock(yield func(int) bool) {
	for range 3 {

	"testing"
)

type Seq2[T1, T2 any] func(yield func(T1, T2) bool)

// ofSliceIndex returns a Seq over the elements of s. It is equivalent
// to range s, except that it splits s into two halves and iterates
// in two separate goroutines.  This is racy if yield is racy, and yield
// will be racy if it contains an early exit.
func ofSliceIndex[T any, S ~[]T](s S) Seq2[int, T] {
	return func(yield func(int, T) bool) {
		c := make(chan bool, 2)

// When called as seq(yield), seq calls yield(v) for each value v in the sequence,
// stopping early if yield returns false.
type Seq[V any] func(yield func(V) bool)

// Seq2 is an iterator over sequences of pairs of values, most commonly key-value pairs.
// When called as seq(yield), seq calls yield(k, v) for each pair (k, v) in the sequence,
// stopping early if yield returns false.

    %1 = "tf.OpA"() {is_stateless = true} : () -> tensor<i1>
    "tf.Yield"(%1) : (tensor<i1>) -> ()
  }, {
  ^bb0(%arg2: tensor<*xf32>, %arg3: tensor<*xf32>):
    %1 = "tf.OpB"(%arg2) {is_stateless = true} : (tensor<*xf32>) -> tensor<*xf32>
    %2 = "tf.OpC"(%arg3) {is_stateless = true} : (tensor<*xf32>) -> tensor<*xf32>
    "tf.Yield"(%1, %2) : (tensor<*xf32>, tensor<*xf32>) -> ()

// CHECK: tf_executor.graph {
// CHECK:   %[[CONTROL:.*]] = tf_executor.island {
// CHECK:     tf_executor.yield
// CHECK:   }
// CHECK:   tf_executor.fetch %[[CONTROL]] : !tf_executor.control
// CHECK: }
// CHECK: return

func.func @graph_already() {
  tf_executor.graph {
    %control = tf_executor.island {
      tf_executor.yield
    }
    tf_executor.fetch %control : !tf_executor.control
  }
  func.return
}

      tf_executor.yield %launch#0, %launch#1: tensor<f32>, tensor<i32>
    }
    tf_executor.fetch
  }
  func.return
}

// CHECK-NOT: tf_executor.island
// CHECK:      [[A:%.+]]:2, {{.*}} = tf_executor.island wraps "tf.opA"
// CHECK-SAME: device = "CPU:0"
// CHECK-NOT:  tf_device.launch
// CHECK-NOT:      tf_executor.yield [[A]]#1, [[A]]#0

	})
	return err
}

func iterSimple(yield func(int) bool) {
	for range 3 {
		if !yield(5) {
			return
		}
	}
}

func iterNested(yield func(int) bool) {
	next, stop := iter.Pull(iterSimple)
	for {
		v, ok := next()
		if ok {
			if !yield(v) {
				stop()
			}
		} else {
			return
		}
	}
}

func iterCallback(yield func(int) bool) {
	for range 3 {