* multimap, {@link Entry#getValue} returns the value from the multimap, which may change over
   * time, and {@link Entry#setValue} modifies that value. Removing the mapping from the multimap
   * does not alter the value returned by {@code getValue()}, though a subsequent {@code setValue()}
   * call won't update the multimap but will lead to a revised value being returned by {@code
   * getValue()}.
   */
  @Override

        registerModifiedProperty("updatedTime");
        this.updatedTime = value;
    }

    public String getValue() {
        checkSpecifiedProperty("value");
        return convertEmptyToNull(value);
    }

    public void setValue(String value) {
        registerModifiedProperty("value");
        this.value = value;
    }

    public String getWebConfigId() {

        given:
        def normalisedPath = path.replace('"', '').replaceAll("'", "")

        when:
        buildScript """
            @Managed
            interface Item {
                String getValue()
                void setValue(String value)
            }

            @Managed
            interface A extends Item {
                B getB()
            }

            @Managed
            interface B extends Item {

        attributes.put("deploy-path", deployPath);
        attributes.put("handle", handle);
        Node node = parentNode.appendNode("dependent-module", attributes);
        node.appendNode("dependency-type").setValue("uses");
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (!getClass().equals(o.getClass())) {

        }
    }
    interface Type extends Named {}
    interface SubType extends Type {}
    interface OtherSubType extends Type {}
    interface CreatedSubType extends Type {
        String getValue()
        void setValue(String value)
    }

    class DefaultCreatedSubType implements CreatedSubType {
        final String name
        String value = "original";

        DefaultCreatedSubType(String name) {

    }

    @Override
    public V getValue() {
      assertTrue(Thread.holdsLock(mutex));
      return super.getValue();
    }

    @Override
    public int hashCode() {
      assertTrue(Thread.holdsLock(mutex));
      return super.hashCode();
    }

    @Override
    public V setValue(V value) {
      assertTrue(Thread.holdsLock(mutex));
      return super.setValue(value);
    }

            return type
        }

        @Override
        protected Value<T> calculateOwnValue(ValueConsumer consumer) {
            return Value.of(value)
        }

        void setValue(T value) {
            T previousValue = this.value
            this.value = value
            changingValue.handle(previousValue)
        }

        @Override
        void onValueChange(Action<T> action) {

     * </ul>
     * <p>
     * <b>Example</b>
     * <p>
     * Here is an example of a valid parameter type declaration:
     * <pre>{@code
     * public interface MyParameter {
     *     String getValue();
     *     void setValue(String value);
     *
     *     boolean isFlag();
     *     void setFlag(boolean value);
     * }
     * }</pre>
     *
     * @return The type of the parameter.
     */

                        @Override
                        public String setValue(String value) {
                          checkNotNull(value);
                          return next.setValue(value);
                        }

                        @Override
                        public String getValue() {
                          return next.getValue();
                        }

                        @Override

        String getValue()
        void setValue(String value)
    }

    @Managed
    static interface SingleFloatValueProperty {
        Float getValue()
        void setValue(Float value)
    }

    @Managed
    static interface AnotherSingleStringValueProperty {
        String getValue()

        void setValue(String value)
    }

    @Managed