/*
 *
 *  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.
 *
 */
package org.apache.royale.compiler.internal.codegen.js.sourcemaps;

import org.apache.royale.compiler.driver.IBackend;
import org.apache.royale.compiler.internal.driver.js.royale.RoyaleBackend;
import org.apache.royale.compiler.internal.test.SourceMapTestBase;
import org.apache.royale.compiler.internal.tree.as.ArrayLiteralNode;
import org.apache.royale.compiler.internal.tree.as.ObjectLiteralNode;
import org.apache.royale.compiler.tree.as.IBinaryOperatorNode;
import org.apache.royale.compiler.tree.as.IDynamicAccessNode;
import org.apache.royale.compiler.tree.as.IFunctionCallNode;
import org.apache.royale.compiler.tree.as.IIterationFlowNode;
import org.apache.royale.compiler.tree.as.IMemberAccessExpressionNode;
import org.apache.royale.compiler.tree.as.IReturnNode;
import org.apache.royale.compiler.tree.as.ITernaryOperatorNode;
import org.apache.royale.compiler.tree.as.IThrowNode;
import org.apache.royale.compiler.tree.as.IUnaryOperatorNode;

import org.junit.Test;

public class TestSourceMapExpressions extends SourceMapTestBase
{
    //----------------------------------
    // Primary expression keywords
    //----------------------------------

    //----------------------------------
    // Arithmetic
    //----------------------------------

    @Test
    public void testVisitBinaryOperatorNode_Plus()
    {
        IBinaryOperatorNode node = getBinaryNode("a + b");
        asBlockWalker.visitBinaryOperator(node);
        assertMapping(node, 0, 0, 0, 0, 0, 1); // a
        assertMapping(node, 0, 1, 0, 1, 0, 4); // +
        assertMapping(node, 0, 4, 0, 4, 0, 5); // b
    }

    @Test
    public void testVisitBinaryOperatorNode_Minus()
    {
        IBinaryOperatorNode node = getBinaryNode("a - b");
        asBlockWalker.visitBinaryOperator(node);
        assertMapping(node, 0, 0, 0, 0, 0, 1); // a
        assertMapping(node, 0, 1, 0, 1, 0, 4); // -
        assertMapping(node, 0, 4, 0, 4, 0, 5); // b
    }

    @Test
    public void testVisitBinaryOperatorNode_Divide()
    {
        IBinaryOperatorNode node = getBinaryNode("a / b");
        asBlockWalker.visitBinaryOperator(node);
        assertMapping(node, 0, 0, 0, 0, 0, 1); // a
        assertMapping(node, 0, 1, 0, 1, 0, 4); // /
        assertMapping(node, 0, 4, 0, 4, 0, 5); // b
    }

    @Test
    public void testVisitBinaryOperatorNode_Modulo()
    {
        IBinaryOperatorNode node = getBinaryNode("a % b");
        asBlockWalker.visitBinaryOperator(node);
        assertMapping(node, 0, 0, 0, 0, 0, 1); // a
        assertMapping(node, 0, 1, 0, 1, 0, 4); // %
        assertMapping(node, 0, 4, 0, 4, 0, 5); // b
    }

    @Test
    public void testVisitBinaryOperatorNode_Multiply()
    {
        IBinaryOperatorNode node = getBinaryNode("a * b");
        asBlockWalker.visitBinaryOperator(node);
        assertMapping(node, 0, 0, 0, 0, 0, 1); // a
        assertMapping(node, 0, 1, 0, 1, 0, 4); // *
        assertMapping(node, 0, 4, 0, 4, 0, 5); // b
    }

    @Test
    public void testVisitUnaryOperatorNode_PostIncrement()
    {
        IUnaryOperatorNode node = getUnaryNode("a++");
        asBlockWalker.visitUnaryOperator(node);
        assertMapping(node, 0, 0, 0, 0, 0, 1); // a
        assertMapping(node, 0, 1, 0, 1, 0, 3); // ++
    }

    @Test
    public void testVisitUnaryOperatorNode_PreIncrement()
    {
        IUnaryOperatorNode node = getUnaryNode("++a");
        asBlockWalker.visitUnaryOperator(node);
        assertMapping(node, 0, 0, 0, 0, 0, 2); // ++
        assertMapping(node, 0, 2, 0, 2, 0, 3); // a
    }

    @Test
    public void testVisitUnaryOperatorNode_PostDecrement()
    {
        IUnaryOperatorNode node = getUnaryNode("a--");
        asBlockWalker.visitUnaryOperator(node);
        assertMapping(node, 0, 0, 0, 0, 0, 1); // a
        assertMapping(node, 0, 1, 0, 1, 0, 3); // --
    }

    @Test
    public void testVisitUnaryOperatorNode_PreDecrement()
    {
        IUnaryOperatorNode node = getUnaryNode("--a");
        asBlockWalker.visitUnaryOperator(node);
        assertMapping(node, 0, 0, 0, 0, 0, 2); // --
        assertMapping(node, 0, 2, 0, 2, 0, 3); // a
    }

