done

Factorial.ctxt

+#BlueJ class context
+comment0.target=Factorial
+comment1.params=value
+comment1.target=java.math.BigInteger\ factorialOf(java.lang.Integer)
+numComments=2

Factorial.java

- 
-
-
 import java.math.BigInteger;
 
 public class Factorial {
 
     public BigInteger factorialOf(Integer value){
-        return null;
+        BigInteger num = new BigInteger("1");
+        for (long i = 1; i <= value; i++){
+           num = num.multiply(BigInteger.valueOf(i));
+        }
+        return num;
     }
-
-}
+}

FactorialTest.ctxt

+#BlueJ class context
+comment0.target=FactorialTest
+comment1.params=
+comment1.target=void\ setUp()
+comment2.params=
+comment2.target=void\ factorialOfTest()
+numComments=3

IntegerPrinter.ctxt

+#BlueJ class context
+comment0.target=IntegerPrinter
+comment1.params=value
+comment1.target=java.lang.String\ printIntegerAsBinary(int)
+comment2.params=value
+comment2.target=java.lang.String\ printIntegerAsOctal(int)
+comment3.params=value
+comment3.target=java.lang.String\ printIntegerAsHexadecimal(int)
+comment4.params=args
+comment4.target=void\ main(java.lang.String[])
+numComments=5

IntegerPrinter.java

 public class IntegerPrinter {
 
     public String printIntegerAsBinary(int value){
-        return null;
+        return Integer.toBinaryString(value);
     }
 
     public String printIntegerAsOctal(int value){
-        return null;
+        return Integer.toOctalString(value);
     }
 
     public String printIntegerAsHexadecimal(int value){
-        return null;
+        return Integer.toHexString(value);
     }
 
     public static void main(String[] args){

IntegerPrinterTest.ctxt

+#BlueJ class context
+comment0.target=IntegerPrinterTest
+comment1.params=
+comment1.target=void\ setUp()
+comment2.params=
+comment2.target=void\ printIntegerAsBinaryTest()
+comment3.params=
+comment3.target=void\ printIntegerAsHexadecimal()
+comment4.params=
+comment4.target=void\ printIntegerAsOctalTest()
+numComments=5

LargestInteger.ctxt

+#BlueJ class context
+comment0.target=LargestInteger
+comment1.params=integers
+comment1.target=java.lang.Integer\ findLargestNumberUsingConditional(java.lang.Integer[])
+comment2.params=integers
+comment2.target=java.lang.Integer\ findLargestNumberUsingMathMax(java.lang.Integer[])
+numComments=3

LargestInteger.java

- 
-
 
 public class LargestInteger {
 
     public Integer findLargestNumberUsingConditional(Integer[] integers){
-        return null;
+        int largest = 0;
+        for (int i = 0; i < integers.length; i++){
+            largest = integers[i] > largest ? integers[i] : largest;
+        }
+        return largest;
     }
 
     public Integer findLargestNumberUsingMathMax(Integer[] integers){
-        return null;
+        int largest = 0;
+        for (int i = 0; i < integers.length; i++){
+            largest = Math.max(integers[i], largest);
+        }
+        return largest;
     }
-}
+}

LargestIntegerTest.ctxt

+#BlueJ class context
+comment0.target=LargestIntegerTest
+comment1.params=
+comment1.target=void\ setUp()
+comment2.params=
+comment2.target=void\ findLargestNumberUsingConditionalTest()
+comment3.params=
+comment3.target=void\ findLargestNumberUsingMathMaxTest()
+numComments=4

NormalizeAngle.ctxt

+#BlueJ class context
+comment0.target=NormalizeAngle
+comment1.params=angle
+comment1.target=java.lang.Integer\ normalizeValueUsingModulo(java.lang.Integer)
+comment2.params=integer
+comment2.target=java.lang.Integer\ normalizeValueUsingFloorMod(java.lang.Integer)
+comment3.params=args
+comment3.target=void\ main(java.lang.String[])
+numComments=4

NormalizeAngle.java

- 
-
-
 public class NormalizeAngle {
 
     public Integer normalizeValueUsingModulo(Integer angle){
-        return 0;
+        angle = angle % 360; 
+        return angle >= 0 ? angle : angle + 360;
     }
 
     public Integer normalizeValueUsingFloorMod(Integer integer){
-        return 0;
+        integer = Math.floorMod(integer, 360);
+        return integer >= 0 ? integer : integer + 360;
     }
 
     public static void main(String[] args){
 
     }
-}
+}

NormalizeAngleTest.ctxt

+#BlueJ class context
+comment0.target=NormalizeAngleTest
+comment1.params=
+comment1.target=void\ setUp()
+comment2.params=
+comment2.target=void\ normalizeValueUsingModuloTest()
+comment3.params=
+comment3.target=void\ normalizeValueUsingFloorModTest()
+numComments=4

RunCalculator.ctxt

+#BlueJ class context
+comment0.target=RunCalculator
+comment1.params=args
+comment1.target=void\ main(java.lang.String[])
+numComments=2

RunCalculator.java

