"{ Encoding: utf8 }"

"

 COPYRIGHT (c) 2006 by eXept Software AG

	      All Rights Reserved

 This software is furnished under a license and may be used

 only in accordance with the terms of that license and with the

 inclusion of the above copyright notice.   This software may not

 be provided or otherwise made available to, or used by, any

 other person.  No title to or ownership of the software is

 hereby transferred.

"

"{ Package: 'stx:goodies/regression' }"

"{ NameSpace: RegressionTests }"

TestCase subclass:#ParserTests

	instanceVariableNames:'mockClass'

	classVariableNames:''

	poolDictionaries:''

	category:'tests-Regression-Compilers'

!

!ParserTests class methodsFor:'documentation'!

copyright

"

 COPYRIGHT (c) 2006 by eXept Software AG

	      All Rights Reserved

 This software is furnished under a license and may be used

 only in accordance with the terms of that license and with the

 inclusion of the above copyright notice.   This software may not

 be provided or otherwise made available to, or used by, any

 other person.  No title to or ownership of the software is

 hereby transferred.

"

! !

!ParserTests methodsFor:'accessing'!

mockClass

    ^ mockClass

!

mockClass:something

    mockClass := something.

!

parserClass

    ^Parser

    "Created: / 01-07-2010 / 11:53:34 / Jan Vrany <jan.vrany@fit.cvut.cz>"

    "Modified: / 01-07-2010 / 17:38:42 / Jan Vrany <jan.vrany@fit.cvut.cz>"

! !

!ParserTests methodsFor:'initialize / release'!

setUp

    "prepares the testing environment which consists of mock class instance

     for sample annotated methods"

    |testClass|

    Class withoutUpdatingChangesDo:[

        testClass := self class 

                    subclass:'AnnotationTestedClass'

                    classInstanceVariableNames:''

                    instanceVariableNames:''

                    classVariableNames:''

                    poolDictionaries:''.

    ].

    self mockClass:testClass.

    "Created: / 29-11-2009 / 20:52:00 / pp <Pavel.Pospichal@gmail.com>"

    "Modified: / 29-11-2009 / 22:09:27 / pp <Pavel.Pospichal@gmail.com>"

    "Modified: / 12-07-2010 / 09:33:21 / Jan Vrany <jan.vrany@fit.cvut.cz>"

!

tearDown

    "release allocated resources for testing environment"

    self mockClass: nil.

    "Created: / 29-11-2009 / 20:52:13 / pp <Pavel.Pospichal@gmail.com>"

    "Modified: / 29-11-2009 / 22:09:33 / pp <Pavel.Pospichal@gmail.com>"

! !

!ParserTests methodsFor:'smoke test'!

testParseAllMethods

    Smalltalk allClassesDo:[:cls |

        Transcript showCR:cls.

        cls instAndClassMethodsDo:[:mthd |

            Parser parseMethod:mthd source in:mthd mclass

        ]

    ].

    "Created: / 28-06-2011 / 22:23:43 / cg"

! !

!ParserTests methodsFor:'tests - annotations'!

testAnnotationWithArrayLiteral

    "Positive testing the structure of unknown annotation definition: the annotation with #(<array>) literal; see grammar"

    |parserState parseErrorOccured annotation arguments|

    " create method for annotation testing purpose "

    " the signal is raised by Parser2::ParseError>>raiseRequest but there is no way how to handle its signal"

    parseErrorOccured := false.

    self parserClass parseErrorSignal 

        handle:[:ex | 

            parseErrorOccured := true.

            ex proceed

        ]

        do:[

            parserState := self parserClass 

                        parseMethod:'annotationWithArrayLiteralExample <annotation: #(1 2 3 4)> |x| x:=1. ^x. '

                        in:mockClass.

        ].

     " check the parser result "

    self deny:parserState isNil.

    self deny:parserState = #Error.

    self assert:parserState hasError = false.

    self assert:parseErrorOccured = false.

     " find the annotations record in parser state "

    self deny:parserState annotations isNil.

    self assert:(parserState annotations size) = 1.

     " check the first annotation defined"

    annotation := parserState annotations at:1.

    self assert:(annotation size) = 2.

    self assert:(annotation at:1) = 'annotation:'.

    arguments := annotation at:2.

    self deny:arguments isNil.

    self assert:arguments size = 1.

    self assert:(arguments at:1) = #( 1 2 3 4 ).

    "Created: / 12-01-2010 / 13:43:19 / pp <Pavel.Pospichal@gmail.com>"

    "Modified: / 23-05-2019 / 09:28:41 / Claus Gittinger"

!

