findTestDescriptors(events.tests.collect { it.descriptor }, className, methodName, taskPath, displayName)
    }

    private static Collection<TestOperationDescriptor> findTestDescriptors(List<TestOperationDescriptor> descriptors, String className, String methodName = null, String taskpath = null, String displayName = null) {

     * Adds a method invocation statement to this block
     */
    void methodInvocation(@Nullable String comment, String methodName, Object... methodArgs);

    /**
     * Adds a method invocation statement to this block
     */
    void methodInvocation(@Nullable String comment, BuildScriptBuilder.Expression target, String methodName, Object... methodArgs);

    /**
     * Adds a statement to this block.
     */

            assert request.testClassNames == ["test"]
            assert request.testExecutionDescriptors == []

            assert request.getInternalJvmTestRequests().collect {[it.className, it.methodName]} == [["test", null]]

            launcher.withJvmTestClasses("test2")
            launcher.withTests(Stub(TestOperationDescriptor))

            assert request.testClassNames == ["test"]

        }
        then:
        assertTaskNotExecuted(":test")
        assertTaskExecuted(":secondTest")
        assertTestExecuted(className: "example.MyTest", methodName: "foo2", task: ":secondTest")
        assertTestNotExecuted(className: "example.MyTest", methodName: "foo")
    }

        )
    }

    private
    fun assertHasParameterNames(type: KClass<*>, methodName: String, parameterTypes: List<KClass<*>>, parameterNames: List<String>) {

        // java.lang.reflect
        val javaMethod = type.java.getDeclaredMethod(
            methodName,
            *parameterTypes.map { it.java }.toTypedArray()
        )
        assertThat(

        BytesClassLoader().loadClassFromBytes(bytes)

    fun instantiateAndCall(methodName: String): Any {
        val loadedClass = loadClass()
        val method = loadedClass.getMethod(methodName)
        val instance = loadedClass.getDeclaredConstructor().newInstance()
        return method.invoke(instance)
    }

    fun callStatic(methodName: String): Any {
        val loadedClass = loadClass()

    }

    /**
     * The returned scope includes calls to all methods named {@code methodName}.
     *
     * @param methodName the name of the method to intercept
     * @return the scope object
     */
    public static InterceptScope methodsNamed(String methodName) {
        return new NamedMemberScope(CallType.METHOD, methodName);
    }

    /**

 * limitations under the License.
 */

package org.gradle.nativeplatform.fixtures.app

class SwiftXCTestWithDepAndCustomXCTestSuite extends SwiftXCTest {
    String testSuiteName
    String methodName
    String assertion
    String[] imports
    String[] importsTestable

    SwiftXCTestWithDepAndCustomXCTestSuite(
        String projectName,
        String classToTest,
        String assertion,

    }

    private void registerBuildListener(String methodName, Closure<?> closure) {
        buildListenerBroadcast.add(new ClosureBackedMethodInvocationDispatch(methodName, closure));
    }

    private void registerBuildListener(String registrationPoint, String methodName, String signature, Action<? super Gradle> action) {

  }

  static void checkNoOverflow(boolean condition, String methodName, int a, int b) {
    if (!condition) {
      throw new ArithmeticException("overflow: " + methodName + "(" + a + ", " + b + ")");
    }
  }

  static void checkNoOverflow(boolean condition, String methodName, long a, long b) {
    if (!condition) {
      throw new ArithmeticException("overflow: " + methodName + "(" + a + ", " + b + ")");
    }
  }