override fun configureTest(testTask: Test, sourceSetName: String) {
            val currentVersionUnderTest = extractTestTaskGradleVersion(testTask.name)
            currentVersionUnderTest?.apply {
                testTask.enabled = currentVersionEnabled(currentVersionUnderTest)
            }
        }

        private
        fun currentVersionEnabled(currentVersionUnderTest: String): Boolean {

	)
	waypointApplyCmd := &cobra.Command{
		Use:   "apply",
		Short: "Apply a waypoint configuration",
		Long:  "Apply a waypoint configuration to the cluster",
		Example: `  # Apply a waypoint to the current namespace
  istioctl waypoint apply

  # Apply a waypoint to a specific namespace and wait for it to be ready
  istioctl waypoint apply --namespace default --wait`,

      assertTrue(MoreFiles.isDirectory().apply(symlinkToDir));
      assertFalse(MoreFiles.isRegularFile().apply(symlinkToDir));

      assertFalse(MoreFiles.isDirectory().apply(symlinkToFile));
      assertTrue(MoreFiles.isRegularFile().apply(symlinkToFile));

      assertFalse(MoreFiles.isDirectory(NOFOLLOW_LINKS).apply(symlinkToDir));
      assertFalse(MoreFiles.isRegularFile(NOFOLLOW_LINKS).apply(symlinkToFile));
    }
  }

  )
  fun trustManager(): X509TrustManager = trustManager

  fun sslSocketFactory(): SSLSocketFactory = sslContext().socketFactory

  fun sslContext(): SSLContext {
    return Platform.get().newSSLContext().apply {
      init(arrayOf<KeyManager>(keyManager), arrayOf<TrustManager>(trustManager), SecureRandom())
    }
  }

  class Builder {
    private var heldCertificate: HeldCertificate? = null

  @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);
  }

  /**

      apply {
        this.pushObserver = pushObserver
      }

    fun pingIntervalMillis(pingIntervalMillis: Int) =
      apply {
        this.pingIntervalMillis = pingIntervalMillis
      }

    fun flowControlListener(flowControlListener: FlowControlListener) =
      apply {
        this.flowControlListener = flowControlListener
      }

    fun build(): Http2Connection {

**Affected product area (please put an X in all that apply)**

[ ] Ambient
[ ] Docs
[ ] Dual Stack
[ ] Installation
[ ] Networking
[ ] Performance and Scalability
[ ] Extensions and Telemetry
[ ] Security
[ ] Test and Release
[ ] User Experience
[ ] Developer Infrastructure

**Affected features (please put an X in all that apply)**

[ ] Multi Cluster
[ ] Virtual Machine
[ ] Multi Control Plane

public class FilteredMultimapTest extends TestCase {

  private static final Predicate<Entry<String, Integer>> ENTRY_PREDICATE =
      new Predicate<Entry<String, Integer>>() {
        @Override
        public boolean apply(Entry<String, Integer> entry) {
          return !"badkey".equals(entry.getKey()) && !((Integer) 55556).equals(entry.getValue());
        }
      };

  protected Multimap<String, Integer> create() {

    SSLContext.getInstance("TLS", provider)

  override fun platformTrustManager(): X509TrustManager {
    val trustManagers =
      TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm()).apply {
        init(null as KeyStore?)
      }.trustManagers!!
    check(trustManagers.size == 1 && trustManagers[0] is X509TrustManager) {
      "Unexpected default trust managers: ${trustManagers.contentToString()}"
    }

  - 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).