<?php
/**
 *
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 * 
 *   http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 *
 * @license http://www.apache.org/licenses/LICENSE-2.0 Apache License, Version 2.0
 * @version //autogentag//
 * @filesource
 * @package Template
 * @subpackage Tests
 */

require_once "invariant_parse_cursor.php";

/**
 * @package Template
 * @subpackage Tests
 */
class ezcTemplateSourceToTstParserTest extends ezcTestCase
{
    public static function suite()
    {
         return new PHPUnit_Framework_TestSuite( __CLASS__ );
    }

    /**
     * Returns a constraint which checks if the input path exist on the filesystem.
     *
     * @return ezcMockFileExistsConstraint
     */
    static public function existsOnDisk()
    {
        return new ezcMockFileExistsConstraint();
    }

    protected function setUp()
    {
        // // required because of Reflection autoload bug
        class_exists( 'ezcTemplateSourceCode' );
        // class_exists( 'ezcTemplateManager' );
        $this->manager = new ezcTemplateManager();
        PHPUnit_Extensions_MockObject_Mock::generate( 'ezcTemplateParser', array( "reportElementCursor" ), 'MockElement_ezcTemplateParser' );

        $this->basePath = realpath( dirname( __FILE__ ) ) . '/';
        $this->templatePath = $this->basePath . 'templates/';
        $this->templateCompiledPath = $this->basePath . 'compiled/';
        $this->templateStorePath = $this->basePath . 'stored_templates/';
    }

    /**
     * Test parsing template code which does not contain any blocks.
     */
    public function testParsingTextElements()
    {
        $text = "abc def \nshow widget";
        $source = new ezcTemplateSourceCode( 'mock', 'mock', $text );
        $parser = new MockElement_ezcTemplateParser( $source, $this->manager );

        $items = array( array( 0, 1, 0,  20, 2, 11,  'TextBlock' ) );

        $this->setupExpectedPositions( $parser, $text, $source, $items );

        $program = $parser->parseIntoNodeTree();

        if ( $parser->debug )
            echo ezcTemplateTstTreeOutput::output( $program ), "\n";

        $parser->verify();
    }

    /**
     * Test parsing template code which has a block with a missing end bracket.
     */
    public function testParsingBlockWithMissingBracketReportsError()
    {
        $text = "abc def \n{show widget";
        $source = new ezcTemplateSourceCode( 'mock', 'mock', $text );
        $parser = new MockElement_ezcTemplateParser( $source, $this->manager );

        $items = array( array( 0, 1, 0,  9, 2, 0,  'TextBlock' ) );

        $this->setupExpectedPositions( $parser, $text, $source, $items );

        try
        {
            $program = $parser->parseIntoNodeTree();
            self::fail( "No parse exception thrown" );
        }
        catch ( ezcTemplateSourceToTstParserException $e )
        {
        }

        $parser->verify();
    }

    /**
     * Test parsing template code contain all comment types.
     */
    public function testParsingAllCommentTypes()
    {
        self::assertThat( $this->templatePath . "comments_test.tpl", self::existsOnDisk() );

        $text = file_get_contents( $this->templatePath . "comments_test.tpl" );
        // $text = "abc def \n{show /*inside comment*/widget\n$w // eol comment\n}";
        $source = new ezcTemplateSourceCode( 'mock', 'mock', $text );
        $parser = new MockElement_ezcTemplateParser( $source, $this->manager );

        if ( $parser->debug )
            echo "\ncomments_test.tpl\n";

        $items = array( array( 'TextBlock' ),

                        array( 'DocComment', 'commentText', ' Documentation block ' ),

                        array( 'TextBlock' ),

                        array( 'Literal' ),
                        array( 'BlockComment', 'commentText', 'inside comment' ),
                        array( 'PlusOperator' ),
                        array( 'EolComment', 'commentText', 'eol comment' ),
                        array( 'Literal' ),
                        array( 'OutputBlock' ),

                        array( 'TextBlock' ),

                        array( 'Literal' ),
                        array( 'EolComment', 'commentText', 'eol comment #2' ),
                        array( 'OutputBlock' ) );

        $this->setupExpectedElements( $parser, $text, $source, $items );

        $program = $parser->parseIntoNodeTree();

        if ( $parser->debug )
            echo ezcTemplateTstTreeOutput::output( $program ), "\n";

        $parser->verify();
    }

