def test_resolve(self):
word = Word(Morpheme([ieml('wa.')]))
p = path('r0')
elems = resolve(word, p)
self.assertSetEqual(elems, {ieml('wa.')})
worda = Word(Morpheme([ieml('wu.')]))
wordm = Word(Morpheme([ieml('we.')]))
s = Sentence([Clause(word, worda, wordm)])
p = path('sa:r')
elems = resolve(s, p)
self.assertSetEqual(elems, {Morpheme([ieml('wu.')])})
p = path('sa0+s0+sm0')
elems = resolve(s, p)
self.assertSetEqual(elems, {word, wordm, worda})
t = Text([s, word])
p = path('t')
elems = resolve(t, p)
self.assertSetEqual(elems, {s, word})
p = path('t1')
elems = resolve(t, p)
self.assertSetEqual(elems, {s})
def p_word(self, p):
"""word : LBRACKET morpheme RBRACKET
| LBRACKET morpheme RBRACKET literal_list
| LBRACKET morpheme TIMES morpheme RBRACKET
| LBRACKET morpheme TIMES morpheme RBRACKET literal_list"""
if len(p) == 4:
p[0] = _build(Word(root=p[2][0]), p[2])
elif len(p) == 5:
p[0] = _build(Word(root=p[2][0], literals=p[4]), p[2])
elif len(p) == 6:
p[0] = _build(Word(root=p[2][0], flexing=p[4][0]), p[2], p[4])
else:
p[0] = _build(Word(root=p[2][0], flexing=p[4][0], literals=p[6]),
p[2], p[4])
def get_test_word_instance():
morpheme_subst = Morpheme(map(SyntaxTerm, [term("a.i.-"), term("i.i.-")]))
morpheme_attr = Morpheme(
map(SyntaxTerm, [term("E:A:T:."),
term("E:S:.wa.-"),
term("E:S:.o.-")]))
return Word(morpheme_subst, morpheme_attr)
def test_deference(self):
rand = RandomPoolIEMLObjectGenerator()
w0 = rand.word()
self.assertEqual(w0['r0'], w0[0][0])
self.assertEqual(w0['r'], w0[0])
w0 = Word.from_term(w0['r0'])
with self.assertRaises(InvalidPathException):
self.assertEqual(w0['f'], w0[1])
def test_invalid_creation(self):
def test(rules, expected=None):
if expected:
try:
usl(rules)
except IEMLObjectResolutionError as e:
self.assertListEqual(e.errors, expected)
else:
self.fail()
else:
with self.assertRaises(IEMLObjectResolutionError):
usl(rules)
# missing node definition on sm0
test([('s:r', ieml('[we.]')), ('sa0:r', ieml('[wa.]'))],
[('s0m0', "Missing node definition.")])
# empty rules
test([], [('', "Missing node definition.")])
# multiple def for a node
test([('r0', ieml('[wa.]')), ('r0', ieml('[we.]'))], [(
'r0',
'Multiple definition, multiple ieml object provided for the same node.'
)])
# missing index on text
test([('t:r', ieml('[we.]')), ('t2:r', ieml('[wa.]'))],
[('', "Index missing on text definition.")])
# missing index on word
test([('r2', ieml('[we.]')), ('r', ieml('[wa.]'))],
[('', "Index missing on word definition.")])
test([('s:r', ieml('[wa.]')), ('sm:r', ieml('[we.]')),
('sa1:r', ieml('[wu.]'))],
[('s0a0', 'Missing node definition.')])
# incompatible path
test([('t:r', ieml('[wa.]')), ('s:f', ieml('[we.]'))],
[('', 'No definition, no type inferred on rules list.')])
# mulitple errors
test([("t0:s:f0", ieml('[wa.]')), ("t0:sa:r", ieml('[a.]')),
('t2:r', ieml('[we.]')),
("t0:sm1", Word(Morpheme([ieml('[wu.]')])))],
[('t0:s0', 'No root for the word node.'),
('t0:s0m0', 'Missing node definition.'),
('t1', 'Missing node definition.')])
def test_rules(self):
rules0 = [(path('r0'), ieml('wa.'))]
obj = resolve_ieml_object(*zip(*rules0))
self.assertEqual(obj, Word(Morpheme([ieml('wa.')])))
rules1 = [(path('r1'), ieml('wa.')), (path('r'), ieml('I:')),
(path('f0'), ieml('we.'))]
obj = resolve_ieml_object(*zip(*rules1))
word1 = Word(Morpheme([ieml('I:'), ieml('wa.')]),
Morpheme([ieml('we.')]))
self.assertEqual(obj, word1)
self.assertEqual(resolve_ieml_object(enumerate_paths(obj)), obj)
r = RandomPoolIEMLObjectGenerator(level=Text)
t = r.text()
self.assertEqual(t, resolve_ieml_object(enumerate_paths(t)))
rules = [(path('r1'), ieml('wa.')), (path('r'), ieml('I:')),
(path('f0'), ieml('we.'))]
obj = resolve_ieml_object(*zip(*rules))
self.assertEqual(
obj,
Word(Morpheme([ieml('I:'), ieml('wa.')]), Morpheme([ieml('we.')])))
def get_words_list():
#this list is already sorted
terms_list = [
term("E:A:T:."),
term("E:.S:.wa.-"),
term("E:.-S:.o.-t.-'"),
term("a.i.-"),
term("i.i.-"),
term("u.M:M:.-")
]
# a small yield to check the word before returning it :-°
for t in terms_list:
word_obj = Word(Morpheme(SyntaxTerm(t)))
yield word_obj
def test_replace(self):
u = usl(Word(Morpheme([ieml('[M:]')])))
u2 = replace_paths(u, {'r0': '[S:]'})
self.assertEqual(u2, usl(Word(Morpheme([ieml('[S:]')]))))
def test_is_term(self):
self.assertTrue(Word.from_term(ieml('[A:]')).is_term)
def test_promotion(self):
self.assertIsInstance(Word.from_term(ieml('[A:]')), Word)
self.assertIsInstance(Word.from_term(term('[A:]')), Word)
self.assertIsInstance(ieml('[A:]'), SyntaxTerm)
self.assertIsInstance(ieml(term('[A:]')), SyntaxTerm)
def test_create_word(self):
a = Word(Morpheme([ieml('[wa.]'), ieml('[we.]')]))
b = Word(Morpheme(reversed([ieml('[wa.]'), ieml('[we.]')])))
self.assertEqual(a, b)
self.assertEqual(str(a), str(b))