List<String> strings = Arrays.asList(p, this.getProperty());
        int len = 0;
        for (String s: strings) {
            len += s.length();
            <% propertyCount.times { %>
            len += o.getProp${it}().length();
            <%}%>
        }
        return len>10;
    }
    <% } %>

    public ${productionClassName}(){
        this.property = null;
    }

        this.property = param;
    }

    public String getProperty() {
        return property;
    }
<% propertyCount.times { %>
    private String prop${it};

    public String getProp${it}() {
        return prop${it};
    }

    public void setProp${it}(String value) {
        prop${it} = value;
    }
<% } %>

                String getProp()
            }

            objects.newInstance(Thing)
"""

        expect:
        fails()
        failure.assertHasCause("Could not create an instance of type Thing.")
        failure.assertHasCause("Could not generate a decorated class for type Thing.")
        failure.assertHasCause("Cannot have abstract method Thing.getProp().")
    }

                T display
                String toString() { display.toString() }
            }

            abstract class ATask extends DefaultTask {
                @Input
                abstract ListProperty<$type> getProp()

                @TaskAction
                void go() {
                    println("prop = \${prop.get()}")
                }
            }

            tasks.create("thing", ATask) {

    }

    interface Params extends BuildServiceParameters {
        String getProp()

        void setProp(String value)
    }

    static abstract class ServiceImpl implements BuildService<Params> {
        static List<ServiceImpl> instances = []

        String getProp() {
            return getParameters().prop
        }

        static void reset() {

  // check values of `paddings` and `crops` to make sure it really stands for
  // a dilated conv.
  auto stb_paddings = stb_op.getPaddings();
  auto bts_crops = bts_op.getCrops();
  ElementsAttr stb_paddings_attr, bts_crops_attr;
  if (!matchPattern(stb_paddings, m_Constant(&stb_paddings_attr)) ||
      !matchPattern(bts_crops, m_Constant(&bts_crops_attr))) {
    return rewriter.notifyMatchFailure(

    }

    input_shape.assign(input_type.getShape().begin(),
                       input_type.getShape().end());
  }

  auto crops_type = mlir::cast<TensorType>(op.getCrops().getType());
  if (crops_type.hasRank()) {
    if (crops_type.getRank() != 2)
      return op.emitOpError()
             << "requires crops to be a 2D tensor, but got " << crops_type;

    auto input_shape = input_ty.getShape();

    DenseIntElementsAttr block_shape;
    DenseIntElementsAttr crops;
    if (!matchPattern(op.getBlockShape(), m_Constant(&block_shape)) ||
        !matchPattern(op.getCrops(), m_Constant(&crops))) {
      return failure();
    }

    auto block_shape_ty = block_shape.getType();
    if (!block_shape_ty.hasRank() || block_shape_ty.getRank() != 1) {
      return failure();

OS]});s.operator=s.operator?s.operator+m:m,f="operator",d=!1;break;case T.comment:if(f)if(d||b&&b[A.FIELDS.TYPE]===T.space||f==="insensitive"){var de=(0,Y.getProp)(s,"spaces",f,"after")||"",De=(0,Y.getProp)(s,"raws","spaces",f,"after")||de;(0,Y.ensureObject)(s,"raws","spaces",f),s.raws.spaces[f].after=De+m}else{var ee=s[f]||"",oe=(0,Y.getProp)(s,"raws",f)||ee;(0,Y.ensureObject)(s,"raws"),s.raws[f]=oe+m}else c=c+m;break;default:return this.error('Unexpected "'+m+'" found.',{index:p[A.FIELDS.START...