cleanup [platform]: Add EelSource(limitLocalRunPlatform) argument to filter local execution by OS.

In some rare cases you need to filter your test by local OS. This hack gives this ability, but do not use it unless you know what you are doing.

GitOrigin-RevId: b70d2145a3be78d878ba0ca0572fe14bfe8866e0

Author: throwable-one

platform/testFramework/junit5/eel/test/params/api/EelHolder.kt

@@ -1,7 +1,6 @@
 // Copyright 2000-2026 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license.
 package com.intellij.platform.testFramework.junit5.eel.params.api
 
-import com.intellij.execution.target.EelTargetEnvironmentRequest
 import com.intellij.execution.target.TargetEnvironmentConfiguration
 import com.intellij.platform.eel.EelApi
 import com.intellij.testFramework.junit5.eel.EelFixtureFilter

platform/testFramework/junit5/eel/test/params/api/EelSource.kt

@@ -1,4 +1,4 @@
-// Copyright 2000-2025 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license.
+// Copyright 2000-2026 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license.
 package com.intellij.platform.testFramework.junit5.eel.params.api
 
 import com.intellij.platform.testFramework.junit5.eel.params.impl.junit5.EelArgumentsProvider
@@ -13,10 +13,12 @@ import kotlin.annotation.AnnotationTarget.VALUE_PARAMETER
 
 /**
  * Mark your parametrized test that accepts [EelHolder]
- * See [TestApplicationWithEel]
+ * See [TestApplicationWithEel].
+ *
+ * [limitLocalRunPlatform] is very special and highly unrecommended hack to skip local executions on various OSes.
  */
 @ArgumentsSource(EelArgumentsProvider::class)
 @CartesianArgumentsSource(EelCartesianArgumentsProvider::class)
 @TestOnly
 @Target(ANNOTATION_CLASS, VALUE_PARAMETER, CONSTRUCTOR, FUNCTION)
-annotation class EelSource
+annotation class EelSource(val limitLocalRunPlatform: TestPlatform = TestPlatform.ANY)

platform/testFramework/junit5/eel/test/params/api/TestPlatform.kt

@@ -0,0 +1,8 @@
+// Copyright 2000-2026 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license.
+package com.intellij.platform.testFramework.junit5.eel.params.api
+
+import com.intellij.execution.Platform
+
+enum class TestPlatform(internal val eelPlatform: Platform?) {
+  POSIX(Platform.UNIX), WINDOWS(Platform.WINDOWS), ANY(null)
+}

platform/testFramework/junit5/eel/test/params/impl/junit5/providersJUnit5.kt

@@ -1,15 +1,18 @@
-// Copyright 2000-2025 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license.
+// Copyright 2000-2026 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license.
 package com.intellij.platform.testFramework.junit5.eel.params.impl.junit5
 
+import com.intellij.execution.Platform
 import com.intellij.platform.testFramework.junit5.eel.params.api.EelHolder
 import com.intellij.platform.testFramework.junit5.eel.params.api.EelHolderImpl
+import com.intellij.platform.testFramework.junit5.eel.params.api.EelSource
 import com.intellij.platform.testFramework.junit5.eel.params.api.LocalEelHolder
 import com.intellij.platform.testFramework.junit5.eel.params.impl.providers.getIjentTestProviders
 import com.intellij.platform.testFramework.junit5.eel.params.spi.EelIjentTestProvider
 import org.jetbrains.annotations.TestOnly
 import org.junit.jupiter.api.extension.ExtensionContext
 import org.junit.jupiter.params.provider.Arguments
 import org.junit.jupiter.params.provider.ArgumentsProvider
+import org.junit.jupiter.params.support.ParameterDeclarations
 import org.junit.platform.commons.util.AnnotationUtils
 import org.junitpioneer.jupiter.cartesian.CartesianParameterArgumentsProvider
 import java.lang.reflect.AnnotatedElement
@@ -19,31 +22,42 @@ import kotlin.jvm.optionals.getOrElse
 
 @TestOnly
 internal class EelArgumentsProvider : ArgumentsProvider {
-  override fun provideArguments(context: ExtensionContext): Stream<out Arguments> =
-    getProvidersAsStream(context).map(Arguments::of)
+  override fun provideArguments(
+    parameters: ParameterDeclarations,
+    context: ExtensionContext,
+  ): Stream<out Arguments> =
+    getProvidersAsStream(context, parameters.sourceElement).map(Arguments::of)
 }
 
 @TestOnly
 internal class EelCartesianArgumentsProvider : CartesianParameterArgumentsProvider<EelHolder> {
   override fun provideArguments(
     context: ExtensionContext,
     parameter: Parameter,
-  ): Stream<EelHolder> = getProvidersAsStream(context)
+  ): Stream<EelHolder> = getProvidersAsStream(context, parameter)
 }
 
 @TestOnly
-private fun getProvidersAsStream(context: ExtensionContext): Stream<EelHolder> {
-  val providers: Array<EelHolder> = arrayOf<EelHolder>(LocalEelHolder) + getIjentTestProviders().flatMap { provider ->
+private fun getProvidersAsStream(context: ExtensionContext, eelHolderElem: AnnotatedElement): Stream<EelHolder> {
+  // parametrized classes might not have EelSource
+  val limitLocalPlatform = eelHolderElem.getAnnotation(EelSource::class.java)?.limitLocalRunPlatform?.eelPlatform
+  val allowLocal = limitLocalPlatform == null || limitLocalPlatform == Platform.current()
 
-    val annotatedElement: AnnotatedElement = arrayOf(context.testMethod, context.testClass).first { it.isPresent }.getOrElse {
-      error("No method nor class has ${EelHolder::class} argument")
-    }
-    createHolders(provider, annotatedElement)
+  // method or class might have mandatory (e.g. WslTest) annotation
+  val elemForMandatoryAnno: AnnotatedElement = arrayOf(context.testMethod, context.testClass).first { it.isPresent }.getOrElse {
+    error("No method nor class has ${EelHolder::class} argument")
+  }
+  val localProvider: Array<EelHolder> = if (allowLocal) arrayOf(LocalEelHolder) else emptyArray<EelHolder>()
+  val providers: Array<EelHolder> = localProvider + getIjentTestProviders().flatMap { provider ->
+    createHolders(provider, elemForMandatoryAnno)
   }.toTypedArray<EelHolder>()
   return Stream.of(*providers)
 }
 
-private fun <T : Annotation> createHolders(provider: EelIjentTestProvider<T>, annotatedElement: AnnotatedElement): List<EelHolderImpl<T>> {
+private fun <T : Annotation> createHolders(
+  provider: EelIjentTestProvider<T>,
+  annotatedElement: AnnotatedElement,
+): List<EelHolderImpl<T>> {
   val annotations =
     AnnotationUtils.findRepeatableAnnotations(annotatedElement, provider.mandatoryAnnotationClass.java)
   return if (annotations.isEmpty()) {