package org.gradle.api.tasks.testing.logging;

/**
 * Stack trace filters for test logging. Multiple filters can be combined.
 */
public enum TestStackTraceFilter {
    // ordered by how much they filter
    ENTRY_POINT, TRUNCATE, GROOVY

       "http://clang.llvm.org/docs/CrossCompilation.html#cpu-fpu-abi"},
      {"target_features", &flags->target_features,
       "Target features, e.g. +avx2, +neon, etc."},
      {"entry_point", &flags->entry_point,
       "Name of the generated function.  If multiple generated object files "
       "will be linked into the same binary, each will need a unique entry "
       "point."},
      {"cpp_class", &flags->cpp_class,

  string graph;
  string debug_info;
  string debug_info_path_begin_marker;
  string config;
  bool dump_fetch_nodes = false;
  string target_triple;
  string target_cpu;
  string target_features;
  string entry_point;
  string cpp_class;
  string out_function_object;
  string out_metadata_object;
  string out_header;
  string out_session_module;
  string mlir_components;
  bool experimental_quantize = false;

                           aot_or.status().message());
  }
  compile_result->aot =
      xla::unique_ptr_down_cast<xla::cpu::CpuAotCompilationResult>(
          std::move(aot_or.value().back()));
  compile_result->entry_point = aot_opts.entry_point_name();
  compile_result->pointer_size =
      xla::CompileOnlyClient::PointerSizeForTriple(aot_opts.triple());
  return absl::OkStatus();
}

}  // namespace

struct CompileResult {
  // Contains object file and meta-info.
  std::unique_ptr<xla::cpu::CpuAotCompilationResult> aot;
  xla::ProgramShapeProto program_shape;  // Static shape of args and results.
  string entry_point;                    // Name of generated function.
  int pointer_size = 0;                  // Size of a pointer in bytes.
};

// CompileGraph compiles the graph_def into an object file containing a function

    flags = [
        "--graph=" + ctx.file.tfcompile_graph.path,
        "--config=" + ctx.file.tfcompile_config.path,
        "--entry_point=" + ctx.attr.entry_point,
        "--cpp_class=" + ctx.attr.cpp_class,
        "--target_triple=" + ctx.attr.target_triple,
    ] + cpu_flags + output_flags + ctx.attr.extra_flags + dfsan_flags

    post_command = ""

              xla::ShapeUtil::MakeShape(xla::F32, {1}),
              xla::ShapeUtil::MakeShape(xla::S32, {5}),
          }))
          .ToProto();
  compile_result.entry_point = "entry_point";
  compile_result.pointer_size = 8;

  MetadataResult metadata_result;
  TF_ASSERT_OK(GenerateMetadata(opts, compile_result, &metadata_result));

#ifndef __s390x__
  flags.target_triple = "x86_64-pc-linux";
#endif
  flags.out_function_object = "out_model.o";
  flags.out_metadata_object = "out_helper.o";
  flags.out_header = "out.h";
  flags.entry_point = "entry";
  flags.debug_info_path_begin_marker = "";

  // Note that tfcompile.bzl's tf_library macro sets fast math flags as that is
  // generally the preferred case.
  std::vector<tensorflow::Flag> flag_list;

    def "also filters stack traces of causes"() {
        testLogging.getShowCauses() >> true
        testLogging.getShowStackTraces() >> true
        testLogging.getStackTraceFilters() >> EnumSet.of(TestStackTraceFilter.ENTRY_POINT)

        def cause = new RuntimeException("oops")
        cause.stackTrace = createGroovyTrace()

        def exception = new Exception("ouch", cause)
        exception.stackTrace = createGroovyTrace()[1..-1]

        return new AndSpec<StackTraceElement>(filters);
    }

    private Spec<StackTraceElement> createFilter(TestDescriptor descriptor, TestStackTraceFilter filterType) {
        switch (filterType) {
            case ENTRY_POINT:
                return new ClassMethodNameStackTraceSpec(descriptor.getClassName(), descriptor.getName());
            case TRUNCATE: