1 ## @file 2 # This file contain unit test for CommentParsing 3 # 4 # Copyright (c) 2011 - 2014, Intel Corporation. All rights reserved.<BR> 5 # 6 # This program and the accompanying materials are licensed and made available 7 # under the terms and conditions of the BSD License which accompanies this 8 # distribution. The full text of the license may be found at 9 # http://opensource.org/licenses/bsd-license.php 10 # 11 # THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, 12 # WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. 13 14 import os 15 import unittest 16 17 import Logger.Log as Logger 18 from GenMetaFile.GenInfFile import GenGuidSections 19 from GenMetaFile.GenInfFile import GenProtocolPPiSections 20 from GenMetaFile.GenInfFile import GenPcdSections 21 from GenMetaFile.GenInfFile import GenSpecialSections 22 from Library.CommentGenerating import GenGenericCommentF 23 from Library.CommentGenerating import _GetHelpStr 24 from Object.POM.CommonObject import TextObject 25 from Object.POM.CommonObject import GuidObject 26 from Object.POM.CommonObject import ProtocolObject 27 from Object.POM.CommonObject import PpiObject 28 from Object.POM.CommonObject import PcdObject 29 from Object.POM.ModuleObject import HobObject 30 31 from Library.String import GetSplitValueList 32 from Library.DataType import TAB_SPACE_SPLIT 33 from Library.DataType import TAB_LANGUAGE_EN_US 34 from Library.DataType import TAB_LANGUAGE_ENG 35 from Library.DataType import ITEM_UNDEFINED 36 from Library.DataType import TAB_INF_FEATURE_PCD 37 from Library import GlobalData 38 from Library.Misc import CreateDirectory 39 40 # 41 # Test _GetHelpStr 42 # 43 class _GetHelpStrTest(unittest.TestCase): 44 def setUp(self): 45 pass 46 47 def tearDown(self): 48 pass 49 50 # 51 # Normal case1: have one help text object with Lang = 'en-US' 52 # 53 def testNormalCase1(self): 54 HelpStr = 'Hello world' 55 HelpTextObj = TextObject() 56 HelpTextObj.SetLang(TAB_LANGUAGE_EN_US) 57 HelpTextObj.SetString(HelpStr) 58 59 HelpTextList = [HelpTextObj] 60 Result = _GetHelpStr(HelpTextList) 61 self.assertEqual(Result, HelpStr) 62 63 # 64 # Normal case2: have two help text object with Lang = 'en-US' and other 65 # 66 def testNormalCase2(self): 67 HelpStr = 'Hello world' 68 HelpTextObj = TextObject() 69 HelpTextObj.SetLang(TAB_LANGUAGE_ENG) 70 HelpTextObj.SetString(HelpStr) 71 72 HelpTextList = [HelpTextObj] 73 74 ExpectedStr = 'Hello world1' 75 HelpTextObj = TextObject() 76 HelpTextObj.SetLang(TAB_LANGUAGE_EN_US) 77 HelpTextObj.SetString(ExpectedStr) 78 79 HelpTextList.append(HelpTextObj) 80 81 Result = _GetHelpStr(HelpTextList) 82 self.assertEqual(Result, ExpectedStr) 83 84 # 85 # Normal case3: have two help text object with Lang = '' and 'eng' 86 # 87 def testNormalCase3(self): 88 HelpStr = 'Hello world' 89 HelpTextObj = TextObject() 90 HelpTextObj.SetLang('') 91 HelpTextObj.SetString(HelpStr) 92 93 HelpTextList = [HelpTextObj] 94 95 ExpectedStr = 'Hello world1' 96 HelpTextObj = TextObject() 97 HelpTextObj.SetLang(TAB_LANGUAGE_ENG) 98 HelpTextObj.SetString(ExpectedStr) 99 100 HelpTextList.append(HelpTextObj) 101 102 Result = _GetHelpStr(HelpTextList) 103 self.assertEqual(Result, ExpectedStr) 104 105 # 106 # Normal case4: have two help text object with Lang = '' and '' 107 # 108 def testNormalCase4(self): 109 110 ExpectedStr = 'Hello world1' 111 HelpTextObj = TextObject() 112 HelpTextObj.SetLang(TAB_LANGUAGE_ENG) 113 HelpTextObj.SetString(ExpectedStr) 114 HelpTextList = [HelpTextObj] 115 116 HelpStr = 'Hello world' 117 HelpTextObj = TextObject() 118 HelpTextObj.SetLang('') 119 HelpTextObj.SetString(HelpStr) 120 HelpTextList.append(HelpTextObj) 121 122 Result = _GetHelpStr(HelpTextList) 123 self.assertEqual(Result, ExpectedStr) 124 125 # 126 # Normal case: have three help text object with Lang = '','en', 'en-US' 127 # 128 def testNormalCase5(self): 129 130 ExpectedStr = 'Hello world1' 131 HelpTextObj = TextObject() 132 HelpTextObj.SetLang(TAB_LANGUAGE_EN_US) 133 HelpTextObj.SetString(ExpectedStr) 134 HelpTextList = [HelpTextObj] 135 136 HelpStr = 'Hello unknown world' 137 HelpTextObj = TextObject() 138 HelpTextObj.SetLang('') 139 HelpTextObj.SetString(HelpStr) 140 HelpTextList.append(HelpTextObj) 141 142 HelpStr = 'Hello mysterious world' 143 HelpTextObj = TextObject() 144 HelpTextObj.SetLang('') 145 HelpTextObj.SetString(HelpStr) 146 HelpTextList.append(HelpTextObj) 147 148 Result = _GetHelpStr(HelpTextList) 149 self.assertEqual(Result, ExpectedStr) 150 151 HelpTextList.sort() 152 self.assertEqual(Result, ExpectedStr) 153 154 HelpTextList.sort(reverse=True) 155 self.assertEqual(Result, ExpectedStr) 156 157 158 # 159 # Test GenGuidSections 160 # 161 class GenGuidSectionsTest(unittest.TestCase): 162 def setUp(self): 163 pass 164 165 def tearDown(self): 166 pass 167 168 # 169 # This is the API to generate Guid Object to help UnitTest 170 # 171 def GuidFactory(self, CName, FFE, Usage, GuidType, VariableName, HelpStr): 172 Guid = GuidObject() 173 Guid.SetCName(CName) 174 Guid.SetFeatureFlag(FFE) 175 Guid.SetGuidTypeList([GuidType]) 176 Guid.SetUsage(Usage) 177 Guid.SetVariableName(VariableName) 178 179 HelpTextObj = TextObject() 180 HelpTextObj.SetLang('') 181 HelpTextObj.SetString(HelpStr) 182 Guid.SetHelpTextList([HelpTextObj]) 183 184 return Guid 185 186 # 187 # Normal case: have two GuidObject 188 # 189 def testNormalCase1(self): 190 GuidList = [] 191 192 CName = 'Guid1' 193 FFE = 'FFE1' 194 Usage = 'PRODUCES' 195 GuidType = 'Event' 196 VariableName = '' 197 HelpStr = 'Usage comment line 1' 198 Guid1 = self.GuidFactory(CName, FFE, Usage, GuidType, 199 VariableName, HelpStr) 200 GuidList.append(Guid1) 201 202 CName = 'Guid1' 203 FFE = 'FFE1' 204 Usage = 'CONSUMES' 205 GuidType = 'Variable' 206 VariableName = '' 207 HelpStr = 'Usage comment line 2' 208 Guid1 = self.GuidFactory(CName, FFE, Usage, GuidType, 209 VariableName, HelpStr) 210 GuidList.append(Guid1) 211 212 Result = GenGuidSections(GuidList) 213 Expected = '''[Guids] 214 ## PRODUCES ## Event # Usage comment line 1 215 ## CONSUMES ## Variable: # Usage comment line 2 216 Guid1|FFE1''' 217 self.assertEqual(Result.strip(), Expected) 218 219 # 220 # Normal case: have two GuidObject 221 # 222 def testNormalCase2(self): 223 GuidList = [] 224 225 CName = 'Guid1' 226 FFE = 'FFE1' 227 Usage = 'PRODUCES' 228 GuidType = 'Event' 229 VariableName = '' 230 HelpStr = 'Usage comment line 1' 231 Guid1 = self.GuidFactory(CName, FFE, Usage, GuidType, 232 VariableName, HelpStr) 233 GuidList.append(Guid1) 234 235 CName = 'Guid1' 236 FFE = 'FFE1' 237 Usage = 'UNDEFINED' 238 GuidType = 'UNDEFINED' 239 VariableName = '' 240 HelpStr = 'Generic comment line 1\n Generic comment line 2' 241 Guid1 = self.GuidFactory(CName, FFE, Usage, GuidType, 242 VariableName, HelpStr) 243 GuidList.append(Guid1) 244 245 Result = GenGuidSections(GuidList) 246 Expected = '''[Guids] 247 ## PRODUCES ## Event # Usage comment line 1 248 # Generic comment line 1 249 # Generic comment line 2 250 Guid1|FFE1''' 251 252 self.assertEqual(Result.strip(), Expected) 253 254 # 255 # Normal case: have two GuidObject, one help goes to generic help, 256 # the other go into usage comment 257 # 258 def testNormalCase3(self): 259 GuidList = [] 260 261 CName = 'Guid1' 262 FFE = 'FFE1' 263 Usage = 'UNDEFINED' 264 GuidType = 'UNDEFINED' 265 VariableName = '' 266 HelpStr = 'Generic comment' 267 Guid1 = self.GuidFactory(CName, FFE, Usage, GuidType, 268 VariableName, HelpStr) 269 GuidList.append(Guid1) 270 271 CName = 'Guid1' 272 FFE = 'FFE1' 273 Usage = 'PRODUCES' 274 GuidType = 'Event' 275 VariableName = '' 276 HelpStr = 'Usage comment line 1' 277 Guid1 = self.GuidFactory(CName, FFE, Usage, GuidType, 278 VariableName, HelpStr) 279 GuidList.append(Guid1) 280 281 Result = GenGuidSections(GuidList) 282 Expected = '''[Guids] 283 # Generic comment 284 ## PRODUCES ## Event # Usage comment line 1 285 Guid1|FFE1''' 286 287 self.assertEqual(Result.strip(), Expected) 288 289 # 290 # Normal case: have one GuidObject, generic comment multiple lines 291 # 292 def testNormalCase5(self): 293 GuidList = [] 294 295 CName = 'Guid1' 296 FFE = 'FFE1' 297 Usage = 'UNDEFINED' 298 GuidType = 'UNDEFINED' 299 VariableName = '' 300 HelpStr = 'Generic comment line1 \n generic comment line 2' 301 Guid1 = self.GuidFactory(CName, FFE, Usage, GuidType, 302 VariableName, HelpStr) 303 GuidList.append(Guid1) 304 305 Result = GenGuidSections(GuidList) 306 Expected = '''[Guids] 307 # Generic comment line1 308 # generic comment line 2 309 Guid1|FFE1''' 310 311 self.assertEqual(Result.strip(), Expected) 312 313 # 314 # Normal case: have one GuidObject, usage comment multiple lines 315 # 316 def testNormalCase6(self): 317 GuidList = [] 318 319 CName = 'Guid1' 320 FFE = 'FFE1' 321 Usage = 'PRODUCES' 322 GuidType = 'Event' 323 VariableName = '' 324 HelpStr = 'Usage comment line 1\n Usage comment line 2' 325 Guid1 = self.GuidFactory(CName, FFE, Usage, GuidType, 326 VariableName, HelpStr) 327 GuidList.append(Guid1) 328 329 Result = GenGuidSections(GuidList) 330 Expected = '''[Guids] 331 Guid1|FFE1 ## PRODUCES ## Event # Usage comment line 1 Usage comment line 2 332 ''' 333 self.assertEqual(Result.strip(), Expected.strip()) 334 335 # 336 # Normal case: have one GuidObject, usage comment one line 337 # 338 def testNormalCase7(self): 339 GuidList = [] 340 341 CName = 'Guid1' 342 FFE = 'FFE1' 343 Usage = 'UNDEFINED' 344 GuidType = 'UNDEFINED' 345 VariableName = '' 346 HelpStr = 'Usage comment line 1' 347 Guid1 = self.GuidFactory(CName, FFE, Usage, GuidType, 348 VariableName, HelpStr) 349 GuidList.append(Guid1) 350 351 Result = GenGuidSections(GuidList) 352 Expected = '''[Guids] 353 Guid1|FFE1 # Usage comment line 1 354 ''' 355 self.assertEqual(Result.strip(), Expected.strip()) 356 357 # 358 # Normal case: have two GuidObject 359 # 360 def testNormalCase8(self): 361 GuidList = [] 362 363 CName = 'Guid1' 364 FFE = 'FFE1' 365 Usage = 'PRODUCES' 366 GuidType = 'Event' 367 VariableName = '' 368 HelpStr = 'Usage comment line 1\n Usage comment line 2' 369 Guid1 = self.GuidFactory(CName, FFE, Usage, GuidType, 370 VariableName, HelpStr) 371 GuidList.append(Guid1) 372 373 CName = 'Guid1' 374 FFE = 'FFE1' 375 Usage = 'PRODUCES' 376 GuidType = 'Event' 377 VariableName = '' 378 HelpStr = 'Usage comment line 3' 379 Guid1 = self.GuidFactory(CName, FFE, Usage, GuidType, 380 VariableName, HelpStr) 381 GuidList.append(Guid1) 382 383 Result = GenGuidSections(GuidList) 384 Expected = '''[Guids] 385 ## PRODUCES ## Event # Usage comment line 1 Usage comment line 2 386 ## PRODUCES ## Event # Usage comment line 3 387 Guid1|FFE1 388 ''' 389 self.assertEqual(Result.strip(), Expected.strip()) 390 391 # 392 # Normal case: have no GuidObject 393 # 394 def testNormalCase9(self): 395 GuidList = [] 396 397 Result = GenGuidSections(GuidList) 398 Expected = '' 399 self.assertEqual(Result.strip(), Expected.strip()) 400 401 # 402 # Normal case: have one GuidObject with no comment generated 403 # 404 def testNormalCase10(self): 405 GuidList = [] 406 407 CName = 'Guid1' 408 FFE = 'FFE1' 409 Usage = 'UNDEFINED' 410 GuidType = 'UNDEFINED' 411 VariableName = '' 412 HelpStr = '' 413 Guid1 = self.GuidFactory(CName, FFE, Usage, GuidType, 414 VariableName, HelpStr) 415 GuidList.append(Guid1) 416 417 Result = GenGuidSections(GuidList) 418 Expected = '''[Guids] 419 Guid1|FFE1 420 ''' 421 self.assertEqual(Result.strip(), Expected.strip()) 422 423 # 424 # Normal case: have three GuidObject 425 # 426 def testNormalCase11(self): 427 GuidList = [] 428 429 CName = 'Guid1' 430 FFE = 'FFE1' 431 Usage = 'UNDEFINED' 432 GuidType = 'UNDEFINED' 433 VariableName = '' 434 HelpStr = 'general comment line 1' 435 Guid1 = self.GuidFactory(CName, FFE, Usage, GuidType, 436 VariableName, HelpStr) 437 GuidList.append(Guid1) 438 439 CName = 'Guid1' 440 FFE = 'FFE1' 441 Usage = 'PRODUCES' 442 GuidType = 'Event' 443 VariableName = '' 444 HelpStr = 'Usage comment line 3' 445 Guid1 = self.GuidFactory(CName, FFE, Usage, GuidType, 446 VariableName, HelpStr) 447 GuidList.append(Guid1) 448 449 CName = 'Guid1' 450 FFE = 'FFE1' 451 Usage = 'UNDEFINED' 452 GuidType = 'UNDEFINED' 453 VariableName = '' 454 HelpStr = 'general comment line 2' 455 Guid1 = self.GuidFactory(CName, FFE, Usage, GuidType, 456 VariableName, HelpStr) 457 GuidList.append(Guid1) 458 459 Result = GenGuidSections(GuidList) 460 Expected = '''[Guids] 461 # general comment line 1 462 ## PRODUCES ## Event # Usage comment line 3 463 # general comment line 2 464 Guid1|FFE1 465 ''' 466 self.assertEqual(Result.strip(), Expected.strip()) 467 468 # 469 # Normal case: have three GuidObject, with Usage/Type and no help 470 # 471 def testNormalCase12(self): 472 GuidList = [] 473 474 CName = 'Guid1' 475 FFE = 'FFE1' 476 Usage = 'PRODUCES' 477 GuidType = 'GUID' 478 VariableName = '' 479 HelpStr = '' 480 Guid1 = self.GuidFactory(CName, FFE, Usage, GuidType, 481 VariableName, HelpStr) 482 GuidList.append(Guid1) 483 484 CName = 'Guid1' 485 FFE = 'FFE1' 486 Usage = 'PRODUCES' 487 GuidType = 'Event' 488 VariableName = '' 489 HelpStr = '' 490 Guid1 = self.GuidFactory(CName, FFE, Usage, GuidType, 491 VariableName, HelpStr) 492 GuidList.append(Guid1) 493 494 CName = 'Guid1' 495 FFE = 'FFE1' 496 Usage = 'CONSUMES' 497 GuidType = 'Event' 498 VariableName = '' 499 HelpStr = '' 500 Guid1 = self.GuidFactory(CName, FFE, Usage, GuidType, 501 VariableName, HelpStr) 502 GuidList.append(Guid1) 503 504 Result = GenGuidSections(GuidList) 505 Expected = '''[Guids] 506 ## PRODUCES ## GUID 507 ## PRODUCES ## Event 508 ## CONSUMES ## Event 509 Guid1|FFE1 510 ''' 511 self.assertEqual(Result.strip(), Expected.strip()) 512 513 # 514 # Test GenProtocolPPiSections 515 # 516 class GenProtocolPPiSectionsTest(unittest.TestCase): 517 def setUp(self): 518 pass 519 520 def tearDown(self): 521 pass 522 523 # 524 # This is the API to generate Protocol/Ppi Object to help UnitTest 525 # 526 def ObjectFactory(self, CName, FFE, Usage, Notify, HelpStr, IsProtocol): 527 if IsProtocol: 528 Object = ProtocolObject() 529 else: 530 Object = PpiObject() 531 532 Object.SetCName(CName) 533 Object.SetFeatureFlag(FFE) 534 Object.SetUsage(Usage) 535 Object.SetNotify(Notify) 536 537 HelpTextObj = TextObject() 538 HelpTextObj.SetLang('') 539 HelpTextObj.SetString(HelpStr) 540 Object.SetHelpTextList([HelpTextObj]) 541 542 return Object 543 544 # Usage Notify Help INF Comment 545 #1 UNDEFINED true Present ## UNDEFINED ## NOTIFY # Help 546 #2 UNDEFINED true Not Present ## UNDEFINED ## NOTIFY 547 #3 UNDEFINED false Present ## UNDEFINED # Help 548 #4 UNDEFINED false Not Present ## UNDEFINED 549 #5 UNDEFINED Not Present Present # Help 550 #6 UNDEFINED Not Present Not Present <empty> 551 #7 Other true Present ## Other ## NOTIFY # Help 552 #8 Other true Not Present ## Other ## NOTIFY 553 #9 Other false Present ## Other # Help 554 #A Other false Not Present ## Other 555 #B Other Not Present Present ## Other # Help 556 #C Other Not Present Not Present ## Other 557 558 def testNormalCase1(self): 559 ObjectList = [] 560 561 CName = 'Guid1' 562 FFE = 'FFE1' 563 564 Usage = 'UNDEFINED' 565 Notify = True 566 HelpStr = 'Help' 567 IsProtocol = True 568 Object = self.ObjectFactory(CName, FFE, Usage, Notify, 569 HelpStr, IsProtocol) 570 ObjectList.append(Object) 571 572 573 Result = GenProtocolPPiSections(ObjectList, IsProtocol) 574 Expected = '''[Protocols] 575 Guid1|FFE1 ## UNDEFINED ## NOTIFY # Help''' 576 self.assertEqual(Result.strip(), Expected) 577 578 IsProtocol = False 579 ObjectList = [] 580 Object = self.ObjectFactory(CName, FFE, Usage, Notify, 581 HelpStr, IsProtocol) 582 ObjectList.append(Object) 583 584 585 Result = GenProtocolPPiSections(ObjectList, IsProtocol) 586 Expected = '''[Ppis] 587 Guid1|FFE1 ## UNDEFINED ## NOTIFY # Help''' 588 self.assertEqual(Result.strip(), Expected) 589 590 def testNormalCase2(self): 591 ObjectList = [] 592 593 CName = 'Guid1' 594 FFE = 'FFE1' 595 596 Usage = 'UNDEFINED' 597 Notify = True 598 HelpStr = '' 599 IsProtocol = True 600 Object = self.ObjectFactory(CName, FFE, Usage, Notify, 601 HelpStr, IsProtocol) 602 ObjectList.append(Object) 603 604 605 Result = GenProtocolPPiSections(ObjectList, IsProtocol) 606 Expected = '''[Protocols] 607 Guid1|FFE1 ## UNDEFINED ## NOTIFY''' 608 self.assertEqual(Result.strip(), Expected) 609 610 def testNormalCase3(self): 611 ObjectList = [] 612 613 CName = 'Guid1' 614 FFE = 'FFE1' 615 616 Usage = 'UNDEFINED' 617 Notify = False 618 HelpStr = 'Help' 619 IsProtocol = True 620 Object = self.ObjectFactory(CName, FFE, Usage, Notify, 621 HelpStr, IsProtocol) 622 ObjectList.append(Object) 623 624 625 Result = GenProtocolPPiSections(ObjectList, IsProtocol) 626 Expected = '''[Protocols] 627 Guid1|FFE1 ## UNDEFINED # Help''' 628 self.assertEqual(Result.strip(), Expected) 629 630 def testNormalCase4(self): 631 ObjectList = [] 632 633 CName = 'Guid1' 634 FFE = 'FFE1' 635 636 Usage = 'UNDEFINED' 637 Notify = False 638 HelpStr = '' 639 IsProtocol = True 640 Object = self.ObjectFactory(CName, FFE, Usage, Notify, 641 HelpStr, IsProtocol) 642 ObjectList.append(Object) 643 644 645 Result = GenProtocolPPiSections(ObjectList, IsProtocol) 646 Expected = '''[Protocols] 647 Guid1|FFE1 ## UNDEFINED''' 648 self.assertEqual(Result.strip(), Expected) 649 650 def testNormalCase5(self): 651 ObjectList = [] 652 653 CName = 'Guid1' 654 FFE = 'FFE1' 655 656 Usage = 'UNDEFINED' 657 Notify = '' 658 HelpStr = 'Help' 659 IsProtocol = True 660 Object = self.ObjectFactory(CName, FFE, Usage, Notify, 661 HelpStr, IsProtocol) 662 ObjectList.append(Object) 663 664 665 Result = GenProtocolPPiSections(ObjectList, IsProtocol) 666 Expected = '''[Protocols] 667 Guid1|FFE1 # Help''' 668 self.assertEqual(Result.strip(), Expected) 669 670 def testNormalCase6(self): 671 ObjectList = [] 672 673 CName = 'Guid1' 674 FFE = 'FFE1' 675 676 Usage = 'UNDEFINED' 677 Notify = '' 678 HelpStr = '' 679 IsProtocol = True 680 Object = self.ObjectFactory(CName, FFE, Usage, Notify, 681 HelpStr, IsProtocol) 682 ObjectList.append(Object) 683 684 685 Result = GenProtocolPPiSections(ObjectList, IsProtocol) 686 Expected = '''[Protocols] 687 Guid1|FFE1''' 688 self.assertEqual(Result.strip(), Expected) 689 690 def testNormalCase7(self): 691 ObjectList = [] 692 693 CName = 'Guid1' 694 FFE = 'FFE1' 695 696 Usage = 'PRODUCES' 697 Notify = True 698 HelpStr = 'Help' 699 IsProtocol = True 700 Object = self.ObjectFactory(CName, FFE, Usage, Notify, 701 HelpStr, IsProtocol) 702 ObjectList.append(Object) 703 704 705 Result = GenProtocolPPiSections(ObjectList, IsProtocol) 706 Expected = '''[Protocols] 707 Guid1|FFE1 ## PRODUCES ## NOTIFY # Help''' 708 self.assertEqual(Result.strip(), Expected) 709 710 def testNormalCase8(self): 711 ObjectList = [] 712 713 CName = 'Guid1' 714 FFE = 'FFE1' 715 716 Usage = 'PRODUCES' 717 Notify = True 718 HelpStr = '' 719 IsProtocol = True 720 Object = self.ObjectFactory(CName, FFE, Usage, Notify, 721 HelpStr, IsProtocol) 722 ObjectList.append(Object) 723 724 725 Result = GenProtocolPPiSections(ObjectList, IsProtocol) 726 Expected = '''[Protocols] 727 Guid1|FFE1 ## PRODUCES ## NOTIFY''' 728 self.assertEqual(Result.strip(), Expected) 729 730 def testNormalCase9(self): 731 ObjectList = [] 732 733 CName = 'Guid1' 734 FFE = 'FFE1' 735 736 Usage = 'PRODUCES' 737 Notify = False 738 HelpStr = 'Help' 739 IsProtocol = True 740 Object = self.ObjectFactory(CName, FFE, Usage, Notify, 741 HelpStr, IsProtocol) 742 ObjectList.append(Object) 743 744 745 Result = GenProtocolPPiSections(ObjectList, IsProtocol) 746 Expected = '''[Protocols] 747 Guid1|FFE1 ## PRODUCES # Help''' 748 self.assertEqual(Result.strip(), Expected) 749 750 def testNormalCaseA(self): 751 ObjectList = [] 752 753 CName = 'Guid1' 754 FFE = 'FFE1' 755 756 Usage = 'PRODUCES' 757 Notify = False 758 HelpStr = '' 759 IsProtocol = True 760 Object = self.ObjectFactory(CName, FFE, Usage, Notify, 761 HelpStr, IsProtocol) 762 ObjectList.append(Object) 763 764 765 Result = GenProtocolPPiSections(ObjectList, IsProtocol) 766 Expected = '''[Protocols] 767 Guid1|FFE1 ## PRODUCES''' 768 self.assertEqual(Result.strip(), Expected) 769 770 def testNormalCaseB(self): 771 ObjectList = [] 772 773 CName = 'Guid1' 774 FFE = 'FFE1' 775 776 Usage = 'PRODUCES' 777 Notify = '' 778 HelpStr = 'Help' 779 IsProtocol = True 780 Object = self.ObjectFactory(CName, FFE, Usage, Notify, 781 HelpStr, IsProtocol) 782 ObjectList.append(Object) 783 784 785 Result = GenProtocolPPiSections(ObjectList, IsProtocol) 786 Expected = '''[Protocols] 787 Guid1|FFE1 ## PRODUCES # Help''' 788 self.assertEqual(Result.strip(), Expected) 789 790 def testNormalCaseC(self): 791 ObjectList = [] 792 793 CName = 'Guid1' 794 FFE = 'FFE1' 795 796 Usage = 'PRODUCES' 797 Notify = '' 798 HelpStr = '' 799 IsProtocol = True 800 Object = self.ObjectFactory(CName, FFE, Usage, Notify, 801 HelpStr, IsProtocol) 802 ObjectList.append(Object) 803 804 805 Result = GenProtocolPPiSections(ObjectList, IsProtocol) 806 Expected = '''[Protocols] 807 Guid1|FFE1 ## PRODUCES''' 808 self.assertEqual(Result.strip(), Expected) 809 810 # 811 # Test GenPcdSections 812 # 813 class GenPcdSectionsTest(unittest.TestCase): 814 def setUp(self): 815 pass 816 817 def tearDown(self): 818 pass 819 820 # 821 # This is the API to generate Pcd Object to help UnitTest 822 # 823 def ObjectFactory(self, ItemType, TSCName, CName, DValue, FFE, Usage, Str): 824 Object = PcdObject() 825 HelpStr = Str 826 827 Object.SetItemType(ItemType) 828 Object.SetTokenSpaceGuidCName(TSCName) 829 Object.SetCName(CName) 830 Object.SetDefaultValue(DValue) 831 Object.SetFeatureFlag(FFE) 832 Object.SetValidUsage(Usage) 833 834 HelpTextObj = TextObject() 835 HelpTextObj.SetLang('') 836 HelpTextObj.SetString(HelpStr) 837 Object.SetHelpTextList([HelpTextObj]) 838 839 return Object 840 841 842 # Usage Help INF Comment 843 #1 UNDEFINED Present # Help 844 #2 UNDEFINED Not Present <empty> 845 #3 Other Present ## Other # Help 846 #4 Other Not Present ## Other 847 848 def testNormalCase1(self): 849 ObjectList = [] 850 ItemType = 'Pcd' 851 TSCName = 'TSCName' 852 CName = 'CName' 853 DValue = 'DValue' 854 FFE = 'FFE' 855 856 Usage = 'UNDEFINED' 857 Str = 'Help' 858 859 Object = self.ObjectFactory(ItemType, TSCName, CName, DValue, FFE, 860 Usage, Str) 861 ObjectList.append(Object) 862 863 Result = GenPcdSections(ObjectList) 864 Expected = \ 865 '[Pcd]\n' + \ 866 'TSCName.CName|DValue|FFE # Help' 867 self.assertEqual(Result.strip(), Expected) 868 869 def testNormalCase2(self): 870 ObjectList = [] 871 ItemType = 'Pcd' 872 TSCName = 'TSCName' 873 CName = 'CName' 874 DValue = 'DValue' 875 FFE = 'FFE' 876 877 Usage = 'UNDEFINED' 878 Str = '' 879 880 Object = self.ObjectFactory(ItemType, TSCName, CName, DValue, FFE, 881 Usage, Str) 882 ObjectList.append(Object) 883 884 Result = GenPcdSections(ObjectList) 885 Expected = '[Pcd]\nTSCName.CName|DValue|FFE' 886 self.assertEqual(Result.strip(), Expected) 887 888 def testNormalCase3(self): 889 ObjectList = [] 890 ItemType = 'Pcd' 891 TSCName = 'TSCName' 892 CName = 'CName' 893 DValue = 'DValue' 894 FFE = 'FFE' 895 896 Usage = 'CONSUMES' 897 Str = 'Help' 898 899 Object = self.ObjectFactory(ItemType, TSCName, CName, DValue, FFE, 900 Usage, Str) 901 ObjectList.append(Object) 902 903 Result = GenPcdSections(ObjectList) 904 Expected = '[Pcd]\nTSCName.CName|DValue|FFE ## CONSUMES # Help' 905 self.assertEqual(Result.strip(), Expected) 906 907 def testNormalCase4(self): 908 ObjectList = [] 909 ItemType = 'Pcd' 910 TSCName = 'TSCName' 911 CName = 'CName' 912 DValue = 'DValue' 913 FFE = 'FFE' 914 915 Usage = 'CONSUMES' 916 Str = '' 917 918 Object = self.ObjectFactory(ItemType, TSCName, CName, DValue, FFE, 919 Usage, Str) 920 ObjectList.append(Object) 921 922 Result = GenPcdSections(ObjectList) 923 Expected = '[Pcd]\nTSCName.CName|DValue|FFE ## CONSUMES' 924 self.assertEqual(Result.strip(), Expected) 925 926 # 927 # multiple lines for normal usage 928 # 929 def testNormalCase5(self): 930 ObjectList = [] 931 ItemType = 'Pcd' 932 TSCName = 'TSCName' 933 CName = 'CName' 934 DValue = 'DValue' 935 FFE = 'FFE' 936 937 Usage = 'CONSUMES' 938 Str = 'commment line 1\ncomment line 2' 939 Object = self.ObjectFactory(ItemType, TSCName, CName, DValue, FFE, 940 Usage, Str) 941 ObjectList.append(Object) 942 943 Result = GenPcdSections(ObjectList) 944 Expected = '''[Pcd] 945 TSCName.CName|DValue|FFE ## CONSUMES # commment line 1 comment line 2''' 946 self.assertEqual(Result.strip(), Expected) 947 948 # 949 # multiple lines for UNDEFINED usage 950 # 951 def testNormalCase6(self): 952 ObjectList = [] 953 ItemType = 'Pcd' 954 TSCName = 'TSCName' 955 CName = 'CName' 956 DValue = 'DValue' 957 FFE = 'FFE' 958 959 Usage = 'UNDEFINED' 960 Str = 'commment line 1\ncomment line 2' 961 Object = self.ObjectFactory(ItemType, TSCName, CName, DValue, FFE, 962 Usage, Str) 963 ObjectList.append(Object) 964 965 Usage = 'UNDEFINED' 966 Str = 'commment line 3' 967 Object = self.ObjectFactory(ItemType, TSCName, CName, DValue, FFE, 968 Usage, Str) 969 ObjectList.append(Object) 970 971 Result = GenPcdSections(ObjectList) 972 Expected = '''[Pcd] 973 # commment line 1 974 # comment line 2 975 # commment line 3 976 TSCName.CName|DValue|FFE''' 977 self.assertEqual(Result.strip(), Expected) 978 979 # 980 # multiple lines for UNDEFINED and normal usage 981 # 982 def testNormalCase7(self): 983 ObjectList = [] 984 ItemType = 'Pcd' 985 TSCName = 'TSCName' 986 CName = 'CName' 987 DValue = 'DValue' 988 FFE = 'FFE' 989 990 Usage = 'UNDEFINED' 991 Str = 'commment line 1\ncomment line 2' 992 Object = self.ObjectFactory(ItemType, TSCName, CName, DValue, FFE, 993 Usage, Str) 994 ObjectList.append(Object) 995 996 Usage = 'CONSUMES' 997 Str = 'Foo' 998 Object = self.ObjectFactory(ItemType, TSCName, CName, DValue, FFE, 999 Usage, Str) 1000 ObjectList.append(Object) 1001 1002 Usage = 'UNDEFINED' 1003 Str = 'commment line 3' 1004 Object = self.ObjectFactory(ItemType, TSCName, CName, DValue, FFE, 1005 Usage, Str) 1006 ObjectList.append(Object) 1007 1008 Result = GenPcdSections(ObjectList) 1009 Expected = '''[Pcd] 1010 # commment line 1 1011 # comment line 2 1012 ## CONSUMES # Foo 1013 # commment line 3 1014 TSCName.CName|DValue|FFE''' 1015 self.assertEqual(Result.strip(), Expected) 1016 1017 # Usage Help INF Comment 1018 # CONSUMES Present # Help (keep <EOL> and insert '#' at beginning of each new line) 1019 # CONSUMES Not Present <empty> 1020 1021 # 1022 # TAB_INF_FEATURE_PCD 1023 # 1024 def testNormalCase8(self): 1025 ObjectList = [] 1026 ItemType = TAB_INF_FEATURE_PCD 1027 TSCName = 'TSCName' 1028 CName = 'CName' 1029 DValue = 'DValue' 1030 FFE = 'FFE' 1031 1032 Usage = 'CONSUMES' 1033 Str = 'commment line 1\ncomment line 2' 1034 Object = self.ObjectFactory(ItemType, TSCName, CName, DValue, FFE, 1035 Usage, Str) 1036 ObjectList.append(Object) 1037 1038 Result = GenPcdSections(ObjectList) 1039 Expected = '''[FeaturePcd] 1040 # commment line 1 1041 # comment line 2 1042 TSCName.CName|DValue|FFE''' 1043 self.assertEqual(Result.strip(), Expected) 1044 1045 # 1046 # TAB_INF_FEATURE_PCD 1047 # 1048 def testNormalCase9(self): 1049 ObjectList = [] 1050 ItemType = TAB_INF_FEATURE_PCD 1051 TSCName = 'TSCName' 1052 CName = 'CName' 1053 DValue = 'DValue' 1054 FFE = 'FFE' 1055 1056 Usage = 'CONSUMES' 1057 Str = '' 1058 Object = self.ObjectFactory(ItemType, TSCName, CName, DValue, FFE, 1059 Usage, Str) 1060 ObjectList.append(Object) 1061 1062 Result = GenPcdSections(ObjectList) 1063 Expected = '''[FeaturePcd] 1064 TSCName.CName|DValue|FFE''' 1065 self.assertEqual(Result.strip(), Expected) 1066 1067 # 1068 # TAB_INF_FEATURE_PCD 1069 # 1070 def testNormalCase10(self): 1071 ObjectList = [] 1072 ItemType = TAB_INF_FEATURE_PCD 1073 TSCName = 'TSCName' 1074 CName = 'CName' 1075 DValue = 'DValue' 1076 FFE = 'FFE' 1077 1078 Usage = 'PRODUCES' 1079 Str = 'commment line 1\ncomment line 2' 1080 Object = self.ObjectFactory(ItemType, TSCName, CName, DValue, FFE, 1081 Usage, Str) 1082 ObjectList.append(Object) 1083 1084 Result = GenPcdSections(ObjectList) 1085 Expected = ''' 1086 1087 [FeaturePcd] 1088 # commment line 1 1089 # comment line 2 1090 TSCName.CName|DValue|FFE 1091 ''' 1092 self.assertEqual(Result, Expected) 1093 1094 1095 # 1096 # Test GenSpecialSections of Hob 1097 # 1098 class GenHobSectionsTest(unittest.TestCase): 1099 def setUp(self): 1100 pass 1101 1102 def tearDown(self): 1103 pass 1104 1105 # 1106 # This is the API to generate Event Object to help UnitTest 1107 # 1108 def ObjectFactory(self, SupArchList, Type, Usage, Str): 1109 Object = HobObject() 1110 HelpStr = Str 1111 1112 Object.SetHobType(Type) 1113 Object.SetUsage(Usage) 1114 Object.SetSupArchList(SupArchList) 1115 1116 HelpTextObj = TextObject() 1117 HelpTextObj.SetLang('') 1118 HelpTextObj.SetString(HelpStr) 1119 Object.SetHelpTextList([HelpTextObj]) 1120 1121 return Object 1122 1123 def testNormalCase1(self): 1124 ObjectList = [] 1125 SupArchList = ['X64'] 1126 Type = 'Foo' 1127 Usage = 'UNDEFINED' 1128 Str = 'Help' 1129 1130 Object = self.ObjectFactory(SupArchList, Type, Usage, Str) 1131 ObjectList.append(Object) 1132 1133 Result = GenSpecialSections(ObjectList, 'Hob') 1134 Expected = '''# [Hob.X64] 1135 # ## 1136 # # Help 1137 # # 1138 # Foo ## UNDEFINED 1139 # 1140 # 1141 ''' 1142 self.assertEqual(Result, Expected) 1143 1144 def testNormalCase2(self): 1145 ObjectList = [] 1146 SupArchList = [] 1147 Type = 'Foo' 1148 Usage = 'UNDEFINED' 1149 Str = 'Help' 1150 1151 Object = self.ObjectFactory(SupArchList, Type, Usage, Str) 1152 ObjectList.append(Object) 1153 1154 Result = GenSpecialSections(ObjectList, 'Hob') 1155 Expected = '''# [Hob] 1156 # ## 1157 # # Help 1158 # # 1159 # Foo ## UNDEFINED 1160 # 1161 # 1162 ''' 1163 self.assertEqual(Result, Expected) 1164 1165 def testNormalCase3(self): 1166 ObjectList = [] 1167 SupArchList = ['X64'] 1168 Type = 'Foo' 1169 Usage = 'UNDEFINED' 1170 Str = '\nComment Line 1\n\n' 1171 1172 Object = self.ObjectFactory(SupArchList, Type, Usage, Str) 1173 ObjectList.append(Object) 1174 1175 Result = GenSpecialSections(ObjectList, 'Hob') 1176 Expected = '''# [Hob.X64] 1177 # ## 1178 # # Comment Line 1 1179 # # 1180 # Foo ## UNDEFINED 1181 # 1182 # 1183 ''' 1184 self.assertEqual(Result, Expected) 1185 1186 def testNormalCase4(self): 1187 ObjectList = [] 1188 SupArchList = ['X64'] 1189 Type = 'Foo' 1190 Usage = 'UNDEFINED' 1191 Str = '\nComment Line 1\n' 1192 1193 Object = self.ObjectFactory(SupArchList, Type, Usage, Str) 1194 ObjectList.append(Object) 1195 1196 Result = GenSpecialSections(ObjectList, 'Hob') 1197 Expected = '''# [Hob.X64] 1198 # ## 1199 # # Comment Line 1 1200 # # 1201 # Foo ## UNDEFINED 1202 # 1203 # 1204 ''' 1205 self.assertEqual(Result, Expected) 1206 1207 def testNormalCase5(self): 1208 ObjectList = [] 1209 SupArchList = ['X64'] 1210 Type = 'Foo' 1211 Usage = 'UNDEFINED' 1212 Str = 'Comment Line 1\n\n' 1213 1214 Object = self.ObjectFactory(SupArchList, Type, Usage, Str) 1215 ObjectList.append(Object) 1216 1217 Result = GenSpecialSections(ObjectList, 'Hob') 1218 Expected = '''# [Hob.X64] 1219 # ## 1220 # # Comment Line 1 1221 # # 1222 # Foo ## UNDEFINED 1223 # 1224 # 1225 ''' 1226 self.assertEqual(Result, Expected) 1227 1228 def testNormalCase6(self): 1229 ObjectList = [] 1230 SupArchList = ['X64'] 1231 Type = 'Foo' 1232 Usage = 'UNDEFINED' 1233 Str = '' 1234 1235 Object = self.ObjectFactory(SupArchList, Type, Usage, Str) 1236 ObjectList.append(Object) 1237 1238 Result = GenSpecialSections(ObjectList, 'Hob') 1239 Expected = '''# [Hob.X64] 1240 # Foo ## UNDEFINED 1241 # 1242 # 1243 ''' 1244 self.assertEqual(Result, Expected) 1245 1246 def testNormalCase7(self): 1247 ObjectList = [] 1248 SupArchList = ['X64'] 1249 Type = 'Foo' 1250 Usage = 'UNDEFINED' 1251 Str = '\nNew Stack HoB' 1252 1253 1254 Object = self.ObjectFactory(SupArchList, Type, Usage, Str) 1255 ObjectList.append(Object) 1256 1257 Result = GenSpecialSections(ObjectList, 'Hob') 1258 Expected = '''# [Hob.X64] 1259 # ## 1260 # # New Stack HoB 1261 # # 1262 # Foo ## UNDEFINED 1263 # 1264 # 1265 ''' 1266 self.assertEqual(Result, Expected) 1267 1268 def testNormalCase8(self): 1269 ObjectList = [] 1270 SupArchList = ['X64'] 1271 Type = 'Foo' 1272 Usage = 'UNDEFINED' 1273 Str = '\nNew Stack HoB\n\nTail Comment' 1274 1275 1276 Object = self.ObjectFactory(SupArchList, Type, Usage, Str) 1277 ObjectList.append(Object) 1278 1279 Result = GenSpecialSections(ObjectList, 'Hob') 1280 Expected = '''# [Hob.X64] 1281 # ## 1282 # # New Stack HoB 1283 # # 1284 # # Tail Comment 1285 # # 1286 # Foo ## UNDEFINED 1287 # 1288 # 1289 ''' 1290 self.assertEqual(Result, Expected) 1291 1292 def testNormalCase9(self): 1293 ObjectList = [] 1294 SupArchList = ['X64'] 1295 Type = 'Foo' 1296 Usage = 'UNDEFINED' 1297 Str = '\n\n' 1298 1299 1300 Object = self.ObjectFactory(SupArchList, Type, Usage, Str) 1301 ObjectList.append(Object) 1302 1303 Result = GenSpecialSections(ObjectList, 'Hob') 1304 Expected = '''# [Hob.X64] 1305 # ## 1306 # # 1307 # # 1308 # Foo ## UNDEFINED 1309 # 1310 # 1311 ''' 1312 self.assertEqual(Result, Expected) 1313 1314 def testNormalCase10(self): 1315 ObjectList = [] 1316 SupArchList = ['X64'] 1317 Type = 'Foo' 1318 Usage = 'UNDEFINED' 1319 Str = '\n' 1320 1321 Object = self.ObjectFactory(SupArchList, Type, Usage, Str) 1322 ObjectList.append(Object) 1323 1324 Result = GenSpecialSections(ObjectList, 'Hob') 1325 Expected = '''# [Hob.X64] 1326 # ## 1327 # # 1328 # # 1329 # Foo ## UNDEFINED 1330 # 1331 # 1332 ''' 1333 self.assertEqual(Result, Expected) 1334 1335 def testNormalCase11(self): 1336 ObjectList = [] 1337 SupArchList = ['X64'] 1338 Type = 'Foo' 1339 Usage = 'UNDEFINED' 1340 Str = '\n\n\n' 1341 1342 Object = self.ObjectFactory(SupArchList, Type, Usage, Str) 1343 ObjectList.append(Object) 1344 1345 Result = GenSpecialSections(ObjectList, 'Hob') 1346 Expected = '''# [Hob.X64] 1347 # ## 1348 # # 1349 # # 1350 # Foo ## UNDEFINED 1351 # 1352 # 1353 ''' 1354 self.assertEqual(Result, Expected) 1355 1356 def testNormalCase12(self): 1357 ObjectList = [] 1358 SupArchList = ['X64'] 1359 Type = 'Foo' 1360 Usage = 'UNDEFINED' 1361 Str = '\n\n\n\n' 1362 1363 Object = self.ObjectFactory(SupArchList, Type, Usage, Str) 1364 ObjectList.append(Object) 1365 1366 Result = GenSpecialSections(ObjectList, 'Hob') 1367 Expected = '''# [Hob.X64] 1368 # ## 1369 # # 1370 # # 1371 # # 1372 # Foo ## UNDEFINED 1373 # 1374 # 1375 ''' 1376 self.assertEqual(Result, Expected) 1377 1378 # 1379 # Test GenGenericCommentF 1380 # 1381 class GenGenericCommentFTest(unittest.TestCase): 1382 def setUp(self): 1383 pass 1384 1385 def tearDown(self): 1386 pass 1387 1388 def testNormalCase1(self): 1389 CommentLines = 'Comment Line 1' 1390 Result = GenGenericCommentF(CommentLines) 1391 Expected = '# Comment Line 1\n' 1392 self.assertEqual(Result, Expected) 1393 1394 def testNormalCase2(self): 1395 CommentLines = '\n' 1396 Result = GenGenericCommentF(CommentLines) 1397 Expected = '#\n' 1398 self.assertEqual(Result, Expected) 1399 1400 def testNormalCase3(self): 1401 CommentLines = '\n\n\n' 1402 Result = GenGenericCommentF(CommentLines) 1403 Expected = '#\n#\n#\n' 1404 self.assertEqual(Result, Expected) 1405 1406 def testNormalCase4(self): 1407 CommentLines = 'coment line 1\n' 1408 Result = GenGenericCommentF(CommentLines) 1409 Expected = '# coment line 1\n' 1410 self.assertEqual(Result, Expected) 1411 1412 def testNormalCase5(self): 1413 CommentLines = 'coment line 1\n coment line 2\n' 1414 Result = GenGenericCommentF(CommentLines) 1415 Expected = '# coment line 1\n# coment line 2\n' 1416 self.assertEqual(Result, Expected) 1417 1418 if __name__ == '__main__': 1419 Logger.Initialize() 1420 unittest.main()