    //----------------------------------
    // Arithmetic compound assignment
    //----------------------------------

    @Test
    public void testVisitBinaryOperatorNode_PlusAssignment()
    {
        IBinaryOperatorNode node = getBinaryNode("a += b");
        asBlockWalker.visitBinaryOperator(node);
        assertMapping(node, 0, 0, 0, 0, 0, 1); // a
        assertMapping(node, 0, 1, 0, 1, 0, 5); // +=
        assertMapping(node, 0, 5, 0, 5, 0, 6); // b
    }

    @Test
    public void testVisitBinaryOperatorNode_MinusAssignment()
    {
        IBinaryOperatorNode node = getBinaryNode("a -= b");
        asBlockWalker.visitBinaryOperator(node);
        assertMapping(node, 0, 0, 0, 0, 0, 1); // a
        assertMapping(node, 0, 1, 0, 1, 0, 5); // -=
        assertMapping(node, 0, 5, 0, 5, 0, 6); // b
    }

    @Test
    public void testVisitBinaryOperatorNode_DivideAssignment()
    {
        IBinaryOperatorNode node = getBinaryNode("a /= b");
        asBlockWalker.visitBinaryOperator(node);
        assertMapping(node, 0, 0, 0, 0, 0, 1); // a
        assertMapping(node, 0, 1, 0, 1, 0, 5); // /=
        assertMapping(node, 0, 5, 0, 5, 0, 6); // b
    }

    @Test
    public void testVisitBinaryOperatorNode_ModuloAssignment()
    {
        IBinaryOperatorNode node = getBinaryNode("a %= b");
        asBlockWalker.visitBinaryOperator(node);
        assertMapping(node, 0, 0, 0, 0, 0, 1); // a
        assertMapping(node, 0, 1, 0, 1, 0, 5); // %=
        assertMapping(node, 0, 5, 0, 5, 0, 6); // b
    }

    @Test
    public void testVisitBinaryOperatorNode_MultiplyAssignment()
    {
        IBinaryOperatorNode node = getBinaryNode("a *= b");
        asBlockWalker.visitBinaryOperator(node);
        assertMapping(node, 0, 0, 0, 0, 0, 1); // a
        assertMapping(node, 0, 1, 0, 1, 0, 5); // *=
        assertMapping(node, 0, 5, 0, 5, 0, 6); // b
    }

    //----------------------------------
    // Assignment
    //----------------------------------

    @Test
    public void testVisitBinaryOperatorNode_Assignment()
    {
        IBinaryOperatorNode node = getBinaryNode("a = b");
        asBlockWalker.visitBinaryOperator(node);
        assertMapping(node, 0, 0, 0, 0, 0, 1); // a
        assertMapping(node, 0, 1, 0, 1, 0, 4); // =
        assertMapping(node, 0, 4, 0, 4, 0, 5); // b
    }

    //----------------------------------
    // Bitwise
    //----------------------------------

    @Test
    public void testVisitBinaryOperatorNode_BitwiseAnd()
    {
        IBinaryOperatorNode node = getBinaryNode("a & b");
        asBlockWalker.visitBinaryOperator(node);
        assertMapping(node, 0, 0, 0, 0, 0, 1); // a
        assertMapping(node, 0, 1, 0, 1, 0, 4); // &
        assertMapping(node, 0, 4, 0, 4, 0, 5); // b
    }

    @Test
    public void testVisitBinaryOperatorNode_BitwiseLeftShift()
    {
        IBinaryOperatorNode node = getBinaryNode("a << b");
        asBlockWalker.visitBinaryOperator(node);
        assertMapping(node, 0, 0, 0, 0, 0, 1); // a
        assertMapping(node, 0, 1, 0, 1, 0, 5); // <<
        assertMapping(node, 0, 5, 0, 5, 0, 6); // b
    }

    @Test
    public void testVisitUnaryOperatorNode_BitwiseNot()
    {
        IUnaryOperatorNode node = getUnaryNode("~a");
        asBlockWalker.visitUnaryOperator(node);
        assertMapping(node, 0, 0, 0, 0, 0, 1); // ~
        assertMapping(node, 0, 1, 0, 1, 0, 2); // a
    }

    @Test
    public void testVisitBinaryOperatorNode_BitwiseOr()
    {
        IBinaryOperatorNode node = getBinaryNode("a | b");
        asBlockWalker.visitBinaryOperator(node);
        assertMapping(node, 0, 0, 0, 0, 0, 1); // a
        assertMapping(node, 0, 1, 0, 1, 0, 4); // |
        assertMapping(node, 0, 4, 0, 4, 0, 5); // b
    }

