def test_get_next_possible_states_2(self):
gate = SeqGate()
gate.parse('{a}lop(opt({b}{c}{d}{e}{f}))xor({g}{h})')
events_with_parents = gate.get_all_child_events_with_parents()
e1 = gate.elements[0]
keys = [x for x in events_with_parents.keys()]
e2 = keys[1]
actual = set(
list(events_with_parents[e1].get_next_possible_states((e1, ), e1,
e2)))
self.assertEqual(7, len(actual))
def test_get_next_possible_states(self):
gate = SeqGate()
gate.parse('{a}lop(opt({b}{c}{d}{e}{f}))xor({g}{h})')
events_with_parents = gate.get_all_child_events_with_parents()
keys = [x for x in events_with_parents.keys()]
e1 = keys[0]
e2 = keys[1]
e3 = keys[2]
e4 = keys[3]
actual = set(
list(events_with_parents[e3].get_next_possible_states((e1, e2, e3),
e3, e4)))
self.assertEqual(7, len(actual))
def test_get_next_possible_states_9_5(self):
gate = SeqGate()
gate.parse('{a}lo3(lo3(opt({d}))and({d}))opt({c}{b}){e}')
events_with_parents = gate.get_all_child_events_with_parents()
keys = [x for x in events_with_parents.keys()]
e1 = keys[0]
e2 = keys[1]
e3 = keys[2]
actual = set(
list(events_with_parents[e2].get_next_possible_states((e1, e2), e2,
e3)))
self.assertEqual(2, len(actual))
def test_get_next_possible_states_4(self):
gate = SeqGate()
gate.parse(
'{a}and(seq(xor(seq(lop({c})opt({c})){b}){d})lop(seq({f}{d})))xor({e}seq({e}{g}))'
)
events_with_parents = gate.get_all_child_events_with_parents()
keys = [x for x in events_with_parents.keys()]
e1 = keys[0]
e2 = keys[2]
e4 = keys[4]
e8 = keys[8]
actual = set(
list(events_with_parents[e4].get_next_possible_states((e1, e2, e4),
e4, e8)))
self.assertEqual(3, len(actual))
def test_get_next_possible_states_8(self):
gate = SeqGate()
gate.parse('{a}{c}and({d})and(lo1({f}{d}{b}{e}){e})xor(xor({g}){h})')
events_with_parents = gate.get_all_child_events_with_parents()
keys = [x for x in events_with_parents.keys()]
e1 = keys[0]
e2 = keys[1]
e3 = keys[2]
e4 = keys[7]
e5 = keys[9]
actual = set(
list(events_with_parents[e4].get_next_possible_states(
(e1, e2, e3, e4), e4, e5)))
self.assertEqual(3, len(actual))
def test_get_next_possible_states_9_6(self):
gate = SeqGate()
gate.parse(
'and(xor({d}{a})and({d}{c}))xor(lop({g})seq({e}{f}{d}{b}))and(opt({h}){e})'
)
events_with_parents = gate.get_all_child_events_with_parents()
keys = [x for x in events_with_parents.keys()]
e1 = keys[1]
e2 = keys[3]
e3 = keys[2]
e4 = keys[5]
actual = set(
list(events_with_parents[e3].get_next_possible_states((e1, e2, e3),
e3, e4)))
self.assertEqual(4, len(actual))
def test_get_next_possible_states_9_7(self):
gate = SeqGate()
gate.parse(
'{a}and(and(opt({e})seq(xor({d}{e}){b}))xor(opt({g})xor(xor({h}xor({f}{h}))xor({f}and(and({c}{h}){a})))))'
)
events_with_parents = gate.get_all_child_events_with_parents()
keys = [x for x in events_with_parents.keys()]
e1 = keys[0]
e2 = keys[2]
e3 = keys[4]
e4 = keys[1]
e5 = keys[6]
actual = set(
list(events_with_parents[e4].get_next_possible_states(
(e1, e2, e3, e4), e4, e5)))
self.assertEqual(8, len(actual))
def test_get_next_possible_states_9_4(self):
gate = SeqGate()
gate.parse(
'seq({a})xor({b}{f}{c}){d}and(xor({h}xor(and(xor(and({c})))lo0(xor({b}{f}{d}{g})))){e})opt({h})'
)
events_with_parents = gate.get_all_child_events_with_parents()
keys = [x for x in events_with_parents.keys()]
e1 = keys[0]
e2 = keys[1]
e3 = keys[4]
e4 = keys[11]
e5 = keys[12]
actual = set(
list(events_with_parents[e4].get_next_possible_states(
(e1, e2, e3, e4), e4, e5)))
self.assertEqual(7, len(actual))
def test_get_next_possible_states_9_2(self):
gate = SeqGate()
gate.parse(
'{a}xor(xor(xor({b})lo2({b}){b}){c}seq(and(and({b})){e})){d}opt(xor(and({e}opt(xor({h}{g})))){h}'
)
events_with_parents = gate.get_all_child_events_with_parents()
keys = [x for x in events_with_parents.keys()]
e1 = keys[0]
e2 = keys[1]
e3 = keys[2]
e4 = keys[7]
e5 = keys[9]
actual = set(
list(events_with_parents[e4].get_next_possible_states(
(e1, e2, e3, e4), e4, e5)))
self.assertEqual(4, len(actual))
def test_get_next_possible_states_9_1(self):
gate = SeqGate()
gate.parse(
'{a}seq({b}and(opt(seq({d}){e})){h})xor({g}and(opt({a}))opt(opt(and({d}))xor(seq({c}){e}seq({e}){a})))'
)
events_with_parents = gate.get_all_child_events_with_parents()
keys = [x for x in events_with_parents.keys()]
e1 = keys[0]
e2 = keys[1]
e3 = keys[2]
e4 = keys[8]
e5 = keys[10]
actual = set(
list(events_with_parents[e4].get_next_possible_states(
(e1, e2, e3, e4), e4, e5)))
self.assertEqual(1, len(actual))
def test_get_next_possible_states_6_6(self):
gate = SeqGate()
gate.parse(
'and(xor(opt(lop({f}))xor(and({e}{a}seq({c}{d})opt({g}{a}))and({b}{h}){g})'
'xor(xor(and({e}{a}seq({c}{d}))opt({b}))xor(xor(opt({c})lop({c}))seq({b}{d}))))opt({h}))'
)
events_with_parents = gate.get_all_child_events_with_parents()
keys = [x for x in events_with_parents.keys()]
e1 = keys[2]
e2 = keys[3]
e3 = keys[4]
e4 = keys[1]
e5 = keys[18]
actual = set(
list(events_with_parents[e4].get_next_possible_states(
(e1, e2, e3, e4), e4, e5)))
self.assertEqual(3, len(actual))
def test_get_next_possible_states_9_8(self):
gate = SeqGate()
gate.parse(
'{a}xor({f}{b})opt(lo1(and({g}xor({f}{b})){d}){c}{d})and(seq({e}))'
)
events_with_parents = gate.get_all_child_events_with_parents()
keys = [x for x in events_with_parents.keys()]
e1 = keys[0]
e2 = keys[1]
e3 = keys[8]
e4 = keys[7]
e5 = keys[3]
e6 = keys[4]
e7 = keys[6]
e8 = keys[3]
e9 = keys[4]
actual = set(
list(events_with_parents[e8].get_next_possible_states(
(e1, e2, e3, e4, e5, e6, e7, e8), e8, e9)))
self.assertEqual(2, len(actual))
