"module": "m",
                    "version": { "prefers": "v" },
                    "excludes": [
                        { "group": "g", "otherString": "string", "otherNumber": 123, "otherObject": { "a": 1 } }
                    ],
                    "otherString": "string",
                    "otherNumber": 123,
                    "otherBoolean": true,
                    "otherNull": null,

}

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")
	}

                @Input
                secondInput
            }

            task test(type: TaskWithNestedBean) {
                beans = [new NestedBean(input: 'someString'), new OtherNestedBean(secondInput: 'otherString')]
            }
            task printMetadata(type: PrintInputsAndOutputs) {
                task = test
            }
        """

        expect:
        succeeds 'test', 'printMetadata'

            configuration("some:thing:1.0")
            (constraints) {
                configuration("other:thing:1.0")
            }
        }

        verify(dependencyHandler).add("c", "some:thing:1.0")
        inOrder(constraintHandler) {
            verify(constraintHandler).add(eq("c"), eq("other:thing:1.0"))
            verifyNoMoreInteractions()
        }
    }

    @Test

            sourceSets.main.java.srcDir("src/common/java")
        """
        file("src/common/java/OtherThing.java") << """
            class OtherThing {
            }
        """
        file("src/main/java/Thing.java") << """
            class Thing extends OtherThing {
            }
        """

        when:
        configurationCacheRun "assemble"

        then:

        'SomeEnum'   | 'SomeEnum.free'                | 'SomeEnum.paid'
        'Thing'      | 'objects.named(Thing, "free")' | 'objects.named(Thing, "paid")'
        'OtherThing' | 'new OtherThing(name: "free")' | 'new OtherThing(name: "paid")'
    }

    def "compatibility and disambiguation rules can be defined by consuming build"() {
        given:
        createDirs("a", "b", "includedBuild")

        public String doSomething() {
            Number thing = getThing();
            List<String> otherThing = getOtherThing();
            return Joiner.on(" ").join(otherThing) + " " + thing;
        }
    }

    public static abstract class AbstractClassWithTypeParamProperty implements InterfacePropertyWithTypeParamBean<Param<String>> {
    }