    @Test
    public void testVisitBinaryOperatorNode_BitwiseRightShift()
    {
        IBinaryOperatorNode node = getBinaryNode("a >> b");
        asBlockWalker.visitBinaryOperator(node);
        assertMapping(node, 0, 0, 0, 0, 0, 1); // a
        assertMapping(node, 0, 1, 0, 1, 0, 5); // >>
        assertMapping(node, 0, 5, 0, 5, 0, 6); // b
    }

    @Test
    public void testVisitBinaryOperatorNode_BitwiseUnsignedRightShift()
    {
        IBinaryOperatorNode node = getBinaryNode("a >>> b");
        asBlockWalker.visitBinaryOperator(node);
        assertMapping(node, 0, 0, 0, 0, 0, 1); // a
        assertMapping(node, 0, 1, 0, 1, 0, 6); // >>>
        assertMapping(node, 0, 6, 0, 6, 0, 7); // b
    }

    @Test
    public void testVisitBinaryOperatorNode_BitwiseXOR()
    {
        IBinaryOperatorNode node = getBinaryNode("a ^ b");
        asBlockWalker.visitBinaryOperator(node);
        assertMapping(node, 0, 0, 0, 0, 0, 1); // a
        assertMapping(node, 0, 1, 0, 1, 0, 4); // ^
        assertMapping(node, 0, 4, 0, 4, 0, 5); // b
    }

    //----------------------------------
    // Bitwise compound assignment
    //----------------------------------

    @Test
    public void testVisitBinaryOperatorNode_BitwiseAndAssignment()
    {
        IBinaryOperatorNode node = getBinaryNode("a &= b");
        asBlockWalker.visitBinaryOperator(node);
        assertMapping(node, 0, 0, 0, 0, 0, 1); // a
        assertMapping(node, 0, 1, 0, 1, 0, 5); // &=
        assertMapping(node, 0, 5, 0, 5, 0, 6); // b
    }

    @Test
    public void testVisitBinaryOperatorNode_BitwiseLeftShiftAssignment()
    {
        IBinaryOperatorNode node = getBinaryNode("a <<= b");
        asBlockWalker.visitBinaryOperator(node);
        assertMapping(node, 0, 0, 0, 0, 0, 1); // a
        assertMapping(node, 0, 1, 0, 1, 0, 6); // <<=
        assertMapping(node, 0, 6, 0, 6, 0, 7); // b
    }

    @Test
    public void testVisitBinaryOperatorNode_BitwiseOrAssignment()
    {
        IBinaryOperatorNode node = getBinaryNode("a |= b");
        asBlockWalker.visitBinaryOperator(node);
        assertMapping(node, 0, 0, 0, 0, 0, 1); // a
        assertMapping(node, 0, 1, 0, 1, 0, 5); // |=
        assertMapping(node, 0, 5, 0, 5, 0, 6); // b
    }

    @Test
    public void testVisitBinaryOperatorNode_BitwiseRightShiftAssignment()
    {
        IBinaryOperatorNode node = getBinaryNode("a >>= b");
        asBlockWalker.visitBinaryOperator(node);
        assertMapping(node, 0, 0, 0, 0, 0, 1); // a
        assertMapping(node, 0, 1, 0, 1, 0, 6); // >>=
        assertMapping(node, 0, 6, 0, 6, 0, 7); // b
    }

    @Test
    public void testVisitBinaryOperatorNode_BitwiseUnsignedRightShiftAssignment()
    {
        IBinaryOperatorNode node = getBinaryNode("a >>>= b");
        asBlockWalker.visitBinaryOperator(node);
        assertMapping(node, 0, 0, 0, 0, 0, 1); // a
        assertMapping(node, 0, 1, 0, 1, 0, 7); // >>>=
        assertMapping(node, 0, 7, 0, 7, 0, 8); // b
    }

    @Test
    public void testVisitBinaryOperatorNode_BitwiseXORAssignment()
    {
        IBinaryOperatorNode node = getBinaryNode("a ^= b");
        asBlockWalker.visitBinaryOperator(node);
        assertMapping(node, 0, 0, 0, 0, 0, 1); // a
        assertMapping(node, 0, 1, 0, 1, 0, 5); // ^=
        assertMapping(node, 0, 5, 0, 5, 0, 6); // b
    }

    //----------------------------------
    // Comparison
    //----------------------------------

    @Test
    public void testVisitBinaryOperatorNode_Equal()
    {
        IBinaryOperatorNode node = getBinaryNode("a == b");
        asBlockWalker.visitBinaryOperator(node);
        assertMapping(node, 0, 0, 0, 0, 0, 1); // a
        assertMapping(node, 0, 1, 0, 1, 0, 5); // ==
        assertMapping(node, 0, 5, 0, 5, 0, 6); // b
    }

    @Test
    public void testVisitBinaryOperatorNode_GreaterThan()
    {
        IBinaryOperatorNode node = getBinaryNode("a > b");
        asBlockWalker.visitBinaryOperator(node);
        assertMapping(node, 0, 0, 0, 0, 0, 1); // a
        assertMapping(node, 0, 1, 0, 1, 0, 4); // >
        assertMapping(node, 0, 4, 0, 4, 0, 5); // b
    }

