package org.gradle.api.internal.provider.sources;

import java.io.File;

import static org.gradle.util.internal.GFileUtils.readFile;

public abstract class FileTextValueSource extends FileContentValueSource<String> {

    @Override
    protected String obtainFrom(File file) {
        return readFile(file);
    }

func TestComparatorMismatchedConfigs(t *testing.T) {
	cfg, err := os.ReadFile("testdata/configdump.json")
	if err != nil {
		t.Fatalf("Failed to read test data: %v", err)
	}
	diffCfg, err := os.ReadFile("testdata/configdump_diff.json")
	if err != nil {
		t.Fatalf("Failed to read test data: %v", err)
	}

	var outputBuffer bytes.Buffer

        try {
            List<String> mergeCommitFileLines = showFileOnCommit(mergeCommit, filePath).readLines()
            List<String> masterCommitFileLines = showFileOnCommit(masterCommit, filePath).readLines()
            List<String> releaseCommitFileLines = showFileOnCommit(releaseCommit, filePath).readLines()
            for (String line in mergeCommitFileLines) {
                if (line.trim().isEmpty()) {

	const buildID = "TestNoteReading-Build-ID"
	tg.run("build", "-ldflags", "-buildid="+buildID, "-o", tg.path("hello.exe"), tg.path("hello.go"))
	id, err := buildid.ReadFile(tg.path("hello.exe"))
	if err != nil {
		t.Fatalf("reading build ID from hello binary: %v", err)
	}
	if id != buildID {
		t.Fatalf("buildID in hello binary = %q, want %q", id, buildID)
	}

	switch {

        def reversedFile = workerExecutorSample(dsl).file("build/reversed/${author}.txt")
        assert reversedFile.exists()
        assert reversedFile.readLines() == workerExecutorSample(dsl).file("sources/${author}.txt").readLines().collect { it.reverse() }
    }

		if err != nil {
			panic(err)
		}
		spec, err := os.ReadFile(f.Path)
		if err != nil {
			panic(err)
		}
		f.bytes = spec
	})
	return f.bytes
}

func (f *OpenAPIV3Getter) SchemaOrDie() *spec3.OpenAPI {
	f.once.Do(func() {
		_, err := os.Stat(f.Path)
		if err != nil {
			panic(err)
		}
		spec, err := os.ReadFile(f.Path)
		if err != nil {
			panic(err)
		}

        renderer.completeConfiguration(conf1);
        renderer.startConfiguration(conf2);
        renderer.completeConfiguration(conf2);

        then:
        textOutput.value.readLines() == [
                'config1 - description',
                '',
                'config2 (n)'
        ]
    }

    def "renders dependency graph"() {

import static org.gradle.internal.UncheckedException.uncheckedCall;

public abstract class AbstractFileAccess implements FileAccess {
    @Override
    public <T> T readFile(final Callable<? extends T> action) throws LockTimeoutException, FileIntegrityViolationException {
        return readFile((Supplier<? extends T>) () -> uncheckedCall(action));
    }

    }

    def "returns null when file does not exist"() {
        when:
        def result = cache.get()

        then:
        result == null
        1 * fileAccess.readFile(!null) >> { it[0].get() }
    }

    def "get returns last value written to file"() {
        when:
        cache.set('some value')

        then:
        1 * fileAccess.writeFile(!null) >> { it[0].run() }

import org.gradle.internal.serialize.graph.Codec
import org.gradle.internal.serialize.graph.ReadContext
import org.gradle.internal.serialize.graph.WriteContext
import org.gradle.internal.serialize.graph.readFile
import org.gradle.internal.serialize.graph.writeFile


class ConfigurableFileTreeCodec(
    private val fileCollectionFactory: FileCollectionFactory
) : Codec<ConfigurableFileTree> {