Policy: generate boilerplate policy type and constant code.

chrome/browser/policy/configuration_policy_pref_store_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 "base/file_path.h"
 #include "chrome/browser/policy/configuration_policy_pref_store.h"
 #include "chrome/browser/policy/mock_configuration_policy_provider.h"
 #include "chrome/browser/prefs/proxy_prefs.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/notification_service.h"
@@ skipping 53 matching lines @@
   Value* value;
   EXPECT_EQ(PrefStore::READ_OK,
             store_.GetValue(GetParam().pref_name(), &value));
   EXPECT_TRUE(in_value->Equals(value));
 }
 
 INSTANTIATE_TEST_CASE_P(
     ConfigurationPolicyPrefStoreListTestInstance,
     ConfigurationPolicyPrefStoreListTest,
     testing::Values(
-        TypeAndName(kPolicyURLsToRestoreOnStartup,
+        TypeAndName(kPolicyRestoreOnStartupURLs,
                     prefs::kURLsToRestoreOnStartup),
-        TypeAndName(kPolicyExtensionInstallAllowList,
+        TypeAndName(kPolicyExtensionInstallWhitelist,
                     prefs::kExtensionInstallAllowList),
-        TypeAndName(kPolicyExtensionInstallDenyList,
+        TypeAndName(kPolicyExtensionInstallBlacklist,
                     prefs::kExtensionInstallDenyList),
         TypeAndName(kPolicyDisabledPlugins,
                     prefs::kPluginsPluginsBlacklist)));
 
 // Test cases for string-valued policy settings.
 class ConfigurationPolicyPrefStoreStringTest
     : public ConfigurationPolicyPrefStoreTestBase<
                  testing::TestWithParam<TypeAndName> > {
 };
 
 TEST_P(ConfigurationPolicyPrefStoreStringTest, GetDefault) {
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
             store_.GetValue(GetParam().pref_name(), NULL));
 }
 
 TEST_P(ConfigurationPolicyPrefStoreStringTest, SetValue) {
   provider_.AddPolicy(GetParam().type(),
                       Value::CreateStringValue("http://chromium.org"));
   store_.OnUpdatePolicy();
   Value* value;
   EXPECT_EQ(PrefStore::READ_OK,
             store_.GetValue(GetParam().pref_name(), &value));
   EXPECT_TRUE(StringValue("http://chromium.org").Equals(value));
 }
 
 INSTANTIATE_TEST_CASE_P(
     ConfigurationPolicyPrefStoreStringTestInstance,
     ConfigurationPolicyPrefStoreStringTest,
     testing::Values(
-        TypeAndName(kPolicyHomePage,
+        TypeAndName(kPolicyHomepageLocation,
                     prefs::kHomePage),
-        TypeAndName(kPolicyApplicationLocale,
+        TypeAndName(kPolicyApplicationLocaleValue,
                     prefs::kApplicationLocale),
-        TypeAndName(kPolicyApplicationLocale,
+        TypeAndName(kPolicyApplicationLocaleValue,
                     prefs::kApplicationLocale),
         TypeAndName(kPolicyAuthSchemes,
                     prefs::kAuthSchemes),
         TypeAndName(kPolicyAuthServerWhitelist,
                     prefs::kAuthServerWhitelist),
         TypeAndName(kPolicyAuthNegotiateDelegateWhitelist,
                     prefs::kAuthNegotiateDelegateWhitelist),
         TypeAndName(kPolicyGSSAPILibraryName,
                     prefs::kGSSAPILibraryName)));
 
@@ skipping 140 matching lines @@
     EXPECT_TRUE(FundamentalValue(expected_proxy_mode).Equals(value));
   }
 };
 
 TEST_F(ConfigurationPolicyPrefStoreProxyTest, ManualOptions) {
   MockConfigurationPolicyProvider provider;
   provider.AddPolicy(kPolicyProxyBypassList,
                      Value::CreateStringValue("http://chromium.org/override"));
   provider.AddPolicy(kPolicyProxyServer,
                      Value::CreateStringValue("chromium.org"));
-  provider.AddPolicy(kPolicyProxyMode,
+  provider.AddPolicy(kPolicyProxyServerMode,
                      Value::CreateIntegerValue(
                          kPolicyManuallyConfiguredProxyMode));
 
   ConfigurationPolicyPrefStore store(&provider);
   VerifyProxyPrefs(
       store, "chromium.org", "", "http://chromium.org/override",
       ProxyPrefs::MODE_FIXED_SERVERS);
 }
 
 TEST_F(ConfigurationPolicyPrefStoreProxyTest, ManualOptionsReversedApplyOrder) {
   MockConfigurationPolicyProvider provider;
-  provider.AddPolicy(kPolicyProxyMode,
+  provider.AddPolicy(kPolicyProxyServerMode,
                      Value::CreateIntegerValue(
                          kPolicyManuallyConfiguredProxyMode));
   provider.AddPolicy(kPolicyProxyBypassList,
                      Value::CreateStringValue("http://chromium.org/override"));
   provider.AddPolicy(kPolicyProxyServer,
                      Value::CreateStringValue("chromium.org"));
 
   ConfigurationPolicyPrefStore store(&provider);
   VerifyProxyPrefs(
       store, "chromium.org", "", "http://chromium.org/override",
       ProxyPrefs::MODE_FIXED_SERVERS);
 }
 
 TEST_F(ConfigurationPolicyPrefStoreProxyTest, NoProxy) {
   MockConfigurationPolicyProvider provider;
-  provider.AddPolicy(kPolicyProxyMode,
+  provider.AddPolicy(kPolicyProxyServerMode,
                      Value::CreateIntegerValue(kPolicyNoProxyServerMode));
 
   ConfigurationPolicyPrefStore store(&provider);
   VerifyProxyPrefs(store, "", "", "", ProxyPrefs::MODE_DIRECT);
 }
 
 TEST_F(ConfigurationPolicyPrefStoreProxyTest, AutoDetect) {
   MockConfigurationPolicyProvider provider;
-  provider.AddPolicy(kPolicyProxyMode,
+  provider.AddPolicy(kPolicyProxyServerMode,
                      Value::CreateIntegerValue(kPolicyAutoDetectProxyMode));
 
   ConfigurationPolicyPrefStore store(&provider);
   VerifyProxyPrefs(store, "", "", "", ProxyPrefs::MODE_AUTO_DETECT);
 }
 
 TEST_F(ConfigurationPolicyPrefStoreProxyTest, AutoDetectPac) {
   MockConfigurationPolicyProvider provider;
   provider.AddPolicy(kPolicyProxyPacUrl,
                      Value::CreateStringValue("http://short.org/proxy.pac"));
   provider.AddPolicy(
-      kPolicyProxyMode,
+      kPolicyProxyServerMode,
       Value::CreateIntegerValue(kPolicyManuallyConfiguredProxyMode));
 
   ConfigurationPolicyPrefStore store(&provider);
   VerifyProxyPrefs(
       store, "", "http://short.org/proxy.pac", "", ProxyPrefs::MODE_PAC_SCRIPT);
 }
 
 TEST_F(ConfigurationPolicyPrefStoreProxyTest, UseSystem) {
   MockConfigurationPolicyProvider provider;
-  provider.AddPolicy(kPolicyProxyMode,
+  provider.AddPolicy(kPolicyProxyServerMode,
                      Value::CreateIntegerValue(kPolicyUseSystemProxyMode));
 
   ConfigurationPolicyPrefStore store(&provider);
   VerifyProxyPrefs(store, "", "", "", ProxyPrefs::MODE_SYSTEM);
 }
 
 TEST_F(ConfigurationPolicyPrefStoreProxyTest, ProxyInvalid) {
   for (int i = 0; i < MODE_COUNT; ++i) {
     MockConfigurationPolicyProvider provider;
-    provider.AddPolicy(kPolicyProxyMode, Value::CreateIntegerValue(i));
+    provider.AddPolicy(kPolicyProxyServerMode, Value::CreateIntegerValue(i));
     // No mode expects all three parameters being set.
     provider.AddPolicy(kPolicyProxyPacUrl,
                        Value::CreateStringValue("http://short.org/proxy.pac"));
     provider.AddPolicy(kPolicyProxyBypassList,
                        Value::CreateStringValue(
                            "http://chromium.org/override"));
     provider.AddPolicy(kPolicyProxyServer,
                        Value::CreateStringValue("chromium.org"));
 
     ConfigurationPolicyPrefStore store(&provider);
@@ skipping 245 matching lines @@
 
   PrefStoreObserverMock observer_;
 };
 
 TEST_F(ConfigurationPolicyPrefStoreRefreshTest, Refresh) {
   Value* value = NULL;
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
             store_.GetValue(prefs::kHomePage, NULL));
 
   EXPECT_CALL(observer_, OnPrefValueChanged(prefs::kHomePage)).Times(1);
-  provider_.AddPolicy(kPolicyHomePage,
+  provider_.AddPolicy(kPolicyHomepageLocation,
                       Value::CreateStringValue("http://www.chromium.org"));
   store_.OnUpdatePolicy();
   Mock::VerifyAndClearExpectations(&observer_);
   EXPECT_EQ(PrefStore::READ_OK,
             store_.GetValue(prefs::kHomePage, &value));
   EXPECT_TRUE(StringValue("http://www.chromium.org").Equals(value));
 
   EXPECT_CALL(observer_, OnPrefValueChanged(_)).Times(0);
   store_.OnUpdatePolicy();
   Mock::VerifyAndClearExpectations(&observer_);
 
   EXPECT_CALL(observer_, OnPrefValueChanged(prefs::kHomePage)).Times(1);
-  provider_.RemovePolicy(kPolicyHomePage);
+  provider_.RemovePolicy(kPolicyHomepageLocation);
   store_.OnUpdatePolicy();
   Mock::VerifyAndClearExpectations(&observer_);
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
             store_.GetValue(prefs::kHomePage, NULL));
 }
 
 TEST_F(ConfigurationPolicyPrefStoreRefreshTest, Initialization) {
   EXPECT_FALSE(store_.IsInitializationComplete());
 
   EXPECT_CALL(observer_, OnInitializationCompleted()).Times(1);
 
   provider_.SetInitializationComplete(true);
   EXPECT_FALSE(store_.IsInitializationComplete());
 
   store_.OnUpdatePolicy();
   Mock::VerifyAndClearExpectations(&observer_);
   EXPECT_TRUE(store_.IsInitializationComplete());
 }
 
 }  // namespace policy