}

    def "Source folder has exclude and include patterns defined"() {
        setup:
        def excludePatterns = excludes.collect { "exclude '$it'" }.join('\n')
        def includePatterns = includes.collect { "include '$it'" }.join('\n')
        settingsFile << 'rootProject.name = "root"'
        buildFile <<
        """apply plugin: 'java'
           sourceSets {
               main {

     *
     * <pre>
     * expect:
     * join(",", new Object[]{"a"}) == "a"
     * join(",", new Object[]{"a", "b", "c"}) == "a,b,c"
     * join(",", new Object[]{}) == ""
     * </pre>
     *
     * The {@code separator} must not be null and {@code objects} must not be null.
     *
     * @param separator The string by which to join each string representation

)

rootdir = os.path.dirname(__file__) + "/../../"
rootdir = os.path.abspath(rootdir)
parser.add_argument("--rootdir", default=rootdir, help="root directory to examine")

default_boilerplate_dir = os.path.join(rootdir, "hack/boilerplate")
parser.add_argument("--boilerplate-dir", default=default_boilerplate_dir)

parser.add_argument(
    "-v",
    "--verbose",
    help="give verbose output regarding why a file does not pass",

		t.Fatalf("Unexpected output for 'istioctl %s'\n got: %q\nwant: %q", strings.Join(c.args, " "), output, c.expectedOutput)
	}

	if c.expectedString != "" && !strings.Contains(output, c.expectedString) {
		t.Fatalf("Output didn't match for '%s %s'\n got %v\nwant: %v", cmd.Name(), strings.Join(c.args, " "), output, c.expectedString)
	}

	if c.wantException {
		if fErr == nil {

	enc := jsoniter.ConfigCompatibleWithStandardLibrary.NewEncoder(buf)

	for i := range item {
		err := enc.Encode(item[i])
		if err != nil {
			return err
		}
	}
	b := buf.Bytes()

	path := filepath.Join(store.directory, key+store.fileExt)
	err := os.WriteFile(path, b, os.FileMode(0o770))
	buf.Reset()
	if err != nil {
		return err
	}

	// Increment the item count.
	store.entries[key] = time.Now().UnixNano()

            }
            .join(PROBLEM_SEPARATOR)
            .replaceAll("\n+", "\n")
        def reportText =
            ValidationProblemSerialization.parseMessageList(reportFile.text)
                .collect { it.definition.severity.toString() + ": " + TypeValidationProblemRenderer.renderMinimalInformationAbout(it) }
                .sort()
                .join(PROBLEM_SEPARATOR)
                .replaceAll("\r\n", "\n")

        name
    }

    void extendsFrom(String... superConfs) {
        sections.add(new GenericSection({
            "extendsFrom ${superConfs.join(',')}"
        }, {
            "extendsFrom(${superConfs.collect { "configurations.getByName(\"$it\")" }.join(',')})"
        }))
    }

    @Override
    String generateSection(GradleDsl dsl) {
        switch (dsl) {
            case GradleDsl.GROOVY:

		if len(missing) > 0 {
			t.Errorf("the following fields were expected, but missing from the result:\n%s", strings.Join(sets.List(missing), "\n"))
		}
		if len(unexpected) > 0 {
			t.Errorf("the following fields were in the result, but unexpected:\n%s", strings.Join(sets.List(unexpected), "\n"))
		}
	}
}

var (

		if !strings.HasPrefix(lkey, "x-amz-") {
			continue
		}
		keys = append(keys, lkey)
		keyval[lkey] = strings.Join(headers[key], ",")
	}
	sort.Strings(keys)
	var canonicalHeaders []string
	for _, key := range keys {
		canonicalHeaders = append(canonicalHeaders, key+":"+keyval[key])
	}
	return strings.Join(canonicalHeaders, "\n")
}

// Return canonical resource string.

			var fileNames []string
			if m.BuildID != "" {
				fileNames = []string{filepath.Join(path, m.BuildID, baseName)}
				if matches, err := filepath.Glob(filepath.Join(path, m.BuildID, "*")); err == nil {
					fileNames = append(fileNames, matches...)
				}
				fileNames = append(fileNames, filepath.Join(path, noVolumeFile, m.BuildID)) // perf path format
				// Llvm buildid protocol: the first two characters of the build id