Add support for int64 and uint64 in values.h's API.

base/values_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <limits>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string16.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace base {
 
+const int64 kTestInt64 = -100200300400500600;
+
+// kTestUint64 is bigger than the max value for int64 and can only be converted
+// to a uint64.
+const uint64 kTestUint64 = 10100200300400500600U;
+
 TEST(ValuesTest, Basic) {
   // Test basic dictionary getting/setting
   DictionaryValue settings;
   std::string homepage = "http://google.com";
   ASSERT_FALSE(settings.GetString("global.homepage", &homepage));
   ASSERT_EQ(std::string("http://google.com"), homepage);
 
   ASSERT_FALSE(settings.Get("global", NULL));
   settings.Set("global", new FundamentalValue(true));
   ASSERT_TRUE(settings.Get("global", NULL));
@@ skipping 25 matching lines @@
   std::string bookmark_name = "Unnamed";
   ASSERT_TRUE(bookmark->GetString("name", &bookmark_name));
   ASSERT_EQ(std::string("Froogle"), bookmark_name);
   std::string bookmark_url;
   ASSERT_TRUE(bookmark->GetString("url", &bookmark_url));
   ASSERT_EQ(std::string("http://froogle.com"), bookmark_url);
 }
 
 TEST(ValuesTest, List) {
   scoped_ptr<ListValue> mixed_list(new ListValue());
-  mixed_list->Set(0, new FundamentalValue(true));
-  mixed_list->Set(1, new FundamentalValue(42));
-  mixed_list->Set(2, new FundamentalValue(88.8));
-  mixed_list->Set(3, new StringValue("foo"));
-  ASSERT_EQ(4u, mixed_list->GetSize());
+  mixed_list->AppendBoolean(true);
+  mixed_list->AppendInteger(42);
+  mixed_list->AppendDouble(88.8);
+  mixed_list->AppendString("foo");
+  mixed_list->AppendInt64(kTestInt64);
+  mixed_list->AppendUint64(kTestUint64);
+  ASSERT_EQ(6u, mixed_list->GetSize());
 
   Value *value = NULL;
   bool bool_value = false;
   int int_value = 0;
   double double_value = 0.0;
   std::string string_value;
+  int64 int64_value = 0;
+  uint64 uint64_value = 0;
 
-  ASSERT_FALSE(mixed_list->Get(4, &value));
+  ASSERT_FALSE(mixed_list->Get(6, &value));
 
   ASSERT_FALSE(mixed_list->GetInteger(0, &int_value));
   ASSERT_EQ(0, int_value);
   ASSERT_FALSE(mixed_list->GetBoolean(1, &bool_value));
   ASSERT_FALSE(bool_value);
   ASSERT_FALSE(mixed_list->GetString(2, &string_value));
   ASSERT_EQ("", string_value);
-  ASSERT_FALSE(mixed_list->GetInteger(2, &int_value));
+  ASSERT_FALSE(mixed_list->GetInt64(2, &int64_value));
+  ASSERT_EQ(0, int64_value);
+  ASSERT_FALSE(mixed_list->GetUint64(3, &uint64_value));
+  ASSERT_FALSE(uint64_value);
+  ASSERT_FALSE(mixed_list->GetInteger(4, &int_value));
   ASSERT_EQ(0, int_value);
-  ASSERT_FALSE(mixed_list->GetBoolean(3, &bool_value));
-  ASSERT_FALSE(bool_value);
+  ASSERT_FALSE(mixed_list->GetInteger(5, &int_value));
+  ASSERT_EQ(0, int_value);
 
   ASSERT_TRUE(mixed_list->GetBoolean(0, &bool_value));
   ASSERT_TRUE(bool_value);
   ASSERT_TRUE(mixed_list->GetInteger(1, &int_value));
   ASSERT_EQ(42, int_value);
   // implicit conversion from Integer to Double should be possible.
   ASSERT_TRUE(mixed_list->GetDouble(1, &double_value));
   ASSERT_EQ(42, double_value);
   ASSERT_TRUE(mixed_list->GetDouble(2, &double_value));
   ASSERT_EQ(88.8, double_value);
   ASSERT_TRUE(mixed_list->GetString(3, &string_value));
   ASSERT_EQ("foo", string_value);
+  ASSERT_TRUE(mixed_list->GetInt64(4, &int64_value));
+  ASSERT_EQ(kTestInt64, int64_value);
+  ASSERT_TRUE(mixed_list->GetUint64(5, &uint64_value));
+  ASSERT_EQ(kTestUint64, uint64_value);
 
   // Try searching in the mixed list.
-  base::FundamentalValue sought_value(42);
+  base::FundamentalValue sought_int_value(42);
+  base::StringValue sought_int64_value(kTestInt64);
   base::FundamentalValue not_found_value(false);
+  ListValue::const_iterator found_value_it;
 
-  ASSERT_NE(mixed_list->end(), mixed_list->Find(sought_value));
-  ASSERT_TRUE((*mixed_list->Find(sought_value))->GetAsInteger(&int_value));
-  ASSERT_EQ(42, int_value);
+  found_value_it = mixed_list->Find(sought_int_value);
+  ASSERT_NE(mixed_list->end(), found_value_it);
+  int found_int_value;
+  ASSERT_TRUE((*found_value_it)->GetAsInteger(&found_int_value));
+  ASSERT_EQ(42, found_int_value);
+
+  found_value_it = mixed_list->Find(sought_int64_value);
+  ASSERT_NE(mixed_list->end(), found_value_it);
+  int64 found_int64_value;
+  ASSERT_TRUE((*found_value_it)->GetAsInt64(&found_int64_value));
+  ASSERT_EQ(kTestInt64, found_int64_value);
+
   ASSERT_EQ(mixed_list->end(), mixed_list->Find(not_found_value));
 }
 
 TEST(ValuesTest, BinaryValue) {
   // Default constructor creates a BinaryValue with a null buffer and size 0.
   scoped_ptr<BinaryValue> binary(new BinaryValue());
   ASSERT_TRUE(binary.get());
   ASSERT_EQ(NULL, binary->GetBuffer());
   ASSERT_EQ(0U, binary->GetSize());
 
@@ skipping 42 matching lines @@
   ASSERT_EQ(ASCIIToUTF16("utf16"), utf16);
   ASSERT_EQ(string_value->GetString(), narrow);
 
   // Don't choke on NULL values.
   ASSERT_TRUE(narrow_value->GetAsString(static_cast<string16*>(NULL)));
   ASSERT_TRUE(narrow_value->GetAsString(static_cast<std::string*>(NULL)));
   ASSERT_TRUE(narrow_value->GetAsString(
                   static_cast<const StringValue**>(NULL)));
 }
 
+TEST(ValuesTest, StringValueInt64) {
+  // Test overloaded StringValue constructors for (u)int64.
+  scoped_ptr<Value> test_int64_value(new StringValue(kTestInt64));
+  ASSERT_TRUE(test_int64_value.get());
+  ASSERT_TRUE(test_int64_value->IsType(Value::TYPE_STRING));
+
+  scoped_ptr<Value> test_uint64_value(new StringValue(kTestUint64));
+  ASSERT_TRUE(test_uint64_value.get());
+  ASSERT_TRUE(test_uint64_value->IsType(Value::TYPE_STRING));
+
+  // Test overloaded GetAs(U)Int64.
+  int64 actual_int64_value;
+  ASSERT_TRUE(test_int64_value->GetAsInt64(&actual_int64_value));
+  ASSERT_EQ(kTestInt64, actual_int64_value);
+
+  uint64 actual_uint64_value;
+  ASSERT_TRUE(test_uint64_value->GetAsUint64(&actual_uint64_value));
+  ASSERT_EQ(kTestUint64, actual_uint64_value);
+
+  // Don't choke on NULL values.
+  ASSERT_TRUE(test_int64_value->GetAsInt64(static_cast<int64*>(NULL)));
+  ASSERT_TRUE(test_uint64_value->GetAsUint64(static_cast<uint64*>(NULL)));
+}
+
 // This is a Value object that allows us to tell if it's been
 // properly deleted by modifying the value of external flag on destruction.
 class DeletionTestValue : public Value {
  public:
   explicit DeletionTestValue(bool* deletion_flag) : Value(TYPE_NULL) {
     Init(deletion_flag);  // Separate function so that we can use ASSERT_*
   }
 
   void Init(bool* deletion_flag) {
     ASSERT_TRUE(deletion_flag);
@@ skipping 636 matching lines @@
 // DictionaryValue/ListValue's Get*() methods should accept NULL as an out-value
 // and still return true/false based on success.
 TEST(ValuesTest, GetWithNullOutValue) {
   DictionaryValue main_dict;
   ListValue main_list;
 
   FundamentalValue bool_value(false);
   FundamentalValue int_value(1234);
   FundamentalValue double_value(12.34567);
   StringValue string_value("foo");
+  StringValue int64_value(kTestInt64);
+  StringValue uint64_value(kTestUint64);
   BinaryValue binary_value;
   DictionaryValue dict_value;
   ListValue list_value;
 
   main_dict.Set("bool", bool_value.DeepCopy());
   main_dict.Set("int", int_value.DeepCopy());
   main_dict.Set("double", double_value.DeepCopy());
   main_dict.Set("string", string_value.DeepCopy());
+  main_dict.Set("int64", int64_value.DeepCopy());
+  main_dict.Set("uint64", uint64_value.DeepCopy());
   main_dict.Set("binary", binary_value.DeepCopy());
   main_dict.Set("dict", dict_value.DeepCopy());
   main_dict.Set("list", list_value.DeepCopy());
 
   main_list.Append(bool_value.DeepCopy());
   main_list.Append(int_value.DeepCopy());
   main_list.Append(double_value.DeepCopy());
   main_list.Append(string_value.DeepCopy());
+  main_list.Append(int64_value.DeepCopy());
+  main_list.Append(uint64_value.DeepCopy());
   main_list.Append(binary_value.DeepCopy());
   main_list.Append(dict_value.DeepCopy());
   main_list.Append(list_value.DeepCopy());
 
   EXPECT_TRUE(main_dict.Get("bool", NULL));
   EXPECT_TRUE(main_dict.Get("int", NULL));
   EXPECT_TRUE(main_dict.Get("double", NULL));
   EXPECT_TRUE(main_dict.Get("string", NULL));
+  EXPECT_TRUE(main_dict.Get("int64", NULL));
+  EXPECT_TRUE(main_dict.Get("uint64", NULL));
   EXPECT_TRUE(main_dict.Get("binary", NULL));
   EXPECT_TRUE(main_dict.Get("dict", NULL));
   EXPECT_TRUE(main_dict.Get("list", NULL));
   EXPECT_FALSE(main_dict.Get("DNE", NULL));
 
   EXPECT_TRUE(main_dict.GetBoolean("bool", NULL));
   EXPECT_FALSE(main_dict.GetBoolean("int", NULL));
   EXPECT_FALSE(main_dict.GetBoolean("double", NULL));
   EXPECT_FALSE(main_dict.GetBoolean("string", NULL));
+  EXPECT_FALSE(main_dict.GetBoolean("int64", NULL));
+  EXPECT_FALSE(main_dict.GetBoolean("uint64", NULL));
   EXPECT_FALSE(main_dict.GetBoolean("binary", NULL));
   EXPECT_FALSE(main_dict.GetBoolean("dict", NULL));
   EXPECT_FALSE(main_dict.GetBoolean("list", NULL));
   EXPECT_FALSE(main_dict.GetBoolean("DNE", NULL));
 
   EXPECT_FALSE(main_dict.GetInteger("bool", NULL));
   EXPECT_TRUE(main_dict.GetInteger("int", NULL));
   EXPECT_FALSE(main_dict.GetInteger("double", NULL));
   EXPECT_FALSE(main_dict.GetInteger("string", NULL));
+  EXPECT_FALSE(main_dict.GetInteger("int64", NULL));
+  EXPECT_FALSE(main_dict.GetInteger("uint64", NULL));
   EXPECT_FALSE(main_dict.GetInteger("binary", NULL));
   EXPECT_FALSE(main_dict.GetInteger("dict", NULL));
   EXPECT_FALSE(main_dict.GetInteger("list", NULL));
   EXPECT_FALSE(main_dict.GetInteger("DNE", NULL));
 
   // Both int and double values can be obtained from GetDouble.
   EXPECT_FALSE(main_dict.GetDouble("bool", NULL));
   EXPECT_TRUE(main_dict.GetDouble("int", NULL));
   EXPECT_TRUE(main_dict.GetDouble("double", NULL));
   EXPECT_FALSE(main_dict.GetDouble("string", NULL));
+  EXPECT_FALSE(main_dict.GetDouble("int64", NULL));
+  EXPECT_FALSE(main_dict.GetDouble("uint64", NULL));
   EXPECT_FALSE(main_dict.GetDouble("binary", NULL));
   EXPECT_FALSE(main_dict.GetDouble("dict", NULL));
   EXPECT_FALSE(main_dict.GetDouble("list", NULL));
   EXPECT_FALSE(main_dict.GetDouble("DNE", NULL));
 
   EXPECT_FALSE(main_dict.GetString("bool", static_cast<std::string*>(NULL)));
   EXPECT_FALSE(main_dict.GetString("int", static_cast<std::string*>(NULL)));
   EXPECT_FALSE(main_dict.GetString("double", static_cast<std::string*>(NULL)));
   EXPECT_TRUE(main_dict.GetString("string", static_cast<std::string*>(NULL)));
+  EXPECT_TRUE(main_dict.GetString("int64", static_cast<std::string*>(NULL)));
+  EXPECT_TRUE(main_dict.GetString("uint64", static_cast<std::string*>(NULL)));
   EXPECT_FALSE(main_dict.GetString("binary", static_cast<std::string*>(NULL)));
   EXPECT_FALSE(main_dict.GetString("dict", static_cast<std::string*>(NULL)));
   EXPECT_FALSE(main_dict.GetString("list", static_cast<std::string*>(NULL)));
   EXPECT_FALSE(main_dict.GetString("DNE", static_cast<std::string*>(NULL)));
 
   EXPECT_FALSE(main_dict.GetString("bool", static_cast<string16*>(NULL)));
   EXPECT_FALSE(main_dict.GetString("int", static_cast<string16*>(NULL)));
   EXPECT_FALSE(main_dict.GetString("double", static_cast<string16*>(NULL)));
   EXPECT_TRUE(main_dict.GetString("string", static_cast<string16*>(NULL)));
+  EXPECT_TRUE(main_dict.GetString("int64", static_cast<string16*>(NULL)));
+  EXPECT_TRUE(main_dict.GetString("uint64", static_cast<string16*>(NULL)));
   EXPECT_FALSE(main_dict.GetString("binary", static_cast<string16*>(NULL)));
   EXPECT_FALSE(main_dict.GetString("dict", static_cast<string16*>(NULL)));
   EXPECT_FALSE(main_dict.GetString("list", static_cast<string16*>(NULL)));
   EXPECT_FALSE(main_dict.GetString("DNE", static_cast<string16*>(NULL)));
 
+  EXPECT_FALSE(main_dict.GetInt64("bool", NULL));
+  EXPECT_FALSE(main_dict.GetInt64("int", NULL));
+  EXPECT_FALSE(main_dict.GetInt64("double", NULL));
+  EXPECT_FALSE(main_dict.GetInt64("string", NULL));
+  EXPECT_TRUE(main_dict.GetInt64("int64", NULL));
+  EXPECT_FALSE(main_dict.GetInt64("uint64", NULL));
+  EXPECT_FALSE(main_dict.GetInt64("binary", NULL));
+  EXPECT_FALSE(main_dict.GetInt64("dict", NULL));
+  EXPECT_FALSE(main_dict.GetInt64("list", NULL));
+  EXPECT_FALSE(main_dict.GetInt64("DNE", NULL));
+
+  EXPECT_FALSE(main_dict.GetUint64("bool", NULL));
+  EXPECT_FALSE(main_dict.GetUint64("int", NULL));
+  EXPECT_FALSE(main_dict.GetUint64("double", NULL));
+  EXPECT_FALSE(main_dict.GetUint64("string", NULL));
+  EXPECT_FALSE(main_dict.GetUint64("int64", NULL));
+  EXPECT_TRUE(main_dict.GetUint64("uint64", NULL));
+  EXPECT_FALSE(main_dict.GetUint64("binary", NULL));
+  EXPECT_FALSE(main_dict.GetUint64("dict", NULL));
+  EXPECT_FALSE(main_dict.GetUint64("list", NULL));
+  EXPECT_FALSE(main_dict.GetUint64("DNE", NULL));
+
   EXPECT_FALSE(main_dict.GetBinary("bool", NULL));
   EXPECT_FALSE(main_dict.GetBinary("int", NULL));
   EXPECT_FALSE(main_dict.GetBinary("double", NULL));
   EXPECT_FALSE(main_dict.GetBinary("string", NULL));
+  EXPECT_FALSE(main_dict.GetBinary("int64", NULL));
+  EXPECT_FALSE(main_dict.GetBinary("uint64", NULL));
   EXPECT_TRUE(main_dict.GetBinary("binary", NULL));
   EXPECT_FALSE(main_dict.GetBinary("dict", NULL));
   EXPECT_FALSE(main_dict.GetBinary("list", NULL));
   EXPECT_FALSE(main_dict.GetBinary("DNE", NULL));
 
   EXPECT_FALSE(main_dict.GetDictionary("bool", NULL));
   EXPECT_FALSE(main_dict.GetDictionary("int", NULL));
   EXPECT_FALSE(main_dict.GetDictionary("double", NULL));
   EXPECT_FALSE(main_dict.GetDictionary("string", NULL));
+  EXPECT_FALSE(main_dict.GetDictionary("int64", NULL));
+  EXPECT_FALSE(main_dict.GetDictionary("uint64", NULL));
   EXPECT_FALSE(main_dict.GetDictionary("binary", NULL));
   EXPECT_TRUE(main_dict.GetDictionary("dict", NULL));
   EXPECT_FALSE(main_dict.GetDictionary("list", NULL));
   EXPECT_FALSE(main_dict.GetDictionary("DNE", NULL));
 
   EXPECT_FALSE(main_dict.GetList("bool", NULL));
   EXPECT_FALSE(main_dict.GetList("int", NULL));
   EXPECT_FALSE(main_dict.GetList("double", NULL));
   EXPECT_FALSE(main_dict.GetList("string", NULL));
+  EXPECT_FALSE(main_dict.GetList("int64", NULL));
+  EXPECT_FALSE(main_dict.GetList("uint64", NULL));
   EXPECT_FALSE(main_dict.GetList("binary", NULL));
   EXPECT_FALSE(main_dict.GetList("dict", NULL));
   EXPECT_TRUE(main_dict.GetList("list", NULL));
   EXPECT_FALSE(main_dict.GetList("DNE", NULL));
 
   EXPECT_TRUE(main_dict.GetWithoutPathExpansion("bool", NULL));
   EXPECT_TRUE(main_dict.GetWithoutPathExpansion("int", NULL));
   EXPECT_TRUE(main_dict.GetWithoutPathExpansion("double", NULL));
   EXPECT_TRUE(main_dict.GetWithoutPathExpansion("string", NULL));
+  EXPECT_TRUE(main_dict.GetWithoutPathExpansion("int64", NULL));
+  EXPECT_TRUE(main_dict.GetWithoutPathExpansion("uint64", NULL));
   EXPECT_TRUE(main_dict.GetWithoutPathExpansion("binary", NULL));
   EXPECT_TRUE(main_dict.GetWithoutPathExpansion("dict", NULL));
   EXPECT_TRUE(main_dict.GetWithoutPathExpansion("list", NULL));
   EXPECT_FALSE(main_dict.GetWithoutPathExpansion("DNE", NULL));
 
   EXPECT_TRUE(main_dict.GetBooleanWithoutPathExpansion("bool", NULL));
   EXPECT_FALSE(main_dict.GetBooleanWithoutPathExpansion("int", NULL));
   EXPECT_FALSE(main_dict.GetBooleanWithoutPathExpansion("double", NULL));
   EXPECT_FALSE(main_dict.GetBooleanWithoutPathExpansion("string", NULL));
+  EXPECT_FALSE(main_dict.GetBooleanWithoutPathExpansion("int64", NULL));
+  EXPECT_FALSE(main_dict.GetBooleanWithoutPathExpansion("uint64", NULL));
   EXPECT_FALSE(main_dict.GetBooleanWithoutPathExpansion("binary", NULL));
   EXPECT_FALSE(main_dict.GetBooleanWithoutPathExpansion("dict", NULL));
   EXPECT_FALSE(main_dict.GetBooleanWithoutPathExpansion("list", NULL));
   EXPECT_FALSE(main_dict.GetBooleanWithoutPathExpansion("DNE", NULL));
 
   EXPECT_FALSE(main_dict.GetIntegerWithoutPathExpansion("bool", NULL));
   EXPECT_TRUE(main_dict.GetIntegerWithoutPathExpansion("int", NULL));
   EXPECT_FALSE(main_dict.GetIntegerWithoutPathExpansion("double", NULL));
   EXPECT_FALSE(main_dict.GetIntegerWithoutPathExpansion("string", NULL));
+  EXPECT_FALSE(main_dict.GetIntegerWithoutPathExpansion("int64", NULL));
+  EXPECT_FALSE(main_dict.GetIntegerWithoutPathExpansion("uint64", NULL));
   EXPECT_FALSE(main_dict.GetIntegerWithoutPathExpansion("binary", NULL));
   EXPECT_FALSE(main_dict.GetIntegerWithoutPathExpansion("dict", NULL));
   EXPECT_FALSE(main_dict.GetIntegerWithoutPathExpansion("list", NULL));
   EXPECT_FALSE(main_dict.GetIntegerWithoutPathExpansion("DNE", NULL));
 
   EXPECT_FALSE(main_dict.GetDoubleWithoutPathExpansion("bool", NULL));
   EXPECT_TRUE(main_dict.GetDoubleWithoutPathExpansion("int", NULL));
   EXPECT_TRUE(main_dict.GetDoubleWithoutPathExpansion("double", NULL));
   EXPECT_FALSE(main_dict.GetDoubleWithoutPathExpansion("string", NULL));
+  EXPECT_FALSE(main_dict.GetDoubleWithoutPathExpansion("int64", NULL));
+  EXPECT_FALSE(main_dict.GetDoubleWithoutPathExpansion("uint64", NULL));
   EXPECT_FALSE(main_dict.GetDoubleWithoutPathExpansion("binary", NULL));
   EXPECT_FALSE(main_dict.GetDoubleWithoutPathExpansion("dict", NULL));
   EXPECT_FALSE(main_dict.GetDoubleWithoutPathExpansion("list", NULL));
   EXPECT_FALSE(main_dict.GetDoubleWithoutPathExpansion("DNE", NULL));
 
   EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion(
       "bool", static_cast<std::string*>(NULL)));
   EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion(
       "int", static_cast<std::string*>(NULL)));
   EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion(
       "double", static_cast<std::string*>(NULL)));
   EXPECT_TRUE(main_dict.GetStringWithoutPathExpansion(
       "string", static_cast<std::string*>(NULL)));
+  EXPECT_TRUE(main_dict.GetStringWithoutPathExpansion(
+      "int64", static_cast<std::string*>(NULL)));
+  EXPECT_TRUE(main_dict.GetStringWithoutPathExpansion(
+      "uint64", static_cast<std::string*>(NULL)));
   EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion(
       "binary", static_cast<std::string*>(NULL)));
   EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion(
       "dict", static_cast<std::string*>(NULL)));
   EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion(
       "list", static_cast<std::string*>(NULL)));
   EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion(
       "DNE", static_cast<std::string*>(NULL)));
 
   EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion(
       "bool", static_cast<string16*>(NULL)));
   EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion(
       "int", static_cast<string16*>(NULL)));
   EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion(
       "double", static_cast<string16*>(NULL)));
   EXPECT_TRUE(main_dict.GetStringWithoutPathExpansion(
       "string", static_cast<string16*>(NULL)));
