<section>
        <title>Properties</title>
        <section>
            <title>Properties added by the <literal>thingo</literal> plugin</title>
            <titleabbrev><literal>thingo</literal> plugin</titleabbrev>
            <table>
                <title>Properties - <literal>thingo</literal> plugin</title>
                <thead>
                    <tr>
                        <td>Property</td>

            thing.extensions.create('thing2', Thing)
            thing.thing.extensions.create('thing2', Thing)
            thing.thing.thing2.extensions.create('thing2', Thing)
            thing.thing2.extensions.create('thing2', Thing)

            thing {
                thing {
                    thing2 {
                        name = 'thing'
                    }
                }

                abstract void setThing(Thing t)

                @Defaults
                void defaultB(@Path('thingB') Thing thingB) {
                    assert thing.name == 'thing a from dsl'
                    thingB.name = thing.name
                }

                @Finalize
                void defaultC(@Path('thingC') Thing thingC) {

        outputContains("processing thing1-1.2.jar using []")
        outputContains("processing thing2-1.2.jar using []")
        outputContains("processing thing3-1.2.jar using [thing1-1.2.jar, thing2-1.2.jar]")
        outputContains("files = [thing3-1.2.jar.green, thing1-1.2.jar.green, thing2-1.2.jar.green]")

                }
                foo.bla {
                    println $.unknown.thing
                    println $.unknown.thing2
                }
                thing1(Thing) {
                    println $.unknown.thing
                }
            }
        '''

        when:
        fails "tasks"

        then:
        // TODO - should report unknown inputs as well

        WeakIdentityHashMap.WeakKey<Thing> weakKey1 = new WeakIdentityHashMap.WeakKey<>(thing1)
        WeakIdentityHashMap.WeakKey<Thing> weakKey2 = new WeakIdentityHashMap.WeakKey<>(thing2)

        expect:
        weakKey1 != weakKey2
    }

    def "hashCodes of weakKeys for equal objects are different"() {
        Thing thing1 = new Thing("thing")
        Thing thing2 = new Thing("thing")

                    name = $.thing1.name + " bar"
                }
                tasks {
                    create("echo") {
                        doLast {
                            println "thing2.name: " + $.thing2.name
                        }
                    }
                }
            }
        '''

        then:
        succeeds "echo"
        output.contains "thing2.name: foo bar"

                }

                void apply(Project project) {
                    project.tasks.create('thing1', CustomTask) {
                        thing = objects.named(Thing, 'thing1')
                    }
                    project.tasks.create('thing2', CustomTask) {
                        thing = project.objects.named(Thing, 'thing2')
                    }
                }
            }

// license that can be found in the LICENSE file.

package p

type thing1 struct {
	things []string
}

type thing2 struct {
	things []thing1
}

func _() {
	var a1, b1 thing1
	_ = a1 /* ERROR "struct containing []string cannot be compared" */ == b1

	var a2, b2 thing2
	_ = a2 /* ERROR "struct containing []thing1 cannot be compared" */ == b2

class Thing {
    def builder = new groovy.ant.AntBuilder()