@CollectionSize.Require(absent = ZERO)
  public void testRemove_present() {
    int initialSize = getMap().size();
    assertEquals("remove(present) should return the associated value", v0(), getMap().remove(k0()));
    assertEquals(
        "remove(present) should decrease a map's size by one.", initialSize - 1, getMap().size());
    expectMissing(e0());
  }

  @MapFeature.Require({FAILS_FAST_ON_CONCURRENT_MODIFICATION, SUPPORTS_REMOVE})

    // no equals and hashCode; it would break the contract!
  }

  /** Returns the number of elements in {@code iterable}. */
  public static int size(Iterable<?> iterable) {
    return (iterable instanceof Collection)
        ? ((Collection<?>) iterable).size()
        : Iterators.size(iterable.iterator());
  }

  /**
   * Returns {@code true} if {@code iterable} contains any element {@code o} for which {@code

    for (int size = 1; size < 200; size++) {
      assertWontGrow(
          size,
          new LinkedHashMap<>(),
          Maps.newLinkedHashMapWithExpectedSize(size),
          Maps.newLinkedHashMapWithExpectedSize(size));
    }
  }

  @J2ktIncompatible
  @GwtIncompatible // reflection
  private static void assertWontGrow(
      int size,
      HashMap<Object, Object> referenceMap,

    try {
      block(content)
      constructedBit = if (constructed) 0b0010_0000 else 0
      constructed = true // The enclosing object is constructed.
    } finally {
      stack.removeAt(stack.size - 1)
      path.removeAt(path.size - 1)
    }

    val sink = sink()

    // Write the tagClass, tag, and constructed bit. This takes 1 byte if tag is less than 31.
    if (tag < 31) {

        return true;
      }
      if (object instanceof BooleanArrayAsList) {
        BooleanArrayAsList that = (BooleanArrayAsList) object;
        int size = size();
        if (that.size() != size) {
          return false;
        }
        for (int i = 0; i < size; i++) {
          if (array[start + i] != that.array[that.start + i]) {
            return false;
          }
        }
        return true;
      }

            parent = list;
            this.allRecordCount = allRecordCount;
            pageSize = size;
            currentPageNumber = offset / size + 1;
            allPageCount = allRecordCount == 0 ? 0 : (allRecordCount - 1) / size + 1;
        }

        @Override
        public int size() {
            return parent.size();
        }

      assertThat(expected.message).isEqualTo(
        "Payload size must be less than or equal to 125",
      )
    }
  }

  private fun assertData(hex: String) {
    assertData(hex.decodeHex())
  }

  private fun assertData(expected: ByteString) {
    val actual = data.readByteString(Math.min(expected.size.toLong(), data.size))
    assertThat(actual).isEqualTo(expected)
  }

  companion object {

  public void testSlice_constrainedRange() throws IOException {
    long size = source.read().length;
    if (size >= 2) {
      ByteSource sliced = source.slice(1, size - 2);
      assertEquals(size - 2, sliced.read().length);
      ByteSource resliced = sliced.slice(0, size - 1);
      assertTrue(sliced.contentEquals(resliced));
    }
  }

        return true;
      }
      if (object instanceof CharArrayAsList) {
        CharArrayAsList that = (CharArrayAsList) object;
        int size = size();
        if (that.size() != size) {
          return false;
        }
        for (int i = 0; i < size; i++) {
          if (array[start + i] != that.array[that.start + i]) {
            return false;
          }
        }
        return true;
      }

  }

  @Override
  public boolean isEmpty() {
    return backingMap.isEmpty();
  }

  @Override
  public int size() {
    int size = 0;
    for (Map<C, V> map : backingMap.values()) {
      size += map.size();
    }
    return size;
  }

  // Mutators

  @Override
  public void clear() {
    backingMap.clear();
  }