result.setVersion(subResult.getVersion());
                    result.setRepository(subResult.getRepository());
                    for (Exception exception : subResult.getExceptions()) {
                        result.addException(exception);
                    }
                }
            } else {
                String key = SNAPSHOT + getKey(artifact.getClassifier(), artifact.getExtension());

            assertFalse(response.isReceived()); // Should not be marked as received
        }

        @Test
        @DisplayName("Should handle exception")
        void testException() {
            Exception testException = new Exception("Test exception");

            response.exception(testException);

            assertTrue(response.isError());
            assertTrue(response.isReceived());

 */
@Deprecated(since = "4.0.0")
public class ToolchainsBuildingException extends Exception {

    private final List<Problem> problems;

    /**
     * Creates a new exception with the specified problems.
     *
     * @param problems The problems that cause this exception, must not be {@code null}.
     */
    public ToolchainsBuildingException(List<Problem> problems) {

            f.setAccessible(true);
            f.set(c, val);
        } catch (Exception e) {
            throw new AssertionError(e);
        }
    }

    // Helper to build a minimal smb URL
    private static URL smbUrl(String spec) throws Exception {
        return new URL(null, spec, new Handler());
    }

    @Test
    @DisplayName("getConfig returns context config")

        assertEquals(mockConfig, config, "Should return the mock Configuration object");
    }

    /**
     * Test for close() method.
     * Verifies that the close method can be called without throwing an exception.
     * @throws CIFSException
     */
    @Test
    void testClose() throws CIFSException {
        smbTreeHandle.close();
        // Verify that close() was called on the mock
        verify(smbTreeHandle).close();

import com.google.common.annotations.GwtCompatible;

/** Exception classes for use in tests. */
@GwtCompatible
final class TestExceptions {
  static final class SomeError extends Error {}

  static final class SomeCheckedException extends Exception {}

  static final class SomeOtherCheckedException extends Exception {}

  static final class YetAnotherCheckedException extends Exception {}

import org.jspecify.annotations.NullUnmarked;

/** Exception classes for use in tests. */
@GwtCompatible
@NullUnmarked
final class TestExceptions {
  static class SomeError extends Error {}

  static class SomeCheckedException extends Exception {}

  static class SomeOtherCheckedException extends Exception {}

  static class YetAnotherCheckedException extends Exception {}

     * parameter, or if the constructor or factory method throws exception.
     *
     * @return this tester
     */
    @CanIgnoreReturnValue
    @SuppressWarnings("CatchingUnchecked") // sneaky checked exception
    public FactoryMethodReturnValueTester testSerializable() throws Exception {
      for (Invokable<?, ?> factory : getFactoriesToTest()) {
        Object instance = instantiate(factory);

    private final ArtifactResolverResult result;

    /**
     * @param message the message for the exception
     * @param e the exception itself
     * @param result the resolution result containing detailed information
     */
    public ArtifactResolverException(String message, Exception e, ArtifactResolverResult result) {
        super(message, e);
        this.result = result;
    }

import org.codelibs.fess.crawler.entity.UrlQueue;
import org.codelibs.fess.crawler.exception.CrawlingAccessException;
import org.codelibs.fess.crawler.exception.MultipleCrawlingAccessException;
import org.codelibs.fess.crawler.helper.impl.LogHelperImpl;
import org.codelibs.fess.crawler.log.LogType;
import org.codelibs.fess.exception.ContainerNotAvailableException;
import org.codelibs.fess.helper.CrawlerStatsHelper.StatsAction;