v0.44.0: Add more REGEX patters for email matching

Add new regex constants for email handling and update related tests
v0.43.4: Fix for config loader with empty to split into lists values
2026-01-08 14:59:49 +09:00 · 2026-01-08 14:58:14 +09:00 · 2026-01-06 10:04:03 +09:00 · 2026-01-06 09:58:21 +09:00 · 2025-12-24 10:25:42 +09:00 · 2025-12-24 10:23:27 +09:00
21 changed files with 1503 additions and 95 deletions
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,7 +1,7 @@
 # MARK: Project info
 [project]
 name = "corelibs"
-version = "0.42.2"
+version = "0.44.0"
 description = "Collection of utils for Python scripts"
 readme = "README.md"
 requires-python = ">=3.13"
--- a/src/corelibs/check_handling/regex_constants.py
+++ b/src/corelibs/check_handling/regex_constants.py
@@ -19,9 +19,26 @@ def compile_re(reg: str) -> re.Pattern[str]:


 # email regex
-EMAIL_BASIC_REGEX: str = r"""
-^[A-Za-z0-9!#$%&'*+\-\/=?^_`{|}~][A-Za-z0-9!#$%:\(\)&'*+\-\/=?^_`{|}~\.]{0,63}
-@(?!-)[A-Za-z0-9-]{1,63}(?<!-)(?:\.[A-Za-z0-9-]{1,63}(?<!-))*\.[a-zA-Z]{2,6}$
+SUB_EMAIL_BASIC_REGEX: str = r"""
+[A-Za-z0-9!#$%&'*+\-\/=?^_`{|}~][A-Za-z0-9!#$%:\(\)&'*+\-\/=?^_`{|}~\.]{0,63}
+@(?!-)[A-Za-z0-9-]{1,63}(?<!-)(?:\.[A-Za-z0-9-]{1,63}(?<!-))*\.[a-zA-Z]{2,6}
+"""
+EMAIL_BASIC_REGEX = rf"^{SUB_EMAIL_BASIC_REGEX}$"
+# name + email regex for email sending type like "foo bar" <email@mail.com>
+NAME_EMAIL_SIMPLE_REGEX = r"""
+^\s*(?:"(?P<name1>[^"]+)"\s*<(?P<email1>[^>]+)>|
+(?P<name2>.+?)\s*<(?P<email2>[^>]+)>|
+<(?P<email3>[^>]+)>|
+(?P<email4>[^\s<>]+))\s*$
+"""
+# name + email with the basic regex set
+NAME_EMAIL_BASIC_REGEX = rf"""
+^\s*(?:
+"(?P<name1>[^"]+)"\s*<(?P<email1>{SUB_EMAIL_BASIC_REGEX})>|
+(?P<name2>.+?)\s*<(?P<email2>{SUB_EMAIL_BASIC_REGEX})>|
+<(?P<email3>{SUB_EMAIL_BASIC_REGEX})>|
+(?P<email4>{SUB_EMAIL_BASIC_REGEX})
+)\s*$
 """
 # Domain regex with localhost
 DOMAIN_WITH_LOCALHOST_REGEX: str = r"""
--- a/src/corelibs/config_handling/settings_loader.py
+++ b/src/corelibs/config_handling/settings_loader.py
@@ -53,6 +53,9 @@ class SettingsLoader:
        # for check settings, abort flag
        self.__check_settings_abort: bool = False

