@Large
        void setSomething(String something) {}
    }


    def "ignores validation of generated Groovy methods"() {
        expect:
        assertProperties TypeWithGeneratedGroovyMethods, [someValue: [(TYPE): Large]]
    }

    @SuppressWarnings("GroovyUnusedDeclaration")
    private static class TypeWithGeneratedGroovyMethods {
        @Memoized
        @Large
        String getSomeValue() { "foo" }

            }
        """

        expect:
        fails('verify')
        failureCauseContains(message)

        where:
        key         | value         || message
        '(null)'    | "'someValue'" || 'Cannot get the value of a property of type java.util.Map with key type java.lang.String as the source contains a null key.'

    if (EqualsZero(op.getInputGateBias())) {
      auto none_value = rewriter.create<TFL::NoValueOp>(
          rewriter.getUnknownLoc(), rewriter.getNoneType(),
          rewriter.getUnitAttr());
      op.getInputGateBiasMutable().assign(none_value);
      return success();
    }

    if (EqualsZero(op.getProjectionBias())) {
      auto none_value = rewriter.create<TFL::NoValueOp>(

	Scope_WORKLOAD_SELECTOR Scope = 2
)

// Enum value maps for Scope.
var (
	Scope_name = map[int32]string{
		0: "GLOBAL",
		1: "NAMESPACE",
		2: "WORKLOAD_SELECTOR",
	}
	Scope_value = map[string]int32{
		"GLOBAL":            0,
		"NAMESPACE":         1,
		"WORKLOAD_SELECTOR": 2,
	}
)

func (x Scope) Enum() *Scope {
	p := new(Scope)
	*p = x
	return p
}

              }
              values {
                key: "varargs"
                value {
                  none_value {
                  }
                }
              }
              values {
                key: "varkw"
                value {
                  none_value {
                  }
                }
              }
              values {
                key: "defaults"

      auto size_value = rewriter.create<tensor::ExtractOp>(loc, sizes, indices);
      Value minus_one = rewriter.create<arith::IndexCastOp>(
          loc, shape_scalar_type,
          rewriter.create<arith::ConstantIndexOp>(loc, -1));
      auto is_minus_one = rewriter.create<arith::CmpIOp>(
          loc, arith::CmpIPredicate::eq, size_value, minus_one);
      Value end_value =

			obj: map[string]interface{}{
				"matchExpressions": []interface{}{
					map[string]interface{}{
						"key":      "tier",
						"operator": "Exists",
						"values":   []interface{}{"somevalue"},
					},
				},
			},
			schema: genMatchSelectorSchema(`self.matchExpressions.all(rule, (rule.operator != "Exists" && rule.operator != "DoesNotExist") || ((!has(rule.values) || size(rule.values) == 0)))`),