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

        @Override
        public CovariantPropertyTypes setValue2(Object value2) {
            super.setValue2(value2);
            return this;
        }
    }

    public static class BeanWithReadOnlyProperties {
        public String getProp() {
            return "value";

}


/**
 * Provides efficient access to a mutable dynamic property.
 */
interface MutablePropertyDelegate : PropertyDelegate {
    operator fun <T> setValue(receiver: Any?, property: KProperty<*>, value: T)
}


internal
fun propertyDelegateFor(dynamicLookupRoutine: DynamicLookupRoutine, target: Any, property: KProperty<*>): PropertyDelegate =

    /** Clears the reference queues used by this segment, if any. */
    void maybeClearReferenceQueues() {}

    /** Sets the value of the given {@code entry}. */
    void setValue(E entry, V value) {
      this.map.entryHelper.setValue(self(), entry, value);
    }

    /** Returns a copy of the given {@code entry}. */
    @CheckForNull
    E copyEntry(E original, E newNext) {

    }

    public File getBasedir() {
        return (pomFile != null) ? pomFile.getParentFile() : null;
    }

    public void setValueOnModel(String expression, Object value) {
        context.setValue(expression, value);
    }

    /*
    public int containerCountForUri( String uri )
        throws IOException
    {
        Validate.notEmpty( uri, "uri can neither be null nor empty " );

        --inputTrackingDisabledCounterForThread
    }
}


private
operator fun <T> ThreadLocal<T>.getValue(thisRef: Any?, property: KProperty<*>) = get()


private

                                          packed_shape_type.getShape().end());
  EXPECT_THAT(packed_shape, testing::ElementsAreArray(expected_packed_shape));
  llvm::SmallVector<int8_t> packed_value_vector(
      packed_value_attr.getValues<int8_t>());
  EXPECT_THAT(packed_value_vector,
              testing::ElementsAreArray(expected_packed_values));
}

TEST(TfToXlaAttributeUtilsTest, PackOperandPackDimSizeEven) {

        def parameterType = ValidParameter
        def parameterInitializer = new Action<ValidParameter>() {
            @Override
            void execute(ValidParameter parameter) {
                parameter.setValue("myValue")
                parameter.setBooleanValue(true)
            }
        }

        when:
        def result = controller.getModel(modelElement, GradleBuild, parameterType, parameterInitializer)

      // recurse into the next axis.
      const bool is_last_axis = output_axis == num_dimensions - 1;
      if (is_last_axis) {
        new_values->push_back(
            input_tensor.getValues<Attribute>()[*input_indices]);
      } else {
        ComputePermutation(input_tensor, perm, output_shape, num_dimensions,
                           output_axis + 1, input_indices, new_values);
      }
    }
  }

    /** Clears the reference queues used by this segment, if any. */
    void maybeClearReferenceQueues() {}

    /** Sets the value of the given {@code entry}. */
    void setValue(E entry, V value) {
      this.map.entryHelper.setValue(self(), entry, value);
    }

    /** Returns a copy of the given {@code entry}. */
    @CheckForNull
    E copyEntry(E original, E newNext) {

     */
    @Input
    String getValue();

    /**
     * Sets the value that applies to the limit.
     *
     * @param value Value
     */
    void setValue(String value);

    /**
     * Gets the minimum expected value for limit. Default to null.
     */
    @Nullable
    @Optional
    @Input
    BigDecimal getMinimum();

    /**