src/main/java/resources/CalculatorResource.java

 package resources;
 
+
+
 import javax.ws.rs.Consumes;
 import javax.ws.rs.POST;
 import javax.ws.rs.Path;
@@ -12,49 +14,90 @@ import javax.ws.rs.core.MediaType;
 @Path("/calculator")
 public class CalculatorResource {
 
-    /**
-     * Method handling HTTP POST requests. The calculated answer to the expression will be sent to the client as
-     * plain/text.
-     * @param expression the expression to be solved as plain/text.
-     * @return solution to the expression as plain/text or -1 on error
+/**
+ * Method handling HTTP POST requests. The calculated answer to the expression will be sent to the client as
+ * plain/text.
+ *
+ * @param expression the expression to be solved as plain/text.
+ * @return solution to the expression as plain/text or -1 on error
+ */
+@POST
+@Consumes(MediaType.TEXT_PLAIN)
+@Produces(MediaType.TEXT_PLAIN)
+public int calculate(String expression) {
+    // Removes all whitespaces
+    String expressionTrimmed = expression.replaceAll("\\s+", "");
+
+    int result = -1;
+
+    /*
+     * .matches use regex expression to decide if a String matches a given pattern.
+     * [0-9]+[+][0-9]+ explained:
+     * [0-9]+: a number from 0-9 one or more times. For example 1, 12 and 123.
+     * [+]: the operator + one time.
+     * The total regex expression accepts for example:
+     * 12+34,
+     * 1+2,
+     * 10000+1000
      */
-    @POST
-    @Consumes(MediaType.TEXT_PLAIN)
-    @Produces(MediaType.TEXT_PLAIN)
-    public int calculate(String expression){
-        // Removes all whitespaces
-        String expressionTrimmed = expression.replaceAll("\\s+","");
-
-        int result = -1;
-
-        /*
-         * .matches use regex expression to decide if a String matches a given pattern.
-         * [0-9]+[+][0-9]+ explained:
-         * [0-9]+: a number from 0-9 one or more times. For example 1, 12 and 123.
-         * [+]: the operator + one time.
-         * The total regex expression accepts for example:
-         * 12+34,
-         * 1+2,
-         * 10000+1000
-         */
-        if(expressionTrimmed.matches("[0-9]+[+][0-9]+")) result = sum(expressionTrimmed);
-        else if(expressionTrimmed.matches("[0-9]+[-][0-9]+")) result = subtraction(expressionTrimmed);
-
-        return result;
-    }
+
+    if (expressionTrimmed.matches("^\\d+(?:\\s*[+]\\s*\\d+)*$")) result = sum(expressionTrimmed);
+    else if (expressionTrimmed.matches("^\\d+(?:\\s*[-]\\s*\\d+)*$")) result = subtraction(expressionTrimmed);
+    else if (expressionTrimmed.matches("^\\d+(?:\\s*[*]\\s*\\d+)*$")) result = multiplication(expressionTrimmed);
+    else if (expressionTrimmed.matches("^\\d+(?:\\s*[/]\\s*\\d+)*$")) result = division(expressionTrimmed);
+
+    return result;
+}
+
+    public int multiplication(String equation) {
+    String[] split = equation.split("[*]");
+    int sum = Integer.parseInt(split[0]);
+    try{
+        for (int i = 1; i < split.length; i++) {
+            if(!(split[i]).equals("0")) {
+                sum *= Integer.parseInt(split[i]);
+            }else throw new IllegalArgumentException(" Number can't be zero");
+        }
+
+        return sum;
+        }catch(IllegalArgumentException e){
+            e.printStackTrace();
+    }return -1;
+
+}
+
+    public int division(String equation){
+    String[] split = equation.split("[/]");
+    try{
+        int sum = Integer.parseInt(split[0]);
+        for (int i = 1; i < split.length; i++) {
+            if(!(split[i]).equals("0")){
+                sum = Integer.parseInt(split[i]);
+            }else throw new IllegalArgumentException("Number can't be zero");
+
+        }
+
+        return sum;
+    }catch (IllegalArgumentException e){
+        e.printStackTrace();
+    }return -1;
+
+}
 
     /**
      * Method used to calculate a sum expression.
      * @param expression the equation to be calculated as a String
      * @return the answer as an int
      */
-    public int sum(String expression){
+    public int sum (String expression){
         String[] split = expression.split("[+]");
+        int sum = Integer.parseInt(split[0]);
+        for (int i = 1; i < split.length; i++) {
+            sum += Integer.parseInt(split[i]);
 
-        int number1 = Integer.parseInt(split[0]);
-        int number2 = Integer.parseInt(split[1]);
+        }
 
-        return number1 + number2;
+        return sum;
     }
 
     /**
@@ -62,12 +105,14 @@ public class CalculatorResource {
      * @param expression the expression to be calculated as a String
      * @return the answer as an int
      */
-    public int subtraction(String expression){
+    public int subtraction (String expression){
         String[] split = expression.split("[-]");
+        int sum = Integer.parseInt(split[0]);
+        for (int i = 1; i < split.length; i++) {
+            sum -= Integer.parseInt(split[i]);
+        }
 
-        int number1 = Integer.parseInt(split[0]);
-        int number2 = Integer.parseInt(split[1]);
 
-        return number1 - number2;
+        return sum;
     }
 }

src/main/webapp/app.html

@@ -17,8 +17,8 @@
             </div>
             <div class="menu">
                 <ul>
-                    <li><a href="#">Ressursovervåking</a></li>
-                    <li><a href="#">Logg</a></li>
+                    <li><a href="http://129.241.97.157:61208/">Ressursovervåking</a></li>
+                    <li><a href="http://129.241.97.157:3000/d/000000002/glances/">Logg</a></li>
                     <li><a href="./settings.html">Innstillinger</a></li>
                     <li><a href="/">Logg ut</a></li>
                 </ul>

src/test/java/CalculatorResourceTest.java

@@ -12,8 +12,8 @@ public class CalculatorResourceTest{
         String expression = "100+300";
         assertEquals(400, calculatorResource.calculate(expression));
 
-        expression = " 300 - 99 ";
-        assertEquals(201, calculatorResource.calculate(expression));
+        expression = " 300 - 99 - 100";
+        assertEquals(101, calculatorResource.calculate(expression));
     }
 
     @Test
@@ -23,8 +23,8 @@ public class CalculatorResourceTest{
         String expression = "100+300";
         assertEquals(400, calculatorResource.sum(expression));
 
-        expression = "300+99";
-        assertEquals(400, calculatorResource.sum(expression));
+        expression = "300+99+100";
+        assertEquals(499, calculatorResource.sum(expression));
     }
 
     @Test
@@ -34,7 +34,24 @@ public class CalculatorResourceTest{
         String expression = "999-100";
         assertEquals(899, calculatorResource.subtraction(expression));
 
-        expression = "20-2";
-        assertEquals(200, calculatorResource.subtraction(expression));
+        expression = "20-2-8";
+        assertEquals(10, calculatorResource.subtraction(expression));
+    }
+
+    @Test
+    public void testMultiplication(){
+        CalculatorResource calculatorResource = new CalculatorResource();
+
+        String equation = "5*5*10";
+        assertEquals(250, calculatorResource.multiplication(equation));
     }
+
+    @Test
+    public void testDivision(){
+        CalculatorResource calculatorResource = new CalculatorResource();
+
+        String equation = "16/4/2";
+        assertEquals(2, calculatorResource.division(equation));
+    }
+
 }