Added few functions to the CalcSkin Project. UI is running good.

src/main/java/rocks/zipcode/calcskin/CalcEngine.java

@@ -5,19 +5,68 @@ public class CalcEngine {
     CalcEngine() {
     }
 
-    public double add(double v, double v1) {
-        return Double.NaN;
+    public static double addition(double x, double y) {
+        return (x + y);
     }
 
-    public double subtract(double v, double v1) {
-        return Double.NaN;
+    public static double subtraction(double x, double y) {
+        return (x - y);
     }
 
-    public double multiply(double v, double v1) {
-        return Double.NaN;
+    public static double multiplication(double x, double y) {
+
+        return (x * y);
+    }
+
+    public static double division(double x, double y) {
+        return (x / y);
     }
 
-    public double divide(double v, double v1) {
-        return Double.NaN;
+    public static double square(double x) {
+        return Math.pow(x, 2);
     }
+
+    public static double squareroot(double x) {
+        return Math.sqrt(x);
+    }
+
+    public static double exponent(double x, double y) {
+
+        return Math.pow(x, y);
+    }
+
+    public static double inverse(double x) {
+        return (1 / x);
+    }
+
+    public static double invert(double x) {
+        return (-x);
+    }
+
+/*
+    public static double findSin(double x) {
+        return Math.sin(x);
+    }
+
+    public static double findCos(double x) {
+        return Math.cos(x);
+    }
+
+    public static double findTan(double x) {
+        return Math.tan(x);
+    }
+
+    public static double findAsin(double x) {
+        return Math.asin(x);
+    }
+
+    public static double findAcos(double x) {
+        return Math.acos(x);
+    }
+
+    public static double findAtan(double x) {
+        return Math.atan(x);
+    }
+*/
+
 }

src/main/java/rocks/zipcode/calcskin/CalcSkin.java

@@ -13,6 +13,7 @@ import javafx.scene.layout.*;
 import javafx.stage.Stage;
 import javafx.stage.StageStyle;
 import rocks.zipcode.calcskin.CalcEngine;
+import sun.print.CUPSPrinter;
 
 import java.util.HashMap;
 import java.util.Map;
@@ -27,7 +28,8 @@ public class CalcSkin extends Application {
             { "7", "8", "9", "/" },
             { "4", "5", "6", "*" },
             { "1", "2", "3", "-" },
-            { "0", "c", "=", "+" }
+            { "0", "c", "=", "+" },
+            { "√", "^", "~", "²"}
     };
 
     private final Map<String, Button> accelerators = new HashMap<>();
@@ -36,7 +38,7 @@ public class CalcSkin extends Application {
     private DoubleProperty currentValue = new SimpleDoubleProperty();
     private CalcEngine calcEngine = new CalcEngine();
 
-    private enum Op { NOOP, ADD, SUBTRACT, MULTIPLY, DIVIDE }
+    private enum Op { NOOP, ADD, SUBTRACT, MULTIPLY, DIVIDE, SQUAREROT, SQUARE, EXPONENT, INVERT}
 
     private Op curOp   = Op.NOOP;
     private Op stackOp = Op.NOOP;
@@ -127,6 +129,10 @@ public class CalcSkin extends Application {
             case "-": triggerOp.set(Op.SUBTRACT); break;
             case "*": triggerOp.set(Op.MULTIPLY); break;
             case "/": triggerOp.set(Op.DIVIDE);   break;
+            case "²": triggerOp.set(Op.SQUARE);   break;
+            case "√": triggerOp.set(Op.SQUAREROT);  break;
+            case "^": triggerOp.set(Op.EXPONENT);   break;
+            case "~": triggerOp.set(Op.INVERT);     break;
         }
         return triggerOp;
     }
@@ -181,10 +187,15 @@ public class CalcSkin extends Application {
             @Override
             public void handle(ActionEvent actionEvent) {
                 switch (stackOp) {
-                    case ADD:      currentValue.set(calcEngine.add(previousValue.get(), currentValue.get())); break;
-                    case SUBTRACT: currentValue.set(calcEngine.subtract(previousValue.get(), currentValue.get())); break;
-                    case MULTIPLY: currentValue.set(calcEngine.multiply(previousValue.get(), currentValue.get())); break;
-                    case DIVIDE:   currentValue.set(calcEngine.divide(previousValue.get(), currentValue.get())); break;
+                    case ADD:      currentValue.set(calcEngine.addition(previousValue.get(), currentValue.get())); break;
+                    case SUBTRACT: currentValue.set(calcEngine.subtraction(previousValue.get(), currentValue.get())); break;
+                    case MULTIPLY: currentValue.set(calcEngine.multiplication(previousValue.get(), currentValue.get())); break;
+                    case DIVIDE:   currentValue.set(calcEngine.division(previousValue.get(), currentValue.get())); break;
+                    case SQUARE:   currentValue.set(calcEngine.square(previousValue.get())); break;
+                    case SQUAREROT: currentValue.set(calcEngine.squareroot(previousValue.get()));   break;
+                    case EXPONENT:  currentValue.set(calcEngine.exponent(previousValue.get(), currentValue.get())); break;
+                    case INVERT:    currentValue.set(calcEngine.invert(previousValue.get()));   break;
+
                 }
             }
         });

src/test/java/rocks/zipcode/calcskin/CalcEngineTest.java

@@ -20,22 +20,140 @@ public class CalcEngineTest {
     }
 
     @Test
-    public void add() {
-        Assert.assertTrue("", (testCalc.add(1.0, 1.0) == 2.0));
+    public void testSquare(){
+        // set up data
+        double x = 3.0;
+
+        //invoke method under test
+        double actualResult = CalcEngine.square(x);
+
+        //verify result
+        double expectResult = 9.0;
+        assertEquals(expectResult, actualResult, 0.001);
+
     }
 
     @Test
-    public void subtract() {
-        Assert.assertTrue("", (testCalc.subtract(17.0, 13.0) == 4.0));
+    public void testsquareroot(){
+        double x = 25.0;
+
+        double actualResult = CalcEngine.squareroot(x);
+
+        double expectResult = 5.0;
+        assertEquals(expectResult, actualResult, 0.001);
     }
 
     @Test
-    public void multiply() {
-        Assert.assertTrue("", (testCalc.multiply(8.0, 3.0) == 24.0));
+    public void testinverse(){
+        double x = 2;
+
+        double actualResult = CalcEngine.inverse(x);
+
+        double expectResult = 0.5;
+        assertEquals(expectResult, actualResult, 0.001);
     }
 
     @Test
-    public void divide() {
-        Assert.assertTrue("", (testCalc.divide(10.0, 2.0) == 5.0));
+    public void testinvert(){
+        double x = 12.0;
+
+        double actualResult = CalcEngine.invert(x);
+
+        double expectResult = -12.0;
+        assertEquals(expectResult, actualResult, 0.001);
     }
+
+/*    @Test
+    public void testfindSin(){
+        double x = 90.0;
+
+        double actualResult = CalcEngine.findSin(x);
+
+        double expectResult = 0.8939966636;
+        assertEquals(expectResult, actualResult, 0.001);
+    }
+
+    @Test
+    public void testfindCos(){
+        double x = 45.0;
+
+        double actualResult = CalcEngine.findCos(x);
+
+        double expectResult = 0.52532198881;
+        assertEquals(expectResult, actualResult, 0.001);
+    }
+
+    @Test
+    public void testfindTan(){
+        double x = 100.0;
+
+        double actualResult = CalcEngine.findTan(x);
+
+        double expectResult = -0.58721391515;
+        assertEquals(expectResult, actualResult, 0.001);
+    }
+
+    @Test
+    public void testfindAsin(){
+        double x = 0.5;
+
+        double actualResult = CalcEngine.findAsin(x);
+
+        double expectResult = 0.52359877559;
+        assertEquals(expectResult, actualResult, 0.001);
+    }
+
+    @Test
+    public void testfindAcos(){
+        double x = 1.0;
+
+        double actualResult = CalcEngine.findAcos(x);
+
+        double expectResult = 0;
+        assertEquals(expectResult, actualResult, 0.001);
+    }
+
+    @Test
+    public void testfindAtan(){
+        double x = 1.0;
+
+        double actualResult = CalcEngine.findAtan(x);
+
+        double expectResult = 0.78539816339;
+        assertEquals(expectResult, actualResult, 0.001);
+
+    }*/
+
+    @Test
+    public void testAddition()
+    {
+        assertEquals(20.0, CalcEngine.addition(15, 5), 0.1);
+    }
+
+
+    @Test
+    public void testSubstraction()
+    {
+        assertEquals(3.0, CalcEngine.subtraction(5, 2), 0.1);
+
+
+    }
+
+    @Test
+    public void testMultiplication(){
+        assertEquals(6.0, CalcEngine.multiplication(3, 2), 0.1);
+    }
+
+    @Test
+    public void testDivision()
+    {
+        assertEquals(3.0, CalcEngine.division(6, 2), 0.1);
+    }
+
+    @Test
+    public void testExponent()
+    {
+        assertEquals(64.0, CalcEngine.exponent(4, 3), 0.1);
+    }
+
 }