* Copyright (c) 2009 IBM Corporation and others.

* All rights reserved. This program and the accompanying materials

* are made available under the terms of the Eclipse Public License v1.0

* which accompanies this distribution, and is available at

* http://www.eclipse.org/legal/epl-v10.html

*

* Contributors:

*     IBM Corporation - initial API and implementation

*     Zend Technologies

*******************************************************************************/

* AST rewrite test which tests the ASTRewriteAnalyzer implementation.

*

* @author shalom

*/

  protected AST ast;

  protected IDocument document;

  protected Program program;

  public ASTRewriteTests(String name) {

    super(name);

  }

  public static TestSuite suite() {

    return new TestSuite(new Class[] { ASTRewriteTests.class,

        NodeDeletionTests.class, ASTRewriteTestsPHP54.class,

        NodeDeletionTestsPHP54.class, ASTRewriteTestsPHP55.class,

        NodeDeletionTestsPHP55.class, },

        ASTRewriteTests.class.getName());

  }

  // //////////////////////// Tests //////////////////////////

  public void testVariable1() throws Exception {

    String str = "<?php $a; $A;?>";

    initialize(str);

    List<Variable> variables = getAllOfType(program, Variable.class);

    Assert.assertTrue("Unexpected list size.", variables.size() == 2);

    variables.get(1).setName(ast.newIdentifier("B1"));

    rewrite();

    checkResult("<?php $a; $B1;?>");

  }

  public void testVariable2() throws Exception {

    String str = "<?php $AAA;?>";

    initialize(str);

    List<Variable> variables = getAllOfType(program, Variable.class);

    Assert.assertTrue("Unexpected list size.", variables.size() == 1);

    ((Identifier) variables.get(0).getName()).setName("B");

    rewrite();

    checkResult("<?php $B;?>");

  }

  public void testFunctionName() throws Exception {

    String str = "<?php foo(); ?>";

    initialize(str);

    List<FunctionInvocation> invocations = getAllOfType(program,

        FunctionInvocation.class);

    Assert.assertTrue("Unexpected list size.", invocations.size() == 1);

    FunctionName functionName = invocations.get(0).getFunctionName();

    functionName.setName(ast.newIdentifier("boobo"));

    rewrite();

    checkResult("<?php boobo(); ?>");

  }

  public void testFunctionInvocationName() throws Exception {

    String str = "<?php foo(); ?>";

    initialize(str);

    List<FunctionInvocation> invocations = getAllOfType(program,

        FunctionInvocation.class);

    Assert.assertTrue("Unexpected list size.", invocations.size() == 1);

    FunctionInvocation functionInvocation = invocations.get(0);

    functionInvocation.setFunctionName(ast.newFunctionName(ast

        .newIdentifier("boobo")));

    rewrite();

    checkResult("<?php boobo(); ?>");

  }

  public void testFunctionInvocationAddParam() throws Exception {

    String str = "<?php foo( ); ?>";

    initialize(str);

    List<FunctionInvocation> invocations = getAllOfType(program,

        FunctionInvocation.class);

    Assert.assertTrue("Unexpected list size.", invocations.size() == 1);

    FunctionInvocation functionInvocation = invocations.get(0);

    functionInvocation.parameters().add(ast.newVariable("aaa"));

    rewrite();

    checkResult("<?php foo($aaa ); ?>");

  }

  public void testFunctionInvocationAddParams() throws Exception {

    String str = "<?php foo(); ?>";

    initialize(str);

    List<FunctionInvocation> invocations = getAllOfType(program,

        FunctionInvocation.class);

    Assert.assertTrue("Unexpected list size.", invocations.size() == 1);

    FunctionInvocation functionInvocation = invocations.get(0);

    functionInvocation.parameters().add(ast.newVariable("aaa"));

    functionInvocation.parameters().add(ast.newVariable("bbb"));

    functionInvocation.parameters().add(ast.newVariable("ccc"));

    rewrite();

    checkResult("<?php foo($aaa, $bbb, $ccc); ?>");

  }

  public void testFunctionInvocationRemoveParam1() throws Exception {

    String str = "<?php foo($aaa, $bbb); ?>";

    initialize(str);

    List<FunctionInvocation> invocations = getAllOfType(program,

        FunctionInvocation.class);

    Assert.assertTrue("Unexpected list size.", invocations.size() == 1);

    FunctionInvocation functionInvocation = invocations.get(0);

    functionInvocation.parameters().remove(1);

    rewrite();

    checkResult("<?php foo($aaa); ?>");

  }

  public void testFunctionInvocationRemoveParam2() throws Exception {

    String str = "<?php foo($aaa, $bbb); ?>";

    initialize(str);

    List<FunctionInvocation> invocations = getAllOfType(program,

        FunctionInvocation.class);

    Assert.assertTrue("Unexpected list size.", invocations.size() == 1);

    FunctionInvocation functionInvocation = invocations.get(0);

    functionInvocation.parameters().remove(0);

    rewrite();

    checkResult("<?php foo($bbb); ?>");

  }

  public void testFunctionInvocationRemoveParams() throws Exception {

    String str = "<?php foo($aaa, $bbb); ?>";

    initialize(str);

    List<FunctionInvocation> invocations = getAllOfType(program,

        FunctionInvocation.class);

    Assert.assertTrue("Unexpected list size.", invocations.size() == 1);

    FunctionInvocation functionInvocation = invocations.get(0);

    functionInvocation.parameters().clear();

    rewrite();

    checkResult("<?php foo(); ?>");

  }

  public void testVariable3() throws Exception {

    String str = "<?php $myClass->bar();?>";

    initialize(str);

    List<Variable> variables = getAllOfType(program, Variable.class);

    Assert.assertTrue("Unexpected list size.", variables.size() == 2);

    variables.get(1).setName(ast.newIdentifier("foo"));

    variables.get(1).setIsDollared(true);

    variables.get(0).setIsDollared(false);

    rewrite();

    checkResult("<?php myClass->$foo();?>");

  }

  public void testStaticFunctionInvocation() throws Exception {

    String str = "<?php A::foo($a); ?>";

    initialize(str);

    List<StaticMethodInvocation> staticInvocations = getAllOfType(program,

        StaticMethodInvocation.class);

    Assert.assertTrue("Unexpected list size.",

        staticInvocations.size() == 1);

    staticInvocations.get(0).setClassName(ast.newIdentifier("B"));

    ArrayList<Expression> parameters = new ArrayList<Expression>();

    parameters.add(ast.newScalar("b", Scalar.TYPE_STRING));

    parameters.add(ast.newVariable("c"));

    staticInvocations.get(0).setMethod(

        ast.newFunctionInvocation(

            ast.newFunctionName(ast.newIdentifier("bar")),

            parameters));

    rewrite();

    checkResult("<?php B::bar(b,$c); ?>");

  }

  public void testArrayAccessWithoutIndex() throws Exception {

    String str = "<?php $a[]; ?>";

    initialize(str);

    List<ArrayAccess> arrayAccess = getAllOfType(program, ArrayAccess.class);

    Assert.assertTrue("Unexpected list size.", arrayAccess.size() == 1);

    arrayAccess.get(0).setName(ast.newVariable("b"));

    // FIXME - We need to fix the ArrayAccess implementation to reflect any

    // dollared property change

    // on the inner Variable. Also, this might need a fix to the initial

    // creation of the ArrayAccess by the parser.

    // arrayAccess.get(0).setIsDollared(false) should also work after that

    // fix.

    rewrite();

    checkResult("<?php $b[]; ?>");

  }

  public void testArrayAccess() throws Exception {

    String str = "<?php $a[$b]; ?>";

    initialize(str);

    List<ArrayAccess> arrayAccess = getAllOfType(program, ArrayAccess.class);

    Assert.assertTrue("Unexpected list size.", arrayAccess.size() == 1);

    arrayAccess.get(0).setIndex(ast.newScalar("1"));

    rewrite();

    checkResult("<?php $a[1]; ?>");

  }

  public void testArrayVariableMultiIndex() throws Exception {

    String str = "<?php $a[$b][5][3]; ?>";

    initialize(str);

    List<ArrayAccess> arrayAccess = getAllOfType(program, ArrayAccess.class);

    Assert.assertTrue("Unexpected list size.", arrayAccess.size() == 3);

    // TODO - The access to this ArrayAccess is reversed - Check if this is

    // the intended behavior.

    // TODO - Setting the name on an ArrayAccess that is not in the highest

    // index (the first) cuts the array access deep.

    arrayAccess.get(0).setIndex(ast.newVariable("foo"));

    arrayAccess.get(2).setName(ast.newVariable("boo"));

    rewrite();

    checkResult("<?php $boo[$b][5][$foo]; ?>");

  }

  public void testArrayAccessType1() throws Exception {

    String str = "<?php $a[$b]; ?>";

    initialize(str);

    List<ArrayAccess> arrayAccess = getAllOfType(program, ArrayAccess.class);

    Assert.assertTrue("Unexpected list size.", arrayAccess.size() == 1);

    arrayAccess.get(0).setArrayType(ArrayAccess.VARIABLE_HASHTABLE);

    rewrite();

    checkResult("<?php $a{$b}; ?>");

  }

  public void testArrayAccessType2() throws Exception {

    String str = "<?php $a{'name'}; ?>";

    initialize(str);

    List<ArrayAccess> arrayAccess = getAllOfType(program, ArrayAccess.class);

    Assert.assertTrue("Unexpected list size.", arrayAccess.size() == 1);

    arrayAccess.get(0).setArrayType(ArrayAccess.VARIABLE_ARRAY);

    arrayAccess.get(0).setIndex(ast.newScalar("333"));

    rewrite();

    checkResult("<?php $a[333]; ?>");

  }

  public void testListVariable1() throws Exception {

    String str = "<?php list($a,$b)=1; ?>";

    initialize(str);

    List<ListVariable> listVariables = getAllOfType(program,

        ListVariable.class);

    Assert.assertTrue("Unexpected list size.", listVariables.size() == 1);

    listVariables.get(0).variables().add(ast.newVariable("c"));

    listVariables.get(0).variables().remove(0);

    rewrite();

    checkResult("<?php list($b,$c)=1; ?>");

  }

  public void testListVariable2() throws Exception {

    String str = "<?php list($a,$b)=1; ?>";

    initialize(str);

    List<ListVariable> listVariables = getAllOfType(program,

        ListVariable.class);

    Assert.assertTrue("Unexpected list size.", listVariables.size() == 1);

    listVariables.get(0).variables().remove(1);

    rewrite();

    checkResult("<?php list($a)=1; ?>");

  }

  public void testNestedListVariable() throws Exception {

    String str = "<?php list($a, list($b,$c))=1;?>";

    initialize(str);

    List<ListVariable> listVariables = getAllOfType(program,

        ListVariable.class);

    Assert.assertTrue("Unexpected list size.", listVariables.size() == 2);

    ArrayList<VariableBase> variables = new ArrayList<VariableBase>();

    variables.add(ast.newVariable("foo"));

    variables.add(ast.newVariable("bar"));

    listVariables.get(1).variables().add(ast.newListVariable(variables));

    rewrite();

    checkResult("<?php list($a, list($b,$c,list($foo, $bar)))=1;?>");

  }

  public void testAssignmentLeft() throws Exception {

    String str = "<?php $a = 1;?>";

    initialize(str);

    List<Assignment> assignments = getAllOfType(program, Assignment.class);

    Assert.assertTrue("Unexpected list size.", assignments.size() == 1);

    assignments.get(0).setLeftHandSide(ast.newVariable("foo"));

    rewrite();

    checkResult("<?php $foo = 1;?>");

  }

  public void testAssignmentRight() throws Exception {

    String str = "<?php $a = 1;?>";

    initialize(str);

    List<Assignment> assignments = getAllOfType(program, Assignment.class);

    Assert.assertTrue("Unexpected list size.", assignments.size() == 1);

    assignments.get(0).setRightHandSide(ast.newScalar("12345"));

    rewrite();

    checkResult("<?php $a = 12345;?>");

  }

  public void testAssignmentOperator() throws Exception {

    String str = "<?php $a = 1;?>";

    initialize(str);

    List<Assignment> assignments = getAllOfType(program, Assignment.class);

    Assert.assertTrue("Unexpected list size.", assignments.size() == 1);

    assignments.get(0).setOperator(Assignment.OP_MUL_EQUAL);

    rewrite();

    checkResult("<?php $a *= 1;?>");

  }

  public void testReflectionSimple() throws Exception {

    String str = "<?php $$a;?>";

    initialize(str);

    List<ReflectionVariable> reflectionVariables = getAllOfType(program,

        ReflectionVariable.class);

    Assert.assertTrue("Unexpected list size.",

        reflectionVariables.size() == 1);

    reflectionVariables.get(0).setName(ast.newVariable("b"));

    // FIXME ???? - We need to fix the ReflectionVariable implementation to

    // reflect any dollared property change.

    // (similar to the ArrayAccess fix).

    rewrite();

    checkResult("<?php $$b;?>");

  }

  // TODO - Add a test for nested ReflectionVariable once the upper bug is

  // fixed.

  public void testReflectionFunction() throws Exception {

    String str = "<?php $$$bar(); ?>";

    initialize(str);

    List<FunctionInvocation> functionInvocations = getAllOfType(program,

        FunctionInvocation.class);

    Assert.assertTrue("Unexpected list size.",

        functionInvocations.size() == 1);

    functionInvocations.get(0).setFunctionName(

        ast.newFunctionName(ast.newReflectionVariable(ast

            .newReflectionVariable(ast.newVariable("foo")))));

    rewrite();

    checkResult("<?php $$$foo(); ?>");

  }

  public void testReflectionComplex() throws Exception {

    String str = "<?php ${\"var\"};?>";

    initialize(str);

    List<ReflectionVariable> reflectionVariables = getAllOfType(program,

        ReflectionVariable.class);

    Assert.assertTrue("Unexpected list size.",

        reflectionVariables.size() == 1);

    reflectionVariables.get(0).setName(

        ast.newScalar("\"boobo\"", Scalar.TYPE_STRING));

    rewrite();

    checkResult("<?php ${\"boobo\"};?>");

  }

  public void testStaticMemberSimple() throws Exception {

    String str = "<?php MyClass::$a;?>";

    initialize(str);

    List<StaticFieldAccess> fieldsAccess = getAllOfType(program,

        StaticFieldAccess.class);

    Assert.assertTrue("Unexpected list size.", fieldsAccess.size() == 1);

    fieldsAccess.get(0).setField(ast.newVariable("boobo"));

    fieldsAccess.get(0).setClassName(ast.newIdentifier("Foo"));

    rewrite();

    checkResult("<?php Foo::$boobo;?>");

  }

  public void testStaticMemberWithArray() throws Exception {

    String str = "<?php MyClass::$$a[5];?>";

    initialize(str);

    List<StaticFieldAccess> fieldsAccess = getAllOfType(program,

        StaticFieldAccess.class);

    Assert.assertTrue("Unexpected list size.", fieldsAccess.size() == 1);

    fieldsAccess.get(0).setField(

        ast.newReflectionVariable(ast.newArrayAccess(

            ast.newVariable("bar"), ast.newScalar("333"))));

    rewrite();

    checkResult("<?php MyClass::$$bar[333];?>");

  }

  public void testDispatchSimple() throws Exception {

    String str = "<?php $a->$b;?>";

    initialize(str);

    List<FieldAccess> fieldsAccess = getAllOfType(program,

        FieldAccess.class);

    Assert.assertTrue("Unexpected list size.", fieldsAccess.size() == 1);

    fieldsAccess.get(0).setDispatcher(ast.newVariable("boo"));

    fieldsAccess.get(0).setField(ast.newVariable("foo"));

    rewrite();

    checkResult("<?php $boo->$foo;?>");

  }

  public void testDispatchNested() throws Exception {

    String str = "<?php $myClass->foo()->bar(); ?>";

    initialize(str);

    List<MethodInvocation> methodInvocations = getAllOfType(program,

        MethodInvocation.class);

    Assert.assertTrue("Unexpected list size.",

        methodInvocations.size() == 2);

    methodInvocations.get(1).getMethod()

        .setFunctionName(ast.newFunctionName(ast.newScalar("boobo")));

    rewrite();

    checkResult("<?php $myClass->boobo()->bar(); ?>");

  }

  public void testDispatchWithStaticCall() throws Exception {

    String str = "<?php MyClass::$a->foo(); ?>";

    initialize(str);

    List<FunctionInvocation> functionInvocations = getAllOfType(program,

        FunctionInvocation.class);

    Assert.assertTrue("Unexpected list size.",

        functionInvocations.size() == 1);

    functionInvocations.get(0).getFunctionName()

        .setName(ast.newScalar("bar"));

    List<MethodInvocation> methodInvocations = getAllOfType(program,

        MethodInvocation.class);

    Assert.assertTrue("Unexpected list size.",

        methodInvocations.size() == 1);

    ((StaticFieldAccess) methodInvocations.get(0).getDispatcher())

        .getField().setName(ast.newScalar("boobo"));

    rewrite();

    checkResult("<?php MyClass::$boobo->bar(); ?>");

  }

  public void testClone() throws Exception {

    String str = "<?php clone $a; ?>";

    initialize(str);

    List<CloneExpression> cloneExpressions = getAllOfType(program,

        CloneExpression.class);

    Assert.assertTrue("Unexpected list size.", cloneExpressions.size() == 1);

    cloneExpressions.get(0).setExpression(ast.newVariable("bbb"));

    rewrite();

    checkResult("<?php clone $bbb; ?>");

  }

  public void testCastOfVariable() throws Exception {

    String str = "<?php (int) $a; ?>";

    initialize(str);

    List<CastExpression> castExpressions = getAllOfType(program,

        CastExpression.class);

    Assert.assertTrue("Unexpected list size.", castExpressions.size() == 1);

    castExpressions.get(0).setExpression(ast.newVariable("b"));

    castExpressions.get(0).setCastingType(CastExpression.TYPE_STRING);

    rewrite();

    checkResult("<?php (string) $b; ?>");

  }

  public void testCastOfDispatch() throws Exception {

    String str = "<?php (string) $b->foo(); ?>";

    initialize(str);

    List<CastExpression> castExpressions = getAllOfType(program,

        CastExpression.class);

    Assert.assertTrue("Unexpected list size.", castExpressions.size() == 1);

    castExpressions.get(0).setCastingType(CastExpression.TYPE_INT);

    rewrite();

    checkResult("<?php (int) $b->foo(); ?>");

  }

  public void testClassConstant() throws Exception {

    String str = "<?php $a = MyClass::MY_CONST; ?>";

    initialize(str);

    List<StaticConstantAccess> staticConstants = getAllOfType(program,

        StaticConstantAccess.class);

    Assert.assertTrue("Unexpected list size.", staticConstants.size() == 1);

    ((Identifier) staticConstants.get(0).getClassName()).setName("Foo");

    staticConstants.get(0).setConstant(ast.newIdentifier("BAR_CONST"));

    rewrite();

    checkResult("<?php $a = Foo::BAR_CONST; ?>");

  }

  public void testPostfixSimple() throws Exception {

    String str = "<?php $a++;?>";

    initialize(str);

    List<PostfixExpression> postfixExp = getAllOfType(program,

        PostfixExpression.class);

    Assert.assertTrue("Unexpected list size.", postfixExp.size() == 1);

    postfixExp.get(0).setOperator(PostfixExpression.OP_DEC);

    postfixExp.get(0).setVariable(ast.newVariable("b"));

    rewrite();

    checkResult("<?php $b--;?>");

  }

  public void testPostfixWithFunction() throws Exception {

    String str = "<?php foo()--;?>";

    initialize(str);

    List<PostfixExpression> postfixExp = getAllOfType(program,

        PostfixExpression.class);

    Assert.assertTrue("Unexpected list size.", postfixExp.size() == 1);

    postfixExp.get(0).setOperator(PostfixExpression.OP_INC);

    ((FunctionInvocation) postfixExp.get(0).getVariable())

        .setFunctionName(ast.newFunctionName(ast.newScalar("bar")));

    rewrite();

    checkResult("<?php bar()++;?>");

  }

  public void testPrefixSimple() throws Exception {

    String str = "<?php ++$a;?>";

    initialize(str);

    List<PrefixExpression> prefixExp = getAllOfType(program,

        PrefixExpression.class);

    Assert.assertTrue("Unexpected list size.", prefixExp.size() == 1);

    prefixExp.get(0).setOperator(PrefixExpression.OP_DEC);

    rewrite();

    checkResult("<?php --$a;?>");

  }

  public void testUnaryOperationSimple() throws Exception {

    String str = "<?php +$a;?>";

    initialize(str);

    List<UnaryOperation> ops = getAllOfType(program, UnaryOperation.class);

    Assert.assertTrue("Unexpected list size.", ops.size() == 1);

    ops.get(0).setOperator(UnaryOperation.OP_TILDA);

    ops.get(0).setExpression(ast.newVariable("b"));

    rewrite();

    checkResult("<?php ~$b;?>");

  }

  public void testUnaryOperationWithFunction() throws Exception {

    String str = "<?php -foo(); ?>";

    initialize(str);

    List<UnaryOperation> ops = getAllOfType(program, UnaryOperation.class);

    Assert.assertTrue("Unexpected list size.", ops.size() == 1);

    ops.get(0).setOperator(UnaryOperation.OP_NOT);

    rewrite();

    checkResult("<?php !foo(); ?>");

  }

  public void testUnaryOperationComplex() throws Exception {

    String str = "<?php +-+-$b;?>";

    initialize(str);

    List<UnaryOperation> ops = getAllOfType(program, UnaryOperation.class);

    Assert.assertTrue("Unexpected list size.", ops.size() == 4);

    ops.get(2).setOperator(UnaryOperation.OP_TILDA);

    ops.get(0).setOperator(UnaryOperation.OP_NOT);

    rewrite();

    checkResult("<?php !-~-$b;?>");

  }

  public void testClassInstanciationSimple() throws Exception {

    String str = "<?php new MyClass(); ?>";

    initialize(str);

    List<ClassInstanceCreation> instanciations = getAllOfType(program,

        ClassInstanceCreation.class);

    Assert.assertTrue("Unexpected list size.", instanciations.size() == 1);

    instanciations.get(0).getClassName().setClassName(ast.newScalar("Foo"));

    rewrite();

    checkResult("<?php new Foo(); ?>");

  }

  public void testClassInstanciationAddParam() throws Exception {

    String str = "<?php new MyClass(); ?>";

    initialize(str);

    List<ClassInstanceCreation> instanciations = getAllOfType(program,

        ClassInstanceCreation.class);

    Assert.assertTrue("Unexpected list size.", instanciations.size() == 1);

    instanciations.get(0).ctorParams().add(ast.newVariable("foo"));

    instanciations.get(0).ctorParams().add(ast.newVariable("bar"));

    rewrite();

    checkResult("<?php new MyClass($foo, $bar); ?>");

  }

  public void testClassInstanciationVariable() throws Exception {

    String str = "<?php new $a('start'); ?>";

    initialize(str);

    List<ClassInstanceCreation> instanciations = getAllOfType(program,

        ClassInstanceCreation.class);

    Assert.assertTrue("Unexpected list size.", instanciations.size() == 1);

    instanciations.get(0).ctorParams().add(ast.newScalar("'hello'"));

    instanciations.get(0).setClassName(

        ast.newClassName(ast.newVariable("b")));

    rewrite();

    checkResult("<?php new $b('start', 'hello'); ?>");

  }

  public void testClassInstanciationVariableRemove() throws Exception {

    String str = "<?php new $a('start','end'); ?>";

    initialize(str);

    List<ClassInstanceCreation> instanciations = getAllOfType(program,

        ClassInstanceCreation.class);

    Assert.assertTrue("Unexpected list size.", instanciations.size() == 1);

    instanciations.get(0).ctorParams().remove(1);

    rewrite();

    checkResult("<?php new $a('start'); ?>");

  }

  public void testClassInstanciationFunction() throws Exception {

    String str = "<?php new $a->$b(1, $a); ?>";

    initialize(str);

    List<ClassInstanceCreation> instanciations = getAllOfType(program,

        ClassInstanceCreation.class);

    Assert.assertTrue("Unexpected list size.", instanciations.size() == 1);

    instanciations.get(0).ctorParams().add(0, ast.newScalar("'Welcome'"));

    rewrite();

    checkResult("<?php new $a->$b('Welcome', 1, $a); ?>");

  }

  public void testRefernceSimple() throws Exception {

    String str = "<?php $b = &$a;?>";

    initialize(str);

    List<Reference> references = getAllOfType(program, Reference.class);

    Assert.assertTrue("Unexpected list size.", references.size() == 1);

    references.get(0).setExpression(ast.newVariable("foo"));

    rewrite();

    checkResult("<?php $b = &$foo;?>");

  }

  public void testRefernceWithFunction() throws Exception {

    String str = "<?php $g = &$foo(); ?>";

    initialize(str);

    List<Reference> references = getAllOfType(program, Reference.class);

    Assert.assertTrue("Unexpected list size.", references.size() == 1);

    references.get(0).setExpression(

        ast.newFunctionInvocation(

            ast.newFunctionName(ast.newVariable("bar")), null));

    rewrite();

    checkResult("<?php $g = &$bar(); ?>");

  }

  public void testRefernceInstanciation() throws Exception {

    String str = "<?php $b = &new MyClass(); ?>";

    initialize(str);

    List<Reference> references = getAllOfType(program, Reference.class);

    Assert.assertTrue("Unexpected list size.", references.size() == 1);

    ((ClassInstanceCreation) references.get(0).getExpression())

        .ctorParams().add(ast.newVariable("boobo"));

    rewrite();

    checkResult("<?php $b = &new MyClass($boobo); ?>");

  }

  public void testInstanceofSimple() throws Exception {

    String str = "<?php $a instanceof MyClass;?>";

    initialize(str);

    List<InstanceOfExpression> instanceOf = getAllOfType(program,

        InstanceOfExpression.class);

    Assert.assertTrue("Unexpected list size.", instanceOf.size() == 1);

    instanceOf.get(0).getClassName()

        .setClassName(ast.newScalar("Foo", Scalar.TYPE_STRING));

    instanceOf.get(0).setExpression(ast.newVariable("b"));

    rewrite();

    checkResult("<?php $b instanceof Foo;?>");

  }

  public void testIgnoreError() throws Exception {

    String str = "<?php @$a->foo(); ?>";

    initialize(str);

    List<IgnoreError> ignoreErrors = getAllOfType(program,

        IgnoreError.class);

    Assert.assertTrue("Unexpected list size.", ignoreErrors.size() == 1);

    ignoreErrors.get(0).setExpression(

        ast.newFunctionInvocation(

            ast.newFunctionName(ast.newScalar("bar")), null));

    rewrite();

    checkResult("<?php @bar(); ?>");

  }

  public void testInclude() throws Exception {

    String str = "<?php include('myFile.php'); ?>";

    initialize(str);

    List<Include> includes = getAllOfType(program, Include.class);

    Assert.assertTrue("Unexpected list size.", includes.size() == 1);

    includes.get(0).setExpression(ast.newScalar("'newFile.php'"));

    includes.get(0).setIncludetype(Include.IT_INCLUDE_ONCE);

    rewrite();

    checkResult("<?php include_once 'newFile.php'; ?>");

  }

  public void testIncludeWithParenthesis1() throws Exception {

    String str = "<?php include('myFile.php'); ?>";

    initialize(str);

    List<Include> includes = getAllOfType(program, Include.class);

    Assert.assertTrue("Unexpected list size.", includes.size() == 1);

    includes.get(0).setExpression(

        ast.newParenthesisExpression(ast.newScalar("'newFile.php'")));

    includes.get(0).setIncludetype(Include.IT_REQUIRE);

    rewrite();

    checkResult("<?php require('newFile.php'); ?>");

  }

  public void testIncludeWithParenthesis2() throws Exception {

    String str = "<?php include 'myFile.php'; ?>";

    initialize(str);

    List<Include> includes = getAllOfType(program, Include.class);

    Assert.assertTrue("Unexpected list size.", includes.size() == 1);

    includes.get(0).setExpression(

        ast.newParenthesisExpression(ast.newScalar("'file.php'")));

    includes.get(0).setIncludetype(Include.IT_REQUIRE_ONCE);