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

        super(
                "Extension " + extension.getId() + " or one of its dependencies could not be resolved: "
                        + cause.getMessage(),
                cause);
        this.extension = extension;
    }

    public CoreExtension getExtension() {
        return extension;
    }

            return CommonsCliUpgradeOptions.parse(context.parserRequest.args().toArray(new String[0]));
        } catch (ParseException e) {
            throw new IllegalArgumentException("Failed to parse command line options: " + e.getMessage(), e);
        }
    }

                try {
                    throw new Exception("Checked exception");
                } catch (Exception e) {
                    throw new RuntimeException("Wrapped: " + e.getMessage(), e);
                }
            }
        };
        ComponentUtil.register(mockSearchLogHelper, "searchLogHelper");

        // Execute the job
        String result = aggregateLogJob.execute();

        try {
            validator.validatePath("\\share\\forbidden\\file.txt");
            fail("Should block blacklisted path");
        } catch (SmbException e) {
            assertTrue(e.getMessage().contains("not allowed"));
        }

        // Should allow other paths
        String allowed = validator.validatePath("\\share\\allowed\\file.txt");
        assertEquals("\\share\\allowed\\file.txt", allowed);

            SSLSocketFactory sslSocketFactory = getSSLSocketFactory(curlHelper);
            assertNull(sslSocketFactory);

        } catch (IOException e) {
            fail("Failed to create test certificate file: " + e.getMessage());
        } finally {
            if (invalidCertFile != null && invalidCertFile.exists()) {
                invalidCertFile.delete();
            }
        }
    }

    @Test

  @Override
  public final void tearDown() {
    try {
      sloppyTearDown();
    } catch (Throwable t) {
      logger.log(Level.INFO, "exception thrown during tearDown: " + t.getMessage(), t);
    }
  }

  public abstract void sloppyTearDown() throws Exception;

            // When & Then
            IOException thrown = assertThrows(IOException.class, () -> new Type2Message(invalidSignature));
            assertEquals("Not an NTLMSSP message.", thrown.getMessage());
        }

        @Test
        @DisplayName("Constructor with invalid message type should throw IOException")
        void testConstructor_ByteArray_InvalidMessageType() {
            // Given

            logger.debug("While recursing: " + e.getMessage(), e);
            result.addCircularDependencyException(e);
        } catch (OverConstrainedVersionException e) {
            logger.debug("While recursing: " + e.getMessage(), e);
            result.addVersionRangeViolation(e);
        } catch (ArtifactResolutionException e) {
            logger.debug("While recursing: " + e.getMessage(), e);

        }

        @Override
        public void add(ModelProblemCollectorRequest req) {
            if (!ModelProblem.Severity.WARNING.equals(req.getSeverity())) {
                result.addMessage(req.getMessage());
            }
        }
    }