if VerifyAgainstWhitelist(input, whitelist) {
				for _, tol := range input {
					require.True(t, isContained(tol, whitelist), debugMsg(input, whitelist))
				}
			} else {
				uncontained := false
				for _, tol := range input {
					if !isContained(tol, whitelist) {
						uncontained = true
						break
					}
				}
				require.True(t, uncontained, debugMsg(input, whitelist))

				fname := podOutputPath(workDir, c, pod, fmt.Sprintf("%s.previous.log", container.Name))
				// only care about istio components restart
				if proxyContainer.IsContainer(container) || discoveryContainer.IsContainer(container) || initContainer.IsContainer(container) ||
					validationContainer.IsContainer(container) || strings.HasPrefix(pod.Name, "istio-cni-node") {
					// This is only called if the test failed, so we cannot mark it as "failed" again. Instead, output

  if (trim_funcs_allowlist_.empty()) return false;

  llvm::SmallVector<func::FuncOp, 4> funcs_to_trim;
  for (auto func : getOperation().getOps<func::FuncOp>()) {
    if (llvm::is_contained(trim_funcs_allowlist_, func.getName())) {
      // If no main is specified in the allowlist, use the 1st func
      // in trim_funcs_allowlist as the main.

  val knownTestFile = File("native-image-tests/src/main/resources/testlist.txt")
  val testSelector = DiscoverySelectors.selectPackage("okhttp3")
  val testClasses =
    findTests(listOf(testSelector))
      .filter { it.isContainer }
      .mapNotNull { (it as? ClassBasedTestDescriptor)?.testClass?.name }
      .filterNot { it in avoidedTests }
      .sorted()
      .distinct()
  knownTestFile.writeText(testClasses.joinToString("\n"))

    }
    originalSystemErr?.print(s)
  }

  override fun executionFinished(
    testIdentifier: TestIdentifier,
    testExecutionResult: TestExecutionResult,
  ) {
    if (!testIdentifier.isContainer) {
      when (testExecutionResult.status!!) {
        TestExecutionResult.Status.ABORTED -> printStatus("-")
        TestExecutionResult.Status.FAILED -> printStatus("F")

#include "tensorflow/compiler/mlir/lite/stablehlo/transforms/passes.h.inc"

namespace {
bool IsSupportedComposite(::mlir::stablehlo::CompositeOp op) {
  // List of supported composites to represent using CustomOp.
  return llvm::is_contained(
      {"odml.update_kv_cache", "odml.scaled_dot_product_attention"},
      op.getName());
}

bool IsKVCacheCompositeOp(::mlir::stablehlo::CompositeOp op) {
  return op.getName() == "odml.update_kv_cache";
}

  }

  const auto is_lhs_batch_or_contracting_dim = [&](uint64_t dim) {
    auto dim_nums = first_dot.getDotDimensionNumbers();
    return llvm::is_contained(dim_nums.getLhsBatchingDimensions(), dim) ||
           llvm::is_contained(dim_nums.getLhsContractingDimensions(), dim);
  };

  // dot_general outputs are always in the
  //   [batch dims, LHS other dims, RHS other dims]

        permutation_array.push_back(scatter_dims_to_operand_dims[i]);
      }
      for (int64_t i = 0; i < operand_type.getRank(); ++i) {
        if (!llvm::is_contained(scatter_dims_to_operand_dims, i)) {
          permutation_array.push_back(i);
        }
      }
      auto permutation_and_shape = GetPermutationAndTransposedShape(

        descriptorsByUniqueId.computeIfAbsent(node.getUniqueId(), uniqueId -> {
            wasCreated.set(true);
            boolean isTestClassId = isTestClassIdentifier(node);
            if (node.getType().isContainer() || isTestClassId) {
                if (isTestClassId) {
                    return createTestClassDescriptor(node);
                }
                String displayName = node.getDisplayName();

    Type type = it.value().getType();
    if (type.isa<TensorType>() &&
        type.cast<TensorType>().getElementType().isa<TF::ResourceType>()) {
      if (!llvm::is_contained(device_var_reads_indices, it.index()) &&
          !llvm::is_contained(device_var_updates_indices, it.index())) {
        return execute_launch.GetBody().front().emitError("operand #")
               << it.index()