try {
            writer.write("class " + className + " {");
            writer.write("    String getValue() { return \\"");
            String messageFromOptions = options.get("message");
            if (messageFromOptions == null) {
                writer.write(HelperUtil.getValue() + "${suffix}");
            } else {
                writer.write(messageFromOptions);
            }

        // Assign device to ops with device attribute that is empty.
        if (device_attr.getValue().empty()) {
          op->setAttr(kDeviceAttr,
                      builder.getStringAttr(func_device_attr.getValue()));
        }
      } else if (op->getDialect() == tf) {
        // Assign device to all ops in Tensorflow dialect that do not have
        // device attribute.
        op->setAttr(kDeviceAttr,

public abstract class ExecutionResult<T> {
    private static final Success<Void> SUCCESS = new Success<Void>() {
        @Override
        public Void getValue() {
            return null;
        }
    };

    /**
     * Returns the value, if available.
     */
    public abstract T getValue();

    /**
     * Returns the failures in this result, or an empty list if the operation was successful.
     */

        final String valueTwo = "valueTwo"

        stringsOption.getValue().add(valueOne)
        stringsOption.getValue().add(valueTwo)

        when:
        stringsOption.write(writerContextMock)

        then:
        1 * writerContextMock.writeValuesOption(optionName, stringsOption.getValue(), joinBy)
    }

        map.put("boost2", 0);
        assertTrue(0.0f == docBoostMatcher.getValue(map));

        map.put("boost1", 1);
        map.put("boost2", 0);
        assertTrue(10.0f == docBoostMatcher.getValue(map));

        map.put("boost1", 1);
        map.put("boost2", 2);
        assertTrue(12.0f == docBoostMatcher.getValue(map));
    }

        }

        val ktFileInCommon = session.modulesWithFiles.getValue(commonModule).single() as KtFile
        val callInCommon = ktFileInCommon.findDescendantOfType<KtCallExpression>()!!
        callInCommon.assertIsCallOf(CallableId(FqName("some.example"), FqName("Person"), Name.identifier("greet")))

        val ktFileInJvm = session.modulesWithFiles.getValue(sourceModule).single() as KtFile

  ElementsAttr attr;
  ShapedType type;
  InspectResult result = {};
  if (auto cst = dyn_cast<ConstOp>(inst)) {
    attr = cst.getValue();
    type = mlir::cast<ShapedType>(cst.getType());
  } else if (auto cst = dyn_cast<QConstOp>(inst)) {
    attr = cst.getValue();
    type = mlir::cast<ShapedType>(cst.getType());
  } else {
    result.can_compress = false;
    return result;
  }

        this.modulePath.getValue().addAll(modulePath);
        return this;
    }

    @Override
    public MinimalJavadocOptions classpath(List<File> classpath) {
        this.classpath.getValue().addAll(classpath);
        return this;
    }

    @Override
    public MinimalJavadocOptions classpath(File... classpath) {
        this.classpath.getValue().addAll(Arrays.asList(classpath));

    public ValueSnapshot asSnapshot() {
        return this;
    }

    @Override
    public T isolate() {
        return getValue();
    }

    @Nullable
    @Override
    public <S> S coerce(Class<S> type) {
        if (type.isInstance(getValue())) {
            return type.cast(getValue());
        }
        return null;
    }

		getValue: func(ep *IstioEndpoint) string {
			return ep.Network.String()
		},
	}
}

type proxyViewImpl struct {
	visible  sets.String
	getValue func(ep *IstioEndpoint) string
}

func (v *proxyViewImpl) IsVisible(ep *IstioEndpoint) bool {
	return v.visible.Contains(v.getValue(ep))
}

func (v *proxyViewImpl) String() string {