IOException exception = assertThrows(IOException.class, () -> {
            packet.readTrailerWireFormat(bais, readBuffer, 0);
        });

        assertEquals("invalid session request wire format", exception.getMessage());
    }

    @ParameterizedTest
    @MethodSource("provideNamesForWriteTest")
    @DisplayName("writeTrailerWireFormat should handle various name combinations")

    Method method;
    try {
      method = extractMethod(test);
    } catch (IllegalArgumentException e) {
      logger.finer(Platform.format("%s: including by default: %s", test, e.getMessage()));
      return true;
    }
    if (suppressedTests.contains(method)) {
      logger.finer(Platform.format("%s: excluding because it was explicitly suppressed.", test));
      return false;
    }

                try {
                    result = interpolator.interpolate(result, recursionInterceptor);
                } catch (InterpolationException e) {
                    throw new ModelInterpolationException(e.getMessage(), e);
                }

                if (debug) {
                    List<Object> feedback = interpolator.getFeedback();
                    if (feedback != null && !feedback.isEmpty()) {

    }

    private ProjectBuildingException transformError(ProjectBuildingException e) {
        if (e.getCause() instanceof ModelBuildingException) {
            return new InvalidProjectModelException(e.getProjectId(), e.getMessage(), e.getPomFile());
        }

        return e;
    }

    @Override
    public MavenProject build(File pom, ProjectBuilderConfiguration configuration) throws ProjectBuildingException {

        final CmdLineParser parser = new CmdLineParser(options);
        try {
            parser.parseArgument(args);
        } catch (final CmdLineException e) {
            System.err.println(e.getMessage());
            System.err.println("java " + SuggestCreator.class.getCanonicalName() + " [options...] arguments...");
            parser.printUsage(System.err);
            return;
        }

        try {
            executeSuggestCreator();
        } catch (final Exception e) {
            logger.warn("Failed to create suggest data.", e);
            resultBuf.append(e.getMessage()).append("\n");
        } finally {
            if (timeoutTask != null && !timeoutTask.isCanceled()) {
                timeoutTask.cancel();
            }
        }

        return resultBuf.toString();

            } catch (final Throwable t) {
                logger.warn("Failed to create thumbnail: {} -> {} ({}:{})", thumbnailId, responseData.getUrl(),
                        t.getClass().getCanonicalName(), t.getMessage());
                if (logger.isDebugEnabled()) {
                    logger.debug("Details for failed thumbnail creation.", t);
                }
            } finally {
                if (!created) {

        IOException ex = assertThrows(IOException.class, stream::available, "Should convert SmbException to IOException");
        assertTrue(ex.getMessage().contains("boom"));
    }

    @Test
    @DisplayName("ensureTreeConnected delegates to handle")
    void ensureTreeConnected_delegates() throws Exception {

      Ints.checkedCast(value);
      fail("Cast to int should have failed: " + value);
    } catch (IllegalArgumentException ex) {
      assertWithMessage("%s not found in exception text: %s", value, ex.getMessage())
          .that(ex.getMessage().contains(String.valueOf(value)))
          .isTrue();
    }
  }

  // We need to test that our method behaves like the JDK method.
  @SuppressWarnings("InlineMeInliner")

                    Thread.currentThread().interrupt();
                    break;
                } catch (Exception e) {
                    log.debug("Error in async notification monitoring for {}: {}", registrationId, e.getMessage());

                    // Exponential backoff on errors: max 30 seconds, based on consecutive failures
                    try {