originalStdOut = System.out;
            System.setOut(redirectedStdOut);
        }
        if (stdErr.destination != null) {
            originalStdErr = System.err;
            System.setErr(redirectedStdErr);
        }
    }

    @Override
    public void stop() {
        try {
            if (originalStdOut != null) {
                System.setOut(originalStdOut);
            }

          new_results.push_back(element_op.getOut());
        }
      }
    }
    for (auto res : llvm::zip(op->getResults(), new_results)) {
      auto casted = builder.create<CastOp>(
          op->getLoc(), std::get<0>(res).getType(), std::get<1>(res));
      std::get<0>(res).replaceAllUsesWith(casted.getOut());
    }

    // Copy all the unregisted attributes to the new op.

			})), c)
		})
	}
}

func verifyExecTestOutput(t *testing.T, cmd *cobra.Command, c execTestCase) {
	t.Helper()

	var out bytes.Buffer
	cmd.SetArgs(c.args)
	cmd.SilenceUsage = true
	cmd.SetOut(&out)
	cmd.SetErr(&out)

	fErr := cmd.Execute()
	output := out.String()

	if c.expectedOutput != "" && c.expectedOutput != output {

        auto casted =
            rewriter.create<CastOp>(loc, unconstrainted_type, new_res);
        tensor_list.push_back(casted.getOut());
      }
      auto list_op = rewriter.create<BuildListOp>(loc, res_type, tensor_list);
      new_results.push_back(list_op.getOut());
    }
  }

  // Copy all the allowed attributes to the new op.
  if (failed(CopyNonSymbolRefAttrs(call_op, new_op))) return failure();

			})), c)
		})
	}
}

func verifyExecTestOutput(t *testing.T, cmd *cobra.Command, c execTestCase) {
	t.Helper()

	var out bytes.Buffer
	cmd.SetArgs(c.args)
	cmd.SilenceUsage = true
	cmd.SetOut(&out)
	cmd.SetErr(&out)

	fErr := cmd.Execute()
	output := out.String()

	if c.expectedOutput != "" && c.expectedOutput != output {

        daemonLog.setExecutable(false);
    }

    private void redirectOutputsAndInput(PrintStream printStream) {
        this.originalOut = System.out;
        this.originalErr = System.err;

        System.setOut(printStream);
        System.setErr(printStream);
        System.setIn(new ByteArrayInputStream(new byte[0]));
    }

    return try {
        val previousOut = System.out
        val previousErr = System.err
        try {
            System.setOut(outCapture)
            System.setErr(errCapture)
            block()
        } finally {
            System.out.flush()
            System.setOut(previousOut)
            outCapture.stop()
            System.err.flush()
            System.setErr(previousErr)

	fmt.Fprintf(h, "vetflags %q\n", vetFlags)

	fmt.Fprintf(h, "pkg %q\n", a.Deps[0].actionID)
	for _, a1 := range a.Deps {
		if a1.Mode == "vet" && a1.built != "" {
			fmt.Fprintf(h, "vetout %q %s\n", a1.Package.ImportPath, b.fileHash(a1.built))
			vcfg.PackageVetx[a1.Package.ImportPath] = a1.built
		}
	}
	key := cache.ActionID(h.Sum())

	if vcfg.VetxOnly && !cfg.BuildA {