1 * writeIndex.lookup("key") >> null
        1 * readIndex.lookup("key")

        when:
        twoStageIndex.lookup("other")

        then:
        1 * writeIndex.lookup("other") >> Stub(CachedExternalResource)
        0 * readIndex._
    }

    def "clearing delegates to the writable cache"() {
        when:
        twoStageIndex.clear("key")

        then:
        1 * writeIndex.clear("key")

            } else {
                encoder.writeBoolean(false);
            }
            Integer idx = writeIndex.get(container);
            if (idx == null) {
                // new value
                encoder.writeSmallInt(writeIndex.size());
                writeIndex.put(container, writeIndex.size());
                delegate.write(encoder, container);
            } else {

            } catch (FileNotFoundException e) {
                throw new UncheckedIOException(e);
            }
        }

        @Override
        public void close() {
            output.close();
            writeIndex();
        }

        public void onOutput(long classId, TestOutputEvent outputEvent) {
            onOutput(classId, 0, outputEvent);
        }

    @Override
    protected int getBatchLimit ( Configuration cfg, byte cmd ) {
        if ( cmd == SMB_COM_READ_ANDX ) {
            return cfg.getBatchLimit("WriteAndX.ReadAndX");
        }
        if ( cmd == SMB_COM_CLOSE ) {
            return cfg.getBatchLimit("WriteAndX.Close");
        }
        return 0;
    }


    @Override
    protected int writeParameterWordsWireFormat ( byte[] dst, int dstIndex ) {

    private static final int READ_ANDX_BATCH_LIMIT =
                            Config.getInt( "jcifs.smb1.smb.client.WriteAndX.ReadAndX", 1 );
    private static final int CLOSE_BATCH_LIMIT =
                            Config.getInt( "jcifs.smb1.smb.client.WriteAndX.Close", 1 );

    private int fid,
        remaining,
        dataLength,
        dataOffset,
        off;
    private byte[] b;

        this.remaining = remaining;
        this.b = b;
        this.off = off;
        count = len;
        digest = null; /* otherwise recycled commands
                        * like writeandx will choke if session
                        * closes in between */
    }
    int writeParameterWordsWireFormat( byte[] dst, int dstIndex ) {
        int start = dstIndex;

        writeInt2( fid, dst, dstIndex );

        this.b = b;
        this.off = off;
        this.count = len;
        this.digest = null; /*
                             * otherwise recycled commands
                             * like writeandx will choke if session
                             * closes in between
                             */
    }


    @Override
    protected int writeParameterWordsWireFormat ( byte[] dst, int dstIndex ) {