Add TYPE_INTEGER64 type to base::Value.

base/values_unittest.cc

 // Copyright (c) 2011 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 <cmath>
 #include <limits>
 
+#include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/string16.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace base {
 
 TEST(ValuesTest, Basic) {
   // Test basic dictionary getting/setting
@@ skipping 35 matching lines @@
   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, Value::CreateBooleanValue(true));
   mixed_list->Set(1, Value::CreateIntegerValue(42));
-  mixed_list->Set(2, Value::CreateDoubleValue(88.8));
-  mixed_list->Set(3, Value::CreateStringValue("foo"));
-  ASSERT_EQ(4u, mixed_list->GetSize());
+  mixed_list->Set(2, Value::CreateInteger64Value(std::pow(2, 42)));
+  mixed_list->Set(3, Value::CreateDoubleValue(88.8));
+  mixed_list->Set(4, Value::CreateStringValue("foo"));
+  ASSERT_EQ(5u, mixed_list->GetSize());
 
   Value *value = NULL;
   bool bool_value = false;
   int int_value = 0;
+  int64 int64_value = 0;
   double double_value = 0.0;
   std::string string_value;
 
-  ASSERT_FALSE(mixed_list->Get(4, &value));
+  ASSERT_FALSE(mixed_list->Get(5, &value));
 
   ASSERT_FALSE(mixed_list->GetInteger(0, &int_value));
   ASSERT_EQ(0, int_value);
+  ASSERT_FALSE(mixed_list->GetInteger64(0, &int64_value));
+  ASSERT_EQ(0, int64_value);
   ASSERT_FALSE(mixed_list->GetBoolean(1, &bool_value));
   ASSERT_FALSE(bool_value);
-  ASSERT_FALSE(mixed_list->GetString(2, &string_value));
+  ASSERT_FALSE(mixed_list->GetBoolean(2, &bool_value));
+  ASSERT_FALSE(bool_value);
+  ASSERT_FALSE(mixed_list->GetInteger(2, &int_value));
+  ASSERT_FALSE(int_value);
+  // Implicit conversion from int64 to double is not allowed, even if the
+  // double can represent the integer.
+  ASSERT_FALSE(mixed_list->GetDouble(2, &double_value));
+  ASSERT_FALSE(double_value);
+  ASSERT_FALSE(mixed_list->GetString(3, &string_value));
   ASSERT_EQ("", string_value);
-  ASSERT_FALSE(mixed_list->GetInteger(2, &int_value));
+  ASSERT_FALSE(mixed_list->GetInteger(3, &int_value));
   ASSERT_EQ(0, int_value);
-  ASSERT_FALSE(mixed_list->GetBoolean(3, &bool_value));
+  ASSERT_FALSE(mixed_list->GetInteger64(3, &int64_value));
+  ASSERT_EQ(0, int64_value);
+  ASSERT_FALSE(mixed_list->GetBoolean(4, &bool_value));
   ASSERT_FALSE(bool_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.
+  // 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_TRUE(mixed_list->GetInteger64(1, &int64_value));
+  ASSERT_EQ(42, int64_value);
+  ASSERT_TRUE(mixed_list->GetInteger64(2, &int64_value));
+  ASSERT_EQ(std::pow(2, 42), int64_value);
+  ASSERT_TRUE(mixed_list->GetDouble(3, &double_value));
   ASSERT_EQ(88.8, double_value);
-  ASSERT_TRUE(mixed_list->GetString(3, &string_value));
+  ASSERT_TRUE(mixed_list->GetString(4, &string_value));
   ASSERT_EQ("foo", string_value);
 
   // Try searching in the mixed list.
   scoped_ptr<Value> sought_value(Value::CreateIntegerValue(42));
   scoped_ptr<Value> not_found_value(Value::CreateBooleanValue(false));
 
   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);
   ASSERT_EQ(mixed_list->end(), mixed_list->Find(*not_found_value));