    /**
     * Test parsing template code containing all builtin types except arrays.
     */
    public function testParseLiteralTypesExpression()
    {
        self::assertThat( $this->templatePath . "expression_types_test.tpl", self::existsOnDisk() );

        $text = file_get_contents( $this->templatePath . "expression_types_test.tpl" );
        // echo "\nexpression_types_test.tpl\n";
        $source = new ezcTemplateSourceCode( 'mock', 'mock', $text );
        $parser = new MockElement_ezcTemplateParser( $source, $this->manager );

        if ( $parser->debug )
            echo "\nexpression_types_test.tpl\n";

        $items = array( array( 'Literal', 'value', 1 ),
                        array( 'OutputBlock' ),

                        array( 'TextBlock' ),
                        array( 'Literal', 'value', 42 ),
                        array( 'OutputBlock' ),

                        array( 'TextBlock' ),
                        array( 'Literal', 'value', -1234 ),
                        array( 'OutputBlock' ),

                        array( 'TextBlock' ),
                        array( 'Literal', 'value', 1.0 ),
                        array( 'OutputBlock' ),

                        array( 'TextBlock' ),
                        array( 'Literal', 'value', -4.2 ),
                        array( 'OutputBlock' ),

                        array( 'TextBlock' ),
                        array( 'Literal', 'value', 0.5 ),
                        array( 'OutputBlock' ),

                        array( 'TextBlock' ),
                        array( 'Literal', 'value', "1" ),
                        array( 'OutputBlock' ),

                        array( 'TextBlock' ),
                        array( 'Literal', 'value', "a short string" ),
                        array( 'OutputBlock' ),

                        array( 'TextBlock' ),
                        array( 'Literal', 'value', "a short \"quoted\" string" ),
                        array( 'OutputBlock' ),

                        array( 'TextBlock' ),
                        array( 'Literal', 'value', "1" ),
                        array( 'OutputBlock' ),

                        array( 'TextBlock' ),
                        array( 'Literal', 'value', "a short string" ),
                        array( 'OutputBlock' ),

                        array( 'TextBlock' ),
                        array( 'Literal', 'value', "a short \'quoted\' string" ),
                        array( 'OutputBlock' ),

                        array( 'TextBlock' ),
                        array( 'Literal', 'value', true ),
                        array( 'OutputBlock' ),

                        array( 'TextBlock' ),
                        array( 'Literal', 'value', false ),
                        array( 'OutputBlock' ) );

        $this->setupExpectedElements( $parser, $text, $source, $items );

        $program = $parser->parseIntoNodeTree();

        if ( $parser->debug )
            echo ezcTemplateTstTreeOutput::output( $program ), "\n";

        $parser->verify();
    }

    /**
     * Test parsing template code containing array types.
     * @todo This currently fails, remove return statement when it is fixed.
     */
    public function testParsingArrayExpression()
    {
        self::assertThat( $this->templatePath . "expression_array_types_test.tpl", self::existsOnDisk() );

        $text = file_get_contents( $this->templatePath . "expression_array_types_test.tpl" );
        $source = new ezcTemplateSourceCode( 'mock', 'mock', $text );
        $parser = new MockElement_ezcTemplateParser( $source, $this->manager );

        if ( $parser->debug )
            echo "\nexpression_array_types_test.tpl\n";

        $items = array( array( 'Literal', 'value', array() ),
                        array( 'OutputBlock' ) );

        $items_array1 = array( array( 'TextBlock' ),
                               array( 'Literal', 'value', 1 ),
                               array( 'Literal', 'value', 2 ),
                               array( 'Literal', 'value', 3 ),
                               array( 'Literal', 'value', array( 1, 2, 3 ) ),
                               array( 'OutputBlock' ) );

        $items = array_merge( $items,
                              $items_array1, $items_array1, $items_array1 );

        $items_array2 = array( array( 'TextBlock' ),
                               array( 'Literal', 'value', 0 ),
                               array( 'Literal', 'value', 1 ),
                               array( 'Literal', 'value', 1 ),
                               array( 'Literal', 'value', 2 ),
                               array( 'Literal', 'value', 2 ),
                               array( 'Literal', 'value', 3 ),
                               array( 'Literal', 'value', array( 0 => 1, 1 => 2, 2 => 3 ) ),
                               array( 'OutputBlock' ) );

        $items = array_merge( $items,
                              $items_array2, $items_array2, $items_array2 );

        $items_array3 = array( array( 'TextBlock' ),
                               array( 'Literal', 'value', "abc" ),
                               array( 'Literal', 'value', "def" ),
                               array( 'Literal', 'value', "foo" ),
                               array( 'Literal', 'value', "bar" ),
                               array( 'Literal', 'value', 5 ),
                               array( 'Literal', 'value', "el1" ),
                               array( 'Literal', 'value', "key1" ),
                               array( 'Literal', 'value', -50 ),
                               array( 'Literal', 'value', array( "abc" => "def", "foo" => "bar", 5 => "el1", "key1" => -50 ) ),
                               array( 'OutputBlock' ) );

        $items = array_merge( $items,
                              $items_array3, $items_array3, $items_array3 );

        $items_array4 = array( array( 'TextBlock' ),
                               array( 'Literal', 'value', 3 ),
                               array( 'Literal', 'value', array( 3 ) ),
                               array( 'Literal', 'value', 2 ),
                               array( 'Literal', 'value', array( array( 3 ), 2 ) ),
                               array( 'Literal', 'value', 1 ),
                               array( 'Literal', 'value', array( array( array( 3 ), 2 ), 1  ) ),
                               array( 'OutputBlock' ) );

        $items = array_merge( $items,
                              $items_array4 );

        $this->setupExpectedElements( $parser, $text, $source, $items );

        $program = $parser->parseIntoNodeTree();

        if ( $parser->debug )
            echo ezcTemplateTstTreeOutput::output( $program ), "\n";

        $parser->verify();
    }

