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