    @Test
    public void testVisitBinaryOperatorNode_GreaterThanEqual()
    {
        IBinaryOperatorNode node = getBinaryNode("a >= b");
        asBlockWalker.visitBinaryOperator(node);
        assertMapping(node, 0, 0, 0, 0, 0, 1); // a
        assertMapping(node, 0, 1, 0, 1, 0, 5); // >=
        assertMapping(node, 0, 5, 0, 5, 0, 6); // b
    }

    @Test
    public void testVisitBinaryOperatorNode_NotEqual()
    {
        IBinaryOperatorNode node = getBinaryNode("a != b");
        asBlockWalker.visitBinaryOperator(node);
        assertMapping(node, 0, 0, 0, 0, 0, 1); // a
        assertMapping(node, 0, 1, 0, 1, 0, 5); // !=
        assertMapping(node, 0, 5, 0, 5, 0, 6); // b
    }

    @Test
    public void testVisitBinaryOperatorNode_LessThan()
    {
        IBinaryOperatorNode node = getBinaryNode("a < b");
        asBlockWalker.visitBinaryOperator(node);
        assertMapping(node, 0, 0, 0, 0, 0, 1); // a
        assertMapping(node, 0, 1, 0, 1, 0, 4); // <
        assertMapping(node, 0, 4, 0, 4, 0, 5); // b
    }

    @Test
    public void testVisitBinaryOperatorNode_LessThanEqual()
    {
        IBinaryOperatorNode node = getBinaryNode("a <= b");
        asBlockWalker.visitBinaryOperator(node);
        assertMapping(node, 0, 0, 0, 0, 0, 1); // a
        assertMapping(node, 0, 1, 0, 1, 0, 5); // <=
        assertMapping(node, 0, 5, 0, 5, 0, 6); // b
    }

    @Test
    public void testVisitBinaryOperatorNode_StrictEqual()
    {
        IBinaryOperatorNode node = getBinaryNode("a === b");
        asBlockWalker.visitBinaryOperator(node);
        assertMapping(node, 0, 0, 0, 0, 0, 1); // a
        assertMapping(node, 0, 1, 0, 1, 0, 6); // ===
        assertMapping(node, 0, 6, 0, 6, 0, 7); // b
    }

    @Test
    public void testVisitBinaryOperatorNode_StrictNotEqual()
    {
        IBinaryOperatorNode node = getBinaryNode("a !== b");
        asBlockWalker.visitBinaryOperator(node);
        assertMapping(node, 0, 0, 0, 0, 0, 1); // a
        assertMapping(node, 0, 1, 0, 1, 0, 6); // !==
        assertMapping(node, 0, 6, 0, 6, 0, 7); // b
    }

    //----------------------------------
    // Logical
    //----------------------------------

    @Test
    public void testVisitBinaryOperatorNode_LogicalAnd()
    {
        IBinaryOperatorNode node = getBinaryNode("a && b");
        asBlockWalker.visitBinaryOperator(node);
        assertMapping(node, 0, 0, 0, 0, 0, 1); // a
        assertMapping(node, 0, 1, 0, 1, 0, 5); // &&
        assertMapping(node, 0, 5, 0, 5, 0, 6); // b
    }

    @Test
    public void testVisitBinaryOperatorNode_LogicalAndAssignment()
    {
        IBinaryOperatorNode node = getBinaryNode("a &&= b");
        asBlockWalker.visitBinaryOperator(node);
        //a = a && b
        assertMapping(node, 0, 0, 0, 0, 0, 1); // a
        assertMapping(node, 0, 1, 0, 1, 0, 4); // =
        assertMapping(node, 0, 0, 0, 4, 0, 5); // a
        assertMapping(node, 0, 1, 0, 5, 0, 9); // &&
        assertMapping(node, 0, 0, 0, 0, 0, 1); // b
    }

    @Test
    public void testVisitUnaryOperatorNode_LogicalNot()
    {
        IUnaryOperatorNode node = getUnaryNode("!a");
        asBlockWalker.visitUnaryOperator(node);
        assertMapping(node, 0, 0, 0, 0, 0, 1); // !
        assertMapping(node, 0, 1, 0, 1, 0, 2); // a
    }

    @Test
    public void testVisitBinaryOperatorNode_LogicalOr()
    {
        IBinaryOperatorNode node = getBinaryNode("a || b");
        asBlockWalker.visitBinaryOperator(node);
        assertMapping(node, 0, 0, 0, 0, 0, 1); // a
        assertMapping(node, 0, 1, 0, 1, 0, 5); // ||
        assertMapping(node, 0, 5, 0, 5, 0, 6); // b
    }

