* limitations under the License.
 */

package org.gradle.model;

import org.gradle.api.Named;

@Managed
public interface NamedThingInterface extends Named {
    String getOther();

    void setOther(String string);

        void setProp(Object value) {
        }
    }

    class SubClass extends SomeClass {
        Long other
    }

    interface SubInterface extends SomeInterface {
        Long getOther()

        void setOther(Long l)
    }

    abstract class AbstractSuperClass implements SomeInterface {
        Number prop
    }

  testrule > named(missingElement, $ElementRules.name)
    subject:
      - beans.missingElement NodeBackedModelMapSpec.Bean [*]
""")
    }

    static class SetOther extends RuleSource {
        @Mutate
        void set(SpecialBean bean, String other) {
            bean.other = other
            bean.value = "changed"
        }
    }

        Class methodWithValue(Number i) {
            return Number
        }
    }

    static class EnumBean {
        SomeEnum prop

        void setOther(String s) {
            prop = SomeEnum.valueOf(s)
        }

        void setOther(SomeEnum e) {
            prop = e
        }

        SomeEnum doThing(SomeEnum e) {
            e
        }

        SomeEnum doOtherThing(String s) {

// tag::property-type-boolean[]
  void setEmployed(boolean isEmployed)
  boolean isEmployed()
// end::property-type-boolean[]

// tag::property-type-managed[]
  void setMother(Person mother)
  Person getMother()
// end::property-type-managed[]

  void setFather(Person father)
  Person getFather()

// tag::property-type-managedset[]
  ModelSet<Person> getChildren()
// end::property-type-managedset[]

            error(methodShouldNotBeAnnotatedConfig { type('MyTask').kind('setter').method('setWriteOnly').annotation('Input') }, 'validation_problems', 'ignored_annotations_on_method'),

            PropertySetter setter = mutateUsingGetter(field);
            return AbstractOptionElement.of(optionName, option, setter, optionValueNotationParserFactory);
        }
        if (HasMultipleValues.class.isAssignableFrom(fieldType)) {
            PropertySetter setter = mutateUsingGetter(field);
            Class<?> elementType = setter.getRawType();

    private static final String DISABLE_NAME_PREFIX = "no-";
    private final PropertySetter setter;
    private final boolean newOptionValue;

    public BooleanOptionElement(String optionName, Option option, PropertySetter setter) {
        super(optionName, option, Void.TYPE, setter.getDeclaringClass());
        this.setter = setter;
        this.newOptionValue = true;
    }

    private final PropertySetter setter;
    private final NotationParser<CharSequence, ?> notationParser;

    public MultipleValueOptionElement(String optionName, Option option, Class<?> elementType, PropertySetter setter, OptionValueNotationParserFactory notationParserFactory) {
        super(optionName, option, List.class, setter.getDeclaringClass());
        this.setter = setter;

        if (setter.getRawType().equals(Boolean.class) || setter.getRawType().equals(Boolean.TYPE)) {
            return new BooleanOptionElement(optionName, option, setter);
        }
        if (setter.getRawType().equals(List.class)) {
            Class<?> elementType = ModelType.of(setter.getGenericType()).getTypeVariables().get(0).getRawClass();