assertEquals(middleCause, exception.getCause());
        assertEquals(innerCause, exception.getCause().getCause());
    }

    @Test
    public void test_throwAndCatch() {
        // Test throwing and catching the exception
        int expectedStatusCode = 403;
        String expectedMessage = "Access denied";

        try {
            throw new WebApiException(expectedStatusCode, expectedMessage);

        return getTasks().toString();
    }

    public List<Task> getTasks() {
        return tasks;
    }

    public boolean isAggregating() {
        return aggregating;
    }

    // TODO Consider throwing UnsupportedSomething on hashCode/equals

        assertEquals("Level 1", level3.getCause().getCause().getMessage());
    }

    @Test
    public void test_throwAndCatchException() {
        // Test throwing and catching the exception
        String expectedMessage = "Storage failure";

        try {
            throw new StorageException(expectedMessage);
        } catch (StorageException e) {

                foundTestMethod = true;
                break;
            }
        }
        assertTrue(foundTestMethod);
    }

    @Test
    public void test_throwAndCatch() {
        // Test throwing and catching the exception
        String message = "Throw and catch test";

        try {
            throw new SearchEngineClientException(message);
        } catch (SearchEngineClientException e) {

 */
package org.codelibs.core.exception;

import static org.codelibs.core.collection.ArrayUtil.asArray;

/**
 * Exception thrown when an argument is null.
 *
 * Intended to be used instead of throwing {@link NullPointerException}.
 *
 * @author wyukawa
 */
public class NullArgumentException extends ClIllegalArgumentException {

    /**
     *
     */

   * Future} need not be {@linkplain Future#isDone done}, making {@code AsyncFunction} suitable for
   * asynchronous derivations.
   *
   * <p>Throwing an exception from this method is equivalent to returning a failing {@code Future}.
   */
  ListenableFuture<O> apply(@ParametricNullness I input) throws Exception;

        assertTrue(exception instanceof Exception);
        assertTrue(exception instanceof Throwable);
    }

    @Test
    public void test_throwAndCatch() {
        // Test throwing and catching PluginException
        String expectedMessage = "Plugin loading failed";

        try {
            throw new PluginException(expectedMessage);
        } catch (PluginException e) {

        UserRoleLoginException exception = new UserRoleLoginException(RootAction.class);
        assertNull(exception.getCause());
    }

    @Test
    public void test_throwAndCatch() {
        // Test throwing and catching the exception
        try {
            throw new UserRoleLoginException(RootAction.class);
        } catch (UserRoleLoginException e) {
            assertEquals(RootAction.class, e.getActionClass());

    }

    @Test
    @DisplayName("constructor accepts null principal")
    void testConstructorWithNullPrincipal(@Mock HttpServletRequest mockRequest) {
        // Constructor accepts null principal without throwing exception
        NtlmHttpServletRequest request = new NtlmHttpServletRequest(mockRequest, null);

        // getRemoteUser() will throw NPE when trying to call getName() on null principal

   *     throw.
   */
  @CanIgnoreReturnValue
  static Error sneakyThrow(Throwable t) {
    throw new SneakyThrows<Error>().throwIt(t);
  }

  @SuppressWarnings("unchecked") // not really safe, but that's the point
  private Error throwIt(Throwable t) throws T {
    throw (T) t;
  }

  private SneakyThrows() {}