expectCx128(t, "neg", neg, -1-2i)
	expect64(t, "real", r, 1)
	expect64(t, "imag", i, 2)
	expectCx128(t, "cnst", cnst, -4+7i)
	expectTrue(t, fmt.Sprintf("%v==%v", a, a), c1)
	expectFalse(t, fmt.Sprintf("%v==%v", a, b), c2)
	expectFalse(t, fmt.Sprintf("%v!=%v", a, a), c3)
	expectTrue(t, fmt.Sprintf("%v!=%v", a, b), c4)
}

func complexTest64(t *testing.T) {
	var a complex64 = 1 + 2i
	var b complex64 = 3 + 6i

  EXPECT_TRUE(cache_value_1->compilation_result != nullptr);
  EXPECT_TRUE(cache_value_1->executable != nullptr);
  EXPECT_EQ(cache_value_1->executable->data, "foo_exe");

  EXPECT_EQ(cache_value_2->compile_state, DeviceCompileState::kCompiling);
  EXPECT_TRUE(cache_value_2->compilation_status.ok());
  EXPECT_TRUE(cache_value_2->compilation_result != nullptr);

  done.WaitForNotification();
  cache_value = xla_cache->Lookup(signature);
  EXPECT_TRUE(cache_value);
  EXPECT_TRUE(cache_value->compile_state == DeviceCompileState::kCompiled);
  EXPECT_TRUE(cache_value->compilation_result != nullptr);
  EXPECT_TRUE(cache_value->executable != nullptr);
  EXPECT_TRUE(cache_value->compilation_status.ok());
}

TEST_F(DeviceCompilerTest, CompilePersistentCacheEnabled) {

TEST(DecodeShardingAttributeTest, CheckInvalidString) {
  xla::OpSharding sharding;
  EXPECT_TRUE(DecodeShardingAttribute("", sharding).succeeded());
  EXPECT_TRUE(DecodeShardingAttribute("manual", sharding).failed());
}

TEST(DecodeShardingAttributeTest, CheckManualShardString) {
  xla::OpSharding sharding;
  EXPECT_TRUE(DecodeShardingAttribute("{manual}", sharding).succeeded());
  EXPECT_TRUE(sharding.type() == sharding.MANUAL);

      /*min=*/1.0f, /*max=*/10.f, /*histogram=*/{});
  collector.Collect(
      /*min=*/-5.0f, /*max=*/5.f, /*histogram=*/{});

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

  EXPECT_TRUE(statistics.has_value());
  EXPECT_EQ(statistics.value().min_max_statistics().global_min(), -5.0f);
  EXPECT_EQ(statistics.value().min_max_statistics().global_max(), 10.0f);
}

  cache2.Insert("a", 1);
  cache2.Insert("b", 2);
  cache2.Insert("c", 3);
  cache2.Insert("d", 4);
  EXPECT_TRUE(cache2.Lookup("a", &value));
  EXPECT_EQ(value, 1);
  EXPECT_TRUE(cache2.Lookup("b", &value));
  EXPECT_EQ(value, 2);
  EXPECT_TRUE(cache2.Lookup("c", &value));
  EXPECT_EQ(value, 3);
  EXPECT_TRUE(cache2.Lookup("d", &value));
  EXPECT_EQ(value, 4);

  EXPECT_THAT(op_nullptr, IsNull());

  EXPECT_TRUE(failed(TryCast<DotGeneralOp>(op_nullptr, /*name=*/"op_nullptr")));
  EXPECT_TRUE(failed(TryCast<DotGeneralOp>(nullptr, /*name=*/"nullptr")));
}

TEST_F(AttrsAndConstraintsTest, I64ValueInI32RangeAreCastedCorrectly) {
  EXPECT_TRUE(succeeded(CastI64ToI32(llvm::minIntN(32))));
  EXPECT_TRUE(succeeded(CastI64ToI32(llvm::maxIntN(32))));
}

  core::ScopedUnref profiler_ref(profiler);

  NameAttrList function;
  function.set_name("TestFunc");

  EXPECT_TRUE(
      profiler->ShouldCompileCluster(function, DeviceCompileMode::kAsync, 0));
  EXPECT_TRUE(
      profiler->ShouldCompileCluster(function, DeviceCompileMode::kLazy, 0));
  EXPECT_TRUE(
      profiler->ShouldCompileCluster(function, DeviceCompileMode::kStrict, 0));
}

  EXPECT_TRUE(failed(
      GetDenseAttrFromTensorProtoAttr(GetQint16Tensor(), result_tensor_type)));
}

TEST(IsTFQintTypeTest, ValidTFQintTypeSucceeds) {
  auto context = CreateContext();

  EXPECT_TRUE(IsTFQintType(TF::Qint8Type::get(context.get())));
  EXPECT_TRUE(IsTFQintType(TF::Qint16Type::get(context.get())));
  EXPECT_TRUE(IsTFQintType(TF::Qint32Type::get(context.get())));

  EXPECT_EQ(flattened.size(), 3);
  EXPECT_TRUE(TensorSpecsAreEqual(*flattened[0],
                                  /* expected_name = */ "x",
                                  /* expected_shape = */ {1},
                                  /* expected_dtype = */ DT_FLOAT))
      << "Expected " << flattened[0]->DebugString();

  EXPECT_TRUE(TensorSpecsAreEqual(*flattened[1],