@@ skipping 230 matching lines @@
 }
 
 TEST(ValuesTest, DeepCopy) {
   DictionaryValue original_dict;
   Value* original_null = Value::CreateNullValue();
   original_dict.Set("null", original_null);
   FundamentalValue* original_bool = Value::CreateBooleanValue(true);
   original_dict.Set("bool", original_bool);
   FundamentalValue* original_int = Value::CreateIntegerValue(42);
   original_dict.Set("int", original_int);
+  FundamentalValue* original_int64 =
+      Value::CreateInteger64Value(std::pow(2, 42));
+  original_dict.Set("int64", original_int64);
   FundamentalValue* original_double = Value::CreateDoubleValue(3.14);
   original_dict.Set("double", original_double);
   StringValue* original_string = Value::CreateStringValue("hello");
   original_dict.Set("string", original_string);
   StringValue* original_string16 =
       Value::CreateStringValue(ASCIIToUTF16("hello16"));
   original_dict.Set("string16", original_string16);
 
   char* original_buffer = new char[42];
   memset(original_buffer, '!', 42);
@@ skipping 32 matching lines @@
 
   Value* copy_int = NULL;
   ASSERT_TRUE(copy_dict->Get("int", &copy_int));
   ASSERT_TRUE(copy_int);
   ASSERT_NE(copy_int, original_int);
   ASSERT_TRUE(copy_int->IsType(Value::TYPE_INTEGER));
   int copy_int_value = 0;
   ASSERT_TRUE(copy_int->GetAsInteger(&copy_int_value));
   ASSERT_EQ(42, copy_int_value);
 
+  Value* copy_int64 = NULL;
+  ASSERT_TRUE(copy_dict->Get("int64", &copy_int64));
+  ASSERT_TRUE(copy_int64);
+  ASSERT_NE(copy_int64, original_int64);
+  ASSERT_TRUE(copy_int64->IsType(Value::TYPE_INTEGER64));
+  int64 copy_int64_value = 0;
+  ASSERT_TRUE(copy_int64->GetAsInteger64(&copy_int64_value));
+  ASSERT_EQ(std::pow(2, 42), copy_int64_value);
+
   Value* copy_double = NULL;
   ASSERT_TRUE(copy_dict->Get("double", &copy_double));
   ASSERT_TRUE(copy_double);
   ASSERT_NE(copy_double, original_double);
   ASSERT_TRUE(copy_double->IsType(Value::TYPE_DOUBLE));
   double copy_double_value = 0;
   ASSERT_TRUE(copy_double->GetAsDouble(&copy_double_value));
   ASSERT_EQ(3.14, copy_double_value);
 
   Value* copy_string = NULL;
@@ skipping 76 matching lines @@
 
   Value* boolean = Value::CreateBooleanValue(false);
   EXPECT_FALSE(null1->Equals(boolean));
   delete null1;
   delete null2;
   delete boolean;
 
   DictionaryValue dv;
   dv.SetBoolean("a", false);
   dv.SetInteger("b", 2);
+  dv.SetInteger64("b64", std::pow(2, 42));
   dv.SetDouble("c", 2.5);
   dv.SetString("d1", "string");
   dv.SetString("d2", ASCIIToUTF16("http://google.com"));
   dv.Set("e", Value::CreateNullValue());
 
   scoped_ptr<DictionaryValue> copy;
   copy.reset(dv.DeepCopy());
   EXPECT_TRUE(dv.Equals(copy.get()));
 
   ListValue* list = new ListValue;
@@ skipping 40 matching lines @@
 }
 
 TEST(ValuesTest, DeepCopyCovariantReturnTypes) {
   DictionaryValue original_dict;
   Value* original_null = Value::CreateNullValue();
   original_dict.Set("null", original_null);
   FundamentalValue* original_bool = Value::CreateBooleanValue(true);
   original_dict.Set("bool", original_bool);
   FundamentalValue* original_int = Value::CreateIntegerValue(42);
   original_dict.Set("int", original_int);
+  FundamentalValue* original_int64 =
+      Value::CreateInteger64Value(std::pow(2, 42));
+  original_dict.Set("int64", original_int64);
   FundamentalValue* original_double = Value::CreateDoubleValue(3.14);
   original_dict.Set("double", original_double);
   StringValue* original_string = Value::CreateStringValue("hello");
   original_dict.Set("string", original_string);
   StringValue* original_string16 =
       Value::CreateStringValue(ASCIIToUTF16("hello16"));
   original_dict.Set("string16", original_string16);
 
   char* original_buffer = new char[42];
   memset(original_buffer, '!', 42);
   BinaryValue* original_binary = BinaryValue::Create(original_buffer, 42);
   original_dict.Set("binary", original_binary);
 
   ListValue* original_list = new ListValue();
   FundamentalValue* original_list_element_0 = Value::CreateIntegerValue(0);
   original_list->Append(original_list_element_0);
   FundamentalValue* original_list_element_1 = Value::CreateIntegerValue(1);
   original_list->Append(original_list_element_1);
   original_dict.Set("list", original_list);
 
   Value* original_dict_value = &original_dict;
   Value* original_bool_value = original_bool;
   Value* original_int_value = original_int;
+  Value* original_int64_value = original_int64;
   Value* original_double_value = original_double;
   Value* original_string_value = original_string;
   Value* original_string16_value = original_string16;
   Value* original_binary_value = original_binary;
   Value* original_list_value = original_list;
 
   scoped_ptr<Value> copy_dict_value(original_dict_value->DeepCopy());
   scoped_ptr<Value> copy_bool_value(original_bool_value->DeepCopy());
   scoped_ptr<Value> copy_int_value(original_int_value->DeepCopy());
+  scoped_ptr<Value> copy_int64_value(original_int64_value->DeepCopy());
   scoped_ptr<Value> copy_double_value(original_double_value->DeepCopy());
   scoped_ptr<Value> copy_string_value(original_string_value->DeepCopy());
   scoped_ptr<Value> copy_string16_value(original_string16_value->DeepCopy());
   scoped_ptr<Value> copy_binary_value(original_binary_value->DeepCopy());
   scoped_ptr<Value> copy_list_value(original_list_value->DeepCopy());
 
   EXPECT_TRUE(original_dict_value->Equals(copy_dict_value.get()));
   EXPECT_TRUE(original_bool_value->Equals(copy_bool_value.get()));
   EXPECT_TRUE(original_int_value->Equals(copy_int_value.get()));
+  EXPECT_TRUE(original_int64_value->Equals(copy_int64_value.get()));
   EXPECT_TRUE(original_double_value->Equals(copy_double_value.get()));
   EXPECT_TRUE(original_string_value->Equals(copy_string_value.get()));
   EXPECT_TRUE(original_string16_value->Equals(copy_string16_value.get()));
   EXPECT_TRUE(original_binary_value->Equals(copy_binary_value.get()));
   EXPECT_TRUE(original_list_value->Equals(copy_list_value.get()));
 }
 
 TEST(ValuesTest, RemoveEmptyChildren) {
   scoped_ptr<DictionaryValue> root(new DictionaryValue);
   // Remove empty lists and dictionaries.
@@ skipping 145 matching lines @@
       seen2 = true;
     } else {
       ADD_FAILURE();
     }
   }
   EXPECT_TRUE(seen1);
   EXPECT_TRUE(seen2);
 }
 
 }  // namespace base