/*
    * Licensed to the Apache Software Foundation (ASF) under one or more
    * contributor license agreements.  See the NOTICE file distributed with
    * this work for additional information regarding copyright ownership.
    * The ASF licenses this file to You under the Apache License, Version 2.0
    * (the "License"); you may not use this file except in compliance with
    * the License.  You may obtain a copy of the License at
    *
    *      https://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  package org.apache.commons.lang3.exception;
  
  import static org.apache.commons.lang3.LangAssertions.assertNullPointerException;
  import static org.junit.jupiter.api.Assertions.assertArrayEquals;
  import static org.junit.jupiter.api.Assertions.assertEquals;
  import static org.junit.jupiter.api.Assertions.assertFalse;
  import static org.junit.jupiter.api.Assertions.assertNotNull;
  import static org.junit.jupiter.api.Assertions.assertNotSame;
  import static org.junit.jupiter.api.Assertions.assertNull;
  import static org.junit.jupiter.api.Assertions.assertSame;
  import static org.junit.jupiter.api.Assertions.assertThrows;
  import static org.junit.jupiter.api.Assertions.assertTrue;
  
  import java.io.ByteArrayOutputStream;
  import java.io.IOException;
  import java.io.PrintStream;
  import java.io.PrintWriter;
  import java.io.StringWriter;
  import java.lang.reflect.Constructor;
  import java.lang.reflect.Modifier;
  import java.util.ArrayList;
  import java.util.List;
  import java.util.stream.Collectors;
  
  import org.apache.commons.lang3.AbstractLangTest;
  import org.apache.commons.lang3.test.NotVisibleExceptionFactory;
  import org.junit.jupiter.api.AfterEach;
  import org.junit.jupiter.api.BeforeEach;
  import org.junit.jupiter.api.Test;
  
  /**
   * Tests {@link org.apache.commons.lang3.exception.ExceptionUtils}.
   */
  class ExceptionUtilsTest extends AbstractLangTest {
  
      /**
       * Provides a method with a well known chained/nested exception
       * name which matches the full signature (e.g. has a return value
       * of {@code Throwable}).
       */
      private static final class ExceptionWithCause extends Exception {
          private static final long serialVersionUID = 1L;
  
          private Throwable cause;
  
          ExceptionWithCause(final String str, final Throwable cause) {
              super(str);
              setCause(cause);
          }
  
          ExceptionWithCause(final Throwable cause) {
              setCause(cause);
          }
  
          @Override
          public synchronized Throwable getCause() {
              return cause;
          }
  
          public void setCause(final Throwable cause) {
              this.cause = cause;
          }
      }
  
      /**
       * Provides a method with a well known chained/nested exception
       * name which does not match the full signature (e.g. lacks a
       * return value of {@code Throwable}).
       */
      private static final class ExceptionWithoutCause extends Exception {
          private static final long serialVersionUID = 1L;
  
          @SuppressWarnings("unused")
          public void getTargetException() {
              // noop
          }
      }
  
      // Temporary classes to allow the nested exception code to be removed
      // prior to a rewrite of this test class.
      private static final class NestableException extends Exception {
          private static final long serialVersionUID = 1L;
  
         @SuppressWarnings("unused")
         NestableException() {
         }
 
         NestableException(final Throwable t) {
             super(t);
         }
     }
 
     public static class TestThrowable extends Throwable {
         private static final long serialVersionUID = 1L;
     }
 
     private static int redeclareCheckedException() {
         return throwsCheckedException();
     }
 
     private static int throwsCheckedException() {
         try {
             throw new IOException();
         } catch (final Exception e) {
             ExceptionUtils.asRuntimeException(e);
             return -1;
         }
     }
 
     private ExceptionWithCause cyclicCause;
 
     private Throwable jdkNoCause;
 
     private NestableException nested;
 
     private Throwable notVisibleException;
 
     private Throwable withCause;
 
     private Throwable withoutCause;
 
     private Throwable createExceptionWithCause() {
         try {
             try {
                 throw new ExceptionWithCause(createExceptionWithoutCause());
             } catch (final Throwable t) {
                 throw new ExceptionWithCause(t);
             }
         } catch (final Throwable t) {
             return t;
         }
     }
 
     private Throwable createExceptionWithoutCause() {
         try {
             throw new ExceptionWithoutCause();
         } catch (final Throwable t) {
             return t;
         }
     }
 
     @BeforeEach
     public void setUp() {
         withoutCause = createExceptionWithoutCause();
         nested = new NestableException(withoutCause);
         withCause = new ExceptionWithCause(nested);
         jdkNoCause = new NullPointerException();
         final ExceptionWithCause a = new ExceptionWithCause(null);
         final ExceptionWithCause b = new ExceptionWithCause(a);
         a.setCause(b);
         cyclicCause = new ExceptionWithCause(a);
         notVisibleException = NotVisibleExceptionFactory.createException(withoutCause);
     }
 
     @AfterEach
     public void tearDown() {
         withoutCause = null;
         nested = null;
         withCause = null;
         jdkNoCause = null;
         cyclicCause = null;
         notVisibleException = null;
     }
 
     @Test
     void test_getMessage_Throwable() {
         Throwable th = null;
         assertEquals("", ExceptionUtils.getMessage(th));
 
         th = new IllegalArgumentException("Base");
         assertEquals("IllegalArgumentException: Base", ExceptionUtils.getMessage(th));
 
         th = new ExceptionWithCause("Wrapper", th);
         assertEquals("ExceptionUtilsTest.ExceptionWithCause: Wrapper", ExceptionUtils.getMessage(th));
     }
 
     @Test
     void test_getRootCauseMessage_Throwable() {
         Throwable th = null;
         assertEquals("", ExceptionUtils.getRootCauseMessage(th));
 
         th = new IllegalArgumentException("Base");
         assertEquals("IllegalArgumentException: Base", ExceptionUtils.getRootCauseMessage(th));
 
         th = new ExceptionWithCause("Wrapper", th);
         assertEquals("IllegalArgumentException: Base", ExceptionUtils.getRootCauseMessage(th));
     }
 
     @Test
     void testAsRuntimeException() {
         final Exception expected = new InterruptedException();
         assertSame(expected, assertThrows(Exception.class, () -> ExceptionUtils.asRuntimeException(expected)));
         assertNotSame(expected, assertThrows(Exception.class, () -> ExceptionUtils.asRuntimeException(new InterruptedException())));
         // API return typed to compile to Object
         assertThrows(expected.getClass(), () -> {
             @SuppressWarnings("unused")
             final Object retVal = ExceptionUtils.asRuntimeException(expected);
         });
         // API return typed to compile to RuntimeException
         assertThrows(expected.getClass(), () -> {
             @SuppressWarnings("unused")
             final RuntimeException retVal = ExceptionUtils.asRuntimeException(expected);
         });
         // API return typed to compile to RuntimeException subclass
         assertThrows(expected.getClass(), () -> {
             @SuppressWarnings("unused")
             final IllegalStateException retVal = ExceptionUtils.asRuntimeException(expected);
         });
     }
 
     @Test
     void testCatchTechniques() {
         IOException ioe = assertThrows(IOException.class, ExceptionUtilsTest::throwsCheckedException);
         assertEquals(1, ExceptionUtils.getThrowableCount(ioe));
 
         ioe = assertThrows(IOException.class, ExceptionUtilsTest::redeclareCheckedException);
         assertEquals(1, ExceptionUtils.getThrowableCount(ioe));
     }
 
     @Test
     void testConstructor() {
         assertNotNull(new ExceptionUtils());
         final Constructor<?>[] cons = ExceptionUtils.class.getDeclaredConstructors();
         assertEquals(1, cons.length);
         assertTrue(Modifier.isPublic(cons[0].getModifiers()));
         assertTrue(Modifier.isPublic(ExceptionUtils.class.getModifiers()));
         assertFalse(Modifier.isFinal(ExceptionUtils.class.getModifiers()));
     }
 
     @Test
     void testForEach_jdkNoCause() {
         final List<Throwable> throwables = new ArrayList<>();
         ExceptionUtils.forEach(jdkNoCause, throwables::add);
         assertEquals(1, throwables.size());
         assertSame(jdkNoCause, throwables.get(0));
     }
 
     @Test
     void testForEach_nested() {
         final List<Throwable> throwables = new ArrayList<>();
         ExceptionUtils.forEach(nested, throwables::add);
         assertEquals(2, throwables.size());
         assertSame(nested, throwables.get(0));
         assertSame(withoutCause, throwables.get(1));
     }
 
     @Test
     void testForEach_null() {
         final List<Throwable> throwables = new ArrayList<>();
         ExceptionUtils.forEach(null, throwables::add);
         assertEquals(0, throwables.size());
     }
 
     @Test
     void testForEach_recursiveCause() {
         final List<Throwable> throwables = new ArrayList<>();
         ExceptionUtils.forEach(cyclicCause, throwables::add);
         assertEquals(3, throwables.size());
         assertSame(cyclicCause, throwables.get(0));
         assertSame(cyclicCause.getCause(), throwables.get(1));
         assertSame(cyclicCause.getCause().getCause(), throwables.get(2));
     }
 
     @Test
     void testForEach_withCause() {
         final List<Throwable> throwables = new ArrayList<>();
         ExceptionUtils.forEach(withCause, throwables::add);
         assertEquals(3, throwables.size());
         assertSame(withCause, throwables.get(0));
         assertSame(nested, throwables.get(1));
         assertSame(withoutCause, throwables.get(2));
     }
 
     @Test
     void testForEach_withoutCause() {
         final List<Throwable> throwables = new ArrayList<>();
         ExceptionUtils.forEach(withoutCause, throwables::add);
         assertEquals(1, throwables.size());
         assertSame(withoutCause, throwables.get(0));
     }
 
     @SuppressWarnings("deprecation") // Specifically tests the deprecated methods
     @Test
     void testGetCause_Throwable() {
         assertSame(null, ExceptionUtils.getCause(null));
         assertSame(null, ExceptionUtils.getCause(withoutCause));
         assertSame(withoutCause, ExceptionUtils.getCause(nested));
         assertSame(nested, ExceptionUtils.getCause(withCause));
         assertSame(null, ExceptionUtils.getCause(jdkNoCause));
         assertSame(cyclicCause.getCause(), ExceptionUtils.getCause(cyclicCause));
         assertSame(cyclicCause.getCause().getCause(), ExceptionUtils.getCause(cyclicCause.getCause()));
         assertSame(cyclicCause.getCause(), ExceptionUtils.getCause(cyclicCause.getCause().getCause()));
         assertSame(withoutCause, ExceptionUtils.getCause(notVisibleException));
     }
 
     @SuppressWarnings("deprecation") // Specifically tests the deprecated methods
     @Test
     void testGetCause_ThrowableArray() {
         assertSame(null, ExceptionUtils.getCause(null, null));
         assertSame(null, ExceptionUtils.getCause(null, new String[0]));
 
         // not known type, so match on supplied method names
         assertSame(nested, ExceptionUtils.getCause(withCause, null));  // default names
         assertSame(null, ExceptionUtils.getCause(withCause, new String[0]));
         assertSame(null, ExceptionUtils.getCause(withCause, new String[]{null}));
         assertSame(nested, ExceptionUtils.getCause(withCause, new String[]{"getCause"}));
 
         // not known type, so match on supplied method names
         assertSame(null, ExceptionUtils.getCause(withoutCause, null));
         assertSame(null, ExceptionUtils.getCause(withoutCause, new String[0]));
         assertSame(null, ExceptionUtils.getCause(withoutCause, new String[]{null}));
         assertSame(null, ExceptionUtils.getCause(withoutCause, new String[]{"getCause"}));
         assertSame(null, ExceptionUtils.getCause(withoutCause, new String[]{"getTargetException"}));
     }
 
     @Test
     void testGetRootCause_Throwable() {
         assertSame(null, ExceptionUtils.getRootCause(null));
         assertSame(withoutCause, ExceptionUtils.getRootCause(withoutCause));
         assertSame(withoutCause, ExceptionUtils.getRootCause(nested));
         assertSame(withoutCause, ExceptionUtils.getRootCause(withCause));
         assertSame(jdkNoCause, ExceptionUtils.getRootCause(jdkNoCause));
         assertSame(cyclicCause.getCause().getCause(), ExceptionUtils.getRootCause(cyclicCause));
     }
 
     @Test
     void testGetRootCauseStackTrace_Throwable() {
         assertEquals(0, ExceptionUtils.getRootCauseStackTrace(null).length);
 
         final Throwable cause = createExceptionWithCause();
         String[] stackTrace = ExceptionUtils.getRootCauseStackTrace(cause);
         boolean match = false;
         for (final String element : stackTrace) {
             if (element.startsWith(ExceptionUtils.WRAPPED_MARKER)) {
                 match = true;
                 break;
             }
         }
         assertTrue(match);
 
         stackTrace = ExceptionUtils.getRootCauseStackTrace(withoutCause);
         match = false;
         for (final String element : stackTrace) {
             if (element.startsWith(ExceptionUtils.WRAPPED_MARKER)) {
                 match = true;
                 break;
             }
         }
         assertFalse(match);
     }
 
     @Test
     void testGetRootCauseStackTraceList_Throwable() {
         assertEquals(0, ExceptionUtils.getRootCauseStackTraceList(null).size());
 
         final Throwable cause = createExceptionWithCause();
         List<String> stackTrace = ExceptionUtils.getRootCauseStackTraceList(cause);
         boolean match = false;
         for (final String element : stackTrace) {
             if (element.startsWith(ExceptionUtils.WRAPPED_MARKER)) {
                 match = true;
                 break;
             }
         }
         assertTrue(match);
 
         stackTrace = ExceptionUtils.getRootCauseStackTraceList(withoutCause);
         match = false;
         for (final String element : stackTrace) {
             if (element.startsWith(ExceptionUtils.WRAPPED_MARKER)) {
                 match = true;
                 break;
             }
         }
         assertFalse(match);
     }
 
     @Test
     /** getStackFrames returns empty string array when the argument is null */
     void testgetStackFramesHappyPath() {
         final String[] actual = ExceptionUtils.getStackFrames(new Throwable() {
             private static final long serialVersionUID = 1L;
 
             // provide static stack trace to make test stable
             @Override
             public void printStackTrace(final PrintWriter s) {
                 s.write("org.apache.commons.lang3.exception.ExceptionUtilsTest$1\n" +
                     "\tat org.apache.commons.lang3.exception.ExceptionUtilsTest.testgetStackFramesGappyPath(ExceptionUtilsTest.java:706)\n" +
                     "\tat java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke0(Native Method)\n" +
                     "\tat com.intellij.rt.junit.JUnitStarter.prepareStreamsAndStart(JUnitStarter.java:230)\n" +
                     "\tat com.intellij.rt.junit.JUnitStarter.main(JUnitStarter.java:58)\n");
             }
         });
 
         assertArrayEquals(new String[]{
             "org.apache.commons.lang3.exception.ExceptionUtilsTest$1",
             "\tat org.apache.commons.lang3.exception.ExceptionUtilsTest.testgetStackFramesGappyPath(ExceptionUtilsTest.java:706)",
             "\tat java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke0(Native Method)",
             "\tat com.intellij.rt.junit.JUnitStarter.prepareStreamsAndStart(JUnitStarter.java:230)",
             "\tat com.intellij.rt.junit.JUnitStarter.main(JUnitStarter.java:58)"
         }, actual);
     }
 
     @Test
     /** getStackFrames returns the string array of the stack frames when there is a real exception */
     void testgetStackFramesNullArg() {
         final String[] actual = ExceptionUtils.getStackFrames((Throwable) null);
         assertEquals(0, actual.length);
     }
 
     @Test
     void testGetThrowableCount_Throwable() {
         assertEquals(0, ExceptionUtils.getThrowableCount(null));
         assertEquals(1, ExceptionUtils.getThrowableCount(withoutCause));
         assertEquals(2, ExceptionUtils.getThrowableCount(nested));
         assertEquals(3, ExceptionUtils.getThrowableCount(withCause));
         assertEquals(1, ExceptionUtils.getThrowableCount(jdkNoCause));
         assertEquals(3, ExceptionUtils.getThrowableCount(cyclicCause));
     }
 
     @Test
     void testGetThrowableList_Throwable_jdkNoCause() {
         final List<?> throwables = ExceptionUtils.getThrowableList(jdkNoCause);
         assertEquals(1, throwables.size());
         assertSame(jdkNoCause, throwables.get(0));
     }
 
     @Test
     void testGetThrowableList_Throwable_nested() {
         final List<?> throwables = ExceptionUtils.getThrowableList(nested);
         assertEquals(2, throwables.size());
         assertSame(nested, throwables.get(0));
         assertSame(withoutCause, throwables.get(1));
     }
 
     @Test
     void testGetThrowableList_Throwable_null() {
         final List<?> throwables = ExceptionUtils.getThrowableList(null);
         assertEquals(0, throwables.size());
     }
 
     @Test
     void testGetThrowableList_Throwable_recursiveCause() {
         final List<?> throwables = ExceptionUtils.getThrowableList(cyclicCause);
         assertEquals(3, throwables.size());
         assertSame(cyclicCause, throwables.get(0));
         assertSame(cyclicCause.getCause(), throwables.get(1));
         assertSame(cyclicCause.getCause().getCause(), throwables.get(2));
     }
 
     @Test
     void testGetThrowableList_Throwable_withCause() {
         final List<?> throwables = ExceptionUtils.getThrowableList(withCause);
         assertEquals(3, throwables.size());
         assertSame(withCause, throwables.get(0));
         assertSame(nested, throwables.get(1));
         assertSame(withoutCause, throwables.get(2));
     }
 
     @Test
     void testGetThrowableList_Throwable_withoutCause() {
         final List<?> throwables = ExceptionUtils.getThrowableList(withoutCause);
         assertEquals(1, throwables.size());
         assertSame(withoutCause, throwables.get(0));
     }
 
     @Test
     void testGetThrowables_Throwable_jdkNoCause() {
         final Throwable[] throwables = ExceptionUtils.getThrowables(jdkNoCause);
         assertEquals(1, throwables.length);
         assertSame(jdkNoCause, throwables[0]);
     }
 
     @Test
     void testGetThrowables_Throwable_nested() {
         final Throwable[] throwables = ExceptionUtils.getThrowables(nested);
         assertEquals(2, throwables.length);
         assertSame(nested, throwables[0]);
         assertSame(withoutCause, throwables[1]);
     }
 
     @Test
     void testGetThrowables_Throwable_null() {
         assertEquals(0, ExceptionUtils.getThrowables(null).length);
     }
 
     @Test
     void testGetThrowables_Throwable_recursiveCause() {
         final Throwable[] throwables = ExceptionUtils.getThrowables(cyclicCause);
         assertEquals(3, throwables.length);
         assertSame(cyclicCause, throwables[0]);
         assertSame(cyclicCause.getCause(), throwables[1]);
         assertSame(cyclicCause.getCause().getCause(), throwables[2]);
     }
 
     @Test
     void testGetThrowables_Throwable_withCause() {
         final Throwable[] throwables = ExceptionUtils.getThrowables(withCause);
         assertEquals(3, throwables.length);
         assertSame(withCause, throwables[0]);
         assertSame(nested, throwables[1]);
         assertSame(withoutCause, throwables[2]);
     }
 
     @Test
     void testGetThrowables_Throwable_withoutCause() {
         final Throwable[] throwables = ExceptionUtils.getThrowables(withoutCause);
         assertEquals(1, throwables.length);
         assertSame(withoutCause, throwables[0]);
     }
 
     @Test
     void testIndexOf_ThrowableClass() {
         assertEquals(-1, ExceptionUtils.indexOfThrowable(null, null));
         assertEquals(-1, ExceptionUtils.indexOfThrowable(null, NestableException.class));
 
         assertEquals(-1, ExceptionUtils.indexOfThrowable(withoutCause, null));
         assertEquals(-1, ExceptionUtils.indexOfThrowable(withoutCause, ExceptionWithCause.class));
         assertEquals(-1, ExceptionUtils.indexOfThrowable(withoutCause, NestableException.class));
         assertEquals(0, ExceptionUtils.indexOfThrowable(withoutCause, ExceptionWithoutCause.class));
 
         assertEquals(-1, ExceptionUtils.indexOfThrowable(nested, null));
         assertEquals(-1, ExceptionUtils.indexOfThrowable(nested, ExceptionWithCause.class));
         assertEquals(0, ExceptionUtils.indexOfThrowable(nested, NestableException.class));
         assertEquals(1, ExceptionUtils.indexOfThrowable(nested, ExceptionWithoutCause.class));
 
         assertEquals(-1, ExceptionUtils.indexOfThrowable(withCause, null));
         assertEquals(0, ExceptionUtils.indexOfThrowable(withCause, ExceptionWithCause.class));
         assertEquals(1, ExceptionUtils.indexOfThrowable(withCause, NestableException.class));
         assertEquals(2, ExceptionUtils.indexOfThrowable(withCause, ExceptionWithoutCause.class));
 
         assertEquals(-1, ExceptionUtils.indexOfThrowable(withCause, Exception.class));
         assertEquals(-1, ExceptionUtils.indexOfThrowable(withCause, Throwable.class));
     }
 
     @Test
     void testIndexOf_ThrowableClassInt() {
         assertEquals(-1, ExceptionUtils.indexOfThrowable(null, null, 0));
         assertEquals(-1, ExceptionUtils.indexOfThrowable(null, NestableException.class, 0));
 
         assertEquals(-1, ExceptionUtils.indexOfThrowable(withoutCause, null));
         assertEquals(-1, ExceptionUtils.indexOfThrowable(withoutCause, ExceptionWithCause.class, 0));
         assertEquals(-1, ExceptionUtils.indexOfThrowable(withoutCause, NestableException.class, 0));
         assertEquals(0, ExceptionUtils.indexOfThrowable(withoutCause, ExceptionWithoutCause.class, 0));
 
         assertEquals(-1, ExceptionUtils.indexOfThrowable(nested, null, 0));
         assertEquals(-1, ExceptionUtils.indexOfThrowable(nested, ExceptionWithCause.class, 0));
         assertEquals(0, ExceptionUtils.indexOfThrowable(nested, NestableException.class, 0));
         assertEquals(1, ExceptionUtils.indexOfThrowable(nested, ExceptionWithoutCause.class, 0));
 
         assertEquals(-1, ExceptionUtils.indexOfThrowable(withCause, null));
         assertEquals(0, ExceptionUtils.indexOfThrowable(withCause, ExceptionWithCause.class, 0));
         assertEquals(1, ExceptionUtils.indexOfThrowable(withCause, NestableException.class, 0));
         assertEquals(2, ExceptionUtils.indexOfThrowable(withCause, ExceptionWithoutCause.class, 0));
 
         assertEquals(0, ExceptionUtils.indexOfThrowable(withCause, ExceptionWithCause.class, -1));
         assertEquals(0, ExceptionUtils.indexOfThrowable(withCause, ExceptionWithCause.class, 0));
         assertEquals(-1, ExceptionUtils.indexOfThrowable(withCause, ExceptionWithCause.class, 1));
         assertEquals(-1, ExceptionUtils.indexOfThrowable(withCause, ExceptionWithCause.class, 9));
 
         assertEquals(-1, ExceptionUtils.indexOfThrowable(withCause, Exception.class, 0));
         assertEquals(-1, ExceptionUtils.indexOfThrowable(withCause, Throwable.class, 0));
     }
 
     @Test
     void testIndexOfType_ThrowableClass() {
         assertEquals(-1, ExceptionUtils.indexOfType(null, null));
         assertEquals(-1, ExceptionUtils.indexOfType(null, NestableException.class));
 
         assertEquals(-1, ExceptionUtils.indexOfType(withoutCause, null));
         assertEquals(-1, ExceptionUtils.indexOfType(withoutCause, ExceptionWithCause.class));
         assertEquals(-1, ExceptionUtils.indexOfType(withoutCause, NestableException.class));
         assertEquals(0, ExceptionUtils.indexOfType(withoutCause, ExceptionWithoutCause.class));
 
         assertEquals(-1, ExceptionUtils.indexOfType(nested, null));
         assertEquals(-1, ExceptionUtils.indexOfType(nested, ExceptionWithCause.class));
         assertEquals(0, ExceptionUtils.indexOfType(nested, NestableException.class));
         assertEquals(1, ExceptionUtils.indexOfType(nested, ExceptionWithoutCause.class));
 
         assertEquals(-1, ExceptionUtils.indexOfType(withCause, null));
         assertEquals(0, ExceptionUtils.indexOfType(withCause, ExceptionWithCause.class));
         assertEquals(1, ExceptionUtils.indexOfType(withCause, NestableException.class));
         assertEquals(2, ExceptionUtils.indexOfType(withCause, ExceptionWithoutCause.class));
 
         assertEquals(0, ExceptionUtils.indexOfType(withCause, Exception.class));
         assertEquals(0, ExceptionUtils.indexOfType(withCause, Throwable.class));
     }
 
     @Test
     void testIndexOfType_ThrowableClassInt() {
         assertEquals(-1, ExceptionUtils.indexOfType(null, null, 0));
         assertEquals(-1, ExceptionUtils.indexOfType(null, NestableException.class, 0));
 
         assertEquals(-1, ExceptionUtils.indexOfType(withoutCause, null));
         assertEquals(-1, ExceptionUtils.indexOfType(withoutCause, ExceptionWithCause.class, 0));
         assertEquals(-1, ExceptionUtils.indexOfType(withoutCause, NestableException.class, 0));
         assertEquals(0, ExceptionUtils.indexOfType(withoutCause, ExceptionWithoutCause.class, 0));
 
         assertEquals(-1, ExceptionUtils.indexOfType(nested, null, 0));
         assertEquals(-1, ExceptionUtils.indexOfType(nested, ExceptionWithCause.class, 0));
         assertEquals(0, ExceptionUtils.indexOfType(nested, NestableException.class, 0));
         assertEquals(1, ExceptionUtils.indexOfType(nested, ExceptionWithoutCause.class, 0));
 
         assertEquals(-1, ExceptionUtils.indexOfType(withCause, null));
         assertEquals(0, ExceptionUtils.indexOfType(withCause, ExceptionWithCause.class, 0));
         assertEquals(1, ExceptionUtils.indexOfType(withCause, NestableException.class, 0));
         assertEquals(2, ExceptionUtils.indexOfType(withCause, ExceptionWithoutCause.class, 0));
 
         assertEquals(0, ExceptionUtils.indexOfType(withCause, ExceptionWithCause.class, -1));
         assertEquals(0, ExceptionUtils.indexOfType(withCause, ExceptionWithCause.class, 0));
         assertEquals(-1, ExceptionUtils.indexOfType(withCause, ExceptionWithCause.class, 1));
         assertEquals(-1, ExceptionUtils.indexOfType(withCause, ExceptionWithCause.class, 9));
 
         assertEquals(0, ExceptionUtils.indexOfType(withCause, Exception.class, 0));
         assertEquals(0, ExceptionUtils.indexOfType(withCause, Throwable.class, 0));
     }
 
     @Test
     void testIsChecked_checked() {
         assertTrue(ExceptionUtils.isChecked(new IOException()));
     }
 
     @Test
     void testIsChecked_error() {
         assertFalse(ExceptionUtils.isChecked(new StackOverflowError()));
     }
 
     @Test
     void testIsChecked_null() {
         assertFalse(ExceptionUtils.isChecked(null));
     }
 
     @Test
     void testIsChecked_unchecked() {
         assertFalse(ExceptionUtils.isChecked(new IllegalArgumentException()));
     }
 
     @Test
     void testIsCheckedCustomThrowable() {
         assertTrue(ExceptionUtils.isChecked(new TestThrowable()));
     }
 
     @Test
     void testIsUnchecked_checked() {
         assertFalse(ExceptionUtils.isUnchecked(new IOException()));
     }
 
     @Test
     void testIsUnchecked_error() {
         assertTrue(ExceptionUtils.isUnchecked(new StackOverflowError()));
     }
 
     @Test
     void testIsUnchecked_null() {
         assertFalse(ExceptionUtils.isUnchecked(null));
     }
 
     @Test
     void testIsUnchecked_unchecked() {
         assertTrue(ExceptionUtils.isUnchecked(new IllegalArgumentException()));
     }
 
     @Test
     void testIsUnCheckedCustomThrowable() {
         assertFalse(ExceptionUtils.isUnchecked(new TestThrowable()));
     }
 
     @Test
     void testPrintRootCauseStackTrace_Throwable() {
         ExceptionUtils.printRootCauseStackTrace(null);
         // could pipe system.err to a known stream, but not much point as
         // internally this method calls stream method anyway
     }
 
     @Test
     void testPrintRootCauseStackTrace_ThrowableStream() {
         ByteArrayOutputStream out = new ByteArrayOutputStream(1024);
         ExceptionUtils.printRootCauseStackTrace(null, (PrintStream) null);
         ExceptionUtils.printRootCauseStackTrace(null, new PrintStream(out));
         assertEquals(0, out.toString().length());
         assertNullPointerException(() -> ExceptionUtils.printRootCauseStackTrace(withCause, (PrintStream) null));
         out = new ByteArrayOutputStream(1024);
         final Throwable cause = createExceptionWithCause();
         ExceptionUtils.printRootCauseStackTrace(cause, new PrintStream(out));
         String stackTrace = out.toString();
         assertTrue(stackTrace.contains(ExceptionUtils.WRAPPED_MARKER));
         out = new ByteArrayOutputStream(1024);
         ExceptionUtils.printRootCauseStackTrace(withoutCause, new PrintStream(out));
         stackTrace = out.toString();
         assertFalse(stackTrace.contains(ExceptionUtils.WRAPPED_MARKER));
     }
 
     @Test
     void testPrintRootCauseStackTrace_ThrowableWriter() {
         StringWriter writer = new StringWriter(1024);
         ExceptionUtils.printRootCauseStackTrace(null, (PrintWriter) null);
         ExceptionUtils.printRootCauseStackTrace(null, new PrintWriter(writer));
         assertEquals(0, writer.getBuffer().length());
         assertNullPointerException(() -> ExceptionUtils.printRootCauseStackTrace(withCause, (PrintWriter) null));
         writer = new StringWriter(1024);
         final Throwable cause = createExceptionWithCause();
         ExceptionUtils.printRootCauseStackTrace(cause, new PrintWriter(writer));
         String stackTrace = writer.toString();
         assertTrue(stackTrace.contains(ExceptionUtils.WRAPPED_MARKER));
         writer = new StringWriter(1024);
         ExceptionUtils.printRootCauseStackTrace(withoutCause, new PrintWriter(writer));
         stackTrace = writer.toString();
         assertFalse(stackTrace.contains(ExceptionUtils.WRAPPED_MARKER));
     }
 
     @Test
     void testRemoveCommonFrames_ListList() {
         assertNullPointerException(() -> ExceptionUtils.removeCommonFrames(null, null));
     }
 
     @Test
     void testRethrow() {
         final Exception expected = new InterruptedException();
         // API return typed to compile to Object
         assertThrows(expected.getClass(), () -> {
             @SuppressWarnings("unused")
             final Object retVal = ExceptionUtils.rethrow(expected);
         });
         // API return typed to compile to Object subclass
         assertThrows(expected.getClass(), () -> {
             @SuppressWarnings("unused")
             final String retVal = ExceptionUtils.rethrow(expected);
         });
         // API return typed to compile to primitive
         assertThrows(expected.getClass(), () -> {
             @SuppressWarnings("unused")
             final int retVal = ExceptionUtils.rethrow(expected);
         });
         //
         assertSame(expected, assertThrows(expected.getClass(), () -> ExceptionUtils.rethrow(expected)));
         assertNotSame(expected, assertThrows(expected.getClass(), () -> ExceptionUtils.rethrow(new InterruptedException())));
     }
 
     @Test
     void testStream_jdkNoCause() {
         assertEquals(1, ExceptionUtils.stream(jdkNoCause).count());
         assertSame(jdkNoCause, ExceptionUtils.stream(jdkNoCause).toArray()[0]);
     }
 
     @Test
     void testStream_nested() {
         assertEquals(2, ExceptionUtils.stream(nested).count());
         final Object[] array = ExceptionUtils.stream(nested).toArray();
         assertSame(nested, array[0]);
         assertSame(withoutCause, array[1]);
     }
 
     @Test
     void testStream_null() {
         assertEquals(0, ExceptionUtils.stream(null).count());
     }
 
     @Test
     void testStream_recursiveCause() {
         final List<?> throwables = ExceptionUtils.stream(cyclicCause).collect(Collectors.toList());
         assertEquals(3, throwables.size());
         assertSame(cyclicCause, throwables.get(0));
         assertSame(cyclicCause.getCause(), throwables.get(1));
         assertSame(cyclicCause.getCause().getCause(), throwables.get(2));
     }
 
     @Test
     void testStream_withCause() {
         final List<?> throwables = ExceptionUtils.stream(withCause).collect(Collectors.toList());
         assertEquals(3, throwables.size());
         assertSame(withCause, throwables.get(0));
         assertSame(nested, throwables.get(1));
         assertSame(withoutCause, throwables.get(2));
     }
 
     @Test
     void testStream_withoutCause() {
         final List<?> throwables = ExceptionUtils.stream(withoutCause).collect(Collectors.toList());
         assertEquals(1, throwables.size());
         assertSame(withoutCause, throwables.get(0));
     }
 
     @Test
     void testThrowableOf_ThrowableClass() {
         assertNull(ExceptionUtils.throwableOfThrowable(null, null));
         assertNull(ExceptionUtils.throwableOfThrowable(null, NestableException.class));
 
         assertNull(ExceptionUtils.throwableOfThrowable(withoutCause, null));
         assertNull(ExceptionUtils.throwableOfThrowable(withoutCause, ExceptionWithCause.class));
         assertNull(ExceptionUtils.throwableOfThrowable(withoutCause, NestableException.class));
         assertEquals(withoutCause, ExceptionUtils.throwableOfThrowable(withoutCause, ExceptionWithoutCause.class));
 
         assertNull(ExceptionUtils.throwableOfThrowable(nested, null));
         assertNull(ExceptionUtils.throwableOfThrowable(nested, ExceptionWithCause.class));
         assertEquals(nested, ExceptionUtils.throwableOfThrowable(nested, NestableException.class));
         assertEquals(nested.getCause(), ExceptionUtils.throwableOfThrowable(nested, ExceptionWithoutCause.class));
 
         assertNull(ExceptionUtils.throwableOfThrowable(withCause, null));
         assertEquals(withCause, ExceptionUtils.throwableOfThrowable(withCause, ExceptionWithCause.class));
         assertEquals(withCause.getCause(), ExceptionUtils.throwableOfThrowable(withCause, NestableException.class));
         assertEquals(withCause.getCause().getCause(), ExceptionUtils.throwableOfThrowable(withCause, ExceptionWithoutCause.class));
 
         assertNull(ExceptionUtils.throwableOfThrowable(withCause, Exception.class));
         assertNull(ExceptionUtils.throwableOfThrowable(withCause, Throwable.class));
     }
 
     @Test
     void testThrowableOf_ThrowableClassInt() {
         assertNull(ExceptionUtils.throwableOfThrowable(null, null, 0));
         assertNull(ExceptionUtils.throwableOfThrowable(null, NestableException.class, 0));
 
         assertNull(ExceptionUtils.throwableOfThrowable(withoutCause, null));
         assertNull(ExceptionUtils.throwableOfThrowable(withoutCause, ExceptionWithCause.class, 0));
         assertNull(ExceptionUtils.throwableOfThrowable(withoutCause, NestableException.class, 0));
         assertEquals(withoutCause, ExceptionUtils.throwableOfThrowable(withoutCause, ExceptionWithoutCause.class, 0));
 
         assertNull(ExceptionUtils.throwableOfThrowable(nested, null, 0));
         assertNull(ExceptionUtils.throwableOfThrowable(nested, ExceptionWithCause.class, 0));
         assertEquals(nested, ExceptionUtils.throwableOfThrowable(nested, NestableException.class, 0));
         assertEquals(nested.getCause(), ExceptionUtils.throwableOfThrowable(nested, ExceptionWithoutCause.class, 0));
 
         assertNull(ExceptionUtils.throwableOfThrowable(withCause, null));
         assertEquals(withCause, ExceptionUtils.throwableOfThrowable(withCause, ExceptionWithCause.class, 0));
         assertEquals(withCause.getCause(), ExceptionUtils.throwableOfThrowable(withCause, NestableException.class, 0));
         assertEquals(withCause.getCause().getCause(), ExceptionUtils.throwableOfThrowable(withCause, ExceptionWithoutCause.class, 0));
 
         assertEquals(withCause, ExceptionUtils.throwableOfThrowable(withCause, ExceptionWithCause.class, -1));
         assertEquals(withCause, ExceptionUtils.throwableOfThrowable(withCause, ExceptionWithCause.class, 0));
         assertNull(ExceptionUtils.throwableOfThrowable(withCause, ExceptionWithCause.class, 1));
         assertNull(ExceptionUtils.throwableOfThrowable(withCause, ExceptionWithCause.class, 9));
 
         assertNull(ExceptionUtils.throwableOfThrowable(withCause, Exception.class, 0));
         assertNull(ExceptionUtils.throwableOfThrowable(withCause, Throwable.class, 0));
     }
 
     @Test
     void testThrowableOfType_ThrowableClass() {
         assertNull(ExceptionUtils.throwableOfType(null, null));
         assertNull(ExceptionUtils.throwableOfType(null, NestableException.class));
 
         assertNull(ExceptionUtils.throwableOfType(withoutCause, null));
         assertNull(ExceptionUtils.throwableOfType(withoutCause, ExceptionWithCause.class));
         assertNull(ExceptionUtils.throwableOfType(withoutCause, NestableException.class));
         assertEquals(withoutCause, ExceptionUtils.throwableOfType(withoutCause, ExceptionWithoutCause.class));
 
         assertNull(ExceptionUtils.throwableOfType(nested, null));
         assertNull(ExceptionUtils.throwableOfType(nested, ExceptionWithCause.class));
         assertEquals(nested, ExceptionUtils.throwableOfType(nested, NestableException.class));
         assertEquals(nested.getCause(), ExceptionUtils.throwableOfType(nested, ExceptionWithoutCause.class));
 
         assertNull(ExceptionUtils.throwableOfType(withCause, null));
         assertEquals(withCause, ExceptionUtils.throwableOfType(withCause, ExceptionWithCause.class));
         assertEquals(withCause.getCause(), ExceptionUtils.throwableOfType(withCause, NestableException.class));
         assertEquals(withCause.getCause().getCause(), ExceptionUtils.throwableOfType(withCause, ExceptionWithoutCause.class));
 
         assertEquals(withCause, ExceptionUtils.throwableOfType(withCause, Exception.class));
         assertEquals(withCause, ExceptionUtils.throwableOfType(withCause, Throwable.class));
     }
 
     @Test
     void testThrowableOfType_ThrowableClassInt() {
         assertNull(ExceptionUtils.throwableOfType(null, null, 0));
         assertNull(ExceptionUtils.throwableOfType(null, NestableException.class, 0));
 
         assertNull(ExceptionUtils.throwableOfType(withoutCause, null));
         assertNull(ExceptionUtils.throwableOfType(withoutCause, ExceptionWithCause.class, 0));
         assertNull(ExceptionUtils.throwableOfType(withoutCause, NestableException.class, 0));
         assertEquals(withoutCause, ExceptionUtils.throwableOfType(withoutCause, ExceptionWithoutCause.class, 0));
 
         assertNull(ExceptionUtils.throwableOfType(nested, null, 0));
         assertNull(ExceptionUtils.throwableOfType(nested, ExceptionWithCause.class, 0));
         assertEquals(nested, ExceptionUtils.throwableOfType(nested, NestableException.class, 0));
         assertEquals(nested.getCause(), ExceptionUtils.throwableOfType(nested, ExceptionWithoutCause.class, 0));
 
         assertNull(ExceptionUtils.throwableOfType(withCause, null));
         assertEquals(withCause, ExceptionUtils.throwableOfType(withCause, ExceptionWithCause.class, 0));
         assertEquals(withCause.getCause(), ExceptionUtils.throwableOfType(withCause, NestableException.class, 0));
         assertEquals(withCause.getCause().getCause(), ExceptionUtils.throwableOfType(withCause, ExceptionWithoutCause.class, 0));
 
         assertEquals(withCause, ExceptionUtils.throwableOfType(withCause, ExceptionWithCause.class, -1));
         assertEquals(withCause, ExceptionUtils.throwableOfType(withCause, ExceptionWithCause.class, 0));
         assertNull(ExceptionUtils.throwableOfType(withCause, ExceptionWithCause.class, 1));
         assertNull(ExceptionUtils.throwableOfType(withCause, ExceptionWithCause.class, 9));
 
         assertEquals(withCause, ExceptionUtils.throwableOfType(withCause, Exception.class, 0));
         assertEquals(withCause, ExceptionUtils.throwableOfType(withCause, Throwable.class, 0));
     }
 
     @Test
     void testWrapAndUnwrapCheckedException() {
         final Throwable t = assertThrows(Throwable.class, () -> ExceptionUtils.wrapAndThrow(new IOException()));
         assertTrue(ExceptionUtils.hasCause(t, IOException.class));
     }
 
     @Test
     void testWrapAndUnwrapError() {
         final Throwable t = assertThrows(Throwable.class, () -> ExceptionUtils.wrapAndThrow(new OutOfMemoryError()));
         assertTrue(ExceptionUtils.hasCause(t, Error.class));
     }
 
     @Test
     void testWrapAndUnwrapRuntimeException() {
         final Throwable t = assertThrows(Throwable.class, () -> ExceptionUtils.wrapAndThrow(new IllegalArgumentException()));
         assertTrue(ExceptionUtils.hasCause(t, RuntimeException.class));
     }
 
     @Test
     void testWrapAndUnwrapThrowable() {
         final Throwable t = assertThrows(Throwable.class, () -> ExceptionUtils.wrapAndThrow(new TestThrowable()));
         assertTrue(ExceptionUtils.hasCause(t, TestThrowable.class));
     }
 }