/*enable_op_fallback=*/false,
                                    /*custom_legalization_passes*/ {});

  EXPECT_FALSE(pass_manager.getPasses().empty());
}

TEST(CompileMlirUtil, HasLegalizationPass) {
  OpPassManager pass_manager;
  llvm::StringRef device_type = "XLA_CPU_JIT";
  absl::string_view kLegalizeTfPass = "xla-legalize-tf";

                       mlir::Operation* op, llvm::raw_ostream& os) {
  std::string str;
  llvm::raw_string_ostream passOS(str);
  llvm::interleaveComma(
      pass_manager.getPasses(), passOS,
      [&](mlir::Pass& pass) { pass.printAsTextualPipeline(passOS); });
  os << "{-# external_resources: { mlir_reproducer: { pipeline: "
        "\"builtin.module("
     << passOS.str() << ")\", ";

                    spec.getForkOptions().setExecutable(Jvm.current().getJavaExecutable());
                }
                spec.getClasspath().setFrom(getClasses(), getClasspath());
            })
            .submit(ValidateAction.class, params -> {
                params.getClasses().setFrom(getClasses());
                params.getOutputFile().set(getOutputFile());
                params.getEnableStricterValidation().set(getEnableStricterValidation());

            List<Throwable> causes = new ArrayList<>(taskExecutionException.getCauses());
            CollectionUtils.addAll(causes, failure.getCauses());
            taskExecutionException.initCauses(causes);
        } else {
            List<Throwable> causes = new ArrayList<>();
            causes.add(this.failure);
            causes.addAll(failure.getCauses());
            failure.initCauses(causes);
            this.failure = failure;

        if (this.failure == null) {
            this.failure = failure;
        } else {
            List<Throwable> causes = new ArrayList<Throwable>(this.failure.getCauses());
            CollectionUtils.addAll(causes, failure.getCauses());
            this.failure.initCauses(causes);
        }
    }

    public boolean hasFailure() {
        return failure != null;
    }

    @Override

            return true;
        }
        if (failure instanceof DefaultMultiCauseException) {
            List<? extends Throwable> causes = ((DefaultMultiCauseException) failure).getCauses();
            for (Throwable cause : causes) {
                if (isLikelyTransientNetworkingIssue(cause)) {
                    return true;
                }
            }
        }

        @Override
        protected Boolean initialValue() {
            return false;
        }
    }

    @Override
    public List<? extends Throwable> getCauses() {
        return causes;
    }

    @Override
    public synchronized Throwable initCause(Throwable throwable) {
        causes.clear();
        causes.add(throwable);
        return null;
    }

        def relevances = Collections.nCopies(stack.size(), USER_CODE)
        def causes = getCauses(t).collect { toFailure(it) }
        def suppressed = t.getSuppressed().collect { toFailure(it) }
        new DefaultFailure(t, stack, relevances, suppressed, causes)
    }

    private static List<Throwable> getCauses(Throwable t) {
        if (t instanceof MultiCauseException) {
            return t.causes
        }

 *
 * DO NOT CHANGE THIS INTERFACE. It is part of the cross-version protocol.
 *
 * @since 7.6
 */
public interface InternalTestSpec extends InternalTaskSpec {
    List<String> getPackages();
    List<String> getClasses();
    Map<String, List<String>> getMethods();
    List<String> getPatterns();

        List<Throwable> mappedCauses = resolveException.getCauses().stream()
            .map(cause -> mapRepositoryOverrideFailure(contextDisplayName, cause))
            .collect(ImmutableList.toImmutableList());

        // Keep the original exception if no changes were made to
        // the causes to avoid losing the original stack trace
        if (mappedCauses.equals(resolveException.getCauses())) {
            return resolveException;
        }