group := action.GetResource().Group
	if len(group) == 0 {
		group = "core"
	}
	fmt.Fprintf(w, "[dryrun] Would perform action %s on resource %q in API group \"%s/%s\"\n", strings.ToUpper(action.GetVerb()), action.GetResource().Resource, group, action.GetResource().Version)

	namedAction, ok := action.(actionWithName)
	if ok {
		fmt.Fprintf(w, "[dryrun] Resource name: %q\n", namedAction.GetName())
	}

	}

	resource := attributes.GetResource()
	if subresource := attributes.GetSubresource(); len(subresource) > 0 {
		resource = resource + "/" + subresource
	}

	if ns := attributes.GetNamespace(); len(ns) > 0 {
		return fmt.Sprintf("User %q cannot %s resource %q in API group %q in the namespace %q", username, attributes.GetVerb(), resource, attributes.GetAPIGroup(), ns)
	}

        private final Method getter;
        private final Field field;
        private final Class<?> elementType;

        public PropertyFieldSetter(Method getter, Field field) {
            this(getter, field, ModelType.of(getter.getGenericReturnType()).getTypeVariables().get(0).getRawClass());
        }

        public PropertyFieldSetter(Method getter, Field field, Class<?> elementType) {

            dummyModel("otherValue"),
            [
                { it.value }
            ]
        )

        then:
        def error = thrown(AssertionError)
        error.message.contains("assert getter(actual) == getter(expected)")
        error.message.contains("       |      |       |  |")
        error.message.contains("       |      |       |  'otherValue'")
        error.message.contains("       'someValue'")
    }

            applyServiceInjectionToGetter(property, null, getter);
        }

        @Override
        public void applyServiceInjectionToGetter(PropertyMetadata property, @Nullable final Class<? extends Annotation> annotation, MethodMetadata getter) {

        return getters.map { (name, getter) ->
            checkNotNull(getter)
            val nameAfterGet = name.substringAfter("get")
            val propertyName = nameAfterGet.replaceFirstChar { it.lowercase(Locale.getDefault()) }
            val type = propertyValueType(getter.returnType).toDataTypeRefOrError()
            val isHidden = getter.annotations.any { it is HiddenInDeclarativeDsl }

	storage := map[string]rest.Storage{}

	// use a simple wrapper so that initialization order won't cause a nil getter
	var policyGetter rest.Getter

	r, err := resolver.NewDiscoveryResourceResolver(p.DiscoveryClient)
	if err != nil {
		return storage, err
	}

	// validatingwebhookconfigurations

        '''

        then:
        succeeds "echo"

        and:
        output.contains("name: foo")
    }

    def "managed type implemented as abstract class can have generative getters"() {
        when:
        buildScript '''
            @Managed
            abstract class Person {
                abstract String getFirstName()
                abstract void setFirstName(String firstName)

        builder.append(' ');
        builder.append(name);
        return builder.toString();
    }

    public MethodMetaData getGetter() {
        return getter;
    }

    public void setGetter(MethodMetaData getter) {
        this.getter = getter;
    }

    public MethodMetaData getSetter() {
        return setter;
    }

    public void setSetter(MethodMetaData setter) {
        this.setter = setter;

        } catch (final Exception e) {
            return keywords;
        }
        for (final TermQuery tq : termQueryList) {
            final String text = tq.getTerm().text();
            if ((0 == text.length()) || keywords.contains(text)) {
                continue;
            }
            keywords.add(text);
        }
        return keywords;
    }