testAnnotationWithByteArrayLiteral

    "Positive testing the structure of unknown annotation definition: the annotation with #[<byte array>] literal; see grammar"

    |parserState parseErrorOccured annotation arguments|

    " create method for annotation testing purpose "

    " the signal is raised by Parser2::ParseError>>raiseRequest but there is no way how to handle its signal"

    parseErrorOccured := false.

    self parserClass parseErrorSignal 

        handle:[:ex | 

            parseErrorOccured := true.

            ex proceed

        ]

        do:[

            parserState := self parserClass 

                        parseMethod:'annotationWithByteArrayLiteralExample <annotation: #[64 128 192]> |x| x:=1. ^x. '

                        in:mockClass.

        ].

     " check the parser result "

    self deny:parserState isNil.

    self deny:parserState = #Error.

    self assert:parserState hasError = false.

    self assert:parseErrorOccured = false.

     " find the annotations record in parser state "

    self deny:parserState annotations isNil.

    self assert:(parserState annotations size) = 1.

     " check the first annotation defined"

    annotation := parserState annotations at:1.

    self assert:(annotation size) = 2.

    self assert:(annotation at:1) = 'annotation:'.

    arguments := annotation at:2.

    self deny:arguments isNil.

    self assert:arguments size = 1.

    self assert:(arguments at:1) = #[ 64 128 192 ].

    "Created: / 12-01-2010 / 13:35:36 / pp <Pavel.Pospichal@gmail.com>"

    "Modified: / 23-05-2019 / 09:28:45 / Claus Gittinger"

!

testAnnotationWithCharacterLiteral

    "Positive testing the structure of unknown annotation definition: the annotation with character literal; see grammar"

    |parserState parseErrorOccured annotation arguments|

    " create method for annotation testing purpose "

    " the signal is raised by Parser2::ParseError>>raiseRequest but there is no way how to handle its signal"

    parseErrorOccured := false.

    self parserClass parseErrorSignal 

        handle:[:ex | 

            parseErrorOccured := true.

            ex proceed

        ]

        do:[

            parserState := self parserClass 

                        parseMethod:'annotationWithCharacterLiteralExample <annotation: $A> |x| x:=1. ^x. '

                        in:mockClass.

        ].

     " check the parser result "

    self deny:parserState isNil.

    self deny:parserState = #Error.

    self assert:parserState hasError = false.

    self assert:parseErrorOccured = false.

     " find the annotations record in parser state "

    self deny:parserState annotations isNil.

    self assert:(parserState annotations size) = 1.

     " check the first annotation defined"

    annotation := parserState annotations at:1.

    self assert:(annotation size) = 2.

    self assert:(annotation at:1) = 'annotation:'.

    arguments := annotation at:2.

    self deny:arguments isNil.

    self assert:arguments size = 1.

    self assert:(arguments at:1) = $A.

    "Created: / 12-01-2010 / 13:20:37 / pp <Pavel.Pospichal@gmail.com>"

    "Modified: / 23-05-2019 / 09:28:48 / Claus Gittinger"

!

testAnnotationWithFalseLiteral

    "Positive testing the structure of unknown annotation definition: the annotation with false literal; see grammar"

    |parserState parseErrorOccured annotation arguments|

    " create method for annotation testing purpose "

    " the signal is raised by Parser2::ParseError>>raiseRequest but there is no way how to handle its signal"

    parseErrorOccured := false.

    self parserClass parseErrorSignal 

        handle:[:ex | 

            parseErrorOccured := true.

            ex proceed

        ]

        do:[

            parserState := self parserClass 

                        parseMethod:'annotationWithFalseLiteralExample <annotation: false> |x| x:=1. ^x. '

                        in:mockClass.

        ].

     " check the parser result "

    self deny:parserState isNil.

    self deny:parserState = #Error.

    self assert:parserState hasError = false.

    self assert:parseErrorOccured = false.

     " find the annotations record in parser state "

    self deny:parserState annotations isNil.

    self assert:(parserState annotations size) = 1.

     " check the first annotation defined"

    annotation := parserState annotations at:1.

    self assert:(annotation size) = 2.

    self assert:(annotation at:1) = 'annotation:'.

    arguments := annotation at:2.

    self deny:arguments isNil.

    self assert:arguments size = 1.

    self assert:(arguments at:1) = false.

    "Created: / 12-01-2010 / 13:13:26 / pp <Pavel.Pospichal@gmail.com>"

    "Modified: / 23-05-2019 / 09:28:50 / Claus Gittinger"

!

testAnnotationWithInvalidArgument

    "Negative testing the structure of unknown annotation definition: the annotation with the non-literal argument; see grammar"

    |parserState parseErrorOccured|

    " create method for annotation testing purpose "

    parseErrorOccured := false.

    self parserClass parseErrorSignal 

        handle:[:ex | 

            parseErrorOccured := true.

            ex proceed

        ]

        do:[

            parserState := self parserClass 

                        parseMethod:'annotationWithInvalidArgumentExample <annotation: annotation:> ^self.'

                        in:mockClass.

        ].

     " check the parser result "

    self deny:parserState isNil.

    self deny:parserState = #Error.

    self assert:parserState hasError = true.

    self assert:parseErrorOccured = true.

    "Created: / 12-01-2010 / 13:48:48 / pp <Pavel.Pospichal@gmail.com>"

    "Modified: / 23-05-2019 / 09:28:53 / Claus Gittinger"