    @Test
    public void testVisitBinaryOperatorNode_LogicalOrAssignment()
    {
        IBinaryOperatorNode node = getBinaryNode("a ||= b");
        asBlockWalker.visitBinaryOperator(node);
        //a = a || b
        assertMapping(node, 0, 0, 0, 0, 0, 1); // a
        assertMapping(node, 0, 1, 0, 1, 0, 4); // =
        assertMapping(node, 0, 0, 0, 4, 0, 5); // a
        assertMapping(node, 0, 1, 0, 5, 0, 9); // ||
        assertMapping(node, 0, 0, 0, 0, 0, 1); // b
    }

    //----------------------------------
    // Other
    //----------------------------------

    @Test
    public void testVisitDynamicAccessNode_1()
    {
        IDynamicAccessNode node = getDynamicAccessNode("a[b]");
        asBlockWalker.visitDynamicAccess(node);
        assertMapping(node, 0, 0, 0, 0, 0, 1); // a
        assertMapping(node, 0, 1, 0, 1, 0, 2); // [
        assertMapping(node, 0, 2, 0, 2, 0, 3); // b
        assertMapping(node, 0, 3, 0, 3, 0, 4); // ]
    }

    @Test
    public void testVisitDynamicAccessNode_2()
    {
        IDynamicAccessNode node = getDynamicAccessNode("a[b[c][d]]");
        asBlockWalker.visitDynamicAccess(node);
        assertMapping(node, 0, 0, 0, 0, 0, 1);   // a
        assertMapping(node, 0, 1, 0, 1, 0, 2);   // [
        assertMapping(node, 0, 2, 0, 2, 0, 3);   // b
        assertMapping(node, 0, 3, 0, 3, 0, 4);   // [
        assertMapping(node, 0, 4, 0, 4, 0, 5);   // c
        assertMapping(node, 0, 5, 0, 5, 0, 6);   // ]
        assertMapping(node, 0, 6, 0, 6, 0, 7);   // [
        assertMapping(node, 0, 7, 0, 7, 0, 8);   // d
        assertMapping(node, 0, 8, 0, 8, 0, 9);   // ]
        assertMapping(node, 0, 9, 0, 9, 0, 10);  // ]
    }

    @Test
    public void testVisitBinaryOperatorNode_Comma()
    {
        IBinaryOperatorNode node = getBinaryNode("a, b");
        asBlockWalker.visitBinaryOperator(node);
        assertMapping(node, 0, 0, 0, 0, 0, 1); // a
        assertMapping(node, 0, 1, 0, 1, 0, 3); // ,
        assertMapping(node, 0, 3, 0, 3, 0, 4); // b
    }

    @Test
    public void testVisitTernaryOperatorNode()
    {
        ITernaryOperatorNode node = (ITernaryOperatorNode) getExpressionNode(
                "a ? b : c", ITernaryOperatorNode.class);
        asBlockWalker.visitTernaryOperator(node);
        assertMapping(node, 0, 0, 0, 0, 0, 1); // a
        assertMapping(node, 0, 1, 0, 1, 0, 4); // ?
        assertMapping(node, 0, 4, 0, 4, 0, 5); // b
        assertMapping(node, 0, 5, 0, 5, 0, 8); // :
        assertMapping(node, 0, 8, 0, 8, 0, 9); // c
    }

    @Test
    public void testVisitUnaryOperator_Delete()
    {
        IUnaryOperatorNode node = getUnaryNode("delete a");
        asBlockWalker.visitUnaryOperator(node);
        assertMapping(node, 0, 0, 0, 0, 0, 7); // delete
        assertMapping(node, 0, 7, 0, 7, 0, 8); // a
    }

    @Test
    public void testVisitMemberAccess_1()
    {
        IMemberAccessExpressionNode node = (IMemberAccessExpressionNode) getExpressionNode(
                "a.b", IMemberAccessExpressionNode.class);
        asBlockWalker.visitMemberAccessExpression(node);
        assertMapping(node, 0, 0, 0, 0, 0, 1); // a
        assertMapping(node, 0, 1, 0, 1, 0, 2); // .
        assertMapping(node, 0, 2, 0, 2, 0, 3); // b
    }

    @Test
    public void testVisitMemberAccess_2()
    {
        IMemberAccessExpressionNode node = (IMemberAccessExpressionNode) getExpressionNode(
                "a.b.c.d", IMemberAccessExpressionNode.class);
        asBlockWalker.visitMemberAccessExpression(node);
        assertMapping(node, 0, 0, 0, 0, 0, 1);  // a
        assertMapping(node, 0, 1, 0, 1, 0, 2);  // .
        assertMapping(node, 0, 2, 0, 2, 0, 3);  // b
        assertMapping(node, 0, 3, 0, 3, 0, 4);  // .
        assertMapping(node, 0, 4, 0, 4, 0, 5);  // c
        assertMapping(node, 0, 5, 0, 5, 0, 6);  // .
        assertMapping(node, 0, 6, 0, 6, 0, 7);  // d
    }

