if (kUseUpdatedHybridSchemeDefault) {
          EXPECT_EQ(quant_tensor->quantization()->scale()->size(), shape[0]);
        } else {
          EXPECT_EQ(quant_tensor->quantization()->scale()->size(), 1);
        }
      } else {
        EXPECT_EQ(quant_tensor->type(), TensorType_FLOAT32);
      }
    }
    EXPECT_EQ(used_tensors.size(), quantized_graph->tensors()->size());
  }
}

  // persistent cache.
  std::vector<XlaJitCompilationActivity> activity_history =
      listener_->GetListenerHistory();
  EXPECT_EQ(activity_history.size(), 1);
  EXPECT_EQ(activity_history[0].cluster_name(), fn.name());
  EXPECT_EQ(activity_history[0].compile_count(), 1);
  EXPECT_FALSE(activity_history[0].used_persistent_cache());

  listener_->ClearListenerHistory();

                const std::vector<string>& want_namespaces) {
    string class_name;
    std::vector<string> namespaces;
    TF_EXPECT_OK(ParseCppClass(cpp_class, &class_name, &namespaces));
    EXPECT_EQ(class_name, want_class_name);
    EXPECT_EQ(namespaces, want_namespaces);
  }

  void ExpectFail(const string& cpp_class) {
    string class_name;
    std::vector<string> namespaces;

  root.graph()->AddControlEdge(call, write_op);

  std::unique_ptr<Graph> graph;
  Status failure_status = BuildXlaOps(root, fdef_lib, &graph);
  ASSERT_FALSE(failure_status.ok());
  EXPECT_EQ(failure_status.code(), error::INVALID_ARGUMENT);
}

TEST_F(BuildXlaOpsTest, OnNonXlaDevice) {
  Scope root = Scope::NewRootScope().ExitOnError();

  FunctionDefLibrary fdef_lib =

  std::optional<CalibrationStatistics> statistics = collector.GetStatistics();

  EXPECT_TRUE(statistics.has_value());
  EXPECT_EQ(statistics.value().average_min_max_statistics().min_sum(), -4.0f);
  EXPECT_EQ(statistics.value().average_min_max_statistics().max_sum(), 15.0f);
  EXPECT_EQ(statistics.value().average_min_max_statistics().num_samples(), 2);
}

TEST(CalibrationStatisticsCollectorTest, ClearDataAndGetResultsMinMax) {

  TF_ASSERT_OK_AND_ASSIGN(auto key, BuildSampleSignature("foo"));
  Cache::Value cache_value = cache->LookupOrCreate(key);

  EXPECT_EQ(cache_value.compile_state, DeviceCompileState::kUncompiled);
  EXPECT_EQ(cache_value.request_count, 1);
  EXPECT_EQ(cache_value.compilation_result, nullptr);
  EXPECT_EQ(cache_value.executable, nullptr);
}

TEST(DeviceCompilationCacheTest, IncrementRequestCountOnLookup) {

  // verify transpose
  EXPECT_EQ(
      fused_lstm_func_->getAttrOfType<StringAttr>(kTFImplements).getValue(),
      convert.GetCompositeOpName());
  EXPECT_EQ(fused_lstm_func_.getNumArguments(), 5);
  EXPECT_EQ(fused_lstm_func_.getFunctionType().getNumResults(), 1);

  auto transpose_op = fused_lstm_func_.getBody().front().begin();
  transpose_op++;

  auto context = CreateContext();

  EXPECT_EQ(ToBfloat16Type(Float8E4M3FNType::get(context.get())),
            Float8E4M3FNType::get(context.get()));
  EXPECT_EQ(ToBfloat16Type(Float16Type::get(context.get())),
            Float16Type::get(context.get()));
  EXPECT_EQ(ToBfloat16Type(BFloat16Type::get(context.get())),
            BFloat16Type::get(context.get()));
  EXPECT_EQ(ToBfloat16Type(Float32Type::get(context.get())),

  EXPECT_EQ(0, TF_ShapeDims(shape_a));

  const TF_SignatureDefParam* param_b = TF_SignatureDefParamListGet(args, 1);
  const TF_TensorSpec* tensor_spec_b = TF_SignatureDefParamTensorSpec(param_b);
  const TF_Shape* shape_b = TF_TensorSpecShape(tensor_spec_b);

  // Input "b" is a scalar, float32 tensor
  EXPECT_EQ("b", std::string(TF_SignatureDefParamName(param_b)));

  ASSERT_TRUE(succeeded(dense_attr));
  EXPECT_THAT(dense_attr->getValues<int8_t>(), testing::SizeIs(4));
  EXPECT_EQ(dense_attr->getValues<int8_t>()[0], 1);
  EXPECT_EQ(dense_attr->getValues<int8_t>()[1], 2);
  EXPECT_EQ(dense_attr->getValues<int8_t>()[2], 3);
  EXPECT_EQ(dense_attr->getValues<int8_t>()[3], 4);
}

TEST(GetDenseAttrFromTensorProtoAttrTest, Qint8ToInt8Succeeds) {