CalcSkin

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

 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 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 double divide(double v, double v1) {
-        return Double.NaN;
-    }
 }

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

 package rocks.zipcode.calcskin;
-
 import javafx.application.Application;
 import javafx.beans.binding.Bindings;
 import javafx.beans.property.*;
 import javafx.scene.layout.*;
 import javafx.stage.Stage;
 import javafx.stage.StageStyle;
-import rocks.zipcode.calcskin.CalcEngine;
-
 import java.util.HashMap;
 import java.util.Map;
 
-// a simple JavaFX calculator.
 public class CalcSkin extends Application {
 
     public static void main(String[] args){
             { "7", "8", "9", "/" },
             { "4", "5", "6", "*" },
             { "1", "2", "3", "-" },
-            { "0", "c", "=", "+" }
+            { "0", "c", "=", "+" },
+            { "√", "^", "~", "²"}
     };
 
     private final Map<String, Button> accelerators = new HashMap<>();
-
     private DoubleProperty previousValue = new SimpleDoubleProperty();
     private DoubleProperty currentValue = new SimpleDoubleProperty();
     private CalcEngine calcEngine = new CalcEngine();
 
-    private enum Op { NOOP, ADD, SUBTRACT, MULTIPLY, DIVIDE }
+    private enum Cal { operation, add, subtract, multiply, divide, squareroot, square, exponent, invert}
 
-    private Op curOp   = Op.NOOP;
-    private Op stackOp = Op.NOOP;
+    private Cal first   = Cal.operation;
+    private Cal second = Cal.operation;
 
     public static void launchCalc(String... args) {
         launch(args);
         if (s.matches("[0-9]")) {
             makeNumericButton(s, button);
         } else {
-            final ObjectProperty<Op> triggerOp = determineOperand(s);
-            if (triggerOp.get() != Op.NOOP) {
-                makeOperandButton(button, triggerOp);
+            final ObjectProperty<Cal> triggerCal = determineOperand(s);
+            if (triggerCal.get() != Cal.operation) {
+                makeOperandButton(button, triggerCal);
             } else if ("c".equals(s)) {
                 makeClearButton(button);
             } else if ("=".equals(s)) {
         return button;
     }
 
-    private ObjectProperty<Op> determineOperand(String s) {
-        final ObjectProperty<Op> triggerOp = new SimpleObjectProperty<>(Op.NOOP);
+    private ObjectProperty<Cal> determineOperand(String s) {
+        final ObjectProperty<Cal> triggerOp = new SimpleObjectProperty<>(Cal.operation);
         switch (s) {
-            case "+": triggerOp.set(Op.ADD);      break;
-            case "-": triggerOp.set(Op.SUBTRACT); break;
-            case "*": triggerOp.set(Op.MULTIPLY); break;
-            case "/": triggerOp.set(Op.DIVIDE);   break;
+            case "+": triggerOp.set(Cal.add);      break;
+            case "-": triggerOp.set(Cal.subtract); break;
+            case "*": triggerOp.set(Cal.multiply); break;
+            case "/": triggerOp.set(Cal.divide);   break;
+            case "²": triggerOp.set(Cal.square);   break;
+            case "√": triggerOp.set(Cal.squareroot);  break;
+            case "^": triggerOp.set(Cal.exponent);   break;
+            case "~": triggerOp.set(Cal.invert);     break;
         }
         return triggerOp;
     }
 
-    private void makeOperandButton(Button button, final ObjectProperty<Op> triggerOp) {
-        button.setStyle("-fx-base: lightgray;");
+    private void makeOperandButton(Button button, final ObjectProperty<Cal> triggerCal) {
+        button.setStyle("-fx-base: black;");
         button.setOnAction(new EventHandler<ActionEvent>() {
             @Override
             public void handle(ActionEvent actionEvent) {
-                curOp = triggerOp.get();
+                first = triggerCal.get();
             }
         });
     }
 
     private Button makeStandardButton(String s) {
         Button button = new Button(s);
-        button.setStyle("-fx-base: beige;");
+        button.setStyle("-fx-base: pink;");
         accelerators.put(s, button);
         button.setMaxSize(Double.MAX_VALUE, Double.MAX_VALUE);
         return button;
         button.setOnAction(new EventHandler<ActionEvent>() {
             @Override
             public void handle(ActionEvent actionEvent) {
-                if (curOp == Op.NOOP) {
+                if (first == Cal.operation) {
                     currentValue.set(currentValue.get() * 10 + Integer.parseInt(s));
                 } else {
                     previousValue.set(currentValue.get());
                     currentValue.set(Integer.parseInt(s));
-                    stackOp = curOp;
-                    curOp = Op.NOOP;
+                    second = first;
+                    second = Cal.operation;
                 }
             }
         });
     }
 
     private void makeClearButton(Button button) {
-        button.setStyle("-fx-base: mistyrose;");
+        button.setStyle("-fx-base: grey;");
         button.setOnAction(new EventHandler<ActionEvent>() {
             @Override
             public void handle(ActionEvent actionEvent) {
     }
 
     private void makeEqualsButton(Button button) {
-        button.setStyle("-fx-base: ghostwhite;");
+        button.setStyle("-fx-base: green;");
         button.setOnAction(new EventHandler<ActionEvent>() {
             @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;
+                switch (second) {
+                    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 squareroot: 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/main/java/rocks/zipcode/calcskin/MainApplication.java

 package rocks.zipcode.calcskin;
-
-import rocks.zipcode.calcskin.CalcSkin;
-
-// You probably should make NO changes here. Keep it simple.
 public class MainApplication {
     public static void main(String[] args){
 

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

 package rocks.zipcode.calcskin;
 
 import org.junit.After;
-import org.junit.Assert;
 import org.junit.Before;
 import org.junit.Test;
-
 import static org.junit.Assert.*;
 
 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 testsquareroot(){
+        double x = 25.0;
+
+        double actualResult = CalcEngine.squareroot(x);
+
+        double expectResult = 5.0;
+        assertEquals(expectResult, actualResult, 0.001);
+    }
+
+    @Test
+    public void testinverse(){
+        double x = 2;
+
+        double actualResult = CalcEngine.inverse(x);
+
+        double expectResult = 0.5;
+        assertEquals(expectResult, actualResult, 0.001);
+    }
+
+    @Test
+    public void testinvert(){
+        double x = 12.0;
+
+        double actualResult = CalcEngine.invert(x);
+
+        double expectResult = -12.0;
+        assertEquals(expectResult, actualResult, 0.001);
     }
 
+
     @Test
-    public void subtract() {
-        Assert.assertTrue("", (testCalc.subtract(17.0, 13.0) == 4.0));
+    public void testAddition()
+    {
+        assertEquals(20.0, CalcEngine.addition(15, 5), 0.1);
     }
 
+
     @Test
-    public void multiply() {
-        Assert.assertTrue("", (testCalc.multiply(8.0, 3.0) == 24.0));
+    public void testSubstraction()
+    {
+        assertEquals(3.0, CalcEngine.subtraction(5, 2), 0.1);
+
+
     }
 
     @Test
-    public void divide() {
-        Assert.assertTrue("", (testCalc.divide(10.0, 2.0) == 5.0));
+    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);
+    }
+
 }