// Then
        assertEquals(expiration, result);
        verify(mockReferralData).getExpiration();
    }

    @Test
    @DisplayName("Should get next referral")
    void testNext() {
        // Given
        DfsReferralData nextReferral = mock(DfsReferralData.class);
        when(mockReferralData.next()).thenReturn(nextReferral);

        // When

            assertDoesNotThrow(() -> concreteImplementation.stripPathConsumed(0));
        }

        @Test
        @DisplayName("Should return next referral data")
        void testNext() {
            // Test with mock
            when(mockReferralData.next()).thenReturn(mockReferralData);
            DfsReferralDataInternal next = mockReferralData.next();
            assertSame(mockReferralData, next);

            assertEquals(second, third.next());
            assertEquals(referralData, second.next());
        }

        @Test
        @DisplayName("Should handle next() correctly")
        void testNext() {
            DfsReferralDataImpl second = new DfsReferralDataImpl();
            referralData.append(second);

            DfsReferralDataImpl next = referralData.next();
            assertSame(second, next);

            mockContext.withCredentials(mock(Credentials.class));
            mockContext.renewCredentials("hint", new Exception());
        });
    }

    @Test
    @DisplayName("Should get SmbResource")
    void testGet() throws CIFSException {
        // Given
        String url = "smb://server/share/file";
        SmbResource mockResource = mock(SmbResource.class);
        when(mockContext.get(url)).thenReturn(mockResource);

    assertFalse(testTable.containsRow('A'));
  }

  public void testContainsValue() {
    assertTrue(testTable.containsValue("blah"));
    assertFalse(testTable.containsValue(""));
  }

  public void testGet() {
    assertEquals("blah", testTable.get('a', 1));
    assertNull(testTable.get('a', 2));
    assertNull(testTable.get('A', 1));
    assertNull(testTable.get('A', 2));
  }

  public void testIsEmpty() {

        assertFalse(concreteResponse.isVerifyFailed());

        // Test exception handling
        assertNull(concreteResponse.getException());
        Exception testEx = new RuntimeException("Test");
        concreteResponse.exception(testEx);
        assertEquals(testEx, concreteResponse.getException());

        // Test expiration
        assertNull(concreteResponse.getExpiration());

  public void testContainsKey() {
    boolean unused = create().containsKey(null);
  }

  public void testContainsValue() {
    boolean unused = create().containsValue(null);
  }

  public void testGet() {
    Object unused = create().get(null);
  }

  public void testPut() {
    create().put(null, null);
  }

  public void testPutAll() {
    create().putAll(new HashMap<String, Integer>());
  }

@SuppressWarnings("JUnit4ClassUsedInJUnit3")
public class ListSetTester<E> extends AbstractListTester<E> {
  @ListFeature.Require(SUPPORTS_SET)
  @CollectionSize.Require(absent = ZERO)
  public void testSet() {
    doTestSet(e3());
  }

  @CollectionSize.Require(absent = ZERO)
  @CollectionFeature.Require(ALLOWS_NULL_VALUES)
  @ListFeature.Require(SUPPORTS_SET)
  public void testSet_null() {
    doTestSet(null);

    assertTrue(table.containsValue('b'));
    assertTrue(table.containsValue('c'));
    assertFalse(table.containsValue('x'));
    assertFalse(table.containsValue(null));
  }

  public void testGet() {
    table = create("foo", 1, 'a', "bar", 1, 'b', "foo", 3, 'c');
    assertEquals((Character) 'a', table.get("foo", 1));
    assertEquals((Character) 'b', table.get("bar", 1));

        }

        @Test
        @DisplayName("Test read string length without termination throws exception")
        void testReadStringLengthNoTermination() {
            byte[] buffer = "TestTest".getBytes();

            assertThrows(RuntimeCIFSException.class, () -> {
                testBlock.readStringLength(buffer, 0, 3);
            });
        }
    }

    @Nested