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