    @Test
    public void testVisitBinaryOperator_In()
    {
        IBinaryOperatorNode node = getBinaryNode("a in b");
        asBlockWalker.visitBinaryOperator(node);
        assertMapping(node, 0, 0, 0, 0, 0, 1); // a
        assertMapping(node, 0, 1, 0, 1, 0, 5); // in
        assertMapping(node, 0, 5, 0, 5, 0, 6); // b
    }

    @Test
    public void testVisitBinaryOperator_Instancof()
    {
        IBinaryOperatorNode node = getBinaryNode("a instanceof b");
        asBlockWalker.visitBinaryOperator(node);
        assertMapping(node, 0, 0, 0, 0, 0, 1);     // a
        assertMapping(node, 0, 1, 0, 1, 0, 13);    // instanceof
        assertMapping(node, 0, 13, 0, 13, 0, 14);  // b
    }

    @Test
    public void testVisitBinaryOperator_New()
    {
        IFunctionCallNode node = (IFunctionCallNode) getExpressionNode(
                "new Object()", IFunctionCallNode.class);
        asBlockWalker.visitFunctionCall(node);
        assertMapping(node, 0, 0, 0, 0, 0, 4);  // new
        assertMapping(node, 0, 4, 0, 4, 0, 10); // Object
    }

    @Test
    public void testVisitObjectLiteral_1()
    {
        ObjectLiteralNode node = (ObjectLiteralNode) getExpressionNode(
                "a = {a:1}", ObjectLiteralNode.class);
        asBlockWalker.visitLiteral(node);
        //{a: 1}
        assertMapping(node, 0, 0, 0, 0, 0, 1); // {
        assertMapping(node, 0, 1, 0, 1, 0, 2); // a
        assertMapping(node, 0, 2, 0, 2, 0, 3); // :
        assertMapping(node, 0, 4, 0, 4, 0, 5); // }
    }

    @Test
    public void testVisitObjectLiteral_2()
    {
        ObjectLiteralNode node = (ObjectLiteralNode) getExpressionNode(
                "a = {a:1,b:{c:2,d:{e:4}}}", ObjectLiteralNode.class);
        asBlockWalker.visitLiteral(node);
        //{a:1, b:{c:2, d:{e:4}}}
        assertMapping(node, 0, 0, 0, 0, 0, 1);    // {
        assertMapping(node, 0, 1, 0, 1, 0, 2);    // a
        assertMapping(node, 0, 2, 0, 2, 0, 3);    // :
        assertMapping(node, 0, 4, 0, 4, 0, 6);    // ,
        assertMapping(node, 0, 5, 0, 6, 0, 7);    // b
        assertMapping(node, 0, 6, 0, 7, 0, 8);    // :
        assertMapping(node, 0, 7, 0, 8, 0, 9);    // {
        assertMapping(node, 0, 8, 0, 9, 0, 10);   // c
        assertMapping(node, 0, 9, 0, 10, 0, 11);  // :
        assertMapping(node, 0, 11, 0, 12, 0, 14); // ,
        assertMapping(node, 0, 12, 0, 14, 0, 15); // d
        assertMapping(node, 0, 13, 0, 15, 0, 16); // :
        assertMapping(node, 0, 14, 0, 16, 0, 17); // {
        assertMapping(node, 0, 15, 0, 17, 0, 18); // e
        assertMapping(node, 0, 16, 0, 18, 0, 19); // :
        assertMapping(node, 0, 18, 0, 20, 0, 21); // }
        assertMapping(node, 0, 19, 0, 21, 0, 22); // }
        assertMapping(node, 0, 20, 0, 22, 0, 23); // }
        
    }

    @Test
    public void testVisitObjectLiteral_3()
    {
        ObjectLiteralNode node = (ObjectLiteralNode) getExpressionNode(
                "a = { a: 12,  bb: 2   \t}", ObjectLiteralNode.class);
        asBlockWalker.visitLiteral(node);
        //{a:12, bb:2}
        assertMapping(node, 0, 0, 0, 0, 0, 1);    // {
        assertMapping(node, 0, 2, 0, 1, 0, 2);    // a
        assertMapping(node, 0, 3, 0, 2, 0, 3);    // :
        assertMapping(node, 0, 7, 0, 5, 0, 7);    // ,
        assertMapping(node, 0, 10, 0, 7, 0, 9);   // bb
        assertMapping(node, 0, 12, 0, 9, 0, 10);  // :
        assertMapping(node, 0, 19, 0, 11, 0, 12); // }
    }

    @Test
    public void testVisitObjectLiteral_4()
    {
        ObjectLiteralNode node = (ObjectLiteralNode) getExpressionNode(
                "a = {a:1,\nb:2}", ObjectLiteralNode.class);
        asBlockWalker.visitLiteral(node);
        //{a:1, b:2}
        assertMapping(node, 0, 0, 0, 0, 0, 1);   // {
        assertMapping(node, 0, 1, 0, 1, 0, 2);   // a
        assertMapping(node, 0, 2, 0, 2, 0, 3);   // :
        assertMapping(node, 0, 3, 0, 3, 0, 4);   // 1
        assertMapping(node, 0, 4, 0, 4, 0, 6);   // ,
        assertMapping(node, 1, 0, 0, 6, 0, 7);   // b
        assertMapping(node, 1, 1, 0, 7, 0, 8);   // :
        assertMapping(node, 1, 2, 0, 8, 0, 9);   // 2
        assertMapping(node, 1, 3, 0, 9, 0, 10);  // }
    }

