}

func TestFileReader(t *testing.T) {
	type (
		testRead struct { // Read(cnt) == (wantStr, wantErr)
			cnt     int
			wantStr string
			wantErr error
		}
		testWriteTo struct { // WriteTo(testFile{ops}) == (wantCnt, wantErr)
			ops     fileOps
			wantCnt int64
			wantErr error
		}
		testRemaining struct { // logicalRemaining() == wantLCnt, physicalRemaining() == wantPCnt
			wantLCnt int64

		}

		out := buf.String()
		if out != src {
			t.Errorf("\ngot : %q\nwant: %q\n", out, src)
		}
	}
}

func TestBaseIndent(t *testing.T) {
	t.Parallel()
	// The testfile must not contain multi-line raw strings since those
	// are not indented (because their values must not change) and make
	// this test fail.
	const filename = "printer.go"
	src, err := os.ReadFile(filename)

		}
	}
	return
}

type builtFile struct {
	*objfilepkg.File
	path string
}

func gobuild(t *testing.T, dir string, testfile string, gcflags string) *builtFile {
	src := filepath.Join(dir, "test.go")
	dst := filepath.Join(dir, "out.exe")

	if err := os.WriteFile(src, []byte(testfile), 0666); err != nil {
		t.Fatal(err)
	}

	cmd := testenv.Command(t, testenv.GoToolPath(t), "build", gcflags, "-o", dst, src)

    }

    def "can cache artifact"() {
        def destFile = tempDir.file("cached.zip")
        def content = "Data".bytes
        server.expectPut("/cache/${key.hashCode}", destFile, HttpStatus.SC_OK, null, content.length)

        when:
        cache.store(key, writer(content))
        then:
        destFile.bytes == content
    }

                <mkdir dir="${basedir}/target/test-classes/${test.projects.repository}/${test.projects.target.directory}/" />

                <jar destfile="${basedir}/target/test-classes/${test.projects.repository}/${test.projects.target.directory}/${test.projects.archetype}.jar" basedir="${basedir}/src/test/archetypes/${test.projects.source.directory}/" />
              </tasks>

        expect(path, false, ['PUT'], fileWriter(destFile), new DefaultPasswordCredentials(username, password))
    }

    private Action fileWriter(File destFile) {
        new ActionSupport("write request to $destFile.name") {
            void handle(HttpServletRequest request, HttpServletResponse response) {
                destFile.parentFile.mkdirs()

            templateArgs.original = originalContents
            templateArgs.beforePlugins = beforePlugins
            templateArgs.afterPlugins = afterPlugins
        }

        destFile.parentFile.mkdirs()
        destFile.withWriter { Writer writer ->
            if (templateName.endsWith('.gradle')) {
                writer << "// Generated for subproject ${templateArgs.projectName}\n"
            }

                ZipEntry entry = entries.nextElement();

                File destFile = new File(dest, safePathName(entry.getName()));
                if (entry.isDirectory()) {
                    destFile.mkdirs();
                    continue;
                }

                OutputStream outputStream = new BufferedOutputStream(new FileOutputStream(destFile));
                try {

        val projectBuildDirPath = projectBuildDir.asFile.get().toPath()

        reports.filter { it.isDirectory }.forEach {
            val destFile = rootBuildDir.resolve("report$projectPathName-${it.name}.zip")
            zip(destFile, it)
        }

        // Zip all files in project build directory into a single zip file to avoid publishing too many tiny files

                    buildFile << "plugins { id('test.my-plugin') }"
                    gradleProperties << "org.gradle.jvmargs=\\"-javaagent:\$jacocoAgentJar=destfile=\$jacocoDestFile\\""

                    when:
                    def result = GradleRunner.create()
                        .withProjectDir(testProjectDir)