+import java.util.Scanner;
+
+public class RunCalculator{
+    public static void main (String[] args){
+        ShortCalculator shortCalculator = new ShortCalculator();
+        Scanner in = new Scanner (System.in);
+
+        System.out.println("Enter a number between 0 and 65535");
+        short numberOne = in.nextShort();
+        while(numberOne < 0 || numberOne > 65535){
+            System.out.println("Enter a number between 0 and 65535");
+            numberOne = in.nextShort();
+        }
+
+        System.out.println("Enter another number between 0 and 65535");
+        short numberTwo = in.nextShort();
+        while(numberTwo < 0 || numberTwo > 65535){
+            System.out.println("Enter another number between 0 and 65535");
+            numberTwo = in.nextShort();
+        }
+
+        System.out.println("Sum: " + shortCalculator.sum(numberOne, numberTwo));
+        System.out.println("Difference: "+ shortCalculator.difference(numberOne, numberTwo));
+        System.out.println("Product: "+ shortCalculator.product(numberOne, numberTwo));
+        System.out.println("Quotient :" + shortCalculator.quotient(numberOne, numberTwo));
+        System.out.println("Remainder: " + shortCalculator.remainder(numberOne, numberTwo));
+    }
+}

ShortCalculator.ctxt

+#BlueJ class context
+comment0.target=ShortCalculator
+comment1.params=x\ y
+comment1.target=short\ sum(short,\ short)
+comment2.params=x\ y
+comment2.target=short\ difference(short,\ short)
+comment3.params=x\ y
+comment3.target=short\ product(short,\ short)
+comment4.params=x\ y
+comment4.target=short\ quotient(short,\ short)
+comment5.params=x\ y
+comment5.target=short\ remainder(short,\ short)
+numComments=6

ShortCalculator.java

- 
+public class ShortCalculator {
 
+    public short sum(short x, short y){
+        return (short) (x + y);
+    }
 
-public class ShortCalculator {
-}
+    public short difference(short x, short y){
+        return (short) (x - y);
+    }
+
+    public short product(short x, short y){
+        return (short) (x * y);
+    }
+
+    public short quotient(short x, short y){
+        return (short) (x / y);
+    }
+
+    public short remainder(short x, short y){
+        return (short) (x % y);
+    }
+}

ShortCalculatorTest.ctxt

+#BlueJ class context
+comment0.target=ShortCalculatorTest
+comment1.params=
+comment1.target=void\ setUp()
+comment2.params=
+comment2.target=void\ sumTest()
+comment3.params=
+comment3.target=void\ differenctTest()
+comment4.params=
+comment4.target=void\ productTest()
+comment5.params=
+comment5.target=void\ quotientTest()
+comment6.params=
+comment6.target=void\ remainderTest()
+numComments=7

ShortCalculatorTest.java

- 
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
 
+public class ShortCalculatorTest
+{
+    private ShortCalculator shortCalculator;
 
-public class ShortCalculatorTest {
+    @Before
+    public void setUp(){
+        shortCalculator = new ShortCalculator();
+    }
+
+    @Test
+    public void sumTest(){
+        // :Given
+        short expected = 12;
+
+        // :When
+        short actual = shortCalculator.sum((short) 10, (short)2);
+
+        // :Then
+        Assert.assertEquals("The values equal 12", expected, actual);
+    }
+
+    @Test
+    public void differenctTest(){
+        // :Given
+        short expected = 8;
+        // :When
+        short actual = shortCalculator.difference((short)10, (short)2);
+        // :Then
+        Assert.assertEquals("The values equal 8", expected, actual);
+    }
+
+    @Test
+    public void productTest(){
+        // :Given
+        short expected = 20;
+        // :When
+        short actual = shortCalculator.product((short)10, (short)2);
+        // :Then  
+        Assert.assertEquals("The values equal 20", expected, actual);
+    }
+
+    @Test
+    public void quotientTest(){
+        // :Given
+        short expected = 10;
+        // :When
+        short actual = shortCalculator.quotient((short)20, (short)2);
+        // :Then
+        Assert.assertEquals("The values equal 10", expected, actual); 
+    }
+
+    @Test
+    public void remainderTest(){
+        // :Given
+        short expected = 1;
+        // :When
+        short actual = shortCalculator.remainder ((short)5, (short)2);
+        // :Then
+        Assert.assertEquals("The values equal 1", expected, actual);
+    }
 }

package.bluej

 editor.fx.0.x=0
 editor.fx.0.y=0
 objectbench.height=101
-objectbench.width=1070
-package.divider.horizontal=0.6
+objectbench.width=637
+package.divider.horizontal=0.5996275605214153
 package.divider.vertical=0.837593984962406
 package.editor.height=550
 package.editor.width=968
 package.frame.height=723
 package.frame.width=1094
 package.numDependencies=4
-package.numTargets=10
+package.numTargets=11
 package.showExtends=true
 package.showUses=true
 project.charset=UTF-8
 target10.width=140
 target10.x=10
 target10.y=370
+target11.height=50
+target11.name=RunCalculator
+target11.showInterface=false
+target11.type=ClassTarget
+target11.width=110
+target11.x=170
+target11.y=250
 target2.height=50
 target2.name=NormalizeAngle
 target2.showInterface=false
 target7.height=50
 target7.name=ShortCalculatorTest
 target7.showInterface=false
-target7.type=ClassTarget
+target7.type=UnitTestTargetJunit4
 target7.width=150
 target7.x=10
 target7.y=250