switch (stringList.size()) {
                case 0:
                    return "";
                case 1:
                    return stringList.get(0);
                case 2:
                    return join(" " + conjunction + " ", stringList);
                default:
                    int bound = stringList.size() - 1;

	"runtime"
	"strings"
	"testing"
)

var foldDupTests = []struct {
	list   []string
	f1, f2 string
}{
	{StringList("math/rand", "math/big"), "", ""},
	{StringList("math", "strings"), "", ""},
	{StringList("strings"), "", ""},
	{StringList("strings", "strings"), "strings", "strings"},
	{StringList("Rand", "rand", "math", "math/rand", "math/Rand"), "Rand", "rand"},
}

func TestFoldDup(t *testing.T) {

	"unicode"
	"unicode/utf8"
)

// StringList flattens its arguments into a single []string.
// Each argument in args must have type string or []string.
func StringList(args ...any) []string {
	var x []string
	for _, arg := range args {
		switch arg := arg.(type) {
		case []string:
			x = append(x, arg...)
		case string:
			x = append(x, arg)
		default:
			panic("stringList: invalid argument of type " + fmt.Sprintf("%T", arg))

/**
 * Gradle options as configured in IntelliJ.
 */
internal
val Environment.gradleOptions: List<String>
    get() = stringList("gradleOptions")


/**
 * Gradle JVM options as configured in IntelliJ.
 */
internal
val Environment.gradleJvmOptions: List<String>
    get() = stringList("gradleJvmOptions")


/**
 * Gradle environment variables as configured in IntelliJ.
 */
internal

        storage.add new TypeOf<List<String>>() {}, 'stringList', ['string']

        expect:
        storage.findByType(typeOf(Number)) == 42
        storage.findByType(new TypeOf<List<String>>() {}) == ['string']
    }

    def "get schema"() {
        given:
        storage.add new TypeOf<List<String>>() {}, 'stringList', ['string']

            environment.stringList(EnvironmentProperties.kotlinDslImplicitImports)

        private
        fun precompiledScriptPluginImportsFrom(environment: Environment?, scriptText: CharSequence): List<String> =
            environment.stringList(hashOfNormalisedString(scriptText))

        private
        fun Environment?.stringList(key: String) =
            string(key)?.split(':')

        final List<String> stringList = Arrays.asList(
                "Thinkin", "of", "a", "master", "plan", "Cuz", "ain’t", "nuthin", "but", "sweat", "inside", "my",
                "hand");
        Iterator<String> lyrics = stringList.iterator();

        ExecutorService executor = Executors.newFixedThreadPool(10);

        return Collectors.collectingAndThen(Collectors.toList(), stringList -> {
            if (stringList.isEmpty()) {
                return "";
            }
            if (stringList.size() == 1) {
                return stringList.get(0);
            }
            int bound = stringList.size() - 1;
            return String.join(", ", stringList.subList(0, bound)) + " or " + stringList.get(bound);
        });
    }

	Map:        map[string]int{"TestSubkey": 1},
	StringList: []string{"a", "b", "c"},
	IntList:    []int{1, 2, 3},
}

type TestStruct struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`
	Key               string         `json:"Key"`
	Map               map[string]int `json:"Map"`
	StringList        []string       `json:"StringList"`
	IntList           []int          `json:"IntList"`
}

    }

    /** Calculate an incremental Id for a given string. */
    private Integer getIdByLine(String line) {
        int newId = stringList.size();
        Integer existingId = stringToId.put(line, newId);
        if (existingId == null) {
            stringList.add(line);
            return newId;
        } else {
            stringToId.put(line, existingId);
            return existingId;
        }
    }