class MyTestCase(unittest.TestCase):
def setUp(self) -> None:
self.calculator = Calculator()
def test_zscore(self):
test_data = CsvReader('/Tests/Data/unit_test_zscore.csv').data
for row in test_data:
self.assertEqual(self.calculator.zscore(row['Value 1'],row['Value 2'],row['Value 3']), Decimal(row['Result']).quantize(Decimal('.001')))
self.assertEqual(self.calculator.result, Decimal(row['Result']).quantize(Decimal('.001')))
def test_standardized_score(self):
test_data = CsvReader('/Tests/Data/unit_test_standardized_score.csv').data
for row in test_data:
self.assertEqual(self.calculator.standardized_score(row['Value 1'],row['Value 2'],row['Value 3']), Decimal(row['Result']).quantize(Decimal('.001')))
self.assertEqual(self.calculator.result, Decimal(row['Result']).quantize(Decimal('.001')))
def test_population_correlation_coefficient(self):
test_data = CsvReader('/Tests/Data/unit_test_population_correlation_coefficient.csv').data
for row in test_data:
self.assertEqual(self.calculator.population_correlation_coefficient(row['Value 1'],row['Value 2'],row['Value 3']), Decimal(row['Result']).quantize(Decimal('.001')))
self.assertEqual(self.calculator.result, Decimal(row['Result']).quantize(Decimal('.001')))
def test_confidence_interval(self):
test_data = CsvReader('/Tests/Data/unit_test_confidence_interval.csv').data
for row in test_data:
self.assertEqual(
self.calculator.confidence_interval(row['Value 1'], row['Value 2'], row['Value 3']),
Decimal(row['Result']).quantize(Decimal('.001')))
self.assertEqual(self.calculator.result, Decimal(row['Result']).quantize(Decimal('.001')))
class MyTestCase(unittest.TestCase):
def setUp(self):
self.calculator = Calculator()
def test_instantiate_calculator(self):
self.assertIsInstance(self.calculator, Calculator)
def test_calculator_return_sum(self):
result = self.calculator.Sum(1, 2)
self.assertEqual(3, result)
def test_calculator_return_difference(self):
result = self.calculator.Difference(1, 2)
self.assertEqual(-1, result)
def test_calculator_access_difference_result(self):
self.calculator.Difference(1, 2)
self.assertEqual(-1, self.calculator.Result)
def test_calculator_access_sum_result(self):
self.calculator.Sum(1, 2)
self.assertEqual(3, self.calculator.Result)
def test_multiple_calculators(self):
calculator1 = Calculator()
calculator2 = Calculator()
self.calculator.Sum(calculator1.Sum(1, 2),
calculator2.Difference(3, 4))
self.assertEqual(2, self.calculator.Result)
def test_multiple_calculators(self):
calculator1 = Calculator()
calculator2 = Calculator()
calculator3 = Calculator()
calculator3.addition(calculator1.addition(1, 2),
calculator2.subtraction(3, 4))
self.assertEqual(2, calculator3.result)
class MyTestCase(unittest.TestCase):
def setUp(self) -> None:
self.calculator = Calculator()
def test_instantiate_calculator(self):
self.assertIsInstance(self.calculator, Calculator)
def test_subtraction(self):
test_data = CsvReader("Group4Test/Group4Data/subtraction.csv").data
for row in test_data:
result = float(row['Result'])
self.assertEqual(self.calculator.subtract(row['Value 1'], row['Value 2']), result)
self.assertEqual(self.calculator.result, result)
def test_addition(self):
test_data = CsvReader("Group4Test/Group4Data/addition.csv").data
for row in test_data:
result = float(row['Result'])
self.assertEqual(self.calculator.add(row['Value 1'], row['Value 2']), result)
self.assertEqual(self.calculator.result, result)
def test_multiplication(self):
test_data = CsvReader("Group4Test/Group4Data/multiplication.csv").data
for row in test_data:
result = float(row['Result'])
self.assertEqual(self.calculator.multiply(row['Value 1'], row['Value 2']), result)
self.assertEqual(self.calculator.result, result)
def test_division(self):
test_data = CsvReader("Group4Test/Group4Data/division.csv").data
for row in test_data:
result = float(row['Result'])
self.assertEqual(self.calculator.divide(row['Value 1'], row['Value 2']), float(row['Result']))
self.assertEqual(self.calculator.result, float(row['Result']))
def test_square(self):
test_data = CsvReader("Group4Test/Group4Data/square.csv").data
for row in test_data:
result = float(row['Result'])
self.assertEqual(row['Value 1'], result)
self.assertEqual(self.calculator.result, result)
#Old values = def test_sqrt(self):
def test_sqrt(self):
test_data = CsvReader("Group4Test/Group4Data/squareroot.csv").data
for row in test_data:
result = float(row['Result'])
self.assertEqual((row['Value 1'], result))
self.assertEqual(self.calculator.result, result)
def test_results_property(self):
self.assertEqual(self.calculator.result, 0)
class MyTestCase(unittest.TestCase):
def setUp(self):
self.calculator = Calculator()
def test_instantiate_calculator(self):
self.assertIsInstance(self.calculator, Calculator)
def test_calculator_return_sum(self):
result = self.calculator.Sum(1, 2)
self.assertEqual(3, result)
def test_calculator_return_difference(self):
result = self.calculator.Difference(1, 2)
self.assertEqual(-1, result)
def test_calculator_access_difference_result(self):
self.calculator.Difference(1, 2)
self.assertEqual(-1, self.calculator.Result)
def test_calculator_access_sum_result(self):
self.calculator.Sum(1, 2)
self.assertEqual(3, self.calculator.Result)
def test_multiple_calculators(self):
calculator1 = Calculator()
calculator2 = Calculator()
self.calculator.Sum(calculator1.Sum(1, 2),
calculator2.Difference(3, 4))
self.assertEqual(2, self.calculator.Result)
def test_calculator_multiply(self):
result = self.calculator.Multiply(2, 3)
self.assertEqual(6, result)
def test_calculator_divide(self):
result = self.calculator.Divide(6, 2)
self.assertEqual(3, result)
def test_calculator_root(self):
result = self.calculator.Root(169, 2)
self.assertEqual(13, result)
def test_calculator_power(self):
result = self.calculator.Power(13, 2)
self.assertEqual(169, result)
def test_calculator_log(self):
result = self.calculator.Logarithm(10, 1)
self.assertEqual(0, result)
class SampleSize(DataLoader):
def __init__(self):
self.calc = Calculator()
pass
def cochran_small(self, n_0, N):
return cochran_small(n_0, N)
def cochran_large(self, proportion, marginerror, confidence):
return cochran_large(proportion, marginerror, confidence)
def cochran(self, N, proportion, marginerror, confidence):
n_0 = cochran_large(proportion, marginerror, confidence)
if N >= 500:
return n_0
else:
return cochran_small(n_0, N)
def find_n_size_unknown_sigma(self, confidence_p, interval_width,
n_pct_of_N):
z = Statistics.z_given_confidence(confidence_p)
E = self.calc.divide(interval_width, 2)
p_hat = n_pct_of_N
q_hat = 1 - p_hat
pq = self.calc.multiply(p_hat, q_hat)
result = self.calc.multiply(self.calc.square(self.calc.divide(z, E)),
pq)
return round(result, 0)
def find_n_size_given_sigma(self, confidence_p, sigma, me):
z = Statistics.z_given_confidence(confidence_p)
zsig = self.calc.multiply(z, sigma)
result = self.calc.square(self.calc.divide(zsig, me))
return round(result, 0)
class MyTestCase(unittest.TestCase):
def setUp(self):
self.calculator = Calculator()
def test_instantiate_calculator(self):
self.assertIsInstance(self.calculator, Calculator)
def test_results_property_calculator(self):
self.assertEquals(self.calculator.result, 0)
def test_addition(self):
test_data = CSVReader("Tests/Data/addition.csv").data
for row in test_data:
result = float(row['Result'])
self.assertEqual(
self.calculator.add(row['Value1'], row['Value 2']), result)
self.assertEqual(self.calculator.result, result)
def test_subtraction(self):
test_data = CSVReader("Tests/Data/subtraction.csv").data
for row in test_data:
result = float(row['Result'])
self.assertEqual(
self.calculator.subtract(row['Value 1'], row['Value 2']),
result)
self.assertEqual(self.calculator.result, result)
def test_multiplication(self):
test_data = CSVReader("Tests/Data/multiplication.csv").data
for row in test_data:
result = float(row['Result'])
self.assertEqual(
self.calculator.multiply(row['Value1'], row['Value2']), result)
self.assertEqual(self.calculator.result, result)
def test_division(self):
test_data = CSVReader("Tests/Data/division.csv").data
for row in test_data:
result = float(row['Result'])
self.assertEqual(
self.calculator.divide(row['Value1'], row['Value2']), result)
self.assertEqual(self.calculator.divide.result, result)
def test_square(self):
test_data = CSVReader("Tests/Data/square.csv")
for row in test_data:
result = float(row['Result'])
self.assertEqual(self.calculator.square(row['Value1']), result)
self.assertEqual(self.calculator.square.result, result)
def test_squareroot(self):
test_data = CSVReader("Tests/Data/squareroot.csv")
for row in test_data:
result = float(row['Result'])
self.assertEqual(self.calculator.squareroot(row['Value1']), result)
self.assertEqual(self.calculator.squareroot.result, result)
def test_results_property(self):
self.calculator.add(2, 1)
self.assertEqual(self.calculator.result, 3)
class MyTestCase(unittest.TestCase):
def setUp(self):
self.calculator = Calculator()
def test_instantiate_calculator(self):
self.assertIsInstance(self.calculator, Calculator)
def test_calculator_return_sum(self):
result = self.calculator.Sum(1, 2)
self.assertEqual(3, result)
def test_calculator_access_sum_result(self):
self.calculator.Sum(1, 2)
self.assertEqual(3, self.calculator.Result)
def test_calculator_return_difference(self):
result = self.calculator.Difference(1, 2)
self.assertEquals(-1, result)
def test_calculator_access_difference_result(self):
self.calculator.Difference(1, 2)
self.assertEqual(-1, self.calculator.Result)
def test_multiple_calculators(self):
calculator1 = Calculator()
calculator2 = Calculator()
self.calculator.Sum(calculator1.Sum(1, 2),
calculator2.Difference(3, 4))
self.assertEqual(2, self.calculator.Result)
def test_calculator_return_product(self):
self.calculator.Product(1, 2)
self.assertEquals(2, self.calculator.Result)
def test_calculator_return_quotient(self):
self.calculator.Quotient(1, 2)
self.assertEqual(0.5, self.calculator.Result)
def test_calculator_return_root(self):
self.calculator.Root(2, 4)
self.assertEquals(2, self.calculator.Result)
def test_calculator_return_power(self):
self.calculator.Power(2, 2)
self.assertEquals(4, self.calculator.Result)
def test_calculator_return_logarithm(self):
self.calculator.Logarithm(2, 8)
self.assertEqual(3, self.calculator.Result)
def test_multiple_result_calculator(self):
calculator1 = Calculator()
calculator2 = Calculator()
calculator1.Sum(1, 2)
calculator2.Difference(3, 4)
self.calculator.Sum(calculator1.Sum(1, 2), calculator2.Difference(3, 4))
self.assertEqual(2, self.calculator.Result)
class MyTestCase(unittest.TestCase):
def setUp(self):
self.calculator = Calculator()
def test_instantiate_calculator(self):
self.assertIsInstance(self.calculator, Calculator)
def test_results_property(self):
self.assertEqual(self.calculator.result, 0)
def test_add_method(self):
add_data = CSVReader('csv/Unit Test Addition.csv')
for row in add_data.data:
self.assertEqual(
self.calculator.add(int(row['Value 1']), int(row['Value 2'])),
int(row['Result']))
def test_subtract_method(self):
sub_data = CSVReader('csv/Unit Test Subtraction.csv')
for row in sub_data.data:
self.assertEqual(
self.calculator.subtract(int(row['Value 2']),
int(row['Value 1'])),
int(row['Result']))
def test_multiply_method(self):
sub_data = CSVReader('csv/Unit Test Multiplication.csv')
for row in sub_data.data:
self.assertEqual(
self.calculator.multiply(int(row['Value 2']),
int(row['Value 1'])),
int(row['Result']))
def test_divide_method(self):
sub_data = CSVReader('csv/Unit Test Division.csv')
for row in sub_data.data:
self.assertEqual(
round(
self.calculator.divide(float(row['Value 2']),
float(row['Value 1'])), 9),
float(row['Result']))
def test_divide_method_zero(self):
with self.assertRaises(Exception):
self.calculator.divide(1, 0)
def test_square_method(self):
sub_data = CSVReader('csv/Unit Test Square.csv')
for row in sub_data.data:
self.assertEqual(self.calculator.square(int(row['Value 1'])),
int(row['Result']))
def test_sqrt_method(self):
sub_data = CSVReader('csv/Unit Test Square Root.csv')
for row in sub_data.data:
self.assertEqual(
round(self.calculator.square_root(float(row['Value 1'])), 8),
round(float(row['Result']), 8))
class MyTestCase(unittest.TestCase):
calculator = Calculator()
def test_sample_sd(self):
my_population = read_population("population.csv")
self.assertEqual(self.calculator.sample_sd(my_population), read_answer("answer_sample_sd.csv")) # positive test
self.assertNotEqual(self.calculator.sample_sd(my_population),(read_answer("answer_sample_sd.csv") + 1.5)) # negative test
class MyTestCase(unittest.TestCase):
calculator = Calculator()
def test_mean(self):
my_population=read_population("population.csv")
expected_output=read_answer("answer_mean.csv")
self.assertEqual(self.calculator.mean(my_population),expected_output) #positive test
self.assertNotEqual(self.calculator.mean(my_population),(expected_output+1)) #negative test
class MyTestCase(unittest.TestCase):
calculator = Calculator() #common object for all the test methods
def test_instantiate_calculator(self):
self.assertIsInstance(self.calculator, Calculator)
def test_add(self):
test_row_list = read_csv("addition.csv")
for row in test_row_list:
a = int(row[0])
b = int(row[1])
c = int(row[2])
exp_result = self.calculator.add(a, b)
self.assertEqual(exp_result, c)
def test_subtract(self):
test_row_list = read_csv("subtraction.csv")
for row in test_row_list:
a = int(row[0])
b = int(row[1])
c = int(row[2])
exp_result = self.calculator.subtract(a, b)
self.assertEqual(exp_result, c)
def test_multiply(self):
test_row_list = read_csv("multiplication.csv")
for row in test_row_list:
a = int(row[0])
b = int(row[1])
c = int(row[2])
exp_result = self.calculator.multiply(a, b)
self.assertEqual(exp_result, c)
def test_divide(self):
test_row_list = read_csv("division.csv")
for row in test_row_list:
a = int(row[0])
b = int(row[1])
c = float(row[2])
exp_result = self.calculator.divide(a, b)
self.assertEqual(exp_result, c)
def test_square(self):
test_row_list = read_csv("square.csv")
for row in test_row_list:
a = int(row[0])
b = int(row[1])
#c=int(row[2])
exp_result = self.calculator.square(a)
self.assertEqual(exp_result, b)
def test_square_root(self):
test_row_list = read_csv("square_root.csv")
for row in test_row_list:
a = int(row[0])
b = Decimal(row[1])
#c=float(row[2])
exp_result = self.calculator.square_root(a)
self.assertEqual(exp_result, b)
class MyTestCase(unittest.TestCase):
def setUp(self):
self.calculator = Calculator()
def test_instantiate_calculator(self):
self.assertIsInstance(self.calculator, Calculator)
def test_calculator_return_sum(self):
result = self.calculator.Sum(1, 2)
self.assertEqual(3, result)
def test_calculator_access_sum_result(self):
self.calculator.Sum(1, 2)
self.assertEqual(3, self.calculator.Result)
def test_calculator_return_difference(self):
result = self.calculator.Difference(1, 2)
self.assertEqual(-1, result)
def test_calculator_access_difference_result(self):
self.calculator.Difference(1, 2)
self.assertEqual(-1, self.calculator.Result)
def test_calculator_return_product(self):
result = self.calculator.Multiplication(1, 2)
self.assertEqual(2, result)
def test_calculator_access_product_result(self):
self.calculator.Multiplication(1, 2)
self.assertEqual(2, self.calculator.Result)
def test_calculator_divide(self):
result = self.calculator.Divide(10, 5)
self.assertEqual(2, result)
def test_calculator_root(self):
result = self.calculator.Root(9)
self.assertEqual(3, result)
def test_calculator_power(self):
result = self.calculator.Power(4, 2)
self.assertEqual(16, result)
def test_calculator_log(self):
result = self.calculator.Logarithm(10, 1)
self.assertEqual(0, result)
class MyTestCase(unittest.TestCase):
calculator = Calculator()
def test_instantiate_calculator(self):
try:
self.assertIsInstance(self.calculator, Calculator)
except AssertionError as e:
print("Calculator Instantiation has Assertion Error:", e)
assert 0
class MyTestCase(unittest.TestCase):
def setUp(self) -> None:
self.calculator = Calculator()
def test_instantiate_calculator(self):
self.assertIsInstance(self.calculator, Calculator)
def test_results_property_calculator(self):
self.assertEqual(self.calculator.result, 0)
def test_divide_zero(self):
self.assertEqual(self.calculator.divide(0, 4), "Division by zero")
def test_add_method_calculator(self):
test_data = CsvReader('Tests/Data/Unit_Test_Addition.csv').data
for row in test_data:
self.assertEqual(
self.calculator.add(row['Value 1'], row['Value 2']),
int(row['Result']))
self.assertEqual(self.calculator.result, int(row['Result']))
def test_subtract_method_calculator(self):
test_data = CsvReader('Tests/Data/Unit_Test_Subtraction.csv').data
for row in test_data:
self.assertEqual(
self.calculator.subtract(row['Value 1'], row['Value 2']),
int(row['Result']))
self.assertEqual(self.calculator.result, int(row['Result']))
def test_multiply_method_calculator(self):
test_data = CsvReader('Tests/Data/Unit_Test_Multiplication.csv').data
for row in test_data:
self.assertEqual(
self.calculator.multiply(row['Value 1'], row['Value 2']),
int(row['Result']))
self.assertEqual(self.calculator.result, int(row['Result']))
def test_divide_method_calculator(self):
test_data = CsvReader('Tests/Data/Unit_Test_Division.csv').data
for row in test_data:
self.assertEqual(
self.calculator.divide(row['Value 1'], row['Value 2']),
float(row['Result']))
self.assertEqual(self.calculator.result, float(row['Result']))
def test_squared_method_calculator(self):
test_data = CsvReader('Tests/Data/Unit_Test_Square.csv').data
for row in test_data:
self.assertEqual(self.calculator.square(row['Value 1']),
int(row['Result']))
self.assertEqual(self.calculator.result, int(row['Result']))
def test_squareroot_method_calculator(self):
test_data = CsvReader('Tests/Data/Unit_Test_Square_Root.csv').data
for row in test_data:
self.assertEqual(self.calculator.squareroot(row['Value 1']),
round(float(row['Result']), 7))
self.assertEqual(self.calculator.result,
round(float(row['Result']), 7))
def cochran_large(proportion, me, confidence):
calc = Calculator()
z = Statistics.z_given_confidence(confidence)
z_2 = calc.square(z)
e_2 = calc.square(me)
n_0 = calc.divide(
calc.multiply(calc.multiply(z_2, proportion), 1 - proportion), e_2)
return round(n_0, 0)
def automateMultiply(self):
print(" Test Case for Multiplication ")
print(self.random1, "- This is first Random number ")
print(self.random2, "- This is second Random number ")
num1 = self.random1
num2 = self.random2
print("Multiply by Automated function =", num1 * num2)
# By using the function
c = Calculator()
Multiply = c.multiply(num1, num2)
print("Multiply Output by Calling function =", Multiply)
if num1 * num2 == Multiply:
print("Test case of calculator Multiply is passed\n\n")
else:
print(" Test Automation of of Calculator Multiply is failed ")
print('*' * 70)
def automateSubtraction(self):
print("Test Case for Subtraction")
print(self.random1, "- This is first Random number ")
print(self.random2, "- This is second Random number ")
num1 = self.random1
num2 = self.random2
print("Subtraction by Automated function =", num1 - num2)
# By using the function
c = Calculator()
subtraction = c.subtract(num1, num2)
print("Subtraction Output by Calling function =", subtraction)
if num1 - num2 == subtraction:
print("Test case of calculator Subtraction passed\n\n")
else:
print(" Test Automation of of Calculator Subtraction is failed ")
print('*' * 70)
def automateAdd(self):
print(" Test Case for Addition ")
print(self.random1, "- This is first Random number ")
print(self.random2, "- This is second Random number ")
num1 = self.random1
num2 = self.random2
print("Addition by Automated funnction =", num1 + num2)
# By using the function
c = Calculator()
sum2 = c.add(num1, num2)
print("Addition Output by Calling function =", sum2)
if num1 + num2 == sum2:
print("Test case of calculator is passed\n\n")
else:
print(" Test Automation of of Calculator Addition is failed ")
print('*' * 70)
class MyTestCase(unittest.TestCase):
def setUp(self):
self.calculator = Calculator()
def test_instantiate_calculator(self):
self.assertIsInstance(self.calculator, Calculator)
def test_calculator_return_sum(self):
self.assertEqual(3, self.calculator.Sum(1, 2))
def test_calculator_result_access_difference_result(self):
self.calculator.Difference(1, 2)
self.assertEqual(-1, self.calculator.Result)
def test_calculator_result_access_Sum_result(self):
self.calculator.Sum(1, 2)
self.assertEqual(3, self.calculator.Result)
def test_multiple_result_calculator(self):
calculator1 = Calculator()
calculator2 = Calculator()
calculator1.Sum(1, 2)
calculator2.Difference(3, 4)
self.calculator.Sum(calculator1.Sum(1, 2), calculator2.Difference(3, 4))
self.assertEqual(2, self.calculator.Result)
def test_product_result_calculator(self):
self.calculator.Product(2, 4)
self.assertEqual(8, self.calculator.Result)
def test_division_result_calculator(self):
self.calculator.Fraction(6, 3)
self.assertEqual(2, self.calculator.Result)
def test_power_result_calculator(self):
self.calculator.Power(2, 3)
self.assertEqual(8, self.calculator.Result)
def test_root_result_calculator(self):
self.calculator.Root(2, 16)
self.assertEqual(4, self.calculator.Result)
def test_log_result_calculator(self):
float(self.calculator.Log(2, 4))
self.assertEqual(2, self.calculator.Result)
class MyTestCase(unittest.TestCase):
calculator = Calculator()
def test_median(self):
my_population = read_population("population.csv")
expected_output = read_answer("answer_median.csv")
try:
self.assertEqual(self.calculator.median(my_population), expected_output) # positive test
self.assertNotEqual(self.calculator.median(my_population), (expected_output + 1)) # negative test
except AssertionError as e:
print("Median has Assertion Error:", e)
assert 0
class MyTestCase(unittest.TestCase):
calculator = Calculator()
def test_standardised_score(self):
my_population = read_population("population.csv")
expected_output = read_answer_list("answer_zscore.csv")
self.assertListEqual(self.calculator.z_score(my_population),
expected_output) # positive test
self.assertNotEqual(
self.calculator.z_score(my_population),
(list(map(lambda x: x + 1, expected_output)))) # negative test
class MyTestCase(unittest.TestCase):
calculator = Calculator()
def test_sample_mean(self):
my_population = read_population("population.csv")
try:
self.assertEqual(self.calculator.sample_mean(my_population),read_answer("answer_sample_mean.csv")) # positive test
self.assertNotEqual(self.calculator.sample_mean(my_population),(read_answer("answer_sample_mean.csv") + 1)) # negative test
except AssertionError as e:
print("Sample Mean has Assertion Error:", e)
assert 0
class MyTestCase(unittest.TestCase):
calculator = Calculator()
def test_variance_sample_proportion(self):
my_population = read_population("population.csv")
# expected_output = read_answer("answer_variance_sample_proportion.csv")
try:
self.assertEqual(self.calculator.variance_sample_proportion(my_population),read_answer("answer_variance_sample_proportion.csv")) # positive test
self.assertNotEqual(self.calculator.variance_sample_proportion(my_population),(read_answer("answer_variance_sample_proportion.csv") + 1)) # negative test
except AssertionError as e:
print("Variance of Sample Proportion has Assertion Error:", e)
assert 0
class MyTestCase(unittest.TestCase):
def setUp(self) -> None:
self.calculator = Calculator()
def test_instantiate_calculator(self):
self.assertIsInstance(self.calculator, Calculator)
def test_addition(self):
add = self.calculator.add(4 ,6)
self.assertEqual(add, 10)
def test_subtraction(self):
subtract = self.calculator.subtract(6 ,3)
self.assertEqual(subtract, 3)
def test_division(self):
divide = self.calculator.divide(10, 2)
self.assertEqual(divide, 5)
def test_multiplication(self):
product = self.calculator.multiply(3, 3)
self.assertEqual(product, 9)
def test_power(self):
power = self.calculator.square(3, 2)
self.assertEqual(power, 9)
def test_root(self):
root = self.calculator.root(9, 2)
self.assertEqual(root, 3)
def test_results_property(self):
self.assertEqual(self.calculator.result, 0)
class MyTestCase(unittest.TestCase):
def setUp(self):
self.calculator = Calculator()
def test_instantiate_calculator(self):
self.assertIsInstance(self.calculator, Calculator)
def test_calculator_return_sum(self):
result = self.calculator.add(1, 2)
self.assertEqual(3, result)
def test_calculator_return_square (self):
result = self.calculator.square(2)
self.assertEqual(4,result)
def test_calculator_return_SquareRoot(self):
result = self.calculator.SquareRoot(4)
self.assertEqual(2, result)
def test_calculator_return_product (self):
result = self.calculator.Product(2,2)
self.assertEqual(4,result)
def test_calculator_return_division (self):
result = self.calculator.Division(2,2)
self.assertEqual(1,result)
def test_calculator_return_difference(self):
result = self.calculator.subtract(1, 2)
self.assertEqual(-1, result)
class MyTestCase(unittest.TestCase):
def setUp(self) -> None:
self.calculator = Calculator()
def test_instantiate_calculator(self):
self.assertIsInstance(self.calculator, Calculator)
def test_addition(self):
add = self.calculator.add(2, 2)
self.assertEqual(add, 4)
def test_subtraction(self):
subtract = self.calculator.subtract(2, 2)
self.assertEqual(subtract, 0)
def test_multiplication(self):
product = self.calculator.product(3, 2)
self.assertEqual(product, 6)
def test_division(self):
divide = self.calculator.divide(2, 1)
self.assertEqual(divide, 2)
def test_power(self):
power = self.calculator.power(3, 2)
self.assertEqual(power, 9)
def test_root(self):
root = self.calculator.root(16, 2)
self.assertEqual(root, 4)
class MyTestCase(unittest.TestCase):
def setUp(self) -> None:
self.calculator = Calculator()
def test_instantiate_calculator(self):
self.assertIsInstance(self.calculator, Calculator)
def test_addition(self):
test_data = CsvReader.CsvReader('Tests/Data/TestAddition.csv').data
for row in test_data:
result = float(row['Result'])
self.assertEqual(
self.calculator.add(row['Value 1'], row['Value 2']), result)
self.assertEqual(self.calculator.result, int(row['Result']))
def test_subtraction(self):
test_data = CsvReader.CsvReader('Tests/Data/TestSubtraction.csv').data
for row in test_data:
result = float(row['Result'])
self.assertEqual(
self.calculator.subtract(row['Value 1'], row['Value 2']),
result)
self.assertEqual(self.calculator.result, int(row['Result']))
def test_multiplication(self):
test_data = CsvReader.CsvReader(
'Tests/Data/TestMultiplication.csv').data
for row in test_data:
result = float(row['Result'])
self.assertEqual(
self.calculator.multiply(row['Value 1'], row['Value 2']),
result)
self.assertEqual(self.calculator.result, int(row['Result']))
def test_division(self):
test_data = CsvReader.CsvReader('Tests/Data/TestDivision.csv').data
for row in test_data:
result = float(row['Result'])
self.assertAlmostEqual(
self.calculator.divide(row['Value 1'], row['Value 2']), result)
self.assertAlmostEqual(self.calculator.result,
float(row['Result']))
def test_square(self):
test_data = CsvReader.CsvReader('Tests/Data/TestSquare.csv').data
for row in test_data:
result = float(row['Result'])
self.assertEqual(self.calculator.square(row['Value 1']), result)
self.assertEqual(self.calculator.result, int(row['Result']))
def test_square_root(self):
test_data = CsvReader.CsvReader('Tests/Data/TestSquareRoot.csv').data
for row in test_data:
result = float(row['Result'])
self.assertAlmostEqual(self.calculator.square_root(row['Value 1']),
result)
self.assertAlmostEqual(self.calculator.result,
float(row['Result']))
class MyTestCase(unittest.TestCase):
def setUp(self) -> None:
self.calculator = Calculator()
def test_instantiate_calculator(self):
self.assertIsInstance(self.calculator, Calculator)
def test_subtraction(self):
test_data = CsvReader("Tests/Data/subtraction.csv").data
for row in test_data:
result = float(row['Result'])
self.assertEqual(
self.calculator.subtract(row['Value 1'], row['Value 2']),
result)
self.assertEqual(self.calculator.result, result)
def test_add_method_calculator(self):
test_data_add = CsvReader('Tests/Data/Addition.csv').data
for row in test_data_add:
self.assertEqual(
self.calculator.add(row['Value 1'], row['Value 2']),
float(row['Result']))
self.assertEqual(self.calculator.result, float(row['Result']))
def test_multiply_method_calculator(self):
test_data_multiply = CsvReader('Tests/Data/Multiplication.csv').data
for row in test_data_multiply:
self.assertEqual(
self.calculator.mul(row['Value 1'], row['Value 2']),
float(row['Result']))
self.assertEqual(self.calculator.result, float(row['Result']))
def test_divide_method_calculator(self):
test_data_divide = CsvReader('Tests/Data/Division.csv').data
for row in test_data_divide:
self.assertEqual(
round(self.calculator.division(row['Value 1'], row['Value 2']),
2), round(float(row['Result']), 2))
self.assertEqual(round(self.calculator.result, 2),
round(float(row['Result']), 2))
def test_square_method_calculator(self):
test_data_square = CsvReader('Tests/Data/Square.csv').data
for row in test_data_square:
self.assertEqual(self.calculator.sq(row['Value 1']),
float(row['Result']))
self.assertEqual(self.calculator.result, float(row['Result']))
def test_square_root_method_calculator(self):
test_data_square_root = CsvReader('Tests/Data/Square Root.csv').data
for row in test_data_square_root:
self.assertEqual(round(self.calculator.sqr(row['Value 1']), 2),
round(float(row['Result']), 2))
self.assertEqual(round(self.calculator.result, 2),
round(float(row['Result']), 2))
def test_results_property(self):
self.assertEqual(self.calculator.result, 0)
import sys
argparser = argparse.ArgumentParser()
argparser.add_argument("-f", help="file path")
args = argparser.parse_args()
if not args.f:
print 'No file option'
sys.exit()
freader = FileIO.FileReader.FileReader(args.f)
try:
expressions = freader.readlines()
except IOError:
print 'File doesnt exist'
sys.exit()
myparser = Parser()
mycalc = Calculator()
i = 1
for expression in expressions:
tokens = myparser.parse(expression)
try:
result = mycalc.calculate(tokens)
except FunctionParseError as exc:
print '{0}){1}'.format(i, exc)
except NumberParseError as exc:
print '{0}){1}'.format(i, exc)
except InvalidSyntaxError as exc:
print '{0}){1}'.format(i, exc)
except FloatingPointError:
print '{0}){1}'.format(i, 'Floating point error')
except ZeroDivisionError:
print '{0}){1}'.format(i, 'Zero division')
