public interface TaskExecutionRequest {
    /**
     * The arguments to use to select and optionally configure the tasks, as if provided on the command-line.
     *
     * @return task name.
     */
    List<String> getArgs();

    /**
     * Project path associated with this task request if any.
     *
     * @return project path or {@code null} to use the default project path.
     */
    @Nullable String getProjectPath();

}

// GetPods mocks base method.
func (m *MockRuntime) GetPods(ctx context.Context, all bool) ([]*container.Pod, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPods", ctx, all)
	ret0, _ := ret[0].([]*container.Pod)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPods indicates an expected call of GetPods.

      ParseModuleOpString(kModuleDotGeneralFullyConnected);
  ASSERT_TRUE(module_op);

  func::FuncOp main_fn = FindMainFuncOp(*module_op);
  ASSERT_THAT(main_fn, NotNull());

  auto dot_general_op = *main_fn.getOps<DotGeneralOp>().begin();
  EXPECT_THAT(IsDotGeneralFullyConnected(dot_general_op), true);
}

TEST_F(AttrsAndConstraintsTest, IsDotGeneralFullyConnectedReturnsFalse) {
  OwningOpRef<ModuleOp> module_op =

    public RunDefaultTasksExecutionRequest(@Nullable String projectPath, @Nullable File rootDir) {
        this.projectPath = projectPath;
        this.rootDir = rootDir;
    }

    @Override
    public List<String> getArgs() {
        return Collections.emptyList();
    }

    @Nullable
    @Override
    public String getProjectPath() {
        return projectPath;
    }

    @Nullable
    @Override

        }
        mergedItem.fields = fieldList.toArray(new String[fieldList.size()]);

        final List<String> tagList = new ArrayList<>(item1.getTags().length + item2.getTags().length);
        Collections.addAll(tagList, item1.getTags());
        for (final String tag : item2.getTags()) {
            if (!tagList.contains(tag)) {
                tagList.add(tag);
            }
        }

  TF::LoadResourceDataflowAnalysis(solver);
  if (failed(solver.initializeAndRun(module))) return signalPassFailure();

  DenseSet<GlobalTensorOp> remaining_global_tensor_ops;
  {
    auto ops = module.getOps<GlobalTensorOp>();
    remaining_global_tensor_ops.insert(ops.begin(), ops.end());
  }

  for (auto global_tensor : remaining_global_tensor_ops) {
    // This pass assumes that all global tensors as immutable (e.g. by a

           call_op.getOperands())) {
    arg_mapper.map(func_arg, operand);
  }

  Region& function_body = func_op.getBody();
  IRMapping new_op_mapper;
  for (Operation& op : function_body.getOps()) {
    if (llvm::isa<func::ReturnOp>(op)) {
      for (auto [call_result, return_value] :
           llvm::zip_equal(call_op.getResults(), op.getOperands())) {
        Value new_result = new_op_mapper.lookup(return_value);

    NativePlatform getTargetPlatform();

    void setTargetPlatform(NativePlatform platform);

    File getTempDir();

    void setTempDir(File tempDir);

    List<String> getArgs();

    void args(List<String> args);

    List<String> getSystemArgs();

    void systemArgs(List<String> args);

    List<String> getAllArgs();

    BuildOperationLogger getOperationLogger();

     */
    List<String> getTasks();

    /**
     * The clean tasks executed.
     */
    List<String> getCleanTasks();

    /**
     * The Gradle arguments.
     */
    List<String> getArgs();

    /**
     * The Gradle JVM args. Null if not known
     */
    @Nullable
    List<String> getGradleOpts();

    /**
     * Was the daemon used. Null if not known
     */
    @Nullable

  temp_file.os().flush();

  // Replace filename constant ops to use the temporary file.
  MLIRContext* context = &getContext();

  for (func::FuncOp func : module.getOps<func::FuncOp>()) {
    llvm::SmallVector<arith::ConstantOp, 4> constant_ops(
        func.getOps<arith::ConstantOp>());
    for (auto op : constant_ops) {
      ShapedType shaped_type =
          RankedTensorType::get({1}, StringType::get(context));