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"

model {
    tasks {
        show(Task) {
            doLast {
                println "value = " + $.things.test.value
            }
        }
    }
    things {
        main(Thing)
        test(Thing) {
            println "configure test"
            value = $.things.main.value
        }
    }
    things {
        main {
            println "configure main"
            value = "12"
        }

    def handler1 = handler(Thing1)
    def handler2 = handler(Thing2)
    def cacheFactory = new TestCrossBuildInMemoryCacheFactory()
    def typeAnnotationMetadataStore = new DefaultTypeAnnotationMetadataStore(
        [],
        [(Thing1): TYPE, (Thing2): TYPE],
        ["java", "groovy"],
        [],
        [Object, GroovyObject],

                    println "display-name: $things.displayName"
                    println "to-string: ${things.toString()}"
                  }
                }
              }
            }
        '''

        then:
        succeeds "print"

        and:
        output.contains "name: things"
        output.contains "display-name: ModelMap<Thing> 'things'"
        output.contains "to-string: ModelMap<Thing> 'things'"

        formatter.toString() == toPlatformLineSeparators("thing TreeFormatterTest.Thing.Nested.Inner")
    }

    def "can append parameterized type name"() {
        when:
        formatter.node("thing ")
        formatter.appendType(Thing.genericInterfaces[0])

        then:
        formatter.toString() == toPlatformLineSeparators("thing List<TreeFormatterTest.Thing.Nested>")
    }

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

            class CustomTask extends DefaultTask {
                @Internal
                Thing thing

        when:
        builder.heading("heading")
        builder.collection("Things", [], renderer, "things")

        then:
        output.value == """
{header}------------------------------------------------------------
heading
------------------------------------------------------------{normal}

{header}Things
------{normal}
    No things.
"""
    }

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

        when:
        fails "tasks"

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

                container.things.create("a") { value = "1" }
                container.things.create("b") { value = "2" }
              }

              @Model
              void things(ModelMap<Thing> things) {
                things.create("a") { value = "1" }
                things.create("b") { value = "2" }
              }
            }

            apply type: Rules

            model {