def parse_object_tests():
word_list = [('stop', 'stop_a'), ('verb', 'verb_a'), ('noun', 'noun_a'), ('direction', 'direction_a')]
assert_raises(parser.ParserError, parser.parse_object, word_list)
parser.parse_verb(word_list)
assert_equals(word_list, [('noun', 'noun_a'), ('direction', 'direction_a')])
assert_equals(parser.parse_object(word_list), ('noun', 'noun_a'))
assert_equals(parser.parse_object(word_list), ('direction', 'direction_a'))
def test_parse_verbs():
assert_equal(parser.parse_verb([('stop', 'the'), ('verb', 'run')]),
('verb', 'run'))
assert_equal(parser.parse_verb([('stop', 'the'), ('verb', 'jump')]),
('verb', 'jump'))
assert_equal(parser.parse_verb([('verb', 'jump'), ('noun', 'sword')]),
('verb', 'jump'))
def test_parse_verb():
a_word_list = lexicon.scan("test some noun.")
assert_raises(parser.ParserError, parser.parse_verb,a_word_list)
b_word_list = lexicon.scan("kill me if I failed.")
assert_equal(parser.parse_verb(b_word_list), ('verb','kill'))
c_word_list = lexicon.scan("at kill world")
assert_equal(parser.parse_verb(c_word_list), ('verb','kill'))
def test_parse_verb():
a_word_list = lexicon.scan("test some noun.")
assert_raises(parser.ParserError, parser.parse_verb, a_word_list)
b_word_list = lexicon.scan("kill me if I failed.")
assert_equal(parser.parse_verb(b_word_list), ('verb', 'kill'))
c_word_list = lexicon.scan("at kill world")
assert_equal(parser.parse_verb(c_word_list), ('verb', 'kill'))
def test_parse_verb():
vector = lexicon.scan('bear eat door')
assert_raises(parser.ParseError, parser.parse_verb, vector)
vector2 = lexicon.scan('bear IAS princess')
assert_raises(parser.ParseError, parser.parse_verb, vector2)
vector3 = lexicon.scan("go kill eat")
assert_equal(parser.parse_verb(vector3), ('verb', 'go'))
vector4 = lexicon.scan("in stop south")
assert_equal(parser.parse_verb(vector4), ('verb', 'stop'))
def test_verb():
word_list = [('stop', 'the'), ('verb', 'eat'), ('noun', 'princess')]
assert_equal(parser.parse_verb(word_list), ('verb', 'eat'))
word_list = [('verb', 'eat'), ('noun', 'bear')]
assert_equal(parser.parse_verb(word_list), ('verb', 'eat'))
word_list = [('direction', 'south'), ('noun', 'bear')]
assert_raises(Exception, parser.parse_verb, word_list)
def test_parse_verb():
raw_word_list = [('stop', 'run'), ('verb', 'go'), ('direction', 'up')]
assert_equal(parser.parse_verb(raw_word_list), ('verb', 'go'))
expected_error_message = "Expected a verb next."
error_word_list = [('stop', 'run'), ('oh', 'go'), ('direction', 'up')]
with assert_raises(parser.ParserError) as error:
assert_equal(parser.parse_verb(error_word_list), ('oh', 'go'))
assert_equal(error.exception.message, expected_error_message)
def test_parse_verb():
sentence = lexicon.scan("go")
assert_equal(parser.parse_verb(sentence), ('verb', 'go'))
sentence = lexicon.scan("the in eat")
assert_equal(parser.parse_verb(sentence), ('verb', 'eat'))
sentence = lexicon.scan("cheese")
with assert_raises(parser.ParserError):
parser.parse_verb(sentence)
def test_parsesverb():
testsentence = "the princess eat the bear"
result = lexicon.scan(testsentence)
assert_raises(parser.ParserError, parser.parse_verb, result)
testsentence = "eat the bear"
result = lexicon.scan(testsentence)
assert_equal(parser.parse_verb(result), ('verb', 'eat'))
def test_parsesverb():
testsentence="the princess eat the bear"
result=lexicon.scan(testsentence)
assert_raises(parser.ParserError, parser.parse_verb, result)
testsentence="eat the bear"
result=lexicon.scan(testsentence)
assert_equal(parser.parse_verb(result), ('verb','eat'))
def test():
assert_equal(parser.peek(lexicon.scan('go kill the princess')), 'verb')
assert_equal(parser.match(lexicon.scan('go kill the princess'), 'verb'),
('verb', 'go'))
assert_equal(parser.skip(lexicon.scan('go kill the princess'), 'verb'),
None)
assert_equal(parser.parse_verb(lexicon.scan('go kill the princess')),
('verb', 'go'))
assert_raises(parser.ParserError, parser.parse_verb, ('noun', 'princess'))
assert_equal(parser.parse_object(lexicon.scan('the princess')),
('noun', 'princess'))
assert_equal(parser.parse_object(lexicon.scan('the north')),
('direction', 'north'))
assert_raises(parser.ParserError, parser.parse_object,
lexicon.scan('go kill the princess'))
subj = 'bear'
assert_equal(
parser.parse_sentence(
lexicon.scan('the bear eat the princess')).subject, subj)
ver = 'eat'
assert_equal(
parser.parse_sentence(lexicon.scan('the bear eat the princess')).verb,
ver)
obj = 'princess'
assert_equal(
parser.parse_sentence(
lexicon.scan('the bear eat the princess')).object, obj)
def test_parse_verb():
result = parser.parse_verb(lexicon.scan("at in kill bear 34587"))
assert_equal(result, ('verb', 'kill'))
word_list = lexicon.scan("at bear in kill bear 34587")
# test the Exception
#assert_raises(Exception, parser.parse_verb, word_list)
assert_raises(parser.ParserError, parser.parse_verb, word_list)
def test_verb():
words = lexicon.scan("the bear will eat you")
## assert_raises(ParserError, parser.parse_verb, words)
# NameError: global name 'ParseError' is not defined
assert_raises(parser.ParserError, parser.parse_verb, words)
words.pop(0) # pop bear
assert_equal(parser.parse_verb(words), ('verb', 'eat'))
def test_parse_verb():
word_list = [('stop', 'of'), ('stop', 'the'), ('verb', 'run')]
assert_equal(parser.parse_verb(word_list), ('verb', 'run'))
assert_raises(Exception, parser.parse_verb, [('stop', 'of'),
('stop', 'the'),
('direction', 'north')])
def test_parse_verb():
result = parser.parse_verb(lexicon.scan("at in kill bear 34587"))
assert_equal(result, ('verb', 'kill'))
word_list = lexicon.scan("at bear in kill bear 34587")
# test the Exception
#assert_raises(Exception, parser.parse_verb, word_list)
assert_raises(parser.ParserError, parser.parse_verb, word_list)
def test_sentence():
subj = parser.parse_subject([('stop', 'the'), ('noun', 'bear')])
verb = parser.parse_verb([('stop', 'the'), ('verb', 'run'), ('direction', 'north')])
obj = parser.parse_object([('stop', 'the'), ('direction', 'north')])
sentence = parser.Sentence(subj, verb, obj)
assert_equal(sentence.subject, "bear")
assert_equal(sentence.verb, "run")
assert_equal(sentence.object, "north")
def test_parse_verb():
word_list = [('verb', 'kill'),
('stop', 'the'),
('noun', 'bear')]
word = parser.parse_verb(word_list)
assert_equal(('verb', 'kill'), word)
assert_raises(parser.ParserError, parser.parse_verb, word_list)
def test_parse_verb():
word_list = [('stop', 'the'),
('stop', 'slow'),
('verb', 'kill')]
assert_equal(parser.parse_verb(word_list), ('verb', 'kill'))
assert_equal(word_list, [])
error_list = [('stop', 'the'),
('noun', 'cow')]
assert_raises(parser.ParserError, parser.parse_verb, error_list)
def test_parse_verb():
word_list1 = [("stop", "at"), ("stop", "the"), ("verb", "eat"),
("direction", "north")]
word_list2 = [("noun", "bear"), ("verb", "go"), ("stop", "at")]
word_list3 = [("stop", "at"), ("stop", "the")]
word_list4 = []
assert_equal(parser.parse_verb(word_list1), ("verb", "eat"))
assert_raises(parser.ParserError, parser.parse_verb, word_list2)
assert_raises(parser.ParserError, parser.parse_verb, word_list3)
assert_raises(parser.ParserError, parser.parse_verb, word_list4)
def test_parse_verb():
word_list = lexicon.scan('go eat door')
assert_equal(parser.parse_verb(word_list), ('verb', 'go'))
word_list = lexicon.scan('bear eat door')
assert_raises(parser.ParserError, parser.parse_verb, word_list)
word_list = lexicon.scan('the east bear eat door')
assert_raises(parser.ParserError, parser.parse_verb, word_list)
word_list = lexicon.scan(
'I am only trying to make this longer before verb: go eat door')
assert_raises(parser.ParserError, parser.parse_verb, word_list)
def test_verb():
assert_equal(
# must start with verb
parser.parse_verb([("verb", "kill"),
("noun", "bear")]),
('verb', 'kill')
)
assert_raises(
parser.ParserError, # expected error
parser.parse_verb, # function to run
[("direction", "north"), ("noun", "princess")] # arg for function
)
def test_verb():
# 'go north': verb is 'go'
assert_equal(
parser.parse_verb([
('verb', 'go'),
('direction', 'north')
]),
('verb', 'go')
)
# 'bear eat honey': ParserError
assert_raises(
parser.ParserError,
parser.parse_verb,
[('noun', 'bear'), ('verb', 'eat'), ('noun', 'honey')]
)
def test_parse_verb():
verb = parser.parse_verb([('verb', 'run')])
assert_equal(verb, ('verb', 'run'))
assert_raises(parser.ParserError, parser.parse_verb, [('noun', 'bear')])
def test_parse_verb():
word_list = lexicon.scan("the eat princess")
assert_equal(('verb', 'eat'), parser.parse_verb(word_list))
def test_parse_verb():
assert_equal(parser.parse_verb([('stop', 'the'), ('verb', 'run'), ('direction', 'north')]), ('verb', 'run'))
assert_raises(parser.ParserError, parser.parse_verb, [('stop', 'the'), ('direction', 'north')])
def test_parse_verb(): #word_list[('verb', 'go')]
word_list = lexicon.scan('go')
assert_equal(parser.parse_verb(word_list), ('verb', 'go'))
assert_raises(parser.ParserError, parser.parse_verb, [('vverb', 'go')])
def test_parse_verb(self):
self.assertRaises(parser.ParserError, parser.parse_verb,
[('noun', 'phone')])
self.assertEqual(parser.parse_verb([('verb', 'drink')]),
('verb', 'drink'))
def test_parse_verb():
verb = parser.parse_verb([('verb', 'run')])
assert_equal(verb, ('verb', 'run'))
assert_raises(parser.ParserError, parser.parse_verb, [('noun', 'bear')])
def test_parse_verb():
word_list = lexicon.scan('it eat door')
assert_equal(parser.parse_verb(word_list), ('verb', 'eat'))
word_list = lexicon.scan('bear eat door')
assert_raises(parser.ParserError, parser.parse_verb, word_list)
def parse_verb_tests():
word_list = [('stop', 'stop_a'), ('verb', 'verb_a'), ('noun', 'noun_a')]
assert_equals(parser.parse_verb(word_list), ('verb', 'verb_a'))
assert_raises(parser.ParserError, parser.parse_verb, word_list)
assert_equals(word_list, [('noun', 'noun_a')])
def test_parse_verb():
word_list1 = lexicon.scan("open the door")
result = parser.parse_verb(word_list1)
assert_equal(result, ('verb', 'open'))
assert_raises(parser.ParserError, parser.parse_verb, word_list1)
def test_parse_verb():
word_list = [('stop', 'the'), ('stop', 'slow'), ('verb', 'kill')]
assert_equal(parser.parse_verb(word_list), ('verb', 'kill'))
assert_equal(word_list, [])
error_list = [('stop', 'the'), ('noun', 'cow')]
assert_raises(parser.ParserError, parser.parse_verb, error_list)
def test_parse_verb():
wordlist = [('stop', 'the'), ('verb', 'run')]
result = parser.parse_verb(wordlist)
assert_equal(result, ('verb', 'run'))
assert_equal(wordlist, [])
def test_parse_sentence():
word_list = lexicon.scan("princess kill the bear")
subj = parser.parse_subject(word_list)
verb = parser.parse_verb(word_list)
obj = parser.parse_object(word_list)
assert parser.Sentence(subj, verb, obj)
def test_parse_verb():
assert_equal(parser.parse_verb(word_list_3), ('verb', 'go'))
assert_raises(parser.ParserError, parser.parse_verb, word_list_2)
def test_parse_verb():
word_list = lexicon.scan("the in of stop")
assert_equal(('verb', 'stop'), parser.parse_verb(word_list))
word_list = lexicon.scan("the princess in of stop")
assert_raises(parser.ParserError, parser.parse_verb, word_list)
def test_parse_verb():
assert_equal(parser.parse_verb(lexicon.scan("in the go")), ('verb', 'go'))
result = parser.parse_verb(lexicon.scan("in stop"))
assert_equal(result, ('verb', 'stop'))
def test_parse_verb():
assert_equal(parser.parse_verb([('verb', 'move')]), ('verb', 'move'))
assert_equal(parser.parse_verb([('stop', 'to'), ('verb', 'move')]),
('verb', 'move'))
assert_raises(parser.ParserError, parser.parse_verb, [('noun', 'bear')])
def test_parse_verb():
word_list = lexicon.scan("scream at the bear")
assert ('verb', "scream") == parser.parse_verb(word_list)
word_list = lexicon.scan("at the bear")
def test_parse_verb():
word_list1 = "a stop bear"
assert_equal(parser.parse_verb(word_list1), ('verb', 'stop'))
assert_equal([parser.parse_verb(s) for s in PHRASE_LIST], [('verb','stop'),'Expected a verb next.',('verb','open'),
'Expected a verb next.'])
def test_parse_verb():
passing_sentence = [('verb', 'eat'), ('stop', 'a'), ('noun', 'bagel')]
failing_sentence = [('stop', 'a'), ('noun', 'bagel'), ('verb', 'appears')]
assert_equal(parser.parse_verb(passing_sentence), ('verb', 'eat'))
assert_raises(parser.ParserError, parser.parse_verb, failing_sentence)
def test_verb():
assert_equal(parser.parse_verb([('verb', 'run')]), ('verb', 'run'))
assert_raises("ParserError", parser.parse_verb, input)
def test_parse_verb():
word_list = [('stop', 'the'), ('verb', 'kill')]
assert_equal(parser.parse_verb(word_list), ('verb', 'kill'))
word_list2 = [('stop', 'the'), ('noun', 'princess')]
assert_raises(parser.ParserError, parser.parse_verb, word_list2)
def test_parse_verb():
assert_equal(parser.parse_verb([('verb', 'kill')]), ('verb', 'kill'))
def test_parse_verb():
word_list = [('verb', 'go'), ('direction', 'north'), ('stop', 'at'), ('noun', 'door')]
assert_equal(parser.parse_verb(word_list), ('verb', 'go'))
word_list = [('direction', 'north'), ('stop', 'at'), ('noun', 'door')]
assert_raises(parser.ParserError, parser.parse_verb, word_list)
def test_pverb(): #parse verb test
assert_equal(parser.parse_verb(lexicon.scan("Eat it")), ("verb", "eat"))
assert_equal(parser.parse_verb(lexicon.scan("In the eat")), ("verb", "eat"))
assert_raises(Exception,parser.parse_verb, lexicon.scan("Princess ate the bear"))
def test_parse_verb():
word_list = lexicon.scan('it eat door')
assert_equal(parser.parse_verb(word_list), ('verb', 'eat'))
word_list = lexicon.scan('bear eat door')
assert_raises(parser.ParserError, parser.parse_verb, word_list)
def test_verb():
assert_equal(parser.parse_verb([('verb', 'run')]), ('verb', 'run'))
def test_parse_verb():
word_list = lexicon.scan("the in of stop")
assert_equal(("verb", "stop"), parser.parse_verb(word_list))
word_list = lexicon.scan("the princess in of stop")
assert_raises(parser.ParserError, parser.parse_verb, word_list)
def test_parse_verb():
word_list = [('verb', 'open'), ('stop', 'the'), ('noun', 'door')]
assert_equal(parser.parse_verb(word_list), ('verb', 'open'))
assert_raises(parser.ParserError, parser.parse_verb, word_list)
def test_parse_verb():
result = parser.parse_verb([('verb', 'hit')])
assert_equal(result, ('verb', 'hit'))
result = parser.parse_verb([('stop', 'the'), ('verb', 'hit')])
assert_equal(result, ('verb', 'hit'))
def test_parse_verb():
word_list = [('stop', 'the'), ('verb', 'throws'), ('object', 'coins')]
parse_verb_working = parser.parse_verb(word_list)
assert_equal(parse_verb_working, ('verb', 'throws'))