    /**
     * Test parsing template code containing variable statements.
     */
    public function testParsingVariablesExpression()
    {
        self::assertThat( $this->templatePath . "expression_variables_test.tpl", self::existsOnDisk() );

        $text = file_get_contents( $this->templatePath . "expression_variables_test.tpl" );
        $source = new ezcTemplateSourceCode( 'mock', 'mock', $text );
        $parser = new MockElement_ezcTemplateParser( $source, $this->manager );

        if ( $parser->debug )
            echo "\nexpression_variables_test.tpl\n";

        $items = array( array( 'Literal', 'value', 'var' ),
                        array( 'Variable', 'name', 'var' ),
                        array( 'OutputBlock' ),

                        array( 'TextBlock' ),
                        array( 'Literal', 'value', 'varName' ),
                        array( 'Variable', 'name', 'varName' ),
                        array( 'OutputBlock' ),

                        array( 'TextBlock' ),
                        array( 'Literal', 'value', 'var_name' ),
                        array( 'Variable', 'name', 'var_name' ),
                        array( 'OutputBlock' ),

                        array( 'TextBlock' ),
                        array( 'Literal', 'value', 'var_0_name' ),
                        array( 'Variable', 'name', 'var_0_name' ),
                        array( 'OutputBlock' ) );

        $this->setupExpectedElements( $parser, $text, $source, $items );

        $program = $parser->parseIntoNodeTree();

        if ( $parser->debug )
            echo ezcTemplateTstTreeOutput::output( $program ), "\n";

        $parser->verify();
    }

