Handle policy refresh internally in ConfigurationPolicyPrefStore.

base/values_unittest.cc

 // Copyright (c) 2010 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/scoped_ptr.h"
 #include "base/string16.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-class ValuesTest: public testing::Test {
- protected:
-  void CompareDictionariesAndCheckResult(
-      const DictionaryValue* dict1,
-      const DictionaryValue* dict2,
-      const char* expected_paths[],
-      size_t expected_paths_count) {
-    std::vector<std::string> differing_paths;
-    std::vector<std::string> expected_paths_vector(expected_paths,
-        expected_paths+expected_paths_count);
-    // All comparisons should be commutative, check dict1 against dict2
-    // and vice-versa.
-    dict1->GetDifferingPaths(dict2, &differing_paths);
-    ASSERT_EQ(expected_paths_count, differing_paths.size());
-    EXPECT_TRUE(equal(differing_paths.begin(), differing_paths.end(),
-                      expected_paths_vector.begin()));
-    dict2->GetDifferingPaths(dict1, &differing_paths);
-    ASSERT_EQ(expected_paths_count, differing_paths.size());
-    EXPECT_TRUE(equal(differing_paths.begin(), differing_paths.end(),
-                      expected_paths_vector.begin()));
-  }
+class ValuesTest : public testing::Test {
 };
 
 TEST_F(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));
@@ skipping 599 matching lines @@
   EXPECT_TRUE(res_sub_dict->GetString("sub_base_key", &sub_base_key_value));
   EXPECT_EQ("sub_base_key_value_base", sub_base_key_value); // Preserved.
   std::string sub_collide_key_value;
   EXPECT_TRUE(res_sub_dict->GetString("sub_collide_key",
                                       &sub_collide_key_value));
   EXPECT_EQ("sub_collide_key_value_merge", sub_collide_key_value); // Replaced.
   std::string sub_merge_key_value;
   EXPECT_TRUE(res_sub_dict->GetString("sub_merge_key", &sub_merge_key_value));
   EXPECT_EQ("sub_merge_key_value_merge", sub_merge_key_value); // Merged in.
 }
-
-TEST_F(ValuesTest, GetDifferingPaths) {
-  scoped_ptr<DictionaryValue> dict1(new DictionaryValue());
-  scoped_ptr<DictionaryValue> dict2(new DictionaryValue());
-  std::vector<std::string> differing_paths;
-
-  // Test comparing empty dictionaries.
-  dict1->GetDifferingPaths(dict2.get(), &differing_paths);
-  EXPECT_EQ(differing_paths.size(), 0UL);
-
-  // Compare an empty dictionary with various non-empty dictionaries.
-  static const char* expected_paths1[] = {
-      "segment1"
-  };
-  dict1->SetString("segment1", "value1");
-  CompareDictionariesAndCheckResult(dict1.get(), dict2.get(), expected_paths1,
-                                    arraysize(expected_paths1));
-
-  static const char* expected_paths2[] = {
-    "segment1",
-    "segment2",
-    "segment2.segment3"
-  };
-  dict1->SetString("segment2.segment3", "value2");
-  CompareDictionariesAndCheckResult(dict1.get(), dict2.get(), expected_paths2,
-                                    arraysize(expected_paths2));
-
-  static const char* expected_paths3[] = {
-    "segment1",
-    "segment2",
-    "segment2.segment3",
-    "segment4",
-    "segment4.segment5"
-  };
-  dict1->SetString("segment4.segment5", "value3");
-  CompareDictionariesAndCheckResult(dict1.get(), dict2.get(), expected_paths3,
-                                    arraysize(expected_paths3));
-
-  // Now various tests with two populated dictionaries.
-  static const char* expected_paths4[] = {
-    "segment1",
-    "segment2",
-    "segment2.segment3",
-    "segment4",
-    "segment4.segment5"
-  };
-  dict2->Set("segment2", new DictionaryValue());
-  CompareDictionariesAndCheckResult(dict1.get(), dict2.get(), expected_paths4,
-                                    arraysize(expected_paths4));
-
-  static const char* expected_paths5[] = {
-    "segment1",
-    "segment4",
-    "segment4.segment5"
-  };
-  dict2->SetString("segment2.segment3", "value2");
-  CompareDictionariesAndCheckResult(dict1.get(), dict2.get(), expected_paths5,
-                                    arraysize(expected_paths5));
-
-  dict2->SetBoolean("segment2.segment3", true);
-  CompareDictionariesAndCheckResult(dict1.get(), dict2.get(), expected_paths4,
-                                    arraysize(expected_paths4));
-
-  // Test two identical dictionaries.
-  dict2.reset(static_cast<DictionaryValue*>(dict1->DeepCopy()));
-  dict2->GetDifferingPaths(dict1.get(), &differing_paths);
-  EXPECT_EQ(differing_paths.size(), 0UL);
-
-  // Test a deep dictionary structure.
-  static const char* expected_paths6[] = {
-    "s1",
-    "s1.s2",
-    "s1.s2.s3",
-    "s1.s2.s3.s4",
-    "s1.s2.s3.s4.s5"
-  };
-  dict1.reset(new DictionaryValue());
-  dict2.reset(new DictionaryValue());
-  dict1->Set("s1.s2.s3.s4.s5", new DictionaryValue());
-  CompareDictionariesAndCheckResult(dict1.get(), dict2.get(), expected_paths6,
-                                    arraysize(expected_paths6));
-
-  // Make sure disjoint dictionaries generate the right differing path list.
-  static const char* expected_paths7[] = {
-    "a",
-    "b",
-    "c",
-    "d"
-  };
-  dict1.reset(new DictionaryValue());
-  dict1->SetBoolean("a", true);
-  dict1->SetBoolean("c", true);
-  dict2.reset(new DictionaryValue());
-  dict1->SetBoolean("b", true);
-  dict1->SetBoolean("d", true);
-  CompareDictionariesAndCheckResult(dict1.get(), dict2.get(), expected_paths7,
-                                    arraysize(expected_paths7));
-
-  // For code coverage completeness. Make sure that all branches
-  // that were not covered are executed.
-  static const char* expected_paths8[] = {
-    "s1",
-    "s1.s2"
-  };
-  dict1.reset(new DictionaryValue());
-  dict1->Set("s1.s2", new DictionaryValue());
-  dict2.reset(new DictionaryValue());
-  dict2->SetInteger("s1", 1);
-  CompareDictionariesAndCheckResult(dict1.get(), dict2.get(), expected_paths8,
-                                    arraysize(expected_paths8));
-}