result.setVersionConstraint(versionConstraint);

        if (versionConstraint.getRange() == null) {
            result.addVersion(versionConstraint.getVersion());
        } else {
            VersionRange.Bound lowerBound = versionConstraint.getRange().getLowerBound();
            if (lowerBound != null
                    && lowerBound.equals(versionConstraint.getRange().getUpperBound())) {

                        valueOrTransform.apply(
                            value -> results.add(value),
                            transform -> {
                                final int index = results.size();
                                results.add(null);
                                transforms.add(() -> {
                                    results.set(index, unchecked(transform));
                                    return null;

    }

    @Override
    protected <RESULT extends BoostDocumentRule> RESULT createEntity(Map<String, Object> source, Class<? extends RESULT> entityType) {
        try {
            final RESULT result = entityType.newInstance();
            result.setBoostExpr(DfTypeUtil.toString(source.get("boostExpr")));
            result.setCreatedBy(DfTypeUtil.toString(source.get("createdBy")));

        )

        when:
        DaemonExpirationResult result = underTest.checkExpiration()

        then:
        if (unhealthy) {
            assert result.status == GRACEFUL_EXPIRE
            assert result.reason == "after running out of JVM heap space"
        } else {
            assert result == DaemonExpirationResult.NOT_TRIGGERED
        }

        where:

  if (parser.resolveOperands(op_infos, types, loc, result.operands))
    return failure();

  // Output result types is a replication `num_outs` times the data input type.
  result.types.append(num_outs.getInt(), types[0]);
  result.types.push_back(control_type);

  return parser.parseOptionalAttrDict(result.attributes);
}

    CrossBuildCachingRuleExecutor.EntryValidator<Result> validator = Mock()
    Transformer<Serializable, Id> keyTransformer = new Transformer<Serializable, Id>() {
        @Override
        Serializable transform(Id id) {
            id.name
        }
    }
    Transformer<Result, Details> detailsToResult = new Transformer<Result, Details>() {
        @Override

        return (result[0] == 0) ? this : rebalance();
      } else if (cmp > 0) {
        AvlNode<E> initRight = right;
        if (initRight == null) {
          result[0] = 0;
          return this;
        }

        right = initRight.remove(comparator, e, count, result);

        if (result[0] > 0) {
          if (count >= result[0]) {
            this.distinctElements--;
            this.totalCount -= result[0];

}

// Generate shape infos for results.
Status GenResultShapeInfos(const xla::ProgramShapeProto& ps, string* infos) {
  if (ps.result().element_type() != xla::TUPLE) {
    return absl::InternalError("codegen requires the XLA result to be a tuple");
  }
  for (int i = 0; i < ps.result().tuple_shapes_size(); ++i) {
    const xla::ShapeProto& shape = ps.result().tuple_shapes(i);

func (c *customResourceDefinitions) Get(ctx context.Context, name string, options v1.GetOptions) (result *v1beta1.CustomResourceDefinition, err error) {
	result = &v1beta1.CustomResourceDefinition{}
	err = c.client.Get().
		Resource("customresourcedefinitions").
		Name(name).
		VersionedParams(&options, scheme.ParameterCodec).
		Do(ctx).
		Into(result)
	return
}

  os.indent(2) << "static const std::set<std::string> * result =\n";
  os.indent(4) << "new std::set<std::string>({\n";

  std::vector<std::string> result;
  GenerateStaticQuantOp(defs, result, InputDataType::INT8, /*per_axis=*/true,
                        /*is_toco=*/false);

  for (const auto &op_name : result) {
    os.indent(6) << "\"" << op_name << "\",\n";
  }

  os.indent(4) << "});";