podCache kubecontainer.Cache

	// os is a facade for various syscalls that need to be mocked during testing.
	os kubecontainer.OSInterface

	// Watcher of out of memory events.
	oomWatcher oomwatcher.Watcher

	// Monitor resource usage
	resourceAnalyzer serverstats.ResourceAnalyzer

	// Whether or not we should have the QOS cgroup hierarchy for resource management
	cgroupsPerQOS bool

	// Data must contain the bytes that will be patched.
	Data []byte
}

// PatchManager defines an object that can apply patches.
type PatchManager struct {
	patchSets    []*patchSet
	knownTargets []string
	output       io.Writer
}

// patchSet defines a set of patches of a certain type that can patch a PatchTarget.
type patchSet struct {
	targetName string
	patchType  types.PatchType
	patches    []string
}

// layer.
type IAMStoreSys struct {
	IAMStorageAPI

	group *singleflight.Group
}

// HasWatcher - returns if the storage system has a watcher.
func (store *IAMStoreSys) HasWatcher() bool {
	_, ok := store.IAMStorageAPI.(iamStorageWatcher)
	return ok
}

// GetUser - fetches credential from memory.

			w, err := noxuNamespacedResourceClient.Watch(context.TODO(), metav1.ListOptions{})
			if err != nil {
				t.Errorf("unexpected error establishing watch: %v", err)
				return
			}
			for event := range w.ResultChan() {
				switch event.Type {
				case watch.Added, watch.Modified, watch.Deleted:
					// all expected
				default:
					t.Errorf("unexpected watch event: %#v", event)
				}
			}
		}(i)
	}

			return nil
		}
		if !apiequality.Semantic.DeepDerivative(*job, testJob) {
			t.Errorf("Expected %#v, but got %#v", testJob, *job)
		}
		return nil
	}
	// Start only the job watcher and the workqueue, send a watch event,
	// and make sure it hits the sync method.
	stopCh := make(chan struct{})
	defer close(stopCh)
	sharedInformerFactory.Start(stopCh)
	go manager.Run(context.TODO(), 1)

        Matcher matcher = pattern.matcher(source);

        if (matcher.matches()) {
            String uid = matcher.group(1) == null ? null : matcher.group(1).substring("uid=".length());
            String javaHome = matcher.group(2);
            JavaLanguageVersion javaVersion = JavaLanguageVersion.of(matcher.group(3));
            String daemonRegistryDir = matcher.group(4);

import spock.lang.Specification

class TestSelectionMatcherTest extends Specification {

    def "knows if test matches class"() {
        expect:
        matcher(input, [], []).matchesTest(className, methodName) == match
        matcher([], [], input).matchesTest(className, methodName) == match

        where:
        input                    | className                 | methodName            | match

        String searchContext = getSearchContext(targetProject, includeSubprojects);

        if (context.getOriginalPath().getPath().equals(taskName)) {
            throw getProblemsService().getInternalReporter().throwing(spec -> {
                configureProblem(spec, matcher, context);
                String message = matcher.formatErrorMessage("Task", searchContext);

            Pattern.MULTILINE + Pattern.DOTALL);

        Matcher matcher = pattern.matcher(daemonLog.text);
        assert matcher.matches(): "Unable to find daemon address in the daemon log. Daemon: $context"

        try {
            return Integer.parseInt(matcher.group(1))
        } catch (NumberFormatException e) {

                        }
                    } as Collection<Matcher<Iterable<? super File>>>
                } as Collection<Matcher<Iterable<? super File>>>

            def resourceDirs =
                sourceRoots.sourceSets.collect { sourceSet ->
                    hasLanguageDir(sourceRoots.projectDir, sourceSet, "resources")
                } as Collection<Matcher<Iterable<? super File>>>

            languageDirs + resourceDirs