mirror of
https://github.com/CloverHackyColor/CloverBootloader.git
synced 2024-12-28 17:08:18 +01:00
1415 lines
38 KiB
Python
Executable File
1415 lines
38 KiB
Python
Executable File
## @file
|
|
# This file contain unit test for CommentParsing
|
|
#
|
|
# Copyright (c) 2011 - 2018, Intel Corporation. All rights reserved.<BR>
|
|
#
|
|
# SPDX-License-Identifier: BSD-2-Clause-Patent
|
|
|
|
import os
|
|
import unittest
|
|
|
|
import Logger.Log as Logger
|
|
from GenMetaFile.GenInfFile import GenGuidSections
|
|
from GenMetaFile.GenInfFile import GenProtocolPPiSections
|
|
from GenMetaFile.GenInfFile import GenPcdSections
|
|
from GenMetaFile.GenInfFile import GenSpecialSections
|
|
from Library.CommentGenerating import GenGenericCommentF
|
|
from Library.CommentGenerating import _GetHelpStr
|
|
from Object.POM.CommonObject import TextObject
|
|
from Object.POM.CommonObject import GuidObject
|
|
from Object.POM.CommonObject import ProtocolObject
|
|
from Object.POM.CommonObject import PpiObject
|
|
from Object.POM.CommonObject import PcdObject
|
|
from Object.POM.ModuleObject import HobObject
|
|
|
|
from Library.StringUtils import GetSplitValueList
|
|
from Library.DataType import TAB_SPACE_SPLIT
|
|
from Library.DataType import TAB_LANGUAGE_EN_US
|
|
from Library.DataType import TAB_LANGUAGE_ENG
|
|
from Library.DataType import ITEM_UNDEFINED
|
|
from Library.DataType import TAB_INF_FEATURE_PCD
|
|
from Library import GlobalData
|
|
from Library.Misc import CreateDirectory
|
|
|
|
#
|
|
# Test _GetHelpStr
|
|
#
|
|
class _GetHelpStrTest(unittest.TestCase):
|
|
def setUp(self):
|
|
pass
|
|
|
|
def tearDown(self):
|
|
pass
|
|
|
|
#
|
|
# Normal case1: have one help text object with Lang = 'en-US'
|
|
#
|
|
def testNormalCase1(self):
|
|
HelpStr = 'Hello world'
|
|
HelpTextObj = TextObject()
|
|
HelpTextObj.SetLang(TAB_LANGUAGE_EN_US)
|
|
HelpTextObj.SetString(HelpStr)
|
|
|
|
HelpTextList = [HelpTextObj]
|
|
Result = _GetHelpStr(HelpTextList)
|
|
self.assertEqual(Result, HelpStr)
|
|
|
|
#
|
|
# Normal case2: have two help text object with Lang = 'en-US' and other
|
|
#
|
|
def testNormalCase2(self):
|
|
HelpStr = 'Hello world'
|
|
HelpTextObj = TextObject()
|
|
HelpTextObj.SetLang(TAB_LANGUAGE_ENG)
|
|
HelpTextObj.SetString(HelpStr)
|
|
|
|
HelpTextList = [HelpTextObj]
|
|
|
|
ExpectedStr = 'Hello world1'
|
|
HelpTextObj = TextObject()
|
|
HelpTextObj.SetLang(TAB_LANGUAGE_EN_US)
|
|
HelpTextObj.SetString(ExpectedStr)
|
|
|
|
HelpTextList.append(HelpTextObj)
|
|
|
|
Result = _GetHelpStr(HelpTextList)
|
|
self.assertEqual(Result, ExpectedStr)
|
|
|
|
#
|
|
# Normal case3: have two help text object with Lang = '' and 'eng'
|
|
#
|
|
def testNormalCase3(self):
|
|
HelpStr = 'Hello world'
|
|
HelpTextObj = TextObject()
|
|
HelpTextObj.SetLang('')
|
|
HelpTextObj.SetString(HelpStr)
|
|
|
|
HelpTextList = [HelpTextObj]
|
|
|
|
ExpectedStr = 'Hello world1'
|
|
HelpTextObj = TextObject()
|
|
HelpTextObj.SetLang(TAB_LANGUAGE_ENG)
|
|
HelpTextObj.SetString(ExpectedStr)
|
|
|
|
HelpTextList.append(HelpTextObj)
|
|
|
|
Result = _GetHelpStr(HelpTextList)
|
|
self.assertEqual(Result, ExpectedStr)
|
|
|
|
#
|
|
# Normal case4: have two help text object with Lang = '' and ''
|
|
#
|
|
def testNormalCase4(self):
|
|
|
|
ExpectedStr = 'Hello world1'
|
|
HelpTextObj = TextObject()
|
|
HelpTextObj.SetLang(TAB_LANGUAGE_ENG)
|
|
HelpTextObj.SetString(ExpectedStr)
|
|
HelpTextList = [HelpTextObj]
|
|
|
|
HelpStr = 'Hello world'
|
|
HelpTextObj = TextObject()
|
|
HelpTextObj.SetLang('')
|
|
HelpTextObj.SetString(HelpStr)
|
|
HelpTextList.append(HelpTextObj)
|
|
|
|
Result = _GetHelpStr(HelpTextList)
|
|
self.assertEqual(Result, ExpectedStr)
|
|
|
|
#
|
|
# Normal case: have three help text object with Lang = '','en', 'en-US'
|
|
#
|
|
def testNormalCase5(self):
|
|
|
|
ExpectedStr = 'Hello world1'
|
|
HelpTextObj = TextObject()
|
|
HelpTextObj.SetLang(TAB_LANGUAGE_EN_US)
|
|
HelpTextObj.SetString(ExpectedStr)
|
|
HelpTextList = [HelpTextObj]
|
|
|
|
HelpStr = 'Hello unknown world'
|
|
HelpTextObj = TextObject()
|
|
HelpTextObj.SetLang('')
|
|
HelpTextObj.SetString(HelpStr)
|
|
HelpTextList.append(HelpTextObj)
|
|
|
|
HelpStr = 'Hello mysterious world'
|
|
HelpTextObj = TextObject()
|
|
HelpTextObj.SetLang('')
|
|
HelpTextObj.SetString(HelpStr)
|
|
HelpTextList.append(HelpTextObj)
|
|
|
|
Result = _GetHelpStr(HelpTextList)
|
|
self.assertEqual(Result, ExpectedStr)
|
|
|
|
HelpTextList.sort()
|
|
self.assertEqual(Result, ExpectedStr)
|
|
|
|
HelpTextList.sort(reverse=True)
|
|
self.assertEqual(Result, ExpectedStr)
|
|
|
|
|
|
#
|
|
# Test GenGuidSections
|
|
#
|
|
class GenGuidSectionsTest(unittest.TestCase):
|
|
def setUp(self):
|
|
pass
|
|
|
|
def tearDown(self):
|
|
pass
|
|
|
|
#
|
|
# This is the API to generate Guid Object to help UnitTest
|
|
#
|
|
def GuidFactory(self, CName, FFE, Usage, GuidType, VariableName, HelpStr):
|
|
Guid = GuidObject()
|
|
Guid.SetCName(CName)
|
|
Guid.SetFeatureFlag(FFE)
|
|
Guid.SetGuidTypeList([GuidType])
|
|
Guid.SetUsage(Usage)
|
|
Guid.SetVariableName(VariableName)
|
|
|
|
HelpTextObj = TextObject()
|
|
HelpTextObj.SetLang('')
|
|
HelpTextObj.SetString(HelpStr)
|
|
Guid.SetHelpTextList([HelpTextObj])
|
|
|
|
return Guid
|
|
|
|
#
|
|
# Normal case: have two GuidObject
|
|
#
|
|
def testNormalCase1(self):
|
|
GuidList = []
|
|
|
|
CName = 'Guid1'
|
|
FFE = 'FFE1'
|
|
Usage = 'PRODUCES'
|
|
GuidType = 'Event'
|
|
VariableName = ''
|
|
HelpStr = 'Usage comment line 1'
|
|
Guid1 = self.GuidFactory(CName, FFE, Usage, GuidType,
|
|
VariableName, HelpStr)
|
|
GuidList.append(Guid1)
|
|
|
|
CName = 'Guid1'
|
|
FFE = 'FFE1'
|
|
Usage = 'CONSUMES'
|
|
GuidType = 'Variable'
|
|
VariableName = ''
|
|
HelpStr = 'Usage comment line 2'
|
|
Guid1 = self.GuidFactory(CName, FFE, Usage, GuidType,
|
|
VariableName, HelpStr)
|
|
GuidList.append(Guid1)
|
|
|
|
Result = GenGuidSections(GuidList)
|
|
Expected = '''[Guids]
|
|
## PRODUCES ## Event # Usage comment line 1
|
|
## CONSUMES ## Variable: # Usage comment line 2
|
|
Guid1|FFE1'''
|
|
self.assertEqual(Result.strip(), Expected)
|
|
|
|
#
|
|
# Normal case: have two GuidObject
|
|
#
|
|
def testNormalCase2(self):
|
|
GuidList = []
|
|
|
|
CName = 'Guid1'
|
|
FFE = 'FFE1'
|
|
Usage = 'PRODUCES'
|
|
GuidType = 'Event'
|
|
VariableName = ''
|
|
HelpStr = 'Usage comment line 1'
|
|
Guid1 = self.GuidFactory(CName, FFE, Usage, GuidType,
|
|
VariableName, HelpStr)
|
|
GuidList.append(Guid1)
|
|
|
|
CName = 'Guid1'
|
|
FFE = 'FFE1'
|
|
Usage = 'UNDEFINED'
|
|
GuidType = 'UNDEFINED'
|
|
VariableName = ''
|
|
HelpStr = 'Generic comment line 1\n Generic comment line 2'
|
|
Guid1 = self.GuidFactory(CName, FFE, Usage, GuidType,
|
|
VariableName, HelpStr)
|
|
GuidList.append(Guid1)
|
|
|
|
Result = GenGuidSections(GuidList)
|
|
Expected = '''[Guids]
|
|
## PRODUCES ## Event # Usage comment line 1
|
|
# Generic comment line 1
|
|
# Generic comment line 2
|
|
Guid1|FFE1'''
|
|
|
|
self.assertEqual(Result.strip(), Expected)
|
|
|
|
#
|
|
# Normal case: have two GuidObject, one help goes to generic help,
|
|
# the other go into usage comment
|
|
#
|
|
def testNormalCase3(self):
|
|
GuidList = []
|
|
|
|
CName = 'Guid1'
|
|
FFE = 'FFE1'
|
|
Usage = 'UNDEFINED'
|
|
GuidType = 'UNDEFINED'
|
|
VariableName = ''
|
|
HelpStr = 'Generic comment'
|
|
Guid1 = self.GuidFactory(CName, FFE, Usage, GuidType,
|
|
VariableName, HelpStr)
|
|
GuidList.append(Guid1)
|
|
|
|
CName = 'Guid1'
|
|
FFE = 'FFE1'
|
|
Usage = 'PRODUCES'
|
|
GuidType = 'Event'
|
|
VariableName = ''
|
|
HelpStr = 'Usage comment line 1'
|
|
Guid1 = self.GuidFactory(CName, FFE, Usage, GuidType,
|
|
VariableName, HelpStr)
|
|
GuidList.append(Guid1)
|
|
|
|
Result = GenGuidSections(GuidList)
|
|
Expected = '''[Guids]
|
|
# Generic comment
|
|
## PRODUCES ## Event # Usage comment line 1
|
|
Guid1|FFE1'''
|
|
|
|
self.assertEqual(Result.strip(), Expected)
|
|
|
|
#
|
|
# Normal case: have one GuidObject, generic comment multiple lines
|
|
#
|
|
def testNormalCase5(self):
|
|
GuidList = []
|
|
|
|
CName = 'Guid1'
|
|
FFE = 'FFE1'
|
|
Usage = 'UNDEFINED'
|
|
GuidType = 'UNDEFINED'
|
|
VariableName = ''
|
|
HelpStr = 'Generic comment line1 \n generic comment line 2'
|
|
Guid1 = self.GuidFactory(CName, FFE, Usage, GuidType,
|
|
VariableName, HelpStr)
|
|
GuidList.append(Guid1)
|
|
|
|
Result = GenGuidSections(GuidList)
|
|
Expected = '''[Guids]
|
|
# Generic comment line1
|
|
# generic comment line 2
|
|
Guid1|FFE1'''
|
|
|
|
self.assertEqual(Result.strip(), Expected)
|
|
|
|
#
|
|
# Normal case: have one GuidObject, usage comment multiple lines
|
|
#
|
|
def testNormalCase6(self):
|
|
GuidList = []
|
|
|
|
CName = 'Guid1'
|
|
FFE = 'FFE1'
|
|
Usage = 'PRODUCES'
|
|
GuidType = 'Event'
|
|
VariableName = ''
|
|
HelpStr = 'Usage comment line 1\n Usage comment line 2'
|
|
Guid1 = self.GuidFactory(CName, FFE, Usage, GuidType,
|
|
VariableName, HelpStr)
|
|
GuidList.append(Guid1)
|
|
|
|
Result = GenGuidSections(GuidList)
|
|
Expected = '''[Guids]
|
|
Guid1|FFE1 ## PRODUCES ## Event # Usage comment line 1 Usage comment line 2
|
|
'''
|
|
self.assertEqual(Result.strip(), Expected.strip())
|
|
|
|
#
|
|
# Normal case: have one GuidObject, usage comment one line
|
|
#
|
|
def testNormalCase7(self):
|
|
GuidList = []
|
|
|
|
CName = 'Guid1'
|
|
FFE = 'FFE1'
|
|
Usage = 'UNDEFINED'
|
|
GuidType = 'UNDEFINED'
|
|
VariableName = ''
|
|
HelpStr = 'Usage comment line 1'
|
|
Guid1 = self.GuidFactory(CName, FFE, Usage, GuidType,
|
|
VariableName, HelpStr)
|
|
GuidList.append(Guid1)
|
|
|
|
Result = GenGuidSections(GuidList)
|
|
Expected = '''[Guids]
|
|
Guid1|FFE1 # Usage comment line 1
|
|
'''
|
|
self.assertEqual(Result.strip(), Expected.strip())
|
|
|
|
#
|
|
# Normal case: have two GuidObject
|
|
#
|
|
def testNormalCase8(self):
|
|
GuidList = []
|
|
|
|
CName = 'Guid1'
|
|
FFE = 'FFE1'
|
|
Usage = 'PRODUCES'
|
|
GuidType = 'Event'
|
|
VariableName = ''
|
|
HelpStr = 'Usage comment line 1\n Usage comment line 2'
|
|
Guid1 = self.GuidFactory(CName, FFE, Usage, GuidType,
|
|
VariableName, HelpStr)
|
|
GuidList.append(Guid1)
|
|
|
|
CName = 'Guid1'
|
|
FFE = 'FFE1'
|
|
Usage = 'PRODUCES'
|
|
GuidType = 'Event'
|
|
VariableName = ''
|
|
HelpStr = 'Usage comment line 3'
|
|
Guid1 = self.GuidFactory(CName, FFE, Usage, GuidType,
|
|
VariableName, HelpStr)
|
|
GuidList.append(Guid1)
|
|
|
|
Result = GenGuidSections(GuidList)
|
|
Expected = '''[Guids]
|
|
## PRODUCES ## Event # Usage comment line 1 Usage comment line 2
|
|
## PRODUCES ## Event # Usage comment line 3
|
|
Guid1|FFE1
|
|
'''
|
|
self.assertEqual(Result.strip(), Expected.strip())
|
|
|
|
#
|
|
# Normal case: have no GuidObject
|
|
#
|
|
def testNormalCase9(self):
|
|
GuidList = []
|
|
|
|
Result = GenGuidSections(GuidList)
|
|
Expected = ''
|
|
self.assertEqual(Result.strip(), Expected.strip())
|
|
|
|
#
|
|
# Normal case: have one GuidObject with no comment generated
|
|
#
|
|
def testNormalCase10(self):
|
|
GuidList = []
|
|
|
|
CName = 'Guid1'
|
|
FFE = 'FFE1'
|
|
Usage = 'UNDEFINED'
|
|
GuidType = 'UNDEFINED'
|
|
VariableName = ''
|
|
HelpStr = ''
|
|
Guid1 = self.GuidFactory(CName, FFE, Usage, GuidType,
|
|
VariableName, HelpStr)
|
|
GuidList.append(Guid1)
|
|
|
|
Result = GenGuidSections(GuidList)
|
|
Expected = '''[Guids]
|
|
Guid1|FFE1
|
|
'''
|
|
self.assertEqual(Result.strip(), Expected.strip())
|
|
|
|
#
|
|
# Normal case: have three GuidObject
|
|
#
|
|
def testNormalCase11(self):
|
|
GuidList = []
|
|
|
|
CName = 'Guid1'
|
|
FFE = 'FFE1'
|
|
Usage = 'UNDEFINED'
|
|
GuidType = 'UNDEFINED'
|
|
VariableName = ''
|
|
HelpStr = 'general comment line 1'
|
|
Guid1 = self.GuidFactory(CName, FFE, Usage, GuidType,
|
|
VariableName, HelpStr)
|
|
GuidList.append(Guid1)
|
|
|
|
CName = 'Guid1'
|
|
FFE = 'FFE1'
|
|
Usage = 'PRODUCES'
|
|
GuidType = 'Event'
|
|
VariableName = ''
|
|
HelpStr = 'Usage comment line 3'
|
|
Guid1 = self.GuidFactory(CName, FFE, Usage, GuidType,
|
|
VariableName, HelpStr)
|
|
GuidList.append(Guid1)
|
|
|
|
CName = 'Guid1'
|
|
FFE = 'FFE1'
|
|
Usage = 'UNDEFINED'
|
|
GuidType = 'UNDEFINED'
|
|
VariableName = ''
|
|
HelpStr = 'general comment line 2'
|
|
Guid1 = self.GuidFactory(CName, FFE, Usage, GuidType,
|
|
VariableName, HelpStr)
|
|
GuidList.append(Guid1)
|
|
|
|
Result = GenGuidSections(GuidList)
|
|
Expected = '''[Guids]
|
|
# general comment line 1
|
|
## PRODUCES ## Event # Usage comment line 3
|
|
# general comment line 2
|
|
Guid1|FFE1
|
|
'''
|
|
self.assertEqual(Result.strip(), Expected.strip())
|
|
|
|
#
|
|
# Normal case: have three GuidObject, with Usage/Type and no help
|
|
#
|
|
def testNormalCase12(self):
|
|
GuidList = []
|
|
|
|
CName = 'Guid1'
|
|
FFE = 'FFE1'
|
|
Usage = 'PRODUCES'
|
|
GuidType = 'GUID'
|
|
VariableName = ''
|
|
HelpStr = ''
|
|
Guid1 = self.GuidFactory(CName, FFE, Usage, GuidType,
|
|
VariableName, HelpStr)
|
|
GuidList.append(Guid1)
|
|
|
|
CName = 'Guid1'
|
|
FFE = 'FFE1'
|
|
Usage = 'PRODUCES'
|
|
GuidType = 'Event'
|
|
VariableName = ''
|
|
HelpStr = ''
|
|
Guid1 = self.GuidFactory(CName, FFE, Usage, GuidType,
|
|
VariableName, HelpStr)
|
|
GuidList.append(Guid1)
|
|
|
|
CName = 'Guid1'
|
|
FFE = 'FFE1'
|
|
Usage = 'CONSUMES'
|
|
GuidType = 'Event'
|
|
VariableName = ''
|
|
HelpStr = ''
|
|
Guid1 = self.GuidFactory(CName, FFE, Usage, GuidType,
|
|
VariableName, HelpStr)
|
|
GuidList.append(Guid1)
|
|
|
|
Result = GenGuidSections(GuidList)
|
|
Expected = '''[Guids]
|
|
## PRODUCES ## GUID
|
|
## PRODUCES ## Event
|
|
## CONSUMES ## Event
|
|
Guid1|FFE1
|
|
'''
|
|
self.assertEqual(Result.strip(), Expected.strip())
|
|
|
|
#
|
|
# Test GenProtocolPPiSections
|
|
#
|
|
class GenProtocolPPiSectionsTest(unittest.TestCase):
|
|
def setUp(self):
|
|
pass
|
|
|
|
def tearDown(self):
|
|
pass
|
|
|
|
#
|
|
# This is the API to generate Protocol/Ppi Object to help UnitTest
|
|
#
|
|
def ObjectFactory(self, CName, FFE, Usage, Notify, HelpStr, IsProtocol):
|
|
if IsProtocol:
|
|
Object = ProtocolObject()
|
|
else:
|
|
Object = PpiObject()
|
|
|
|
Object.SetCName(CName)
|
|
Object.SetFeatureFlag(FFE)
|
|
Object.SetUsage(Usage)
|
|
Object.SetNotify(Notify)
|
|
|
|
HelpTextObj = TextObject()
|
|
HelpTextObj.SetLang('')
|
|
HelpTextObj.SetString(HelpStr)
|
|
Object.SetHelpTextList([HelpTextObj])
|
|
|
|
return Object
|
|
|
|
# Usage Notify Help INF Comment
|
|
#1 UNDEFINED true Present ## UNDEFINED ## NOTIFY # Help
|
|
#2 UNDEFINED true Not Present ## UNDEFINED ## NOTIFY
|
|
#3 UNDEFINED false Present ## UNDEFINED # Help
|
|
#4 UNDEFINED false Not Present ## UNDEFINED
|
|
#5 UNDEFINED Not Present Present # Help
|
|
#6 UNDEFINED Not Present Not Present <empty>
|
|
#7 Other true Present ## Other ## NOTIFY # Help
|
|
#8 Other true Not Present ## Other ## NOTIFY
|
|
#9 Other false Present ## Other # Help
|
|
#A Other false Not Present ## Other
|
|
#B Other Not Present Present ## Other # Help
|
|
#C Other Not Present Not Present ## Other
|
|
|
|
def testNormalCase1(self):
|
|
ObjectList = []
|
|
|
|
CName = 'Guid1'
|
|
FFE = 'FFE1'
|
|
|
|
Usage = 'UNDEFINED'
|
|
Notify = True
|
|
HelpStr = 'Help'
|
|
IsProtocol = True
|
|
Object = self.ObjectFactory(CName, FFE, Usage, Notify,
|
|
HelpStr, IsProtocol)
|
|
ObjectList.append(Object)
|
|
|
|
|
|
Result = GenProtocolPPiSections(ObjectList, IsProtocol)
|
|
Expected = '''[Protocols]
|
|
Guid1|FFE1 ## UNDEFINED ## NOTIFY # Help'''
|
|
self.assertEqual(Result.strip(), Expected)
|
|
|
|
IsProtocol = False
|
|
ObjectList = []
|
|
Object = self.ObjectFactory(CName, FFE, Usage, Notify,
|
|
HelpStr, IsProtocol)
|
|
ObjectList.append(Object)
|
|
|
|
|
|
Result = GenProtocolPPiSections(ObjectList, IsProtocol)
|
|
Expected = '''[Ppis]
|
|
Guid1|FFE1 ## UNDEFINED ## NOTIFY # Help'''
|
|
self.assertEqual(Result.strip(), Expected)
|
|
|
|
def testNormalCase2(self):
|
|
ObjectList = []
|
|
|
|
CName = 'Guid1'
|
|
FFE = 'FFE1'
|
|
|
|
Usage = 'UNDEFINED'
|
|
Notify = True
|
|
HelpStr = ''
|
|
IsProtocol = True
|
|
Object = self.ObjectFactory(CName, FFE, Usage, Notify,
|
|
HelpStr, IsProtocol)
|
|
ObjectList.append(Object)
|
|
|
|
|
|
Result = GenProtocolPPiSections(ObjectList, IsProtocol)
|
|
Expected = '''[Protocols]
|
|
Guid1|FFE1 ## UNDEFINED ## NOTIFY'''
|
|
self.assertEqual(Result.strip(), Expected)
|
|
|
|
def testNormalCase3(self):
|
|
ObjectList = []
|
|
|
|
CName = 'Guid1'
|
|
FFE = 'FFE1'
|
|
|
|
Usage = 'UNDEFINED'
|
|
Notify = False
|
|
HelpStr = 'Help'
|
|
IsProtocol = True
|
|
Object = self.ObjectFactory(CName, FFE, Usage, Notify,
|
|
HelpStr, IsProtocol)
|
|
ObjectList.append(Object)
|
|
|
|
|
|
Result = GenProtocolPPiSections(ObjectList, IsProtocol)
|
|
Expected = '''[Protocols]
|
|
Guid1|FFE1 ## UNDEFINED # Help'''
|
|
self.assertEqual(Result.strip(), Expected)
|
|
|
|
def testNormalCase4(self):
|
|
ObjectList = []
|
|
|
|
CName = 'Guid1'
|
|
FFE = 'FFE1'
|
|
|
|
Usage = 'UNDEFINED'
|
|
Notify = False
|
|
HelpStr = ''
|
|
IsProtocol = True
|
|
Object = self.ObjectFactory(CName, FFE, Usage, Notify,
|
|
HelpStr, IsProtocol)
|
|
ObjectList.append(Object)
|
|
|
|
|
|
Result = GenProtocolPPiSections(ObjectList, IsProtocol)
|
|
Expected = '''[Protocols]
|
|
Guid1|FFE1 ## UNDEFINED'''
|
|
self.assertEqual(Result.strip(), Expected)
|
|
|
|
def testNormalCase5(self):
|
|
ObjectList = []
|
|
|
|
CName = 'Guid1'
|
|
FFE = 'FFE1'
|
|
|
|
Usage = 'UNDEFINED'
|
|
Notify = ''
|
|
HelpStr = 'Help'
|
|
IsProtocol = True
|
|
Object = self.ObjectFactory(CName, FFE, Usage, Notify,
|
|
HelpStr, IsProtocol)
|
|
ObjectList.append(Object)
|
|
|
|
|
|
Result = GenProtocolPPiSections(ObjectList, IsProtocol)
|
|
Expected = '''[Protocols]
|
|
Guid1|FFE1 # Help'''
|
|
self.assertEqual(Result.strip(), Expected)
|
|
|
|
def testNormalCase6(self):
|
|
ObjectList = []
|
|
|
|
CName = 'Guid1'
|
|
FFE = 'FFE1'
|
|
|
|
Usage = 'UNDEFINED'
|
|
Notify = ''
|
|
HelpStr = ''
|
|
IsProtocol = True
|
|
Object = self.ObjectFactory(CName, FFE, Usage, Notify,
|
|
HelpStr, IsProtocol)
|
|
ObjectList.append(Object)
|
|
|
|
|
|
Result = GenProtocolPPiSections(ObjectList, IsProtocol)
|
|
Expected = '''[Protocols]
|
|
Guid1|FFE1'''
|
|
self.assertEqual(Result.strip(), Expected)
|
|
|
|
def testNormalCase7(self):
|
|
ObjectList = []
|
|
|
|
CName = 'Guid1'
|
|
FFE = 'FFE1'
|
|
|
|
Usage = 'PRODUCES'
|
|
Notify = True
|
|
HelpStr = 'Help'
|
|
IsProtocol = True
|
|
Object = self.ObjectFactory(CName, FFE, Usage, Notify,
|
|
HelpStr, IsProtocol)
|
|
ObjectList.append(Object)
|
|
|
|
|
|
Result = GenProtocolPPiSections(ObjectList, IsProtocol)
|
|
Expected = '''[Protocols]
|
|
Guid1|FFE1 ## PRODUCES ## NOTIFY # Help'''
|
|
self.assertEqual(Result.strip(), Expected)
|
|
|
|
def testNormalCase8(self):
|
|
ObjectList = []
|
|
|
|
CName = 'Guid1'
|
|
FFE = 'FFE1'
|
|
|
|
Usage = 'PRODUCES'
|
|
Notify = True
|
|
HelpStr = ''
|
|
IsProtocol = True
|
|
Object = self.ObjectFactory(CName, FFE, Usage, Notify,
|
|
HelpStr, IsProtocol)
|
|
ObjectList.append(Object)
|
|
|
|
|
|
Result = GenProtocolPPiSections(ObjectList, IsProtocol)
|
|
Expected = '''[Protocols]
|
|
Guid1|FFE1 ## PRODUCES ## NOTIFY'''
|
|
self.assertEqual(Result.strip(), Expected)
|
|
|
|
def testNormalCase9(self):
|
|
ObjectList = []
|
|
|
|
CName = 'Guid1'
|
|
FFE = 'FFE1'
|
|
|
|
Usage = 'PRODUCES'
|
|
Notify = False
|
|
HelpStr = 'Help'
|
|
IsProtocol = True
|
|
Object = self.ObjectFactory(CName, FFE, Usage, Notify,
|
|
HelpStr, IsProtocol)
|
|
ObjectList.append(Object)
|
|
|
|
|
|
Result = GenProtocolPPiSections(ObjectList, IsProtocol)
|
|
Expected = '''[Protocols]
|
|
Guid1|FFE1 ## PRODUCES # Help'''
|
|
self.assertEqual(Result.strip(), Expected)
|
|
|
|
def testNormalCaseA(self):
|
|
ObjectList = []
|
|
|
|
CName = 'Guid1'
|
|
FFE = 'FFE1'
|
|
|
|
Usage = 'PRODUCES'
|
|
Notify = False
|
|
HelpStr = ''
|
|
IsProtocol = True
|
|
Object = self.ObjectFactory(CName, FFE, Usage, Notify,
|
|
HelpStr, IsProtocol)
|
|
ObjectList.append(Object)
|
|
|
|
|
|
Result = GenProtocolPPiSections(ObjectList, IsProtocol)
|
|
Expected = '''[Protocols]
|
|
Guid1|FFE1 ## PRODUCES'''
|
|
self.assertEqual(Result.strip(), Expected)
|
|
|
|
def testNormalCaseB(self):
|
|
ObjectList = []
|
|
|
|
CName = 'Guid1'
|
|
FFE = 'FFE1'
|
|
|
|
Usage = 'PRODUCES'
|
|
Notify = ''
|
|
HelpStr = 'Help'
|
|
IsProtocol = True
|
|
Object = self.ObjectFactory(CName, FFE, Usage, Notify,
|
|
HelpStr, IsProtocol)
|
|
ObjectList.append(Object)
|
|
|
|
|
|
Result = GenProtocolPPiSections(ObjectList, IsProtocol)
|
|
Expected = '''[Protocols]
|
|
Guid1|FFE1 ## PRODUCES # Help'''
|
|
self.assertEqual(Result.strip(), Expected)
|
|
|
|
def testNormalCaseC(self):
|
|
ObjectList = []
|
|
|
|
CName = 'Guid1'
|
|
FFE = 'FFE1'
|
|
|
|
Usage = 'PRODUCES'
|
|
Notify = ''
|
|
HelpStr = ''
|
|
IsProtocol = True
|
|
Object = self.ObjectFactory(CName, FFE, Usage, Notify,
|
|
HelpStr, IsProtocol)
|
|
ObjectList.append(Object)
|
|
|
|
|
|
Result = GenProtocolPPiSections(ObjectList, IsProtocol)
|
|
Expected = '''[Protocols]
|
|
Guid1|FFE1 ## PRODUCES'''
|
|
self.assertEqual(Result.strip(), Expected)
|
|
|
|
#
|
|
# Test GenPcdSections
|
|
#
|
|
class GenPcdSectionsTest(unittest.TestCase):
|
|
def setUp(self):
|
|
pass
|
|
|
|
def tearDown(self):
|
|
pass
|
|
|
|
#
|
|
# This is the API to generate Pcd Object to help UnitTest
|
|
#
|
|
def ObjectFactory(self, ItemType, TSCName, CName, DValue, FFE, Usage, Str):
|
|
Object = PcdObject()
|
|
HelpStr = Str
|
|
|
|
Object.SetItemType(ItemType)
|
|
Object.SetTokenSpaceGuidCName(TSCName)
|
|
Object.SetCName(CName)
|
|
Object.SetDefaultValue(DValue)
|
|
Object.SetFeatureFlag(FFE)
|
|
Object.SetValidUsage(Usage)
|
|
|
|
HelpTextObj = TextObject()
|
|
HelpTextObj.SetLang('')
|
|
HelpTextObj.SetString(HelpStr)
|
|
Object.SetHelpTextList([HelpTextObj])
|
|
|
|
return Object
|
|
|
|
|
|
# Usage Help INF Comment
|
|
#1 UNDEFINED Present # Help
|
|
#2 UNDEFINED Not Present <empty>
|
|
#3 Other Present ## Other # Help
|
|
#4 Other Not Present ## Other
|
|
|
|
def testNormalCase1(self):
|
|
ObjectList = []
|
|
ItemType = 'Pcd'
|
|
TSCName = 'TSCName'
|
|
CName = 'CName'
|
|
DValue = 'DValue'
|
|
FFE = 'FFE'
|
|
|
|
Usage = 'UNDEFINED'
|
|
Str = 'Help'
|
|
|
|
Object = self.ObjectFactory(ItemType, TSCName, CName, DValue, FFE,
|
|
Usage, Str)
|
|
ObjectList.append(Object)
|
|
|
|
Result = GenPcdSections(ObjectList)
|
|
Expected = \
|
|
'[Pcd]\n' + \
|
|
'TSCName.CName|DValue|FFE # Help'
|
|
self.assertEqual(Result.strip(), Expected)
|
|
|
|
def testNormalCase2(self):
|
|
ObjectList = []
|
|
ItemType = 'Pcd'
|
|
TSCName = 'TSCName'
|
|
CName = 'CName'
|
|
DValue = 'DValue'
|
|
FFE = 'FFE'
|
|
|
|
Usage = 'UNDEFINED'
|
|
Str = ''
|
|
|
|
Object = self.ObjectFactory(ItemType, TSCName, CName, DValue, FFE,
|
|
Usage, Str)
|
|
ObjectList.append(Object)
|
|
|
|
Result = GenPcdSections(ObjectList)
|
|
Expected = '[Pcd]\nTSCName.CName|DValue|FFE'
|
|
self.assertEqual(Result.strip(), Expected)
|
|
|
|
def testNormalCase3(self):
|
|
ObjectList = []
|
|
ItemType = 'Pcd'
|
|
TSCName = 'TSCName'
|
|
CName = 'CName'
|
|
DValue = 'DValue'
|
|
FFE = 'FFE'
|
|
|
|
Usage = 'CONSUMES'
|
|
Str = 'Help'
|
|
|
|
Object = self.ObjectFactory(ItemType, TSCName, CName, DValue, FFE,
|
|
Usage, Str)
|
|
ObjectList.append(Object)
|
|
|
|
Result = GenPcdSections(ObjectList)
|
|
Expected = '[Pcd]\nTSCName.CName|DValue|FFE ## CONSUMES # Help'
|
|
self.assertEqual(Result.strip(), Expected)
|
|
|
|
def testNormalCase4(self):
|
|
ObjectList = []
|
|
ItemType = 'Pcd'
|
|
TSCName = 'TSCName'
|
|
CName = 'CName'
|
|
DValue = 'DValue'
|
|
FFE = 'FFE'
|
|
|
|
Usage = 'CONSUMES'
|
|
Str = ''
|
|
|
|
Object = self.ObjectFactory(ItemType, TSCName, CName, DValue, FFE,
|
|
Usage, Str)
|
|
ObjectList.append(Object)
|
|
|
|
Result = GenPcdSections(ObjectList)
|
|
Expected = '[Pcd]\nTSCName.CName|DValue|FFE ## CONSUMES'
|
|
self.assertEqual(Result.strip(), Expected)
|
|
|
|
#
|
|
# multiple lines for normal usage
|
|
#
|
|
def testNormalCase5(self):
|
|
ObjectList = []
|
|
ItemType = 'Pcd'
|
|
TSCName = 'TSCName'
|
|
CName = 'CName'
|
|
DValue = 'DValue'
|
|
FFE = 'FFE'
|
|
|
|
Usage = 'CONSUMES'
|
|
Str = 'commment line 1\ncomment line 2'
|
|
Object = self.ObjectFactory(ItemType, TSCName, CName, DValue, FFE,
|
|
Usage, Str)
|
|
ObjectList.append(Object)
|
|
|
|
Result = GenPcdSections(ObjectList)
|
|
Expected = '''[Pcd]
|
|
TSCName.CName|DValue|FFE ## CONSUMES # commment line 1 comment line 2'''
|
|
self.assertEqual(Result.strip(), Expected)
|
|
|
|
#
|
|
# multiple lines for UNDEFINED usage
|
|
#
|
|
def testNormalCase6(self):
|
|
ObjectList = []
|
|
ItemType = 'Pcd'
|
|
TSCName = 'TSCName'
|
|
CName = 'CName'
|
|
DValue = 'DValue'
|
|
FFE = 'FFE'
|
|
|
|
Usage = 'UNDEFINED'
|
|
Str = 'commment line 1\ncomment line 2'
|
|
Object = self.ObjectFactory(ItemType, TSCName, CName, DValue, FFE,
|
|
Usage, Str)
|
|
ObjectList.append(Object)
|
|
|
|
Usage = 'UNDEFINED'
|
|
Str = 'commment line 3'
|
|
Object = self.ObjectFactory(ItemType, TSCName, CName, DValue, FFE,
|
|
Usage, Str)
|
|
ObjectList.append(Object)
|
|
|
|
Result = GenPcdSections(ObjectList)
|
|
Expected = '''[Pcd]
|
|
# commment line 1
|
|
# comment line 2
|
|
# commment line 3
|
|
TSCName.CName|DValue|FFE'''
|
|
self.assertEqual(Result.strip(), Expected)
|
|
|
|
#
|
|
# multiple lines for UNDEFINED and normal usage
|
|
#
|
|
def testNormalCase7(self):
|
|
ObjectList = []
|
|
ItemType = 'Pcd'
|
|
TSCName = 'TSCName'
|
|
CName = 'CName'
|
|
DValue = 'DValue'
|
|
FFE = 'FFE'
|
|
|
|
Usage = 'UNDEFINED'
|
|
Str = 'commment line 1\ncomment line 2'
|
|
Object = self.ObjectFactory(ItemType, TSCName, CName, DValue, FFE,
|
|
Usage, Str)
|
|
ObjectList.append(Object)
|
|
|
|
Usage = 'CONSUMES'
|
|
Str = 'Foo'
|
|
Object = self.ObjectFactory(ItemType, TSCName, CName, DValue, FFE,
|
|
Usage, Str)
|
|
ObjectList.append(Object)
|
|
|
|
Usage = 'UNDEFINED'
|
|
Str = 'commment line 3'
|
|
Object = self.ObjectFactory(ItemType, TSCName, CName, DValue, FFE,
|
|
Usage, Str)
|
|
ObjectList.append(Object)
|
|
|
|
Result = GenPcdSections(ObjectList)
|
|
Expected = '''[Pcd]
|
|
# commment line 1
|
|
# comment line 2
|
|
## CONSUMES # Foo
|
|
# commment line 3
|
|
TSCName.CName|DValue|FFE'''
|
|
self.assertEqual(Result.strip(), Expected)
|
|
|
|
# Usage Help INF Comment
|
|
# CONSUMES Present # Help (keep <EOL> and insert '#' at beginning of each new line)
|
|
# CONSUMES Not Present <empty>
|
|
|
|
#
|
|
# TAB_INF_FEATURE_PCD
|
|
#
|
|
def testNormalCase8(self):
|
|
ObjectList = []
|
|
ItemType = TAB_INF_FEATURE_PCD
|
|
TSCName = 'TSCName'
|
|
CName = 'CName'
|
|
DValue = 'DValue'
|
|
FFE = 'FFE'
|
|
|
|
Usage = 'CONSUMES'
|
|
Str = 'commment line 1\ncomment line 2'
|
|
Object = self.ObjectFactory(ItemType, TSCName, CName, DValue, FFE,
|
|
Usage, Str)
|
|
ObjectList.append(Object)
|
|
|
|
Result = GenPcdSections(ObjectList)
|
|
Expected = '''[FeaturePcd]
|
|
# commment line 1
|
|
# comment line 2
|
|
TSCName.CName|DValue|FFE'''
|
|
self.assertEqual(Result.strip(), Expected)
|
|
|
|
#
|
|
# TAB_INF_FEATURE_PCD
|
|
#
|
|
def testNormalCase9(self):
|
|
ObjectList = []
|
|
ItemType = TAB_INF_FEATURE_PCD
|
|
TSCName = 'TSCName'
|
|
CName = 'CName'
|
|
DValue = 'DValue'
|
|
FFE = 'FFE'
|
|
|
|
Usage = 'CONSUMES'
|
|
Str = ''
|
|
Object = self.ObjectFactory(ItemType, TSCName, CName, DValue, FFE,
|
|
Usage, Str)
|
|
ObjectList.append(Object)
|
|
|
|
Result = GenPcdSections(ObjectList)
|
|
Expected = '''[FeaturePcd]
|
|
TSCName.CName|DValue|FFE'''
|
|
self.assertEqual(Result.strip(), Expected)
|
|
|
|
#
|
|
# TAB_INF_FEATURE_PCD
|
|
#
|
|
def testNormalCase10(self):
|
|
ObjectList = []
|
|
ItemType = TAB_INF_FEATURE_PCD
|
|
TSCName = 'TSCName'
|
|
CName = 'CName'
|
|
DValue = 'DValue'
|
|
FFE = 'FFE'
|
|
|
|
Usage = 'PRODUCES'
|
|
Str = 'commment line 1\ncomment line 2'
|
|
Object = self.ObjectFactory(ItemType, TSCName, CName, DValue, FFE,
|
|
Usage, Str)
|
|
ObjectList.append(Object)
|
|
|
|
Result = GenPcdSections(ObjectList)
|
|
Expected = '''
|
|
|
|
[FeaturePcd]
|
|
# commment line 1
|
|
# comment line 2
|
|
TSCName.CName|DValue|FFE
|
|
'''
|
|
self.assertEqual(Result, Expected)
|
|
|
|
|
|
#
|
|
# Test GenSpecialSections of Hob
|
|
#
|
|
class GenHobSectionsTest(unittest.TestCase):
|
|
def setUp(self):
|
|
pass
|
|
|
|
def tearDown(self):
|
|
pass
|
|
|
|
#
|
|
# This is the API to generate Event Object to help UnitTest
|
|
#
|
|
def ObjectFactory(self, SupArchList, Type, Usage, Str):
|
|
Object = HobObject()
|
|
HelpStr = Str
|
|
|
|
Object.SetHobType(Type)
|
|
Object.SetUsage(Usage)
|
|
Object.SetSupArchList(SupArchList)
|
|
|
|
HelpTextObj = TextObject()
|
|
HelpTextObj.SetLang('')
|
|
HelpTextObj.SetString(HelpStr)
|
|
Object.SetHelpTextList([HelpTextObj])
|
|
|
|
return Object
|
|
|
|
def testNormalCase1(self):
|
|
ObjectList = []
|
|
SupArchList = ['X64']
|
|
Type = 'Foo'
|
|
Usage = 'UNDEFINED'
|
|
Str = 'Help'
|
|
|
|
Object = self.ObjectFactory(SupArchList, Type, Usage, Str)
|
|
ObjectList.append(Object)
|
|
|
|
Result = GenSpecialSections(ObjectList, 'Hob')
|
|
Expected = '''# [Hob.X64]
|
|
# ##
|
|
# # Help
|
|
# #
|
|
# Foo ## UNDEFINED
|
|
#
|
|
#
|
|
'''
|
|
self.assertEqual(Result, Expected)
|
|
|
|
def testNormalCase2(self):
|
|
ObjectList = []
|
|
SupArchList = []
|
|
Type = 'Foo'
|
|
Usage = 'UNDEFINED'
|
|
Str = 'Help'
|
|
|
|
Object = self.ObjectFactory(SupArchList, Type, Usage, Str)
|
|
ObjectList.append(Object)
|
|
|
|
Result = GenSpecialSections(ObjectList, 'Hob')
|
|
Expected = '''# [Hob]
|
|
# ##
|
|
# # Help
|
|
# #
|
|
# Foo ## UNDEFINED
|
|
#
|
|
#
|
|
'''
|
|
self.assertEqual(Result, Expected)
|
|
|
|
def testNormalCase3(self):
|
|
ObjectList = []
|
|
SupArchList = ['X64']
|
|
Type = 'Foo'
|
|
Usage = 'UNDEFINED'
|
|
Str = '\nComment Line 1\n\n'
|
|
|
|
Object = self.ObjectFactory(SupArchList, Type, Usage, Str)
|
|
ObjectList.append(Object)
|
|
|
|
Result = GenSpecialSections(ObjectList, 'Hob')
|
|
Expected = '''# [Hob.X64]
|
|
# ##
|
|
# # Comment Line 1
|
|
# #
|
|
# Foo ## UNDEFINED
|
|
#
|
|
#
|
|
'''
|
|
self.assertEqual(Result, Expected)
|
|
|
|
def testNormalCase4(self):
|
|
ObjectList = []
|
|
SupArchList = ['X64']
|
|
Type = 'Foo'
|
|
Usage = 'UNDEFINED'
|
|
Str = '\nComment Line 1\n'
|
|
|
|
Object = self.ObjectFactory(SupArchList, Type, Usage, Str)
|
|
ObjectList.append(Object)
|
|
|
|
Result = GenSpecialSections(ObjectList, 'Hob')
|
|
Expected = '''# [Hob.X64]
|
|
# ##
|
|
# # Comment Line 1
|
|
# #
|
|
# Foo ## UNDEFINED
|
|
#
|
|
#
|
|
'''
|
|
self.assertEqual(Result, Expected)
|
|
|
|
def testNormalCase5(self):
|
|
ObjectList = []
|
|
SupArchList = ['X64']
|
|
Type = 'Foo'
|
|
Usage = 'UNDEFINED'
|
|
Str = 'Comment Line 1\n\n'
|
|
|
|
Object = self.ObjectFactory(SupArchList, Type, Usage, Str)
|
|
ObjectList.append(Object)
|
|
|
|
Result = GenSpecialSections(ObjectList, 'Hob')
|
|
Expected = '''# [Hob.X64]
|
|
# ##
|
|
# # Comment Line 1
|
|
# #
|
|
# Foo ## UNDEFINED
|
|
#
|
|
#
|
|
'''
|
|
self.assertEqual(Result, Expected)
|
|
|
|
def testNormalCase6(self):
|
|
ObjectList = []
|
|
SupArchList = ['X64']
|
|
Type = 'Foo'
|
|
Usage = 'UNDEFINED'
|
|
Str = ''
|
|
|
|
Object = self.ObjectFactory(SupArchList, Type, Usage, Str)
|
|
ObjectList.append(Object)
|
|
|
|
Result = GenSpecialSections(ObjectList, 'Hob')
|
|
Expected = '''# [Hob.X64]
|
|
# Foo ## UNDEFINED
|
|
#
|
|
#
|
|
'''
|
|
self.assertEqual(Result, Expected)
|
|
|
|
def testNormalCase7(self):
|
|
ObjectList = []
|
|
SupArchList = ['X64']
|
|
Type = 'Foo'
|
|
Usage = 'UNDEFINED'
|
|
Str = '\nNew Stack HoB'
|
|
|
|
|
|
Object = self.ObjectFactory(SupArchList, Type, Usage, Str)
|
|
ObjectList.append(Object)
|
|
|
|
Result = GenSpecialSections(ObjectList, 'Hob')
|
|
Expected = '''# [Hob.X64]
|
|
# ##
|
|
# # New Stack HoB
|
|
# #
|
|
# Foo ## UNDEFINED
|
|
#
|
|
#
|
|
'''
|
|
self.assertEqual(Result, Expected)
|
|
|
|
def testNormalCase8(self):
|
|
ObjectList = []
|
|
SupArchList = ['X64']
|
|
Type = 'Foo'
|
|
Usage = 'UNDEFINED'
|
|
Str = '\nNew Stack HoB\n\nTail Comment'
|
|
|
|
|
|
Object = self.ObjectFactory(SupArchList, Type, Usage, Str)
|
|
ObjectList.append(Object)
|
|
|
|
Result = GenSpecialSections(ObjectList, 'Hob')
|
|
Expected = '''# [Hob.X64]
|
|
# ##
|
|
# # New Stack HoB
|
|
# #
|
|
# # Tail Comment
|
|
# #
|
|
# Foo ## UNDEFINED
|
|
#
|
|
#
|
|
'''
|
|
self.assertEqual(Result, Expected)
|
|
|
|
def testNormalCase9(self):
|
|
ObjectList = []
|
|
SupArchList = ['X64']
|
|
Type = 'Foo'
|
|
Usage = 'UNDEFINED'
|
|
Str = '\n\n'
|
|
|
|
|
|
Object = self.ObjectFactory(SupArchList, Type, Usage, Str)
|
|
ObjectList.append(Object)
|
|
|
|
Result = GenSpecialSections(ObjectList, 'Hob')
|
|
Expected = '''# [Hob.X64]
|
|
# ##
|
|
# #
|
|
# #
|
|
# Foo ## UNDEFINED
|
|
#
|
|
#
|
|
'''
|
|
self.assertEqual(Result, Expected)
|
|
|
|
def testNormalCase10(self):
|
|
ObjectList = []
|
|
SupArchList = ['X64']
|
|
Type = 'Foo'
|
|
Usage = 'UNDEFINED'
|
|
Str = '\n'
|
|
|
|
Object = self.ObjectFactory(SupArchList, Type, Usage, Str)
|
|
ObjectList.append(Object)
|
|
|
|
Result = GenSpecialSections(ObjectList, 'Hob')
|
|
Expected = '''# [Hob.X64]
|
|
# ##
|
|
# #
|
|
# #
|
|
# Foo ## UNDEFINED
|
|
#
|
|
#
|
|
'''
|
|
self.assertEqual(Result, Expected)
|
|
|
|
def testNormalCase11(self):
|
|
ObjectList = []
|
|
SupArchList = ['X64']
|
|
Type = 'Foo'
|
|
Usage = 'UNDEFINED'
|
|
Str = '\n\n\n'
|
|
|
|
Object = self.ObjectFactory(SupArchList, Type, Usage, Str)
|
|
ObjectList.append(Object)
|
|
|
|
Result = GenSpecialSections(ObjectList, 'Hob')
|
|
Expected = '''# [Hob.X64]
|
|
# ##
|
|
# #
|
|
# #
|
|
# Foo ## UNDEFINED
|
|
#
|
|
#
|
|
'''
|
|
self.assertEqual(Result, Expected)
|
|
|
|
def testNormalCase12(self):
|
|
ObjectList = []
|
|
SupArchList = ['X64']
|
|
Type = 'Foo'
|
|
Usage = 'UNDEFINED'
|
|
Str = '\n\n\n\n'
|
|
|
|
Object = self.ObjectFactory(SupArchList, Type, Usage, Str)
|
|
ObjectList.append(Object)
|
|
|
|
Result = GenSpecialSections(ObjectList, 'Hob')
|
|
Expected = '''# [Hob.X64]
|
|
# ##
|
|
# #
|
|
# #
|
|
# #
|
|
# Foo ## UNDEFINED
|
|
#
|
|
#
|
|
'''
|
|
self.assertEqual(Result, Expected)
|
|
|
|
#
|
|
# Test GenGenericCommentF
|
|
#
|
|
class GenGenericCommentFTest(unittest.TestCase):
|
|
def setUp(self):
|
|
pass
|
|
|
|
def tearDown(self):
|
|
pass
|
|
|
|
def testNormalCase1(self):
|
|
CommentLines = 'Comment Line 1'
|
|
Result = GenGenericCommentF(CommentLines)
|
|
Expected = '# Comment Line 1\n'
|
|
self.assertEqual(Result, Expected)
|
|
|
|
def testNormalCase2(self):
|
|
CommentLines = '\n'
|
|
Result = GenGenericCommentF(CommentLines)
|
|
Expected = '#\n'
|
|
self.assertEqual(Result, Expected)
|
|
|
|
def testNormalCase3(self):
|
|
CommentLines = '\n\n\n'
|
|
Result = GenGenericCommentF(CommentLines)
|
|
Expected = '#\n#\n#\n'
|
|
self.assertEqual(Result, Expected)
|
|
|
|
def testNormalCase4(self):
|
|
CommentLines = 'coment line 1\n'
|
|
Result = GenGenericCommentF(CommentLines)
|
|
Expected = '# coment line 1\n'
|
|
self.assertEqual(Result, Expected)
|
|
|
|
def testNormalCase5(self):
|
|
CommentLines = 'coment line 1\n coment line 2\n'
|
|
Result = GenGenericCommentF(CommentLines)
|
|
Expected = '# coment line 1\n# coment line 2\n'
|
|
self.assertEqual(Result, Expected)
|
|
|
|
if __name__ == '__main__':
|
|
Logger.Initialize()
|
|
unittest.main()
|