Merge branch 'develop'v0.23.03

6 files changed, 1336 insertions, 0 deletions

diff --git a/test/parsing/__init__.py b/test/parsing/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/test/parsing/__init__.py
diff --git a/test/parsing/filter/__init__.py b/test/parsing/filter/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/test/parsing/filter/__init__.py
diff --git a/test/parsing/filter/test_from_string.py b/test/parsing/filter/test_from_string.py
new file mode 100644
index 0000000..180820a
--- /dev/null
+++ b/test/parsing/filter/test_from_string.py
@@ -0,0 +1,751 @@
+"""
+
+Part of the tagit test suite.
+A copy of the license is provided with the project.
+Author: Matthias Baumgartner, 2022
+"""
+# standard imports
+import unittest
+from datetime import datetime
+
+# external imports
+from pyparsing import ParseException
+
+# tagit imports
+from tagit.utils import bsfs, errors, ns
+from tagit.utils.bsfs import ast
+
+# objects to test
+from tagit.parsing.filter.from_string import FromString
+
+
+## code ##
+
+class TestFromString(unittest.TestCase):
+    longMessage = True
+
+    def setUp(self):
+        #predicates.expose('mime', TestScope('attribute', 'mime'), 'Categorical')
+        #predicates.expose('iso', TestScope('attribute', 'iso'), 'Continuous', 'Categorical')
+        #predicates.expose('time', TestScope('generic', 't_image_create_loc'), 'TimeRange', 'Datetime')
+        #predicates.expose('tag', TestScope('generic', 'tag'), 'Categorical')
+
+        #predicates.expose('mime', TestScope('attribute', 'mime'), 'Categorical')
+        #predicates.expose('rank', TestScope('attribute', 'rank'), 'Continuous')
+        #predicates.expose('iso', TestScope('attribute', 'iso'), 'Continuous', 'Categorical')
+        #predicates.expose('time', TestScope('generic', 't_image_create_loc'), 'TimeRange', 'Datetime')
+        #predicates.expose('tag', TestScope('generic', 'tag'), 'Categorical')
+
+
+        self.schema = bsfs.schema.from_string('''
+            # common external prefixes
+            prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#>
+            prefix xsd: <http://www.w3.org/2001/XMLSchema#>
+
+            # common bsfs prefixes
+            prefix bsfs: <http://bsfs.ai/schema/>
+            prefix bse: <http://bsfs.ai/schema/Entity#>
+
+            # nodes
+            bsfs:Entity rdfs:subClassOf bsfs:Node .
+            bsfs:Tag rdfs:subClassOf bsfs:Node .
+
+            # literals
+            bsfs:Time rdfs:subClassOf bsfs:Literal .
+            xsd:string rdfs:subClassOf bsfs:Literal .
+            bsfs:Number rdfs:subClassOf bsfs:Literal .
+            xsd:integer rdfs:subClassOf bsfs:Number .
+
+            # predicates
+            bse:mime rdfs:subClassOf bsfs:Predicate ;
+                rdfs:domain bsfs:Entity ;
+                rdfs:range xsd:string ;
+                bsfs:unique "true"^^xsd:boolean .
+
+            bse:iso rdfs:subClassOf bsfs:Predicate ;
+                rdfs:domain bsfs:Entity ;
+                rdfs:range xsd:integer ;
+                bsfs:unique "true"^^xsd:boolean .
+
+            bse:time rdfs:subClassOf bsfs:Predicate ;
+                rdfs:domain bsfs:Entity ;
+                rdfs:range bsfs:Time;
+                bsfs:unique "true"^^xsd:boolean .
+
+            bse:tag rdfs:subClassOf bsfs:Predicate ;
+                rdfs:domain bsfs:Entity ;
+                rdfs:range bsfs:Tag ;
+                bsfs:unique "false"^^xsd:boolean .
+
+            bse:rank rdfs:subClassOf bsfs:Predicate ;
+                rdfs:domain bsfs:Entity ;
+                rdfs:range xsd:integer ;
+                bsfs:unique "false"^^xsd:boolean .
+
+            ''')
+        self.parse = FromString(self.schema)
+
+    def _test_number(self, query, target):
+        predicate, condition = target
+        result = self.parse(query)
+        target = ast.filter.And(ast.filter.Any(predicate, condition))
+        self.assertEqual(result, target, msg="in query '{}'".format(query))
+
+    def test_larger_than(self):
+        # larger than A (inclusive)
+        for editable in [
+            # range
+            "{predicate} in [{num}:]", "{predicate} in [{num}:[", "{predicate} in [{num}:)",
+            "{predicate} :  [{num}:]", "{predicate} :  [{num}:[", "{predicate} :  [{num}:)",
+            "{predicate} =  [{num}:]", "{predicate} =  [{num}:[", "{predicate} =  [{num}:)",
+            ]:
+            # positive
+            self._test_number(editable.format(num=1.23, predicate='iso'),
+                (ns.bse.iso, ast.filter.GreaterThan(1.23, False)))
+            # negative
+            self._test_number(editable.format(num=-1.23, predicate='iso'),
+                (ns.bse.iso, ast.filter.GreaterThan(-1.23, False)))
+
+        for editable in [
+            # range
+            "{predicate} in [{num}-]", "{predicate} in [{num}-[", "{predicate} in [{num}-)",
+            "{predicate} :  [{num}-]", "{predicate} :  [{num}-[", "{predicate} :  [{num}-)",
+            "{predicate} =  [{num}-]", "{predicate} =  [{num}-[", "{predicate} =  [{num}-)",
+            # equation
+            "{predicate} >= {num}", "{num} <= {predicate}",
+            ]:
+            # positive
+            self._test_number(editable.format(num=1.23, predicate='iso'),
+                (ns.bse.iso, ast.filter.GreaterThan(1.23, False)))
+            # negative
+            self._test_number(editable.format(num=-1.23, predicate='iso'),
+                (ns.bse.iso, ast.filter.GreaterThan(-1.23, False)))
+            # FIXME: date
+            #self._test_number(editable.format(predicate='time', num="30.04.2012, 13:18"),
+            #    ('time', ast.Datetime(datetime(2012, 4, 30, 13, 18), datetime.max, True, False)))
+
+        # larger than A (exclusive)
+        for editable in [
+            # range / bracket
+            "{predicate} in ]{num}:]", "{predicate} in ]{num}:[", "{predicate} in ]{num}:)",
+            "{predicate} :  ]{num}:]", "{predicate} :  ]{num}:[", "{predicate} :  ]{num}:)",
+            "{predicate} =  ]{num}:]", "{predicate} =  ]{num}:[", "{predicate} =  ]{num}:)",
+            # range / parenthesis
+            "{predicate} in ({num}:]", "{predicate} in ({num}:[", "{predicate} in ({num}:)",
+            "{predicate} :  ({num}:]", "{predicate} :  ({num}:[", "{predicate} :  ({num}:)",
+            "{predicate} =  ({num}:]", "{predicate} =  ({num}:[", "{predicate} =  ({num}:)",
+            ]:
+            # positive
+            self._test_number(editable.format(num=1.23, predicate='iso'),
+                (ns.bse.iso, ast.filter.GreaterThan(1.23, True)))
+            # negative
+            self._test_number(editable.format(num=-1.23, predicate='iso'),
+                (ns.bse.iso, ast.filter.GreaterThan(-1.23, True)))
+
+        for editable in [
+            # range / bracket
+            "{predicate} in ]{num}-]", "{predicate} in ]{num}-[", "{predicate} in ]{num}-)",
+            "{predicate} :  ]{num}-]", "{predicate} :  ]{num}-[", "{predicate} :  ]{num}-)",
+            "{predicate} =  ]{num}-]", "{predicate} =  ]{num}-[", "{predicate} =  ]{num}-)",
+            # range / parenthesis
+            "{predicate} in ({num}-]", "{predicate} in ({num}-[", "{predicate} in ({num}-)",
+            "{predicate} :  ({num}-]", "{predicate} :  ({num}-[", "{predicate} :  ({num}-)",
+            "{predicate} =  ({num}-]", "{predicate} =  ({num}-[", "{predicate} =  ({num}-)",
+            # equation
+            "{predicate} > {num}", "{num} < {predicate}",
+            ]:
+            # positive
+            self._test_number(editable.format(num=1.23, predicate='iso'),
+                (ns.bse.iso, ast.filter.GreaterThan(1.23, True)))
+            # negative
+            self._test_number(editable.format(num=-1.23, predicate='iso'),
+                (ns.bse.iso, ast.filter.GreaterThan(-1.23, True)))
+            # FIXME: date
+            #self._test_number(editable.format(predicate='time', num="30.04.2012, 13:18"),
+            #    ('time', ast.Datetime(datetime(2012, 4, 30, 13, 19), datetime.max, True, False)))
+
+    def test_smaller_than(self):
+        # smaller than B (inclusive)
+        for editable in [
+            # range
+            "{predicate} in [:{num}]", "{predicate} in (:{num}]", "{predicate} in ]:{num}]",
+            "{predicate} :  [:{num}]", "{predicate} :  (:{num}]", "{predicate} :  ]:{num}]",
+            "{predicate} =  [:{num}]", "{predicate} =  (:{num}]", "{predicate} =  ]:{num}]",
+            ]:
+            # positives
+            self._test_number(editable.format(num=1.23, predicate='iso'),
+                (ns.bse.iso, ast.filter.LessThan(1.23, False)))
+            # negatives
+            self._test_number(editable.format(num=-1.23, predicate='iso'),
+                (ns.bse.iso, ast.filter.LessThan(-1.23, False)))
+
+        for editable in [
+            # range
+            "{predicate} in [-{num}]", "{predicate} in (-{num}]", "{predicate} in ]-{num}]",
+            "{predicate} :  [-{num}]", "{predicate} :  (-{num}]", "{predicate} :  ]-{num}]",
+            "{predicate} =  [-{num}]", "{predicate} =  (-{num}]", "{predicate} =  ]-{num}]",
+            # equation
+            "{predicate} <={num}", "{num} >= {predicate}",
+            ]:
+            # positives
+            self._test_number(editable.format(num=1.23, predicate='iso'),
+                (ns.bse.iso, ast.filter.LessThan(1.23, False)))
+            # negatives
+            self._test_number(editable.format(num=-1.23, predicate='iso'),
+                (ns.bse.iso, ast.filter.LessThan(-1.23, False)))
+            # FIXME: date
+            #self._test_number(editable.format(predicate='time', num="30.04.2012, 13:18"),
+            #    ('time', ast.Datetime(datetime.min, datetime(2012, 4, 30, 13, 19), False, False)))
+
+        # smaller than B (exclusive)
+        for editable in [
+            # range / bracket
+            "{predicate} in [:{num}[", "{predicate} in (:{num}[", "{predicate} in ]:{num}[",
+            "{predicate} :  [:{num}[", "{predicate} :  (:{num}[", "{predicate} :  ]:{num}[",
+            "{predicate} =  [:{num}[", "{predicate} =  (:{num}[", "{predicate} =  ]:{num}[",
+            # range / parenthesis
+            "{predicate} in [:{num})", "{predicate} in (:{num})", "{predicate} in ]:{num})",
+            "{predicate} :  [:{num})", "{predicate} :  (:{num})", "{predicate} :  ]:{num})",
+            "{predicate} =  [:{num})", "{predicate} =  (:{num})", "{predicate} =  ]:{num})",
+            ]:
+            # positives
+            self._test_number(editable.format(num=1.23, predicate='iso'),
+                (ns.bse.iso, ast.filter.LessThan(1.23, True)))
+            # negatives
+            self._test_number(editable.format(num=-1.23, predicate='iso'),
+                (ns.bse.iso, ast.filter.LessThan(-1.23, True)))
+
+        for editable in [
+            # range / bracket
+            "{predicate} in [-{num}[", "{predicate} in (-{num}[", "{predicate} in ]-{num}[",
+            "{predicate} :  [-{num}[", "{predicate} :  (-{num}[", "{predicate} :  ]-{num}[",
+            "{predicate} =  [-{num}[", "{predicate} =  (-{num}[", "{predicate} =  ]-{num}[",
+            # range / parenthesis
+            "{predicate} in [-{num})", "{predicate} in (-{num})", "{predicate} in ]-{num})",
+            "{predicate} :  [-{num})", "{predicate} :  (-{num})", "{predicate} :  ]-{num})",
+            "{predicate} =  [-{num})", "{predicate} =  (-{num})", "{predicate} =  ]-{num})",
+            # equation
+            "{predicate} <{num}", "{num} > {predicate}",
+            ]:
+            # positives
+            self._test_number(editable.format(num=1.23, predicate='iso'),
+                (ns.bse.iso, ast.filter.LessThan(1.23, True)))
+            # negatives
+            self._test_number(editable.format(num=-1.23, predicate='iso'),
+                (ns.bse.iso, ast.filter.LessThan(-1.23, True)))
+            # FIXME: date
+            #self._test_number(editable.format(predicate='time', num="30.04.2012, 13:18"),
+            #    ('time', ast.Datetime(datetime.min, datetime(2012, 4, 30, 13, 18), False, False)))
+
+    def test_between(self):
+        # between A and B (including A, including B)
+        for editable in [
+            # range
+            "{predicate} in [{numA}:{numB}]", "{predicate} :  [{numA}:{numB}]", "{predicate} =  [{numA}:{numB}]",
+            ]:
+            # positives
+            self._test_number(editable.format(predicate='iso', numA=1.23, numB=4.56),
+                (ns.bse.iso, ast.filter.Between(1.23, 4.56, False, False)))
+            # negatives
+            self._test_number(editable.format(predicate='iso', numA=-4.56, numB=-1.23),
+                (ns.bse.iso, ast.filter.Between(-4.56, -1.23, False, False)))
+            # mixed
+            self._test_number(editable.format(predicate='iso', numA=-1.23, numB=4.56),
+                (ns.bse.iso, ast.filter.Between(-1.23, 4.56, False, False)))
+
+        for editable in [
+            # range
+            "{predicate} in [{numA}-{numB}]", "{predicate} :  [{numA}-{numB}]", "{predicate} =  [{numA}-{numB}]",
+            # equation
+            "{numA} <= {predicate} <= {numB}"
+            ]:
+            # positives
+            self._test_number(editable.format(predicate='iso', numA=1.23, numB=4.56),
+                (ns.bse.iso, ast.filter.Between(1.23, 4.56, False, False)))
+            # negatives
+            self._test_number(editable.format(predicate='iso', numA=-4.56, numB=-1.23),
+                (ns.bse.iso, ast.filter.Between(-4.56, -1.23, False, False)))
+            # mixed
+            self._test_number(editable.format(predicate='iso', numA=-1.23, numB=4.56),
+                (ns.bse.iso, ast.filter.Between(-1.23, 4.56, False, False)))
+            # FIXME: date
+            #self._test_number(editable.format(predicate='time', numA="30.04.2012, 13:18", numB="13.6.2014, 18:27"),
+            #    ('time', ast.Datetime(datetime(2012, 4, 30, 13, 18), datetime(2014, 6, 13, 18, 28), True, False)))
+
+        # between A and B (including A, excluding B)
+        for editable in [
+            # range
+            "{predicate} in [{numA}:{numB})", "{predicate} in [{numA}:{numB}[",
+            "{predicate} :  [{numA}:{numB})", "{predicate} :  [{numA}:{numB}[",
+            "{predicate} =  [{numA}:{numB})", "{predicate} =  [{numA}:{numB}[",
+            ]:
+            # positives
+            self._test_number(editable.format(predicate='iso', numA=1.23, numB=4.56),
+                (ns.bse.iso, ast.filter.Between(1.23, 4.56, False, True)))
+            # negatives
+            self._test_number(editable.format(predicate='iso', numA=-4.56, numB=-1.23),
+                (ns.bse.iso, ast.filter.Between(-4.56, -1.23, False, True)))
+            # mixed
+            self._test_number(editable.format(predicate='iso', numA=-1.23, numB=4.56),
+                (ns.bse.iso, ast.filter.Between(-1.23, 4.56, False, True)))
+
+        for editable in [
+            # range
+            "{predicate} in [{numA}-{numB})", "{predicate} in [{numA}-{numB}[",
+            "{predicate} :  [{numA}-{numB})", "{predicate} :  [{numA}-{numB}[",
+            "{predicate} =  [{numA}-{numB})", "{predicate} =  [{numA}-{numB}[",
+            # equation
+            "{numA} <= {predicate} < {numB}",
+            ]:
+            # positives
+            self._test_number(editable.format(predicate='iso', numA=1.23, numB=4.56),
+                (ns.bse.iso, ast.filter.Between(1.23, 4.56, False, True)))
+            # negatives
+            self._test_number(editable.format(predicate='iso', numA=-4.56, numB=-1.23),
+                (ns.bse.iso, ast.filter.Between(-4.56, -1.23, False, True)))
+            # mixed
+            self._test_number(editable.format(predicate='iso', numA=-1.23, numB=4.56),
+                (ns.bse.iso, ast.filter.Between(-1.23, 4.56, False, True)))
+            # FIXME: date
+            #self._test_number(editable.format(predicate='time', numA="30.04.2012, 13:18", numB="13.6.2014, 18:27"),
+            #    ('time', ast.Datetime(datetime(2012, 4, 30, 13, 18), datetime(2014, 6, 13, 18, 27), True, False)))
+
+        # between A and B (excluding A, including B)
+        for editable in [
+            # range
+            "{predicate} in ({numA}:{numB}]", "{predicate} in ]{numA}:{numB}]",
+            "{predicate} :  ({numA}:{numB}]", "{predicate} :  ]{numA}:{numB}]",
+            "{predicate} =  ({numA}:{numB}]", "{predicate} =  ]{numA}:{numB}]",
+            ]:
+            # positives
+            self._test_number(editable.format(predicate='iso', numA=1.23, numB=4.56),
+                (ns.bse.iso, ast.filter.Between(1.23, 4.56, True, False)))
+            # negatives
+            self._test_number(editable.format(predicate='iso', numA=-4.56, numB=-1.23),
+                (ns.bse.iso, ast.filter.Between(-4.56, -1.23, True, False)))
+            # mixed
+            self._test_number(editable.format(predicate='iso', numA=-1.23, numB=4.56),
+                (ns.bse.iso, ast.filter.Between(-1.23, 4.56, True, False)))
+
+        for editable in [
+            # range
+            "{predicate} in ({numA}-{numB}]", "{predicate} in ]{numA}-{numB}]",
+            "{predicate} :  ({numA}-{numB}]", "{predicate} :  ]{numA}-{numB}]",
+            "{predicate} =  ({numA}-{numB}]", "{predicate} =  ]{numA}-{numB}]",
+            # equation
+            "{numA} < {predicate} <= {numB}",
+            ]:
+            # positives
+            self._test_number(editable.format(predicate='iso', numA=1.23, numB=4.56),
+                (ns.bse.iso, ast.filter.Between(1.23, 4.56, True, False)))
+            # negatives
+            self._test_number(editable.format(predicate='iso', numA=-4.56, numB=-1.23),
+                (ns.bse.iso, ast.filter.Between(-4.56, -1.23, True, False)))
+            # mixed
+            self._test_number(editable.format(predicate='iso', numA=-1.23, numB=4.56),
+                (ns.bse.iso, ast.filter.Between(-1.23, 4.56, True, False)))
+            # FIXME: date
+            #self._test_number(editable.format(predicate='time', numA="30.04.2012, 13:18", numB="13.6.2014, 18:27"),
+            #    ('time', ast.Datetime(datetime(2012, 4, 30, 13, 19), datetime(2014, 6, 13, 18, 28), True, False)))
+
+        # between A and B (excluding A, excluding B)
+        for editable in [
+            "{predicate} in ({numA}:{numB})", "{predicate} in ]{numA}:{numB}[",
+            "{predicate} :  ({numA}:{numB})", "{predicate} :  ]{numA}:{numB}[",
+            "{predicate} =  ({numA}:{numB})", "{predicate} =  ]{numA}:{numB}[",
+            ]:
+            # positives
+            self._test_number(editable.format(predicate='iso', numA=1.23, numB=4.56),
+                (ns.bse.iso, ast.filter.Between(1.23, 4.56, True, True)))
+            # negatives
+            self._test_number(editable.format(predicate='iso', numA=-4.56, numB=-1.23),
+                (ns.bse.iso, ast.filter.Between(-4.56, -1.23, True, True)))
+            # mixed
+            self._test_number(editable.format(predicate='iso', numA=-1.23, numB=4.56),
+                (ns.bse.iso, ast.filter.Between(-1.23, 4.56, True, True)))
+
+        for editable in [
+            "{predicate} in ({numA}-{numB})", "{predicate} in ]{numA}-{numB}[",
+            "{predicate} :  ({numA}-{numB})", "{predicate} :  ]{numA}-{numB}[",
+            "{predicate} =  ({numA}-{numB})", "{predicate} =  ]{numA}-{numB}[",
+            # equation
+            "{numA} < {predicate} < {numB}",
+            ]:
+            # positives
+            self._test_number(editable.format(predicate='iso', numA=1.23, numB=4.56),
+                (ns.bse.iso, ast.filter.Between(1.23, 4.56, True, True)))
+            # negatives
+            self._test_number(editable.format(predicate='iso', numA=-4.56, numB=-1.23),
+                (ns.bse.iso, ast.filter.Between(-4.56, -1.23, True, True)))
+            # mixed
+            self._test_number(editable.format(predicate='iso', numA=-1.23, numB=4.56),
+                (ns.bse.iso, ast.filter.Between(-1.23, 4.56, True, True)))
+            # FIXME: date
+            #self._test_number(editable.format(predicate='time', numA="30.04.2012, 13:18", numB="13.6.2014, 18:27"),
+            #    ('time', ast.Datetime(datetime(2012, 4, 30, 13, 19), datetime(2014, 6, 13, 18, 27), True, False)))
+
+    def test_equal(self):
+        # equal to A
+        for editable in [
+            # range
+            "{predicate} in [{num}:{num}]", "{predicate} :  [{num}:{num}]", "{predicate} =  [{num}:{num}]",
+            ]:
+            # positives
+            self._test_number(editable.format(predicate='iso', num=1.23),
+                (ns.bse.iso, ast.filter.Equals(1.23)))
+            # negatives
+            self._test_number(editable.format(predicate='iso', num=-1.23),
+                (ns.bse.iso, ast.filter.Equals(-1.23)))
+
+        for editable in [
+            # range
+            "{predicate} in [{num}-{num}]", "{predicate} :  [{num}-{num}]", "{predicate} =  [{num}-{num}]",
+            # equation
+            "{predicate} =  {num}", "{num} = {predicate}",
+            ]:
+            # positives
+            self._test_number(editable.format(predicate='iso', num=1.23),
+                (ns.bse.iso, ast.filter.Equals(1.23)))
+            # negatives
+            self._test_number(editable.format(predicate='iso', num=-1.23),
+                (ns.bse.iso, ast.filter.Equals(-1.23)))
+            # FIXME: date
+            #self._test_number(editable.format(predicate='time', num="30.04.2012, 13:18"),
+            #    ('time', ast.Datetime(datetime(2012, 4, 30, 13, 18), datetime(2012, 4, 30, 13, 19), True, False)))
+
+    def test_dates(self):
+        raise NotImplementedError() # FIXME
+        self._test_number("{predicate} < {num}".format(predicate='time', num="2012"),
+            ('time', ast.Datetime(datetime.min, datetime(2012, 1, 1), False, False)))
+        self._test_number("{predicate} < {num}".format(predicate='time', num="2012.04"),
+            ('time', ast.Datetime(datetime.min, datetime(2012, 4, 1), False, False)))
+        self._test_number("{predicate} < {num}".format(predicate='time', num="2012.04.30"),
+            ('time', ast.Datetime(datetime.min, datetime(2012, 4, 30), False, False)))
+        self._test_number("{predicate} < {num}".format(predicate='time', num="2012.04.30, 3 pm"),
+            ('time', ast.Datetime(datetime.min, datetime(2012, 4, 30, 15), False, False)))
+        self._test_number("{predicate} < {num}".format(predicate='time', num="2012.04.30, 15:34"),
+            ('time', ast.Datetime(datetime.min, datetime(2012, 4, 30, 15, 34), False, False)))
+        self._test_number("{predicate} < {num}".format(predicate='time', num="2012.04.30, 15:34:12"),
+            ('time', ast.Datetime(datetime.min, datetime(2012, 4, 30, 15, 34, 12), False, False)))
+        self._test_number("{predicate} < {num}".format(predicate='time', num="2012.04.30, 15:34:12.98"),
+            ('time', ast.Datetime(datetime.min, datetime(2012, 4, 30, 15, 34, 12, 980000), False, False)))
+
+        self._test_number("{predicate} <= {num}".format(predicate='time', num="2012"),
+            ('time', ast.Datetime(datetime.min, datetime(2013, 1, 1), False, False)))
+        self._test_number("{predicate} <= {num}".format(predicate='time', num="2012.04"),
+            ('time', ast.Datetime(datetime.min, datetime(2012, 5, 1), False, False)))
+        self._test_number("{predicate} <= {num}".format(predicate='time', num="2012.04.30"),
+            ('time', ast.Datetime(datetime.min, datetime(2012, 5, 1), False, False)))
+        self._test_number("{predicate} <= {num}".format(predicate='time', num="2012.04.30, 3 pm"),
+            ('time', ast.Datetime(datetime.min, datetime(2012, 4, 30, 16), False, False)))
+        self._test_number("{predicate} <= {num}".format(predicate='time', num="2012.04.30, 15:34"),
+            ('time', ast.Datetime(datetime.min, datetime(2012, 4, 30, 15, 35), False, False)))
+        self._test_number("{predicate} <= {num}".format(predicate='time', num="2012.04.30, 15:34:12"),
+            ('time', ast.Datetime(datetime.min, datetime(2012, 4, 30, 15, 34, 13), False, False)))
+        self._test_number("{predicate} <= {num}".format(predicate='time', num="2012.04.30, 15:34:12.98"),
+            ('time', ast.Datetime(datetime.min, datetime(2012, 4, 30, 15, 34, 12, 980001), False, False)))
+
+    def test_timerange(self):
+        raise NotImplementedError() # FIXME
+        self._test_number("{predicate} < {num}".format(predicate='time', num="15:34"),
+            ('time', ast.TimeRange(datetime.utcfromtimestamp(0.0), datetime(1970, 1, 1, 15, 34), True, False)))
+        self._test_number("{predicate} <= {num}".format(predicate='time', num="15:34"),
+            ('time', ast.TimeRange(datetime.utcfromtimestamp(0.0), datetime(1970, 1, 1, 15, 35), True, False)))
+        self._test_number("{predicate} = {num}".format(predicate='time', num="15:34"),
+            ('time', ast.TimeRange(datetime(1970, 1, 1, 15, 34), datetime(1970, 1, 1, 15, 35), True, False)))
+        self._test_number("{predicate} > {num}".format(predicate='time', num="15:34"),
+            ('time', ast.TimeRange(datetime(1970, 1, 1, 15, 35), datetime(1970, 1, 2), True, True)))
+        self._test_number("{predicate} >= {num}".format(predicate='time', num="15:34"),
+            ('time', ast.TimeRange(datetime(1970, 1, 1, 15, 34), datetime(1970, 1, 2), True, True)))
+
+        self._test_number("{numA} <= {predicate} <= {numB}".format(predicate='time', numA="12:34", numB="15:28"),
+            ('time', ast.TimeRange(datetime(1970, 1, 1, 12, 34), datetime(1970, 1, 1, 15, 29), True, False)))
+        self._test_number("{numA} <= {predicate} < {numB}".format(predicate='time', numA="12:34", numB="15:28"),
+            ('time', ast.TimeRange(datetime(1970, 1, 1, 12, 34), datetime(1970, 1, 1, 15, 28), True, False)))
+        self._test_number("{numA} < {predicate} <= {numB}".format(predicate='time', numA="12:34", numB="15:28"),
+            ('time', ast.TimeRange(datetime(1970, 1, 1, 12, 35), datetime(1970, 1, 1, 15, 29), True, False)))
+        self._test_number("{numA} < {predicate} < {numB}".format(predicate='time', numA="12:34", numB="15:28"),
+            ('time', ast.TimeRange(datetime(1970, 1, 1, 12, 35), datetime(1970, 1, 1, 15, 28), True, False)))
+
+    def test_special(self):
+        # special cases: explicit plus sign
+        self._test_number("{predicate} in [+1.23-+4.56]".format(predicate='iso'),
+            (ns.bse.iso, ast.filter.Between(1.23, 4.56, False, False)))
+        self._test_number("{predicate} in [-+4.56]".format(predicate='iso'),
+            (ns.bse.iso, ast.filter.LessThan(4.56, False)))
+
+    def test_errors(self):
+        # parse errors
+        for editable in [
+            # equal with exclusive
+            "{predicate} in ({num}:{num})", "{predicate} in ({num}-{num})",
+            "{predicate} in ({num}:{num}[", "{predicate} in ({num}-{num}[",
+            "{predicate} in ]{num}:{num})", "{predicate} in ]{num}-{num})",
+            "{predicate} in ]{num}:{num}[", "{predicate} in ]{num}-{num}[",
+            # invalid parentesis
+            "{predicate} in ){num}:{num}(",
+            # misc errors
+            # FIXME: Currently all special characters are allowed as categorical value.
+            # If this changes, don't forget to enable the tests below.
+            #"{predicate} in [{num}{num}]",
+            #"{predicate} [{num}:{num}:{num}]",
+            #"{predicate} = ({num})",
+            #"{predicate} = {num})",
+            ]:
+            self.assertRaises(errors.ParserError, self.parse,
+                editable.format(predicate='iso', num=1.23))
+
+        for editable in [
+            "{predicate} in [{numA}:{numB}]", "{predicate} :  [{numA}:{numB}]", "{predicate} =  [{numA}:{numB}]",
+            "{predicate} in ]{numA}:{numB}]", "{predicate} :  ]{numA}:{numB}]", "{predicate} =  ]{numA}:{numB}]",
+            "{predicate} in [{numA}:{numB}[", "{predicate} :  [{numA}:{numB}[", "{predicate} =  [{numA}:{numB}[",
+            "{predicate} in ({numA}:{numB}]", "{predicate} :  ({numA}:{numB}]", "{predicate} =  ({numA}:{numB}]",
+            "{predicate} in [{numA}:{numB})", "{predicate} :  [{numA}:{numB})", "{predicate} =  [{numA}:{numB})",
+            "{predicate} in ]{numA}:{numB}[", "{predicate} :  ]{numA}:{numB}[", "{predicate} =  ]{numA}:{numB}[",
+            "{predicate} in ]{numA}:{numB})", "{predicate} :  ]{numA}:{numB})", "{predicate} =  ]{numA}:{numB})",
+            "{predicate} in ({numA}:{numB}[", "{predicate} :  ({numA}:{numB}[", "{predicate} =  ({numA}:{numB}[",
+            "{predicate} in ({numA}:{numB})", "{predicate} :  ({numA}:{numB})", "{predicate} =  ({numA}:{numB})",
+            "{numA} < {predicate} < {numB}",
+            "{numA} <= {predicate} < {numB}",
+            "{numA} < {predicate} <= {numB}",
+            ]:
+            self.assertRaises(errors.ParserError, self.parse,
+                    editable.format(predicate='iso', numA=4.56, numB=1.23))
+            # FIXME:
+            #self.assertRaises(errors.ParserError, self.parse,
+            #        editable.format(predicate='time', numA="17:35", numB="10:55"))
+            #self.assertRaises(errors.ParserError, self.parse,
+            #        editable.format(predicate='time', numA="18.12.2035", numB="5.7.1999"))
+
+        raise NotImplementedError() # FIXME
+        # special cases: empty range with boundary
+        self.assertRaises(ParseException, ast_from_string.CONTINUOUS.parseString,
+            "{predicate} in [:]".format(predicate='iso'))
+        self.assertRaises(ParseException, ast_from_string.CONTINUOUS.parseString,
+            "{predicate} in (:[".format(predicate='iso'))
+        self.assertRaises(ParseException, ast_from_string.CONTINUOUS.parseString,
+            "{predicate} in ]:)".format(predicate='iso'))
+        self.assertRaises(ParseException, ast_from_string.CONTINUOUS.parseString,
+            "{predicate} in ".format(predicate='iso'))
+        # misc
+        self.assertRaises(ParseException, ast_from_string.CONTINUOUS.parseString,
+            "{predicate} in [{num}{num}]".format(predicate='iso', num=1.23))
+        self.assertRaises(ParseException, ast_from_string.CONTINUOUS.parseString,
+            "{predicate} [{num}:{num}:{num}]".format(predicate='iso', num=1.23))
+        self.assertRaises(ParseException, ast_from_string.CONTINUOUS.parseString,
+            "{predicate} = ({num})".format(predicate='iso', num=1.23))
+        self.assertRaises(ParseException, ast_from_string.CONTINUOUS.parseString,
+            "{predicate} = ({num}".format(predicate='iso', num=1.23), dict(parseAll=True))
+        self.assertRaises(ParseException, ast_from_string.CONTINUOUS.parseString,
+            "{predicate} = {num})".format(predicate='iso', num=1.23), dict(parseAll=True))
+        # range errors
+        self.assertRaises(errors.ParserError, self.parse, "100 >= iso < 200")
+        self.assertRaises(errors.ParserError, self.parse, "100 > iso < 200")
+        self.assertRaises(errors.ParserError, self.parse, "100 > iso <= 200")
+        self.assertRaises(errors.ParserError, self.parse, "100 >= iso <= 200")
+        self.assertRaises(errors.ParserError, self.parse, "100 = iso = 200")
+        # time/date mixture errors
+        self.assertRaises(errors.ParserError, self.parse, "12:45 < time < 17.5.2004")
+        self.assertRaises(errors.ParserError, self.parse, "17.5.2004 < time < 12:45")
+        # date/int mixture errors
+        self.assertRaises(errors.ParserError, self.parse, "17.5.2004 < time < 1245")
+        # 1245 is interpreted as the year
+        #self.assertRaises(errors.ParserError, self.parse, "1245 < time < 17.5.2004")
+        # time/int mixture errors
+        self.assertRaises(errors.ParserError, self.parse, "17:12 < time < 1245")
+        self.assertRaises(errors.ParserError, self.parse, "1712 < time < 12:45")
+
+        # empty query
+        self.assertRaises(ParseException, ast_from_string.CONTINUOUS.parseString, "")
+
+
+
+
+    def _test(self, query, target):
+        result = self.parse(query)
+        target = ast.filter.And(target)
+        self.assertEqual(result, target, msg="in query '{}'".format(query))
+
+    def test_parse_existence(self):
+        self._test('has mime',
+            ast.filter.Has(ns.bse.mime))
+        self._test('has no mime',
+            ast.filter.Not(ast.filter.Has(ns.bse.mime)))
+        self._test('has not mime',
+            ast.filter.Not(ast.filter.Has(ns.bse.mime)))
+
+    def test_parse_categorical(self):
+        # positive
+        self._test("iso in 100, 200, 500",
+            ast.filter.Any(ns.bse.iso, ast.filter.Includes('100', '200', '500')))
+        self._test("iso in (100, 200)",
+            ast.filter.Any(ns.bse.iso, ast.filter.Includes('100', '200')))
+        self._test("iso = (100, 200)",
+            ast.filter.Any(ns.bse.iso, ast.filter.Includes('100', '200')))
+        # FIXME!
+        #self._test("iso = 100, 200",
+        #    ast.filter.Any(ns.bse.iso, ast.filter.Includes('100', '200')))
+        self._test("iso : (100, 200)",
+            ast.filter.Any(ns.bse.iso, ast.filter.Includes('100', '200')))
+        self._test("iso : 100, 200",
+            ast.filter.Any(ns.bse.iso, ast.filter.Includes('100', '200')))
+        self._test("iso:(100,200)",
+            ast.filter.Any(ns.bse.iso, ast.filter.Includes('100', '200')))
+        self._test("iso in (100,200)",
+            ast.filter.Any(ns.bse.iso, ast.filter.Includes('100', '200')))
+        self._test("iso in 100,200",
+            ast.filter.Any(ns.bse.iso, ast.filter.Includes('100', '200')))
+        self._test("iso ~ (100,200)",
+            ast.filter.Any(ns.bse.iso, ast.filter.Includes('100', '200', approx=True)))
+        self._test("iso ~ 100,200",
+            ast.filter.Any(ns.bse.iso, ast.filter.Includes('100', '200', approx=True)))
+
+        # negative
+        self._test("iso not in 100,200",
+            ast.filter.All(ns.bse.iso, ast.filter.Excludes('100', '200')))
+        self._test("iso not in (100, 200)",
+            ast.filter.All(ns.bse.iso, ast.filter.Excludes('100', '200')))
+        self._test("iso != 100,200",
+            ast.filter.All(ns.bse.iso, ast.filter.Excludes('100', '200')))
+        self._test("iso != (100, 200)",
+            ast.filter.All(ns.bse.iso, ast.filter.Excludes('100', '200')))
+        self._test("iso !~ 100,200",
+            ast.filter.All(ns.bse.iso, ast.filter.Excludes('100', '200', approx=True)))
+        self._test("iso !~ (100, 200)",
+            ast.filter.All(ns.bse.iso, ast.filter.Excludes('100', '200', approx=True)))
+
+        # one value
+        self._test("mime : text",
+            ast.filter.Any(ns.bse.mime, ast.filter.Includes('text')))
+        self._test("mime in text",
+            ast.filter.Any(ns.bse.mime, ast.filter.Includes('text')))
+        self._test("mime = text",
+            ast.filter.Any(ns.bse.mime, ast.filter.Includes('text')))
+        self._test("mime ~ text",
+            ast.filter.Any(ns.bse.mime, ast.filter.Includes('text', approx=True)))
+        self._test("mime != text",
+            ast.filter.All(ns.bse.mime, ast.filter.Excludes('text')))
+        self._test("mime not in text",
+            ast.filter.All(ns.bse.mime, ast.filter.Excludes('text')))
+        self._test("mime !~ text",
+            ast.filter.All(ns.bse.mime, ast.filter.Excludes('text', approx=True)))
+
+        # expressions with slash and comma
+        self._test('mime : "text"',
+            ast.filter.Any(ns.bse.mime, ast.filter.Includes('text')))
+        self._test('mime : "text", "plain"',
+            ast.filter.Any(ns.bse.mime, ast.filter.Includes('text', 'plain')))
+        self._test('mime : "text, plain"',
+            ast.filter.Any(ns.bse.mime, ast.filter.Includes('text, plain')))
+        self._test('mime ~ "text/plain"',
+            ast.filter.Any(ns.bse.mime, ast.filter.Includes('text/plain', approx=True)))
+        self._test('mime = ("text/plain", "image/jpeg")',
+            ast.filter.Any(ns.bse.mime, ast.filter.Includes('text/plain', 'image/jpeg')))
+
+    def test_parse_tag(self):
+        # only tag: tag, tags, (tag), (tags)
+        self._test("foo",
+            ast.filter.Any(ns.bse.tag, ast.filter.Any(ns.bst.label, ast.filter.Equals('foo'))))
+        self._test("(foo)",
+            ast.filter.Any(ns.bse.tag, ast.filter.Any(ns.bst.label, ast.filter.Equals('foo'))))
+        self._test("foo, bar",
+            ast.filter.Any(ns.bse.tag, ast.filter.Any(ns.bst.label, ast.filter.Includes('foo', 'bar'))))
+        self._test("foo,bar",
+            ast.filter.Any(ns.bse.tag, ast.filter.Any(ns.bst.label, ast.filter.Includes('foo', 'bar'))))
+        self._test("(foo, bar,foobar)",
+            ast.filter.Any(ns.bse.tag, ast.filter.Any(ns.bst.label, ast.filter.Includes('foo', 'bar', 'foobar'))))
+
+        # op and tag: !tag, ~tag, !~tag
+        self._test("~foo",
+            ast.filter.Any(ns.bse.tag, ast.filter.Any(ns.bst.label, ast.filter.Substring('foo'))))
+        self._test("~ foo",
+            ast.filter.Any(ns.bse.tag, ast.filter.Any(ns.bst.label, ast.filter.Substring('foo'))))
+        self._test("!foo",
+            ast.filter.All(ns.bse.tag, ast.filter.Any(ns.bst.label, ast.filter.Not(ast.filter.Equals('foo')))))
+        self._test("! foo",
+            ast.filter.All(ns.bse.tag, ast.filter.Any(ns.bst.label, ast.filter.Not(ast.filter.Equals('foo')))))
+        self._test("!~foo",
+            ast.filter.All(ns.bse.tag, ast.filter.Any(ns.bst.label, ast.filter.Not(ast.filter.Substring('foo')))))
+        self._test("!~ foo",
+            ast.filter.All(ns.bse.tag, ast.filter.Any(ns.bst.label, ast.filter.Not(ast.filter.Substring('foo')))))
+
+        # op and list: ! (tags), ~tags, ...
+        self._test("~ foo, bar",
+            ast.filter.Any(ns.bse.tag, ast.filter.Any(ns.bst.label, ast.filter.Includes('foo', 'bar', approx=True))))
+        self._test("~foo, bar",
+            ast.filter.Any(ns.bse.tag, ast.filter.Any(ns.bst.label, ast.filter.Includes('foo', 'bar', approx=True))))
+        self._test("~ (foo, bar)",
+            ast.filter.Any(ns.bse.tag, ast.filter.Any(ns.bst.label, ast.filter.Includes('foo', 'bar', approx=True))))
+        self._test("! foo, bar",
+            ast.filter.All(ns.bse.tag, ast.filter.Any(ns.bst.label, ast.filter.Excludes('foo', 'bar'))))
+        self._test("! (foo, bar)",
+            ast.filter.All(ns.bse.tag, ast.filter.Any(ns.bst.label, ast.filter.Excludes('foo', 'bar'))))
+        self._test("! (foo,bar)",
+            ast.filter.All(ns.bse.tag, ast.filter.Any(ns.bst.label, ast.filter.Excludes('foo', 'bar'))))
+        self._test("!~ foo, bar",
+            ast.filter.All(ns.bse.tag, ast.filter.Any(ns.bst.label, ast.filter.Excludes('foo', 'bar', approx=True))))
+        self._test("!~ (foo, bar)",
+            ast.filter.All(ns.bse.tag, ast.filter.Any(ns.bst.label, ast.filter.Excludes('foo', 'bar', approx=True))))
+        self._test("!~(foo,bar)",
+            ast.filter.All(ns.bse.tag, ast.filter.Any(ns.bst.label, ast.filter.Excludes('foo', 'bar', approx=True))))
+
+    def test_parse_query(self):
+        # simple query
+        self.assertEqual(self.parse('foo / bar'), ast.filter.And(
+            ast.filter.Any(ns.bse.tag, ast.filter.Any(ns.bst.label, ast.filter.Equals('foo'))),
+            ast.filter.Any(ns.bse.tag, ast.filter.Any(ns.bst.label, ast.filter.Equals('bar')))))
+        self.assertEqual(self.parse('iso in ("foo", "bar") / mime = plain'), ast.filter.And(
+            ast.filter.Any(ns.bse.iso, ast.filter.Includes('foo', 'bar')),
+            ast.filter.Any(ns.bse.mime, ast.filter.Equals('plain'))))
+        self.assertEqual(self.parse('iso in ("foo", "bar") / mime = plain'), ast.filter.And(
+            ast.filter.Any(ns.bse.iso, ast.filter.Includes('foo', 'bar')),
+            ast.filter.Any(ns.bse.mime, ast.filter.Equals('plain'))))
+        self.assertEqual(self.parse('iso = 1.23 / rank < 5'), ast.filter.And(
+            ast.filter.Any(ns.bse.iso, ast.filter.Equals(1.23)),
+            ast.filter.Any(ns.bse.rank, ast.filter.LessThan(5, True))))
+        # FIXME
+        #self.assertEqual(self.parse('time >= 12:50 / time < 13:50'), ast.filter.And(
+        #    ast.filter.Any(ns.bse.time, ast.TimeRange(lo=datetime(1970, 1, 1, 12, 50), lo_inc=True, hi_inc=True)),
+        #    ast.filter.Any(ns.bse.time, ast.TimeRange(hi=datetime(1970, 1, 1, 13, 50), lo_inc=True, hi_inc=False))))
+        #self.assertEqual(self.parse('time >= 17.5.2001 / time < 18.4.2002'), ast.filter.And(
+        #    ast.filter.Any(ns.bse.time, ast.Datetime(lo=datetime(2001, 5, 17, 0, 0), lo_inc=True)),
+        #    ast.filter.Any(ns.bse.time, ast.Datetime(hi=datetime(2002, 4, 18, 0, 0)))))
+        #  mixing expressions
+        #self.assertEqual(self.parse('foo / iso in "bar" / mime ~ "text/plain" / iso < 100 / time >= 17.5.2001 / time < 13:50'), ast.filter.And(
+        #    ast.filter.Any(ns.bse.tag, ast.filter.Equals('foo')),
+        #    ast.filter.Any(ns.bse.iso, ast.filter.Equals('bar')),
+        #    ast.filter.Any(ns.bse.mime, ast.filter.Substring('text/plain')),
+        #    ast.filter.Any(ns.bse.iso, ast.filter.LessThan(100)),
+        #    ast.filter.Any(ns.bse.time, ast.Datetime(lo=datetime(2001, 5, 17, 0, 0), lo_inc=True)),
+        #    ast.filter.Any(ns.bse.time, ast.TimeRange(hi=datetime(1970, 1, 1, 13, 50), lo_inc=True))))
+
+        # leading/trailing slashes
+        self.assertRaises(errors.ParserError, self.parse, '/ foobar')
+        self.assertRaises(errors.ParserError, self.parse, 'foobar /')
+        self.assertRaises(errors.ParserError, self.parse, 'foobar / ')
+        self.assertRaises(errors.ParserError, self.parse, 'foo // bar')
+        self.assertRaises(errors.ParserError, self.parse, 'foo / / bar')
+
+    def test_quoting(self):
+        self._test("tag in ('(foo, bar)', foobar)",
+            ast.filter.Any(ns.bse.tag, ast.filter.Includes('(foo, bar)', 'foobar')))
+        self._test('tag in ("(foo, bar)", foobar)',
+            ast.filter.Any(ns.bse.tag, ast.filter.Includes('(foo, bar)', 'foobar')))
+        self._test('tag in ("(foo, \\"bar\\")", foobar)',
+            ast.filter.Any(ns.bse.tag, ast.filter.Includes('(foo, "bar")', 'foobar')))
+        self._test('tag in ("(foo, bar)", "foobar")',
+            ast.filter.Any(ns.bse.tag, ast.filter.Includes('(foo, bar)', 'foobar')))
+        self._test('tag in ("(foo, bar)", \'foobar\')',
+            ast.filter.Any(ns.bse.tag, ast.filter.Includes('(foo, bar)', 'foobar')))
+
+        # error cases
+        self.assertRaises(errors.ParserError, self.parse, ('tag in ("(foo, bar, foobar)'))
+        self.assertRaises(errors.ParserError, self.parse, ("tag in ('(foo, bar, foobar)"))
+
+
+## main ##
+
+if __name__ == '__main__':
+    unittest.main()
+
+## EOF ##
diff --git a/test/parsing/filter/test_to_string.py b/test/parsing/filter/test_to_string.py
new file mode 100644
index 0000000..6df7360
--- /dev/null
+++ b/test/parsing/filter/test_to_string.py
@@ -0,0 +1,111 @@
+"""
+
+Part of the tagit test suite.
+A copy of the license is provided with the project.
+Author: Matthias Baumgartner, 2022
+"""
+# standard imports
+import contextlib
+import io
+import unittest
+
+# tagit imports
+with contextlib.redirect_stderr(io.StringIO()):
+    from tagit.parsing.filter.from_string import FromString
+    from tagit.utils import bsfs, errors, ns
+    from tagit.utils.bsfs import ast
+
+    # objects to test
+    from tagit.parsing.filter.to_string import ToString
+
+
+## code ##
+
+class TestFromString(unittest.TestCase):
+    def setUp(self):
+        self.schema = bsfs.schema.from_string('''
+            # common external prefixes
+            prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#>
+            prefix xsd: <http://www.w3.org/2001/XMLSchema#>
+
+            # common bsfs prefixes
+            prefix bsfs: <http://bsfs.ai/schema/>
+            prefix bse: <http://bsfs.ai/schema/Entity#>
+
+            # nodes
+            bsfs:Entity rdfs:subClassOf bsfs:Node .
+            bsfs:Tag rdfs:subClassOf bsfs:Node .
+
+            # literals
+            bsfs:Time rdfs:subClassOf bsfs:Literal .
+            xsd:string rdfs:subClassOf bsfs:Literal .
+            bsfs:Number rdfs:subClassOf bsfs:Literal .
+            xsd:integer rdfs:subClassOf bsfs:Number .
+
+            # predicates
+            bse:mime rdfs:subClassOf bsfs:Predicate ;
+                rdfs:domain bsfs:Entity ;
+                rdfs:range xsd:string ;
+                bsfs:unique "true"^^xsd:boolean .
+
+            bse:iso rdfs:subClassOf bsfs:Predicate ;
+                rdfs:domain bsfs:Entity ;
+                rdfs:range xsd:integer ;
+                bsfs:unique "true"^^xsd:boolean .
+
+            bse:time rdfs:subClassOf bsfs:Predicate ;
+                rdfs:domain bsfs:Entity ;
+                rdfs:range bsfs:Time;
+                bsfs:unique "true"^^xsd:boolean .
+
+            bse:tag rdfs:subClassOf bsfs:Predicate ;
+                rdfs:domain bsfs:Entity ;
+                rdfs:range bsfs:Tag ;
+                bsfs:unique "false"^^xsd:boolean .
+
+            bse:rank rdfs:subClassOf bsfs:Predicate ;
+                rdfs:domain bsfs:Entity ;
+                rdfs:range xsd:integer ;
+                bsfs:unique "false"^^xsd:boolean .
+
+            ''')
+        self.to_string = ToString(self.schema)
+        self.from_string = FromString(self.schema)
+
+    def test_has(self):
+        self.assertEqual('has iso', self.to_string(self.from_string('has iso')))
+        #from debug import debug
+        #debug(locals(), globals())
+
+    def test_categorical(self):
+        self.assertEqual('iso = 100.0', self.to_string(self.from_string('iso = 100')))
+
+    def test_tag(self):
+        self.assertEqual('foobar', self.to_string(self.from_string('foobar')))
+        self.assertEqual('not foobar', self.to_string(self.from_string('not foobar')))
+        self.assertEqual('~ foobar', self.to_string(self.from_string('~ foobar')))
+        self.assertEqual('!~ foobar', self.to_string(self.from_string('!~ foobar')))
+        self.assertIn(self.to_string(self.from_string('foo, bar')), ('"foo", "bar"', '"bar", "foo"'))
+
+    def test_range(self):
+        self.assertEqual('iso < 100.0', self.to_string(self.from_string('iso < 100')))
+        self.assertEqual('iso <= 100.0', self.to_string(self.from_string('iso <= 100')))
+        self.assertEqual('iso > 100.0', self.to_string(self.from_string('iso > 100')))
+        self.assertEqual('iso >= 100.0', self.to_string(self.from_string('iso >= 100')))
+        self.assertEqual('iso = [10.0 - 100.0]', self.to_string(self.from_string('iso = [10-100]')))
+        raise NotImplementedError() # FIXME: test with dates!
+
+    def test_entity(self):
+        self.assertEqual('id in "http://example.com/entity#1234"',
+            self.to_string(self.from_string('id in "http://example.com/entity#1234"')))
+
+    def test_group(self):
+        self.assertEqual('group in "http://example.com/group#1234"',
+            self.to_string(self.from_string('group in "http://example.com/group#1234"')))
+
+## main ##
+
+if __name__ == '__main__':
+    unittest.main()
+
+## EOF ##
diff --git a/test/parsing/test_datefmt.py b/test/parsing/test_datefmt.py
new file mode 100644
index 0000000..3f80c15
--- /dev/null
+++ b/test/parsing/test_datefmt.py
@@ -0,0 +1,378 @@
+"""Test datetime parser.
+
+Part of the tagit test suite.
+A copy of the license is provided with the project.
+Author: Matthias Baumgartner, 2022
+"""
+# standard imports
+import unittest
+from datetime import date as ddate
+from datetime import time as dtime
+from datetime import datetime
+
+# external imports
+from pyparsing import ParseException
+
+# tagit imports
+from tagit.utils import errors, Struct
+
+# objects to test
+#from tagit.parsing.datefmt import DatefmtError, DateParserError, TimeParserError, DateFormatError, guess_date, guess_time, guess_datetime, increment, PRIORITIES_US, DF
+from tagit.parsing.datefmt import guess_date, guess_time, PRIORITIES_US, DateParserError, DateFormatError, TimeParserError, guess_datetime, DF, parse_datetime, increment, DateTimeParser
+
+
+## code ##
+
+class TestGuessDatetime(unittest.TestCase):
+    def test_parse_datetime(self):
+        parse_datetime = DateTimeParser()
+        cyear = ddate.today().year
+        cmon = ddate.today().month
+        cday = ddate.today().day
+
+        # date only: vary number formats
+        self.assertEqual(parse_datetime('3.4.12'), datetime(2012, 4, 3))
+        self.assertEqual(parse_datetime('15.8.19'), datetime(2019, 8, 15))
+        self.assertEqual(parse_datetime('8.11.98'), datetime(1998, 11, 8))
+        self.assertEqual(parse_datetime('10.11.12'), datetime(2012, 11, 10))
+        self.assertEqual(parse_datetime('3.4.1912'), datetime(1912, 4, 3))
+        self.assertEqual(parse_datetime('15.8.1919'), datetime(1919, 8, 15))
+        self.assertEqual(parse_datetime('8.11.1998'), datetime(1998, 11, 8))
+        self.assertEqual(parse_datetime('10.11.1912'), datetime(1912, 11, 10))
+        self.assertEqual(parse_datetime('8.1998'), datetime(1998, 8, 1))
+        self.assertEqual(parse_datetime('10.1912'), datetime(1912, 10, 1))
+        self.assertRaises(errors.ParserError, parse_datetime, 'ab.cd.ef')
+        self.assertRaises(errors.ParserError, parse_datetime, '123.123.2000')
+        self.assertRaises(errors.ParserError, parse_datetime, '.123.2000')
+        self.assertRaises(errors.ParserError, parse_datetime, '123..2000')
+        self.assertRaises(errors.ParserError, parse_datetime, '12.12.20001')
+        # date only: vary order (three-part)
+        self.assertEqual(parse_datetime('15.98.8'), datetime(1998, 8, 15))
+        self.assertEqual(parse_datetime('8.98.15'), datetime(1998, 8, 15))
+        self.assertEqual(parse_datetime('8.15.98'), datetime(1998, 8, 15))
+        self.assertEqual(parse_datetime('15.8.98'), datetime(1998, 8, 15))
+        self.assertEqual(parse_datetime('98.8.15'), datetime(1998, 8, 15))
+        self.assertEqual(parse_datetime('98.15.8'), datetime(1998, 8, 15))
+        # date only: vary order (two-part)
+        self.assertEqual(parse_datetime('15.98'), datetime(1998, 1, 15))
+        self.assertEqual(parse_datetime('08.98'), datetime(1998, 8, 1))
+        self.assertEqual(parse_datetime('08.15'), datetime(2015, 8, 1))
+        self.assertEqual(parse_datetime('15.08'), datetime(cyear, 8, 15))
+        self.assertEqual(parse_datetime('98.08'), datetime(1998, 8, 1))
+        self.assertEqual(parse_datetime('98.15'), datetime(1998, 1, 15))
+        # date only: one part
+        self.assertEqual(parse_datetime('1998'), datetime(1998, 1, 1))
+        # date only: literal month
+        self.assertEqual(parse_datetime('98.April'), datetime(1998, 4, 1))
+        # FIXME: Allow more patterns
+        #self.assertEqual(parse_datetime('98, April'), datetime(1998, 4, 1))
+        #self.assertEqual(parse_datetime('April, 15'), datetime(2015, 4, 1))
+        # date only: day with suffix
+        #self.assertEqual(parse_datetime('10th 2000'), datetime(2000, 1, 10))
+        #self.assertEqual(parse_datetime('2000, 10th'), datetime(2000, 1, 10))
+        #self.assertEqual(parse_datetime('April, 10th'), datetime(cyear, 4, 10))
+        #self.assertEqual(parse_datetime('April 10th'), datetime(cyear, 4, 10))
+        #self.assertEqual(parse_datetime('10th April'), datetime(cyear, 4, 10))
+        # date only: of notation
+        #self.assertEqual(parse_datetime('10th of April, 2000'), datetime(2000, 4, 10))
+        #self.assertEqual(parse_datetime('10th of April'), datetime(cyear, 4, 10))
+        #self.assertEqual(parse_datetime('10 of 04'), datetime(cyear, 4, 10))
+        # invalid ranges
+        self.assertRaises(DateParserError, parse_datetime, '10.93.2013')
+        self.assertRaises(DateParserError, parse_datetime, '48.10.2013')
+        self.assertRaises(DateParserError, parse_datetime, '48.93.2013')
+        self.assertRaises(DateParserError, parse_datetime, "52.74")
+
+        # time only: am/pm
+        self.assertEqual(parse_datetime("10 am"), datetime(1970, 1, 1, 10))
+        self.assertEqual(parse_datetime("10 pm"), datetime(1970, 1, 1, 22))
+        self.assertEqual(parse_datetime("10:02 pm"), datetime(1970, 1, 1, 22, 2))
+        self.assertEqual(parse_datetime("14 am"), datetime(1970, 1, 1, 14))
+        self.assertRaises(TimeParserError, parse_datetime, "14 pm")
+        # time only: 24hrs format
+        self.assertEqual(parse_datetime("1:2"), datetime(1970, 1, 1, 1, 2))
+        self.assertEqual(parse_datetime("12:34"), datetime(1970, 1, 1, 12, 34))
+        self.assertEqual(parse_datetime("12:34:54"), datetime(1970, 1, 1, 12, 34, 54))
+        self.assertEqual(parse_datetime("12:34:54.123"), datetime(1970, 1, 1, 12, 34, 54, 123000))
+        self.assertEqual(parse_datetime("1:2:3.4"), datetime(1970, 1, 1, 1, 2, 3, 400000))
+        self.assertRaises(errors.ParserError, parse_datetime, '84:12')
+        self.assertRaises(errors.ParserError, parse_datetime, '12:75')
+        self.assertRaises(errors.ParserError, parse_datetime, '12:13:84')
+        # time only: HH:MM
+        self.assertEqual(parse_datetime("54:34"), datetime(1970, 1, 1, 0, 54, 34))
+        # time only: invalid format
+        self.assertRaises(errors.ParserError, parse_datetime, '12:')
+
+        # date and time
+        self.assertEqual(parse_datetime("12:34 18.05.2012"), datetime(2012, 5, 18, 12, 34))
+        self.assertEqual(parse_datetime("12:34, 18.05.2012"), datetime(2012, 5, 18, 12, 34))
+        self.assertEqual(parse_datetime("18.05.2012 12:34"), datetime(2012, 5, 18, 12, 34))
+        self.assertEqual(parse_datetime("18.05.2012, 12:34"), datetime(2012, 5, 18, 12, 34))
+        self.assertEqual(parse_datetime("2012, 12:34"), datetime(2012, 1, 1, 12, 34))
+        self.assertEqual(parse_datetime("2012, 12am"), datetime(2012, 1, 1, 12))
+        self.assertRaises(errors.ParserError, parse_datetime, '12.34 18:05:2012')
+
+        # invalid args
+        self.assertRaises(errors.ParserError, parse_datetime, '')
+
+    def test_guess_date(self):
+        this_year = ddate.today().year
+        # some unambiguous formats
+        self.assertEqual(guess_date('18 . 05 . 2012'.split()), (ddate(2012, 5, 18), 'DMY'))
+        self.assertEqual(guess_date('18 5 2012'.split()), (ddate(2012, 5, 18), 'DMY'))
+        self.assertEqual(guess_date('2012 , 05 , 18'.split()), (ddate(2012, 5, 18), 'YMD'))
+        self.assertEqual(guess_date('2012 5 18'.split()), (ddate(2012, 5, 18), 'YMD'))
+        self.assertEqual(guess_date('18 5 2004'.split()), (ddate(2004, 5, 18), 'DMY'))
+        self.assertEqual(guess_date('2004 5 18'.split()), (ddate(2004, 5, 18), 'YMD'))
+        self.assertEqual(guess_date('10 11 12'.split()), (ddate(2012, 11, 10), 'DMY'))
+        self.assertEqual(guess_date('10 11 12'.split(), priorities=PRIORITIES_US),
+            (ddate(2012, 10, 11), 'MDY'))
+        self.assertEqual(guess_date('2012 04 05'.split()), (ddate(2012, 4, 5), 'YMD'))
+        self.assertEqual(guess_date('2012 4 5'.split()), (ddate(2012, 4, 5), 'YMD'))
+        self.assertEqual(guess_date('2012 May , 4th'.split()), (ddate(2012, 5, 4), 'YMD'))
+        self.assertEqual(guess_date('4 5 2012'.split()), (ddate(2012, 5, 4), 'DMY'))
+        self.assertEqual(guess_date('4th of May 2012'.split()), (ddate(2012, 5, 4), 'DMY'))
+        self.assertEqual(guess_date('2012 4th of May'.split()), (ddate(2012, 5, 4), 'YDM'))
+
+        # three-part format
+        # unambiguous MD ranges, full year
+        self.assertEqual(guess_date('28 11 2018'.split()), (ddate(2018, 11, 28), 'DMY'))
+        self.assertEqual(guess_date('28 2018 11'.split()), (ddate(2018, 11, 28), 'DYM'))
+        self.assertEqual(guess_date('11 28 2018'.split()), (ddate(2018, 11, 28), 'MDY'))
+        self.assertEqual(guess_date('11 2018 28'.split()), (ddate(2018, 11, 28), 'MYD'))
+        self.assertEqual(guess_date('2018 11 28'.split()), (ddate(2018, 11, 28), 'YMD'))
+        self.assertEqual(guess_date('2018 28 11'.split()), (ddate(2018, 11, 28), 'YDM'))
+        # unambiguous MDY ranges
+        self.assertEqual(guess_date('28 11 98'.split()), (ddate(1998, 11, 28), 'DMY'))
+        self.assertEqual(guess_date('28 98 11'.split()), (ddate(1998, 11, 28), 'DYM'))
+        self.assertEqual(guess_date('11 28 98'.split()), (ddate(1998, 11, 28), 'MDY'))
+        self.assertEqual(guess_date('11 98 28'.split()), (ddate(1998, 11, 28), 'MYD'))
+        self.assertEqual(guess_date('98 11 28'.split()), (ddate(1998, 11, 28), 'YMD'))
+        self.assertEqual(guess_date('98 28 11'.split()), (ddate(1998, 11, 28), 'YDM'))
+        # explicit YMD
+        self.assertEqual(guess_date('10th of April 2018'.split()), (ddate(2018, 4, 10), 'DMY'))
+        self.assertEqual(guess_date('April 10th 98'.split()), (ddate(1998, 4, 10), 'MDY'))
+        self.assertEqual(guess_date('98 April 10th'.split()), (ddate(1998, 4, 10), 'YMD'))
+        self.assertEqual(guess_date('2018 10th of April'.split()), (ddate(2018, 4, 10), 'YDM'))
+        self.assertEqual(guess_date('2018 10 of 04'.split()), (ddate(2018, 4, 10), 'YDM'))
+        # explicit MY
+        self.assertEqual(guess_date('2018 10 April'.split()), (ddate(2018, 4, 10), 'YDM'))
+        self.assertEqual(guess_date('2018 April 10'.split()), (ddate(2018, 4, 10), 'YMD'))
+        self.assertEqual(guess_date('April 10 2018'.split()), (ddate(2018, 4, 10), 'MDY'))
+        # explicit DY
+        self.assertEqual(guess_date('10th 04 98'.split()), (ddate(1998, 4, 10), 'DMY'))
+        self.assertEqual(guess_date('2018 10th 04'.split()), (ddate(2018, 4, 10), 'YDM'))
+        self.assertEqual(guess_date('2018 04 10th'.split()), (ddate(2018, 4, 10), 'YMD'))
+        # explicit DM
+        self.assertEqual(guess_date('10th April 10'.split()), (ddate(2010, 4, 10), 'DMY'))
+        self.assertEqual(guess_date('10 10th April'.split()), (ddate(2010, 4, 10), 'YDM'))
+        self.assertEqual(guess_date('10 April 10th'.split()), (ddate(2010, 4, 10), 'YMD'))
+        # ambiguous formats: explicit Y
+        self.assertEqual(guess_date('2018 04 08'.split()), (ddate(2018, 4, 8), 'YMD'))
+        self.assertEqual(guess_date('04 2018 08'.split()), (ddate(2018, 8, 4), 'DYM'))
+        self.assertEqual(guess_date('08 04 2018'.split()), (ddate(2018, 4, 8), 'DMY'))
+        self.assertEqual(guess_date('4 8 11'.split()), (ddate(2011, 8, 4), 'DMY'))
+        # ambiguous formats: explicit D
+        self.assertEqual(guess_date('10 4th 11'.split()), (ddate(2011, 10, 4), 'MDY'))
+        self.assertEqual(guess_date('11 10 4th'.split()), (ddate(2011, 10, 4), 'YMD'))
+        self.assertEqual(guess_date('4th 11 10'.split()), (ddate(2010, 11, 4), 'DMY'))
+        self.assertEqual(guess_date('4th 10 11'.split()), (ddate(2011, 10, 4), 'DMY'))
+        # ambiguous formats: explicit M
+        self.assertEqual(guess_date('April 21 08'.split()), (ddate(2008, 4, 21), 'MDY'))
+        self.assertEqual(guess_date('08 April 21'.split()), (ddate(2021, 4, 8), 'DMY'))
+        self.assertEqual(guess_date('21 08 April'.split()), (ddate(2021, 4, 8), 'YDM'))
+        # fully ambiguous
+        self.assertEqual(guess_date('04 08 10'.split()), (ddate(2010, 8, 4), 'DMY'))
+        # errors
+        self.assertRaises(DateParserError, guess_date, '2012 98 10'.split())
+        self.assertRaises(DateParserError, guess_date, 'April 98 April'.split())
+        self.assertRaises(DateParserError, guess_date, '10th 98 29'.split())
+
+        # two-part format
+        # unambiguous DY ranges
+        self.assertEqual(guess_date('28 98'.split()), (ddate(1998, 1, 28), 'DY'))
+        self.assertEqual(guess_date('98 28'.split()), (ddate(1998, 1, 28), 'YD'))
+        self.assertEqual(guess_date('2010 28'.split()), (ddate(2010, 1, 28), 'YD'))
+        self.assertEqual(guess_date('28 2010'.split()), (ddate(2010, 1, 28), 'DY'))
+        # explicit DY
+        self.assertEqual(guess_date('28th 2010'.split()), (ddate(2010, 1, 28), 'DY'))
+        self.assertEqual(guess_date('2010 28th'.split()), (ddate(2010, 1, 28), 'YD'))
+        # explicit MY
+        self.assertEqual(guess_date('2010 April'.split()), (ddate(2010, 4, 1), 'YM'))
+        self.assertEqual(guess_date('April 2010'.split()), (ddate(2010, 4, 1), 'MY'))
+        # explicit DM
+        self.assertEqual(guess_date('April 10th'.split()), (ddate(this_year, 4, 10), 'MD'))
+        self.assertEqual(guess_date('10th April'.split()), (ddate(this_year, 4, 10), 'DM'))
+        self.assertEqual(guess_date('10th of April'.split()), (ddate(this_year, 4, 10), 'DM'))
+        self.assertEqual(guess_date('10 of 04'.split()), (ddate(this_year, 4, 10), 'DM'))
+        self.assertEqual(guess_date('10th 4'.split()), (ddate(this_year, 4, 10), 'DM'))
+        # explicit Y
+        self.assertEqual(guess_date('2010 04'.split()), (ddate(2010, 4, 1), 'YM'))
+        self.assertEqual(guess_date('04 2010'.split()), (ddate(2010, 4, 1), 'MY'))
+        self.assertEqual(guess_date('04 98'.split()), (ddate(1998, 4, 1), 'MY'))
+        self.assertEqual(guess_date('98 04'.split()), (ddate(1998, 4, 1), 'YM'))
+        # explicit M
+        self.assertEqual(guess_date('April 10'.split()), (ddate(2010, 4, 1), 'MY'))
+        self.assertEqual(guess_date('10 April'.split()), (ddate(this_year, 4, 10), 'DM'))
+        # explicit D
+        self.assertEqual(guess_date('10th 08'.split()), (ddate(this_year, 8, 10), 'DM'))
+        self.assertEqual(guess_date('08 10th'.split()), (ddate(this_year, 8, 10), 'MD'))
+        # some hints
+        self.assertEqual(guess_date('18 5'.split()), (ddate(this_year, 5, 18), 'DM'))
+        self.assertEqual(guess_date('4 8'.split()), (ddate(this_year, 8, 4), 'DM'))
+        # fully ambiguous
+        self.assertEqual(guess_date('08 10'.split()), (ddate(this_year, 10, 8), 'DM'))
+
+        # one-part format
+        # full year
+        self.assertEqual(guess_date('2018'.split()), (ddate(2018, 1, 1), 'Y'))
+        # short year
+        self.assertEqual(guess_date('18'.split()), (ddate(2018, 1, 1), 'Y'))
+        self.assertEqual(guess_date('98'.split()), (ddate(1998, 1, 1), 'Y'))
+        self.assertEqual(guess_date('08'.split()), (ddate(2008, 1, 1), 'Y'))
+        # non-year token
+        self.assertRaises(DateParserError, guess_date, ('1', ))
+        self.assertRaises(DateParserError, guess_date, ('April', ))
+        self.assertRaises(DateParserError, guess_date, ('10th', ))
+
+        # other errors
+        self.assertRaises(DateParserError, guess_date, '')
+        self.assertRaises(DateParserError, guess_date, 'fuuu'.split())
+        self.assertRaises(DateParserError, guess_date, '1 fuuu'.split())
+        self.assertRaises(DateParserError, guess_date, '1 fuuu bar 2'.split())
+        self.assertRaises(DateParserError, guess_date, '1 2 3 4'.split())
+
+    def test_guess_time(self):
+        # single token
+        self.assertEqual(guess_time(['9']), (dtime(hour=9), 'h'))
+        # am/pm notation
+        self.assertEqual(guess_time("9 am".split()), (dtime(hour=9), 'h'))
+        self.assertEqual(guess_time("10 am".split()), (dtime(hour=10), 'h'))
+        self.assertEqual(guess_time("09 am".split()), (dtime(hour=9), 'h'))
+        self.assertEqual(guess_time("9 pm".split()), (dtime(hour=21), 'h'))
+        self.assertEqual(guess_time("10 pm".split()), (dtime(hour=22), 'h'))
+        self.assertEqual(guess_time("09 pm".split()), (dtime(hour=21), 'h'))
+        self.assertEqual(guess_time("10 02 am".split()), (dtime(hour=10, minute=2), 'hm'))
+        self.assertEqual(guess_time("10 02 pm".split()), (dtime(hour=22, minute=2), 'hm'))
+        self.assertEqual(guess_time("14 am".split()), (dtime(hour=14), 'h'))
+        self.assertRaises(TimeParserError, guess_time, "14 pm".split())
+
+        # 24-hrs notation
+        self.assertEqual(guess_time("12 34".split()), (dtime(hour=12, minute=34), 'hm'))
+        self.assertEqual(guess_time("15 32".split()), (dtime(hour=15, minute=32), 'hm'))
+        self.assertEqual(guess_time("12 04".split()), (dtime(hour=12, minute=4), 'hm'))
+        self.assertEqual(guess_time("12 4".split()), (dtime(hour=12, minute=4), 'hm'))
+        # range
+        self.assertEqual(guess_time("12 58".split()), (dtime(hour=12, minute=58), 'hm'))
+        self.assertEqual(guess_time("31 04".split()), (dtime(minute=31, second=4), 'ms'))
+        self.assertEqual(guess_time("31 58".split()), (dtime(minute=31, second=58), 'ms'))
+        # three terms
+        self.assertEqual(guess_time("12 34 54".split()),
+            (dtime(hour=12, minute=34, second=54), 'hms'))
+        # four terms
+        self.assertEqual(guess_time("12 34 54 984".split()),
+            (dtime(hour=12, minute=34, second=54, microsecond=984000), 'hmsn'))
+        # trailing zeros
+        self.assertEqual(guess_time("12 34 54 98400".split()),
+            (dtime(hour=12, minute=34, second=54, microsecond=984000), 'hmsn'))
+        # leading zeros
+        self.assertEqual(guess_time("12 34 54 098400".split()),
+            (dtime(hour=12, minute=34, second=54, microsecond=98400), 'hmsn'))
+
+        # invalid formats
+        self.assertRaises(TimeParserError, guess_time, [])
+        self.assertRaises(TimeParserError, guess_time, ['0', '1', '2', '3', '4'])
+        self.assertRaises(TimeParserError, guess_time, "83 02".split())
+        self.assertRaises(TimeParserError, guess_time, "52 74".split())
+
+    def test_guess_datetime(self):
+        self.assertEqual(guess_datetime(
+            Struct({'date': '18 05 2012'.split(), 'time': '12 34'.split()})),
+            (datetime(2012, 5, 18, 12, 34), 'DMYhm'))
+        self.assertEqual(guess_datetime(Struct({'date': '18 05 2012'.split()})),
+            (datetime(2012, 5, 18), 'DMY'))
+        self.assertEqual(guess_datetime(Struct({'time': '12 34'.split()})),
+            (datetime(1970, 1, 1, 12, 34), 'hm'))
+        self.assertRaises(DateFormatError, guess_datetime, Struct({}))
+
+    def test_DF(self):
+        # msb
+        self.assertRaises(DateFormatError, DF('').msb)
+        self.assertRaises(DateFormatError, DF('abc').msb)
+        self.assertRaises(DateFormatError, DF('ydHSN').msb)
+        self.assertEqual('Y', DF('Yab').msb())
+        self.assertEqual('Y', DF('YDM').msb())
+        self.assertEqual('Y', DF('MdY').msb())
+        self.assertEqual('D', DF('mDn').msb())
+        self.assertEqual('m', DF('mdn').msb())
+        self.assertEqual('n', DF('nab').msb())
+        # lsb
+        self.assertRaises(DateFormatError, DF('').lsb)
+        self.assertRaises(DateFormatError, DF('abc').lsb)
+        self.assertEqual('Y', DF('Yab').lsb())
+        self.assertEqual('D', DF('YDM').lsb())
+        self.assertEqual('M', DF('MdY').lsb())
+        self.assertEqual('n', DF('mDn').lsb())
+        self.assertEqual('n', DF('nab').lsb())
+        # is_time
+        self.assertTrue(DF('mshn').is_time())
+        self.assertTrue(DF('mh').is_time())
+        self.assertTrue(DF('h').is_time())
+        self.assertTrue(DF('m').is_time())
+        self.assertTrue(DF('s').is_time())
+        self.assertTrue(DF('n').is_time())
+        self.assertFalse(DF('').is_time())
+        self.assertFalse(DF('abc').is_time())
+        self.assertFalse(DF('Msnh').is_time())
+        self.assertFalse(DF('Ymsnh').is_time())
+        self.assertFalse(DF('Dmsnh').is_time())
+        self.assertFalse(DF('YDM').is_time())
+        # is_date
+        self.assertTrue(DF('YDM').is_date())
+        self.assertTrue(DF('YM').is_date())
+        self.assertTrue(DF('DM').is_date())
+        self.assertTrue(DF('DY').is_date())
+        self.assertTrue(DF('Y').is_date())
+        self.assertTrue(DF('D').is_date())
+        self.assertTrue(DF('M').is_date())
+        self.assertFalse(DF('').is_date())
+        self.assertFalse(DF('abc').is_date())
+        self.assertFalse(DF('YDMn').is_date())
+        self.assertFalse(DF('YDm').is_date())
+        self.assertFalse(DF('YDh').is_date())
+        self.assertFalse(DF('hmsn').is_date())
+        # valid
+        self.assertTrue(DF('Y').valid())
+        self.assertTrue(DF('YDMhsmn').valid())
+        self.assertTrue(DF('Yabc').valid())
+        self.assertFalse(DF('').valid())
+        self.assertFalse(DF('abc').valid())
+        self.assertFalse(DF('ydHSN').valid())
+
+
+    def test_increment(self):
+        self.assertRaises(DateFormatError, increment, None, '')
+        self.assertEqual(increment(datetime(1970, 1, 1, 0, 0, 0, 10), DF('n')),
+            datetime(1970, 1, 1, 0, 0, 0, 11))
+        self.assertEqual(increment(datetime(1970, 1, 1, 0, 0, 1), DF('s')),
+            datetime(1970, 1, 1, 0, 0, 2))
+        self.assertEqual(increment(datetime(1970, 1, 1, 0, 1), DF('m')),
+            datetime(1970, 1, 1, 0, 2))
+        self.assertEqual(increment(datetime(1970, 1, 1, 1), DF('h')),
+            datetime(1970, 1, 1, 2))
+        self.assertEqual(increment(datetime(1970, 1, 1, 1), DF('h')),
+            datetime(1970, 1, 1, 2))
+        self.assertEqual(increment(datetime(1970, 2, 3, 4, 5, 6), DF('D')),
+            datetime(1970, 2, 4))
+        self.assertEqual(increment(datetime(1970, 2, 3, 4, 5, 6), DF('M')),
+            datetime(1970, 3, 1))
+        self.assertEqual(increment(datetime(1970, 2, 3, 4, 5, 6), DF('Y')),
+            datetime(1971, 1, 1))
+        self.assertRaises(DateFormatError, increment, datetime(1970, 2, 3, 4, 5, 6), DF('abc'))
+
+## main ##
+
+if __name__ == '__main__':
+    unittest.main()
+
+## EOF ##
diff --git a/test/parsing/test_sort.py b/test/parsing/test_sort.py
new file mode 100644
index 0000000..40c9ee1
--- /dev/null
+++ b/test/parsing/test_sort.py
@@ -0,0 +1,96 @@
+"""
+
+Part of the tagit test suite.
+A copy of the license is provided with the project.
+Author: Matthias Baumgartner, 2022
+"""
+# standard imports
+import unittest
+
+# tagit imports
+from tagit.utils import errors
+#from tagit.parsing.search import ast, sortkeys # FIXME: mb/port/parsing
+
+# objects to test
+from tagit.parsing.sort import sort_from_string
+
+
+## code ##
+
+class TestParseSort(unittest.TestCase):
+    def setUp(self):
+        sortkeys.expose('iso',
+            TestScope('attribute', 'iso'), 'Numerical')
+        sortkeys.expose('rank',
+            TestScope('attribute', 'rank'), 'Alphabetical', 'Numerical')
+        sortkeys.expose('time',
+            TestScope('attribute', 'time'), 'Numerical')
+        sortkeys.expose('entity',
+            TestScope('property', 'guid'), 'Alphabetical')
+        sortkeys.expose('tag',
+            TestScope('property', 't_image_create_loc'), 'Anchored')
+        sortkeys.expose('mistake',
+            TestScope('property', 't_image_create_loc'))
+
+    def test_parse_sort(self):
+        # simple patterns
+        self.assertEqual(sort_from_string("time"), ast.NumericalSort('time', False))
+        self.assertEqual(sort_from_string("entity"), ast.AlphabeticalSort('entity', False))
+        self.assertEqual(sort_from_string("time asc"), ast.NumericalSort('time', False))
+        self.assertEqual(sort_from_string("time desc"), ast.NumericalSort('time', True))
+        self.assertEqual(sort_from_string("entity desc"), ast.AlphabeticalSort('entity', True))
+        self.assertEqual(sort_from_string("sort by time"), ast.NumericalSort('time', False))
+        self.assertEqual(sort_from_string("sort by time desc"), ast.NumericalSort('time', True))
+        self.assertEqual(sort_from_string("sort by entity desc"),
+            ast.AlphabeticalSort('entity', True))
+        # full pattern
+        self.assertEqual(sort_from_string("sort alphabetically by entity upwards"),
+            ast.AlphabeticalSort('entity', False))
+        self.assertEqual(sort_from_string("sort numerically by time desc"),
+            ast.NumericalSort('time', True))
+        # invalid type
+        self.assertRaises(errors.ParserError, sort_from_string, "sort alphabetically by time desc")
+        self.assertRaises(errors.ParserError, sort_from_string, "sort numerically by entity desc")
+        self.assertRaises(errors.ParserError, sort_from_string, "sort by time similarity to AF39D281CE3")
+        self.assertRaises(errors.ParserError, sort_from_string, "sort alphabetically by tag down,")
+        # ambiguous type
+        self.assertEqual(sort_from_string("sort alphabetically by rank"),
+            ast.AlphabeticalSort('rank', False))
+        self.assertEqual(sort_from_string("sort numerically by rank"),
+            ast.NumericalSort('rank', False))
+        self.assertRaises(errors.ParserError, sort_from_string, "sort by rank")
+        # anchor pattern
+        self.assertEqual(sort_from_string("sort by tag similarity to AF39D281CE3"),
+            ast.AnchoredSort('tag', 'AF39D281CE3', False))
+        self.assertEqual(sort_from_string("tag AF39D281CE3 up"),
+            ast.AnchoredSort('tag', 'AF39D281CE3', False))
+        self.assertEqual(sort_from_string("tag AF39D281CE3 down"),
+            ast.AnchoredSort('tag', 'AF39D281CE3', True))
+        self.assertRaises(errors.ParserError, sort_from_string, "time AF39D281CE3")
+        self.assertRaises(errors.ParserError, sort_from_string, "sort by tag down,")
+        self.assertRaises(errors.ParserError, sort_from_string, "tag XXXXXXXXXXX down,")
+        # compound statements
+        self.assertEqual(sort_from_string("time, iso"),
+            ast.Order(ast.NumericalSort('time'), ast.NumericalSort('iso')))
+        self.assertEqual(sort_from_string("tag AF39D281CE3 down, time up"),
+            ast.Order(ast.AnchoredSort('tag', 'AF39D281CE3', True),
+                ast.NumericalSort('time', False)))
+        self.assertRaises(errors.ParserError, sort_from_string, "tag AF39D281CE3 down,")
+        # empty string
+        self.assertRaises(errors.ParserError, sort_from_string, "")
+        # invalid predicate
+        self.assertRaises(errors.ParserError, sort_from_string, "foobar")
+        # invalid direction
+        self.assertRaises(errors.ParserError, sort_from_string, "sort by entity sideways")
+        # invalid typedef
+        self.assertRaises(errors.ParserError, sort_from_string, "sort by mistake")
+        # missing anchor
+        self.assertRaises(errors.ParserError, sort_from_string, "sort by time similarity to")
+
+
+## main ##
+
+if __name__ == '__main__':
+    unittest.main()
+
+## EOF ##