inOrder.verify(creds, atLeastOnce()).isAnonymous();
    }

    @Test
    @DisplayName("isIPC is true for IPC$ or no share")
    void testIsIpc() {
        assertTrue(locator("smb://server/IPC$/").isIPC());
        assertTrue(locator("smb://server/").isIPC());
        assertFalse(locator("smb://server/share/").isIPC());
    }

    @Test

    Set<Entry<Integer, Character>> entrySet = row.entrySet();
    assertTrue(entrySet.contains(immutableEntry(10, 'X')));
    assertTrue(entrySet.contains(immutableEntry(20, 'X')));
    assertFalse(entrySet.contains(immutableEntry(15, 'X')));
    entrySet = row.tailMap(15).entrySet();
    assertFalse(entrySet.contains(immutableEntry(10, 'X')));
    assertTrue(entrySet.contains(immutableEntry(20, 'X')));

    byte[] dest = new byte[4];
    HashCode.fromInt(42).writeBytesTo(dest, 0, 4);
    assertTrue(Arrays.equals(HashCode.fromInt(42).asBytes(), dest));
  }

  public void testLongWriteBytesTo() {
    byte[] dest = new byte[8];
    HashCode.fromLong(42).writeBytesTo(dest, 0, 8);
    assertTrue(Arrays.equals(HashCode.fromLong(42).asBytes(), dest));
  }

  private static final HashCode HASH_ABCD =

        // Assert
        assertEquals("GET", ntlmConnection.getRequestMethod());
        assertTrue(ntlmConnection.getAllowUserInteraction());
        assertTrue(ntlmConnection.getDoInput());
        assertTrue(ntlmConnection.getDoOutput());
        assertEquals(12345L, ntlmConnection.getIfModifiedSince());
        assertFalse(ntlmConnection.getUseCaches());

        assertTrue(ex instanceof CIFSException, "Should be a CIFSException subtype");

        // Assert throwing/catching behavior with assertThrows
        SMBProtocolDecodingException thrown = assertThrows(SMBProtocolDecodingException.class, () -> {
            throw new SMBProtocolDecodingException();
        }, "Should be throwable via assertThrows");

        assertTrue(result >= 8);
        assertNotNull(response.getInfo());
    }

    @Test
    @DisplayName("Test inheritance from ServerMessageBlock2Response")
    void testInheritance() {
        response = new Smb2QueryInfoResponse(mockConfig, (byte) 1, (byte) 2);
        assertTrue(response instanceof ServerMessageBlock2Response);
        assertTrue(response instanceof ServerMessageBlock2);

        String log = MemoryUtil.getMemoryUsageLog();

        assertNotNull(log);
        assertTrue(log.startsWith("Mem:{used "));
        assertTrue(log.contains(", heap "));
        assertTrue(log.contains(", max "));
        assertTrue(log.endsWith("}"));

        // Verify format contains expected memory units
        assertTrue(log.matches(".*used [0-9.]+[a-zA-Z]+, heap [0-9.]+[a-zA-Z]+, max [0-9.]+[a-zA-Z]+.*"));
    }

            String result = referralData.toString();

            assertTrue(result.contains("DfsReferralData["));
            assertTrue(result.contains("pathConsumed=20"));
            assertTrue(result.contains("server=server.example.com"));
            assertTrue(result.contains("share=share"));
            assertTrue(result.contains("link=\\\\link\\target"));
            assertTrue(result.contains("path=folder"));

    assertEquals(Multisets.immutableEntry(k0(), 1), itr.next());
    itr.remove();
    assertTrue(multimap().isEmpty());
  }

  @CollectionSize.Require(SEVERAL)
  @MapFeature.Require(SUPPORTS_REMOVE)
  public void testKeysEntrySetRemove() {
    resetContainer(mapEntry(k0(), v0()), mapEntry(k0(), v1()), mapEntry(k1(), v0()));
    assertTrue(multimap().keys().entrySet().remove(Multisets.immutableEntry(k0(), 2)));

        TransWaitNamedPipe pipe = new TransWaitNamedPipe(pipeName);

        String result = pipe.toString();
        assertNotNull(result);
        assertTrue(result.contains("TransWaitNamedPipe"), "toString should contain class name");
        assertTrue(result.contains(pipeName), "toString should contain pipe name");
    }

    @Test
    public void testMultiplePipeNames() {
        // Test with various pipe names