+  EXPECT_TRUE(main_dict.GetStringWithoutPathExpansion(
+      "int64", static_cast<string16*>(NULL)));
+  EXPECT_TRUE(main_dict.GetStringWithoutPathExpansion(
+      "uint64", static_cast<string16*>(NULL)));
   EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion(
       "binary", static_cast<string16*>(NULL)));
   EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion(
       "dict", static_cast<string16*>(NULL)));
   EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion(
       "list", static_cast<string16*>(NULL)));
   EXPECT_FALSE(main_dict.GetStringWithoutPathExpansion(
       "DNE", static_cast<string16*>(NULL)));
 
+  EXPECT_FALSE(main_dict.GetInt64WithoutPathExpansion("bool", NULL));
+  EXPECT_FALSE(main_dict.GetInt64WithoutPathExpansion("int", NULL));
+  EXPECT_FALSE(main_dict.GetInt64WithoutPathExpansion("double", NULL));
+  EXPECT_FALSE(main_dict.GetInt64WithoutPathExpansion("string", NULL));
+  EXPECT_TRUE(main_dict.GetInt64WithoutPathExpansion("int64", NULL));
+  EXPECT_FALSE(main_dict.GetInt64WithoutPathExpansion("uint64", NULL));
+  EXPECT_FALSE(main_dict.GetInt64WithoutPathExpansion("binary", NULL));
+  EXPECT_FALSE(main_dict.GetInt64WithoutPathExpansion("dict", NULL));
+  EXPECT_FALSE(main_dict.GetInt64WithoutPathExpansion("list", NULL));
+  EXPECT_FALSE(main_dict.GetInt64WithoutPathExpansion("DNE", NULL));
+
+  EXPECT_FALSE(main_dict.GetUint64WithoutPathExpansion("bool", NULL));
+  EXPECT_FALSE(main_dict.GetUint64WithoutPathExpansion("int", NULL));
+  EXPECT_FALSE(main_dict.GetUint64WithoutPathExpansion("double", NULL));
+  EXPECT_FALSE(main_dict.GetUint64WithoutPathExpansion("string", NULL));
+  EXPECT_FALSE(main_dict.GetUint64WithoutPathExpansion("int64", NULL));
+  EXPECT_TRUE(main_dict.GetUint64WithoutPathExpansion("uint64", NULL));
+  EXPECT_FALSE(main_dict.GetUint64WithoutPathExpansion("binary", NULL));
+  EXPECT_FALSE(main_dict.GetUint64WithoutPathExpansion("dict", NULL));
+  EXPECT_FALSE(main_dict.GetUint64WithoutPathExpansion("list", NULL));
+  EXPECT_FALSE(main_dict.GetUint64WithoutPathExpansion("DNE", NULL));
+
   // There is no GetBinaryWithoutPathExpansion for some reason, but if there
   // were it should be tested here...
 
   EXPECT_FALSE(main_dict.GetDictionaryWithoutPathExpansion("bool", NULL));
   EXPECT_FALSE(main_dict.GetDictionaryWithoutPathExpansion("int", NULL));
   EXPECT_FALSE(main_dict.GetDictionaryWithoutPathExpansion("double", NULL));
   EXPECT_FALSE(main_dict.GetDictionaryWithoutPathExpansion("string", NULL));
