def verify_implementation():
"""Run many iterations and report the data for analysis.
This test is intended to be run by hand in order to validate
the runtime of the algorithm. (If the runtime is roughly
polynomial of degree 3, then it's probably correct.)
One means of testing this is to apply a log_3 transform
to the data, then perform a test of linearity. (A QQ plot
would probably be sufficient.) Of course, there may be
some other, lower-order terms.
"""
import csv
import time
times = dict()
max_run_times = 200
for n in range(1, max_run_times):
sentence = ''
for _ in range(n):
sentence += random.choice('01')
sentence += 'ε'
start = time.time()
parse(SmallGrammar, sentence)
end = time.time()
times[n] = end - start
print(n)
with open('cyk_run_times.csv', 'w') as fout:
writer = csv.writer(fout)
for n in range(1, max_run_times):
writer.writerow([n, times[n]])
def test_parses_ambiguous_grammars(self):
"""Make sure it can parse an ambigous grammar."""
lexed_positive = [
Token(
value="Hegh",
token_type=AKT.VERB,
line_number=0,
),
Token(
value="be'",
token_type=AKT.BE,
line_number=0,
),
]
self.assertTrue(parse(AmbiguousKlingonGrammar, lexed_positive))
lexed_negative = [
Token(
value="Hegh",
token_type=AKT.VERB,
line_number=0,
),
Token(
value="be'",
token_type=AKT.BE,
line_number=0,
),
Token(
value="be'",
token_type=AKT.BE,
line_number=0,
),
]
self.assertTrue(parse(AmbiguousKlingonGrammar, lexed_negative))
def test_parse_long_sentence_small_grammar(self):
"""Make sure we can handle a decently long string."""
max_string_length = 50
sentence = list()
for _ in range(max_string_length):
if random.random() < 0.5:
sentence.append(Token(
value='0',
token_type=ST.ZERO,
line_number=0,
))
else:
sentence.append(Token(
value='1',
token_type=ST.ONE,
line_number=0,
))
sentence.append(Token(
value='ε',
token_type=ST.EPSILON,
line_number=0,
))
self.assertTrue(parse(
SmallGrammar,
sentence
))
def test_valid_case(self):
lexed = ekg_lex('qet loD')
node = parse(ErrorKlingonGrammar, lexed)
self.assertTrue(node is not None)
self.assertEqual(node.symbol, 'sentence')
self.assertEqual(node.lchild.symbol, 'intransitive_verb')
self.assertEqual(node.rchild.symbol, 'noun')
self.assertFalse(self.has_annotation(node))
def test_correct_number_prefered(self):
for number in [
'983-32',
'38-328-288',
'1-1-1-1',
'3829279-32879',
]:
tokens = pn_lex(number)
node = parse(PhoneNumberGrammar, tokens)
self.assertTrue(node, 'Unable to parse {}'.format(number))
self.assertFalse(self.contains_annotation(node, ConfusionError))
def test_equivalent_to_combined(self):
for poem in poems:
tokens = lex(poem)
total = parse(TotalPoetryGrammar, tokens)
combined = parser_combinator(
top_parse,
lookup,
combine,
tokens,
)
self.assertTrue(total.equals(combined), )
def test_backup_determined_by_weight(self):
for number in [
'983-32.1',
'38.328-288',
'1-1.1-1',
'3829279-32879.1',
]:
tokens = pn_lex(number)
node = parse(PhoneNumberGrammar, tokens)
self.assertTrue(node, 'Unable to parse {}'.format(number))
self.assertTrue(self.contains_annotation(node, ConfusionError))
def test_valid_sentences(self):
sentences = [
"Hegh puq",
"loD HoH puq Duj",
"qIp bIQ QIp",
"puq val qIp loD",
]
for sentence in sentences:
self.assertTrue(
parse(Grammar, lex(sentence)),
'Expected to parse "{}", but failed.'.format(
sentence
)
)
def test_parse_simple_nonmember(self):
"""Make sure we reject invalid strings."""
lexed = [
Token(
value="qet",
token_type=KT.UNKNOWN,
line_number=0,
),
Token(
value="be'",
token_type=KT.NOUN,
line_number=0,
),
]
self.assertFalse(parse(SimpleKlingonGrammar, lexed))
def test_invalid_sentences(self):
bad_sentences = [
# Unrecognized symbol
"unrecognized puq"
# Incorrect structure
"qIp qIp"
]
for sentence in bad_sentences:
self.assertFalse(
parse(Grammar, lex(sentence)),
'Unexpectedly parsed "{}"'.format(
sentence,
)
)
def test_parse_simple_member(self):
"""Make sure that we can recognize a valid string in the language."""
lexed = [
Token(
value="SuS",
token_type=KT.VERB,
line_number=0,
),
Token(
value="be'",
token_type=KT.NOUN,
line_number=0,
),
]
self.assertTrue(parse(SimpleKlingonGrammar, lexed))
def test_parse_returns_parse_tree(self):
"""Make sure the parse returned a valid tree."""
lexed = [
Token(
value="SuS",
token_type=KT.VERB,
line_number=0,
),
Token(
value="be'",
token_type=KT.NOUN,
line_number=1,
),
]
node = parse(SimpleKlingonGrammar, lexed)
self.assertTrue(node is not None)
self.assertEqual(node.symbol, 'sentence')
self.assertEqual(node.lchild.symbol, 'verb')
self.assertEqual(node.lchild.value, lexed[0])
self.assertEqual(node.rchild.symbol, 'noun')
self.assertEqual(node.rchild.value, lexed[1])
def test_total_grammar(self):
for poem in poems:
tokens = lex(poem)
parsed = parse(TotalPoetryGrammar, tokens)
self.assertTrue(parsed is not None)
def lookup(*args):
return [lambda x: parse(StanzaGrammar, x)]
def test_parse_empty_is_never_part_of_grammar(self):
"""Make sure we don't crash with an empty list."""
self.assertFalse(parse(SimpleKlingonGrammar, []))
def test_invalid_case(self):
lexed = ekg_lex('qam qet')
node = parse(ErrorKlingonGrammar, lexed)
self.assertTrue(node is None)
def test_error_case(self):
lexed = ekg_lex('qam qet loD')
node = parse(ErrorKlingonGrammar, lexed)
self.assertTrue(node is not None)
self._debug(node)
self.assertTrue(self.has_annotation(node))
