tasks.register("upper") {
    doLast {
        val someString = "mY_nAmE"
        println("Original: $someString")
        println("Upper case: ${someString.toUpperCase()}")
    }

tasks.register('upper') {
    doLast {
        String someString = 'mY_nAmE'
        println "Original: $someString"
        println "Upper case: ${someString.toUpperCase()}"
    }

        file("src/main/java/com/example/Example.java") << """
package com.example;

import org.apache.commons.lang3.StringUtils;

public class Example {
    public boolean testIsEmpty(String someString) {
        return StringUtils.isEmpty(someString);
    }
}
"""

        when:
        runner("jar")
            .forwardOutput()
            .build()

        then: "version numbers exist in the manifest"

        OptionValueNotationParserFactory factory = new OptionValueNotationParserFactory()
        when:
        def parser = factory.toComposite(String.class);
        then:
        parser.parseNotation("somestring") == "somestring"
    }

    def "creates notationparser for handling handles enums"(){
        given:
        OptionValueNotationParserFactory factory = new OptionValueNotationParserFactory()
        when:

        buildFile << """
            task test(type: TaskWithNestedObjectProperty) {
                input = "someString"
                bean = new NestedProperty(
                    inputDir: file('input'),
                    input: 'someString',
                    outputDir: file("\$buildDir/output"),
                    nestedBean: new AnotherNestedProperty(inputFile: file('inputFile'))

func TestString(t *testing.T) {
	want := "abc\u1234"
	o := dummys.Get("someString")
	if got := o.String(); got != want {
		t.Errorf("got %#v, want %#v", got, want)
	}
	dummys.Set("otherString", want)
	if got := dummys.Get("otherString").String(); got != want {
		t.Errorf("got %#v, want %#v", got, want)
	}
	if !dummys.Get("someString").Equal(dummys.Get("someString")) {
		t.Errorf("same value not equal")
	}

        verifyRoundtripOf({
            SerializableBeanContainingExternalizable().apply {
                someString = "foo"
                childBean = ExternalizableBean(42)
                someInt = 13
            }
        }) {
            assertThat(it.someString, equalTo("foo"))
            assertThat(
                it.childBean?.value,
                equalTo(42)
            )

		}
	})
}

func BenchmarkBuildString_WriteString(b *testing.B) {
	someString := string(someBytes)
	benchmarkBuilder(b, func(b *testing.B, numWrite int, grow bool) {
		for i := 0; i < b.N; i++ {
			var buf Builder
			if grow {
				buf.Grow(len(someString) * numWrite)
			}
			for i := 0; i < numWrite; i++ {
				buf.WriteString(someString)
			}
			sinkS = buf.String()
		}
	})
}

    }

    static class ImplementationWithNoPublicConstructor extends BaseLanguageSourceSet implements CustomLanguageSourceSet {
        public ImplementationWithNoPublicConstructor(String someString) {}
    }

    class NotImplementingCustomLanguageSourceSet extends BaseLanguageSourceSet {}

    class NotExtendingBaseLanguageSourceSet extends AbstractBuildableComponentSpec implements CustomLanguageSourceSet {

//  <offset to pkg 0>
//  <offset to pkg 1>
//  ...
//  --package lengths table------
//  <length of pkg 0>
//  <length of pkg 1>
//  ...
//  --string table------
//  <uleb128 len> 8
//  <data> "somestring"
//  ...
//  --package payloads------
//  <meta-symbol for pkg 0>
//  <meta-symbol for pkg 1>
//  ...
//
// Each package payload is a stand-alone blob emitted by the compiler,