def test_enumerate_paths(self): r = RandomPoolIEMLObjectGenerator(level=Text) t = r.text() e = list(enumerate_paths(t, level=Term)) self.assertSetEqual({t[1] for t in e}, set(e for e in t.tree_iter() if isinstance(e, Term)))
def test_deference(self): rand = RandomPoolIEMLObjectGenerator() w0 = rand.topic() self.assertEqual(w0['r0'], w0.root[0]) self.assertEqual(w0['r'], w0.root) w0 = topic([w0['r0']]) self.assertEqual(w0['f'], w0.flexing)
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_random(self): r = RandomPoolIEMLObjectGenerator(level=Fact) s = r.fact() p = path("s+a+m + (s+a+m):(r+f)") elems = resolve(s, p) self.assertSetEqual(elems, s.words.union(s.semes)) p = path("t + t:(s+a+m+r+f+(s+a+m):(s+a+m+r+f+(s+a+m):(r+f)))") usl = random_usl(rank_type=Text) elems = resolve(usl, p) self.assertSetEqual(usl.facts.union(usl.words).union(usl.semes).union(usl.theories), elems)
class TestTexts(unittest.TestCase): # TODO : more tests on texts def setUp(self): self.rand_gen = RandomPoolIEMLObjectGenerator(level=SuperSentence) def test_text_ordering_simple(self): """Just checks that elements created in a text are ordered the right way""" word = self.rand_gen.word() sentence, supersentence = self.rand_gen.sentence( ), self.rand_gen.super_sentence() text = Text([supersentence, sentence, word]) self.assertIsInstance(text.children[0], Word) self.assertIsInstance(text.children[1], Sentence) self.assertIsInstance(text.children[2], SuperSentence)
def test_equal(self): t = RandomPoolIEMLObjectGenerator(level=Text).text() t2 = Text(children=t.children) self.assertNotEqual(id(t), id(t2)) self.assertEqual(t, t2) self.assertEqual(t, str(t)) self.assertEqual(str(t), t)
def test_random(self): r = RandomPoolIEMLObjectGenerator(level=Sentence) s = r.sentence() p = path("s+a+m + (s+a+m):(r+f)") elems = resolve(s, p) self.assertSetEqual( elems, {p for p in s.tree_iter() if isinstance(p, (Word, Morpheme))}) p = path("t + t:(s+a+m+r+f+(s+a+m):(s+a+m+r+f+(s+a+m):(r+f)))") usl = random_usl(rank_type=Text) elems = resolve(usl.ieml_object, p) self.assertSetEqual( set(e for e in usl.ieml_object.tree_iter() if not isinstance(e, (Text, SuperClause, Clause, SyntaxTerm))), elems)
class TestText(unittest.TestCase): def setUp(self): self.gen = RandomPoolIEMLObjectGenerator(Text) def test_equality(self): text0 = self.gen.text() self.assertEqual(text0, Text(text0)) s0 = self.gen.fact() t1 = text([text0, s0]) self.assertIn(s0, t1) self.assertIn(text0, t1) def test_hashing(self): s = RandomPoolIEMLObjectGenerator(level=Text).text() h = {s: 1, 2: 3} self.assertIn(s, h)
def test_rank(self): r = RandomPoolIEMLObjectGenerator(level=Text) self.assertEqual(r.word().__class__.syntax_rank(), 1) self.assertEqual(r.topic().__class__.syntax_rank(), 2) self.assertEqual(r.fact().__class__.syntax_rank(), 3) self.assertEqual(r.theory().__class__.syntax_rank(), 4) self.assertEqual(r.text().__class__.syntax_rank(), 5)
def test_rules(self): rules0 = [(path('r0'), ieml('wa.'))] obj = resolve_ieml_object(*zip(*rules0)) self.assertEqual(obj, topic([ieml('wa.')])) rules1 = [(path('r1'), ieml('wa.')), (path('r'), ieml('I:')), (path('f0'), ieml('we.'))] obj = resolve_ieml_object(*zip(*rules1)) word1 = topic([ieml('I:'), ieml('wa.')], [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, topic([ieml('I:'), ieml('wa.')], [ieml('we.')]))
class TestTexts(unittest.TestCase): # TODO : more tests on texts def setUp(self): self.rand_gen = RandomPoolIEMLObjectGenerator(level=Theory) def test_text_ordering_simple(self): """Just checks that elements created in a text are ordered the right way""" topic = self.rand_gen.topic() sentence, supersentence = self.rand_gen.fact(), self.rand_gen.theory() text = Text([supersentence, sentence, topic]) self.assertIn(topic, text.topics) self.assertIn(sentence, text.facts) self.assertIn(supersentence, text.theories) self.assertTrue(all(isinstance(t, Word) for t in text.words)) self.assertTrue(all(isinstance(t, Topic) for t in text.topics)) self.assertTrue(all(isinstance(t, Fact) for t in text.facts)) self.assertTrue(all(isinstance(t, Theory) for t in text.theories))
def random_usl(dictionary, rank_type=None): global _ieml_object_generator if _ieml_object_generator is None: _ieml_object_generator = RandomPoolIEMLObjectGenerator(dictionary, level=Text, pool_size=100) if rank_type and not isinstance(rank_type, IEMLSyntaxType): raise ValueError( 'The wanted type for the generated usl object must be a IEMLType, here : ' '%s' % rank_type.__class__.__name__) if not rank_type: i = random.randint(0, 10) if i < 4: rank_type = _ieml_objects_types[i] else: rank_type = Text return usl(_ieml_object_generator.from_type(rank_type))
class TestTheory(unittest.TestCase): def setUp(self): self.rnd_gen = RandomPoolIEMLObjectGenerator(Fact) def test_theory_creation(self): a, b, c, d, e, f = tuple(self.rnd_gen.fact() for _ in range(6)) try: theory([(a, b, f), (a, c, f), (b, e, f), (b, d, f)]) except InvalidIEMLObjectArgument as e: self.fail() def test_hashing(self): s = RandomPoolIEMLObjectGenerator(level=Theory).theory() h = {s: 1, 2: 3} self.assertIn(s, h)
class TestSuperSentence(unittest.TestCase): def setUp(self): self.rnd_gen = RandomPoolIEMLObjectGenerator(Sentence) def test_supersentence_creation(self): a, b, c, d, e, f = tuple(self.rnd_gen.sentence() for i in range(6)) try: super_sentence = SuperSentence([SuperClause(a,b,f), SuperClause(a,c,f), SuperClause(b,e,f), SuperClause(b,d,f)]) except InvalidIEMLObjectArgument as e: self.fail() def test_hashing(self): s = RandomPoolIEMLObjectGenerator(level=SuperSentence).super_sentence() h = {s: 1, 2:3} self.assertIn(s, h)
def setUp(self): self.rand = RandomPoolIEMLObjectGenerator(level=Text) self.parser = IEMLParser()
class TestPropositionParser(unittest.TestCase): def setUp(self): self.rand = RandomPoolIEMLObjectGenerator(level=Text) self.parser = IEMLParser() def test_parse_term(self): for i in range(10): o = self.rand.term() self.assertEqual(self.parser.parse(str(o)), o) def test_parse_word(self): for i in range(10): o = self.rand.word() self.assertEqual(self.parser.parse(str(o)), o) def test_parse_term_plus(self): t = term("f.-O:M:.+M:O:.-s.y.-'") to_check = ieml("[f.-O:M:.+M:O:.-s.y.-']") self.assertEqual(to_check, SyntaxTerm(t)) def test_parse_sentence(self): for i in range(10): o = self.rand.sentence() self.assertEqual(self.parser.parse(str(o)), o) def test_parse_super_sentence(self): for i in range(10): o = self.rand.word() self.assertEqual(self.parser.parse(str(o)), o) def test_parse_text(self): for i in range(10): o = self.rand.text() self.assertEqual(self.parser.parse(str(o)), o) def test_literals(self): w1 = str(self.rand.word()) + "<la\la\>lal\>fd>" w2 = str(self.rand.word()) + "<@!#$#@%{}\>fd>" self.assertEqual(str(self.parser.parse(w1)), w1) self.assertEqual(str(self.parser.parse(w2)), w2) s1 = '[(' + '*'.join( (w1, w2, str(self.rand.word()))) + ')]' + "<!@#$%^&*()_+\<>" self.assertEqual(str(self.parser.parse(s1)), s1) ss1 = '[(' + '*'.join((s1, str( self.rand.sentence()), str(self.rand.sentence()))) + ')]<opopop>' self.assertEqual(str(self.parser.parse(ss1)), ss1) def test_invalid_term(self): with self.assertRaises(CannotParse): self.parser.parse("[([A:A:A:.-'])]") with self.assertRaises(TermNotFoundInDictionary): term("A:A:A:.") def test_multiple_ieml_parser(self): p0 = IEMLParser() p1 = IEMLParser() self.assertEqual(p0, p1) p2 = IEMLParser(Dictionary('dictionary_2017-06-07_00:00:00')) self.assertNotEqual(p0, p2) p3 = IEMLParser(from_version='dictionary_2017-06-07_00:00:00') self.assertNotEqual(p2, p3) def test_parse_script(self): self.assertEqual(str(self.parser.parse("A:")), '[A:]') def test_threading(self): pool = ThreadPool(4) results = pool.map(self.parser.parse, Dictionary().version.terms) self.assertSetEqual( {str(t) for t in results}, {'[{0}]'.format(str(t)) for t in Dictionary().version.terms}) results = pool.map(script, Dictionary().version.terms) self.assertSetEqual({str(t) for t in results}, set(Dictionary().version.terms))
def test_hashing(self): s = RandomPoolIEMLObjectGenerator(level=Text).text() h = {s: 1, 2: 3} self.assertIn(s, h)
def setUp(self): self.gen = RandomPoolIEMLObjectGenerator(Text)
def setUp(self): self.rnd_gen = RandomPoolIEMLObjectGenerator(Sentence)
def __init__(self, **kwargs): self.generator = RandomPoolIEMLObjectGenerator(**kwargs)
def test_hashing(self): s = RandomPoolIEMLObjectGenerator(level=SuperSentence).super_sentence() h = {s: 1, 2:3} self.assertIn(s, h)
def setUp(self): self.rand = RandomPoolIEMLObjectGenerator(level=Theory) self.parser = IEMLParser()
def test_rank(self): r = RandomPoolIEMLObjectGenerator(level=Text) self.assertEqual(r.word().__class__.syntax_rank(), 2) self.assertEqual(r.sentence().__class__.syntax_rank(), 4) self.assertEqual(r.super_sentence().__class__.syntax_rank(), 6) self.assertEqual(r.text().__class__.syntax_rank(), 7)
def test_enumerate_paths(self): r = RandomPoolIEMLObjectGenerator(level=Text) t = r.text() e = list(enumerate_paths(t, level=Word)) self.assertSetEqual({t[1] for t in e}, t.words)
def setUp(self): self.rand_gen = RandomPoolIEMLObjectGenerator(level=SuperSentence)
class RandomUslGenerator: def __init__(self, **kwargs): self.generator = RandomPoolIEMLObjectGenerator(**kwargs) def __call__(self, type): return usl(self.generator.from_type(type))
def setUp(self): self.rnd_gen = RandomPoolIEMLObjectGenerator(Fact)
def test_equality(self): ieml = RandomPoolIEMLObjectGenerator(level=Text).text() self.assertEqual(Usl(ieml_object=ieml), Usl(ieml_object=ieml))
def setUp(self): self.rand_gen = RandomPoolIEMLObjectGenerator(level=Theory)
class TestPropositionParser(unittest.TestCase): def setUp(self): self.rand = RandomPoolIEMLObjectGenerator(level=Theory) self.parser = IEMLParser() def test_parse_word(self): for i in range(10): o = self.rand.word() self.assertEqual(self.parser.parse(str(o)), o) def test_parse_topic(self): for i in range(10): o = self.rand.topic() self.assertEqual(self.parser.parse(str(o)), o) def test_parse_term_plus(self): t = term("f.-O:M:.+M:O:.-s.y.-'") to_check = ieml("[f.-O:M:.+M:O:.-s.y.-']") self.assertEqual(to_check, Word(t)) def test_parse_sentence(self): for i in range(10): o = self.rand.fact() self.assertEqual(self.parser.parse(str(o)), o) def test_parse_super_sentence(self): for i in range(10): o = self.rand.theory() self.assertEqual(self.parser.parse(str(o)), o) # def test_parse_text(self): # for i in range(10): # o = self.rand.text() # self.assertEqual(self.parser.parse(str(o)), o) def test_literals(self): w1 = str(self.rand.topic()) + "<la\la\>lal\>fd>" w2 = str(self.rand.topic()) + "<@!#$#@%{}\>fd>" self.assertEqual(str(self.parser.parse(w1)), w1) self.assertEqual(str(self.parser.parse(w2)), w2) s1 = '[('+ '*'.join((w1, w2, str(self.rand.topic()))) +')]' + "<!@#$%^&*()_+\<>" self.assertEqual(str(self.parser.parse(s1)), s1) ss1 = '[('+ '*'.join((s1, str(self.rand.fact()), str(self.rand.fact()))) + ')]<opopop>' self.assertEqual(str(self.parser.parse(ss1)), ss1) def test_invalid_term(self): with self.assertRaises(CannotParse): self.parser.parse("[([A:A:A:.-'])]") with self.assertRaises(TermNotFoundInDictionary): term("A:A:A:.") def test_multiple_ieml_parser(self): p0 = IEMLParser() p1 = IEMLParser() self.assertEqual(p0, p1) p2 = IEMLParser(Dictionary('dictionary_2017-06-07_00:00:00')) self.assertNotEqual(p0, p2) p3 = IEMLParser(from_version='dictionary_2017-06-07_00:00:00') self.assertNotEqual(p2, p3) def test_parse_script(self): self.assertEqual(str(self.parser.parse("A:")), '[A:]') def test_threading(self): pool = ThreadPool(4) results = pool.map(self.parser.parse, Dictionary().version.terms) self.assertSetEqual({str(t) for t in results}, {'[{0}]'.format(str(t)) for t in Dictionary().version.terms}) results = pool.map(script, Dictionary().version.terms) self.assertSetEqual({str(t) for t in results}, set(Dictionary().version.terms))
def setUp(self): self.d = Dictionary.load() self.rand_gen = RandomPoolIEMLObjectGenerator(self.d, level=Theory)