LogicalResult matchAndRewrite(TF::UniformQuantizeOp op,
                                PatternRewriter &rewriter) const override {
    auto output_type = GetUniformQuantizedType(
        op, op.getOutput().getType(), op.getScales(), op.getZeroPoints(),
        /*expressed_type=*/rewriter.getF32Type(), op.getQuantizationMinVal(),
        op.getQuantizationMaxVal(), op.getQuantizationAxis(), rewriter);

                .build()
        }
        1 * implicitInput1.getInput() >> '/foo/bar'
        1 * implicitInput1.getOutput() >> 'abcdef012'
        1 * implicitInput2.getInput() >> '/foo/baz'
        1 * implicitInput2.getOutput() >> 'abcdef987'
        1 * validator.isValid(cachePolicy, _) >> true
        1 * service.isUpToDate('/foo/bar', 'abcdef012') >> true

        BuildResult result = GradleRunner.create()
            .withProjectDir(testProjectDir)
            .withArguments("helloWorld")
            .build();

        assertTrue(result.getOutput().contains("Hello world!"));
        assertEquals(SUCCESS, result.task(":helloWorld").getOutcome());
    }

    private void writeFile(File destination, String content) throws IOException {

  auto reshape = builder.create<TF::ReshapeOp>(
      loc, ArrayRef<Type>{element_type},
      ArrayRef<Value>{slice,
                      GetR1Const(element_type.getShape(), builder, loc)});
  return reshape.getOutput();
}

Value SetElement(Value index, Value buffer, Value element, OpBuilder builder,
                 Location loc) {
  auto buffer_type = mlir::cast<RankedTensorType>(buffer.getType());

                                 preceding_cast.getOut().getType()) {
        return failure();
      }
      raw_data_op.getOutput().replaceAllUsesWith(redundant_cast.getArg());
    } else {
      // If the argument of cast op is input, then simply remove the RawData op.
      raw_data_op.getOutput().replaceAllUsesWith(preceding_cast.getOut());
    }
    return success();
  }

         * The type of value returned here depends on the {@link UnitOfWork} implmenetation.
         */
        // TODO Parametrize UnitOfWork with this generated result
        @Nullable
        Object getOutput(File workspace);

        /**
         * Whether the outputs of this execution should be stored in the build cache.
         */
        default boolean canStoreOutputsInCache() {
            return true;

    private final List<BuildTask> tasks;

    public DefaultBuildResult(String output, List<BuildTask> tasks) {
        this.output = output;
        this.tasks = tasks;
    }

    @Override
    public String getOutput() {
        return output;
    }

    @Override
    public List<BuildTask> getTasks() {
        return Collections.unmodifiableList(tasks);
    }

    @Override

        host_tensor, device_, device_tensor));

    tensors_.push_back(device_tensor);
    return device_tensor;
  }

  // Gets the `output_index`-th output set in the context_
  Tensor* GetOutput(int output_index) {
    CHECK_LT(output_index, context_->num_outputs());
    Tensor* device_tensor = context_->mutable_output(output_index);
    managed_outputs_.resize(context_->num_outputs());

        return path;
    }

    public List<String> getExcludes() {
        return excludes;
    }

    public List<String> getIncludes() {
        return includes;
    }

    public String getOutput() {
        return output;
    }

            JvmFeatureInternal mainFeature = JavaPluginHelper.getJavaComponent(project).getMainFeature();
            groovyDoc.setClasspath(mainFeature.getSourceSet().getOutput().plus(mainFeature.getSourceSet().getCompileClasspath()));

            SourceDirectorySet groovySourceSet = mainFeature.getSourceSet().getExtensions().getByType(GroovySourceDirectorySet.class);