added method executor; tests

common/src/main/java/com/uqac/rthoni/java_rmi/common/Command.java

 package com.uqac.rthoni.java_rmi.common;
 
 import java.io.Serializable;
+import java.util.Arrays;
+import java.util.Collections;
 import java.util.Vector;
 import java.util.stream.Collectors;
 
         return _arguments.get(i);
     }
 
+    public Vector<String> getArgmumentAsList(int i)
+    {
+        return new Vector<String>(Arrays.asList(_arguments.get(i).split(",")));
+    }
+
     public void setResult(String result)
     {
         _result = result;

common/src/main/java/com/uqac/rthoni/java_rmi/common/ReflectionUtil.java

 
         return classList;
     }
+
+    public static Object toObject(Class className, String value)
+    {
+        if (className == Boolean.class || className == boolean.class) {
+            return Boolean.parseBoolean(value);
+        }
+        if (className == Byte.class || className == byte.class) {
+            return Byte.parseByte(value);
+        }
+        if (className == Short.class || className == short.class) {
+            return Short.parseShort(value);
+        }
+        if (className == Integer.class || className == int.class) {
+            return Integer.parseInt(value);
+        }
+        if (className == Long.class || className == long.class) {
+            return Long.parseLong(value);
+        }
+        if (className == Float.class || className == float.class) {
+            return Float.parseFloat(value);
+        }
+        if (className == Double.class || className == double.class) {
+            return Double.parseDouble(value);
+        }
+        return value;
+    }
+
+    public static Class getClass(String className) throws ClassNotFoundException {
+        if (className.equals("boolean")) {
+            return boolean.class;
+        }
+        if (className.equals("byte")) {
+            return byte.class;
+        }
+        if (className.equals("short")) {
+            return short.class;
+        }
+        if (className.equals("int")) {
+            return int.class;
+        }
+        if (className.equals("long")) {
+            return long.class;
+        }
+        if (className.equals("float")) {
+            return float.class;
+        }
+        if (className.equals("double")) {
+            return double.class;
+        }
+        return Class.forName(className);
+    }
 }

server/pom.xml

     <modelVersion>4.0.0</modelVersion>
 
     <artifactId>server</artifactId>
+    <dependencies>
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>4.12</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
 
 
 </project>

server/server.iml

     </content>
     <orderEntry type="inheritedJdk" />
     <orderEntry type="sourceFolder" forTests="false" />
+    <orderEntry type="library" scope="TEST" name="Maven: junit:junit:4.12" level="project" />
+    <orderEntry type="library" scope="TEST" name="Maven: org.hamcrest:hamcrest-core:1.3" level="project" />
     <orderEntry type="module" module-name="common" />
   </component>
 </module>

server/src/main/java/com/uqac/rthoni/java_rmi/server/ServerApplication.java

         }
     }
 
-    private void loadExecutors() throws ClassNotFoundException
+    public void loadExecutors() throws ClassNotFoundException
     {
         _executors = new Vector<>();
         Vector<Class> classes = AbstractCommandExecutor.getAllExecutors();
         }
     }
 
-    private void runServer(ServerSocket serverSocket)
+    public void runServer(ServerSocket serverSocket)
     {
         while (true) {
             Socket client = null;
         }
     }
 
-    private void handleClient(Socket client)
+    public void handleClient(Socket client)
     {
         String str;
         try {
         }
     }
 
