public UpgradedProperty(String containingType, String propertyName, String methodName, String methodDescriptor, List<ReplacedAccessor> replacedAccessors) {
            this.containingType = containingType;
            this.propertyName = propertyName;
            this.methodName = methodName;
            this.methodDescriptor = methodDescriptor;
            this.replacedAccessors = replacedAccessors;

    }

    void checkIncludesExcludes(PatternFilterable patternSet, String methodName, String propertyName) {
        assert patternSet."$methodName"(TEST_PATTERN_1, TEST_PATTERN_2).is(patternSet)
        assert patternSet."$propertyName" == [TEST_PATTERN_1, TEST_PATTERN_2] as Set

        assert patternSet."$methodName"(TEST_PATTERN_3).is(patternSet)

        spec.isSatisfiedBy(_) >> { StackTraceElement elem -> elem.methodName.size() > 10 }

        when:
        def filtered = filter.filter(trace)

        then:
        filtered.size() > 0
        filtered.size() < trace.size()
        filtered == trace.findAll { StackTraceElement elem -> elem.methodName.size() > 10 }
    }

    def "filters stack trace in invocation order (bottom to top)"() {

            }
            String methodName = cells.get(0).getTextContent().trim();
            Collection<MethodMetaData> methods = classDoc.getClassMetaData().findDeclaredMethods(methodName);
            if (methods.isEmpty()) {
                throw new RuntimeException(String.format("No metadata for method '%s.%s()'. Available methods: %s", classDoc.getName(), methodName, classDoc.getClassMetaData().getDeclaredMethodNames()));

                }

                if (call.getMethod() instanceof ConstantExpression) {
                    ConstantExpression methodName = (ConstantExpression) call.getMethod();
                    if (isOfType(methodName, String.class)) {
                        String methodNameText = methodName.getText();
                        switch (methodNameText) {
                            case "alias":

        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"]

// Make sure that the compiler can analyze non-reflect
// Type.{Method,MethodByName} calls.

package p

type I interface {
	MethodByName(string)
	Method(int)
}

type M struct{}

func (M) MethodByName(string) {}
func (M) Method(int)          {}

func f() {
	var m M
	I.MethodByName(m, "")
	I.Method(m, 42)

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