From d2d1313f612f081195ec017f50f0dc4f29730bac Mon Sep 17 00:00:00 2001 From: Dave Andreoli Date: Tue, 8 Oct 2019 22:50:55 +0200 Subject: [PATCH] Pyolian: rewritten tests for the pytest framework ...much more readable now, worst the pain! :) --- src/scripts/pyolian/test_eolian.py | 867 ++++++++++++++--------------- 1 file changed, 432 insertions(+), 435 deletions(-) diff --git a/src/scripts/pyolian/test_eolian.py b/src/scripts/pyolian/test_eolian.py index c6d8afe5c9..bc869c9370 100755 --- a/src/scripts/pyolian/test_eolian.py +++ b/src/scripts/pyolian/test_eolian.py @@ -1,17 +1,19 @@ #!/usr/bin/env python3 # encoding: utf-8 """ -Pyolian test suite. +Pyolian test suite +================== -Just run this file to execute the full suite. - -A return value of 0 means all test passed successfully. +to run all the tests: +> pytest test_eolian.py """ import os -import unittest +import sys -import eolian +import pytest + +from . import eolian # Use .eo files from the source tree (not the installed ones) @@ -19,207 +21,233 @@ 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 TestEolian(unittest.TestCase): +@pytest.fixture(scope='module') +def eolian_db(): + db = eolian.Eolian_State() + if not isinstance(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 db.directory_add(SCAN_FOLDER): + raise (RuntimeError('Eolian, failed to scan source directory')) + + # Parse all known eo files + if not db.all_eot_files_parse(): + raise (RuntimeError('Eolian, failed to parse all EOT files')) + + if not db.all_eo_files_parse(): + raise (RuntimeError('Eolian, failed to parse all EO files')) + + # tests are executed here + yield db + + # cleanup eolian + del db + + +class TestEolian(object): def test_file_format(self): v = eolian.file_format_version - self.assertIsInstance(v, int) - self.assertGreaterEqual(v, 1) + assert isinstance(v, int) + assert v >= 1 -class TestBaseObject(unittest.TestCase): - def test_base_object_equality(self): +class TestBaseObject(object): + def test_base_object_equality(self, eolian_db): 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) + assert isinstance(cls1, eolian.Class) + assert isinstance(cls2, eolian.Class) + assert cls1 == cls2 + assert cls1 == 'Efl.Loop_Timer' + assert cls2 == 'Efl.Loop_Timer' + assert cls1 != 'another string' + assert cls1 != 1234 + assert cls1 is not None + assert 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) + assert isinstance(enum1, eolian.Typedecl) + assert isinstance(enum2, eolian.Typedecl) + assert enum1 == enum2 + assert enum1 == 'Efl.Ui.Focus.Direction' + assert enum2 == 'Efl.Ui.Focus.Direction' + assert enum1 != 'another string' + assert enum1 != 1234 + assert enum1 is not None + assert enum1 != 0 - self.assertNotEqual(cls1, enum1) + assert cls1 != enum1 -class TestEolianState(unittest.TestCase): - def test_unit_getters(self): +class TestEolianState(object): + def test_unit_getters(self, eolian_db): count = 0 for unit in eolian_db.units: - self.assertIsInstance(unit, eolian.Eolian_Unit) - self.assertTrue(unit.file.endswith(('.eo', '.eot'))) + assert isinstance(unit, eolian.Eolian_Unit) + assert unit.file.endswith(('.eo', '.eot')) count += 1 - self.assertGreater(count, 400) + assert count > 400 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') + assert isinstance(unit, eolian.Eolian_Unit) + assert unit.file == 'efl_ui_win.eo' - def test_object_getters(self): + def test_object_getters(self, eolian_db): 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') + assert isinstance(obj, eolian.Object) + assert type(obj) != eolian.Object + assert obj.name == 'Efl.Ui.Frame' count = 0 for obj in eolian_db.objects: - self.assertIsInstance(obj, eolian.Object) - self.assertFalse(type(obj) == eolian.Object) + assert isinstance(obj, eolian.Object) + assert type(obj) != eolian.Object count += 1 - self.assertGreater(count, 800) + assert 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) + assert isinstance(obj, eolian.Object) + assert type(obj) != eolian.Object count += 1 - self.assertGreater(count, 1) + assert count > 1 - @unittest.skip('Should this return True?') - def test_integrity(self): - self.assertTrue(eolian_db.state_check()) + @pytest.mark.skip(reason='Should this return True sooner or later?') + def test_integrity(self, eolian_db): + assert eolian_db.state_check() is True -class TestEolianUnit(unittest.TestCase): - def test_unit_get(self): +class TestEolianUnit(object): + def test_unit_get(self, eolian_db): unit = eolian_db.unit_by_file_get('efl_ui_win.eo') - self.assertIsInstance(unit.state, eolian.Eolian_State) - self.assertEqual(unit.state, eolian_db) - self.assertIsInstance(unit.version, int) - self.assertGreaterEqual(unit.version, 1) + assert isinstance(unit.state, eolian.Eolian_State) + assert unit.state == eolian_db + assert isinstance(unit.version, int) + assert unit.version >= 1 - def test_file_get(self): + def test_file_get(self, eolian_db): 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') - self.assertTrue(unit.file_path.endswith('efl_ui_win.eo')) # full path can change + assert isinstance(unit, eolian.Eolian_Unit) + assert unit.file == 'efl_ui_win.eo' + assert unit.file_path.endswith('efl_ui_win.eo') # full path can change - @unittest.skip('Skipped until unit/state support is fixed') - def test_children_listing(self): + @pytest.mark.skip(reason='Skipped until unit/state support is fixed') + def test_children_listing(self, eolian_db): li = list(eolian_db.children) - self.assertGreater(len(li), 500) - self.assertIsInstance(li[0], eolian.Eolian_Unit) + assert len(li) > 500 + assert isinstance(li[0], eolian.Eolian_Unit) - def test_file_listing(self): + def test_file_listing(self, eolian_db): li = list(eolian_db.eo_file_paths) - self.assertGreater(len(li), 400) - self.assertTrue(li[0].endswith('.eo')) + assert len(li) > 400 + assert li[0].endswith('.eo') li = list(eolian_db.eo_files) - self.assertGreater(len(li), 400) - self.assertTrue(li[0].endswith('.eo')) + assert len(li) > 400 + assert li[0].endswith('.eo') li = list(eolian_db.eot_file_paths) - self.assertGreater(len(li), 10) - self.assertTrue(li[0].endswith('.eot')) + assert len(li) > 10 + assert li[0].endswith('.eot') li = list(eolian_db.eot_files) - self.assertGreater(len(li), 10) - self.assertTrue(li[0].endswith('.eot')) + assert len(li) > 10 + assert li[0].endswith('.eot') - def test_object_listing(self): + def test_object_listing(self, eolian_db): unit = eolian_db.unit_by_file_get('efl_ui_win.eo') - self.assertIsNone(unit.object_by_name_get('Efl.Ui.Frame')) + assert unit.object_by_name_get('Efl.Ui.Frame') is None 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') + assert isinstance(obj, eolian.Object) + assert type(obj) != eolian.Object + assert obj.name == 'Efl.Ui.Win' count = 0 for obj in unit.objects: - self.assertIsInstance(obj, eolian.Object) - self.assertFalse(type(obj) == eolian.Object) + assert isinstance(obj, eolian.Object) + assert type(obj) != eolian.Object count += 1 - self.assertGreater(count, 5) + assert count > 5 - def test_enum_listing(self): + def test_enum_listing(self, eolian_db): li = list(eolian_db.enums_by_file_get('efl_ui_win.eo')) - self.assertGreater(len(li), 5) - self.assertIsInstance(li[0], eolian.Typedecl) - self.assertEqual(li[0].type, eolian.Eolian_Typedecl_Type.ENUM) + assert len(li) > 5 + assert isinstance(li[0], eolian.Typedecl) + assert li[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) + assert isinstance(enum, eolian.Typedecl) + assert enum.type == eolian.Eolian_Typedecl_Type.ENUM all_count += 1 - self.assertGreater(all_count, 50) + assert all_count > 50 - def test_struct_listing(self): + def test_struct_listing(self, eolian_db): li = list(eolian_db.structs_by_file_get('eina_types.eot')) - self.assertGreater(len(li), 10) - self.assertIsInstance(li[0], eolian.Typedecl) - self.assertIn(li[0].type, ( - eolian.Eolian_Typedecl_Type.STRUCT, - eolian.Eolian_Typedecl_Type.STRUCT_OPAQUE)) + assert len(li) > 10 + assert isinstance(li[0], eolian.Typedecl) + assert li[0].type in (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)) + assert isinstance(struct, eolian.Typedecl) + assert struct.type in (eolian.Eolian_Typedecl_Type.STRUCT, + eolian.Eolian_Typedecl_Type.STRUCT_OPAQUE) all_count += 1 - self.assertGreater(all_count, 50) + assert all_count > 50 - def test_alias_listing(self): + def test_alias_listing(self, eolian_db): li = list(eolian_db.aliases_by_file_get('eina_types.eot')) - self.assertGreater(len(li), 2) - self.assertIsInstance(li[0], eolian.Typedecl) + assert len(li) > 2 + assert isinstance(li[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 ?? + assert isinstance(alias, eolian.Typedecl) + assert alias.type in (eolian.Eolian_Typedecl_Type.ALIAS, + eolian.Eolian_Typedecl_Type.FUNCTION_POINTER) # TODO is this correct ?? all_count += 1 - self.assertGreater(all_count, 10) + assert all_count > 10 - def test_constant_listing(self): + def test_constant_listing(self, eolian_db): li = list(eolian_db.constants) - self.assertGreater(len(li), 2) - self.assertIsInstance(li[0], eolian.Constant) + assert len(li) > 2 + assert isinstance(li[0], eolian.Constant) li = list(eolian_db.constants_by_file_get('efl_gfx_stack.eo')) - self.assertGreater(len(li), 1) - self.assertIsInstance(li[0], eolian.Constant) + assert len(li) > 1 + assert isinstance(li[0], eolian.Constant) - def test_class_listing(self): + def test_class_listing(self, eolian_db): all_count = 0 for cls in eolian_db.classes: - self.assertIsInstance(cls, eolian.Class) + assert isinstance(cls, eolian.Class) all_count += 1 - self.assertGreater(all_count, 400) + assert all_count > 400 -class TestEolianNamespace(unittest.TestCase): - def test_all_namespace(self): +class TestEolianNamespace(object): + def test_all_namespace(self, eolian_db): count = 0 for ns in eolian_db.all_namespaces: - self.assertIsInstance(ns, eolian.Namespace) + assert isinstance(ns, eolian.Namespace) count += 1 - self.assertGreater(count, 50) + assert count > 50 - def test_namespace_vs_class_collision(self): + def test_namespace_vs_class_collision(self, eolian_db): colliding_classes = ['Ecore.Audio', 'Ecore.Audio.In', 'Ecore.Audio.Out', @@ -238,446 +266,415 @@ class TestEolianNamespace(unittest.TestCase): cls = eolian_db.class_by_name_get(ns.name) # Some legacy classes are parsed and still make this fail. if cls: - self.assertIn(cls.name, colliding_classes) + assert cls.name in colliding_classes else: - self.assertIsNone(cls) + assert cls is None - def test_namespace_equality(self): + def test_namespace_equality(self, eolian_db): 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')) + assert isinstance(ns1, eolian.Namespace) + assert isinstance(ns2, eolian.Namespace) + assert ns1 != ns2 + assert ns1 == eolian.Namespace(eolian_db, 'Efl.Io') + assert ns2 == eolian.Namespace(eolian_db, 'Efl.Net') - def test_namespace_sorting(self): + def test_namespace_sorting(self, eolian_db): nspaces = eolian_db.all_namespaces nspaces.sort(reverse=True) - self.assertGreater(nspaces[0], nspaces[-1]) - self.assertLess(nspaces[1], nspaces[0]) + assert nspaces[0] > nspaces[-1] + assert nspaces[1] < nspaces[0] - def test_namespace_by_name(self): + def test_namespace_by_name(self, eolian_db): ns = eolian.Namespace(eolian_db, 'Efl.Net') - self.assertIsInstance(ns, eolian.Namespace) - self.assertEqual(ns.name, 'Efl.Net') - self.assertEqual(ns.namespaces, ['Efl', 'Net']) + assert isinstance(ns, eolian.Namespace) + assert ns.name == 'Efl.Net' + assert ns.namespaces == ['Efl', 'Net'] ns = eolian_db.namespace_get_by_name('Efl') - self.assertIsInstance(ns, eolian.Namespace) - self.assertEqual(ns.name, 'Efl') + assert isinstance(ns, eolian.Namespace) + assert ns.name == 'Efl' - self.assertGreater(len(ns.classes), 30) + assert len(ns.classes) > 30 for cls in ns.classes: - self.assertIsInstance(cls, eolian.Class) - self.assertGreater(len(ns.regulars), 4) + assert isinstance(cls, eolian.Class) + assert 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) + assert isinstance(cls, eolian.Class) + assert cls.type == eolian.Eolian_Class_Type.REGULAR + assert 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) + assert isinstance(cls, eolian.Class) + assert cls.type == eolian.Eolian_Class_Type.MIXIN + assert len(ns.interfaces) > 15 for cls in ns.interfaces: - self.assertIsInstance(cls, eolian.Class) - self.assertEqual(cls.type, eolian.Eolian_Class_Type.INTERFACE) + assert isinstance(cls, eolian.Class) + assert cls.type == eolian.Eolian_Class_Type.INTERFACE - self.assertGreater(len(ns.enums), 1) + assert 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) + assert isinstance(td, eolian.Typedecl) + assert td.type == eolian.Eolian_Typedecl_Type.ENUM + assert len(ns.aliases) > 0 for td in ns.aliases: - self.assertIsInstance(td, eolian.Typedecl) + assert isinstance(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) + # assert Equal(td.type, eolian.Eolian_Typedecl_Type.ALIAS) + assert len(ns.structs) > 2 for td in ns.structs: - self.assertIsInstance(td, eolian.Typedecl) - self.assertEqual(td.type, eolian.Eolian_Typedecl_Type.STRUCT) + assert isinstance(td, eolian.Typedecl) + assert td.type == eolian.Eolian_Typedecl_Type.STRUCT -class TestEolianObject(unittest.TestCase): - def test_object_instance(self): +class TestEolianObject(object): + def test_object_instance(self, eolian_db): obj = eolian_db.object_by_name_get('Efl.Ui.Frame') - self.assertIsInstance(obj, eolian.Class) - self.assertEqual(obj.name, 'Efl.Ui.Frame') + assert isinstance(obj, eolian.Class) + assert obj.name == 'Efl.Ui.Frame' - def test_unit(self): + def test_unit(self, eolian_db): 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') + assert isinstance(obj.unit, eolian.Eolian_Unit) + assert obj.unit.file == 'efl_ui_frame.eo' - def test_name(self): + def test_name(self, eolian_db): obj = eolian_db.object_by_name_get('Efl.Ui.Frame') - self.assertEqual(obj.name, 'Efl.Ui.Frame') - self.assertEqual(obj.c_name, 'Efl_Ui_Frame') + assert obj.name == 'Efl.Ui.Frame' + assert obj.c_name == 'Efl_Ui_Frame' - def test_short_name(self): + def test_short_name(self, eolian_db): obj = eolian_db.object_by_name_get('Efl.Ui.Frame') - self.assertEqual(obj.short_name, 'Frame') + assert obj.short_name == 'Frame' - def test_file(self): + def test_file(self, eolian_db): obj = eolian_db.object_by_name_get('Efl.Ui.Frame') - self.assertEqual(obj.file, 'efl_ui_frame.eo') - - def test_line(self): + assert obj.file == 'efl_ui_frame.eo' + + def test_line(self, eolian_db): obj = eolian_db.object_by_name_get('Efl.Ui.Frame') - self.assertIsInstance(obj.line, int) - self.assertGreater(obj.line, 0) + assert isinstance(obj.line, int) + assert obj.line > 0 - def test_column(self): + def test_column(self, eolian_db): obj = eolian_db.object_by_name_get('Efl.Ui.Frame') - self.assertIsInstance(obj.column, int) - self.assertGreater(obj.column, 0) + assert isinstance(obj.column, int) + assert obj.column > 0 -class TestEolianClass(unittest.TestCase): - def test_class(self): +class TestEolianClass(object): + def test_class(self, eolian_db): cls = eolian_db.class_by_file_get('efl_loop_timer.eo') - self.assertIsInstance(cls, eolian.Class) + assert isinstance(cls, eolian.Class) cls = eolian_db.class_by_name_get('Efl.Loop_Timer') - self.assertIsInstance(cls, eolian.Class) + assert isinstance(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.assertIsNone(cls.c_prefix) # TODO fin a class with a value - self.assertIsNone(cls.event_c_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], ['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) + assert cls.name == 'Efl.Loop_Timer' + assert cls.short_name == 'Loop_Timer' + assert cls.file == 'efl_loop_timer.eo' + assert list(cls.namespaces) == ['Efl'] + assert cls.type == eolian.Eolian_Class_Type.REGULAR + assert isinstance(cls.documentation, eolian.Documentation) + assert cls.c_prefix is None # TODO fin a class with a value + assert cls.event_c_prefix is None # TODO same as above + assert cls.data_type is None # TODO same as above + assert cls.parent.name == 'Efl.Loop_Consumer' + assert [c.name for c in cls.extensions] == [] + assert [c.name for c in cls.hierarchy] == ['Efl.Loop_Consumer', 'Efl.Object'] + assert cls.ctor_enable is False + assert cls.dtor_enable is False + assert cls.c_get_function_name == 'efl_loop_timer_class_get' + assert cls.c_macro == 'EFL_LOOP_TIMER_CLASS' + assert cls.c_data_type == 'Efl_Loop_Timer_Data' + assert [f.name for f in cls.methods] == ['timer_reset', 'timer_loop_reset', 'timer_delay'] + assert [f.name for f in cls.properties] == ['timer_interval', 'time_pending'] + assert len(list(cls.implements)) > 5 + assert isinstance(list(cls.implements)[0], eolian.Implement) -class TestEolianFunction(unittest.TestCase): - def test_function(self): +class TestEolianFunction(object): + def test_function(self, eolian_db): cls = eolian_db.class_by_name_get('Efl.Loop_Timer') f = cls.function_by_name_get('timer_delay') - self.assertIsInstance(f, eolian.Function) - 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? - 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.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_static) - self.assertFalse(f.is_beta) - self.assertFalse(f.is_constructor(cls)) + assert isinstance(f, eolian.Function) + assert f.name == 'timer_delay' + assert f.type == eolian.Eolian_Function_Type.METHOD + assert f.method_scope == eolian.Eolian_Object_Scope.PUBLIC + assert f.getter_scope == eolian.Eolian_Object_Scope.UNKNOWN # TODO correct ? + assert f.setter_scope == eolian.Eolian_Object_Scope.UNKNOWN # TODO correct ? + assert f.full_c_method_name == 'efl_loop_timer_delay' + assert f.full_c_getter_name == 'efl_loop_timer_delay_get' + assert f.full_c_setter_name == 'efl_loop_timer_delay_set' + assert f.method_return_type is None # TODO correct ? + assert f.setter_return_type is None # TODO correct ? + assert f.getter_return_type is None # TODO correct ? + assert f.is_static is False + assert f.is_beta is False + assert f.is_constructor(cls) is False # # #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) + assert len(list(f.getter_values)) == 1 + assert len(list(f.getter_values)) == 1 + assert len(list(f.parameters)) == 1 + assert f.return_allow_unused(eolian.Eolian_Function_Type.METHOD) is True + assert f.object_is_const is False + assert f.class_.name == 'Efl.Loop_Timer' + assert isinstance(f.implement, eolian.Implement) - def test_function_parameter(self): + def test_function_parameter(self, eolian_db): cls = eolian_db.class_by_name_get('Efl.Loop_Timer') f = cls.function_by_name_get('timer_delay') p = list(f.parameters)[0] - self.assertEqual(p.direction, eolian.Eolian_Parameter_Direction.IN) - self.assertEqual(p.name, 'add') - self.assertIsNone(p.default_value) - self.assertFalse(p.is_optional) - self.assertEqual(p.type.name, 'double') - self.assertEqual(p.c_type_get(False), 'double') - self.assertEqual(p.c_type_get(True), 'double') - self.assertIsInstance(p.documentation, eolian.Documentation) + assert p.direction == eolian.Eolian_Parameter_Direction.IN + assert p.name == 'add' + assert p.default_value is None + assert p.is_optional is False + assert p.type.name == 'double' + assert p.c_type_get(False) == 'double' + assert p.c_type_get(True) == 'double' + assert isinstance(p.documentation, eolian.Documentation) -class TestEolianImplement(unittest.TestCase): - def test_implement(self): +class TestEolianImplement(object): + def test_implement(self, eolian_db): cls = eolian_db.class_by_name_get('Efl.Loop_Timer') f = cls.function_by_name_get('timer_delay') im = f.implement - self.assertIsInstance(im, eolian.Implement) - self.assertEqual(im.name, 'Efl.Loop_Timer.timer_delay') - self.assertIsInstance(im.class_, eolian.Class) - self.assertIsInstance(im.function, eolian.Function) - self.assertIsInstance(im.implementing_class, eolian.Class) - self.assertEqual(im.implementing_class.name, 'Efl.Loop_Timer') - 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) - self.assertIsNone(im.parent) + assert isinstance(im, eolian.Implement) + assert im.name == 'Efl.Loop_Timer.timer_delay' + assert isinstance(im.class_, eolian.Class) + assert isinstance(im.function, eolian.Function) + assert isinstance(im.implementing_class, eolian.Class) + assert im.implementing_class.name == 'Efl.Loop_Timer' + assert isinstance(im.documentation_get(), eolian.Documentation) # TODO is UNRESOLVED correct ? + assert im.is_auto() is False + assert im.is_empty() is False + assert im.is_pure_virtual() is False + assert im.is_prop_set is False + assert im.is_prop_get is False + assert im.is_property is False + assert im.is_method is True + assert im.parent is None - def test_implement_parent(self): + def test_implement_parent(self, eolian_db): cls = eolian_db.class_by_name_get('Efl.Ui.Button') im = [im for im in cls.implements if im.short_name == 'content_unset'][0] - self.assertIsInstance(im, eolian.Implement) - self.assertEqual(im.name, 'Efl.Content.content_unset') # TODO is this right?? - self.assertEqual(im.parent.name, 'Efl.Content.content_unset') + assert isinstance(im, eolian.Implement) + assert im.name == 'Efl.Content.content_unset' # TODO is this right?? + assert im.parent.name == 'Efl.Content.content_unset' -class TestEolianEvent(unittest.TestCase): - def test_event(self): +class TestEolianEvent(object): + def test_event(self, eolian_db): cls = eolian_db.class_by_name_get('Efl.Loop_Timer') - self.assertEqual([e.name for e in cls.events], ['timer,tick']) + assert [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, '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) - self.assertEqual(ev.scope, eolian.Eolian_Object_Scope.PUBLIC) - self.assertFalse(ev.is_beta) - self.assertFalse(ev.is_hot) - self.assertFalse(ev.is_restart) - self.assertEqual(ev.class_.name, cls.name) + assert isinstance(ev, eolian.Event) + assert ev.name == 'timer,tick' + assert ev.c_macro == 'EFL_LOOP_TIMER_EVENT_TIMER_TICK' + assert ev.type is None # TODO is this correct + assert isinstance(ev.documentation, eolian.Documentation) + assert ev.scope == eolian.Eolian_Object_Scope.PUBLIC + assert ev.is_beta is False + assert ev.is_hot is False + assert ev.is_restart is False + assert ev.class_.name == cls.name -class TestEolianPart(unittest.TestCase): - def test_part(self): +class TestEolianPart(object): + def test_part(self, eolian_db): cls = eolian_db.class_by_name_get('Efl.Ui.Popup') parts = list(cls.parts) - self.assertGreater(len(parts), 0) + assert 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) + assert part.name == 'backwall' + assert isinstance(part.class_, eolian.Class) + assert part.class_.name == 'Efl.Ui.Popup_Part_Backwall' + assert isinstance(part.documentation, eolian.Documentation) -class TestEolianConstructor(unittest.TestCase): - def test_constructor(self): +class TestEolianConstructor(object): + def test_constructor(self, eolian_db): cls = eolian_db.class_by_name_get('Efl.Ui.Win') ctors = list(cls.constructors) - self.assertGreater(len(ctors), 0) + assert len(ctors) > 0 ctor = ctors[0] - self.assertIsInstance(ctor, eolian.Constructor) - self.assertEqual(ctor.name, 'Efl.Ui.Win.win_name') - 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) - self.assertEqual(ctor.function.name, 'win_name') + assert isinstance(ctor, eolian.Constructor) + assert ctor.name == 'Efl.Ui.Win.win_name' + assert ctor.is_optional is True + assert isinstance(ctor.class_, eolian.Class) + assert ctor.class_.name == 'Efl.Ui.Win' + assert isinstance(ctor.function, eolian.Function) + assert ctor.function.name == 'win_name' -class TestEolianDocumentation(unittest.TestCase): - def test_documentation(self): +class TestEolianDocumentation(object): + def test_documentation(self, eolian_db): 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.22') + assert isinstance(doc, eolian.Documentation) + assert isinstance(doc.summary, str) + assert len(doc.summary) > 10 + assert isinstance(doc.description, str) + assert len(doc.description) > 20 + assert doc.since == '1.22' -class TestEolianConstant(unittest.TestCase): - def test_constant(self): +class TestEolianConstant(object): + def test_constant(self, eolian_db): var = eolian_db.constant_by_name_get('Efl.Gfx.Hint_Expand') - self.assertIsInstance(var, eolian.Constant) - self.assertEqual(var.name, 'Efl.Gfx.Hint_Expand') - self.assertEqual(var.short_name, 'Hint_Expand') - 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.type, eolian.Type) - self.assertIsInstance(var.value, eolian.Expression) - self.assertEqual(float(var.value.serialize), +1.0) + assert isinstance(var, eolian.Constant) + assert var.name == 'Efl.Gfx.Hint_Expand' + assert var.short_name == 'Hint_Expand' + assert var.file == 'efl_gfx_hint.eo' + assert var.is_extern is False + assert list(var.namespaces) == ['Efl', 'Gfx'] + assert isinstance(var.documentation, eolian.Documentation) + assert isinstance(var.type, eolian.Type) + assert isinstance(var.value, eolian.Expression) + assert float(var.value.serialize) == +1.0 -class TestEolianTypedecl(unittest.TestCase): - def test_typedecl_enum(self): +class TestEolianTypedecl(object): + def test_typedecl_enum(self, eolian_db): 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 }') + assert isinstance(td, eolian.Typedecl) + assert td.name == 'Efl.Net.Http.Version' + assert td.short_name == 'Version' + assert td.file == 'efl_net_http_types.eot' + assert list(td.namespaces) == ['Efl', 'Net', 'Http'] + assert isinstance(td.documentation, eolian.Documentation) + assert td.base_type is None # TODO find a better test + assert td.free_func is None # TODO find a better test + assert td.function_pointer is None # TODO find a better test + assert td.is_extern is False + assert len(list(td.enum_fields)) == 3 + assert td.c_type == 'enum Efl_Net_Http_Version { v1_0 = 100, v1_1 = 101, v2_0 = 200 }' - def test_typedecl_enum_field(self): + def test_typedecl_enum_field(self, eolian_db): 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) + assert isinstance(field, eolian.Enum_Type_Field) + assert field.name == 'v1_0' + assert field.c_constant == 'EFL_NET_HTTP_VERSION_V1_0' + assert isinstance(field.documentation, eolian.Documentation) + assert isinstance(field.value, eolian.Expression) - def test_typedecl_struct(self): + def test_typedecl_struct(self, eolian_db): 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; }') + assert isinstance(td, eolian.Typedecl) + assert td.name == 'Efl.Gfx.Color32' + assert td.short_name == 'Color32' + assert td.file == 'efl_canvas_filter_internal.eo' + assert list(td.namespaces) == ['Efl', 'Gfx'] + assert isinstance(td.documentation, eolian.Documentation) + assert td.base_type is None # TODO find a better test + assert td.free_func is None # TODO find a better test + assert td.function_pointer is None # TODO find a better test + assert td.is_extern is False + assert len(list(td.struct_fields)) == 4 + assert 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): + def test_typedecl_struct_field(self, eolian_db): 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) + assert isinstance(field, eolian.Struct_Type_Field) + assert field.name == 'b' + assert isinstance(field.type, eolian.Type) + assert isinstance(field.documentation, eolian.Documentation) - def test_typedecl_alias(self): + def test_typedecl_alias(self, eolian_db): 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') + assert isinstance(alias, eolian.Typedecl) + assert alias.type == eolian.Eolian_Typedecl_Type.ALIAS + assert alias.name == 'Eina.Error' + assert alias.short_name == 'Error' + assert isinstance(alias.aliased_base, eolian.Type) + assert alias.aliased_base.name == 'int' + assert alias.c_type == 'typedef int Eina_Error' -class TestEolianType(unittest.TestCase): - def test_type_regular_builtin(self): +class TestEolianType(object): + def test_type_regular_builtin(self, eolian_db): cls = eolian_db.class_by_name_get('Efl.Loop_Timer') func = cls.function_by_name_get('timer_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_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 + assert isinstance(t, eolian.Type) + assert t.name == 'double' + assert t.short_name == 'double' + assert t.type == eolian.Eolian_Type_Type.REGULAR + assert t.builtin_type == eolian.Eolian_Type_Builtin_Type.DOUBLE + assert t.file == 'efl_loop_timer.eo' # TODO is this correct ? + assert t.base_type is None # TODO find a better test + assert t.next_type is None # TODO find a better test + assert t.is_const is False + assert t.is_ptr is False + assert list(t.namespaces) == [] + assert t.class_ is None + assert t == t.aliased_base # TODO find a better test - def test_type_regular(self): + def test_type_regular(self, eolian_db): 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) + assert isinstance(t, eolian.Type) + assert t.name == 'Eina.Rect' + assert t.short_name == 'Rect' + assert t.type == eolian.Eolian_Type_Type.REGULAR + assert t.builtin_type == eolian.Eolian_Type_Builtin_Type.INVALID + assert t.file == 'efl_gfx_entity.eo' # TODO is this correct ? + assert list(t.namespaces) == ['Eina'] + assert t.class_ is None + assert t == t.aliased_base td = t.typedecl - self.assertIsInstance(td, eolian.Typedecl) - self.assertEqual(td.name, 'Eina.Rect') + assert isinstance(td, eolian.Typedecl) + assert td.name == 'Eina.Rect' - def test_type_class(self): + def test_type_class(self, eolian_db): 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) + assert isinstance(t, eolian.Type) + assert t.name == 'Efl.Gfx.Entity' + assert t.short_name == 'Entity' + assert t.type == eolian.Eolian_Type_Type.CLASS + assert t.builtin_type == eolian.Eolian_Type_Builtin_Type.INVALID + assert t.file == 'efl_content.eo' # TODO is this correct ? + assert list(t.namespaces) == ['Efl', 'Gfx'] + assert t == t.aliased_base cls = t.class_ - self.assertIsInstance(cls, eolian.Class) - self.assertEqual(cls.name, 'Efl.Gfx.Entity') + assert isinstance(cls, eolian.Class) + assert cls.name == 'Efl.Gfx.Entity' -class TestEolianExpression(unittest.TestCase): - def test_expression_simple(self): +class TestEolianExpression(object): + def test_expression_simple(self, eolian_db): 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') + assert isinstance(exp, eolian.Expression) + assert exp.type == eolian.Eolian_Expression_Type.INT + assert exp.serialize == '100' - def test_expression_unary(self): + def test_expression_unary(self, eolian_db): 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), 32768.0) # TODO is this a bug? isn't -1.0 ? - self.assertEqual(exp.unary_operator, eolian.Eolian_Unary_Operator.UNM) # Invalid -> NOP + assert isinstance(exp, eolian.Expression) + assert exp.type == eolian.Eolian_Expression_Type.UNARY + assert float(exp.serialize) == 32768.0 # TODO is this a bug? isn't -1.0 = + assert exp.unary_operator == eolian.Eolian_Unary_Operator.UNM # Invalid -> NO unary = exp.unary_expression - self.assertIsInstance(unary, eolian.Expression) - self.assertEqual(unary.type, eolian.Eolian_Expression_Type.INT) - self.assertEqual(float(exp.serialize), 32768.0) # Bug too? + assert isinstance(unary, eolian.Expression) + assert unary.type == eolian.Eolian_Expression_Type.INT + assert float(exp.serialize) == 32768.0 # Bug too ? # 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)