@Test
    @DisplayName("Construct with a valid configuration - should not throw")
    void testConstructionWithValidConfiguration() {
        assertDoesNotThrow(() -> new SmbComSeekResponse(mockConfig));
    }

    @Test
    @DisplayName("getOffset before any read - should return zero")
    void testOffsetInitiallyZero() {
        assertEquals(0L, response.getOffset(), "Offset should be initialized to 0");
    }

  @MapFeature.Require(SUPPORTS_PUT)
  public void testComputeIfAbsent_supportedAbsent() {
    assertEquals(
        "computeIfAbsent(notPresent, function) should return new value",
        v3(),
        getMap()
            .computeIfAbsent(
                k3(),
                k -> {
                  assertEquals(k3(), k);
                  return v3();

        // Then
        assertTrue(smb2Only, "Should delegate SMB2 only negotiation");
        assertFalse(secureNegotiate, "Should delegate secure negotiate requirement");
        assertTrue(ntlmTargetName, "Should delegate NTLM target name setting");
        assertFalse(port139Failover, "Should delegate port 139 failover setting");
        assertTrue(dfsStrictView, "Should delegate DFS strict view setting");

            assertNotNull(str, "toString should not return null");
            assertTrue(str.contains("SmbComTreeConnectAndXResponse"), "Should contain class name");
            assertTrue(str.contains("supportSearchBits=true"), "Should contain search bits flag");
            assertTrue(str.contains("shareIsInDfs=true"), "Should contain DFS flag");
            assertTrue(str.contains("service=IPC"), "Should contain service");

            caughtSpecific = true;
        } catch (RuntimeException e) {
            caughtRuntime = true;
        }

        assertTrue("Should have caught DictionaryExpiredException", caughtSpecific);
        assertFalse("Should not have caught as RuntimeException", caughtRuntime);
    }

    public void test_rethrow() {
        // Test rethrowing the exception

  public void testGet_yes() {
    assertEquals("get(present) should return the associated value", v0(), get(k0()));
  }

  public void testGet_no() {
    assertNull("get(notPresent) should return null", get(k3()));
  }

  @MapFeature.Require(ALLOWS_NULL_KEY_QUERIES)
  public void testGet_nullNotContainedButAllowed() {
    assertNull("get(null) should return null", get(null));
  }

    void testHasNextAlwaysReturnsFalse() {
        // When & Then
        assertFalse(emptyIterator.hasNext(), "hasNext should return false");
        assertFalse(emptyIterator.hasNext(), "hasNext should consistently return false");
        assertFalse(emptyIterator.hasNext(), "hasNext should always return false on repeated calls");
    }

    @Test
    @DisplayName("next should return null")

		expected    APIErrorCode
	}{
		// (0) Should error without a set URL query.
		{
			expected: ErrInvalidQueryParams,
		},
		// (1) Should error on an invalid access key.
		{
			queryParams: map[string]string{
				"Expires":        "60",
				"Signature":      "badsignature",
				"AWSAccessKeyId": "Z7IXGOO6BZ0REAN1Q26I",
			},
			expected: ErrInvalidAccessKeyID,
		},
		// (2) Should error with malformed expires.
		{

            // Then
            assertNotNull(uniBytes, "UNI bytes should not be null");
            assertNotNull(asciiBytes, "ASCII bytes should not be null");
            assertNotNull(oemBytes, "OEM bytes should not be null");
            assertEquals(0, uniBytes.length, "UNI bytes should be empty");
            assertEquals(0, asciiBytes.length, "ASCII bytes should be empty");

        // Should match with same values
        assertTrue(fileInfo.matches(1024L, 1000L, 0x20));

        // Should not match with different size
        assertFalse(fileInfo.matches(2048L, 1000L, 0x20));

        // Should not match with different last modified
        assertFalse(fileInfo.matches(1024L, 2000L, 0x20));

        // Should not match with different attributes