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