    /**
     * Test parsing template code containing operators expressions.
     */
    public function testParsingOperatorExpression()
    {
        self::assertThat( $this->templatePath . "expression_test.tpl", self::existsOnDisk() );

        $text = file_get_contents( $this->templatePath . "expression_test.tpl" );
        $source = new ezcTemplateSourceCode( 'mock', 'mock', $text );
        $parser = new MockElement_ezcTemplateParser( $source, $this->manager );

        if ( $parser->debug )
            echo "\nexpression_test.tpl\n";

        $items = array( array( 'Literal', 'value', 'item' ),
                        array( 'Variable', 'name', 'item' ),
                        array( 'PropertyFetchOperator' ),
                        array( 'Literal', 'value', 'prop1' ),
                        array( 'OutputBlock' ),

                        array( 'TextBlock' ),
                        array( 'Literal', 'value', 'item' ),
                        array( 'Variable', 'name', 'item' ),
                        array( 'PropertyFetchOperator' ),
                        array( 'Literal', 'value', 0 ),
                        array( 'OutputBlock' ), // index 10

                        array( 'TextBlock' ),
                        array( 'Literal', 'value', 'item' ),
                        array( 'Variable', 'name', 'item' ),
                        array( 'Literal', 'value', 'prop1' ),
                        array( 'ArrayFetchOperator' ),
                        array( 'OutputBlock' ),

                        array( 'TextBlock' ),
                        array( 'Literal', 'value', 'item' ),
                        array( 'Variable', 'name', 'item' ),
                        array( 'Literal', 'value', 0 ), // index 20
                        array( 'ArrayFetchOperator' ),
                        array( 'OutputBlock' ),

                        array( 'TextBlock' ),
                        array( 'Literal', 'value', 'item' ),
                        array( 'Variable', 'name', 'item' ),
                        array( 'Literal', 'value', 42 ),
                        array( 'ArrayFetchOperator' ),
                        array( 'PropertyFetchOperator' ),
                        array( 'Literal', 'value', 'subitem' ),
                        array( 'Literal', 'value', "test" ), // index 30
                        array( 'ArrayFetchOperator' ),
                        array( 'OutputBlock' ),

                        array( 'TextBlock' ),
                        array( 'Literal', 'value', 1 ),
                        array( 'PlusOperator' ),
                        array( 'Literal', 'value', 2 ),
                        array( 'OutputBlock' ),

                        array( 'TextBlock' ),
                        array( 'Literal', 'value', 1 ),
                        array( 'MultiplicationOperator' ), // index 40
                        array( 'Literal', 'value', 2 ),
                        array( 'PlusOperator' ),
                        array( 'Literal', 'value', 3 ),
                        array( 'OutputBlock' ),

                        array( 'TextBlock' ),
                        array( 'Literal', 'value', 1 ),
                        array( 'PlusOperator' ),
                        array( 'Literal', 'value', 2 ),
                        array( 'MinusOperator' ),
                        array( 'Literal', 'value', 4 ), // index 50
                        array( 'MultiplicationOperator' ),
                        array( 'Literal', 'value', 6 ),
                        array( 'DivisionOperator' ),
                        array( 'Literal', 'value', 'var' ),
                        array( 'Variable', 'name', 'var' ),
                        array( 'PropertyFetchOperator' ),
                        array( 'Literal', 'value', 'lines' ),
                        array( 'Literal', 'value', 0 ),
                        array( 'ArrayFetchOperator' ),
                        array( 'MinusOperator' ), // index 60
                        array( 'Literal', 'value', 5 ),
                        array( 'PlusOperator' ),
                        array( 'Literal', 'value', 100 ),
                        array( 'ConcatOperator' ),
                        array( 'Literal', 'value', "a" ),
                        array( 'OutputBlock' ),

                        array( 'TextBlock') );

        $this->setupExpectedElements( $parser, $text, $source, $items );

        $program = $parser->parseIntoNodeTree();

        if ( $parser->debug )
            echo ezcTemplateTstTreeOutput::output( $program ), "\n";

        $parser->verify();
    }

    /**
     * Test parsing operators with sub-expressions.
     */
    public function testParsingOperatorSubExpressions()
    {
        self::assertThat( $this->templatePath . "sub_expressions_test.tpl", self::existsOnDisk() );

        $text = file_get_contents( $this->templatePath . "sub_expressions_test.tpl" );
        // echo "\nsub_expressions_test.tpl\n";
        $source = new ezcTemplateSourceCode( 'mock', 'mock', $text );
        $parser = new MockElement_ezcTemplateParser( $source, $this->manager );

        $items = array( array( 'Literal', 'value', 1 ),
                        array( 'PlusOperator' ),
                        array( 'Literal', 'value', 2 ),
                        array( 'MultiplicationOperator' ),
                        array( 'Literal', 'value', 3 ),
                        array( 'Parenthesis' ),
                        array( 'OutputBlock' ),

                        array( 'TextBlock' ),

                        array( 'Literal', 'value', 1 ),
                        array( 'MultiplicationOperator' ),
                        array( 'Literal', 'value', 2 ),
                        array( 'PlusOperator' ),
                        array( 'Literal', 'value', 3 ),
                        array( 'MinusOperator' ),
                        array( 'Literal', 'value', 4 ),
                        array( 'DivisionOperator' ),
                        array( 'Literal', 'value', 200 ),
                        array( 'MultiplicationOperator' ),
                        array( 'Literal', 'value', 2 ),
                        array( 'Parenthesis' ),
                        array( 'Parenthesis' ),
                        array( 'Parenthesis' ),
                        array( 'PlusOperator' ),
                        array( 'Literal', 'value', 5 ),
                        array( 'PlusOperator' ),
                        array( 'Literal', 'value', 'node' ),
                        array( 'Variable', 'name', 'node' ),
                        array( 'PlusOperator' ),
                        array( 'Literal', 'value', 200 ),
                        array( 'Parenthesis' ),
                        array( 'OutputBlock' ) );

        $this->setupExpectedElements( $parser, $text, $source, $items );

        $program = $parser->parseIntoNodeTree();

        if ( $parser->debug )
            echo ezcTemplateTstTreeOutput::output( $program ), "\n";

        $parser->verify();
    }

