def test_nw_with_wrapper_parallel_inside_6(self):
event_group = EventGroup([
EventGroupParallel(string_to_events('ac')),
EventGroup(string_to_events('ez'))
])
alignment_cached = BestAlignmentCached()
result, model_result = alignment_cached.get_best_alignment(
event_group, ['z', 'x', 'q'], dict())
char_list = events_to_char_list(model_result)
print(events_to_char_list(model_result))
self.assertEqual(-5, result)
self.assertCountEqual([x for x in ['z']], char_list)
self.assertEqual(['z'], events_to_char_list(model_result))
def test_7(self):
gate = SeqGate()
gate.parse('lop({c})')
self.assertEqual(None, gate.get_all_n_length_routes(6))
self.assertEqual([
EventGroupMatcher(
EventGroup([EventGroupParallel(string_to_events('ccc'))]))
], gate.get_all_n_length_routes(3))
def test_6(self):
gate = SeqGate()
gate.parse('xor(and({c}and(and({c}{b}and({d}{f})){b}{e})){e}{e})')
self.assertEqual([
EventGroup(
[EventGroupParallel(string_to_events('abcdefghijklmn'))])
], gate.get_all_n_length_routes(7))
self.assertEqual([], gate.get_all_n_length_routes(6))
def test_8(self):
gate = SeqGate()
gate.parse(
'xor({f}{d}and({e}xor(lop(xor({f}{d}))lop({a}))))and({b}{a})')
all_length_3_routes = gate.get_all_n_length_routes(3)
self.assertCountEqual([
EventGroupMatcher(
EventGroup(
[Event('f'),
EventGroupParallel(string_to_events('ba'))])),
EventGroupMatcher(
EventGroup(
[Event('d'),
EventGroupParallel(string_to_events('ba'))])),
EventGroupMatcher(
EventGroup(
[Event('e'),
EventGroupParallel(string_to_events('ba'))]))
], all_length_3_routes)
def test_nw_with_wrapper_parallel_inside_9(self):
event_group = EventGroup([
Event('f'),
EventGroupParallel(
[EventGroupParallel(string_to_events('dc')),
Event('f')]),
Event('b'),
EventGroupParallel(
[EventGroupParallel(string_to_events('df')),
Event('e')])
])
alignment_cached = BestAlignmentCached()
result, model_result = alignment_cached.get_best_alignment(
event_group, ['a', 'c', 'b', 'd'], dict())
char_list = events_to_char_list(model_result)
print(events_to_char_list(model_result))
self.assertEqual(-6, result)
self.assertCountEqual([x for x in ['c', 'b', 'd']], char_list)
self.assertEqual(['c', 'b', 'd'], events_to_char_list(model_result))
def test_nw_with_wrapper_parallel(self):
event_group = EventGroupParallel(string_to_events('pqacezxys'))
alignment_cached = BestAlignmentCached()
result, model_result = alignment_cached.get_best_alignment(
event_group, ['z', 'x', 'k', 'l', 'm', 'n', 'o', 'z', 'x'], dict())
print(events_to_char_list(model_result))
self.assertEqual(-14, result)
self.assertCountEqual([x for x in ['z', 'x']],
events_to_char_list(model_result))
self.assertEqual(['z', 'x'], events_to_char_list(model_result))
def test_nw_with_wrapper(self):
event_group = EventGroup(string_to_events('pqacezxys'))
alignment_cached = BestAlignmentCached()
result, model_result = alignment_cached.get_best_alignment(
event_group, ['z', 'x', 'a', 'b', 'c', 'd', 'e', 'z', 'x'], dict())
print(events_to_char_list(model_result))
self.assertEqual(-8, result)
self.assertCountEqual([x for x in ['a', 'c', 'e', 'z', 'x']],
events_to_char_list(model_result))
self.assertEqual(['a', 'c', 'e', 'z', 'x'],
events_to_char_list(model_result))
def test_cache(self):
event_group = [
EventGroupParallel([
Event('a'),
Event('f'),
EventGroupParallel(string_to_events('bec')),
Event('d')
])
]
event_group2 = [
EventGroupParallel([
Event('a'),
Event('f'),
EventGroupParallel(string_to_events('bec')),
Event('d')
])
]
log = ['a', 'b', 'c', 'd', 'e', 'f']
log2 = ['a', 'b', 'c', 'd', 'e', 'f']
cache1 = get_cache_id(event_group, log)
cache2 = get_cache_id(event_group2, log2)
self.assertEqual(cache1, cache2)
def test_2(self):
gate = SeqGate()
gate.parse('{f}xor({d}and({b}lop({c})opt({a})))')
actual = gate.get_all_n_length_routes(5)
expected_1 = EventGroupMatcher(
EventGroup([
Event('f'),
EventGroupParallel(
[Event('b'),
EventGroup(string_to_events('ccc'))])
]))
expected_2 = EventGroupMatcher(
EventGroup([
Event('f'),
EventGroupParallel([
Event('b'),
EventGroup(string_to_events('cc')),
Event('a')
])
]))
expected = [expected_1, expected_2]
self.assertCountEqual(expected, actual)
def test_nw_with_wrapper_parallel_inside(self):
event_group = EventGroupParallel(
[Event('t'),
EventGroupParallel(string_to_events('spqacezxy'))])
alignment_cached = BestAlignmentCached()
result, model_result = alignment_cached.get_best_alignment(
event_group, ['z', 'x', 'a', 'b', 'c', 'd', 'e', 'z', 't'], dict())
char_list = events_to_char_list(model_result)
print(events_to_char_list(model_result))
self.assertEqual(-7, result)
self.assertCountEqual([x for x in ['z', 'x', 'a', 'c', 'e', 't']],
char_list)
self.assertEqual(['z', 'x', 'a', 'c', 'e', 't'],
events_to_char_list(model_result))
def test_1(self):
gate = SeqGate()
gate.parse('and({a}{b}{c}{d}{e}{f}{g}{h}{i}{j}{k}{l}{m}{n})')
self.assertCountEqual([
EventGroupMatcher(
EventGroup(
[EventGroupParallel(string_to_events('abcdefghijklmn'))]))
],
gate.get_all_n_length_routes(
14, ('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h',
'i', 'j', 'k', 'l', 'm', 'n')))
self.assertEqual(
None,
gate.get_all_n_length_routes(13,
('a', 'b', 'c', 'd', 'e', 'f', 'g',
'h', 'i', 'j', 'k', 'l', 'm', 'n')))
def test_92(self):
gate = SeqGate()
gate.parse('and({a}{f}opt(and({b}{e}lop({c}))){d})')
all_length_6_routes = gate.get_all_n_length_routes(6)
expected = [
EventGroupMatcher(
EventGroup([
EventGroupParallel([
Event('a'),
Event('f'),
EventGroupParallel(string_to_events('bec')),
Event('d')
])
]))
]
self.assertCountEqual(expected, all_length_6_routes)
def test_all_events_in_model(self):
# when your algorithm is smarter than you
event_group = EventGroupParallel([
Event('a'),
Event('f'),
EventGroupParallel(string_to_events('bec')),
Event('d')
])
alignment_cached = BestAlignmentCached()
result, model_result = alignment_cached.get_best_alignment(
event_group, ['a', 'b', 'c', 'd', 'e', 'f'], dict())
char_list = events_to_char_list(model_result)
print(events_to_char_list(model_result))
self.assertEqual(-2, result)
self.assertCountEqual([x for x in ['a', 'b', 'c', 'e', 'f']],
char_list)
def test_9(self):
gate = SeqGate()
gate.parse('and({c}and({a}lop({e}opt({d}))seq({c}{b})))')
all_length_5_routes = gate.get_all_n_length_routes(5)
expected = [
EventGroupMatcher(
EventGroup([
EventGroupParallel([
Event('c'),
EventGroupParallel([
Event('a'),
Event('e'),
EventGroup(string_to_events('cb'))
])
])
]))
]
self.assertCountEqual(expected, all_length_5_routes)
def test_eq4(self):
e1 = EventGroup([Event('f'), EventGroupParallel([Event('b'),
EventGroup(string_to_events('ccc'))])])
e2 = EventGroupParallel([Event('f'), EventGroup([Event('b'),
EventGroupParallel(string_to_events('ccc'))])])
self.assertFalse(e1 == e2)
