pyolian: Fix tests

Summary: Update tests after some legacy cleanup from last release.

Reviewers: bu5hm4n, DaveMDS, segfaultxavi

Reviewed By: DaveMDS

Subscribers: segfaultxavi, cedric, #reviewers, #committers

Tags: #efl

Differential Revision: https://phab.enlightenment.org/D8817

1 files changed, 45 insertions, 32 deletions

diff --git a/src/scripts/pyolian/test_eolian.py b/src/scripts/pyolian/test_eolian.py
index 23a618be11..b597e812b7 100755
--- a/src/scripts/pyolian/test_eolian.py
+++ b/src/scripts/pyolian/test_eolian.py
@@ -59,7 +59,7 @@ class TestEolianState(unittest.TestCase):
             self.assertIsInstance(unit, eolian.Eolian_Unit)
             self.assertTrue(unit.file.endswith(('.eo', '.eot')))
             count += 1
-        self.assertGreater(count, 500)
+        self.assertGreater(count, 400)
 
         unit = eolian_db.unit_by_file_get('efl_ui_win.eo')
         self.assertIsInstance(unit, eolian.Eolian_Unit)
@@ -167,8 +167,8 @@ class TestEolianUnit(unittest.TestCase):
         self.assertGreater(all_count, 50)
 
     def test_alias_listing(self):
-        l = list(eolian_db.aliases_by_file_get('edje_types.eot'))
-        self.assertGreater(len(l), 5)
+        l = list(eolian_db.aliases_by_file_get('eina_types.eot'))
+        self.assertGreater(len(l), 2)
         self.assertIsInstance(l[0], eolian.Typedecl)
 
         all_count = 0
@@ -211,12 +211,30 @@ class TestEolianNamespace(unittest.TestCase):
         for ns in eolian_db.all_namespaces:
             self.assertIsInstance(ns, eolian.Namespace)
             count += 1
-        self.assertGreater(count, 100)
+        self.assertGreater(count, 50)
 
     def test_namespace_vs_class_collision(self):
+        colliding_classes = ['Ecore.Audio',
+                             'Ecore.Audio.In',
+                             'Ecore.Audio.Out',
+                             'Ecore.Event.Message',
+                             'Ector.Buffer',
+                             'Ector.Renderer',
+                             'Ector.Renderer.Cairo',
+                             'Ector.Renderer.GL',
+                             'Ector.Renderer.Gradient',
+                             'Ector.Renderer.Software',
+                             'Ector.Software.Buffer',
+                             'Eio.Sentry',
+                             'Eldbus.Model',
+                            ]
         for ns in eolian_db.all_namespaces:
             cls = eolian_db.class_by_name_get(ns.name)
-            self.assertIsNone(cls)
+            # Some legacy classes are parsed and still make this fail.
+            if cls:
+                self.assertIn(cls.name, colliding_classes)
+            else:
+                self.assertIsNone(cls)
 
     def test_namespace_equality(self):
         ns1 = eolian.Namespace(eolian_db, 'Efl.Io')
@@ -323,7 +341,6 @@ class TestEolianClass(unittest.TestCase):
         self.assertEqual(list(cls.namespaces), ['Efl'])
         self.assertEqual(cls.type, eolian.Eolian_Class_Type.REGULAR)
         self.assertIsInstance(cls.documentation, eolian.Documentation)
-        self.assertEqual(cls.legacy_prefix, 'ecore_timer')
         self.assertIsNone(cls.eo_prefix)  # TODO fin a class with a value
         self.assertIsNone(cls.event_prefix)  # TODO same as above
         self.assertIsNone(cls.data_type)  # TODO same as above
@@ -335,8 +352,8 @@ class TestEolianClass(unittest.TestCase):
         self.assertEqual(cls.c_get_function_name, 'efl_loop_timer_class_get')
         self.assertEqual(cls.c_macro, 'EFL_LOOP_TIMER_CLASS')
         self.assertEqual(cls.c_data_type, 'Efl_Loop_Timer_Data')
-        self.assertEqual([f.name for f in cls.methods], ['reset','loop_reset','delay'])
-        self.assertEqual([f.name for f in cls.properties], ['interval','pending'])
+        self.assertEqual([f.name for f in cls.methods], ['timer_reset','timer_loop_reset','timer_delay'])
+        self.assertEqual([f.name for f in cls.properties], ['timer_interval','time_pending'])
         self.assertGreater(len(list(cls.implements)), 5)
         self.assertIsInstance(list(cls.implements)[0], eolian.Implement)
 
