func FromTimestamp(t time.Time) *Value {
	return &Value{value: t}
}

// FromNull creates a Value with Null value
func FromNull() *Value {
	return &Value{value: nil}
}

// FromMissing creates a Value with Missing value
func FromMissing() *Value {
	return &Value{value: Missing{}}
}

// FromBytes creates a Value from a []byte
func FromBytes(b []byte) *Value {
	return &Value{value: b}
}

// valueBuilders contains one constructor for each value type.
// Values should match if type is the same.
var valueBuilders = []func() *Value{
	FromNull,
	func() *Value {
		return FromBool(true)
	},
	func() *Value {
		return FromBytes([]byte("byte contents"))
	},
	func() *Value {
		return FromFloat(math.Pi)
	},
	func() *Value {
		return FromInt(0x1337)
	},
	func() *Value {

Harshavardhana <******@****.***> 1622584780 -0700

	DB.Migrator().DropTable(&Harumph{})

	if err := DB.AutoMigrate(&Harumph{}); err != nil {
		t.Fatalf("Failed to migrate with default value, got error: %v", err)
	}

	harumph := Harumph{Email: "******@****.***"}
	if err := DB.Create(&harumph).Error; err != nil {
		t.Fatalf("Failed to create data with default value, got error: %v", err)

  cache.Insert("d", 4);
  int value = 0;
  EXPECT_TRUE(cache.Lookup("a", &value));
  EXPECT_EQ(value, 1);
  EXPECT_TRUE(cache.Lookup("b", &value));
  EXPECT_EQ(value, 2);
  EXPECT_TRUE(cache.Lookup("c", &value));
  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));

        value = "${a";
        assertEquals(value, ResourceUtil.resolve(value));

        value = "$a}";
        assertEquals(value, ResourceUtil.resolve(value));

        value = "${abc}";
        assertEquals(value, ResourceUtil.resolve(value));

        value = "${abc.xyz}";
        assertEquals(value, ResourceUtil.resolve(value));

        System.setProperty("abc", "123");

        value = "${abc}";

    for (int value : TEST_INTS) {
      assertWithMessage(UnsignedInts.toString(value))
          .that(UnsignedInteger.fromIntBits(value).intValue())
          .isEqualTo(value);
    }
  }

  public void testFromIntBitsLongValue() {
    for (int value : TEST_INTS) {
      long expected = value & 0xffffffffL;
      assertWithMessage(UnsignedInts.toString(value))

            ConstantValueKind.Double -> (value as Number).toDouble()
            ConstantValueKind.Float -> (value as Number).toFloat()
            ConstantValueKind.Int -> (value as Number).toInt()
            ConstantValueKind.Long -> (value as Number).toLong()
            ConstantValueKind.Short -> (value as Number).toShort()
            ConstantValueKind.UnsignedByte -> (value as Number).toLong().toUByte()

      assertWithMessage(UnsignedLongs.toString(value))
          .that(UnsignedLong.fromLongBits(value).longValue())
          .isEqualTo(value);
    }
  }

  public void testAsUnsignedBigIntegerValue() {
    for (long value : TEST_LONGS) {
      BigInteger expected =
          (value >= 0)
              ? BigInteger.valueOf(value)
              : BigInteger.valueOf(value).add(BigInteger.ZERO.setBit(64));

public final class CacheBuilderSpec {
  /** Parses a single value. */
  private interface ValueParser {
    void parse(CacheBuilderSpec spec, String key, @CheckForNull String value);
  }

  /** Splits each key-value pair. */
  private static final Splitter KEYS_SPLITTER = Splitter.on(',').trimResults();

  /** Splits the key from the value. */
  private static final Splitter KEY_VALUE_SPLITTER = Splitter.on('=').trimResults();