parsing early port

4 files changed, 1181 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/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_search.py b/test/parsing/test_search.py
new file mode 100644
index 0000000..23801d0
--- /dev/null
+++ b/test/parsing/test_search.py
@@ -0,0 +1,707 @@
+"""
+
+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 errors
+#from tagit.parsing.search import ast, predicates, PredicateScope # FIXME: mb/port/parsing
+
+# objects to test
+from tagit.parsing.search import ast_from_string
+
+
+## code ##
+
+class TestScope(PredicateScope):
+    _scope_order = ['major', 'minor', 'micro']
+    _init_values = ['library']
+
+
+class TestParseContinuous(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')
+
+    def _test(self, query, target):
+        predicate, condition = target
+        result = ast_from_string(query)
+        target = ast.AND([ast.Token(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(editable.format(num=1.23, predicate='iso'),
+                ('iso', ast.Continuous(1.23, float('inf'), True, False)))
+            # negative
+            self._test(editable.format(num=-1.23, predicate='iso'),
+                ('iso', ast.Continuous(-1.23, float('inf'), True, 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(editable.format(num=1.23, predicate='iso'),
+                ('iso', ast.Continuous(1.23, float('inf'), True, False)))
+            # negative
+            self._test(editable.format(num=-1.23, predicate='iso'),
+                ('iso', ast.Continuous(-1.23, float('inf'), True, False)))
+            # date
+            self._test(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(editable.format(num=1.23, predicate='iso'),
+                    ('iso', ast.Continuous(1.23, float('inf'), False, False)))
+            # negative
+            self._test(editable.format(num=-1.23, predicate='iso'),
+                    ('iso', ast.Continuous(-1.23, float('inf'), False, False)))
+
+        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(editable.format(num=1.23, predicate='iso'),
+                    ('iso', ast.Continuous(1.23, float('inf'), False, False)))
+            # negative
+            self._test(editable.format(num=-1.23, predicate='iso'),
+                    ('iso', ast.Continuous(-1.23, float('inf'), False, False)))
+            # date
+            self._test(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(editable.format(num=1.23, predicate='iso'),
+                ('iso', ast.Continuous(float('-inf'), 1.23, False, True)))
+            # negatives
+            self._test(editable.format(num=-1.23, predicate='iso'),
+                ('iso', ast.Continuous(float('-inf'), -1.23, False, True)))
+
+        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(editable.format(num=1.23, predicate='iso'),
+                ('iso', ast.Continuous(float('-inf'), 1.23, False, True)))
+            # negatives
+            self._test(editable.format(num=-1.23, predicate='iso'),
+                ('iso', ast.Continuous(float('-inf'), -1.23, False, True)))
+            # date
+            self._test(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(editable.format(num=1.23, predicate='iso'),
+                ('iso', ast.Continuous(float('-inf'), 1.23, False, False)))
+            # negatives
+            self._test(editable.format(num=-1.23, predicate='iso'),
+                ('iso', ast.Continuous(float('-inf'), -1.23, False, False)))
+
+        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(editable.format(num=1.23, predicate='iso'),
+                ('iso', ast.Continuous(float('-inf'), 1.23, False, False)))
+            # negatives
+            self._test(editable.format(num=-1.23, predicate='iso'),
+                ('iso', ast.Continuous(float('-inf'), -1.23, False, False)))
+            # date
+            self._test(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(editable.format(predicate='iso', numA=1.23, numB=4.56),
+                ('iso', ast.Continuous(1.23, 4.56, True, True)))
+            # negatives
+            self._test(editable.format(predicate='iso', numA=-4.56, numB=-1.23),
+                ('iso', ast.Continuous(-4.56, -1.23, True, True)))
+            # mixed
+            self._test(editable.format(predicate='iso', numA=-1.23, numB=4.56),
+                ('iso', ast.Continuous(-1.23, 4.56, True, True)))
+
+        for editable in [
+            # range
+            "{predicate} in [{numA}-{numB}]", "{predicate} :  [{numA}-{numB}]", "{predicate} =  [{numA}-{numB}]",
+            # equation
+            "{numA} <= {predicate} <= {numB}"
+            ]:
+            # positives
+            self._test(editable.format(predicate='iso', numA=1.23, numB=4.56),
+                ('iso', ast.Continuous(1.23, 4.56, True, True)))
+            # negatives
+            self._test(editable.format(predicate='iso', numA=-4.56, numB=-1.23),
+                ('iso', ast.Continuous(-4.56, -1.23, True, True)))
+            # mixed
+            self._test(editable.format(predicate='iso', numA=-1.23, numB=4.56),
+                ('iso', ast.Continuous(-1.23, 4.56, True, True)))
+            # date
+            self._test(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(editable.format(predicate='iso', numA=1.23, numB=4.56),
+                ('iso', ast.Continuous(1.23, 4.56, True, False)))
+            # negatives
+            self._test(editable.format(predicate='iso', numA=-4.56, numB=-1.23),
+                ('iso', ast.Continuous(-4.56, -1.23, True, False)))
+            # mixed
+            self._test(editable.format(predicate='iso', numA=-1.23, numB=4.56),
+                ('iso', ast.Continuous(-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(editable.format(predicate='iso', numA=1.23, numB=4.56),
+                ('iso', ast.Continuous(1.23, 4.56, True, False)))
+            # negatives
+            self._test(editable.format(predicate='iso', numA=-4.56, numB=-1.23),
+                ('iso', ast.Continuous(-4.56, -1.23, True, False)))
+            # mixed
+            self._test(editable.format(predicate='iso', numA=-1.23, numB=4.56),
+                ('iso', ast.Continuous(-1.23, 4.56, True, False)))
+            # date
+            self._test(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(editable.format(predicate='iso', numA=1.23, numB=4.56),
+                ('iso', ast.Continuous(1.23, 4.56, False, True)))
+            # negatives
+            self._test(editable.format(predicate='iso', numA=-4.56, numB=-1.23),
+                ('iso', ast.Continuous(-4.56, -1.23, False, True)))
+            # mixed
+            self._test(editable.format(predicate='iso', numA=-1.23, numB=4.56),
+                ('iso', ast.Continuous(-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(editable.format(predicate='iso', numA=1.23, numB=4.56),
+                ('iso', ast.Continuous(1.23, 4.56, False, True)))
+            # negatives
+            self._test(editable.format(predicate='iso', numA=-4.56, numB=-1.23),
+                ('iso', ast.Continuous(-4.56, -1.23, False, True)))
+            # mixed
+            self._test(editable.format(predicate='iso', numA=-1.23, numB=4.56),
+                ('iso', ast.Continuous(-1.23, 4.56, False, True)))
+            # date
+            self._test(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(editable.format(predicate='iso', numA=1.23, numB=4.56),
+                ('iso', ast.Continuous(1.23, 4.56, False, False)))
+            # negatives
+            self._test(editable.format(predicate='iso', numA=-4.56, numB=-1.23),
+                ('iso', ast.Continuous(-4.56, -1.23, False, False)))
+            # mixed
+            self._test(editable.format(predicate='iso', numA=-1.23, numB=4.56),
+                ('iso', ast.Continuous(-1.23, 4.56, False, False)))
+
+        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(editable.format(predicate='iso', numA=1.23, numB=4.56),
+                ('iso', ast.Continuous(1.23, 4.56, False, False)))
+            # negatives
+            self._test(editable.format(predicate='iso', numA=-4.56, numB=-1.23),
+                ('iso', ast.Continuous(-4.56, -1.23, False, False)))
+            # mixed
+            self._test(editable.format(predicate='iso', numA=-1.23, numB=4.56),
+                ('iso', ast.Continuous(-1.23, 4.56, False, False)))
+            # date
+            self._test(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(editable.format(predicate='iso', num=1.23),
+                ('iso', ast.Continuous(1.23, 1.23, True, True)))
+            # negatives
+            self._test(editable.format(predicate='iso', num=-1.23),
+                ('iso', ast.Continuous(-1.23, -1.23, True, True)))
+
+        for editable in [
+            # range
+            "{predicate} in [{num}-{num}]", "{predicate} :  [{num}-{num}]", "{predicate} =  [{num}-{num}]",
+            # equation
+            "{predicate} =  {num}", "{num} = {predicate}",
+            ]:
+            # positives
+            self._test(editable.format(predicate='iso', num=1.23),
+                ('iso', ast.Continuous(1.23, 1.23, True, True)))
+            # negatives
+            self._test(editable.format(predicate='iso', num=-1.23),
+                ('iso', ast.Continuous(-1.23, -1.23, True, True)))
+            # date
+            self._test(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):
+        self._test("{predicate} < {num}".format(predicate='time', num="2012"),
+            ('time', ast.Datetime(datetime.min, datetime(2012, 1, 1), False, False)))
+        self._test("{predicate} < {num}".format(predicate='time', num="2012.04"),
+            ('time', ast.Datetime(datetime.min, datetime(2012, 4, 1), False, False)))
+        self._test("{predicate} < {num}".format(predicate='time', num="2012.04.30"),
+            ('time', ast.Datetime(datetime.min, datetime(2012, 4, 30), False, False)))
+        self._test("{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("{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("{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("{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("{predicate} <= {num}".format(predicate='time', num="2012"),
+            ('time', ast.Datetime(datetime.min, datetime(2013, 1, 1), False, False)))
+        self._test("{predicate} <= {num}".format(predicate='time', num="2012.04"),
+            ('time', ast.Datetime(datetime.min, datetime(2012, 5, 1), False, False)))
+        self._test("{predicate} <= {num}".format(predicate='time', num="2012.04.30"),
+            ('time', ast.Datetime(datetime.min, datetime(2012, 5, 1), False, False)))
+        self._test("{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("{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("{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("{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):
+        self._test("{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("{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("{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("{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("{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("{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("{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("{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("{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("{predicate} in [+1.23-+4.56]".format(predicate='iso'),
+            ('iso', ast.Continuous(1.23, 4.56, True, True)))
+        self._test("{predicate} in [-+4.56]".format(predicate='iso'),
+            ('iso', ast.Continuous(float('-inf'), 4.56, False, True)))
+
+    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, ast_from_string,
+                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, ast_from_string,
+                    editable.format(predicate='iso', numA=4.56, numB=1.23))
+            self.assertRaises(errors.ParserError, ast_from_string,
+                    editable.format(predicate='time', numA="17:35", numB="10:55"))
+            self.assertRaises(errors.ParserError, ast_from_string,
+                    editable.format(predicate='time', numA="18.12.2035", numB="5.7.1999"))
+
+        # 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, ast_from_string, "100 >= iso < 200")
+        self.assertRaises(errors.ParserError, ast_from_string, "100 > iso < 200")
+        self.assertRaises(errors.ParserError, ast_from_string, "100 > iso <= 200")
+        self.assertRaises(errors.ParserError, ast_from_string, "100 >= iso <= 200")
+        self.assertRaises(errors.ParserError, ast_from_string, "100 = iso = 200")
+        # time/date mixture errors
+        self.assertRaises(errors.ParserError, ast_from_string, "12:45 < time < 17.5.2004")
+        self.assertRaises(errors.ParserError, ast_from_string, "17.5.2004 < time < 12:45")
+        # date/int mixture errors
+        self.assertRaises(errors.ParserError, ast_from_string, "17.5.2004 < time < 1245")
+        # 1245 is interpreted as the year
+        #self.assertRaises(errors.ParserError, ast_from_string, "1245 < time < 17.5.2004")
+        # time/int mixture errors
+        self.assertRaises(errors.ParserError, ast_from_string, "17:12 < time < 1245")
+        self.assertRaises(errors.ParserError, ast_from_string, "1712 < time < 12:45")
+
+        # empty query
+        self.assertRaises(ParseException, ast_from_string.CONTINUOUS.parseString, "")
+
+
+class TestParseSearch(unittest.TestCase):
+    def setUp(self):
+        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')
+
+    def test_parse_existence(self):
+        self.assertEqual(ast_from_string("has mime"),
+            ast.AND([ast.Token('mime', ast.Existence())]))
+        self.assertEqual(ast_from_string("has no mime"),
+            ast.AND([ast.Token('mime', ast.Inexistence())]))
+        self.assertEqual(ast_from_string("has not mime"),
+            ast.AND([ast.Token('mime', ast.Inexistence())]))
+
+    def test_parse_categorical(self):
+        # positive
+        self.assertEqual(ast_from_string("iso in 100, 200, 500"),
+            ast.AND([ast.Token('iso', ast.SetInclude(['100', '200', '500']))]))
+        self.assertEqual(ast_from_string("iso in (100, 200)"),
+            ast.AND([ast.Token('iso', ast.SetInclude(['100', '200']))]))
+        self.assertEqual(ast_from_string("iso = (100, 200)"),
+            ast.AND([ast.Token('iso', ast.SetInclude(['100', '200']))]))
+        # FIXME!
+        #self.assertEqual(ast_from_string("iso = 100, 200"),
+        #    ast.AND([ast.Token('iso', ast.SetInclude(['100', '200']))]))
+        self.assertEqual(ast_from_string("iso : (100, 200)"),
+            ast.AND([ast.Token('iso', ast.SetInclude(['100', '200']))]))
+        self.assertEqual(ast_from_string("iso : 100, 200"),
+            ast.AND([ast.Token('iso', ast.SetInclude(['100', '200']))]))
+        self.assertEqual(ast_from_string("iso:(100,200)"),
+            ast.AND([ast.Token('iso', ast.SetInclude(['100', '200']))]))
+        self.assertEqual(ast_from_string("iso in (100,200)"),
+            ast.AND([ast.Token('iso', ast.SetInclude(['100', '200']))]))
+        self.assertEqual(ast_from_string("iso in 100,200"),
+            ast.AND([ast.Token('iso', ast.SetInclude(['100', '200']))]))
+        self.assertEqual(ast_from_string("iso ~ (100,200)"),
+            ast.AND([ast.Token('iso', ast.SetInclude(['100', '200'], approximate=True))]))
+        self.assertEqual(ast_from_string("iso ~ 100,200"),
+            ast.AND([ast.Token('iso', ast.SetInclude(['100', '200'], approximate=True))]))
+
+        # negative
+        self.assertEqual(ast_from_string("iso not in 100,200"),
+            ast.AND([ast.Token('iso', ast.SetExclude(['100', '200']))]))
+        self.assertEqual(ast_from_string("iso not in (100, 200)"),
+            ast.AND([ast.Token('iso', ast.SetExclude(['100', '200']))]))
+        self.assertEqual(ast_from_string("iso != 100,200"),
+            ast.AND([ast.Token('iso', ast.SetExclude(['100', '200']))]))
+        self.assertEqual(ast_from_string("iso != (100, 200)"),
+            ast.AND([ast.Token('iso', ast.SetExclude(['100', '200']))]))
+        self.assertEqual(ast_from_string("iso !~ 100,200"),
+            ast.AND([ast.Token('iso', ast.SetExclude(['100', '200'], approximate=True))]))
+        self.assertEqual(ast_from_string("iso !~ (100, 200)"),
+            ast.AND([ast.Token('iso', ast.SetExclude(['100', '200'], approximate=True))]))
+
+        # one value
+        self.assertEqual(ast_from_string("mime : text"),
+            ast.AND([ast.Token('mime', ast.SetInclude(['text']))]))
+        self.assertEqual(ast_from_string("mime in text"),
+            ast.AND([ast.Token('mime', ast.SetInclude(['text']))]))
+        self.assertEqual(ast_from_string("mime = text"),
+            ast.AND([ast.Token('mime', ast.SetInclude(['text']))]))
+        self.assertEqual(ast_from_string("mime ~ text"),
+            ast.AND([ast.Token('mime', ast.SetInclude(['text'], approximate=True))]))
+        self.assertEqual(ast_from_string("mime != text"),
+            ast.AND([ast.Token('mime', ast.SetExclude(['text']))]))
+        self.assertEqual(ast_from_string("mime not in text"),
+            ast.AND([ast.Token('mime', ast.SetExclude(['text']))]))
+        self.assertEqual(ast_from_string("mime !~ text"),
+            ast.AND([ast.Token('mime', ast.SetExclude(['text'], approximate=True))]))
+
+        # expressions with slash and comma
+        self.assertEqual(ast_from_string('mime : "text"'),
+            ast.AND([ast.Token('mime', ast.SetInclude(['text']))]))
+        self.assertEqual(ast_from_string('mime : "text", "plain"'),
+            ast.AND([ast.Token('mime', ast.SetInclude(['text', 'plain']))]))
+        self.assertEqual(ast_from_string('mime : "text, plain"'),
+            ast.AND([ast.Token('mime', ast.SetInclude(['text, plain']))]))
+        self.assertEqual(ast_from_string('mime ~ "text/plain"'),
+            ast.AND([ast.Token('mime', ast.SetInclude(['text/plain'], approximate=True))]))
+        self.assertEqual(ast_from_string('mime = ("text/plain", "image/jpeg")'),
+            ast.AND([ast.Token('mime', ast.SetInclude(['text/plain', 'image/jpeg']))]))
+
+    def test_parse_tag(self):
+
+        # only tag: tag, tags, (tag), (tags)
+        self.assertEqual(ast_from_string("foo"),
+            ast.AND([ast.Token('tag', ast.SetInclude(['foo']))]))
+        self.assertEqual(ast_from_string("(foo)"),
+            ast.AND([ast.Token('tag', ast.SetInclude(['foo']))]))
+        self.assertEqual(ast_from_string("foo, bar"),
+            ast.AND([ast.Token('tag', ast.SetInclude(['foo', 'bar']))]))
+        self.assertEqual(ast_from_string("foo,bar"),
+            ast.AND([ast.Token('tag', ast.SetInclude(['foo', 'bar']))]))
+        self.assertEqual(ast_from_string("(foo, bar,foobar)"),
+            ast.AND([ast.Token('tag', ast.SetInclude(['foo', 'bar', 'foobar']))]))
+
+        # op and tag: !tag, ~tag, !~tag
+        self.assertEqual(ast_from_string("~foo"),
+            ast.AND([ast.Token('tag', ast.SetInclude(['foo'], approximate=True))]))
+        self.assertEqual(ast_from_string("~ foo"),
+            ast.AND([ast.Token('tag', ast.SetInclude(['foo'], approximate=True))]))
+        self.assertEqual(ast_from_string("!foo"),
+            ast.AND([ast.Token('tag', ast.SetExclude(['foo']))]))
+        self.assertEqual(ast_from_string("! foo"),
+            ast.AND([ast.Token('tag', ast.SetExclude(['foo']))]))
+        self.assertEqual(ast_from_string("!~foo"),
+            ast.AND([ast.Token('tag', ast.SetExclude(['foo'], approximate=True))]))
+        self.assertEqual(ast_from_string("!~ foo"),
+            ast.AND([ast.Token('tag', ast.SetExclude(['foo'], approximate=True))]))
+
+        # op and list: ! (tags), ~tags, ...
+        self.assertEqual(ast_from_string("~ foo, bar"),
+            ast.AND([ast.Token('tag', ast.SetInclude(['foo', 'bar'], approximate=True))]))
+        self.assertEqual(ast_from_string("~foo, bar"),
+            ast.AND([ast.Token('tag', ast.SetInclude(['foo', 'bar'], approximate=True))]))
+        self.assertEqual(ast_from_string("~ (foo, bar)"),
+            ast.AND([ast.Token('tag', ast.SetInclude(['foo', 'bar'], approximate=True))]))
+        self.assertEqual(ast_from_string("! foo, bar"),
+            ast.AND([ast.Token('tag', ast.SetExclude(['foo', 'bar']))]))
+        self.assertEqual(ast_from_string("! (foo, bar)"),
+            ast.AND([ast.Token('tag', ast.SetExclude(['foo', 'bar']))]))
+        self.assertEqual(ast_from_string("! (foo,bar)"),
+            ast.AND([ast.Token('tag', ast.SetExclude(['foo', 'bar']))]))
+        self.assertEqual(ast_from_string("!~ foo, bar"),
+            ast.AND([ast.Token('tag', ast.SetExclude(['foo', 'bar'], approximate=True))]))
+        self.assertEqual(ast_from_string("!~ (foo, bar)"),
+            ast.AND([ast.Token('tag', ast.SetExclude(['foo', 'bar'], approximate=True))]))
+        self.assertEqual(ast_from_string("!~(foo,bar)"),
+            ast.AND([ast.Token('tag', ast.SetExclude(['foo', 'bar'], approximate=True))]))
+
+    def test_parse_query(self):
+        # simple query
+        self.assertEqual(ast_from_string('foo / bar'), ast.AND([
+            ast.Token('tag', ast.SetInclude('foo')),
+            ast.Token('tag', ast.SetInclude('bar'))]))
+        self.assertEqual(ast_from_string('iso in ("foo", "bar") / mime = plain'), ast.AND([
+            ast.Token('iso', ast.SetInclude('foo', 'bar')),
+            ast.Token('mime', ast.SetInclude('plain'))]))
+        self.assertEqual(ast_from_string('iso in ("foo", "bar") / mime = plain'), ast.AND([
+            ast.Token('iso', ast.SetInclude('foo', 'bar')),
+            ast.Token('mime', ast.SetInclude('plain'))]))
+        self.assertEqual(ast_from_string('iso = 1.23 / rank < 5'), ast.AND([
+            ast.Token('iso', ast.Continuous(1.23, 1.23, True, True)),
+            ast.Token('rank', ast.Continuous(hi=5))]))
+        self.assertEqual(ast_from_string('time >= 12:50 / time < 13:50'), ast.AND([
+            ast.Token('time', ast.TimeRange(lo=datetime(1970, 1, 1, 12, 50), lo_inc=True, hi_inc=True)),
+            ast.Token('time', ast.TimeRange(hi=datetime(1970, 1, 1, 13, 50), lo_inc=True, hi_inc=False))]))
+        self.assertEqual(ast_from_string('time >= 17.5.2001 / time < 18.4.2002'), ast.AND([
+            ast.Token('time', ast.Datetime(lo=datetime(2001, 5, 17, 0, 0), lo_inc=True)),
+            ast.Token('time', ast.Datetime(hi=datetime(2002, 4, 18, 0, 0)))]))
+        # mixing expressions
+        self.assertEqual(ast_from_string('foo / iso in "bar" / mime ~ "text/plain" / iso < 100 / time >= 17.5.2001 / time < 13:50'), ast.AND([
+            ast.Token('tag', ast.SetInclude('foo')),
+            ast.Token('iso', ast.SetInclude('bar')),
+            ast.Token('mime', ast.SetInclude('text/plain', approximate=True)),
+            ast.Token('iso', ast.Continuous(hi=100)),
+            ast.Token('time', ast.Datetime(lo=datetime(2001, 5, 17, 0, 0), lo_inc=True)),
+            ast.Token('time', ast.TimeRange(hi=datetime(1970, 1, 1, 13, 50), lo_inc=True))]))
+
+        # leading/trailing slashes
+        self.assertRaises(errors.ParserError, ast_from_string, '/ foobar')
+        self.assertRaises(errors.ParserError, ast_from_string, 'foobar /')
+        self.assertRaises(errors.ParserError, ast_from_string, 'foobar / ')
+        self.assertRaises(errors.ParserError, ast_from_string, 'foo // bar')
+        self.assertRaises(errors.ParserError, ast_from_string, 'foo / / bar')
+
+    def test_quoting(self):
+        self.assertEqual(ast_from_string("tag in ('(foo, bar)', foobar)"),
+            ast.AND([ast.Token('tag', ast.SetInclude(['(foo, bar)', 'foobar']))]))
+        self.assertEqual(ast_from_string('tag in ("(foo, bar)", foobar)'),
+            ast.AND([ast.Token('tag', ast.SetInclude(['(foo, bar)', 'foobar']))]))
+        self.assertEqual(ast_from_string('tag in ("(foo, \\"bar\\")", foobar)'),
+            ast.AND([ast.Token('tag', ast.SetInclude(['(foo, "bar")', 'foobar']))]))
+        self.assertEqual(ast_from_string('tag in ("(foo, bar)", "foobar")'),
+            ast.AND([ast.Token('tag', ast.SetInclude(['(foo, bar)', 'foobar']))]))
+        self.assertEqual(ast_from_string('tag in ("(foo, bar)", \'foobar\')'),
+            ast.AND([ast.Token('tag', ast.SetInclude(['(foo, bar)', 'foobar']))]))
+
+        # error cases
+        self.assertRaises(errors.ParserError, ast_from_string, ('tag in ("(foo, bar, foobar)'))
+        self.assertRaises(errors.ParserError, ast_from_string, ("tag in ('(foo, bar, foobar)"))
+
+
+## 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 ##