# -*- coding: utf-8 -*-
#
# Picard, the next-generation MusicBrainz tagger
#
# Copyright (C) 2007 Lukáš Lalinský
# Copyright (C) 2010, 2014, 2018-2022 Philipp Wolfer
# Copyright (C) 2012 Chad Wilson
# Copyright (C) 2013 Michael Wiencek
# Copyright (C) 2013, 2017-2021 Laurent Monin
# Copyright (C) 2014, 2017 Sophist-UK
# Copyright (C) 2016-2017 Sambhav Kothari
# Copyright (C) 2017 Antonio Larrosa
# Copyright (C) 2017-2018, 2021 Wieland Hoffmann
# Copyright (C) 2018 virusMac
# Copyright (C) 2020-2022 Bob Swift
# Copyright (C) 2021 Adam James
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.


import builtins
import copy
import datetime
import re
import unittest
from unittest import mock
from unittest.mock import MagicMock

from test.picardtestcase import PicardTestCase

from picard.cluster import Cluster
from picard.const import DEFAULT_FILE_NAMING_FORMAT
from picard.metadata import (
    MULTI_VALUED_JOINER,
    Metadata,
)
from picard.plugin import ExtensionPoint
from picard.script import (
    MultiValue,
    ScriptEndOfFile,
    ScriptError,
    ScriptExpression,
    ScriptFunction,
    ScriptFunctionDocError,
    ScriptParser,
    ScriptRuntimeError,
    ScriptSyntaxError,
    ScriptUnicodeError,
    ScriptUnknownFunction,
    register_script_function,
    script_function,
    script_function_documentation,
    script_function_documentation_all,
)
from picard.script.functions import FunctionRegistryItem


try:
    from markdown import markdown
except ImportError:
    markdown = None


class _TestTimezone(datetime.tzinfo):
    def utcoffset(self, dt):
        # Set to GMT+2
        return datetime.timedelta(hours=2) + self.dst(dt)

    def dst(self, dt):
        d = datetime.datetime(dt.year, 4, 1)
        self.dston = d - datetime.timedelta(days=d.weekday() + 1)
        d = datetime.datetime(dt.year, 11, 1)
        self.dstoff = d - datetime.timedelta(days=d.weekday() + 1)
        if self.dston <= dt.replace(tzinfo=None) < self.dstoff:
            return datetime.timedelta(hours=1)
        else:
            return datetime.timedelta(0)

    def tzname(self, dt):
        return "TZ Test"


class _DateTime(datetime.datetime):
    @classmethod
    def now(cls, tz=None):
        return datetime.datetime(2020, 1, 2, hour=12, minute=34, second=56, microsecond=789, tzinfo=tz)

    def astimezone(self, tz=None):
        # Ignore tz passed to the method and force use of test timezone.
        tz = _TestTimezone()
        utc = (self - self.utcoffset()).replace(tzinfo=tz)
        # Convert from UTC to tz's local time.
        return tz.fromutc(utc)


