def test_match():
vector = lexicon.scan('princess')
assert_equal(parser.match(vector, 'noun'), ('noun', 'princess'))
vector = lexicon.scan('go')
assert_equal(parser.match(vector, 'verb'), ('verb', 'go'))
vector = lexicon.scan('the')
assert_equal(parser.match(vector, 'error'), None)
def test_parse_number():
testsentence="100 bear"
result=lexicon.scan(testsentence)
assert_equal(parser.parse_number(result), ('number', 100))
testsentence="kill bear"
result=lexicon.scan(testsentence)
assert_equal(parser.parse_number(result), None)
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_errors():
word_list = lexicon.scan("bear go east")
assert_raises(Exception, parser.parse_verb, word_list)
word_list = lexicon.scan("go east")
assert_raises(Exception, parser.parse_object, word_list)
word_list = lexicon.scan("east")
assert_raises(Exception, parser.parse_sentence, word_list)
def test_parse_object():
vector = lexicon.scan('unknown eat door')
assert_raises(parser.ParseError, parser.parse_object, vector)
vector = lexicon.scan('princess go door')
assert_equal(parser.parse_object(vector), ('noun', 'princess'))
vector = lexicon.scan('from north')
assert_equal(parser.parse_object(vector), ('direction', 'north'))
def test_verbs():
assert_equal(lexicon.scan("go"), [('verb', 'go')])
result = lexicon.scan("go kill eat open")
assert_equal(result, [('verb', 'go'),
('verb', 'kill'),
('verb', 'eat'),
('verb', 'open')])
def test_parse_object():
word_list = lexicon.scan("the door")
assert_equal(parser.parse_object(word_list), ("noun", "door"))
word_list = lexicon.scan("the east")
assert_equal(parser.parse_object(word_list), ("direction", "east"))
word_list = lexicon.scan("the it")
assert_raises(parser.ParserError, parser.parse_object, word_list)
def test_stops():
assert_equal(lexicon.scan("ABDFADFASDF"), [('error',
'ABDFADFASDF')])
result = lexicon.scan("bear IAS princess")
assert_equal(result, [('noun', 'bear'),
('error', 'IAS'),
('noun', 'princess')])
def test_directions():
assert_equal(lexicon.scan("north").[('direction','north')])
result=lexicon.scan("north south east")
assert_equal(result,[('direction','north'),
('direction','south'),
('direction','east')])
def test_parse_sentence():
temp = lexicon.scan('bear eat princess')
assert_equal(Sentence.parse_sentence(temp), Sentence.parse_subject(temp, 'bear'))
temp2 = lexicon.scan('go player go')
assert_equal(Sentence.parse_sentence(temp2), Sentence.parse_subject(temp2, 'player'))
temp3 = lexicon.scan('Duuuuuu')
assert_equal(Sentence.parse_sentence(temp3), ParserError("Must start with subject, object, or verb not: Duuuuuu"))
def test_stops():
assert_equal(lexicon.scan("go", [('verb', 'go')])
result = lexicon.scan("the in of")
assert_equal(result, [('stop', 'the'),
('stop', 'in'),
('stop', 'of')])
def test_nouns():
assert_equal(lexicon.scan("bear"), [('noun', 'bear')])
result = lexicon.scan("bear princess")
assert_equal(result, [('noun', 'bear'),
('noun', 'princess')])
def test_numbers():
assert_equal(lexicon.scan("1234"), [('number', 1234)])
result = lexicon.scan("3 91234")
assert_equal(result, [('number', 3),
('number', 91234)])
def test_errors():
assert_equal(lexicon.scan("ASDFADFASDF"), [('error', 'ASDFADFASDF')])
result = lexicon.scan("bear IAS princess")
assert_equal(result, [('noun', 'bear'),
('error', 'IAS'),
('noun', 'princess')])
def test_nouns():
assert_equal(lexicon.scan("bear"), [('noun', 'bear')])
result = lexicon.scan("bear princess tree bush")
assert_equal(result, [('noun', 'bear'),
('noun', 'princess'),
('noun', 'tree'),
('noun', 'bush')])
def test_parse_object():
a_word_list = lexicon.scan("door some noun.")
b_word_list = lexicon.scan("north me if I failed.")
c_word_list = lexicon.scan("at kill world")
assert_equal(parser.parse_object(a_word_list), ('noun','door'))
assert_equal(parser.parse_object(b_word_list), ('direction','north'))
assert_raises(parser.ParserError, parser.parse_object, c_word_list)
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():
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_errors():
assert_equal(lexicon.scan("ASDFASDFASDF"), [('error', 'ASDFASDFASDF')])
result = lexicon.scan("bear IAS princess 42")
assert_equal(result, [('noun', 'bear'),
('error', 'IAS'),
('noun', 'princess'),
('number', 42)])
def test_nouns():
assert_equal(lexicon.scan('bear'), [('noun', 'bear')])
result = lexicon.scan("bear princess door cabinet")
assert_equal(result, [('noun', 'bear'),
('noun', 'princess'),
('noun', 'door'),
('noun', 'cabinet'),])
def test_fillers():
assert_equal(lexicon.scan('the'), [('filler', 'the')])
result = lexicon.scan("the in of and")
assert_equal(result, [('filler', 'the'),
('filler', 'in'),
('filler', 'of'),
('filler', 'and'),])
def test_nouns():
assert_equal(lexicon.scan("bear"), [('noun', 'bear')])
result = lexicon.scan("bear princess cave castle")
assert_equal(result, [('noun', 'bear'),
('noun', 'princess'),
('noun', 'cave'),
('noun', 'castle')])
def test_errors():
assert_equal(lexicon.scan("ASDFADFASDF"), [('error', 'ASDFADFASDF')])
result = lexicon.scan("Bear IA princess")
assert_equal(result, [('noun', 'Bear'),
('error', 'IA'),
('noun', 'princess')
])
def tests_stops():
assert_equal(lexicon.scan("the"), [('stop', 'the')])
result = lexicon.scan("the in of out")
assert_equal(result, [('stop', 'the'),
('stop', 'in'),
('stop', 'of'),
('stop', 'out')])
def tests_verbs():
assert_equal(lexicon.scan("go"), [('verb', 'go')])
result = lexicon.scan("go kill eat sleep")
assert_equal(result, [('verb', 'go'),
('verb', 'kill'),
('verb', 'eat'),
('verb', 'sleep')])
def test_directions():
assert_equal(lexicon.scan("north"), [("direction", "north")])
result = lexicon.scan("north south east")
assert_equal(result, [("direction", "north"), ("direction", "south"), ("direction", "east")])
def test_verbs():
assert_equal(lexicon.scan("go"), [("verb", "go")])
result = lexicon.scan("go kill eat")
assert_equal(result, [("verb", "go"), ("verb", "kill"), ("verb", "eat")])
def test_stops():
assert_equal(lexicon.scan("the"), [("stop", "the")])
result = lexicon.scan("the in of")
assert_equal(result, [("stop", "the"), ("stop", "in"), ("stop", "of")])
def test_nouns():
assert_equal(lexicon.scan("bear"), [("noun", "bear")])
result = lexicon.scan("bear princess")
assert_equal(result, [("noun", "bear"), ("noun", "princess")])
def test_numbers():
assert_equal(lexicon.scan("1234"), [("number", 1234)])
result = lexicon.scan("3 912347")
assert_equal(result, [("number", 3), ("number", 91234)])
def test_errors():
assert_equal(lexicon.scan("ASDFADFASDF"), [("error", "ASDFADFASDF")])
result = lexicon.scan("bear IAS princess")
assert_equal(result, [("noun", "bear"), ("error", "IAS"), ("noun", "princess")])
def test_parse_sentence():
word_list = lexicon.scan('the bear eat door')
s = parser.parse_sentence(word_list)
word_list = lexicon.scan('in eat door')
s = parser.parse_sentence(word_list)
word_list = lexicon.scan('north eat door')
assert_raises(parser.ParserError, parser.parse_sentence, word_list)
def test_stops():
'''Testing stops'''
assert_equal(lexicon.scan("the"), [('stop', 'the')])
result = lexicon.scan("the in of")
assert_equal(result, [('stop', 'the'),
('stop', 'in'),
('stop', 'of')])
def test_parse_object():
word_list = lexicon.scan('the door')
assert_equal(parser.parse_object(word_list), ('noun', 'door'))
word_list = lexicon.scan('the east')
assert_equal(parser.parse_object(word_list), ('direction', 'east'))
word_list = lexicon.scan('the it')
assert_raises(parser.ParserError, parser.parse_object, word_list)
def test_verbs():
'''testing verbs '''
assert_equal(lexicon.scan("go"), [('verb', 'go')])
result = lexicon.scan("go kill eat")
assert_equal(result, [('verb', 'go'),
('verb', 'kill'),
('verb', 'eat')])
def test_numbers():
assert_equal(lexicon.scan("1234"), [('number', 1234)])
result = lexicon.scan("3 91234 0 -1234")
assert_equal(result, [('number', 3),
('number', 91234),
('number', 0),
('number', -1234)])
def test_stops():
assert_equal(lexicon.scan("the"), [('stop', 'the')])
result = lexicon.scan("the in a of")
assert_equal(result, [('stop', 'the'),
('stop', 'in'),
('stop', 'a'),
('stop', 'of')])
def test_errors():
assert_equal(lexicon.scan("ASDFASDFASDF"), [('error','asdfasdfasdf')])
result=lexicon.scan("bear IAS princess")
assert_equal(result, [('noun','bear'),
('error','ias'),
('noun','princess')])
def test_verbs():
assert_equal(lexicon.scan("go"), [("verb", "go")])
result = lexicon.scan("go kill eat")
assert_equal(result, [("verb", "go"), ("verb", "kill"), ("verb", "eat")])
from ex48 import lexicon
print("Please provide a sentence for lexicon analysis.")
stuff = input('> ')
print(lexicon.scan(stuff))
def test_stop():
assert_equal(lexicon.scan("the"), [("stop", "the")])
result = lexicon.scan("the in of")
assert_equal(result, [("stop", "the"), ("stop", "in"), ("stop", "of")])
def test_senctence():
result = lexicon.scan("eat the bear and kill the princess")
assert_equal(result, [('verb', 'eat'), ('stop', 'the'), ('noun', 'bear'),
('error', 'and'), ('verb', 'kill'), ('stop', 'the'),
('noun', 'princess')])
def test_errors():
assert_equal(lexicon.scan('shausuhauhsa'), [('error', 'shausuhauhsa')])
result = lexicon.scan('bear IAS princess')
assert_equal(result, [('noun', 'bear'), ('error', 'IAS'),
('noun', 'princess')])
def test_numbers(self):
self.assertEqual(lexicon.scan("1234"), [('number', 1234)])
result = lexicon.scan("3 91234")
self.assertEqual(result, [('number', 3), ('number', 91234)])
def test_stops(self):
self.assertEqual(lexicon.scan("the"), [('stop', 'the')])
result = lexicon.scan("the in of")
self.assertEqual(result, [('stop', 'the'), ('stop', 'in'),
('stop', 'of')])
def test_nouns():
assert_equal(lexicon.scan("bear"), [('noun', 'bear')])
result = lexicon.scan('bear princess')
assert_equal(result,[('noun', 'bear'),('noun','princess')])
def test_numbers():
assert_equal(lexicon.scan("1234"),[('numbers', 1234)])
result = lexicon.scan('3 91234')
assert_equal(result,[('number', 3),('number', 91234)])
def test_errors():
assert_equal(lexicon.scan("ASDFADFASDF"), [('error', 'ASDFADFASDF')])
result = lexicon.scan("bear IAS princess")
assert_equal(result, [('noun', 'bear'), ('error', 'IAS'),
('noun', 'princess')])
def test_stops():
assert_equal(lexicon.scan("the"),[('stop','the')])
result = lexicon.scan('the in of')
assert_equal(result, [('stop','the'), ('stop','in'), ('stop','of')])
def test_errors():
assert_equal(lexicon.scan('ASDFASDFASDF'), [('error', 'ASDFASDFASDF')])
result = lexicon.scan('bear IAD princess')
assert_equal(result, [('noun', 'bear'), ('error', 'IAD'),
('noun', 'princess')])
from nose.tools import *
from ex48 import lexicon
def test_directions():
assert_equal(lexicon.scan("north"), [('direction', 'north')])
result = lexicon.scan("north south east")
assert_equal(result, [('direction', 'north'),
('direction', 'south'),
('direction', 'east')])
def test_verbs():
assert_equal(lexicon.scan("go"), [('verb', 'go')])
result = lexicon.scan("go kill eat")
assert_equal(result, [('verb', 'go'),
('verb', 'kill'),
('verb', 'eat')])
def test_stops():
assert_equal(lexicon.scan("the"), [('stop', 'the')])
result = lexicon.scan("the in of")
assert_equal(result, [('stop', 'the'),
('stop', 'in'),
('stop', 'of')])
def test_nouns():
assert_equal(lexicon.scan("bear"), [('noun', 'bear')])
result = lexicon.scan("bear princess")
assert_equal(result, [('noun', 'bear'),
def test_errors():
assert_equal(lexicon.scan("ASDFASDFASDF"), [("error", "ASDFASDFASDF")])
result = lexicon.scan("bear IASS princess")
assert_equal(result, [("noun", "bear"), ("error", "IASS"),
("noun", "princess")])
def test_numbers():
assert_equal(lexicon.scan("1234"), [('number', '1234')])
result = lexicon.scan("3 91234")
assert_equal(result, [('number', '3'),
('number', '91234')])
def test_error():
assert_equal(lexicon.scan("ASDFGFDSA"),[('error', 'ASDFGFDSA')])
result = lexicon.scan('bear IAS princess')
assert_equal(result,[('noun', 'bear'), ('IAS', 'error'),('noun', 'princess')])
def test_directions(self):
self.assertEqual(lexicon.scan("north"), [('direction', 'north')])
result = lexicon.scan("north south east")
self.assertEqual(result,
[('direction', 'north'), ('direction', 'south'),
('direction', 'east')])
def test_directions():
assert_equal(lexicon.scan("north"),[('direction', 'north')])
result = lexicon.scan('north south east')
assert_equal(result,[('direction','north'),('direction','south'),('direction','east')])
def test_nouns(self):
self.assertEqual(lexicon.scan("bear"), [('noun', 'bear')])
result = lexicon.scan("bear princess")
self.assertEqual(result, [('noun', 'bear'), ('noun', 'princess')])
def test_verbs():
assert_equal(lexicon.scan("go"), [('verb', 'go')])
result = lexicon.scan("go kill eat")
assert_equal(result, [('verb', 'go'), ('verb', 'kill'), ('verb', 'eat')])
def test_verbs(self):
self.assertEqual(lexicon.scan("go"), [('verb', 'go')])
result = lexicon.scan("go kill eat")
self.assertEqual(result, [('verb', 'go'), ('verb', 'kill'),
('verb', 'eat')])
def test_numbers():
assert_equal(lexicon.scan("1234"), [("number", "1234")])
result = lexicon.scan("3 141592653589")
assert_equal(result, [("number", "3"), ("number", "141592653589")])
def test_pronouns():
assert_equal(lexicon.scan("it"), [('pronoun', 'it')])
result = lexicon.scan("go to her")
assert_equal(result, [('verb', 'go'), ('stop', 'to'), ('pronoun', 'her')])
def test_nouns():
assert_equal(lexicon.scan("bear"), [("noun", "bear")])
result = lexicon.scan("bear princess")
assert_equal(result, [("noun", "bear"), ("noun", "princess")])
def test_parse_object():
word_list2 = lexicon.scan("in the west")
result = parser.parse_object(word_list2)
assert_equal(result, ('direction', 'west'))
assert_raises(parser.ParserError, parser.parse_object, word_list2)
def test_directions():
assert_equal(lexicon.scan("north"), [("direction", "north")])
result = lexicon.scan("north south east")
assert_equal(result, [("direction", "north"), ("direction", "south"),
("direction", "east")])
def tests_numbers():
assert_equal(lexicon.scan('1234'), [('number', 1234)])
result = lexicon.scan('2 1234')
assert_equal(result, [('number', 2), ('number', 1234)])
def test_peek():
word_list1 = lexicon.scan("open the door")
result = parser.peek(word_list1)
assert_equal(result, 'verb')
def numbers():
assert_equal(lexicon.scan("1234"), [('number', 1234)])
result = lexicon.scan("3 91234")
assert_equal(result, [('number', 3), ('number', 91234)])
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)
