"{ Package: 'stx:goodies/petitparser/compiler/tests' }"

PPAbstractParserTest subclass:#PPCCompilerTest

	instanceVariableNames:'parser result context'

	classVariableNames:''

	poolDictionaries:''

	category:'PetitCompiler-Tests-Core'

!

!PPCCompilerTest methodsFor:'context'!

context	

	^ context := PPCProfilingContext new

! !

!PPCCompilerTest methodsFor:'running'!

tearDown

    | parserClass |

    parserClass := (Smalltalk at: #PPGeneratedParser).

    parserClass notNil ifTrue:[ 

        parserClass removeFromSystem

    ].

    "Created: / 30-10-2014 / 22:56:19 / Jan Vrany <jan.vrany@fit.cvut.cz>"

! !

!PPCCompilerTest methodsFor:'test support'!

assert: p parse: whatever

	^ result := super assert: p parse: whatever.

!

compile: aPPParser

	| compiler |

	compiler := PPCCompiler new.

	compiler profile: true.

	^ (compiler compile: aPPParser as: #PPGeneratedParser) new.

!

compile: aPPParser params: params

	| compiler |

	compiler := PPCCompiler new.

	compiler profile: true.

	^ (compiler compile: aPPParser as: #PPGeneratedParser params: params) new.

!

compileInlining: aPPParser

	| compiler |

	compiler := PPCCompiler new.

	compiler inlining: true.

	compiler profile: true.

	^ (compiler compile: aPPParser as: #PPGeneratedParser) new.

!

compileTree: tree params: params

	| compiler mock |

	compiler := PPCCompiler new.

	compiler profile: true.

	mock := nil asParser.

	^ (compiler compileTree: tree as: #PPGeneratedParser parser: mock params: params) new.

!

parse: whatever

	^ result := super parse: whatever.

! !

!PPCCompilerTest methodsFor:'tests - compiling'!

testCompileAnd

	parser := #digit asParser and compile.

	self assert: parser parse: '1' to: $1 end: 0.

	self assert: parser fail: 'a'.

	self assert: parser fail: ''.

	parser := ('foo' asParser, ($: asParser and)) compile.

	self assert: parser parse: 'foo:' to: { 'foo'. $: } end: 3.

!

testCompileAny

	parser := #any asParser compile.

	self assert: parser parse: 'a' to: $a.

	self assert: parser parse: '_' to: $_.

	self assert: parser parse: '

' to: Character cr.

!

testCompileAnyStar

	parser := #any asParser star compile.

	self assert: parser parse: 'aaa' to: { $a. $a . $a }.

	self assert: parser parse: '' to: { }.

!

testCompileBlock

	parser := (#letter asParser) plus ==> [ :res | res collect: [:each | each asUppercase ]].

	parser := parser compile.

	self assert: parser parse: 'foo' to: { $F . $O . $O}.

	self assert: parser parse: 'bar' to: { $B . $A . $R}.

	self assert: parser fail: ''.

!

testCompileCharacter

	parser := $a asParser compile.

	self assert: parser parse: 'a'  to: $a.

	self assert: parser fail: 'b'.

	parser := $# asParser compile.

	self assert: parser parse: '#'.

!

testCompileChoice

	parser := (#digit asParser / #letter asParser) compile.

	self assert: parser parse: '1' to: $1.

	self assert: parser parse: 'a' to: $a.

	self assert: parser fail: '_'.

!

testCompileLiteral

	parser := 'foo' asParser compile.

	self assert: parser parse: 'foo'  to: 'foo'.

	self assert: parser parse: 'foobar'  to: 'foo' end: 3.

	self assert: parser fail: 'boo'.

	parser := '#[' asParser compile.

	self assert: parser parse: '#[1]' to: '#[' end: 2.

!

testCompileLiteral2

	| quote |

	quote := '''' asParser.

	parser := (quote, $a asParser )compile: #PPCompilerTest.	

	self assert: parser parse: '''a'  to: {'''' . $a}.	

!

testCompileNegate

	parser := #letter asParser negate star, #letter asParser.

	parser := parser compile.

	self assert: parser parse: '...a' to: { { $. . $. . $. } . $a }.

	self assert: parser parse: 'aaa' to: { {} . $a } end: 1.

	self assert: parser fail: '...'.

!

testCompileNil

	parser := nil asParser compile.

	self assert: parser parse: 'a' to: nil end: 0.

	self assert: parser parse: '' to: nil end: 0.

	parser := nil asParser, 'foo' asParser.

	self assert: parser parse: 'foo' to: { nil . 'foo' }

!

testCompileNot

	parser := #digit asParser not compile.

	self assert: parser parse: 'a' to: nil end: 0.

	self assert: parser fail: '1'.

	self assert: parser parse: '' to: nil end: 0.

	parser := 'foo' asParser, $: asParser not.

	parser := parser compile: #PPCompilerTest.	

	self assert: parser parse: 'foo' to: { 'foo'. nil } end: 3.

	parser := 'foo' asParser, $: asParser not, 'bar' asParser.

	parser := parser compile: #PPCompilerTest.	

	self assert: parser parse: 'foobar' to: { 'foo'. nil . 'bar' } end: 6.

!

testCompileNot2

	parser := ($a asParser, $b asParser) not compile.

	self assert: parser parse: '' to: nil end: 0.

	self assert: parser parse: 'a' to: nil end: 0.

	self assert: parser parse: 'aa' to: nil end: 0.

	self assert: parser fail: 'ab'.

!

testCompileNot3

	parser := ('foo' asParser not, 'fee' asParser) compile.

	self assert: parser parse: 'fee' to: #(nil 'fee').

	self assert: parser fail: 'foo'.

!

testCompileNotLiteral

!

testCompileOptional

	parser := #digit asParser optional compile.

	self assert: parser parse: '1' to: $1.

	self assert: parser parse: 'a' to: nil end: 0.

	self assert: parser class parsers isEmpty.

	parser := (#digit asParser optional, #letter asParser) compile.

	self assert: parser parse: '1a' to: { $1 . $a }.

	self assert: parser parse: 'a' to: { nil . $a }.

	self assert: parser class parsers isEmpty.

!

testCompilePlus

	parser := #letter asParser plus compile: #PPCompilerTest.

	self assert: parser parse: 'lorem' to: {$l. $o. $r. $e. $m} .

	self assert: parser parse: 'a123' to: {$a} end: 1.

	self assert: parser parse: 'ab123' to: {$a . $b} end: 2.

	self assert: parser fail: ''.

	self assert: parser fail: '123'.

!

testCompilePredicate

	parser := #digit asParser compile.

	self assert: parser parse: '1' to: $1.

	self assert: parser parse: '0' to: $0.

	self assert: parser fail: 'a'.

!

testCompilePredicate2

	parser := #space asParser compile.

	self assert: parser parse: ' ' to: Character space.

	self assert: parser fail: 'a'.

!

testCompileSequence

	parser := (#digit asParser, #letter asParser) compile.

	self assert: parser parse: '1a' to: {$1 .$a}.

!

testCompileSequence2

	parser := (#digit asParser, #space asParser, #letter asParser) compile: #PPCompilerTest.

	self assert: parser parse: '9 c' to: {$9 . Character space. $c }.	

	self assert: parser fail: '9c'.

!

testCompileSequence3

	parser := (#any asParser, #any asParser, #any asParser) compile.

	self assert: parser parse: 'foo' to: #($f $o $o).	

	self assert: parser fail: 'fo'.

!

testCompileStar

	parser := #letter asParser star compile.

	self assert: parser parse: 'lorem' to: {$l. $o. $r. $e. $m} .

	self assert: parser parse: '' to: {}.

	self assert: parser parse: '123' to: {} end: 0.

	self assert: parser parse: 'ab123' to: {$a . $b} end: 2.

!

testCompileStarLiteral

	parser := 'foo' asParser star compile.

	self assert: parser parse: 'foo' to: #('foo' ) .

	self assert: parser parse: 'foofoo' to: #('foo' 'foo') .

	self assert: parser parse: 'foofoofoo' to: #('foo' 'foo' 'foo') .

	self assert: parser parse: '' to: #().

	self assert: parser parse: 'bar' to: #() end: 0.

!

testCompileStarPredicate

	parser := #letter asParser star compile.

	self assert: parser parse: 'foo' to: #($f $o $o ) .

	self assert: parser parse: '' to: #().

	self assert: parser parse: '123' to: #() end: 0.

!

testCompileSymbolBlock

	parser := (#letter asParser) plus ==> #second.

	parser := parser compile: #PPCompilerTest.

	self assert: parser parse: 'foo' to: $o.

	self assert: parser parse: 'bar' to: $a.

	self assert: parser fail: ''.

	self should: [ parser parse: 'f' ] raise: Error.

!

testTrim

	parser := self compile: $a asParser trim.

	self assert: parser fail: ''.

	self assert: parser parse: 'a' to: $a.

	self assert: parser parse: '   a' to: $a.

	self assert: parser parse: 'a    ' to: $a.

	self assert: parser parse: '  a    ' to: $a.

! !

!PPCCompilerTest methodsFor:'tests - extra'!

testCompileSmalltalkToken

	parser := (#letter asParser, ((#letter asParser / #digit asParser) star)) smalltalkToken compile.

	self assert: parser parse: 'foo'.

	self assert: result inputValue = 'foo'.

	self assert: parser parse: 'a'.

	self assert: result inputValue = 'a'.

	self assert: parser parse: 'f123a'.

	self assert: result inputValue = 'f123a'.

	self assert: parser fail: ''.

	self assert: parser fail: '12'.

	self assert: parser parse: ' "comment" foo'.

	self assert: result inputValue = 'foo'.

	self assert: parser parse: ' "comment" bar "another comment" '.

	self assert: result inputValue = 'bar'.

	self assert: parser parse: '

		"b"

		"b"

		foo

		"and yet, another comment"

		"one more to make sure :)"

	'.

	self assert: result inputValue = 'foo'.

!

testCycle

	| p1 block |

	p1 := PPDelegateParser new.

	block := ${ asParser, p1, $} asParser / nil asParser.

	p1 setParser: block.

	parser := block compile: #PPCompilerTest.

	self assert: parser parse: '{}' to: { ${. nil . $} }.

	self assert: parser parse: '{{}}' to: { ${. { ${ . nil . $} } . $} }.

!

testGuardSmalltlakToken

	| charSet |

	charSet := PPCCompiler new guardCharSet: 'foo' asParser smalltalkToken.

	self assert: (charSet equals: (PPCharSetPredicate on: [ :char | char = $f ])).

	parser := (#letter asParser, #word asParser star) smalltalkToken compileWithParameters: { #profile -> true }.

	self assert: parser parse: 'bar'.

	self assert: (context invocations anySatisfy: [ :e | e beginsWith: 'seq' ]).

	self assert: parser fail: '123'.

	self assert: (context invocations noneSatisfy: [ :e | e beginsWith: 'seq' ]).

!

testSmalltalkToken

!

testSmalltalkToken2

	|id|

	id := (#letter asParser, (#digit asParser / #letter asParser) star)

		name: 'identifier';

		yourself.

	parser := (id, $: asParser) smalltalkToken 

		name: 'kw';

		yourself.

	parser := parser compileWithParameters: {#profile -> true}.

	self assert: parser parse: 'foo:'.

	self assert: result inputValue = 'foo:'.

!

testToken

	parser := (#letter asParser, (#digit asParser / #letter asParser) star) flatten compile.

	self assert: parser parse: 'foo' to: 'foo'.

	self assert: parser parse: 'a' to: 'a'.

	self assert: parser parse: 'f123a' to: 'f123a'.

	self assert: parser fail: ''.

!

testToken2

!

testTrimmingToken

! !

!PPCCompilerTest methodsFor:'tests - first set'!

testFirstSetSuchThat

	| a b fs at |

	a := $a asParser.

	at := a trim.

	b := $b asParser.

	parser := b optional, at.

	fs :=	parser firstSetSuchThat: [ :e | (e isKindOf: PPTrimmingParser) or: [ e isTerminal  ] ].

	self assert: (fs anySatisfy: [ :e | e = at ]).

	self assert: (fs anySatisfy: [ :e | e = b ]).

	self assert: (fs noneSatisfy: [ :e | e = a ]).	

!

testFirstSetSuchThat2

	| a b fs at bt |

	a := $a asParser optional.

	at := a trim.

	b := $b asParser.

	bt := b trim.

	parser := at, bt.

	fs :=	parser firstSetSuchThat: [ :e | (e isKindOf: PPTrimmingParser) or: [ e isTerminal  ] ].

	self assert: (fs anySatisfy: [ :e | e = at ]).

	self assert: (fs anySatisfy: [ :e | e = bt ]).

	self assert: fs size = 2.

!

testFirstSetSuchThat3

	| a b c fs at bt ct |

	a := $a asParser optional.

	at := a trim.

	b := $b asParser.

	bt := b trim.

	c := $c asParser.

	ct := c trim.

	parser := (at, bt optional) wrapped, at, ct.

	fs :=	parser firstSetSuchThat: [ :e | (e isKindOf: PPTrimmingParser) or: [ e isTerminal  ] ].

	self assert: (fs anySatisfy: [ :e | e = at ]).

	self assert: (fs anySatisfy: [ :e | e = bt ]).

	self assert: (fs anySatisfy: [ :e | e = ct ]).

	self assert: fs size = 3.

! !

!PPCCompilerTest methodsFor:'tests - guard'!