}
	AssertAssociationCount(t, user, "Languages", 1, "after replace with 1 map")

	var langs []Language
	if err := DB.Model(&user).Association("Languages").Find(&langs); err != nil {
		t.Fatalf("find languages after replace: %v", err)
	}
	if len(langs) != 1 || langs[0].Code != "rm2m_map_1" {
		t.Fatalf("expected only rm2m_map_1 after replace, got %+v", langs)
	}

      }

    /**
     * Process the response without even attempting to reading the request body. For HTTP/2 this
     * will close the response stream after the response body or trailers. For HTTP/1 this will
     * close the socket after the response body or trailers.
     */
    public fun doNotReadRequestBody(): Builder =
      apply {
        doNotReadRequestBody = true

        assertEquals("Success", result);
        assertEquals(6, attemptCount.get()); // Initial attempt + 5 retries
    }

    /**
     * Test: Retry logic fails after exceeding maxRetryCount
     * Verifies that the operation fails after maxRetryCount attempts
     */
    @Test
    public void testRetryLogicExceedsMaxRetryCount() {
        fesenClient.setMaxRetryCount(3);
        fesenClient.setRetryInterval(10L);

        assertFalse(target.isOpen());
        assertTrue(target.isStale());
    }

    @Test
    @DisplayName("getInput and getOutput throw after close")
    void testGetInputOutputAndClosed() throws CIFSException {
        // After closing the handle, further calls throw
        target.close();
        CIFSException e1 = assertThrows(SmbException.class, target::getInput);

   *
   * <p>If {@code !range.contains(k)}, {@link #get(Comparable) get(k)} will return the same result
   * before and after a call to {@code remove(range)}. If {@code range.contains(k)}, then after a
   * call to {@code remove(range)}, {@code get(k)} will return {@code null}.
   */
  void remove(Range<K> range);

  /**

   * this graph.
   *
   * <p>This is equal to the union of {@link #predecessors(Object)} and {@link #successors(Object)}.
   *
   * <p>If {@code node} is removed from the graph after this method is called, the {@code Set}
   * {@code view} returned by this method will be invalidated, and will throw {@code
   * IllegalStateException} if it is accessed in any way, with the following exceptions:
   *

  public void testPut_nullKeyUnsupported() {
    assertThrows(NullPointerException.class, () -> put(nullKeyEntry));
    expectUnchanged();
    expectNullKeyMissingWhenNullKeysUnsupported(
        "Should not contain null key after unsupported put(null, value)");
  }

  @MapFeature.Require({SUPPORTS_PUT, ALLOWS_NULL_VALUES})
  public void testPut_nullValueSupported() {
    assertNull("put(key, null) should return null", put(nullValueEntry));

        assertEquals(auth1, auth2);
        assertEquals(auth1.hashCode(), auth2.hashCode());

        // Test inequality with different password
        assertNotEquals(auth1, auth3);

        // Test after password wipe
        auth1.secureWipePassword();
        assertNotEquals(auth1, auth2);
    }

    /**
     * Test concurrent password access and wiping
     */
    @Test

        this.existPrePage = existPrePage;
    }

    /**
     * Checks if a next page exists after the current page.
     *
     * @return true if a next page exists, false otherwise
     */
    public boolean isExistNextPage() {
        return existNextPage;
    }

    /**
     * Sets whether a next page exists after the current page.
     *
     * @param existNextPage true if a next page exists, false otherwise

        assertTrue(output.contains("42"));
        assertTrue(output.contains("true"));

        // Test close
        logStream.close();
        // After close, the stream should not accept more writes
        // but PrintStream doesn't throw exceptions on write after close
    }

    @Test
    void testConcurrentAccess() throws InterruptedException {
        // Test thread safety of getInstance