    /**
     * Test parsing all supported operators.
     */
    public function testParseOperators()
    {
        self::assertThat( $this->templatePath . "operators_test.tpl", self::existsOnDisk() );

        $text = file_get_contents( $this->templatePath . "operators_test.tpl" );
        $source = new ezcTemplateSourceCode( 'mock', 'mock', $text );
        $parser = new MockElement_ezcTemplateParser( $source, $this->manager );

        $items = array( array( 'Literal', 'value', 'obj' ),
                        array( 'Variable', 'name', 'obj' ),
                        array( 'PropertyFetchOperator' ),
                        array( 'Literal', 'value', 'prop' ),
                        array( 'OutputBlock' ),

                        array( 'TextBlock' ),
                        array( 'Literal', 'value', 'a' ),
                        array( 'Variable', 'name', 'a' ),
                        array( 'Literal', 'value', 0 ),
                        array( 'ArrayFetchOperator' ),
                        array( 'OutputBlock' ),

                        array( 'TextBlock' ),
                        array( 'Literal', 'value', 1 ),
                        array( 'PlusOperator' ),
                        array( 'Literal', 'value', 2 ),
                        array( 'OutputBlock' ),

                        array( 'TextBlock' ),
                        array( 'Literal', 'value', 1 ),
                        array( 'MinusOperator' ),
                        array( 'Literal', 'value', 2 ),
                        array( 'OutputBlock' ),

                        array( 'TextBlock' ),
                        array( 'Literal', 'value', 'a' ),
                        array( 'ConcatOperator' ),
                        array( 'Literal', 'value', 'b' ),
                        array( 'OutputBlock' ),

                        array( 'TextBlock' ),
                        array( 'Literal', 'value', 1 ),
                        array( 'MultiplicationOperator' ),
                        array( 'Literal', 'value', 2 ),
                        array( 'OutputBlock' ),

                        array( 'TextBlock' ),
                        array( 'Literal', 'value', 1 ),
                        array( 'DivisionOperator' ),
                        array( 'Literal', 'value', 2 ),
                        array( 'OutputBlock' ),

                        array( 'TextBlock' ),
                        array( 'Literal', 'value', 1 ),
                        array( 'ModuloOperator' ),
                        array( 'Literal', 'value', 2 ),
                        array( 'OutputBlock' ),

                        array( 'TextBlock' ),
                        array( 'Literal', 'value', 1 ),
                        array( 'EqualOperator' ),
                        array( 'Literal', 'value', 2 ),
                        array( 'EqualOperator' ),
                        array( 'Literal', 'value', 3 ),
                        array( 'OutputBlock' ),

                        array( 'TextBlock' ),
                        array( 'Literal', 'value', 1 ),
                        array( 'NotEqualOperator' ),
                        array( 'Literal', 'value', 2 ),
                        array( 'NotEqualOperator' ),
                        array( 'Literal', 'value', 3 ),
                        array( 'OutputBlock' ),

                        array( 'TextBlock' ),
                        array( 'Literal', 'value', 1 ),
                        array( 'IdenticalOperator' ),
                        array( 'Literal', 'value', 2 ),
                        array( 'IdenticalOperator' ),
                        array( 'Literal', 'value', 3 ),
                        array( 'OutputBlock' ),

                        array( 'TextBlock' ),
                        array( 'Literal', 'value', 1 ),
                        array( 'NotIdenticalOperator' ),
                        array( 'Literal', 'value', 2 ),
                        array( 'NotIdenticalOperator' ),
                        array( 'Literal', 'value', 3 ),
                        array( 'OutputBlock' ),

                        array( 'TextBlock' ),
                        array( 'Literal', 'value', 1 ),
                        array( 'LessThanOperator' ),
                        array( 'Literal', 'value', 2 ),
                        array( 'LessThanOperator' ),
                        array( 'Literal', 'value', 3 ),
                        array( 'OutputBlock' ),

                        array( 'TextBlock' ),
                        array( 'Literal', 'value', 1 ),
                        array( 'GreaterThanOperator' ),
                        array( 'Literal', 'value', 2 ),
                        array( 'GreaterThanOperator' ),
                        array( 'Literal', 'value', 3 ),
                        array( 'OutputBlock' ),

                        array( 'TextBlock' ),
                        array( 'Literal', 'value', 1 ),
                        array( 'LessEqualOperator' ),
                        array( 'Literal', 'value', 2 ),
                        array( 'LessEqualOperator' ),
                        array( 'Literal', 'value', 3 ),
                        array( 'OutputBlock' ),

                        array( 'TextBlock' ),
                        array( 'Literal', 'value', 1 ),
                        array( 'GreaterEqualOperator' ),
                        array( 'Literal', 'value', 2 ),
                        array( 'GreaterEqualOperator' ),
                        array( 'Literal', 'value', 3 ),
                        array( 'OutputBlock' ),

                        array( 'TextBlock' ),
                        array( 'Literal', 'value', 1 ),
                        array( 'LogicalAndOperator' ),
                        array( 'Literal', 'value', 2 ),
                        array( 'LogicalAndOperator' ),
                        array( 'Literal', 'value', 3 ),
                        array( 'OutputBlock' ),

                        array( 'TextBlock' ),
                        array( 'Literal', 'value', 1 ),
                        array( 'LogicalOrOperator' ),
                        array( 'Literal', 'value', 2 ),
                        array( 'LogicalOrOperator' ),
                        array( 'Literal', 'value', 3 ),
                        array( 'OutputBlock' ),

                        array( 'TextBlock' ),
                        array( 'Literal', 'value', 1 ),
                        array( 'AssignmentOperator' ),
                        array( 'Literal', 'value', 2 ),
                        array( 'OutputBlock' ),

                        array( 'TextBlock' ),
                        array( 'Literal', 'value', 1 ),
                        array( 'PlusAssignmentOperator' ),
                        array( 'Literal', 'value', 2 ),
                        array( 'OutputBlock' ),

                        array( 'TextBlock' ),
                        array( 'Literal', 'value', 1 ),
                        array( 'MinusAssignmentOperator' ),
                        array( 'Literal', 'value', 2 ),
                        array( 'OutputBlock' ),

                        array( 'TextBlock' ),
                        array( 'Literal', 'value', 1 ),
                        array( 'MultiplicationAssignmentOperator' ),
                        array( 'Literal', 'value', 2 ),
                        array( 'OutputBlock' ),

                        array( 'TextBlock' ),
                        array( 'Literal', 'value', 1 ),
                        array( 'DivisionAssignmentOperator' ),
                        array( 'Literal', 'value', 2 ),
                        array( 'OutputBlock' ),

                        array( 'TextBlock' ),
                        array( 'Literal', 'value', 1 ),
                        array( 'ConcatAssignmentOperator' ),
                        array( 'Literal', 'value', 2 ),
                        array( 'OutputBlock' ),

                        array( 'TextBlock' ),
                        array( 'Literal', 'value', 1 ),
                        array( 'ModuloAssignmentOperator' ),
                        array( 'Literal', 'value', 2 ),
                        array( 'OutputBlock' ),

                        array( 'TextBlock' ),
                        array( 'PreIncrementOperator' ),
                        array( 'Literal', 'value', 1 ),
                        array( 'OutputBlock' ),

                        array( 'TextBlock' ),
                        array( 'PreDecrementOperator' ),
                        array( 'Literal', 'value', 1 ),
                        array( 'OutputBlock' ),

                        array( 'TextBlock' ),
                        array( 'Literal', 'value', 1 ),
                        array( 'PostIncrementOperator' ),
                        array( 'PlusOperator' ),
                        array( 'Literal', 'value', 1 ),
                        array( 'PostDecrementOperator' ),
                        array( 'OutputBlock' ),

                        array( 'TextBlock' ),
                        array( 'Literal', 'value', 1 ),
                        array( 'PostIncrementOperator' ),
                        array( 'OutputBlock' ),

                        array( 'TextBlock' ),
                        array( 'Literal', 'value', 1 ),
                        array( 'PostDecrementOperator' ),
                        array( 'OutputBlock' ),

                        array( 'TextBlock' ),
                        array( 'NegateOperator' ),
                        array( 'Literal', 'value', 'a' ),
                        array( 'Variable', 'name', 'a' ),
                        array( 'OutputBlock' ),

                        array( 'TextBlock' ),
                        array( 'LogicalNegateOperator' ),
                        array( 'Literal', 'value', 'a' ),
                        array( 'Variable', 'name', 'a' ),
                        array( 'OutputBlock' ),

                        array( 'TextBlock' ),
                        array( 'Literal', 'value', 'a' ),
                        array( 'Variable', 'name', 'a' ),
                        array( 'InstanceOfOperator' ),
                        array( 'Literal', 'value', 'b' ),
                        array( 'Variable', 'name', 'b' ),
                        array( 'OutputBlock' ),

                        );

        if ( $parser->debug )
            echo "\noperators_test.tpl\n";

//        $this->setupExpectedElements( $parser, $text, $source, $items );

        $program = $parser->parseIntoNodeTree();

        if ( $parser->debug )
            echo ezcTemplateTstTreeOutput::output( $program ), "\n";

        $parser->verify();
    }