+        # error messages for raise ValueError
+        self.__error_msg: list[str] = []
+
    # MARK: load settings
    def load_settings(
        self,
@@ -87,6 +90,8 @@ class SettingsLoader:
        Returns:
            dict[str, str]: key = value list
        """
+        # reset error message list before run
+        self.__error_msg = []
        # default set entries
        entry_set_empty: dict[str, str | None] = {}
        # entries that have to be split
@@ -109,7 +114,7 @@ class SettingsLoader:
                if allow_not_exist is True:
                    return {}
                raise ValueError(self.__print(
-                    f"[!] Cannot read [{config_id}] block in the {self.config_file}: {e}",
+                    f"[!] Cannot read [{config_id}] block in the file {self.config_file}: {e}",
                    'CRITICAL'
                )) from e
            try:
@@ -168,10 +173,13 @@ class SettingsLoader:
                            args_overrride.append(key)
                    if skip:
                        continue
-                    settings[config_id][key] = [
-                        __value.replace(" ", "")
-                        for __value in settings[config_id][key].split(split_char)
-                    ]
+                    if settings[config_id][key]:
+                        settings[config_id][key] = [
+                            __value.replace(" ", "")
+                            for __value in settings[config_id][key].split(split_char)
+                        ]
+                    else:
+                        settings[config_id][key] = []
            except KeyError as e:
                raise ValueError(self.__print(
                    f"[!] Cannot read [{config_id}] block because the entry [{e}] could not be found",
@@ -181,9 +189,8 @@ class SettingsLoader:
            # ignore error if arguments are set
            if not self.__check_arguments(config_validate, True):
                raise ValueError(self.__print(f"[!] Cannot find file: {self.config_file}", 'CRITICAL'))
-            else:
-                # base set
-                settings[config_id] = {}
+            # base set
+            settings[config_id] = {}
        # make sure all are set
        # if we have arguments set, this override config settings
        error: bool = False
@@ -274,7 +281,10 @@ class SettingsLoader:
                    error = True
                    self.__print(f"[!] Missing content entry for: {entry}", 'ERROR')
        if error is True:
-            raise ValueError(self.__print("[!] Missing or incorrect settings data. Cannot proceed", 'CRITICAL'))
+            self.__print("[!] Missing or incorrect settings data. Cannot proceed", 'CRITICAL')
+            raise ValueError(
+                "Missing or incorrect settings data. Cannot proceed: " + "; ".join(self.__error_msg)
+            )
        # set empty
        for [entry, empty_set] in entry_set_empty.items():
            # if set, skip, else set to empty value
@@ -568,6 +578,9 @@ class SettingsLoader:
        if self.log is None or self.always_print:
            if print_error:
                print(msg)
+        if level == 'ERROR':
+            # remove any prefix [!] for error message list
+            self.__error_msg.append(msg.replace('[!] ', '').strip())
        return msg


--- a/src/corelibs/csv_handling/csv_interface.py
+++ b/src/corelibs/csv_handling/csv_interface.py
@@ -7,10 +7,13 @@ from typing import Any, Sequence
 from pathlib import Path
 from collections import Counter
 import csv
+from corelibs.file_handling.file_bom_encoding import is_bom_encoded, is_bom_encoded_info
 from corelibs.exceptions.csv_exceptions import (
    NoCsvReader, CompulsoryCsvHeaderCheckFailed, CsvHeaderDataMissing
 )

+ENCODING = 'utf-8'
+ENCODING_UTF8_SIG = 'utf-8-sig'
 DELIMITER = ","
 QUOTECHAR = '"'
 # type: _QuotingType
@@ -27,6 +30,7 @@ class CsvWriter:
        file_name: Path,
        header_mapping: dict[str, str],
        header_order: list[str] | None = None,
+        encoding: str = ENCODING,
        delimiter: str = DELIMITER,
        quotechar: str = QUOTECHAR,
        quoting: Any = QUOTING,
@@ -38,6 +42,7 @@ class CsvWriter:
        self.__delimiter = delimiter
        self.__quotechar = quotechar
        self.__quoting = quoting
+        self.__encoding = encoding
        self.csv_file_writer = self.__open_csv(header_order)

    def __open_csv(self, header_order: list[str] | None) -> csv.DictWriter[str]:
@@ -69,7 +74,8 @@ class CsvWriter:
        try:
            fp = open(
                self.__file_name,
-                "w", encoding="utf-8"
+                "w",
+                encoding=self.__encoding
            )
            csv_file_writer = csv.DictWriter(
                fp,
@@ -109,6 +115,7 @@ class CsvReader:
        self,
        file_name: Path,
        header_check: Sequence[str] | None = None,
+        encoding: str = ENCODING,
        delimiter: str = DELIMITER,
        quotechar: str = QUOTECHAR,
        quoting: Any = QUOTING,
@@ -118,6 +125,7 @@ class CsvReader:
        self.__delimiter = delimiter
        self.__quotechar = quotechar
        self.__quoting = quoting
+        self.__encoding = encoding
        self.header: Sequence[str] | None = None
        self.csv_file_reader = self.__open_csv()

@@ -129,9 +137,16 @@ class CsvReader:
            csv.DictReader | None: _description_
        """
        try:
+            # if UTF style check if this is BOM
+            if self.__encoding.lower().startswith('utf-') and is_bom_encoded(self.__file_name):
+                bom_info = is_bom_encoded_info(self.__file_name)
+                if bom_info['encoding'] == 'utf-8':
+                    self.__encoding = ENCODING_UTF8_SIG
+                else:
+                    self.__encoding = bom_info['encoding'] or self.__encoding
            fp = open(
                self.__file_name,
-                "r", encoding="utf-8"
+                "r", encoding=self.__encoding
            )
            csv_file_reader = csv.DictReader(
                fp,
--- a/src/corelibs/db_handling/sql_main.py
+++ b/src/corelibs/db_handling/sql_main.py
@@ -0,0 +1,76 @@
+"""
+Main SQL base for any SQL calls
+This is a wrapper for SQLiteIO or other future DB Interfaces
+[Note: at the moment only SQLiteIO is implemented]
+- on class creation connection with ValueError on fail
+- connect method checks if already connected and warns
+- connection class fails with ValueError if not valid target is selected (SQL wrapper type)
+- connected check class method
+- a process class that returns data as list or False if end or error
+
+TODO: adapt more CoreLibs DB IO class flow here
+"""
+
+from typing import TYPE_CHECKING, Any, Literal
+from corelibs.debug_handling.debug_helpers import call_stack
+from corelibs.db_handling.sqlite_io import SQLiteIO
+if TYPE_CHECKING:
+    from corelibs.logging_handling.log import Logger
+
+
+IDENT_SPLIT_CHARACTER: str = ':'
+
+
+class SQLMain:
+    """Main SQL interface class"""
+    def __init__(self, log: 'Logger', db_ident: str):
+        self.log = log
+        self.dbh: SQLiteIO | None = None
+        self.db_target: str | None = None
+        self.connect(db_ident)
+        if not self.connected():
+            raise ValueError(f'Failed to connect to database [{call_stack()}]')
+
+    def connect(self, db_ident: str):
+        """setup basic connection"""
+        if self.dbh is not None and self.dbh.conn is not None:
+            self.log.warning(f"A database connection already exists for: {self.db_target} [{call_stack()}]")
+            return
+        self.db_target, db_dsn = db_ident.split(IDENT_SPLIT_CHARACTER)
+        match self.db_target:
+            case 'sqlite':
+                # this is a Path only at the moment
+                self.dbh = SQLiteIO(self.log, db_dsn, row_factory='Dict')
+            case _:
+                raise ValueError(f'SQL interface for {self.db_target} is not implemented [{call_stack()}]')
+        if not self.dbh.db_connected():
+            raise ValueError(f"DB Connection failed for: {self.db_target} [{call_stack()}]")
+
+    def close(self):
+        """close connection"""
+        if self.dbh is None or not self.connected():
+            return
+        # self.log.info(f"Close DB Connection: {self.db_target} [{call_stack()}]")
+        self.dbh.db_close()
+
+    def connected(self) -> bool:
+        """check connectuon"""
+        if self.dbh is None or not self.dbh.db_connected():
+            self.log.warning(f"No connection [{call_stack()}]")
+            return False
+        return True
+
+    def process_query(
+        self, query: str, params: tuple[Any, ...] | None = None
+    ) -> list[tuple[Any, ...]] | list[dict[str, Any]] | Literal[False]:
+        """mini wrapper for execute query"""
+        if self.dbh is not None:
+            result = self.dbh.execute_query(query, params)
+            if result is False:
+                return False
+        else:
+            self.log.error(f"Problem connecting to db: {self.db_target} [{call_stack()}]")
+            return False
+        return result
+
+# __END__
--- a/src/corelibs/email_handling/send_email.py
+++ b/src/corelibs/email_handling/send_email.py
@@ -4,6 +4,8 @@ Send email wrapper

 import smtplib
 from email.message import EmailMessage
+from email.header import Header
+from email.utils import formataddr, parseaddr
 from typing import TYPE_CHECKING, Any
 if TYPE_CHECKING:
    from corelibs.logging_handling.log import Logger
@@ -133,21 +135,30 @@ class SendEmail:
            _subject = template["subject"]
            _body = template["body"]
            for key, value in replace.items():
-                _subject = _subject.replace(f"{{{{{key}}}}}", value)
-                _body = _body.replace(f"{{{{{key}}}}}", value)
+                placeholder = f"{{{{{key}}}}}"
+                _subject = _subject.replace(placeholder, value)
+                _body = _body.replace(placeholder, value)
+            name, addr = parseaddr(from_email)
+            if name:
+                # Encode the name part with MIME encoding
+                encoded_name = str(Header(name, 'utf-8'))
+                from_email_encoded = formataddr((encoded_name, addr))
+            else:
+                from_email_encoded = from_email
            # create a simple email and add subhect, from email
            msg_email = EmailMessage()
            # msg.set_content(_body, charset='utf-8', cte='quoted-printable')
            msg_email.set_content(_body, charset="utf-8")
            msg_email["Subject"] = _subject
-            msg_email["From"] = from_email
+            msg_email["From"] = from_email_encoded
            # push to array for sening
            msg.append(msg_email)
        return msg

    def send_email_list(
        self,
-        email: list[EmailMessage], receivers: list[str],
+        emails: list[EmailMessage],
+        receivers: list[str],
        combined_send: bool | None = None,
        test_only: bool | None = None
    ):
@@ -170,18 +181,27 @@ class SendEmail:
            smtp = smtplib.SMTP(smtp_host)
        except ConnectionRefusedError as e:
            self.log.error("Could not open SMTP connection to: %s, %s", smtp_host, e)
+        # prepare receiver list
+        receivers_encoded: list[str] = []
+        for __receiver in receivers:
+            to_name, to_addr = parseaddr(__receiver)
+            if to_name:
+                # Encode the name part with MIME encoding
+                encoded_to_name = str(Header(to_name, 'utf-8'))
+                receivers_encoded.append(formataddr((encoded_to_name, to_addr)))
+            else:
+                receivers_encoded.append(__receiver)
        # loop over messages and then over recievers
-        for msg in email:
+        for msg in emails:
            if combined_send is True:
-                msg["To"] = ", ".join(receivers)
+                msg["To"] = ", ".join(receivers_encoded)
                if not self.settings.get('test'):
                    if smtp is not None:
-                        smtp.send_message(msg, msg["From"], receivers)
+                        smtp.send_message(msg, msg["From"], receivers_encoded)
                else:
                    self.log.info(f"[EMAIL] Test, not sending email\n{msg}")
            else:
-                for receiver in receivers:
-                    # send to
+                for receiver in receivers_encoded:
                    self.log.debug(f"===> Send to: {receiver}")
                    if "To" in msg:
                        msg.replace_header("To", receiver)
--- a/src/corelibs/math_handling/init.py
+++ b/src/corelibs/math_handling/init.py
--- a/src/corelibs/math_handling/math_helpers.py
+++ b/src/corelibs/math_handling/math_helpers.py
@@ -0,0 +1,35 @@
+"""
+Various math helpers
+"""
+
+import math
+
+
+def gcd(a: int, b: int):
+    """
+    Calculate: Greatest Common Divisor
+
+    Arguments:
+        a {int} -- _description_
+        b {int} -- _description_
+
+    Returns:
+        _type_ -- _description_
+    """
+    return math.gcd(a, b)
+
+
+def lcd(a: int, b: int):
+    """
+    Calculate: Least Common Denominator
+
+    Arguments:
+        a {int} -- _description_
+        b {int} -- _description_
+
+    Returns:
+        _type_ -- _description_
+    """
+    return math.lcm(a, b)
+
+# __END__
--- a/src/corelibs/var_handling/enum_base.py
+++ b/src/corelibs/var_handling/enum_base.py
@@ -12,7 +12,7 @@ class EnumBase(CorelibsEnumBase):

    .. deprecated::
        Use corelibs_enum_base.EnumBase instead
-    DEPRECATED: Use corelibs_enum_base.EnumBase instead
+    DEPRECATED: Use corelibs_enum_base.enum_base.EnumBase instead

    lookup_any and from_any will return "EnumBase" and the sub class name
    run the return again to "from_any" to get a clean value, or cast it
@@ -20,6 +20,6 @@ class EnumBase(CorelibsEnumBase):


 # At the module level, issue a deprecation warning
-warnings.warn("Use corelibs_enum_base.EnumBase instead", DeprecationWarning, stacklevel=2)
+warnings.warn("Use corelibs_enum_base.enum_base.EnumBase instead", DeprecationWarning, stacklevel=2)

 # __EMD__
--- a/src/corelibs/var_handling/enum_base.pyi
+++ b/src/corelibs/var_handling/enum_base.pyi
@@ -6,7 +6,7 @@ from typing_extensions import deprecated
 from corelibs_enum_base.enum_base import EnumBase as CorelibsEnumBase


-@deprecated("Use corelibs_enum_base.EnumBase instead")
+@deprecated("Use corelibs_enum_base.enum_base.EnumBase instead")
 class EnumBase(CorelibsEnumBase):
    """
    base for enum
--- a/test-run/check_handling/regex_checks.py
+++ b/test-run/check_handling/regex_checks.py
@@ -0,0 +1,100 @@
+"""
+Test check andling for regex checks
+"""
+
+from corelibs_text_colors.text_colors import Colors
+from corelibs.check_handling.regex_constants import (
+    compile_re, DOMAIN_WITH_LOCALHOST_REGEX, EMAIL_BASIC_REGEX, NAME_EMAIL_BASIC_REGEX, SUB_EMAIL_BASIC_REGEX
+)
+
+NAME_EMAIL_SIMPLE_REGEX = r"""
+^\s*(?:"(?P<name1>[^"]+)"\s*<(?P<email1>[^>]+)>|
+(?P<name2>.+?)\s*<(?P<email2>[^>]+)>|
+<(?P<email3>[^>]+)>|
+(?P<email4>[^\s<>]+))\s*$
+"""
+
+
+def domain_test():
+    """
+    domain regex test
+    """
+    print("=" * 30)
+    test_domains = [
+        "example.com",
+        "localhost",
+        "subdomain.localhost",
+        "test.localhost.com",
+        "some-domain.org"
+    ]
+
+    regex_domain_check = compile_re(DOMAIN_WITH_LOCALHOST_REGEX)
+    print(f"REGEX: {DOMAIN_WITH_LOCALHOST_REGEX}")
+    print(f"Check regex: {regex_domain_check.search('localhost')}")
+
+    for domain in test_domains:
+        if regex_domain_check.search(domain):
+            print(f"Matched: {domain}")
+        else:
+            print(f"Did not match: {domain}")
+
+
+def email_test():
+    """
+    email regex test
+    """
+    print("=" * 30)
+    email_list = """
+    e@bar.com
+    <f@foobar.com>
+    "Master" <foobar@bar.com>
+    "not valid" not@valid.com
+    also not valid not@valid.com
+    some header <something@bar.com>
+    test master <master@master.com>
+    日本語 <japan@jp.net>
+    "ひほん カケ苦" <foo@bar.com>
+    single@entry.com
+    arsch@popsch.com
+    test open <open@open.com>
+    """
+
+    basic_email = compile_re(EMAIL_BASIC_REGEX)
+    sub_basic_email = compile_re(SUB_EMAIL_BASIC_REGEX)
+    simple_name_email_regex = compile_re(NAME_EMAIL_SIMPLE_REGEX)
+    full_name_email_regex = compile_re(NAME_EMAIL_BASIC_REGEX)
+    for email in email_list.splitlines():
+        email = email.strip()
+        if not email:
+            continue
+        print(f">>> Testing:        {email}")
+        if not basic_email.match(email):
+            print(f"{Colors.red}[EMAIL ] No match: {email}{Colors.reset}")
+        else:
+            print(f"{Colors.green}[EMAIL ] Matched : {email}{Colors.reset}")
+        if not sub_basic_email.match(email):
+            print(f"{Colors.red}[SUB   ] No match: {email}{Colors.reset}")
+        else:
+            print(f"{Colors.green}[SUB   ] Matched : {email}{Colors.reset}")
+        if not simple_name_email_regex.match(email):
+            print(f"{Colors.red}[SIMPLE] No match: {email}{Colors.reset}")
+        else:
+            print(f"{Colors.green}[SIMPLE] Matched : {email}{Colors.reset}")
+        if not full_name_email_regex.match(email):
+            print(f"{Colors.red}[FULL  ] No match: {email}{Colors.reset}")
+        else:
+            print(f"{Colors.green}[FULL  ] Matched : {email}{Colors.reset}")
+
+
+def main():
+    """
+    Test regex checks
+    """
+    domain_test()
+    email_test()
+
+
+if __name__ == "__main__":
+    main()
+
+# __END__
--- a/test-run/config_handling/config/settings.ini
+++ b/test-run/config_handling/config/settings.ini
@@ -12,6 +12,7 @@ some_match_list=foo,bar
 test_list=a,b,c,d f, g h
 other_list=a|b|c|d|
 third_list=xy|ab|df|fg
+empty_list=
 str_length=foobar
 int_range=20
 int_range_not_set=
@@ -37,3 +38,6 @@ email_bad=gii@bar.com
 [LoadTest]
 a.b.c=foo
 d:e:f=bar
+
+[ErrorTest]
+some_value=42
--- a/test-run/config_handling/settings_loader.py
+++ b/test-run/config_handling/settings_loader.py
@@ -21,11 +21,6 @@ def main():
    Main run
    """

-    value = "2025/1/1"
-    regex_c = re.compile(SettingsLoaderCheck.CHECK_SETTINGS['string.date']['regex'], re.VERBOSE)
-    result = regex_c.search(value)
-    print(f"regex {regex_c} check against {value} -> {result}")
-
    # for log testing
    log = Log(
        log_path=ROOT_PATH.joinpath(LOG_DIR, 'settings_loader.log'),
@@ -37,6 +32,11 @@ def main():
    )
    log.logger.info('Settings loader')

