def calculate(self, question=None): ''' Return answer to the get/post value question via json in answer. ''' cherrypy.response.headers['Content-type'] = 'application/json' calc = '' if 'workings' not in cherrypy.session: cherrypy.session['workings'] = '' if 'calc' not in cherrypy.session: calc = Calculator() calc.set_precision(3) cherrypy.session['calc'] = calc else: calc = cherrypy.session['calc'] ans = calc.evaluate(question) strippedans = '' # TODO: Make general if isinstance(ans, StrWithHtml): ans = re.sub(r'c:/users/.*/appdata/local/temp/', r'/tmp/', ans.html, 100) strippedans = re.sub('[ ]?style=".*"', '', ans, 100) strippedans = re.sub('</?canvas[^>]*>', '', strippedans, 100) strippedans = re.sub('svg', 'png', strippedans, 100) else: ans = '\n'.join(map(lambda a: '<p>' + a + '</p>', re.split(r"\n", ans))) cherrypy.session['workings'] += ('<div style="page-break-after">' + '<h4 style="-pdf-keep-with-next">{}' + '</h4>\n<div>{}\n</div></div>\n').format(question, strippedans) return json.dumps({'answer': ans})
def index(): result = [] #utc = datetime.utcnow() #year = utc.year #month = utc.month #day = utc.day #hour = utc.hour #minute = utc.minute #minute = int(math.floor(minute / 10.0) * 10.0) #minute = 10 * math.floor(utc.minute / 10) #now = datetime(year, month, day, hour, minute) utc = request.args.get('utc', '') utc = datetime.strptime(utc, '%Y-%m-%d %H:%M') lat = float(request.args.get('lat', '')) lon = float(request.args.get('lon', '')) for item in db.location.find({"time" : utc}): calculator = Calculator() answer = calculator.convert(item['ra'], item['dec'], lat, lon, item['lt'], utc) data = { 'aid' : item['aid'], 'lt' : item['lt'], 'alt' : answer['altitude'], 'azi' : answer['azimuth'] } result.append(data) return Response(json.dumps(result), mimetype='application/json')
class TddInPythonExample(unittest.TestCase): def setUp(self): self.calc = Calculator() def test_calculator_add_method_returns_correct_result(self): result = self.calc.add(2, 2) self.assertEqual(4, result) def test_calculator_returns_error_message_if_both_args_not_numbers(self): self.assertRaises(ValueError, self.calc.add, 'two', 'three') def test_calculator_subtract_method_returns_correct_result(self): result = self.calc.subtract(4,2) self.assertEqual(2, result) def test_calculator_returns_error_message_if_both_args_not_numbers(self): self.assertRaises(ValueError, self.calc.subtract, "four", "two") def test_calculator_multiply_method_returns_correct_result(self): result = self.calc.multiply(3,5) self.assertEqual(15, result) def test_calculator_returns_error_message_if_both_args_not_number(self): self.assertRaises(ValueError, self.calc.multiply, "three","five") def test_calculator_divide_method_returns_correct_result(self): result = self.calc.divide(15,3) self.assertEqual(5, result) def test_calcualtor_returns_error_message_if_btoh_args_not_number(self): self.assertRaises(ValueError, self.calc.divide, "fifteen","three")
def test_add(): calc = Calculator() (4).should.equal(calc.add(2, 2)) calc.add.when.called_with('two', 'three').should.throw(ValueError) calc.add.when.called_with('two', 3).should.throw(ValueError) calc.add.when.called_with(2, 'three').should.throw(ValueError)
def main(argv=None): if argv is None: argv = sys.argv variable_table = VariableTable() calculator = Calculator(variable_table) # get user input while True: try: input_str = raw_input('> ') except EOFError: break except KeyboardInterrupt: print '' break #print "input: '" + input_str + "'" try: print calculator.run(input_str) except UndefinedVariableException as e: print 'Undefined variable: %s' % e except ParserException: print 'Parser error' except LexerException: print 'Lexer error' except ExitCMD: return 0 return 0
class TestCalculator(unittest.TestCase): @classmethod def setUpClass(self): # Create an instance of the calculator that can be used in all tests self.calc = Calculator() print('Set up class') @classmethod def tearDownClass(self): print('Tear down class') def test_add(self): self.assertEqual(self.calc.add(2, 7), 9) # Write test methods for subtract, multiply, and divide def test_subtract(self): self.assertEqual(self.calc.subtract(5, 3), 2) def test_multiply(self): self.assertEqual(self.calc.multiply(2, 7), 14) def test_divide(self): self.assertEqual(self.calc.divide(14, 7), 2)
class TestComplex(unittest.TestCase): def setUp(self): self.calc = Calculator() @weight(2) @visibility('after_due_date') def test_eval_parens(self): """Evaluate (1 + 1) * 4""" val = self.calc.eval("(1 + 1) * 4") self.assertEqual(val, 8) @weight(2) @visibility('after_due_date') def test_eval_precedence(self): """Evaluate 1 + 1 * 8""" val = self.calc.eval("1 + 1 * 8") self.assertEqual(val, 9) @weight(2) def test_eval_mul_div(self): """Evaluate 8 / 4 * 2""" val = self.calc.eval("8 / 4 * 2") self.assertEqual(val, 4) @weight(2) def test_eval_negative_number(self): """Evaluate -2 + 6""" val = self.calc.eval("-2 + 6") self.assertEqual(val, 4)
def test_adds_numbers(self): # Arrange calculator = Calculator() # Act result = calculator.add(1, 2) # Assert self.assertEqual(3, result)
def tf_idf(): util.print_message('Start counting tf-idf...', debug=True) if not os.path.exists(settings.TFIDF_FILE_PATH): os.mkdir(settings.TFIDF_FILE_PATH) c = Calculator() file_names = util.get_file_list(settings.WORD_COUNT_FILE_PATH) for file_name in file_names: util.print_message('Processing tf-idf on {0}', arg=file_name) c.tf_idf(file_name, None, None)
class TestEvaluator(unittest.TestCase): def setUp(self): self.calc = Calculator() @weight(2) @visibility('after_published') def test_eval_power(self): """Evaluating 2 ** 8 should raise an exception""" with self.assertRaises(CalculatorException): self.calc.eval("2 ** 8")
def test_invalid_string(self): calc = Calculator() calc.expr = "a,b" try: result = calc.add() finally: result = -1 self.assertEqual(result, -1)
class TestCalculator(unittest.TestCase): def setUp(self): self.c = Calculator() def test_add3To4ToGet7(self): actual = self.c.add(3, 4) self.assertEquals(7, actual) def test_addTwoIntegers(self): actual = self.c.add(5, 8) self.assertEquals(13, actual) def test_invalidFirstArgThrowsException(self): self.assertRaises(ValueError, self.c.add, "three", 6)
def count_words(): util.print_message('Start counting words...', debug=True) if not os.path.exists(settings.WORD_COUNT_FILE_PATH): os.mkdir(settings.WORD_COUNT_FILE_PATH) client = MongoClient(settings.MONGO_HOST, 27017) db = client[settings.MONGO_DATABASE] c = Calculator() cursor = db.arch.find() for post in cursor: c.tf(str(post['_id'])+'.txt', post['url'], post['body'])
class CalculatorPushTestCase(unittest.TestCase): """Test :py:meth:`Calculator.push`.""" def setUp(self): self.calculator = Calculator() def test_should_add_number_to_stack_if_powered(self): """Scenario: add number to stack.""" # Arrange self.calculator.on() number = 50 # Act self.calculator.push(number) # Assert self.assertEqual(self.calculator._stack, [number]) def test_should_raise_exception_if_not_powered(self): """Scenario: not powered.""" # Act & Assert self.assertRaises(CalculatorNotPoweredError, self.calculator.push, 50) def test_should_add_two_numbers_to_stack(self): """Scenario: add two numbers to stack.""" # Arrange self.calculator.on() number1 = 50 number2 = 70 # Act self.calculator.push(number1) self.calculator.push(number2) # Assert self.assertEqual(self.calculator._stack, [number1, number2])
class Mytest(unittest.TestCase): def setUp(self): self.foo = Calculator(3,2) def test_add(self): self.assertEqual(self.foo.add(), 5) def test_sub(self): self.assertEqual(self.foo.sub(),1) def test_mul(self): self.assertEqual(self.foo.mul(),6) def test_div(self): self.assertEqual(self.foo.div(), 1)
class TddInPythonExample(unittest.TestCase): # ran before each test def setUp(self): self.calc = Calculator() # ran after each test def tearDown(self): pass def test_calculator_add_method_returns_correct_result(self): self.assertEqual(self.calc.add(2,2), 4) def test_calculator_add_method_returns_correct_result_example_two(self): self.assertEqual(self.calc.add(3,2), 5)
def __init__(self): """Sets up the calculator app.""" EasyFrame.__init__(self, "Calculator App", background = "black", resizable = False) self.calculator = Calculator() self.operatorEntered = False self.mainLabel = self.addLabel ("0", row = 0, column = 0, columnspan = 4, sticky = "E", background = "black", foreground = "white") self.clearButton = self.addButton ("AC", row = 1, column = 0, command = self.clearLabel) self.signButton = self.addButton ("+/-", row = 1, column = 1, command = self.changeSign) self.percentButton = self.addButton ("%", row = 1, column = 2) self.divideButton = self.addButton ("/", row = 1, column = 3, command = self.makeOperatorCommand("/")) self.multiplyButton = self.addButton ("x", row = 2, column = 3, command = self.makeOperatorCommand("*")) self.subtractButton = self.addButton ("-", row = 3, column = 3, command = self.makeOperatorCommand("-")) self.additionButton = self.addButton ("+", row = 4, column = 3, command = self.makeOperatorCommand("+")) self.equalsButton = self.addButton ("=", row = 5, column = 3, command = self.makeOperatorCommand("=")) self.decimalButton = self.addButton (".", row = 5, column = 2, command = self.addDecimal) self.zeroButton = self.addButton ("0", row = 5, column = 0, command = self.addZero) digit = 9 for row in range (2,5): for column in range (0,3): numberButton = self.addButton(str(digit), row, column) numberButton["command"] = self.makeCommand(str(digit)) digit -= 1
class TryingOutUnitTest(unittest.TestCase): def setUp(self): self.calc = Calculator() def test_adding_two_numbers_should_pass(self): result = self.calc.add(2, 2) self.assertEquals(4, result) def test_adding_two_number_should_fail(self): result = self.calc.add(2, 4) self.assertNotEqual(4, result) def test_adding_int_and_text_fails(self): result = self.calc.add("hello", 2) self.assertRaises(TypeError)
def calculate_next_position(self): """ Calculate the agent's next position depending on the alliance decided. Changed after Muge, added sigma_m/sigma_k values. """ if (self.alliance != None): # if there is a link self.next_map_market = Calculator.calculate_next_position(self.map_market, \ self.alliance.map_market, \ MAP_MARKET, \ ALPHA_MARKET, self.sigma_m) self.next_map_tech = Calculator.calculate_next_position(self.map_knowledge, \ self.alliance.map_knowledge, \ MAP_TECH, \ ALPHA_TECH, self.sigma_k)
class TddCalculator(unittest.TestCase): def setUp(self): self.calc = Calculator() def test_calculator_add_method_returns_correct_result(self): result = self.calc.add(2, 2) self.assertEqual(4, result) def test_calculator_returns_error_message_if_both_args_not_numbers(self): self.assertRaises(ValueError, self.calc.add, "two", "three") def test_calculator_returns_error_message_second(self): self.assertRaises(ValueError, self.calc.add, 2, "three") def test_calculator_assert_not_equal(self): result = self.calc.add(3, 4) self.assertNotEqual(6, result)
def __init__(self, parent=None): ''' Initialize the graphical interface ''' # Initialize the parent class super(CalculatorForm, self).__init__(parent) # Load the ui file uic.loadUi('advancedui.ui', self) # This is probably wrong # Create an instance of the calculator self.calc = Calculator()
class CalculatorDocstringTestCase(unittest.TestCase): """Calculator acceptance test case.""" def test_addition(self): """Addition feature.""" run( __file__, self, as_str=__doc__, scenario="Subsequent additions", verbose=True, ) def setUp(self): self.calculator = Calculator() def step_I_have_powered_calculator_on(self): r"I have powered calculator on" self.calculator.on() def step_I_enter_a_number_into_the_calculator(self, number): r'I enter "(.+)" into the calculator' # match by regexp self.calculator.push(int(number)) def step_I_press_add(self): # matched by method name self.calculator.add() def step_the_result_should_be_on_the_screen(self, number): r'the result should be "{number}" on the screen' # match by format-like string self.assertEqual(int(number), self.calculator.get_result())
class CalculatorTestCase(unittest.TestCase): """ Calculator acceptance test case. """ def setUp(self): self.calculator = Calculator() def step_I_have_powered_calculator_on(self): r'I have powered calculator on' self.calculator.on() def step_I_enter_a_number_into_the_calculator(self, number): r'I enter "(.+)" into the calculator' # match by regexp self.calculator.push(int(number)) def step_I_press_add(self): # matched by method name self.calculator.add() def step_the_result_should_be_on_the_screen(self, number): r'the result should be "{number}" on the screen' # match by format-like string self.assertEqual(int(number), self.calculator.get_result()) def test_addition(self): """ Addition feature """ filename = os.path.join(os.path.dirname(__file__), 'calculator.feature') run(filename, self, verbose=True)
class TestCalculator(unittest.TestCase): '''Test Calculator module.''' def setUp(self): self.calc = Calculator() def test_sum(self): '''Test sum operation.''' answer = self.calc.add(2, 4) self.assertEqual(answer, 6)
def test_calculate_loan_balance_start(self): months_elapsed = 0 loan_balance = round(Calculator.calculate_loan_balance(self.principal, self.rate, self.term, months_elapsed), 0) self.assertEqual( loan_balance, self.principal, "The loan balance should be the full principal")
def test_calculate_loan_balance_end(self): months_elapsed = 360 loan_balance = round(Calculator.calculate_loan_balance(self.principal, self.rate, self.term, months_elapsed), 0) self.assertEqual( loan_balance, 0, "the loan balance at the end of the mortgage term should be 0")
class CalculatorTest(unittest.TestCase): def setUp(self): self.calc = Calculator() def test_add(self): result = self.calc.add(4, 8) self.assertEqual(12, result) def test_subtract(self): result = self.calc.subtract(8, 4) self.assertEqual(4, result) def test_multiply(self): result = self.calc.multiply(8, 4) self.assertEqual(32, result) def test_divide(self): result = self.calc.divide(8, 4) self.assertEqual(2, result)
def calculate_mortgage_schedule(self): principal = 200000 rate = 6.5 term = 30 # Run the calculation schedule = Calculator.calculate_schedule(principal, rate, term) # Display it self.view.display_schedule(schedule)
class TestCalc(unittest.TestCase): def setUp(self): self.calc = Calculator() def test_add(self): result = self.calc.add(2, 2) self.assertEqual(4, result) def test_error_if_not_numbers(self): self.assertRaises(ValueError, self.calc.add, 'two', 'three')
class CalculatorTestCase(unittest.TestCase): def setUp(self): self.c = Calculator() def testAdd(self): res = self.c.add(1, 1.2) self.assertEquals(2.2, res) def testSub(self): res = self.c.sub(13.2, 10.4) self.assertEquals(2.8, res) def testMul(self): res = self.c.mul(12, 0.1) self.assertEquals(1.2, res) def testDiv(self): res = self.c.div(0.3, 0.1) self.assertEquals(3, res) def testZeroDiv(self): self.assertRaises(ValueError, self.c.div, 5, 0) def testMyPowerZero(self): res = self.c.my_pow(3, 0) self.assertEquals(1, res) def testMyPowerNegativeToFractional(self): self.assertRaises(ValueError, self.c.my_pow, -2, 3.45) def testMyPowerZeroToNegative(self): self.assertRaises(ValueError, self.c.my_pow, 0, -2) def testMyPowerFractionalDegree(self): res = self.c.my_pow(4, 1.5) self.assertEquals(8, res) def testMyPowerIntegerNegativeDegree(self): res = self.c.my_pow(2, -3) self.assertEquals(0.125, res) def testMyPowerIntegerPositiveDegree(self): res = self.c.my_pow(0.1, 2) self.assertEquals(0.01, res) def testMyPowerFloatFractionalDegree(self): res = self.c.my_pow(1.44, 0.5); self.assertEquals(1.2, res)
def test_div(self): a = Calculator(1, 2) self.assertEqual(a.div(), 0.5)
def main(): calc = Calculator() performCalcLoop(calc) print("Done Calculating.")
class Test(unittest.TestCase): def setUp(self): ''' Set up the calculator for each of the unit tests This function is run once, before each of the test methods below. ''' self.calc = Calculator() def test_addition(self): try: assert self.calc.calculate('0', '+', '1') == 1 assert self.calc.calculate('3', '+', '9') == 12 assert self.calc.calculate('-4', '+', '-8') == -12 assert self.calc.calculate('-7', '+', '9') == 2 assert self.calc.calculate('3', '+', '0') == 3 assert self.calc.calculate('2.0', '+', '5.3') == 7.3 except: self.fail('This should not raise an exception.') def test_subtraction(self): try: assert self.calc.calculate('3', '-', '9') == -6 assert self.calc.calculate('-4', '-', '-8') == 4 assert self.calc.calculate('-7', '-', '9') == -16 assert self.calc.calculate('3', '-', '0') == 3 assert self.calc.calculate('2.0', '-', '5.3') == -3.3 except: self.fail('This should not raise an exception.') def test_division(self): try: assert self.calc.calculate('3', '/', '12') == 0.25 assert self.calc.calculate('-4', '/', '-8') == 0.5 assert self.calc.calculate('16', '/', '-8') == -2 assert self.calc.calculate('0', '/', '3') == 0 assert self.calc.calculate('-5.0', '/', '2') == -2.5 except: self.fail('This should not raise an exception.') def test_multiplication(self): try: assert self.calc.calculate('3', '*', '9') == 27 assert self.calc.calculate('-4', '*', '-8') == 32 assert self.calc.calculate('-7', '*', '9') == -63 assert self.calc.calculate('3', '*', '0') == 0 assert self.calc.calculate('2.0', '*', '5.3') == 10.6 except: self.fail('This should not raise an exception.') def test_memory(self): try: assert self.calc.calculate('M', '*', '9') == 0 assert self.calc.calculate('M', '+', '-8') == -8 assert self.calc.calculate('M', '-', '9') == -9 assert self.calc.calculate('M', '/', '5') == 0 assert self.calc.calculate('9', '*', 'M') == 0 assert self.calc.calculate('8', '+', 'M') == 8 assert self.calc.calculate('9', '-', 'M') == 9 assert self.calc.calculate('5', '/', 'M') == ZeroDivisionError except: self.fail('This should not raise an exception.') def test_exceptions(self): # Test the bad operator exception. try: self.calc.calculate(4, 'f', '9') self.fail('This should raise an exception.') except Exception as e: assert isinstance(e, ValueError) assert e.__str__() == 'Invalid operation: f' # Test the divide by zero exception. try: self.calc.calculate(5, '/', 0) self.fail('This should raise an exception.') except Exception as e: assert isinstance(e, ZeroDivisionError) assert e.__str__() == 'float division by zero' # Test the bad operand exception try: self.calc.calculate('hi', '+', '9') self.fail('This should raise an exception.') except Exception as e: assert isinstance(e, ValueError) assert e.__str__() == "could not convert string to float: 'hi'"
def test_nlog3(self): c = Calculator() self.assertEqual(c.nlog(8), 2.0794)
def test_inlog3(self): c = Calculator() self.assertEqual(c.inlog(5), 148.4132)
def test_add(self): a = Calculator(1, 2) self.assertEqual(a.add(), 3)
def test_sub(self): a = Calculator(1, 2) self.assertEqual(a.sub(), -1)
def test_ceil2(self): c = Calculator() self.assertEqual(c.ceil(5.9), 6)
def test_ceil(self): c = Calculator() self.assertEqual(c.ceil(3.1), 4)
def test_floor3(self): c = Calculator() self.assertEqual(c.floor(0.9), 0)
def test_add3(self): c = Calculator() self.assertEqual(c.add(5, 8), 13)
def setUp(self): """stuff to do before every test""" """All tests below will run in order setUp, test_x, tearDown""" self.calc = Calculator()
# Calculator UI program # # This program uses the functions that are defined in the calculator program to run calculations. # It provides a menu to the user to selct what function they wish to run. # It also does error checking on the inputs to protect the program from invalid data. # # The program will run multiple times before ending if the users wants to do a number of calculations. x=0 y=0 # Import funtions from the Calculator Class that's set up in the calculator.py program. from calculator import Calculator calculation = Calculator() # Create a function to ask user which calculation they wish to perform and do error checking def menu_input (): # # ask user which calculation they wish to perform and do error check if operand is not valid symbol # print '\nThis program calculates the result based on which function you request' print '\n***** Please select menu number from below list. *****\n' print 'Input 1 for Add' print 'Input 2 for Subtract' print 'Input 3 for Multiply' print 'Input 4 for Divide' print 'Input 5 for Exponent'
def test_mul(self): a = Calculator(1, 2) self.assertEqual(a.mul(), 2)
def setUpClass(self): print('Set up class') # Create an instance of the calculator that can be used in all tests self.calc = Calculator() num1 = 2 num2 = 6
def setUp(self): self.calc = Calculator()
from calculator import Calculator mycalc = Calculator() print( 'A 10 Function Calculator\n**********************\nPlease use the following symbol:function pairs to perform calculations:\n' ) mycalc.printFunction() uinput = '' while (mycalc.quitCheck == False): try: uinput = input("\n\nEnter a number to start or q to exit: ") mycalc.checkQuit(uinput) if mycalc.quitCheck: break else: mycalc.userinput1 = uinput uinput = input("Select a function: ") mycalc.checkQuit(uinput) if (mycalc.quitCheck): break else: mycalc.userfunction = uinput if mycalc.userfunction in mycalc.oneValueSymbols: result = mycalc.selectFunction(mycalc.userfunction, mycalc.userinput1) print(result) elif mycalc.userfunction in mycalc.twoValueSymbols: uinput = input('Enter a second number: ') mycalc.checkQuit(uinput)
from calculator import Calculator from room import Room calc = Calculator() room = Room( input('Qual a largura do cômodo? '), input('Qual a profundidade do cômodo? ') ) print( 'A área das paredes é: ', calc.calculate_wall_area( room ) ) print( 'A área do teto é: ', calc.calculate_roof_area( room ) ) print( 'A litragem de tinta necessária é: ', calc.calculate_required_liter() )
def test_nlog(self): c = Calculator() self.assertEqual(c.nlog(4), 1.3863)
def test_inlog2(self): c = Calculator() self.assertEqual(c.inlog(2), 7.3891)
we need 3 class: main -> principal class... calculator -> to resolver the integral... graphs -> to plot the integral ... """ from calculator import Calculator import graphs # Asking for variables... f = input("Input the function...: ") inf = int(input("Input the inferior limit...: ")) sup = int(input("Input the superior limit...: ")) p = int(input("Input the point numbers...: ")) # Define a function object... eqt = Calculator(f, inf, sup, p) print("The value of the integral is: ", eqt.integral()) print(eqt.table()) ftn = int( input("""Input the approximate that you want: -> Trapezium (1) -> Rectangle (2) -> Simpson (3) """)) if ftn == 1: print(eqt.trapezium_values()) elif ftn == 2: print(eqt.rectangle_values()) elif ftn == 3:
def setUp(self): ''' Set up the calculator for each of the unit tests This function is run once, before each of the test methods below. ''' self.calc = Calculator()
from policy import Policy from calculator import Calculator from outputBuilder import OutputBuilder """ Note: Before running the following, make sure to execute the code in data.py. Also, compute the average EMTRs on each type of pass-through income using mtr_taxcalc.py. """ parmdict = {'forwardLooking': True} # Current law pol_clbase = Policy() parm_clbase = Parameter(parmdict) calc_clbase = Calculator(parm_clbase, pol_clbase) # Extension of individual income tax parameters pol_extII = Policy('policy_extendII.csv') parm_extII = Parameter(parmdict) calc_extII = Calculator(parm_extII, pol_extII) # Extension of all current TCJA tax parameters (current policy baseline) pol_cpbase = Policy('policy_currentPolicy.csv') parm_cpbase = Parameter(parmdict) calc_cpbase = Calculator(parm_cpbase, pol_cpbase) # Biden tax plan pol_biden = Policy('policy_biden.csv') parm_biden = Parameter(parmdict) calc_biden = Calculator(parm_biden, pol_biden)
def test_nlog2(self): c = Calculator() self.assertEqual(c.nlog(3), 1.0986)
def test_ceil3(self): c = Calculator() self.assertEqual(c.ceil(10.9), 11)
class CalculatorTestCase(TestCase): def setUp(self): """stuff to do before every test""" """All tests below will run in order setUp, test_x, tearDown""" self.calc = Calculator() def tearDown(self): """stuff to do after each test""" @unittest.skip("skipping prompt user") def test_initial_menu_display(self): # Display operation menu # Enter Operation and operand - # '+', '-', '/', and '=', 'C' (clear last), and an 'AC' (clear all) # Current State: 0 $: captured_output = io.StringIO() sys.stdout = captured_output # whatever happens here is captured... self.calc.run_initial_menu() sys.stdout = sys.__stdout__ mock_stdout = ( "Enter Operation and operand -" "'+', '-', '*', '/', and '=', 'R' (clear last), and an 'AC' (clear all)" "'m' for menu\n") self.assertEqual(captured_output.getvalue(), mock_stdout) # @unittest.skip("skipping prompt user") def test_accept_user_input_all_operators(self): valid_operators = set(['+', '-', '/', '=']) self.calc.get_user_input('-') self.assertTrue(self.calc.data[-1] == '-') random_alpha = choice(ascii_letters) # print(random_alpha) user_input = self.calc.get_user_input(random_alpha) self.assertTrue(user_input == 'That is not a valid input!') user_input = self.calc.get_user_input("") self.assertNotIn(user_input, valid_operators) # @unittest.skip("skipping accept user input") def test_accept_user_input_number(self): self.calc.get_user_input("9") self.assertTrue(self.calc.current_state == '9.0') user_input = self.calc.get_user_input('a') self.assertEqual(user_input, 'That is not a valid input!') @unittest.skip("skipping prompt user") def test_prompt_user(self): self.calc.current_state = "9" captured_output = io.StringIO() sys.stdout = captured_output # what every happens here is captured... self.calc.prompt_user() sys.stdout = sys.__stdout__ mock_stdout = "Current State: 9 Enter: " self.assertEqual(captured_output.getvalue(), mock_stdout) # @unittest.skip("skipping recall last two") def test_recall_last_two_inputs(self): # self.calc.get_user_input("=") # self.assertEqual(self.calc.last_operator, 0) self.calc.get_user_input("4") self.calc.get_user_input("+") self.calc.get_user_input("5") self.assertEqual(self.calc.last, "5.0") self.assertEqual(self.calc.last_operator, "+") self.assertNotEqual(self.calc.last, "=") # def test_convert_number # @unittest.skip("skipping add calculation ") def test_add_calculation(self): self.calc.get_user_input("+") self.calc.get_user_input("+") self.calc.get_user_input("5") self.calc.get_user_input("5") self.calc.get_user_input("+") self.calc.get_user_input("5") self.assertEqual(self.calc.current_state, "15.0") # @unittest.skip("skipping subtraction ") def test_subtraction_calculation(self): self.calc.get_user_input("5") self.calc.get_user_input('-') self.calc.get_user_input("1") self.assertEqual(self.calc.current_state, "4.0") # @unittest.skip("skipping multiplication ") def test_multiplication(self): self.calc.get_user_input("2") self.calc.get_user_input('*') self.calc.get_user_input("14") self.assertEqual(self.calc.current_state, "28.0") # @unittest.skip("skipping recall ") def test_divsion(self): self.calc.get_user_input("22") self.calc.get_user_input('/') self.calc.get_user_input("11") self.assertEqual(self.calc.current_state, "2.0") # @unittest.skip("skipping recall ") def test_division_by_zero(self): self.calc.get_user_input("21") self.calc.get_user_input('/') self.calc.get_user_input("0") self.assertEqual(self.calc.current_state, "21.0") self.calc.get_user_input("=") print(self.calc.list_of_states) self.calc.get_user_input("3") self.assertEqual(self.calc.current_state, "7.0") self.calc.get_user_input('/') self.calc.get_user_input("0") self.assertEqual(self.calc.current_state, "7.0") self.calc.get_user_input('+') self.calc.get_user_input("3") self.assertEqual(self.calc.current_state, "10.0") # @unittest.skip("skipping recall ") def test_one_numeric_input_equals(self): self.calc.get_user_input("5") self.calc.get_user_input("=") self.calc.get_user_input("=") self.assertNotEqual(self.calc.get_user_input("="), "That is not a valid input!") self.assertEqual(self.calc.current_state, "5.0") self.calc.get_user_input("+") self.calc.get_user_input("=") self.assertEqual(self.calc.current_state, "10.0") # @unittest.skip("skipping recall ") def test_2_numeric_inputs_with_equals(self): self.calc.get_user_input("5") self.calc.get_user_input("+") self.calc.get_user_input("3") # -> self.assertEqual(self.calc.current_state, "8.0") self.calc.get_user_input("=") # self.calc.get_user_input("=") # self.assertEqual(self.calc.current_state, "14.0") self.calc.get_user_input("-") # self.calc.get_user_input("4") # self.assertEqual(self.calc.current_state, "10.0") self.calc.get_user_input("=") self.assertEqual(self.calc.current_state, "6.0") self.calc.get_user_input("*") # self.calc.get_user_input("4") # self.assertEqual(self.calc.current_state, "24.0") self.calc.get_user_input("=") self.assertEqual(self.calc.current_state, "96.0") # @unittest.skip("skipping recall ") def test_R_command(self): self.calc.get_user_input("5") self.calc.get_user_input("+") self.calc.get_user_input("2") # -> self.calc.get_user_input("=") # -> 9 self.calc.get_user_input("R") self.calc.get_user_input("R") self.assertEqual(self.calc.data[-1], "+") self.assertEqual(self.calc.current_state, "5.0") # @unittest.skip("skipping recall ") def test_AC_command(self): self.calc.get_user_input("5") self.calc.get_user_input("+") self.calc.get_user_input("2") self.calc.get_user_input("=") self.calc.get_user_input("AC") self.assertEqual(self.calc.list_of_states, []) self.assertEqual(self.calc.data, []) self.assertEqual(self.calc.current_state, '0') self.assertEqual(self.calc.last_operator, None) self.assertEqual(self.calc.last, '0') def test_jumbled_operators_and_numbers(self): self.calc.get_user_input("+") self.calc.get_user_input("-") self.calc.get_user_input("*") self.calc.get_user_input("/") self.calc.get_user_input("9") self.assertEqual(self.calc.current_state, '0.0') self.calc.get_user_input("AC") self.calc.get_user_input("7") self.calc.get_user_input("4") self.calc.get_user_input("3") self.calc.get_user_input("2") self.assertEqual(self.calc.current_state, '2.0') def test_division_on_floats(self): self.calc.get_user_input("9") self.calc.get_user_input("/") self.calc.get_user_input("2") self.assertEqual(self.calc.current_state, '4.5') def test_all_operators_on_floats(self): self.calc.get_user_input("9") self.calc.get_user_input("/") self.calc.get_user_input("2") self.calc.get_user_input("/") self.calc.get_user_input("2") self.assertEqual(self.calc.current_state, '2.25') self.calc.get_user_input("*") self.calc.get_user_input("4") self.assertEqual(self.calc.current_state, '9.0') self.calc.get_user_input("+") self.calc.get_user_input("4.33") self.assertEqual(self.calc.current_state, '13.33') self.calc.get_user_input("-") self.calc.get_user_input("4.33") self.assertEqual(self.calc.current_state, '9.0')
def test_exponentiation1(self): c = Calculator() self.assertEqual(c.exponentiation(2, 3), 8.0)
def test_myCalculator(self): calc = Calculator() result = calc.add(2, 2) self.assertEqual(4, result)
def test_floor(self): c = Calculator() self.assertEqual(c.floor(3.9), 3)
def test_floor2(self): c = Calculator() self.assertEqual(c.floor(5.1), 5)