* Get buffer length
     *
     * @return buffer length
     */
    public int getLength() {
        return length;
    }

    /**
     * Get size of this structure
     *
     * @return size in bytes (16)
     */
    public static int size() {
        return 16; // 8 + 4 + 4
    }

    /**
     * Encode this structure to byte array
     *
     * @param dst destination buffer

    public void test_include_processUrl() {
        assertEquals(0, includeFilter.cachedIncludeSet.size());
        assertEquals(0, includeFilter.cachedExcludeSet.size());

        includeFilter.processUrl("http://example.com/");

        assertEquals(1, includeFilter.cachedIncludeSet.size());
        assertEquals(0, includeFilter.cachedExcludeSet.size());
        assertEquals("http://example.com/.*", includeFilter.cachedIncludeSet.toArray()[0]);

    new NullPointerTester().testAllPublicInstanceMethods(new AtomicDoubleArray(1));
  }

  /** constructor creates array of given size with all elements zero */
  public void testConstructor() {
    AtomicDoubleArray aa = new AtomicDoubleArray(SIZE);
    for (int i = 0; i < SIZE; i++) {
      assertBitEquals(0.0, aa.get(i));
    }
  }

  /** constructor with null array throws NPE */
  public void testConstructor2NPE() {

    assertEquals(1, Iterators.size(registry.getSubscribers(1)));

    registry.register(new IntegerSubscriber());
    assertEquals(3, Iterators.size(registry.getSubscribers("")));
    assertEquals(1, Iterators.size(registry.getSubscribers(new Object())));
    assertEquals(2, Iterators.size(registry.getSubscribers(1)));
  }

  public void testGetSubscribers_returnsImmutableSnapshot() {

    public String accessType;

    /**
     * The size field for controlling page size.
     */
    public String size;

    /**
     * Sets the page size for search log results.
     *
     * @param size the page size to set
     */
    public void setPageSize(final int size) {
        this.size = Integer.toString(size);
    }

    /**
     * Gets the page size for search log results with validation.

		wantValid:    true,
		wantInverted: []sparseEntry{{0, 5000}},
	}, {
		in: []sparseEntry{{1, 0}}, size: 0,
		wantValid: false,
	}, {
		in: []sparseEntry{{-1, 0}}, size: 100,
		wantValid: false,
	}, {
		in: []sparseEntry{{0, -1}}, size: 100,
		wantValid: false,
	}, {
		in: []sparseEntry{{0, 0}}, size: -100,
		wantValid: false,
	}, {

    }
  }

  enum Topology {
    BALANCED {
      @Override
      Optional<BinaryNode> createTree(int size, Random rng) {
        if (size == 0) {
          return Optional.absent();
        } else {
          int leftChildSize = (size - 1) / 2;
          int rightChildSize = size - 1 - leftChildSize;
          return Optional.of(
              new BinaryNode(

    this.alternatingKeysAndValues = alternatingKeysAndValues;
    this.size = size;
    this.keyOffset = 0;
    int tableSize = (size >= 2) ? ImmutableSet.chooseTableSize(size) : 0;
    this.keyHashTable = createHashTableOrThrow(alternatingKeysAndValues, size, tableSize, 0);
    Object valueHashTable = createHashTableOrThrow(alternatingKeysAndValues, size, tableSize, 1);
    this.inverse =

    int[] axesSizeProduct = new int[axes.size() + 1];
    axesSizeProduct[axes.size()] = 1;
    try {
      for (int i = axes.size() - 1; i >= 0; i--) {
        axesSizeProduct[i] = Math.multiplyExact(axesSizeProduct[i + 1], axes.get(i).size());
      }
    } catch (ArithmeticException e) {
      throw new IllegalArgumentException(
          "Cartesian product too large; must have size at most Integer.MAX_VALUE");
    }

   *     size}
   * @throws IllegalArgumentException if {@code size} is negative
   */
  protected AbstractIndexedListIterator(int size, int position) {
    checkPositionIndex(position, size);
    this.size = size;
    this.position = position;
  }

  @Override
  public final boolean hasNext() {
    return position < size;
  }

  @Override
  @ParametricNullness