    /**
     * Test parsing the literal block and escaped text portions.
     */
    public function testParsingLiteralBlock()
    {
        self::assertThat( $this->templatePath . "literal_test.tpl", self::existsOnDisk() );

        $text = file_get_contents( $this->templatePath . "literal_test.tpl" );
        $source = new ezcTemplateSourceCode( 'literal_test.tpl', 'mock:literal_test.tpl', $text );
        $parser = new MockElement_ezcTemplateParser( $source, $this->manager );

        if ( $parser->debug )
            echo "\nliteral_test.tpl\n";

        $items = array( array( 'TextBlock', 'originalText', "some plain text\n\n" ),
                        array( 'LiteralBlock', 'originalText', "{literal}\n\nno { code } inside here\nand \\{ escaped \\} braces are kept\n{/literal}" ),
                        array( 'TextBlock', 'originalText', "\n\nand \\no/ \{ code \} here either\n" ),
                        );

        $this->setupExpectedElements( $parser, $text, $source, $items );

        $program = $parser->parseIntoNodeTree();

        if ( $parser->debug )
            echo ezcTemplateTstTreeOutput::output( $program ), "\n";

        $parser->verify();
    }

    /**
     * Test parsing the foreach block.
     */
    public function testParsingForeachBlock()
    {
        self::assertThat( $this->templatePath . "foreach_test.tpl", self::existsOnDisk() );

        $text = file_get_contents( $this->templatePath . "foreach_test.tpl" );
        $source = new ezcTemplateSourceCode( 'foreach_test.tpl', 'mock:foreach_test.tpl', $text );
        $parser = new MockElement_ezcTemplateParser( $source, $this->manager );
//        $parser->debug = true;

        if ( $parser->debug )
            echo "\nforeach_test.tpl\n";

        $program = $parser->parseIntoNodeTree();

        if ( $parser->debug )
            echo "\n\n", ezcTemplateTstTreeOutput::output( $program ), "\n";
        $parser->verify();
    }

