def test_check_float_numbers(self):
c1 = Calc("54+123.345-2")
self.assertEqual(c1.check_float_numbers(), True)
c2 = Calc("54+123,345-2")
self.assertEqual(c2.check_float_numbers(), True)
c3 = Calc("54+123345-2")
self.assertEqual(c3.check_float_numbers(), False)
def test_div(self):
comb1 = Calc(4, 2)
comb2 = Calc(4, 0)
div = comb1.div()
self.assertEqual(div, 2)
with self.assertRaises(ValueError):
comb2.div()
def test_expression_with_missing_operator(self):
expression = "((100+20)3-10/2+11-1*(10+34)-54)"
c1 = Calc(expression)
expected = 'missing operator near parentheses'
actual = c1.expression_result()
self.assertEqual(actual, expected)
expression = "((100+20)*3-10/2+11-2(10+34)-54)"
c2 = Calc(expression)
expected = 'missing operator near parentheses'
actual = c2.expression_result()
self.assertEqual(actual, expected)
def test_check_skip_operator(self):
expression = "555(22-34)*56/78"
c1 = Calc(expression)
self.assertEqual(c1.check_skip_operator(), True)
expression = "555*(22-34)56/78"
c2 = Calc(expression)
self.assertEqual(c2.check_skip_operator(), True)
expression = "555*(22-34)-56/78"
c3 = Calc(expression)
self.assertEqual(c3.check_skip_operator(), False)
def test_expressions_with_floats(self):
expression = "100+2.345*3-10/2"
c1 = Calc(expression)
expected = 'Expression contains float number(s)'
actual = c1.expression_result()
self.assertEqual(actual, expected)
expression = "100,34+2*3-10/2"
c2 = Calc(expression)
expected = 'Expression contains float number(s)'
actual = c2.expression_result()
self.assertEqual(actual, expected)
def check():
"""校验答题结果
"""
data = request.json
cal = Calc()
result = cal.calc_score(data)
return jsonify(result)
def operacao(m=0):
if request.method == 'POST':
x = Calc(request.form.get['X'], request.form.get['Y'])
if m == 'divisao':
r = {'resultado': x.divisao()}
return jsonify(r)
elif m == "multiplicacao":
r = {'resultado': x.multiplicacao()}
return jsonify(r)
elif m == 'soma':
r = {'resultado': x.soma()}
return jsonify(r)
elif m == 'sub':
r = {'resultado': x.sub()}
return jsonify(r)
elif request.method == 'GET':
return "FACA UM POST PARA USAR A CALCULADORA"
else:
return "Defina uma operacao basica"
def test_sum_small():
a = 0.0000001
b = 0.00000007
calc = Calc()
assert calc.sum(a, b) == a + b
def test_mult_zero():
a = 15
b = 0
calc = Calc()
assert calc.mult(a, b) == 0
def test_sum_big():
a = 700987100000
b = 15700987100666
calc = Calc()
assert calc.sum(a, b) == a + b
def test_status1(): c = Calc() c.reset( 144 ) c.update( '1' ) c.update( '2' ) c.update( '*' ) res = c.status() s = str( res[0] ) episode_stat = res[1] total_reward = res[2] print( s ) assert s == str( 12.0 ) assert episode_stat == False assert total_reward == 0.0 c.update( '1' ) c.update( '2' ) c.update( '=' ) res = c.status() s = str( res[0] ) episode_stat = res[1] total_reward = res[2] assert s == str( 144.0 ) assert episode_stat == True assert total_reward == 1.0
class Calc_Test2(unittest.TestCase):
simple_calc_two = Calc()
def test_remainder(self):
#self.assertTrue(self.simple_calc_two.remainder(9,9), )
self.assertEqual(self.simple_calc_two.remainder(9, 9), 0)
def test_expression_with_ten_numbers(self):
expression = "100+20*3-10/2+11-1*10+34-54"
c = Calc(expression)
expected = (10, "100+20*3-10/2+11-1*10+34-54",
100 + 20 * 3 - 10 / 2 + 11 - 1 * 10 + 34 - 54)
actual = c.expression_result()
self.assertEqual(actual, expected)
def test_expression_with_correct_parentheses(self):
expression = "((100+20)*3-10/2+11-1*(10+34)-54)"
c = Calc(expression)
expected = (10, "((100+20)*3-10/2+11-1*(10+34)-54)",
((100 + 20) * 3 - 10 / 2 + 11 - 1 * (10 + 34) - 54))
actual = c.expression_result()
self.assertEqual(actual, expected)
def test_create_object(self):
c = Calc("123")
expected = "123"
self.assertEqual(c.expression, expected)
expected = "Calc object with expression = 123"
self.assertEqual(c.__repr__(), expected)
def normalization(dictionary):
calc = Calc()
values = [value for value in dictionary.values()]
for key in dictionary:
current_values = dictionary[key]
dictionary[key] = calc.normalization(current_values, values)
return dictionary
def test_basic(self):
"""Test that the intializer is correct"""
calc = Calc()
self.assertEqual(
calc.functions['EXP'].execute(calc.operators['ADD'].execute(
1, calc.operators['MULTIPLY'].execute(2, 3))),
1096.6331584284585)
def main():
logging.basicConfig(filename="manager.log",
format="%(levelname)s: %(message)s",
level=logging.INFO)
logging.info('====================================================')
logging.info(' %s', datetime.now().strftime("%Y-%m-%d %H:%M:%S"))
logging.info('====================================================')
parser = argparse.ArgumentParser(description='database manager')
parser.add_argument('--update', help='update data')
parser.add_argument('--calc', help='data visualization')
args = parser.parse_args()
if args.update:
from PyQt5.QtWidgets import QApplication
from update import Update
if args.update in ['marketinfo', 'OHLC', 'minute']:
app = QApplication(sys.argv)
kiwoom = Update(args.update)
kiwoom.CommConnect(0)
sys.exit(app.exec_())
else:
raise NameError(args.update)
elif args.calc:
from calc import Calc
calc = Calc()
if args.calc == 'density':
calc.density()
def main():
"""
The main entry point into the ``calc`` program.
This function takes input from the user, attempts to parse it, and either
returns the result or shows a stack trace to make it easier to identify the
root cause of the error.
Args:
None
Returns:
None
"""
while True:
# Attempt to get user input.
try:
text = input('calc> ')
except EOFError: # Allow the user to use ctrl+d to exit the calculator.
break
if not text:
continue
calc = Calc(text)
try:
result = calc.parse()
except CalcError:
traceback.print_exc() # Show a stack trace on errors.
else:
print(result)
def find_best_shift(self, tasks):
calc = Calc()
best_start_time = 0
# We should always start in Time = 0 to check one of possibled optional point
# Next we will move x time units to ensure task finish in due date line
start_time = 0
min_value = calc.calculate_penalties(tasks=tasks,
start=start_time,
due_date=self.due_date)
# Now we should move tasks to finish in due date line
last_task_index = None
for index, task in enumerate(tasks):
start_time += task['p']
if start_time >= self.due_date:
start_time -= (start_time - task['p'])
last_task_index = index - 1
break
# Now in loop we can shift time and verify penalties
for index in range(last_task_index, -1, -1):
value = calc.calculate_penalties(tasks=tasks,
start=start_time,
due_date=self.due_date)
if value < min_value:
min_value = value
best_start_time = start_time
start_time += tasks[index]['p']
return min_value, best_start_time
def main():
calc = Calc(int(input('첫번째 수: ')), int(input('두번재 수: ')))
print(calc.first)
print(calc.second)
print('{} + {} = {}'.format(calc.first, calc.second, calc.sum()))
print('{} * {} = {}'.format(calc.first, calc.second, calc.mul()))
print('{} - {} = {}'.format(calc.first, calc.second, calc.sub()))
print('{} / {} = {}'.format(calc.first, calc.second, calc.div()))
def makeJob(job): if isinstance(job[0],TrajDataBulk): bulk = BulkTraj(job[0].name) else: bulk=BulkPure(job[0]) dft = job[1] calc = Calc(*job[2:]) return BulkJob(bulk,calc,dft)
def test_expression_with_other_arith_operators(self):
"""
This test case for demonstration a bug
"""
expression = "10%3+2-2**2"
c = Calc(expression)
expected = 'Expression contains nondigital symbol(s) or invalid operator(s)'
self.assertEqual(c.expression_result(), expected)
def test_calc_finds_eof_token_at_end_of_line():
"""
Test that, upon finding an end of line, a :class:`Calc` correctly tokenizes
an EOF :class:`Token`.
"""
input_text = ""
calc = Calc(text=input_text)
assert calc._next_token().type == EOF
def test_use_calc_to_divide(self):
calc = Calc()
calc.divide = MagicMock(return_value=3)
subect = Person(calc)
result = subect.use_calc_to_divide(10, 5)
self.assertNotEqual(
2, result) # not equal because the mock should do the job
def test_parse_text(self):
"""Test that text parser works correctly"""
calc = Calc()
output = calc.parse_text("2 multiply 3 add 1")
expected_output = Queue(
[2.0, Operator(np.multiply, 1), 3.0,
Operator(np.add, 0), 1.0])
self.assertEqual(str(expected_output), str(output))
def test_input(): c = Calc() c.update( '1' ) c.update( '2' ) c.update( '3' ) s = str( c.result() ) assert s == '123.0'
def test_f_lz():
calc = Calc()
with pytest.raises(ValueError) as ex:
calc.f(-5)
assert "Invalid argument: number must be more or eq of zero" in str(
ex.value)
def main():
calc = Calc(int(input("첫번째 수 : ")),int(input("두번째 수 : ")))
print(calc.first)
print(calc.second)
print("{}+{}={}".format(calc.first, calc.second, calc.sum()))
print("{}x{}={}".format(calc.first, calc.second, calc.mul()))
print("{}-{}={}".format(calc.first, calc.second, calc.sub()))
print("{}/{}={}".format(calc.first, calc.second, calc.div()))
def test():
"""测试用函数
"""
data = request.json
cal = Calc()
result = cal.calc_score(data)
print(result)
return jsonify(result)