+    value = "2025/1/1"
+    regex_c = re.compile(SettingsLoaderCheck.CHECK_SETTINGS['string.date']['regex'], re.VERBOSE)
+    result = regex_c.search(value)
+    log.info(f"regex {regex_c} check against {value} -> {result}")
+
    sl = SettingsLoader(
        {
            'overload_from_args': 'OVERLOAD from ARGS',
@@ -69,6 +69,9 @@ def main():
                    "split:|",
                    "check:string.alphanumeric"
                ],
+                "empty_list": [
+                    "split:,",
+                ],
                "str_length": [
                    "length:2-10"
                ],
@@ -125,6 +128,20 @@ def main():
    except ValueError as e:
        print(f"Could not load settings: {e}")

+    try:
+        config_load = 'ErrorTest'
+        config_data = sl.load_settings(
+            config_load,
+            {
+                "some_value": [
+                    "check:string.email.basic",
+                ],
+            }
+        )
+        print(f"[{config_load}] Load: {config_load} -> {dump_data(config_data)}")
+    except ValueError as e:
+        print(f"Could not load settings: {e}")
+

 if __name__ == "__main__":
    main()
--- a/test-run/db_handling/sql_main.py
+++ b/test-run/db_handling/sql_main.py
@@ -0,0 +1,139 @@
+"""
+SQL Main wrapper test
+"""
+
+from pathlib import Path
+from uuid import uuid4
+import json
+from corelibs.debug_handling.dump_data import dump_data
+from corelibs.logging_handling.log import Log, Logger
+from corelibs.db_handling.sql_main import SQLMain
+
+SCRIPT_PATH: Path = Path(__file__).resolve().parent
+ROOT_PATH: Path = SCRIPT_PATH
+DATABASE_DIR: Path = Path("database")
+LOG_DIR: Path = Path("log")
+
+
+def main() -> None:
+    """
+    Comment
+    """
+    log = Log(
+        log_path=ROOT_PATH.joinpath(LOG_DIR, 'sqlite_main.log'),
+        log_name="SQLite Main",
+        log_settings={
+            "log_level_console": 'DEBUG',
+            "log_level_file": 'DEBUG',
+        }
+    )
+    sql_main = SQLMain(
+        log=Logger(log.get_logger_settings()),
+        db_ident=f"sqlite:{ROOT_PATH.joinpath(DATABASE_DIR, 'test_sqlite_main.db')}"
+    )
+    if sql_main.connected():
+        log.info("SQL Main connected successfully")
+    else:
+        log.error('SQL Main connection failed')
+    if sql_main.dbh is None:
+        log.error('SQL Main DBH instance is None')
+        return
+
+    if sql_main.dbh.trigger_exists('trg_test_a_set_date_updated_on_update'):
+        log.info("Trigger trg_test_a_set_date_updated_on_update exists")
+    if sql_main.dbh.table_exists('test_a'):
+        log.info("Table test_a exists, dropping for clean test")
+        sql_main.dbh.execute_query("DROP TABLE test_a;")
+    # create a dummy table
+    table_sql = """
+    CREATE TABLE IF NOT EXISTS test_a (
+        test_a_id INTEGER PRIMARY KEY,
+        date_created TEXT DEFAULT (strftime('%Y-%m-%d %H:%M:%f', 'now')),
+        date_updated TEXT,
+        uid TEXT NOT NULL UNIQUE,
+        set_current_timestamp TEXT DEFAULT CURRENT_TIMESTAMP,
+        text_a TEXT,
+        content,
+        int_a INTEGER,
+        float_a REAL
+    );
+    """
+
+    result = sql_main.dbh.execute_query(table_sql)
+    log.debug(f"Create table result: {result}")
+    trigger_sql = """
+    CREATE TRIGGER trg_test_a_set_date_updated_on_update
+        AFTER UPDATE ON test_a
+        FOR EACH ROW
+        WHEN OLD.date_updated IS NULL OR NEW.date_updated = OLD.date_updated
+    BEGIN
+        UPDATE test_a
+        SET date_updated = (strftime('%Y-%m-%d %H:%M:%f', 'now'))
+        WHERE test_a_id = NEW.test_a_id;
+    END;
+    """
+    result = sql_main.dbh.execute_query(trigger_sql)
+    log.debug(f"Create trigger result: {result}")
+    result = sql_main.dbh.meta_data_detail('test_a')
+    log.debug(f"Table meta data detail: {dump_data(result)}")
+    # INSERT DATA
+    sql = """
+    INSERT INTO test_a (uid, text_a, content, int_a, float_a)
+    VALUES (?, ?, ?, ?, ?)
+    RETURNING test_a_id, uid;
+    """
+    result = sql_main.dbh.execute_query(
+        sql,
+        (
+            str(uuid4()),
+            'Some text A',
+            json.dumps({'foo': 'bar', 'number': 42}),
+            123,
+            123.456,
+        )
+    )
+    log.debug(f"[1] Insert data result: {dump_data(result)}")
+    __uid: str = ''
+    if result is not False:
+        # first one only of interest
+        result = dict(result[0])
+        __uid = str(result.get('uid', ''))
+    # second insert
+    result = sql_main.dbh.execute_query(
+        sql,
+        (
+            str(uuid4()),
+            'Some text A',
+            json.dumps({'foo': 'bar', 'number': 42}),
+            123,
+            123.456,
+        )
+    )
+    log.debug(f"[2] Insert data result: {dump_data(result)}")
+    result = sql_main.dbh.execute_query("SELECT * FROM test_a;")
+    log.debug(f"Select data result: {dump_data(result)}")
+    result = sql_main.dbh.return_one("SELECT * FROM test_a WHERE uid = ?;", (__uid,))
+    log.debug(f"Fetch row result: {dump_data(result)}")
+    sql = """
+    UPDATE test_a
+    SET text_a = ?
+    WHERE uid = ?;
+    """
+    result = sql_main.dbh.execute_query(
+        sql,
+        (
+            'Some updated text A',
+            __uid,
+        )
+    )
+    log.debug(f"Update data result: {dump_data(result)}")
+    result = sql_main.dbh.return_one("SELECT * FROM test_a WHERE uid = ?;", (__uid,))
+    log.debug(f"Fetch row after update result: {dump_data(result)}")
+
+    sql_main.close()
+
+
+if __name__ == "__main__":
+    main()
+
+# __END__
--- a/test-run/db_handling/sqlite_io.py
+++ b/test-run/db_handling/sqlite_io.py
@@ -1,7 +1,5 @@
-#!/usr/bin/env python3
-
 """
-Main comment
+SQLite IO test
 """

 from pathlib import Path
--- a/test-run/iterator_handling/data_search.py
+++ b/test-run/iterator_handling/data_search.py
@@ -24,12 +24,19 @@ def main() -> None:
            "lookup_value_c": "B02",
            "replace_value": "R02",
        },
+        {
+            "lookup_value_p": "A03",
+            "lookup_value_c": "B03",
+            "replace_value": "R03",
+        },
    ]
    test_foo = ArraySearchList(
-        key = "lookup_value_p",
-        value = "A01"
+        key="lookup_value_p",
+        value="A01"
    )
