679 lines
29 KiB
Python
Executable File
679 lines
29 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
# encoding: utf-8
|
|
"""
|
|
Pyolian test suite.
|
|
|
|
Just run this file to execute the full suite.
|
|
|
|
A return value of 0 means all test passed successfully.
|
|
|
|
"""
|
|
import os
|
|
import unittest
|
|
|
|
import eolian
|
|
|
|
|
|
# Use .eo files from the source tree (not the installed ones)
|
|
script_path = os.path.dirname(os.path.realpath(__file__))
|
|
root_path = os.path.abspath(os.path.join(script_path, '..', '..', '..'))
|
|
SCAN_FOLDER = os.path.join(root_path, 'src', 'lib')
|
|
|
|
# the main Eolian unit state
|
|
eolian_db = None
|
|
|
|
|
|
class TestBaseObject(unittest.TestCase):
|
|
def test_base_object_equality(self):
|
|
cls1 = eolian_db.class_by_name_get('Efl.Loop_Timer')
|
|
cls2 = eolian_db.class_by_file_get('efl_loop_timer.eo')
|
|
self.assertIsInstance(cls1, eolian.Class)
|
|
self.assertIsInstance(cls2, eolian.Class)
|
|
self.assertEqual(cls1, cls2)
|
|
self.assertEqual(cls1, 'Efl.Loop_Timer')
|
|
self.assertEqual(cls2, 'Efl.Loop_Timer')
|
|
self.assertNotEqual(cls1, 'another string')
|
|
self.assertNotEqual(cls1, 1234)
|
|
self.assertNotEqual(cls1, None)
|
|
self.assertNotEqual(cls1, 0)
|
|
|
|
enum1 = eolian_db.enum_by_name_get('Efl.Ui.Focus.Direction')
|
|
enum2 = eolian_db.enum_by_name_get('Efl.Ui.Focus.Direction')
|
|
self.assertIsInstance(enum1, eolian.Typedecl)
|
|
self.assertIsInstance(enum2, eolian.Typedecl)
|
|
self.assertEqual(enum1, enum2)
|
|
self.assertEqual(enum1, 'Efl.Ui.Focus.Direction')
|
|
self.assertEqual(enum2, 'Efl.Ui.Focus.Direction')
|
|
self.assertNotEqual(enum1, 'another string')
|
|
self.assertNotEqual(enum1, 1234)
|
|
self.assertNotEqual(enum1, None)
|
|
self.assertNotEqual(enum1, 0)
|
|
|
|
self.assertNotEqual(cls1, enum1)
|
|
|
|
|
|
class TestEolianState(unittest.TestCase):
|
|
def test_unit_getters(self):
|
|
count = 0
|
|
for unit in eolian_db.units:
|
|
self.assertIsInstance(unit, eolian.Eolian_Unit)
|
|
self.assertTrue(unit.file.endswith(('.eo', '.eot')))
|
|
count += 1
|
|
self.assertGreater(count, 500)
|
|
|
|
unit = eolian_db.unit_by_file_get('efl_ui_win.eo')
|
|
self.assertIsInstance(unit, eolian.Eolian_Unit)
|
|
self.assertEqual(unit.file, 'efl_ui_win.eo')
|
|
|
|
def test_object_getters(self):
|
|
obj = eolian_db.object_by_name_get('Efl.Ui.Frame')
|
|
self.assertIsInstance(obj, eolian.Object)
|
|
self.assertFalse(type(obj) == eolian.Object)
|
|
self.assertEqual(obj.name, 'Efl.Ui.Frame')
|
|
|
|
count = 0
|
|
for obj in eolian_db.objects:
|
|
self.assertIsInstance(obj, eolian.Object)
|
|
self.assertFalse(type(obj) == eolian.Object)
|
|
count += 1
|
|
self.assertGreater(count, 800)
|
|
|
|
count = 0
|
|
for obj in eolian_db.objects_by_file_get('efl_loop.eo'):
|
|
self.assertIsInstance(obj, eolian.Object)
|
|
self.assertFalse(type(obj) == eolian.Object)
|
|
count += 1
|
|
self.assertGreater(count, 1)
|
|
|
|
|
|
class TestEolianUnit(unittest.TestCase):
|
|
def test_unit_get(self):
|
|
unit = eolian_db.unit_by_file_get('efl_ui_win.eo')
|
|
self.assertIsInstance(unit.state, eolian.Eolian_State)
|
|
self.assertEqual(unit.state, eolian_db)
|
|
|
|
def test_file_get(self):
|
|
unit = eolian_db.unit_by_file_get('efl_ui_win.eo')
|
|
self.assertIsInstance(unit, eolian.Eolian_Unit)
|
|
self.assertEqual(unit.file, 'efl_ui_win.eo')
|
|
|
|
@unittest.skip('Skipped until unit/state support is fixed')
|
|
def test_children_listing(self):
|
|
l = list(eolian_db.children)
|
|
self.assertGreater(len(l), 500)
|
|
self.assertIsInstance(l[0], eolian.Eolian_Unit)
|
|
|
|
def test_file_listing(self):
|
|
l = list(eolian_db.eo_file_paths)
|
|
self.assertGreater(len(l), 400)
|
|
self.assertTrue(l[0].endswith('.eo'))
|
|
|
|
l = list(eolian_db.eo_files)
|
|
self.assertGreater(len(l), 400)
|
|
self.assertTrue(l[0].endswith('.eo'))
|
|
|
|
l = list(eolian_db.eot_file_paths)
|
|
self.assertGreater(len(l), 10)
|
|
self.assertTrue(l[0].endswith('.eot'))
|
|
|
|
l = list(eolian_db.eot_files)
|
|
self.assertGreater(len(l), 10)
|
|
self.assertTrue(l[0].endswith('.eot'))
|
|
|
|
def test_object_listing(self):
|
|
unit = eolian_db.unit_by_file_get('efl_ui_win.eo')
|
|
self.assertIsNone(unit.object_by_name_get('Efl.Ui.Frame'))
|
|
|
|
obj = unit.object_by_name_get('Efl.Ui.Win')
|
|
self.assertIsInstance(obj, eolian.Object)
|
|
self.assertFalse(type(obj) == eolian.Object)
|
|
self.assertEqual(obj.name, 'Efl.Ui.Win')
|
|
|
|
count = 0
|
|
for obj in unit.objects:
|
|
self.assertIsInstance(obj, eolian.Object)
|
|
self.assertFalse(type(obj) == eolian.Object)
|
|
count += 1
|
|
self.assertGreater(count, 5)
|
|
|
|
def test_enum_listing(self):
|
|
l = list(eolian_db.enums_by_file_get('efl_ui_win.eo'))
|
|
self.assertGreater(len(l), 5)
|
|
self.assertIsInstance(l[0], eolian.Typedecl)
|
|
self.assertEqual(l[0].type, eolian.Eolian_Typedecl_Type.ENUM)
|
|
|
|
all_count = 0
|
|
for enum in eolian_db.enums:
|
|
self.assertIsInstance(enum, eolian.Typedecl)
|
|
self.assertEqual(enum.type, eolian.Eolian_Typedecl_Type.ENUM)
|
|
all_count += 1
|
|
self.assertGreater(all_count, 50)
|
|
|
|
def test_struct_listing(self):
|
|
l = list(eolian_db.structs_by_file_get('eina_types.eot'))
|
|
self.assertGreater(len(l), 10)
|
|
self.assertIsInstance(l[0], eolian.Typedecl)
|
|
self.assertIn(l[0].type, (
|
|
eolian.Eolian_Typedecl_Type.STRUCT,
|
|
eolian.Eolian_Typedecl_Type.STRUCT_OPAQUE))
|
|
|
|
all_count = 0
|
|
for struct in eolian_db.structs:
|
|
self.assertIsInstance(struct, eolian.Typedecl)
|
|
self.assertIn(struct.type, (
|
|
eolian.Eolian_Typedecl_Type.STRUCT,
|
|
eolian.Eolian_Typedecl_Type.STRUCT_OPAQUE))
|
|
all_count += 1
|
|
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)
|
|
self.assertIsInstance(l[0], eolian.Typedecl)
|
|
|
|
all_count = 0
|
|
for alias in eolian_db.aliases:
|
|
self.assertIsInstance(alias, eolian.Typedecl)
|
|
self.assertIn(alias.type, (
|
|
eolian.Eolian_Typedecl_Type.ALIAS,
|
|
eolian.Eolian_Typedecl_Type.FUNCTION_POINTER)) # TODO is this correct ??
|
|
all_count += 1
|
|
self.assertGreater(all_count, 10)
|
|
|
|
def test_variable_listing(self):
|
|
l = list(eolian_db.constants)
|
|
self.assertGreater(len(l), 2)
|
|
self.assertIsInstance(l[0], eolian.Variable)
|
|
|
|
l = list(eolian_db.globals)
|
|
self.assertGreater(len(l), 20)
|
|
self.assertIsInstance(l[0], eolian.Variable)
|
|
|
|
l = list(eolian_db.constants_by_file_get('efl_gfx_stack.eo'))
|
|
self.assertGreater(len(l), 1)
|
|
self.assertIsInstance(l[0], eolian.Variable)
|
|
|
|
l = list(eolian_db.globals_by_file_get('efl_net_http_types.eot'))
|
|
self.assertGreater(len(l), 10)
|
|
self.assertIsInstance(l[0], eolian.Variable)
|
|
|
|
def test_class_listing(self):
|
|
all_count = 0
|
|
for cls in eolian_db.classes:
|
|
self.assertIsInstance(cls, eolian.Class)
|
|
all_count += 1
|
|
self.assertGreater(all_count, 400)
|
|
|
|
|
|
class TestEolianNamespace(unittest.TestCase):
|
|
def test_all_namespace(self):
|
|
count = 0
|
|
for ns in eolian_db.all_namespaces:
|
|
self.assertIsInstance(ns, eolian.Namespace)
|
|
count += 1
|
|
self.assertGreater(count, 100)
|
|
|
|
def test_namespace_vs_class_collision(self):
|
|
for ns in eolian_db.all_namespaces:
|
|
cls = eolian_db.class_by_name_get(ns.name)
|
|
self.assertIsNone(cls)
|
|
|
|
def test_namespace_equality(self):
|
|
ns1 = eolian.Namespace(eolian_db, 'Efl.Io')
|
|
ns2 = eolian.Namespace(eolian_db, 'Efl.Net')
|
|
self.assertIsInstance(ns1, eolian.Namespace)
|
|
self.assertIsInstance(ns2, eolian.Namespace)
|
|
self.assertNotEqual(ns1, ns2)
|
|
self.assertEqual(ns1, eolian.Namespace(eolian_db, 'Efl.Io'))
|
|
self.assertEqual(ns2, eolian.Namespace(eolian_db, 'Efl.Net'))
|
|
|
|
def test_namespace_sorting(self):
|
|
nspaces = eolian_db.all_namespaces
|
|
nspaces.sort(reverse=True)
|
|
self.assertGreater(nspaces[0], nspaces[-1])
|
|
self.assertLess(nspaces[1], nspaces[0])
|
|
|
|
def test_namespace_by_name(self):
|
|
ns = eolian.Namespace(eolian_db, 'Efl.Net')
|
|
self.assertIsInstance(ns, eolian.Namespace)
|
|
self.assertEqual(ns.name, 'Efl.Net')
|
|
self.assertEqual(ns.namespaces, ['Efl', 'Net'])
|
|
|
|
ns = eolian_db.namespace_get_by_name('Efl')
|
|
self.assertIsInstance(ns, eolian.Namespace)
|
|
self.assertEqual(ns.name, 'Efl')
|
|
|
|
self.assertGreater(len(ns.classes), 30)
|
|
for cls in ns.classes:
|
|
self.assertIsInstance(cls, eolian.Class)
|
|
self.assertGreater(len(ns.regulars), 4)
|
|
for cls in ns.regulars:
|
|
self.assertIsInstance(cls, eolian.Class)
|
|
self.assertEqual(cls.type, eolian.Eolian_Class_Type.REGULAR)
|
|
self.assertGreater(len(ns.mixins), 0)
|
|
for cls in ns.mixins:
|
|
self.assertIsInstance(cls, eolian.Class)
|
|
self.assertEqual(cls.type, eolian.Eolian_Class_Type.MIXIN)
|
|
self.assertGreater(len(ns.interfaces), 15)
|
|
for cls in ns.interfaces:
|
|
self.assertIsInstance(cls, eolian.Class)
|
|
self.assertEqual(cls.type, eolian.Eolian_Class_Type.INTERFACE)
|
|
|
|
self.assertGreater(len(ns.enums), 1)
|
|
for td in ns.enums:
|
|
self.assertIsInstance(td, eolian.Typedecl)
|
|
self.assertEqual(td.type, eolian.Eolian_Typedecl_Type.ENUM)
|
|
self.assertGreater(len(ns.aliases), 0)
|
|
for td in ns.aliases:
|
|
self.assertIsInstance(td, eolian.Typedecl)
|
|
# TODO eolian_typedecl_all_aliases_get also return FUNCTION_POINTER
|
|
# is this correct? or an eolian bug ?
|
|
# self.assertEqual(td.type, eolian.Eolian_Typedecl_Type.ALIAS)
|
|
self.assertGreater(len(ns.structs), 2)
|
|
for td in ns.structs:
|
|
self.assertIsInstance(td, eolian.Typedecl)
|
|
self.assertEqual(td.type, eolian.Eolian_Typedecl_Type.STRUCT)
|
|
|
|
|
|
class TestEolianObject(unittest.TestCase):
|
|
def test_object_instance(self):
|
|
obj = eolian_db.object_by_name_get('Efl.Ui.Frame')
|
|
self.assertIsInstance(obj, eolian.Class)
|
|
self.assertEqual(obj.name, 'Efl.Ui.Frame')
|
|
|
|
def test_unit(self):
|
|
obj = eolian_db.object_by_name_get('Efl.Ui.Frame')
|
|
self.assertIsInstance(obj.unit, eolian.Eolian_Unit)
|
|
self.assertEqual(obj.unit.file, 'efl_ui_frame.eo')
|
|
|
|
def test_name(self):
|
|
obj = eolian_db.object_by_name_get('Efl.Ui.Frame')
|
|
self.assertEqual(obj.name, 'Efl.Ui.Frame')
|
|
|
|
def test_short_name(self):
|
|
obj = eolian_db.object_by_name_get('Efl.Ui.Frame')
|
|
self.assertEqual(obj.short_name, 'Frame')
|
|
|
|
def test_file(self):
|
|
obj = eolian_db.object_by_name_get('Efl.Ui.Frame')
|
|
self.assertEqual(obj.file, 'efl_ui_frame.eo')
|
|
|
|
def test_line(self):
|
|
obj = eolian_db.object_by_name_get('Efl.Ui.Frame')
|
|
self.assertIsInstance(obj.line, int)
|
|
self.assertGreater(obj.line, 0)
|
|
|
|
def test_column(self):
|
|
obj = eolian_db.object_by_name_get('Efl.Ui.Frame')
|
|
self.assertIsInstance(obj.column, int)
|
|
self.assertGreater(obj.column, 0)
|
|
|
|
|
|
class TestEolianClass(unittest.TestCase):
|
|
def test_class(self):
|
|
cls = eolian_db.class_by_file_get('efl_loop_timer.eo')
|
|
self.assertIsInstance(cls, eolian.Class)
|
|
|
|
cls = eolian_db.class_by_name_get('Efl.Loop_Timer')
|
|
self.assertIsInstance(cls, eolian.Class)
|
|
|
|
self.assertEqual(cls.name, 'Efl.Loop_Timer')
|
|
self.assertEqual(cls.short_name, 'Loop_Timer')
|
|
self.assertEqual(cls.file, 'efl_loop_timer.eo')
|
|
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
|
|
self.assertEqual(cls.parent.name, 'Efl.Loop_Consumer')
|
|
self.assertEqual([c.name for c in cls.extensions], [])
|
|
self.assertEqual([c.name for c in cls.hierarchy], ['Efl.Loop_Consumer', 'Efl.Object'])
|
|
self.assertFalse(cls.ctor_enable)
|
|
self.assertFalse(cls.dtor_enable)
|
|
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.assertGreater(len(list(cls.implements)), 5)
|
|
self.assertIsInstance(list(cls.implements)[0], eolian.Implement)
|
|
|
|
|
|
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')
|
|
self.assertIsInstance(f, eolian.Function)
|
|
self.assertEqual(f.name, '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?
|
|
self.assertEqual(f.setter_scope, eolian.Eolian_Object_Scope.UNKNOWN) # TODO correct?
|
|
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))
|
|
# # #assert f.is_function_pointer == False # TODO broken somehow
|
|
self.assertEqual(len(list(f.getter_values)), 1)
|
|
self.assertEqual(len(list(f.getter_values)), 1)
|
|
self.assertEqual(len(list(f.parameters)), 1)
|
|
self.assertTrue(f.return_allow_unused(eolian.Eolian_Function_Type.METHOD))
|
|
self.assertFalse(f.object_is_const)
|
|
self.assertEqual(f.class_.name, 'Efl.Loop_Timer')
|
|
self.assertIsInstance(f.implement, eolian.Implement)
|
|
|
|
def test_function_parameter(self):
|
|
cls = eolian_db.class_by_name_get('Efl.Loop_Timer')
|
|
f = cls.function_by_name_get('delay')
|
|
p = list(f.parameters)[0]
|
|
self.assertEqual(p.direction, eolian.Eolian_Parameter_Dir.IN)
|
|
self.assertEqual(p.name, 'add')
|
|
self.assertIsNone(p.default_value)
|
|
self.assertFalse(p.is_optional)
|
|
self.assertEqual(p.type.name, 'double')
|
|
self.assertIsInstance(p.documentation, eolian.Documentation)
|
|
|
|
|
|
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')
|
|
im = f.implement
|
|
self.assertIsInstance(im, eolian.Implement)
|
|
self.assertEqual(im.name, 'Efl.Loop_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 ?
|
|
self.assertFalse(im.is_auto())
|
|
self.assertFalse(im.is_empty())
|
|
self.assertFalse(im.is_pure_virtual())
|
|
self.assertFalse(im.is_prop_set)
|
|
self.assertFalse(im.is_prop_get)
|
|
self.assertFalse(im.is_property)
|
|
self.assertTrue(im.is_method)
|
|
|
|
|
|
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.assertIsInstance(ev, eolian.Event)
|
|
self.assertEqual(ev.name, '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)
|
|
self.assertEqual(ev.scope, eolian.Eolian_Object_Scope.PUBLIC)
|
|
self.assertFalse(ev.is_beta)
|
|
self.assertFalse(ev.is_hot)
|
|
self.assertFalse(ev.is_restart)
|
|
|
|
|
|
class TestEolianPart(unittest.TestCase):
|
|
def test_part(self):
|
|
cls = eolian_db.class_by_name_get('Efl.Ui.Popup')
|
|
parts = list(cls.parts)
|
|
self.assertGreater(len(parts), 0)
|
|
|
|
part = parts[0]
|
|
self.assertEqual(part.name, 'backwall')
|
|
self.assertIsInstance(part.class_, eolian.Class)
|
|
self.assertEqual(part.class_.name, 'Efl.Ui.Popup_Part_Backwall')
|
|
self.assertIsInstance(part.documentation, eolian.Documentation)
|
|
|
|
|
|
class TestEolianConstructor(unittest.TestCase):
|
|
def test_constructor(self):
|
|
cls = eolian_db.class_by_name_get('Efl.Ui.Win')
|
|
ctors = list(cls.constructors)
|
|
self.assertGreater(len(ctors), 0)
|
|
ctor = ctors[0]
|
|
self.assertIsInstance(ctor, eolian.Constructor)
|
|
self.assertEqual(ctor.name, 'Efl.Ui.Win.win_name')
|
|
self.assertFalse(ctor.is_optional)
|
|
self.assertIsInstance(ctor.class_, eolian.Class)
|
|
self.assertEqual(ctor.class_.name, 'Efl.Ui.Win')
|
|
self.assertIsInstance(ctor.function, eolian.Function)
|
|
self.assertEqual(ctor.function.name, 'win_name')
|
|
|
|
|
|
class TestEolianDocumentation(unittest.TestCase):
|
|
def test_documentation(self):
|
|
td = eolian_db.class_by_name_get('Efl.Net.Control.Manager')
|
|
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')
|
|
|
|
|
|
class TestEolianVariable(unittest.TestCase):
|
|
def test_variable_global(self):
|
|
var = eolian_db.global_by_name_get('Efl.Net.Http.Error.BAD_CONTENT_ENCODING')
|
|
self.assertIsInstance(var, eolian.Variable)
|
|
self.assertEqual(var.name, 'Efl.Net.Http.Error.BAD_CONTENT_ENCODING')
|
|
self.assertEqual(var.short_name, 'BAD_CONTENT_ENCODING')
|
|
self.assertEqual(var.type, eolian.Eolian_Variable_Type.GLOBAL)
|
|
self.assertEqual(var.file, 'efl_net_http_types.eot')
|
|
self.assertFalse(var.is_extern)
|
|
self.assertEqual(list(var.namespaces), ['Efl','Net','Http','Error'])
|
|
self.assertIsInstance(var.documentation, eolian.Documentation)
|
|
self.assertIsInstance(var.base_type, eolian.Type)
|
|
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')
|
|
self.assertIsInstance(var, eolian.Variable)
|
|
self.assertEqual(var.name, 'Efl.Gfx.Hint_Fill')
|
|
self.assertEqual(var.short_name, 'Size_Hint_Fill')
|
|
self.assertEqual(var.type, eolian.Eolian_Variable_Type.CONSTANT)
|
|
self.assertEqual(var.file, 'efl_gfx_hint.eo')
|
|
self.assertFalse(var.is_extern)
|
|
self.assertEqual(list(var.namespaces), ['Efl','Gfx'])
|
|
self.assertIsInstance(var.documentation, eolian.Documentation)
|
|
self.assertIsInstance(var.base_type, eolian.Type)
|
|
self.assertIsInstance(var.value, eolian.Expression)
|
|
self.assertEqual(float(var.value.serialize), +1.0)
|
|
|
|
|
|
class TestEolianTypedecl(unittest.TestCase):
|
|
def test_typedecl_enum(self):
|
|
td = eolian_db.enum_by_name_get('Efl.Net.Http.Version')
|
|
self.assertIsInstance(td, eolian.Typedecl)
|
|
self.assertEqual(td.name, 'Efl.Net.Http.Version')
|
|
self.assertEqual(td.short_name, 'Version')
|
|
self.assertEqual(td.file, 'efl_net_http_types.eot')
|
|
self.assertEqual(list(td.namespaces), ['Efl','Net','Http'])
|
|
self.assertIsInstance(td.documentation, eolian.Documentation)
|
|
self.assertIsNone(td.base_type) # TODO find a better test
|
|
self.assertIsNone(td.free_func) # TODO find a better test
|
|
self.assertIsNone(td.function_pointer) # TODO find a better test
|
|
self.assertFalse(td.is_extern)
|
|
self.assertEqual(len(list(td.enum_fields)), 3)
|
|
self.assertEqual(td.c_type, 'enum Efl_Net_Http_Version { v1_0 = 100, v1_1 = 101, v2_0 = 200 }')
|
|
|
|
def test_typedecl_enum_field(self):
|
|
td = eolian_db.enum_by_name_get('Efl.Net.Http.Version')
|
|
field = td.enum_field_get('v1_0')
|
|
self.assertIsInstance(field, eolian.Enum_Type_Field)
|
|
self.assertEqual(field.name, 'v1_0')
|
|
self.assertEqual(field.c_constant, 'EFL_NET_HTTP_VERSION_V1_0')
|
|
self.assertIsInstance(field.documentation, eolian.Documentation)
|
|
self.assertIsInstance(field.value, eolian.Expression)
|
|
|
|
def test_typedecl_struct(self):
|
|
td = eolian_db.struct_by_name_get('Efl.Gfx.Color32')
|
|
self.assertIsInstance(td, eolian.Typedecl)
|
|
self.assertEqual(td.name, 'Efl.Gfx.Color32')
|
|
self.assertEqual(td.short_name, 'Color32')
|
|
self.assertEqual(td.file, 'efl_canvas_filter_internal.eo')
|
|
self.assertEqual(list(td.namespaces), ['Efl','Gfx'])
|
|
self.assertIsInstance(td.documentation, eolian.Documentation)
|
|
self.assertIsNone(td.base_type) # TODO find a better test
|
|
self.assertIsNone(td.free_func) # TODO find a better test
|
|
self.assertIsNone(td.function_pointer) # TODO find a better test
|
|
self.assertFalse(td.is_extern)
|
|
self.assertEqual(len(list(td.struct_fields)), 4)
|
|
self.assertEqual(td.c_type, 'struct Efl_Gfx_Color32 { uint8_t r; uint8_t g; uint8_t b; uint8_t a; }')
|
|
|
|
def test_typedecl_struct_field(self):
|
|
td = eolian_db.struct_by_name_get('Efl.Gfx.Color32')
|
|
field = td.struct_field_get('b')
|
|
self.assertIsInstance(field, eolian.Struct_Type_Field)
|
|
self.assertEqual(field.name, 'b')
|
|
self.assertIsInstance(field.type, eolian.Type)
|
|
self.assertIsInstance(field.documentation, eolian.Documentation)
|
|
|
|
def test_typedecl_alias(self):
|
|
alias = eolian_db.alias_by_name_get('Eina.Error')
|
|
self.assertIsInstance(alias, eolian.Typedecl)
|
|
self.assertEqual(alias.type, eolian.Eolian_Typedecl_Type.ALIAS)
|
|
self.assertEqual(alias.name, 'Eina.Error')
|
|
self.assertEqual(alias.short_name, 'Error')
|
|
self.assertIsInstance(alias.aliased_base, eolian.Type)
|
|
self.assertEqual(alias.aliased_base.name, 'int')
|
|
self.assertEqual(alias.c_type, 'typedef int Eina_Error')
|
|
|
|
|
|
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')
|
|
param = list(func.parameters)[0]
|
|
t = param.type # type: double
|
|
self.assertIsInstance(t, eolian.Type)
|
|
self.assertEqual(t.name, 'double')
|
|
self.assertEqual(t.short_name, 'double')
|
|
self.assertEqual(t.type, eolian.Eolian_Type_Type.REGULAR)
|
|
self.assertEqual(t.builtin_type, eolian.Eolian_Type_Builtin_Type.DOUBLE)
|
|
self.assertEqual(t.file, 'efl_loop_timer.eo') # TODO is this correct ?
|
|
self.assertIsNone(t.base_type) # TODO find a better test
|
|
self.assertIsNone(t.next_type) # TODO find a better test
|
|
self.assertFalse(t.is_owned)
|
|
self.assertFalse(t.is_const)
|
|
self.assertFalse(t.is_ptr)
|
|
self.assertEqual(list(t.namespaces), [])
|
|
self.assertIsNone(t.class_)
|
|
self.assertEqual(t, t.aliased_base) # TODO find a better test
|
|
|
|
self.assertEqual(t.c_type_default, 'double') # TODO find a better test
|
|
self.assertEqual(t.c_type_param, 'double')
|
|
self.assertEqual(t.c_type_return, 'double')
|
|
|
|
def test_type_regular(self):
|
|
cls = eolian_db.class_by_name_get('Efl.Gfx.Entity')
|
|
func = cls.function_by_name_get('geometry')
|
|
param = list(func.setter_values)[0]
|
|
t = param.type # type: Eina.Rect
|
|
self.assertIsInstance(t, eolian.Type)
|
|
self.assertEqual(t.name, 'Eina.Rect')
|
|
self.assertEqual(t.short_name, 'Rect')
|
|
self.assertEqual(t.type, eolian.Eolian_Type_Type.REGULAR)
|
|
self.assertEqual(t.builtin_type, eolian.Eolian_Type_Builtin_Type.INVALID)
|
|
self.assertEqual(t.file, 'efl_gfx_entity.eo') # TODO is this correct ?
|
|
self.assertEqual(list(t.namespaces), ['Eina'])
|
|
self.assertIsNone(t.class_)
|
|
self.assertEqual(t, t.aliased_base)
|
|
|
|
self.assertEqual(t.c_type_default, 'Eina_Rect') # TODO find a better test
|
|
self.assertEqual(t.c_type_param, 'Eina_Rect')
|
|
self.assertEqual(t.c_type_return, 'Eina_Rect')
|
|
|
|
td = t.typedecl
|
|
self.assertIsInstance(td, eolian.Typedecl)
|
|
self.assertEqual(td.name, 'Eina.Rect')
|
|
|
|
def test_type_class(self):
|
|
cls = eolian_db.class_by_name_get('Efl.Content')
|
|
func = cls.function_by_name_get('content')
|
|
param = list(func.setter_values)[0]
|
|
t = param.type # type: Efl.Gfx (class interface)
|
|
self.assertIsInstance(t, eolian.Type)
|
|
self.assertEqual(t.name, 'Efl.Gfx.Entity')
|
|
self.assertEqual(t.short_name, 'Entity')
|
|
self.assertEqual(t.type, eolian.Eolian_Type_Type.CLASS)
|
|
self.assertEqual(t.builtin_type, eolian.Eolian_Type_Builtin_Type.INVALID)
|
|
self.assertEqual(t.file, 'efl_content.eo') # TODO is this correct ?
|
|
self.assertEqual(list(t.namespaces), ['Efl', 'Gfx'])
|
|
self.assertEqual(t, t.aliased_base)
|
|
|
|
self.assertEqual(t.c_type_default, 'Efl_Gfx_Entity *') # TODO find a better test
|
|
self.assertEqual(t.c_type_param, 'Efl_Gfx_Entity *')
|
|
self.assertEqual(t.c_type_return, 'Efl_Gfx_Entity *')
|
|
|
|
cls = t.class_
|
|
self.assertIsInstance(cls, eolian.Class)
|
|
self.assertEqual(cls.name, 'Efl.Gfx.Entity')
|
|
|
|
|
|
class TestEolianExpression(unittest.TestCase):
|
|
def test_expression_simple(self):
|
|
td = eolian_db.enum_by_name_get('Efl.Net.Http.Version')
|
|
field = td.enum_field_get('v1_0')
|
|
exp = field.value
|
|
self.assertIsInstance(exp, eolian.Expression)
|
|
self.assertEqual(exp.type, eolian.Eolian_Expression_Type.INT)
|
|
self.assertEqual(exp.serialize, '100')
|
|
|
|
def test_expression_unary(self):
|
|
var = eolian_db.constant_by_name_get('Efl.Gfx.Hint_Fill')
|
|
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)
|
|
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)
|
|
|
|
# TODO test_expression_binary
|
|
# exp.binary_operator # TODO find a better test (only works for BINARY expr)
|
|
# exp.binary_lhs # TODO find a better test (only works for BINARY expr)
|
|
# exp.binary_rhs # TODO find a better test (only works for BINARY expr)
|
|
|
|
|
|
|
|
if __name__ == '__main__':
|
|
# create main eolian state
|
|
eolian_db = eolian.Eolian_State()
|
|
if not isinstance(eolian_db, eolian.Eolian_State):
|
|
raise(RuntimeError('Eolian, failed to create Eolian state'))
|
|
|
|
# eolian system scan (BROKEN)
|
|
# if not eolian_db.system_directory_add():
|
|
# raise(RuntimeError('Eolian, failed to scan system directories'))
|
|
|
|
# eolian source tree scan
|
|
if not eolian_db.directory_add(SCAN_FOLDER):
|
|
raise(RuntimeError('Eolian, failed to scan source directory'))
|
|
|
|
# Parse all known eo files
|
|
if not eolian_db.all_eot_files_parse():
|
|
raise(RuntimeError('Eolian, failed to parse all EOT files'))
|
|
|
|
if not eolian_db.all_eo_files_parse():
|
|
raise(RuntimeError('Eolian, failed to parse all EO files'))
|
|
|
|
# start the test suite
|
|
suite = unittest.main(verbosity=2, exit=False)
|
|
|
|
# cleanup (or it will segfault on gc, that happend after atexit)
|
|
del eolian_db
|
|
|
|
# exit 0 (success) or 1 (failure)
|
|
exit(0 if suite.result.wasSuccessful() else 1)
|