context.info("Available goals:");
        context.indent();
        context.info("help  - display this help message");
        context.info("check - check for available upgrades");
        context.info("apply - apply available upgrades");
        context.unindent();
        context.println();
        context.info("Usage: mvnup [options] <goal>");
        context.println();
        context.info("Options:");
        context.indent();

        printStream.accept("Goals:");
        printStream.accept("  help  - display this help message");
        printStream.accept("  check - check for available upgrades");
        printStream.accept("  apply - apply available upgrades");
        printStream.accept("");
        printStream.accept("Options:");
        printStream.accept("  -m, --model-version <version> Target POM model version (4.0.0 or 4.1.0)");

       * [DIGEST], [PARALLEL] and [FORM].
       */
      fun setType(type: MediaType) =
        apply {
          require(type.type == "multipart") { "multipart != $type" }
          this.type = type
        }

      /** Add a part to the body. */
      fun addPart(body: RequestBody) =
        apply {
          addPart(Part.create(body))
        }

      /** Add a part to the body. */

                    continue;
                }

                boolean hasInferences = false;

                // Apply limited parent inference for all eligible models (4.0.0+)
                hasInferences |= applyLimitedParentInference(context, pomDocument);

                // Apply full inference optimizations only for 4.1.0+ models

            import org.gradle.api.internal.tasks.testing.TestResultProcessor

            plugins {
                id("gradlebuild.ci-reporting")
            }

            subprojects {
                apply(plugin = "gradlebuild.ci-reporting")
            }

            project(":failed-test-with-leftover").configureTestWithLeftover(false, true)
            project(":flaky-test-with-leftover").configureTestWithLeftover(true, true)

     */
    fun maxAge(maxAge: Duration) =
      apply {
        val maxAgeSeconds = maxAge.inWholeSeconds
        require(maxAgeSeconds >= 0) { "maxAge < 0: $maxAgeSeconds" }
        this.maxAgeSeconds = maxAgeSeconds.commonClampToInt()
      }

    fun maxStale(maxStale: Duration) =
      apply {
        val maxStaleSeconds = maxStale.inWholeSeconds

import org.junit.jupiter.api.Test;
import org.mockito.Mockito;

/**
 * Tests for {@link SmbFilenameFilter}. Since the interface only defines
 * a single method, the tests simply ensure that the lambda expression
 * correctly implements the method and that any exception is propagated.
 */
class SmbFilenameFilterTest {

    @Test
    void acceptReturnsTrueWhenNameMatches() throws Exception {

  @Override
  public ImmutableMap<K, V> getAll(Iterable<? extends K> keys) throws ExecutionException {
    return delegate().getAll(keys);
  }

  @Override
  public V apply(K key) {
    return delegate().apply(key);
  }

  @Override
  public void refresh(K key) {
    delegate().refresh(key);
  }

  /**

  - IMPORTANT NOTE: if the first import fails, you have to select and apply `Synchronization disabled`, then repeat the step above.
    Otherwise, TeamCity complains "Can't find the previous revision, please commit current settings first".
  - If anything bad happens, feel free to delete the project you created and retry (you may need to apply `Synchronization disabled` before deleting it).  
    

private
fun IntegrationTest.setUpAgentIfNeeded(testType: TestType, executer: String) {
    if (executer == "embedded") {
        // Apply the instrumentation agent to the test process when running integration tests with embedded Gradle executer.
        jvmArgumentProviders.add(project.objects.newInstance<AgentsClasspathProvider>().apply {
            agentsClasspath.from(project.configurations["${testType.prefix}TestAgentsClasspath"])
        })
    }