}
        """

        then:
        def handle1 = executer.withArguments(':a:build', '-i').start()
        poll(120) {
            assert handle1.standardOutput.contains('waiting for file...')
        }
        //first build is waiting for file, so the lock should be releasable now (for example: the task history lock)

        and:
        def handle2 = executer.withArguments('b:build', '-is').start()

        when: "two processes are started, which will edit the settings file at the same time"
        def handle1 = executer.withTasks('tasks').start()
        def handle2 = executer.withTasks('tasks').start()

        and: "they both complete"
        def result1 = handle1.waitForFinish()
        def result2 = handle2.waitForFinish()

        then: "both builds ran, with the settings script editing the archive atomically"

//
//
// CHECK-LABEL:  func.func @serving_default(%arg0: tensor<1x3xf32>) -> tensor<1x1xf32> {
// CHECK-NEXT:   [[HANDLE2:%.*]] = "tf.VarHandleOp"
// CHECK-NEXT:   [[KEY:%.*]], [[FUTURE:%.*]] = "tf.IfrtLoadVariable"([[HANDLE2]])
// CHECK-SAME:       used_by_host = false 
// CHECK-NEXT:   [[RES:%.*]] = "tf.IfrtCall"([[KEY]], %arg0) <{program_id = 6515870160938153680 : i64, variable_arg_indices = [0 : i32]}>

			specVolID: "test.vol.id",
			volHandle: "testvol-handle1",

			originSpec: volume.NewSpecFromPersistentVolume(makeTestPV("test.vol.id", 20, testDriver, "testvol-handle1"), true),
			podUID:     types.UID(fmt.Sprintf("%08X", rand.Uint64())),
		},
		{
			name:       "construct spec2 from original persistent spec",
			specVolID:  "spec2",
			volHandle:  "handle2",

  // CHECK-DAG: [[handle1:%.*]] = "tf.VarHandleOp"() <{{{.*}}, shared_name = "variable1"}>
  // CHECK-DAG: [[handle2:%.*]] = "tf.VarHandleOp"() <{{{.*}}, shared_name = "variable2"}>
  // CHECK: "tf.ReadVariableOp"([[handle1]])
  // CHECK: "tf.ReadVariableOp"([[handle2]])

            handle.release("a")
            handle.waitForAllPendingCalls()
            handle.release(1)
            handle.waitForAllPendingCalls()
            handle.releaseAll()
            handle.waitForAllPendingCalls()
            handle.releaseAll()
            handle.waitForAllPendingCalls()
        }
        server.stop()

        then:
        noExceptionThrown()
    }

  // expected-remark@above {{Sinks: {6}}}
}

// -----

// Tests that two resources allocated with identical non-empty `shared_name`
// attributes are dependent. That means, `%handle1` and `%handle2` point to
// the same resources and the second `InitializeTableV2` op depends on the
// first one.
func.func @resources_allocated_with_same_nonempty_shared_name(
  // expected-remark@above {{ID: 9}}

type ReadyFunc func() bool

// Handler is a base for admission control handlers that
// support a predefined set of operations
type Handler struct {
	operations sets.String
	readyFunc  ReadyFunc
}

// Handles returns true for methods that this handler supports
func (h *Handler) Handles(operation Operation) bool {
	return h.operations.Has(string(operation))

// manage this concurrency.
//
// Users of the slog package should not invoke Handler methods directly.
// They should use the methods of [Logger] instead.
type Handler interface {
	// Enabled reports whether the handler handles records at the given level.
	// The handler ignores records whose level is lower.
	// It is called early, before any arguments are processed,

	Director http.Handler
}

// HandlerChainBuilderFn is used to wrap the GoRestfulContainer handler using the provided handler chain.
// It is normally used to apply filtering like authentication and authorization
type HandlerChainBuilderFn func(apiHandler http.Handler) http.Handler