val scriptsFiles = projectLayout.projectDirectory.dir("scripts").asFile.listFiles()

        bundleFile.outputStream().use { stream ->
            scriptsFiles.sorted().forEach {
                stream.write(it.readBytes())
            }
        }
    }
}

// tag::bundle-task[]
tasks.register<NpmTask>("bundle") {
    args = listOf("run", "bundle")

    outputs.cacheIf { true }

    inputs.dir(file("scripts"))

func handleConnection(conn net.Conn, prefix string) {
	defer conn.Close()
	reader := bufio.NewReader(conn)
	for {
		// read client request data
		bytes, err := reader.ReadBytes(byte('\n'))
		if err != nil {
			if err != io.EOF {
				fmt.Println("failed to read data, err:", err)
			}
			return
		}
		fmt.Printf("request: %s", bytes)

		// prepend prefix and send as response

        val scriptsFiles = projectLayout.projectDirectory.dir("scripts").asFile.listFiles()

        bundleFile.outputStream().use { stream ->
            scriptsFiles.sorted().forEach {
                stream.write(it.readBytes())
            }
        }
    }
}

// tag::bundle-task[]
@CacheableTask                                       // <1>
abstract class BundleTask : NpmTask() {

	for i, v := range vectors {
		val := br.ReadBits(v.nbits)
		if fail := bool(br.err != nil); fail != v.fail {
			if fail {
				t.Errorf("test %d, unexpected failure: ReadBits(%d) = %v", i, v.nbits, br.err)
			} else {
				t.Errorf("test %d, unexpected success: ReadBits(%d) = nil", i, v.nbits)
			}
		}
		if !v.fail && val != v.value {
			t.Errorf("test %d, mismatching value: ReadBits(%d) = %d, want %d", i, v.nbits, val, v.value)
		}

	userOnly := userCommas[1 : len(userCommas)-1] // john

	// Add primary Gid first.
	groups := []string{u.Gid}

	rd := bufio.NewReader(r)
	done := false
	for !done {
		line, err := rd.ReadBytes('\n')
		if err != nil {
			if err == io.EOF {
				done = true
			} else {
				return groups, err
			}
		}

		// Look for username in the list of users. If user is found,

		// test the TCP Echo Server output
		if _, err := conn.Write([]byte(request + "\n")); err != nil {
			t.Fatalf("couldn't send request: %v", err)
		} else {
			reader := bufio.NewReader(conn)
			if response, err := reader.ReadBytes(byte('\n')); err != nil {
				t.Fatalf("couldn't read server response: %v", err)
			} else if !strings.HasPrefix(string(response), want) {
				t.Errorf("output doesn't match, wanted: %s, got: %s", want, response)
			}
		}

        val utils = withClassJar("utils.jar", JavaClassUtil::class.java)
        mavenRepo.module("test", "utils", "1.0")
            .mainArtifact(mapOf("content" to utils.readBytes()))
            .publish()

        withDefaultSettingsIn("plugin")
        withBuildScriptIn("plugin", """
            plugins {
                `kotlin-dsl`
                `maven-publish`
            }

            }
        }
        try {
            return new String(FileUtil.readBytes(outputFile), outputEncoding);
        } catch (final UnsupportedEncodingException e) {
            return new String(FileUtil.readBytes(outputFile), Constants.UTF_8_CHARSET);
        }
    }

    private Extractor getExtractor(final String ext) {

// the read was successful.
func (s *String) ReadUint24LengthPrefixed(out *String) bool {
	return s.readLengthPrefixed(3, out)
}

// ReadBytes reads n bytes into out and advances over them. It reports
// whether the read was successful.
func (s *String) ReadBytes(out *[]byte, n int) bool {
	v := s.read(n)
	if v == nil {
		return false
	}
	*out = v
	return true
}

fun fileEntriesRelativeTo(baseDir: File, files: Sequence<File>): Sequence<Pair<String, ByteArray>> =
    files.filter { it.isFile }.map { file ->
        val path = file.normalisedPathRelativeTo(baseDir)
        val bytes = file.readBytes()
        path to bytes
    }


internal
fun File.normalisedPathRelativeTo(baseDir: File) =
    normaliseFileSeparators(relativeTo(baseDir).path)