commit d05a2fd5a85891e27ab15cd3fd18e3eb4389813a Author: stubbfel Date: Mon Oct 23 00:39:59 2017 +0200 init diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..6fa6af8 --- /dev/null +++ b/.gitignore @@ -0,0 +1,173 @@ + +# Created by https://www.gitignore.io/api/python,pycharm + +### PyCharm ### +# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio and Webstorm +# Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839 + +# User-specific stuff: +.idea/**/workspace.xml +.idea/**/tasks.xml +.idea/dictionaries + +# Sensitive or high-churn files: +.idea/**/dataSources/ +.idea/**/dataSources.ids +.idea/**/dataSources.xml +.idea/**/dataSources.local.xml +.idea/**/sqlDataSources.xml +.idea/**/dynamic.xml +.idea/**/uiDesigner.xml + +# Gradle: +.idea/**/gradle.xml +.idea/**/libraries + +# CMake +cmake-build-debug/ + +# Mongo Explorer plugin: +.idea/**/mongoSettings.xml + +## File-based project format: +*.iws + +## Plugin-specific files: + +# IntelliJ +/out/ + +# mpeltonen/sbt-idea plugin +.idea_modules/ + +# JIRA plugin +atlassian-ide-plugin.xml + +# Cursive Clojure plugin +.idea/replstate.xml + +# Ruby plugin and RubyMine +/.rakeTasks + +# Crashlytics plugin (for Android Studio and IntelliJ) +com_crashlytics_export_strings.xml +crashlytics.properties +crashlytics-build.properties +fabric.properties + +### PyCharm Patch ### +# Comment Reason: https://github.com/joeblau/gitignore.io/issues/186#issuecomment-215987721 + +# *.iml +# modules.xml +# .idea/misc.xml +# *.ipr + +# Sonarlint plugin +.idea/sonarlint + +### Python ### +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] +*$py.class + +# C extensions +*.so + +# Distribution / packaging +.Python +build/ +develop-eggs/ +dist/ +downloads/ +eggs/ +.eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +wheels/ +*.egg-info/ +.installed.cfg +*.egg + +# PyInstaller +# Usually these files are written by a python script from a template +# before PyInstaller builds the exe, so as to inject date/other infos into it. +*.manifest +*.spec + +# Installer logs +pip-log.txt +pip-delete-this-directory.txt + +# Unit test / coverage reports +htmlcov/ +.tox/ +.coverage +.coverage.* +.cache +nosetests.xml +coverage.xml +*.cover +.hypothesis/ + +# Translations +*.mo +*.pot + +# Django stuff: +*.log +local_settings.py + +# Flask stuff: +instance/ +.webassets-cache + +# Scrapy stuff: +.scrapy + +# Sphinx documentation +docs/_build/ + +# PyBuilder +target/ + +# Jupyter Notebook +.ipynb_checkpoints + +# pyenv +.python-version + +# celery beat schedule file +celerybeat-schedule + +# SageMath parsed files +*.sage.py + +# Environments +.env +.venv +env/ +venv/ +ENV/ +env.bak/ +venv.bak/ + +# Spyder project settings +.spyderproject +.spyproject + +# Rope project settings +.ropeproject + +# mkdocs documentation +/site + +# mypy +.mypy_cache/ + +# End of https://www.gitignore.io/api/python,pycharm + diff --git a/.idea/misc.xml b/.idea/misc.xml new file mode 100644 index 0000000..c3c95b5 --- /dev/null +++ b/.idea/misc.xml @@ -0,0 +1,4 @@ + + + + \ No newline at end of file diff --git a/.idea/modules.xml b/.idea/modules.xml new file mode 100644 index 0000000..6586b6e --- /dev/null +++ b/.idea/modules.xml @@ -0,0 +1,8 @@ + + + + + + + + \ No newline at end of file diff --git a/.idea/typefs.iml b/.idea/typefs.iml new file mode 100644 index 0000000..d0fbe74 --- /dev/null +++ b/.idea/typefs.iml @@ -0,0 +1,13 @@ + + + + + + + + + + + + \ No newline at end of file diff --git a/example/namespace_1/type_1/1.member b/example/namespace_1/type_1/1.member new file mode 120000 index 0000000..b29a05c --- /dev/null +++ b/example/namespace_1/type_1/1.member @@ -0,0 +1 @@ +../../basetypes/int \ No newline at end of file diff --git a/example/namespace_1/type_1/2.member b/example/namespace_1/type_1/2.member new file mode 120000 index 0000000..9f4152c --- /dev/null +++ b/example/namespace_1/type_1/2.member @@ -0,0 +1 @@ +../../myApp/myType \ No newline at end of file diff --git a/example/system/int/snippet.c b/example/system/int/snippet.c new file mode 100644 index 0000000..e69de29 diff --git a/example/system/int/snippet.cpp b/example/system/int/snippet.cpp new file mode 100644 index 0000000..e69de29 diff --git a/example/system/int/snippet.cs b/example/system/int/snippet.cs new file mode 100644 index 0000000..e69de29 diff --git a/example/system/int/snippet.py b/example/system/int/snippet.py new file mode 100644 index 0000000..e69de29 diff --git a/src/typefs/__init__.py b/src/typefs/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/typefs/generator/__init__.py b/src/typefs/generator/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/typefs/generator/code/__init__.py b/src/typefs/generator/code/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/typefs/generator/code/base.py b/src/typefs/generator/code/base.py new file mode 100644 index 0000000..e69de29 diff --git a/src/typefs/generator/code/c.py b/src/typefs/generator/code/c.py new file mode 100644 index 0000000..44b1ec9 --- /dev/null +++ b/src/typefs/generator/code/c.py @@ -0,0 +1,23 @@ + + +c_object_type_template = """ +#ifndef {TYPE_NAME_UPPER}_T_H +#define {TYPE_NAME_UPPER}_T_H + +{includes} + +#pragma pack(push, 1) + +typedef struct {type_name_lower}_sTag +{ + {members} +} {type_name_lower}_s, *ptr_{type_name_lower}_s; + +#pragma pack(pop) + +#endif // TYPE_NAME_UPPER_T_H +""" + +c_value_type_template = """ +tbd +""" \ No newline at end of file diff --git a/src/typefs/generator/code/cpp.py b/src/typefs/generator/code/cpp.py new file mode 100644 index 0000000..e69de29 diff --git a/src/typefs/generator/code/cs.py b/src/typefs/generator/code/cs.py new file mode 100644 index 0000000..e69de29 diff --git a/src/typefs/generator/code/python.py b/src/typefs/generator/code/python.py new file mode 100644 index 0000000..e69de29 diff --git a/src/typefs/generator/fs/__init__.py b/src/typefs/generator/fs/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/typefs/generator/object/__init__.py b/src/typefs/generator/object/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/typefs/generator/object/base.py b/src/typefs/generator/object/base.py new file mode 100644 index 0000000..36cc8e1 --- /dev/null +++ b/src/typefs/generator/object/base.py @@ -0,0 +1,3 @@ +class ObjectGenerator: + def __init__(self): + pass \ No newline at end of file diff --git a/src/typefs/generator/object/json.py b/src/typefs/generator/object/json.py new file mode 100644 index 0000000..701f11c --- /dev/null +++ b/src/typefs/generator/object/json.py @@ -0,0 +1,78 @@ +from typefs.member import Member +from typefs.type import Type +from typefs.namespace import Namespace + + +def create_type(name, type_value_json): + """ + + :param name: str + :param type_value_json: dict + :return: Type + """ + members = create_members(type_value_json.get("members", {})) + meta_info = type_value_json.get("meta") + return Type(name, members, meta_info) + + +def create_types(types_json): + """ + + :param types_json: dict + :return: Type[] + """ + type_list = [] + for type_name, type_json in types_json.iteritems(): + type_list.append(create_type(type_name, type_json)) + + return type_list + + +def create_members(members_json): + """ + + :param members_json: dict + :return: Member[] + """ + member_list = [] + for member_name, member_json in members_json.iteritems(): + member_list.append(create_member(member_name, member_json)) + + return member_list + + +def create_member(name, member_value_json): + """ + + :param name: str + :param member_value_json: dict + :return: Member + """ + types = create_types(member_value_json["type"]) + member_order = member_value_json.get("order", 0) + return Member(name, types[0], member_order) + + +def create_namespace(name, namespace_value_json): + """ + + :param name: str + :param namespace_value_json: dict + :return: Namespace + """ + types = create_types(namespace_value_json) + return Namespace(name, types) + + +def create_namespaces(namespaces_json): + """ + + :param namespaces_json: dict + :return: Namespace[] + """ + namespaces_list = [] + for namespace_name, namespace_json in namespaces_json.iteritems(): + namespaces_list.append(create_namespace(namespace_name, namespace_json)) + + return namespaces_list + diff --git a/src/typefs/member.py b/src/typefs/member.py new file mode 100644 index 0000000..a6f440d --- /dev/null +++ b/src/typefs/member.py @@ -0,0 +1,52 @@ +from name import Name + + +class Member(Name): + def __init__(self, name, member_type=None, member_order=0): + """ + + :param name: typefs.name.Name + :param member_type: typefs.type.Type + """ + Name.__init__(self, name) + self.__member_type = member_type + self.__member_order = member_order + + def is_type_of(self): + return self.__member_type + + def __eq__(self, other): + return Name.__eq__(self, other) and self.__member_type == other.__member_type \ + and self.__member_order == other.__member_order + + def __lt__(self, other): + """ + + :param other: typefs.member.Member + :return: bool + """ + return self.__member_order < other.__member_order + + def __le__(self, other): + """ + + :param other: typefs.member.Member + :return: bool + """ + return self.__member_order <= other.__member_order + + def __gt__(self, other): + """ + + :param other: typefs.member.Member + :return: bool + """ + return self.__member_order > other.__member_order + + def __ge__(self, other): + """ + + :param other: typefs.member.Member + :return: bool + """ + return self.__member_order >= other.__member_order \ No newline at end of file diff --git a/src/typefs/name.py b/src/typefs/name.py new file mode 100644 index 0000000..168bc8d --- /dev/null +++ b/src/typefs/name.py @@ -0,0 +1,33 @@ +import util.operator + + +class Name: + def __init__(self, value_string): + """ + + :param value_string: object which support str() + """ + self.__value_string = str(value_string) + + def __str__(self): + """ + + :return: str + """ + return self.__value_string + + def __eq__(self, other): + """ + + :param other: typefs.name.Name + :return: bool + """ + return type(self) == type(other) and (self.__value_string == other.__value_string) + + def __ne__(self, other): + """ + + :param other: typefs.name.Name + :return: bool + """ + return not self == other diff --git a/src/typefs/namespace.py b/src/typefs/namespace.py new file mode 100644 index 0000000..b0da9fb --- /dev/null +++ b/src/typefs/namespace.py @@ -0,0 +1,41 @@ +import util.list +from name import Name + + +class Namespace(Name): + def __init__(self, name, type_list): + """ + + :param name: typefs.name.Name + :param type_list: typefs.type.Type[] + """ + Name.__init__(self, name) + self.__type_list = type_list + + def add_type(self, new_type): + """ + + :param new_type: typefs.type.Type + :return: typefs.namespace.Namespace + """ + def new_namespace(): + return Namespace(self, util.list.append(self.__type_list, new_type)) + + return util.list.contains_value(self.__type_list, new_type, lambda: self, new_namespace) + + def remove_type(self, delete_type): + """ + + :param delete_type: typefs.type.Type + :return: typefs.namespace.Namespace + """ + return Namespace(self, util.list.remove(self.__type_list, delete_type)) + + def __len__(self): + return len(self.__type_list) + + def __eq__(self, other): + return Name.__eq__(self, other) and len(self) == len(other) + + def __getitem__(self, item): + return self.__type_list[item] diff --git a/src/typefs/type.py b/src/typefs/type.py new file mode 100644 index 0000000..531991c --- /dev/null +++ b/src/typefs/type.py @@ -0,0 +1,50 @@ +import util.operator +import util.list +from name import Name + + +class Type(Name): + def __init__(self, name, member_list=None, meta_info=None): + """ + + :type meta_info: dict + :param name: typefs.name.Name + :param member_list: typefs.member.Member[] + """ + Name.__init__(self, name) + self.__member_list = None + self.__meta_info = None + self.__member_list = util.operator.assign(lambda: member_list is None, lambda: [], lambda: member_list) + self.__meta_info = util.operator.assign(lambda: meta_info is None, lambda: {}, lambda: meta_info) + + def add_member(self, new_member): + """ + + :param new_member: typefs.member.Member + :return: typefs.type.Type + """ + + def new_type(): + return Type(self, util.list.append(self.__member_list, new_member), dict(self.__member_list)) + + return util.list.contains_value(self.__member_list, new_member, lambda: self, new_type) + + def remove_member(self, delete_member): + """ + + :param delete_member: typefs.member.Member + :return: typefs.type.Type + """ + return Type(self, util.list.remove(self.__member_list, delete_member), dict(self.__meta_info)) + + def __eq__(self, other): + return Name.__eq__(self, other) and len(self) == len(other) + + def __len__(self): + return len(self.__member_list) + + def __iter__(self): + iter(self.__member_list) + + def __getitem__(self, item): + return self.__member_list[item] \ No newline at end of file diff --git a/src/typefs/util/__init__.py b/src/typefs/util/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/typefs/util/list.py b/src/typefs/util/list.py new file mode 100644 index 0000000..b0bc647 --- /dev/null +++ b/src/typefs/util/list.py @@ -0,0 +1,96 @@ + +def contains_value_bool(object_list, compare_object): + """ + + :param object_list: object[] + :param compare_object: object + :return: + """ + return contains_value(object_list, compare_object, lambda: True, lambda: False) + + +def contains_ref_bool(object_list, compare_object): + """ + + :param object_list: object[] + :param compare_object: object + :return: + """ + return contains_ref(object_list, compare_object, lambda: True, lambda: False) + + +def contains_value(object_list, compare_object, create_is_in_result, create_is_not_in_result): + """ + + :param object_list: object[] + :param compare_object: object + :param create_is_in_result: () -> object + :param create_is_not_in_result: () -> object + :return: + """ + return contains(object_list, compare_object, lambda x, y: x == y, create_is_in_result, create_is_not_in_result) + + +def contains_ref(object_list, compare_object, create_is_in_result, create_is_not_in_result): + """ + + :param object_list: object[] + :param compare_object: object + :param create_is_in_result: () -> object + :param create_is_not_in_result: () -> object + :return: + """ + return contains(object_list, compare_object, lambda x, y: x is y, create_is_in_result, create_is_not_in_result) + + +def contains(object_list, compare_object, compare, create_is_in_result, create_is_not_in_result): + """ + :param object_list: object[] + :param compare_object: object + :param compare: (object, object) -> bool + :param create_is_in_result: () -> object + :param create_is_not_in_result: () -> object + :return : object + """ + for list_item in object_list: + if compare(list_item, compare_object): + return create_is_in_result() + + return create_is_not_in_result() + + +def modify(object_list, modify_action): + """ + + :param object_list: object[] + :param modify_action: (object[]) -> None + :return: object[] + """ + new_list = list(object_list) + try: + + modify_action(new_list) + except ValueError: + pass + + return new_list + + +def append(object_list, new_object): + """ + + :param object_list: object[] + :param new_object: object + :return: object[] + """ + return modify(object_list, lambda lst: lst.append(new_object)) + + +def remove(object_list, new_object): + """ + + :param object_list: object[] + :param new_object: object + :return: object[] + """ + return modify(object_list, lambda lst: lst.remove(new_object)) diff --git a/src/typefs/util/operator.py b/src/typefs/util/operator.py new file mode 100644 index 0000000..8b51031 --- /dev/null +++ b/src/typefs/util/operator.py @@ -0,0 +1,5 @@ +def assign(compare, condition_true_action, condition_false_action): + if compare(): + return condition_true_action() + else: + return condition_false_action() \ No newline at end of file diff --git a/test/typefs/__init__.py b/test/typefs/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/test/typefs/generator/__init__.py b/test/typefs/generator/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/test/typefs/generator/object/__init__.py b/test/typefs/generator/object/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/test/typefs/generator/object/test_json.py b/test/typefs/generator/object/test_json.py new file mode 100644 index 0000000..bf659e3 --- /dev/null +++ b/test/typefs/generator/object/test_json.py @@ -0,0 +1,70 @@ +import unittest +from typefs.member import Member +from typefs.type import Type +import typefs.generator.object.json as json_generator +from typefs.namespace import Namespace + + +class TestObjectGenerator(unittest.TestCase): + + def test_create_member(self): + json = {"member1": {"type": {"int": {"meta": {"type": "pointer"}}}, "order": 1}} + self.assertEqual([Member("member1", Type("int"), 1)], json_generator.create_members(json)) + + def test_create_type(self): + json = { + "type_1": { + "members": { + "member1": { + "type": {"int": {}}, + "order": 1 + }, + "member2": { + "order": 2, + "type": {"namespace_1.type_1": {}}, + } + }, + "meta": {} + } + } + + members = [Member("member1", Type("int"), 1), Member("member2", Type("namespace_1.type_1*"), 2)] + result_objects = json_generator.create_types(json) + self.assertEqual([Type("type_1", members)], result_objects) + self.assertEqual("type_1", str(result_objects[0])) + self.assertEqual("member1", str(result_objects[0][0])) + self.assertEqual("member2", str(result_objects[0][1])) + self.assertEqual("int", str(result_objects[0][0].is_type_of())) + self.assertEqual("namespace_1.type_1", str(result_objects[0][1].is_type_of())) + + def test_create_namespace(self): + json = { + "namespace_1": { + "type_1": { + "members": { + "member1": { + "type": {"int": {}}, + "order": 1 + }, + "member2": { + "type": {"namespace_1.type_1": {}}, + "order": 1 + } + }, + "meta": { + "c": { + "dependencies": ["#include "], + "type": "complex_type" + } + } + } + } + } + + members = [Member("member1", Type("int"), 1), Member("member2", Type("namespace_1.type_1"), 2)] + types = [Type("type_1", members)] + self.assertEqual([Namespace("namespace_1", types)], json_generator.create_namespaces(json)) + + +if __name__ == '__main__': + unittest.main() diff --git a/test/typefs/test_member.py b/test/typefs/test_member.py new file mode 100644 index 0000000..24dd7f8 --- /dev/null +++ b/test/typefs/test_member.py @@ -0,0 +1,21 @@ +import unittest +from typefs.member import Member + + +class TestMember(unittest.TestCase): + def test_order(self): + self.assertLess(Member("foo", None, 1), Member("foo", None, 2)) + self.assertLessEqual(Member("foo", None, -2), Member("foo", None, -2)) + self.assertEqual(Member("foo", None, 2), Member("foo", None, 2)) + self.assertGreaterEqual(Member("foo", None, -1), Member("foo", None, -1)) + self.assertGreater(Member("foo", None, 0), Member("foo", None, -1)) + + self.assertLess(Member("foo", None, 1), Member("bar", None, 2)) + self.assertLessEqual(Member("foo", None, -2), Member("bar", None, -2)) + self.assertNotEqual(Member("foo", None, 2), Member("bar", None, 2)) + self.assertGreaterEqual(Member("foo", None, -1), Member("bar", None, -1)) + self.assertGreater(Member("foo", None, 0), Member("bar", None, -1)) + + +if __name__ == '__main__': + unittest.main() diff --git a/test/typefs/test_name.py b/test/typefs/test_name.py new file mode 100644 index 0000000..b2d00ed --- /dev/null +++ b/test/typefs/test_name.py @@ -0,0 +1,22 @@ +import unittest +from typefs.name import Name + + +class TestName(unittest.TestCase): + + def test_to_string(self): + self.assertEqual(str(Name("foo")), "foo") + self.assertEqual(str(Name(Name("foo"))), "foo") + + def test_equal(self): + name = Name("bar") + self.assertEqual(Name("foo"), Name("foo")) + self.assertEqual(Name(Name("foo")), Name("foo")) + self.assertNotEqual(Name("foo"), Name("bar")) + self.assertNotEqual(Name(Name("foo")), Name("bar")) + self.assertIsNot(name, Name("bar")) + self.assertIs(name, name) + + +if __name__ == '__main__': + unittest.main() diff --git a/test/typefs/test_namespace.py b/test/typefs/test_namespace.py new file mode 100644 index 0000000..be12532 --- /dev/null +++ b/test/typefs/test_namespace.py @@ -0,0 +1,22 @@ +import unittest +from typefs.type import Type +from typefs.namespace import Namespace + + +class TestNamespace(unittest.TestCase): + + def test_add_member(self): + namespace = Namespace("space1", []) + test_type = Type("myType") + self.assertEqual(1, len(namespace.add_type(test_type))) + self.assertEqual(1, len(namespace.add_type(test_type).add_type(test_type))) + + def test_remove_member(self): + test_type = Type("myType") + namespace = Namespace("space1", []).add_type(test_type) + self.assertEqual(1, len(namespace.remove_type(Type("myType2")))) + self.assertEqual(0, len(namespace.remove_type(test_type))) + + +if __name__ == '__main__': + unittest.main() diff --git a/test/typefs/test_type.py b/test/typefs/test_type.py new file mode 100644 index 0000000..2d42387 --- /dev/null +++ b/test/typefs/test_type.py @@ -0,0 +1,22 @@ +import unittest +from typefs.type import Type +from typefs.member import Member + + +class TestType(unittest.TestCase): + + def test_add_member(self): + member = Member("member1") + test_type = Type("myType") + self.assertEqual(1, len(test_type.add_member(member))) + self.assertEqual(1, len(test_type.add_member(member).add_member(member))) + + def test_remove_member(self): + member = Member("member1") + test_type = Type("myType").add_member(member) + self.assertEqual(1, len(test_type.remove_member(Member("member2")))) + self.assertEqual(0, len(test_type.remove_member(member))) + + +if __name__ == '__main__': + unittest.main() diff --git a/test/typefs/util/__init__.py b/test/typefs/util/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/test/typefs/util/test_list.py b/test/typefs/util/test_list.py new file mode 100644 index 0000000..f5d5212 --- /dev/null +++ b/test/typefs/util/test_list.py @@ -0,0 +1,61 @@ +import unittest +import typefs.util.list as lst + + +class SomeObject: + def __init__(self, value=1): + self.value = value + + def __eq__(self, other): + return self.value == other.value + + def __ne__(self, other): + return not self == other + + +class TestList(unittest.TestCase): + + def setUp(self): + self.__0 = SomeObject(0) + self.__1 = SomeObject(1) + self.__2 = SomeObject(2) + self.__3 = SomeObject(3) + self.__4 = SomeObject(4) + self.__5 = SomeObject(5) + self.__23 = SomeObject(23) + self.__array1 = [self.__1, self.__2, self.__3, self.__4, self.__5] + self.__array2 = [self.__23, SomeObject(23), SomeObject(23), SomeObject(23), SomeObject(23)] + + def test_contains(self): + self.assertFalse(lst.contains(self.__array1, self.__0, lambda x, y: x == y, lambda: True, lambda: False)) + self.assertTrue(lst.contains(self.__array1, self.__1, lambda x, y: x == y, lambda: True, lambda: False)) + + def test_contains_value(self): + self.assertFalse(lst.contains_value(self.__array1, self.__0, lambda: True, lambda: False)) + self.assertTrue(lst.contains_value(self.__array1, self.__1, lambda: True, lambda: False)) + + def test_contains_value_bool(self): + self.assertFalse(lst.contains_value_bool(self.__array1, self.__0)) + self.assertTrue(lst.contains_value_bool(self.__array1, self.__1)) + + def test_contains_ref(self): + + self.assertFalse(lst.contains_ref(self.__array2, self.__0, lambda: True, lambda: False)) + self.assertTrue(lst.contains_ref(self.__array2, self.__23, lambda: True, lambda: False)) + + def test_contains_ref_bool(self): + self.assertFalse(lst.contains_ref_bool(self.__array2, self.__0)) + self.assertTrue(lst.contains_ref_bool(self.__array2, self.__23)) + + def test_modify(self): + self.assertEqual([3, 2, 1], lst.modify([1, 2, 3], lambda l: l.reverse())) + + def test_append(self): + self.assertItemsEqual([1, 2, 3, 4], lst.append([1, 2, 3], 4)) + + def test_remove(self): + self.assertItemsEqual([1, 2, 3], lst.remove([1, 2, 3, 4], 4)) + + +if __name__ == '__main__': + unittest.main() diff --git a/test/typefs/util/test_operator.py b/test/typefs/util/test_operator.py new file mode 100644 index 0000000..78d3410 --- /dev/null +++ b/test/typefs/util/test_operator.py @@ -0,0 +1,12 @@ +import unittest +import typefs.util.operator as op + + +class TestOperator(unittest.TestCase): + def test_assign(self): + self.assertFalse(op.assign(lambda: True is False, lambda: True, lambda: False)) + self.assertTrue(op.assign(lambda: True is True, lambda: True, lambda: False)) + + +if __name__ == '__main__': + unittest.main()