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

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

    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]

#include "tensorflow/core/platform/types.h"

namespace Eigen { struct ThreadPoolDevice; }
namespace xla { class ExecutableRunOptions; }

// (Implementation detail) Entry point to the function in the object file.
extern "C" void entry_point(
    void* result, const ::xla::ExecutableRunOptions* run_options,
    const void** args, void** temps, XlaCustomCallStatus* status,
    int64_t* profile_counters);

      {"{{CLASS}}", opts.class_name},
      {"{{DECLS_FROM_OBJ_FILE}}",
       absl::StrJoin(metadata_result.header_variable_decls, "\n")},
      {"{{ENTRY}}", compile_result.entry_point},
      {"{{HLO_PROFILE_PRINTER_DATA_SHIM_EXPRESSION}}",
       metadata_result.hlo_profile_printer_data_access_shim},
      {"{{INCLUDE_XLA_DATA_PROTO}}", include_xla_data_proto},

        }
        2.times {
            fails 'entryPoint', '-PentryPoint.broken', '--continue'
            result.assertTasksExecutedInOrder ':entryPoint', ':finalizerDepDep', ':finalizerDep'
        }
        2.times {
            fails 'entryPoint', '-PfinalizerDepDep.broken'
            result.assertTasksExecutedInOrder ':entryPoint', ':finalizerDepDep'
        }
        2.times {

        @Nullable
        private StreamedValueListener streamedValueListener;

        private Builder() {
        }

        public Builder setEntryPoint(String entryPoint) {
            this.entryPoint = entryPoint;
            return this;
        }

        public Builder setParameters(ConnectionParameters parameters) {
            this.parameters = parameters;
            return this;
        }

            writeLn();
            writeLibraryAccessors(entryPoints.librariesEntryPoint, deprecated);
            writeVersionAccessors(entryPoints.versionsEntryPoint);
            writeBundleAccessors(entryPoints.bundlesEntryPoint, deprecated);
            writePluginAccessors(entryPoints.pluginsEntryPoint);
            writeLibrarySubClasses(entryPoints.librariesEntryPoint, deprecated);

			var registerPluginFuncs []tf.RegisterPluginFunc
			for name, entrypoint := range tt.entrypoints {
				registerPluginFuncs = append(registerPluginFuncs,
					// anything supported by TestPlugin is fine
					tf.RegisterFilterPlugin(name, entrypoint),
				)
			}
			// we always need this
			registerPluginFuncs = append(registerPluginFuncs,