def test_circular_formula_dependency(self):
txt = """
A(D)
B(A)
C(B*3)
D(C*B)
"""
with self.assertRaises(systems.errors.CircularReferences):
m = parse.parse(txt, tracebacks=False)
m.run()
def test_parsing_infinity(self):
txt = """
pi_a(100, inf) > pi_b @ 10
pi_b > [pi_c] @ 5
"""
model = parse.parse(txt)
results = model.run(rounds=5)
final = results[-1]
self.assertEqual(50, final['pi_a'])
self.assertEqual(30, final['pi_b'])
def test_parse_invalid_int_or_float(self):
txt = """
c > d @ 1
d > e @ 3
[a] > b @ hi
"""
with self.assertRaises(InvalidFormula) as pe:
m = parse.parse(txt)
m.run()
def test_conflicting_stock_values(self):
txt = """
a(10) > b @ 1
b > a(5) @ 2
"""
with self.assertRaises(ConflictingValues) as cv:
m = parse.parse(txt, tracebacks=False)
self.assertEqual('a', cv.exception.name)
self.assertEqual(10, cv.exception.first.compute())
self.assertEqual(5, cv.exception.second.compute())
def test_parens(self):
txt = """
A(5)
B(10)
C((A+B)/2)
D((((A+A) * (B+B)) / A))
"""
m = parse.parse(txt)
results = m.run()
final = results[0]
self.assertEqual(5, final['A'])
self.assertEqual(10, final['B'])
self.assertEqual(7.5, final['C'])
self.assertEqual(40, final['D'])
def test_non_circular_formula_dependency(self):
txt = """
A(100)
B(A)
C(B*3)
D(C*B)
"""
m = parse.parse(txt)
results = m.run()
final = results[0]
self.assertEqual(100, final['A'])
self.assertEqual(100, final['B'])
self.assertEqual(300, final['C'])
self.assertEqual(30000, final['D'])
def test_parse(self):
model = parse.parse(EXAMPLE_FULL)
stock_names = ['a', 'b', 'c', 'd', 'e']
values = {
'a': float('+inf'),
'b': 0,
'e': float('+inf'),
}
for stock_name in stock_names:
stock = model.get_stock(stock_name)
self.assertIsNotNone(stock)
self.assertEqual(stock_name, stock.name)
if stock_name in values:
value = values[stock_name]
self.assertEqual(value, stock.initial.compute())
def test_standalone_stock(self):
txt = """
a
b(2)
c(3, 5)
a > b @ 1
b > c @ 2
"""
m = parse.parse(txt)
m.run()
self.assertEqual(0, m.get_stock('a').initial.compute())
self.assertEqual(2, m.get_stock('b').initial.compute())
self.assertEqual(3, m.get_stock('c').initial.compute())
self.assertEqual(5, m.get_stock('c').maximum.compute())
def test_parse_complex_formula(self):
spec = """[Hires] > Developers @ 1
[Ideas] > Projects @ Developers / (Projects+1)
Projects > Started @ Developers - (Started+1)
Started > Finished @ Developers"""
model = parse.parse(spec)
names = [
'Hires', 'Developers', 'Ideas', 'Projects', 'Started', 'Finished'
]
for name in names:
self.assertEquals(name, model.get_stock(name).name)
results = model.run(rounds=10)
for row in results:
for val in row.values():
self.assertLessEqual(0, val)
def test_maximums(self):
model = parse.parse(EXAMPLE_MAXIMUM)
results = model.run(rounds=4)
final = results[-1]
self.assertEqual(5, final['b'])
self.assertEqual(10, final['c'])