| OLD | NEW |
|---|
| (Empty) |
| 1 #!/usr/bin/env python | |
| 2 # Copyright (c) 2012 The Chromium Authors. All rights reserved. | |
| 3 # Use of this source code is governed by a BSD-style license that can be | |
| 4 # found in the LICENSE file. | |
| 5 | |
| 6 '''Unit tests for grit.format.policy_templates.writers.adm_writer''' | |
| 7 | |
| 8 | |
| 9 import os | |
| 10 import sys | |
| 11 if __name__ == '__main__': | |
| 12 sys.path.append(os.path.join(os.path.dirname(__file__), '../../../..')) | |
| 13 | |
| 14 import unittest | |
| 15 | |
| 16 from grit.format.policy_templates.writers import writer_unittest_common | |
| 17 | |
| 18 | |
| 19 class AdmWriterUnittest(writer_unittest_common.WriterUnittestCommon): | |
| 20 '''Unit tests for AdmWriter.''' | |
| 21 | |
| 22 def ConstructOutput(self, classes, body, strings): | |
| 23 result = [] | |
| 24 for clazz in classes: | |
| 25 result.append('CLASS ' + clazz) | |
| 26 result.append(body) | |
| 27 result.append(strings) | |
| 28 return ''.join(result) | |
| 29 | |
| 30 def CompareOutputs(self, output, expected_output): | |
| 31 '''Compares the output of the adm_writer with its expected output. | |
| 32 | |
| 33 Args: | |
| 34 output: The output of the adm writer as returned by grit. | |
| 35 expected_output: The expected output. | |
| 36 | |
| 37 Raises: | |
| 38 AssertionError: if the two strings are not equivalent. | |
| 39 ''' | |
| 40 self.assertEquals( | |
| 41 output.strip(), | |
| 42 expected_output.strip().replace('\n', '\r\n')) | |
| 43 | |
| 44 def testEmpty(self): | |
| 45 # Test PListWriter in case of empty polices. | |
| 46 grd = self.PrepareTest(''' | |
| 47 { | |
| 48 'policy_definitions': [], | |
| 49 'placeholders': [], | |
| 50 'messages': { | |
| 51 'win_supported_winxpsp2': { | |
| 52 'text': 'At least "Windows 3.11', 'desc': 'blah' | |
| 53 }, | |
| 54 'doc_recommended': { | |
| 55 'text': 'Recommended', 'desc': 'bleh' | |
| 56 } | |
| 57 } | |
| 58 }''') | |
| 59 output = self.GetOutput(grd, 'fr', {'_chromium': '1',}, 'adm', 'en') | |
| 60 expected_output = self.ConstructOutput( | |
| 61 ['MACHINE', 'USER'], ''' | |
| 62 CATEGORY !!chromium | |
| 63 KEYNAME "Software\\Policies\\Chromium" | |
| 64 | |
| 65 END CATEGORY | |
| 66 | |
| 67 CATEGORY !!chromium_recommended | |
| 68 KEYNAME "Software\\Policies\\Chromium\\Recommended" | |
| 69 | |
| 70 END CATEGORY | |
| 71 | |
| 72 | |
| 73 ''', '''[Strings] | |
| 74 SUPPORTED_WINXPSP2="At least "Windows 3.11" | |
| 75 chromium="Chromium" | |
| 76 chromium_recommended="Chromium - Recommended"''') | |
| 77 self.CompareOutputs(output, expected_output) | |
| 78 | |
| 79 def testVersionAnnotation(self): | |
| 80 # Test PListWriter in case of empty polices. | |
| 81 grd = self.PrepareTest(''' | |
| 82 { | |
| 83 'policy_definitions': [], | |
| 84 'placeholders': [], | |
| 85 'messages': { | |
| 86 'win_supported_winxpsp2': { | |
| 87 'text': 'At least "Windows 3.11', 'desc': 'blah' | |
| 88 }, | |
| 89 'doc_recommended': { | |
| 90 'text': 'Recommended', 'desc': 'bleh' | |
| 91 } | |
| 92 } | |
| 93 }''') | |
| 94 output = self.GetOutput( | |
| 95 grd, 'fr', {'_chromium': '1', 'version':'39.0.0.0'}, 'adm', 'en') | |
| 96 expected_output = '; chromium version: 39.0.0.0\n' + \ | |
| 97 self.ConstructOutput(['MACHINE', 'USER'], ''' | |
| 98 CATEGORY !!chromium | |
| 99 KEYNAME "Software\\Policies\\Chromium" | |
| 100 | |
| 101 END CATEGORY | |
| 102 | |
| 103 CATEGORY !!chromium_recommended | |
| 104 KEYNAME "Software\\Policies\\Chromium\\Recommended" | |
| 105 | |
| 106 END CATEGORY | |
| 107 | |
| 108 | |
| 109 ''', '''[Strings] | |
| 110 SUPPORTED_WINXPSP2="At least "Windows 3.11" | |
| 111 chromium="Chromium" | |
| 112 chromium_recommended="Chromium - Recommended"''') | |
| 113 self.CompareOutputs(output, expected_output) | |
| 114 | |
| 115 def testMainPolicy(self): | |
| 116 # Tests a policy group with a single policy of type 'main'. | |
| 117 grd = self.PrepareTest(''' | |
| 118 { | |
| 119 'policy_definitions': [ | |
| 120 { | |
| 121 'name': 'MainPolicy', | |
| 122 'type': 'main', | |
| 123 'supported_on': ['chrome.win:8-'], | |
| 124 'features': { 'can_be_recommended': True }, | |
| 125 'caption': 'Caption of main.', | |
| 126 'desc': 'Description of main.', | |
| 127 }, | |
| 128 ], | |
| 129 'placeholders': [], | |
| 130 'messages': { | |
| 131 'win_supported_winxpsp2': { | |
| 132 'text': 'At least Windows 3.12', 'desc': 'blah' | |
| 133 }, | |
| 134 'doc_recommended': { | |
| 135 'text': 'Recommended', 'desc': 'bleh' | |
| 136 } | |
| 137 } | |
| 138 }''') | |
| 139 output = self.GetOutput(grd, 'fr', {'_google_chrome' : '1'}, 'adm', 'en') | |
| 140 expected_output = self.ConstructOutput( | |
| 141 ['MACHINE', 'USER'], ''' | |
| 142 CATEGORY !!google | |
| 143 CATEGORY !!googlechrome | |
| 144 KEYNAME "Software\\Policies\\Google\\Chrome" | |
| 145 | |
| 146 POLICY !!MainPolicy_Policy | |
| 147 #if version >= 4 | |
| 148 SUPPORTED !!SUPPORTED_WINXPSP2 | |
| 149 #endif | |
| 150 EXPLAIN !!MainPolicy_Explain | |
| 151 VALUENAME "MainPolicy" | |
| 152 VALUEON NUMERIC 1 | |
| 153 VALUEOFF NUMERIC 0 | |
| 154 END POLICY | |
| 155 | |
| 156 END CATEGORY | |
| 157 END CATEGORY | |
| 158 | |
| 159 CATEGORY !!google | |
| 160 CATEGORY !!googlechrome_recommended | |
| 161 KEYNAME "Software\\Policies\\Google\\Chrome\\Recommended" | |
| 162 | |
| 163 POLICY !!MainPolicy_Policy | |
| 164 #if version >= 4 | |
| 165 SUPPORTED !!SUPPORTED_WINXPSP2 | |
| 166 #endif | |
| 167 EXPLAIN !!MainPolicy_Explain | |
| 168 VALUENAME "MainPolicy" | |
| 169 VALUEON NUMERIC 1 | |
| 170 VALUEOFF NUMERIC 0 | |
| 171 END POLICY | |
| 172 | |
| 173 END CATEGORY | |
| 174 END CATEGORY | |
| 175 | |
| 176 | |
| 177 ''', '''[Strings] | |
| 178 SUPPORTED_WINXPSP2="At least Windows 3.12" | |
| 179 google="Google" | |
| 180 googlechrome="Google Chrome" | |
| 181 googlechrome_recommended="Google Chrome - Recommended" | |
| 182 MainPolicy_Policy="Caption of main." | |
| 183 MainPolicy_Explain="Description of main."''') | |
| 184 self.CompareOutputs(output, expected_output) | |
| 185 | |
| 186 def testMainPolicyRecommendedOnly(self): | |
| 187 # Tests a policy group with a single policy of type 'main'. | |
| 188 grd = self.PrepareTest(''' | |
| 189 { | |
| 190 'policy_definitions': [ | |
| 191 { | |
| 192 'name': 'MainPolicy', | |
| 193 'type': 'main', | |
| 194 'supported_on': ['chrome.win:8-'], | |
| 195 'features': { | |
| 196 'can_be_recommended': True, | |
| 197 'can_be_mandatory': False | |
| 198 }, | |
| 199 'caption': 'Caption of main.', | |
| 200 'desc': 'Description of main.', | |
| 201 }, | |
| 202 ], | |
| 203 'placeholders': [], | |
| 204 'messages': { | |
| 205 'win_supported_winxpsp2': { | |
| 206 'text': 'At least Windows 3.12', 'desc': 'blah' | |
| 207 }, | |
| 208 'doc_recommended': { | |
| 209 'text': 'Recommended', 'desc': 'bleh' | |
| 210 } | |
| 211 } | |
| 212 }''') | |
| 213 output = self.GetOutput(grd, 'fr', {'_google_chrome' : '1'}, 'adm', 'en') | |
| 214 expected_output = self.ConstructOutput( | |
| 215 ['MACHINE', 'USER'], ''' | |
| 216 CATEGORY !!google | |
| 217 CATEGORY !!googlechrome | |
| 218 KEYNAME "Software\\Policies\\Google\\Chrome" | |
| 219 | |
| 220 END CATEGORY | |
| 221 END CATEGORY | |
| 222 | |
| 223 CATEGORY !!google | |
| 224 CATEGORY !!googlechrome_recommended | |
| 225 KEYNAME "Software\\Policies\\Google\\Chrome\\Recommended" | |
| 226 | |
| 227 POLICY !!MainPolicy_Policy | |
| 228 #if version >= 4 | |
| 229 SUPPORTED !!SUPPORTED_WINXPSP2 | |
| 230 #endif | |
| 231 EXPLAIN !!MainPolicy_Explain | |
| 232 VALUENAME "MainPolicy" | |
| 233 VALUEON NUMERIC 1 | |
| 234 VALUEOFF NUMERIC 0 | |
| 235 END POLICY | |
| 236 | |
| 237 END CATEGORY | |
| 238 END CATEGORY | |
| 239 | |
| 240 | |
| 241 ''', '''[Strings] | |
| 242 SUPPORTED_WINXPSP2="At least Windows 3.12" | |
| 243 google="Google" | |
| 244 googlechrome="Google Chrome" | |
| 245 googlechrome_recommended="Google Chrome - Recommended" | |
| 246 MainPolicy_Policy="Caption of main." | |
| 247 MainPolicy_Explain="Description of main."''') | |
| 248 self.CompareOutputs(output, expected_output) | |
| 249 | |
| 250 def testStringPolicy(self): | |
| 251 # Tests a policy group with a single policy of type 'string'. | |
| 252 grd = self.PrepareTest(''' | |
| 253 { | |
| 254 'policy_definitions': [ | |
| 255 { | |
| 256 'name': 'StringPolicy', | |
| 257 'type': 'string', | |
| 258 'supported_on': ['chrome.win:8-'], | |
| 259 'features': { 'can_be_recommended': True }, | |
| 260 'desc': """Description of group. | |
| 261 With a newline.""", | |
| 262 'caption': 'Caption of policy.', | |
| 263 }, | |
| 264 ], | |
| 265 'placeholders': [], | |
| 266 'messages': { | |
| 267 'win_supported_winxpsp2': { | |
| 268 'text': 'At least Windows 3.13', 'desc': 'blah' | |
| 269 }, | |
| 270 'doc_recommended': { | |
| 271 'text': 'Recommended', 'desc': 'bleh' | |
| 272 } | |
| 273 } | |
| 274 }''') | |
| 275 output = self.GetOutput(grd, 'fr', {'_chromium' : '1'}, 'adm', 'en') | |
| 276 expected_output = self.ConstructOutput( | |
| 277 ['MACHINE', 'USER'], ''' | |
| 278 CATEGORY !!chromium | |
| 279 KEYNAME "Software\\Policies\\Chromium" | |
| 280 | |
| 281 POLICY !!StringPolicy_Policy | |
| 282 #if version >= 4 | |
| 283 SUPPORTED !!SUPPORTED_WINXPSP2 | |
| 284 #endif | |
| 285 EXPLAIN !!StringPolicy_Explain | |
| 286 | |
| 287 PART !!StringPolicy_Part EDITTEXT | |
| 288 VALUENAME "StringPolicy" | |
| 289 MAXLEN 1000000 | |
| 290 END PART | |
| 291 END POLICY | |
| 292 | |
| 293 END CATEGORY | |
| 294 | |
| 295 CATEGORY !!chromium_recommended | |
| 296 KEYNAME "Software\\Policies\\Chromium\\Recommended" | |
| 297 | |
| 298 POLICY !!StringPolicy_Policy | |
| 299 #if version >= 4 | |
| 300 SUPPORTED !!SUPPORTED_WINXPSP2 | |
| 301 #endif | |
| 302 EXPLAIN !!StringPolicy_Explain | |
| 303 | |
| 304 PART !!StringPolicy_Part EDITTEXT | |
| 305 VALUENAME "StringPolicy" | |
| 306 MAXLEN 1000000 | |
| 307 END PART | |
| 308 END POLICY | |
| 309 | |
| 310 END CATEGORY | |
| 311 | |
| 312 | |
| 313 ''', '''[Strings] | |
| 314 SUPPORTED_WINXPSP2="At least Windows 3.13" | |
| 315 chromium="Chromium" | |
| 316 chromium_recommended="Chromium - Recommended" | |
| 317 StringPolicy_Policy="Caption of policy." | |
| 318 StringPolicy_Explain="Description of group.\\nWith a newline." | |
| 319 StringPolicy_Part="Caption of policy." | |
| 320 ''') | |
| 321 self.CompareOutputs(output, expected_output) | |
| 322 | |
| 323 def testIntPolicy(self): | |
| 324 # Tests a policy group with a single policy of type 'string'. | |
| 325 grd = self.PrepareTest(''' | |
| 326 { | |
| 327 'policy_definitions': [ | |
| 328 { | |
| 329 'name': 'IntPolicy', | |
| 330 'type': 'int', | |
| 331 'caption': 'Caption of policy.', | |
| 332 'features': { 'can_be_recommended': True }, | |
| 333 'desc': 'Description of policy.', | |
| 334 'supported_on': ['chrome.win:8-'] | |
| 335 }, | |
| 336 ], | |
| 337 'placeholders': [], | |
| 338 'messages': { | |
| 339 'win_supported_winxpsp2': { | |
| 340 'text': 'At least Windows 3.13', 'desc': 'blah' | |
| 341 }, | |
| 342 'doc_recommended': { | |
| 343 'text': 'Recommended', 'desc': 'bleh' | |
| 344 } | |
| 345 } | |
| 346 }''') | |
| 347 output = self.GetOutput(grd, 'fr', {'_chromium' : '1'}, 'adm', 'en') | |
| 348 expected_output = self.ConstructOutput( | |
| 349 ['MACHINE', 'USER'], ''' | |
| 350 CATEGORY !!chromium | |
| 351 KEYNAME "Software\\Policies\\Chromium" | |
| 352 | |
| 353 POLICY !!IntPolicy_Policy | |
| 354 #if version >= 4 | |
| 355 SUPPORTED !!SUPPORTED_WINXPSP2 | |
| 356 #endif | |
| 357 EXPLAIN !!IntPolicy_Explain | |
| 358 | |
| 359 PART !!IntPolicy_Part NUMERIC | |
| 360 VALUENAME "IntPolicy" | |
| 361 MIN 0 MAX 2000000000 | |
| 362 END PART | |
| 363 END POLICY | |
| 364 | |
| 365 END CATEGORY | |
| 366 | |
| 367 CATEGORY !!chromium_recommended | |
| 368 KEYNAME "Software\\Policies\\Chromium\\Recommended" | |
| 369 | |
| 370 POLICY !!IntPolicy_Policy | |
| 371 #if version >= 4 | |
| 372 SUPPORTED !!SUPPORTED_WINXPSP2 | |
| 373 #endif | |
| 374 EXPLAIN !!IntPolicy_Explain | |
| 375 | |
| 376 PART !!IntPolicy_Part NUMERIC | |
| 377 VALUENAME "IntPolicy" | |
| 378 MIN 0 MAX 2000000000 | |
| 379 END PART | |
| 380 END POLICY | |
| 381 | |
| 382 END CATEGORY | |
| 383 | |
| 384 | |
| 385 ''', '''[Strings] | |
| 386 SUPPORTED_WINXPSP2="At least Windows 3.13" | |
| 387 chromium="Chromium" | |
| 388 chromium_recommended="Chromium - Recommended" | |
| 389 IntPolicy_Policy="Caption of policy." | |
| 390 IntPolicy_Explain="Description of policy." | |
| 391 IntPolicy_Part="Caption of policy." | |
| 392 ''') | |
| 393 self.CompareOutputs(output, expected_output) | |
| 394 | |
| 395 def testIntEnumPolicy(self): | |
| 396 # Tests a policy group with a single policy of type 'int-enum'. | |
| 397 grd = self.PrepareTest(''' | |
| 398 { | |
| 399 'policy_definitions': [ | |
| 400 { | |
| 401 'name': 'EnumPolicy', | |
| 402 'type': 'int-enum', | |
| 403 'items': [ | |
| 404 { | |
| 405 'name': 'ProxyServerDisabled', | |
| 406 'value': 0, | |
| 407 'caption': 'Option1', | |
| 408 }, | |
| 409 { | |
| 410 'name': 'ProxyServerAutoDetect', | |
| 411 'value': 1, | |
| 412 'caption': 'Option2', | |
| 413 }, | |
| 414 ], | |
| 415 'desc': 'Description of policy.', | |
| 416 'caption': 'Caption of policy.', | |
| 417 'supported_on': ['chrome.win:8-'], | |
| 418 'features': { 'can_be_recommended': True }, | |
| 419 }, | |
| 420 ], | |
| 421 'placeholders': [], | |
| 422 'messages': { | |
| 423 'win_supported_winxpsp2': { | |
| 424 'text': 'At least Windows 3.14', 'desc': 'blah' | |
| 425 }, | |
| 426 'doc_recommended': { | |
| 427 'text': 'Recommended', 'desc': 'bleh' | |
| 428 } | |
| 429 } | |
| 430 }''') | |
| 431 output = self.GetOutput(grd, 'fr', {'_google_chrome': '1'}, 'adm', 'en') | |
| 432 expected_output = self.ConstructOutput( | |
| 433 ['MACHINE', 'USER'], ''' | |
| 434 CATEGORY !!google | |
| 435 CATEGORY !!googlechrome | |
| 436 KEYNAME "Software\\Policies\\Google\\Chrome" | |
| 437 | |
| 438 POLICY !!EnumPolicy_Policy | |
| 439 #if version >= 4 | |
| 440 SUPPORTED !!SUPPORTED_WINXPSP2 | |
| 441 #endif | |
| 442 EXPLAIN !!EnumPolicy_Explain | |
| 443 | |
| 444 PART !!EnumPolicy_Part DROPDOWNLIST | |
| 445 VALUENAME "EnumPolicy" | |
| 446 ITEMLIST | |
| 447 NAME !!ProxyServerDisabled_DropDown VALUE NUMERIC 0 | |
| 448 NAME !!ProxyServerAutoDetect_DropDown VALUE NUMERIC 1 | |
| 449 END ITEMLIST | |
| 450 END PART | |
| 451 END POLICY | |
| 452 | |
| 453 END CATEGORY | |
| 454 END CATEGORY | |
| 455 | |
| 456 CATEGORY !!google | |
| 457 CATEGORY !!googlechrome_recommended | |
| 458 KEYNAME "Software\\Policies\\Google\\Chrome\\Recommended" | |
| 459 | |
| 460 POLICY !!EnumPolicy_Policy | |
| 461 #if version >= 4 | |
| 462 SUPPORTED !!SUPPORTED_WINXPSP2 | |
| 463 #endif | |
| 464 EXPLAIN !!EnumPolicy_Explain | |
| 465 | |
| 466 PART !!EnumPolicy_Part DROPDOWNLIST | |
| 467 VALUENAME "EnumPolicy" | |
| 468 ITEMLIST | |
| 469 NAME !!ProxyServerDisabled_DropDown VALUE NUMERIC 0 | |
| 470 NAME !!ProxyServerAutoDetect_DropDown VALUE NUMERIC 1 | |
| 471 END ITEMLIST | |
| 472 END PART | |
| 473 END POLICY | |
| 474 | |
| 475 END CATEGORY | |
| 476 END CATEGORY | |
| 477 | |
| 478 | |
| 479 ''', '''[Strings] | |
| 480 SUPPORTED_WINXPSP2="At least Windows 3.14" | |
| 481 google="Google" | |
| 482 googlechrome="Google Chrome" | |
| 483 googlechrome_recommended="Google Chrome - Recommended" | |
| 484 EnumPolicy_Policy="Caption of policy." | |
| 485 EnumPolicy_Explain="Description of policy." | |
| 486 EnumPolicy_Part="Caption of policy." | |
| 487 ProxyServerDisabled_DropDown="Option1" | |
| 488 ProxyServerAutoDetect_DropDown="Option2" | |
| 489 ''') | |
| 490 self.CompareOutputs(output, expected_output) | |
| 491 | |
| 492 def testStringEnumPolicy(self): | |
| 493 # Tests a policy group with a single policy of type 'int-enum'. | |
| 494 grd = self.PrepareTest(''' | |
| 495 { | |
| 496 'policy_definitions': [ | |
| 497 { | |
| 498 'name': 'EnumPolicy', | |
| 499 'type': 'string-enum', | |
| 500 'caption': 'Caption of policy.', | |
| 501 'desc': 'Description of policy.', | |
| 502 'items': [ | |
| 503 {'name': 'ProxyServerDisabled', 'value': 'one', | |
| 504 'caption': 'Option1'}, | |
| 505 {'name': 'ProxyServerAutoDetect', 'value': 'two', | |
| 506 'caption': 'Option2'}, | |
| 507 ], | |
| 508 'supported_on': ['chrome.win:8-'], | |
| 509 'features': { 'can_be_recommended': True }, | |
| 510 }, | |
| 511 ], | |
| 512 'placeholders': [], | |
| 513 'messages': { | |
| 514 'win_supported_winxpsp2': { | |
| 515 'text': 'At least Windows 3.14', 'desc': 'blah' | |
| 516 }, | |
| 517 'doc_recommended': { | |
| 518 'text': 'Recommended', 'desc': 'bleh' | |
| 519 } | |
| 520 } | |
| 521 }''') | |
| 522 output = self.GetOutput(grd, 'fr', {'_google_chrome': '1'}, 'adm', 'en') | |
| 523 expected_output = self.ConstructOutput( | |
| 524 ['MACHINE', 'USER'], ''' | |
| 525 CATEGORY !!google | |
| 526 CATEGORY !!googlechrome | |
| 527 KEYNAME "Software\\Policies\\Google\\Chrome" | |
| 528 | |
| 529 POLICY !!EnumPolicy_Policy | |
| 530 #if version >= 4 | |
| 531 SUPPORTED !!SUPPORTED_WINXPSP2 | |
| 532 #endif | |
| 533 EXPLAIN !!EnumPolicy_Explain | |
| 534 | |
| 535 PART !!EnumPolicy_Part DROPDOWNLIST | |
| 536 VALUENAME "EnumPolicy" | |
| 537 ITEMLIST | |
| 538 NAME !!ProxyServerDisabled_DropDown VALUE "one" | |
| 539 NAME !!ProxyServerAutoDetect_DropDown VALUE "two" | |
| 540 END ITEMLIST | |
| 541 END PART | |
| 542 END POLICY | |
| 543 | |
| 544 END CATEGORY | |
| 545 END CATEGORY | |
| 546 | |
| 547 CATEGORY !!google | |
| 548 CATEGORY !!googlechrome_recommended | |
| 549 KEYNAME "Software\\Policies\\Google\\Chrome\\Recommended" | |
| 550 | |
| 551 POLICY !!EnumPolicy_Policy | |
| 552 #if version >= 4 | |
| 553 SUPPORTED !!SUPPORTED_WINXPSP2 | |
| 554 #endif | |
| 555 EXPLAIN !!EnumPolicy_Explain | |
| 556 | |
| 557 PART !!EnumPolicy_Part DROPDOWNLIST | |
| 558 VALUENAME "EnumPolicy" | |
| 559 ITEMLIST | |
| 560 NAME !!ProxyServerDisabled_DropDown VALUE "one" | |
| 561 NAME !!ProxyServerAutoDetect_DropDown VALUE "two" | |
| 562 END ITEMLIST | |
| 563 END PART | |
| 564 END POLICY | |
| 565 | |
| 566 END CATEGORY | |
| 567 END CATEGORY | |
| 568 | |
| 569 | |
| 570 ''', '''[Strings] | |
| 571 SUPPORTED_WINXPSP2="At least Windows 3.14" | |
| 572 google="Google" | |
| 573 googlechrome="Google Chrome" | |
| 574 googlechrome_recommended="Google Chrome - Recommended" | |
| 575 EnumPolicy_Policy="Caption of policy." | |
| 576 EnumPolicy_Explain="Description of policy." | |
| 577 EnumPolicy_Part="Caption of policy." | |
| 578 ProxyServerDisabled_DropDown="Option1" | |
| 579 ProxyServerAutoDetect_DropDown="Option2" | |
| 580 ''') | |
| 581 self.CompareOutputs(output, expected_output) | |
| 582 | |
| 583 def testListPolicy(self): | |
| 584 # Tests a policy group with a single policy of type 'list'. | |
| 585 grd = self.PrepareTest(''' | |
| 586 { | |
| 587 'policy_definitions': [ | |
| 588 { | |
| 589 'name': 'ListPolicy', | |
| 590 'type': 'list', | |
| 591 'supported_on': ['chrome.win:8-'], | |
| 592 'features': { 'can_be_recommended': True }, | |
| 593 'desc': """Description of list policy. | |
| 594 With a newline.""", | |
| 595 'caption': 'Caption of list policy.', | |
| 596 'label': 'Label of list policy.' | |
| 597 }, | |
| 598 ], | |
| 599 'placeholders': [], | |
| 600 'messages': { | |
| 601 'win_supported_winxpsp2': { | |
| 602 'text': 'At least Windows 3.15', 'desc': 'blah' | |
| 603 }, | |
| 604 'doc_recommended': { | |
| 605 'text': 'Recommended', 'desc': 'bleh' | |
| 606 } | |
| 607 }, | |
| 608 }''') | |
| 609 output = self.GetOutput(grd, 'fr', {'_chromium' : '1'}, 'adm', 'en') | |
| 610 expected_output = self.ConstructOutput( | |
| 611 ['MACHINE', 'USER'], ''' | |
| 612 CATEGORY !!chromium | |
| 613 KEYNAME "Software\\Policies\\Chromium" | |
| 614 | |
| 615 POLICY !!ListPolicy_Policy | |
| 616 #if version >= 4 | |
| 617 SUPPORTED !!SUPPORTED_WINXPSP2 | |
| 618 #endif | |
| 619 EXPLAIN !!ListPolicy_Explain | |
| 620 | |
| 621 PART !!ListPolicy_Part LISTBOX | |
| 622 KEYNAME "Software\\Policies\\Chromium\\ListPolicy" | |
| 623 VALUEPREFIX "" | |
| 624 END PART | |
| 625 END POLICY | |
| 626 | |
| 627 END CATEGORY | |
| 628 | |
| 629 CATEGORY !!chromium_recommended | |
| 630 KEYNAME "Software\\Policies\\Chromium\\Recommended" | |
| 631 | |
| 632 POLICY !!ListPolicy_Policy | |
| 633 #if version >= 4 | |
| 634 SUPPORTED !!SUPPORTED_WINXPSP2 | |
| 635 #endif | |
| 636 EXPLAIN !!ListPolicy_Explain | |
| 637 | |
| 638 PART !!ListPolicy_Part LISTBOX | |
| 639 KEYNAME "Software\\Policies\\Chromium\\Recommended\\ListPolicy" | |
| 640 VALUEPREFIX "" | |
| 641 END PART | |
| 642 END POLICY | |
| 643 | |
| 644 END CATEGORY | |
| 645 | |
| 646 | |
| 647 ''', '''[Strings] | |
| 648 SUPPORTED_WINXPSP2="At least Windows 3.15" | |
| 649 chromium="Chromium" | |
| 650 chromium_recommended="Chromium - Recommended" | |
| 651 ListPolicy_Policy="Caption of list policy." | |
| 652 ListPolicy_Explain="Description of list policy.\\nWith a newline." | |
| 653 ListPolicy_Part="Label of list policy." | |
| 654 ''') | |
| 655 self.CompareOutputs(output, expected_output) | |
| 656 | |
| 657 def testStringEnumListPolicy(self): | |
| 658 # Tests a policy group with a single policy of type 'string-enum-list'. | |
| 659 grd = self.PrepareTest(''' | |
| 660 { | |
| 661 'policy_definitions': [ | |
| 662 { | |
| 663 'name': 'ListPolicy', | |
| 664 'type': 'string-enum-list', | |
| 665 'supported_on': ['chrome.win:8-'], | |
| 666 'features': { 'can_be_recommended': True }, | |
| 667 'desc': """Description of list policy. | |
| 668 With a newline.""", | |
| 669 'items': [ | |
| 670 {'name': 'ProxyServerDisabled', 'value': 'one', | |
| 671 'caption': 'Option1'}, | |
| 672 {'name': 'ProxyServerAutoDetect', 'value': 'two', | |
| 673 'caption': 'Option2'}, | |
| 674 ], | |
| 675 'caption': 'Caption of list policy.', | |
| 676 'label': 'Label of list policy.' | |
| 677 }, | |
| 678 ], | |
| 679 'placeholders': [], | |
| 680 'messages': { | |
| 681 'win_supported_winxpsp2': { | |
| 682 'text': 'At least Windows 3.15', 'desc': 'blah' | |
| 683 }, | |
| 684 'doc_recommended': { | |
| 685 'text': 'Recommended', 'desc': 'bleh' | |
| 686 } | |
| 687 }, | |
| 688 }''') | |
| 689 output = self.GetOutput(grd, 'fr', {'_chromium' : '1'}, 'adm', 'en') | |
| 690 expected_output = self.ConstructOutput( | |
| 691 ['MACHINE', 'USER'], ''' | |
| 692 CATEGORY !!chromium | |
| 693 KEYNAME "Software\\Policies\\Chromium" | |
| 694 | |
| 695 POLICY !!ListPolicy_Policy | |
| 696 #if version >= 4 | |
| 697 SUPPORTED !!SUPPORTED_WINXPSP2 | |
| 698 #endif | |
| 699 EXPLAIN !!ListPolicy_Explain | |
| 700 | |
| 701 PART !!ListPolicy_Part LISTBOX | |
| 702 KEYNAME "Software\\Policies\\Chromium\\ListPolicy" | |
| 703 VALUEPREFIX "" | |
| 704 END PART | |
| 705 END POLICY | |
| 706 | |
| 707 END CATEGORY | |
| 708 | |
| 709 CATEGORY !!chromium_recommended | |
| 710 KEYNAME "Software\\Policies\\Chromium\\Recommended" | |
| 711 | |
| 712 POLICY !!ListPolicy_Policy | |
| 713 #if version >= 4 | |
| 714 SUPPORTED !!SUPPORTED_WINXPSP2 | |
| 715 #endif | |
| 716 EXPLAIN !!ListPolicy_Explain | |
| 717 | |
| 718 PART !!ListPolicy_Part LISTBOX | |
| 719 KEYNAME "Software\\Policies\\Chromium\\Recommended\\ListPolicy" | |
| 720 VALUEPREFIX "" | |
| 721 END PART | |
| 722 END POLICY | |
| 723 | |
| 724 END CATEGORY | |
| 725 | |
| 726 | |
| 727 ''', '''[Strings] | |
| 728 SUPPORTED_WINXPSP2="At least Windows 3.15" | |
| 729 chromium="Chromium" | |
| 730 chromium_recommended="Chromium - Recommended" | |
| 731 ListPolicy_Policy="Caption of list policy." | |
| 732 ListPolicy_Explain="Description of list policy.\\nWith a newline." | |
| 733 ListPolicy_Part="Label of list policy." | |
| 734 ''') | |
| 735 self.CompareOutputs(output, expected_output) | |
| 736 | |
| 737 def testDictionaryPolicy(self): | |
| 738 # Tests a policy group with a single policy of type 'dict'. | |
| 739 grd = self.PrepareTest(''' | |
| 740 { | |
| 741 'policy_definitions': [ | |
| 742 { | |
| 743 'name': 'DictionaryPolicy', | |
| 744 'type': 'dict', | |
| 745 'supported_on': ['chrome.win:8-'], | |
| 746 'features': { 'can_be_recommended': True }, | |
| 747 'desc': 'Description of group.', | |
| 748 'caption': 'Caption of policy.', | |
| 749 }, | |
| 750 ], | |
| 751 'placeholders': [], | |
| 752 'messages': { | |
| 753 'win_supported_winxpsp2': { | |
| 754 'text': 'At least Windows 3.13', 'desc': 'blah' | |
| 755 }, | |
| 756 'doc_recommended': { | |
| 757 'text': 'Recommended', 'desc': 'bleh' | |
| 758 } | |
| 759 } | |
| 760 }''') | |
| 761 output = self.GetOutput(grd, 'fr', {'_chromium' : '1'}, 'adm', 'en') | |
| 762 expected_output = self.ConstructOutput( | |
| 763 ['MACHINE', 'USER'], ''' | |
| 764 CATEGORY !!chromium | |
| 765 KEYNAME "Software\\Policies\\Chromium" | |
| 766 | |
| 767 POLICY !!DictionaryPolicy_Policy | |
| 768 #if version >= 4 | |
| 769 SUPPORTED !!SUPPORTED_WINXPSP2 | |
| 770 #endif | |
| 771 EXPLAIN !!DictionaryPolicy_Explain | |
| 772 | |
| 773 PART !!DictionaryPolicy_Part EDITTEXT | |
| 774 VALUENAME "DictionaryPolicy" | |
| 775 MAXLEN 1000000 | |
| 776 END PART | |
| 777 END POLICY | |
| 778 | |
| 779 END CATEGORY | |
| 780 | |
| 781 CATEGORY !!chromium_recommended | |
| 782 KEYNAME "Software\\Policies\\Chromium\\Recommended" | |
| 783 | |
| 784 POLICY !!DictionaryPolicy_Policy | |
| 785 #if version >= 4 | |
| 786 SUPPORTED !!SUPPORTED_WINXPSP2 | |
| 787 #endif | |
| 788 EXPLAIN !!DictionaryPolicy_Explain | |
| 789 | |
| 790 PART !!DictionaryPolicy_Part EDITTEXT | |
| 791 VALUENAME "DictionaryPolicy" | |
| 792 MAXLEN 1000000 | |
| 793 END PART | |
| 794 END POLICY | |
| 795 | |
| 796 END CATEGORY | |
| 797 | |
| 798 | |
| 799 ''', '''[Strings] | |
| 800 SUPPORTED_WINXPSP2="At least Windows 3.13" | |
| 801 chromium="Chromium" | |
| 802 chromium_recommended="Chromium - Recommended" | |
| 803 DictionaryPolicy_Policy="Caption of policy." | |
| 804 DictionaryPolicy_Explain="Description of group." | |
| 805 DictionaryPolicy_Part="Caption of policy." | |
| 806 ''') | |
| 807 self.CompareOutputs(output, expected_output) | |
| 808 | |
| 809 def testNonSupportedPolicy(self): | |
| 810 # Tests a policy that is not supported on Windows, so it shouldn't | |
| 811 # be included in the ADM file. | |
| 812 grd = self.PrepareTest(''' | |
| 813 { | |
| 814 'policy_definitions': [ | |
| 815 { | |
| 816 'name': 'NonWinGroup', | |
| 817 'type': 'group', | |
| 818 'policies': [{ | |
| 819 'name': 'NonWinPolicy', | |
| 820 'type': 'list', | |
| 821 'supported_on': ['chrome.linux:8-', 'chrome.mac:8-'], | |
| 822 'caption': 'Caption of list policy.', | |
| 823 'desc': 'Desc of list policy.', | |
| 824 }], | |
| 825 'caption': 'Group caption.', | |
| 826 'desc': 'Group description.', | |
| 827 }, | |
| 828 ], | |
| 829 'placeholders': [], | |
| 830 'messages': { | |
| 831 'win_supported_winxpsp2': { | |
| 832 'text': 'At least Windows 3.16', 'desc': 'blah' | |
| 833 }, | |
| 834 'doc_recommended': { | |
| 835 'text': 'Recommended', 'desc': 'bleh' | |
| 836 } | |
| 837 } | |
| 838 }''') | |
| 839 output = self.GetOutput(grd, 'fr', {'_chromium' : '1'}, 'adm', 'en') | |
| 840 expected_output = self.ConstructOutput( | |
| 841 ['MACHINE', 'USER'], ''' | |
| 842 CATEGORY !!chromium | |
| 843 KEYNAME "Software\\Policies\\Chromium" | |
| 844 | |
| 845 END CATEGORY | |
| 846 | |
| 847 CATEGORY !!chromium_recommended | |
| 848 KEYNAME "Software\\Policies\\Chromium\\Recommended" | |
| 849 | |
| 850 END CATEGORY | |
| 851 | |
| 852 | |
| 853 ''', '''[Strings] | |
| 854 SUPPORTED_WINXPSP2="At least Windows 3.16" | |
| 855 chromium="Chromium" | |
| 856 chromium_recommended="Chromium - Recommended" | |
| 857 ''') | |
| 858 self.CompareOutputs(output, expected_output) | |
| 859 | |
| 860 def testNonRecommendedPolicy(self): | |
| 861 # Tests a policy that is not recommended, so it should be included. | |
| 862 grd = self.PrepareTest(''' | |
| 863 { | |
| 864 'policy_definitions': [ | |
| 865 { | |
| 866 'name': 'MainPolicy', | |
| 867 'type': 'main', | |
| 868 'supported_on': ['chrome.win:8-'], | |
| 869 'caption': 'Caption of main.', | |
| 870 'desc': 'Description of main.', | |
| 871 }, | |
| 872 ], | |
| 873 'placeholders': [], | |
| 874 'messages': { | |
| 875 'win_supported_winxpsp2': { | |
| 876 'text': 'At least Windows 3.12', 'desc': 'blah' | |
| 877 }, | |
| 878 'doc_recommended': { | |
| 879 'text': 'Recommended', 'desc': 'bleh' | |
| 880 } | |
| 881 } | |
| 882 }''') | |
| 883 output = self.GetOutput(grd, 'fr', {'_google_chrome' : '1'}, 'adm', 'en') | |
| 884 expected_output = self.ConstructOutput( | |
| 885 ['MACHINE', 'USER'], ''' | |
| 886 CATEGORY !!google | |
| 887 CATEGORY !!googlechrome | |
| 888 KEYNAME "Software\\Policies\\Google\\Chrome" | |
| 889 | |
| 890 POLICY !!MainPolicy_Policy | |
| 891 #if version >= 4 | |
| 892 SUPPORTED !!SUPPORTED_WINXPSP2 | |
| 893 #endif | |
| 894 EXPLAIN !!MainPolicy_Explain | |
| 895 VALUENAME "MainPolicy" | |
| 896 VALUEON NUMERIC 1 | |
| 897 VALUEOFF NUMERIC 0 | |
| 898 END POLICY | |
| 899 | |
| 900 END CATEGORY | |
| 901 END CATEGORY | |
| 902 | |
| 903 CATEGORY !!google | |
| 904 CATEGORY !!googlechrome_recommended | |
| 905 KEYNAME "Software\\Policies\\Google\\Chrome\\Recommended" | |
| 906 | |
| 907 END CATEGORY | |
| 908 END CATEGORY | |
| 909 | |
| 910 | |
| 911 ''', '''[Strings] | |
| 912 SUPPORTED_WINXPSP2="At least Windows 3.12" | |
| 913 google="Google" | |
| 914 googlechrome="Google Chrome" | |
| 915 googlechrome_recommended="Google Chrome - Recommended" | |
| 916 MainPolicy_Policy="Caption of main." | |
| 917 MainPolicy_Explain="Description of main."''') | |
| 918 self.CompareOutputs(output, expected_output) | |
| 919 | |
| 920 def testPolicyGroup(self): | |
| 921 # Tests a policy group that has more than one policies. | |
| 922 grd = self.PrepareTest(''' | |
| 923 { | |
| 924 'policy_definitions': [ | |
| 925 { | |
| 926 'name': 'Group1', | |
| 927 'type': 'group', | |
| 928 'desc': 'Description of group.', | |
| 929 'caption': 'Caption of group.', | |
| 930 'policies': [{ | |
| 931 'name': 'Policy1', | |
| 932 'type': 'list', | |
| 933 'supported_on': ['chrome.win:8-'], | |
| 934 'features': { 'can_be_recommended': True }, | |
| 935 'caption': 'Caption of policy1.', | |
| 936 'desc': """Description of policy1. | |
| 937 With a newline.""" | |
| 938 },{ | |
| 939 'name': 'Policy2', | |
| 940 'type': 'string', | |
| 941 'supported_on': ['chrome.win:8-'], | |
| 942 'caption': 'Caption of policy2.', | |
| 943 'desc': """Description of policy2. | |
| 944 With a newline.""" | |
| 945 }], | |
| 946 }, | |
| 947 ], | |
| 948 'placeholders': [], | |
| 949 'messages': { | |
| 950 'win_supported_winxpsp2': { | |
| 951 'text': 'At least Windows 3.16', 'desc': 'blah' | |
| 952 }, | |
| 953 'doc_recommended': { | |
| 954 'text': 'Recommended', 'desc': 'bleh' | |
| 955 } | |
| 956 } | |
| 957 }''') | |
| 958 output = self.GetOutput(grd, 'fr', {'_chromium' : '1'}, 'adm', 'en') | |
| 959 expected_output = self.ConstructOutput( | |
| 960 ['MACHINE', 'USER'], ''' | |
| 961 CATEGORY !!chromium | |
| 962 KEYNAME "Software\\Policies\\Chromium" | |
| 963 | |
| 964 CATEGORY !!Group1_Category | |
| 965 POLICY !!Policy1_Policy | |
| 966 #if version >= 4 | |
| 967 SUPPORTED !!SUPPORTED_WINXPSP2 | |
| 968 #endif | |
| 969 EXPLAIN !!Policy1_Explain | |
| 970 | |
| 971 PART !!Policy1_Part LISTBOX | |
| 972 KEYNAME "Software\\Policies\\Chromium\\Policy1" | |
| 973 VALUEPREFIX "" | |
| 974 END PART | |
| 975 END POLICY | |
| 976 | |
| 977 POLICY !!Policy2_Policy | |
| 978 #if version >= 4 | |
| 979 SUPPORTED !!SUPPORTED_WINXPSP2 | |
| 980 #endif | |
| 981 EXPLAIN !!Policy2_Explain | |
| 982 | |
| 983 PART !!Policy2_Part EDITTEXT | |
| 984 VALUENAME "Policy2" | |
| 985 MAXLEN 1000000 | |
| 986 END PART | |
| 987 END POLICY | |
| 988 | |
| 989 END CATEGORY | |
| 990 | |
| 991 END CATEGORY | |
| 992 | |
| 993 CATEGORY !!chromium_recommended | |
| 994 KEYNAME "Software\\Policies\\Chromium\\Recommended" | |
| 995 | |
| 996 CATEGORY !!Group1_Category | |
| 997 POLICY !!Policy1_Policy | |
| 998 #if version >= 4 | |
| 999 SUPPORTED !!SUPPORTED_WINXPSP2 | |
| 1000 #endif | |
| 1001 EXPLAIN !!Policy1_Explain | |
| 1002 | |
| 1003 PART !!Policy1_Part LISTBOX | |
| 1004 KEYNAME "Software\\Policies\\Chromium\\Recommended\\Policy1" | |
| 1005 VALUEPREFIX "" | |
| 1006 END PART | |
| 1007 END POLICY | |
| 1008 | |
| 1009 END CATEGORY | |
| 1010 | |
| 1011 END CATEGORY | |
| 1012 | |
| 1013 | |
| 1014 ''', '''[Strings] | |
| 1015 SUPPORTED_WINXPSP2="At least Windows 3.16" | |
| 1016 chromium="Chromium" | |
| 1017 chromium_recommended="Chromium - Recommended" | |
| 1018 Group1_Category="Caption of group." | |
| 1019 Policy1_Policy="Caption of policy1." | |
| 1020 Policy1_Explain="Description of policy1.\\nWith a newline." | |
| 1021 Policy1_Part="Caption of policy1." | |
| 1022 Policy2_Policy="Caption of policy2." | |
| 1023 Policy2_Explain="Description of policy2.\\nWith a newline." | |
| 1024 Policy2_Part="Caption of policy2." | |
| 1025 ''') | |
| 1026 self.CompareOutputs(output, expected_output) | |
| 1027 | |
| 1028 def testDuplicatedStringEnumPolicy(self): | |
| 1029 # Verifies that duplicated enum constants get merged, and that | |
| 1030 # string constants get escaped. | |
| 1031 grd = self.PrepareTest(''' | |
| 1032 { | |
| 1033 'policy_definitions': [ | |
| 1034 { | |
| 1035 'name': 'EnumPolicy.A', | |
| 1036 'type': 'string-enum', | |
| 1037 'caption': 'Caption of policy A.', | |
| 1038 'desc': 'Description of policy A.', | |
| 1039 'items': [ | |
| 1040 {'name': 'tls1.2', 'value': 'tls1.2', 'caption': 'tls1.2' }, | |
| 1041 ], | |
| 1042 'supported_on': ['chrome.win:39-'], | |
| 1043 }, | |
| 1044 { | |
| 1045 'name': 'EnumPolicy.B', | |
| 1046 'type': 'string-enum', | |
| 1047 'caption': 'Caption of policy B.', | |
| 1048 'desc': 'Description of policy B.', | |
| 1049 'items': [ | |
| 1050 {'name': 'tls1.2', 'value': 'tls1.2', 'caption': 'tls1.2' }, | |
| 1051 ], | |
| 1052 'supported_on': ['chrome.win:39-'], | |
| 1053 }, | |
| 1054 ], | |
| 1055 'placeholders': [], | |
| 1056 'messages': { | |
| 1057 'win_supported_winxpsp2': { | |
| 1058 'text': 'At least Windows 3.14', 'desc': 'blah' | |
| 1059 }, | |
| 1060 'doc_recommended': { | |
| 1061 'text': 'Recommended', 'desc': 'bleh' | |
| 1062 } | |
| 1063 } | |
| 1064 }''') | |
| 1065 output = self.GetOutput(grd, 'fr', {'_google_chrome': '1'}, 'adm', 'en') | |
| 1066 expected_output = self.ConstructOutput( | |
| 1067 ['MACHINE', 'USER'], ''' | |
| 1068 CATEGORY !!google | |
| 1069 CATEGORY !!googlechrome | |
| 1070 KEYNAME "Software\\Policies\\Google\\Chrome" | |
| 1071 | |
| 1072 POLICY !!EnumPolicy_A_Policy | |
| 1073 #if version >= 4 | |
| 1074 SUPPORTED !!SUPPORTED_WINXPSP2 | |
| 1075 #endif | |
| 1076 EXPLAIN !!EnumPolicy_A_Explain | |
| 1077 | |
| 1078 PART !!EnumPolicy_A_Part DROPDOWNLIST | |
| 1079 VALUENAME "EnumPolicy.A" | |
| 1080 ITEMLIST | |
| 1081 NAME !!tls1_2_DropDown VALUE "tls1.2" | |
| 1082 END ITEMLIST | |
| 1083 END PART | |
| 1084 END POLICY | |
| 1085 | |
| 1086 POLICY !!EnumPolicy_B_Policy | |
| 1087 #if version >= 4 | |
| 1088 SUPPORTED !!SUPPORTED_WINXPSP2 | |
| 1089 #endif | |
| 1090 EXPLAIN !!EnumPolicy_B_Explain | |
| 1091 | |
| 1092 PART !!EnumPolicy_B_Part DROPDOWNLIST | |
| 1093 VALUENAME "EnumPolicy.B" | |
| 1094 ITEMLIST | |
| 1095 NAME !!tls1_2_DropDown VALUE "tls1.2" | |
| 1096 END ITEMLIST | |
| 1097 END PART | |
| 1098 END POLICY | |
| 1099 | |
| 1100 END CATEGORY | |
| 1101 END CATEGORY | |
| 1102 | |
| 1103 CATEGORY !!google | |
| 1104 CATEGORY !!googlechrome_recommended | |
| 1105 KEYNAME "Software\\Policies\\Google\\Chrome\\Recommended" | |
| 1106 | |
| 1107 END CATEGORY | |
| 1108 END CATEGORY | |
| 1109 | |
| 1110 | |
| 1111 ''', '''[Strings] | |
| 1112 SUPPORTED_WINXPSP2="At least Windows 3.14" | |
| 1113 google="Google" | |
| 1114 googlechrome="Google Chrome" | |
| 1115 googlechrome_recommended="Google Chrome - Recommended" | |
| 1116 EnumPolicy_A_Policy="Caption of policy A." | |
| 1117 EnumPolicy_A_Explain="Description of policy A." | |
| 1118 EnumPolicy_A_Part="Caption of policy A." | |
| 1119 tls1_2_DropDown="tls1.2" | |
| 1120 EnumPolicy_B_Policy="Caption of policy B." | |
| 1121 EnumPolicy_B_Explain="Description of policy B." | |
| 1122 EnumPolicy_B_Part="Caption of policy B." | |
| 1123 ''') | |
| 1124 self.CompareOutputs(output, expected_output) | |
| 1125 | |
| 1126 if __name__ == '__main__': | |
| 1127 unittest.main() | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1442863002:
Remove contents of grit's SVN repository. (Closed)
Base URL: http://grit-i18n.googlecode.com/svn/trunk/