multiset.add("foo", 2);
    multiset.add("bar");
    assertEquals(3, multiset.size());
    assertEquals(2, multiset.count("foo"));
    assertThat(multiset.toString()).isEqualTo("[foo x 2, bar]");
  }

  public void testCreateWithSize() {
    Multiset<String> multiset = LinkedHashMultiset.create(50);
    multiset.add("foo", 2);
    multiset.add("bar");
    assertEquals(3, multiset.size());
    assertEquals(2, multiset.count("foo"));

      assertEquals(hashUtf8, murmur3_32().newHasher().putBytes(str.getBytes(UTF_8)).hash());
      assertEquals(hashUtf8, murmur3_32().hashString(str, UTF_8));
      assertEquals(hashUtf8, murmur3_32().newHasher().putString(str, UTF_8).hash());
      HashCode hashUtf16 = murmur3_32().hashBytes(str.getBytes(UTF_16));

    assertEquals(expected, view);
    assertEquals(expected.asRanges(), view.asRanges());
    assertEquals(expected.isEmpty(), view.isEmpty());

    if (!expected.isEmpty()) {
      assertEquals(expected.span(), view.span());
    }

    for (int i = MIN_BOUND - 1; i <= MAX_BOUND + 1; i++) {
      assertEquals(expected.contains(i), view.contains(i));

        testableFilter.doFilter(mockRequest, mockResponse, mockFilterChain);

        assertFalse(mockFilterChain.wasDoFilterCalled());
        assertEquals(429, mockResponse.getStatus());
        assertEquals("application/json;charset=UTF-8", mockResponse.getContentType());
        assertEquals("60", mockResponse.getHeaderValue("Retry-After"));
        assertTrue(mockResponse.getWriterOutput().contains("\"status\":9"));

  public void testComputeIfPresent_supportedPresent() {
    assertEquals(
        "computeIfPresent(present, function) should return new value",
        v3(),
        getMap()
            .computeIfPresent(
                k0(),
                (k, v) -> {
                  assertEquals(k0(), k);
                  assertEquals(v0(), v);
                  return v3();
                }));

package jcifs.dcerpc.msrpc;

import static org.junit.jupiter.api.Assertions.assertEquals;

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;

import jcifs.dcerpc.rpc;

class MsrpcSamrOpenDomainTest {

    @Mock
    private SamrPolicyHandle mockHandle;
    @Mock
    private rpc.sid_t mockSid;
    @Mock

      boolean floorWasEven = (BigIntegerMath.log10(x, FLOOR) & 1) == 0;
      assertEquals(BigIntegerMath.log10(x, floorWasEven ? HALF_DOWN : HALF_UP), halfEven);
    }
  }

  @GwtIncompatible // TODO
  public void testLog10TrivialOnPowerOf10() {
    BigInteger x = BigInteger.TEN.pow(100);
    for (RoundingMode mode : ALL_ROUNDING_MODES) {
      assertEquals(100, BigIntegerMath.log10(x, mode));
    }
  }

  @CollectionSize.Require(absent = ZERO)
  public void testGetOrDefault_present() {
    assertEquals(
        "getOrDefault(present, def) should return the associated value",
        v0(),
        getMap().getOrDefault(k0(), v3()));
  }

  @CollectionSize.Require(absent = ZERO)
  public void testGetOrDefault_presentNullDefault() {
    assertEquals(
        "getOrDefault(present, null) should return the associated value",
        v0(),

    public void testAlgorithmNames() {
        assertEquals("None", compressionService.getAlgorithmName(CompressionService.COMPRESSION_NONE));
        assertEquals("LZ77", compressionService.getAlgorithmName(CompressionService.COMPRESSION_LZ77));
        assertEquals("LZ77+Huffman", compressionService.getAlgorithmName(CompressionService.COMPRESSION_LZ77_HUFFMAN));

        )

        val initialVerifyResult = run(":verifyAcceptedApiChangesOrdering").buildAndFail()
        assertEquals(TaskOutcome.FAILED, initialVerifyResult.task(":verifyAcceptedApiChangesOrdering")!!.outcome)

        val sortingResult = run(":sortAcceptedApiChanges").build()
        assertEquals(TaskOutcome.SUCCESS, sortingResult.task(":sortAcceptedApiChanges")!!.outcome)