for _, test := range tests {
		t.Run(test.name, func(t *testing.T) {
			registration := &fakeAPIServiceRegistration{}
			crdCache := cache.NewIndexer(cache.DeletionHandlingMetaNamespaceKeyFunc, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc})
			crdLister := crdlisters.NewCustomResourceDefinitionLister(crdCache)
			c := crdRegistrationController{
				crdLister:              crdLister,
				apiServiceRegistration: registration,
			}

	t.Parallel()
	c, _ := NewFakeControllerWithOptions(t, FakeControllerOptions{})

	ns := "default"
	podCache := c.pods

	handled := 0
	podCache.c.handlers.AppendWorkloadHandler(func(*model.WorkloadInstance, model.Event) {
		handled++
	})

	f := podCache.onEvent

	ip := "172.0.3.35"
	pod1 := metav1.ObjectMeta{Name: "pod1", Namespace: ns}

            this.modelRepositoryHolder = modelRepositoryHolder;
            return this;
        }

        public ModelBuilderRequestBuilder modelCache(ModelCache modelCache) {
            this.modelCache = modelCache;
            return this;
        }

        public ModelBuilderRequestBuilder listener(Object listener) {
            this.listener = listener;
            return this;

}

// AddModCommonFlags adds the module-related flags common to build commands
// and 'go mod' subcommands.
func AddModCommonFlags(flags *flag.FlagSet) {
	flags.BoolVar(&cfg.ModCacheRW, "modcacherw", false, "")
	flags.StringVar(&cfg.ModFile, "modfile", "", "")
	flags.StringVar(&fsys.OverlayFile, "overlay", "", "")
}

func ChdirFlag(s string) error {
	// main handles -C by removing it from the command line.

		cmdFlags = &run.CmdRun.Flag
	}

	// The modcachrw flag is unique, in that it affects how we fetch the
	// requested module to even figure out what toolchain it needs.
	// We need to actually set it before we check the toolchain version.
	// (See https://go.dev/issue/64282.)
	modcacherwFlag := cmdFlags.Lookup("modcacherw")
	if modcacherwFlag == nil {
		base.Fatalf("internal error: modcacherw flag not registered for command")
	}

        return this;
    }

    @Override
    public ModelCache getModelCache() {
        return request.getModelCache();
    }

    @Override
    public FilterModelBuildingRequest setModelCache(ModelCache modelCache) {
        request.setModelCache(modelCache);

        return this;
    }

    @Override
    public Model getFileModel() {

symlink $GOROOT -> $TESTGO_GOROOT

# Set up fresh GOCACHE
env GOCACHE=$WORK/gocache1
mkdir $GOCACHE

# Build a simple binary
go build -o binary1 -trimpath -x main.go

# Now repeat the same process with the compiler at a different local path
env GOROOT=$WORK/goroot2
symlink $GOROOT -> $TESTGO_GOROOT

env GOCACHE=$WORK/gocache2
mkdir $GOCACHE

go build -o binary2 -trimpath -x main.go

env GO111MODULE=off
[short] skip

# Set up fresh GOCACHE.
env GOCACHE=$WORK/gocache
mkdir $GOCACHE

# Building trivial non-main package should run compiler the first time.
go build -x lib.go
stderr '(compile|gccgo)( |\.exe).*lib\.go'

# ... but not again ...
go build -x lib.go
! stderr '(compile|gccgo)( |\.exe).*lib\.go'

# ... unless we use -a.
go build -a -x lib.go
stderr '(compile|gccgo)( |\.exe)'

-- lib.go --

# Download modules and populate go.sum.
go get -modcacherw
exists $GOPATH/pkg/mod/rsc.io/quote@v1.5.2/go.mod

# 'go mod verify' should fail if we delete a file.
go mod verify
rm $GOPATH/pkg/mod/rsc.io/quote@v1.5.2/go.mod
! go mod verify

# Create a .partial file to simulate an failure extracting the zip file.
cp empty $GOPATH/pkg/mod/cache/download/rsc.io/quote/@v/v1.5.2.partial

        return this;
    }

    @Override
    public ModelCache getModelCache() {
        return this.modelCache;
    }

    @Override
    public DefaultModelBuildingRequest setModelCache(ModelCache modelCache) {
        this.modelCache = modelCache;

        return this;
    }

    @Override
    public Model getFileModel() {