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')