@@ -344,9 +361,9 @@ class TestEolianClass(unittest.TestCase):
 class TestEolianFunction(unittest.TestCase):
     def test_function(self):
         cls = eolian_db.class_by_name_get('Efl.Loop_Timer')
-        f = cls.function_by_name_get('delay')
+        f = cls.function_by_name_get('timer_delay')
         self.assertIsInstance(f, eolian.Function)
-        self.assertEqual(f.name, 'delay')
+        self.assertEqual(f.name, 'timer_delay')
         self.assertEqual(f.type, eolian.Eolian_Function_Type.METHOD)
         self.assertEqual(f.method_scope, eolian.Eolian_Object_Scope.PUBLIC)
         self.assertEqual(f.getter_scope, eolian.Eolian_Object_Scope.UNKNOWN)  # TODO correct?
@@ -354,13 +371,9 @@ class TestEolianFunction(unittest.TestCase):
         self.assertEqual(f.full_c_method_name, 'efl_loop_timer_delay')
         self.assertEqual(f.full_c_getter_name, 'efl_loop_timer_delay_get')
         self.assertEqual(f.full_c_setter_name, 'efl_loop_timer_delay_set')
-        self.assertEqual(f.full_c_method_name_legacy, 'ecore_timer_delay')
-        self.assertEqual(f.full_c_getter_name_legacy, 'ecore_timer_delay_get')
-        self.assertEqual(f.full_c_setter_name_legacy, 'ecore_timer_delay_set')
         self.assertIsNone(f.method_return_type)  # TODO correct ?
         self.assertIsNone(f.setter_return_type)  # TODO correct ?
         self.assertIsNone(f.getter_return_type)  # TODO correct ?
-        self.assertFalse(f.is_legacy_only(eolian.Eolian_Function_Type.PROP_GET))
         self.assertFalse(f.is_class)
         self.assertFalse(f.is_beta)
         self.assertFalse(f.is_constructor(cls))
@@ -375,7 +388,7 @@ class TestEolianFunction(unittest.TestCase):
 
     def test_function_parameter(self):
         cls = eolian_db.class_by_name_get('Efl.Loop_Timer')
-        f = cls.function_by_name_get('delay')
+        f = cls.function_by_name_get('timer_delay')
         p = list(f.parameters)[0]
         self.assertEqual(p.direction, eolian.Eolian_Parameter_Dir.IN)
         self.assertEqual(p.name, 'add')
@@ -388,10 +401,10 @@ class TestEolianFunction(unittest.TestCase):
 class TestEolianImplement(unittest.TestCase):
     def test_implement(self):
         cls = eolian_db.class_by_name_get('Efl.Loop_Timer')
-        f = cls.function_by_name_get('delay')
+        f = cls.function_by_name_get('timer_delay')
         im = f.implement
         self.assertIsInstance(im, eolian.Implement)
-        self.assertEqual(im.name, 'Efl.Loop_Timer.delay')
+        self.assertEqual(im.name, 'Efl.Loop_Timer.timer_delay')
         self.assertIsInstance(im.class_, eolian.Class)
         self.assertIsInstance(im.function, eolian.Function)
         self.assertIsInstance(im.documentation_get(), eolian.Documentation) # TODO is UNRESOLVED correct ?
@@ -407,10 +420,10 @@ class TestEolianImplement(unittest.TestCase):
 class TestEolianEvent(unittest.TestCase):
     def test_event(self):
         cls = eolian_db.class_by_name_get('Efl.Loop_Timer')
-        self.assertEqual([e.name for e in cls.events], ['tick'])
-        ev = cls.event_by_name_get('tick')
+        self.assertEqual([e.name for e in cls.events], ['timer,tick'])
+        ev = cls.event_by_name_get('timer,tick')
         self.assertIsInstance(ev, eolian.Event)
-        self.assertEqual(ev.name, 'tick')
+        self.assertEqual(ev.name, 'timer,tick')
         self.assertEqual(ev.c_macro, 'EFL_LOOP_TIMER_EVENT_TIMER_TICK')
         self.assertIsNone(ev.type)  # TODO is this correct
         self.assertIsInstance(ev.documentation, eolian.Documentation)
