Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(186)

Issues Search
    My Issues | Starred     Open | Closed | All

Side by Side Diff: chrome/browser/policy/configuration_policy_handler_unittest.cc

Issue 185413025: Moved policy unittests into the policy component. (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src
Patch Set: rebase Created 6 years, 9 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch | Annotate | Revision Log
« no previous file with comments | « chrome/browser/net/proxy_policy_handler_unittest.cc ('k') | chrome/browser/policy/configuration_policy_pref_store_test.h » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
(Empty)
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
OLDNEW
« no previous file with comments | « chrome/browser/net/proxy_policy_handler_unittest.cc ('k') | chrome/browser/policy/configuration_policy_pref_store_test.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698