SomeChainingException exception = new SomeChainingException(new SomeChainingException(cause));
    assertSame(cause, getRootCause(exception));
  }

  public void testGetRootCause_loop() {
    Exception cause = new Exception();
    Exception exception = new Exception(cause);
    cause.initCause(exception);
    IllegalArgumentException expected =

    }

    // Test appendException method with nested exception
    public void test_appendException_nestedException() {
        StringBuilder buf = new StringBuilder();
        Exception cause = new IllegalArgumentException("Root cause");
        Exception exception = new RuntimeException("Wrapper exception", cause);

        monitorTarget.appendException(buf, exception);
        assertTrue(buf.toString().contains("Wrapper exception"));

    CaseInsensitiveMap<String> map;

    /**
     * @throws Exception
     */
    @Before
    public void setUp() throws Exception {
        map = new CaseInsensitiveMap<String>();
        map.put("one", "1");
        map.put("two", "2");
    }

    /**
     * @throws Exception
     */
    @After
    public void tearDown() throws Exception {
        map = null;
    }

    /**
     * @throws Exception

   *
   * @param exceptionType the exception type that triggers use of {@code fallback}. The exception
   *     type is matched against this step's exception. "This step's exception" means the cause of
   *     the {@link ExecutionException} thrown by {@link Future#get()} on the {@link Future}
   *     underlying this step or, if {@code get()} throws a different kind of exception, that

    MockCallback callback = new MockCallback(e);
    addCallback(f, callback, directExecutor());
  }

  public void testOnSuccessThrowsRuntimeException() throws Exception {
    RuntimeException exception = new RuntimeException();
    String result = "result";
    SettableFuture<String> future = SettableFuture.create();
    int[] successCalls = new int[1];
    int[] failureCalls = new int[1];

     * errors by throwing an {@link Exception}. Error conditions should provide
     * sufficient detail to aid troubleshooting.</p>
     *
     * @throws Exception if any issue occurs that prevents the successful execution
     *                   of the Mojo
     */
    void execute() throws Exception;

    assertEquals(key, result.get(1));
    assertEquals(key + suffix, cache.getUnchecked(key));
  }

  static <T> Callable<T> throwing(Exception exception) {
    return new Callable<T>() {
      @Override
      public T call() throws Exception {
        throw exception;
      }
    };
  }

    }

    public void test_serialVersionUID() {
        // Test that the exception is serializable
        ParseException parseException = new ParseException("Serialization test");
        QueryParseException queryParseException = new QueryParseException(parseException);

        // Verify that the exception can be created and has serialVersionUID
        assertNotNull(queryParseException);

import org.codelibs.core.beans.factory.BeanDescFactory;
import org.codelibs.core.exception.MethodNotFoundRuntimeException;
import org.junit.Test;

/**
 * @author higa
 * @author manhole
 */
public class BeanDescImplTest {

    /**
     * @throws Exception
     */
    @Test
    public void testPropertyDesc() throws Exception {
        final BeanDesc beanDesc = new BeanDescImpl(MyBean.class);

     *   close(is);
     * }
     * </pre>
     * <p>
     * If an exception occurs in the try block, there is a possibility that an exception will also occur in the finally block's {@link #close(Closeable)}. If the exception is thrown from the finally block, the original exception from the try block will be lost.
     * </p>
     *
     * @param closeable the closeable object
     * @see Closeable#close()
     */