encoder.writeBoolean(true)
            encoder.writeBoolean(false)
        }
        decode(bytes) { Decoder decoder ->
            assert decoder.readBoolean()
            assert !decoder.readBoolean()
        }
    }

    def "decode fails when boolean cannot be fully read"() {
        given:
        def bytes = truncate { Encoder encoder ->
            encoder.writeBoolean(true)

            val contents = codec.run { decodeContents() }
            val fileCollection = fileCollectionFactory.configurableFiles()
            fileCollection.from(contents)
            if (readBoolean()) {
                fileCollection.finalizeValue()
            }
            isolate.identities.putInstance(id, fileCollection)
            fileCollection
        }
    }

        long timestamp = decoder.readLong();
        String category = decoder.readString();
        LogLevel logLevel = logLevelSerializer.read(decoder);
        OperationIdentifier buildOperationId = decoder.readBoolean() ? new OperationIdentifier(decoder.readSmallLong()) : null;
        List<StyledTextOutputEvent.Span> spans = spanSerializer.read(decoder);

        dataOutput.writeBoolean(!state.dirty);
    }

    @Override
    public LockState read(DataInput dataInput) throws IOException {
        return new DirtyFlagLockState(!dataInput.readBoolean());
    }

    private static class DirtyFlagLockState implements LockState {
        private final boolean dirty;

        private DirtyFlagLockState(boolean dirty) {
            this.dirty = dirty;
        }

            }
        }
    }

    override suspend fun ReadContext.decode(): CalculatedValueContainer<Any, ValueCalculator<Any>>? {
        return decodePreservingSharedIdentity {
            val available = readBoolean()
            if (available) {
                val value = read()
                // TODO - restore the correct display name when the container is attached to its owner (rather than writing the display name to the cache)

        long selectorId = decoder.readSmallLong();
        ComponentSelector requested = selectors.get(selectorId);
        boolean constraint = decoder.readBoolean();
        long fromVariant = decoder.readSmallLong();
        byte resultByte = decoder.readByte();
        if (resultByte == SUCCESSFUL) {
            long selectedId = decoder.readSmallLong();

            writeString(removal.key)
        }
    }

    override suspend fun ReadContext.decode(): ConfigurationCacheEnvironmentChangeTracker.CachedEnvironmentState {
        val cleared = readBoolean()
        val updates = readList {
            val clazz = readClass()
            val key = read() as Any
            val value = read()
            when (clazz) {

            write(encoder, value);
        }
    }

    @Nullable
    public IvyArtifactName readNullable(Decoder decoder) throws IOException {
        boolean hasArtifact = decoder.readBoolean();
        if (hasArtifact) {
            return read(decoder);
        }
        return null;
    }

    writeCollection(value.includeSpecsView)
    writeCollection(value.excludeSpecsView)
}


private
suspend fun ReadContext.readPatternSet(value: PatternSet) {
    value.isCaseSensitive = readBoolean()
    value.setIncludes(readStrings())
    value.setExcludes(readStrings())
    readCollection {
        value.include(readNonNull<Spec<FileTreeElement>>())
    }
    readCollection {

    }

    @Override
    public TransportableActionExecutionSpec read(Decoder decoder) throws Exception {
        String implementationClassName = decoder.readString();
        boolean usesInternalServices = decoder.readBoolean();
        String baseDirPath = decoder.readString();
        String projectCacheDir = decoder.readString();
        byte[] serializedParameters = decoder.readBinary();
        byte classLoaderStructureTag = decoder.readByte();