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`() {

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

            assertThat(properties, equalTo(this))
        }
    }

    @Test
    fun `can handle Hashtable`() {
        val hashtable = Hashtable<String, Any>(100)
        hashtable.put("key1", "value1")
        hashtable.put("key2", true)
        hashtable.put("key3", 42)
        configurationCacheRoundtripOf(hashtable).run {
            assertThat(hashtable, equalTo(this))
        }
    }

            )
        }
    }

    @Test
    fun `Peano sanity check`() {

        assertThat(
            Peano.fromInt(0),
            equalTo(Peano.Z)
        )

        assertThat(
            Peano.fromInt(1024).toInt(),
            equalTo(1024)
        )
    }

    sealed class Peano {

        companion object {

import org.gradle.api.Task
import org.gradle.internal.configuration.problems.PropertyKind
import org.gradle.internal.configuration.problems.PropertyTrace

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

import org.junit.Test


class PropertyTraceTest {

    @Test
    fun `field of bean found in input property of task`() {

        assertThat(
            force(value),
            equalTo("after")
        )
    }

    protected
    fun <T : Any> assertEagerEvaluationOf(eager: T, extract: T.() -> Any?) {
        Runtime.value = "before"
        val value = configurationCacheRoundtripOf(eager)

        Runtime.value = "after"
        assertThat(
            extract(value),
            equalTo("before")
        )
    }

    object Runtime {

import org.hamcrest.Matchers.equalTo
import org.junit.Test
import java.util.function.Consumer


typealias TestableIsolatedAction<T> = IsolatedAction<in Consumer<T>>


class IsolatedActionSerializerTest {

    @Test
    fun `can serialize Kotlin action`() {
        assertThat(
            valueCarriedBy(roundtripOf(isolatedActionCarrying(42))),
            equalTo(42)
        )
    }

    @Test

import org.gradle.internal.operations.CallableBuildOperation
import org.gradle.internal.operations.RunnableBuildOperation
import org.gradle.test.fixtures.file.TestNameTestDirectoryProvider
import org.hamcrest.CoreMatchers.equalTo
import org.hamcrest.MatcherAssert.assertThat
import org.junit.Rule
import org.junit.Test
import org.mockito.ArgumentCaptor
import org.mockito.ArgumentMatchers.any
import java.util.UUID

import org.gradle.internal.configuration.problems.PropertyTrace
import org.gradle.internal.configuration.problems.StructuredMessage
import org.hamcrest.MatcherAssert.assertThat
import org.hamcrest.Matchers.equalTo
import org.junit.Assert.assertFalse
import org.junit.Assert.assertTrue
import org.junit.Test


class ConfigurationCacheProblemsSummaryTest {

    @Test

    override fun hashCode(): Int = Objects.hashCode(backingArgument, backingType, backingIsNegated)
    override fun equals(other: Any?): Boolean {
        return this === other ||
                other is KaContractIsInstancePredicateExpression &&
                other.backingArgument == backingArgument &&