String::class.java == returnType &&
        callArgs.size == 1 &&
        callArgs[0] is List<*>
      ) {
        val peerProtocols = callArgs[0] as List<*>
        // Pick the first known protocol the peer advertises.
        for (i in 0..peerProtocols.size) {
          val protocol = peerProtocols[i] as String
          if (protocol in protocols) {

  @MapFeature.Require(SUPPORTS_REMOVE)
  public void testAsMapRemove() {
    assertContentsInOrder(multimap().asMap().remove(k0()), v0());
    assertGet(k0());
    assertEquals(getNumElements() - 1, multimap().size());
  }

  @CollectionSize.Require(SEVERAL)
  @MapFeature.Require(SUPPORTS_PUT)
  public void testAsMapEntrySetReflectsPutSameKey() {
    resetContainer(mapEntry(k0(), v0()), mapEntry(k0(), v3()));

 * Multiset#entrySet()} method, plus optionally overriding {@link #add(Object, int)} and {@link
 * #remove(Object, int)} to enable modifications to the multiset.
 *
 * <p>The {@link #count} and {@link #size} implementations all iterate across the set returned by
 * {@link Multiset#entrySet()}, as do many methods acting on the set returned by {@link
 * #elementSet()}. Override those methods for better performance.
 *

            properties.put("prerequisites.maven", prerequisites.getMaven());
        }

        List<License> licenses = model.getLicenses();
        properties.put("license.count", licenses.size());
        for (int i = 0; i < licenses.size(); i++) {
            License license = licenses.get(i);
            properties.put("license." + i + ".name", license.getName());
            properties.put("license." + i + ".url", license.getUrl());

                if (fessConfig.isValidSearchLogPermissions(roles.toArray(new String[roles.size()]))) {
                    suggester.indexer()
                            .indexFromSearchWord(sb.toString(), fields.toArray(new String[fields.size()]),
                                    tags.toArray(new String[tags.size()]), roles.toArray(new String[roles.size()]), 1, langs);
                    duplicateSessionMap.put(sessionId, requestedAt);

        assertEquals(8192, receiveBufferSize, "Should delegate receive buffer size");
        assertEquals(65536, maximumBufferSize, "Should delegate maximum buffer size");
        assertEquals(65024, transactionBufferSize, "Should delegate transaction buffer size");
        assertEquals(16, bufferCacheSize, "Should delegate buffer cache size");

        public V get(int index) {
            return asList().get(index);
        }

        @Override
        public int size() {
            if (map != null) {
                return map.size();
            } else {
                return list.size();
            }
        }
    }

      assertThat(network.nodes()).isEmpty();
      assertThat(network.edges()).isEmpty();
      AbstractNetworkTest.validateNetwork(network);

      while (network.nodes().size() < NUM_NODES) {
        network.addNode(gen.nextInt(NODE_POOL_SIZE));
      }
      ArrayList<Integer> nodeList = new ArrayList<>(network.nodes());
      for (int i = 0; i < NUM_EDGES; ++i) {

            bufferIndex += 6; // 2 + 4 for reserved fields
        }

        return bufferIndex - start;
    }

    @Override
    public int size() {
        return 20; // Fixed size: 2 + 2 + 4 + 12 (transform structure)
    }

    /**
     * Check if RDMA is supported based on this context
     *
     * @return true if RDMA Transform V1 is supported
     */

        bufferIndex += 4;
        return bufferIndex - start;
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.Encodable#size()
     */
    @Override
    public int size() {
        return 40;
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.Encodable#encode(byte[], int)
     */
    @Override