assertEquals("2014-11-16T00:16:00Z", format.format(secondTestDate));
    }

    @Test
    public void testShouldNotThrowExceptionOnReferenceToNonExistentValue() throws Exception {
        Model model = new Model(org.apache.maven.api.model.Model.newBuilder()
                .scm(org.apache.maven.api.model.Scm.newBuilder()
                        .connection("${test}/somepath")

    verifyThreadWasNotInterrupted();
  }

  public void testFailed() throws Exception {
    Exception e = new Exception();
    TrustedListenableFutureTask<Integer> task =
        TrustedListenableFutureTask.create(
            new Callable<Integer>() {
              @Override
              public Integer call() throws Exception {
                throw e;
              }
            });
    task.run();

        Parameter parameter = new Parameter();
        parameter.setType("java.lang.String[]");
        parameter.setName("toAddresses");

        parameter.setRequired(true);

        PluginParameterException exception =
                new PluginParameterException(mojoDescriptor, Collections.singletonList(parameter));

        assertEquals(
                "One or more required plugin parameters are invalid/missing for 'goalPrefix:goal'" + LS

        String reference = "";
        if (!dejaVu.add(exception)) {
            return reference;
        }

        if (exception != null) {
            if (exception instanceof MojoExecutionException) {
                reference = MojoExecutionException.class.getSimpleName();

                Throwable cause = exception.getCause();

   *
   * @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

@NullUnmarked
public class SingleThreadAbstractFutureBenchmark {
  @Param Impl impl;

  private final Exception exception = new Exception();
  private Facade<?> notDoneFuture;

  @BeforeExperiment
  void setUp() throws Exception {
    notDoneFuture = impl.newFacade();
  }

  @Benchmark
  public long timeComplete_Normal(int reps) throws Exception {
    long r = 0;
    List<Facade<Integer>> list = new ArrayList<>(reps);

/**
 * Classes and futures used in {@link FuturesGetCheckedTest} and {@link FuturesGetUncheckedTest}.
 */
@GwtCompatible
@NullUnmarked
final class FuturesGetCheckedInputs {
  static final Exception CHECKED_EXCEPTION = new Exception("mymessage");
  static final Future<String> FAILED_FUTURE_CHECKED_EXCEPTION =
      immediateFailedFuture(CHECKED_EXCEPTION);
  static final RuntimeException UNCHECKED_EXCEPTION = new RuntimeException("mymessage");

But because of our changes in `GzipRequest.body`, the request body will be automatically decompressed when it is loaded by **FastAPI** when needed.

## Accessing the request body in an exception handler { #accessing-the-request-body-in-an-exception-handler }

/// tip

    }

    @Override
    @BeforeEach
    public void setUp() throws Exception {
        projectBuilder = getContainer().lookup(ProjectBuilder.class);
    }

    protected MavenProject getProject(Artifact pom, boolean allowStub) throws Exception {
        ProjectBuildingRequest configuration = new DefaultProjectBuildingRequest();

        }

        @Test
        void testGuice() throws Exception {
            List<Binding<ModelParser>> parsers =
                    container.lookup(Injector.class).findBindingsByType(TypeLiteral.get(ModelParser.class));
            assertNotNull(parsers);
            assertEquals(1, parsers.size());
        }

        @Test
        void testDI() throws Exception {
            DiInjected diInjected = new DiInjected();