@Test
public void shouldReturnResultSevenIfItFiveIsAddedToNumberTwoWhichWasAddedEarlier() {
Calculator calculator = new Calculator();
calculator.add(2.0);
assertEquals(7.0, calculator.add(5.0), 0.0001);
}
@Test
public void shouldReturnTheNumberIfTheNumberIsAddedAfterOperationsAreCancelled() {
Calculator calculator = new Calculator();
calculator.add(5.0);
calculator.cancel();
assertEquals(5.0, calculator.add(5.0), 0.0001);
}
// TASK 1: WRITE JUNIT TESTS
// YOUR CODE HERE
@Test
public void testAddition() {
int res;
res = tester.add(1503, 1230);
assertEquals(2733, res);
res = tester.add(-1503, 1230);
assertEquals(-273, res);
res = tester.add(1503, -1230);
assertEquals(273, res);
}
/** Test the Add method with valid input and negative input */
public void testAdd() {
// Test Normal functionality
try {
assertEquals("Method did not add properly", calc.add(4, 5), 9);
} catch (NegativeArgumentException e) {
fail("Method did not add properly");
}
// Test Negative input handling
try {
calc.add(-4, 5);
fail("Calculator did not throw NegativeArgumentException");
} catch (NegativeArgumentException e) {
}
}
public static void main(String[] args) {
Calculator cal = new Calculator();
cal.add(2, 5);
cal.substruct(5, 3);
cal.div(8, 5);
cal.multiple(9, 2);
}
@Test
public void shouldReturnTheNumberItselfIfOneDividesAnyNumber() {
Calculator calculator = new Calculator();
calculator.add(5.0);
assertEquals(5.0, calculator.divide(1.0), 0.0001);
}
@Test
public void shouldReturnOneIfNumberDividesItself() {
Calculator calculator = new Calculator();
calculator.add(5.0);
assertEquals(1.0, calculator.divide(5.0), 0.0001);
}
/** @param args */
public static void main(String[] args) {
/*
* Instantiate Normal Calculator. Note that CALC_TYPE_NORMAL is a public
* static final variable defined in Calculator class.
*/
Calculator normalCalc = new Calculator(Calculator.CALC_TYPE_NORMAL);
System.out.println(
"*** Calculations will be performed using "
+ normalCalc.getCalculatorType()
+ " calculator ***");
// Add
int result = normalCalc.add(450, 9);
System.out.println("1) Add result is " + result);
// Subtract
result = normalCalc.subtract(450, 9);
System.out.println("2) Subtract result is " + result);
// Multiply
int[] mul = {45, 10, 9};
result = normalCalc.multiply(mul);
System.out.println("3) Multiplication result is " + result);
// Divide
result = normalCalc.divide(450, 9);
System.out.println("4) Division result is " + result);
}
@Test
public void shouldReturnNotANumberIfANumberIsAddedToNotANumberObtainedOnDividingByZero() {
Calculator calculator = new Calculator();
calculator.divide(0.0);
assertEquals(Double.NaN, calculator.add(4.0), 0.0001);
}
@Test
public void
shouldReturnTheNumberToBeAddedIfItIsAddedInitiallySatisfyingTheAdditiveIdentityProperty() {
Calculator calculator = new Calculator();
assertEquals(5.0, calculator.add(5.0), 0.0001);
}
@Test
public void shouldReturnTwoIfFiveIsSubtractedAfterSevenWasAdded() {
Calculator calculator = new Calculator();
calculator.add(7.0);
assertEquals(2.0, calculator.subtract(5.0), 0.0001);
}
@Test
public void shouldReturnFifteenIfThreeIsMultipliedToFive() {
Calculator calculator = new Calculator();
calculator.add(5.0);
assertEquals(15.0, calculator.multiply(3.0), 0.0001);
}
@Test
public void shouldReturnTwoIfFiveDividesTen() {
Calculator calculator = new Calculator();
calculator.add(10.0);
assertEquals(2.0, calculator.divide(5.0), 0.0001);
}
public static void main(String[] args) {
Calculator calc = new Calculator();
calc.add(5, 5);
calc.subtract(10, 5);
calc.multiply(5, 3);
calc.divide(20, 3);
calc.modulus(10, 4);
}
@Test
public void shouldReturnTwoIfFiveDividesTenWhichIsObtainedOnDividingTwentyByTwo() {
Calculator calculator = new Calculator();
calculator.add(20.0);
calculator.divide(2.0);
assertEquals(2.0, calculator.divide(5.0), 0.0001);
}
@Test
public void shouldBeAbleToExitTheApplicationOnExit() {
exit.expectSystemExitWithStatus(0);
Calculator calculator = new Calculator();
calculator.add(5.0);
calculator.exit();
}
@Test
public void shouldReturnTenIfTwoIsMultipliedToMultiplicationOfFiveAndOne() {
Calculator calculator = new Calculator();
calculator.add(1.0);
calculator.multiply(5.0);
assertEquals(10.0, calculator.multiply(2.0), 0.0001);
}
@Test
public void
shouldReturnTheNumberItselfIfOneIsMultipliedToAnyNumberSatisfyingMultiplicativeIdentity() {
Calculator calculator = new Calculator();
calculator.add(5.0);
assertEquals(5.0, calculator.multiply(1.0), 0.0001);
}
public static void main(String[] args) {
Calculator myCalculator = new Calculator();
System.out.println(myCalculator.add(5, 7));
System.out.println(myCalculator.subtract(45, 11));
System.out.println(myCalculator.multiply(4, 5));
System.out.println(myCalculator.divide(20, 5));
System.out.println(myCalculator.modulo(30, 3));
}
public static void main(String[] args) {
System.out.println("Calculator class started");
Calculator calc = new Calculator();
int a = 10;
int b = 5;
System.out.println("add=" + calc.add(a, b));
System.out.println("subtract=" + calc.subtract(a, b));
System.out.println("multiply=" + calc.multiply(a, b));
System.out.println("divide=" + calc.divide(a, b));
}
@Test
public void shouldDisplayTheResultOnScreen() {
final ByteArrayOutputStream outContent = new ByteArrayOutputStream();
System.setOut(new PrintStream(outContent));
Calculator calculator = new Calculator();
calculator.add(5.0);
calculator.displayResult();
assertEquals("5.0", outContent.toString());
}
@Test
public void testGetTotal() {
Calculator calc = new Calculator();
calc.add(4);
calc.subtract(1);
calc.multiply(6);
calc.divide(3);
// The total value should be 6
assertEquals(calc.getTotal(), 6);
}
@Test
public void testAdd() {
Calculator calc = new Calculator();
// Make sure the total value is 0
assertEquals(calc.getTotal(), 0);
calc.add(6);
calc.add(1);
// The total value should be 7 after adding 6 and 1 to 0
assertEquals(calc.getTotal(), 7);
}
public static void main(String[] arg) {
System.out.println("Calculate...");
if (arg.length == 2) {
Calculator calc = new Calculator();
Integer first = Integer.parseInt(arg[0]);
Integer second = Integer.parseInt(arg[1]);
calc.add(first, second);
System.out.println("Result: " + calc.getResult());
} else {
System.out.println("Enter two paramenters.");
}
}
@Test
public void testMultiply() {
Calculator calc = new Calculator();
calc.multiply(10);
assertEquals(calc.getTotal(), 0);
calc.add(2);
calc.multiply(7);
// The total value should be 14 after adding 2 to 0 then multiplying by 7
assertEquals(calc.getTotal(), 14);
}
@Test
public void testGetHistory() {
Calculator calc = new Calculator();
assertEquals(calc.getHistory(), "" + 0);
calc.add(14);
calc.divide(2);
calc.multiply(3);
calc.subtract(6);
// Testing the history method
assertEquals("0 + 14 / 2 * 3 - 6", calc.getHistory());
}
@Test
public void testDivide() {
Calculator calc = new Calculator();
calc.divide(0);
// Testing dividing by 0
assertEquals(calc.getTotal(), 0);
calc.add(12);
calc.divide(6);
// The total value should be 2 after adding 12 then dividing by 6
assertEquals(calc.getTotal(), 2);
}
/** Запуск */
public void go() {
try {
while (!exit.equals("y")) {
chooseOperation();
enterParams();
if (operation != null && operation.equals("add")) {
calc.add(Double.valueOf(first), Double.valueOf(second));
report();
setClean();
setExit();
}
if (operation != null && operation.equals("sub")) {
calc.sub(Double.valueOf(first), Double.valueOf(second));
report();
setClean();
setExit();
}
if (operation != null && operation.equals("div")) {
calc.div(Double.valueOf(first), Double.valueOf(second));
report();
setClean();
setExit();
}
if (operation != null && operation.equals("mul")) {
calc.mul(Double.valueOf(first), Double.valueOf(second));
report();
setClean();
setExit();
}
if (operation != null && operation.equals("inv")) {
calc.inv(Double.valueOf(first), Integer.valueOf(second));
report();
setExit();
}
}
} finally {
reader.close();
}
}
@Test
public void testDivide() {
calculator.add(8);
calculator.divide(2);
assertEquals(4, calculator.getResult());
}
@Test
public void testSubstract() {
calculator.add(10);
calculator.substract(2);
assertEquals(8, calculator.getResult());
}
