BaseTools/Source/Python/UPT/UnitTest/CommentGeneratingUnitTest.py

   1 ## @file
   2 # This file contain unit test for CommentParsing
   3 #
   4 # Copyright (c) 2011 - 2018, 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.StringUtils 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()