resetContainer(mapEntry(k0(), v0()), mapEntry(k0(), v1()), mapEntry(k1(), v0()));
    Multiset<K> keys = multimap().keys();
    assertEquals(2, keys.count(k0()));
    assertEquals(1, keys.count(k1()));
    assertEquals(3, keys.size());
    assertContainsAllOf(keys, k0(), k1());
    assertContainsAllOf(
        keys.entrySet(), Multisets.immutableEntry(k0(), 2), Multisets.immutableEntry(k1(), 1));
  }

  @MapFeature.Require(ALLOWS_NULL_KEY_QUERIES)

    @Test
    @DisplayName("Test size returns positive message size")
    void testSizeReturnsPositiveValue() {
        // Given
        int expectedSize = 1024;
        when(request.size()).thenReturn(expectedSize);

        // When
        int result = request.size();

        // Then
        assertEquals(expectedSize, result);
        verify(request, times(1)).size();
    }

    @Test

    }
    int size = this.size;
    if (size < requireEntries().length) {
      resizeEntries(size);
    }
    int minimumTableSize = CompactHashing.tableSize(size);
    int mask = hashTableMask();
    if (minimumTableSize < mask) { // smaller table size will always be less than current mask
      resizeTable(mask, minimumTableSize, UNSET, UNSET);
    }
  }

  @Override
  public void clear() {

    /**
     * Gets the last modified time.
     *
     * @return the last modified time in milliseconds since epoch
     */
    long lastModified();

    /**
     * Gets the file size.
     *
     * @return the file size in bytes
     */
    long length();

        // The validation in getBuffer() ensures size is within bounds (0 < size <= 1MB)
        assertTrue(buffer.length > 0, "Buffer size should be positive");
        assertTrue(buffer.length <= 0x100000, "Buffer size should not exceed 1MB");
    }

    /**
     * Test that releaseBuffer validates buffer before accepting it.
     */
    @Test

    }

    ensureCapacity(size + 1);
    keys[size] = key;
    values[size] = value;

    insertIntoTableKToV(size, keyHash);
    insertIntoTableVToK(size, valueHash);

    setSucceeds(lastInInsertionOrder, size);
    setSucceeds(size, ENDPOINT);
    size++;
    modCount++;
    return null;
  }

  @Override
  @CanIgnoreReturnValue

   */
  public static <E> Set<Set<E>> combinations(Set<E> set, int size) {
    ImmutableMap<E, Integer> index = Maps.indexMap(set);
    checkNonnegative(size, "size");
    checkArgument(size <= index.size(), "size (%s) must be <= set.size() (%s)", size, index.size());
    if (size == 0) {
      return ImmutableSet.<Set<E>>of(ImmutableSet.<E>of());
    } else if (size == index.size()) {
      return ImmutableSet.<Set<E>>of(index.keySet());

     * If not set or invalid, returns the default page size.
     *
     * @return the page size
     */
    public int getPageSize() {
        if (pageSize <= 0) {
            pageSize = getDefaultPageSize();
        }
        return pageSize;
    }

    /**
     * Sets the number of records to display per page.
     *
     * @param pageSize the page size to set
     */

     */
    public byte[] getData() {
        return data;
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.internal.CommonServerMessageBlockRequest#size()
     */
    @Override
    public int size() {
        return size8(Smb2Constants.SMB2_HEADER_LENGTH + 48 + this.dataLength);
    }

    /**
     * {@inheritDoc}
     *

                @Override
                public int size() {
                    return 1;
                }
            };
        }
    }

    private static class MapN<K, V> extends AbstractImmutableMap<K, V> {
        private final Object[] entries;

        private MapN(Map<K, V> map) {
            if (map != null) {
                entries = new Object[map.size()];
                int idx = 0;