/** Test the divide method with valid input, negative input, and dividing by zero */
public void testDivide() {
// Test valid input
try {
assertEquals("Method did not divide properly", calc.divide(10, 5), 2);
} catch (NegativeArgumentException e) {
fail("Method did not divide properly");
} catch (ArithmeticException e) {
fail("Method did not divide properly");
}
// Test negative input
try {
calc.divide(-4, 5);
fail("Calculator did not throw NegativeArgumentException");
} catch (NegativeArgumentException e) {
} catch (ArithmeticException e) {
fail("Calculator did not throw NegativeArgumentException");
}
// Test divide by zero
try {
calc.divide(10, 0);
fail("Calculator did not throw ArithmeticException");
} catch (NegativeArgumentException e) {
fail("Calculator did not throw ArithmeticException");
} catch (ArithmeticException e) {
}
}
@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 testDivide() {
a = 8;
b = 2;
int result = calculator.divide(a, b);
Assert.assertEquals(a / b, result);
a = 8;
b = -2;
result = calculator.divide(a, b);
Assert.assertEquals(a / b, result);
}
@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);
}
@Test
public void shouldReturnTheNumberItselfIfOneDividesAnyNumber() {
Calculator calculator = new Calculator();
calculator.add(5.0);
assertEquals(5.0, calculator.divide(1.0), 0.0001);
}
@Test
public void shouldReturnTwoIfFiveDividesTen() {
Calculator calculator = new Calculator();
calculator.add(10.0);
assertEquals(2.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 divideで3と2の除算結果が取得できる() {
Calculator calc = new Calculator();
float expected = 1.5f;
float actual = calc.divide(3, 2);
assertThat(actual, is(expected));
}
@Test
public void testDivideByZero() {
a = 20;
b = 0;
Integer result = calculator.divide(a, b);
Assert.assertNull(result);
}
@Test
public void shouldReturnOneIfNumberDividesItself() {
Calculator calculator = new Calculator();
calculator.add(5.0);
assertEquals(1.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);
}
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 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);
}
public static void main(String[] args) {
// 3 * 7 - 4 + 8 / 2 = ?
int result = 0;
result = Calculator.multiple(3, 7);
result = Calculator.minus(result, 4);
result = Calculator.plus(result, 8);
result = Calculator.divide(result, 2);
System.out.printf("결과 = %d\n", result);
// remainder()는 private 접근 범위를 갖기 때문에 외부 클래스에서 호출할 수 없다.
// result = Calculator.remainder(10, 3);
}
@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() throws Exception {
assertEquals(4d, calculator.divide(20d, 5d), 0);
}
@Test
public void testDivide() {
calculator.add(8);
calculator.divide(2);
assertEquals(4, calculator.getResult());
}
@Test(expected = IllegalArgumentException.class)
public void divideで5と0のときIllegalArgumentExceptionを送出する() {
Calculator calc = new Calculator();
calc.divide(5, 0);
}
@Test(expected = Exception.class)
public void divisionWithException() {
// divide by zero
calculator.divide(42, 0);
}
@Test(expected = ArithmeticException.class)
public void testDivideWillThrowExceptionWhenDivideOnZero() {
Calculator calculator = new Calculator();
calculator.divide(6, 0);
}
@Test
public void testDivide() {
Calculator calculator = new Calculator();
Assert.assertEquals(2, calculator.divide(6, 3));
}
@Override
public int divide(int a, int b) {
return calculator.divide(a, b);
}
@Test
public void shouldReturnNotANumberIfZeroDividesInitially() {
Calculator calculator = new Calculator();
assertEquals(Double.NaN, calculator.divide(0.0), 0.0001);
}
