for (Callable<T> task : tasks) {
      builder.add(wrapTask(task));
    }
    return builder.build();
  }

  // These methods wrap before delegating.
  @Override
  public final void execute(Runnable command) {
    delegate.execute(wrapTask(command));
  }

  @Override
  public final <T extends @Nullable Object> Future<T> submit(Callable<T> task) {
    return delegate.submit(wrapTask(checkNotNull(task)));
  }

Only the code prior to and including the `yield` statement is executed before creating a response:

{* ../../docs_src/dependencies/tutorial007.py hl[2:4] *}

The yielded value is what is injected into *path operations* and other dependencies:

{* ../../docs_src/dependencies/tutorial007.py hl[4] *}

The code following the `yield` statement is executed after creating the response but before sending it:

  $LAUNCHER_CLASS \
  $MAVEN_ARGS"
# Add remaining arguments with proper quoting
for arg in "$@"; do
    cmd="$cmd \"$arg\""
done

# Debug: print the command that will be executed
#echo "About to execute:"
#echo "$cmd"

 * {@link #shutDown} and also a {@link #runOneIteration} method that will be executed periodically.
 *
 * <p>This class uses the {@link ScheduledExecutorService} returned from {@link #executor} to run
 * the {@link #startUp} and {@link #shutDown} methods and also uses that service to schedule the
 * {@link #runOneIteration} that will be executed periodically as specified by its {@link

   * one of the listener's callbacks will execute at once. However, multiple listeners' callbacks
   * may execute concurrently, and listeners may execute in an order different from the one in which
   * they were registered.
   *
   * <p>RuntimeExceptions thrown by a listener will be caught and logged. Any exception thrown
   * during {@code Executor.execute} (e.g., a {@code RejectedExecutionException}) will be caught and

        String result1 = aggregateLogJob.execute();
        assertEquals("", result1);

        // Second call (even) should fail
        String result2 = aggregateLogJob.execute();
        assertTrue(result2.contains("Even call error"));

        // Third call (odd) should succeed
        String result3 = aggregateLogJob.execute();
        assertEquals("", result3);
    }

        scriptEngineFactory.add("type2", engine2);

        // Execute with first engine
        Object result1 = scriptExecutor.execute("type1", "script for engine1");
        assertEquals("engine1:processed: script for engine1", result1);

        // Execute with second engine
        Object result2 = scriptExecutor.execute("type2", "script for engine2");

        // Execute the job
        String result = purgeDocJob.execute();

        // Assert error message is in the result
        assertTrue(result.contains("Invalid argument provided"));
    }

    public void test_execute_queryBuilderCreation() {
        // Execute the job
        purgeDocJob.execute();

        // Verify the query builder was created correctly

        corsHandlerFactory.add(specificOrigin, specificHandler);
        corsHandlerFactory.add("*", wildcardHandler);

        // Execute & Verify - specific origin should return specific handler
        assertEquals(specificHandler, corsHandlerFactory.get(specificOrigin));

        // Execute & Verify - unknown origin should return wildcard handler
        assertEquals(wildcardHandler, corsHandlerFactory.get("https://unknown.com"));
    }

          .Builder()
          .url(server.url("/"))
          .build(),
      ).execute()
      .close()
    listener.removeUpToEvent<CallEnd>()
    val call =
      client.newCall(
        Request
          .Builder()
          .url(server.url("/"))
          .build(),
      )
    val response = call.execute()
    response.close()
    assertThat(listener.recordedEventTypes()).containsExactly(