!

testAnnotationWithInvalidContentFollowed

    "Negative testing the structure of unknown annotation definition: the annotation with valid argument followed by invalid content; see grammar"

    "Test Note: based on the previous parser behaviour this type of situation is not considered as serious,

     it's considered as ignorable, informing requester and proceeding execution"

    |parserState annotation arguments ignorableErrorOccured|

    ignorableErrorOccured := false.

     " create method for annotation testing purpose " " the signal is raised by Parser2::ParseError>>raiseRequest but there is no way how to handle its signal"

    self parserClass parseErrorSignal 

        handle:[:ex | 

            ignorableErrorOccured := true.

            ex proceed

        ]

        do:[

            parserState := self parserClass 

                        parseMethod:'annotationWithInvalidContentFollowedExample <annotation: #argument #argument> ^self.'

                        in:mockClass.

        ].

     " ignorable error should occured "

    self assert:ignorableErrorOccured = true.

     " check the parser result "

    self deny:parserState isNil.

    self deny:parserState = #Error.

     " find the annotation record in parser state "

    self deny:parserState annotations isNil.

    self assert:(parserState annotations size) = 1.

    annotation := parserState annotations at:1.

    self assert:(annotation size) = 2.

    self assert:(annotation at:1) = 'annotation:'.

    arguments := annotation at:2.

    self deny:arguments isNil.

    self assert:arguments size = 1.

    self assert:(arguments at:1) = #argument.

    "Created: / 12-01-2010 / 13:52:16 / pp <Pavel.Pospichal@gmail.com>"

!

testAnnotationWithKeywordLiteral

    "Positive testing the structure of unknown annotation definition: the annotation with #<keyword> literal; see grammar"

    |parserState parseErrorOccured annotation arguments|

    " create method for annotation testing purpose "

    " the signal is raised by Parser2::ParseError>>raiseRequest but there is no way how to handle its signal"

    parseErrorOccured := false.

    self parserClass parseErrorSignal 

        handle:[:ex | 

            parseErrorOccured := true.

            ex proceed

        ]

        do:[

            parserState := self parserClass 

                        parseMethod:'annotationWithKeywordLiteralExample <annotation: #equals:> |x| x:=1. ^x. '

                        in:mockClass.

        ].

     " check the parser result "

    self deny:parserState isNil.

    self deny:parserState = #Error.

    self assert:parserState hasError = false.

    self assert:parseErrorOccured = false.

     " find the annotations record in parser state "

    self deny:parserState annotations isNil.

    self assert:(parserState annotations size) = 1.

     " check the first annotation defined"

    annotation := parserState annotations at:1.

    self assert:(annotation size) = 2.

    self assert:(annotation at:1) = 'annotation:'.

    arguments := annotation at:2.

    self deny:arguments isNil.

    self assert:arguments size = 1.

    self assert:(arguments at:1) = #equals:.

    "Created: / 12-01-2010 / 13:30:47 / pp <Pavel.Pospichal@gmail.com>"

    "Modified: / 23-05-2019 / 09:28:56 / Claus Gittinger"

!

testAnnotationWithMultiKeywordLiteral

    "Positive testing the structure of unknown annotation definition: the annotation with #<multikeyword> literal; see grammar"

    |parserState parseErrorOccured annotation arguments|

    " create method for annotation testing purpose "

    " the signal is raised by Parser2::ParseError>>raiseRequest but there is no way how to handle its signal"

    parseErrorOccured := false.

    self parserClass parseErrorSignal 

        handle:[:ex | 

            parseErrorOccured := true.

            ex proceed

        ]

        do:[

            parserState := self parserClass 

                        parseMethod:'annotationWithMultiKeywordLiteralExample <annotation: #equals:from:> |x| x:=1. ^x. '

                        in:mockClass.

        ].

     " check the parser result "

    self deny:parserState isNil.

    self deny:parserState = #Error.

    self assert:parserState hasError = false.

    self assert:parseErrorOccured = false.

     " find the annotations record in parser state "

    self deny:parserState annotations isNil.

    self assert:(parserState annotations size) = 1.

     " check the first annotation defined"

    annotation := parserState annotations at:1.

    self assert:(annotation size) = 2.

    self assert:(annotation at:1) = 'annotation:'.

    arguments := annotation at:2.

    self deny:arguments isNil.

    self assert:arguments size = 1.

    self assert:(arguments at:1) = #equals:from:.

    "Created: / 12-01-2010 / 13:31:41 / pp <Pavel.Pospichal@gmail.com>"

    "Modified: / 23-05-2019 / 09:28:58 / Claus Gittinger"