+  EXPECT_FALSE(main_dict.GetDictionaryWithoutPathExpansion("int64", NULL));
+  EXPECT_FALSE(main_dict.GetDictionaryWithoutPathExpansion("uint64", NULL));
   EXPECT_FALSE(main_dict.GetDictionaryWithoutPathExpansion("binary", NULL));
   EXPECT_TRUE(main_dict.GetDictionaryWithoutPathExpansion("dict", NULL));
   EXPECT_FALSE(main_dict.GetDictionaryWithoutPathExpansion("list", NULL));
   EXPECT_FALSE(main_dict.GetDictionaryWithoutPathExpansion("DNE", NULL));
 
   EXPECT_FALSE(main_dict.GetListWithoutPathExpansion("bool", NULL));
   EXPECT_FALSE(main_dict.GetListWithoutPathExpansion("int", NULL));
   EXPECT_FALSE(main_dict.GetListWithoutPathExpansion("double", NULL));
   EXPECT_FALSE(main_dict.GetListWithoutPathExpansion("string", NULL));
+  EXPECT_FALSE(main_dict.GetListWithoutPathExpansion("int64", NULL));
+  EXPECT_FALSE(main_dict.GetListWithoutPathExpansion("uint64", NULL));
   EXPECT_FALSE(main_dict.GetListWithoutPathExpansion("binary", NULL));
   EXPECT_FALSE(main_dict.GetListWithoutPathExpansion("dict", NULL));
   EXPECT_TRUE(main_dict.GetListWithoutPathExpansion("list", NULL));
   EXPECT_FALSE(main_dict.GetListWithoutPathExpansion("DNE", NULL));
 
   EXPECT_TRUE(main_list.Get(0, NULL));
   EXPECT_TRUE(main_list.Get(1, NULL));
   EXPECT_TRUE(main_list.Get(2, NULL));
   EXPECT_TRUE(main_list.Get(3, NULL));
   EXPECT_TRUE(main_list.Get(4, NULL));
   EXPECT_TRUE(main_list.Get(5, NULL));
   EXPECT_TRUE(main_list.Get(6, NULL));