-    print(test_foo)
+    result = find_in_array_from_list(data, [test_foo])
+    print(f"Search A: {dump_data(test_foo)} -> {dump_data(result)}")
+
    search: list[ArraySearchList] = [
        {
            "key": "lookup_value_p",
@@ -38,12 +45,122 @@ def main() -> None:
        {
            "key": "lookup_value_c",
            "value": "B01"
+        },
+    ]
+    result = find_in_array_from_list(data, search)
+    print(f"Search B: {dump_data(search)} -> {dump_data(result)}")
+
+    search: list[ArraySearchList] = [
+        {
+            "key": "lookup_value_p",
+            "value": "A01"
+        },
+        {
+            "key": "lookup_value_c",
+            "value": "B01"
+        },
+        {
+            "key": "lookup_value_c",
+            "value": "B02"
+        },
+    ]
+    try:
+        result = find_in_array_from_list(data, search)
+        print(f"Search C: {dump_data(search)} -> {dump_data(result)}")
+    except KeyError as e:
+        print(f"Search C raised KeyError: {e}")
+
+    search: list[ArraySearchList] = [
+        {
+            "key": "lookup_value_p",
+            "value": "A01"
+        },
+        {
+            "key": "lookup_value_c",
+            "value": ["B01", "B02"]
+        },
+    ]
+    try:
+        result = find_in_array_from_list(data, search)
+        print(f"Search D: {dump_data(search)} -> {dump_data(result)}")
+    except KeyError as e:
+        print(f"Search D raised KeyError: {e}")
+
+    search: list[ArraySearchList] = [
+        {
+            "key": "lookup_value_p",
+            "value": ["A01", "A03"]
+        },
+        {
+            "key": "lookup_value_c",
+            "value": ["B01", "B02"]
+        },
+    ]
+    try:
+        result = find_in_array_from_list(data, search)
+        print(f"Search E: {dump_data(search)} -> {dump_data(result)}")
+    except KeyError as e:
+        print(f"Search E raised KeyError: {e}")
+
+    search: list[ArraySearchList] = [
+        {
+            "key": "lookup_value_p",
+            "value": "NOT FOUND"
+        },
+    ]
+    try:
+        result = find_in_array_from_list(data, search)
+        print(f"Search F: {dump_data(search)} -> {dump_data(result)}")
+    except KeyError as e:
+        print(f"Search F raised KeyError: {e}")
+
+    data = [
+        {
+            "sd_user_id": "1593",
+            "email": "",
+            "employee_id": ""
+        },
+        {
+            "sd_user_id": "1592",
+            "email": "",
+            "employee_id": ""
+        },
+        {
+            "sd_user_id": "1596",
+            "email": "",
+            "employee_id": ""
+        },
+        {
+            "sd_user_id": "1594",
+            "email": "",
+            "employee_id": ""
+        },
+        {
+            "sd_user_id": "1595",
+            "email": "",
+            "employee_id": ""
+        },
+        {
+            "sd_user_id": "1861",
+            "email": "",
+            "employee_id": ""
+        },
+        {
+            "sd_user_id": "1862",
+            "email": "",
+            "employee_id": ""
+        },
+        {
+            "sd_user_id": "1860",
+            "email": "",
+            "employee_id": ""
        }
    ]
-
-    result = find_in_array_from_list(data, search)
-
-    print(f"Search {dump_data(search)} -> {dump_data(result)}")
+    result = find_in_array_from_list(data, [ArraySearchList(
+        key="sd_user_id",
+        value="1593"
+    )])
+    print(f"Search F: -> {dump_data(result)}")


 if __name__ == "__main__":
--- a/tests/unit/check_handling/test_regex_constants.py
+++ b/tests/unit/check_handling/test_regex_constants.py
@@ -8,7 +8,10 @@ import re
 import pytest
 from corelibs.check_handling.regex_constants import (
    compile_re,
+    SUB_EMAIL_BASIC_REGEX,
    EMAIL_BASIC_REGEX,
+    NAME_EMAIL_SIMPLE_REGEX,
+    NAME_EMAIL_BASIC_REGEX,
    DOMAIN_WITH_LOCALHOST_REGEX,
    DOMAIN_WITH_LOCALHOST_PORT_REGEX,
    DOMAIN_REGEX,
@@ -123,6 +126,265 @@ class TestEmailBasicRegex:
        assert not email_pattern.match(email)


+class TestSubEmailBasicRegex:
+    """Test cases for SUB_EMAIL_BASIC_REGEX pattern (without anchors)."""
+
+    @pytest.fixture
+    def sub_email_pattern(self) -> re.Pattern[str]:
+        """Fixture that returns compiled sub email regex pattern."""
+        return compile_re(rf"^{SUB_EMAIL_BASIC_REGEX}$")
+
+    @pytest.mark.parametrize("valid_email", [
+        "user@example.com",
+        "test.user@example.com",
+        "user+tag@example.co.uk",
+        "first.last@subdomain.example.com",
+        "user123@test-domain.com",
+        "a@example.com",
+        "user_name@example.com",
+        "user-name@example.com",
+        "user@sub.domain.example.com",
+        "test!#$%&'*+-/=?^_`{|}~@example.com",
+        "1234567890@example.com",
+    ])
+    def test_valid_emails_match(self, sub_email_pattern: re.Pattern[str], valid_email: str) -> None:
+        """Test that valid email addresses match SUB_EMAIL_BASIC_REGEX."""
+        assert sub_email_pattern.match(valid_email), (
+            f"Failed to match valid email: {valid_email}"
+        )
+
+    @pytest.mark.parametrize("invalid_email", [
+        "",
+        "@example.com",
+        "user@",
+        "user",
+        "user@.com",
+        "user@domain",
+        "user @example.com",
+        ".user@example.com",
+        "user@-example.com",
+        "user@example-.com",
+        "user@example.c",
+        "user@example.toolong",
+    ])
+    def test_invalid_emails_no_match(self, sub_email_pattern: re.Pattern[str], invalid_email: str) -> None:
+        """Test that invalid emails don't match SUB_EMAIL_BASIC_REGEX."""
+        assert not sub_email_pattern.match(invalid_email), (
+            f"Incorrectly matched invalid email: {invalid_email}"
+        )
+
+    def test_sub_email_max_local_part_length(self, sub_email_pattern: re.Pattern[str]) -> None:
+        """Test email with maximum local part length (64 characters)."""
+        local_part = "a" * 64
+        email = f"{local_part}@example.com"
+        assert sub_email_pattern.match(email)
+
+    def test_sub_email_exceeds_local_part_length(self, sub_email_pattern: re.Pattern[str]) -> None:
+        """Test email exceeding maximum local part length."""
+        local_part = "a" * 65
+        email = f"{local_part}@example.com"
+        assert not sub_email_pattern.match(email)
+
+
+class TestNameEmailSimpleRegex:
+    """Test cases for NAME_EMAIL_SIMPLE_REGEX pattern."""
+
+    @pytest.fixture
+    def name_email_simple_pattern(self) -> re.Pattern[str]:
+        """Fixture that returns compiled name+email simple regex pattern."""
+        return compile_re(NAME_EMAIL_SIMPLE_REGEX)
+
+    @pytest.mark.parametrize("test_input,expected_groups", [
+        ('"John Doe" <john@example.com>', {'name1': 'John Doe', 'email1': 'john@example.com'}),
+        ('John Doe <john@example.com>', {'name2': 'John Doe', 'email2': 'john@example.com'}),
+        ('<john@example.com>', {'email3': 'john@example.com'}),
+        ('john@example.com', {'email4': 'john@example.com'}),
+        ('  "Jane Smith" <jane@test.com>  ', {'name1': 'Jane Smith', 'email1': 'jane@test.com'}),
+        ('Bob <bob@test.org>', {'name2': 'Bob', 'email2': 'bob@test.org'}),
+    ])
+    def test_valid_name_email_combinations(
+        self, name_email_simple_pattern: re.Pattern[str], test_input: str, expected_groups: dict[str, str]
+    ) -> None:
+        """Test that valid name+email combinations match and extract correct groups."""
+        match = name_email_simple_pattern.match(test_input)
+        assert match is not None, f"Failed to match: {test_input}"
+
+        # Check that expected groups are present and match
+        for group_name, expected_value in expected_groups.items():
+            assert match.group(group_name) == expected_value, (
+                f"Group {group_name} expected '{expected_value}', got '{match.group(group_name)}'"
+            )
+
+    @pytest.mark.parametrize("invalid_input", [
+        "",
+        "not an email",
+        "<>",
+        '"Name Only"',
+        'Name <',
+        '<email',
+        'Name <<email@test.com>>',
+        'Name <email@test.com',
+        'Name email@test.com>',
+    ])
+    def test_invalid_name_email_combinations(
+        self, name_email_simple_pattern: re.Pattern[str], invalid_input: str
+    ) -> None:
+        """Test that invalid inputs don't match NAME_EMAIL_SIMPLE_REGEX."""
+        assert not name_email_simple_pattern.match(invalid_input), (
+            f"Incorrectly matched invalid input: {invalid_input}"
+        )
+
+    def test_extract_name_from_quoted(
+        self, name_email_simple_pattern: re.Pattern[str]
+    ) -> None:
+        """Test extracting name from quoted format."""
+        match = name_email_simple_pattern.match('"Alice Wonder" <alice@example.com>')
+        assert match is not None
+        assert match.group('name1') == 'Alice Wonder'
+        assert match.group('email1') == 'alice@example.com'
+
+    def test_extract_name_from_unquoted(
+        self, name_email_simple_pattern: re.Pattern[str]
+    ) -> None:
+        """Test extracting name from unquoted format."""
+        match = name_email_simple_pattern.match('Bob Builder <bob@example.com>')
+        assert match is not None
+        assert match.group('name2') == 'Bob Builder'
+        assert match.group('email2') == 'bob@example.com'
+
+    def test_email_only_in_brackets(
+        self, name_email_simple_pattern: re.Pattern[str]
+    ) -> None:
+        """Test email-only format in angle brackets."""
+        match = name_email_simple_pattern.match('<charlie@example.com>')
+        assert match is not None
+        assert match.group('email3') == 'charlie@example.com'
+
+    def test_email_only_plain(
+        self, name_email_simple_pattern: re.Pattern[str]
+    ) -> None:
+        """Test plain email format without brackets."""
+        match = name_email_simple_pattern.match('dave@example.com')
+        assert match is not None
+        assert match.group('email4') == 'dave@example.com'
+
+    def test_whitespace_handling(
+        self, name_email_simple_pattern: re.Pattern[str]
+    ) -> None:
+        """Test that leading/trailing whitespace is handled correctly."""
+        match = name_email_simple_pattern.match('   "User Name" <user@example.com>   ')
+        assert match is not None
+        assert match.group('name1') == 'User Name'
+        assert match.group('email1') == 'user@example.com'
+
+
+class TestNameEmailBasicRegex:
+    """Test cases for NAME_EMAIL_BASIC_REGEX pattern with strict email validation."""
+
+    @pytest.fixture
+    def name_email_basic_pattern(self) -> re.Pattern[str]:
+        """Fixture that returns compiled name+email basic regex pattern."""
+        return compile_re(NAME_EMAIL_BASIC_REGEX)
+
+    @pytest.mark.parametrize("test_input,expected_name,expected_email", [
+        ('"John Doe" <john@example.com>', 'John Doe', 'john@example.com'),
+        ('John Doe <john@example.com>', 'John Doe', 'john@example.com'),
+        ('<john@example.com>', None, 'john@example.com'),
+        ('john@example.com', None, 'john@example.com'),
+        ('  "Jane Smith" <jane.smith@test.co.uk>  ', 'Jane Smith', 'jane.smith@test.co.uk'),
+        ('Alice Wonder <alice+tag@example.com>', 'Alice Wonder', 'alice+tag@example.com'),
+    ])
+    def test_valid_name_email_with_validation(
+        self,
+        name_email_basic_pattern: re.Pattern[str],
+        test_input: str,
+        expected_name: str | None,
+        expected_email: str,
+    ) -> None:
+        """Test valid name+email with strict email validation."""
+        match = name_email_basic_pattern.match(test_input)
+        assert match is not None, f"Failed to match: {test_input}"
+
+        # Extract name and email from whichever group matched
+        name = match.group('name1') or match.group('name2')
+        email = (
+            match.group('email1') or match.group('email2') or
+            match.group('email3') or match.group('email4')
+        )
+
+        assert name == expected_name, f"Expected name '{expected_name}', got '{name}'"
+        assert email == expected_email, f"Expected email '{expected_email}', got '{email}'"
+
+    @pytest.mark.parametrize("invalid_input", [
+        '"John Doe" <invalid.email>',  # invalid email format
+        'John Doe <@example.com>',  # missing local part
+        '<user@>',  # missing domain
+        'user@domain',  # no TLD
+        '"Name" <user @example.com>',  # space in email
+        '<.user@example.com>',  # starts with dot
+        'user@-example.com',  # domain starts with hyphen
+        'Name <user@example.c>',  # TLD too short
+        'Name <user@example.toolongdomain>',  # TLD too long
+    ])
+    def test_invalid_email_format_rejected(
+        self, name_email_basic_pattern: re.Pattern[str], invalid_input: str
+    ) -> None:
+        """Test that inputs with invalid email formats are rejected."""
+        assert not name_email_basic_pattern.match(invalid_input), (
+            f"Incorrectly matched invalid input: {invalid_input}"
+        )
+
+    def test_quoted_name_with_valid_email(
+        self, name_email_basic_pattern: re.Pattern[str]
+    ) -> None:
+        """Test quoted name format with valid email."""
+        match = name_email_basic_pattern.match('"Alice Wonder" <alice@example.com>')
+        assert match is not None
+        assert match.group('name1') == 'Alice Wonder'
+        assert match.group('email1') == 'alice@example.com'
+
+    def test_unquoted_name_with_valid_email(
+        self, name_email_basic_pattern: re.Pattern[str]
+    ) -> None:
+        """Test unquoted name format with valid email."""
+        match = name_email_basic_pattern.match('Bob Builder <bob@example.com>')
+        assert match is not None
+        assert match.group('name2') == 'Bob Builder'
+        assert match.group('email2') == 'bob@example.com'
+
+    def test_email_only_formats(
+        self, name_email_basic_pattern: re.Pattern[str]
+    ) -> None:
+        """Test email-only formats (with and without brackets)."""
+        # With brackets
+        match1 = name_email_basic_pattern.match('<charlie@example.com>')
+        assert match1 is not None
+        assert match1.group('email3') == 'charlie@example.com'
+
+        # Without brackets
+        match2 = name_email_basic_pattern.match('dave@example.com')
+        assert match2 is not None
+        assert match2.group('email4') == 'dave@example.com'
+
+    def test_whitespace_handling(
+        self, name_email_basic_pattern: re.Pattern[str]
+    ) -> None:
+        """Test that leading/trailing whitespace is handled correctly."""
+        match = name_email_basic_pattern.match('   "User" <user@example.com>   ')
+        assert match is not None
+        assert match.group('name1') == 'User'
+        assert match.group('email1') == 'user@example.com'
+
+    def test_special_characters_in_local_part(
+        self, name_email_basic_pattern: re.Pattern[str]
+    ) -> None:
+        """Test email with special characters in local part."""
+        match = name_email_basic_pattern.match('Test User <test!#$%&\'*+-/=?^_`{|}~@example.com>')
+        assert match is not None
+        assert match.group('name2') == 'Test User'
+        assert match.group('email2') == 'test!#$%&\'*+-/=?^_`{|}~@example.com'
+
+
 class TestDomainWithLocalhostRegex:
    """Test cases for DOMAIN_WITH_LOCALHOST_REGEX pattern."""

--- a/tests/unit/config_handling/test_settings_loader.py
+++ b/tests/unit/config_handling/test_settings_loader.py
@@ -16,7 +16,7 @@ class TestSettingsLoaderInit:

    def test_init_with_valid_config_file(self, tmp_path: Path):
        """Test initialization with a valid config file"""
-        config_file = tmp_path / "test.ini"
+        config_file = tmp_path.joinpath("test.ini")
        config_file.write_text("[Section]\nkey=value\n")

        loader = SettingsLoader(
@@ -35,7 +35,7 @@ class TestSettingsLoaderInit:

    def test_init_with_missing_config_file(self, tmp_path: Path):
        """Test initialization with missing config file"""
-        config_file = tmp_path / "missing.ini"
+        config_file = tmp_path.joinpath("missing.ini")

        loader = SettingsLoader(
            args={},
@@ -60,7 +60,7 @@ class TestSettingsLoaderInit:

    def test_init_with_log(self, tmp_path: Path):
        """Test initialization with Log object"""
-        config_file = tmp_path / "test.ini"
+        config_file = tmp_path.joinpath("test.ini")
        config_file.write_text("[Section]\nkey=value\n")
        mock_log = Mock(spec=Log)

@@ -80,7 +80,7 @@ class TestLoadSettings:

    def test_load_settings_basic(self, tmp_path: Path):
        """Test loading basic settings without validation"""
-        config_file = tmp_path / "test.ini"
+        config_file = tmp_path.joinpath("test.ini")
        config_file.write_text("[TestSection]\nkey1=value1\nkey2=value2\n")

        loader = SettingsLoader(args={}, config_file=config_file)
@@ -90,7 +90,7 @@ class TestLoadSettings:

    def test_load_settings_with_missing_section(self, tmp_path: Path):
        """Test loading settings with missing section"""
-        config_file = tmp_path / "test.ini"
+        config_file = tmp_path.joinpath("test.ini")
        config_file.write_text("[OtherSection]\nkey=value\n")

        loader = SettingsLoader(args={}, config_file=config_file)
@@ -100,7 +100,7 @@ class TestLoadSettings:

    def test_load_settings_allow_not_exist(self, tmp_path: Path):
        """Test loading settings with allow_not_exist flag"""
-        config_file = tmp_path / "test.ini"
+        config_file = tmp_path.joinpath("test.ini")
        config_file.write_text("[OtherSection]\nkey=value\n")

        loader = SettingsLoader(args={}, config_file=config_file)
@@ -110,7 +110,7 @@ class TestLoadSettings:

    def test_load_settings_mandatory_field_present(self, tmp_path: Path):
        """Test mandatory field validation when field is present"""
-        config_file = tmp_path / "test.ini"
+        config_file = tmp_path.joinpath("test.ini")
        config_file.write_text("[TestSection]\nrequired_field=value\n")

        loader = SettingsLoader(args={}, config_file=config_file)
@@ -123,7 +123,7 @@ class TestLoadSettings:

    def test_load_settings_mandatory_field_missing(self, tmp_path: Path):
        """Test mandatory field validation when field is missing"""
-        config_file = tmp_path / "test.ini"
+        config_file = tmp_path.joinpath("test.ini")
        config_file.write_text("[TestSection]\nother_field=value\n")

        loader = SettingsLoader(args={}, config_file=config_file)
@@ -136,7 +136,7 @@ class TestLoadSettings:

    def test_load_settings_mandatory_field_empty(self, tmp_path: Path):
        """Test mandatory field validation when field is empty"""
-        config_file = tmp_path / "test.ini"
+        config_file = tmp_path.joinpath("test.ini")
        config_file.write_text("[TestSection]\nrequired_field=\n")

        loader = SettingsLoader(args={}, config_file=config_file)
@@ -149,7 +149,7 @@ class TestLoadSettings:

    def test_load_settings_with_split(self, tmp_path: Path):
        """Test splitting values into lists"""
-        config_file = tmp_path / "test.ini"
+        config_file = tmp_path.joinpath("test.ini")
        config_file.write_text("[TestSection]\nlist_field=a,b,c,d\n")

        loader = SettingsLoader(args={}, config_file=config_file)
@@ -162,7 +162,7 @@ class TestLoadSettings:

    def test_load_settings_with_custom_split_char(self, tmp_path: Path):
        """Test splitting with custom delimiter"""
-        config_file = tmp_path / "test.ini"
+        config_file = tmp_path.joinpath("test.ini")
        config_file.write_text("[TestSection]\nlist_field=a|b|c|d\n")

        loader = SettingsLoader(args={}, config_file=config_file)
@@ -175,7 +175,7 @@ class TestLoadSettings:

    def test_load_settings_split_removes_spaces(self, tmp_path: Path):
        """Test that split removes spaces from values"""
-        config_file = tmp_path / "test.ini"
+        config_file = tmp_path.joinpath("test.ini")
        config_file.write_text("[TestSection]\nlist_field=a, b , c , d\n")

        loader = SettingsLoader(args={}, config_file=config_file)
@@ -188,7 +188,7 @@ class TestLoadSettings:

    def test_load_settings_empty_split_char_fallback(self, tmp_path: Path, capsys: CaptureFixture[str]):
        """Test fallback to default split char when empty"""
-        config_file = tmp_path / "test.ini"
+        config_file = tmp_path.joinpath("test.ini")
        config_file.write_text("[TestSection]\nlist_field=a,b,c\n")

        loader = SettingsLoader(args={}, config_file=config_file)
@@ -201,9 +201,22 @@ class TestLoadSettings:
        captured = capsys.readouterr()
        assert "fallback to:" in captured.out

+    def test_load_settings_split_empty_value(self, tmp_path: Path):
+        """Test that split on empty value results in empty list"""
+        config_file = tmp_path.joinpath("test.ini")
+        config_file.write_text("[TestSection]\nlist_field=\n")
+
+        loader = SettingsLoader(args={}, config_file=config_file)
+        result = loader.load_settings(
+            "TestSection",
+            {"list_field": ["split:,"]}
+        )
+
+        assert result["list_field"] == []
+
    def test_load_settings_convert_to_int(self, tmp_path: Path):
        """Test converting values to int"""
-        config_file = tmp_path / "test.ini"
+        config_file = tmp_path.joinpath("test.ini")
        config_file.write_text("[TestSection]\nnumber=123\n")

        loader = SettingsLoader(args={}, config_file=config_file)
@@ -217,7 +230,7 @@ class TestLoadSettings:

    def test_load_settings_convert_to_float(self, tmp_path: Path):
        """Test converting values to float"""
-        config_file = tmp_path / "test.ini"
+        config_file = tmp_path.joinpath("test.ini")
        config_file.write_text("[TestSection]\nnumber=123.45\n")

        loader = SettingsLoader(args={}, config_file=config_file)
@@ -231,7 +244,7 @@ class TestLoadSettings:

    def test_load_settings_convert_to_bool_true(self, tmp_path: Path):
        """Test converting values to boolean True"""
-        config_file = tmp_path / "test.ini"
+        config_file = tmp_path.joinpath("test.ini")
        config_file.write_text("[TestSection]\nflag1=true\nflag2=True\n")

        loader = SettingsLoader(args={}, config_file=config_file)
@@ -245,7 +258,7 @@ class TestLoadSettings:

    def test_load_settings_convert_to_bool_false(self, tmp_path: Path):
        """Test converting values to boolean False"""
-        config_file = tmp_path / "test.ini"
+        config_file = tmp_path.joinpath("test.ini")
        config_file.write_text("[TestSection]\nflag1=false\nflag2=False\n")

        loader = SettingsLoader(args={}, config_file=config_file)
@@ -259,7 +272,7 @@ class TestLoadSettings:

    def test_load_settings_convert_invalid_type(self, tmp_path: Path):
        """Test converting with invalid type raises error"""
-        config_file = tmp_path / "test.ini"
+        config_file = tmp_path.joinpath("test.ini")
        config_file.write_text("[TestSection]\nvalue=test\n")

        loader = SettingsLoader(args={}, config_file=config_file)
@@ -272,7 +285,7 @@ class TestLoadSettings:

    def test_load_settings_empty_set_to_none(self, tmp_path: Path):
        """Test setting empty values to None"""
-        config_file = tmp_path / "test.ini"
+        config_file = tmp_path.joinpath("test.ini")
        config_file.write_text("[TestSection]\nother=value\n")

        loader = SettingsLoader(args={}, config_file=config_file)
@@ -285,7 +298,7 @@ class TestLoadSettings:

    def test_load_settings_empty_set_to_custom_value(self, tmp_path: Path):
        """Test setting empty values to custom value"""
-        config_file = tmp_path / "test.ini"
+        config_file = tmp_path.joinpath("test.ini")
        config_file.write_text("[TestSection]\nother=value\n")

        loader = SettingsLoader(args={}, config_file=config_file)
@@ -298,7 +311,7 @@ class TestLoadSettings:

    def test_load_settings_matching_valid(self, tmp_path: Path):
        """Test matching validation with valid value"""
-        config_file = tmp_path / "test.ini"
+        config_file = tmp_path.joinpath("test.ini")
        config_file.write_text("[TestSection]\nmode=production\n")

        loader = SettingsLoader(args={}, config_file=config_file)
@@ -311,7 +324,7 @@ class TestLoadSettings:

    def test_load_settings_matching_invalid(self, tmp_path: Path):
        """Test matching validation with invalid value"""
-        config_file = tmp_path / "test.ini"
+        config_file = tmp_path.joinpath("test.ini")
        config_file.write_text("[TestSection]\nmode=invalid\n")

        loader = SettingsLoader(args={}, config_file=config_file)
@@ -324,7 +337,7 @@ class TestLoadSettings:

    def test_load_settings_in_valid(self, tmp_path: Path):
        """Test 'in' validation with valid value"""
-        config_file = tmp_path / "test.ini"
+        config_file = tmp_path.joinpath("test.ini")
        config_file.write_text("[TestSection]\nallowed=a,b,c\nvalue=b\n")

        loader = SettingsLoader(args={}, config_file=config_file)
@@ -340,7 +353,7 @@ class TestLoadSettings:

    def test_load_settings_in_invalid(self, tmp_path: Path):
        """Test 'in' validation with invalid value"""
-        config_file = tmp_path / "test.ini"
+        config_file = tmp_path.joinpath("test.ini")
        config_file.write_text("[TestSection]\nallowed=a,b,c\nvalue=d\n")

        loader = SettingsLoader(args={}, config_file=config_file)
@@ -356,7 +369,7 @@ class TestLoadSettings:

    def test_load_settings_in_missing_target(self, tmp_path: Path):
        """Test 'in' validation with missing target"""
-        config_file = tmp_path / "test.ini"
+        config_file = tmp_path.joinpath("test.ini")
        config_file.write_text("[TestSection]\nvalue=a\n")

        loader = SettingsLoader(args={}, config_file=config_file)
@@ -369,7 +382,7 @@ class TestLoadSettings:

    def test_load_settings_length_exact(self, tmp_path: Path):
        """Test length validation with exact match"""
-        config_file = tmp_path / "test.ini"
+        config_file = tmp_path.joinpath("test.ini")
        config_file.write_text("[TestSection]\nvalue=test\n")

        loader = SettingsLoader(args={}, config_file=config_file)
@@ -382,7 +395,7 @@ class TestLoadSettings:

    def test_load_settings_length_exact_invalid(self, tmp_path: Path):
        """Test length validation with exact match failure"""
-        config_file = tmp_path / "test.ini"
+        config_file = tmp_path.joinpath("test.ini")
        config_file.write_text("[TestSection]\nvalue=test\n")

        loader = SettingsLoader(args={}, config_file=config_file)
@@ -395,7 +408,7 @@ class TestLoadSettings:

    def test_load_settings_length_range(self, tmp_path: Path):
        """Test length validation with range"""
-        config_file = tmp_path / "test.ini"
+        config_file = tmp_path.joinpath("test.ini")
        config_file.write_text("[TestSection]\nvalue=testing\n")

        loader = SettingsLoader(args={}, config_file=config_file)
@@ -408,7 +421,7 @@ class TestLoadSettings:

    def test_load_settings_length_min_only(self, tmp_path: Path):
        """Test length validation with minimum only"""
-        config_file = tmp_path / "test.ini"
+        config_file = tmp_path.joinpath("test.ini")
        config_file.write_text("[TestSection]\nvalue=testing\n")

        loader = SettingsLoader(args={}, config_file=config_file)
@@ -421,7 +434,7 @@ class TestLoadSettings:

    def test_load_settings_length_max_only(self, tmp_path: Path):
        """Test length validation with maximum only"""
-        config_file = tmp_path / "test.ini"
+        config_file = tmp_path.joinpath("test.ini")
        config_file.write_text("[TestSection]\nvalue=test\n")

        loader = SettingsLoader(args={}, config_file=config_file)
@@ -434,7 +447,7 @@ class TestLoadSettings:

    def test_load_settings_range_valid(self, tmp_path: Path):
        """Test range validation with valid value"""
-        config_file = tmp_path / "test.ini"
+        config_file = tmp_path.joinpath("test.ini")
        config_file.write_text("[TestSection]\nnumber=25\n")

        loader = SettingsLoader(args={}, config_file=config_file)
@@ -447,7 +460,7 @@ class TestLoadSettings:

    def test_load_settings_range_invalid(self, tmp_path: Path):
        """Test range validation with invalid value"""
-        config_file = tmp_path / "test.ini"
+        config_file = tmp_path.joinpath("test.ini")
        config_file.write_text("[TestSection]\nnumber=100\n")

        loader = SettingsLoader(args={}, config_file=config_file)
@@ -460,7 +473,7 @@ class TestLoadSettings:

    def test_load_settings_check_int_valid(self, tmp_path: Path):
        """Test check:int with valid integer"""
-        config_file = tmp_path / "test.ini"
+        config_file = tmp_path.joinpath("test.ini")
        config_file.write_text("[TestSection]\nnumber=12345\n")

        loader = SettingsLoader(args={}, config_file=config_file)
@@ -473,7 +486,7 @@ class TestLoadSettings:

    def test_load_settings_check_int_cleanup(self, tmp_path: Path):
        """Test check:int with cleanup"""
-        config_file = tmp_path / "test.ini"
+        config_file = tmp_path.joinpath("test.ini")
        config_file.write_text("[TestSection]\nnumber=12a34b5\n")

        loader = SettingsLoader(args={}, config_file=config_file)
@@ -486,7 +499,7 @@ class TestLoadSettings:

    def test_load_settings_check_email_valid(self, tmp_path: Path):
        """Test check:string.email.basic with valid email"""
-        config_file = tmp_path / "test.ini"
+        config_file = tmp_path.joinpath("test.ini")
        config_file.write_text("[TestSection]\nemail=test@example.com\n")

        loader = SettingsLoader(args={}, config_file=config_file)
@@ -499,7 +512,7 @@ class TestLoadSettings:

    def test_load_settings_check_email_invalid(self, tmp_path: Path):
        """Test check:string.email.basic with invalid email"""
-        config_file = tmp_path / "test.ini"
+        config_file = tmp_path.joinpath("test.ini")
        config_file.write_text("[TestSection]\nemail=not-an-email\n")

        loader = SettingsLoader(args={}, config_file=config_file)
@@ -512,7 +525,7 @@ class TestLoadSettings:

    def test_load_settings_args_override(self, tmp_path: Path, capsys: CaptureFixture[str]):
        """Test command line arguments override config values"""
-        config_file = tmp_path / "test.ini"
+        config_file = tmp_path.joinpath("test.ini")
        config_file.write_text("[TestSection]\nvalue=config_value\n")

        loader = SettingsLoader(
@@ -530,7 +543,7 @@ class TestLoadSettings:

    def test_load_settings_args_no_flag(self, tmp_path: Path, capsys: CaptureFixture[str]):
        """Test default behavior (no args_override:yes) with list argument that has split"""
-        config_file = tmp_path / "test.ini"
+        config_file = tmp_path.joinpath("test.ini")
        config_file.write_text("[TestSection]\nvalue=a,b,c\n")

        loader = SettingsLoader(
@@ -550,7 +563,7 @@ class TestLoadSettings:

    def test_load_settings_args_list_no_split(self, tmp_path: Path, capsys: CaptureFixture[str]):
        """Test that list arguments without split entry are skipped"""
-        config_file = tmp_path / "test.ini"
+        config_file = tmp_path.joinpath("test.ini")
        config_file.write_text("[TestSection]\nvalue=config_value\n")

        loader = SettingsLoader(
@@ -570,7 +583,7 @@ class TestLoadSettings:

    def test_load_settings_args_list_with_split(self, tmp_path: Path, capsys: CaptureFixture[str]):
        """Test that list arguments with split entry and args_override:yes are applied"""
-        config_file = tmp_path / "test.ini"
+        config_file = tmp_path.joinpath("test.ini")
        config_file.write_text("[TestSection]\nvalue=a,b,c\n")

        loader = SettingsLoader(
@@ -589,7 +602,7 @@ class TestLoadSettings:

    def test_load_settings_args_no_with_mandatory(self, tmp_path: Path, capsys: CaptureFixture[str]):
        """Test default behavior (no args_override:yes) with mandatory field and list args with split"""
-        config_file = tmp_path / "test.ini"
+        config_file = tmp_path.joinpath("test.ini")
        config_file.write_text("[TestSection]\nvalue=config1,config2\n")

        loader = SettingsLoader(
@@ -609,7 +622,7 @@ class TestLoadSettings:

    def test_load_settings_args_no_with_mandatory_valid(self, tmp_path: Path, capsys: CaptureFixture[str]):
        """Test default behavior with string args (always overrides due to current logic)"""
-        config_file = tmp_path / "test.ini"
+        config_file = tmp_path.joinpath("test.ini")
        config_file.write_text("[TestSection]\nvalue=config_value\n")

        loader = SettingsLoader(
@@ -628,7 +641,7 @@ class TestLoadSettings:

    def test_load_settings_args_string_no_split(self, tmp_path: Path, capsys: CaptureFixture[str]):
        """Test that string arguments with args_override:yes work normally"""
-        config_file = tmp_path / "test.ini"
+        config_file = tmp_path.joinpath("test.ini")
        config_file.write_text("[TestSection]\nvalue=config_value\n")

        loader = SettingsLoader(
@@ -647,7 +660,7 @@ class TestLoadSettings:

    def test_load_settings_no_config_file_with_args(self, tmp_path: Path):
        """Test loading settings without config file but with mandatory args"""
-        config_file = tmp_path / "missing.ini"
+        config_file = tmp_path.joinpath("missing.ini")

        loader = SettingsLoader(
            args={"required": "value"},
@@ -662,7 +675,7 @@ class TestLoadSettings:

    def test_load_settings_no_config_file_missing_args(self, tmp_path: Path):
        """Test loading settings without config file and missing args"""
-        config_file = tmp_path / "missing.ini"
+        config_file = tmp_path.joinpath("missing.ini")

        loader = SettingsLoader(args={}, config_file=config_file)

@@ -674,7 +687,7 @@ class TestLoadSettings:

    def test_load_settings_check_list_with_split(self, tmp_path: Path):
        """Test check validation with list values"""
-        config_file = tmp_path / "test.ini"
+        config_file = tmp_path.joinpath("test.ini")
        config_file.write_text("[TestSection]\nlist=abc,def,ghi\n")

        loader = SettingsLoader(args={}, config_file=config_file)
@@ -687,7 +700,7 @@ class TestLoadSettings:

    def test_load_settings_check_list_cleanup(self, tmp_path: Path):
        """Test check validation cleans up list values"""
-        config_file = tmp_path / "test.ini"
+        config_file = tmp_path.joinpath("test.ini")
        config_file.write_text("[TestSection]\nlist=ab-c,de_f,gh!i\n")

        loader = SettingsLoader(args={}, config_file=config_file)
@@ -700,7 +713,7 @@ class TestLoadSettings:

    def test_load_settings_invalid_check_type(self, tmp_path: Path):
        """Test with invalid check type"""
-        config_file = tmp_path / "test.ini"
+        config_file = tmp_path.joinpath("test.ini")
        config_file.write_text("[TestSection]\nvalue=test\n")

        loader = SettingsLoader(args={}, config_file=config_file)
@@ -717,7 +730,7 @@ class TestComplexScenarios:

    def test_complex_validation_scenario(self, tmp_path: Path):
        """Test complex scenario with multiple validations"""
-        config_file = tmp_path / "test.ini"
+        config_file = tmp_path.joinpath("test.ini")
        config_file.write_text(
            "[Production]\n"
            "environment=production\n"
@@ -758,7 +771,7 @@ class TestComplexScenarios:

    def test_email_list_validation(self, tmp_path: Path):
        """Test email list with validation"""
-        config_file = tmp_path / "test.ini"
+        config_file = tmp_path.joinpath("test.ini")
        config_file.write_text(
            "[EmailConfig]\n"
            "emails=test@example.com,admin@domain.org,user+tag@site.co.uk\n"
@@ -775,7 +788,7 @@ class TestComplexScenarios:

    def test_mixed_args_and_config(self, tmp_path: Path):
        """Test mixing command line args and config file"""
-        config_file = tmp_path / "test.ini"
+        config_file = tmp_path.joinpath("test.ini")
        config_file.write_text(
            "[Settings]\n"
            "value1=config_value1\n"
@@ -796,7 +809,7 @@ class TestComplexScenarios:

    def test_multiple_check_types(self, tmp_path: Path):
        """Test multiple different check types"""
-        config_file = tmp_path / "test.ini"
+        config_file = tmp_path.joinpath("test.ini")
        config_file.write_text(
            "[Checks]\n"
            "numbers=123,456,789\n"
@@ -823,7 +836,7 @@ class TestComplexScenarios:

    def test_args_no_and_list_skip_combination(self, tmp_path: Path, capsys: CaptureFixture[str]):
        """Test combination of args_override:yes flag and list argument skip behavior"""
-        config_file = tmp_path / "test.ini"
+        config_file = tmp_path.joinpath("test.ini")
        config_file.write_text(
            "[Settings]\n"
            "no_override=a,b,c\n"
--- a/tests/unit/db_handling/test_sql_main.py
+++ b/tests/unit/db_handling/test_sql_main.py
@@ -0,0 +1,461 @@
+"""
+PyTest: db_handling/sql_main
+Tests for SQLMain class - Main SQL interface wrapper
+
+Note: Pylance warnings about "Redefining name from outer scope" in fixtures are expected.
+This is standard pytest fixture behavior where fixture parameters shadow fixture definitions.
+"""
+# pylint: disable=redefined-outer-name,too-many-public-methods,protected-access
+# pyright: reportUnknownParameterType=false, reportUnknownArgumentType=false
+# pyright: reportMissingParameterType=false, reportUnknownVariableType=false
+# pyright: reportArgumentType=false, reportGeneralTypeIssues=false
+
+from pathlib import Path
+from typing import Generator
+from unittest.mock import MagicMock, patch
+import pytest
+from corelibs.db_handling.sql_main import SQLMain, IDENT_SPLIT_CHARACTER
+from corelibs.db_handling.sqlite_io import SQLiteIO
+
+
+# Test fixtures
+@pytest.fixture
+def mock_logger() -> MagicMock:
+    """Create a mock logger for testing"""
+    logger = MagicMock()
+    logger.debug = MagicMock()
+    logger.info = MagicMock()
+    logger.warning = MagicMock()
+    logger.error = MagicMock()
+    return logger
+
+
+@pytest.fixture
+def temp_db_path(tmp_path: Path) -> Path:
+    """Create a temporary database file path"""
+    return tmp_path / "test_database.db"
+
+
+@pytest.fixture
+def mock_sqlite_io() -> Generator[MagicMock, None, None]:
+    """Create a mock SQLiteIO instance"""
+    mock_io = MagicMock(spec=SQLiteIO)
+    mock_io.conn = MagicMock()
+    mock_io.db_connected = MagicMock(return_value=True)
+    mock_io.db_close = MagicMock()
+    mock_io.execute_query = MagicMock(return_value=[])
+    yield mock_io
+
+
+# Test constant
+class TestConstants:
+    """Tests for module-level constants"""
+
+    def test_ident_split_character(self):
+        """Test that IDENT_SPLIT_CHARACTER is defined correctly"""
+        assert IDENT_SPLIT_CHARACTER == ':'
+
+
+# Test SQLMain class initialization
+class TestSQLMainInit:
+    """Tests for SQLMain.__init__"""
+
+    @patch('corelibs.db_handling.sql_main.SQLiteIO')
+    def test_successful_initialization_sqlite(
+        self, mock_sqlite_class: MagicMock, mock_logger: MagicMock, temp_db_path: Path
+    ):
+        """Test successful initialization with SQLite"""
+        mock_sqlite_instance = MagicMock()
+        mock_sqlite_instance.conn = MagicMock()
+        mock_sqlite_instance.db_connected = MagicMock(return_value=True)
+        mock_sqlite_class.return_value = mock_sqlite_instance
+
+        db_ident = f'sqlite:{temp_db_path}'
+        sql_main = SQLMain(mock_logger, db_ident)
+
+        assert sql_main.log == mock_logger
+        assert sql_main.dbh == mock_sqlite_instance
+        assert sql_main.db_target == 'sqlite'
+        mock_sqlite_class.assert_called_once_with(mock_logger, str(temp_db_path), row_factory='Dict')
+
+    @patch('corelibs.db_handling.sql_main.SQLiteIO')
+    def test_initialization_connection_failure(self, mock_sqlite_class: MagicMock, mock_logger: MagicMock):
+        """Test initialization fails when connection cannot be established"""
+        mock_sqlite_instance = MagicMock()
+        mock_sqlite_instance.conn = None
+        mock_sqlite_instance.db_connected = MagicMock(return_value=False)
+        mock_sqlite_class.return_value = mock_sqlite_instance
+
+        db_ident = 'sqlite:/path/to/db.db'
+        with pytest.raises(ValueError, match='DB Connection failed for: sqlite'):
+            SQLMain(mock_logger, db_ident)
+
+    def test_initialization_invalid_db_target(self, mock_logger: MagicMock):
+        """Test initialization with unsupported database target"""
+        db_ident = 'postgresql:/path/to/db'
+        with pytest.raises(ValueError, match='SQL interface for postgresql is not implemented'):
+            SQLMain(mock_logger, db_ident)
+
+    def test_initialization_malformed_db_ident(self, mock_logger: MagicMock):
+        """Test initialization with malformed db_ident string"""
+        db_ident = 'sqlite_no_colon'
+        with pytest.raises(ValueError):
+            SQLMain(mock_logger, db_ident)
+
+
+# Test SQLMain.connect method
+class TestSQLMainConnect:
+    """Tests for SQLMain.connect"""
+
+    @patch('corelibs.db_handling.sql_main.SQLiteIO')
+    def test_connect_when_already_connected(
+        self, mock_sqlite_class: MagicMock, mock_logger: MagicMock, temp_db_path: Path
+    ):
+        """Test connect warns when already connected"""
+        mock_sqlite_instance = MagicMock()
+        mock_sqlite_instance.conn = MagicMock()
+        mock_sqlite_instance.db_connected = MagicMock(return_value=True)
+        mock_sqlite_class.return_value = mock_sqlite_instance
+
+        db_ident = f'sqlite:{temp_db_path}'
+        sql_main = SQLMain(mock_logger, db_ident)
+
+        # Reset mock to check second call
+        mock_logger.warning.reset_mock()
+
+        # Try to connect again
+        sql_main.connect(f'sqlite:{temp_db_path}')
+
+        # Should have warned about existing connection
+        mock_logger.warning.assert_called_once()
+        assert 'already exists' in str(mock_logger.warning.call_args)
+
+    @patch('corelibs.db_handling.sql_main.SQLiteIO')
+    def test_connect_sqlite_success(
+        self, mock_sqlite_class: MagicMock, mock_logger: MagicMock, temp_db_path: Path
+    ):
+        """Test successful SQLite connection"""
+        mock_sqlite_instance = MagicMock()
+        mock_sqlite_instance.conn = MagicMock()
+        mock_sqlite_instance.db_connected = MagicMock(return_value=True)
+        mock_sqlite_class.return_value = mock_sqlite_instance
+
+        sql_main = SQLMain.__new__(SQLMain)
+        sql_main.log = mock_logger
+        sql_main.dbh = None
+        sql_main.db_target = None
+
+        db_ident = f'sqlite:{temp_db_path}'
+        sql_main.connect(db_ident)
+
+        assert sql_main.db_target == 'sqlite'
+        assert sql_main.dbh == mock_sqlite_instance
+        mock_sqlite_class.assert_called_once_with(mock_logger, str(temp_db_path), row_factory='Dict')
+
+    def test_connect_unsupported_database(self, mock_logger: MagicMock):
+        """Test connect with unsupported database type"""
+        sql_main = SQLMain.__new__(SQLMain)
+        sql_main.log = mock_logger
+        sql_main.dbh = None
+        sql_main.db_target = None
+
+        db_ident = 'mysql:/path/to/db'
+        with pytest.raises(ValueError, match='SQL interface for mysql is not implemented'):
+            sql_main.connect(db_ident)
+
+    @patch('corelibs.db_handling.sql_main.SQLiteIO')
+    def test_connect_db_connection_failed(
+        self, mock_sqlite_class: MagicMock, mock_logger: MagicMock, temp_db_path: Path
+    ):
+        """Test connect raises error when DB connection fails"""
+        mock_sqlite_instance = MagicMock()
+        mock_sqlite_instance.db_connected = MagicMock(return_value=False)
+        mock_sqlite_class.return_value = mock_sqlite_instance
+
+        sql_main = SQLMain.__new__(SQLMain)
+        sql_main.log = mock_logger
+        sql_main.dbh = None
+        sql_main.db_target = None
+
+        db_ident = f'sqlite:{temp_db_path}'
+        with pytest.raises(ValueError, match='DB Connection failed for: sqlite'):
+            sql_main.connect(db_ident)
+
+
+# Test SQLMain.close method
+class TestSQLMainClose:
+    """Tests for SQLMain.close"""
+
+    @patch('corelibs.db_handling.sql_main.SQLiteIO')
+    def test_close_successful(
+        self, mock_sqlite_class: MagicMock, mock_logger: MagicMock, temp_db_path: Path
+    ):
+        """Test successful database close"""
+        mock_sqlite_instance = MagicMock()
+        mock_sqlite_instance.conn = MagicMock()
+        mock_sqlite_instance.db_connected = MagicMock(return_value=True)
+        mock_sqlite_instance.db_close = MagicMock()
+        mock_sqlite_class.return_value = mock_sqlite_instance
+
+        db_ident = f'sqlite:{temp_db_path}'
+        sql_main = SQLMain(mock_logger, db_ident)
+
+        sql_main.close()
+
+        mock_sqlite_instance.db_close.assert_called_once()
+
+    @patch('corelibs.db_handling.sql_main.SQLiteIO')
+    def test_close_when_not_connected(
+        self, mock_sqlite_class: MagicMock, mock_logger: MagicMock, temp_db_path: Path
+    ):
+        """Test close when not connected does nothing"""
+        mock_sqlite_instance = MagicMock()
+        mock_sqlite_instance.conn = MagicMock()
+        mock_sqlite_instance.db_connected = MagicMock(return_value=True)
+        mock_sqlite_instance.db_close = MagicMock()
+        mock_sqlite_class.return_value = mock_sqlite_instance
+
+        db_ident = f'sqlite:{temp_db_path}'
+        sql_main = SQLMain(mock_logger, db_ident)
+
+        # Change db_connected to return False to simulate disconnection
+        mock_sqlite_instance.db_connected = MagicMock(return_value=False)
+
+        sql_main.close()
+
+        # Should not raise error and should exit early
+        assert mock_sqlite_instance.db_close.call_count == 0
+
+    def test_close_when_dbh_is_none(self, mock_logger: MagicMock):
+        """Test close when dbh is None"""
+        sql_main = SQLMain.__new__(SQLMain)
+        sql_main.log = mock_logger
+        sql_main.dbh = None
+        sql_main.db_target = 'sqlite'
+
+        # Should not raise error
+        sql_main.close()
+
+
+# Test SQLMain.connected method
+class TestSQLMainConnected:
+    """Tests for SQLMain.connected"""
+
+    @patch('corelibs.db_handling.sql_main.SQLiteIO')
+    def test_connected_returns_true(
+        self, mock_sqlite_class: MagicMock, mock_logger: MagicMock, temp_db_path: Path
+    ):
+        """Test connected returns True when connected"""
+        mock_sqlite_instance = MagicMock()
+        mock_sqlite_instance.conn = MagicMock()
+        mock_sqlite_instance.db_connected = MagicMock(return_value=True)
+        mock_sqlite_class.return_value = mock_sqlite_instance
+
+        db_ident = f'sqlite:{temp_db_path}'
+        sql_main = SQLMain(mock_logger, db_ident)
+
+        assert sql_main.connected() is True
+        mock_logger.warning.assert_not_called()
+
+    @patch('corelibs.db_handling.sql_main.SQLiteIO')
+    def test_connected_returns_false_when_not_connected(
+        self, mock_sqlite_class: MagicMock, mock_logger: MagicMock, temp_db_path: Path
+    ):
+        """Test connected returns False and warns when not connected"""
+        mock_sqlite_instance = MagicMock()
+        mock_sqlite_instance.conn = MagicMock()
+        mock_sqlite_instance.db_connected = MagicMock(return_value=True)
+        mock_sqlite_class.return_value = mock_sqlite_instance
+
+        db_ident = f'sqlite:{temp_db_path}'
+        sql_main = SQLMain(mock_logger, db_ident)
+
+        # Reset warning calls from init
+        mock_logger.warning.reset_mock()
+
+        # Change db_connected to return False to simulate disconnection
+        mock_sqlite_instance.db_connected = MagicMock(return_value=False)
+
+        assert sql_main.connected() is False
+        mock_logger.warning.assert_called_once()
+        assert 'No connection' in str(mock_logger.warning.call_args)
+
+    def test_connected_returns_false_when_dbh_is_none(self, mock_logger: MagicMock):
+        """Test connected returns False when dbh is None"""
+        sql_main = SQLMain.__new__(SQLMain)
+        sql_main.log = mock_logger
+        sql_main.dbh = None
+        sql_main.db_target = 'sqlite'
+
+        assert sql_main.connected() is False
+        mock_logger.warning.assert_called_once()
+
+
+# Test SQLMain.process_query method
+class TestSQLMainProcessQuery:
+    """Tests for SQLMain.process_query"""
+
+    @patch('corelibs.db_handling.sql_main.SQLiteIO')
+    def test_process_query_success_no_params(
+        self, mock_sqlite_class: MagicMock, mock_logger: MagicMock, temp_db_path: Path
+    ):
+        """Test successful query execution without parameters"""
+        mock_sqlite_instance = MagicMock()
+        mock_sqlite_instance.conn = MagicMock()
+        mock_sqlite_instance.db_connected = MagicMock(return_value=True)
+        expected_result = [{'id': 1, 'name': 'test'}]
+        mock_sqlite_instance.execute_query = MagicMock(return_value=expected_result)
+        mock_sqlite_class.return_value = mock_sqlite_instance
+
+        db_ident = f'sqlite:{temp_db_path}'
+        sql_main = SQLMain(mock_logger, db_ident)
+
+        query = "SELECT * FROM test"
+        result = sql_main.process_query(query)
+
+        assert result == expected_result
+        mock_sqlite_instance.execute_query.assert_called_once_with(query, None)
+
+    @patch('corelibs.db_handling.sql_main.SQLiteIO')
+    def test_process_query_success_with_params(
+        self, mock_sqlite_class: MagicMock, mock_logger: MagicMock, temp_db_path: Path
+    ):
+        """Test successful query execution with parameters"""
+        mock_sqlite_instance = MagicMock()
+        mock_sqlite_instance.conn = MagicMock()
+        mock_sqlite_instance.db_connected = MagicMock(return_value=True)
+        expected_result = [{'id': 1, 'name': 'test'}]
+        mock_sqlite_instance.execute_query = MagicMock(return_value=expected_result)
+        mock_sqlite_class.return_value = mock_sqlite_instance
+
+        db_ident = f'sqlite:{temp_db_path}'
+        sql_main = SQLMain(mock_logger, db_ident)
+
+        query = "SELECT * FROM test WHERE id = ?"
+        params = (1,)
+        result = sql_main.process_query(query, params)
+
+        assert result == expected_result
+        mock_sqlite_instance.execute_query.assert_called_once_with(query, params)
+
+    @patch('corelibs.db_handling.sql_main.SQLiteIO')
+    def test_process_query_returns_false_on_error(
+        self, mock_sqlite_class: MagicMock, mock_logger: MagicMock, temp_db_path: Path
+    ):
+        """Test query returns False when execute_query fails"""
+        mock_sqlite_instance = MagicMock()
+        mock_sqlite_instance.conn = MagicMock()
+        mock_sqlite_instance.db_connected = MagicMock(return_value=True)
+        mock_sqlite_instance.execute_query = MagicMock(return_value=False)
+        mock_sqlite_class.return_value = mock_sqlite_instance
+
+        db_ident = f'sqlite:{temp_db_path}'
+        sql_main = SQLMain(mock_logger, db_ident)
+
+        query = "SELECT * FROM nonexistent"
+        result = sql_main.process_query(query)
+
+        assert result is False
+
+    @patch('corelibs.db_handling.sql_main.SQLiteIO')
+    def test_process_query_dbh_is_none(
+        self, mock_sqlite_class: MagicMock, mock_logger: MagicMock, temp_db_path: Path
+    ):
+        """Test query returns False when dbh is None"""
+        mock_sqlite_instance = MagicMock()
+        mock_sqlite_instance.conn = MagicMock()
+        mock_sqlite_instance.db_connected = MagicMock(return_value=True)
+        mock_sqlite_class.return_value = mock_sqlite_instance
+
+        db_ident = f'sqlite:{temp_db_path}'
+        sql_main = SQLMain(mock_logger, db_ident)
+
+        # Manually set dbh to None
+        sql_main.dbh = None
+
+        query = "SELECT * FROM test"
+        result = sql_main.process_query(query)
+
+        assert result is False
+        mock_logger.error.assert_called_once()
+        assert 'Problem connecting to db' in str(mock_logger.error.call_args)
+
+    @patch('corelibs.db_handling.sql_main.SQLiteIO')
+    def test_process_query_returns_empty_list(
+        self, mock_sqlite_class: MagicMock, mock_logger: MagicMock, temp_db_path: Path
+    ):
+        """Test query returns empty list when no results"""
+        mock_sqlite_instance = MagicMock()
+        mock_sqlite_instance.conn = MagicMock()
+        mock_sqlite_instance.db_connected = MagicMock(return_value=True)
+        mock_sqlite_instance.execute_query = MagicMock(return_value=[])
+        mock_sqlite_class.return_value = mock_sqlite_instance
+
+        db_ident = f'sqlite:{temp_db_path}'
+        sql_main = SQLMain(mock_logger, db_ident)
+
+        query = "SELECT * FROM test WHERE 1=0"
+        result = sql_main.process_query(query)
+
+        assert result == []
+
+
+# Integration-like tests
+class TestSQLMainIntegration:
+    """Integration-like tests for complete workflows"""
+
+    @patch('corelibs.db_handling.sql_main.SQLiteIO')
+    def test_full_workflow_connect_query_close(
+        self, mock_sqlite_class: MagicMock, mock_logger: MagicMock, temp_db_path: Path
+    ):
+        """Test complete workflow: connect, query, close"""
+        mock_sqlite_instance = MagicMock()
+        mock_sqlite_instance.conn = MagicMock()
+        mock_sqlite_instance.db_connected = MagicMock(return_value=True)
+        mock_sqlite_instance.execute_query = MagicMock(return_value=[{'count': 5}])
+        mock_sqlite_instance.db_close = MagicMock()
+        mock_sqlite_class.return_value = mock_sqlite_instance
+
+        db_ident = f'sqlite:{temp_db_path}'
+        sql_main = SQLMain(mock_logger, db_ident)
+
+        # Execute query
+        result = sql_main.process_query("SELECT COUNT(*) as count FROM test")
+        assert result == [{'count': 5}]
+
+        # Check connected
+        assert sql_main.connected() is True
+
+        # Close connection
+        sql_main.close()
+        mock_sqlite_instance.db_close.assert_called_once()
+
+    @patch('corelibs.db_handling.sql_main.SQLiteIO')
+    def test_multiple_queries_same_connection(
+        self, mock_sqlite_class: MagicMock, mock_logger: MagicMock, temp_db_path: Path
+    ):
+        """Test multiple queries on the same connection"""
+        mock_sqlite_instance = MagicMock()
+        mock_sqlite_instance.conn = MagicMock()
+        mock_sqlite_instance.db_connected = MagicMock(return_value=True)
+        mock_sqlite_instance.execute_query = MagicMock(side_effect=[
+            [{'id': 1}],
+            [{'id': 2}],
+            [{'id': 3}]
+        ])
+        mock_sqlite_class.return_value = mock_sqlite_instance
+
+        db_ident = f'sqlite:{temp_db_path}'
+        sql_main = SQLMain(mock_logger, db_ident)
+
+        result1 = sql_main.process_query("SELECT * FROM test WHERE id = 1")
+        result2 = sql_main.process_query("SELECT * FROM test WHERE id = 2")
+        result3 = sql_main.process_query("SELECT * FROM test WHERE id = 3")
+
+        assert result1 == [{'id': 1}]
+        assert result2 == [{'id': 2}]
+        assert result3 == [{'id': 3}]
+        assert mock_sqlite_instance.execute_query.call_count == 3
+
+
+# __END__
--- a/tests/unit/math_handling/init.py
+++ b/tests/unit/math_handling/init.py
--- a/tests/unit/math_handling/test_math_helpers.py
+++ b/tests/unit/math_handling/test_math_helpers.py
@@ -0,0 +1,121 @@
+"""
+Unit tests for math_helpers module
+"""
+
+from corelibs.math_handling.math_helpers import gcd, lcd
+
+
+class TestGcd:
+    """Test cases for the gcd (Greatest Common Divisor) function"""
+
+    def test_gcd_basic_positive_numbers(self):
+        """Test GCD with basic positive numbers"""
+        assert gcd(12, 8) == 4
+        assert gcd(15, 10) == 5
+        assert gcd(21, 14) == 7
+
+    def test_gcd_coprime_numbers(self):
+        """Test GCD with coprime numbers (GCD should be 1)"""
+        assert gcd(13, 7) == 1
+        assert gcd(17, 19) == 1
+        assert gcd(25, 49) == 1
+
+    def test_gcd_same_numbers(self):
+        """Test GCD with same numbers"""
+        assert gcd(5, 5) == 5
+        assert gcd(100, 100) == 100
+
+    def test_gcd_with_zero(self):
+        """Test GCD when one or both numbers are zero"""
+        assert gcd(0, 5) == 5
+        assert gcd(5, 0) == 5
+        assert gcd(0, 0) == 0
+
+    def test_gcd_with_one(self):
+        """Test GCD when one number is 1"""
+        assert gcd(1, 5) == 1
+        assert gcd(100, 1) == 1
+
+    def test_gcd_large_numbers(self):
+        """Test GCD with large numbers"""
+        assert gcd(1000000, 500000) == 500000
+        assert gcd(123456, 789012) == 12
+
+    def test_gcd_reversed_order(self):
+        """Test GCD is commutative (order doesn't matter)"""
+        assert gcd(12, 8) == gcd(8, 12)
+        assert gcd(100, 35) == gcd(35, 100)
+
+    def test_gcd_negative_numbers(self):
+        """Test GCD with negative numbers"""
+        assert gcd(-12, 8) == 4
+        assert gcd(12, -8) == 4
+        assert gcd(-12, -8) == 4
+
+    def test_gcd_multiples(self):
+        """Test GCD when one number is a multiple of the other"""
+        assert gcd(10, 5) == 5
+        assert gcd(100, 25) == 25
+        assert gcd(7, 21) == 7
+
+
+class TestLcd:
+    """Test cases for the lcd (Least Common Denominator/Multiple) function"""
+
+    def test_lcd_basic_positive_numbers(self):
+        """Test LCD with basic positive numbers"""
+        assert lcd(4, 6) == 12
+        assert lcd(3, 5) == 15
+        assert lcd(12, 8) == 24
+
+    def test_lcd_coprime_numbers(self):
+        """Test LCD with coprime numbers (should be their product)"""
+        assert lcd(7, 13) == 91
+        assert lcd(11, 13) == 143
+        assert lcd(5, 7) == 35
+
+    def test_lcd_same_numbers(self):
+        """Test LCD with same numbers"""
+        assert lcd(5, 5) == 5
+        assert lcd(100, 100) == 100
+
+    def test_lcd_with_one(self):
+        """Test LCD when one number is 1"""
+        assert lcd(1, 5) == 5
+        assert lcd(100, 1) == 100
+
+    def test_lcd_with_zero(self):
+        """Test LCD when one or both numbers are zero"""
+        assert lcd(0, 5) == 0
+        assert lcd(5, 0) == 0
+        assert lcd(0, 0) == 0
+
+    def test_lcd_large_numbers(self):
+        """Test LCD with large numbers"""
+        assert lcd(100, 150) == 300
+        assert lcd(1000, 500) == 1000
+
+    def test_lcd_reversed_order(self):
+        """Test LCD is commutative (order doesn't matter)"""
+        assert lcd(4, 6) == lcd(6, 4)
+        assert lcd(12, 18) == lcd(18, 12)
+
+    def test_lcd_negative_numbers(self):
+        """Test LCD with negative numbers"""
+        assert lcd(-4, 6) == 12
+        assert lcd(4, -6) == 12
+        assert lcd(-4, -6) == 12
+
+    def test_lcd_multiples(self):
+        """Test LCD when one number is a multiple of the other"""
+        assert lcd(5, 10) == 10
+        assert lcd(3, 9) == 9
+        assert lcd(25, 100) == 100
+
+    def test_lcd_gcd_relationship(self):
+        """Test the mathematical relationship between LCD and GCD: lcd(a,b) * gcd(a,b) = a * b"""
+        test_cases = [(12, 8), (15, 10), (21, 14), (100, 35)]
+        for a, b in test_cases:
+            assert lcd(a, b) * gcd(a, b) == a * b
+
+# __END__
Author	SHA1	Message	Date
Clemens Schwaighofer	ae938f9909	v0.44.0: Add more REGEX patters for email matching	2026-01-08 14:59:49 +09:00
Clemens Schwaighofer	f91e0bb93a	Add new regex constants for email handling and update related tests	2026-01-08 14:58:14 +09:00
Clemens Schwaighofer	d3f61005cf	v0.43.4: Fix for config loader with empty to split into lists values	2026-01-06 10:04:03 +09:00
Clemens Schwaighofer	2923a3e88b	Fix settings loader to return empty list when splitting empty string value	2026-01-06 09:58:21 +09:00
Clemens Schwaighofer	a73ced0067	v0.43.3: settings loader raise exception and log message text split	2025-12-24 10:25:42 +09:00
Clemens Schwaighofer	f89b91fe7f	Settings loader different log string to value error raise string	2025-12-24 10:23:27 +09:00
Clemens Schwaighofer	5950485d46	v0.43.2: add error message list reset to settings loader	2025-12-24 10:18:54 +09:00
Clemens Schwaighofer	f349927a63	Reset error message list in settings loader	2025-12-24 10:14:54 +09:00
Clemens Schwaighofer	dfe8890598	v0.43.1: settings loader update for error reporting on exception raise	2025-12-24 10:09:53 +09:00
Clemens Schwaighofer	d224876a8e	Settings loader, pass error messages to exception raise So we can get the actual error message in the exception if logging is all off	2025-12-24 10:08:38 +09:00
Clemens Schwaighofer	17e8c76b94	v0.43.0: SQLmain wrapper class, math helper functions	2025-12-18 17:24:05 +09:00
Clemens Schwaighofer	9034a31cd6	Add math helper module Currently with GCD and LCD functions, along with unit tests.	2025-12-18 17:21:14 +09:00
Clemens Schwaighofer	523e61c9f7	Add SQL Main class as general wrapper for SQL DB handling	2025-12-18 17:20:57 +09:00
Clemens Schwaighofer	cf575ded90	Update on the CSV helper class with UTF detection for BOM reading	2025-12-16 18:53:16 +09:00
Clemens Schwaighofer	11a75d8532	Settings loader error message text update	2025-12-16 09:47:40 +09:00
Clemens Schwaighofer	6593e11332	Update deprecation infor for enum base Test run add for regex checks domain name regex contants	2025-12-10 11:35:00 +09:00