!

testAnnotationWithNegativeNumberLiteral

    "Positive testing the structure of unknown annotation definition: the annotation with negative_number literal; see grammar"

    |parserState parseErrorOccured annotation arguments|

    " create method for annotation testing purpose "

    " the signal is raised by Parser2::ParseError>>raiseRequest but there is no way how to handle its signal"

    parseErrorOccured := false.

    self parserClass parseErrorSignal 

        handle:[:ex | 

            parseErrorOccured := true.

            ex proceed

        ]

        do:[

            parserState := self parserClass 

                        parseMethod:'annotationWithNegativeNumberLiteralExample <annotation: -123> |x| x:=1. ^x. '

                        in:mockClass.

        ].

     " check the parser result "

    self deny:parserState isNil.

    self deny:parserState = #Error.

    self assert:parserState hasError = false.

    self assert:parseErrorOccured = false.

     " find the annotations record in parser state "

    self deny:parserState annotations isNil.

    self assert:(parserState annotations size) = 1.

     " check the first annotation defined"

    annotation := parserState annotations at:1.

    self assert:(annotation size) = 2.

    self assert:(annotation at:1) = 'annotation:'.

    arguments := annotation at:2.

    self deny:arguments isNil.

    self assert:arguments size = 1.

    self assert:(arguments at:1) = -123.

    "Created: / 12-01-2010 / 13:18:46 / pp <Pavel.Pospichal@gmail.com>"

    "Modified: / 23-05-2019 / 09:29:01 / Claus Gittinger"

!

testAnnotationWithNilLiteral

    "Positive testing the structure of unknown annotation definition: the annotation with nil literal; see grammar"

    |parserState parseErrorOccured annotation arguments|

    " create method for annotation testing purpose "

    " the signal is raised by Parser2::ParseError>>raiseRequest but there is no way how to handle its signal"

    parseErrorOccured := false.

    self parserClass parseErrorSignal 

        handle:[:ex | 

            parseErrorOccured := true.

            ex proceed

        ]

        do:[

            parserState := self parserClass 

                        parseMethod:'annotationWithFalseLiteralExample <annotation: nil> |x| x:=1. ^x. '

                        in:mockClass.

        ].

     " check the parser result "

    self deny:parserState isNil.

    self deny:parserState = #Error.

    self assert:parserState hasError = false.

    self assert:parseErrorOccured = false.

     " find the annotations record in parser state "

    self deny:parserState annotations isNil.

    self assert:(parserState annotations size) = 1.

     " check the first annotation defined"

    annotation := parserState annotations at:1.

    self assert:(annotation size) = 2.

    self assert:(annotation at:1) = 'annotation:'.

    arguments := annotation at:2.

    self deny:arguments isNil.

    self assert:arguments size = 1.

    self assert:(arguments at:1) isNil.

    "Created: / 12-01-2010 / 13:13:59 / pp <Pavel.Pospichal@gmail.com>"

    "Modified: / 23-05-2019 / 09:29:04 / Claus Gittinger"

!

testAnnotationWithNumberLiteral

    "Positive testing the structure of unknown annotation definition: the annotation with number literal; see grammar"

    |parserState parseErrorOccured annotation arguments|

    " create method for annotation testing purpose "

    " the signal is raised by Parser2::ParseError>>raiseRequest but there is no way how to handle its signal"

    parseErrorOccured := false.

    self parserClass parseErrorSignal 

        handle:[:ex | 

            parseErrorOccured := true.

            ex proceed

        ]

        do:[

            parserState := self parserClass 

                        parseMethod:'annotationWithNumberLiteralExample <annotation: 123> |x| x:=1. ^x. '

                        in:mockClass.

        ].

     " check the parser result "

    self deny:parserState isNil.

    self deny:parserState = #Error.

    self assert:parserState hasError = false.

    self assert:parseErrorOccured = false.

     " find the annotations record in parser state "

    self deny:parserState annotations isNil.

    self assert:(parserState annotations size) = 1.

     " check the first annotation defined"

    annotation := parserState annotations at:1.

    self assert:(annotation size) = 2.

    self assert:(annotation at:1) = 'annotation:'.

    arguments := annotation at:2.

    self deny:arguments isNil.

    self assert:arguments size = 1.

    self assert:(arguments at:1) = 123.

    "Created: / 12-01-2010 / 13:18:15 / pp <Pavel.Pospichal@gmail.com>"

    "Modified: / 23-05-2019 / 09:29:06 / Claus Gittinger"

!

testAnnotationWithStringLiteral

    "Positive testing the structure of unknown annotation definition: the annotation with string literal; see grammar"

    |parserState parseErrorOccured annotation arguments|