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)
