protected Iterator<E> standardIterator() {
    return Multisets.iteratorImpl(this);
  }

  /**
   * A sensible, albeit inefficient, definition of {@link #size} in terms of {@link #entrySet}. If
   * you override {@link #entrySet}, you may wish to override {@link #size} to forward to this
   * implementation.
   *
   * @since 7.0
   */
  protected int standardSize() {
    return Multisets.linearTimeSizeImpl(this);
  }

    # - - - - - - - - - -/

    # /- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    # o shortCharHandlingMode: (NotRequired - Default NONE)
    #  If the parameter of condition-bean or parameter-bean has short size,
    #   NONE - Do nothing. (default)
    #   EXCEPTION - It throws an exception.
    #   RFILL - It fills the parameter by right spaces.
    #   LFILL - It fills the parameter by left spaces.
    #

import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;

@DisplayName("Smb2LeaseKey Tests")
class Smb2LeaseKeyTest {

    @Test
    @DisplayName("Should generate random lease key with correct size")
    void testRandomLeaseKeyGeneration() {
        Smb2LeaseKey key = new Smb2LeaseKey();

        assertNotNull(key.getKey());
        assertEquals(16, key.getKey().length);
        assertFalse(key.isZero());
    }

          Iterator<E> iterator = collection.iterator();
          assertTrue(collection.removeAll(MinimalCollection.of(e0(), e3())));
          iterator.next();
        });
  }

  /** Trigger the {@code other.size() >= this.size()} case in {@link AbstractSet#removeAll}. */
  @CollectionFeature.Require(SUPPORTS_REMOVE)
  @CollectionSize.Require(absent = ZERO)
  public void testRemoveAll_somePresentLargeCollectionToRemove() {
    assertTrue(

  private fun executeRequests(
    hostname: String,
    networkRequests: List<Call>,
    responses: MutableList<InetAddress>,
    failures: MutableList<Exception>,
  ) {
    val latch = CountDownLatch(networkRequests.size)

    for (call in networkRequests) {
      call.enqueue(
        object : Callback {
          override fun onFailure(
            call: Call,
            e: IOException,
          ) {

    }

    /**
     * @throws Exception
     */
    @Test
    public void testRemove() throws Exception {
        assertThat(map.remove("ONE"), is("1"));
        assertThat(map.size(), is(1));
        assertThat(map.remove("dummy"), is(nullValue()));
    }

    /**
     * @throws Exception
     */
    @Test
    public void testPutAll() throws Exception {

      }

      @Override
      public Iterator<Entry<E>> iterator() {
        return entryIterator();
      }

      @Override
      public int size() {
        return forwardMultiset().entrySet().size();
      }
    }
    return new EntrySetImpl();
  }

  @Override
  public Iterator<E> iterator() {
    return Multisets.iteratorImpl(this);
  }

  @Override

        builder.append(returnType.getSignature());
        builder.append(' ');
        builder.append(name);
        builder.append('(');
        for (int i = 0; i < parameters.size(); i++) {
            ParameterMetaData param = parameters.get(i);
            if (i > 0) {
                builder.append(", ");
            }
            builder.append(param.getSignature());
        }

                Collections.singleton(g), projectArtifact, remoteRepositories(), localRepository(), null);

        printErrors(result);

        assertEquals(2, result.getArtifacts().size());

        assertTrue(result.getArtifacts().contains(g));

        assertTrue(result.getArtifacts().contains(h));

        assertLocalArtifactPresent(g);

        assertLocalArtifactPresent(h);
    }

- **Reduce the API surface** - We no longer need to maintain two methods.
- **Consistency** - All languages have consistent access to the same APIs and ergonomics in the DSL.
- **Reduce the size of the Gradle distribution** - We no longer need to carry multiple standard libraries for different languages.

## Decision

We do not introduce new public API methods that include Groovy types in their signatures.