def test_subject():
s = parser.Sentence(
('noun', 'cheese'), ('verb', 'eats'), ('noun', 'pigeon')
)
assert s.verb == 'eats'
assert s.subject == 'cheese'
assert s.object == 'pigeon'
def test_parse_sentence(self):
self.addTypeEqualityFunc(parser.Sentence, sentence_eq)
self.assertEqual(
parser.parse_sentence([('noun', 'ratman'), ('verb', 'eats'),
('noun', 'cake')]),
parser.Sentence(('noun', 'ratman'), ('verb', 'eats'),
('noun', 'cake')))
def test_subject():
s1 = parser.Sentence(('noun',"cheese"),
('verb',"eats"),
('noun',"pigeon"))
assert s1.verb == "eats"
assert s1.subject == "cheese"
assert s1.object == "pigeon"
def test_sentence():
s1 = parser.Sentence(('noun', "princess"), ('verb', "stop"), ('noun', "bear"))
print(">>>s1.subject", s1.subject)
print(">>> s1.verb", s1.verb)
assert s1.subject == 'princess'
assert s1.verb == 'stop'
assert s1.object == 'bear'
def test_sentence_obj():
s = parser.Sentence(('noun', 'bear'), ('verb', 'eat'), ('number', 1),
('noun', 'door'))
assert_equal(s.subject, 'bear')
assert_equal(s.verb, 'eat')
assert_equal(s.number, 1)
assert_equal(s.object, 'door')
assert_equal(s.to_tuple(), ('bear', 'eat', 1, 'door'))
def test_Sentence():
s1 = parser.Sentence(("noun", "cheese"), ("verb", "eats"),
("noun", "pigeon"))
assert s1.subject == "cheese"
assert s1.verb == "eats"
assert s1.object == "pigeon"
def test_parse_subject():
word_list1 = lexicon.scan("open the door")
result = parser.parse_subject(word_list1, ('noun', 'princess'))
wanted = parser.Sentence(('noun', 'princess'), ('verb', 'open'),
('noun', 'door'))
assert_equal(result.subject, wanted.subject)
assert_equal(result.verb, wanted.verb)
assert_equal(result.object, wanted.object)
def test_parse_sentence():
word_list3 = lexicon.scan("princess open the door")
result = parser.parse_sentence(word_list3)
wanted = parser.Sentence(('noun', 'princess'), ('verb', 'open'),
('noun', 'door'))
assert_equal(result.subject, wanted.subject)
assert_equal(result.verb, wanted.verb)
assert_equal(result.object, wanted.object)
assert_raises(parser.ParserError, parser.parse_sentence, word_list3)
def test_sentence(self):
sentence = parser.Sentence(('noun', 'bear'), ('verb', 'eat'),
('noun', 'cake'))
self.assertEqual(sentence.subject, 'bear')
self.assertEqual(sentence.verb, 'eat')
self.assertEqual(sentence.object, 'cake')
from nose.tools import *
from ex48 import lexicon, parser
lexi = lexicon.scan("fighter kill bear")
sen = parser.Sentence(lexi[0], lexi[1], lexi[2])
def test_class_Sentence():
assert_equal(sen.subject, 'fighter')
assert_equal(sen.verb, 'kill')
assert_equal(sen.object, 'bear')
def test_peek():
assert_equal(parser.peek(lexi), 'noun')
assert_equal(parser.peek([]), None)
def test_match():
words = lexicon.scan("the bear will eat you")
assert_equal(parser.match(words, 'noun'), None)
assert_equal(parser.match(words, 'noun'), ('noun', 'bear'))
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
def test_sentence():
s = parser.Sentence(('noun', 'bear'), ('verb', 'eat'), ('noun', 'door'))
assert_equal(s.subject, 'bear')
assert_equal(s.verb, 'eat')
assert_equal(s.object, 'door')
def test_sentence():
sentence = parser.Sentence(('noun', 'player'), ('verb', 'open'),
('noun', 'door'))
assert_equal(sentence.subject, 'player')
assert_equal(sentence.verb, 'open')
assert_equal(sentence.object, 'door')
def test_Sentence():
result = parser.Sentence(("noun", "bear"), ("verb", "eat"),
("noun", "honey"))
assert_equal(result.subject, "bear")
assert_equal(result.verb, "eat")
assert_equal(result.object, "honey")
def test_parse_sentence():
a = parser.Sentence(('subject', 'sarah'), ('verb', 'play'),
('object', 'Scott'))
assert_equal(a.subject, 'sarah')
assert_equal(a.verb, 'play')
assert_equal(a.object, 'Scott')
def test_sentence():
s1 = parser.Sentence(('noun', "l"), ('verb', "wanna"), ('noun', "bed"))
def test_Sentence():
a_sentence = parser.Sentence(('noun', 'Player'), ('verb', 'kill'),
('noun', 'Monster'))
assert_equal(a_sentence.subject, "Player")
assert_equal(a_sentence.verb, "kill")
assert_equal(a_sentence.obj, "Monster")
def test_parse_sentence3():
word_list = lexicon.scan("run north")
result = parser.parse_sentence(word_list)
assert_equal(result, parser.Sentence('player', 'run', 'north'))
def test_sentence():
s1 = parser.Sentence(('noun', "soap"), ('verb', "hear"),
('noun', "pillow"))
assert s1.verb == "hear"
assert s1.subject == "soap"
assert s1.object == "pillow"
def test_parse_sentence4():
word_list = lexicon.scan("bear eat the honey")
result = parser.parse_sentence(word_list)
assert_equal(result,
parser.Sentence(subject='bear', verb='eat', obj='honey'))
def test_parse_sentence2():
result = parser.parse_sentence([('noun', 'bear'), ('verb', 'eat'),
('stop', 'the'), ('noun', 'honey')])
assert_equal(result,
parser.Sentence(subject='bear', verb='eat', obj='honey'))
def test_parse_sentence():
result = parser.parse_sentence([('verb', 'run'), ('direction', 'north')])
assert_equal(result, parser.Sentence('player', 'run', 'north'))
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_sentence_class():
sen = parser.Sentence(('direction', 'north'), ('verb', 'stop'),
('noun', 'door'))
assert_equal(sen.subject, 'north')
assert_equal(sen.verb, 'stop')
assert_equal(sen.object, 'door')
