configurations = listOf("api")
            ),
            equalTo(
                hashCodeFor(
                    configurations = listOf("api")
                )
            )
        )

        assertThat(
            hashCodeFor(
                configurations = listOf("api")
            ),
            not(
                equalTo(
                    hashCodeFor(

import org.gradle.kotlin.dsl.typeOf

import org.hamcrest.CoreMatchers.equalTo
import org.hamcrest.MatcherAssert.assertThat
import org.junit.Test


class KotlinTypeStringTest {

    @Test
    fun `#kotlinTypeStringFor array type`() {
        assertThat(
            kotlinTypeStringFor(typeOf<Array<String>>()),
            equalTo("Array<String>")
        )
    }

    @Test

            assertThat(
                it.childBean?.value,
                equalTo(42)
            )
            assertThat(it.someInt, equalTo(13))
        }
    }

    @Test
    fun `can handle multiple writeObject implementations in the hierarchy`() {
        verifyRoundtripOf({ MultiWriteObjectBean() }) { bean ->
            assertThat(
                bean.stringValue,
                equalTo("42")

            subject.push(r1)
            subject.push(r2)
        }

        assertThat(
            subject.nextGroup(),
            equalTo(requestsInGroup2.reversed())
        )

        assertThat(
            subject.nextGroup(),
            equalTo(requestsInGroup1.reversed())
        )
    }

    @Test
    fun `#nextGroup honours timeout`() {

        withMockForSettings(existing = "p" to 42) {

            val p: Int by settings
            assertThat(p, equalTo(42))
        }

        withMockForProject(existing = "p" to 42) {

            val p: Int by project
            assertThat(p, equalTo(42))
        }
    }

    @Test
    fun `non-nullable delegated property access of existing null gradle property throws`() {

            assertThat(hierarchy.classLoaders.size, equalTo(3))
            assertThat(hierarchy.scopes.size, equalTo(1))
            assertThat(hierarchy.classLoaders[0].parents, hasItem(hierarchy.classLoaders[1].id))
            assertThat(hierarchy.scopes[0].label, equalTo("the path"))
            assertThat(hierarchy.scopes[0].localClassLoader, equalTo(hierarchy.classLoaders[0].id))

        val original = "foo${'$'}${'$'}bar"
        val spec = AccessorNameSpec(original)

        assertThat(spec.original, equalTo(original))
        assertThat(spec.kotlinIdentifier, equalTo(original))
        assertThat(spec.stringLiteral, equalTo("foo${'$'}{'${'$'}'}${'$'}{'${'$'}'}bar"))
    }

    interface NonExistingType

    @Test

                    return "foo"
                }
            """,
            { assertThat(it.instantiateAndCall("foo"), equalTo("foo")) },
            """
                fun foo(): String {
                    return "bar"
                }
            """,
            { assertThat(it.instantiateAndCall("foo"), equalTo("bar")) }
        ).assertSameApi()
    }

            },
            equalTo(
                cacheKeyStringFromStartParameter {
                    includeBuild(file("included"))
                }
            )
        )
        assertThat(
            cacheKeyStringFromStartParameter {
                includeBuild(file("included"))
            },
            not(equalTo(cacheKeyStringFromStartParameter { }))
        )
    }

    @Test
    void generatesMonotonicallyIncreasingLongIdsStartingAtOne() {
        assertThat(generator.generateId(), equalTo(1L))
        assertThat(generator.generateId(), equalTo(2L))
        assertThat(generator.generateId(), equalTo(3L))
    }

    @Test
    void generatesUniqueIdsWhenInvokedConcurrently() {
        Set<Long> ids = new CopyOnWriteArraySet<Long>()

        5.times {