}

    @Override
    public void apply(Object object, List<String> parameterValues) throws TypeConversionException {
        Object arg = notationParser.parseNotation(parameterValues.get(0));
        setter.setValue(object, arg);
    }

        return controller.getModel(CustomModel.class, CustomParameter.class, new Action<CustomParameter>() {
            @Override
            public void execute(CustomParameter customParameter) {
                customParameter.setValue("myParameter");
            }
        });
    }

                                                 bool enable_inliner) {
  PassManager bridge(module.getContext());

  StandardPipelineOptions pipeline_options;
  pipeline_options.enable_inliner.setValue(enable_inliner);
  CreateTFStandardPipeline(bridge, pipeline_options);

  mlir::StatusScopedDiagnosticHandler diag_handler(
      module.getContext(), /*propagate=*/false,
      /*filter_stack=*/!VLOG_IS_ON(1));

        e1.message == "${InvalidParameter.name} is not a valid parameter type. It must be an interface."
    }

    interface ValidParameter {
        void setValue(String value)

        String getValue()

        void setBooleanValue(boolean booleanValue)

        boolean isBooleanValue()
    }

    class InvalidParameter {
        String foo
    }

        --inputTrackingDisabledCounterForThread
    }
}


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


private

        for (final LabelType labelType : labelTypeList) {
            final LabelTypeItem item = new LabelTypeItem();
            item.setLabel(labelType.getName());
            item.setValue(labelType.getValue());
            item.setPermissions(labelType.getPermissions());
            item.setVirtualHost(labelType.getVirtualHost());
            item.setLocale(labelType.getLocale());
            itemList.add(item);

    /** 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) {

     *
     * @return The header value. May be null.
     */
    @Nullable
    String getValue();

    /**
     * Sets the header value to use when authenticating.
     *
     * @param value The header value. May be null.
     */
    void setValue(@Nullable String value);

     * of the source for the merge.
     */
    String getValue();

    /**
     * Set's the value for the key of the manifest after the merge takes place.
     */
    void setValue(String value);

    /**
     * Excludes this key from being in the manifest after the merge.
     */
    void exclude();

        then:
        0 * writerContextMock._
    }

    def testWriteNonNullValue() throws IOException {
        final File testValue = new File("dummyTestFileValue")
        fileOption.setValue(testValue)

        when:
        fileOption.write(writerContextMock)

        then:
        1 * writerContextMock.writeValueOption(optionName, testValue.absolutePath)
    }