Value::GetAsDictionary

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 <limits>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/string16.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
@@ skipping 344 matching lines @@
   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);
 
+  DictionaryValue* original_nested_dictionary = new DictionaryValue();
+  original_nested_dictionary->Set("key", Value::CreateStringValue("value"));
+  original_dict.Set("dictionary", original_nested_dictionary);
+
   scoped_ptr<DictionaryValue> copy_dict(original_dict.DeepCopy());
   ASSERT_TRUE(copy_dict.get());
   ASSERT_NE(copy_dict.get(), &original_dict);
 
   Value* copy_null = NULL;
   ASSERT_TRUE(copy_dict->Get("null", &copy_null));
   ASSERT_TRUE(copy_null);
   ASSERT_NE(copy_null, original_null);
   ASSERT_TRUE(copy_null->IsType(Value::TYPE_NULL));
 
@@ skipping 57 matching lines @@
     static_cast<BinaryValue*>(copy_binary)->GetSize());
   ASSERT_EQ(0, memcmp(original_binary->GetBuffer(),
                static_cast<BinaryValue*>(copy_binary)->GetBuffer(),
                original_binary->GetSize()));
 
   Value* copy_value = NULL;
   ASSERT_TRUE(copy_dict->Get("list", &copy_value));
   ASSERT_TRUE(copy_value);
   ASSERT_NE(copy_value, original_list);
   ASSERT_TRUE(copy_value->IsType(Value::TYPE_LIST));
-  ListValue* copy_list = static_cast<ListValue*>(copy_value);
+  ListValue* copy_list = NULL;
+  ASSERT_TRUE(copy_value->GetAsList(&copy_list));
+  ASSERT_TRUE(copy_list);
   ASSERT_EQ(2U, copy_list->GetSize());
 
   Value* copy_list_element_0;
   ASSERT_TRUE(copy_list->Get(0, &copy_list_element_0));
   ASSERT_TRUE(copy_list_element_0);
   ASSERT_NE(copy_list_element_0, original_list_element_0);
   int copy_list_element_0_value;
   ASSERT_TRUE(copy_list_element_0->GetAsInteger(&copy_list_element_0_value));
   ASSERT_EQ(0, copy_list_element_0_value);
 
   Value* copy_list_element_1;
   ASSERT_TRUE(copy_list->Get(1, &copy_list_element_1));
   ASSERT_TRUE(copy_list_element_1);
   ASSERT_NE(copy_list_element_1, original_list_element_1);
   int copy_list_element_1_value;
   ASSERT_TRUE(copy_list_element_1->GetAsInteger(&copy_list_element_1_value));
   ASSERT_EQ(1, copy_list_element_1_value);
+
+  copy_value = NULL;
+  ASSERT_TRUE(copy_dict->Get("dictionary", &copy_value));
+  ASSERT_TRUE(copy_value);
+  ASSERT_NE(copy_value, original_nested_dictionary);
+  ASSERT_TRUE(copy_value->IsType(Value::TYPE_DICTIONARY));
+  DictionaryValue* copy_nested_dictionary = NULL;
+  ASSERT_TRUE(copy_value->GetAsDictionary(&copy_nested_dictionary));
+  ASSERT_TRUE(copy_nested_dictionary);
+  EXPECT_TRUE(copy_nested_dictionary->HasKey("key"));
 }
 
 TEST(ValuesTest, Equals) {
   Value* null1 = Value::CreateNullValue();
   Value* null2 = Value::CreateNullValue();
   EXPECT_NE(null1, null2);
   EXPECT_TRUE(null1->Equals(null2));
 
   Value* boolean = Value::CreateBooleanValue(false);
   EXPECT_FALSE(null1->Equals(boolean));
@@ skipping 263 matching lines @@
       seen2 = true;
     } else {
       ADD_FAILURE();
     }
   }
   EXPECT_TRUE(seen1);
   EXPECT_TRUE(seen2);
 }
 
 }  // namespace base