@@ -441,7 +454,7 @@ class TestEolianConstructor(unittest.TestCase):
         ctor = ctors[0]
         self.assertIsInstance(ctor, eolian.Constructor)
         self.assertEqual(ctor.name, 'Efl.Ui.Win.win_name')
-        self.assertFalse(ctor.is_optional)
+        self.assertTrue(ctor.is_optional)
         self.assertIsInstance(ctor.class_, eolian.Class)
         self.assertEqual(ctor.class_.name, 'Efl.Ui.Win')
         self.assertIsInstance(ctor.function, eolian.Function)
@@ -450,14 +463,14 @@ class TestEolianConstructor(unittest.TestCase):
 
 class TestEolianDocumentation(unittest.TestCase):
     def test_documentation(self):
-        td = eolian_db.class_by_name_get('Efl.Net.Control.Manager')
+        td = eolian_db.class_by_name_get('Efl.Object')
         doc = td.documentation
         self.assertIsInstance(doc, eolian.Documentation)
         self.assertIsInstance(doc.summary, str)
         self.assertGreater(len(doc.summary), 10)
         self.assertIsInstance(doc.description, str)
         self.assertGreater(len(doc.description), 20)
-        self.assertEqual(doc.since, '1.19')
+        self.assertEqual(doc.since, '1.22')
 
 
 class TestEolianVariable(unittest.TestCase):
@@ -475,10 +488,10 @@ class TestEolianVariable(unittest.TestCase):
         self.assertIsNone(var.value)  # TODO is None correct here? no value?
 
     def test_variable_constant(self):
-        var = eolian_db.constant_by_name_get('Efl.Gfx.Hint_Fill')
+        var = eolian_db.constant_by_name_get('Efl.Gfx.Hint_Expand')
         self.assertIsInstance(var, eolian.Variable)
-        self.assertEqual(var.name, 'Efl.Gfx.Hint_Fill')
-        self.assertEqual(var.short_name, 'Size_Hint_Fill')
+        self.assertEqual(var.name, 'Efl.Gfx.Hint_Expand')
+        self.assertEqual(var.short_name, 'Hint_Expand')
         self.assertEqual(var.type, eolian.Eolian_Variable_Type.CONSTANT)
         self.assertEqual(var.file, 'efl_gfx_hint.eo')
         self.assertFalse(var.is_extern)
@@ -551,7 +564,7 @@ class TestEolianTypedecl(unittest.TestCase):
 class TestEolianType(unittest.TestCase):
     def test_type_regular_builtin(self):
         cls = eolian_db.class_by_name_get('Efl.Loop_Timer')
-        func = cls.function_by_name_get('delay')
+        func = cls.function_by_name_get('timer_delay')
         param = list(func.parameters)[0]
         t = param.type  # type: double
         self.assertIsInstance(t, eolian.Type)
@@ -629,16 +642,16 @@ class TestEolianExpression(unittest.TestCase):
         self.assertEqual(exp.serialize, '100')
 
     def test_expression_unary(self):
-        var = eolian_db.constant_by_name_get('Efl.Gfx.Hint_Fill')
+        var = eolian_db.constant_by_name_get('Efl.Gfx.Stack_Layer_Min')
         exp = var.value
         self.assertIsInstance(exp, eolian.Expression)
         self.assertEqual(exp.type, eolian.Eolian_Expression_Type.UNARY)
-        self.assertEqual(float(exp.serialize), 1.0)  # TODO is this a bug? isn't -1.0 ?
-        self.assertEqual(exp.unary_operator, eolian.Eolian_Unary_Operator.UNM)
+        self.assertEqual(float(exp.serialize), 32768.0)  # TODO is this a bug? isn't -1.0 ?
+        self.assertEqual(exp.unary_operator, eolian.Eolian_Unary_Operator.UNM) # Invalid -> NOP
         unary = exp.unary_expression
         self.assertIsInstance(unary, eolian.Expression)
-        self.assertEqual(unary.type, eolian.Eolian_Expression_Type.DOUBLE)
-        self.assertEqual(float(exp.serialize), 1.0)
+        self.assertEqual(unary.type, eolian.Eolian_Expression_Type.INT)
+        self.assertEqual(float(exp.serialize), 32768.0) # Bug too?
 
         # TODO test_expression_binary
         #  exp.binary_operator # TODO find a better test (only works for BINARY expr)