return s
	}
	result := *s
	props := make(map[string]spec.Schema, len(s.Properties))
	for k, prop := range s.Properties {
		props[k] = prop
	}
	stringType := spec.StringProperty()
	props["kind"] = *stringType
	props["apiVersion"] = *stringType
	props["metadata"] = spec.Schema{
		SchemaProps: spec.SchemaProps{
			Type: []string{"object"},

```java
/**
 * <pre><code class="language-kotlin">
 * project.ext.prop1 = "foo"
 * task doStuff {
 *     ext.prop2 = "bar"
 * }
 * subprojects { ext.${prop3} = false }
 * </code></pre>
 */
```

     */
    @Test
    void testCombineId() throws Exception {
        String lhs = "<props>" + "<property combine.id='LHS-ONLY'><name>LHS-ONLY</name><value>LHS</value></property>"
                + "<property combine.id='TOOVERWRITE'><name>TOOVERWRITE</name><value>LHS</value></property>"
                + "</props>";

        String rhs = "<props>" + "<property combine.id='RHS-ONLY'><name>RHS-ONLY</name><value>RHS</value></property>"

        def beanWithDisplayName = create(FinalReadOnlyNonManagedPropertyBean, Describables.of("<display-name>"))

        expect:
        bean.prop.toString() == "property 'prop'"
        beanWithDisplayName.prop.toString() == "<display-name> property 'prop'"
    }

    def "can attach nested extensions to object"() {
        given:
        def bean = create(Bean)

        succeeds('help', '--task', 'sample')

        then:
        outputContains("""
Options
     --prop1     Configures command line option 'prop1'.

     --prop2     Configures command line option 'prop2'.

     --no-prop2     Disables option --prop2.

     --prop3     Configures command line option 'prop3'.""")
    }

    @ToBeFixedForConfigurationCache(skip = INVESTIGATE)

        isolated instanceof JavaSerializedValueSnapshot
        def other = isolated.isolate()
        other.prop == "123"
        !other.is(original)

        def v = isolated.coerce(cl)
        v.prop == "123"
    }

    def "can coerce java serializable value"() {
        def original = new Bean(prop: "123")

        expect:
        def isolated = isolatableFactory.isolate(original)

	p.types = nil

	for _, r := range p.runes {
		props, i := LookupRune(r)
		bytecount += i
		cls := props.Class()
		if cls == B {
			return bytecount, nil
		}
		p.types = append(p.types, cls)
		if props.IsOpeningBracket() {
			p.pairTypes = append(p.pairTypes, bpOpen)
			p.pairValues = append(p.pairValues, r)
		} else if props.IsBracket() {
			// this must be a closing bracket,

	}
	return sb.String()
}

func compareEntries(t *testing.T, tc string, dentry *fnInlHeur, dcsites encodedCallSiteTab, eentry *fnInlHeur, ecsites encodedCallSiteTab) {
	dfp := dentry.props
	efp := eentry.props
	dfn := dentry.fname

	// Compare function flags.
	if dfp.Flags != efp.Flags {
		t.Errorf("testcase %q: Flags mismatch for %q: got %s, wanted %s",
			tc, dfn, dfp.Flags.String(), efp.Flags.String())

        void setProp3(String string);
    }

    def "multiple properties"() {
        when:
        def properties = extract(MultipleProps).properties

        then:
        properties*.name == ["prop1", "prop2", "prop3"]
        properties*.type == [ModelType.of(String)] * 3
    }

    @Managed
    interface SelfReferencing {
        SelfReferencing getSelf()
    }

        def e2 = builder.createContainerElement(null, "foo.bar", "e2", "someElement")
        builder.propertyAssignment("Set some thing", "prop", e1)
        builder.propertyAssignment(null, "prop2", builder.propertyExpression(e2, "outputDir"))

        when:
        builder.create(target).generate()

        then:
        assertOutputFile("""/*