src/chrome/browser/policy/configuration_policy_handler_unittest.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/callback.h"
   6 #include "base/memory/scoped_ptr.h"
   7 #include "base/prefs/pref_value_map.h"
   8 #include "chrome/browser/policy/configuration_policy_handler.h"
   9 #include "chrome/browser/policy/external_data_fetcher.h"
  10 #include "chrome/browser/policy/policy_error_map.h"
  11 #include "chrome/browser/policy/policy_map.h"
  12 #include "policy/policy_constants.h"
  13 #include "testing/gtest/include/gtest/gtest.h"
  14
  15 namespace policy {
  16
  17 namespace {
  18
  19 StringToIntEnumListPolicyHandler::MappingEntry kTestTypeMap[] = {
  20   { "one", 1 },
  21   { "two", 2 },
  22 };
  23
  24 const char kTestPref[] = "unit_test.test_pref";
  25
  26 }  // namespace
  27
  28 TEST(StringToIntEnumListPolicyHandlerTest, CheckPolicySettings) {
  29   base::ListValue list;
  30   PolicyMap policy_map;
  31   PolicyErrorMap errors;
  32   StringToIntEnumListPolicyHandler handler(
  33       key::kExtensionAllowedTypes,
  34       kTestPref,
  35       kTestTypeMap,
  36       kTestTypeMap + arraysize(kTestTypeMap));
  37
  38   policy_map.Set(key::kExtensionAllowedTypes, POLICY_LEVEL_MANDATORY,
  39                  POLICY_SCOPE_USER, list.DeepCopy(), NULL);
  40   errors.Clear();
  41   EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors));
  42   EXPECT_TRUE(errors.empty());
  43
  44   list.AppendString("one");
  45   policy_map.Set(key::kExtensionAllowedTypes, POLICY_LEVEL_MANDATORY,
  46                  POLICY_SCOPE_USER, list.DeepCopy(), NULL);
  47   errors.Clear();
  48   EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors));
  49   EXPECT_TRUE(errors.empty());
  50
  51   list.AppendString("invalid");
  52   policy_map.Set(key::kExtensionAllowedTypes, POLICY_LEVEL_MANDATORY,
  53                  POLICY_SCOPE_USER, list.DeepCopy(), NULL);
  54   errors.Clear();
  55   EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors));
  56   EXPECT_FALSE(errors.empty());
  57   EXPECT_FALSE(errors.GetErrors(key::kExtensionAllowedTypes).empty());
  58
  59   policy_map.Set(key::kExtensionAllowedTypes, POLICY_LEVEL_MANDATORY,
  60                  POLICY_SCOPE_USER,
  61                  base::Value::CreateStringValue("no list"), NULL);
  62   errors.Clear();
  63   EXPECT_FALSE(handler.CheckPolicySettings(policy_map, &errors));
  64   EXPECT_FALSE(errors.empty());
  65   EXPECT_FALSE(errors.GetErrors(key::kExtensionAllowedTypes).empty());
  66 }
  67
  68 TEST(StringToIntEnumListPolicyHandlerTest, ApplyPolicySettings) {
  69   base::ListValue list;
  70   base::ListValue expected;
  71   PolicyMap policy_map;
  72   PrefValueMap prefs;
  73   base::Value* value;
  74   StringToIntEnumListPolicyHandler handler(
  75       key::kExtensionAllowedTypes,
  76       kTestPref,
  77       kTestTypeMap,
  78       kTestTypeMap + arraysize(kTestTypeMap));
  79
  80   policy_map.Set(key::kExtensionAllowedTypes, POLICY_LEVEL_MANDATORY,
  81                  POLICY_SCOPE_USER, list.DeepCopy(), NULL);
  82   handler.ApplyPolicySettings(policy_map, &prefs);
  83   EXPECT_TRUE(prefs.GetValue(kTestPref, &value));
  84   EXPECT_TRUE(base::Value::Equals(&expected, value));
  85
  86   list.AppendString("two");
  87   expected.AppendInteger(2);
  88   policy_map.Set(key::kExtensionAllowedTypes, POLICY_LEVEL_MANDATORY,
  89                  POLICY_SCOPE_USER, list.DeepCopy(), NULL);
  90   handler.ApplyPolicySettings(policy_map, &prefs);
  91   EXPECT_TRUE(prefs.GetValue(kTestPref, &value));
  92   EXPECT_TRUE(base::Value::Equals(&expected, value));
  93
  94   list.AppendString("invalid");
  95   policy_map.Set(key::kExtensionAllowedTypes, POLICY_LEVEL_MANDATORY,
  96                  POLICY_SCOPE_USER, list.DeepCopy(), NULL);
  97   handler.ApplyPolicySettings(policy_map, &prefs);
  98   EXPECT_TRUE(prefs.GetValue(kTestPref, &value));
  99   EXPECT_TRUE(base::Value::Equals(&expected, value));
 100 }
 101
 102 TEST(IntRangePolicyHandler, CheckPolicySettingsClamp) {
 103   PolicyMap policy_map;
 104   PolicyErrorMap errors;
 105
 106   // This tests needs to modify an int policy. The exact policy used and its
 107   // semantics outside the test are irrelevant.
 108   IntRangePolicyHandler handler(key::kDiskCacheSize, kTestPref, 0, 10, true);
 109
 110   // Check that values lying in the accepted range are not rejected.
 111   policy_map.Set(key::kDiskCacheSize, POLICY_LEVEL_MANDATORY,
 112                  POLICY_SCOPE_USER, base::Value::CreateIntegerValue(0), NULL);
 113   errors.Clear();
 114   EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors));
 115   EXPECT_TRUE(errors.empty());
 116
 117   policy_map.Set(key::kDiskCacheSize, POLICY_LEVEL_MANDATORY,
 118                  POLICY_SCOPE_USER, base::Value::CreateIntegerValue(5), NULL);
 119   errors.Clear();
 120   EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors));
 121   EXPECT_TRUE(errors.empty());
 122
 123   policy_map.Set(key::kDiskCacheSize, POLICY_LEVEL_MANDATORY,
 124                  POLICY_SCOPE_USER, base::Value::CreateIntegerValue(10), NULL);
 125   errors.Clear();
 126   EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors));
 127   EXPECT_TRUE(errors.empty());
 128
 129   // Check that values lying outside the accepted range are not rejected
 130   // (because clamping is enabled) but do yield a warning message.
 131   policy_map.Set(key::kDiskCacheSize, POLICY_LEVEL_MANDATORY,
 132                  POLICY_SCOPE_USER, base::Value::CreateIntegerValue(-5), NULL);
 133   errors.Clear();
 134   EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors));
 135   EXPECT_FALSE(errors.empty());
 136
 137   policy_map.Set(key::kDiskCacheSize, POLICY_LEVEL_MANDATORY,
 138                  POLICY_SCOPE_USER, base::Value::CreateIntegerValue(15), NULL);
 139   errors.Clear();
 140   EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors));
 141   EXPECT_FALSE(errors.empty());
 142
 143   // Check that an entirely invalid value is rejected and yields an error
 144   // message.
 145   policy_map.Set(key::kDiskCacheSize,
 146                  POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
 147                  base::Value::CreateStringValue("invalid"), NULL);
 148   errors.Clear();
 149   EXPECT_FALSE(handler.CheckPolicySettings(policy_map, &errors));
 150   EXPECT_FALSE(errors.empty());
 151 }
 152
 153 TEST(IntRangePolicyHandler, CheckPolicySettingsDontClamp) {
 154   PolicyMap policy_map;
 155   PolicyErrorMap errors;
 156
 157   // This tests needs to modify an int policy. The exact policy used and its
 158   // semantics outside the test are irrelevant.
 159   IntRangePolicyHandler handler(key::kDiskCacheSize, kTestPref, 0, 10, false);
 160
 161   // Check that values lying in the accepted range are not rejected.
 162   policy_map.Set(key::kDiskCacheSize, POLICY_LEVEL_MANDATORY,
 163                  POLICY_SCOPE_USER, base::Value::CreateIntegerValue(0), NULL);
 164   errors.Clear();
 165   EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors));
 166   EXPECT_TRUE(errors.empty());
 167
 168   policy_map.Set(key::kDiskCacheSize, POLICY_LEVEL_MANDATORY,
 169                  POLICY_SCOPE_USER, base::Value::CreateIntegerValue(5), NULL);
 170   errors.Clear();
 171   EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors));
 172   EXPECT_TRUE(errors.empty());
 173
 174   policy_map.Set(key::kDiskCacheSize, POLICY_LEVEL_MANDATORY,
 175                  POLICY_SCOPE_USER, base::Value::CreateIntegerValue(10), NULL);
 176   errors.Clear();
 177   EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors));
 178   EXPECT_TRUE(errors.empty());
 179
 180   // Check that values lying outside the accepted range are rejected and yield
 181   // an error message.
 182   policy_map.Set(key::kDiskCacheSize, POLICY_LEVEL_MANDATORY,
 183                  POLICY_SCOPE_USER, base::Value::CreateIntegerValue(-5), NULL);
 184   errors.Clear();
 185   EXPECT_FALSE(handler.CheckPolicySettings(policy_map, &errors));
 186   EXPECT_FALSE(errors.empty());
 187
 188   policy_map.Set(key::kDiskCacheSize, POLICY_LEVEL_MANDATORY,
 189                  POLICY_SCOPE_USER, base::Value::CreateIntegerValue(15), NULL);
 190   errors.Clear();
 191   EXPECT_FALSE(handler.CheckPolicySettings(policy_map, &errors));
 192   EXPECT_FALSE(errors.empty());
 193
 194   // Check that an entirely invalid value is rejected and yields an error
 195   // message.
 196   policy_map.Set(key::kDiskCacheSize, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
 197                  base::Value::CreateStringValue("invalid"), NULL);
 198   errors.Clear();
 199   EXPECT_FALSE(handler.CheckPolicySettings(policy_map, &errors));
 200   EXPECT_FALSE(errors.empty());
 201 }
 202
 203 TEST(IntRangePolicyHandler, ApplyPolicySettingsClamp) {
 204   PolicyMap policy_map;
 205   PrefValueMap prefs;
 206   scoped_ptr<base::Value> expected;
 207   const base::Value* value;
 208
 209   // This tests needs to modify an int policy. The exact policy used and its
 210   // semantics outside the test are irrelevant.
 211   IntRangePolicyHandler handler(key::kDiskCacheSize, kTestPref, 0, 10, true);
 212
 213   // Check that values lying in the accepted range are written to the pref.
 214   policy_map.Set(key::kDiskCacheSize, POLICY_LEVEL_MANDATORY,
 215                  POLICY_SCOPE_USER, base::Value::CreateIntegerValue(0), NULL);
 216   prefs.Clear();
 217   handler.ApplyPolicySettings(policy_map, &prefs);
 218   expected.reset(base::Value::CreateIntegerValue(0));
 219   EXPECT_TRUE(prefs.GetValue(kTestPref, &value));
 220   EXPECT_TRUE(base::Value::Equals(expected.get(), value));
 221
 222   policy_map.Set(key::kDiskCacheSize, POLICY_LEVEL_MANDATORY,
 223                  POLICY_SCOPE_USER, base::Value::CreateIntegerValue(5), NULL);
 224   prefs.Clear();
 225   handler.ApplyPolicySettings(policy_map, &prefs);
 226   expected.reset(base::Value::CreateIntegerValue(5));
 227   EXPECT_TRUE(prefs.GetValue(kTestPref, &value));
 228   EXPECT_TRUE(base::Value::Equals(expected.get(), value));
 229
 230   policy_map.Set(key::kDiskCacheSize, POLICY_LEVEL_MANDATORY,
 231                  POLICY_SCOPE_USER, base::Value::CreateIntegerValue(10), NULL);
 232   prefs.Clear();
 233   handler.ApplyPolicySettings(policy_map, &prefs);
 234   expected.reset(base::Value::CreateIntegerValue(10));
 235   EXPECT_TRUE(prefs.GetValue(kTestPref, &value));
 236   EXPECT_TRUE(base::Value::Equals(expected.get(), value));
 237
 238   // Check that values lying outside the accepted range are clamped and written
 239   // to the pref.
 240   policy_map.Set(key::kDiskCacheSize, POLICY_LEVEL_MANDATORY,
 241                  POLICY_SCOPE_USER, base::Value::CreateIntegerValue(-5), NULL);
 242   prefs.Clear();
 243   handler.ApplyPolicySettings(policy_map, &prefs);
 244   expected.reset(base::Value::CreateIntegerValue(0));
 245   EXPECT_TRUE(prefs.GetValue(kTestPref, &value));
 246   EXPECT_TRUE(base::Value::Equals(expected.get(), value));
 247
 248   policy_map.Set(key::kDiskCacheSize, POLICY_LEVEL_MANDATORY,
 249                  POLICY_SCOPE_USER, base::Value::CreateIntegerValue(15), NULL);
 250   prefs.Clear();
 251   handler.ApplyPolicySettings(policy_map, &prefs);
 252   expected.reset(base::Value::CreateIntegerValue(10));
 253   EXPECT_TRUE(prefs.GetValue(kTestPref, &value));
 254   EXPECT_TRUE(base::Value::Equals(expected.get(), value));
 255 }
 256
 257 TEST(IntRangePolicyHandler, ApplyPolicySettingsDontClamp) {
 258   PolicyMap policy_map;
 259   PrefValueMap prefs;
 260   scoped_ptr<base::Value> expected;
 261   const base::Value* value;
 262
 263   // This tests needs to modify an int policy. The exact policy used and its
 264   // semantics outside the test are irrelevant.
 265   IntRangePolicyHandler handler(key::kDiskCacheSize, kTestPref, 0, 10, true);
 266
 267   // Check that values lying in the accepted range are written to the pref.
 268   policy_map.Set(key::kDiskCacheSize, POLICY_LEVEL_MANDATORY,
 269                  POLICY_SCOPE_USER, base::Value::CreateIntegerValue(0), NULL);
 270   prefs.Clear();
 271   handler.ApplyPolicySettings(policy_map, &prefs);
 272   expected.reset(base::Value::CreateIntegerValue(0));
 273   EXPECT_TRUE(prefs.GetValue(kTestPref, &value));
 274   EXPECT_TRUE(base::Value::Equals(expected.get(), value));
 275
 276   policy_map.Set(key::kDiskCacheSize, POLICY_LEVEL_MANDATORY,
 277                  POLICY_SCOPE_USER, base::Value::CreateIntegerValue(5), NULL);
 278   prefs.Clear();
 279   handler.ApplyPolicySettings(policy_map, &prefs);
 280   expected.reset(base::Value::CreateIntegerValue(5));
 281   EXPECT_TRUE(prefs.GetValue(kTestPref, &value));
 282   EXPECT_TRUE(base::Value::Equals(expected.get(), value));
 283
 284   policy_map.Set(key::kDiskCacheSize, POLICY_LEVEL_MANDATORY,
 285                  POLICY_SCOPE_USER, base::Value::CreateIntegerValue(10), NULL);
 286   prefs.Clear();
 287   handler.ApplyPolicySettings(policy_map, &prefs);
 288   expected.reset(base::Value::CreateIntegerValue(10));
 289   EXPECT_TRUE(prefs.GetValue(kTestPref, &value));
 290   EXPECT_TRUE(base::Value::Equals(expected.get(), value));
 291 }
 292
 293 TEST(IntPercentageToDoublePolicyHandler, CheckPolicySettingsClamp) {
 294   PolicyMap policy_map;
 295   PolicyErrorMap errors;
 296
 297   // This tests needs to modify an int policy. The exact policy used and its
 298   // semantics outside the test are irrelevant.
 299   IntPercentageToDoublePolicyHandler handler(
 300       key::kDiskCacheSize, kTestPref, 0, 10, true);
 301
 302   // Check that values lying in the accepted range are not rejected.
 303   policy_map.Set(key::kDiskCacheSize, POLICY_LEVEL_MANDATORY,
 304                  POLICY_SCOPE_USER, base::Value::CreateIntegerValue(0), NULL);
 305   errors.Clear();
 306   EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors));
 307   EXPECT_TRUE(errors.empty());
 308
 309   policy_map.Set(key::kDiskCacheSize, POLICY_LEVEL_MANDATORY,
 310                  POLICY_SCOPE_USER, base::Value::CreateIntegerValue(5), NULL);
 311   errors.Clear();
 312   EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors));
 313   EXPECT_TRUE(errors.empty());
 314
 315   policy_map.Set(key::kDiskCacheSize, POLICY_LEVEL_MANDATORY,
 316                  POLICY_SCOPE_USER, base::Value::CreateIntegerValue(10), NULL);
 317   errors.Clear();
 318   EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors));
 319   EXPECT_TRUE(errors.empty());
 320
 321   // Check that values lying outside the accepted range are not rejected
 322   // (because clamping is enabled) but do yield a warning message.
 323   policy_map.Set(key::kDiskCacheSize, POLICY_LEVEL_MANDATORY,
 324                  POLICY_SCOPE_USER, base::Value::CreateIntegerValue(-5), NULL);
 325   errors.Clear();
 326   EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors));
 327   EXPECT_FALSE(errors.empty());
 328
 329   policy_map.Set(key::kDiskCacheSize, POLICY_LEVEL_MANDATORY,
 330                  POLICY_SCOPE_USER, base::Value::CreateIntegerValue(15), NULL);
 331   errors.Clear();
 332   EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors));
 333   EXPECT_FALSE(errors.empty());
 334
 335   // Check that an entirely invalid value is rejected and yields an error
 336   // message.
 337   policy_map.Set(key::kDiskCacheSize, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
 338                  base::Value::CreateStringValue("invalid"), NULL);
 339   errors.Clear();
 340   EXPECT_FALSE(handler.CheckPolicySettings(policy_map, &errors));
 341   EXPECT_FALSE(errors.empty());
 342 }
 343
 344 TEST(IntPercentageToDoublePolicyHandler, CheckPolicySettingsDontClamp) {
 345   PolicyMap policy_map;
 346   PolicyErrorMap errors;
 347
 348   // This tests needs to modify an int policy. The exact policy used and its
 349   // semantics outside the test are irrelevant.
 350   IntPercentageToDoublePolicyHandler handler(
 351       key::kDiskCacheSize, kTestPref, 0, 10, false);
 352
 353   // Check that values lying in the accepted range are not rejected.
 354   policy_map.Set(key::kDiskCacheSize, POLICY_LEVEL_MANDATORY,
 355                  POLICY_SCOPE_USER, base::Value::CreateIntegerValue(0), NULL);
 356   errors.Clear();
 357   EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors));
 358   EXPECT_TRUE(errors.empty());
 359
 360   policy_map.Set(key::kDiskCacheSize, POLICY_LEVEL_MANDATORY,
 361                  POLICY_SCOPE_USER, base::Value::CreateIntegerValue(5), NULL);
 362   errors.Clear();
 363   EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors));
 364   EXPECT_TRUE(errors.empty());
 365
 366   policy_map.Set(key::kDiskCacheSize, POLICY_LEVEL_MANDATORY,
 367                  POLICY_SCOPE_USER, base::Value::CreateIntegerValue(10), NULL);
 368   errors.Clear();
 369   EXPECT_TRUE(handler.CheckPolicySettings(policy_map, &errors));
 370   EXPECT_TRUE(errors.empty());
 371
 372   // Check that values lying outside the accepted range are rejected and yield
 373   // an error message.
 374   policy_map.Set(key::kDiskCacheSize, POLICY_LEVEL_MANDATORY,
 375                  POLICY_SCOPE_USER, base::Value::CreateIntegerValue(-5), NULL);
 376   errors.Clear();
 377   EXPECT_FALSE(handler.CheckPolicySettings(policy_map, &errors));
 378   EXPECT_FALSE(errors.empty());
 379
 380   policy_map.Set(key::kDiskCacheSize, POLICY_LEVEL_MANDATORY,
 381                  POLICY_SCOPE_USER, base::Value::CreateIntegerValue(15), NULL);
 382   errors.Clear();
 383   EXPECT_FALSE(handler.CheckPolicySettings(policy_map, &errors));
 384   EXPECT_FALSE(errors.empty());
 385
 386   // Check that an entirely invalid value is rejected and yields an error
 387   // message.
 388   policy_map.Set(key::kDiskCacheSize, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
 389                  base::Value::CreateStringValue("invalid"), NULL);
 390   errors.Clear();
 391   EXPECT_FALSE(handler.CheckPolicySettings(policy_map, &errors));
 392   EXPECT_FALSE(errors.empty());
 393 }
 394
 395 TEST(IntPercentageToDoublePolicyHandler, ApplyPolicySettingsClamp) {
 396   PolicyMap policy_map;
 397   PrefValueMap prefs;
 398   scoped_ptr<base::Value> expected;
 399   const base::Value* value;
 400
 401   // This tests needs to modify an int policy. The exact policy used and its
 402   // semantics outside the test are irrelevant.
 403   IntPercentageToDoublePolicyHandler handler(
 404       key::kDiskCacheSize, kTestPref, 0, 10, true);
 405
 406   // Check that values lying in the accepted range are written to the pref.
 407   policy_map.Set(key::kDiskCacheSize, POLICY_LEVEL_MANDATORY,
 408                  POLICY_SCOPE_USER, base::Value::CreateIntegerValue(0), NULL);
 409   prefs.Clear();
 410   handler.ApplyPolicySettings(policy_map, &prefs);
 411   expected.reset(base::Value::CreateDoubleValue(0.0));
 412   EXPECT_TRUE(prefs.GetValue(kTestPref, &value));
 413   EXPECT_TRUE(base::Value::Equals(expected.get(), value));
 414
 415   policy_map.Set(key::kDiskCacheSize, POLICY_LEVEL_MANDATORY,
 416                  POLICY_SCOPE_USER, base::Value::CreateIntegerValue(5), NULL);
 417   prefs.Clear();
 418   handler.ApplyPolicySettings(policy_map, &prefs);
 419   expected.reset(base::Value::CreateDoubleValue(0.05));
 420   EXPECT_TRUE(prefs.GetValue(kTestPref, &value));
 421   EXPECT_TRUE(base::Value::Equals(expected.get(), value));
 422
 423   policy_map.Set(key::kDiskCacheSize, POLICY_LEVEL_MANDATORY,
 424                  POLICY_SCOPE_USER, base::Value::CreateIntegerValue(10), NULL);
 425   prefs.Clear();
 426   handler.ApplyPolicySettings(policy_map, &prefs);
 427   expected.reset(base::Value::CreateDoubleValue(0.1));
 428   EXPECT_TRUE(prefs.GetValue(kTestPref, &value));
 429   EXPECT_TRUE(base::Value::Equals(expected.get(), value));
 430
 431   // Check that values lying outside the accepted range are clamped and written
 432   // to the pref.
 433   policy_map.Set(key::kDiskCacheSize, POLICY_LEVEL_MANDATORY,
 434                  POLICY_SCOPE_USER, base::Value::CreateIntegerValue(-5), NULL);
 435   prefs.Clear();
 436   handler.ApplyPolicySettings(policy_map, &prefs);
 437   expected.reset(base::Value::CreateDoubleValue(0.0));
 438   EXPECT_TRUE(prefs.GetValue(kTestPref, &value));
 439   EXPECT_TRUE(base::Value::Equals(expected.get(), value));
 440
 441   policy_map.Set(key::kDiskCacheSize, POLICY_LEVEL_MANDATORY,
 442                  POLICY_SCOPE_USER, base::Value::CreateIntegerValue(15), NULL);
 443   prefs.Clear();
 444   handler.ApplyPolicySettings(policy_map, &prefs);
 445   expected.reset(base::Value::CreateDoubleValue(0.1));
 446   EXPECT_TRUE(prefs.GetValue(kTestPref, &value));
 447   EXPECT_TRUE(base::Value::Equals(expected.get(), value));
 448 }
 449
 450 TEST(IntPercentageToDoublePolicyHandler, ApplyPolicySettingsDontClamp) {
 451   PolicyMap policy_map;
 452   PrefValueMap prefs;
 453   scoped_ptr<base::Value> expected;
 454   const base::Value* value;
 455
 456   // This tests needs to modify an int policy. The exact policy used and its
 457   // semantics outside the test are irrelevant.
 458   IntPercentageToDoublePolicyHandler handler(
 459       key::kDiskCacheSize, kTestPref, 0, 10, true);
 460
 461   // Check that values lying in the accepted range are written to the pref.
 462   policy_map.Set(key::kDiskCacheSize, POLICY_LEVEL_MANDATORY,
 463                  POLICY_SCOPE_USER, base::Value::CreateIntegerValue(0), NULL);
 464   prefs.Clear();
 465   handler.ApplyPolicySettings(policy_map, &prefs);
 466   expected.reset(base::Value::CreateDoubleValue(0.0));
 467   EXPECT_TRUE(prefs.GetValue(kTestPref, &value));
 468   EXPECT_TRUE(base::Value::Equals(expected.get(), value));
 469
 470   policy_map.Set(key::kDiskCacheSize, POLICY_LEVEL_MANDATORY,
 471                  POLICY_SCOPE_USER, base::Value::CreateIntegerValue(5), NULL);
 472   prefs.Clear();
 473   handler.ApplyPolicySettings(policy_map, &prefs);
 474   expected.reset(base::Value::CreateDoubleValue(0.05));
 475   EXPECT_TRUE(prefs.GetValue(kTestPref, &value));
 476   EXPECT_TRUE(base::Value::Equals(expected.get(), value));
 477
 478   policy_map.Set(key::kDiskCacheSize, POLICY_LEVEL_MANDATORY,
 479                  POLICY_SCOPE_USER, base::Value::CreateIntegerValue(10), NULL);
 480   prefs.Clear();
 481   handler.ApplyPolicySettings(policy_map, &prefs);
 482   expected.reset(base::Value::CreateDoubleValue(0.1));
 483   EXPECT_TRUE(prefs.GetValue(kTestPref, &value));
 484   EXPECT_TRUE(base::Value::Equals(expected.get(), value));
 485 }
 486
 487 }  // namespace policy