return caught;
      }
      throw new AssertionError(
          "expected to throw " + expectedThrowable.getSimpleName() + " but threw " + t, t);
    }
    if (userPassedSupplier) {
      throw new AssertionError(
          "expected to throw "
              + expectedThrowable.getSimpleName()
              + " but returned result: "
              + result);
    } else {

        return caught;
      }
      throw new AssertionError(
          "expected to throw " + expectedThrowable.getSimpleName() + " but threw " + t, t);
    }
    if (userPassedSupplier) {
      throw new AssertionError(
          "expected to throw "
              + expectedThrowable.getSimpleName()
              + " but returned result: "
              + result);
    } else {

            off += fragSize;
        }
        throw new IOException();
    }

    /**
     * @param msg
     * @param in
     * @param off
     * @param isDirect
     * @return
     * @throws IOException
     * @throws DcerpcException
     * @throws NdrException
     */
    private byte[] receiveMoreFragments(final DcerpcMessage msg, byte[] in) throws IOException, DcerpcException, NdrException {

    }

    @Test
    public void testFileBasedCacheConstructor() throws IOException {
        tempFile = File.createTempFile("test", ".tmp", Curl.tmpDir);
        ContentCache cache = new ContentCache(tempFile);

        assertNotNull(cache);
    }

    @Test
    public void testMemoryBasedCacheGetInputStream() throws IOException {
        String testContent = "Hello, World!";

    @Test
    @DisplayName("Test decode throws exception when length is too short")
    void testDecodeThrowsExceptionWhenLengthTooShort() {
        byte[] buffer = new byte[28];

        // Test with len = 23 (one byte too short)
        SMBProtocolDecodingException exception = assertThrows(SMBProtocolDecodingException.class, () -> response.decode(buffer, 0, 23),
                "Should throw exception when length < 24");

    public void test_FilePurgeVisitor_visitFileFailed() throws IOException {
        // Test that visitFileFailed doesn't throw exception
        // This is primarily a logging method, so we just verify no exception
        assertTrue(true);
    }

    // Test FilePurgeVisitor postVisitDirectory
    public void test_FilePurgeVisitor_postVisitDirectory() throws IOException {
        // Test empty directory deletion logic

        handle.sendrecv(rpc);
        if (rpc.retval != 0) {
            throw new SmbException(rpc.retval, false);
        }
    }

    /**
     * Closes this SAM domain handle.
     *
     * @throws IOException if an I/O error occurs during handle closure
     */
    public void close() throws IOException {
        final MsrpcSamrCloseHandle rpc = new MsrpcSamrCloseHandle(this);
        handle.sendrecv(rpc);

                throw de;
            }

            final MsrpcSamrConnect2 rpc2 = new MsrpcSamrConnect2(server, access, this);
            handle.sendrecv(rpc2);
        }
    }

    /**
     * Closes this SAM policy handle.
     *
     * @throws IOException if an I/O error occurs during handle closure
     */
    public void close() throws IOException {

        final MsrpcLookupSids rpc = new MsrpcLookupSids(policyHandle, sids);
        handle.sendrecv(rpc);
        switch (rpc.retval) {
        case 0:
        case NtStatus.NT_STATUS_NONE_MAPPED:
        case 0x00000107: // NT_STATUS_SOME_NOT_MAPPED
            break;
        default:
            throw new SmbException(rpc.retval, false);
        }

    }

    public void test_throwAndCatch() {
        // Test throwing and catching the exception
        String expectedMessage = "Thrown exception";

        try {
            throw new UnsupportedSearchException(expectedMessage);
            // fail("Exception was not thrown");
        } catch (UnsupportedSearchException e) {
            assertEquals(expectedMessage, e.getMessage());