-  EXPECT_FALSE(main_list.Get(7, NULL));
+  EXPECT_TRUE(main_list.Get(7, NULL));
+  EXPECT_TRUE(main_list.Get(8, NULL));
+  EXPECT_FALSE(main_list.Get(9, NULL));
 
   EXPECT_TRUE(main_list.GetBoolean(0, NULL));
   EXPECT_FALSE(main_list.GetBoolean(1, NULL));
   EXPECT_FALSE(main_list.GetBoolean(2, NULL));
   EXPECT_FALSE(main_list.GetBoolean(3, NULL));
   EXPECT_FALSE(main_list.GetBoolean(4, NULL));
   EXPECT_FALSE(main_list.GetBoolean(5, NULL));
   EXPECT_FALSE(main_list.GetBoolean(6, NULL));
   EXPECT_FALSE(main_list.GetBoolean(7, NULL));
+  EXPECT_FALSE(main_list.GetBoolean(8, NULL));
+  EXPECT_FALSE(main_list.GetBoolean(9, NULL));
 
   EXPECT_FALSE(main_list.GetInteger(0, NULL));
   EXPECT_TRUE(main_list.GetInteger(1, NULL));
   EXPECT_FALSE(main_list.GetInteger(2, NULL));
   EXPECT_FALSE(main_list.GetInteger(3, NULL));
   EXPECT_FALSE(main_list.GetInteger(4, NULL));
   EXPECT_FALSE(main_list.GetInteger(5, NULL));
   EXPECT_FALSE(main_list.GetInteger(6, NULL));
   EXPECT_FALSE(main_list.GetInteger(7, NULL));