    /**
     * Test parsing incorrect "foreach" blocks.
     */
    public function testParsingForeachBlock2()
    {
        $texts = array(
            '{foreach 1 as $i}{/foreach}',
            '{foreach $objects error $item}{/foreach}',
        );

        $nFailures = 0;
        foreach ( $texts as $i => $text )
        {
            $source = new ezcTemplateSourceCode( "while_test$i.tpl", "mock:while_test$i.tpl", $text );
            $parser = new MockElement_ezcTemplateParser( $source, $this->manager );

            try
            {
                $program = $parser->parseIntoNodeTree();
                if ( $parser->debug )
                    echo "\n\n", ezcTemplateTstTreeOutput::output( $program ), "\n";
            }
            catch ( Exception $e )
            {
                $nFailures++;
            }

            $parser->verify();

            unset( $parser );
            unset( $source );
        }

        $nOk = count( $texts ) - $nFailures;
        if ( $nOk > 0 )
            $this->fail( "Parser did not fail on $nOk incorrect templates foreach_test2" );
    }


    /**
     * Test parsing the "while" block.
     */
    public function testParsingWhileBlock()
    {
        self::assertThat( $this->templatePath . "while_test.tpl", self::existsOnDisk() );

        $text = file_get_contents( $this->templatePath . "while_test.tpl" );
        $source = new ezcTemplateSourceCode( 'while_test.tpl', 'mock:while_test.tpl', $text );
        $parser = new MockElement_ezcTemplateParser( $source, $this->manager );
        // $parser->debug = true;

        if ( $parser->debug )
            echo "\nwhile_test.tpl\n";

        $program = $parser->parseIntoNodeTree();

        if ( $parser->debug )
            echo "\n\n", ezcTemplateTstTreeOutput::output( $program ), "\n";

        $parser->verify();
    }

