#include "tensorflow/compiler/mlir/lite/transforms/passes.h"
#include "tensorflow/compiler/mlir/quantization/common/quantization_lib/quantization_utils.h"

namespace mlir::quant::stablehlo {

#define GEN_PASS_DEF_POSTQUANTIZEPASS
#include "tensorflow/compiler/mlir/quantization/stablehlo/passes/passes.h.inc"

namespace {

// Applies clean-up patterns after quantization.

#include "mlir/Pass/PassRegistry.h"  // from @llvm-project
#include "mlir/Support/LogicalResult.h"  // from @llvm-project
#include "mlir/Transforms/Passes.h"  // from @llvm-project
#include "tensorflow/compiler/jit/flags.h"
#include "tensorflow/compiler/mlir/tensorflow/transforms/passes.h"
#include "tensorflow/compiler/mlir/tensorflow/utils/data_dumper_logger_config.h"
#include "tensorflow/compiler/mlir/tensorflow/utils/dump_mlir_util.h"

                         const std::function<void(PassManager*)>& passes) {
  mlir::registerPassManagerCLOptions();
  MLIRContext context;

  OwningOpRef<ModuleOp> module =
      GetMlirModuleFromString(module_string, &context).value();

  PassManager pm(&context);

  if (mlir::failed(mlir::applyPassManagerCLOptions(pm))) return false;
  passes(&pm);

  return pm.run(module.get()).succeeded();
}

#define TENSORFLOW_COMPILER_MLIR_LITE_STABLEHLO_TRANSFORMS_TRANSFORMS_H_

#include "mlir/Pass/PassManager.h"  // from @llvm-project

namespace mlir {
namespace odml {

// Adds all the necessary passes to lower a TF module to StableHLO.
// `skip_resize` enables or disables skipping conversion of tf.ResizeBilinear
// and tf.ResizeNearestNeighbor ops.
// `smuggle_disallowed_ops` enables or disables converting disallowed ops

            public class FooTest {
                @org.junit.Test public void passes() {}
                @org.junit.Test public void fails() { throw new RuntimeException("Boo!"); }
            }
        """

        when:
        withConnection { it.newBuild().withArguments('test', '--tests', 'FooTest.passes').run() }

        then:
        noExceptionThrown()
    }

  void RegisterExtraDialects(mlir::DialectRegistry& registry);

 protected:
  // Adds TAC passes to the 'pass_manager'.
  virtual void AddTACPass(mlir::OpPassManager* pass_manager,
                          llvm::ArrayRef<std::string> device_specs);

 private:
  // Runs all TAC passes on the provided module.
  absl::Status RunTacPasses(mlir::ModuleOp* module, bool debug_mode = false);

! stderr .
stdout '^exitcode=1exit status 1\n'
stdout '^FAIL\s+example/fail'

# In package list mode, if the test passes the 'ok' message appears
# on its own line.
cd ../skip
go test -v .
! stderr .
stdout '^skipping\n'
stdout '^ok\s+example/skip'

# If the output is streamed and the test passes, we can't tell whether it ended
# in a partial line, and don't want to emit any extra output in the

    def clientDescriptor = Stub(InternalOperationDescriptor)
    def clientStartEvent = Stub(InternalOperationStartedProgressEvent)
    def clientFinishEvent = Stub(InternalOperationFinishedProgressEvent)

    def "passes events when enabled mapper available for details type"() {
        def mapper1 = Mock(BuildOperationMapper)
        def mapper2 = Mock(BuildOperationMapper)
        def mappedProgressEvent = Mock(InternalProgressEvent)

        if (keyType.isPrimitive()) {
            // Kotlin passes these types for its own basic types
            return Cast.uncheckedNonnullCast(mapProperty(JavaReflectionUtil.getWrapperTypeForPrimitiveType(keyType), valueType));
        }
        if (valueType.isPrimitive()) {
            // Kotlin passes these types for its own basic types

#include "mlir/Support/LogicalResult.h"  // from @llvm-project
#include "mlir/Transforms/Passes.h"  // from @llvm-project
#include "tensorflow/compiler/jit/flags.h"
#include "tensorflow/compiler/mlir/tensorflow/transforms/host_runtime/runtime_passes.h"
#include "tensorflow/compiler/mlir/tensorflow/transforms/passes.h"
#include "tensorflow/compiler/mlir/tensorflow/transforms/sparsecore/sparsecore_passes.h"