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_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 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_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))
def get_test_morpheme_instance():
morpheme = Morpheme(
map(SyntaxTerm, [term("E:A:T:."),
term("E:S:.wa.-"),
term("E:S:.o.-")]))
return morpheme
def p_morpheme(self, p):
"""morpheme : LPAREN terms_sum RPAREN"""
p[0] = _build(Morpheme(p[2][0]), p[2])