+  EXPECT_FALSE(main_list.GetInteger(8, NULL));
+  EXPECT_FALSE(main_list.GetInteger(9, NULL));
 
   EXPECT_FALSE(main_list.GetDouble(0, NULL));
   EXPECT_TRUE(main_list.GetDouble(1, NULL));
   EXPECT_TRUE(main_list.GetDouble(2, NULL));
   EXPECT_FALSE(main_list.GetDouble(3, NULL));
   EXPECT_FALSE(main_list.GetDouble(4, NULL));
   EXPECT_FALSE(main_list.GetDouble(5, NULL));
   EXPECT_FALSE(main_list.GetDouble(6, NULL));
   EXPECT_FALSE(main_list.GetDouble(7, NULL));
+  EXPECT_FALSE(main_list.GetDouble(8, NULL));
+  EXPECT_FALSE(main_list.GetDouble(9, NULL));
 
   EXPECT_FALSE(main_list.GetString(0, static_cast<std::string*>(NULL)));
   EXPECT_FALSE(main_list.GetString(1, static_cast<std::string*>(NULL)));
   EXPECT_FALSE(main_list.GetString(2, static_cast<std::string*>(NULL)));
   EXPECT_TRUE(main_list.GetString(3, static_cast<std::string*>(NULL)));
