// Invalid first byte should be rejected by token parsing
        CIFSException ex = assertThrows(CIFSException.class, () -> ctx.initSecContext(new byte[] { firstByte }, 0, 1));
        assertEquals("Invalid token", ex.getMessage());

        // Ensure mechContext was not engaged due to early failure
        verify(this.mechContext, never()).initSecContext(any(), anyInt(), anyInt());
    }

    @Test

        target.close();
        CIFSException e1 = assertThrows(SmbException.class, target::getInput);
        assertTrue(e1.getMessage().contains("Already closed"));
        CIFSException e2 = assertThrows(SmbException.class, target::getOutput);
        assertTrue(e2.getMessage().contains("Already closed"));
    }

    @Test
    @DisplayName("ensureOpen throws after close() is called")

                buf.append(line);
            }
        } catch (final Exception e) {
            throwValidationError(messages -> messages.addErrorsFailedToReadRequestFile(GLOBAL, e.getMessage()),
                    () -> asListHtml(this::saveToken));
        }

        final CurlRequest curlRequest = getCurlRequest(header);
        if (curlRequest == null) {
            final String msg = header;

        try {
            transformer.transform(null);
            fail("Should throw CrawlingAccessException for null response");
        } catch (final CrawlingAccessException e) {
            assertTrue(e.getMessage().contains("No response body"));
        }
    }

    @Test
    public void test_transform_noResponseBody() {
        final ResponseData responseData = new ResponseData();

            provider.provide(null);
            fail("Should throw exception for null classification name");
        } catch (ProvidedClassificationNotFoundException e) {
            // expected
            assertTrue(e.getMessage().contains("Not found the classification: null"));
        } catch (NullPointerException e) {
            // Also acceptable if null is not handled explicitly
        }
    }

    @Test

        } catch (final LoginFailureException lfe) {
            if (logger.isInfoEnabled()) {
                logger.info("Login failed for user: username={}, reason={}", username, lfe.getMessage());
            }
            activityHelper.loginFailure(OptionalThing.of(new LocalUserCredential(username, password)));

        // Act & Assert
        IOException thrown = assertThrows(IOException.class, () -> {
            new LsaPolicyHandle(mockDcerpcHandle, server, access);
        });

        assertEquals("Network error", thrown.getMessage());
        verify(mockDcerpcHandle, times(1)).sendrecv(any(MsrpcLsarOpenPolicy2.class));
    }

    @Test
    void close_shouldClosePolicySuccessfully() throws IOException {
        // Arrange

        PACDecodingException e =
                assertThrows(PACDecodingException.class, () -> PacMac.calculateMac(PacSignature.KERB_CHECKSUM_HMAC_MD5, keys, TEST_DATA));
        assertEquals("Missing key", e.getMessage());
    }

    /**
     * Test calculateMac with an invalid algorithm type.
     */
    @Test
    void testCalculateMacInvalidAlgorithm() {
        Map<Integer, KerberosKey> keys = new HashMap<>();

    void testConstructorWithMessage() {
        String testMessage = "This is a test message for NdrException.";
        NdrException exception = new NdrException(testMessage);
        assertEquals(testMessage, exception.getMessage(), "The exception message should match the input message.");
    }

    /**
     * Test the NO_NULL_REF static field.
     * Ensures that the static field holds the expected string value.
     */
    @Test

     *
     * @param cause
     *            the cause
     */
    public UnsupportedEncodingRuntimeException(final UnsupportedEncodingException cause) {
        super("ECL0105", new Object[] { cause.getMessage() }, cause);
    }