    /**
     * Test parsing incorrect do/while blocks.
     */
    public function testParsingWhileBlock2()
    {
        $texts = array(
            '{while}{/while}',
            '{while}',
        );

        $nFailures = 0;
        foreach ( $texts as $i => $text )
        {
            $ok = true;
            $source = new ezcTemplateSourceCode( "while_test$i.tpl", "mock:while_test$i.tpl", $text );
            $parser = new MockElement_ezcTemplateParser( $source, $this->manager );

            try
            {
                $program = $parser->parseIntoNodeTree();
                if ( $parser->debug )
                    echo "\n\n", ezcTemplateTstTreeOutput::output( $program ), "\n";
            }
            catch ( Exception $e )
            {
                $nFailures++;
            }

            $parser->verify();

            unset( $parser );
            unset( $source );
        }

        $nOk = count( $texts ) - $nFailures;
        if ( $nOk > 0 )
            $this->fail( "Parser did not fail on $nOk incorrect templates while_test2" );
    }

    /**
     * Test parsing the "if" block.
     */
    public function testParsingIfBlock()
    {
        self::assertThat( $this->templatePath . "if_test.tpl", self::existsOnDisk() );

        $text = file_get_contents( $this->templatePath . "if_test.tpl" );
        $source = new ezcTemplateSourceCode( 'if_test.tpl', 'mock:if_test.tpl', $text );
        $parser = new MockElement_ezcTemplateParser( $source, $this->manager );

        // $parser->debug = true;

        if ( $parser->debug )
            echo "\nforeach_test.tpl\n";

        $program = $parser->parseIntoNodeTree();

        if ( $parser->debug )
            echo "\n\n", ezcTemplateTstTreeOutput::output( $program ), "\n";

        $parser->verify();

    }

    /**
     * Sets up expectations for reportElementCursor based on item list $items
     * which contains the start and ending position + expected class element.
     */
    public function setupExpectedElements( $parser, $text, $source, $items )
    {
        $index = 0;
        foreach ( $items as $item )
        {
            $class = 'ezcTemplate' . $item[0];
            if ( substr( $class, -15 ) != 'OperatorTstNode' )
                $class .= 'TstNode';
            if ( isset( $item[1] ) && isset( $item[2] ) )
            {
                $parser->expects( self::at( $index ) )
                    ->method( "reportElementCursor" )
                    ->with( self::anything(),
                            self::anything(),
                            self::logicalAnd( self::isInstanceOf( $class ),
                                              self::hasProperty( $item[1] )->that( self::identicalTo( $item[2] ) ) ) );
            }
            else
            {
                $parser->expects( self::at( $index ) )
                    ->method( "reportElementCursor" )
                    ->with( self::anything(),
                            self::anything(),
                            self::logicalAnd( self::isInstanceOf( $class ) ) );
            }
            ++$index;
        }
        $parser->expects( self::exactly( $index ) )
            ->method( "reportElementCursor" )
            ->withAnyParameters();
    }

    /**
     * Sets up expectations for reportElementCursor based on item list $items
     * which contains the start and ending position + expected class element.
     */
    public function setupExpectedPositions( $parser, $text, $source, $items )
    {
        $index = 0;
        foreach ( $items as $item )
        {
            $startCursor = new ezcTemplateCursor( $text, $item[0], $item[1], $item[2] );
            $endCursor = new ezcTemplateCursor( $text, $item[3], $item[4], $item[5] );
            $class = 'ezcTemplate' . $item[6];
            if ( substr( $class, -15 ) != 'OperatorTstNode' )
                $class .= 'TstNode';
            $element = new $class( $source, $startCursor, $endCursor );
            if ( isset( $item[7] ) && isset( $item[8] ) )
            {
                $property = $item[7];
                $element->$property = $item[8];
            }
            $parser->expects( self::at( $index ) )
                ->method( "reportElementCursor" )
                ->with( $startCursor, $endCursor, $element );
            $startCursor = $endCursor;
            ++$index;
        }
        $parser->expects( self::exactly( $index ) )
            ->method( "reportElementCursor" )
            ->withAnyParameters();
    }
}

?>