assertEquals('B', stream.read());

        // Mark current position
        stream.mark(10);

        assertEquals('C', stream.read());
        assertEquals('D', stream.read());

        // Reset to marked position
        stream.reset();

        // Should read from marked position again
        assertEquals('C', stream.read());
        assertEquals('D', stream.read());
    }

     */
    void addRule(Rule rule);

    /**
     * Adds a rule to the specified index.
     *
     * @param index the position at which the rule should be added
     * @param rule the rule to be added
     */
    /**
     * Adds a rule to the specified index.
     *
     * @param index the position at which the rule should be added
     * @param rule the rule to be added
     */
    void addRule(int index, Rule rule);

     * @param rule the rule to add
     */
    @Override
    public void addRule(final Rule rule) {
        ruleList.add(rule);
    }

    /**
     * Adds a rule at the specified position in the rule list.
     * @param index the position to insert the rule
     * @param rule the rule to add
     */
    @Override
    public void addRule(final int index, final Rule rule) {
        ruleList.add(index, rule);
    }

    /*

  private void addToCache(K key, V value) {
    addToCache(new CacheEntry<K, V>(key, value));
  }

  private void addToCache(CacheEntry<K, V> entry) {
    // Slide new entry into first cache position. Drop previous entry in second cache position.
    cacheEntry2 = cacheEntry1;
    cacheEntry1 = entry;
  }

  private static final class CacheEntry<K, V> {
    final K key;
    final V value;

    CacheEntry(K key, V value) {

    }
    return this;
  }

  @Override
  @CanIgnoreReturnValue
  public Hasher putBytes(ByteBuffer b) {
    if (b.hasArray()) {
      putBytes(b.array(), b.arrayOffset() + b.position(), b.remaining());
      Java8Compatibility.position(b, b.limit());
    } else {
      for (int remaining = b.remaining(); remaining > 0; remaining--) {
        putByte(b.get());
      }
    }
    return this;
  }

  @Override

ams\":{\"type\":\"histogram\",\"grid\":{\"categoryLines\":false},\"categoryAxes\":[{\"id\":\"CategoryAxis-1\",\"type\":\"category\",\"position\":\"bottom\",\"show\":true,\"style\":{},\"scale\":{\"type\":\"linear\"},\"labels\":{\"show\":true,\"truncate\":100},\"title\":{}}],\"valueAxes\":[{\"id\":\"ValueAxis-1\",\"name\":\"LeftAxis-1\",\"type\":\"value\",\"position\":\"left\",\"show\":true,\"style\":{},\"scale\":{\"type\":\"linear\",\"mode\":\"normal\"},\"labels\":{\"show\":true,\"rotate\":0,\"fi...

      }
      return crossOverUp(index, x);
    }

    /**
     * Fills the hole at {@code index} by moving in the least of its grandchildren to this position,
     * then recursively filling the new hole created.
     *
     * @return the position of the new hole (where the lowest grandchild moved from, that had no
     *     grandchild to replace it)
     */
    int fillHoleAt(int index) {

        for (int i = 0; i < 16; i++) {
            fileId[i] = (byte) (i + 1);
        }

        request.setFileId(fileId);

        // Verify by writing to buffer and checking the fileId position
        byte[] buffer = new byte[1024];
        request.writeBytesWireFormat(buffer, Smb2Constants.SMB2_HEADER_LENGTH);

        // FileId is at offset 8 in the request structure
        for (int i = 0; i < 16; i++) {

    }

    @Override
    public <T> T[] toArray(final T[] a) {
        return parent.toArray(a);
    }

    /**
     * Gets the starting position of the current page in the overall result set.
     *
     * @return the start position (0-based)
     */
    public int getStart() {
        return start;
    }

    /**
     * Gets the offset value used for pagination calculations.
     *

        NdrHyper hyper = new NdrHyper(original);
        // Create buffer with extra space for alignment
        NdrBuffer buf = new NdrBuffer(new byte[16], 0);
        hyper.encode(buf);
        // Reset buffer position for decoding
        buf.reset();
        NdrHyper decoded = new NdrHyper(0);
        decoded.decode(buf);
        assertEquals(original, decoded.value, "Decoded value should match encoded value");
    }

    /**