// per image stored in the node status.
	MaxNamesPerImageInNodeStatus = 5
)

// Setter modifies the node in-place, and returns an error if the modification failed.
// Setters may partially mutate the node before returning an error.
type Setter func(ctx context.Context, node *v1.Node) error

// NodeAddress returns a Setter that updates address-related information on the node.

    }

    def "picks the generic object setter if the typed setter does not match the value type"() {
        when:
        def property = writeableProperty(JavaTestSubject, "myProperty", File.class)

        then:
        property.type == Object.class
    }

    def "picks the typed setter if it is the better match"() {
        when:

		n := field.name
		help := configHelp[n]
		var setter func()
		switch ptr := cfg.fieldPtr(field).(type) {
		case *bool:
			f := flag.Bool(n, *ptr, help)
			setter = func() { *ptr = *f }
		case *int:
			f := flag.Int(n, *ptr, help)
			setter = func() { *ptr = *f }
		case *float64:
			f := flag.Float64(n, *ptr, help)
			setter = func() { *ptr = *f }
		case *string:
			if len(field.choices) == 0 {

    }

    def "fails when abstract property has only setter"() {
        when:
        extract(TypeWithAbstractWriteOnlyProperty)
        then:
        def ex = thrown InvalidManagedTypeException
        ex.message == """Type ${fullyQualifiedNameOf(TypeWithAbstractWriteOnlyProperty)} is not a valid managed type:
- Property 'z' is not valid: it must both have an abstract getter and a setter"""
    }

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

                    break;
                case SETTER:
                    if (!hasVoidReturnType(method.getMethod())) {
                        problems.add(method, "property accessor", "setter method must have void return type");
                    }
                    if (!takesSingleParameter(method.getMethod())) {
                        problems.add(method, "property accessor", "setter method must take exactly one parameter");

        PropertyAccessorType.of(DeviantBean.class.getMethod("isidore")) == PropertyAccessorType.IS_GETTER
        PropertyAccessorType.fromName('settings') == PropertyAccessorType.SETTER
        PropertyAccessorType.of(DeviantBean.class.getMethod("settings", String)) == PropertyAccessorType.SETTER
    }

    def "deviant bean properties are considered as such by Java"() {
        expect:

            return;
        }

        String propertyName = accessorType.propertyNameFor(method);
        if (accessorType == PropertyAccessorType.SETTER) {
            validateNotAnnotated(MethodKind.SETTER, method, annotations.keySet(), validationContext);
            validateSetterForMutableType(method, accessorType, validationContext, propertyName);
            return;
        }

        return readMethod != null;
    }

    @Override
    public final Method getWriteMethod() {
        return writeMethod;
    }

    /**
     * setterメソッドを設定します。
     *
     * @param writeMethod
     *            setterメソッド
     */
    protected final void setWriteMethod(final Method writeMethod) {
        this.writeMethod = writeMethod;
        if (writeMethod != null) {

                        }
                    }
                    fir.setter?.let { setter ->
                        methods.singleOrNull { it.name.startsWith("set") }?.let {
                            bindings.put(METHOD_FOR_FIR_FUNCTION, setter, Method(it.name, getAsmMethodSignatureWithCorrection(it)))
                        }
                    }