    @Test
    public void testVisitArrayLiteral_1()
    {
        ArrayLiteralNode node = (ArrayLiteralNode) getExpressionNode(
                "a = [0,1,2]", ArrayLiteralNode.class);
        asBlockWalker.visitLiteral(node);
        //[0, 1, 2]
        assertMapping(node, 0, 0, 0, 0, 0, 1); // [
        assertMapping(node, 0, 1, 0, 1, 0, 2); // 0
        assertMapping(node, 0, 2, 0, 2, 0, 4); // ,
        assertMapping(node, 0, 3, 0, 4, 0, 5); // 1
        assertMapping(node, 0, 4, 0, 5, 0, 7); // ,
        assertMapping(node, 0, 5, 0, 7, 0, 8); // 2
        assertMapping(node, 0, 6, 0, 8, 0, 9); // ]
    }

    @Test
    public void testVisitArrayLiteral_2()
    {
        ArrayLiteralNode node = (ArrayLiteralNode) getExpressionNode(
                "a = [0,[0,1,[0,1]],2,[1,2]]", ArrayLiteralNode.class);
        asBlockWalker.visitLiteral(node);
        //[0, [0, 1, [0, 1]], 2, [1, 2]]
        assertMapping(node, 0, 0, 0, 0, 0, 1);    // [
        assertMapping(node, 0, 2, 0, 2, 0, 4);    // ,
        assertMapping(node, 0, 3, 0, 4, 0, 5);    // [
        assertMapping(node, 0, 5, 0, 6, 0, 8);    // ,
        assertMapping(node, 0, 7, 0, 9, 0, 11);   // ,
        assertMapping(node, 0, 8, 0, 11, 0, 12);  // [
        assertMapping(node, 0, 10, 0, 13, 0, 15); // ,
        assertMapping(node, 0, 12, 0, 16, 0, 17); // ]
        assertMapping(node, 0, 13, 0, 17, 0, 18); // ]
        
        assertMapping(node, 0, 14, 0, 18, 0, 20); // ,
        assertMapping(node, 0, 16, 0, 21, 0, 23); // ,
        assertMapping(node, 0, 17, 0, 23, 0, 24); // [
        assertMapping(node, 0, 19, 0, 25, 0, 27); // ,
        assertMapping(node, 0, 21, 0, 28, 0, 29); // ]
        assertMapping(node, 0, 22, 0, 29, 0, 30); // ]
    }

    @Test
    public void testVisitArrayLiteral_3()
    {
        ArrayLiteralNode node = (ArrayLiteralNode) getExpressionNode(
                "a = [ 0,  123, 45   \t]", ArrayLiteralNode.class);
        asBlockWalker.visitLiteral(node);
        //[0, 123, 45]
        assertMapping(node, 0, 0, 0, 0, 0, 1);    // [
        assertMapping(node, 0, 3, 0, 2, 0, 4);    // ,
        assertMapping(node, 0, 9, 0, 7, 0, 9);    // ,
        assertMapping(node, 0, 17, 0, 11, 0, 12); // ]
    }

    @Test
    public void testVisitArrayLiteral_4()
    {
        ArrayLiteralNode node = (ArrayLiteralNode) getExpressionNode(
                "a = [0,\n123, 45]", ArrayLiteralNode.class);
        asBlockWalker.visitLiteral(node);
        //[0, 123, 45]
        assertMapping(node, 0, 0, 0, 0, 0, 1);    // [
        assertMapping(node, 0, 1, 0, 1, 0, 2);    // 0
        assertMapping(node, 0, 2, 0, 2, 0, 4);    // ,
        assertMapping(node, 1, 0, 0, 4, 0, 7);    // 123
        assertMapping(node, 1, 3, 0, 7, 0, 9);    // ,
        assertMapping(node, 1, 5, 0, 9, 0, 11);   // 45
        assertMapping(node, 1, 7, 0, 11, 0, 12);  // 45
    }

    @Test
    public void testVisitUnaryOperatorNode_Typeof()
    {
        IUnaryOperatorNode node = getUnaryNode("typeof(a)");
        asBlockWalker.visitUnaryOperator(node);
        //typeof(a)
        assertMapping(node, 0, 0, 0, 0, 0, 7); // typeof(
        assertMapping(node, 0, 0, 0, 8, 0, 9); // )
    }

