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