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

			expectValue: types.OptionalNone,
		},
		{
			name:        "example_usage_qualifiedName",
			expr:        `format.qualifiedName().validate("apiextensions.k8s.io/v1beta1")`,
			expectValue: types.OptionalNone,
		},
		{
			name:        "example_usage_dns1123LabelPrefix",
			expr:        `format.dns1123LabelPrefix().validate("my-label-prefix-")`,
			expectValue: types.OptionalNone,
		},
		{

}

TEST(XlaCompileUtilTest, PjRtXlaLaunchFlagTest) {
  EXPECT_FALSE(UsePjRtForSingleDeviceCompilation(DeviceType(DEVICE_CPU)));

  // Flag is turned on, but no device is allowlisted.
  auto& rollout_config = GetXlaOpsCommonFlags()->tf_xla_use_device_api;
  rollout_config.enabled_for_xla_launch_ = true;

  EXPECT_FALSE(UsePjRtForSingleDeviceCompilation(DeviceType(DEVICE_CPU)));

		},
		{
			name:        "isQuantity",
			expr:        `isQuantity("20")`,
			expectValue: trueVal,
		},
		{
			name:        "isQuantity_megabytes",
			expr:        `isQuantity("20M")`,
			expectValue: trueVal,
		},
		{
			name:        "isQuantity_mebibytes",
			expr:        `isQuantity("20Mi")`,
			expectValue: trueVal,
		},
		{
			name:        "isQuantity_invalidSuffix",

  EXPECT_FALSE(options.allow_cpu_custom_calls);
  EXPECT_FALSE(options.alias_passthrough_params);
}

TEST_F(XlaCompilerOptionsTest, GenerateCompileOptions) {
  XlaCompiler::CompileOptions option1 = GenerateCompileOptions(
      /*has_ref_vars=*/false, /*may_alias_resource_update=*/false);
  EXPECT_TRUE(option1.is_entry_computation);
  EXPECT_FALSE(option1.always_return_tuple);

  EXPECT_TRUE(IsLargeFloatType(Float80Type::get(context.get())));

  EXPECT_FALSE(IsLargeFloatType(IntegerType::get(context.get(), 8)));
  EXPECT_FALSE(IsLargeFloatType(IntegerType::get(context.get(), 16)));
  EXPECT_FALSE(IsLargeFloatType(IntegerType::get(context.get(), 32)));
}

TEST(IsLargeFloatTypeTest, tensors) {
  auto context = CreateContext();

  EXPECT_FALSE(IsLargeFloatType(

  // Both strings do not appear in any module.
  setenv("MLIR_BRIDGE_LOG_STRING_FILTER", "func @main(%arg0:tensor;XXX", 1);
  BridgeLoggerConfig logger_config2;
  EXPECT_FALSE(
      logger_config2.ShouldPrint(dummy_pass.get(), mlir_module_with_add.get()));
  EXPECT_FALSE(
      logger_config2.ShouldPrint(dummy_pass.get(), mlir_module_with_sub.get()));

  // String appears in one module but not in the other.

import (
	"encoding/binary"
	"testing"
)

func TestNtohs(t *testing.T) {
	hostValue := ntohs(0xbeef)
	expectValue := 0xbeef
	if nativeByteOrder == binary.LittleEndian {
		expectValue = 0xefbe
	}
	if hostValue != uint16(expectValue) {
		t.Errorf("Expected evaluating ntohs(%v) is %v, actual %v", 0xbeef, expectValue, hostValue)
	}

  EXPECT_TRUE(IsTypeLegalizedWithMlir(TypeID::get<TF::ModOp>()));
  EXPECT_FALSE(HasTf2XlaFallback(TypeID::get<TF::ModOp>()));
  EXPECT_FALSE(IsOpAllowedTf2xlaFallback(TypeID::get<TF::ModOp>()));
  EXPECT_FALSE(IsOpAllowedTf2xlaPreferred(TypeID::get<TF::ModOp>()));
}

TEST_F(LegalizationOpConfigTest, ExpectsTrueForTF2XLATypeID) {
  EXPECT_TRUE(HasTf2XlaFallback(TypeID::get<TF::AllOp>()));

  EXPECT_EQ(value, 3);
  EXPECT_TRUE(cache.Lookup("d", &value));
  EXPECT_EQ(value, 4);
  cache.Clear();
  EXPECT_FALSE(cache.Lookup("a", &value));
  EXPECT_FALSE(cache.Lookup("b", &value));
  EXPECT_FALSE(cache.Lookup("c", &value));
  EXPECT_FALSE(cache.Lookup("d", &value));
}

TEST(ExpiringLRUCacheTest, Delete) {
  // Insert an entry.
  tf_gcs_filesystem::ExpiringLRUCache<int> cache(1, 4);