-  EXPECT_FALSE(main_list.GetString(4, static_cast<std::string*>(NULL)));
-  EXPECT_FALSE(main_list.GetString(5, static_cast<std::string*>(NULL)));
+  EXPECT_TRUE(main_list.GetString(4, static_cast<std::string*>(NULL)));
+  EXPECT_TRUE(main_list.GetString(5, static_cast<std::string*>(NULL)));
   EXPECT_FALSE(main_list.GetString(6, static_cast<std::string*>(NULL)));
   EXPECT_FALSE(main_list.GetString(7, static_cast<std::string*>(NULL)));
+  EXPECT_FALSE(main_list.GetString(8, static_cast<std::string*>(NULL)));
+  EXPECT_FALSE(main_list.GetString(9, static_cast<std::string*>(NULL)));
 
   EXPECT_FALSE(main_list.GetString(0, static_cast<string16*>(NULL)));
   EXPECT_FALSE(main_list.GetString(1, static_cast<string16*>(NULL)));
   EXPECT_FALSE(main_list.GetString(2, static_cast<string16*>(NULL)));
   EXPECT_TRUE(main_list.GetString(3, static_cast<string16*>(NULL)));
-  EXPECT_FALSE(main_list.GetString(4, static_cast<string16*>(NULL)));
-  EXPECT_FALSE(main_list.GetString(5, static_cast<string16*>(NULL)));
+  EXPECT_TRUE(main_list.GetString(4, static_cast<string16*>(NULL)));
+  EXPECT_TRUE(main_list.GetString(5, static_cast<string16*>(NULL)));
   EXPECT_FALSE(main_list.GetString(6, static_cast<string16*>(NULL)));
   EXPECT_FALSE(main_list.GetString(7, static_cast<string16*>(NULL)));
