break
		}
		return func(yield func(Value) bool) {
			v = v.Elem()
			for i := range v.Len() {
				if !yield(ValueOf(i)) {
					return
				}
			}
		}
	case Array, Slice:
		return func(yield func(Value) bool) {
			for i := range v.Len() {
				if !yield(ValueOf(i)) {
					return
				}
			}
		}
	case String:
		return func(yield func(Value) bool) {
			for i := range v.String() {

        "tf.Yield"() : () -> ()
        }, {
        "tf.Yield"() : () -> ()
       }) {is_stateless = true} : (tensor<i1>) -> ()
       "tf.Yield"(%1) : (tensor<i1>) -> ()
    }, {
    ^bb0(%arg1: tensor<i32>, %arg2: tensor<?xf32>):
      "tf.IfRegion"(%0) ({
        %2 = "tf.B"() : () -> (tensor<f32>)
        "tf.Yield"() : () -> ()
        }, {
        "tf.Yield"() : () -> ()

        "tf_executor.yield"(%0) : (tensor<*xi32>) -> ()
      }) : () -> (tensor<*xi32>, !tf_executor.control)
      %outputs_4, %control_5 = "tf_executor.island"(%control_3) ({
        %0 = "tf.Const"() {device = "", value = dense<2.000000e+00> : tensor<f32>} : () -> tensor<f32>
        "tf_executor.yield"(%0) : (tensor<f32>) -> ()

 * Runs a [TaskRunner] in a controlled environment so that everything is sequential and
 * deterministic.
 *
 * This class ensures that at most one thread is running at a time. This is initially the JUnit test
 * thread, which yields its execution privilege while calling [runTasks], [runNextTask], or
 * [advanceUntil]. These functions don't return until the task threads are all idle.
 *
 * Task threads release their execution privilege in these ways:
 *

      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) {

  %0:2 = tf_executor.graph {
    %1:2 = tf_executor.island {
      tf_executor.yield %arg1 : tensor<i1>
    }
    %2:2 = tf_executor.island {
      tf_executor.yield %arg0 : tensor<i1>
    }
    %3:2 = tf_executor.island {
      tf_executor.yield %1#0 : tensor<i1>
    }
    %4:2 = tf_executor.island {
      tf_executor.yield %2#0 : tensor<i1>
    }

  "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

  tf_executor.graph {
    %0 = tf_executor.island {
      tf_executor.yield
    }
    %1 = tf_executor.island(%0) {
      %3 = "tf.opA"() : () -> tensor<i1>
      tf_executor.yield
    }
    %2 = tf_executor.island(%0, %1) {
      %4 = "tf.opB"() : () -> tensor<i1>
      tf_executor.yield
    }
    tf_executor.fetch
  }
  func.return
}

	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 {