originalStdErr = System.err;
                stdOutRouter.setOut(originalStdOut);
                stdErrRouter.setOut(originalStdErr);
                try {
                    System.setOut(stdOutPrintStream);
                    System.setErr(stdErrPrintStream);
                    base.evaluate();
                } finally {
                    System.setOut(originalStdOut);
                    System.setErr(originalStdErr);

  }

  fun install() {
    originalSystemOut = System.out
    originalSystemErr = System.err

    System.setOut(object : PrintStream(OutputStream.nullOutputStream()) {})
    System.setErr(object : PrintStream(OutputStream.nullOutputStream()) {})
  }

  fun uninstall() {
    originalSystemOut.let {
      System.setOut(it)
    }
    originalSystemErr.let {
      System.setErr(it)
    }
  }

            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);
            }

	kubeClientFunc = func() (kube.CLIClient, error) {
		return nil, nil
	}
	rootCmd := GetRootCmd(cli.NewFakeContext(&cli.NewFakeContextOption{
		Version: "25",
	}), args)
	var out bytes.Buffer
	rootCmd.SetOut(&out)
	rootCmd.SetErr(&out)

	err := rootCmd.Execute()
	if err != nil {
		t.Fatalf("failed to execute istioctl profile command: %v", err)
	}
	output := out.String()

          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 {

    executor = newVirtualThreadPerTaskExecutor()

    // Capture non-deterministic but probable sysout warnings of pinned threads
    // https://docs.oracle.com/en/java/javase/21/core/virtual-threads.html
    System.setOut(PrintStream(capturedOut))
  }

  @AfterEach
  fun checkForPinning() {
    assertThat(capturedOut.toString()).isEmpty()
  }

  private fun newVirtualThreadPerTaskExecutor(): ExecutorService {

			}
			expectedOut := string(defaultFile)
			if len(expectedOut) == 0 {
				t.Fatal("expected output is empty")
			}

			var out bytes.Buffer
			rootCmd := Cmd(ctx)
			rootCmd.SetArgs(tt.args)
			rootCmd.SetOut(&out)
			rootCmd.SetErr(&out)

			fErr := rootCmd.Execute()
			if fErr != nil {
				t.Fatal(fErr)
			}
			output := out.String()
			if output != expectedOut {

		"--kubeconfig",
		c.kubeconfig,
	}, args...)

	var out bytes.Buffer
	var err bytes.Buffer

	start := time.Now()

	invokeMutex.Lock()
	rootCmd := cmd.GetRootCmd(cmdArgs)
	rootCmd.SetOut(&out)
	rootCmd.SetErr(&err)
	// istioctl will overwrite logs which we don't want.
	// It happens to do this via PersistentPreRunE, which we can disable.

        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();