+  EXPECT_FALSE(main_list.GetString(8, static_cast<string16*>(NULL)));
+  EXPECT_FALSE(main_list.GetString(9, static_cast<string16*>(NULL)));
+
+  EXPECT_FALSE(main_list.GetInt64(0, NULL));
+  EXPECT_FALSE(main_list.GetInt64(1, NULL));
+  EXPECT_FALSE(main_list.GetInt64(2, NULL));
+  EXPECT_FALSE(main_list.GetInt64(3, NULL));
+  EXPECT_TRUE(main_list.GetInt64(4, NULL));
+  EXPECT_FALSE(main_list.GetInt64(5, NULL));
+  EXPECT_FALSE(main_list.GetInt64(6, NULL));
+  EXPECT_FALSE(main_list.GetInt64(7, NULL));
+  EXPECT_FALSE(main_list.GetInt64(8, NULL));
+  EXPECT_FALSE(main_list.GetInt64(9, NULL));
+
+  EXPECT_FALSE(main_list.GetUint64(0, NULL));
+  EXPECT_FALSE(main_list.GetUint64(1, NULL));
+  EXPECT_FALSE(main_list.GetUint64(2, NULL));
+  EXPECT_FALSE(main_list.GetUint64(3, NULL));
+  EXPECT_FALSE(main_list.GetUint64(4, NULL));
+  EXPECT_TRUE(main_list.GetUint64(5, NULL));
+  EXPECT_FALSE(main_list.GetUint64(6, NULL));
+  EXPECT_FALSE(main_list.GetUint64(7, NULL));
+  EXPECT_FALSE(main_list.GetUint64(8, NULL));
+  EXPECT_FALSE(main_list.GetUint64(9, NULL));
 
   EXPECT_FALSE(main_list.GetBinary(0, NULL));
   EXPECT_FALSE(main_list.GetBinary(1, NULL));
   EXPECT_FALSE(main_list.GetBinary(2, NULL));
   EXPECT_FALSE(main_list.GetBinary(3, NULL));
