this.testKind = testKind;
        this.suiteName = suiteName;
        this.className = className;
        this.methodName = methodName;
        this.parentId = parentId;
        this.taskPath = taskPath;
    }

    @Override
    public OperationIdentifier getId() {
        return id;
    }

    @Override
    public String getName() {
        return operationName;
    }

    @Override

        String methodName = propertyType.substring(0, 1).toLowerCase() + propertyType.substring(1)

        """
            public class SampleTask extends DefaultTask {
                @Internal
                @Option(option = "myProp", description = "Configures command line option 'myProp'.")
                final $propertyType<$optionType> myProp = project.objects.$methodName($optionType)

        return new DefaultTestDescriptor(id, className(description), methodName(description));
    }

    private static TestDescriptorInternal nullSafeDescriptor(Object id, Description description) {
        String methodName = methodName(description);
        if (methodName != null) {
            return new DefaultTestDescriptor(id, className(description), methodName);
        } else {

        declaringClass = ste.getClassName();
        methodName = ste.getMethodName();
        fileName = ste.getFileName();
        lineNumber = ste.getLineNumber();
    }

    public StackTraceElement toStackTraceElement() {
        if (JavaVersion.current().isJava9Compatible()) {
            return new StackTraceElement(classLoaderName, moduleName, moduleVersion, declaringClass, methodName, fileName, lineNumber);
        } else {

  }

  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 + ")");
    }
  }

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