encoder.writeNullableString(value.getDetails().getMessage());
            encoder.writeString(value.getDetails().getClassName());
            encoder.writeString(value.getDetails().getStacktrace());
            encoder.writeBoolean(value.getDetails().isAssertionFailure());
            encoder.writeNullableString(value.getDetails().getExpected());

            }
        }
    }

    private
    fun DefaultWriteContext.writeModelKey(key: ModelKey) {
        writeNullableString(key.identityPath?.path)
        writeString(key.modelName)
        writeNullableString(key.parameterHash?.toString())
    }

    internal
    fun readCacheEntryDetailsFrom(stateFile: ConfigurationCacheStateFile): EntryDetails? {

            val taskName = task.name
            writeClass(taskType)
            writeString(projectPath)
            writeString(taskName)
            writeLong(task.taskIdentity.uniqueId)
            writeNullableString(task.reasonTaskIsIncompatibleWithConfigurationCache.orElse(null))

            withDebugFrame({ taskType.name }) {
                withTaskOf(taskType, task, userTypesCodec) {
                    writeUpToDateSpec(task)

        then:
        thrown(IllegalArgumentException)
    }

    def "can encode and decode a nullable string"() {
        expect:
        def bytes = encode { Encoder encoder ->
            encoder.writeNullableString(value)
        }
        decode(bytes) { Decoder decoder ->
            assert decoder.readNullableString() == value?.toString()
        }

        where:
        value                            | _

                hierarchicalNameSerializer.write(encoder, entry.getKey());
                IntSetSerializer.INSTANCE.write(encoder, entry.getValue());
            }
            encoder.writeNullableString(value.fullRebuildCause);
        }
    }

        override fun pop(): Unit =
            undefined()

        override suspend fun forIncompatibleType(path: String, action: suspend () -> Unit) =
            undefined()

        override fun writeNullableString(value: CharSequence?): Unit =
            undefined()

        override fun writeNullableSmallInt(value: Int?): Unit =
            undefined()

        override fun writeLong(value: Long): Unit =

    private static class DaemonUnavailableSerializer implements Serializer<DaemonUnavailable> {
        @Override
        public void write(Encoder encoder, DaemonUnavailable value) throws Exception {
            encoder.writeNullableString(value.getReason());
        }

        @Override
        public DaemonUnavailable read(Decoder decoder) throws Exception {
            return new DaemonUnavailable(decoder.readNullableString());
        }