if (cacheableWork.shouldInvalidateOutputsBeforeLoad()) {
            ImmutableList.Builder<String> roots = ImmutableList.builder();
            cacheableWork.visitOutputTrees((name, type, root) -> roots.add(root.getAbsolutePath()));
            fileSystemAccess.invalidate(roots.build());
        }
        return buildCache.load(cacheKey, cacheableWork);
    }

                roots == []
            }
            with(inputFileProperties.inputArtifact) {
                hash != null
                attributes == ['DIRECTORY_SENSITIVITY_DEFAULT', 'FINGERPRINTING_STRATEGY_ABSOLUTE_PATH', 'LINE_ENDING_SENSITIVITY_DEFAULT']
                with(Iterables.getOnlyElement(roots)) {
                    hash != null

        protected static class Property {

            private final String hash;
            private final Set<String> attributes;
            private final List<Entry> roots = new ArrayList<>();

            public Property(String hash, Set<String> attributes) {
                this.hash = hash;
                this.attributes = attributes;
            }

        when:
        def directories = supplier.get()

        then:
        directories.isEmpty()
    }

    def "has default roots"() {
        given:
        def supplier = new LinuxInstallationSupplier()

        expect:
        supplier.roots.length > 1
    }

    def "supplies no installations for non-existing directory"() {
        given:

			}
			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
}

        }
    }

    @Override
    List<BuildOperationRecord> getRoots() {
        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,

	// default root set of the current operating system.
	roots := x509.NewCertPool()
	ok := roots.AppendCertsFromPEM([]byte(rootPEM))
	if !ok {
		panic("failed to parse root certificate")
	}

	conn, err := tls.Dial("tcp", "mail.google.com:443", &tls.Config{
		RootCAs: roots,
	})
	if err != nil {
		panic("failed to connect: " + err.Error())
	}
	conn.Close()
}

		// 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
		// to google.com until it works, suggesting the pool has been properly

PKJQCs0CM0zkesktuLi/gFpuB0nEwyOgLg==
-----END CERTIFICATE-----`
)

func TestX509(t *testing.T) {
	multilevelOpts := DefaultVerifyOptions()
	multilevelOpts.Roots = x509.NewCertPool()
	multilevelOpts.Roots.AddCert(getCertsFromFile(t, "root")[0])

	testCases := map[string]struct {
		Insecure bool
		Certs    []*x509.Certificate

		Opts x509.VerifyOptions
		User UserConversion