}

  @CollectionFeature.Require(SUPPORTS_ADD)
  public void testAddAll_nonEmptyList() {
    assertTrue(getMultiset().addAll(asList(e3(), e4(), e3())));
    expectAdded(e3(), e4(), e3());
  }

  @CollectionFeature.Require(SUPPORTS_ADD)
  public void testAddAll_nonEmptyMultiset() {
    assertTrue(getMultiset().addAll(getSubjectGenerator().create(e3(), e4(), e3())));
    expectAdded(e3(), e4(), e3());
  }

  public void testRemoveIf_sometimesTrue() {
    assertTrue(
        "removeIf(isEqual(present)) should return true",
        collection.removeIf(Predicate.isEqual(samples.e0())));
    expectMissing(samples.e0());
  }

  @CollectionFeature.Require(SUPPORTS_ITERATOR_REMOVE)
  @CollectionSize.Require(absent = ZERO)
  public void testRemoveIf_allPresent() {

            assertFalse("Exception message should not be empty", message.trim().isEmpty());
            assertTrue("Exception message should mention 'inputstream'", message.toLowerCase().contains("inputstream"));
            assertTrue("Exception message should mention 'null'", message.toLowerCase().contains("null"));
        }
    }

    /**

        // When
        String result = smbComTreeDisconnect.toString();

        // Then
        assertTrue(result.startsWith("SmbComTreeDisconnect["), "toString should start with 'SmbComTreeDisconnect['");
        assertTrue(result.endsWith("]"), "toString should end with ']'");
    }

  public void testAsMapValuesImplementSet() {
    for (Collection<V> valueCollection : multimap().asMap().values()) {
      assertTrue(valueCollection instanceof Set);
    }
  }

  public void testAsMapGetImplementsSet() {
    for (K key : multimap().keySet()) {
      assertTrue(multimap().asMap().get(key) instanceof Set);
    }
  }

  @MapFeature.Require(SUPPORTS_REMOVE)

        setField(cmd, "typeOfLock", (byte) 0x07);
        setField(cmd, "newOpLockLevel", (byte) 0x02);
        String repr = cmd.toString();
        assertTrue(repr.contains("fid=42"));
        assertTrue(repr.contains("typeOfLock=7"));
        assertTrue(repr.contains("newOplockLevel=2"));
    }

    /**
     * Test decoding of bytes buffer that is too short triggers an exception.

package jcifs;

import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

import java.net.URLStreamHandler;

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

    assertTrue(multimap.keySet() instanceof SortedSet);
    assertTrue(multimap.asMap() instanceof SortedMap);
  }

  public void testTreeKeys_gwtCompatible() {
    ListMultimap<String, Integer> multimap =
        rawtypeToWildcard(MultimapBuilder.treeKeys()).arrayListValues().<String, Integer>build();
    assertTrue(multimap.keySet() instanceof SortedSet);

        serverData.encryptedPasswords = true;
        serverData.signaturesEnabled = true;
        serverData.signaturesRequired = true;

        // Then
        assertTrue(serverData.encryptedPasswords);
        assertTrue(serverData.signaturesEnabled);
        assertTrue(serverData.signaturesRequired);

        // When - set all to false
        serverData.encryptedPasswords = false;
        serverData.signaturesEnabled = false;

        assertNotNull(result);
        assertTrue(result.startsWith("NetShareEnumResponse["));
        assertTrue(result.contains("status=0"));
        assertTrue(result.contains("converter=100"));
        assertTrue(result.contains("entriesReturned=2"));
        assertTrue(result.contains("totalAvailableEntries=5"));
        assertTrue(result.endsWith("]"));
    }

    @Test