"/etc/pki/tls/certs", // Fedora/RHEL
}

func init() {
	if goos.IsAndroid == 1 {
		certDirectories = append(certDirectories,
			"/system/etc/security/cacerts",    // Android system roots
			"/data/misc/keychain/certs-added", // User trusted CA folder
		)
	}

 * limitations under the License.
 */
package org.gradle.api.internal.file.collections;

/**
 * A file tree whose contents are contained in zero or more local roots (file or directory).
 */
public interface LocalFileTree extends MinimalFileTree {

 *
 *     <dt>watchable hierarchies</dt>
 *     <dd>The list of file system hierarchies Gradle might want to watch if interesting content appears in the VFS for them.
 *     These are currently roots of the builds seen by the daemon during the current or previous invocations.
 *     Interesting content means that we keep track of something that actually exists under the hierarchy (so not exclusively missing files).

    /**
     * The [KtModule]'s properties or references to other modules are being changed.
     *
     * #### Examples
     *
     *  - The name of the module is being changed.
     *  - The module's content roots are being changed, such as adding another source folder to a source module.
     *  - If module A depends on module B and module B is being removed, in addition to the removal event for module B, module A also

    /**
     * The underlying fingerprints indexed by absolute path.
     */
    Map<String, FileSystemLocationFingerprint> getFingerprints();

    /**
     * The Merkle hashes of the roots which make up this file collection fingerprint.
     */
    ImmutableMultimap<String, HashCode> getRootHashes();

    boolean wasCreatedWithStrategy(FingerprintingStrategy strategy);

    variantImplementation[style=dashed, label=<main<i>Variant</i>Implementation<br/>(configuration)>]
  }

  subgraph secondLine {
    includeRoot[style="rounded,filled", fillcolor="#bfffbf", label="Compilation include roots"]
  }

  subgraph thirdLine {
    {rank=same sourceFiles compileVariantCpp outputDirectory}
    includeRoot -> compileVariantCpp
    sourceFiles -> compileVariantCpp
    compileVariantCpp -> outputDirectory

        List<String> result = new ArrayList<>();

        if (isExplodedModularRuntime(jdkHome)) {
            try {
                try (DirectoryStream<Path> roots = Files.newDirectoryStream(jdkHome.resolve("modules"))) {
                    for (Path root : roots) {
                        result.add(getUrlForLibraryRoot(root));
                    }
                }
            }
            catch (IOException ignore) {

        textFile.text = "text file as root"

        expect:
        fails language.compileTaskName
        failure.assertHasCause(
            'Unable to infer source roots. ' +
                'Incremental Groovy compilation requires the source roots. ' +
                'Change the configuration of your sources or disable incremental Groovy compilation.')
    }

        output.contains("Full recompilation is required because the source roots could not be inferred.")
    }

    def "does not recompile when a resource changes"() {
        given:
        buildFile << """
            ${language.compileTaskName}.source 'src/main/resources'
        """

     *
     * {@link Optional#empty()} if no information is available.
     */
    Optional<MetadataSnapshot> getSnapshot();

    boolean hasDescendants();

    /**
     * Returns all the snapshot roots accessible from the node.
     */
    Stream<FileSystemLocationSnapshot> rootSnapshots();

    /*
     * Gets a snapshot from the current node with relative path filePath.substring(offset).
     *