def notRequired = mavenRepo.module('test', 'dont-include-me', '1.0')
        def m1 = mavenRepo.module('test', 'test1', '1.0').publish()
        def m2 = mavenRepo.module('test', 'test2', '1.0').publish()
        def m3 = mavenRepo.module('test', 'test3', '1.0').publish()
        def m4 = mavenRepo.module('test', 'test4', '1.0').publish()
        def m5 = mavenRepo.module('test', 'test5', '1.0')
            .dependsOn(m1, scope: 'compile')

using ::tsl::testing::IsOk;

using QuantizationReportTest = ::mlir::quant::QuantizationTestBase;

TEST_F(QuantizationReportTest, GetQuantizationResultsReturnsEmptyResults) {
  QuantizationReport report{};

  const QuantizationResults& results = report.GetQuantizationResults();
  ASSERT_THAT(results.results(), IsEmpty());
}

TEST_F(QuantizationReportTest, AddQuantizationResult) {

  EXPECT_EQ(histogram.num(), 1);
  EXPECT_EQ(compilation_status.Delta("kOldBridgeNoMlirSuccess"), 1);
}

TEST_F(CompileTFGraphTest, SuccessfullyCompilesWithManualSharding) {
  // MLIR module from failing test.
  constexpr char kSupportedManualSharding[] = R"(

			hash,
			false,
		},
	}
	for _, test := range tests {
		updated := IsPodUpdated(test.pod, test.hash, test.templateGeneration)
		if updated != test.isUpdated {
			t.Errorf("%s: IsPodUpdated returned wrong value. Expected %t, got %t", test.test, test.isUpdated, updated)
		}
	}
}

func TestCreatePodTemplate(t *testing.T) {
	tests := []struct {
		templateGeneration *int64

        outputContains("external-dependencies: [test1-1.0.jar]")
        outputContains("child1-dependencies: [child1.jar, child1-lib.jar, test2-1.0.jar]")
    }

    @ToBeFixedForConfigurationCache(because = "task uses Configuration API")
    def "can query files for filtered first level dependencies when there is a cycle in the dependency graph"() {
        mavenRepo.module("group", "test1", "1.0").publish()

#include "tensorflow/core/tpu/kernels/tpu_compile_op_support.h"
#include "tsl/lib/core/status_test_util.h"

namespace mlir::quant::stablehlo {
namespace {

using ::testing::Test;

class LegalizeTFQuantTest : public Test {
 protected:
  void TestBridgeLowering(llvm::StringRef mlir_module_string,
                          llvm::ArrayRef<tensorflow::TensorShape> arg_shapes,

    public void run(RunNotifier runNotifier) {
        // Run tests in 'parallel'
        Description test1 = Description.createTestDescription(type, 'broken')
        Description test2 = Description.createTestDescription(type, 'ok')
        runNotifier.fireTestStarted(test1)
        runNotifier.fireTestStarted(test2)
        runNotifier.fireTestFailure(new Failure(test1, failure.rawFailure))
        runNotifier.fireTestFinished(test2)

  EXPECT_THAT(saver_def->save_tensor_name(), "tf_quant__save_op_0:0");
}

TEST(CreateSaverDefTest, ReturnsNulloptIfNoSaverDefRelatedNodesExist) {
  TF_ASSERT_OK_AND_ASSIGN(
      const std::optional<SaverDef> saver_def,
      CreateSaverDef(/*control_ret_node_names=*/{}, GraphDef()));
  EXPECT_EQ(saver_def, std::nullopt);
}

TEST(CreateSaverDefTest, ReturnsErrorStatusIfSaverDefNodesPartiallyExist) {

  EXPECT_TRUE(status.ok());
  auto decomposed = test_ctx_->ExpandNode(test_node, "test");
  EXPECT_TRUE(decomposed.ok());
  std::vector<NodeAndType> expected_results{{"Identity", DT_FLOAT}};
  EXPECT_THAT(NodesSequenceOf(decomposed.value()),
              ElementsAreArray(expected_results));
}

TEST_F(TFRDecomposeContextTest, FLOAT_3_ins) {
  std::vector<NodeDefBuilder::NodeOut> src_list;

    return run_result;
  }

 private:
  mlir::MLIRContext context_;
  mlir::OwningOpRef<ModuleOp> module_;
  std::unique_ptr<mlir::PassManager> pm_;
};

TEST_F(InputLoweringMetricsPassTest, CountsNoDynamicOps) {
  static constexpr char kMlirModuleStr[] = R"(
  module attributes {tf.versions = {bad_consumers = [], min_consumer = 0 : i32, producer = 268 : i32}} {