Exception ex = assertThrows(Exception.class, handle::getSessionKey);
        assertTrue(
                ex.getMessage().contains("session fail") || (ex.getCause() != null && ex.getCause().getMessage().contains("session fail")));
    }

      actual = e;
    }
    assertNotNull("verify() should be able to cause test failure", actual);
    assertTrue(
        "AssertionError should have info about why test failed",
        actual.getCause().getMessage().contains(message));
  }

  public void testMissingException() {
    List<Integer> emptyList = new ArrayList<>();

    IteratorTester<Integer> tester =
        new IteratorTester<Integer>(

            } catch (final ClientAbortException e) {
                logger.debug("Client aborts this request.", e);
            }
        } catch (final Exception e) {
            if (!(e.getCause() instanceof ClientAbortException)) {
                throw new WebApiException(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, e);
            }
            logger.debug("Client aborts this request.", e);
        }
    }

            SerializableTester.reserialize(instance);
          } catch (Exception e) { // sneaky checked exception
            throw new AssertionError(
                "Serialization failed on return value of " + factory, e.getCause());
          }
        }
      }
      return this;
    }

    /**
     * Runs equals and serialization test on the return values.
     *

      assertTrue("setUp should have run", setUpRan.get());
      try {
        return method.invoke(map, args);
      } catch (InvocationTargetException e) {
        throw e.getCause();
      } catch (IllegalAccessException e) {
        throw newLinkageError(e);
      }
    }
  }

  /** Verifies that {@code setUp} and {@code tearDown} are called in all map test cases. */

         *
         * But for now, we use the value from the system property as our best guess.
         */
        return fromSystemProperty;
      } catch (InvocationTargetException e) {
        throwIfUnchecked(e.getCause()); // in case it's an Error or something
        return fromSystemProperty; // should be impossible
      } catch (NoSuchMethodException shouldBeImpossible) {
        return fromSystemProperty;

            // Act + Assert
            SmbException thrown = assertThrows(SmbException.class, () -> SmbEnumerationUtil.list(parent, "*", 0, null, null));
            assertSame(cifsEx, thrown.getCause());
        }
    }

    @Nested
    @DisplayName("DosFileFilter integration tests")
    class DosFileFilterTests {

        @Test

    checkNotNull(future);
    try {
      return getUninterruptibly(future);
    } catch (ExecutionException wrapper) {
      if (wrapper.getCause() instanceof Error) {
        throw new ExecutionError((Error) wrapper.getCause());
      }
      /*
       * It's an Exception. (Or it's a non-Error, non-Exception Throwable. From my survey of such

            execJob.testCreateSystemProperties(cmdList, invalidFile);
            fail("Should throw IORuntimeException");
        } catch (IORuntimeException e) {
            assertNotNull(e.getCause());
            assertTrue(e.getCause() instanceof IOException);
        }
    }

    // Test getLogName method
    public void test_getLogName() {
        // Test without suffix
        execJob.logSuffix = "";

              }
              throw new NoSuchFieldError("the Unsafe");
            }
          });
    } catch (PrivilegedActionException e) {
      throw new RuntimeException("Could not initialize intrinsics", e.getCause());
    }
  }