BundleTaskExtension::class.java,
        this,
      )
    val osgiApiArtifacts = osgiApi.artifacts
    val jvmMainClasses = tasks.named("jvmMainClasses").map { it.outputs.files }
    bundleExtension.apply {
      classpath(osgiApiArtifacts)
      classpath(jvmMainClasses)
      properties.empty()
      bnd(*bndProperties)
    }
    doLast("buildBundle", BndBuildAction(bundleExtension, this, mainSourceSet.allSource))
  }

) {
  @RegisterExtension
  val platform = PlatformRule()

  @RegisterExtension
  val clientTestRule = OkHttpClientTestRule()

  @StartStop
  private val server =
    MockWebServer().apply {
      protocols = listOf(protocol)
    }

  private var client =
    clientTestRule
      .newClientBuilder()
      .protocols(listOf(protocol))
      .build()

  @Test
  fun largeStatusLine() {

                if (!this.filter.accept(nr)) {
                    continue;
                }
                return nr;
            } catch (final CIFSException e) {
                log.error("Failed to apply filter", e);
                continue;
            } catch (final MalformedURLException e) {
                log.error("Failed to create child URL", e);
                continue;
            }
        }

        help.execute(context);

        // Verify that the --all option is mentioned with correct description
        Mockito.verify(context.logger)
                .info(
                        "  -a, --all             Apply all upgrades (equivalent to --model-version 4.1.0 --infer --model --plugins)");
    }

    @Test
    void testHelpIncludesDefaultBehavior() throws Exception {
        UpgradeContext context = createMockContext();

  cache: Cache,
  request: Request,
): Response? = cache.get(request)

internal fun applyConnectionSpec(
  connectionSpec: ConnectionSpec,
  sslSocket: SSLSocket,
  isFallback: Boolean,
) = connectionSpec.apply(sslSocket, isFallback)

internal fun ConnectionSpec.effectiveCipherSuites(socketEnabledCipherSuites: Array<String>): Array<String> =
  if (cipherSuitesAsString != null) {
    // 3 options here for ordering

    new ForwardingWrapperTester()
        .testForwarding(
            Collection.class,
            new Function<Collection, Collection>() {
              @Override
              public Collection apply(Collection delegate) {
                return wrap(delegate);
              }
            });
  }

  private static <T> Collection<T> wrap(Collection<T> delegate) {
    return new ForwardingCollection<T>() {

  public void testForwarding() {
    new ForwardingWrapperTester()
        .testForwarding(
            Queue.class,
            new Function<Queue, Queue>() {
              @Override
              public Queue apply(Queue delegate) {
                return wrap(delegate);
              }
            });
  }

  private static <T> Queue<T> wrap(Queue<T> delegate) {
    return new ForwardingQueue<T>() {
      @Override

        if (bwcVersions != null) {
            project.getExtensions().getExtraProperties().set("bwcVersions", bwcVersions);
        }
        project.getPlugins().apply("elasticsearch.distribution-download");
        return project;
    }

## Global Dependencies { #global-dependencies }

import java.util.Set;

/**
 * Filter to only retain objects in the given scope or better. This implementation allows the accumulation of multiple
 * scopes and their associated implied scopes, so that the user can filter apply a series of implication rules in a
 * single step. This should be a more efficient implementation of multiple standard {@link ScopeArtifactFilter}
 * instances ORed together.
 *
 */