/**
     * Asserts that there is exactly one file present with the given path, and that this file has the given content.
     */
    def assertFileContent(String relativePath, String fileContent) {
        assertFileContent(relativePath, equalTo(fileContent))
    }

    def assertFileContent(String relativePath, Matcher contentMatcher) {
        assertThat(content(relativePath), contentMatcher)
        this
    }

    /**

		},
	} {
		cwd, err := os.Getwd()
		require.NoError(t, err)

		t.Run(name, func(t *testing.T) {
			tmp := t.TempDir()
			for fileName, fileContent := range tt.files {
				err := os.WriteFile(path.Join(tmp, fileName), []byte(fileContent), 0666)
				require.NoError(t, err, "create input file")
			}
			defer os.Chdir(cwd)
			require.NoError(t, os.Chdir(tmp), "change into tmp directory")

func getVersion(readFile readFileFunc) (*version.Version, error) {
	kernelVersionFile := "/proc/sys/kernel/osrelease"
	fileContent, err := readFile(kernelVersionFile)
	if err != nil {
		return nil, fmt.Errorf("failed to read os-release file: %s", err.Error())
	}

	kernelVersion, err := version.ParseGeneric(strings.TrimSpace(string(fileContent)))
	if err != nil {
		return nil, fmt.Errorf("failed to parse kernel version: %s", err.Error())
	}

exec ./mkold$GOEXE 1m testcache/file.txt
go test testcache -run=FileContent
go test testcache -run=FileContent
stdout '\(cached\)'
cp 2y.txt testcache/file.txt
exec ./mkold$GOEXE 50s testcache/file.txt
go test testcache -run=FileContent
! stdout '\(cached\)'
go test testcache -run=FileContent
stdout '\(cached\)'

# Directory contents read via os.ReadDirNames should affect caching.

        this.fileSystemAccess = fileSystemAccess;
        this.inMemoryCacheDecoratorFactory = inMemoryCacheDecoratorFactory;
        this.cache = cacheBuilderFactory
            .createCacheBuilder("fileContent")
            .withDisplayName("file content cache")
            .withInitialLockMode(FileLockManager.LockMode.OnDemand)
            .open();
    }

    @Override
    public void close() throws IOException {

 */

package org.gradle.api.file;

import org.gradle.api.provider.Provider;

/**
 * Provides lazy access to the contents of a given file.
 *
 * @since 6.1
 */
public interface FileContents {

    /**
     * Gets a provider of the entire file contents as a single String.
     *
     * <p>
     * The file is read only once and only when the value is requested for the first time.
     * </p>

        } else {
            for (ExecutionOutput output : getOutputFiles()) {
                String gradleStdout = fileContents(output.stdout);
                String gradleStderr = fileContents(output.stderr);

                System.out.println(gradleStdout);
                System.out.println(gradleStderr);

        );
    }

    @Override
    public FileContents fileContents(RegularFile file) {
        return fileContents(property -> property.set(file));
    }

    @Override
    public FileContents fileContents(Provider<RegularFile> file) {
        return fileContents(property -> property.set(file));
    }

    private FileContents fileContents(Action<RegularFileProperty> setFileProperty) {

	// cfgFiles is in cluster_test.go
	var tests = []struct {
		name         string
		fileContents []byte
		expectErr    bool
		validate     func(*testing.T, *kubeadm.InitConfiguration)
	}{
		{
			name:         "v1beta3.partial1",
			fileContents: cfgFiles["InitConfiguration_v1beta3"],
		},
		{
			name: "v1beta3.partial2",
			fileContents: bytes.Join([][]byte{
				cfgFiles["InitConfiguration_v1beta3"],
				clusterCfg,

    @Rule
    final GcsServer server = new GcsServer(temporaryFolder)

    def "should perform put, get and list on an Gcs bucket"() {
        setup:
        def fileContents = 'This is only a test'
        File file = temporaryFolder.createFile(FILE_NAME)
        file << fileContents

        Storage.Builder builder = new Storage.Builder(new NetHttpTransport(), new GsonFactory(), null)
        builder.setRootUrl(server.uri.toString())