package net.sourceforge.jenesis4java.impl;
   
   /*
    * #%L
    * Jenesis 4 Java Code Generator
    * %%
    * Copyright (C) 2000 - 2016 jenesis4java
    * %%
    * This program is free software: you can redistribute it and/or modify
   * it under the terms of the GNU Lesser General Public License as
   * published by the Free Software Foundation, either version 3 of the
   * License, or (at your option) any later version.
   * 
   * This program is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   * GNU General Lesser Public License for more details.
   * 
   * You should have received a copy of the GNU General Lesser Public
   * License along with this program.  If not, see
   * <http://www.gnu.org/licenses/lgpl-3.0.html>.
   * #L%
   */
  
  import net.sourceforge.jenesis4java.Expression;
  import net.sourceforge.jenesis4java.Invoke;
  import net.sourceforge.jenesis4java.VirtualMachine;
  import net.sourceforge.jenesis4java.util.InstanceReplacingVisitor;
  import net.sourceforge.jenesis4java.util.WithVmAndMethod;
  import org.junit.Before;
  import org.junit.Test;
  import org.junit.experimental.runners.Enclosed;
  import org.junit.runner.RunWith;
  
  import java.util.Arrays;
  import java.util.Collections;
  
  import static java.util.Collections.singletonList;
  import static org.junit.Assert.assertEquals;
  import static org.junit.Assert.assertSame;
  
  @RunWith(Enclosed.class)
  public class InvokeTest {
  
      public static class BasicSyntax extends WithVmAndMethod {
  
          @Test
          public void withoutParameters() {
              assertEquals("method()", vm.newInvoke("method").toString());
          }
  
          @Test
          public void withOneParameter() {
              Invoke invoke = vm.newInvoke("method");
              invoke.addVariableArg("param");
              assertEquals("method(param)", invoke.toString());
          }
  
          @Test
          public void withMultipleParameters() {
              Invoke invoke = vm.newInvoke("method");
              invoke.addVariableArg("first");
              invoke.addVariableArg("second");
              assertEquals("method(first, second)", invoke.toString());
          }
      }
  
      public static class ParameterShortcuts {
  
          private Invoke invoke;
  
          @Before
          public void setUp() {
              this.invoke = VirtualMachine.getVirtualMachine().newInvoke("method");
          }
  
          @Test
          public void booleanParam() {
              Invoke returned = invoke.addArg(true);
              assertEquals("method(true)", invoke.toString());
              assertSame(invoke, returned);
          }
  
          @Test
          public void intParam() {
              Invoke returned = invoke.addArg(123);
              assertEquals("method(123)", invoke.toString());
              assertSame(invoke, returned);
          }
  
          @Test
          public void longParam() {
              Invoke returned = invoke.addArg(123L);
              assertEquals("method(123L)", invoke.toString());
              assertSame(invoke, returned);
          }
  
          @Test
          public void doubleParam() {
             Invoke returned = invoke.addArg(123.4d);
             assertEquals("method(123.4D)", invoke.toString());
             assertSame(invoke, returned);
         }
 
         @Test
         public void floatParam() {
             Invoke returned = invoke.addArg(123.0f);
             assertEquals("method(123.0F)", invoke.toString());
             assertSame(invoke, returned);
         }
 
         @Test
         public void stringParam() {
             Invoke returned = invoke.addArg("string");
             assertEquals("method(\"string\")", invoke.toString());
             assertSame(invoke, returned);
         }
 
         @Test
         public void variableParam() {
             Invoke returned = invoke.addVariableArg("param");
             assertEquals("method(param)", invoke.toString());
             assertSame(invoke, returned);
         }
     }
 
     public static class ArgumentOrder {
 
         private VirtualMachine vm;
 
         private Invoke invoke;
 
         @Before
         public void setUp() {
             this.vm = VirtualMachine.getVirtualMachine();
             this.invoke = vm.newInvoke("method");
         }
 
         @Test
         public void getNoArguments() {
             assertEquals(Collections.emptyList(), invoke.getArgs());
         }
 
         @Test
         public void getMultipleArgs() {
             Expression arg1 = vm.newInt(1);
             Expression arg2 = vm.newInt(2);
             invoke.addArg(arg1).addArg(arg2);
             assertEquals(Arrays.asList(arg1, arg2), invoke.getArgs());
         }
 
         @Test(expected = IllegalArgumentException.class)
         public void removeArgIllegalNumber() {
             invoke.removeArg(-1);
         }
 
         @Test
         public void removeArg() {
             Expression arg1 = vm.newInt(1);
             Expression arg2 = vm.newInt(2);
             invoke.addArg(arg1).addArg(arg2);
             invoke.removeArg(0);
             assertEquals(singletonList(arg2), invoke.getArgs());
         }
     }
 
     public static class Accessor extends WithVmAndMethod {
 
         @Test
         public void setAndGetQualifier() {
             Invoke invoke = vm.newInvoke("method");
             invoke.setQualifier("qualifier");
             assertEquals("qualifier", invoke.getQualifier());
 
             // TODO: this is somewhat inconsistent
             // why distinguish between String and Expression?
             assertEquals(null, invoke.getQualExpression());
         }
 
         @Test
         public void getQualifyingExpression() {
             Expression qualifier = vm.newString("qualifier");
             Invoke invoke = vm.newInvoke(qualifier, "method");
             assertEquals(qualifier, invoke.getQualExpression());
 
             // TODO: this is somewhat inconsistent
             // why not return a string version of the qualifier here?
             assertEquals(null, invoke.getQualifier());
         }
 
     }
 
     public static class Visitor extends WithVmAndMethod {
 
         @Test
         public void replaceArgument() {
             Invoke invoke = vm.newInvoke("method");
 
             Expression arg1 = vm.newInt(1);
             invoke.addArg(arg1);
 
             Expression arg2 = vm.newInt(2);
             invoke.visit(new InstanceReplacingVisitor(arg1, arg2));
 
             assertEquals(singletonList(arg2), invoke.getArgs());
         }
 
         @Test
         public void replaceQualifierExpression() {
             Expression qualifier = vm.newString("qualifier");
             Invoke invoke = vm.newInvoke(qualifier, "method");
 
             Expression qualifierReplacement = vm.newString("anotherQualifier");
             invoke.visit(new InstanceReplacingVisitor(qualifier, qualifierReplacement));
 
             assertEquals(qualifierReplacement, invoke.getQualExpression());
         }
 
     }
 }