class UserTypesCodecTest : AbstractUserTypeCodecTest() {

    @Test
    fun `can handle deeply nested graphs`() {

        val deepGraph = Peano.fromInt(1024)

        val read = configurationCacheRoundtripOf(deepGraph)

        assertThat(
            read.toInt(),
            equalTo(deepGraph.toInt())
        )
    }

    @Test

    @Test
    fun `can handle Properties`() {
        val properties = Properties()
        properties.setProperty("prop1", "value1")
        properties.setProperty("prop2", "value2")
        configurationCacheRoundtripOf(properties).run {
            assertThat(properties, equalTo(this))
        }
    }

    @Test
    fun `can handle Hashtable`() {
        val hashtable = Hashtable<String, Any>(100)

        Runtime.value = "before"
        val value = configurationCacheRoundtripOf(deferred)

        Runtime.value = "after"
        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"

class UnitCodecTest : AbstractUserTypeCodecTest() {

    @Test
    @Issue("https://github.com/gradle/gradle/issues/25560")
    fun `same Unit instance is used upon restore`() {
        configurationCacheRoundtripOf(Unit).run {
            assertThat(this, sameInstance(Unit))
        }
    }

                        problems += problem
                    }
                }
            )
        }

    protected
    fun <T : Any> configurationCacheRoundtripOf(graph: T, codec: Codec<Any?> = userTypesCodec()): T =
        writeToByteArray(graph, codec)
            .let { readFromByteArray(it, codec)!! }
            .uncheckedCast()

    internal

    private
    fun <T : Any> verifyRoundtripOf(factory: () -> T, verify: (T) -> Unit) {
        verify(javaSerializationRoundtripOf(factory()))
        verify(configurationCacheRoundtripOf(factory()))
    }

    private
    fun <T : Any> javaSerializationRoundtripOf(bean: T): T =
        javaDeserialize(javaSerialize(bean)).uncheckedCast()

    private