initial commit

Factorial.java

@@ -0,0 +1,12 @@
+ 
+
+
+import java.math.BigInteger;
+
+public class Factorial {
+
+    public BigInteger factorialOf(Integer value){
+        return null;
+    }
+
+}

FactorialTest.java

@@ -0,0 +1,30 @@
+ 
+
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.math.BigInteger;
+
+public class FactorialTest {
+
+    private Factorial factorial;
+
+    @Before
+    public void setUp(){
+        factorial = new Factorial();
+    }
+
+    @Test
+    public void factorialOfTest(){
+        //:Given
+        BigInteger expected = new BigInteger("24");
+
+        //:When
+        BigInteger actual = factorial.factorialOf(4);
+
+        //:Then
+        Assert.assertEquals("Values should be equal", expected, actual);
+    }
+}

IntegerPrinter.java

@@ -0,0 +1,21 @@
+ 
+
+
+public class IntegerPrinter {
+
+    public String printIntegerAsBinary(int value){
+        return null;
+    }
+
+    public String printIntegerAsOctal(int value){
+        return null;
+    }
+
+    public String printIntegerAsHexadecimal(int value){
+        return null;
+    }
+
+    public static void main(String[] args){
+
+    }
+}

IntegerPrinterTest.java

@@ -0,0 +1,53 @@
+ 
+
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+public class IntegerPrinterTest {
+
+    IntegerPrinter integerPrinter;
+
+    @Before
+    public void setUp(){
+        integerPrinter = new IntegerPrinter();
+    }
+
+    @Test
+    public void printIntegerAsBinaryTest(){
+        //:Given
+        String expected = "111110100";
+
+        //:When
+        String actual = integerPrinter.printIntegerAsBinary(500);
+
+        //:Then
+        Assert.assertEquals("The value equals 111110100", expected, actual);
+    }
+
+    @Test
+    public void printIntegerAsHexadecimal(){
+        //:Given
+        String expected = "1f4";
+
+        //:When
+        String actual = integerPrinter.printIntegerAsHexadecimal(500);
+
+        //:Then
+        Assert.assertEquals("The value equals 1f4", expected, actual);
+    }
+
+    @Test
+    public void printIntegerAsOctalTest(){
+        //:Given
+        String expected = "764";
+
+        //:When
+        String actual = integerPrinter.printIntegerAsOctal(500);
+
+        //:Then
+        Assert.assertEquals("The value equals 764", expected, actual);
+    }
+
+}

LargestInteger.java

@@ -0,0 +1,13 @@
+ 
+
+
+public class LargestInteger {
+
+    public Integer findLargestNumberUsingConditional(Integer[] integers){
+        return null;
+    }
+
+    public Integer findLargestNumberUsingMathMax(Integer[] integers){
+        return null;
+    }
+}

LargestIntegerTest.java

@@ -0,0 +1,40 @@
+ 
+
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+public class LargestIntegerTest {
+
+    private LargestInteger largestInteger;
+
+    @Before
+    public void setUp(){
+        largestInteger = new LargestInteger();
+    }
+
+    @Test
+    public void findLargestNumberUsingConditionalTest(){
+        // :Given
+        Integer expected = 30;
+
+        // :When
+        Integer actual = largestInteger.findLargestNumberUsingConditional(new Integer[]{30,20,10});
+
+        // :Then
+        Assert.assertEquals("The Largest Number should be 30", expected, actual);
+    }
+
+    @Test
+    public void findLargestNumberUsingMathMaxTest(){
+        // :Given
+        Integer expected = 600;
+
+        // :When
+        Integer actual = largestInteger.findLargestNumberUsingMathMax(new Integer[]{300,200,600});
+
+        // :Then
+        Assert.assertEquals("The Largest Number should be 600.", expected, actual);
+    }
+}

NormalizeAngle.java

@@ -0,0 +1,17 @@
+ 
+
+
+public class NormalizeAngle {
+
+    public Integer normalizeValueUsingModulo(Integer angle){
+        return 0;
+    }
+
+    public Integer normalizeValueUsingFloorMod(Integer integer){
+        return 0;
+    }
+
+    public static void main(String[] args){
+
+    }
+}

NormalizeAngleTest.java