class ScriptParserTest(PicardTestCase):

    def setUp(self):
        super().setUp()
        self.set_config_values({
            'enabled_plugins': '',
        })

        self.parser = ScriptParser()

        # ensure we start on clean registry
        ScriptParser._cache = {}
        self._backup_registry = copy.deepcopy(ScriptParser._function_registry)

    def tearDown(self):
        ScriptParser._function_registry = copy.deepcopy(self._backup_registry)

    def assertScriptResultEquals(self, script, expected, context=None, file=None):
        """Asserts that evaluating `script` returns `expected`.


        Args:
            script: The tagger script
            expected: The expected result
            context: A Metadata object with pre-set tags or None
        """
        actual = self.parser.eval(script, context=context, file=file)
        self.assertEqual(actual,
                         expected,
                         "'%s' evaluated to '%s', expected '%s'"
                         % (script, actual, expected))

    def test_function_registry_item(self):
        def somefunc():
            return 'x'
        item = FunctionRegistryItem(somefunc, 'x', 'y', 'doc')
        self.assertEqual(item.function, somefunc)
        self.assertEqual(item.eval_args, 'x')
        self.assertEqual(item.argcount, 'y')
        self.assertEqual(item.documentation, 'doc')

        regex = r'^'\
                + re.escape(r'FunctionRegistryItem(<function ')\
                + r'[^ ]+'\
                + re.escape(r'.somefunc at ')\
                + r'[^>]+'\
                + re.escape(r'>, x, y, """doc""")')\
                + r'$'

        self.assertRegex(repr(item), regex)

    def test_script_unicode_char(self):
        self.assertScriptResultEquals("\\u6e56", "湖")
        self.assertScriptResultEquals("foo\\u6e56bar", "foo湖bar")
        self.assertScriptResultEquals("\\uFFFF", "\uffff")

    def test_script_unicode_char_eof(self):
        areg = r"^\d+:\d+: Unexpected end of script"
        with self.assertRaisesRegex(ScriptEndOfFile, areg):
            self.parser.eval("\\u")
        with self.assertRaisesRegex(ScriptEndOfFile, areg):
            self.parser.eval("\\uaff")

    def test_script_unicode_char_err(self):
        areg = r"^\d+:\d+: Invalid unicode character '\\ufffg'"
        with self.assertRaisesRegex(ScriptUnicodeError, areg):
            self.parser.eval("\\ufffg")

    def test_script_function_decorator_default(self):
        # test default decorator and default prefix
        @script_function()
        def func_somefunc(parser):
            return "x"
        self.assertScriptResultEquals("$somefunc()", "x")

    def test_script_function_decorator_no_prefix(self):
        # function without prefix
        @script_function()
        def somefunc(parser):
            return "x"
        self.assertScriptResultEquals("$somefunc()", "x")

    def test_script_function_decorator_arg(self):
        # function with argument
        @script_function()
        def somefunc(parser, arg):
            return arg
        self.assertScriptResultEquals("$somefunc($title(x))", "X")
        areg = r"^\d+:\d+:\$somefunc: Wrong number of arguments for \$somefunc: Expected exactly 1"
        with self.assertRaisesRegex(ScriptError, areg):
            self.parser.eval("$somefunc()")

    def test_script_function_decorator_argcount(self):
        # ignore argument count
        @script_function(check_argcount=False)
        def somefunc(parser, *arg):
            return str(len(arg))
        self.assertScriptResultEquals("$somefunc(a,b,c)", "3")

    def test_script_function_decorator_altname(self):
        # alternative name
        @script_function(name="otherfunc")
        def somefunc4(parser):
            return "x"
        self.assertScriptResultEquals("$otherfunc()", "x")
        areg = r"^\d+:\d+:\$somefunc: Unknown function '\$somefunc'"
        with self.assertRaisesRegex(ScriptError, areg):
            self.parser.eval("$somefunc()")

    def test_script_function_decorator_altprefix(self):
        # alternative prefix
        @script_function(prefix='theprefix_')
        def theprefix_somefunc(parser):
            return "x"
        self.assertScriptResultEquals("$somefunc()", "x")

    def test_script_function_decorator_eval_args(self):
        # disable argument evaluation
        @script_function(eval_args=False)
        def somefunc(parser, arg):
            return arg.eval(parser)
        self.assertScriptResultEquals("$somefunc($title(x))", "X")

    @staticmethod
    def assertStartswith(text, expect):
        if not text.startswith(expect):
            raise AssertionError("do not start with %r but with %r" % (expect, text[:len(expect)]))

    @staticmethod
    def assertEndswith(text, expect):
        if not text.endswith(expect):
            raise AssertionError("do not end with %r but with %r" % (expect, text[-len(expect):]))

    @staticmethod
    def reset_registry():
        # use a clean registry, to ensure we have only one registered function
        ScriptParser._function_registry = ExtensionPoint()

    def test_script_function_documentation_nodoc(self):
        """test script_function_documentation() with a function without documentation"""
        self.reset_registry()

        @script_function()
        def func_nodocfunc(parser):
            return ""

        doc = script_function_documentation('nodocfunc', 'markdown')
        self.assertEqual(doc, '')
        doc = script_function_documentation('nodocfunc', 'html')
        self.assertEqual(doc, '')

    def test_script_function_documentation(self):
        """test script_function_documentation() with a function with documentation"""
        self.reset_registry()

        # the documentation used to test includes backquotes
        testdoc = '`$somefunc()`'

        @script_function(documentation=testdoc)
        def func_somefunc(parser):
            return "x"

        doc = script_function_documentation('somefunc', 'markdown')
        self.assertEqual(doc, testdoc)
        areg = r"^no such documentation format: unknownformat"
        with self.assertRaisesRegex(ScriptFunctionDocError, areg):
            script_function_documentation('somefunc', 'unknownformat')

    @unittest.skipUnless(markdown, "markdown module missing")
    def test_script_function_documentation_html(self):
        """test script_function_documentation() with a function with documentation"""
        self.reset_registry()

        # get html code as generated by markdown
        pre, post = markdown('`XXX`').split('XXX')

        # the documentation used to test includes backquotes
        testdoc = '`$somefunc()`'

        @script_function(documentation=testdoc)
        def func_somefunc(parser):
            return "x"

        doc = script_function_documentation('somefunc', 'html')
        self.assertEqual(doc, pre + '$somefunc()' + post)

    def test_script_function_documentation_unknown_function(self):
        """test script_function_documentation() with an unknown function"""
        self.reset_registry()

        areg = r"^no such function: unknownfunc"
        with self.assertRaisesRegex(ScriptFunctionDocError, areg):
            script_function_documentation('unknownfunc', 'html')

    def test_script_function_documentation_all(self):
        """test script_function_documentation_all() with markdown format"""
        self.reset_registry()

        @script_function(documentation='somedoc2')
        def func_somefunc2(parser):
            return "x"

        @script_function(documentation='somedoc1')
        def func_somefunc1(parser):
            return "x"

        docall = script_function_documentation_all()
        self.assertEqual(docall, 'somedoc1\nsomedoc2')

    @unittest.skipUnless(markdown, "markdown module missing")
    def test_script_function_documentation_all_html(self):
        """test script_function_documentation_all() with html format"""
        self.reset_registry()

        # get html code as generated by markdown
        pre, post = markdown('XXX').split('XXX')

        @script_function(documentation='somedoc')
        def func_somefunc(parser):
            return "x"

        def postprocessor(data, function):
            return 'w' + data + function.name + 'y'

        docall = script_function_documentation_all(
            fmt='html',
            pre='<div id="test">',
            post="</div>\n",
            postprocessor=postprocessor,
        )

        self.assertStartswith(docall, '<div id="test">w' + pre)
        self.assertEndswith(docall, post + 'somefuncy</div>\n')

    def test_unknown_function(self):
        areg = r"^\d+:\d+:\$unknownfunction: Unknown function '\$unknownfunction'"
        with self.assertRaisesRegex(ScriptError, areg):
            self.parser.eval("$unknownfunction()")

    def test_noname_function(self):
        areg = r"^\d+:\d+:\$: Unknown function '\$'"
        with self.assertRaisesRegex(ScriptError, areg):
            self.parser.eval("$()")

    def test_unexpected_end_of_script(self):
        areg = r"^\d+:\d+: Unexpected end of script"
        with self.assertRaisesRegex(ScriptError, areg):
            self.parser.eval("$noop(")
        with self.assertRaisesRegex(ScriptError, areg):
            self.parser.eval("$")

    def test_unexpected_character(self):
        areg = r"^\d+:\d+: Unexpected character '\^'"
        with self.assertRaisesRegex(ScriptError, areg):
            self.parser.eval("$^noop()")

    def test_scriptfunction_unknown(self):
        parser = ScriptParser()
        parser.parse('')
        areg = r"^\d+:\d+:\$x: Unknown function '\$x'"
        with self.assertRaisesRegex(ScriptError, areg):
            ScriptFunction('x', '', parser)
        areg = r"^\d+:\d+:\$noop: Unknown function '\$noop'"
        with self.assertRaisesRegex(ScriptError, areg):
            f = ScriptFunction('noop', '', parser)
            del parser.functions['noop']
            f.eval(parser)

    def test_cmd_noop(self):
        self.assertScriptResultEquals("$noop()", "")
        self.assertScriptResultEquals("$noop(abcdefg)", "")

    def test_cmd_if(self):
        self.assertScriptResultEquals("$if(1,a,b)", "a")
        self.assertScriptResultEquals("$if(,a,b)", "b")

    def test_cmd_if2(self):
        self.assertScriptResultEquals("$if2(,a,b)", "a")
        self.assertScriptResultEquals("$if2($noop(),b)", "b")
        self.assertScriptResultEquals("$if2()", "")
        self.assertScriptResultEquals("$if2(,)", "")

    def test_cmd_left(self):
        self.assertScriptResultEquals("$left(abcd,2)", "ab")
        self.assertScriptResultEquals("$left(abcd,x)", "")

    def test_cmd_right(self):
        self.assertScriptResultEquals("$right(abcd,2)", "cd")
        self.assertScriptResultEquals("$right(abcd,x)", "")

    def test_cmd_set(self):
        context = Metadata()
        self.assertScriptResultEquals("$set(test,aaa)%test%", "aaa", context)
        self.assertEqual(context['test'], 'aaa')

    def test_cmd_set_empty(self):
        self.assertScriptResultEquals("$set(test,)%test%", "")

    def test_cmd_set_multi_valued(self):
        context = Metadata()
        context["source"] = ["multi", "valued"]
        self.parser.eval("$set(test,%source%)", context)
        self.assertEqual(context.getall("test"), ["multi; valued"])  # list has only a single value

    def test_cmd_setmulti_multi_valued(self):
        context = Metadata()
        context["source"] = ["multi", "valued"]
        self.assertEqual("", self.parser.eval("$setmulti(test,%source%)", context))  # no return value
        self.assertEqual(context.getall("source"), context.getall("test"))

    def test_cmd_setmulti_multi_valued_wth_spaces(self):
        context = Metadata()
        context["source"] = ["multi, multi", "valued, multi"]
        self.assertEqual("", self.parser.eval("$setmulti(test,%source%)", context))  # no return value
        self.assertEqual(context.getall("source"), context.getall("test"))

    def test_cmd_setmulti_not_multi_valued(self):
        context = Metadata()
        context["source"] = "multi, multi"
        self.assertEqual("", self.parser.eval("$setmulti(test,%source%)", context))  # no return value
        self.assertEqual(context.getall("source"), context.getall("test"))

    def test_cmd_setmulti_will_keep_empty_items(self):
        context = Metadata()
        context["source"] = ["", "multi", ""]
        self.assertEqual("", self.parser.eval("$setmulti(test,%source%)", context))  # no return value
        self.assertEqual(["", "multi", ""], context.getall("test"))

    def test_cmd_setmulti_custom_splitter_string(self):
        context = Metadata()
        self.assertEqual("", self.parser.eval("$setmulti(test,multi##valued##test##,##)", context))  # no return value
        self.assertEqual(["multi", "valued", "test", ""], context.getall("test"))

    def test_cmd_setmulti_empty_splitter_does_nothing(self):
        context = Metadata()
        self.assertEqual("", self.parser.eval("$setmulti(test,multi; valued,)", context))  # no return value
        self.assertEqual(["multi; valued"], context.getall("test"))

    def test_cmd_get(self):
        context = Metadata()
        context["test"] = "aaa"
        self.assertScriptResultEquals("$get(test)", "aaa", context)
        context["test2"] = ["multi", "valued"]
        self.assertScriptResultEquals("$get(test2)", "multi; valued", context)

    def test_cmd_num(self):
        self.assertScriptResultEquals("$num(3,3)", "003")
        self.assertScriptResultEquals("$num(03,3)", "003")
        self.assertScriptResultEquals("$num(123,2)", "123")
        self.assertScriptResultEquals("$num(123,a)", "")
        self.assertScriptResultEquals("$num(a,2)", "00")
        self.assertScriptResultEquals("$num(123,-1)", "123")
        self.assertScriptResultEquals("$num(123,35)", "00000000000000000123")

    def test_cmd_or(self):
        self.assertScriptResultEquals("$or(,)", "")
        self.assertScriptResultEquals("$or(,,)", "")
        self.assertScriptResultEquals("$or(,q)", "1")
        self.assertScriptResultEquals("$or(q,)", "1")
        self.assertScriptResultEquals("$or(q,q)", "1")
        self.assertScriptResultEquals("$or(q,,)", "1")

    def test_cmd_and(self):
        self.assertScriptResultEquals("$and(,)", "")
        self.assertScriptResultEquals("$and(,q)", "")
        self.assertScriptResultEquals("$and(q,)", "")
        self.assertScriptResultEquals("$and(q,q,)", "")
        self.assertScriptResultEquals("$and(q,q)", "1")
        self.assertScriptResultEquals("$and(q,q,q)", "1")

    def test_cmd_not(self):
        self.assertScriptResultEquals("$not($noop())", "1")
        self.assertScriptResultEquals("$not(q)", "")

    def test_cmd_trim(self):
        self.assertScriptResultEquals("$trim( \\t test \\n )", "test")
        self.assertScriptResultEquals("$trim(test,t)", "es")
        self.assertScriptResultEquals("$trim(test,ts)", "e")

    def test_cmd_add(self):
        self.assertScriptResultEquals("$add(1,2)", "3")
        self.assertScriptResultEquals("$add(1,2,3)", "6")
        self.assertScriptResultEquals("$add(a,2)", "")
        self.assertScriptResultEquals("$add(2,a)", "")

    def test_cmd_sub(self):
        self.assertScriptResultEquals("$sub(1,2)", "-1")
        self.assertScriptResultEquals("$sub(2,1)", "1")
        self.assertScriptResultEquals("$sub(4,2,1)", "1")
        self.assertScriptResultEquals("$sub(a,2)", "")
        self.assertScriptResultEquals("$sub(2,a)", "")

    def test_cmd_div(self):
        self.assertScriptResultEquals("$div(9,3)", "3")
        self.assertScriptResultEquals("$div(10,3)", "3")
        self.assertScriptResultEquals("$div(30,3,3)", "3")
        self.assertScriptResultEquals("$div(30,0)", "")
        self.assertScriptResultEquals("$div(30,a)", "")

    def test_cmd_mod(self):
        self.assertScriptResultEquals("$mod(9,3)", "0")
        self.assertScriptResultEquals("$mod(10,3)", "1")
        self.assertScriptResultEquals("$mod(10,6,3)", "1")
        self.assertScriptResultEquals("$mod(a,3)", "")
        self.assertScriptResultEquals("$mod(10,a)", "")
        self.assertScriptResultEquals("$mod(10,0)", "")

    def test_cmd_mul(self):
        self.assertScriptResultEquals("$mul(9,3)", "27")
        self.assertScriptResultEquals("$mul(10,3)", "30")
        self.assertScriptResultEquals("$mul(2,5,3)", "30")
        self.assertScriptResultEquals("$mul(2,a)", "")
        self.assertScriptResultEquals("$mul(2,5,a)", "")

    def test_cmd_eq(self):
        self.assertScriptResultEquals("$eq(,)", "1")
        self.assertScriptResultEquals("$eq(,$noop())", "1")
        self.assertScriptResultEquals("$eq(,q)", "")
        self.assertScriptResultEquals("$eq(q,q)", "1")
        self.assertScriptResultEquals("$eq(q,)", "")

    def test_cmd_ne(self):
        self.assertScriptResultEquals("$ne(,)", "")
        self.assertScriptResultEquals("$ne(,$noop())", "")
        self.assertScriptResultEquals("$ne(,q)", "1")
        self.assertScriptResultEquals("$ne(q,q)", "")
        self.assertScriptResultEquals("$ne(q,)", "1")

    def test_cmd_lower(self):
        self.assertScriptResultEquals("$lower(AbeCeDA)", "abeceda")

    def test_cmd_upper(self):
        self.assertScriptResultEquals("$upper(AbeCeDA)", "ABECEDA")

    def test_cmd_pad(self):
        self.assertScriptResultEquals("$pad(abc de,10,-)", "----abc de")
        self.assertScriptResultEquals("$pad(abc de,e,-)", "")
        self.assertScriptResultEquals("$pad(abc de,6,-)", "abc de")
        self.assertScriptResultEquals("$pad(abc de,3,-)", "abc de")
        self.assertScriptResultEquals("$pad(abc de,0,-)", "abc de")
        self.assertScriptResultEquals("$pad(abc de,-3,-)", "abc de")

    def test_cmd_replace(self):
        self.assertScriptResultEquals("$replace(abc ab abd a,ab,test)", "testc test testd a")

    def test_cmd_replacemulti(self):
        context = Metadata()
        context["genre"] = ["Electronic", "Idm", "Techno"]
        self.assertScriptResultEquals("$replacemulti(%genre%,Idm,IDM)", "Electronic; IDM; Techno", context)

        context["genre"] = ["Electronic", "Jungle", "Bardcore"]
        self.assertScriptResultEquals("$replacemulti(%genre%,Bardcore,Hardcore)", "Electronic; Jungle; Hardcore", context)

        context["test"] = ["One", "Two", "Three"]
        self.assertScriptResultEquals("$replacemulti(%test%,Two,)", "One; Three", context)

        context["test"] = ["One", "Two", "Three"]
        self.assertScriptResultEquals("$replacemulti(%test%,Four,Five)", "One; Two; Three", context)

        context["test"] = ["Four", "Five", "Six"]
        self.assertScriptResultEquals("$replacemulti(%test%,Five,)", "Four; Six", context)

        self.assertScriptResultEquals("$replacemulti(a; b,,,)", "a; b")
        self.assertScriptResultEquals("$setmulti(foo,a; b)$replacemulti(%foo%,,,)", "a; b")

    def test_cmd_strip(self):
        self.assertScriptResultEquals("$strip(  \t abc  de \n f  )", "abc de f")

    def test_cmd_rreplace(self):
        self.assertScriptResultEquals(r'''$rreplace(test \(disc 1\),\\s\\\(disc \\d+\\\),)''', "test")
        self.assertScriptResultEquals(r'''$rreplace(test,[t,)''', "test")

    def test_cmd_rsearch(self):
        self.assertScriptResultEquals(r"$rsearch(test \(disc 1\),\\\(disc \(\\d+\)\\\))", "1")
        self.assertScriptResultEquals(r"$rsearch(test \(disc 1\),\\\(disc \\d+\\\))", "(disc 1)")
        self.assertScriptResultEquals(r"$rsearch(test,x)", "")
        self.assertScriptResultEquals(r'''$rsearch(test,[t)''', "")

    def test_arguments(self):
        self.assertTrue(
            self.parser.eval(
                r"$set(bleh,$rsearch(test \(disc 1\),\\\(disc \(\\d+\)\\\)))) $set(wer,1)"))

    def test_cmd_gt(self):
        # Test with default processing
        self.assertScriptResultEquals("$gt(10,4)", "1")
        self.assertScriptResultEquals("$gt(6,6)", "")
        self.assertScriptResultEquals("$gt(6,7)", "")
        self.assertScriptResultEquals("$gt(6.5,4)", "1")
        self.assertScriptResultEquals("$gt(6.5,4.5)", "1")
        self.assertScriptResultEquals("$gt(6.5,6.5)", "")
        self.assertScriptResultEquals("$gt(a,b)", "")
        self.assertScriptResultEquals("$gt(b,a)", "1")
        self.assertScriptResultEquals("$gt(a,6)", "1")
        self.assertScriptResultEquals("$gt(a,6.5)", "1")
        self.assertScriptResultEquals("$gt(6,a)", "")
        self.assertScriptResultEquals("$gt(6.5,a)", "")

        # Test with "int" processing
        self.assertScriptResultEquals("$gt(10,4,int)", "1")
        self.assertScriptResultEquals("$gt(6,4,int)", "1")
        self.assertScriptResultEquals("$gt(6.5,4,int)", "")
        self.assertScriptResultEquals("$gt(6,7,int)", "")
        self.assertScriptResultEquals("$gt(6,6,int)", "")
        self.assertScriptResultEquals("$gt(a,b,int)", "")

        # Test with "float" processing
        self.assertScriptResultEquals("$gt(1.2,1,float)", "1")
        self.assertScriptResultEquals("$gt(1.2,1.1,float)", "1")
        self.assertScriptResultEquals("$gt(1.2,1.3,float)", "")
        self.assertScriptResultEquals("$gt(1.2,1.2,float)", "")
        self.assertScriptResultEquals("$gt(a,b,float)", "")

        # Test date type arguments with "text" processing
        self.assertScriptResultEquals("$gt(2020-01-01,2020-01-02,text)", "")
        self.assertScriptResultEquals("$gt(2020-01-02,2020-01-01,text)", "1")
        self.assertScriptResultEquals("$gt(2020-01-01,2020-02,text)", "")
        self.assertScriptResultEquals("$gt(2020-02,2020-01-01,text)", "1")
        self.assertScriptResultEquals("$gt(2020-01-01,2020-01-01,text)", "")

        # Test text type arguments with "text" processing
        self.assertScriptResultEquals("$gt(abc,abcd,text)", "")
        self.assertScriptResultEquals("$gt(abcd,abc,text)", "1")
        self.assertScriptResultEquals("$gt(abc,ac,text)", "")
        self.assertScriptResultEquals("$gt(ac,abc,text)", "1")
        self.assertScriptResultEquals("$gt(abc,abc,text)", "")

        # Test with empty arguments (default processing)
        self.assertScriptResultEquals("$gt(,1)", "")
        self.assertScriptResultEquals("$gt(1,)", "1")
        self.assertScriptResultEquals("$gt(,)", "")

        # Test with empty arguments ("int" processing)
        self.assertScriptResultEquals("$gt(,1,int)", "")
        self.assertScriptResultEquals("$gt(1,,int)", "")
        self.assertScriptResultEquals("$gt(,,int)", "")

        # Test with empty arguments ("float" processing)
        self.assertScriptResultEquals("$gt(,1.1,float)", "")
        self.assertScriptResultEquals("$gt(1.1,float)", "")
        self.assertScriptResultEquals("$gt(,,float)", "")

        # Test with empty arguments ("text" processing)
        self.assertScriptResultEquals("$gt(,a,text)", "")
        self.assertScriptResultEquals("$gt(a,,text)", "1")
        self.assertScriptResultEquals("$gt(,,text)", "")

        # Test case sensitive arguments ("text" processing)
        self.assertScriptResultEquals("$gt(A,a,text)", "")
        self.assertScriptResultEquals("$gt(a,A,text)", "1")

        # Test case insensitive arguments ("nocase" processing)
        self.assertScriptResultEquals("$gt(a,B,nocase)", "")
        self.assertScriptResultEquals("$gt(A,b,nocase)", "")
        self.assertScriptResultEquals("$gt(B,a,nocase)", "1")
        self.assertScriptResultEquals("$gt(b,A,nocase)", "1")

        # Test unknown processing type
        self.assertScriptResultEquals("$gt(2,1,unknown)", "")

        # Tests with invalid number of arguments
        areg = r"^\d+:\d+:\$gt: Wrong number of arguments for \$gt: Expected between 2 and 3, "
        with self.assertRaisesRegex(ScriptError, areg):
            self.parser.eval("$gt()")
        with self.assertRaisesRegex(ScriptError, areg):
            self.parser.eval("$gt(1)")
        with self.assertRaisesRegex(ScriptError, areg):
            self.parser.eval("$gt(foo,bar,text,)")

    def test_cmd_gte(self):
        # Test with default processing
        self.assertScriptResultEquals("$gte(10,9)", "1")
        self.assertScriptResultEquals("$gte(10,10)", "1")
        self.assertScriptResultEquals("$gte(10,11)", "")
        self.assertScriptResultEquals("$gte(10.1,10)", "1")
        self.assertScriptResultEquals("$gte(10.1,10.1)", "1")
        self.assertScriptResultEquals("$gte(10.1,10.2)", "")
        self.assertScriptResultEquals("$gte(a,b)", "")
        self.assertScriptResultEquals("$gte(b,a)", "1")
        self.assertScriptResultEquals("$gte(a,a)", "1")
        self.assertScriptResultEquals("$gte(a,6)", "1")
        self.assertScriptResultEquals("$gte(a,6.5)", "1")
        self.assertScriptResultEquals("$gte(6,a)", "")
        self.assertScriptResultEquals("$gte(6.5,a)", "")

        # Test with "int" processing
        self.assertScriptResultEquals("$gte(10,10.1,int)", "")
        self.assertScriptResultEquals("$gte(10,10,int)", "1")
        self.assertScriptResultEquals("$gte(10,4,int)", "1")
        self.assertScriptResultEquals("$gte(6,4,int)", "1")
        self.assertScriptResultEquals("$gte(6,7,int)", "")
        self.assertScriptResultEquals("$gte(a,b,int)", "")

        # Test with "float" processing
        self.assertScriptResultEquals("$gte(10.2,10.1,float)", "1")
        self.assertScriptResultEquals("$gte(10.2,10.2,float)", "1")
        self.assertScriptResultEquals("$gte(6,4,float)", "1")
        self.assertScriptResultEquals("$gte(10,10.1,float)", "")
        self.assertScriptResultEquals("$gte(10.2,10.3,float)", "")
        self.assertScriptResultEquals("$gte(6,7,float)", "")
        self.assertScriptResultEquals("$gte(a,b,float)", "")

        # Test date type arguments ("text" processing)
        self.assertScriptResultEquals("$gte(2020-01-01,2020-01-02,text)", "")
        self.assertScriptResultEquals("$gte(2020-01-02,2020-01-01,text)", "1")
        self.assertScriptResultEquals("$gte(2020-01-01,2020-02,text)", "")
        self.assertScriptResultEquals("$gte(2020-02,2020-01-01,text)", "1")
        self.assertScriptResultEquals("$gte(2020-01-01,2020-01-01,text)", "1")

        # Test text type arguments ("text" processing)
        self.assertScriptResultEquals("$gte(abc,abcd,text)", "")
        self.assertScriptResultEquals("$gte(abcd,abc,text)", "1")
        self.assertScriptResultEquals("$gte(abc,ac,text)", "")
        self.assertScriptResultEquals("$gte(ac,abc,text)", "1")
        self.assertScriptResultEquals("$gte(abc,abc,text)", "1")

        # Test with empty arguments (default processing)
        self.assertScriptResultEquals("$gte(,1)", "")
        self.assertScriptResultEquals("$gte(1,)", "1")
        self.assertScriptResultEquals("$gte(,)", "1")

        # Test with empty arguments ("int" processing)
        self.assertScriptResultEquals("$gte(,1,int)", "")
        self.assertScriptResultEquals("$gte(1,,int)", "")
        self.assertScriptResultEquals("$gte(,,int)", "")

        # Test with empty arguments ("float" processing)
        self.assertScriptResultEquals("$gte(,1,float)", "")
        self.assertScriptResultEquals("$gte(1,float)", "")
        self.assertScriptResultEquals("$gte(,,float)", "")

        # Test with empty arguments ("text" processing)
        self.assertScriptResultEquals("$gte(,a,text)", "")
        self.assertScriptResultEquals("$gte(a,,text)", "1")
        self.assertScriptResultEquals("$gte(,,text)", "1")

        # Test case sensitive arguments ("text" processing)
        self.assertScriptResultEquals("$gte(A,a,text)", "")
        self.assertScriptResultEquals("$gte(a,A,text)", "1")

        # Test case insensitive arguments ("nocase" processing)
        self.assertScriptResultEquals("$gte(a,B,nocase)", "")
        self.assertScriptResultEquals("$gte(A,b,nocase)", "")
        self.assertScriptResultEquals("$gte(B,a,nocase)", "1")
        self.assertScriptResultEquals("$gte(b,A,nocase)", "1")
        self.assertScriptResultEquals("$gte(a,A,nocase)", "1")
        self.assertScriptResultEquals("$gte(A,a,nocase)", "1")

        # Test unknown processing type
        self.assertScriptResultEquals("$gte(2,1,unknown)", "")

        # Tests with invalid number of arguments
        areg = r"^\d+:\d+:\$gte: Wrong number of arguments for \$gte: Expected between 2 and 3, "
        with self.assertRaisesRegex(ScriptError, areg):
            self.parser.eval("$gte()")
        with self.assertRaisesRegex(ScriptError, areg):
            self.parser.eval("$gte(1)")
        with self.assertRaisesRegex(ScriptError, areg):
            self.parser.eval("$gte(foo,bar,text,)")

    def test_cmd_lt(self):
        # Test with default processing
        self.assertScriptResultEquals("$lt(10,4)", "")
        self.assertScriptResultEquals("$lt(6,6)", "")
        self.assertScriptResultEquals("$lt(6,7)", "1")
        self.assertScriptResultEquals("$lt(6.5,4)", "")
        self.assertScriptResultEquals("$lt(6.5,4.5)", "")
        self.assertScriptResultEquals("$lt(6.5,6.5)", "")
        self.assertScriptResultEquals("$lt(6.5,6.6)", "1")
        self.assertScriptResultEquals("$lt(a,b)", "1")
        self.assertScriptResultEquals("$lt(b,a)", "")
        self.assertScriptResultEquals("$lt(a,6)", "")
        self.assertScriptResultEquals("$lt(a,6.5)", "")
        self.assertScriptResultEquals("$lt(6,a)", "1")
        self.assertScriptResultEquals("$lt(6.5,a)", "1")

        # Test with "int" processing
        self.assertScriptResultEquals("$lt(4,6,int)", "1")
        self.assertScriptResultEquals("$lt(4,6.1,int)", "")
        self.assertScriptResultEquals("$lt(4,3,int)", "")
        self.assertScriptResultEquals("$lt(4,4.1,int)", "")
        self.assertScriptResultEquals("$lt(4.1,4.2,int)", "")
        self.assertScriptResultEquals("$lt(4,4,int)", "")
        self.assertScriptResultEquals("$lt(a,b,int)", "")

        # Test with "float" processing
        self.assertScriptResultEquals("$lt(4,4.1,float)", "1")
        self.assertScriptResultEquals("$lt(4.1,4.2,float)", "1")
        self.assertScriptResultEquals("$lt(4,6,float)", "1")
        self.assertScriptResultEquals("$lt(4.2,4.1,float)", "")
        self.assertScriptResultEquals("$lt(4.1,4.1,float)", "")
        self.assertScriptResultEquals("$lt(a,b,float)", "")

        # Test date type arguments ("text" processing)
        self.assertScriptResultEquals("$lt(2020-01-01,2020-01-02,text)", "1")
        self.assertScriptResultEquals("$lt(2020-01-02,2020-01-01,text)", "")
        self.assertScriptResultEquals("$lt(2020-01-01,2020-02,text)", "1")
        self.assertScriptResultEquals("$lt(2020-02,2020-01-01,text)", "")
        self.assertScriptResultEquals("$lt(2020-01-01,2020-01-01,text)", "")

        # Test text type arguments ("text" processing)
        self.assertScriptResultEquals("$lt(abc,abcd,text)", "1")
        self.assertScriptResultEquals("$lt(abcd,abc,text)", "")
        self.assertScriptResultEquals("$lt(abc,ac,text)", "1")
        self.assertScriptResultEquals("$lt(ac,abc,text)", "")
        self.assertScriptResultEquals("$lt(abc,abc,text)", "")

        # Test with empty arguments (default processing)
        self.assertScriptResultEquals("$lt(,1)", "1")
        self.assertScriptResultEquals("$lt(1,)", "")
        self.assertScriptResultEquals("$lt(,)", "")

        # Test with empty arguments ("int" processing)
        self.assertScriptResultEquals("$lt(,1,int)", "")
        self.assertScriptResultEquals("$lt(1,,int)", "")
        self.assertScriptResultEquals("$lt(,,int)", "")

        # Test with empty arguments ("float" processing)
        self.assertScriptResultEquals("$lt(,1,float)", "")
        self.assertScriptResultEquals("$lt(1,,float)", "")
        self.assertScriptResultEquals("$lt(,,float)", "")

        # Test with empty arguments ("text" processing)
        self.assertScriptResultEquals("$lt(,a,text)", "1")
        self.assertScriptResultEquals("$lt(a,,text)", "")
        self.assertScriptResultEquals("$lt(,,text)", "")

        # Test case sensitive arguments ("text" processing)
        self.assertScriptResultEquals("$lt(A,a,text)", "1")
        self.assertScriptResultEquals("$lt(a,A,text)", "")

        # Test case insensitive arguments ("nocase" processing)
        self.assertScriptResultEquals("$lt(a,B,nocase)", "1")
        self.assertScriptResultEquals("$lt(A,b,nocase)", "1")
        self.assertScriptResultEquals("$lt(B,a,nocase)", "")
        self.assertScriptResultEquals("$lt(b,A,nocase)", "")

        # Test unknown processing type
        self.assertScriptResultEquals("$lt(1,2,unknown)", "")

        # Tests with invalid number of arguments
        areg = r"^\d+:\d+:\$lt: Wrong number of arguments for \$lt: Expected between 2 and 3, "
        with self.assertRaisesRegex(ScriptError, areg):
            self.parser.eval("$lt()")
        with self.assertRaisesRegex(ScriptError, areg):
            self.parser.eval("$lt(1)")
        with self.assertRaisesRegex(ScriptError, areg):
            self.parser.eval("$lt(foo,bar,text,)")

    def test_cmd_lte(self):
        # Test with default processing
        self.assertScriptResultEquals("$lte(10,4)", "")
        self.assertScriptResultEquals("$lte(6,6)", "1")
        self.assertScriptResultEquals("$lte(6,7)", "1")
        self.assertScriptResultEquals("$lte(6.5,4)", "")
        self.assertScriptResultEquals("$lte(6.5,4.5)", "")
        self.assertScriptResultEquals("$lte(6.5,6.5)", "1")
        self.assertScriptResultEquals("$lte(6.5,6.6)", "1")
        self.assertScriptResultEquals("$lte(a,b)", "1")
        self.assertScriptResultEquals("$lte(a,a)", "1")
        self.assertScriptResultEquals("$lte(b,a)", "")
        self.assertScriptResultEquals("$lte(a,6)", "")
        self.assertScriptResultEquals("$lte(a,6.5)", "")
        self.assertScriptResultEquals("$lte(6,a)", "1")
        self.assertScriptResultEquals("$lte(6.5,a)", "1")

        # Test with "int" processing
        self.assertScriptResultEquals("$lte(10,10,int)", "1")
        self.assertScriptResultEquals("$lte(10.1,10.2,int)", "")
        self.assertScriptResultEquals("$lte(4,10,int)", "1")
        self.assertScriptResultEquals("$lte(4,3,int)", "")
        self.assertScriptResultEquals("$lte(a,b,int)", "")

        # Test with "float" processing
        self.assertScriptResultEquals("$lte(10,10,float)", "1")
        self.assertScriptResultEquals("$lte(10.1,10.1,float)", "1")
        self.assertScriptResultEquals("$lte(10.1,10.2,float)", "1")
        self.assertScriptResultEquals("$lte(10.2,10.1,float)", "")
        self.assertScriptResultEquals("$lte(4,3,float)", "")
        self.assertScriptResultEquals("$lte(a,b,float)", "")

        # Test date type arguments ("text" processing)
        self.assertScriptResultEquals("$lte(2020-01-01,2020-01-02,text)", "1")
        self.assertScriptResultEquals("$lte(2020-01-02,2020-01-01,text)", "")
        self.assertScriptResultEquals("$lte(2020-01-01,2020-02,text)", "1")
        self.assertScriptResultEquals("$lte(2020-02,2020-01-01,text)", "")
        self.assertScriptResultEquals("$lte(2020-01-01,2020-01-01,text)", "1")

        # Test text type arguments ("text" processing)
        self.assertScriptResultEquals("$lte(abc,abcd,text)", "1")
        self.assertScriptResultEquals("$lte(abcd,abc,text)", "")
        self.assertScriptResultEquals("$lte(abc,ac,text)", "1")
        self.assertScriptResultEquals("$lte(ac,abc,text)", "")
        self.assertScriptResultEquals("$lte(abc,abc,text)", "1")

        # Test with empty arguments (default processing)
        self.assertScriptResultEquals("$lte(,1)", "1")
        self.assertScriptResultEquals("$lte(1,)", "")
        self.assertScriptResultEquals("$lte(,)", "1")

        # Test with empty arguments ("int" processing)
        self.assertScriptResultEquals("$lte(,1,int)", "")
        self.assertScriptResultEquals("$lte(1,,int)", "")
        self.assertScriptResultEquals("$lte(,,int)", "")

        # Test with empty arguments ("float" processing)
        self.assertScriptResultEquals("$lte(,1,float)", "")
        self.assertScriptResultEquals("$lte(1,,float)", "")
        self.assertScriptResultEquals("$lte(,,float)", "")

        # Test with empty arguments ("text" processing)
        self.assertScriptResultEquals("$lte(,a,text)", "1")
        self.assertScriptResultEquals("$lte(a,,text)", "")
        self.assertScriptResultEquals("$lte(,,text)", "1")

        # Test case sensitive arguments ("text" processing)
        self.assertScriptResultEquals("$lte(A,a,text)", "1")
        self.assertScriptResultEquals("$lte(a,A,text)", "")

        # Test case insensitive arguments ("nocase" processing)
        self.assertScriptResultEquals("$lte(a,B,nocase)", "1")
        self.assertScriptResultEquals("$lte(A,b,nocase)", "1")
        self.assertScriptResultEquals("$lte(B,a,nocase)", "")
        self.assertScriptResultEquals("$lte(b,A,nocase)", "")
        self.assertScriptResultEquals("$lte(a,A,nocase)", "1")
        self.assertScriptResultEquals("$lte(A,a,nocase)", "1")

        # Test unknown processing type
        self.assertScriptResultEquals("$lte(1,2,unknown)", "")

        # Tests with invalid number of arguments
        areg = r"^\d+:\d+:\$lte: Wrong number of arguments for \$lte: Expected between 2 and 3, "
        with self.assertRaisesRegex(ScriptError, areg):
            self.parser.eval("$lte()")
        with self.assertRaisesRegex(ScriptError, areg):
            self.parser.eval("$lte(1)")
        with self.assertRaisesRegex(ScriptError, areg):
            self.parser.eval("$lte(foo,bar,text,)")

    def test_cmd_len(self):
        self.assertScriptResultEquals("$len(abcdefg)", "7")
        self.assertScriptResultEquals("$len(0)", "1")
        self.assertScriptResultEquals("$len()", "0")

    def test_cmd_firstalphachar(self):
        self.assertScriptResultEquals("$firstalphachar(abc)", "A")
        self.assertScriptResultEquals("$firstalphachar(Abc)", "A")
        self.assertScriptResultEquals("$firstalphachar(1abc)", "#")
        self.assertScriptResultEquals("$firstalphachar(...abc)", "#")
        self.assertScriptResultEquals("$firstalphachar(1abc,_)", "_")
        self.assertScriptResultEquals("$firstalphachar(...abc,_)", "_")
        self.assertScriptResultEquals("$firstalphachar()", "#")
        self.assertScriptResultEquals("$firstalphachar(,_)", "_")
        self.assertScriptResultEquals("$firstalphachar( abc)", "#")

    def test_cmd_initials(self):
        self.assertScriptResultEquals("$initials(Abc def Ghi)", "AdG")
        self.assertScriptResultEquals("$initials(Abc #def Ghi)", "AG")
        self.assertScriptResultEquals("$initials(Abc 1def Ghi)", "AG")
        self.assertScriptResultEquals("$initials(Abc)", "A")
        self.assertScriptResultEquals("$initials()", "")

    def test_cmd_firstwords(self):
        self.assertScriptResultEquals("$firstwords(Abc Def Ghi,11)", "Abc Def Ghi")
        self.assertScriptResultEquals("$firstwords(Abc Def Ghi,12)", "Abc Def Ghi")
        self.assertScriptResultEquals("$firstwords(Abc Def Ghi,7)", "Abc Def")
        self.assertScriptResultEquals("$firstwords(Abc Def Ghi,8)", "Abc Def")
        self.assertScriptResultEquals("$firstwords(Abc Def Ghi,6)", "Abc")
        self.assertScriptResultEquals("$firstwords(Abc Def Ghi,0)", "")
        self.assertScriptResultEquals("$firstwords(Abc Def Ghi,NaN)", "")
        self.assertScriptResultEquals("$firstwords(Abc Def Ghi,)", "")
        self.assertScriptResultEquals("$firstwords(Abc Def Ghi,-2)", "Abc Def")
        self.assertScriptResultEquals("$firstwords(Abc Def Ghi,-50)", "")

    def test_cmd_startswith(self):
        self.assertScriptResultEquals("$startswith(abc,a)", "1")
        self.assertScriptResultEquals("$startswith(abc,abc)", "1")
        self.assertScriptResultEquals("$startswith(abc,)", "1")
        self.assertScriptResultEquals("$startswith(abc,b)", "")
        self.assertScriptResultEquals("$startswith(abc,Ab)", "")

    def test_cmd_endswith(self):
        self.assertScriptResultEquals("$endswith(abc,c)", "1")
        self.assertScriptResultEquals("$endswith(abc,abc)", "1")
        self.assertScriptResultEquals("$endswith(abc,)", "1")
        self.assertScriptResultEquals("$endswith(abc,b)", "")
        self.assertScriptResultEquals("$endswith(abc,bC)", "")

    def test_cmd_truncate(self):
        self.assertScriptResultEquals("$truncate(abcdefg,0)", "")
        self.assertScriptResultEquals("$truncate(abcdefg,7)", "abcdefg")
        self.assertScriptResultEquals("$truncate(abcdefg,3)", "abc")
        self.assertScriptResultEquals("$truncate(abcdefg,10)", "abcdefg")
        self.assertScriptResultEquals("$truncate(abcdefg,)", "abcdefg")
        self.assertScriptResultEquals("$truncate(abcdefg,NaN)", "abcdefg")

    def test_cmd_copy(self):
        context = Metadata()
        tagsToCopy = ["tag1", "tag2"]
        context["source"] = tagsToCopy
        context["target"] = ["will", "be", "overwritten"]
        self.parser.eval("$copy(target,source)", context)
        self.assertEqual(self.parser.context.getall("target"), tagsToCopy)

    def _eval_and_check_copymerge(self, context, expected):
        self.parser.eval("$copymerge(target,source)", context)
        self.assertEqual(self.parser.context.getall("target"), expected)

    def test_cmd_copymerge_notarget(self):
        context = Metadata()
        tagsToCopy = ["tag1", "tag2"]
        context["source"] = tagsToCopy
        self._eval_and_check_copymerge(context, tagsToCopy)

    def test_cmd_copymerge_nosource(self):
        context = Metadata()
        target = ["tag1", "tag2"]
        context["target"] = target
        self._eval_and_check_copymerge(context, target)

    def test_cmd_copymerge_removedupes(self):
        context = Metadata()
        context["target"] = ["tag1", "tag2", "tag1"]
        context["source"] = ["tag2", "tag3", "tag2"]
        self._eval_and_check_copymerge(context, ["tag1", "tag2", "tag3"])

    def test_cmd_copymerge_nonlist(self):
        context = Metadata()
        context["target"] = "targetval"
        context["source"] = "sourceval"
        self._eval_and_check_copymerge(context, ["targetval", "sourceval"])

    def test_cmd_copymerge_empty_keepdupes(self):
        context = Metadata()
        context["target"] = ["tag1", "tag2", "tag1"]
        context["source"] = ["tag2", "tag3", "tag2"]
        self.parser.eval("$copymerge(target,source,)", context)
        self.assertEqual(self.parser.context.getall("target"), ["tag1", "tag2", "tag3"])

    def test_cmd_copymerge_keepdupes(self):
        context = Metadata()
        context["target"] = ["tag1", "tag2", "tag1"]
        context["source"] = ["tag2", "tag3", "tag2"]
        self.parser.eval("$copymerge(target,source,keep)", context)
        self.assertEqual(self.parser.context.getall("target"), ["tag1", "tag2", "tag1", "tag2", "tag3", "tag2"])

    def test_cmd_copymerge_nonlist_keepdupes(self):
        context = Metadata()
        context["target"] = "targetval"
        context["source"] = "targetval"
        self.parser.eval("$copymerge(target,source,keep)", context)
        self.assertEqual(self.parser.context.getall("target"), ["targetval", "targetval"])

    def test_cmd_eq_any(self):
        self.assertScriptResultEquals("$eq_any(abc,def,ghi,jkl)", "")
        self.assertScriptResultEquals("$eq_any(abc,def,ghi,jkl,abc)", "1")

    def test_cmd_ne_all(self):
        self.assertScriptResultEquals("$ne_all(abc,def,ghi,jkl)", "1")
        self.assertScriptResultEquals("$ne_all(abc,def,ghi,jkl,abc)", "")

    def test_cmd_eq_all(self):
        self.assertScriptResultEquals("$eq_all(abc,abc,abc,abc)", "1")
        self.assertScriptResultEquals("$eq_all(abc,abc,def,ghi)", "")

    def test_cmd_ne_any(self):
        self.assertScriptResultEquals("$ne_any(abc,abc,abc,abc)", "")
        self.assertScriptResultEquals("$ne_any(abc,abc,def,ghi)", "1")

    def test_cmd_title(self):
        self.assertScriptResultEquals("$title(abc Def g)", "Abc Def G")
        self.assertScriptResultEquals("$title(Abc Def G)", "Abc Def G")
        self.assertScriptResultEquals("$title(abc def g)", "Abc Def G")
        self.assertScriptResultEquals("$title(#1abc 4def - g)", "#1abc 4def - G")
        self.assertScriptResultEquals(r"$title(abcd \(efg hi jkl mno\))", "Abcd (Efg Hi Jkl Mno)")
        self.assertScriptResultEquals("$title(...abcd)", "...Abcd")
        self.assertScriptResultEquals("$title(a)", "A")
        self.assertScriptResultEquals("$title(’a)", "’a")
        self.assertScriptResultEquals("$title('a)", "'a")
        self.assertScriptResultEquals("$title(l'a)", "L'a")
        self.assertScriptResultEquals("$title(2'a)", "2'A")
        self.assertScriptResultEquals(r"$title(%empty%)", "")
        # Tests wrong number of arguments
        areg = r"^\d+:\d+:\$title: Wrong number of arguments for \$title: Expected exactly 1, "
        with self.assertRaisesRegex(ScriptError, areg):
            self.parser.eval("$title()")

    def test_cmd_swapprefix(self):
        self.assertScriptResultEquals("$swapprefix(A stitch in time)", "stitch in time, A")
        self.assertScriptResultEquals("$swapprefix(The quick brown fox)", "quick brown fox, The")
        self.assertScriptResultEquals("$swapprefix(How now brown cow)", "How now brown cow")
        self.assertScriptResultEquals("$swapprefix(When the red red robin)", "When the red red robin")
        self.assertScriptResultEquals("$swapprefix(A stitch in time,How,When,Who)", "A stitch in time")
        self.assertScriptResultEquals("$swapprefix(The quick brown fox,How,When,Who)", "The quick brown fox")
        self.assertScriptResultEquals("$swapprefix(How now brown cow,How,When,Who)", "now brown cow, How")
        self.assertScriptResultEquals("$swapprefix(When the red red robin,How,When,Who)", "the red red robin, When")

    def test_cmd_delprefix(self):
        self.assertScriptResultEquals("$delprefix(A stitch in time)", "stitch in time")
        self.assertScriptResultEquals("$delprefix(The quick brown fox)", "quick brown fox")
        self.assertScriptResultEquals("$delprefix(How now brown cow)", "How now brown cow")
        self.assertScriptResultEquals("$delprefix(When the red red robin)", "When the red red robin")
        self.assertScriptResultEquals("$delprefix(A stitch in time,How,When,Who)", "A stitch in time")
        self.assertScriptResultEquals("$delprefix(The quick brown fox,How,When,Who)", "The quick brown fox")
        self.assertScriptResultEquals("$delprefix(How now brown cow,How,When,Who)", "now brown cow")
        self.assertScriptResultEquals("$delprefix(When the red red robin,How,When,Who)", "the red red robin")

    def test_default_filenaming(self):
        context = Metadata()
        context['albumartist'] = 'albumartist'
        context['artist'] = 'artist'
        context['album'] = 'album'
        context['totaldiscs'] = 2
        context['discnumber'] = 1
        context['tracknumber'] = 8
        context['title'] = 'title'
        result = self.parser.eval(DEFAULT_FILE_NAMING_FORMAT, context)
        self.assertEqual(result, 'albumartist/\nalbum/\n1-08 title')
        context['~multiartist'] = '1'
        result = self.parser.eval(DEFAULT_FILE_NAMING_FORMAT, context)
        self.assertEqual(result, 'albumartist/\nalbum/\n1-08 artist - title')

    def test_default_NAT_filenaming(self):
        context = Metadata()
        context['artist'] = 'artist'
        context['album'] = '[standalone recordings]'
        context['title'] = 'title'
        result = self.parser.eval(DEFAULT_FILE_NAMING_FORMAT, context)
        self.assertEqual(result, 'artist/\n\ntitle')

    def test_cmd_with_not_arguments(self):
        def func_noargstest(parser):
            return ""

        register_script_function(func_noargstest, "noargstest")
        self.parser.eval("$noargstest()")

    def test_cmd_with_wrong_argcount_or(self):
        # $or() requires at least 2 arguments
        areg = r"^\d+:\d+:\$or: Wrong number of arguments for \$or: Expected at least 2, "
        with self.assertRaisesRegex(ScriptError, areg):
            self.parser.eval('$or(0)')

    def test_cmd_with_wrong_argcount_eq(self):
        # $eq() requires exactly 2 arguments
        areg = r"^\d+:\d+:\$eq: Wrong number of arguments for \$eq: Expected exactly 2, "
        with self.assertRaisesRegex(ScriptError, areg):
            self.parser.eval('$eq(0)')
        with self.assertRaisesRegex(ScriptError, areg):
            self.parser.eval('$eq(0,0,0)')

    def test_cmd_with_wrong_argcount_if(self):
        areg = r"^\d+:\d+:\$if: Wrong number of arguments for \$if: Expected between 2 and 3, "
        # $if() requires 2 or 3 arguments
        with self.assertRaisesRegex(ScriptError, areg):
            self.parser.eval('$if(1)')
        with self.assertRaisesRegex(ScriptError, areg):
            self.parser.eval('$if(1,a,b,c)')

    def test_cmd_unset_simple(self):
        context = Metadata()
        context['title'] = 'Foo'
        context['album'] = 'Foo'
        context['artist'] = 'Foo'
        self.parser.eval("$unset(album)", context)
        self.assertNotIn('album', context)

    def test_cmd_unset_prefix(self):
        context = Metadata()
        context['title'] = 'Foo'
        context['~rating'] = '4'
        self.parser.eval("$unset(_rating)", context)
        self.assertNotIn('~rating', context)

    def test_cmd_unset_multi(self):
        context = Metadata()
        context['performer:foo'] = 'Foo'
        context['performer:bar'] = 'Foo'
        self.parser.eval("$unset(performer:*)", context)
        self.assertNotIn('performer:bar', context)
        self.assertNotIn('performer:foo', context)

    def test_cmd_unset(self):
        context = Metadata()
        context['title'] = 'Foo'
        self.parser.eval("$unset(title)", context)
        self.assertNotIn('title', context)
        self.assertNotIn('title', context.deleted_tags)

    def test_cmd_delete(self):
        context = Metadata()
        context['title'] = 'Foo'
        self.parser.eval("$delete(title)", context)
        self.assertNotIn('title', context)
        self.assertIn('title', context.deleted_tags)

    def test_cmd_inmulti(self):
        context = Metadata()

        # Test with single-value string
        context["foo"] = "First:A; Second:B; Third:C"
        # Tests with $in for comparison purposes
        self.assertScriptResultEquals("$in(%foo%,Second:B)", "1", context)
        self.assertScriptResultEquals("$in(%foo%,irst:A; Second:B; Thi)", "1", context)
        self.assertScriptResultEquals("$in(%foo%,First:A; Second:B; Third:C)", "1", context)
        # Base $inmulti tests
        self.assertScriptResultEquals("$inmulti(%foo%,Second:B)", "", context)
        self.assertScriptResultEquals("$inmulti(%foo%,irst:A; Second:B; Thi)", "", context)
        self.assertScriptResultEquals("$inmulti(%foo%,First:A; Second:B; Third:C)", "1", context)
        # Test separator override but with existing separator - results should be same as base
        self.assertScriptResultEquals("$inmulti(%foo%,Second:B,; )", "", context)
        self.assertScriptResultEquals("$inmulti(%foo%,irst:A; Second:B; Thi,; )", "", context)
        self.assertScriptResultEquals("$inmulti(%foo%,First:A; Second:B; Third:C,; )", "1", context)
        # Test separator override
        self.assertScriptResultEquals("$inmulti(%foo%,First:A,:)", "", context)
        self.assertScriptResultEquals("$inmulti(%foo%,Second:B,:)", "", context)
        self.assertScriptResultEquals("$inmulti(%foo%,Third:C,:)", "", context)
        self.assertScriptResultEquals("$inmulti(%foo%,First,:)", "1", context)
        self.assertScriptResultEquals("$inmulti(%foo%,A; Second,:)", "1", context)
        self.assertScriptResultEquals("$inmulti(%foo%,B; Third,:)", "1", context)
        self.assertScriptResultEquals("$inmulti(%foo%,C,:)", "1", context)
        # Test no separator
        self.assertScriptResultEquals("$inmulti(%foo%,First:A; Second:B; Third:C,)", "1", context)

        # Test with multi-values
        context["foo"] = ["First:A", "Second:B", "Third:C"]
        # Tests with $in for comparison purposes
        self.assertScriptResultEquals("$in(%foo%,Second:B)", "1", context)
        self.assertScriptResultEquals("$in(%foo%,irst:A; Second:B; Thi)", "1", context)
        self.assertScriptResultEquals("$in(%foo%,First:A; Second:B; Third:C)", "1", context)
        # Base $inmulti tests
        self.assertScriptResultEquals("$inmulti(%foo%,Second:B)", "1", context)
        self.assertScriptResultEquals("$inmulti(%foo%,irst:A; Second:B; Thi)", "", context)
        self.assertScriptResultEquals("$inmulti(%foo%,First:A; Second:B; Third:C)", "", context)
        # Test separator override but with existing separator - results should be same as base
        self.assertScriptResultEquals("$inmulti(%foo%,Second:B,; )", "1", context)
        self.assertScriptResultEquals("$inmulti(%foo%,irst:A; Second:B; Thi,; )", "", context)
        self.assertScriptResultEquals("$inmulti(%foo%,First:A; Second:B; Third:C,; )", "", context)
        # Test separator override
        self.assertScriptResultEquals("$inmulti(%foo%,First:A,:)", "", context)
        self.assertScriptResultEquals("$inmulti(%foo%,Second:B,:)", "", context)
        self.assertScriptResultEquals("$inmulti(%foo%,Third:C,:)", "", context)
        self.assertScriptResultEquals("$inmulti(%foo%,First,:)", "1", context)
        self.assertScriptResultEquals("$inmulti(%foo%,A; Second,:)", "1", context)
        self.assertScriptResultEquals("$inmulti(%foo%,B; Third,:)", "1", context)
        self.assertScriptResultEquals("$inmulti(%foo%,C,:)", "1", context)
        # Test no separator
        self.assertScriptResultEquals("$inmulti(%foo%,First:A; Second:B; Third:C,)", "1", context)

    def test_cmd_lenmulti(self):
        context = Metadata()
        context["foo"] = "First:A; Second:B; Third:C"
        context["bar"] = ["First:A", "Second:B", "Third:C"]
        # Tests with $len for comparison purposes
        self.assertScriptResultEquals("$len(%foo%)", "26", context)
        self.assertScriptResultEquals("$len(%bar%)", "26", context)
        # Base $lenmulti tests
        self.assertScriptResultEquals("$lenmulti(%foo%)", "1", context)
        self.assertScriptResultEquals("$lenmulti(%bar%)", "3", context)
        self.assertScriptResultEquals("$lenmulti(%foo%.)", "3", context)
        # Test separator override but with existing separator - results should be same as base
        self.assertScriptResultEquals("$lenmulti(%foo%,; )", "1", context)
        self.assertScriptResultEquals("$lenmulti(%bar%,; )", "3", context)
        self.assertScriptResultEquals("$lenmulti(%foo%.,; )", "3", context)
        # Test separator override
        self.assertScriptResultEquals("$lenmulti(%foo%,:)", "4", context)
        self.assertScriptResultEquals("$lenmulti(%bar%,:)", "4", context)
        self.assertScriptResultEquals("$lenmulti(%foo%.,:)", "4", context)
        # Test no separator
        self.assertScriptResultEquals("$lenmulti(%foo%,)", "1", context)
        self.assertScriptResultEquals("$lenmulti(%bar%,)", "1", context)
        # Test blank name
        context["baz"] = ""
        self.assertScriptResultEquals("$lenmulti(%baz%)", "0", context)
        self.assertScriptResultEquals("$lenmulti(%baz%,:)", "0", context)
        # Test empty multi-value
        context["baz"] = []
        self.assertScriptResultEquals("$lenmulti(%baz%)", "0", context)
        self.assertScriptResultEquals("$lenmulti(%baz%,:)", "0", context)
        # Test empty multi-value elements
        context["baz"] = ["one", "", "three"]
        self.assertScriptResultEquals("$lenmulti(%baz%)", "3", context)
        # Test missing name
        self.assertScriptResultEquals("$lenmulti(,)", "0", context)
        self.assertScriptResultEquals("$lenmulti(,:)", "0", context)

    def test_cmd_performer(self):
        context = Metadata()
        context['performer:guitar'] = 'Foo1'
        context['performer:rhythm-guitar'] = ['Foo2', 'Foo3']
        context['performer:drums'] = 'Drummer'
        # Matches pattern
        result = self.parser.eval("$performer(guitar)", context=context)
        self.assertEqual({'Foo1', 'Foo2', 'Foo3'}, set(result.split(', ')))
        # Empty pattern returns all performers
        result = self.parser.eval("$performer()", context=context)
        self.assertEqual({'Foo1', 'Foo2', 'Foo3', 'Drummer'}, set(result.split(', ')))
        self.assertScriptResultEquals("$performer(perf)", "", context)

    def test_cmd_performer_regex(self):
        context = Metadata()
        context['performer:guitar'] = 'Foo1'
        context['performer:guitars'] = 'Foo2'
        context['performer:rhythm-guitar'] = 'Foo3'
        context['performer:drums (drum kit)'] = 'Drummer'
        result = self.parser.eval(r"$performer(/^guitar/)", context=context)
        self.assertEqual({'Foo1', 'Foo2'}, set(result.split(', ')))
        result = self.parser.eval(r"$performer(/^guitar\$/)", context=context)
        self.assertEqual({'Foo1'}, set(result.split(', ')))

    def test_cmd_performer_regex_invalid(self):
        context = Metadata()
        context['performer:drums (drum kit)'] = 'Drummer'
        self.assertScriptResultEquals(r"$performer(/drums \(/)", "", context)
        self.assertScriptResultEquals(r"$performer(drums \()", "Drummer", context)

    def test_cmd_performer_regex_ignore_case(self):
        context = Metadata()
        context['performer:guitar'] = 'Foo1'
        context['performer:GUITARS'] = 'Foo2'
        context['performer:rhythm-guitar'] = 'Foo3'
        result = self.parser.eval(r"$performer(/^guitars?/i)", context=context)
        self.assertEqual({'Foo1', 'Foo2'}, set(result.split(', ')))

    def test_cmd_performer_custom_join(self):
        context = Metadata()
        context['performer:guitar'] = 'Foo1'
        context['performer:rhythm-guitar'] = 'Foo2'
        context['performer:drums'] = 'Drummer'
        result = self.parser.eval("$performer(guitar, / )", context=context)
        self.assertEqual({'Foo1', 'Foo2'}, set(result.split(' / ')))

    def test_cmd_performer_multi_colons(self):
        context = Metadata()
        context['performer:CV:松井栞里'] = '仁奈(CV:大出千夏)'
        result = self.parser.eval("$performer(CV:松井栞里)", context=context)
        self.assertEqual('仁奈(CV:大出千夏)', result)

    def test_cmd_matchedtracks(self):
        file = MagicMock()
        file.parent.album.get_num_matched_tracks.return_value = 42
        self.assertScriptResultEquals("$matchedtracks()", "42", file=file)
        self.assertScriptResultEquals("$matchedtracks()", "0")
        # The following only is possible for backward compatibility, arg is unused
        self.assertScriptResultEquals("$matchedtracks(arg)", "0")

    def test_cmd_matchedtracks_with_cluster(self):
        file = MagicMock()
        cluster = Cluster(name="Test")
        cluster.files.append(file)
        file.parent = cluster
        self.assertScriptResultEquals("$matchedtracks()", "0", file=file)

    def test_cmd_is_complete(self):
        file = MagicMock()
        file.parent.album.is_complete.return_value = True
        self.assertScriptResultEquals("$is_complete()", "1", file=file)
        file.parent.album.is_complete.return_value = False
        self.assertScriptResultEquals("$is_complete()", "", file=file)
        self.assertScriptResultEquals("$is_complete()", "")

    def test_cmd_is_complete_with_cluster(self):
        file = MagicMock()
        cluster = Cluster(name="Test")
        cluster.files.append(file)
        file.parent = cluster
        self.assertScriptResultEquals("$is_complete()", "", file=file)

    def test_cmd_is_video(self):
        context = Metadata({'~video': '1'})
        self.assertScriptResultEquals("$is_video()", "1", context=context)
        context = Metadata({'~video': '0'})
        self.assertScriptResultEquals("$is_video()", "", context=context)
        self.assertScriptResultEquals("$is_video()", "")

    def test_cmd_is_audio(self):
        context = Metadata({'~video': '1'})
        self.assertScriptResultEquals("$is_audio()", "", context=context)
        context = Metadata({'~video': '0'})
        self.assertScriptResultEquals("$is_audio()", "1", context=context)
        self.assertScriptResultEquals("$is_audio()", "1")

    def test_required_kwonly_parameters(self):
        def func(a, *, required_kwarg):
            pass

        with self.assertRaises(TypeError,
                               msg="Functions with required keyword-only parameters are not supported"):
            register_script_function(func)

    @staticmethod
    def test_optional_kwonly_parameters():
        def func(a, *, optional_kwarg=1):
            pass
        register_script_function(func)

    def test_char_escape(self):
        self.assertScriptResultEquals(r"\n\t\$\%\(\)\,\\", "\n\t$%(),\\")

    def test_char_escape_unexpected_char(self):
        self.assertRaises(ScriptSyntaxError, self.parser.eval, r'\x')

    def test_char_escape_end_of_file(self):
        self.assertRaises(ScriptEndOfFile, self.parser.eval, 'foo\\')

    def test_raise_unknown_function(self):
        self.assertRaises(ScriptUnknownFunction, self.parser.eval, '$unknownfn()')

    def test_raise_end_of_file(self):
        self.assertRaises(ScriptEndOfFile, self.parser.eval, '$noop(')
        self.assertRaises(ScriptEndOfFile, self.parser.eval, '%var')

    def test_raise_syntax_error(self):
        self.assertRaises(ScriptSyntaxError, self.parser.eval, '%var()%')
        self.assertRaises(ScriptSyntaxError, self.parser.eval, '$noop(()')
        self.assertRaises(ScriptSyntaxError, self.parser.eval, r'\x')

    def test_cmd_find(self):
        context = Metadata()
        context["foo"] = "First:A; Second:B; Third:C"
        context["bar"] = ["First:A", "Second:B", "Third:C"]
        context["baz"] = "Second"
        context["err"] = "Forth"
        # Tests with context
        self.assertScriptResultEquals("$find(%foo%,%baz%)", "9", context)
        self.assertScriptResultEquals("$find(%bar%,%baz%)", "9", context)
        self.assertScriptResultEquals("$find(%foo%,%bar%)", "0", context)
        self.assertScriptResultEquals("$find(%bar%,%foo%)", "0", context)
        self.assertScriptResultEquals("$find(%foo%,%err%)", "", context)
        # Tests with static input
        self.assertScriptResultEquals("$find(abcdef,c)", "2", context)
        self.assertScriptResultEquals("$find(abcdef,cd)", "2", context)
        self.assertScriptResultEquals("$find(abcdef,g)", "", context)
        # Tests ends of string
        self.assertScriptResultEquals("$find(abcdef,a)", "0", context)
        self.assertScriptResultEquals("$find(abcdef,ab)", "0", context)
        self.assertScriptResultEquals("$find(abcdef,f)", "5", context)
        self.assertScriptResultEquals("$find(abcdef,ef)", "4", context)
        # Tests case sensitivity
        self.assertScriptResultEquals("$find(abcdef,C)", "", context)
        # Tests no characters processed as wildcards
        self.assertScriptResultEquals("$find(abcdef,.f)", "", context)
        self.assertScriptResultEquals("$find(abcdef,?f)", "", context)
        self.assertScriptResultEquals("$find(abcdef,*f)", "", context)
        self.assertScriptResultEquals("$find(abc.ef,cde)", "", context)
        self.assertScriptResultEquals("$find(abc?ef,cde)", "", context)
        self.assertScriptResultEquals("$find(abc*ef,cde)", "", context)
        # Tests missing inputs
        self.assertScriptResultEquals("$find(,c)", "", context)
        self.assertScriptResultEquals("$find(abcdef,)", "0", context)
        # Tests wrong number of arguments
        areg = r"^\d+:\d+:\$find: Wrong number of arguments for \$find: Expected exactly 2, "
        with self.assertRaisesRegex(ScriptError, areg):
            self.parser.eval("$find(abcdef)")

    def test_cmd_reverse(self):
        context = Metadata()
        context["foo"] = "One; Two; Three"
        context["bar"] = ["One", "Two", "Three"]
        # Tests with context
        self.assertScriptResultEquals("$reverse(%foo%)", "eerhT ;owT ;enO", context)
        self.assertScriptResultEquals("$reverse(%bar%)", "eerhT ;owT ;enO", context)
        # Tests with static input
        self.assertScriptResultEquals("$reverse(One; Two; Three)", "eerhT ;owT ;enO", context)
        # Tests with missing input
        areg = r"^\d+:\d+:\$reverse: Wrong number of arguments for \$reverse: Expected exactly 1, "
        with self.assertRaisesRegex(ScriptError, areg):
            self.parser.eval("$reverse()")

    def test_cmd_substr(self):
        context = Metadata()
        context["foo"] = "One; Two; Three"
        context["bar"] = ["One", "Two", "Three"]
        context["start"] = '5'
        context["end"] = '9'
        # Tests with context
        self.assertScriptResultEquals("$substr(%foo%,%start%,%end%)", "Two;", context)
        self.assertScriptResultEquals("$substr(%bar%,%start%,%end%)", "Two;", context)
        # Tests with static input
        self.assertScriptResultEquals("$substr(One; Two; Three,5,9)", "Two;", context)
        # Tests ends of string
        self.assertScriptResultEquals("$substr(One; Two; Three,0,4)", "One;", context)
        self.assertScriptResultEquals("$substr(One; Two; Three,10,15)", "Three", context)
        # Tests negative index inputs
        self.assertScriptResultEquals("$substr(One; Two; Three,-15,4)", "One;", context)
        self.assertScriptResultEquals("$substr(One; Two; Three,-5,15)", "Three", context)
        self.assertScriptResultEquals("$substr(One; Two; Three,-10,8)", "Two", context)
        self.assertScriptResultEquals("$substr(One; Two; Three,5,-7)", "Two", context)
        # Tests overrun ends of string
        self.assertScriptResultEquals("$substr(One; Two; Three,10,25)", "Three", context)
        self.assertScriptResultEquals("$substr(One; Two; Three,-25,4)", "One;", context)
        self.assertScriptResultEquals("$substr(One; Two; Three,-5,25)", "Three", context)
        # Tests invalid ranges (end < start, end = start)
        self.assertScriptResultEquals("$substr(One; Two; Three,10,9)", "", context)
        self.assertScriptResultEquals("$substr(One; Two; Three,10,10)", "", context)
        # Tests invalid index inputs
        self.assertScriptResultEquals("$substr(One; Two; Three,10-1,4)", "One;", context)
        self.assertScriptResultEquals("$substr(One; Two; Three,10,4+2)", "Three", context)
        self.assertScriptResultEquals("$substr(One; Two; Three,10-1,4+2)", "One; Two; Three", context)
        self.assertScriptResultEquals("$substr(One; Two; Three,a,4)", "One;", context)
        self.assertScriptResultEquals("$substr(One; Two; Three,0,b)", "One; Two; Three", context)
        self.assertScriptResultEquals("$substr(One; Two; Three,a,b)", "One; Two; Three", context)
        # # Tests with missing input
        self.assertScriptResultEquals("$substr(One; Two; Three,,4)", "One;", context)
        self.assertScriptResultEquals("$substr(One; Two; Three,10)", "Three", context)
        self.assertScriptResultEquals("$substr(One; Two; Three,10,)", "Three", context)
        self.assertScriptResultEquals("$substr(One; Two; Three,)", "One; Two; Three", context)
        self.assertScriptResultEquals("$substr(One; Two; Three,,)", "One; Two; Three", context)
        # Tests with missing input
        areg = r"^\d+:\d+:\$substr: Wrong number of arguments for \$substr: Expected between 2 and 3, "
        with self.assertRaisesRegex(ScriptError, areg):
            self.parser.eval("$substr()")
        with self.assertRaisesRegex(ScriptError, areg):
            self.parser.eval("$substr(abc)")
        with self.assertRaisesRegex(ScriptError, areg):
            self.parser.eval("$substr(abc,0,,)")

    def test_cmd_getmulti(self):
        context = Metadata()
        context["foo"] = ["First:A", "Second:B", "Third:C"]
        context["index"] = "1"
        # Tests with context
        self.assertScriptResultEquals("$getmulti(%foo%,%index%)", "Second:B", context)
        # Tests with static inputs
        self.assertScriptResultEquals("$getmulti(First:A; Second:B; Third:C,0)", "First:A", context)
        self.assertScriptResultEquals("$getmulti(First:A; Second:B; Third:C,1)", "Second:B", context)
        # Tests separator override
        self.assertScriptResultEquals("$getmulti(%foo%,1,:)", "A; Second", context)
        self.assertScriptResultEquals("$getmulti(First:A; Second:B; Third:C,1,:)", "A; Second", context)
        # Tests negative index values
        self.assertScriptResultEquals("$getmulti(First:A; Second:B; Third:C,-1)", "Third:C", context)
        self.assertScriptResultEquals("$getmulti(First:A; Second:B; Third:C,-2)", "Second:B", context)
        self.assertScriptResultEquals("$getmulti(First:A; Second:B; Third:C,-3)", "First:A", context)
        # Tests out of range index values
        self.assertScriptResultEquals("$getmulti(First:A; Second:B; Third:C,10)", "", context)
        self.assertScriptResultEquals("$getmulti(First:A; Second:B; Third:C,-4)", "", context)
        # Tests invalid index values
        self.assertScriptResultEquals("$getmulti(,0)", "", context)
        self.assertScriptResultEquals("$getmulti(First:A; Second:B; Third:C,)", "", context)
        self.assertScriptResultEquals("$getmulti(First:A; Second:B; Third:C,10+1)", "", context)
        self.assertScriptResultEquals("$getmulti(First:A; Second:B; Third:C,a)", "", context)
        # Tests with missing inputs
        self.assertScriptResultEquals("$getmulti(,0)", "", context)
        self.assertScriptResultEquals("$getmulti(First:A; Second:B; Third:C,)", "", context)
        # Tests with invalid number of arguments
        areg = r"^\d+:\d+:\$getmulti: Wrong number of arguments for \$getmulti: Expected between 2 and 3, "
        with self.assertRaisesRegex(ScriptError, areg):
            self.parser.eval("$getmulti()")
        with self.assertRaisesRegex(ScriptError, areg):
            self.parser.eval("$getmulti(abc)")
        with self.assertRaisesRegex(ScriptError, areg):
            self.parser.eval("$getmulti(abc,0,; ,extra)")

    def test_cmd_foreach(self):
        context = Metadata()
        context["foo"] = "First:A; Second:B; Third:C"
        context["bar"] = ["First:A", "Second:B", "Third:C"]
        foo_output = "Output: 1=First:A; Second:B; Third:C"
        loop_output = "Output: 1=First:A 2=Second:B 3=Third:C"
        alternate_output = "Output: 1=First 2=A; Second 3=B; Third 4=C"
        # Tests with context
        context["output"] = "Output:"
        self.assertScriptResultEquals("$foreach(%foo%,$set(output,%output% %_loop_count%=%_loop_value%))%output%", foo_output, context)
        context["output"] = "Output:"
        self.assertScriptResultEquals("$foreach(%bar%,$set(output,%output% %_loop_count%=%_loop_value%))%output%", loop_output, context)
        # Tests with static inputs
        context["output"] = "Output:"
        self.assertScriptResultEquals("$foreach(First:A; Second:B; Third:C,$set(output,%output% %_loop_count%=%_loop_value%))%output%", loop_output, context)
        # Tests with missing inputs
        context["output"] = "Output:"
        self.assertScriptResultEquals("$foreach(,$set(output,%output% %_loop_count%=%_loop_value%))%output%", "Output:", context)
        context["output"] = "Output:"
        self.assertScriptResultEquals("$foreach(First:A; Second:B; Third:C,)%output%", "Output:", context)
        # Tests with separator override
        context["output"] = "Output:"
        self.assertScriptResultEquals("$foreach(First:A; Second:B; Third:C,$set(output,%output% %_loop_count%=%_loop_value%),:)%output%", alternate_output, context)
        # Tests with invalid number of arguments
        areg = r"^\d+:\d+:\$foreach: Wrong number of arguments for \$foreach: Expected between 2 and 3, "
        with self.assertRaisesRegex(ScriptError, areg):
            self.parser.eval("$foreach()")
        with self.assertRaisesRegex(ScriptError, areg):
            self.parser.eval("$foreach(abc;def)")
        with self.assertRaisesRegex(ScriptError, areg):
            self.parser.eval("$foreach(abc:def,$noop(),:,extra)")

    def test_cmd_while(self):
        context = Metadata()
        context["max_value"] = '5'
        loop_output = "Output: 1 2 3 4 5"
        # Tests with context
        context["output"] = "Output:"
        self.assertScriptResultEquals("$set(_loop_count,1)$while($lt(%_loop_count%,%max_value%,int),$set(output,%output% %_loop_count%))%output%", loop_output, context)
        # Tests with static inputs
        context["output"] = "Output:"
        self.assertScriptResultEquals("$set(_loop_count,1)$while($lt(%_loop_count%,5,int),$set(output,%output% %_loop_count%))%output%", loop_output, context)
        # Tests with invalid conditional input
        context["output"] = "Output:"
        self.assertScriptResultEquals("$while($lt(%_loop_count%,5,int),$set(output,%output% %_loop_count%))%output%", "Output:", context)
        # Tests with forced conditional (runaway condition)
        context["output"] = "Output:"
        self.assertScriptResultEquals("$while(1,$set(output,%output% %_loop_count%))$right(%output%,4)", "1000", context)
        context["output"] = "Output:"
        self.assertScriptResultEquals("$while(0,$set(output,%output% %_loop_count%))$right(%output%,4)", "1000", context)
        # Tests with missing inputs
        context["output"] = "Output:"
        self.assertScriptResultEquals("$while($lt(%_loop_count%,5,int),)%output%", "Output:", context)
        context["output"] = "Output:"
        self.assertScriptResultEquals("$while(,$set(output,%output% %_loop_count%))%output%", "Output:", context)
        # Tests with invalid number of arguments
        areg = r"^\d+:\d+:\$while: Wrong number of arguments for \$while: Expected exactly 2, "
        with self.assertRaisesRegex(ScriptError, areg):
            self.parser.eval("$while()")
        with self.assertRaisesRegex(ScriptError, areg):
            self.parser.eval("$while(a)")
        with self.assertRaisesRegex(ScriptError, areg):
            self.parser.eval("$while(a,$noop(),extra)")

    def test_cmd_map(self):
        context = Metadata()
        foo_output = "1=FIRST:A; SECOND:B; THIRD:C"
        loop_output = "1=FIRST:A; 2=SECOND:B; 3=THIRD:C"
        alternate_output = "1=FIRST:2=A; SECOND:3=B; THIRD:4=C"
        # Tests with context
        context["foo"] = "First:A; Second:B; Third:C"
        self.assertScriptResultEquals("$map(%foo%,$upper(%_loop_count%=%_loop_value%))", foo_output, context)
        context["bar"] = ["First:A", "Second:B", "Third:C"]
        self.assertScriptResultEquals("$map(%bar%,$upper(%_loop_count%=%_loop_value%))", loop_output, context)
        # Tests with static inputs
        self.assertScriptResultEquals("$map(First:A; Second:B; Third:C,$upper(%_loop_count%=%_loop_value%))", loop_output, context)
        # Tests for removing empty elements
        context["baz"] = ["First:A", "Second:B", "Remove", "Third:C"]
        test_output = "1=FIRST:A; 2=SECOND:B; 4=THIRD:C"
        self.assertScriptResultEquals("$lenmulti(%baz%)", "4", context)
        self.assertScriptResultEquals("$map(%baz%,$if($eq(%_loop_count%,3),,$upper(%_loop_count%=%_loop_value%)))", test_output, context)
        context["baz"] = ["First:A", "Second:B", "Remove", "Third:C"]
        self.assertScriptResultEquals("$setmulti(baz,$map(%baz%,$if($eq(%_loop_count%,3),,$upper(%_loop_count%=%_loop_value%))))%baz%", test_output, context)
        self.assertScriptResultEquals("$lenmulti(%baz%)", "3", context)
        self.assertScriptResultEquals("%baz%", test_output, context)
        # Tests with missing inputs
        self.assertScriptResultEquals("$map(,$upper(%_loop_count%=%_loop_value%))", "", context)
        self.assertScriptResultEquals("$map(First:A; Second:B; Third:C,)", "", context)
        # Tests with separator override
        self.assertScriptResultEquals("$map(First:A; Second:B; Third:C,$upper(%_loop_count%=%_loop_value%),:)", alternate_output, context)
        # Tests with invalid number of arguments
        areg = r"^\d+:\d+:\$map: Wrong number of arguments for \$map: Expected between 2 and 3, "
        with self.assertRaisesRegex(ScriptError, areg):
            self.parser.eval("$map()")
        with self.assertRaisesRegex(ScriptError, areg):
            self.parser.eval("$map(abc; def)")
        with self.assertRaisesRegex(ScriptError, areg):
            self.parser.eval("$map(abc:def,$noop(),:,extra)")

    def test_cmd_joinmulti(self):
        context = Metadata()
        context["foo"] = "First:A; Second:B; Third:C"
        context["bar"] = ["First:A", "Second:B", "Third:C"]
        context["joiner"] = " ==> "
        foo_output = "First:A; Second:B; Third:C"
        bar_output = "First:A ==> Second:B ==> Third:C"
        alternate_output = "First ==> A; Second ==> B; Third ==> C"
        # Tests with context
        self.assertScriptResultEquals("$join(%foo%,%joiner%)", foo_output, context)
        self.assertScriptResultEquals("$join(%bar%,%joiner%)", bar_output, context)
        # Tests with static inputs
        self.assertScriptResultEquals("$join(First:A; Second:B; Third:C, ==> )", bar_output, context)
        # Tests with missing inputs
        self.assertScriptResultEquals("$join(, ==> )", "", context)
        self.assertScriptResultEquals("$join(First:A; Second:B; Third:C,)", "First:ASecond:BThird:C", context)
        # Tests with separator override
        self.assertScriptResultEquals("$join(First:A; Second:B; Third:C, ==> ,:)", alternate_output, context)
        # Tests with invalid number of arguments
        areg = r"^\d+:\d+:\$join: Wrong number of arguments for \$join: Expected between 2 and 3, "
        with self.assertRaisesRegex(ScriptError, areg):
            self.parser.eval("$join()")
        with self.assertRaisesRegex(ScriptError, areg):
            self.parser.eval("$join(abc; def)")
        with self.assertRaisesRegex(ScriptError, areg):
            self.parser.eval("$join(abc:def, ==> ,:,extra)")

    def test_cmd_slice(self):
        context = Metadata()
        context["foo"] = "First:A; Second:B; Third:C"
        context["bar"] = ["First:A", "Second:B", "Third:C"]
        context["zero"] = '0'
        context["one"] = '1'
        context["two"] = '2'
        context["three"] = '3'
        output_0_1 = "First:A"
        output_0_2 = "First:A; Second:B"
        output_0_3 = "First:A; Second:B; Third:C"
        output_1_2 = "Second:B"
        output_1_3 = "Second:B; Third:C"
        output_2_3 = "Third:C"
        alternate_output = "A; Second:B; Third"
        # Tests with context
        self.assertScriptResultEquals("$slice(%foo%,%zero%,%one%)", output_0_3, context)
        self.assertScriptResultEquals("$slice(%bar%,%zero%,%one%)", output_0_1, context)
        self.assertScriptResultEquals("$slice(%bar%,%zero%,%two%)", output_0_2, context)
        self.assertScriptResultEquals("$slice(%bar%,%zero%,%three%)", output_0_3, context)
        # Tests with static inputs
        self.assertScriptResultEquals("$slice(First:A; Second:B; Third:C,0,1)", output_0_1, context)
        self.assertScriptResultEquals("$slice(First:A; Second:B; Third:C,0,2)", output_0_2, context)
        self.assertScriptResultEquals("$slice(First:A; Second:B; Third:C,0,3)", output_0_3, context)
        self.assertScriptResultEquals("$slice(First:A; Second:B; Third:C,1,2)", output_1_2, context)
        self.assertScriptResultEquals("$slice(First:A; Second:B; Third:C,1,3)", output_1_3, context)
        self.assertScriptResultEquals("$slice(First:A; Second:B; Third:C,2,3)", output_2_3, context)
        # Tests with negative inputs
        self.assertScriptResultEquals("$slice(First:A; Second:B; Third:C,-3,1)", output_0_1, context)
        self.assertScriptResultEquals("$slice(First:A; Second:B; Third:C,0,-1)", output_0_2, context)
        self.assertScriptResultEquals("$slice(First:A; Second:B; Third:C,-2,2)", output_1_2, context)
        # Tests with missing inputs
        self.assertScriptResultEquals("$slice(First:A; Second:B; Third:C,,1)", output_0_1, context)
        self.assertScriptResultEquals("$slice(First:A; Second:B; Third:C,1)", output_1_3, context)
        self.assertScriptResultEquals("$slice(First:A; Second:B; Third:C,1,)", output_1_3, context)
        self.assertScriptResultEquals("$slice(First:A; Second:B; Third:C,,)", output_0_3, context)
        # Tests with invalid inputs (end < start)
        self.assertScriptResultEquals("$slice(First:A; Second:B; Third:C,1,0)", "", context)
        # Tests with invalid inputs (non-numeric end and/or start)
        self.assertScriptResultEquals("$slice(First:A; Second:B; Third:C,a,1)", output_0_1, context)
        self.assertScriptResultEquals("$slice(First:A; Second:B; Third:C,1,b)", output_1_3, context)
        self.assertScriptResultEquals("$slice(First:A; Second:B; Third:C,a,b)", output_0_3, context)
        # Tests with separator override
        self.assertScriptResultEquals("$slice(First:A; Second:B; Third:C,1,3,:)", alternate_output, context)
        # Tests with invalid number of arguments
        areg = r"^\d+:\d+:\$slice: Wrong number of arguments for \$slice: Expected between 2 and 4, "
        with self.assertRaisesRegex(ScriptError, areg):
            self.parser.eval("$slice()")
        with self.assertRaisesRegex(ScriptError, areg):
            self.parser.eval("$slice(abc; def)")
        with self.assertRaisesRegex(ScriptError, areg):
            self.parser.eval("$slice(abc; def),0,1,:,extra")

    def test_cmd_datetime(self):
        # Save original datetime object and substitute one returning
        # a fixed now() value for testing.
        original_datetime = datetime.datetime
        datetime.datetime = _DateTime

        try:
            context = Metadata()
            context["foo"] = "%Y%m%d%H%M%S.%f"
            # Tests with context
            self.assertScriptResultEquals("$datetime(%foo%)", "20200102123456.000789", context)
            self.assertScriptResultEquals("$datetime($initials())", "2020-01-02 12:34:56", context)
            # Tests with static input
            self.assertScriptResultEquals(r"$datetime(\%Y\%m\%d\%H\%M\%S.\%f)", "20200102123456.000789", context)
            # Tests with timezones
            self.assertScriptResultEquals(r"$datetime(\%H\%M\%S \%z \%Z)", "123456 +0200 TZ Test", context)
            # Tests with missing input
            self.assertScriptResultEquals("$datetime()", "2020-01-02 12:34:56", context)
            # Tests with invalid format
            self.assertScriptResultEquals("$datetime(xxx)", "xxx", context)
            # Tests with invalid number of arguments
            areg = r"^\d+:\d+:\$datetime: Wrong number of arguments for \$datetime: Expected between 0 and 1, "
            with self.assertRaisesRegex(ScriptError, areg):
                self.parser.eval("$datetime(abc,def)")
        finally:
            # Restore original datetime object
            datetime.datetime = original_datetime

    def test_cmd_datetime_platform_dependent(self):
        # Platform dependent testing because different platforms (both os and Python version)
        # support some format arguments differently.
        possible_tests = (
            '%',    # Hanging % at end of format
            '%-d',  # Non zero-padded day
            '%-m',  # Non zero-padded month
            '%3Y',  # Length specifier shorter than string
        )
        tests_to_run = []
        # Get list of tests for unsupported format codes
        for test_case in possible_tests:
            try:
                datetime.datetime.now().strftime(test_case)
            except ValueError:
                tests_to_run.append(test_case)
        if not tests_to_run:
            self.skipTest('datetime module supports all test cases')
        # Save original datetime object and substitute one returning
        # a fixed now() value for testing.
        original_datetime = datetime.datetime
        datetime.datetime = _DateTime

        try:
            areg = r"^\d+:\d+:\$datetime: Unsupported format code"
            # Tests with invalid format code (platform dependent tests)
            for test_case in tests_to_run:
                with self.assertRaisesRegex(ScriptRuntimeError, areg):
                    self.parser.eval(r'$datetime(\{0})'.format(test_case))
        finally:
            # Restore original datetime object
            datetime.datetime = original_datetime

    def test_scriptruntimeerror(self):
        # Platform dependent testing because different platforms (both os and Python version)
        # support some format arguments differently.  Use $datetime function to generate exceptions.
        possible_tests = (
            '%',    # Hanging % at end of format
            '%-d',  # Non zero-padded day
            '%-m',  # Non zero-padded month
            '%3Y',  # Length specifier shorter than string
        )
        test_to_run = ''
        # Get list of tests for unsupported format codes
        for test_case in possible_tests:
            try:
                datetime.datetime.now().strftime(test_case)
            except ValueError:
                test_to_run = test_case
                break
        if not test_to_run:
            self.skipTest('no test found to generate ScriptRuntimeError')
        # Save original datetime object and substitute one returning
        # a fixed now() value for testing.
        original_datetime = datetime.datetime
        datetime.datetime = _DateTime

        try:
            # Test that the correct position number is passed
            areg = r"^\d+:7:\$datetime: Unsupported format code"
            with self.assertRaisesRegex(ScriptRuntimeError, areg):
                self.parser.eval(r'$noop()$datetime(\{0})'.format(test_to_run))
            # Test that the function stack is returning the correct name (nested functions)
            areg = r"^\d+:\d+:\$datetime: Unsupported format code"
            with self.assertRaisesRegex(ScriptRuntimeError, areg):
                self.parser.eval(r'$set(foo,$datetime($if(,,\{0})))'.format(test_to_run))
            # Test that the correct line number is passed
            areg = r"^2:\d+:\$datetime: Unsupported format code"
            with self.assertRaisesRegex(ScriptRuntimeError, areg):
                self.parser.eval('$noop(\n)$datetime($if(,,\\{0})))'.format(test_to_run))
        finally:
            # Restore original datetime object
            datetime.datetime = original_datetime

    def test_multivalue_1(self):
        self.parser.context = Metadata({'foo': ':', 'bar': 'x:yz', 'empty': ''})
        expr = self.parser.parse('a:bc; d:ef')
        self.assertIsInstance(expr, ScriptExpression)

        mv = MultiValue(self.parser, expr, MULTI_VALUED_JOINER)
        self.assertEqual(mv._multi, ['a:bc', 'd:ef'])
        self.assertEqual(mv.separator, MULTI_VALUED_JOINER)
        self.assertEqual(len(mv), 2)
        del mv[0]
        self.assertEqual(len(mv), 1)
        mv.insert(0, 'x')
        self.assertEqual(mv[0], 'x')
        mv[0] = 'y'
        self.assertEqual(mv[0], 'y')
        self.assertEqual(str(mv), 'y; d:ef')
        self.assertTrue(repr(mv).startswith('MultiValue('))

        mv = MultiValue(self.parser, expr, ':')
        self.assertEqual(mv._multi, ['a', 'bc; d', 'ef'])
        self.assertEqual(mv.separator, ':')

        expr = self.parser.parse('a:bc; d:ef')
        self.assertIsInstance(expr, ScriptExpression)
        sep = self.parser.parse('%foo%')
        self.assertIsInstance(sep, ScriptExpression)
        mv = MultiValue(self.parser, expr, sep)
        self.assertEqual(mv._multi, ['a', 'bc; d', 'ef'])

        expr = self.parser.parse('%bar%; d:ef')
        self.assertIsInstance(expr, ScriptExpression)
        sep = self.parser.parse('%foo%')
        self.assertIsInstance(sep, ScriptExpression)
        mv = MultiValue(self.parser, expr, sep)
        self.assertEqual(mv._multi, ['x', 'yz; d', 'ef'])

        expr = self.parser.parse('%bar%')
        self.assertIsInstance(expr, ScriptExpression)
        mv = MultiValue(self.parser, expr, MULTI_VALUED_JOINER)
        self.assertEqual(mv._multi, ['x:yz'])

        expr = self.parser.parse('%bar%; d:ef')
        self.assertIsInstance(expr, ScriptExpression)
        sep = self.parser.parse('%empty%')
        self.assertIsInstance(sep, ScriptExpression)
        mv = MultiValue(self.parser, expr, sep)
        self.assertEqual(mv._multi, ['x:yz; d:ef'])

        expr = self.parser.parse('')
        self.assertIsInstance(expr, ScriptExpression)
        mv = MultiValue(self.parser, expr, MULTI_VALUED_JOINER)
        self.assertEqual(mv._multi, [])

    def test_cmd_sortmulti(self):
        context = Metadata()
        context["foo"] = ['B', 'D', 'E', 'A', 'C']
        context["bar"] = ['B:AB', 'D:C', 'E:D', 'A:A', 'C:X']
        context['baz'] = "B; D; E; A; C"
        # Tests with context
        self.assertScriptResultEquals("$sortmulti(%foo%)", "A; B; C; D; E", context)
        self.assertScriptResultEquals("$sortmulti(%bar%)", "A:A; B:AB; C:X; D:C; E:D", context)
        self.assertScriptResultEquals("$sortmulti(%baz%)", "B; D; E; A; C", context)
        # Tests with static inputs
        self.assertScriptResultEquals("$sortmulti(B; D; E; A; C)", "A; B; C; D; E", context)
        self.assertScriptResultEquals("$sortmulti(B:AB; D:C; E:D; A:A; C:X)", "A:A; B:AB; C:X; D:C; E:D", context)
        # Tests with separator override
        self.assertScriptResultEquals("$sortmulti(B:AB; D:C; E:D; A:A; C:X,:)", "A; C:AB; D:B:C; E:D; A:X", context)
        # Tests with missing inputs
        self.assertScriptResultEquals("$sortmulti(,)", "", context)
        self.assertScriptResultEquals("$sortmulti(,:)", "", context)
        # Tests with invalid number of arguments
        areg = r"^\d+:\d+:\$sortmulti: Wrong number of arguments for \$sortmulti: Expected between 1 and 2, "
        with self.assertRaisesRegex(ScriptError, areg):
            self.parser.eval("$sortmulti()")
        with self.assertRaisesRegex(ScriptError, areg):
            self.parser.eval("$sortmulti(B:AB; D:C; E:D; A:A; C:X,:,extra)")

    def test_cmd_reversemulti(self):
        context = Metadata()
        context["foo"] = ['B', 'D', 'E', 'A', 'C']
        context["bar"] = ['B:AB', 'D:C', 'E:D', 'A:A', 'C:X']
        context['baz'] = "B; D; E; A; C"
        # Tests with context
        self.assertScriptResultEquals("$reversemulti(%foo%)", "C; A; E; D; B", context)
        self.assertScriptResultEquals("$reversemulti(%bar%)", "C:X; A:A; E:D; D:C; B:AB", context)
        self.assertScriptResultEquals("$reversemulti(%baz%)", "B; D; E; A; C", context)
        # Tests with static inputs
        self.assertScriptResultEquals("$reversemulti(B; D; E; A; C)", "C; A; E; D; B", context)
        self.assertScriptResultEquals("$reversemulti(B:AB; D:C; E:D; A:A; C:X)", "C:X; A:A; E:D; D:C; B:AB", context)
        # Tests with separator override
        self.assertScriptResultEquals("$reversemulti(B:AB; D:C; E:D; A:A; C:X,:)", "X:A; C:D; A:C; E:AB; D:B", context)
        # Tests with missing inputs
        self.assertScriptResultEquals("$reversemulti(,)", "", context)
        self.assertScriptResultEquals("$reversemulti(,:)", "", context)
        # Tests with invalid number of arguments
        areg = r"^\d+:\d+:\$reversemulti: Wrong number of arguments for \$reversemulti: Expected between 1 and 2, "
        with self.assertRaisesRegex(ScriptError, areg):
            self.parser.eval("$reversemulti()")
        with self.assertRaisesRegex(ScriptError, areg):
            self.parser.eval("$reversemulti(B:AB; D:C; E:D; A:A; C:X,:,extra)")

    def test_cmd_unique(self):
        context = Metadata()
        context["foo"] = ['a', 'A', 'B', 'b', 'cd', 'Cd', 'cD', 'CD', 'a', 'A', 'b']
        context["bar"] = "a; A; B; b; cd; Cd; cD; CD; a; A; b"
        # Tests with context
        self.assertScriptResultEquals("$unique(%foo%)", "A; CD; b", context)
        self.assertScriptResultEquals("$unique(%bar%)", "a; A; B; b; cd; Cd; cD; CD; a; A; b", context)
        # Tests with static inputs
        self.assertScriptResultEquals("$unique(a; A; B; b; cd; Cd; cD; CD; a; A; b)", "A; CD; b", context)
        # Tests with separator override
        self.assertScriptResultEquals("$unique(a: A: B: b: cd: Cd: cD: CD: a: A: b,,: )", "A: CD: b", context)
        # Tests with case-sensitive comparison
        self.assertScriptResultEquals("$unique(%foo%,1)", "A; B; CD; Cd; a; b; cD; cd", context)
        # Tests with missing inputs
        self.assertScriptResultEquals("$unique(,)", "", context)
        self.assertScriptResultEquals("$unique(,,)", "", context)
        self.assertScriptResultEquals("$unique(,:)", "", context)
        # Tests with invalid number of arguments
        areg = r"^\d+:\d+:\$unique: Wrong number of arguments for \$unique: Expected between 1 and 3, "
        with self.assertRaisesRegex(ScriptError, areg):
            self.parser.eval("$unique()")
        with self.assertRaisesRegex(ScriptError, areg):
            self.parser.eval("$unique(B:AB; D:C; E:D; A:A; C:X,1,:,extra)")

    def test_cmd_countryname(self):
        context = Metadata()
        context["foo"] = "ca"
        context["bar"] = ""
        context["baz"] = "INVALID"

        # Ensure that `builtins` contains a `gettext_countries` attribute to avoid an `AttributeError`
        # exception when mocking the function, in case the `picard.i18n` module has not been loaded.
        # This is required by the $countryname() function in order to translate the country names.
        if not hasattr(builtins, 'gettext_countries'):
            builtins.__dict__['gettext_countries'] = None

        # Mock function to simulate English locale.
        def mock_gettext_countries_en(arg):
            return arg

        # Mock function to simulate Russian locale.
        def mock_gettext_countries_ru(arg):
            return "Канада" if arg == 'Canada' else arg

        # Test with Russian locale
        with mock.patch('builtins.gettext_countries', mock_gettext_countries_ru):
            self.assertScriptResultEquals("$countryname(ca)", "Canada", context)
            self.assertScriptResultEquals("$countryname(ca,)", "Canada", context)
            self.assertScriptResultEquals("$countryname(ca, )", "Канада", context)
            self.assertScriptResultEquals("$countryname(ca,yes)", "Канада", context)
            self.assertScriptResultEquals("$countryname(INVALID,yes)", "", context)
            # Test for unknown translation of correct code
            self.assertScriptResultEquals("$countryname(fr,yes)", "France", context)

        # Reset locale to English for remaining tests
        with mock.patch('builtins.gettext_countries', mock_gettext_countries_en):
            self.assertScriptResultEquals("$countryname(ca,)", "Canada", context)
            self.assertScriptResultEquals("$countryname(ca,yes)", "Canada", context)
            self.assertScriptResultEquals("$countryname(ca)", "Canada", context)
            self.assertScriptResultEquals("$countryname(CA)", "Canada", context)
            self.assertScriptResultEquals("$countryname(%foo%)", "Canada", context)
            self.assertScriptResultEquals("$countryname(%bar%)", "", context)
            self.assertScriptResultEquals("$countryname(%baz%)", "", context)
            self.assertScriptResultEquals("$countryname(INVALID)", "", context)

        # Tests with invalid number of arguments
        areg = r"^\d+:\d+:\$countryname: Wrong number of arguments for \$countryname: Expected between 1 and 2, "
        with self.assertRaisesRegex(ScriptError, areg):
            self.parser.eval("$countryname()")
        with self.assertRaisesRegex(ScriptError, areg):
            self.parser.eval("$countryname(CA,,Extra)")

    def test_cmd_year(self):
        context = Metadata()
        context["foo"] = "07.21.2021"
        context["bar"] = "mdy"

        # Test with default values
        self.assertScriptResultEquals("$year(2021 07 21)", "2021", context)
        self.assertScriptResultEquals("$year(2021.07.21)", "2021", context)
        self.assertScriptResultEquals("$year(2021-07-21)", "2021", context)
        self.assertScriptResultEquals("$year(21-07-21)", "21", context)

        # Test with overrides specified
        self.assertScriptResultEquals("$year(%foo%,%bar%)", "2021", context)

        # Test with invalid overrides
        self.assertScriptResultEquals("$year(2021-07-21,myd)", "2021", context)

        # Test missing elements
        self.assertScriptResultEquals("$year(,)", "", context)
        self.assertScriptResultEquals("$year(07-21,mdy)", "", context)
        self.assertScriptResultEquals("$year(21-07,dmy)", "", context)

        # Tests with invalid number of arguments
        areg = r"^\d+:\d+:\$year: Wrong number of arguments for \$year: Expected between 1 and 2, "
        with self.assertRaisesRegex(ScriptError, areg):
            self.parser.eval("$year()")
        with self.assertRaisesRegex(ScriptError, areg):
            self.parser.eval("$year(2021-07-21,,)")

    def test_cmd_month(self):
        context = Metadata()
        context["foo"] = "07.21.2021"
        context["bar"] = "mdy"

        # Test with default values
        self.assertScriptResultEquals("$month(2021 07 21)", "07", context)
        self.assertScriptResultEquals("$month(2021.07.21)", "07", context)
        self.assertScriptResultEquals("$month(2021-07-21)", "07", context)
        self.assertScriptResultEquals("$month(2021-7-21)", "7", context)

        # Test with overrides specified
        self.assertScriptResultEquals("$month(%foo%,%bar%)", "07", context)

        # Test with invalid overrides
        self.assertScriptResultEquals("$month(2021-07-21,myd)", "07", context)

        # Test missing elements
        self.assertScriptResultEquals("$month(,)", "", context)
        self.assertScriptResultEquals("$month(-21-2021,mdy)", "", context)

        # Tests with invalid number of arguments
        areg = r"^\d+:\d+:\$month: Wrong number of arguments for \$month: Expected between 1 and 2, "
        with self.assertRaisesRegex(ScriptError, areg):
            self.parser.eval("$month()")
        with self.assertRaisesRegex(ScriptError, areg):
            self.parser.eval("$month(2021-07-21,,)")

    def test_cmd_day(self):
        context = Metadata()
        context["foo"] = "07.21.2021"
        context["bar"] = "mdy"

        # Test with default values
        self.assertScriptResultEquals("$day(2021 07 21)", "21", context)
        self.assertScriptResultEquals("$day(2021.07.21)", "21", context)
        self.assertScriptResultEquals("$day(2021-07-21)", "21", context)
        self.assertScriptResultEquals("$day(2021-07-2)", "2", context)

        # Test with overrides specified
        self.assertScriptResultEquals("$day(%foo%,%bar%)", "21", context)

        # Test with invalid overrides
        self.assertScriptResultEquals("$day(2021-07-21,myd)", "21", context)

        # Test missing elements
        self.assertScriptResultEquals("$day(,)", "", context)
        self.assertScriptResultEquals("$day(-07-2021,dmy)", "", context)

        # Tests with invalid number of arguments
        areg = r"^\d+:\d+:\$day: Wrong number of arguments for \$day: Expected between 1 and 2, "
        with self.assertRaisesRegex(ScriptError, areg):
            self.parser.eval("$day()")
        with self.assertRaisesRegex(ScriptError, areg):
            self.parser.eval("$day(2021-07-21,,)")

    def test_cmd_dateformat(self):
        context = Metadata()
        context["foo"] = "07.21.2021"
        context["bar"] = "mdy"
        context["format"] = "%Y.%m.%d"

        # Test with default values
        self.assertScriptResultEquals("$dateformat(2021 07 21)", "2021-07-21", context)
        self.assertScriptResultEquals("$dateformat(2021.07.21)", "2021-07-21", context)
        self.assertScriptResultEquals("$dateformat(2021-07-21)", "2021-07-21", context)
        self.assertScriptResultEquals("$dateformat(2021-7-21)", "2021-07-21", context)

        # Test with overrides specified
        self.assertScriptResultEquals("$dateformat(%foo%,%format%,%bar%)", "2021.07.21", context)

        # Test with invalid overrides
        self.assertScriptResultEquals("$dateformat(2021-07-21,,myd)", "2021-07-21", context)
        self.assertScriptResultEquals("$dateformat(2021-07-21,,dmy)", "", context)
        self.assertScriptResultEquals("$dateformat(2021-07-21,,mdy)", "", context)
        self.assertScriptResultEquals("$dateformat(2021-July-21)", "", context)
        self.assertScriptResultEquals("$dateformat(2021)", "", context)
        self.assertScriptResultEquals("$dateformat(2021-07)", "", context)

        # Test missing elements
        self.assertScriptResultEquals("$dateformat(,)", "", context)

        # Tests with invalid number of arguments
        areg = r"^\d+:\d+:\$dateformat: Wrong number of arguments for \$dateformat: Expected between 1 and 3, "
        with self.assertRaisesRegex(ScriptError, areg):
            self.parser.eval("$dateformat()")
        with self.assertRaisesRegex(ScriptError, areg):
            self.parser.eval("$dateformat(2021-07-21,,,)")

    def test_cmd_is_multi(self):
        context = Metadata()
        context["foo"] = "a; b; c"
        context["bar"] = ""

        self.assertScriptResultEquals("$is_multi(%foo%)", "", context)
        self.assertScriptResultEquals("$is_multi(%bar%)", "", context)
        self.assertScriptResultEquals("$setmulti(baz,a)$is_multi(%baz%)", "", context)
        self.assertScriptResultEquals("$setmulti(baz,a; b; c)$is_multi(%baz%)", "1", context)
        self.assertScriptResultEquals("$is_multi(a; b; c)", "1", context)
        self.assertScriptResultEquals("$is_multi(a)", "", context)

        # Tests with invalid number of arguments
        areg = r"^\d+:\d+:\$is_multi: Wrong number of arguments for \$is_multi: Expected exactly 1, "
        with self.assertRaisesRegex(ScriptError, areg):
            self.parser.eval("$is_multi()")
        with self.assertRaisesRegex(ScriptError, areg):
            self.parser.eval("$is_multi(a,)")

    def test_cmd_cleanmulti(self):
        context = Metadata()
        context["foo"] = ["", "one", "two"]
        context["bar"] = ["one", "", "two"]
        context["baz"] = ["one", "two", ""]

        # Confirm initial values
        self.assertScriptResultEquals("%foo%", "; one; two", context)
        self.assertScriptResultEquals("%bar%", "one; ; two", context)
        self.assertScriptResultEquals("%baz%", "one; two; ", context)
        # Test cleaned values
        self.assertScriptResultEquals("$cleanmulti(foo)%foo%", "one; two", context)
        self.assertScriptResultEquals("$cleanmulti(bar)%bar%", "one; two", context)
        self.assertScriptResultEquals("$cleanmulti(baz)%baz%", "one; two", context)

    def test_cmd_cleanmulti_with_hidden_var(self):
        context = Metadata()
        context["~foo"] = ["one", "", "two"]

        # Confirm initial values
        self.assertScriptResultEquals("%_foo%", "one; ; two", context)
        # Test cleaned values
        self.assertScriptResultEquals("$cleanmulti(_foo)%_foo%", "one; two", context)

    def test_cmd_cleanmulti_only_empty_strings(self):
        context = Metadata()
        context["foo"] = ["", "", ""]

        # Confirm initial values
        self.assertScriptResultEquals("%foo%", "; ; ", context)
        # Test cleaned values
        self.assertScriptResultEquals("$cleanmulti(foo)%foo%", "", context)

    def test_cmd_cleanmulti_indirect_argument(self):
        context = Metadata()
        context["foo"] = ["", "one", "two"]
        context["bar"] = "foo"

        # Confirm initial values
        self.assertScriptResultEquals("%foo%", "; one; two", context)
        # Test cleaned values
        self.assertScriptResultEquals("$cleanmulti(%bar%)%foo%", "one; two", context)

    def test_cmd_cleanmulti_non_multi_argument(self):
        context = Metadata()
        context["foo"] = "one"
        context["bar"] = "one; ; two"
        context["baz"] = ""

        # Confirm initial values
        self.assertScriptResultEquals("%foo%", "one", context)
        self.assertScriptResultEquals("%bar%", "one; ; two", context)
        self.assertScriptResultEquals("%baz%", "", context)
        # Test cleaned values
        self.assertScriptResultEquals("$cleanmulti(foo)%foo%", "one", context)
        self.assertScriptResultEquals("$cleanmulti(bar)%bar%", "one; ; two", context)
        self.assertScriptResultEquals("$cleanmulti(baz)%baz%", "", context)

    def test_cmd_cleanmulti_invalid_number_of_arguments(self):
        areg = r"^\d+:\d+:\$cleanmulti: Wrong number of arguments for \$cleanmulti: Expected exactly 1, "
        with self.assertRaisesRegex(ScriptError, areg):
            self.parser.eval("$cleanmulti()")
        with self.assertRaisesRegex(ScriptError, areg):
            self.parser.eval("$cleanmulti(foo,)")

    def test_cmd_min(self):
        # Test "text" processing
        self.assertScriptResultEquals("$min(text,abc)", "abc")
        self.assertScriptResultEquals("$min(text,abc,abcd,ac)", "abc")
        self.assertScriptResultEquals("$min(text,ac,abcd,abc)", "abc")
        self.assertScriptResultEquals("$min(text,,a)", "")
        self.assertScriptResultEquals("$min(text,a,)", "")
        self.assertScriptResultEquals("$min(text,,)", "")

        # Test date type arguments using "text" processing
        self.assertScriptResultEquals("$min(text,2020-01-01)", "2020-01-01")
        self.assertScriptResultEquals("$min(text,2020-01-01,2020-01-02,2020-02)", "2020-01-01")
        self.assertScriptResultEquals("$min(text,2020-02,2020-01-02,2020-01-01)", "2020-01-01")

        # Test "int" processing
        self.assertScriptResultEquals("$min(int,1)", "1")
        self.assertScriptResultEquals("$min(int,2,3)", "2")
        self.assertScriptResultEquals("$min(int,2,1,3)", "1")
        self.assertScriptResultEquals("$min(int,2,1,3.1)", "")
        self.assertScriptResultEquals("$min(int,2,1,a)", "")
        self.assertScriptResultEquals("$min(int,2,,1)", "")
        self.assertScriptResultEquals("$min(int,2,1,)", "")

        # Test "float" processing
        self.assertScriptResultEquals("$min(float,1)", "1.0")
        self.assertScriptResultEquals("$min(float,2,3)", "2.0")
        self.assertScriptResultEquals("$min(float,2,1,3)", "1.0")
        self.assertScriptResultEquals("$min(float,2,1.1,3)", "1.1")
        self.assertScriptResultEquals("$min(float,1.11,1.1,1.111)", "1.1")
        self.assertScriptResultEquals("$min(float,2,1,a)", "")
        self.assertScriptResultEquals("$min(float,2,,1)", "")
        self.assertScriptResultEquals("$min(float,2,1,)", "")

        # Test 'nocase' processing
        self.assertScriptResultEquals("$min(nocase,a,B)", "a")
        self.assertScriptResultEquals("$min(nocase,c,A,b)", "A")

        # Test case sensitive arguments with 'text' processing
        self.assertScriptResultEquals("$min(text,A,a)", "A")
        self.assertScriptResultEquals("$min(text,a,B)", "B")

        # Test multi-value arguments
        context = Metadata()
        context['mv'] = ['y', 'z', 'x']
        self.assertScriptResultEquals("$min(text,%mv%)", "x", context)
        self.assertScriptResultEquals("$min(text,a,%mv%)", "a", context)
        self.assertScriptResultEquals("$min(text,y; z; x)", "x")
        self.assertScriptResultEquals("$min(text,a,y; z; x)", "a")
        self.assertScriptResultEquals("$min(int,5,4; 6; 3)", "3")
        self.assertScriptResultEquals("$min(float,5.9,4.2; 6; 3.35)", "3.35")

        # Test 'auto' processing
        self.assertScriptResultEquals("$min(,1,2)", "1")
        self.assertScriptResultEquals("$min(,2,1)", "1")
        self.assertScriptResultEquals("$min(auto,1,2)", "1")
        self.assertScriptResultEquals("$min(auto,2,1)", "1")
        self.assertScriptResultEquals("$min(,1,2.1)", "1.0")
        self.assertScriptResultEquals("$min(,2.1,1)", "1.0")
        self.assertScriptResultEquals("$min(auto,1,2.1)", "1.0")
        self.assertScriptResultEquals("$min(auto,2.1,1)", "1.0")
        self.assertScriptResultEquals("$min(,2.1,1,a)", "1")
        self.assertScriptResultEquals("$min(auto,2.1,1,a)", "1")
        self.assertScriptResultEquals("$min(,a,A)", "A")
        self.assertScriptResultEquals("$min(,A,a)", "A")
        self.assertScriptResultEquals("$min(auto,a,A)", "A")
        self.assertScriptResultEquals("$min(auto,A,a)", "A")

        # Test invalid processing types
        self.assertScriptResultEquals("$min(unknown,a,B)", "")

        # Tests with invalid number of arguments
        areg = r"^\d+:\d+:\$min: Wrong number of arguments for \$min: Expected at least 2, "
        with self.assertRaisesRegex(ScriptError, areg):
            self.parser.eval("$min()")
        with self.assertRaisesRegex(ScriptError, areg):
            self.parser.eval("$min(text)")

    def test_cmd_max(self):
        # Test "text" processing
        self.assertScriptResultEquals("$max(text,abc)", "abc")
        self.assertScriptResultEquals("$max(text,abc,abcd,ac)", "ac")
        self.assertScriptResultEquals("$max(text,ac,abcd,abc)", "ac")
        self.assertScriptResultEquals("$max(text,,a)", "a")
        self.assertScriptResultEquals("$max(text,a,)", "a")
        self.assertScriptResultEquals("$max(text,,)", "")

        # Test date type arguments using "text" processing
        self.assertScriptResultEquals("$max(text,2020-01-01)", "2020-01-01")
        self.assertScriptResultEquals("$max(text,2020-01-01,2020-01-02,2020-02)", "2020-02")
        self.assertScriptResultEquals("$max(text,2020-02,2020-01-02,2020-01-01)", "2020-02")

        # Test "int" processing
        self.assertScriptResultEquals("$max(int,1)", "1")
        self.assertScriptResultEquals("$max(int,2,3)", "3")
        self.assertScriptResultEquals("$max(int,2,1,3)", "3")
        self.assertScriptResultEquals("$max(int,2,1,3.1)", "")
        self.assertScriptResultEquals("$max(int,2,1,a)", "")
        self.assertScriptResultEquals("$max(int,2,,1)", "")
        self.assertScriptResultEquals("$max(int,2,1,)", "")

        # Test "float" processing
        self.assertScriptResultEquals("$max(float,1)", "1.0")
        self.assertScriptResultEquals("$max(float,2,3)", "3.0")
        self.assertScriptResultEquals("$max(float,2,1.1,3)", "3.0")
        self.assertScriptResultEquals("$max(float,2,1,3.1)", "3.1")
        self.assertScriptResultEquals("$max(float,2.1,2.11,2.111)", "2.111")
        self.assertScriptResultEquals("$max(float,2,1,a)", "")
        self.assertScriptResultEquals("$max(float,2,,1)", "")
        self.assertScriptResultEquals("$max(float,2,1,)", "")

        # Test 'nocase' processing
        self.assertScriptResultEquals("$max(nocase,a,B)", "B")
        self.assertScriptResultEquals("$max(nocase,c,a,B)", "c")

        # Test case sensitive arguments with 'text' processing
        self.assertScriptResultEquals("$max(text,A,a)", "a")
        self.assertScriptResultEquals("$max(text,a,B)", "a")

        # Test multi-value arguments
        context = Metadata()
        context['mv'] = ['y', 'z', 'x']
        self.assertScriptResultEquals("$max(text,%mv%)", "z", context)
        self.assertScriptResultEquals("$max(text,a,%mv%)", "z", context)
        self.assertScriptResultEquals("$max(text,y; z; x)", "z")
        self.assertScriptResultEquals("$max(text,a,y; z; x)", "z")
        self.assertScriptResultEquals("$max(int,5,4; 6; 3)", "6")
        self.assertScriptResultEquals("$max(float,5.9,4.2; 6; 3.35)", "6.0")

        # Test 'auto' processing
        self.assertScriptResultEquals("$max(,1,2)", "2")
        self.assertScriptResultEquals("$max(,2,1)", "2")
        self.assertScriptResultEquals("$max(auto,1,2)", "2")
        self.assertScriptResultEquals("$max(auto,2,1)", "2")
        self.assertScriptResultEquals("$max(,1.1,2)", "2.0")
        self.assertScriptResultEquals("$max(,2,1.1)", "2.0")
        self.assertScriptResultEquals("$max(auto,1.1,2)", "2.0")
        self.assertScriptResultEquals("$max(auto,2,1.1)", "2.0")
        self.assertScriptResultEquals("$max(,2.1,1,a)", "a")
        self.assertScriptResultEquals("$max(auto,2.1,1,a)", "a")
        self.assertScriptResultEquals("$max(,a,A)", "a")
        self.assertScriptResultEquals("$max(,A,a)", "a")
        self.assertScriptResultEquals("$max(auto,a,A)", "a")
        self.assertScriptResultEquals("$max(auto,A,a)", "a")

        # Test invalid processing types
        self.assertScriptResultEquals("$max(unknown,a,B)", "")

        # Tests with invalid number of arguments
        areg = r"^\d+:\d+:\$max: Wrong number of arguments for \$max: Expected at least 2, "
        with self.assertRaisesRegex(ScriptError, areg):
            self.parser.eval("$max()")
        with self.assertRaisesRegex(ScriptError, areg):
            self.parser.eval("$max(text)")
