lbkit 0.5.18__tar.gz → 0.5.19__tar.gz

{lbkit-0.5.18/lbkit.egg-info → lbkit-0.5.19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lbkit
-Version: 0.5.18
+Version: 0.5.19
 Summary: Tools provided by litebmc.com
 Home-page: https://www.litebmc.com
 Author: xuhj@litebmc.com

lbkit-0.5.19/lbkit/__init__.py

@@ -0,0 +1,2 @@
+
+__version__ = '0.5.19'

{lbkit-0.5.18 → lbkit-0.5.19}/lbkit/codegen/idf_interface.py

@@ -8,6 +8,7 @@ from lbkit.codegen.renderer import Renderer
 from lbkit.codegen.ctype_defination import CTYPE_OBJS, RefObjArrayValidator, RefObjValidator
 from lbkit.misc import load_yml_with_json_schema_validate
 from lbkit.errors import OdfValidateException
+from lbkit.helper import SigInvalidException, validate_glib_signature
 
 log = Logger("gen_interface")
 
@@ -133,6 +134,7 @@ class IdfCtypeRender():
     ctype: str = None
     name: str = ""
     idf_data = None
+    default = None
     flags: list[str] = []
 
     def __init__(self):
@@ -186,20 +188,27 @@ class IdfCtypeRender():
         log.debug(f"Get odf schema info, name: {self.name}, ctype: {self.ctype}")
         if "variant" == self.ctype:
             return None
+        validator_cfg = self.validator_cfg
         match = re.match(f"^array\[({CTYPE_BASE_REG})\]$", self.ctype)
         if match:
             if "refobj" in self.flags:
                 valiator = RefObjArrayValidator()
                 return valiator.odf_schema(allow_ref)
-            ctype_obj = CTYPE_OBJS.get(self.ctype)
-            return ctype_obj.validator.odf_schema(allow_ref)
+            ctype_obj = copy.deepcopy(CTYPE_OBJS.get(self.ctype))
+            validator = ctype_obj.validator
+            if validator_cfg:
+                validator.set_validator(validator_cfg, self.name)
+            return validator.odf_schema(allow_ref)
         match = re.match(f"^({CTYPE_BASE_REG})$", self.ctype)
         if match:
             if "refobj" in self.flags:
                 valiator = RefObjValidator()
                 return valiator.odf_schema(allow_ref)
             ctype_obj = CTYPE_OBJS.get(self.ctype)
-            return ctype_obj.validator.odf_schema(allow_ref)
+            validator = ctype_obj.validator
+            if validator_cfg:
+                validator.set_validator(validator_cfg, self.name)
+            return validator.odf_schema(allow_ref)
         # 非基础类型
         is_array = False
         ctype = self.ctype
@@ -519,13 +528,11 @@ class IdfCtypeRender():
             value = self.idf_data.get("pattern")
             if value:
                 cfg["pattern"] = value
-        elif (self.ctype == "byte" or self.ctype == "array[byte]" or
-            self.ctype == "int16" or self.ctype == "array[int16]" or
-            self.ctype == "uint16" or self.ctype == "array[uint16]" or
-            self.ctype == "int32" or self.ctype == "array[int32]" or
-            self.ctype == "uint32" or self.ctype == "array[uint32]" or
-            self.ctype == "int64" or self.ctype == "array[int64]" or
-            self.ctype == "uint64" or self.ctype == "array[uint64]"):
+        elif self.ctype in ["byte", "array[byte]", "int16", "array[int16]",
+                            "uint16", "array[uint16]", "int32", "array[int32]",
+                            "uint32", "array[uint32]","int64", "array[int64]",
+                            "uint64", "array[uint64]", "size", "array[size]",
+                            "ssize", "array[ssize]"]:
             value = self.idf_data.get("max")
             if value:
                 cfg["max"] = value
@@ -596,6 +603,127 @@ class IdfProperty(IdfCtypeRender):
         else:
             self.desc_flags = " | ".join(c_flags)
 
+        self._load_default()
+
+    def _load_default(self):
+        # 只有基础类型有default值
+        match = re.match(f"^array\[({CTYPE_BASE_REG})\]$", self.ctype)
+        if not match:
+            match = re.match(f"^({CTYPE_BASE_REG})$", self.ctype)
+        if not match:
+            return
+        self.default = self.idf_data.get("default")
+        if self.default is None:
+            return
+
+        if self.ctype in ["boolean", "array[boolean]"]:
+            return
+        pattern = self.idf_data.get("pattern")
+        if pattern:
+            if self.ctype == "string":
+                match = re.match(pattern, self.default)
+                if not match:
+                    raise OdfValidateException(f"Fail to validation default value of property {self.name} with pattern \"{pattern}\", get default: {self.default}")
+                return
+            if self.ctype == "array[string]":
+                for val in self.default:
+                    match = re.match(pattern, val)
+                    if not match:
+                        raise OdfValidateException(f"Fail to validation default value of property {self.name} with pattern \"{pattern}\", get default: {val}")
+                return
+        if self.ctype == "object_path":
+            if pattern:
+                match = re.match(pattern, self.default)
+                if not match:
+                    raise OdfValidateException(f"Fail to validation default value of property {self.name} with pattern \"{pattern}\", get default: {self.default}")
+            match = re.match(f"^(/[A-Z0-9a-z_]+)+$", self.default)
+            if not match:
+                raise OdfValidateException(f"Fail to validation default value of property {self.name} with pattern \"^(/[A-Z0-9a-z_]+)+$\", get default: {self.default}")
+            return
+        if self.ctype == "array[object_path]":
+            for val in self.default:
+                if pattern:
+                    match = re.match(pattern, val)
+                    if not match:
+                        raise OdfValidateException(f"Fail to validation default value of property {self.name} with pattern \"{pattern}\", get default: {val}")
+                match = re.match(f"^(/[A-Z0-9a-z_]+)+$", val)
+                if not match:
+                    raise OdfValidateException(f"Fail to validation default value of property {self.name} with pattern \"^(/[A-Z0-9a-z_]+)+$\", get default: {val}")
+            return
+
+        if self.ctype == "signature":
+            try:
+                validate_glib_signature(self.default)
+                if pattern:
+                    match = re.match(pattern, self.default)
+                    if not match:
+                        raise OdfValidateException(f"Fail to validation default value of property {self.name} with pattern \"{pattern}\", get default: {self.default}")
+            except SigInvalidException:
+                raise OdfValidateException(f"Fail to validation default value of property {self.name}, get default: {self.default}")
+            return
+        if self.ctype == "array[oobject_path]":
+            try:
+                for val in self.default:
+                    validate_glib_signature(val)
+                    if pattern:
+                        match = re.match(pattern, self.default)
+                        if not match:
+                            raise OdfValidateException(f"Fail to validation default value of property {self.name} with pattern \"{pattern}\", get default: {self.default}")
+            except SigInvalidException:
+                raise OdfValidateException(f"Fail to validation default value of property {self.name}, get default: {self.default}")
+            return
+
+        cfg = self.validator_cfg
+        if self.ctype in ["byte", "int16", "uint16", "int32", "uint32", "size", "ssize",
+                          "int64", "uint64"]:
+            mmax = cfg.get("max")
+            if mmax is not None and mmax < self.default:
+                raise OdfValidateException(f"Fail to validation default value of property {self.name}, get default: {self.default}, max: {mmax}")
+            mmin = cfg.get("min")
+            if mmin is not None and mmin > self.default:
+                raise OdfValidateException(f"Fail to validation default value of property {self.name}, get default: {self.default}, min: {mmin}")
+            return
+        if self.ctype in ["array[byte]", "array[int16]", "array[uint16]", "array[int32]", "array[uint32]", "array[size]",
+                          "array[ssize]", "array[int64]", "array[uint64]"]:
+            for val in self.default:
+                mmax = cfg.get("max")
+                if mmax is not None and mmax < val:
+                    raise OdfValidateException(f"Fail to validation default value of property {self.name}, get default: {val}, max: {mmax}")
+                mmin = cfg.get("min")
+                if mmin is not None and mmin > val:
+                    raise OdfValidateException(f"Fail to validation default value of property {self.name}, get default: {val}, min: {mmin}")
+            return
+
+        if self.ctype == "double":
+            emax = cfg.get("exclusive_max")
+            mmax = cfg.get("max")
+            if emax is not None and emax <= self.default:
+                raise OdfValidateException(f"Fail to validation default value of property {self.name}, get default: {self.default}, eclusive_max: {emax}")
+            if mmax is not None and mmax < self.default:
+                raise OdfValidateException(f"Fail to validation default value of property {self.name}, get default: {self.default}, max: {mmax}")
+            emin = cfg.get("exclusive_min")
+            mmin = cfg.get("min")
+            if emin is not None and emin >= self.default:
+                raise OdfValidateException(f"Fail to validation default value of property {self.name}, get default: {self.default}, exclusive_min: {emin}")
+            if mmin is not None and mmin > self.default:
+                raise OdfValidateException(f"Fail to validation default value of property {self.name}, get default: {self.default}, min: {emin}")
+            return
+        if self.ctype == "array[double]":
+            for val in self.default:
+                emax = cfg.get("exclusive_max")
+                mmax = cfg.get("max")
+                if emax is not None and emax <= val:
+                    raise OdfValidateException(f"Fail to validation default value of property {self.name}, get default: {val}, eclusive_max: {emax}")
+                if mmax is not None and mmax < val:
+                    raise OdfValidateException(f"Fail to validation default value of property {self.name}, get default: {val}, max: {mmax}")
+                emin = cfg.get("exclusive_min")
+                mmin = cfg.get("min")
+                if emin is not None and emin >= val:
+                    raise OdfValidateException(f"Fail to validation default value of property {self.name}, get default: {val}, exclusive_min: {emin}")
+                if mmin is not None and mmin > val:
+                    raise OdfValidateException(f"Fail to validation default value of property {self.name}, get default: {val}, min: {emin}")
+            return
+        raise OdfValidateException(f"Only basic type(byaqiuxtdsog) support default value, Property {self.name} type is {self.ctype}")
 
     @property
     def signature(self):
@@ -819,8 +947,8 @@ class IdfDictionary():
 
 class IdfInterface(IdfInterfaceBase):
     def __init__(self, lookup, idf_file):
-        if not idf_file.endswith(".yaml"):
-            raise IDFException(f"IDF file {idf_file} not endswith .yaml")
+        if not idf_file.endswith(".yaml") and not idf_file.endswith(".yml"):
+            raise IDFException(f"IDF file {idf_file} neither endswith .yaml nor endswith .yml")
         super().__init__()
         self.lookup = lookup
         self.file = idf_file
@@ -920,7 +1048,7 @@ class IdfInterface(IdfInterfaceBase):
         # 使用schema校验数据，确保IDF文件符合格式要求，减少程序处理过程中的异常处理
         # 验证失败时抛异常，此处不用处理，由外层处理
         idf = load_yml_with_json_schema_validate(self.file, "/usr/share/litebmc/schema/idf.v1.json")
-        log.info(f"validate {self.file} successfully")
+        log.debug(f"validate {self.file} successfully")
         self.version = idf.get("version")
         self.description = idf.get("description", "")
         # 别名
@@ -974,19 +1102,17 @@ class IdfInterface(IdfInterfaceBase):
         self.structures[self.alias] = intf_stru
 
     def render_dbus_xml(self, template, out_file):
-        fd = open(out_file, "w")
 
         out = self.render(self.lookup, template, intf=self)
         hash = hashlib.sha256()
         hash.update(out.encode('utf-8'))
         self.introspect_xml_sha256 = hash.hexdigest()
         log.info("The sha256sum of interface {} is {}".format(out_file, self.introspect_xml_sha256))
-        fd.write(out)
-        fd.close()
+        with open(out_file, "w") as fd:
+            fd.write(out)
 
     def render_c_source(self, template, out_file):
-        fd = open(out_file, "w")
 
         out = self.render(self.lookup, template, intf=self)
-        fd.write(out)
-        fd.close()
+        with open(out_file, "w") as fd:
+            fd.write(out)

{lbkit-0.5.18 → lbkit-0.5.19}/lbkit/codegen/template/public.c.mako

@@ -282,7 +282,7 @@ ${name} *${name}_decode_v(GVariant *in, gsize *n)
     }
     ${name} *output = g_new0(${name}, *n);
     while (g_variant_iter_loop(&iter, "s", &str_val)) {
-        for (int i = 0; i <= ${len(enum.values.parameters)}; i++) {
+        for (int i = 0; i < ${len(enum.values.parameters)}; i++) {
             if (g_strcmp0(str_val, _${name}StrMap[i]) == 0) {
                 output[id++] = (${name})i;
             }

{lbkit-0.5.18 → lbkit-0.5.19}/lbkit/codegen/template/server.c.mako

@@ -319,6 +319,7 @@ static void _load_from_odf(yaml_document_t *doc, yaml_node_t *node, GclObject *g
  */
 GclObject *_${class_name}_create(const gchar *obj_name, gpointer opaque)
 {
+    __attribute__((unused)) gint i = 0;
     ${class_name} *obj = g_new0(${class_name}, 1);
     memcpy(obj->_base.magic, GCL_MAGIC, strlen(GCL_MAGIC) + 1);
     obj->_base.lock = g_new0(GRecMutex, 1);
@@ -326,6 +327,56 @@ GclObject *_${class_name}_create(const gchar *obj_name, gpointer opaque)
     obj->_base.name = obj_name;
     obj->_base.intf = &_${class_name}_interface;
     obj->_base.opaque = opaque;
+    % for prop in intf.properties:
+        % if prop.default:
+            % if prop.ctype == "boolean":
+                % if prop.default:
+    obj->${prop.name} = TRUE;
+                % endif
+            % elif prop.ctype in ["byte", "int16", "uint16", "int32", "uint32", "int64", "uint64", "size", "ssize", "double"]:
+                    % if prop.ctype == "uint64":
+    obj->${prop.name} = ${prop.default}UL;
+                    % elif prop.ctype == "int64":
+    obj->${prop.name} = ${prop.default}LL;
+                    % else:
+    obj->${prop.name} = ${prop.default};
+                    % endif
+            % elif prop.ctype in ["object_path", "string", "signature"]:
+    obj->${prop.name} = g_strdup("${prop.default}");
+            % elif prop.ctype == "array[boolean]":
+    i = 0;
+    obj->n_${prop.name} = ${len(prop.default)};
+    obj->${prop.name} = g_new0(gboolean, obj->n_${prop.name});
+                % for val in prop.default:
+                    % if val:
+    obj->${prop.name}[i++] = TRUE;
+                    % else:
+    obj->${prop.name}[i++] = FALSE;
+                    % endif
+                % endfor
+            % elif prop.ctype in ["array[byte]", "array[int16]", "array[uint16]", "array[int32]", "array[uint32]", "array[int64]", "array[uint64]", "array[size]", "array[ssize]", "array[double]"]:
+<% ctype = prop.ctype[6:-1]%>
+    i = 0;
+    obj->n_${prop.name} = ${len(prop.default)};
+    obj->${prop.name} = g_new0(g${ctype},  obj->n_${prop.name});
+                % for val in prop.default:
+                    % if prop.ctype == "array[uint64]":
+    obj->${prop.name}[i++] = ${val}UL;
+                    % elif prop.ctype == "array[int64]":
+    obj->${prop.name}[i++] = ${val}LL;
+                    % else:
+    obj->${prop.name}[i++] = ${val};
+                    % endif
+                % endfor
+            % elif prop.ctype in ["array[object_path]", "array[string]", "array[signature]"]:
+    i = 0;
+    obj->${prop.name} = g_new0(gchar *, ${len(prop.default) + 1});
+                % for val in prop.default:
+    obj->${prop.name}[i++] = g_strdup("${val}");
+                % endfor
+            % endif
+        % endif
+    % endfor
     return (GclObject *)obj;
 }
 

{lbkit-0.5.18 → lbkit-0.5.19}/lbkit/component/build.py

@@ -85,8 +85,8 @@ class BuildComponent():
         示例: project(gcom LANGUAGES C VERSION 0.1.0)
         """
         try:
-            fp = open("CMakeLists.txt", "r")
-            content = fp.read()
+            with open("CMakeLists.txt", "r") as fp:
+                content = fp.read()
             version = re.search("project\((.*)VERSION ([0-9][1-9]*.[0-9][1-9]*.[0-9][1-9]*)\)", content).group(2)
             return version.strip()
         except Exception as e:

lbkit-0.5.19/lbkit/helper.py

@@ -0,0 +1,96 @@
+import os
+import yaml
+import unittest
+from xml.dom import minidom, Node
+
+class Helper():
+    @staticmethod
+    def get_node_value(dom: Node, name, default=None):
+        node: minidom.Attr = dom.attributes.get(name)
+        if node is None:
+            if default is None:
+                raise Exception("Parse node failed, abort")
+            return default
+        return node.childNodes[0].nodeValue.strip()
+
+    def read_yaml(file: str, key, default=None):
+        if not os.path.isfile(file):
+            return default
+        fd = open(file, "r");
+        try:
+            data = yaml.load(fd, Loader=yaml.FullLoader)
+            for split in key.split("/", -1):
+                data = data.get(split)
+                if data is None:
+                    return default
+            return data
+        except:
+            return default
+
+
+generate_sig_chars = [
+    "y", "b", "n", "q", "i", "u", "x", "t", "h",
+    "d", "v", "s", "o", "g"]
+
+
+class SigInvalidException(Exception):
+    pass
+
+def _validate_glib_signature(sig_str, sigs):
+    if len(sigs) == 0:
+        raise SigInvalidException(f"String {sig_str} is not a valid signature str")
+    if sigs[0] in generate_sig_chars:
+        if len(sigs) > 1:
+            return _validate_glib_signature(sig_str, sigs[1:])
+        return
+    if sigs[0] == "a":
+        return _validate_glib_signature(sig_str, sigs[1:])
+    if sigs[0] in ["(", "{"]:
+        next_chr = ")"
+        if sigs[0] == "{":
+            next_chr = "}"
+
+        cnt = 0
+        next_pos = -1
+        for i, c in enumerate(sigs):
+            if c == sigs[0]:
+                cnt += 1
+            elif c == next_chr:
+                cnt -= 1
+            if cnt == 0:
+                next_pos = i
+                break
+        # 未找到下一个右括号
+        if next_pos == -1:
+            raise SigInvalidException(f"String {sig_str} is not a valid signature str")
+        # 元组()之间可以为空
+        if sigs[0] == '(' and next_pos == 1:
+            return
+        if sigs[0] == "{":
+            # 字典至少需要两个字符
+            if next_pos < 3:
+                raise SigInvalidException(f"String {sig_str} is not a valid signature str")
+            # 字典第一个签名必须是简单类型
+            if sigs[1] not in generate_sig_chars:
+                raise SigInvalidException(f"String {sig_str} is not a valid signature str")
+        _validate_glib_signature(sig_str, sigs[1:next_pos])
+        sigs = sigs[next_pos + 1:]
+        if not sigs:
+            return
+        _validate_glib_signature(sig_str, sigs)
+        return
+
+    # '}' 和 ')'及其它字符起始的认为是非法字符
+    raise SigInvalidException(f"String {sig_str} is not a valid signature str")
+
+
+def validate_glib_signature(sig_str):
+    _validate_glib_signature(sig_str, list(sig_str))
+
+
+class TestSignatureValidateClass(unittest.TestCase):
+    def test_validate_glib_signature(self):
+        validate_glib_signature("as")
+
+if __name__ == "__main__":
+    unittest.main()

{lbkit-0.5.18 → lbkit-0.5.19/lbkit.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lbkit
-Version: 0.5.18
+Version: 0.5.19
 Summary: Tools provided by litebmc.com
 Home-page: https://www.litebmc.com
 Author: xuhj@litebmc.com

{lbkit-0.5.18 → lbkit-0.5.19}/lbkit.egg-info/SOURCES.txt

@@ -45,4 +45,7 @@ lbkit/integration/build_prepare.py
 lbkit/integration/build_rootfs.py
 lbkit/integration/config.py
 lbkit/integration/task.py
-lbkit/integration/template/conanfile.py.mako
+lbkit/integration/template/conanfile.py.mako
+test/__init__.py
+test/test_codegen.py
+test/test_helper.py

{lbkit-0.5.18 → lbkit-0.5.19}/lbkit.egg-info/top_level.txt

@@ -1 +1,2 @@
 lbkit
+test

lbkit-0.5.19/test/test_codegen.py

@@ -0,0 +1,279 @@
+import unittest
+import tempfile
+import os
+import tracemalloc
+
+tracemalloc.start()
+from lbkit.codegen.idf_interface import IdfInterface, IdfProperty
+from lbkit import errors
+
+schema_dir = os.path.realpath(os.path.join(os.getcwd(), "..", "schema"))
+
+class TestCodeGenClass(unittest.TestCase):
+    tmp_file = None
+
+    @classmethod
+    def setUpClass(cls) -> None:
+        cls.tmp_file = tempfile.mktemp(prefix="idf_test", suffix=".yaml")
+        return super().setUpClass()
+
+    @classmethod
+    def tearDownClass(cls) -> None:
+        os.unlink(cls.tmp_file)
+        return super().tearDownClass()
+
+
+    def mk_interface_with_number_property(self, name, type, max, min, default_val):
+        with open(self.tmp_file, mode="w+") as fp:
+            fp.write(f"# yaml-language-server: $schema={schema_dir}/idf.v1.json\n")
+            fp.write("version: \"0.1\"\n")
+            fp.write("description: 测试接口，用于验证libgcom/gdbusplus，同时验证自动生成逻辑\n")
+            fp.write("alias: Test\n")
+            fp.write("properties:\n")
+            fp.write(f"   - name: {name}\n")
+            fp.write(f"     description: {name}\n")
+            fp.write(f"     type: {type}\n")
+            fp.write(f"     max: {max}\n")
+            fp.write(f"     min: {min}\n")
+            fp.write(f"     default: {default_val}\n")
+
+    def mk_interface_with_string_property(self, name, type, pattern, default_val):
+        with open(self.tmp_file, mode="w+") as fp:
+            fp.write(f"# yaml-language-server: $schema={schema_dir}/idf.v1.json\n")
+            fp.write("version: \"0.1\"\n")
+            fp.write("description: 测试接口，用于验证libgcom/gdbusplus，同时验证自动生成逻辑\n")
+            fp.write("alias: Test\n")
+            fp.write("properties:\n")
+            fp.write(f"   - name: {name}\n")
+            fp.write(f"     description: {name}\n")
+            fp.write(f"     type: {type}\n")
+            if pattern:
+                fp.write(f"     pattern: {pattern}\n")
+            fp.write(f"     default: {default_val}\n")
+
+    def mk_interface_with_double_property(self, name, type, default_val, max=None, min=None, exclusive_max=None, exclusive_min=None):
+        with open(self.tmp_file, mode="w+") as fp:
+            fp.write(f"# yaml-language-server: $schema={schema_dir}/idf.v1.json\n")
+            fp.write("version: \"0.1\"\n")
+            fp.write("description: 测试接口，用于验证libgcom/gdbusplus，同时验证自动生成逻辑\n")
+            fp.write("alias: Test\n")
+            fp.write("properties:\n")
+            fp.write(f"   - name: {name}\n")
+            fp.write(f"     description: {name}\n")
+            fp.write(f"     type: {type}\n")
+            if max is not None:
+                fp.write(f"     max: {max}\n")
+            if min is not None:
+                fp.write(f"     min: {min}\n")
+            if exclusive_max is not None:
+                fp.write(f"     exclusive_max: {exclusive_max}\n")
+            if exclusive_min is not None:
+                fp.write(f"     exclusive_min: {exclusive_min}\n")
+            fp.write(f"     default: {default_val}\n")
+
+
+    def validate_boolean(self, name, type, default):
+        with open(self.tmp_file, mode="w+") as fp:
+            fp.write(f"# yaml-language-server: $schema={schema_dir}/idf.v1.json\n")
+            fp.write("version: \"0.1\"\n")
+            fp.write("description: 测试接口，用于验证libgcom/gdbusplus，同时验证自动生成逻辑\n")
+            fp.write("alias: Test\n")
+            fp.write("properties:\n")
+            fp.write(f"   - name: {name}\n")
+            fp.write(f"     description: {name}\n")
+            fp.write(f"     type: {type}\n")
+            fp.write(f"     default: {default}\n")
+
+    def test_validate_default_bool(self):
+        self.validate_boolean("b", "boolean", "true")
+        IdfInterface(None, self.tmp_file)
+        self.validate_boolean("b", "boolean", "false")
+        IdfInterface(None, self.tmp_file)
+        self.validate_boolean("b", "boolean", "False")
+        IdfInterface(None, self.tmp_file)
+        self.validate_boolean("b", "boolean", "True")
+        IdfInterface(None, self.tmp_file)
+        self.validate_boolean("b", "boolean", "ONsdf")
+        with self.assertRaises(errors.PackageConfigException):
+            IdfInterface(None, self.tmp_file)
+        self.validate_boolean("b", "boolean", "asdaffa")
+        with self.assertRaises(errors.PackageConfigException):
+            IdfInterface(None, self.tmp_file)
+
+    def test_validate_default_array_bool(self):
+        self.validate_boolean("b", "array[boolean]", "[false, true]")
+        IdfInterface(None, self.tmp_file)
+        self.validate_boolean("b", "array[boolean]", "[on, 1]")
+        # boolean值比较特殊，由json schema校验验证
+        with self.assertRaises(errors.PackageConfigException):
+            IdfInterface(None, self.tmp_file)
+
+    def validate_number(self, name, type):
+        self.mk_interface_with_number_property(name, type, "100", "1", "1")
+        IdfInterface(None, self.tmp_file)
+        self.mk_interface_with_number_property(name, type, "100", "1", "100")
+        IdfInterface(None, self.tmp_file)
+        self.mk_interface_with_number_property(name, type, "100", "1", "0")
+        with self.assertRaises(errors.OdfValidateException):
+            IdfInterface(None, self.tmp_file)
+        self.mk_interface_with_number_property(name, type, "100", "1", "101")
+        with self.assertRaises(errors.OdfValidateException):
+            IdfInterface(None, self.tmp_file)
+
+    def test_validate_default_byte(self):
+        self.validate_number("y", "byte")
+
+    def test_validate_default_uint16(self):
+        self.validate_number("n", "uint16")
+
+    def test_validate_default_int16(self):
+        self.validate_number("q", "int16")
+
+    def test_validate_default_int32(self):
+        self.validate_number("i", "int32")
+
+    def test_validate_default_uint32(self):
+        self.validate_number("u", "uint32")
+
+    def test_validate_default_int64(self):
+        self.validate_number("x", "int64")
+
+    def test_validate_default_uint64(self):
+        self.validate_number("t", "uint64")
+
+    def test_validate_default_size(self):
+        self.validate_number("size", "size")
+
+    def test_validate_default_uint16(self):
+        self.validate_number("ssize", "ssize")
+
+    def test_validate_default_boolean(self):
+        self.validate_number("double", "double")
+
+    def validate_array_number(self, name, type):
+        self.mk_interface_with_number_property(name, f"array[{type}]", "100", "1", "[1, 1]")
+        IdfInterface(None, self.tmp_file)
+        self.mk_interface_with_number_property(name, f"array[{type}]", "100", "1", "[100, 100]")
+        IdfInterface(None, self.tmp_file)
+        self.mk_interface_with_number_property(name, f"array[{type}]", "100", "1", "[0, 0]")
+        with self.assertRaises(errors.OdfValidateException):
+            IdfInterface(None, self.tmp_file)
+        self.mk_interface_with_number_property(name, f"array[{type}]", "100", "1", "[101, 101]")
+        with self.assertRaises(errors.OdfValidateException):
+            IdfInterface(None, self.tmp_file)
+
+    def test_validate_default_array_byte(self):
+        self.validate_array_number("y", "byte")
+
+    def test_validate_default_array_uint16(self):
+        self.validate_array_number("n", "uint16")
+
+    def test_validate_default_array_int16(self):
+        self.validate_array_number("q", "int16")
+
+    def test_validate_default_array_int32(self):
+        self.validate_array_number("i", "int32")
+
+    def test_validate_default_array_uint32(self):
+        self.validate_array_number("u", "uint32")
+
+    def test_validate_default_array_int64(self):
+        self.validate_array_number("x", "int64")
+
+    def test_validate_default_array_uint64(self):
+        self.validate_array_number("t", "uint64")
+
+    def test_validate_default_array_size(self):
+        self.validate_array_number("size", "size")
+
+    def test_validate_default_array_uint16(self):
+        self.validate_array_number("ssize", "ssize")
+
+    def test_validate_default_array_double(self):
+        self.validate_array_number("double", "double")
+
+    def test_validate_array_double(self):
+        self.mk_interface_with_double_property("double", f"array[double]", "[1, 1]", exclusive_max="100", exclusive_min="1")
+        with self.assertRaises(errors.OdfValidateException):
+            IdfInterface(None, self.tmp_file)
+        self.mk_interface_with_double_property("double", f"array[double]", "[100, 100]", exclusive_max="100", exclusive_min="1")
+        with self.assertRaises(errors.OdfValidateException):
+            IdfInterface(None, self.tmp_file)
+        self.mk_interface_with_double_property("double", f"array[double]", "[0.9, 0.9]", exclusive_max="100", exclusive_min="1")
+        with self.assertRaises(errors.OdfValidateException):
+            IdfInterface(None, self.tmp_file)
+        self.mk_interface_with_double_property("double", f"array[double]", "[100.1, 100.1]", exclusive_max="100", exclusive_min="1")
+        with self.assertRaises(errors.OdfValidateException):
+            IdfInterface(None, self.tmp_file)
+
+    def test_validate_double(self):
+        self.mk_interface_with_double_property("double", "double", "1", exclusive_max="100", exclusive_min="1")
+        with self.assertRaises(errors.OdfValidateException):
+            IdfInterface(None, self.tmp_file)
+        self.mk_interface_with_double_property("double", "double", "100", exclusive_max="100", exclusive_min="1")
+        with self.assertRaises(errors.OdfValidateException):
+            IdfInterface(None, self.tmp_file)
+        self.mk_interface_with_double_property("double", "double", "0.9", exclusive_max="100", exclusive_min="1")
+        with self.assertRaises(errors.OdfValidateException):
+            IdfInterface(None, self.tmp_file)
+        self.mk_interface_with_double_property("double", "double", "100.1", exclusive_max="100", exclusive_min="1")
+        with self.assertRaises(errors.OdfValidateException):
+            IdfInterface(None, self.tmp_file)
+
+    def test_validate_string(self):
+        self.mk_interface_with_string_property("string", "string", "^a[s]{1,2}$", "as")
+        IdfInterface(None, self.tmp_file)
+        self.mk_interface_with_string_property("string", "string", "^a[s]{1,2}$", "ass")
+        IdfInterface(None, self.tmp_file)
+        self.mk_interface_with_string_property("string", "string", "^a[s]{1,2}$", "asss")
+        with self.assertRaises(errors.OdfValidateException):
+            IdfInterface(None, self.tmp_file)
+        self.mk_interface_with_string_property("string", "string", "^a[s]{1,2}$", "a")
+        with self.assertRaises(errors.OdfValidateException):
+            IdfInterface(None, self.tmp_file)
+        self.mk_interface_with_string_property("string", "string", "^a[s]{1,2}$", "0.123")
+        with self.assertRaises(errors.PackageConfigException):
+            IdfInterface(None, self.tmp_file)
+
+    def test_validate_array_string(self):
+        self.mk_interface_with_string_property("string", "array[string]", "^a[s]{1,2}$", "[as, as]")
+        IdfInterface(None, self.tmp_file)
+        self.mk_interface_with_string_property("string", "array[string]", "^a[s]{1,2}$", "[ass, ass]")
+        IdfInterface(None, self.tmp_file)
+        self.mk_interface_with_string_property("string", "array[string]", "^a[s]{1,2}$", "[asss, asss]")
+        with self.assertRaises(errors.OdfValidateException):
+            IdfInterface(None, self.tmp_file)
+        self.mk_interface_with_string_property("string", "array[string]", "^a[s]{1,2}$", "[a, a]")
+        with self.assertRaises(errors.OdfValidateException):
+            IdfInterface(None, self.tmp_file)
+        self.mk_interface_with_string_property("string", "array[string]", "^a[s]{1,2}$", "[0.123, 0.123]")
+        with self.assertRaises(errors.PackageConfigException):
+            IdfInterface(None, self.tmp_file)
+
+    def test_validate_object_path(self):
+        self.mk_interface_with_string_property("object_path", "object_path", None, "/as")
+        IdfInterface(None, self.tmp_file)
+        self.mk_interface_with_string_property("object_path", "object_path", None, "/a/s")
+        IdfInterface(None, self.tmp_file)
+        self.mk_interface_with_string_property("object_path", "object_path", None, "a/s")
+        with self.assertRaises(errors.PackageConfigException):
+            IdfInterface(None, self.tmp_file)
+        self.mk_interface_with_string_property("object_path", "object_path", None, "/a/s/")
+        with self.assertRaises(errors.PackageConfigException):
+            IdfInterface(None, self.tmp_file)
+
+    def test_validate_array_object_path(self):
+        self.mk_interface_with_string_property("object_path", "array[object_path]", None, "[/as, /as]")
+        IdfInterface(None, self.tmp_file)
+        self.mk_interface_with_string_property("object_path", "array[object_path]", None, "[/a/s, /a]")
+        IdfInterface(None, self.tmp_file)
+        self.mk_interface_with_string_property("object_path", "array[object_path]", None, "[a/s, a/s]")
+        with self.assertRaises(errors.PackageConfigException):
+            IdfInterface(None, self.tmp_file)
+        self.mk_interface_with_string_property("object_path", "array[object_path]", None, "[/a/s/, /a/s/]")
+        with self.assertRaises(errors.PackageConfigException):
+            IdfInterface(None, self.tmp_file)
+
+
+if __name__ == "__main__":
+    unittest.main()

lbkit-0.5.19/test/test_helper.py

@@ -0,0 +1,247 @@
+import unittest
+from lbkit.helper import SigInvalidException, validate_glib_signature
+
+class TestSignatureValidateClass(unittest.TestCase):
+    def test_validate_glib_signature_b(self):
+        validate_glib_signature("b")
+        validate_glib_signature("ab")
+        validate_glib_signature("bbb")
+        validate_glib_signature("{bb}")
+        validate_glib_signature("{bb}bbabaab")
+        validate_glib_signature("({bb}bbabaab()(b))")
+        validate_glib_signature("a{sb}")
+        validate_glib_signature("(b)")
+        validate_glib_signature("a(b)")
+        validate_glib_signature("a(sb)")
+    def test_validate_glib_signature_y(self):
+        validate_glib_signature("y")
+        validate_glib_signature("ay")
+        validate_glib_signature("yyy")
+        validate_glib_signature("{yy}")
+        validate_glib_signature("{yy}yyayaay")
+        validate_glib_signature("({yy}yyayaay()(y))")
+        validate_glib_signature("a{sy}")
+        validate_glib_signature("(b)")
+        validate_glib_signature("a(b)")
+        validate_glib_signature("a(sb)")
+    def test_validate_glib_signature_n(self):
+        validate_glib_signature("n")
+        validate_glib_signature("an")
+        validate_glib_signature("nnn")
+        validate_glib_signature("{nn}")
+        validate_glib_signature("{nn}nnanaan")
+        validate_glib_signature("({nn}nnanaan()(n))")
+        validate_glib_signature("a{sn}")
+        validate_glib_signature("(b)")
+        validate_glib_signature("a(b)")
+        validate_glib_signature("a(sb)")
+    def test_validate_glib_signature_q(self):
+        validate_glib_signature("q")
+        validate_glib_signature("aq")
+        validate_glib_signature("qqq")
+        validate_glib_signature("{qq}")
+        validate_glib_signature("{qq}qqaqaaq")
+        validate_glib_signature("({qq}qqaqaaq()(q))")
+        validate_glib_signature("a{sq}")
+        validate_glib_signature("(b)")
+        validate_glib_signature("a(b)")
+        validate_glib_signature("a(sb)")
+    def test_validate_glib_signature_i(self):
+        validate_glib_signature("i")
+        validate_glib_signature("ai")
+        validate_glib_signature("iii")
+        validate_glib_signature("{ii}")
+        validate_glib_signature("{ii}iiaiaai")
+        validate_glib_signature("({ii}iiaiaai()(i))")
+        validate_glib_signature("a{si}")
+        validate_glib_signature("(b)")
+        validate_glib_signature("a(b)")
+        validate_glib_signature("a(sb)")
+    def test_validate_glib_signature_u(self):
+        validate_glib_signature("u")
+        validate_glib_signature("au")
+        validate_glib_signature("uuu")
+        validate_glib_signature("{uu}")
+        validate_glib_signature("{uu}uuauaau")
+        validate_glib_signature("({uu}uuauaau()(u))")
+        validate_glib_signature("a{su}")
+        validate_glib_signature("(b)")
+        validate_glib_signature("a(b)")
+        validate_glib_signature("a(sb)")
+    def test_validate_glib_signature_x(self):
+        validate_glib_signature("x")
+        validate_glib_signature("ax")
+        validate_glib_signature("xxx")
+        validate_glib_signature("{xx}")
+        validate_glib_signature("{xx}xxaxaax")
+        validate_glib_signature("({xx}xxaxaax()(x))")
+        validate_glib_signature("a{sx}")
+        validate_glib_signature("(b)")
+        validate_glib_signature("a(b)")
+        validate_glib_signature("a(sb)")
+    def test_validate_glib_signature_t(self):
+        validate_glib_signature("t")
+        validate_glib_signature("at")
+        validate_glib_signature("ttt")
+        validate_glib_signature("{tt}")
+        validate_glib_signature("{tt}ttataat")
+        validate_glib_signature("({tt}ttataat()(t))")
+        validate_glib_signature("a{st}")
+        validate_glib_signature("(b)")
+        validate_glib_signature("a(b)")
+        validate_glib_signature("a(sb)")
+    def test_validate_glib_signature_d(self):
+        validate_glib_signature("d")
+        validate_glib_signature("ad")
+        validate_glib_signature("ddd")
+        validate_glib_signature("{dd}")
+        validate_glib_signature("{dd}ddadaad")
+        validate_glib_signature("({dd}ddadaad()(d))")
+        validate_glib_signature("a{sd}")
+        validate_glib_signature("(b)")
+        validate_glib_signature("a(b)")
+        validate_glib_signature("a(sb)")
+    def test_validate_glib_signature_h(self):
+        validate_glib_signature("h")
+        validate_glib_signature("ah")
+        validate_glib_signature("hhh")
+        validate_glib_signature("{hh}")
+        validate_glib_signature("{hh}hhahaah")
+        validate_glib_signature("({hh}hhahaah()(h))")
+        validate_glib_signature("a{sh}")
+        validate_glib_signature("(b)")
+        validate_glib_signature("a(b)")
+        validate_glib_signature("a(sb)")
+    def test_validate_glib_signature_s(self):
+        validate_glib_signature("s")
+        validate_glib_signature("as")
+        validate_glib_signature("sss")
+        validate_glib_signature("{ss}")
+        validate_glib_signature("{ss}ssasaas")
+        validate_glib_signature("({ss}ssasaas()(s))")
+        validate_glib_signature("a{ss}")
+        validate_glib_signature("(b)")
+        validate_glib_signature("a(b)")
+        validate_glib_signature("a(sb)")
+    def test_validate_glib_signature_g(self):
+        validate_glib_signature("g")
+        validate_glib_signature("ag")
+        validate_glib_signature("ggg")
+        validate_glib_signature("{gg}")
+        validate_glib_signature("{gg}ggagaag")
+        validate_glib_signature("({gg}ggagaag()(g))")
+        validate_glib_signature("a{sg}")
+        validate_glib_signature("(b)")
+        validate_glib_signature("a(b)")
+        validate_glib_signature("a(sb)")
+    def test_validate_glib_signature_o(self):
+        validate_glib_signature("o")
+        validate_glib_signature("ao")
+        validate_glib_signature("ooo")
+        validate_glib_signature("{oo}")
+        validate_glib_signature("{oo}ooaoaao")
+        validate_glib_signature("({oo}ooaoaao()(o))")
+        validate_glib_signature("a{so}")
+        validate_glib_signature("(b)")
+        validate_glib_signature("a(b)")
+        validate_glib_signature("a(sb)")
+
+    def test_validate_glib_signature(self):
+        validate_glib_signature("()")
+        validate_glib_signature("(ss)")
+        validate_glib_signature("(aaaaaaaaaaaaaaaaaaaaaay)")
+        validate_glib_signature("aaaaaaaaaaaaaaaaaaaaaay")
+        validate_glib_signature("{saaaaaaaaaaaaaaaaaaaaaay}")
+
+    def test_validate_glib_signature_failed(self):
+        with self.assertRaises(SigInvalidException):
+            validate_glib_signature("{}")
+        with self.assertRaises(SigInvalidException):
+            validate_glib_signature("a")
+        with self.assertRaises(SigInvalidException):
+            validate_glib_signature("aaa")
+        with self.assertRaises(SigInvalidException):
+            validate_glib_signature("{b}")
+        with self.assertRaises(SigInvalidException):
+            validate_glib_signature("{ayy}")
+        with self.assertRaises(SigInvalidException):
+            validate_glib_signature("{b}")
+        with self.assertRaises(SigInvalidException):
+            validate_glib_signature("{ab}")
+        with self.assertRaises(SigInvalidException):
+            validate_glib_signature("{aby}")
+        with self.assertRaises(SigInvalidException):
+            validate_glib_signature("{y}")
+        with self.assertRaises(SigInvalidException):
+            validate_glib_signature("{ay}")
+        with self.assertRaises(SigInvalidException):
+            validate_glib_signature("{ayy}")
+        with self.assertRaises(SigInvalidException):
+            validate_glib_signature("{n}")
+        with self.assertRaises(SigInvalidException):
+            validate_glib_signature("{an}")
+        with self.assertRaises(SigInvalidException):
+            validate_glib_signature("{any}")
+        with self.assertRaises(SigInvalidException):
+            validate_glib_signature("{q}")
+        with self.assertRaises(SigInvalidException):
+            validate_glib_signature("{aq}")
+        with self.assertRaises(SigInvalidException):
+            validate_glib_signature("{aqy}")
+        with self.assertRaises(SigInvalidException):
+            validate_glib_signature("{i}")
+        with self.assertRaises(SigInvalidException):
+            validate_glib_signature("{ai}")
+        with self.assertRaises(SigInvalidException):
+            validate_glib_signature("{aiy}")
+        with self.assertRaises(SigInvalidException):
+            validate_glib_signature("{u}")
+        with self.assertRaises(SigInvalidException):
+            validate_glib_signature("{au}")
+        with self.assertRaises(SigInvalidException):
+            validate_glib_signature("{auy}")
+        with self.assertRaises(SigInvalidException):
+            validate_glib_signature("{x}")
+        with self.assertRaises(SigInvalidException):
+            validate_glib_signature("{ax}")
+        with self.assertRaises(SigInvalidException):
+            validate_glib_signature("{axy}")
+        with self.assertRaises(SigInvalidException):
+            validate_glib_signature("{t}")
+        with self.assertRaises(SigInvalidException):
+            validate_glib_signature("{at}")
+        with self.assertRaises(SigInvalidException):
+            validate_glib_signature("{aty}")
+        with self.assertRaises(SigInvalidException):
+            validate_glib_signature("{d}")
+        with self.assertRaises(SigInvalidException):
+            validate_glib_signature("{ad}")
+        with self.assertRaises(SigInvalidException):
+            validate_glib_signature("{ady}")
+        with self.assertRaises(SigInvalidException):
+            validate_glib_signature("{h}")
+        with self.assertRaises(SigInvalidException):
+            validate_glib_signature("{ah}")
+        with self.assertRaises(SigInvalidException):
+            validate_glib_signature("{ahy}")
+        with self.assertRaises(SigInvalidException):
+            validate_glib_signature("{s}")
+        with self.assertRaises(SigInvalidException):
+            validate_glib_signature("{as}")
+        with self.assertRaises(SigInvalidException):
+            validate_glib_signature("{asy}")
+        with self.assertRaises(SigInvalidException):
+            validate_glib_signature("{o}")
+        with self.assertRaises(SigInvalidException):
+            validate_glib_signature("{ao}")
+        with self.assertRaises(SigInvalidException):
+            validate_glib_signature("{aoy}")
+        with self.assertRaises(SigInvalidException):
+            validate_glib_signature("{g}")
+        with self.assertRaises(SigInvalidException):
+            validate_glib_signature("{ag}")
+        with self.assertRaises(SigInvalidException):
+            validate_glib_signature("{agy}")
+
+if __name__ == "__main__":
+    unittest.main()

lbkit-0.5.18/lbkit/__init__.py

@@ -1,2 +0,0 @@
-
-__version__ = '0.5.18'

lbkit-0.5.18/lbkit/helper.py

@@ -1,27 +0,0 @@
-import os
-import yaml
-from xml.dom import minidom, Node
-
-class Helper():
-    @staticmethod
-    def get_node_value(dom: Node, name, default=None):
-        node: minidom.Attr = dom.attributes.get(name)
-        if node is None:
-            if default is None:
-                raise Exception("Parse node failed, abort")
-            return default
-        return node.childNodes[0].nodeValue.strip()
-
-    def read_yaml(file: str, key, default=None):
-        if not os.path.isfile(file):
-            return default
-        fd = open(file, "r");
-        try:
-            data = yaml.load(fd, Loader=yaml.FullLoader)
-            for split in key.split("/", -1):
-                data = data.get(split)
-                if data is None:
-                    return default
-            return data
-        except:
-            return default