// configmap exists in each namespace.
func NewPublisher(cmInformer coreinformers.ConfigMapInformer, nsInformer coreinformers.NamespaceInformer, cl clientset.Interface, rootCA []byte) (*Publisher, error) {
	e := &Publisher{
		client: cl,
		rootCA: rootCA,
		queue: workqueue.NewTypedRateLimitingQueueWithConfig(
			workqueue.DefaultTypedControllerRateLimiter[string](),
			workqueue.TypedRateLimitingQueueConfig[string]{

			}
			continue
		}

		roots = append(roots, r.Mod)
		if !r.Indirect {
			direct[r.Mod.Path] = true
		}
	}
	goVersion := gover.FromGoMod(modFile)
	var toolchain string
	if addToolchainRoot && modFile.Toolchain != nil {
		toolchain = modFile.Toolchain.Name
	}
	roots = appendGoAndToolchainRoots(roots, goVersion, toolchain, direct)
	return roots, direct
}

        getTree().roots
    }

    List<BuildOperationRecord> getDanglingChildren() {
        new BuildOperationTreeFixture(BuildOperationTrace.readPartialTree(path)).roots.findAll { it.parentId != null }
    }

    @Override
    @SuppressWarnings("GrUnnecessaryPublicModifier")

import kotlin.io.path.extension

/**
 * Collect source file path as [String] from the given source roots in [compilerConfig].
 *
 * Such source roots are either [KotlinSourceRoot] or [JavaSourceRoot], and thus
 * this util collects all `.kt` and `.java` files under source roots.
 */
internal fun getSourceFilePaths(
    compilerConfig: CompilerConfiguration,
    includeDirectoryRoot: Boolean = false,

        windowsRegistry.getStringValue(WindowsRegistry.Key.HKEY_LOCAL_MACHINE, /SOFTWARE\Microsoft\Windows Kits\Installed Roots/, "KitsRoot") >> dir2.absolutePath
        windowsRegistry.getStringValue(WindowsRegistry.Key.HKEY_LOCAL_MACHINE, /SOFTWARE\Microsoft\Windows Kits\Installed Roots/, "KitsRoot81") >> dir3.absolutePath

        when:
        def result = windowsSdkLocator.locateComponent(null)

        then:

import org.gradle.test.fixtures.file.TestFile

class BuildActionCrossVersionSpec extends ToolingApiSpecification {
    @TargetGradleVersion(">=3.2")
    def "can use multiple action implementations with different classpath roots and loaded from same ClassLoader"() {
        settingsFile.text = 'rootProject.name = "not broken"'

        // Ensure daemon is reused
        toolingApi.requireIsolatedDaemons()

        }) == SnapshotVisitResult.CONTINUE;
    }

    private static Map<String, FileSystemLocationFingerprint> collectFingerprints(FileSystemSnapshot roots) {
        Map<String, FileSystemLocationFingerprint> result = new LinkedHashMap<>();
        roots.accept(new RelativePathTracker(),
            (snapshot, relativePath) -> {
                result.put(snapshot.getAbsolutePath(), createFingerprint(relativePath, snapshot));

        'nested'            | { MyCycleTask root -> CycleFirstNode.newInitializedRootCycle(root) }                                                            | "'<root>' and 'nested.secondNested.thirdNested.rootNested'"
        'nestedProperty'    | { MyCycleTask root -> TestUtil.propertyFactory().property(CycleFirstNode).value(CycleFirstNode.newInitializedRootCycle(root)) } | "'<root>' and 'nestedProperty.secondNested.thirdNested.rootNested'"

		t.Skip()
	}
	if runtime.GOOS == "windows" {
		// NOTE(#51599): on the Windows builders we sometimes see that the state
		// of the root pool is not fully initialized, causing an expected
		// platform verification to fail. In part this is because Windows
		// dynamically populates roots into its local trust store at time of
		// use. We can attempt to prime the pool by attempting TLS connections

 */
public interface ExecutionOutputState {

    /**
     * Whether the execution was successful.
     */
    boolean isSuccessful();

    /**
     * Snapshots of the roots of output properties.
     *
     * In the presence of overlapping outputs this might be different from
     * {@link BeforeExecutionState#getOutputFileLocationSnapshots()},