try {
            jobHelper.register((ScheduledJob) null);
            fail("Should throw ScheduledJobException");
        } catch (ScheduledJobException e) {
            assertEquals("No job.", e.getMessage());
        } catch (Exception e) {
            // Expected due to missing dependencies in test environment
            assertTrue(true);
        }
    }

        DcerpcException exception = new DcerpcException(errorCode);

        assertEquals(errorCode, exception.getErrorCode(), "Error code should match the input.");
        assertTrue(exception.getMessage().contains("DCERPC_FAULT_ACCESS_DENIED"),
                "Message should contain the corresponding fault message.");
    }

    /**
     * Test constructor DcerpcException(int error) with an unknown error code.
     */

        assertEquals(SmbException.getStatusByCode(-1), e.getNtStatus());
        assertEquals(SmbException.getMessageByCode(-1), e.getMessage());
    }

    @Test
    void zeroCodeProducesSuccess() {
        SmbAuthException e = new SmbAuthException(0);
        assertEquals("NT_STATUS_SUCCESS", e.getMessage());
        assertEquals(SmbException.getStatusByCode(0), e.getNtStatus());
    }

    try {
      SerializableTester.reserializeAndAssert(orig);
      errorNotThrown = true;
    } catch (AssertionFailedError error) {
      // expected
      assertContains("must be Object#equals to", error.getMessage());
    }
    assertFalse(errorNotThrown);
  }

  public void testClassWhichIsAlwaysEqualButHasDifferentHashcodes() {
    ClassWhichIsAlwaysEqualButHasDifferentHashcodes orig =

        // Act & Assert: calling release without prior acquire drops usage below zero
        RuntimeException ex = assertThrows(RuntimeException.class, trace::release);
        assertTrue(ex.getMessage() != null && ex.getMessage().contains("Usage count dropped below zero"));
    }

    @Test
    @DisplayName("getTreeId(): no tree returns -1")
    void getTreeId_noTree_returnsMinusOne() {
        // Arrange

            fail("Should not throw exception: " + e.getMessage());
        }
    }

    public void test_sendMail_withEmptyInfoMap() {
        Map<String, String> infoMap = new HashMap<>();

        try {
            crawler.sendMail(infoMap);
        } catch (Exception e) {
            fail("Should not throw exception with empty map: " + e.getMessage());
        }
    }

        };

        try {
            errorHelper.getAvailableArtifacts(ArtifactType.DATA_STORE);
            fail("Expected PluginException");
        } catch (PluginException e) {
            assertTrue(e.getMessage().contains("Failed to access"));
        }
    }

    public void test_getInstalledArtifacts_unknown() {
        Artifact[] artifacts = pluginHelper.getInstalledArtifacts(ArtifactType.UNKNOWN);

        // Assert: type, message derived from code, status mapping, and no cause
        assertNotNull(ex);
        assertTrue(ex instanceof SmbException);
        assertEquals(SmbException.getMessageByCode(errCode), ex.getMessage(), "message should reflect error code mapping");
        assertEquals(expectedStatus, ex.getNtStatus(), "status should map based on code");
        assertNull(ex.getCause(), "cause must be null for int constructor");

        PACDecodingException exception = assertThrows(PACDecodingException.class, () -> new PacCredentialType(null));
        assertEquals("Invalid PAC credential type", exception.getMessage());
    }

    /**
     * Tests the constructor with a byte array that is too large.
     */
    @Test
    void testConstructorWithDataTooLarge() {

        doThrow(new CIFSException("session key failure")).when(session).getSessionKey();

        CIFSException ex = assertThrows(CIFSException.class, () -> session.getSessionKey());
        assertTrue(ex.getMessage().contains("failure"));
        verify(session).getSessionKey();
    }

    // Happy path: transport is returned and verified
    @Test
    @DisplayName("getTransport returns mocked transport")