1## @file
2# This file contain unit test for CommentParsing
3#
4# Copyright (c) 2011 - 2014, Intel Corporation. All rights reserved.<BR>
5#
6# This program and the accompanying materials are licensed and made available
7# under the terms and conditions of the BSD License which accompanies this
8# distribution. The full text of the license may be found at
9# http://opensource.org/licenses/bsd-license.php
10#
11# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
12# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
13
14import unittest
15
16import Logger.Log as Logger
17from Library.CommentParsing import ParseHeaderCommentSection, \
18                                   ParseGenericComment, \
19                                   ParseDecPcdGenericComment, \
20                                   ParseDecPcdTailComment
21from Library.CommentParsing import _IsCopyrightLine
22from Library.String import GetSplitValueList
23from Library.DataType import TAB_SPACE_SPLIT
24from Library.DataType import TAB_LANGUAGE_EN_US
25
26#
27# Test ParseHeaderCommentSection
28#
29class ParseHeaderCommentSectionTest(unittest.TestCase):
30    def setUp(self):
31        pass
32
33    def tearDown(self):
34        pass
35
36    #
37    # Normal case1: have license/copyright/license above @file
38    #
39    def testNormalCase1(self):
40        TestCommentLines1 = \
41        '''# License1
42        # License2
43        #
44        ## @file
45        # example abstract
46        #
47        # example description
48        #
49        # Copyright (c) 2007 - 2010, Intel Corporation. All rights reserved.<BR>
50        #
51        # License3
52        #'''
53
54        CommentList = GetSplitValueList(TestCommentLines1, "\n")
55        LineNum = 0
56        TestCommentLinesList = []
57        for Comment in CommentList:
58            LineNum += 1
59            TestCommentLinesList.append((Comment, LineNum))
60
61        Abstract, Description, Copyright, License = \
62            ParseHeaderCommentSection(TestCommentLinesList, "PhonyFile")
63
64        ExpectedAbstract = 'example abstract'
65        self.assertEqual(Abstract, ExpectedAbstract)
66
67        ExpectedDescription = 'example description'
68        self.assertEqual(Description, ExpectedDescription)
69
70        ExpectedCopyright = \
71            'Copyright (c) 2007 - 2010,'\
72            ' Intel Corporation. All rights reserved.<BR>'
73        self.assertEqual(Copyright, ExpectedCopyright)
74
75        ExpectedLicense = 'License1\nLicense2\n\nLicense3'
76        self.assertEqual(License, ExpectedLicense)
77
78    #
79    # Normal case2: have license/copyright above @file, but no copyright after
80    #
81    def testNormalCase2(self):
82        TestCommentLines2 = \
83        ''' # License1
84        # License2
85        #
86        ## @file
87        # example abstract
88        #
89        # example description
90        #
91        #Copyright (c) 2007 - 2010, Intel Corporation. All rights reserved.<BR>
92        #
93        ##'''
94
95        CommentList = GetSplitValueList(TestCommentLines2, "\n")
96        LineNum = 0
97        TestCommentLinesList = []
98        for Comment in CommentList:
99            LineNum += 1
100            TestCommentLinesList.append((Comment, LineNum))
101
102        Abstract, Description, Copyright, License = \
103            ParseHeaderCommentSection(TestCommentLinesList, "PhonyFile")
104
105        ExpectedAbstract = 'example abstract'
106        self.assertEqual(Abstract, ExpectedAbstract)
107
108        ExpectedDescription = 'example description'
109        self.assertEqual(Description, ExpectedDescription)
110
111        ExpectedCopyright = \
112            'Copyright (c) 2007 - 2010, Intel Corporation.'\
113            ' All rights reserved.<BR>'
114        self.assertEqual(Copyright, ExpectedCopyright)
115
116        ExpectedLicense = 'License1\nLicense2'
117        self.assertEqual(License, ExpectedLicense)
118
119
120    #
121    # Normal case2: have license/copyright/license above @file,
122    # but no abstract/description
123    #
124    def testNormalCase3(self):
125        TestCommentLines3 = \
126        ''' # License1
127        # License2
128        #
129        ## @file
130        # Copyright (c) 2007 - 2010, Intel Corporation. All rights reserved.<BR>
131        #
132        # License3 Line1
133        # License3 Line2
134        ##'''
135
136        CommentList = GetSplitValueList(TestCommentLines3, "\n")
137        LineNum = 0
138        TestCommentLinesList = []
139        for Comment in CommentList:
140            LineNum += 1
141            TestCommentLinesList.append((Comment, LineNum))
142
143        Abstract, Description, Copyright, License = \
144            ParseHeaderCommentSection(TestCommentLinesList, "PhonyFile")
145
146        ExpectedAbstract = ''
147        self.assertEqual(Abstract, ExpectedAbstract)
148
149        ExpectedDescription = ''
150        self.assertEqual(Description, ExpectedDescription)
151
152        ExpectedCopyright = \
153            'Copyright (c) 2007 - 2010,'\
154            ' Intel Corporation. All rights reserved.<BR>'
155        self.assertEqual(Copyright, ExpectedCopyright)
156
157        ExpectedLicense = \
158            'License1\n' \
159            'License2\n\n' \
160            'License3 Line1\n' \
161            'License3 Line2'
162        self.assertEqual(License, ExpectedLicense)
163
164    #
165    # Normal case4: format example in spec
166    #
167    def testNormalCase4(self):
168        TestCommentLines = \
169        '''
170        ## @file
171        # Abstract
172        #
173        # Description
174        #
175        # Copyright (c) 2007 - 2010, Intel Corporation. All rights reserved.<BR>
176        #
177        # License
178        #
179        ##'''
180
181        CommentList = GetSplitValueList(TestCommentLines, "\n")
182        LineNum = 0
183        TestCommentLinesList = []
184        for Comment in CommentList:
185            LineNum += 1
186            TestCommentLinesList.append((Comment, LineNum))
187
188        Abstract, Description, Copyright, License = \
189            ParseHeaderCommentSection(TestCommentLinesList, "PhonyFile")
190
191        ExpectedAbstract = 'Abstract'
192        self.assertEqual(Abstract, ExpectedAbstract)
193
194        ExpectedDescription = 'Description'
195        self.assertEqual(Description, ExpectedDescription)
196
197        ExpectedCopyright = \
198            'Copyright (c) 2007 - 2010, Intel Corporation.'\
199            ' All rights reserved.<BR>'
200        self.assertEqual(Copyright, ExpectedCopyright)
201
202        ExpectedLicense = \
203            'License'
204        self.assertEqual(License, ExpectedLicense)
205
206    #
207    # Normal case5: other line between copyright
208    #
209    def testNormalCase5(self):
210        TestCommentLines = \
211        '''
212        ## @file
213        # Abstract
214        #
215        # Description
216        #
217        # Copyright (c) 2007 - 2010, Intel Corporation. All rights reserved.<BR>
218        # other line
219        # Copyright (c) 2007 - 2010, Intel Corporation. All rights reserved.<BR>
220        #
221        # License
222        #
223        ##'''
224
225        CommentList = GetSplitValueList(TestCommentLines, "\n")
226        LineNum = 0
227        TestCommentLinesList = []
228        for Comment in CommentList:
229            LineNum += 1
230            TestCommentLinesList.append((Comment, LineNum))
231
232        Abstract, Description, Copyright, License = \
233            ParseHeaderCommentSection(TestCommentLinesList, "PhonyFile")
234
235        ExpectedAbstract = 'Abstract'
236        self.assertEqual(Abstract, ExpectedAbstract)
237
238        ExpectedDescription = 'Description'
239        self.assertEqual(Description, ExpectedDescription)
240
241        ExpectedCopyright = \
242            'Copyright (c) 2007 - 2010, Intel Corporation.'\
243            ' All rights reserved.<BR>\n'\
244            'Copyright (c) 2007 - 2010, Intel Corporation.'\
245            ' All rights reserved.<BR>'
246        self.assertEqual(Copyright, ExpectedCopyright)
247
248        ExpectedLicense = \
249            'License'
250        self.assertEqual(License, ExpectedLicense)
251
252    #
253    # Normal case6: multiple lines of copyright
254    #
255    def testNormalCase6(self):
256        TestCommentLines = \
257        '''
258        ## @file
259        # Abstract
260        #
261        # Description
262        #
263        # Copyright (c) 2007 - 2010, Intel Corporation. All rights reserved.<BR>
264        # Copyright (c) 2007 - 2010, FOO1 Corporation. All rights reserved.<BR>
265        # Copyright (c) 2007 - 2010, FOO2 Corporation. All rights reserved.<BR>
266        #
267        # License
268        #
269        ##'''
270
271        CommentList = GetSplitValueList(TestCommentLines, "\n")
272        LineNum = 0
273        TestCommentLinesList = []
274        for Comment in CommentList:
275            LineNum += 1
276            TestCommentLinesList.append((Comment, LineNum))
277
278        Abstract, Description, Copyright, License = \
279            ParseHeaderCommentSection(TestCommentLinesList, "PhonyFile")
280
281        ExpectedAbstract = 'Abstract'
282        self.assertEqual(Abstract, ExpectedAbstract)
283
284        ExpectedDescription = 'Description'
285        self.assertEqual(Description, ExpectedDescription)
286
287        ExpectedCopyright = \
288            'Copyright (c) 2007 - 2010, Intel Corporation.'\
289            ' All rights reserved.<BR>\n'\
290            'Copyright (c) 2007 - 2010, FOO1 Corporation.'\
291            ' All rights reserved.<BR>\n'\
292            'Copyright (c) 2007 - 2010, FOO2 Corporation.'\
293            ' All rights reserved.<BR>'
294        self.assertEqual(Copyright, ExpectedCopyright)
295
296        ExpectedLicense = \
297            'License'
298        self.assertEqual(License, ExpectedLicense)
299
300    #
301    # Normal case7: Abstract not present
302    #
303    def testNormalCase7(self):
304        TestCommentLines = \
305        '''
306        ## @file
307        #
308        # Description
309        #
310        # Copyright (c) 2007 - 2010, Intel Corporation. All rights reserved.<BR>
311        # Copyright (c) 2007 - 2010, FOO1 Corporation. All rights reserved.<BR>
312        # Copyright (c) 2007 - 2010, FOO2 Corporation. All rights reserved.<BR>
313        #
314        # License
315        #
316        ##'''
317
318        CommentList = GetSplitValueList(TestCommentLines, "\n")
319        LineNum = 0
320        TestCommentLinesList = []
321        for Comment in CommentList:
322            LineNum += 1
323            TestCommentLinesList.append((Comment, LineNum))
324
325        Abstract, Description, Copyright, License = \
326            ParseHeaderCommentSection(TestCommentLinesList, "PhonyFile")
327
328        ExpectedAbstract = ''
329        self.assertEqual(Abstract, ExpectedAbstract)
330
331        ExpectedDescription = 'Description'
332        self.assertEqual(Description, ExpectedDescription)
333
334        ExpectedCopyright = \
335            'Copyright (c) 2007 - 2010, Intel Corporation.'\
336            ' All rights reserved.<BR>\n'\
337            'Copyright (c) 2007 - 2010, FOO1 Corporation.'\
338            ' All rights reserved.<BR>\n'\
339            'Copyright (c) 2007 - 2010, FOO2 Corporation.'\
340            ' All rights reserved.<BR>'
341        self.assertEqual(Copyright, ExpectedCopyright)
342
343        ExpectedLicense = \
344            'License'
345        self.assertEqual(License, ExpectedLicense)
346
347    #
348    # Normal case8: Description not present
349    #
350    def testNormalCase8(self):
351        TestCommentLines = \
352        '''
353        ## @file
354        # Abstact
355        #
356        # Copyright (c) 2007 - 2010, Intel Corporation. All rights reserved.<BR>
357        #
358        # License
359        #
360        ##'''
361
362        CommentList = GetSplitValueList(TestCommentLines, "\n")
363        LineNum = 0
364        TestCommentLinesList = []
365        for Comment in CommentList:
366            LineNum += 1
367            TestCommentLinesList.append((Comment, LineNum))
368
369        Abstract, Description, Copyright, License = \
370            ParseHeaderCommentSection(TestCommentLinesList, "PhonyFile")
371
372        ExpectedAbstract = 'Abstact'
373        self.assertEqual(Abstract, ExpectedAbstract)
374
375        ExpectedDescription = ''
376        self.assertEqual(Description, ExpectedDescription)
377
378        ExpectedCopyright = \
379            'Copyright (c) 2007 - 2010, Intel Corporation.'\
380            ' All rights reserved.<BR>'
381        self.assertEqual(Copyright, ExpectedCopyright)
382
383        ExpectedLicense = \
384            'License'
385        self.assertEqual(License, ExpectedLicense)
386
387    #
388    # Error case1: No copyright found
389    #
390    def testErrorCase1(self):
391        TestCommentLines = \
392        '''
393        ## @file
394        # Abstract
395        #
396        # Description
397        #
398        # License
399        #
400        ##'''
401
402        CommentList = GetSplitValueList(TestCommentLines, "\n")
403        LineNum = 0
404        TestCommentLinesList = []
405        for Comment in CommentList:
406            LineNum += 1
407            TestCommentLinesList.append((Comment, LineNum))
408
409        self.assertRaises(Logger.FatalError,
410                          ParseHeaderCommentSection,
411                          TestCommentLinesList,
412                          "PhonyFile")
413
414    #
415    # Error case2: non-empty non-comment lines passed in
416    #
417    def testErrorCase2(self):
418        TestCommentLines = \
419        '''
420        ## @file
421        # Abstract
422        #
423        this is invalid line
424        # Description
425        #
426        # Copyright (c) 2007 - 2010, Intel Corporation. All rights reserved.<BR>
427        # License
428        #
429        ##'''
430
431        CommentList = GetSplitValueList(TestCommentLines, "\n")
432        LineNum = 0
433        TestCommentLinesList = []
434        for Comment in CommentList:
435            LineNum += 1
436            TestCommentLinesList.append((Comment, LineNum))
437
438        self.assertRaises(Logger.FatalError,
439                          ParseHeaderCommentSection,
440                          TestCommentLinesList,
441                          "PhonyFile")
442
443#
444# Test ParseGenericComment
445#
446class ParseGenericCommentTest(unittest.TestCase):
447    def setUp(self):
448        pass
449
450    def tearDown(self):
451        pass
452
453    #
454    # Normal case1: one line of comment
455    #
456    def testNormalCase1(self):
457        TestCommentLines = \
458        '''# hello world'''
459
460        CommentList = GetSplitValueList(TestCommentLines, "\n")
461        LineNum = 0
462        TestCommentLinesList = []
463        for Comment in CommentList:
464            LineNum += 1
465            TestCommentLinesList.append((Comment, LineNum))
466
467        HelptxtObj = ParseGenericComment(TestCommentLinesList, 'testNormalCase1')
468        self.failIf(not HelptxtObj)
469        self.assertEqual(HelptxtObj.GetString(), 'hello world')
470        self.assertEqual(HelptxtObj.GetLang(), TAB_LANGUAGE_EN_US)
471
472    #
473    # Normal case2: multiple lines of comment
474    #
475    def testNormalCase2(self):
476        TestCommentLines = \
477        '''## hello world
478        # second line'''
479
480        CommentList = GetSplitValueList(TestCommentLines, "\n")
481        LineNum = 0
482        TestCommentLinesList = []
483        for Comment in CommentList:
484            LineNum += 1
485            TestCommentLinesList.append((Comment, LineNum))
486
487        HelptxtObj = ParseGenericComment(TestCommentLinesList, 'testNormalCase2')
488        self.failIf(not HelptxtObj)
489        self.assertEqual(HelptxtObj.GetString(),
490                         'hello world\n' + 'second line')
491        self.assertEqual(HelptxtObj.GetLang(), TAB_LANGUAGE_EN_US)
492
493    #
494    # Normal case3: multiple lines of comment, non comment lines will be skipped
495    #
496    def testNormalCase3(self):
497        TestCommentLines = \
498        '''## hello world
499        This is not comment line'''
500
501        CommentList = GetSplitValueList(TestCommentLines, "\n")
502        LineNum = 0
503        TestCommentLinesList = []
504        for Comment in CommentList:
505            LineNum += 1
506            TestCommentLinesList.append((Comment, LineNum))
507
508        HelptxtObj = ParseGenericComment(TestCommentLinesList, 'testNormalCase3')
509        self.failIf(not HelptxtObj)
510        self.assertEqual(HelptxtObj.GetString(),
511                         'hello world\n\n')
512        self.assertEqual(HelptxtObj.GetLang(), TAB_LANGUAGE_EN_US)
513
514#
515# Test ParseDecPcdGenericComment
516#
517class ParseDecPcdGenericCommentTest(unittest.TestCase):
518    def setUp(self):
519        pass
520
521    def tearDown(self):
522        pass
523
524    #
525    # Normal case1: comments with no special comment
526    #
527    def testNormalCase1(self):
528        TestCommentLines = \
529        '''## hello world
530        # second line'''
531
532        CommentList = GetSplitValueList(TestCommentLines, "\n")
533        LineNum = 0
534        TestCommentLinesList = []
535        for Comment in CommentList:
536            LineNum += 1
537            TestCommentLinesList.append((Comment, LineNum))
538
539        (HelpTxt, PcdErr) = \
540            ParseDecPcdGenericComment(TestCommentLinesList, 'testNormalCase1')
541        self.failIf(not HelpTxt)
542        self.failIf(PcdErr)
543        self.assertEqual(HelpTxt,
544                         'hello world\n' + 'second line')
545
546
547    #
548    # Normal case2: comments with valid list
549    #
550    def testNormalCase2(self):
551        TestCommentLines = \
552        '''## hello world
553        # second line
554        # @ValidList 1, 2, 3
555        # other line'''
556
557        CommentList = GetSplitValueList(TestCommentLines, "\n")
558        LineNum = 0
559        TestCommentLinesList = []
560        for Comment in CommentList:
561            LineNum += 1
562            TestCommentLinesList.append((Comment, LineNum))
563
564        (HelpTxt, PcdErr) = \
565            ParseDecPcdGenericComment(TestCommentLinesList, 'UnitTest')
566        self.failIf(not HelpTxt)
567        self.failIf(not PcdErr)
568        self.assertEqual(HelpTxt,
569                         'hello world\n' + 'second line\n' + 'other line')
570        ExpectedList = GetSplitValueList('1 2 3', TAB_SPACE_SPLIT)
571        ActualList = [item for item in \
572            GetSplitValueList(PcdErr.GetValidValue(), TAB_SPACE_SPLIT) if item]
573        self.assertEqual(ExpectedList, ActualList)
574        self.failIf(PcdErr.GetExpression())
575        self.failIf(PcdErr.GetValidValueRange())
576
577    #
578    # Normal case3: comments with valid range
579    #
580    def testNormalCase3(self):
581        TestCommentLines = \
582        '''## hello world
583        # second line
584        # @ValidRange LT 1 AND GT 2
585        # other line'''
586
587        CommentList = GetSplitValueList(TestCommentLines, "\n")
588        LineNum = 0
589        TestCommentLinesList = []
590        for Comment in CommentList:
591            LineNum += 1
592            TestCommentLinesList.append((Comment, LineNum))
593
594        (HelpTxt, PcdErr) = \
595            ParseDecPcdGenericComment(TestCommentLinesList, 'UnitTest')
596        self.failIf(not HelpTxt)
597        self.failIf(not PcdErr)
598        self.assertEqual(HelpTxt,
599                         'hello world\n' + 'second line\n' + 'other line')
600        self.assertEqual(PcdErr.GetValidValueRange().strip(), 'LT 1 AND GT 2')
601        self.failIf(PcdErr.GetExpression())
602        self.failIf(PcdErr.GetValidValue())
603
604    #
605    # Normal case4: comments with valid expression
606    #
607    def testNormalCase4(self):
608        TestCommentLines = \
609        '''## hello world
610        # second line
611        # @Expression LT 1 AND GT 2
612        # other line'''
613
614        CommentList = GetSplitValueList(TestCommentLines, "\n")
615        LineNum = 0
616        TestCommentLinesList = []
617        for Comment in CommentList:
618            LineNum += 1
619            TestCommentLinesList.append((Comment, LineNum))
620
621        (HelpTxt, PcdErr) = \
622            ParseDecPcdGenericComment(TestCommentLinesList, 'UnitTest')
623        self.failIf(not HelpTxt)
624        self.failIf(not PcdErr)
625        self.assertEqual(HelpTxt,
626                         'hello world\n' + 'second line\n' + 'other line')
627        self.assertEqual(PcdErr.GetExpression().strip(), 'LT 1 AND GT 2')
628        self.failIf(PcdErr.GetValidValueRange())
629        self.failIf(PcdErr.GetValidValue())
630
631    #
632    # Normal case5: comments with valid expression and no generic comment
633    #
634    def testNormalCase5(self):
635        TestCommentLines = \
636        '''# @Expression LT 1 AND GT 2'''
637
638        CommentList = GetSplitValueList(TestCommentLines, "\n")
639        LineNum = 0
640        TestCommentLinesList = []
641        for Comment in CommentList:
642            LineNum += 1
643            TestCommentLinesList.append((Comment, LineNum))
644
645        (HelpTxt, PcdErr) = \
646            ParseDecPcdGenericComment(TestCommentLinesList, 'UnitTest')
647        self.failIf(HelpTxt)
648        self.failIf(not PcdErr)
649        self.assertEqual(PcdErr.GetExpression().strip(), 'LT 1 AND GT 2')
650        self.failIf(PcdErr.GetValidValueRange())
651        self.failIf(PcdErr.GetValidValue())
652
653    #
654    # Normal case6: comments with only generic help text
655    #
656    def testNormalCase6(self):
657        TestCommentLines = \
658        '''#'''
659
660        CommentList = GetSplitValueList(TestCommentLines, "\n")
661        LineNum = 0
662        TestCommentLinesList = []
663        for Comment in CommentList:
664            LineNum += 1
665            TestCommentLinesList.append((Comment, LineNum))
666
667        (HelpTxt, PcdErr) = \
668            ParseDecPcdGenericComment(TestCommentLinesList, 'UnitTest')
669        self.assertEqual(HelpTxt, '\n')
670        self.failIf(PcdErr)
671
672
673
674    #
675    # Error case1: comments with both expression and valid list, use later
676    # ignore the former and with a warning message
677    #
678    def testErrorCase1(self):
679        TestCommentLines = \
680        '''## hello world
681        # second line
682        # @ValidList 1, 2, 3
683        # @Expression LT 1 AND GT 2
684        # other line'''
685
686        CommentList = GetSplitValueList(TestCommentLines, "\n")
687        LineNum = 0
688        TestCommentLinesList = []
689        for Comment in CommentList:
690            LineNum += 1
691            TestCommentLinesList.append((Comment, LineNum))
692
693        try:
694            ParseDecPcdGenericComment(TestCommentLinesList, 'UnitTest')
695        except Logger.FatalError:
696            pass
697
698#
699# Test ParseDecPcdTailComment
700#
701class ParseDecPcdTailCommentTest(unittest.TestCase):
702    def setUp(self):
703        pass
704
705    def tearDown(self):
706        pass
707
708    #
709    # Normal case1: comments with no SupModeList
710    #
711    def testNormalCase1(self):
712        TestCommentLines = \
713        '''## #hello world'''
714
715        CommentList = GetSplitValueList(TestCommentLines, "\n")
716        LineNum = 0
717        TestCommentLinesList = []
718        for Comment in CommentList:
719            LineNum += 1
720            TestCommentLinesList.append((Comment, LineNum))
721
722        (SupModeList, HelpStr) = \
723            ParseDecPcdTailComment(TestCommentLinesList, 'UnitTest')
724        self.failIf(not HelpStr)
725        self.failIf(SupModeList)
726        self.assertEqual(HelpStr,
727                         'hello world')
728
729    #
730    # Normal case2: comments with one SupMode
731    #
732    def testNormalCase2(self):
733        TestCommentLines = \
734        '''## BASE #hello world'''
735
736        CommentList = GetSplitValueList(TestCommentLines, "\n")
737        LineNum = 0
738        TestCommentLinesList = []
739        for Comment in CommentList:
740            LineNum += 1
741            TestCommentLinesList.append((Comment, LineNum))
742
743        (SupModeList, HelpStr) = \
744            ParseDecPcdTailComment(TestCommentLinesList, 'UnitTest')
745        self.failIf(not HelpStr)
746        self.failIf(not SupModeList)
747        self.assertEqual(HelpStr,
748                         'hello world')
749        self.assertEqual(SupModeList,
750                         ['BASE'])
751
752    #
753    # Normal case3: comments with more than one SupMode
754    #
755    def testNormalCase3(self):
756        TestCommentLines = \
757        '''## BASE  UEFI_APPLICATION #hello world'''
758
759        CommentList = GetSplitValueList(TestCommentLines, "\n")
760        LineNum = 0
761        TestCommentLinesList = []
762        for Comment in CommentList:
763            LineNum += 1
764            TestCommentLinesList.append((Comment, LineNum))
765
766        (SupModeList, HelpStr) = \
767            ParseDecPcdTailComment(TestCommentLinesList, 'UnitTest')
768        self.failIf(not HelpStr)
769        self.failIf(not SupModeList)
770        self.assertEqual(HelpStr,
771                         'hello world')
772        self.assertEqual(SupModeList,
773                         ['BASE', 'UEFI_APPLICATION'])
774
775    #
776    # Normal case4: comments with more than one SupMode, no help text
777    #
778    def testNormalCase4(self):
779        TestCommentLines = \
780        '''## BASE  UEFI_APPLICATION'''
781
782        CommentList = GetSplitValueList(TestCommentLines, "\n")
783        LineNum = 0
784        TestCommentLinesList = []
785        for Comment in CommentList:
786            LineNum += 1
787            TestCommentLinesList.append((Comment, LineNum))
788
789        (SupModeList, HelpStr) = \
790            ParseDecPcdTailComment(TestCommentLinesList, 'UnitTest')
791        self.failIf(HelpStr)
792        self.failIf(not SupModeList)
793        self.assertEqual(SupModeList,
794                         ['BASE', 'UEFI_APPLICATION'])
795
796    #
797    # Normal case5: general comments with no supModList, extract from real case
798    #
799    def testNormalCase5(self):
800        TestCommentLines = \
801        ''' # 1 = 128MB, 2 = 256MB, 3 = MAX'''
802
803        CommentList = GetSplitValueList(TestCommentLines, "\n")
804        LineNum = 0
805        TestCommentLinesList = []
806        for Comment in CommentList:
807            LineNum += 1
808            TestCommentLinesList.append((Comment, LineNum))
809
810        (SupModeList, HelpStr) = \
811            ParseDecPcdTailComment(TestCommentLinesList, 'UnitTest')
812        self.failIf(not HelpStr)
813        self.assertEqual(HelpStr,
814                         '1 = 128MB, 2 = 256MB, 3 = MAX')
815        self.failIf(SupModeList)
816
817
818    #
819    # Error case2: comments with supModList contains valid and invalid
820    # module type
821    #
822    def testErrorCase2(self):
823        TestCommentLines = \
824        '''## BASE INVALID_MODULE_TYPE #hello world'''
825
826        CommentList = GetSplitValueList(TestCommentLines, "\n")
827        LineNum = 0
828        TestCommentLinesList = []
829        for Comment in CommentList:
830            LineNum += 1
831            TestCommentLinesList.append((Comment, LineNum))
832
833        try:
834            ParseDecPcdTailComment(TestCommentLinesList, 'UnitTest')
835        except Logger.FatalError:
836            pass
837
838
839#
840# Test _IsCopyrightLine
841#
842class _IsCopyrightLineTest(unittest.TestCase):
843    def setUp(self):
844        pass
845
846    def tearDown(self):
847        pass
848
849    #
850    # Normal case
851    #
852    def testCase1(self):
853        Line = 'this is a copyright ( line'
854        Result = _IsCopyrightLine(Line)
855        self.failIf(not Result)
856
857    #
858    # Normal case
859    #
860    def testCase2(self):
861        Line = 'this is a Copyright ( line'
862        Result = _IsCopyrightLine(Line)
863        self.failIf(not Result)
864
865    #
866    # Normal case
867    #
868    def testCase3(self):
869        Line = 'this is not aCopyright ( line'
870        Result = _IsCopyrightLine(Line)
871        self.failIf(Result)
872
873    #
874    # Normal case
875    #
876    def testCase4(self):
877        Line = 'this is Copyright( line'
878        Result = _IsCopyrightLine(Line)
879        self.failIf(not Result)
880
881    #
882    # Normal case
883    #
884    def testCase5(self):
885        Line = 'this is Copyright         (line'
886        Result = _IsCopyrightLine(Line)
887        self.failIf(not Result)
888
889    #
890    # Normal case
891    #
892    def testCase6(self):
893        Line = 'this is not Copyright line'
894        Result = _IsCopyrightLine(Line)
895        self.failIf(Result)
896
897    #
898    # Normal case
899    #
900    def testCase7(self):
901        Line = 'Copyright (c) line'
902        Result = _IsCopyrightLine(Line)
903        self.failIf(not Result)
904
905    #
906    # Normal case
907    #
908    def testCase8(self):
909        Line = ' Copyright (c) line'
910        Result = _IsCopyrightLine(Line)
911        self.failIf(not Result)
912
913    #
914    # Normal case
915    #
916    def testCase9(self):
917        Line = 'not a Copyright '
918        Result = _IsCopyrightLine(Line)
919        self.failIf(Result)
920
921if __name__ == '__main__':
922    Logger.Initialize()
923    unittest.main()