    @Test
    public void testVisitUnaryOperatorNode_Typeof_NoParens()
    {
        // TODO (mschmalle) the notation without parenthesis is also valid in AS/JS
        IUnaryOperatorNode node = getUnaryNode("typeof a");
        asBlockWalker.visitUnaryOperator(node);
        //typeof(a)
        assertMapping(node, 0, 0, 0, 0, 0, 7); // typeof(
        assertMapping(node, 0, 0, 0, 8, 0, 9); // )
    }

    @Test
    public void testVisitUnaryOperatorNode_Void()
    {
        IUnaryOperatorNode node = getUnaryNode("void a");
        asBlockWalker.visitUnaryOperator(node);
        assertMapping(node, 0, 0, 0, 0, 0, 5); // void
        assertMapping(node, 0, 5, 0, 5, 0, 6); // a
    }

    @Test
    public void testVisitIterationFlowNode_BreakWithoutLabel()
    {
        IIterationFlowNode node = (IIterationFlowNode) getNode("break",
                IIterationFlowNode.class);
        asBlockWalker.visitIterationFlow(node);
        assertMapping(node, 0, 0, 0, 0, 0, 5); // break
    }

    @Test
    public void testVisitIterationFlowNode_BreakWithLabel()
    {
        IIterationFlowNode node = (IIterationFlowNode) getNode("break label",
                IIterationFlowNode.class);
        asBlockWalker.visitIterationFlow(node);
        assertMapping(node, 0, 0, 0, 0, 0, 6);  // break
        assertMapping(node, 0, 6, 0, 6, 0, 11); // label
    }

    @Test
    public void testVisitIterationFlowNode_ContinueWithoutLabel()
    {
        IIterationFlowNode node = (IIterationFlowNode) getNode("continue",
                IIterationFlowNode.class);
        asBlockWalker.visitIterationFlow(node);
        assertMapping(node, 0, 0, 0, 0, 0, 8); // continue
    }

    @Test
    public void testVisitIterationFlowNode_ContinueWithLabel()
    {
        IIterationFlowNode node = (IIterationFlowNode) getNode("continue label",
                IIterationFlowNode.class);
        asBlockWalker.visitIterationFlow(node);
        assertMapping(node, 0, 0, 0, 0, 0, 9); // continue
        assertMapping(node, 0, 9, 0, 9, 0, 14); // label
    }

    @Test
    public void testVisitReturnWithoutValue()
    {
        IReturnNode node = (IReturnNode) getNode("return", IReturnNode.class);
        asBlockWalker.visitReturn(node);
        assertMapping(node, 0, 0, 0, 0, 0, 6); // return
    }

    @Test
    public void testVisitReturnWithValue()
    {
        IReturnNode node = (IReturnNode) getNode("return 0", IReturnNode.class);
        asBlockWalker.visitReturn(node);
        assertMapping(node, 0, 0, 0, 0, 0, 7); // return
        assertMapping(node, 0, 7, 0, 7, 0, 8); // 0
    }

    @Test
    public void testThrow()
    {
        IThrowNode node = (IThrowNode) getNode("throw a", IThrowNode.class);
        asBlockWalker.visitThrow(node);
        assertMapping(node, 0, 0, 0, 0, 0, 6); // throw
        assertMapping(node, 0, 6, 0, 6, 0, 7); // a
    }

    @Test
    public void testVisitFunctionCall_1()
    {
        IFunctionCallNode node = (IFunctionCallNode) getNode("a()", IFunctionCallNode.class);
        asBlockWalker.visitFunctionCall(node);
        assertMapping(node, 0, 0, 0, 0, 0, 1); // a
        assertMapping(node, 0, 1, 0, 1, 0, 2); // (
        assertMapping(node, 0, 2, 0, 2, 0, 3); // )
    }

    @Test
    public void testVisitFunctionCall_2()
    {
        IFunctionCallNode node = (IFunctionCallNode) getNode("a(b)", IFunctionCallNode.class);
        asBlockWalker.visitFunctionCall(node);
        assertMapping(node, 0, 0, 0, 0, 0, 1); // a
        assertMapping(node, 0, 1, 0, 1, 0, 2); // (
        assertMapping(node, 0, 2, 0, 2, 0, 3); // b
        assertMapping(node, 0, 3, 0, 3, 0, 4); // )
    }

    @Test
    public void testVisitFunctionCall_3()
    {
        IFunctionCallNode node = (IFunctionCallNode) getNode("a(b, c)", IFunctionCallNode.class);
        asBlockWalker.visitFunctionCall(node);
        assertMapping(node, 0, 0, 0, 0, 0, 1); // a
        assertMapping(node, 0, 1, 0, 1, 0, 2); // (
        assertMapping(node, 0, 2, 0, 2, 0, 3); // b
        assertMapping(node, 0, 3, 0, 3, 0, 5); // ,
        assertMapping(node, 0, 5, 0, 5, 0, 6); // c
        assertMapping(node, 0, 6, 0, 6, 0, 7); // )
    }

    protected IBackend createBackend()
    {
        return new RoyaleBackend();
    }
}
