return localInterfaces.size() > 0 && remoteInterfaces.size() > 0
            && (localInterfaces.size() > 1 || remoteInterfaces.size() > 1);
    }
    
    private void establishAdditionalChannels() {
        int currentChannels = channels.size();
        int targetChannels = Math.min(maxChannels, 
            Math.min(localInterfaces.size(), remoteInterfaces.size()));
        

        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;
      }

    public void setExistNextPage(final boolean existNextPage) {
        this.existNextPage = existNextPage;
    }

    /**
     * Gets the number of items per page.
     * If the page size is not set or is zero or negative, returns the default page size.
     *
     * @return the number of items per page
     */
    public int getPageSize() {
        if (pageSize <= 0) {
            pageSize = getDefaultPageSize();
        }

      AbstractTable.this.clear();
    }

    @Override
    public Iterator<Table.Cell<R, C, V>> iterator() {
      return cellIterator();
    }

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

  @LazyInit private transient @Nullable Collection<V> values;

  @Override
  public Collection<V> values() {
    Collection<V> result = values;

    }

    /**
     * Generates test data with repeating patterns for good compression.
     */
    private byte[] generateTestData(int size) {
        byte[] data = new byte[size];

        // Create data with repeating patterns
        for (int i = 0; i < size; i++) {
            if (i % 100 < 50) {
                data[i] = (byte) 'A';
            } else if (i % 100 < 75) {
                data[i] = (byte) 'B';

  private fun writeControlFrame(
    opcode: Int,
    payload: ByteString,
  ) {
    if (writerClosed) throw IOException("closed")

    val length = payload.size
    require(length <= PAYLOAD_BYTE_MAX) {
      "Payload size must be less than or equal to $PAYLOAD_BYTE_MAX"
    }

    val b0 = B0_FLAG_FIN or opcode
    sinkBuffer.writeByte(b0)

    var b1 = length
    if (isClient) {

    assertEquals(getNumElements() + 1, multimap().size());
    assertTrue(multimap().containsEntry(k0(), v3()));
  }

  @MapFeature.Require(SUPPORTS_PUT)
  public void testPropagatesAddAllToMultimap() {
    Collection<V> result = multimap().get(k0());
    assertTrue(result.addAll(singletonList(v3())));
    assertTrue(multimap().containsKey(k0()));
    assertEquals(getNumElements() + 1, multimap().size());

	var buffer []byte
	switch size := data.Size(); {
	case size == 0:
		buffer = make([]byte, 1) // Allocate at least a byte to reach EOF
	case size >= fi.Erasure.BlockSize || size == -1:
		buffer = globalBytePoolCap.Load().Get()
		defer globalBytePoolCap.Load().Put(buffer)
	case size < fi.Erasure.BlockSize:

    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)

    for (int i = 0; i < entries.size(); i++) {
      List<Entry<E>> expected = spec.expectedEntries(i, entries);
      SortedMultiset<E> subMultiset = spec.subMultiset(sortedMultiset, entries, i);
      assertEquals(expected.size(), subMultiset.entrySet().size());
      assertEquals(expected.size(), subMultiset.elementSet().size());
    }
  }

  public void testTailClosedEntrySet() {