}

    static class TestReportContainer extends TaskReportContainer<Report> {
        TestReportContainer(Task task, Closure c) {
            super(Report, task, CollectionCallbackActionDecorator.NOOP)

            c.delegate = new Object() {
                Report file(String name) {
                    add(TaskGeneratedSingleFileReport, name, task)
                }
                Report dir(String name) {

    Instantiator instantiator = TestUtil.instantiatorFactory().decorateLenient()
    DefaultPublicationContainer container = instantiator.newInstance(DefaultPublicationContainer, instantiator, CollectionCallbackActionDecorator.NOOP)

    def "exception is thrown on unknown access"() {
        given:
        container.add(publication("foo"))

        expect:
        container.foo instanceof Publication

        when:

        @Override
        protected SnapshotHierarchy updateNotifyingListeners(AbstractVirtualFileSystem.UpdateFunction updateFunction) {
            return updateFunction.update(SnapshotHierarchy.NodeDiffListener.NOOP)
        }
    }

    def "does not store snapshot when invalidation happened in between"() {
        def location = '/my/location/new'
        when:
        start {
            vfs.store(location, { ->

limitations under the License.
*/

package storagebackend

import (
	"time"

	oteltrace "go.opentelemetry.io/otel/trace"
	noopoteltrace "go.opentelemetry.io/otel/trace/noop"

	"k8s.io/apimachinery/pkg/runtime"
	"k8s.io/apimachinery/pkg/runtime/schema"
	"k8s.io/apiserver/pkg/server/egressselector"
	"k8s.io/apiserver/pkg/storage/etcd3"
	"k8s.io/apiserver/pkg/storage/value"

  func.func @tail_single_outside_compiled_op() {
    // CHECK:      %[[CLUSTER_OUT:.*]] = "tf_device.cluster"
    // CHECK-NEXT:   %[[A_OUT:.*]] = "tf.A"
    // CHECK-NEXT:   "tf.NoOp"
    // CHECK-NEXT:   tf_device.return %[[A_OUT]]
    // CHECK-NEXT: {
    // CHECK-DAG:  num_cores_per_replica = 1
    // CHECK-DAG:  step_marker_location = ""
    // CHECK-DAG:  topology = ""

func.func @multiple_func_body_ops() {
  tf_executor.graph {
    tf_executor.island {
      "tf.NoOp"() : () -> ()
      tf_executor.yield
    }
    tf_executor.fetch
  }
  tf_executor.graph {
    tf_executor.island {
      "tf.NoOp"() : () -> ()
      tf_executor.yield
    }
    tf_executor.fetch
  }
  func.return
}

// -----

*/

package factory

import (
	"context"
	"io/ioutil"
	"os"
	"path"
	"path/filepath"
	"testing"

	"go.etcd.io/etcd/client/pkg/v3/transport"
	noopoteltrace "go.opentelemetry.io/otel/trace/noop"

	apitesting "k8s.io/apimachinery/pkg/api/apitesting"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"k8s.io/apimachinery/pkg/runtime"
	"k8s.io/apimachinery/pkg/runtime/schema"

    def ideArtifactRegistry = Mock(IdeArtifactRegistry)
    def registry = new VisualStudioProjectRegistry(fileResolver, TestUtil.instantiatorFactory().decorateLenient(), ideArtifactRegistry, CollectionCallbackActionDecorator.NOOP, TestUtil.objectFactory(), new DefaultProviderFactory())

    def "creates a matching visual studio project configuration for target binary"() {
        def executableBinary = targetBinary("vsConfig")
        when:

	// Just mark the PID unusable.
	p.pidDeactivate(statusReleased)

	// no need for a finalizer anymore
	runtime.SetFinalizer(p, nil)
	return nil
}

func findProcess(pid int) (p *Process, err error) {
	// NOOP for Plan 9.
	return newPIDProcess(pid), nil
}

// ProcessState stores information about a process, as reported by Wait.
type ProcessState struct {
	pid    int              // The process's id.

    final resolver = Stub(NativeDependencyResolver)
    final outputFile = Mock(File)
    def tasks = new DefaultStaticLibraryBinarySpec.DefaultTasksCollection(new DefaultBinaryTasksCollection(null, null, CollectionCallbackActionDecorator.NOOP))

    def "has useful string representation"() {
        expect:
        staticLibrary.toString() == "static library 'main:staticLibrary'"
    }

    def getStaticLibrary() {