@@ -0,0 +1,40 @@
+ 
+
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+public class NormalizeAngleTest {
+
+    private NormalizeAngle normalizeAngle;
+
+    @Before
+    public void setUp(){
+        normalizeAngle = new NormalizeAngle();
+    }
+
+    @Test
+    public void normalizeValueUsingModuloTest(){
+        //:Given
+        Integer expected = 60;
+
+        //:When
+        Integer actual = normalizeAngle.normalizeValueUsingModulo(780);
+
+        //:Then
+        Assert.assertEquals("The value equals 60", expected, actual);
+    }
+
+    @Test
+    public void normalizeValueUsingFloorModTest(){
+        //:Given
+        Integer expected = 60;
+
+        //:When
+        Integer actual = normalizeAngle.normalizeValueUsingFloorMod(780);
+
+        //:Then
+        Assert.assertEquals("The value equals 60", expected, actual);
+    }
+}

README.md

@@ -0,0 +1,25 @@
+# Integer Printer
+
+* Write a program that reads an integer and prints it in :
+1. binary
+2. Octal
+3. Hexadecimal
+
+
+# Normalize Angle
+* Write a program that reads an integer angle (which may be positive or negative) and normalizes it to a value between 0 and 359 degrees. Try it first with the % operator, then with floorMod.
+
+
+# Largest Integer
+
+* Using only the conditional operator, write a program that reads three integers and prints the largest. Repeat with Math.max
+
+
+# Factorial
+
+* Write a program that computes the factorial n! = 1 x 2 x ... x n, using BigInteger. Compute the factorial of 1000.
+
+
+# ShortValues
+
+* Write a program that reads in two numbers between 0 and 65535, stores them in short variables, and computes their unsigned sum, difference, product, quotient, and remainder , without converting them to int.

ShortCalculator.java

@@ -0,0 +1,5 @@
+ 
+
+
+public class ShortCalculator {
+}

ShortCalculatorTest.java

@@ -0,0 +1,5 @@
+ 
+
+
+public class ShortCalculatorTest {
+}

package.bluej

@@ -0,0 +1,107 @@
+#BlueJ package file
+dependency1.from=LargestIntegerTest
+dependency1.to=LargestInteger
+dependency1.type=UsesDependency
+dependency2.from=NormalizeAngleTest
+dependency2.to=NormalizeAngle
+dependency2.type=UsesDependency
+dependency3.from=FactorialTest
+dependency3.to=Factorial
+dependency3.type=UsesDependency
+dependency4.from=IntegerPrinterTest
+dependency4.to=IntegerPrinter
+dependency4.type=UsesDependency
+editor.fx.0.height=0
+editor.fx.0.width=0
+editor.fx.0.x=0
+editor.fx.0.y=0
+objectbench.height=101
+objectbench.width=1070
+package.divider.horizontal=0.6
+package.divider.vertical=0.837593984962406
+package.editor.height=550
+package.editor.width=968
+package.editor.x=59
+package.editor.y=82
+package.frame.height=723
+package.frame.width=1094
+package.numDependencies=4
+package.numTargets=10
+package.showExtends=true
+package.showUses=true
+project.charset=UTF-8
+readme.height=58
+readme.name=@README
+readme.width=47
+readme.x=10
+readme.y=10
+target1.height=50
+target1.name=Factorial
+target1.showInterface=false
+target1.type=ClassTarget
+target1.width=80
+target1.x=160
+target1.y=10
+target10.height=50
+target10.name=IntegerPrinterTest
+target10.showInterface=false
+target10.type=UnitTestTargetJunit4
+target10.width=140
+target10.x=10
+target10.y=370
+target2.height=50
+target2.name=NormalizeAngle
+target2.showInterface=false
+target2.type=ClassTarget
+target2.width=120
+target2.x=70
+target2.y=70
+target3.height=50
+target3.name=IntegerPrinter
+target3.showInterface=false
+target3.type=ClassTarget
+target3.width=110
+target3.x=10
+target3.y=130
+target4.height=50
+target4.name=ShortCalculator
+target4.showInterface=false
+target4.type=ClassTarget
+target4.width=120
+target4.x=130
+target4.y=130
+target5.height=50
+target5.name=LargestInteger
+target5.showInterface=false
+target5.type=ClassTarget
+target5.width=120
+target5.x=10
+target5.y=190
+target6.height=50
+target6.name=LargestIntegerTest
+target6.showInterface=false
+target6.type=UnitTestTargetJunit4
+target6.width=140
+target6.x=250
+target6.y=190
+target7.height=50
+target7.name=ShortCalculatorTest
+target7.showInterface=false
+target7.type=ClassTarget
+target7.width=150
+target7.x=10
+target7.y=250
+target8.height=50
+target8.name=NormalizeAngleTest
+target8.showInterface=false
+target8.type=UnitTestTargetJunit4
+target8.width=150
+target8.x=10
+target8.y=310
+target9.height=50
+target9.name=FactorialTest
+target9.showInterface=false
+target9.type=UnitTestTargetJunit4
+target9.width=110
+target9.x=410
+target9.y=260