public void testReplaceAllPreservesOrder() {
    getMap()
        .replaceAll(
            (K k, V v) -> {
              int index = keys().asList().indexOf(k);
              return values().asList().get(index + 1);
            });
    List<Entry<K, V>> orderedEntries = getOrderedElements();
    int index = 0;
    for (K key : getMap().keySet()) {
      assertEquals(orderedEntries.get(index).getKey(), key);

  public void testToString_minimal() {
    assertNotNull("toString() should not return null", getMap().toString());
  }

  @CollectionSize.Require(ZERO)
  @CollectionFeature.Require(absent = NON_STANDARD_TOSTRING)
  public void testToString_size0() {
    assertEquals("emptyMap.toString should return {}", "{}", getMap().toString());
  }

  @CollectionSize.Require(ONE)

    private InetAddress witnessServer;
    private InetAddress serverAddress;

    @BeforeEach
    void setUp() throws Exception {
        witnessServer = InetAddress.getByName("192.168.1.200");
        serverAddress = InetAddress.getByName("192.168.1.100");

        // Setup mock configuration with lenient stubbing
        lenient().when(mockContext.getConfig()).thenReturn(mockConfig);

  public void testForEachKnownOrder() {
    List<Entry<K, V>> entries = new ArrayList<>();
    getMap().forEach((k, v) -> entries.add(entry(k, v)));
    assertEquals(getOrderedElements(), entries);
  }

  @CollectionFeature.Require(absent = KNOWN_ORDER)
  public void testForEachUnknownOrder() {
    List<Entry<K, V>> entries = new ArrayList<>();
    getMap().forEach((k, v) -> entries.add(entry(k, v)));

    for (Entry<K, V> entry : getMap().entrySet()) {
      assertThrows(NullPointerException.class, () -> entry.setValue(null));
      expectUnchanged();
    }
  }

  @MapFeature.Require({SUPPORTS_PUT, ALLOWS_NULL_VALUES})
  @CollectionSize.Require(absent = ZERO)
  public void testSetValueNullSupported() {
    for (Entry<K, V> entry : getMap().entrySet()) {
      if (entry.getKey().equals(k0())) {

    private static final String TEST_SERVER = "server";
    private static final String TEST_ENDPOINT = "\\pipe\\test";

    @BeforeEach
    void setUp() throws IOException {
        // Setup mock behavior with lenient stubbing to avoid UnnecessaryStubbingException
        lenient().when(mockSmbNamedPipe.openPipe()).thenReturn(mockSmbPipeHandle);

  public void testForEachKnownOrder() {
    List<Entry<K, V>> entries = new ArrayList<>();
    getMap().forEach((k, v) -> entries.add(entry(k, v)));
    assertEquals(getOrderedElements(), entries);
  }

  @CollectionFeature.Require(absent = KNOWN_ORDER)
  public void testForEachUnknownOrder() {
    List<Entry<K, V>> entries = new ArrayList<>();
    getMap().forEach((k, v) -> entries.add(entry(k, v)));

            this.bytesRead = value;
        }

        public int getWordCount() {
            return wordCount;
        }
    }

    @BeforeEach
    void setUp() {
        MockitoAnnotations.openMocks(this);
        when(mockConfig.getPid()).thenReturn(12345);
    }

    @Nested
    @DisplayName("Constructor Tests")
    class ConstructorTests {

        @Test

public class BiMapInverseTester<K, V> extends AbstractBiMapTester<K, V> {

  public void testInverseSame() {
    assertSame(getMap(), getMap().inverse().inverse());
  }

  @CollectionFeature.Require(SERIALIZABLE)
  public void testInverseSerialization() {
    BiMapPair<K, V> pair = new BiMapPair<>(getMap());
    BiMapPair<K, V> copy = SerializableTester.reserialize(pair);
    assertEquals(pair.forward, copy.forward);

    @Mock
    private CrawlerContainer crawlerContainer;

    @Mock
    private SitemapsHelper sitemapsHelper;

    @Override
    protected void setUp() throws Exception {
        super.setUp();
        MockitoAnnotations.openMocks(this);
    }

    public void test_constructor() {
        // Test constructor
        SitemapsResponseProcessor proc = new SitemapsResponseProcessor();