-    private AbstractCommandExecutor getExecutor(Command command)
+    public AbstractCommandExecutor getExecutor(Command command)
     {
         for (AbstractCommandExecutor executor : _executors) {
             if (executor.getCommandName().equals(command.getCommandName())) {
         return null;
     }
 
-    private void handleCommand(Command command, Socket client)
+    public void handleCommand(Command command, Socket client)
     {
         String data;
         AbstractCommandExecutor executor = getExecutor(command);

server/src/main/java/com/uqac/rthoni/java_rmi/server/TestDbo.java

     public void setPrivateInt(int privateInt) {
         this.privateInt = privateInt;
     }
+
+    public void setPrivateInteger(Integer privateInt) {
+        this.privateInt = privateInt;
+    }
 }

server/src/main/java/com/uqac/rthoni/java_rmi/server/executors/MethodExecutor.java

+package com.uqac.rthoni.java_rmi.server.executors;
+
+import com.uqac.rthoni.java_rmi.common.Command;
+import com.uqac.rthoni.java_rmi.common.ReflectionUtil;
+import com.uqac.rthoni.java_rmi.server.ServerApplication;
+import javafx.util.Pair;
+
+import java.lang.reflect.Method;
+import java.util.List;
+import java.util.stream.Collectors;
+
+/**
+ * Created by robin on 9/16/16.
+ */
+public class MethodExecutor extends AbstractCommandExecutor {
+    @Override
+    public String getCommandName() {
+        return "fonction";
+    }
+
+    @Override
+    public String run(Command command, ServerApplication server) throws Exception {
+        String id = command.getArgument(0);
+        String methodName = command.getArgument(1);
+        Object obj = server.getObject(id);
+        List<Pair<Class, String>> argClasses = command.getArgmumentAsList(2).stream().map(v -> {
+            String[] split = v.split(":");
+            try {
+                return new Pair<>(ReflectionUtil.getClass(split[0]), split[1]);
+            } catch (ClassNotFoundException e) {
+                return null;
+            }
+        }).collect(Collectors.toList());
+        List<Object> arguments = argClasses.stream().map(p -> {
+            String value = p.getValue();
+            if (value.startsWith("ID(") && value.endsWith(")")) {
+                value = value.substring(3, value.length() - 2);
+                return server.getObject(value);
+            }
+            return ReflectionUtil.toObject(p.getKey(), value);
+        }).collect(Collectors.toList());
+        List<Class> classes = argClasses.stream().map(Pair::getKey).collect(Collectors.toList());
+
+        Method method = obj.getClass().getDeclaredMethod(methodName, classes.toArray(new Class[classes.size()]));
+        Object result = method.invoke(obj, arguments.toArray());
+
+        return (result == null ? "NULL" : result.toString());
+    }
+}

server/src/main/java/com/uqac/rthoni/java_rmi/server/executors/WriteExecutor.java

 package com.uqac.rthoni.java_rmi.server.executors;
 
 import com.uqac.rthoni.java_rmi.common.Command;
+import com.uqac.rthoni.java_rmi.common.ReflectionUtil;
 import com.uqac.rthoni.java_rmi.server.ServerApplication;
 
 import java.lang.reflect.Field;
         Object obj = server.getObject(id);
         Class objClass = obj.getClass();
         Field field = objClass.getDeclaredField(fieldName);
+        Object typedValue = ReflectionUtil.toObject(field.getDeclaringClass(), value);
 
         try {
-            field.set(obj, value);
+            field.set(obj, typedValue);
         } catch (IllegalAccessException e) {
-            try {
-                Method method = objClass.getDeclaredMethod(methodName, String.class);
-                method.invoke(obj, value);
-            }
-            catch (NoSuchMethodException e2) {
-                try {
-                    Method method = objClass.getDeclaredMethod(methodName, int.class);
-                    method.invoke(obj, Integer.parseInt(value));
-                }
-                catch (NoSuchMethodException e3) {
-                    try {
-                        Method method = objClass.getDeclaredMethod(methodName, float.class);
-                        method.invoke(obj, Float.parseFloat(value));
-                    }
-                    catch (NoSuchMethodException e4) {
-                        try {
-                            Method method = objClass.getDeclaredMethod(methodName, boolean.class);
-                            method.invoke(obj, Boolean.parseBoolean(value));
-                        }
-                        catch (NoSuchMethodException e5) {
-                            throw new Exception("No such setter");
-                        }
-                    }
-                }
-            }
+            Method method = objClass.getDeclaredMethod(methodName, typedValue.getClass());
+            method.invoke(obj, typedValue);
         }
 
         return null;

server/src/test/java/com/uqac/rthoni/java_rmi/server/executors/NewInstanceExecutorTest.java

+package com.uqac.rthoni.java_rmi.server.executors;
+
+import com.uqac.rthoni.java_rmi.common.Command;
+import com.uqac.rthoni.java_rmi.server.ServerApplication;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+/**
+ * Created by robin on 9/16/16.
+ */
+public class NewInstanceExecutorTest {
+
+    public String runCommand(String str, ServerApplication app) throws Exception {
+        Command command = Command.fromString(str);
+        AbstractCommandExecutor executor = app.getExecutor(command);
+        return executor.run(command, app);
+    }
+
+    public ServerApplication getServer() throws Exception {
+        ServerApplication app = new ServerApplication();
+        app.loadExecutors();
+        return app;
+    }
+
+    @Test
+    public void test1() throws Exception
+    {
+        ServerApplication app = getServer();
+        String res = runCommand("creation#com.uqac.rthoni.java_rmi.server.TestDbo#test", app);
+        assertNull(res);
+        Object obj = app.getObject("test");
+        assertNotNull(obj);
+    }
+
+    @Test
+    public void test2() throws Exception
+    {
+        ServerApplication app = getServer();
+        String res = runCommand("creation#java.lang.String#mystr", app);
+        assertNull(res);
+        Object obj = app.getObject("mystr");
+        assertNotNull(obj);
+        assertEquals(obj.toString(), "");
+    }
+
+    @Test(expected = ClassNotFoundException.class)
+    public void test3() throws Exception
+    {
+        runCommand("creation#not_existing_class#myobj", getServer());
+    }
+
+}