) : Closeable {

    private
    val valuesStore by lazy {
        val writer = ValueStore.Writer<V> { encoder, value ->
            write(encoder, value)
        }
        val reader = ValueStore.Reader { decoder ->
            read(decoder)
        }
        store.createValueStore(stateType, writer, reader)
    }

    private
    val previousValues = ConcurrentHashMap<K, BlockAddress>()

        server.expectGetEmptyOk("/redirect/cache/${key.hashCode}")

        when:
        def writer = writer(content)
        cache.store(key, writer)

        then:
        noExceptionThrown()
        writer.writeCount == 1
    }

    def "storing to cache can follow method preserving redirects"() {
        def destFile = tempDir.file("cached.zip")

                    }
                }
                BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(file), encoding));
                try {
                    action.execute(writer);
                } finally {
                    writer.close();
                }
            } catch (Exception e) {

internal
typealias BytecodeWriter = BytecodeFragmentScope.() -> Unit


internal
class BytecodeFragmentScope(
    val signature: JvmMethodSignature,
    writer: ClassWriter,
    val useLowPriorityInOverloadResolution: Boolean
) : ClassVisitor(ASM_LEVEL, writer)


internal
typealias MetadataWriter = MetadataFragmentScope.() -> Unit


internal
data class MetadataFragmentScope(
    val signature: JvmMethodSignature,

    def buildCacheKey = TestHashCodes.hashCodeFrom(1234)

    def "converts to origin metadata"() {
        def origin = new Properties()
        def writer = factory.createWriter("identity", CacheableEntity, buildCacheKey, Duration.ofMillis(10))
        def baos = new ByteArrayOutputStream()
        writer.execute(baos)
        when:
        def reader = factory.createReader()
        // doesn't explode

                    try {
                        FileWriter writer = new FileWriter(buildOperationIdFile);
                        writer.write(CurrentBuildOperationRef.instance().get().getId().toString());
                        writer.close();
                    } catch (Exception e) {
                        throw new RuntimeException(e);
                    }

        reportFor(rules.toList()*.build())
    }

    String reportFor(List<UnboundRule> rules) {
        def writer = new StringWriter()
        new UnboundRulesReporter(new PrintWriter(writer), "").reportOn(rules)
        normaliseLineSeparators(writer.toString())
    }

    def "creates unbound rules for unfulfilled binders with unbound subject reference"() {
        binder {

            writer.write(" ");
            writer.write(input.getType() == null ? "<untyped>" : input.getType());
            if (input.getDescription() != null) {
                writer.write(" ");
                writer.write("(");
                writer.write(input.getDescription());
                writer.write(")");
            }
            if (!input.isBound()) {
                writer.write(" ");
                writer.write("[*]");

    final StringWriter writer = new StringWriter()
    final PrintWriter printWriter = new PrintWriter(writer, true)
    final ArgWriter argWriter = ArgWriter.unixStyle(printWriter)

    def "writes single argument to line"() {
        when:
        argWriter.args("-nologo")

        then:
        writer.toString() == toPlatformLineSeparators("-nologo\n")
    }

    private static final Pattern WHITESPACE_OR_HASH = Pattern.compile("\\s|#");

    private final PrintWriter writer;
    private final boolean backslashEscape;
    private final Pattern quotablePattern;

    private ArgWriter(PrintWriter writer, boolean backslashEscape, Pattern quotablePattern) {
        this.writer = writer;
        this.backslashEscape = backslashEscape;
        this.quotablePattern = quotablePattern;
    }