def tooMany = parent.createDir("dir12")
        def tooFew = parent.createDir("dir")
        def child = dir1.createDir("child1")
        def single = from(dir1)

        expect:
        def s1 = single.plus(dir2)
        s1.contains(dir1)
        s1.contains(child)
        s1.contains(dir2)
        !s1.contains(dir3)
        !s1.contains(tooFew)
        !s1.contains(tooMany)

 * A marker interface for a provider that can be composed, i.e. multiple instances of the same provider can be composed into a single
 * provider.
 *
 * Composable providers share certain traits: There is a notion of a sequentially composed [KotlinCompositeProvider] of that kind, and there
 * is usually a merge function which allows to create a single provider from a list of providers. Mergers of composable providers may

  return a != Attribute() && b != Attribute() && c != Attribute();
}

// Returns the single float element from an ElementsAttr. Returns empty
// attribute if the number of elements in the attribute is not 1 or the
// element isn't a float attribute.
FloatAttr ExtractSingleElementAsFloat(ElementsAttr attr);

// Returns the single float element if the input is an ElementsAttr, or return

	}
}

// Must only be called from a single goroutine at a time.
//
//go:linkname signal_enable os/signal.signal_enable
func signal_enable(s uint32) {
	if !sig.inuse {
		// This is the first call to signal_enable. Initialize.
		sig.inuse = true // enable reception of signals; cannot disable
		noteclear(&sig.note)
	}
}

// Must only be called from a single goroutine at a time.
//

 *
 * <p>Implementations are not guaranteed to be completely thread-safe.
 * However, the implementations:
 * <ul>
 * <li>should allow separate threads for dispatching and receiving, i.e. single thread that dispatches
 * and a different single thread that receives should be perfectly safe</li>
 * <li>should allow stopping or requesting stopping from a different thread than receiving/dispatching</li>

        require(closure.call() == "result") { "parameter-less closure" }

    fun takingUnaryClosure(closure: Closure<*>) =
        require(closure.call("foo") == "result from single parameter foo") { "unary closure" }

    fun takingBinaryClosure(closure: Closure<*>) =
        require(closure.call("foo", "bar") == "result from parameters foo and bar") { "binary closure" }
}

// tag::kotlinClosure[]

}

// -----

// Test that functions' graph op must have only island ops wrapping a single op
// and a single fetch op, otherwise, the pass will signal failure.

func.func @graph_multi_op_island() {
  tf_executor.graph {
    // expected-error@+1 {{functions must be of a single Graph with single op Islands: tf_executor.island must perfectly wrap a single op}}
    tf_executor.island {
      "tf.NoOp"() : () -> ()
      "tf.NoOp"() : () -> ()

// Test simple serialized computation consisting of a function named `main`
// with a tf.Identity op forwarding the function single argument to the function
// single result.

// CHECK-LABEL: module
// CHECK-SAME:  attributes {tf.versions = {producer = 888 : i32}} {
// CHECK-NEXT:   func @main([[ARG0:%.+]]: tensor<?xi32> loc({{.*}})) -> tensor<?xi32> {

// block comment
retract (
	v1.0.0-block

	// inner comment
	v1.0.0-blockwithcomment
)

retract (
	[v1.0.0-order, v1.0.0-order] // degenerate range
	v1.0.0-order // single version

	v1.0.1-order // single version
	[v1.0.1-order, v1.0.1-order] // degenerate range
)
-- .info --

// RUN: tf-opt %s -split-input-file -tf-verify-for-export -verify-diagnostics | FileCheck %s

module {
  func.func @failsNoIslands() {
    // expected-error @+1 {{functions must be of a single Graph with single op Islands: first op in function is not a tf_executor.graph}}
    func.return
  }
}

// -----

module {
  // CHECK-LABEL: func @passesSingleIslandOp
  func.func @passesSingleIslandOp() {
    // CHECK: _class = ["loc:@class"]