}

	realGoroot := testenv.GOROOT(t)

	// To ensure that bootstrapping doesn't unexpectedly depend
	// on the Go repo's git metadata, add a fake (unreadable) git
	// directory above the simulated GOROOT.
	// This mimics the configuration one much have when
	// building from distro-packaged source code
	// (see https://go.dev/issue/54852).
	parent := t.TempDir()

 *
 * <p>There can be different reasons for declaring a task as untracked, for example:
 * <ul>
 *     <li>Some input or output locations contain unreadable files like pipes where Gradle cannot track the content.</li>
 *     <li>The input or output is stored remotely, for example in a database, and its state cannot be tracked.</li>

    }

    @Requires(UnitTestPreconditions.FilePermissions)
    def "snapshotting unreadable #type fails"() {
        given:
        def rootDir = tmpDir.createDir("root")
        rootDir.file('readableFile').createFile()
        rootDir.file('readableDirectory').createDir()

        def unreadable = rootDir.file('unreadable')
        unreadable."create${type.capitalize()}"().makeUnreadable()

        when:

  }

  /**
   * Returns all resources loadable from the current class path, including the class files of all
   * loadable classes but excluding the "META-INF/MANIFEST.MF" file.
   */
  public ImmutableSet<ResourceInfo> getResources() {
    return resources;
  }

  /**
   * Returns all classes loadable from the current class path.
   *
   * @since 16.0
   */

    @Issue('https://github.com/gradle/gradle/issues/9576')
    def "unreadable #type not produced by task fails"() {
        given:
        def input = file("readableFile.txt").createFile()

        def outputDirectory = file("output")
        def unreadableOutput = file("${outputDirectory.name}/unreadable${type.capitalize()}")
        create(unreadableOutput).makeUnreadable()

        buildFile << """

                .withAdvice("Declare the task as untracked by using Task.doNotTrackState().");
        } else if (isDestinationDir && task instanceof Sync) {
            builder.withSummary("Cannot access a file in the destination directory.")
                .withContext("Syncing to a directory which contains unreadable content is not supported.")

import org.gradle.internal.classpath.ClassPath;
import org.gradle.internal.service.scopes.Scope;
import org.gradle.internal.service.scopes.ServiceScope;

import javax.annotation.Nullable;

/**
 * A registry of dynamically loadable modules.
 */
@ServiceScope(Scope.Global.class)
public interface ModuleRegistry {
    /**

                    if (relativePath.isRoot()) {
                        return false;
                    }
                    // Otherwise check for newly added broken symlinks and unreadable files
                    return hasNewContent(relativePath, missingSnapshot);
                }
            });
            if (newContent) {
                overlappingPath = snapshot.getAbsolutePath();

// license that can be found in the LICENSE file.

package main

import (
	"runtime"
	"testing"
	"unsafe"
)

// global pointer slot
var a *[8]uint

// unfoldable true
var always = true

// Test to make sure that a pointer value which is alive
// across a call is retained, even when there are matching
// conversions to/from uintptr around the call.

            failure.assertHasDescription("Execution failed for task ':copy'.")
            failure.assertHasDocumentedCause("Cannot access input property 'rootSpec\$1' of task ':copy'. " +
                "Accessing unreadable inputs or outputs is not supported. " +
                "Declare the task as untracked by using Task.doNotTrackState(). " +