-  EXPECT_TRUE(main_list.GetBinary(4, NULL));
+  EXPECT_FALSE(main_list.GetBinary(4, NULL));
   EXPECT_FALSE(main_list.GetBinary(5, NULL));
-  EXPECT_FALSE(main_list.GetBinary(6, NULL));
+  EXPECT_TRUE(main_list.GetBinary(6, NULL));
   EXPECT_FALSE(main_list.GetBinary(7, NULL));
+  EXPECT_FALSE(main_list.GetBinary(8, NULL));
+  EXPECT_FALSE(main_list.GetBinary(9, NULL));
 
   EXPECT_FALSE(main_list.GetDictionary(0, NULL));
   EXPECT_FALSE(main_list.GetDictionary(1, NULL));
   EXPECT_FALSE(main_list.GetDictionary(2, NULL));
   EXPECT_FALSE(main_list.GetDictionary(3, NULL));
   EXPECT_FALSE(main_list.GetDictionary(4, NULL));
-  EXPECT_TRUE(main_list.GetDictionary(5, NULL));
+  EXPECT_FALSE(main_list.GetDictionary(5, NULL));
   EXPECT_FALSE(main_list.GetDictionary(6, NULL));
-  EXPECT_FALSE(main_list.GetDictionary(7, NULL));
+  EXPECT_TRUE(main_list.GetDictionary(7, NULL));
+  EXPECT_FALSE(main_list.GetDictionary(8, NULL));
+  EXPECT_FALSE(main_list.GetDictionary(9, NULL));
 
   EXPECT_FALSE(main_list.GetList(0, NULL));
   EXPECT_FALSE(main_list.GetList(1, NULL));
   EXPECT_FALSE(main_list.GetList(2, NULL));
   EXPECT_FALSE(main_list.GetList(3, NULL));
   EXPECT_FALSE(main_list.GetList(4, NULL));
   EXPECT_FALSE(main_list.GetList(5, NULL));
-  EXPECT_TRUE(main_list.GetList(6, NULL));
+  EXPECT_FALSE(main_list.GetList(6, NULL));
   EXPECT_FALSE(main_list.GetList(7, NULL));
+  EXPECT_TRUE(main_list.GetList(8, NULL));
+  EXPECT_FALSE(main_list.GetList(9, NULL));
 }
 
 }  // namespace base