2024-12-13 16:21:11 +00:00 · 2024-11-19 07:31:53 +00:00 · 2024-12-10 14:35:49 +00:00 · 2024-11-20 06:58:51 +00:00 · 2024-11-28 15:45:15 +00:00 · 2024-11-28 20:54:56 +00:00
33 changed files with 2118 additions and 26 deletions
--- a/.gitignore
+++ b/.gitignore
@ -5,3 +5,4 @@ src/tiles/
 *pycache*
 *swp
 *bak
+/.idea
--- a/README.md
+++ b/README.md
@ -7,3 +7,31 @@ Python dependencies:
 ```bash
 pip3 install -r requirements.txt
 ```
+
+## Running unittests
+
+To run all unittests execute next command from project root folder:
+
+```bash
+python3 -m unittest discover -s tests
+```
+
+this will search for all `test*.py` files within `tests` directory
+and execute tests from those files.
+
+## Running integration tests
+
+File `integration-tests/full_drules_gen.py` is intended to generate drules
+files for all 6 themes from main Organic Maps repo. It could be used to understand
+which parts of the project are actually used by Organic Maps repo.
+
+Usage:
+
+```shell
+cd integration-tests
+python3 full_drules_gen.py -d ../../../data -o drules --txt
+```
+
+This command will run generation for styles - default light, default dark,
+outdoors light, outdoors dark, vehicle light, vehicle dark and put `*.bin`
+and `*.txt` files into 'drules' subfolder.
--- a/integration-tests/drules/.gitkeep
+++ b/integration-tests/drules/.gitkeep
--- a/integration-tests/full_drules_gen.py
+++ b/integration-tests/full_drules_gen.py
@ -0,0 +1,73 @@
+#!/usr/bin/env python3
+
+import sys
+from copy import deepcopy
+from optparse import OptionParser
+from pathlib import Path
+import logging
+
+# Add `src` directory to the import paths
+sys.path.insert(0, str(Path(__file__).parent.parent / 'src'))
+
+import libkomwm
+
+FORMAT = '%(asctime)s [%(levelname)s] %(message)s'
+logging.basicConfig(format=FORMAT)
+log = logging.getLogger('test_drules_gen')
+log.setLevel(logging.INFO)
+
+styles = {
+    'default_light':  ['styles/default/light/style.mapcss',  'styles/default/include'],
+    'default_dark':   ['styles/default/dark/style.mapcss',   'styles/default/include'],
+    'outdoors_light': ['styles/outdoors/light/style.mapcss', 'styles/outdoors/include'],
+    'outdoors_dark':  ['styles/outdoors/dark/style.mapcss',  'styles/outdoors/include'],
+    'vehicle_light':  ['styles/vehicle/light/style.mapcss',  'styles/vehicle/include'],
+    'vehicle_dark':   ['styles/vehicle/dark/style.mapcss',   'styles/vehicle/include'],
+}
+
+
+def full_styles_regenerate(options):
+    log.info("Start generating styles")
+    libkomwm.MULTIPROCESSING = False
+    prio_ranges_orig = deepcopy(libkomwm.prio_ranges)
+
+    for name, (style_path, include_path) in styles.items():
+        log.info(f"Generating {name} style ...")
+
+        # Restore initial state
+        libkomwm.prio_ranges = deepcopy(prio_ranges_orig)
+        libkomwm.visibilities = {}
+
+        options.filename = options.data + '/' + style_path
+        options.priorities_path = options.data + '/' + include_path
+        options.outfile = options.outdir + '/' + name
+
+        # Run generation
+        libkomwm.komap_mapswithme(options)
+    log.info(f"Done!")
+
+def main():
+    parser = OptionParser()
+    parser.add_option("-d", "--data-path", dest="data",
+                      help="path to mapcss-mapping.csv and other files", metavar="PATH")
+    parser.add_option("-o", "--output-dir", dest="outdir", default="drules",
+                      help="output directory", metavar="DIR")
+    parser.add_option("-f", "--minzoom", dest="minzoom", default=0, type="int",
+                      help="minimal available zoom level", metavar="ZOOM")
+    parser.add_option("-t", "--maxzoom", dest="maxzoom", default=20, type="int",
+                      help="maximal available zoom level", metavar="ZOOM")
+    parser.add_option("-x", "--txt", dest="txt", action="store_true",
+                      help="create a text file for output", default=False)
+
+    (options, args) = parser.parse_args()
+
+    if options.data is None:
+        parser.error("Please specify base 'data' path.")
+
+    if options.outdir is None:
+        parser.error("Please specify base output path.")
+
+    full_styles_regenerate(options)
+
+if __name__ == '__main__':
+    main()
--- a/src/libkomwm.py
+++ b/src/libkomwm.py
@ -89,6 +89,7 @@ Priorities ranges' rendering order overview:
 - BG-by-size: landcover areas sorted by their size
 '''

+# TODO: Implement better error handling
 validation_errors_count = 0

 def to_boolean(s):
@ -104,6 +105,9 @@ def mwm_encode_color(colors, st, prefix='', default='black'):
    if prefix:
        prefix += "-"
    opacity = hex(255 - int(255 * float(st.get(prefix + "opacity", 1))))
+    # TODO: Refactoring idea: here color is converted from float to hex. While MapCSS class
+    #       reads colors from *.mapcss files and converts to float. How about changing MapCSS
+    #       to keep hex values and avoid Hex->Float->Hex operations?
    color = whatever_to_hex(st.get(prefix + 'color', default))[1:]
    result = int(opacity + color, 16)
    colors.add(result)
@ -118,6 +122,7 @@ def mwm_encode_image(st, prefix='icon', bgprefix='symbol'):
        return False
    # strip last ".svg"
    handle = st.get(prefix + "image")[:-4]
+    # TODO: return `handle` only once
    return handle, handle


@ -454,6 +459,7 @@ def get_drape_priority(cl, dr_type, object_id, auto_dr_type = None, auto_comment
    return 0


+# TODO: Split large function to smaller ones
 def komap_mapswithme(options):
    if options.data and os.path.isdir(options.data):
        ddir = options.data
@ -464,6 +470,7 @@ def komap_mapswithme(options):
    class_order = []
    class_tree = {}

+    # TODO: Introduce new function to parse `colors.txt` for better testability
    colors_file_name = os.path.join(ddir, 'colors.txt')
    colors = set()
    if os.path.exists(colors_file_name):
@ -472,6 +479,7 @@ def komap_mapswithme(options):
            colors.add(int(colorLine))
        colors_in_file.close()

+    # TODO: Introduce new function to parse `patterns.txt` for better testability
    patterns = []
    def addPattern(dashes):
        if dashes and dashes not in patterns:
@ -488,9 +496,11 @@ def komap_mapswithme(options):
    types_file = open(os.path.join(ddir, 'types.txt'), "w")

    # The mapcss-mapping.csv format is described inside the file itself.
+    # TODO: introduce new function to parse 'mapcss-mapping.csv' for better testability
    cnt = 1
    unique_types_check = set()
-    for row in csv.reader(open(os.path.join(ddir, 'mapcss-mapping.csv')), delimiter=';'):
+    mapping_file = open(os.path.join(ddir, 'mapcss-mapping.csv'))
+    for row in csv.reader(mapping_file, delimiter=';'):
        if len(row) <= 1 or row[0].startswith('#'):
            # Allow for empty lines and comment lines starting with '#'.
            continue
@ -537,6 +547,7 @@ def komap_mapswithme(options):
                print("mapswithme", file=types_file)
        class_tree[cl] = row[0]
    class_order.sort()
+    mapping_file.close()
    types_file.close()

    output = ''
@ -554,8 +565,10 @@ def komap_mapswithme(options):
        for i, t in enumerate(v.keys()):
            mapcss_static_tags[t] = mapcss_static_tags.get(t, True) and i == 0

+    # TODO: Introduce new function to parse `mapcss-dynamic.txt` for better testability
    # Get all mapcss dynamic tags from mapcss-dynamic.txt
-    mapcss_dynamic_tags = set([line.rstrip() for line in open(os.path.join(ddir, 'mapcss-dynamic.txt'))])
+    with open(os.path.join(ddir, 'mapcss-dynamic.txt')) as dynamic_file:
+        mapcss_dynamic_tags = set([line.rstrip() for line in dynamic_file])

    # Parse style mapcss
    global style
@ -579,6 +592,7 @@ def komap_mapswithme(options):

    style.finalize_choosers_tree()

+    # TODO: Introduce new function to work with colors for better testability
    # Get colors section from style
    style_colors = {}
    raw_style_colors = style.get_colors()
@ -616,6 +630,7 @@ def komap_mapswithme(options):

    all_draw_elements = set()

+    # TODO: refactor next for-loop for readability and testability
    global validation_errors_count
    for results in imapfunc(query_style, ((cl, classificator[cl], options.minzoom, options.maxzoom) for cl in class_order)):
        for result in results:
@ -920,6 +935,7 @@ def komap_mapswithme(options):
        return -1
    viskeys.sort(key=functools.cmp_to_key(cmprepl))

+    # TODO: Introduce new function to dump `visibility.txt` and `classificator.txt` for better testability
    visibility_file = open(os.path.join(ddir, 'visibility.txt'), "w")
    classificator_file = open(os.path.join(ddir, 'classificator.txt'), "w")

@ -942,11 +958,13 @@ def komap_mapswithme(options):
    visibility_file.close()
    classificator_file.close()

+    # TODO: Introduce new function to dump `colors.txt` for better testability
    colors_file = open(colors_file_name, "w")
    for c in sorted(colors):
        colors_file.write("%d\n" % (c))
    colors_file.close()

+    # TODO: Introduce new function to dump `patterns.txt` for better testability
    patterns_file = open(patterns_file_name, "w")
    for p in patterns:
        patterns_file.write("%s\n" % (' '.join(str(elem) for elem in p)))
--- a/src/mapcss/Condition.py
+++ b/src/mapcss/Condition.py
@ -24,7 +24,7 @@ class Condition:
            params = (params,)
        self.params = params      # e.g. ('highway','primary')
        if typez == "regex":
-            self.regex = re.compile(self.params[0], re.I)
+            self.regex = re.compile(self.params[1], re.I)

    def extract_tag(self):
        if self.params[0][:2] == "::" or self.type == "regex":
--- a/src/mapcss/Eval.py
+++ b/src/mapcss/Eval.py
@ -15,6 +15,10 @@
 #   You should have received a copy of the GNU General Public License
 #   along with kothic.  If not, see <http://www.gnu.org/licenses/>.

+import logging
+
+logger = logging.getLogger('mapcss.Eval')
+logger.setLevel(logging.ERROR)

 class Eval():
    def __init__(self, s='eval()'):
@ -57,6 +61,8 @@ class Eval():
                 "any": fake_compute,
                 "min": fake_compute,
                 "max": fake_compute,
+                 "cond": fake_compute,
+                 "boolean": fake_compute,
                 })
        return tags

@ -99,12 +105,15 @@ class Eval():
                return "{:.4g}".format(result)

            return str(result)
-        except:
+        except Exception as e:
+            logger.warning(f"Error evaluating expression `{self.expr_text}`", e)
            return ""

    def __repr__(self):
        return "eval(%s)" % self.expr_text

+    def __eq__(self, other):
+        return type(self) == type(other) and self.expr_text == other.expr_text

 def m_boolean(expr):
    expr = str(expr)
--- a/src/mapcss/StyleChooser.py
+++ b/src/mapcss/StyleChooser.py
@ -76,6 +76,8 @@ class StyleChooser:
    The styles property is an array of all the style objects to be drawn
        if any of the ruleChains evaluate to true.
    """
+    # TODO: use logging for debug logs
+
    def __repr__(self):
        return "{(%s) : [%s] }\n" % (self.ruleChains, self.styles)

@ -122,6 +124,7 @@ class StyleChooser:

        return rule.runtime_conditions

+    # TODO: Rename to "applyStyles"
    def updateStyles(self, sl, tags, xscale, zscale, filter_by_runtime_conditions):
        # Are any of the ruleChains fulfilled?
        rule_and_object_id = self.testChains(tags)
@ -143,6 +146,7 @@ class StyleChooser:
                for a, b in r.items():
                    "calculating eval()'s"
                    if type(b) == self.eval_type:
+                        # TODO: Move next block to a separate function
                        combined_style = {}
                        for t in sl:
                            combined_style.update(t)
@ -235,6 +239,7 @@ class StyleChooser:
        """
        adds to this.styles
        """
+        # TODO: move next for-loop to a new method. Don't call it on every style append
        for r in self.ruleChains:
            if not self.selzooms:
                self.selzooms = [r.minZoom, r.maxZoom]
--- a/src/mapcss/init.py
+++ b/src/mapcss/init.py
@ -25,6 +25,7 @@ from .Condition import Condition
 NEEDED_KEYS = set(["width", "casing-width", "casing-width-add", "fill-color", "fill-image", "icon-image", "text", "extrude",
                   "background-image", "background-color", "pattern-image", "shield-color", "symbol-shape"])

+# TODO: Unused constant
 WHITESPACE = re.compile(r'\s+ ', re.S | re.X)

 COMMENT = re.compile(r'\/\* .*? \*\/ \s* ', re.S | re.X)
@ -40,29 +41,30 @@ VARIABLE_SET = re.compile(r'@([a-z][\w\d]*) \s* : \s* (.+?) \s* ; \s* ', re.S |
 UNKNOWN = re.compile(r'(\S+) \s* ', re.S | re.X)

 ZOOM_MINMAX = re.compile(r'(\d+)\-(\d+) $', re.S | re.X)
-ZOOM_MIN = re.compile(r'(\d+)\-      $', re.S | re.X)
-ZOOM_MAX = re.compile(r'     \-(\d+) $', re.S | re.X)
+ZOOM_MIN    = re.compile(r'(\d+)\-      $', re.S | re.X)
+ZOOM_MAX    = re.compile(r'     \-(\d+) $', re.S | re.X)
 ZOOM_SINGLE = re.compile(r'       (\d+) $', re.S | re.X)

-CONDITION_TRUE = re.compile(r'\s* ([:\w]+) \s* [?] \s*  $', re.I | re.S | re.X)
+# TODO: move to Condition.py
+CONDITION_TRUE    = re.compile(r'\s* ([:\w]+) \s* [?] \s*  $', re.I | re.S | re.X)
 CONDITION_invTRUE = re.compile(r'\s* [!] \s* ([:\w]+) \s* [?] \s*  $', re.I | re.S | re.X)
-CONDITION_FALSE = re.compile(r'\s* ([:\w]+) \s* = \s* no  \s*  $', re.I | re.S | re.X)
-CONDITION_SET = re.compile(r'\s* ([-:\w]+) \s* $', re.S | re.X)
-CONDITION_UNSET = re.compile(r'\s* !([:\w]+) \s* $', re.S | re.X)
-CONDITION_EQ = re.compile(r'\s* ([:\w]+) \s* =  \s* (.+) \s* $', re.S | re.X)
-CONDITION_NE = re.compile(r'\s* ([:\w]+) \s* != \s* (.+) \s* $', re.S | re.X)
-CONDITION_GT = re.compile(r'\s* ([:\w]+) \s* >  \s* (.+) \s* $', re.S | re.X)
-CONDITION_GE = re.compile(r'\s* ([:\w]+) \s* >= \s* (.+) \s* $', re.S | re.X)
-CONDITION_LT = re.compile(r'\s* ([:\w]+) \s* <  \s* (.+) \s* $', re.S | re.X)
-CONDITION_LE = re.compile(r'\s* ([:\w]+) \s* <= \s* (.+) \s* $', re.S | re.X)
-CONDITION_REGEX = re.compile(r'\s* ([:\w]+) \s* =~\/ \s* (.+) \/ \s* $', re.S | re.X)
+CONDITION_FALSE   = re.compile(r'\s* ([:\w]+) \s* = \s* no  \s*  $', re.I | re.S | re.X)
+CONDITION_SET     = re.compile(r'\s* ([-:\w]+) \s* $', re.S | re.X)
+CONDITION_UNSET   = re.compile(r'\s* !([:\w]+) \s* $', re.S | re.X)
+CONDITION_EQ      = re.compile(r'\s* ([:\w]+) \s* =  \s* (.+) \s* $', re.S | re.X)
+CONDITION_NE      = re.compile(r'\s* ([:\w]+) \s* != \s* (.+) \s* $', re.S | re.X)
+CONDITION_GT      = re.compile(r'\s* ([:\w]+) \s* >  \s* (.+) \s* $', re.S | re.X)
+CONDITION_GE      = re.compile(r'\s* ([:\w]+) \s* >= \s* (.+) \s* $', re.S | re.X)
+CONDITION_LT      = re.compile(r'\s* ([:\w]+) \s* <  \s* (.+) \s* $', re.S | re.X)
+CONDITION_LE      = re.compile(r'\s* ([:\w]+) \s* <= \s* (.+) \s* $', re.S | re.X)
+CONDITION_REGEX   = re.compile(r'\s* ([:\w]+) \s* =~\/ \s* (.+) \/ \s* $', re.S | re.X)

 ASSIGNMENT_EVAL = re.compile(r"\s* (\S+) \s* \:      \s* eval \s* \( \s* ' (.+?) ' \s* \) \s* $", re.I | re.S | re.X)
-ASSIGNMENT = re.compile(r'\s* (\S+) \s* \:      \s*          (.+?) \s*                   $', re.S | re.X)
-SET_TAG_EVAL = re.compile(r"\s* set \s+(\S+)\s* = \s* eval \s* \( \s* ' (.+?) ' \s* \) \s* $", re.I | re.S | re.X)
-SET_TAG = re.compile(r'\s* set \s+(\S+)\s* = \s*          (.+?) \s*                   $', re.I | re.S | re.X)
-SET_TAG_TRUE = re.compile(r'\s* set \s+(\S+)\s* $', re.I | re.S | re.X)
-EXIT = re.compile(r'\s* exit \s* $', re.I | re.S | re.X)
+ASSIGNMENT      = re.compile(r'\s* (\S+) \s* \:      \s*          (.+?) \s*                   $', re.S | re.X)
+SET_TAG_EVAL    = re.compile(r"\s* set \s+(\S+)\s* = \s* eval \s* \( \s* ' (.+?) ' \s* \) \s* $", re.I | re.S | re.X)
+SET_TAG         = re.compile(r'\s* set \s+(\S+)\s* = \s*          (.+?) \s*                   $', re.I | re.S | re.X)
+SET_TAG_TRUE    = re.compile(r'\s* set \s+(\S+)\s* $', re.I | re.S | re.X)
+EXIT            = re.compile(r'\s* exit \s* $', re.I | re.S | re.X)

 oNONE = 0
 oZOOM = 2
@ -73,6 +75,7 @@ oDECLARATION = 6
 oSUBPART = 7
 oVARIABLE_SET = 8

+# TODO: Following block of variables is never used
 DASH = re.compile(r'\-/g')
 COLOR = re.compile(r'color$/')
 BOLD = re.compile(r'^bold$/i')
@ -81,6 +84,7 @@ UNDERLINE = re.compile(r'^underline$/i')
 CAPS = re.compile(r'^uppercase$/i')
 CENTER = re.compile(r'^center$/i')

+# TODO: Remove unused HEX variable
 HEX = re.compile(r'^#([0-9a-f]+)$/i')
 VARIABLE = re.compile(r'@([a-z][\w\d]*)')

@ -98,6 +102,7 @@ class MapCSS():
        self.choosers_by_type = {}
        self.choosers_by_type_zoom_tag = {}
        self.variables = {}
+        self.unused_variables = set()
        self.style_loaded = False

    def parseZoom(self, s):
@ -110,6 +115,7 @@ class MapCSS():
        elif ZOOM_SINGLE.match(s):
            return float(ZOOM_SINGLE.match(s).groups()[0]), float(ZOOM_SINGLE.match(s).groups()[0])
        else:
+            # TODO: Should we raise an exception here?
            logging.error("unparsed zoom: %s" % s)

    def build_choosers_tree(self, clname, type, cltag):
@ -163,6 +169,8 @@ class MapCSS():
                    runtime_rules.append(runtime_conditions)
        return runtime_rules

+    # TODO: Renamed to `get_styles` because it returns a list of styles for each class `::XXX`
+    # Refactoring idea: Maybe return dict with `object-id` as a key
    def get_style(self, clname, type, tags, zoom, xscale, zscale, filter_by_runtime_conditions):
        style = []
        if type in self.choosers_by_type_zoom_tag:
@ -207,6 +215,8 @@ class MapCSS():

    def get_variable(self, m):
        name = m.group()[1:]
+        if name in self.unused_variables:
+            self.unused_variables.remove(name)
        if not name in self.variables:
            raise Exception("Variable not found: " + str(format(name)))
        return self.variables[name] if name in self.variables else m.group()
@ -219,7 +229,8 @@ class MapCSS():
        if filename:
            basepath = os.path.dirname(filename)
        if not css:
-            css = open(filename).read()
+            with open(filename) as css_file:
+                css = css_file.read()
        if not self.style_loaded:
            self.choosers = []

@ -339,7 +350,8 @@ class MapCSS():
                        import_filename = os.path.join(basepath, IMPORT.match(css).groups()[0])
                        try:
                            css = IMPORT.sub("", css, 1)
-                            import_text = open(import_filename, "r").read()
+                            with open(import_filename, "r") as import_file:
+                                import_text = import_file.read()
                            stck[-1][1] = css # store remained part
                            stck.append([import_filename, import_text, import_text])
                            wasBroken = True
@ -352,6 +364,7 @@ class MapCSS():
                        name = VARIABLE_SET.match(css).groups()[0]
                        log.debug("variable set found: %s" % name)
                        self.variables[name] = VARIABLE_SET.match(css).groups()[1]
+                        self.unused_variables.add( name )
                        css = VARIABLE_SET.sub("", css, 1)
                        previous = oVARIABLE_SET

@ -359,7 +372,7 @@ class MapCSS():
                    elif UNKNOWN.match(css):
                        raise Exception("Unknown construction: " + UNKNOWN.match(css).group())

-                    # Must be unreacheable
+                    # Must be unreachable
                    else:
                        raise Exception("Unexpected construction: " + css)

@ -377,10 +390,13 @@ class MapCSS():
            css_orig = stck[-1][2] # original
            css = stck[-1][1] # remained
            line = css_orig[:-len(css)].count("\n") + 1
+            # TODO: Handle filename is None
            msg = str(e) + "\nFile: " + filename + "\nLine: " + str(line)
+            # TODO: Print stack trace of original exception `e`
            raise Exception(msg)

        try:
+            # TODO: Drop support of z-index because `clamp` is always False and z-index properties unused in Organic Maps)
            if clamp:
                "clamp z-indexes, so they're tightly following integers"
                zindex = set()
@ -398,8 +414,10 @@ class MapCSS():
                            else:
                                stylez['z-index'] = res
        except TypeError:
+            # TODO: Better error handling here
            pass

+        # Group MapCSS styles by object type: 'area', 'line', 'way', 'node'
        for chooser in self.choosers:
            for t in chooser.compatible_types:
                if t not in self.choosers_by_type:
@ -407,7 +425,11 @@ class MapCSS():
                else:
                    self.choosers_by_type[t].append(chooser)

+        if self.unused_variables:
+            # TODO: Do not print warning here. Instead let libkomwn.komap_mapswithme(...) analyze unused_variables
+            print(f"Warning: Unused variables: {', '.join(self.unused_variables)}")

+# TODO: move to Condition.py
 def parseCondition(s):
    log = logging.getLogger('mapcss.parser.condition')

@ -488,7 +510,7 @@ def parseDeclaration(s):
            logging.debug("%s == %s" % (tzz[0], tzz[1]))
        else:
            logging.debug("unknown %s" % (a))
-    return [t]
+    return [t] # TODO: don't wrap `t` dict into a list. Return `t` instead.


 if __name__ == "__main__":
--- a/tests/init.py
+++ b/tests/init.py
--- a/tests/assets/case-1-import/colors.mapcss
+++ b/tests/assets/case-1-import/colors.mapcss
@ -0,0 +1,6 @@
+colors {
+  GuiText-color: #FFFFFF;
+  GuiText-opacity: 0.7;
+  Route-color: #0000FF;
+  Route-opacity: 0.5;
+}
--- a/tests/assets/case-1-import/import1.mapcss
+++ b/tests/assets/case-1-import/import1.mapcss
@ -0,0 +1 @@
+@import("import2.mapcss");
--- a/tests/assets/case-1-import/import2.mapcss
+++ b/tests/assets/case-1-import/import2.mapcss
@ -0,0 +1 @@
+@import("colors.mapcss");
--- a/tests/assets/case-1-import/main.mapcss
+++ b/tests/assets/case-1-import/main.mapcss
@ -0,0 +1 @@
+@import("import1.mapcss");
--- a/tests/assets/case-2-generate-drules-mini/.gitignore
+++ b/tests/assets/case-2-generate-drules-mini/.gitignore
@ -0,0 +1,7 @@
+classificator.txt
+colors.txt
+patterns.txt
+style.bin.bin
+style.bin.txt
+types.txt
+visibility.txt
--- a/tests/assets/case-2-generate-drules-mini/include/Roads.mapcss
+++ b/tests/assets/case-2-generate-drules-mini/include/Roads.mapcss
@ -0,0 +1,136 @@
+/* ~~~~ CONTENT OF ROADS ~~~~~
+
+1.Z-INDEX ROADS
+2.WORLD LEVEL ROAD 4-9 ZOOM
+3.TRUNK & MOTORWAY 6-22 ZOOM
+  3.1 Trunk & Motorway 6-22 ZOOM
+  3.2 Trunk & Motorway tunnel 12-22 ZOOM
+  3.3 Trunk & Motorway bridge 13-22 ZOOM
+4.PRIMARY 8-22 ZOOM
+  4.1 Primary 8-22 ZOOM
+  4.2 Primary tunnel 14-22 ZOOM
+  4.3 Primary bridge 14-22 ZOOM
+5.SECONDARY 10-22 ZOOM
+  5.1 Secondary 10-22 ZOOM
+  5.2 Secondary tunnel 16-22 ZOOM
+  5.3 Secondary bridge 14-22 ZOOM
+6.TERTIARY & UNCLASSIFIED 11-22 ZOOM
+  6.1 Tertiary & Unclassified 11-22 ZOOM
+  6.2 Tertiary & Unclassified tunnel 16-22 ZOOM
+  6.3 Tertiary & Unclassified bridge 14-22 ZOOM
+7.RESIDENTAL, ROAD, STREETS & SERVICE 12-22 ZOOM
+  7.1 Residential, Road, Street 12-22 ZOOM
+  7.2 Residential, Road, Street tunnel 16-22 ZOOM
+  7.3 Residential, Road, Street bridge 14-22 ZOOM
+  7.4 Service 15-22 ZOOM
+8.OTHERS ROADS 13-22 ZOOM
+  8.1 Pedestrian & ford 13-22 ZOOM
+  8.2 Pedestrian & ford tunnel 16-22 ZOOM
+  8.3 Pedestrian & other brige 13-22 ZOOM
+  8.4 Cycleway 13-22 ZOOM
+  8.5 Construction 13-22 ZOOM
+  8.6 Track & Path 14-22 ZOOM
+  8.7 Footway 15-22 ZOOM
+  8.8 Steps 15-22 ZOOM
+  8.9 Bridleway 14-22 ZOOM
+  8.11 Runway 12-22 ZOOM
+9.RAIL 11-22 ZOOM
+  9.1 RAIL 11-22 ZOOM
+  9.2 Rail tunnel 14-22 ZOOM
+  9.3 Rail bridge 14-22 ZOOM
+  9.4 Monorail 14-22 ZOOM
+  9.5 Tram line 13-22 ZOOM
+  9.6 Funicular 12-22 ZOOM
+10.PISTE 12-22 ZOOM
+ 10.1 Lift 12-22 ZOOM
+ 10.2 Aerialway 12-22 ZOOM
+ 10.3 Piste & Route 14-22 ZOOM
+11.FERRY
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+*/
+
+/* 2.WORLD LEVEL ROAD 4-9 ZOOM */
+
+line|z6-9[highway=world_towns_level],
+line|z4-9[highway=world_level],
+{color: @trunk1;opacity: 1;}
+
+line|z4[highway=world_level]
+{width: 0.5;}
+line|z5-6[highway=world_level],
+{width: 0.7;}
+line|z6[highway=world_towns_level],
+{width: 0.9;}
+line|z7[highway=world_towns_level],
+line|z7[highway=world_level]
+{width: 0.7;}
+line|z8[highway=world_towns_level],
+line|z8[highway=world_level]
+{width: 0.9;}
+line|z9[highway=world_towns_level],
+line|z9[highway=world_level]
+{width: 0.8;}
+
+/* 3.TRUNK & MOTORWAY 6-22 ZOOM */
+
+line|z6[highway=trunk],
+line|z6[highway=motorway],
+{color: @trunk0; opacity: 0.3;}
+line|z7-9[highway=trunk],
+line|z7-9[highway=motorway],
+{color: @trunk0; opacity: 0.7;}
+
+line|z10-[highway=trunk],
+line|z10-[highway=motorway],
+{color: @trunk1; opacity: 0.7;}
+line|z10-[highway=motorway_link],
+line|z10-[highway=trunk_link],
+{color: @primary0; opacity: 0.7;}
+
+/* 3.1 Trunk & Motorway 6-22 ZOOM */
+
+line|z6[highway=trunk],
+line|z6[highway=motorway],
+{width: 0.8;}
+line|z7[highway=trunk],
+line|z7[highway=motorway]
+{width: 0.9;}
+line|z8[highway=trunk],
+line|z8[highway=motorway]
+{width: 1.1;}
+line|z9[highway=trunk],
+line|z9[highway=motorway]
+{width: 1.2;}
+line|z10[highway=trunk],
+line|z10[highway=motorway]
+{width: 1.5;}
+
+line|z10[highway=motorway_link],
+line|z10[highway=trunk_link]
+{width: 0.8;}
+
+
+/* 4.PRIMARY 8-22 ZOOM */
+
+line|z8-10[highway=primary],
+{color: @primary0; opacity: 0.7;}
+
+/* 4.1 Primary 8-22 ZOOM */
+
+line|z8[highway=primary],
+{width: 0.7;}
+line|z9[highway=primary],
+{width: 0.8;}
+line|z10[highway=primary],
+{width: 1.2;}
+
+/* 5.SECONDARY 10-22 ZOOM */
+
+line|z10[highway=secondary],
+{color: @secondary0; opacity: 0.8;}
+
+/* 5.1 Secondary 10-22 ZOOM */
+
+line|z10[highway=secondary],
+{width: 1.2;}
+
--- a/tests/assets/case-2-generate-drules-mini/include/Roads_label.mapcss
+++ b/tests/assets/case-2-generate-drules-mini/include/Roads_label.mapcss
@ -0,0 +1,75 @@
+/* ~~~~ CONTENT OF ROADS ~~~~~
+
+1.Z-INDEX ROADS
+2.SHIELD 10-22 ZOOM
+3.TRUNK & MOTORWAY 10-22 ZOOM
+4.PRIMARY 10-22 ZOOM
+5.SECONDARY 10-22 ZOOM
+6.RESIDENTAL & TERTIARY 12-22 ZOOM
+7.ROAD, STREETS, UNCLASSIFIED & SERVICE 15-22 ZOOM
+8.OTHERS ROADS 15-22 ZOOM
+9.RAIL 15-22 ZOOM ????
+  9.1 Monorail 14-22 ZOOM
+  9.2 Tram line 13-22 ZOOM
+  9.3 Funicular 12-22 ZOOM
+10.PISTE 12-22 ZOOM ????
+ 10.1 Lift 12-22 ZOOM
+ 10.2 Aerialway 12-22 ZOOM
+ 10.3 Piste & Route 14-22 ZOOM
+11.FERRY 10-22 ZOOM
+12.ONEWAY ARROWS 15-22 ZOOM
+13.JUNCTION 15-22 ZOOM
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+*/
+
+line[highway]
+{text-position: line;}
+
+/* 2.SHIELD 10-22 ZOOM */
+
+line|z10-[highway=motorway]::shield,
+line|z10-[highway=trunk]::shield,
+line|z10-[highway=motorway_link]::shield,
+line|z10-[highway=trunk_link]::shield,
+line|z10-[highway=primary]::shield,
+{shield-font-size: 9;shield-text-color: @shield_text;shield-text-halo-radius: 0;shield-text-halo-color: @shield_text_halo;shield-color: @shield;shield-outline-radius: 1;shield-outline-color: @shield_outline;}
+
+line|z10[highway=motorway]::shield,
+line|z10[highway=trunk]::shield,
+line|z10[highway=motorway_link]::shield,
+line|z10[highway=trunk_link]::shield,
+line|z10[highway=primary]::shield,
+{shield-min-distance: 85;}
+
+/* 3.TRUNK & MOTORWAY 10-22 ZOOM */
+
+line|z10-[highway=trunk],
+line|z10-[highway=motorway],
+line|z10-[highway=motorway_link],
+line|z10-[highway=trunk_link],
+{text: name; text-halo-radius: 1; text-halo-color: @label_halo_medium;}
+
+line|z10-[highway=motorway],
+line|z10-[highway=trunk],
+{font-size: 11; text-color: @label_medium; text-halo-opacity: 0.9;}
+
+line|z10-[highway=motorway_link],
+line|z10-[highway=trunk_link],
+{font-size: 10; text-color: @label_medium; text-halo-opacity: 0.7;}
+
+/* 4.PRIMARY 10-22 ZOOM */
+
+line|z10-[highway=primary],
+{text: name; text-halo-radius: 1; text-halo-color: @label_halo_medium;}
+
+line|z10-[highway=primary],
+{font-size: 10; text-color: @label_medium; text-halo-opacity: 0.7;}
+
+/* 5.SECONDARY 10-22 ZOOM */
+
+line|z10-[highway=secondary],
+{text: name; text-halo-radius: 1; text-halo-color: @label_halo_medium;}
+
+line|z10-[highway=secondary],
+{font-size: 10; text-color: @label_light; text-halo-opacity: 0.7;}
+
--- a/tests/assets/case-2-generate-drules-mini/include/colors.mapcss
+++ b/tests/assets/case-2-generate-drules-mini/include/colors.mapcss
@ -0,0 +1,16 @@
+/* 5.1 All roads */
+@trunk0: #FF7326;
+@trunk1: #FF7A26;
+@primary0:  #FF8726;
+@secondary0: #FFB226;
+
+/* 6.1 Main labels */
+@label_medium: #333333;
+@label_light: #444444;
+@label_halo_medium: #EDEBDB;
+
+/* 6.4 Road labels */
+@shield_text: #000000;
+@shield_text_halo: #000000;
+@shield: #FFFFFF;
+@shield_outline: #000000;
--- a/tests/assets/case-2-generate-drules-mini/include/priorities_1_BG-by-size.prio.txt
+++ b/tests/assets/case-2-generate-drules-mini/include/priorities_1_BG-by-size.prio.txt
@ -0,0 +1,16 @@
+# This file is automatically re-formatted and re-sorted in priorities descending order
+# when generate_drules.sh is run. All comments (automatic priorities of e.g. optional captions, drule types visibilities, etc.)
+# are generated automatically for information only. Custom formatting and comments are not preserved.
+#
+# BG-by-size geometry: background areas rendered below BG-top and everything else.
+# Smaller areas are rendered above larger ones (area's size is estimated as the size of its' bounding box).
+# So effectively priority values of BG-by-size areas are not used at the moment.
+# But we might use them later for some special cases, e.g. to determine a main area type of a multi-type feature.
+# Keep them in a logical importance order please.
+#
+# Priorities ranges' rendering order overview:
+# - overlays (icons, captions...)
+# - FG: foreground areas and lines
+# - BG-top: water (linear and areal)
+# - BG-by-size: landcover areas sorted by their size
+
--- a/tests/assets/case-2-generate-drules-mini/include/priorities_2_BG-top.prio.txt
+++ b/tests/assets/case-2-generate-drules-mini/include/priorities_2_BG-top.prio.txt
@ -0,0 +1,18 @@
+# This file is automatically re-formatted and re-sorted in priorities descending order
+# when generate_drules.sh is run. All comments (automatic priorities of e.g. optional captions, drule types visibilities, etc.)
+# are generated automatically for information only. Custom formatting and comments are not preserved.
+#
+# BG-top geometry: background lines and areas that should be always below foreground ones
+# (including e.g. layer=-10 underwater tunnels), but above background areas sorted by size (BG-by-size),
+# because ordering by size doesn't always work with e.g. water mapped over a forest,
+# so water should be on top of other landcover always, but linear waterways should be hidden beneath it.
+# Still, e.g. a layer=-1 BG-top feature will be rendered under a layer=0 BG-by-size feature
+# (so areal water tunnels are hidden beneath other landcover area) and a layer=1 landcover areas
+# are displayed above layer=0 BG-top.
+#
+# Priorities ranges' rendering order overview:
+# - overlays (icons, captions...)
+# - FG: foreground areas and lines
+# - BG-top: water (linear and areal)
+# - BG-by-size: landcover areas sorted by their size
+
--- a/tests/assets/case-2-generate-drules-mini/include/priorities_3_FG.prio.txt
+++ b/tests/assets/case-2-generate-drules-mini/include/priorities_3_FG.prio.txt
@ -0,0 +1,41 @@
+# This file is automatically re-formatted and re-sorted in priorities descending order
+# when generate_drules.sh is run. All comments (automatic priorities of e.g. optional captions, drule types visibilities, etc.)
+# are generated automatically for information only. Custom formatting and comments are not preserved.
+#
+# FG geometry: foreground lines and areas (e.g. buildings) are rendered always below overlays
+# and always on top of background geometry (BG-top & BG-by-size) even if a foreground feature
+# is layer=-10 (as tunnels should be visibile over landcover and water).
+#
+# Priorities ranges' rendering order overview:
+# - overlays (icons, captions...)
+# - FG: foreground areas and lines
+# - BG-top: water (linear and areal)
+# - BG-by-size: landcover areas sorted by their size
+
+highway-motorway                                    # line z6- (also has pathtext z10-, shield::shield z10-)
+highway-motorway-bridge                             # line z6- (also has pathtext z10-, shield::shield z10-)
+highway-motorway-tunnel                             # line z6- (also has pathtext z10-, shield::shield z10-)
+highway-trunk                                       # line z6- (also has pathtext z10-, shield::shield z10-)
+highway-trunk-bridge                                # line z6- (also has pathtext z10-, shield::shield z10-)
+highway-trunk-tunnel                                # line z6- (also has pathtext z10-, shield::shield z10-)
+highway-world_level                                 # line z4-9
+highway-world_towns_level                           # line z6-9
+=== 310
+
+highway-primary                                     # line z8- (also has pathtext z10-, shield::shield z10-)
+highway-primary-bridge                              # line z8- (also has pathtext z10-, shield::shield z10-)
+highway-primary-tunnel                              # line z8- (also has pathtext z10-, shield::shield z10-)
+=== 290
+
+highway-secondary                                   # line z10- (also has pathtext z10-)
+highway-secondary-bridge                            # line z10- (also has pathtext z10-)
+highway-secondary-tunnel                            # line z10- (also has pathtext z10-)
+=== 270
+
+highway-motorway_link                               # line z10- (also has pathtext z10-, shield::shield z10-)
+highway-motorway_link-bridge                        # line z10- (also has pathtext z10-, shield::shield z10-)
+highway-motorway_link-tunnel                        # line z10- (also has pathtext z10-, shield::shield z10-)
+highway-trunk_link                                  # line z10- (also has pathtext z10-, shield::shield z10-)
+highway-trunk_link-bridge                           # line z10- (also has pathtext z10-, shield::shield z10-)
+highway-trunk_link-tunnel                           # line z10- (also has pathtext z10-, shield::shield z10-)
+=== 228
--- a/tests/assets/case-2-generate-drules-mini/include/priorities_4_overlays.prio.txt
+++ b/tests/assets/case-2-generate-drules-mini/include/priorities_4_overlays.prio.txt
@ -0,0 +1,61 @@
+# This file is automatically re-formatted and re-sorted in priorities descending order
+# when generate_drules.sh is run. All comments (automatic priorities of e.g. optional captions, drule types visibilities, etc.)
+# are generated automatically for information only. Custom formatting and comments are not preserved.
+#
+# Overlays (icons, captions, path texts and shields) are rendered on top of all the geometry (lines, areas).
+# Overlays don't overlap each other, instead the ones with higher priority displace the less important ones.
+# Optional captions (which have an icon) are usually displayed only if there are no other overlays in their way
+# (technically, max overlays priority value (10000) is subtracted from their priorities automatically).
+#
+# Priorities ranges' rendering order overview:
+# - overlays (icons, captions...)
+# - FG: foreground areas and lines
+# - BG-top: water (linear and areal)
+# - BG-by-size: landcover areas sorted by their size
+
+highway-motorway                                    # pathtext z10- (also has shield::shield z10-, line z6-)
+highway-motorway-bridge                             # pathtext z10- (also has shield::shield z10-, line z6-)
+highway-motorway-tunnel                             # pathtext z10- (also has shield::shield z10-, line z6-)
+highway-trunk                                       # pathtext z10- (also has shield::shield z10-, line z6-)
+highway-trunk-bridge                                # pathtext z10- (also has shield::shield z10-, line z6-)
+highway-trunk-tunnel                                # pathtext z10- (also has shield::shield z10-, line z6-)
+=== 6750
+
+highway-motorway::shield                            # shield::shield z10- (also has pathtext z10-, line z6-)
+highway-motorway-bridge::shield                     # shield::shield z10- (also has pathtext z10-, line z6-)
+highway-motorway-tunnel::shield                     # shield::shield z10- (also has pathtext z10-, line z6-)
+highway-trunk::shield                               # shield::shield z10- (also has pathtext z10-, line z6-)
+highway-trunk-bridge::shield                        # shield::shield z10- (also has pathtext z10-, line z6-)
+highway-trunk-tunnel::shield                        # shield::shield z10- (also has pathtext z10-, line z6-)
+=== 6740
+
+highway-primary                                     # pathtext z10- (also has shield::shield z10-, line z8-)
+highway-primary-bridge                              # pathtext z10- (also has shield::shield z10-, line z8-)
+highway-primary-tunnel                              # pathtext z10- (also has shield::shield z10-, line z8-)
+=== 6200
+
+highway-motorway_link                               # pathtext z10- (also has shield::shield z10-, line z10-)
+highway-motorway_link-bridge                        # pathtext z10- (also has shield::shield z10-, line z10-)
+highway-motorway_link-tunnel                        # pathtext z10- (also has shield::shield z10-, line z10-)
+highway-trunk_link                                  # pathtext z10- (also has shield::shield z10-, line z10-)
+highway-trunk_link-bridge                           # pathtext z10- (also has shield::shield z10-, line z10-)
+highway-trunk_link-tunnel                           # pathtext z10- (also has shield::shield z10-, line z10-)
+=== 6150
+
+highway-motorway_link::shield                       # shield::shield z10- (also has pathtext z10-, line z10-)
+highway-motorway_link-bridge::shield                # shield::shield z10- (also has pathtext z10-, line z10-)
+highway-motorway_link-tunnel::shield                # shield::shield z10- (also has pathtext z10-, line z10-)
+highway-trunk_link::shield                          # shield::shield z10- (also has pathtext z10-, line z10-)
+highway-trunk_link-bridge::shield                   # shield::shield z10- (also has pathtext z10-, line z10-)
+highway-trunk_link-tunnel::shield                   # shield::shield z10- (also has pathtext z10-, line z10-)
+=== 6140
+
+highway-secondary                                   # pathtext z10- (also has line z10-)
+highway-secondary-bridge                            # pathtext z10- (also has line z10-)
+highway-secondary-tunnel                            # pathtext z10- (also has line z10-)
+=== 5600
+
+highway-primary::shield                             # shield::shield z10- (also has pathtext z10-, line z8-)
+highway-primary-bridge::shield                      # shield::shield z10- (also has pathtext z10-, line z8-)
+highway-primary-tunnel::shield                      # shield::shield z10- (also has pathtext z10-, line z8-)
+=== 2975
--- a/tests/assets/case-2-generate-drules-mini/main.mapcss
+++ b/tests/assets/case-2-generate-drules-mini/main.mapcss
@ -0,0 +1,133 @@
+*::int_name
+{
+  text-offset: 1;
+}
+
+@import("include/colors.mapcss");
+@import("include/Roads.mapcss");
+@import("include/Roads_label.mapcss");
+
+colors
+{
+  GuiText-color: #4D4D4D;
+  GuiText-opacity: 0.86;
+  MyPositionAccuracy-color: #000000;
+  MyPositionAccuracy-opacity: 0.08;
+  Selection-color: #1E96F0;
+  Selection-opacity: 0.64;
+  Route-color: #0087FF;
+  RouteOutline-color: #055FCD;
+  RouteTrafficG0-color: #9B2300;
+  RouteTrafficG1-color: #E82705;
+  RouteTrafficG2-color: #E82705;
+  RouteTrafficG3-color: #FFE500;
+  RouteTrafficG3-opacity: 0.0;
+  RoutePedestrian-color: #1D339E;
+  RoutePedestrian-opacity: 0.8;
+  RouteBicycle-color: #9C27B0;
+  RouteBicycle-opacity: 0.8;
+  RouteRuler-color: #66347F;
+  RouteRuler-opacity: 0.9;
+  RoutePreview-color: #000000;
+  RoutePreview-opacity: 0.3;
+  RouteMaskCar-color: #000000;
+  RouteMaskCar-opacity: 0.3;
+  RouteFirstSegmentArrowsMaskCar-color: #033B80;
+  RouteFirstSegmentArrowsMaskCar-opacity: 0.0;
+  RouteArrowsMaskCar-color: #033B80;
+  RouteArrowsMaskCar-opacity: 0.2;
+  RouteMaskBicycle-color: #000000;
+  RouteMaskBicycle-opacity: 0.5;
+  RouteFirstSegmentArrowsMaskBicycle-color: #9C27B0;
+  RouteFirstSegmentArrowsMaskBicycle-opacity: 0.0;
+  RouteArrowsMaskBicycle-color: #9C27B0;
+  RouteArrowsMaskBicycle-opacity: 0.2;
+  RouteMaskPedestrian-color: #000000;
+  RouteMaskPedestrian-opacity: 0.5;
+  RouteFake-color: #A8A8A8;
+  RouteFakeOutline-color: #717171;
+  Arrow3D-color: #50AAFF;
+  Arrow3DObsolete-color: #82AAC8;
+  Arrow3DObsolete-opacity: 0.72;
+  Arrow3DShadow-color: #3C3C3C;
+  Arrow3DShadow-opacity: 0.24;
+  Arrow3DOutline-color: #FFFFFF;
+  TrackHumanSpeed-color: #1D339E;
+  TrackCarSpeed-color: #7C8EDE;
+  TrackPlaneSpeed-color: #A8B7ED;
+  TrackUnknownDistance-color: #616161;
+  TrafficG0-color: #7E1712;
+  TrafficG1-color: #E42300;
+  TrafficG2-color: #E42300;
+  TrafficG3-color: #FCDE00;
+  TrafficG3-opacity: 0.0;
+  TrafficG4-color: #39962E;
+  TrafficG5-color: #39962E;
+  TrafficTempBlock-color: #525252;
+  TrafficUnknown-color: #000000;
+  TrafficArrowLight-color: #FFFFFF;
+  TrafficArrowDark-color: #473635;
+  TrafficOutline-color: #E8E6DC;
+  RoadShieldBlackText-color: #000000;
+  RoadShieldWhiteText-color: #FFFFFF;
+  RoadShieldUKYellowText-color: #FFD400;
+  RoadShieldBlueBackground-color: #1A5EC1;
+  RoadShieldGreenBackground-color: #309302;
+  RoadShieldRedBackground-color: #E63534;
+  RoadShieldOrangeBackground-color: #FFBE00;
+  PoiHotelTextOutline-color: #FFFFFF;
+  PoiHotelTextOutline-opacity: 0.6;
+  PoiDeletedMask-color: #FFFFFF;
+  PoiDeletedMask-opacity: 0.3;
+  PoiVisitedMask-color: #FFFFFF;
+  PoiVisitedMask-opacity: 0.7;
+  DefaultTrackColor-color: #1E96F0;
+  RouteMarkPrimaryText-color: #000000;
+  RouteMarkPrimaryTextOutline-color: #FFFFFF;
+  RouteMarkSecondaryText-color: #000000;
+  RouteMarkSecondaryTextOutline-color: #FFFFFF;
+  TransitMarkPrimaryText-color: #000000;
+  TransitMarkPrimaryTextOutline-color: #FFFFFF;
+  TransitMarkSecondaryText-color: #000000;
+  TransitMarkSecondaryTextOutline-color: #FFFFFF;
+  TransitTransferOuterMarker-color: #000000;
+  TransitTransferInnerMarker-color: #FFFFFF;
+  TransitStopInnerMarker-color: #FFFFFF;
+  LocalAdsPrimaryText-color: #000000;
+  LocalAdsPrimaryTextOutline-color: #FFFFFF;
+  LocalAdsSecondaryText-color: #000000;
+  LocalAdsSecondaryTextOutline-color: #FFFFFF;
+  TransitBackground-color: #FFFFFF;
+  TransitBackground-opacity: 0.4;
+  BookmarkRed-color: #E51B23;
+  BookmarkPink-color: #FF4182;
+  BookmarkPurple-color: #9B24B2;
+  BookmarkDeepPurple-color: #6639BF;
+  BookmarkBlue-color: #0066CC;
+  BookmarkLightBlue-color: #249CF2;
+  BookmarkCyan-color: #14BECD;
+  BookmarkTeal-color: #00A58C;
+  BookmarkGreen-color: #3C8C3C;
+  BookmarkLime-color: #93BF39;
+  BookmarkYellow-color: #FFC800;
+  BookmarkOrange-color: #FF9600;
+  BookmarkDeepOrange-color: #F06432;
+  BookmarkBrown-color: #804633;
+  BookmarkGray-color: #737373;
+  BookmarkBlueGray-color: #597380;
+  SearchmarkPreparing-color: #597380;
+  SearchmarkNotAvailable-color: #597380;
+  SearchmarkSelectedNotAvailable-color: #F06432;
+  RatingBad-color: #F06432;
+  RatingGood-color: #3C8C3C;
+  RatingNone-color: #249CF2;
+  SearchmarkDefault-color: #249CF2;
+  RatingText-color: #FFFFFF;
+  UGCRatingText-color: #000000;
+  SpeedCameraMarkText-color: #FFFFFF;
+  SpeedCameraMarkBg-color: #F51E30;
+  SpeedCameraMarkOutline-color: #FFFFFF;
+  GuideCityMarkText-color: #6639BF;
+  GuideOutdoorMarkText-color: #3C8C3C;
+  HotelPriceText-color: #000000;
+}
--- a/tests/assets/case-2-generate-drules-mini/mapcss-dynamic.txt
+++ b/tests/assets/case-2-generate-drules-mini/mapcss-dynamic.txt
@ -0,0 +1,4 @@
+population
+name
+bbox_area
+rating
--- a/tests/assets/case-2-generate-drules-mini/mapcss-mapping.csv
+++ b/tests/assets/case-2-generate-drules-mini/mapcss-mapping.csv
@ -0,0 +1,148 @@
+highway|residential;2;
+highway|service;3;
+highway|unclassified;5;
+highway|footway;7;
+highway|track;8;
+highway|tertiary;9;
+highway|secondary;13;
+highway|path;16;
+highway|bus_stop;17;
+highway|footway|sidewalk;[highway=footway][footway=sidewalk];;name;int_name;18;
+highway|primary;27;
+highway|service|parking_aisle;[highway=service][service=parking_aisle];;name;int_name;29;
+moved:highway|road:05.2024;31;highway|road
+deprecated:highway|track|grade2:04.2024;[highway=track][tracktype=grade2];x;name;int_name;32;highway|track
+deprecated:highway|track|grade3:04.4024;[highway=track][tracktype=grade3];x;name;int_name;34;highway|track
+highway|cycleway;37;
+deprecated:highway|track|grade1:04.2024;[highway=track][tracktype=grade1];x;name;int_name;40;highway|track
+highway|service|driveway;[highway=service][service=driveway];;name;int_name;42;
+highway|motorway_link;44;
+deprecated:highway|track|grade4:04.2024;[highway=track][tracktype=grade4];x;name;int_name;46;highway|track
+highway|footway|crossing;[highway=footway][footway=crossing];;name;int_name;51;
+highway|path|bicycle;[highway=path][bicycle=designated];;;;53;
+highway|living_street;55;
+highway|motorway;58;
+highway|steps;59;
+deprecated:highway|track|grade5:04.2024;[highway=track][tracktype=grade5];x;name;int_name;63;highway|track
+highway|trunk;66;
+highway|pedestrian;70;
+highway|motorway|bridge;[highway=motorway][bridge?];;name;int_name;72;
+highway|residential|bridge;[highway=residential][bridge?];;name;int_name;81;
+highway|secondary|bridge;[highway=secondary][bridge?];;name;int_name;85;
+highway|tertiary|bridge;[highway=tertiary][bridge?];;name;int_name;86;
+highway|trunk_link;91;
+highway|unclassified|bridge;[highway=unclassified][bridge?];;name;int_name;92;
+highway|primary|bridge;[highway=primary][bridge?];;name;int_name;95;
+highway|primary_link;96;
+highway|footway|bridge;[highway=footway][bridge?];;name;int_name;98;
+deprecated:highway|path|hiking:04.2024;[highway=path][route=hiking],[highway=path][sac_scale=hiking];x;name;int_name;113;highway|path
+highway|trunk|bridge;[highway=trunk][bridge?];;name;int_name;116;
+highway|motorway_junction;121;
+highway|footway|bicycle;[highway=footway][bicycle=designated];;;;141;
+highway|motorway_link|bridge;[highway=motorway_link][bridge?];;name;int_name;143;
+deprecated:highway|footway|permissive:12.2023;[highway=footway][access=permissive],[highway=footway][foot=permissive];x;name;int_name;153;highway|footway
+highway|pedestrian|area;[highway=pedestrian][area?];;name;int_name;158;
+highway|construction;163;
+highway|cycleway|bridge;[highway=cycleway][bridge?];;name;int_name;164;
+deprecated:highway|path|mountain_hiking:04.2024;[highway=path][sac_scale=mountain_hiking];x;name;int_name;166;highway|path
+highway|bridleway;168;
+highway|secondary_link;177;
+highway|footway|tunnel;[highway=footway][tunnel?],[highway=footway][location=underground];;name;int_name;183;
+highway|track|bridge;[highway=track][bridge?];;name;int_name;193;
+highway|path|bridge;[highway=path][bridge?];;name;int_name;194;
+highway|service|bridge;[highway=service][bridge?];;name;int_name;203;
+highway|service|area;[highway=service][area?];;name;int_name;226;
+highway|residential|area;[highway=residential][area?];;name;int_name;227;
+deprecated:highway|track|permissive:12.2023;[highway=track][access=permissive];x;name;int_name;229;highway|track
+highway|cycleway|tunnel;[highway=cycleway][tunnel?];;name;int_name;232;
+highway|unclassified|tunnel;[highway=unclassified][tunnel?];;name;int_name;235;
+highway|residential|tunnel;[highway=residential][tunnel?];;name;int_name;238;
+deprecated:highway|path|permissive:12.2023;[highway=path][access=permissive];x;name;int_name;240;highway|path
+highway|trunk_link|bridge;[highway=trunk_link][bridge?];;name;int_name;261;
+highway|service|tunnel;[highway=service][tunnel?];;name;int_name;263;
+highway|tertiary|tunnel;[highway=tertiary][tunnel?];;name;int_name;269;
+highway|tertiary_link;273;
+highway|footway|area;[highway=footway][area?];;name;int_name;276;
+highway|road|bridge;[highway=road][bridge?];;name;int_name;280;
+highway|secondary|tunnel;[highway=secondary][tunnel?];;name;int_name;297;
+deprecated:highway|path|demanding_mountain_hiking:04.2024;[highway=path][sac_scale=demanding_mountain_hiking];x;name;int_name;300;highway|path|difficult
+highway|pedestrian|bridge;[highway=pedestrian][bridge?];;name;int_name;304;
+highway|raceway;308;
+highway|primary|tunnel;[highway=primary][tunnel?];;name;int_name;309;
+highway|primary_link|bridge;[highway=primary_link][bridge?];;name;int_name;310;
+deprecated:highway|footway|hiking:04.2024;[highway=footway][sac_scale=hiking];x;name;int_name;314;highway|path
+highway|path|horse;[highway=path][horse?];;name;int_name;317;
+highway|trunk|tunnel;[highway=trunk][tunnel?];;name;int_name;326;
+highway|steps|tunnel;[highway=steps][tunnel?],[highway=steps][location=underground];;name;int_name;327;
+highway|steps|bridge;[highway=steps][bridge?];;name;int_name;330;
+highway|pedestrian|tunnel;[highway=pedestrian][tunnel?],[highway=pedestrian][location=underground];;name;int_name;332;
+highway|path|tunnel;[highway=path][tunnel?],[highway=path][location=underground];;name;int_name;336;
+deprecated:highway|path|alpine_hiking:04.2024;[highway=path][sac_scale=alpine_hiking];x;name;int_name;350;highway|path|expert
+deprecated:highway|cycleway|permissive:12.2023;[highway=cycleway][access=permissive];x;name;int_name;353;highway|cycleway
+highway|unclassified|area;[highway=unclassified][area?];;name;int_name;354;
+deprecated:highway|footway|mountain_hiking:04.2024;[highway=footway][sac_scale=mountain_hiking];x;name;int_name;361;highway|path
+deprecated:highway|service|driveway|bridge:01.2020;[highway=service][service=driveway][bridge?];x;name;int_name;362;highway|service|driveway
+deprecated:highway|bridleway|permissive:12.2023;[highway=bridleway][access=permissive];x;name;int_name;370;highway|bridleway
+highway|bridleway|bridge;[highway=bridleway][bridge?];;name;int_name;378;
+deprecated:highway|service|driveway|tunnel:01.2020;[highway=service][service=driveway][tunnel?];x;name;int_name;379;highway|service|driveway
+deprecated:highway|service|driveway|area:01.2020;[highway=service][service=driveway][area?];x;name;int_name;386;highway|service|driveway
+deprecated:highway|path|demanding_alpine_hiking:04.2024;[highway=path][sac_scale=demanding_alpine_hiking];x;name;int_name;395;highway|path|expert
+highway|secondary_link|bridge;[highway=secondary_link][bridge?];;name;int_name;397;
+area:highway|living_street;401;
+highway|living_street|bridge;[highway=living_street][bridge?];;name;int_name;407;
+highway|road;411;
+highway|motorway|tunnel;[highway=motorway][tunnel?];;name;int_name;416;
+area:highway|service;418;
+highway|road|tunnel;[highway=road][tunnel?];;name;int_name;423;
+highway|ford;427;
+area:highway|path;428;
+highway|track|area;[highway=track][area?];;name;int_name;430;
+deprecated:highway|path|difficult_alpine_hiking:04.2024;[highway=path][sac_scale=difficult_alpine_hiking];x;name;int_name;444;highway|path|expert
+deprecated:highway|footway|demanding_mountain_hiking:04.2024;[highway=footway][sac_scale=demanding_mountain_hiking];x;name;int_name;452;highway|path|difficult
+highway|living_street|tunnel;[highway=living_street][tunnel?];;name;int_name;457;
+highway|path|difficult;[highway=path][_path_grade=difficult];;name;int_name;464;
+highway|path|expert;[highway=path][_path_grade=expert];;name;int_name;465;
+area:highway|steps;470;
+highway|bridleway|tunnel;[highway=bridleway][tunnel?];;name;int_name;488;
+highway|motorway_link|tunnel;[highway=motorway_link][tunnel?];;name;int_name;489;
+highway|tertiary_link|bridge;[highway=tertiary_link][bridge?];;name;int_name;493;
+highway|trunk_link|tunnel;[highway=trunk_link][tunnel?];;name;int_name;503;
+highway|primary_link|tunnel;[highway=primary_link][tunnel?];;name;int_name;528;
+deprecated:highway|footway|alpine_hiking:04.2024;[highway=footway][sac_scale=alpine_hiking];x;name;int_name;529;highway|path|expert
+deprecated:amenity|speed_trap:10.2021;542;highway|speed_camera
+area:highway|track;543;
+area:highway|primary;544;
+deprecated:highway|footway|demanding_alpine_hiking:04.2024;[highway=footway][sac_scale=demanding_alpine_hiking];x;name;int_name;555;highway|path|expert
+highway|secondary_link|tunnel;[highway=secondary_link][tunnel?];;name;int_name;578;
+highway|track|grade3|permissive;[highway=track][tracktype=grade3][access=permissive];x;name;int_name;591;highway|track
+deprecated:highway|footway|difficult_alpine_hiking:04.2024;[highway=footway][sac_scale=difficult_alpine_hiking];x;name;int_name;627;highway|path|expert
+highway|track|grade5|permissive;[highway=track][tracktype=grade5][access=permissive];x;name;int_name;631;highway|track
+highway|tertiary_link|tunnel;[highway=tertiary_link][tunnel?];;name;int_name;634;
+highway|track|grade4|permissive;[highway=track][tracktype=grade4][access=permissive];x;name;int_name;675;highway|track
+highway|track|grade3|no-access;[highway=track][tracktype=grade3][access=no];x;name;int_name;821;highway|track
+highway|track|grade4|no-access;[highway=track][tracktype=grade4][access=no];x;name;int_name;822;highway|track
+highway|track|grade5|no-access;[highway=track][tracktype=grade5][access=no];x;name;int_name;823;highway|track
+highway|track|no-access;[highway=track][access=no];;name;int_name;824;
+deprecated:highway|service|busway:10.2023;[highway=service][service=busway];x;name;int_name;857;highway|busway
+highway|busway;[highway=busway],[highway=service][service=busway],[highway=service][service=bus];;name;int_name;858;
+highway|busway|bridge;[highway=busway][bridge?];;name;int_name;859;
+highway|busway|tunnel;[highway=busway][tunnel?];;name;int_name;860;
+area:highway|footway;866;
+area:highway|residential;868;
+area:highway|secondary;869;
+area:highway|tertiary;870;
+area:highway|pedestrian;873;
+area:highway|unclassified;874;
+area:highway|cycleway;877;
+area:highway|motorway;879;
+area:highway|trunk;880;
+highway|speed_camera;991;
+highway|world_level;1052;
+highway|world_towns_level;1053;
+highway|elevator;1059;
+highway|rest_area;1080;
+highway|traffic_signals;1081;
+hwtag|nobicycle;1114;
+hwtag|yesbicycle;1115;
+hwtag|bidir_bicycle;1116;
+highway|services;1173;
--- a/tests/assets/case-2-generate-drules-mini/readme.md
+++ b/tests/assets/case-2-generate-drules-mini/readme.md
@ -0,0 +1,4 @@
+Files for testLibkomwm.test_generate_drules_mini() method.
+
+These styles contain only zooms 0-10 and only highway=* rules.
+So we can verify generated files content.
--- a/tests/assets/case-3-styles-validation/readme.md
+++ b/tests/assets/case-3-styles-validation/readme.md
@ -0,0 +1 @@
+Files for testLibkomwm.test_generate_drules_validation_errors() method.
--- a/tests/testCondition.py
+++ b/tests/testCondition.py
@ -0,0 +1,300 @@
+import re
+import unittest
+import sys
+from pathlib import Path
+
+# Add `src` directory to the import paths
+sys.path.insert(0, str(Path(__file__).parent.parent / 'src'))
+
+from mapcss import parseCondition
+from mapcss.Condition import Condition
+
+class ConditionTest(unittest.TestCase):
+
+    def test_parser_eq(self):
+        cond:Condition = parseCondition("natural=coastline")
+        self.assertEqual(cond.type, "eq")
+        self.assertEqual(cond.params, ("natural", "coastline"))
+        self.assertTrue(cond.test({'natural': 'coastline'}))
+        self.assertFalse(cond.test({'Natural': 'Coastline'}))
+
+        cond = parseCondition("  highway\t=\tprimary")
+        self.assertEqual(cond.type, "eq")
+        self.assertEqual(cond.params, ("highway", "primary"))
+        self.assertTrue(cond.test({'highway': 'primary'}))
+        self.assertFalse(cond.test({'highway': 'secondary'}))
+
+        cond = parseCondition("  admin_level  =   3")
+        self.assertEqual(cond.type, "eq")
+        self.assertEqual(cond.params, ("admin_level", "3"))
+        self.assertTrue(cond.test({'admin_level': '3'}))
+        self.assertFalse(cond.test({'admin_level': '32'}))
+
+        cond = Condition('eq', ("::class", "::*"))
+        self.assertEqual(cond.type, "eq")
+        self.assertEqual(cond.params, ("::class", "::*"))
+        self.assertEqual(cond.extract_tag(), "*")
+        self.assertEqual(cond.test({'any_key': 'any_value'}), "::*")
+        self.assertTrue(cond.test({'any_key': 'any_value'}))
+
+        cond = Condition('eq', ("::class", "::int_name"))
+        self.assertEqual(cond.type, "eq")
+        self.assertEqual(cond.params, ("::class", "::int_name"))
+        self.assertEqual(cond.extract_tag(), "*")
+        self.assertEqual(cond.test({'any_key': 'any_value'}), "::int_name")
+        self.assertTrue(cond.test({'any_key': 'any_value'}))
+
+    def test_parser_regex(self):
+        """ Test conditions in format natural =~/water.+/
+            Note that such conditions are not used by Organic Maps styles.
+        """
+        cond:Condition = parseCondition("natural =~/water.+/")
+        self.assertEqual(cond.type, "regex")
+        self.assertEqual(cond.params, ("natural", "water.+"))
+        self.assertEqual(type(cond.regex), re.Pattern)
+        self.assertTrue(cond.test({"natural": "waterway"}))
+        self.assertTrue(cond.test({"natural": "water123"}))
+        self.assertFalse(cond.test({"natural": "water"}))
+        self.assertFalse(cond.test({"natural": " waterway "}))
+
+    def test_parser_ge(self):
+        cond:Condition = parseCondition("population>=0")
+        self.assertEqual(cond.type, ">=")
+        self.assertEqual(cond.params, ("population", "0"))
+        self.assertTrue(cond.test({"population": "0"}))
+        self.assertTrue(cond.test({"population": "100000"}))
+        self.assertFalse(cond.test({"highway": "secondary"}))
+        self.assertFalse(cond.test({"population": "-1"}))
+
+        cond:Condition = parseCondition("population >= 150000")
+        self.assertEqual(cond.type, ">=")
+        self.assertEqual(cond.params, ("population", "150000"))
+        self.assertTrue(cond.test({"population": "150000"}))
+        self.assertTrue(cond.test({"population": "250000"}))
+        self.assertFalse(cond.test({"highway": "secondary"}))
+        self.assertFalse(cond.test({"population": "10000"}))
+
+        cond:Condition = parseCondition("\tbbox_area  >= 4000000")
+        self.assertEqual(cond.type, ">=")
+        self.assertEqual(cond.params, ("bbox_area", "4000000"))
+        self.assertTrue(cond.test({"bbox_area": "4000000"}))
+        self.assertTrue(cond.test({"bbox_area": "8000000"}))
+        self.assertFalse(cond.test({"highway": "secondary"}))
+        self.assertFalse(cond.test({"bbox_area": "999"}))
+
+    def test_parser_gt(self):
+        """ Test conditions in format population > 100000
+            Note that such conditions are not used by Organic Maps styles.
+        """
+        cond:Condition = parseCondition("population>0")
+        self.assertEqual(cond.type, ">")
+        self.assertEqual(cond.params, ("population", "0"))
+        self.assertTrue(cond.test({"population": "100"}))
+        self.assertFalse(cond.test({"population": "000"}))
+        self.assertFalse(cond.test({"highway": "secondary"}))
+        self.assertFalse(cond.test({"population": "-1"}))
+
+        cond:Condition = parseCondition("population > 150000")
+        self.assertEqual(cond.type, ">")
+        self.assertEqual(cond.params, ("population", "150000"))
+        self.assertTrue(cond.test({"population": "250000"}))
+        self.assertFalse(cond.test({"population": "150000"}))
+        self.assertFalse(cond.test({"highway": "secondary"}))
+        self.assertFalse(cond.test({"population": "10000"}))
+
+        cond:Condition = parseCondition("\tbbox_area > 4000000 ")
+        self.assertEqual(cond.type, ">")
+        self.assertEqual(cond.params, ("bbox_area", "4000000 ")) # TODO fix parser to exclude trailing space
+        self.assertTrue(cond.test({"bbox_area": "8000000"}))
+        self.assertFalse(cond.test({"bbox_area": "4000000"}))
+        self.assertFalse(cond.test({"highway": "secondary"}))
+        self.assertFalse(cond.test({"bbox_area": "999"}))
+
+    def test_parser_lt(self):
+        cond:Condition = parseCondition("population<40000")
+        self.assertEqual(cond.type, "<")
+        self.assertEqual(cond.params, ("population", "40000"))
+        self.assertTrue(cond.test({"population": "100"}))
+        self.assertTrue(cond.test({"population": "-1"}))
+        self.assertFalse(cond.test({"population": "40000"}))
+        self.assertFalse(cond.test({"highway": "secondary"}))
+        self.assertFalse(cond.test({"population": "500000"}))
+
+        cond:Condition = parseCondition("\tbbox_area < 4000000\n")
+        self.assertEqual(cond.type, "<")
+        self.assertEqual(cond.params, ("bbox_area", "4000000\n")) # TODO fix parser to exclude trailing \n
+        self.assertTrue(cond.test({"bbox_area": "100"}))
+        self.assertTrue(cond.test({"bbox_area": "-1"}))
+        self.assertTrue(cond.test({"bbox_area": "000"}))
+        self.assertFalse(cond.test({"highway": "secondary"}))
+        self.assertFalse(cond.test({"bbox_area": "4000000"}))
+        self.assertFalse(cond.test({"bbox_area": "8000000"}))
+
+    def test_parser_le(self):
+        """ Test conditions in format population <= 100000
+            Note that such conditions are not used by Organic Maps styles.
+        """
+        cond:Condition = parseCondition("population<=40000")
+        self.assertEqual(cond.type, "<=")
+        self.assertEqual(cond.params, ("population", "40000"))
+        self.assertTrue(cond.test({"population": "100"}))
+        self.assertTrue(cond.test({"population": "-1"}))
+        self.assertTrue(cond.test({"population": "40000"}))
+        self.assertFalse(cond.test({"highway": "secondary"}))
+        self.assertFalse(cond.test({"population": "500000"}))
+
+        cond:Condition = parseCondition("\tbbox_area <= 4000000\n")
+        self.assertEqual(cond.type, "<=")
+        self.assertEqual(cond.params, ("bbox_area", "4000000\n")) # TODO fix parser to exclude trailing \n
+        self.assertTrue(cond.test({"bbox_area": "100"}))
+        self.assertTrue(cond.test({"bbox_area": "-1"}))
+        self.assertTrue(cond.test({"bbox_area": "000"}))
+        self.assertTrue(cond.test({"bbox_area": "4000000"}))
+        self.assertFalse(cond.test({"highway": "secondary"}))
+        self.assertFalse(cond.test({"bbox_area": "8000000"}))
+
+    def test_parser_ne(self):
+        cond:Condition = parseCondition("capital!=2")
+        self.assertEqual(cond.type, "ne")
+        self.assertEqual(cond.params, ("capital", "2"))
+        self.assertTrue(cond.test({"capital": "1"}))
+        self.assertTrue(cond.test({"capital": "22"}))
+        self.assertTrue(cond.test({"highway": "secondary"}))
+        self.assertFalse(cond.test({"capital": "2"}))
+
+        cond:Condition = parseCondition("\tcapital  !=  2")
+        self.assertEqual(cond.type, "ne")
+        self.assertEqual(cond.params, ("capital", "2"))
+        self.assertTrue(cond.test({"capital": "1"}))
+        self.assertTrue(cond.test({"capital": "22"}))
+        self.assertTrue(cond.test({"highway": "secondary"}))
+        self.assertFalse(cond.test({"capital": "2"}))
+
+        cond:Condition = parseCondition("garden:type != residential")
+        self.assertEqual(cond.type, "ne")
+        self.assertEqual(cond.params, ("garden:type", "residential"))
+        self.assertTrue(cond.test({"garden:type": "public"}))
+        self.assertTrue(cond.test({"garden:type": "res"}))
+        self.assertTrue(cond.test({"garden:type": "residential_plus"}))
+        self.assertTrue(cond.test({"highway": "secondary"}))
+        self.assertFalse(cond.test({"garden:type": "residential"}))
+
+    def test_parser_set(self):
+        cond:Condition = parseCondition("tunnel")
+        self.assertEqual(cond.type, "set")
+        self.assertEqual(cond.params, ("tunnel", ))
+        self.assertTrue(cond.test({"tunnel": "yes"}))
+        self.assertTrue(cond.test({"tunnel": "maybe"}))
+        self.assertTrue(cond.test({"tunnel": "+1"}))
+        self.assertFalse(cond.test({"highway": "secondary"}))
+
+        cond:Condition = parseCondition("building\t")
+        self.assertEqual(cond.type, "set")
+        self.assertEqual(cond.params, ("building", ))
+        self.assertTrue(cond.test({"building": "yes"}))
+        self.assertTrue(cond.test({"building": "apartment"}))
+        self.assertTrue(cond.test({"building": "1"}))
+        self.assertFalse(cond.test({"highway": "secondary"}))
+        self.assertFalse(cond.test({"building:part": "yes"}))
+
+        cond:Condition = parseCondition(" addr:housenumber ")
+        self.assertEqual(cond.type, "set")
+        self.assertEqual(cond.params, ("addr:housenumber", ))
+        self.assertTrue(cond.test({"addr:housenumber": "1"}))
+        self.assertTrue(cond.test({"addr:housenumber": "yes"}))
+        self.assertFalse(cond.test({"highway": "secondary"}))
+        self.assertFalse(cond.test({"addr:street": "Baker st"}))
+
+        cond:Condition = parseCondition(" some-tag ")
+        self.assertEqual(cond.type, "set")
+        self.assertEqual(cond.params, ("some-tag", ))
+        self.assertTrue(cond.test({"some-tag": "1"}))
+        self.assertTrue(cond.test({"some-tag": "yes"}))
+        self.assertFalse(cond.test({"highway": "secondary"}))
+        self.assertFalse(cond.test({"some": "tag"}))
+
+    def test_parser_unset(self):
+        cond:Condition = parseCondition("!tunnel")
+        self.assertEqual(cond.type, "unset")
+        self.assertEqual(cond.params, ("tunnel", ))
+        self.assertTrue(cond.test({"capital": "1"}))
+        self.assertFalse(cond.test({"tunnel": "yes"}))
+        self.assertFalse(cond.test({"tunnel": "no"}))
+
+        cond:Condition = parseCondition("\t!name  ")
+        self.assertEqual(cond.type, "unset")
+        self.assertEqual(cond.params, ("name", ))
+        self.assertTrue(cond.test({"capital": "1"}))
+        self.assertTrue(cond.test({"int_name": "1"}))
+        self.assertFalse(cond.test({"name": "London"}))
+
+    def test_parser_false(self):
+        """ Test conditions in format some_tag = no
+            Note that such conditions are not used by Organic Maps styles.
+        """
+        cond:Condition = parseCondition("access=no")
+        self.assertEqual(cond.type, "false")
+        self.assertEqual(cond.params, ("access", ))
+        #self.assertTrue(cond.test({"access": "no"}))      # test is not implemented for `false` condition
+        #self.assertTrue(cond.test({"access": "private"})) # test is not implemented for `false` condition
+        self.assertFalse(cond.test({"tunnel": "yes"}))
+
+    def test_parser_invTrue(self):
+        """ Test conditions in format [!some_tag?] It works the same way as [some_tag != yes]
+            Note that such conditions are not used by Organic Maps styles.
+        """
+        cond:Condition = parseCondition("!oneway?")
+        self.assertEqual(cond.type, "ne")
+        self.assertEqual(cond.params, ("oneway", "yes"))
+        self.assertTrue(cond.test({"oneway": "no"}))
+        self.assertTrue(cond.test({"oneway": "nobody_knows"}))
+        self.assertTrue(cond.test({"access": "private"}))
+        self.assertFalse(cond.test({"oneway": "yes"}))
+
+        cond:Condition = parseCondition("\t! intermittent ?\n")
+        self.assertEqual(cond.type, "ne")
+        self.assertEqual(cond.params, ("intermittent", "yes"))
+        self.assertTrue(cond.test({"intermittent": "no"}))
+        self.assertTrue(cond.test({"intermittent": "maybe"}))
+        self.assertTrue(cond.test({"access": "private"}))
+        self.assertFalse(cond.test({"intermittent": "yes"}))
+
+    def test_parser_true(self):
+        """ Test conditions in format [some_tag?] It works the same way as [some_tag = yes] """
+        cond:Condition = parseCondition("area?")
+        self.assertEqual(cond.type, "true")
+        self.assertEqual(cond.params, ("area", ))
+        self.assertTrue(cond.test({"area": "yes"}))
+        self.assertFalse(cond.test({"area": "no"}))
+        self.assertFalse(cond.test({"access": "private"}))
+        self.assertFalse(cond.test({"oneway": "nobody_knows"}))
+
+        cond:Condition = parseCondition("\tbridge ? ")
+        self.assertEqual(cond.type, "true")
+        self.assertEqual(cond.params, ("bridge", ))
+        self.assertTrue(cond.test({"bridge": "yes"}))
+        self.assertFalse(cond.test({"bridge": "no"}))
+        self.assertFalse(cond.test({"access": "private"}))
+        self.assertFalse(cond.test({"bridge": "maybe"}))
+
+    def test_untrue(self):
+        """ parseCondition(...) doesn't support this type of condition.
+            Not sure if it's ever used.
+        """
+        cond:Condition = Condition("untrue", "access")
+        self.assertEqual(cond.type, "untrue")
+        self.assertEqual(cond.params, ("access", ))
+        self.assertTrue(cond.test({"access": "no"}))
+        self.assertFalse(cond.test({"access": "private"}))
+        self.assertFalse(cond.test({"oneway": "yes"}))
+
+    def test_parser_errors(self):
+        with self.assertRaises(Exception):
+            parseCondition("! tunnel")
+        with self.assertRaises(Exception):
+            """ Symbol '-' is only supported in simple 'set' rule. E.g. [key-with-dash]
+                But not in 'unset' rule [!key-with-dash] """
+            parseCondition("key-with-dash?")
+
+if __name__ == '__main__':
+    unittest.main()
--- a/tests/testEval.py
+++ b/tests/testEval.py
@ -0,0 +1,124 @@
+import unittest
+import sys
+from pathlib import Path
+
+# Add `src` directory to the import paths
+sys.path.insert(0, str(Path(__file__).parent.parent / 'src'))
+
+from mapcss.Eval import Eval
+
+class EvalTest(unittest.TestCase):
+    """ Test eval(...) feature for CSS properties.
+        NOTE: eval() is not used in Organic Maps styles. We can drop it completely.
+    """
+    def test_eval_tag(self):
+        a = Eval("""eval( tag("lanes") )""")
+        self.assertEqual(a.compute({"lanes": "4"}), "4")
+        self.assertEqual(a.compute({"natural": "trees"}), "")
+        self.assertSetEqual(a.extract_tags(), {"lanes"})
+
+    def test_eval_prop(self):
+        a = Eval("""eval( prop("dpi") / 2 )""")
+        self.assertEqual(a.compute({"lanes": "4"}, {"dpi": 144}), "72")
+        self.assertEqual(a.compute({"lanes": "4"}, {"orientation": "vertical"}), "")
+        self.assertSetEqual(a.extract_tags(), set())
+
+    def test_eval_num(self):
+        a = Eval("""eval( num(tag("lanes")) + 2 )""")
+        self.assertEqual(a.compute({"lanes": "4"}), "6")
+        self.assertEqual(a.compute({"lanes": "many"}), "2")
+        self.assertSetEqual(a.extract_tags(), {"lanes"})
+
+    def test_eval_metric(self):
+        a = Eval("""eval( metric(tag("height")) )""")
+        self.assertEqual(a.compute({"height": "512"}), "512")
+        self.assertEqual(a.compute({"height": "10m"}), "10")
+        self.assertEqual(a.compute({"height": " 10m"}), "10")
+        self.assertEqual(a.compute({"height": "500cm"}), "5")
+        self.assertEqual(a.compute({"height": "500 cm"}), "5")
+        self.assertEqual(a.compute({"height": "250CM"}), "2.5")
+        self.assertEqual(a.compute({"height": "250 CM"}), "2.5")
+        self.assertEqual(a.compute({"height": "30см"}), "0.3")
+        self.assertEqual(a.compute({"height": " 30 см"}), "0.3")
+        self.assertEqual(a.compute({"height": "1200 mm"}), "1.2")
+        self.assertEqual(a.compute({"height": "2400MM"}), "2.4")
+        self.assertEqual(a.compute({"height": "2800 мм"}), "2.8")
+        self.assertSetEqual(a.extract_tags(), {"height"})
+
+    def test_eval_metric_with_scale(self):
+        a = Eval("""eval( metric(tag("height")) )""")
+        self.assertEqual(a.compute({"height": "512"}, xscale=4), "2048")
+        self.assertEqual(a.compute({"height": "512"}, zscale=4), "512")
+        self.assertEqual(a.compute({"height": "10m"}, xscale=4), "40")
+        self.assertEqual(a.compute({"height": " 10m"}, xscale=4), "40")
+        self.assertEqual(a.compute({"height": "500cm"}, xscale=4), "20")
+        self.assertEqual(a.compute({"height": "500 cm"}, xscale=4), "20")
+        self.assertEqual(a.compute({"height": "250CM"}, xscale=4), "10")
+        self.assertEqual(a.compute({"height": "250 CM"}, xscale=4), "10")
+        self.assertEqual(a.compute({"height": "30см"}, xscale=4), "1.2")
+        self.assertEqual(a.compute({"height": " 30 см"}, xscale=4), "1.2")
+        self.assertEqual(a.compute({"height": "1200 mm"}, xscale=4), "4.8")
+        self.assertEqual(a.compute({"height": "2400MM"}, xscale=4), "9.6")
+        self.assertEqual(a.compute({"height": "2800 мм"}, xscale=4), "11.2")
+        self.assertSetEqual(a.extract_tags(), {"height"})
+
+    def test_eval_zmetric(self):
+        a = Eval("""eval( zmetric(tag("depth")) )""")
+        self.assertEqual(a.compute({"depth": "512"}), "256")
+        self.assertEqual(a.compute({"depth": "10m"}), "5")
+        self.assertEqual(a.compute({"depth": " 10m"}), "5")
+        self.assertEqual(a.compute({"depth": "500cm"}), "2.5")
+        self.assertEqual(a.compute({"depth": "500 cm"}), "2.5")
+        self.assertEqual(a.compute({"depth": "250CM"}), "1.25")
+        self.assertEqual(a.compute({"depth": "250 CM"}), "1.25")
+        self.assertEqual(a.compute({"depth": "30см"}), "0.15")
+        self.assertEqual(a.compute({"depth": " 30 см"}), "0.15")
+        self.assertEqual(a.compute({"depth": "1200 mm"}), "0.6")
+        self.assertEqual(a.compute({"depth": "2400MM"}), "1.2")
+        self.assertEqual(a.compute({"depth": "2800 мм"}), "1.4")
+        self.assertSetEqual(a.extract_tags(), {"depth"})
+
+    def test_eval_str(self):
+        a = Eval("""eval( str( num(tag("width")) - 200 ) )""")
+        self.assertEqual(a.compute({"width": "400"}), "200.0")
+        self.assertSetEqual(a.extract_tags(), {"width"})
+
+    def test_eval_any(self):
+        a = Eval("""eval( any(tag("building"), tag("building:part"), "no") )""")
+        self.assertEqual(a.compute({"building": "apartment"}), "apartment")
+        self.assertEqual(a.compute({"building:part": "roof"}), "roof")
+        self.assertEqual(a.compute({"junction": "roundabout"}), "no")
+        self.assertSetEqual(a.extract_tags(), {"building", "building:part"})
+
+    def test_eval_min(self):
+        a = Eval("""eval( min( num(tag("building:levels")) * 3, 50) )""")
+        self.assertEqual(a.compute({"natural": "wood"}), "0")
+        self.assertEqual(a.compute({"building:levels": "0"}), "0")
+        self.assertEqual(a.compute({"building:levels": "10"}), "30")
+        self.assertEqual(a.compute({"building:levels": "30"}), "50")
+        self.assertSetEqual(a.extract_tags(), {"building:levels"})
+
+    def test_eval_max(self):
+        a = Eval("""eval( max( tag("speed:limit"), 60) )""")
+        self.assertEqual(a.compute({"natural": "wood"}), "60")
+        self.assertEqual(a.compute({"speed:limit": "30"}), "60")
+        self.assertEqual(a.compute({"speed:limit": "60"}), "60")
+        self.assertEqual(a.compute({"speed:limit": "90"}), "90")
+        self.assertSetEqual(a.extract_tags(), {"speed:limit"})
+
+    def test_eval_cond(self):
+        a = Eval("""eval( cond( boolean(tag("oneway")), 200, 100) )""")
+        self.assertEqual(a.compute({"natural": "wood"}), "100")
+        self.assertEqual(a.compute({"oneway": "yes"}), "200")
+        self.assertEqual(a.compute({"oneway": "no"}), "100")
+        self.assertEqual(a.compute({"oneway": "true"}), "200")
+        self.assertEqual(a.compute({"oneway": "probably no"}), "200")
+        self.assertSetEqual(a.extract_tags(), {"oneway"})
+
+    def test_complex_eval(self):
+        a = Eval(""" eval( any( metric(tag("height")), metric ( num(tag("building:levels")) * 3), metric("1m"))) """)
+        self.assertEqual(a.compute({"building:levels": "3"}), "9")
+        self.assertSetEqual(a.extract_tags(), {"height", "building:levels"})
+
+if __name__ == '__main__':
+    unittest.main()
--- a/tests/testLibkomwm.py
+++ b/tests/testLibkomwm.py
@ -0,0 +1,68 @@
+import unittest
+import sys
+from pathlib import Path
+from copy import deepcopy
+
+# Add `src` directory to the import paths
+sys.path.insert(0, str(Path(__file__).parent.parent / 'src'))
+
+import libkomwm
+from libkomwm import komap_mapswithme
+
+
+class LibKomwmTest(unittest.TestCase):
+    def test_generate_drules_mini(self):
+        assets_dir = Path(__file__).parent / 'assets' / 'case-2-generate-drules-mini'
+
+        class Options(object):
+            pass
+
+        options = Options()
+        options.data = None
+        options.minzoom = 0
+        options.maxzoom = 10
+        options.txt = True
+        options.filename = str( assets_dir / "main.mapcss" )
+        options.outfile = str( assets_dir / "style_output" )
+        options.priorities_path = str( assets_dir / "include" )
+
+        try:
+            # Save state
+            libkomwm.MULTIPROCESSING = False
+            prio_ranges_orig = deepcopy(libkomwm.prio_ranges)
+            libkomwm.visibilities = {}
+
+            # Run style generation
+            komap_mapswithme(options)
+
+            # Restore state
+            libkomwm.prio_ranges = prio_ranges_orig
+            libkomwm.MULTIPROCESSING = True
+            libkomwm.visibilities = {}
+
+            # Check that types.txt contains 1173 lines
+            with open(assets_dir / "types.txt", "rt") as typesFile:
+                lines = [l.strip() for l in typesFile]
+                self.assertEqual(len(lines), 1173, "Generated types.txt file should contain 1173 lines")
+                self.assertEqual(len([l for l in lines if l!="mapswithme"]), 148, "Actual types count should be 148 as in mapcss-mapping.csv")
+
+            # Check that style_output.bin has 20 styles
+            with open(assets_dir / "style_output.bin", "rb") as protobuf_file:
+                protobuf_data = protobuf_file.read()
+            drules = libkomwm.ContainerProto()
+            drules.ParseFromString(protobuf_data)
+
+            self.assertEqual(len(drules.cont), 20, "Generated style_output.bin should contain 20 styles")
+
+        finally:
+            # Clean up generated files
+            files2delete = ["classificator.txt", "colors.txt", "patterns.txt", "style_output.bin",
+                            "style_output.txt", "types.txt", "visibility.txt"]
+            for filename in files2delete:
+                (assets_dir / filename).unlink(missing_ok=True)
+
+    def test_generate_drules_validation_errors(self):
+        assets_dir = Path(__file__).parent / 'assets' / 'case-3-styles-validation'
+        # TODO: needs refactoring of libkomwm.validation_errors_count to have a list
+        #       of validation errors.
+        self.assertTrue(True)
--- a/tests/testMapCSS.py
+++ b/tests/testMapCSS.py
@ -0,0 +1,364 @@
+import unittest
+import sys
+from pathlib import Path
+
+# Add `src` directory to the import paths
+sys.path.insert(0, str(Path(__file__).parent.parent / 'src'))
+
+from mapcss import parseDeclaration, MapCSS
+
+
+class MapCSSTest(unittest.TestCase):
+    def test_declarations(self):
+        decl = parseDeclaration(""" linejoin: round; """)
+        self.assertEqual(len(decl), 1)
+        self.assertEqual(decl[0], {"linejoin": "round"})
+
+        decl = parseDeclaration("""\tlinejoin :\nround ; """)
+        self.assertEqual(len(decl), 1)
+        self.assertEqual(decl[0], {"linejoin": "round"})
+
+        decl = parseDeclaration(""" icon-image: parking_private-s.svg; text: "name"; """)
+        self.assertEqual(len(decl), 1)
+        self.assertEqual(decl[0], {
+            "icon-image": "parking_private-s.svg",
+            "text": "name"
+        })
+
+        decl = parseDeclaration("""
+            pattern-offset: 90\t;
+            pattern-image:\tarrow-m.svg   ;
+            pattern-spacing: @trunk0 ;""")
+        self.assertEqual(len(decl), 1)
+        self.assertEqual(decl[0], {
+            "pattern-offset": "90",
+            "pattern-image": "arrow-m.svg",
+            "pattern-spacing": "@trunk0",
+        })
+
+    def test_parse_variables(self):
+        parser = MapCSS()
+        parser.parse("""
+@city_label: #999999;
+@country_label: #444444;
+@wave_length: 25;
+""")
+        self.assertEqual(parser.variables, {
+            "city_label": "#999999",
+            "country_label": "#444444",
+            "wave_length": "25"
+        })
+
+    def test_parse_colors(self):
+        parser = MapCSS()
+        parser.parse("""
+@city_label : #999999;
+@country_label: #444444 ;
+  @wave_length: 25;
+""")
+        self.assertEqual(parser.variables, {
+            "city_label": "#999999",
+            "country_label": "#444444",
+            "wave_length": "25"
+        })
+
+    def test_parse_import(self):
+        parser = MapCSS()
+        mapcssFile = Path(__file__).parent / 'assets' / 'case-1-import' / 'main.mapcss'
+        parser.parse(filename=str(mapcssFile))
+
+        colors = parser.get_colors()
+        self.assertEqual(colors, {
+            "GuiText-color": (1.0, 1.0, 1.0),
+            "GuiText-opacity": 0.7,
+            "Route-color": (0.0, 0.0, 1.0),
+            "Route-opacity": 0.5,
+        })
+
+    def test_parse_basic_chooser(self):
+        parser = MapCSS()
+        static_tags = {"tourism": True, "office": True,
+                        "craft": True, "amenity": True}
+        parser.parse("""
+node|z17-[tourism],
+area|z17-[tourism],
+node|z18-[office],
+area|z18-[office],
+node|z18-[craft],
+area|z18-[craft],
+node|z19-[amenity],
+area|z19-[amenity],
+{text: name; text-color: #000030; text-offset: 1;}
+""", static_tags=static_tags)
+
+        self.assertEqual(len(parser.choosers), 1)
+        self.assertEqual(len(parser.choosers[0].ruleChains), 8)
+
+    def test_parse_basic_chooser_2(self):
+        parser = MapCSS()
+        static_tags = {"highway": True}
+        parser.parse("""
+@trunk0: #FF7326;
+
+line|z6[highway=trunk],
+line|z6[highway=motorway],
+{color: @trunk0; opacity: 0.3;}
+line|z7-9[highway=trunk],
+line|z7-9[highway=motorway],
+{color: @trunk0; opacity: 0.7;}
+""", static_tags=static_tags)
+
+        self.assertEqual(len(parser.choosers), 2)
+        self.assertEqual(len(parser.choosers[0].ruleChains), 2)
+        self.assertEqual(parser.choosers[0].ruleChains[0].subject, 'line')
+        self.assertEqual(parser.choosers[0].selzooms, [6, 6])
+        self.assertEqual(parser.choosers[1].selzooms, [7, 9])
+
+        rule, object_id = parser.choosers[0].testChains({"highway": "trunk"})
+        self.assertEqual(object_id, "::default")
+
+    def test_parse_basic_chooser_3(self):
+        parser = MapCSS()
+        static_tags = {"addr:housenumber": True, "addr:street": False}
+        parser.parse("""
+/* Some Comment Here */
+
+/*
+   This sample is borrowed from Organic Maps Basemap_label.mapcss file
+ */
+node|z18-[addr:housenumber][addr:street]::int_name
+{text: int_name; text-color: #65655E; text-position: center;}
+""", static_tags=static_tags)
+
+        building_tags = {"building": "yes", "addr:housenumber": "12", "addr:street": "Baker street"}
+
+        # Check that mapcss parsed correctly
+        self.assertEqual(len(parser.choosers), 1)
+        styleChooser = parser.choosers[0]
+        self.assertEqual(len(styleChooser.ruleChains), 1)
+        self.assertEqual(styleChooser.selzooms, [18, 19])
+        rule, object_id = styleChooser.testChains(building_tags)
+        self.assertEqual(object_id, "::int_name")
+
+        rule = styleChooser.ruleChains[0]
+        self.assertEqual(rule.subject, 'node')
+        self.assertEqual(rule.extract_tags(), {'addr:housenumber', 'addr:street'})
+
+    def test_parse_basic_chooser_class(self):
+        parser = MapCSS()
+        parser.parse("""
+way|z-13::*
+{
+  linejoin: round;
+}
+""")
+
+        # Check that mapcss parsed correctly
+        self.assertEqual(len(parser.choosers), 1)
+        styleChooser = parser.choosers[0]
+        self.assertEqual(len(styleChooser.ruleChains), 1)
+        self.assertEqual(styleChooser.selzooms, [0, 13])
+        rule, object_id = styleChooser.testChains({})
+        self.assertEqual(object_id, "::*")
+
+        rule = styleChooser.ruleChains[0]
+        self.assertEqual(rule.subject, 'way')
+        self.assertEqual(rule.extract_tags(), {'*'})
+
+    def test_parse_basic_chooser_class_2(self):
+        parser = MapCSS()
+        parser.parse("""
+way|z10-::*
+{
+  linejoin: round;
+}
+""")
+
+        # Check that mapcss parsed correctly
+        self.assertEqual(len(parser.choosers), 1)
+        styleChooser = parser.choosers[0]
+        self.assertEqual(len(styleChooser.ruleChains), 1)
+        self.assertEqual(styleChooser.selzooms, [10, 19])
+        rule, object_id = styleChooser.testChains({})
+        self.assertEqual(object_id, "::*")
+
+        rule = styleChooser.ruleChains[0]
+        self.assertEqual(rule.subject, 'way')
+        self.assertEqual(rule.extract_tags(), {'*'})
+
+    def test_parse_basic_chooser_colors(self):
+        parser = MapCSS()
+        parser.parse("""
+way|z-6::*
+{
+  linejoin: round;
+}
+
+colors {
+  GuiText-color: #FFFFFF;
+  GuiText-opacity: 0.7;
+  MyPositionAccuracy-color: #FFFFFF;
+  MyPositionAccuracy-opacity: 0.06;
+  Selection-color: #FFFFFF;
+  Selection-opacity: 0.64;
+  Route-color: #0000FF;
+  RouteOutline-color: #00FFFF;
+}
+""")
+
+        # Check that colors from mapcss parsed correctly
+        colors = parser.get_colors()
+        self.assertEqual(colors, {
+            "GuiText-color": (1.0, 1.0, 1.0),
+            "GuiText-opacity": 0.7,
+            "MyPositionAccuracy-color": (1.0, 1.0, 1.0),
+            "MyPositionAccuracy-opacity": 0.06,
+            "Selection-color": (1.0, 1.0, 1.0),
+            "Selection-opacity": 0.64,
+            "Route-color": (0.0, 0.0, 1.0),
+            "RouteOutline-color": (0.0, 1.0, 1.0)
+        })
+
+    def test_parser_choosers_tree(self):
+        parser = MapCSS()
+        static_tags = {"tourism": True, "office": True,
+                       "craft": True, "amenity": True}
+
+        parser.parse("""
+node|z17-[office=lawyer],
+area|z17-[office=lawyer],
+{text: name;text-color: #444444;text-offset: 1;font-size: 10;}
+
+node|z17-[tourism],
+area|z17-[tourism],
+node|z18-[office],
+area|z18-[office],
+node|z18-[craft],
+area|z18-[craft],
+node|z19-[amenity],
+area|z19-[amenity],
+{text: name; text-color: #000030; text-offset: 1;}
+
+node|z18-[office],
+area|z18-[office],
+node|z18-[craft],
+area|z18-[craft],
+{font-size: 11;}
+
+node|z17-[office=lawyer],
+area|z17-[office=lawyer]
+{icon-image: lawyer-m.svg;}
+""", static_tags=static_tags)
+
+        for obj_type in ["line", "area", "node"]:
+            parser.build_choosers_tree("tourism", obj_type, "tourism")
+            parser.build_choosers_tree("office", obj_type, "office")
+            parser.build_choosers_tree("craft", obj_type, "craft")
+            parser.build_choosers_tree("amenity", obj_type, "amenity")
+
+        parser.finalize_choosers_tree()
+
+        # Pick style for zoom = 17
+        styles18 = parser.get_style("office", "node", {"office": "lawyer"},
+                                    zoom=18, xscale=1, zscale=1, filter_by_runtime_conditions=False)
+
+        self.assertEqual(len(styles18), 1),
+        self.assertEqual(styles18[0], {'object-id': '::default',
+            'font-size': '11',
+            'text': 'name',
+            'text-color': (0, 0, 16*3/255),
+            'text-offset': 1.0,
+            'icon-image': 'lawyer-m.svg'})
+
+        # Pick style for zoom = 17
+        styles17 = parser.get_style("office", "node", {"office": "lawyer"},
+                                    zoom=17, xscale=1, zscale=1, filter_by_runtime_conditions=False)
+
+        self.assertEqual(len(styles17), 1),
+        self.assertEqual(styles17[0], {'object-id': '::default',
+            'font-size': '10',
+            'text': 'name',
+            'text-color': (68/255, 68/255, 68/255),
+            'text-offset': 1.0,
+            'icon-image': 'lawyer-m.svg'})
+
+        # Pick style for zoom = 15
+        styles15 = parser.get_style("office", "node", {"office": "lawyer"},
+                                    zoom=15, xscale=1, zscale=1, filter_by_runtime_conditions=False)
+
+        self.assertEqual(styles15, []),
+
+    def test_parser_choosers_tree_with_classes(self):
+        parser = MapCSS()
+        static_tags = {"highway": True}
+
+        parser.parse("""
+line|z10-[highway=motorway]::shield,
+line|z10-[highway=trunk]::shield,
+line|z10-[highway=motorway_link]::shield,
+line|z10-[highway=trunk_link]::shield,
+line|z10-[highway=primary]::shield,
+line|z11-[highway=primary_link]::shield,
+line|z12-[highway=secondary]::shield,
+line|z13-[highway=tertiary]::shield,
+line|z15-[highway=residential]::shield,
+{
+  shield-font-size: 9;
+  shield-text-color: #000000;
+  shield-text-halo-radius: 0;
+  shield-color: #FFFFFF;
+  shield-outline-radius: 1;
+}
+
+line|z12-[highway=residential],
+line|z12-[highway=tertiary],
+line|z18-[highway=tertiary_link]
+{
+  text: name;
+  text-color: #333333;
+  text-halo-opacity: 0.8;
+  text-halo-radius: 1;
+}
+
+line|z12-13[highway=residential],
+line|z12-13[highway=tertiary]
+{
+    font-size: 12;
+    text-color: #444444;
+}
+""", static_tags=static_tags)
+
+        parser.build_choosers_tree("highway", "line", "highway")
+        parser.finalize_choosers_tree()
+
+        # Pick style for zoom = 10
+        styles10 = parser.get_style("highway", "line", {"highway": "primary"},
+                                    zoom=10, xscale=1, zscale=1, filter_by_runtime_conditions=False)
+
+        self.assertEqual(len(styles10), 1),
+        self.assertEqual(styles10[0], {'object-id': '::shield',
+            'shield-font-size': '9',
+            'shield-text-color': (0.0, 0.0, 0.0),
+            'shield-text-halo-radius': 0.0,
+            'shield-color': (1.0, 1.0, 1.0),
+            'shield-outline-radius': 1.0})
+
+        # Pick style for zoom = 15. Expecting two `object-id` values: '::shield' and '::default'
+        styles15 = parser.get_style("highway", "line", {"highway": "tertiary"},
+                                    zoom=15, xscale=1, zscale=1, filter_by_runtime_conditions=False)
+
+        self.assertEqual(len(styles15), 2),
+        self.assertEqual(styles15[0], {'object-id': '::shield',
+            'shield-font-size': '9',
+            'shield-text-color': (0.0, 0.0, 0.0),
+            'shield-text-halo-radius': 0.0,
+            'shield-color': (1.0, 1.0, 1.0),
+            'shield-outline-radius': 1.0})
+        self.assertEqual(styles15[1], {'object-id': '::default',
+            'text': 'name',
+            'text-color': (51/255, 51/255, 51/255),
+            'text-halo-opacity': 0.8,
+            'text-halo-radius': 1.0})
+
+if __name__ == '__main__':
+    unittest.main()
--- a/tests/testRule.py
+++ b/tests/testRule.py
@ -0,0 +1,114 @@
+import unittest
+import sys
+from pathlib import Path
+
+# Add `src` directory to the import paths
+sys.path.insert(0, str(Path(__file__).parent.parent / 'src'))
+
+from mapcss.Rule import Rule
+from mapcss.Condition import Condition
+from mapcss import parseCondition
+
+class RuleTest(unittest.TestCase):
+    def test_rule_subject(self):
+        self.assertEqual(Rule().subject, "")
+        self.assertEqual(Rule("*").subject, "")
+        self.assertEqual(Rule("way").subject, "way")
+        self.assertEqual(Rule("area").subject, "area")
+        self.assertEqual(Rule("node").subject, "node")
+        self.assertEqual(Rule("planet").subject, "planet")
+
+    def test_rule_type_matches(self):
+        self.assertCountEqual(Rule().type_matches, ('area', 'line', 'way', 'node'))
+        self.assertCountEqual(Rule("*").type_matches, ('area', 'line', 'way', 'node'))
+        self.assertCountEqual(Rule("way").type_matches, ('area', 'line', 'way'))
+        self.assertCountEqual(Rule("area").type_matches, ('area', 'way'))
+        self.assertCountEqual(Rule("node").type_matches, ('node', ))
+        self.assertCountEqual(Rule("planet").type_matches, set())
+
+    def test_rule_with_conditions(self):
+        rule = Rule()
+        rule.conditions = [
+            parseCondition("aeroway=aerodrome"),
+            parseCondition("aerodrome=international")
+        ]
+
+        tt = rule.test({
+            "aeroway": "aerodrome",
+            "aerodrome": "international",
+            "name": "JFK"
+        })
+        self.assertTrue(tt)
+        self.assertEqual(tt, "::default")
+
+        self.assertCountEqual(rule.extract_tags(), ["aeroway", "aerodrome"])
+
+        # Negative test cases
+        self.assertFalse(rule.test({
+            "aeroway": "aerodrome",
+            "name": "JFK"
+        }))
+
+    def test_rule_with_class(self):
+        rule = Rule()
+        rule.conditions = [
+            parseCondition("highway=unclassified"),
+            parseCondition("bridge?"),
+            Condition("eq", ("::class", "::bridgeblack"))
+        ]
+
+        tt = rule.test({
+            "highway": "unclassified",
+            "bridge": "yes",
+            "layer": "1"
+        })
+        self.assertTrue(tt)
+        self.assertEqual(tt, "::bridgeblack")
+
+        self.assertCountEqual(rule.extract_tags(), ["highway", "bridge"])
+
+        # Negative test cases
+        self.assertFalse(rule.test({
+            "highway": "unclassified",
+            "bridge": "no",
+            "layer": "1"
+        }))
+        self.assertFalse(rule.test({
+            "highway": "unclassified",
+            "tunnel": "yes",
+            "layer": "-1"
+        }))
+
+    def test_tags_from_rule_with_class(self):
+        # Class condition doesn't add new tags
+        rule = Rule()
+        rule.conditions = [
+            parseCondition("highway=unclassified"),
+            parseCondition("bridge?"),
+            Condition("eq", ("::class", "::bridgeblack")),
+        ]
+
+        self.assertCountEqual(rule.extract_tags(), ["highway", "bridge"])
+
+        # Class condition doesn't add new tags
+        rule = Rule()
+        rule.conditions = [
+            parseCondition("highway=unclassified"),
+            Condition("eq", ("::class", "::*")),
+            parseCondition("bridge?"),
+        ]
+
+        self.assertCountEqual(rule.extract_tags(), ["highway", "bridge"])
+
+        # BUT having class as a first item overrides all the others
+        rule = Rule()
+        rule.conditions = [
+            Condition("eq", ("::class", "::int_name")),
+            parseCondition("highway=unclassified"),
+            parseCondition("bridge?"),
+        ]
+
+        self.assertCountEqual(rule.extract_tags(), ["*"])
+
+if __name__ == '__main__':
+    unittest.main()
--- a/tests/testStyleChooser.py
+++ b/tests/testStyleChooser.py
@ -0,0 +1,297 @@
+import unittest
+import sys
+from pathlib import Path
+
+from mapcss.Rule import Rule
+
+# Add `src` directory to the import paths
+sys.path.insert(0, str(Path(__file__).parent.parent / 'src'))
+
+from mapcss import parseCondition, Condition
+from mapcss.Eval import Eval
+from mapcss.StyleChooser import StyleChooser, make_nice_style
+
+
+class StyleChooserTest(unittest.TestCase):
+    def test_rules_chain(self):
+        sc = StyleChooser((0, 16))
+
+        sc.newObject()
+        sc.addCondition(parseCondition("highway=footway"))
+        sc.addCondition(parseCondition("footway=sidewalk"))
+
+        sc.newObject()
+        sc.addCondition(parseCondition("highway=footway"))
+        sc.addCondition(parseCondition("footway=crossing"))
+        sc.addCondition(Condition("eq", ("::class", "::*")))
+
+        self.assertTrue( sc.testChains({ "highway": "footway", "footway": "sidewalk" }) )
+        self.assertTrue( sc.testChains({ "highway": "footway", "footway": "crossing" }) )
+        self.assertFalse( sc.testChains({ "highway": "footway"}) )
+        self.assertFalse( sc.testChains({ "highway": "residential", "footway": "crossing" }) )
+
+        rule1, tt = sc.testChains({ "highway": "footway", "footway": "sidewalk" })
+        self.assertEqual(tt, "::default")
+
+        rule2, tt = sc.testChains({ "highway": "footway", "footway": "crossing" })
+        self.assertEqual(tt, "::*")
+
+        self.assertNotEqual(rule1, rule2)
+
+    def test_zoom(self):
+        sc = StyleChooser((0, 16))
+
+        sc.newObject()
+        sc.addZoom( (10, 19) )
+        sc.addCondition(parseCondition("railway=station"))
+        sc.addCondition(parseCondition("transport=subway"))
+        sc.addCondition(parseCondition("city=yerevan"))
+
+        sc.newObject()
+        sc.addZoom( (4, 15) )
+        sc.addCondition(parseCondition("railway=station"))
+        sc.addCondition(parseCondition("transport=subway"))
+        sc.addCondition(parseCondition("city=yokohama"))
+
+        rule1, tt = sc.testChains({ "railway": "station", "transport": "subway", "city": "yerevan" })
+        self.assertEqual(rule1.minZoom, 10)
+        self.assertEqual(rule1.maxZoom, 19)
+
+        rule2, tt = sc.testChains({ "railway": "station", "transport": "subway", "city": "yokohama" })
+        self.assertEqual(rule2.minZoom, 4)
+        self.assertEqual(rule2.maxZoom, 15)
+
+    def test_extract_tags(self):
+        sc = StyleChooser((0, 16))
+
+        sc.newObject()
+        sc.addCondition(parseCondition("aerialway=rope_tow"))
+
+        sc.newObject()
+        sc.addCondition(parseCondition("piste:type=downhill"))
+
+        self.assertSetEqual(sc.extract_tags(), {"aerialway", "piste:type"})
+
+        sc = StyleChooser((0, 16))
+
+        sc.newObject()
+        sc.addCondition(parseCondition("aeroway=terminal"))
+        sc.addCondition(parseCondition("building"))
+
+        sc.newObject()
+        sc.addCondition(parseCondition("waterway=dam"))
+        sc.addCondition(parseCondition("building:part"))
+
+        self.assertSetEqual(sc.extract_tags(), {"waterway", "building:part", "building", "aeroway"})
+
+    def test_make_nice_style(self):
+        style = make_nice_style({
+            "outline-color": "none",
+            "bg-color": "red",
+            "dash-color": "#ffff00",
+            "front-color": "rgb(0, 255, 255)",
+            "line-width": Eval("""eval(min(tag("line_width"), 10))"""),
+            "outline-width": "2.5",
+            "arrow-opacity": "0.5",
+            "offset-2": "20",
+            "border-radius": "4",
+            "line-extrude": "16",
+            "dashes": "3,3,1.5,3",
+            "wrong-dashes": "yes, yes, yes, no",
+            "make-nice": True,
+            "additional-len": 44.5
+        })
+
+        expectedStyle = {
+            "outline-color": "none",
+            "bg-color": (1.0, 0.0, 0.0),
+            "dash-color": (1.0, 1.0, 0.0),
+            "front-color": (0.0, 1.0, 1.0),
+            "line-width": Eval("""eval(min(tag("line_width"), 10))"""),
+            "outline-width": 2.5,
+            "arrow-opacity": 0.5,
+            "offset-2": 20.0,
+            "border-radius": 4.0,
+            "line-extrude": 16.0,
+            "dashes": [3.0, 3.0, 1.5, 3.0],
+            "wrong-dashes": [],
+            "make-nice": True,
+            "additional-len": 44.5
+        }
+
+        self.assertEqual(style, expectedStyle)
+
+    def test_add_styles(self):
+        sc = StyleChooser((15, 19))
+        sc.newObject()
+        sc.addStyles([{
+            "width": "1.3",
+            "opacity": "0.6",
+            "bg-color": "blue"
+        }])
+        sc.addStyles([{
+            "color": "#FFFFFF",
+            "casing-width": "+10"
+        }])
+
+        self.assertEqual(len(sc.styles), 2)
+        self.assertEqual(sc.styles[0], {
+            "width": 1.3,
+            "opacity": 0.6,
+            "bg-color": (0.0, 0.0, 1.0)
+        })
+        self.assertEqual(sc.styles[1], {
+            "color": (1.0, 1.0, 1.0),
+            "casing-width": 5.0
+        })
+
+    def test_update_styles(self):
+        styles = [{"primary_color": (1.0, 1.0, 1.0)}]
+
+        sc = StyleChooser((15, 19))
+        sc.newObject()
+        sc.addStyles([{
+            "width": "1.3",
+            "opacity": "0.6",
+            "bg-color": """eval( prop("primary_color") )""", # Check that property from `styles` is applied
+            "text-offset": """eval( cond( boolean(tag("oneway")), 10, 5) )""" # Check that tags are applied
+        }])
+
+        object_tags = {"highway": "service",
+                       "oneway": "yes"}
+        new_styles = sc.updateStyles(styles, object_tags, 1.0, 1.0, False)
+        expected_new_styles = {
+            "width": 1.3,
+            "opacity": 0.6,
+            "bg-color": (1.0, 1.0, 1.0),
+            "text-offset": 10.0,
+            "object-id": "::default"
+        }
+
+        self.assertEqual(len(new_styles), 2)
+        self.assertEqual(new_styles[-1], expected_new_styles)
+
+    def test_update_styles_2(self):
+        styles = []
+
+        sc = StyleChooser((15, 19))
+
+        sc.newObject()
+        sc.addCondition(Condition("eq", ("::class", "::int_name") )) # Class should be added to the style
+        sc.addCondition(parseCondition("oneway?"))
+
+        sc.addStyles([{
+            "width": "1.3",
+            "bg-color": "black"
+        }])
+
+        object_tags = {"highway": "service", "oneway": "yes"}
+        new_styles = sc.updateStyles(styles, object_tags, 1.0, 1.0, False)
+        expected_new_styles = {
+            "width": 1.3,
+            "bg-color": (0.0, 0.0, 0.0),
+            "object-id": "::int_name" # Check that class from sc.ruleChains is added to the style
+        }
+
+        self.assertEqual(len(new_styles), 1)
+        self.assertEqual(new_styles[-1], expected_new_styles)
+
+
+    def test_update_styles_by_class(self):
+        # Predefined styles
+        styles = [{
+            "some-width": 2.5,
+            "object-id": "::flats"
+        },
+        {
+            "some-width": 3.5,
+            "object-id": "::bridgeblack"
+        },
+        {
+            "some-width": 4.5,
+            "object-id": "::default"
+        }]
+
+        sc = StyleChooser((15, 19))
+
+        sc.newObject()
+        sc.addCondition(Condition("eq", ("::class", "::flats") )) # `sc` styles should apply only to `::flats` class
+        sc.addCondition(parseCondition("oneway?"))
+
+        sc.newObject()
+        sc.addCondition(Condition("eq", ("::class", "::bridgeblack") )) # This class is ignored by StyleChooser
+        sc.addCondition(parseCondition("oneway?"))
+
+        sc.addStyles([{
+            "some-width": "1.5",
+            "other-offset": "4"
+        }])
+
+        object_tags = {"highway": "service", "oneway": "yes"}
+
+        # Apply new style to predefined styles with filter by class
+        new_styles = sc.updateStyles(styles, object_tags, 1.0, 1.0, False)
+
+        expected_new_styles = [{ # The first style changes
+            "some-width": 1.5,
+            "other-offset": 4.0,
+            "object-id": "::flats"
+        },
+        { # Style not changed (class is not `::flats`)
+            "some-width": 3.5,
+            "object-id": "::bridgeblack"
+        },
+        { # Style not changed (class is not `::flats`)
+            "some-width": 4.5,
+            "object-id": "::default"
+        }]
+
+        self.assertEqual(len(new_styles), 3)
+        self.assertEqual(new_styles, expected_new_styles)
+
+
+    def test_update_styles_by_class_all(self):
+        # Predefined styles
+        styles = [{ # This is applied to StyleChooser styles
+            "some-width": 2.5,
+            "corner-radius": 2.5,
+            "object-id": "::*"
+        },
+        {
+            "some-width": 3.5,
+            "object-id": "::bridgeblack"
+        }]
+
+        sc = StyleChooser((15, 19))
+
+        sc.newObject()
+        sc.addCondition(parseCondition("tunnel"))
+
+        sc.addStyles([{
+            "some-width": "1.5",
+            "other-offset": "4"
+        }])
+        object_tags = {"highway": "service", "tunnel": "yes"}
+
+        # Apply new style to predefined styles with filter by class
+        new_styles = sc.updateStyles(styles, object_tags, 1.0, 1.0, False)
+
+        # Check that new style with new `object-id` is added.
+        # This style is built from `styles[0]` and styles from `sc`
+        expected_new_style = {
+            "some-width": 1.5,
+            "corner-radius": 2.5,
+            "other-offset": 4.0,
+            "object-id": "::default"  # New class, never listed in `styles`
+        }
+
+        self.assertEqual(len(new_styles), 3)
+        self.assertEqual(new_styles[-1], expected_new_style)
+
+
+    def test_runtime_conditions(self):
+        # TODO: Create test with  sc.addRuntimeCondition(Condition(condType, ('extra_tag', cond)))
+        pass
+
+if __name__ == '__main__':
+    unittest.main()
				`@ -0,0 +1 @@`
				`Files for testLibkomwm.test_generate_drules_validation_errors() method.`