From ea4ab0d993d4f3bd469e2b07e4ed370334a6d803 Mon Sep 17 00:00:00 2001 From: Bob Swift Date: Thu, 26 May 2022 11:30:28 -0600 Subject: [PATCH] Add different processing types to functions --- picard/script/functions.py | 174 +++++++++++---- test/test_script.py | 436 +++++++++++++++++++++++++------------ 2 files changed, 426 insertions(+), 184 deletions(-) diff --git a/picard/script/functions.py b/picard/script/functions.py index 1527a0d2b..b3d54a5c5 100644 --- a/picard/script/functions.py +++ b/picard/script/functions.py @@ -681,70 +681,110 @@ def func_ne(parser, x, y): @script_function(documentation=N_( - """`$lt(x,y[,text])` + """`$lt(x,y[,type])` -Returns true if `x` is less than `y`. -Values `x` and `y` are treated as integers unless `text` is set.""" +Returns true if `x` is less than `y` using the comparison specified in `type`. +Possible values of `type` are "int" (integer), "float" (floating point) and +"text" (case-sensitive text), with "int" used as the default comparison method +if `type` is not specified.""" )) -def func_lt(parser, x, y, text=None): - if text: +def func_lt(parser, x, y, _type=None): + if not _type: + _type = 'int' + _typer = None + if _type == 'text': return "1" if x < y else "" - try: - if int(x) < int(y): - return "1" - except ValueError: - pass + elif _type == 'float': + _typer = float + elif _type == 'int': + _typer = int + if _typer is not None: + try: + if _typer(x) < _typer(y): + return "1" + except ValueError: + pass return "" @script_function(documentation=N_( - """`$lte(x,y[,text])` + """`$lte(x,y[,type])` -Returns true if `x` is less than or equal to `y`. -Values `x` and `y` are treated as integers unless `text` is set.""" +Returns true if `x` is less than or equal to `y` using the comparison specified in `type`. +Possible values of `type` are "int" (integer), "float" (floating point) and +"text" (case-sensitive text), with "int" used as the default comparison method +if `type` is not specified.""" )) -def func_lte(parser, x, y, text=None): - if text: +def func_lte(parser, x, y, _type=None): + if not _type: + _type = 'int' + _typer = None + if _type == 'text': return "" if x > y else "1" - try: - if int(x) <= int(y): - return "1" - except ValueError: - pass + elif _type == 'float': + _typer = float + elif _type == 'int': + _typer = int + if _typer is not None: + try: + if _typer(x) <= _typer(y): + return "1" + except ValueError: + pass return "" @script_function(documentation=N_( - """`$gt(x,y[,text])` + """`$gt(x,y[,type])` -Returns true if `x` is greater than `y`. -Values `x` and `y` are treated as integers unless `text` is set.""" +Returns true if `x` is greater than `y` using the comparison specified in `type`. +Possible values of `type` are "int" (integer), "float" (floating point) and +"text" (case-sensitive text), with "int" used as the default comparison method +if `type` is not specified.""" )) -def func_gt(parser, x, y, text=None): - if text: +def func_gt(parser, x, y, _type=None): + if not _type: + _type = 'int' + _typer = None + if _type == 'text': return "1" if x > y else "" - try: - if int(x) > int(y): - return "1" - except ValueError: - pass + elif _type == 'float': + _typer = float + elif _type == 'int': + _typer = int + if _typer is not None: + try: + if _typer(x) > _typer(y): + return "1" + except ValueError: + pass return "" @script_function(documentation=N_( - """`$gte(x,y[,text])` + """`$gte(x,y[,type])` -Returns true if `x` is greater than or equal to `y`. -Values `x` and `y` are treated as integers unless `text` is set.""" +Returns true if `x` is greater than or equal to `y` using the comparison specified in `type`. +Possible values of `type` are "int" (integer), "float" (floating point) and +"text" (case-sensitive text), with "int" used as the default comparison method +if `type` is not specified.""" )) -def func_gte(parser, x, y, text=None): - if text: +def func_gte(parser, x, y, _type=None): + if not _type: + _type = 'int' + _typer = None + if _type == 'text': return "" if x < y else "1" - try: - if int(x) >= int(y): - return "1" - except ValueError: - pass + elif _type == 'float': + _typer = float + elif _type == 'int': + _typer = int + if _typer is not None: + try: + if _typer(x) >= _typer(y): + return "1" + except ValueError: + pass return "" @@ -1532,24 +1572,62 @@ def func_cleanmulti(parser, multi): @script_function(documentation=N_( - """$textmin(x,...) + """$min(type,x,...) + +Returns the minimum value using the comparison specified in `type`. +Possible values of `type` are "int" (integer), "float" (floating point) and +"text" (case-sensitive text). -Returns the minimum value using a text comparison. Can be used with an arbitrary number of arguments. _Since Picard 3.0_""" )) -def func_textmin(parser, x, *args): - return min((*args, x)) +def func_min(parser, _type, x, *args): + haystack = set((x, *args)) + _typer = None + if _type == 'int': + _typer = int + elif _type == 'float': + _typer = float + elif _type == 'text': + pass + else: + # Unknown processing type + return "" + if _typer is not None: + try: + haystack = set(_typer(item) for item in haystack) + except ValueError: + return "" + return str(min(haystack)) @script_function(documentation=N_( - """$textmax(x,...) + """$max(type,x,...) + +Returns the maximum value using the comparison specified in `type`. +Possible values of `type` are "int" (integer), "float" (floating point) and +"text" (case-sensitive text). -Returns the maximum value using a text comparison. Can be used with an arbitrary number of arguments. _Since Picard 3.0_""" )) -def func_textmax(parser, x, *args): - return max((*args, x)) +def func_max(parser, _type, x, *args): + haystack = set((x, *args)) + _typer = None + if _type == 'int': + _typer = int + elif _type == 'float': + _typer = float + elif _type == 'text': + pass + else: + # Unknown processing type + return "" + if _typer is not None: + try: + haystack = set(_typer(item) for item in haystack) + except ValueError: + return "" + return str(max(haystack)) diff --git a/test/test_script.py b/test/test_script.py index be27445e9..f1b9adacd 100644 --- a/test/test_script.py +++ b/test/test_script.py @@ -591,46 +591,75 @@ class ScriptParserTest(PicardTestCase): def test_cmd_gt(self): context = Metadata() - # Test with integer values (default processing) + # Test with default processing self.assertScriptResultEquals("$gt(10,4)", "1") self.assertScriptResultEquals("$gt(6,4)", "1") + self.assertScriptResultEquals("$gt(6.5,4)", "") self.assertScriptResultEquals("$gt(6,7)", "") self.assertScriptResultEquals("$gt(6,6)", "") self.assertScriptResultEquals("$gt(a,b)", "") - # Test date type arguments (text processing) + # 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 context["foo"] = "2020-01-01" context["bar"] = "2020-01-02" context["baz"] = "2020-02" - self.assertScriptResultEquals("$gt(%foo%,%bar%,1)", "", context) - self.assertScriptResultEquals("$gt(%bar%,%foo%,1)", "1", context) - self.assertScriptResultEquals("$gt(%foo%,%baz%,1)", "", context) - self.assertScriptResultEquals("$gt(%baz%,%foo%,1)", "1", context) - self.assertScriptResultEquals("$gt(%foo%,%foo%,1)", "", context) + self.assertScriptResultEquals("$gt(%foo%,%bar%,text)", "", context) + self.assertScriptResultEquals("$gt(%bar%,%foo%,text)", "1", context) + self.assertScriptResultEquals("$gt(%foo%,%baz%,text)", "", context) + self.assertScriptResultEquals("$gt(%baz%,%foo%,text)", "1", context) + self.assertScriptResultEquals("$gt(%foo%,%foo%,text)", "", context) - # Test text type arguments (text processing) + # Test text type arguments with "text" processing context["foo"] = "abc" context["bar"] = "abcd" context["baz"] = "ac" - self.assertScriptResultEquals("$gt(%foo%,%bar%,1)", "", context) - self.assertScriptResultEquals("$gt(%bar%,%foo%,1)", "1", context) - self.assertScriptResultEquals("$gt(%foo%,%baz%,1)", "", context) - self.assertScriptResultEquals("$gt(%baz%,%foo%,1)", "1", context) - self.assertScriptResultEquals("$gt(%foo%,%foo%,1)", "", context) + self.assertScriptResultEquals("$gt(%foo%,%bar%,text)", "", context) + self.assertScriptResultEquals("$gt(%bar%,%foo%,text)", "1", context) + self.assertScriptResultEquals("$gt(%foo%,%baz%,text)", "", context) + self.assertScriptResultEquals("$gt(%baz%,%foo%,text)", "1", context) + self.assertScriptResultEquals("$gt(%foo%,%foo%,text)", "", context) - # Test with empty arguments (integer processing) + # Test with empty arguments (default processing) self.assertScriptResultEquals("$gt(,1)", "", context) self.assertScriptResultEquals("$gt(1,)", "", context) self.assertScriptResultEquals("$gt(,)", "", context) - # Test with empty arguments (text processing) - self.assertScriptResultEquals("$gt(,a,1)", "", context) - self.assertScriptResultEquals("$gt(a,,1)", "1", context) - self.assertScriptResultEquals("$gt(,,1)", "", context) + # Test with empty arguments ("int" processing) + self.assertScriptResultEquals("$gt(,1,int)", "", context) + self.assertScriptResultEquals("$gt(1,,int)", "", context) + self.assertScriptResultEquals("$gt(,,int)", "", context) - # Test case sensitive arguments (text processing) - self.assertScriptResultEquals("$gt(A,a,1)", "", context) - self.assertScriptResultEquals("$gt(a,A,1)", "1", context) + # Test with empty arguments ("float" processing) + self.assertScriptResultEquals("$gt(,1.1,float)", "", context) + self.assertScriptResultEquals("$gt(1.1,float)", "", context) + self.assertScriptResultEquals("$gt(,,float)", "", context) + + # Test with empty arguments ("text" processing) + self.assertScriptResultEquals("$gt(,a,text)", "", context) + self.assertScriptResultEquals("$gt(a,,text)", "1", context) + self.assertScriptResultEquals("$gt(,,text)", "", context) + + # Test case sensitive arguments ("text" processing) + self.assertScriptResultEquals("$gt(A,a,text)", "", context) + self.assertScriptResultEquals("$gt(a,A,text)", "1", context) + + # Test unknown processing type + self.assertScriptResultEquals("$gt(2,1,unknown)", "", context) # Tests with invalid number of arguments areg = r"^\d+:\d+:\$gt: Wrong number of arguments for \$gt: Expected between 2 and 3, " @@ -639,51 +668,82 @@ class ScriptParserTest(PicardTestCase): with self.assertRaisesRegex(ScriptError, areg): self.parser.eval("$gt(1)") with self.assertRaisesRegex(ScriptError, areg): - self.parser.eval("$gt(foo,bar,1,)") + self.parser.eval("$gt(foo,bar,text,)") def test_cmd_gte(self): context = Metadata() - # Test with integer values (default processing) + # Test with default processing + self.assertScriptResultEquals("$gte(10,10.1)", "") self.assertScriptResultEquals("$gte(10,10)", "1") self.assertScriptResultEquals("$gte(10,4)", "1") self.assertScriptResultEquals("$gte(6,4)", "1") self.assertScriptResultEquals("$gte(6,7)", "") self.assertScriptResultEquals("$gte(a,b)", "") - # Test date type arguments (text processing) + # 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) context["foo"] = "2020-01-01" context["bar"] = "2020-01-02" context["baz"] = "2020-02" - self.assertScriptResultEquals("$gte(%foo%,%bar%,1)", "", context) - self.assertScriptResultEquals("$gte(%bar%,%foo%,1)", "1", context) - self.assertScriptResultEquals("$gte(%foo%,%baz%,1)", "", context) - self.assertScriptResultEquals("$gte(%baz%,%foo%,1)", "1", context) - self.assertScriptResultEquals("$gte(%foo%,%foo%,1)", "1", context) + self.assertScriptResultEquals("$gte(%foo%,%bar%,text)", "", context) + self.assertScriptResultEquals("$gte(%bar%,%foo%,text)", "1", context) + self.assertScriptResultEquals("$gte(%foo%,%baz%,text)", "", context) + self.assertScriptResultEquals("$gte(%baz%,%foo%,text)", "1", context) + self.assertScriptResultEquals("$gte(%foo%,%foo%,text)", "1", context) - # Test text type arguments (text processing) + # Test text type arguments ("text" processing) context["foo"] = "abc" context["bar"] = "abcd" context["baz"] = "ac" - self.assertScriptResultEquals("$gte(%foo%,%bar%,1)", "", context) - self.assertScriptResultEquals("$gte(%bar%,%foo%,1)", "1", context) - self.assertScriptResultEquals("$gte(%foo%,%baz%,1)", "", context) - self.assertScriptResultEquals("$gte(%baz%,%foo%,1)", "1", context) - self.assertScriptResultEquals("$gte(%foo%,%foo%,1)", "1", context) + self.assertScriptResultEquals("$gte(%foo%,%bar%,text)", "", context) + self.assertScriptResultEquals("$gte(%bar%,%foo%,text)", "1", context) + self.assertScriptResultEquals("$gte(%foo%,%baz%,text)", "", context) + self.assertScriptResultEquals("$gte(%baz%,%foo%,text)", "1", context) + self.assertScriptResultEquals("$gte(%foo%,%foo%,text)", "1", context) - # Test with empty arguments (integer processing) + # Test with empty arguments (default processing) self.assertScriptResultEquals("$gte(,1)", "", context) self.assertScriptResultEquals("$gte(1,)", "", context) self.assertScriptResultEquals("$gte(,)", "", context) - # Test with empty arguments (text processing) - self.assertScriptResultEquals("$gte(,a,1)", "", context) - self.assertScriptResultEquals("$gte(a,,1)", "1", context) - self.assertScriptResultEquals("$gte(,,1)", "1", context) + # Test with empty arguments ("int" processing) + self.assertScriptResultEquals("$gte(,1,int)", "", context) + self.assertScriptResultEquals("$gte(1,,int)", "", context) + self.assertScriptResultEquals("$gte(,,int)", "", context) - # Test case sensitive arguments (text processing) - self.assertScriptResultEquals("$gte(A,a,1)", "", context) - self.assertScriptResultEquals("$gte(a,A,1)", "1", context) + # Test with empty arguments ("float" processing) + self.assertScriptResultEquals("$gte(,1,float)", "", context) + self.assertScriptResultEquals("$gte(1,float)", "", context) + self.assertScriptResultEquals("$gte(,,float)", "", context) + + # Test with empty arguments ("text" processing) + self.assertScriptResultEquals("$gte(,a,text)", "", context) + self.assertScriptResultEquals("$gte(a,,text)", "1", context) + self.assertScriptResultEquals("$gte(,,text)", "1", context) + + # Test case sensitive arguments ("text" processing) + self.assertScriptResultEquals("$gte(A,a,text)", "", context) + self.assertScriptResultEquals("$gte(a,A,text)", "1", context) + + # Test unknown processing type + self.assertScriptResultEquals("$gte(2,1,unknown)", "", context) # Tests with invalid number of arguments areg = r"^\d+:\d+:\$gte: Wrong number of arguments for \$gte: Expected between 2 and 3, " @@ -692,51 +752,83 @@ class ScriptParserTest(PicardTestCase): with self.assertRaisesRegex(ScriptError, areg): self.parser.eval("$gte(1)") with self.assertRaisesRegex(ScriptError, areg): - self.parser.eval("$gte(foo,bar,1,)") + self.parser.eval("$gte(foo,bar,text,)") def test_cmd_lt(self): context = Metadata() - # Test with integer values (default processing) - self.assertScriptResultEquals("$lt(4,10)", "1") + # Test with default processing self.assertScriptResultEquals("$lt(4,6)", "1") + self.assertScriptResultEquals("$lt(4,6.1)", "") self.assertScriptResultEquals("$lt(4,3)", "") + self.assertScriptResultEquals("$lt(4,4.1)", "") + self.assertScriptResultEquals("$lt(4.1,4.2)", "") self.assertScriptResultEquals("$lt(4,4)", "") self.assertScriptResultEquals("$lt(a,b)", "") - # Test date type arguments (text processing) + # 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) context["foo"] = "2020-01-01" context["bar"] = "2020-01-02" context["baz"] = "2020-02" - self.assertScriptResultEquals("$lt(%foo%,%bar%,1)", "1", context) - self.assertScriptResultEquals("$lt(%bar%,%foo%,1)", "", context) - self.assertScriptResultEquals("$lt(%foo%,%baz%,1)", "1", context) - self.assertScriptResultEquals("$lt(%baz%,%foo%,1)", "", context) - self.assertScriptResultEquals("$lt(%foo%,%foo%,1)", "", context) + self.assertScriptResultEquals("$lt(%foo%,%bar%,text)", "1", context) + self.assertScriptResultEquals("$lt(%bar%,%foo%,text)", "", context) + self.assertScriptResultEquals("$lt(%foo%,%baz%,text)", "1", context) + self.assertScriptResultEquals("$lt(%baz%,%foo%,text)", "", context) + self.assertScriptResultEquals("$lt(%foo%,%foo%,text)", "", context) - # Test text type arguments (text processing) + # Test text type arguments ("text" processing) context["foo"] = "abc" context["bar"] = "abcd" context["baz"] = "ac" - self.assertScriptResultEquals("$lt(%foo%,%bar%,1)", "1", context) - self.assertScriptResultEquals("$lt(%bar%,%foo%,1)", "", context) - self.assertScriptResultEquals("$lt(%foo%,%baz%,1)", "1", context) - self.assertScriptResultEquals("$lt(%baz%,%foo%,1)", "", context) - self.assertScriptResultEquals("$lt(%foo%,%foo%,1)", "", context) + self.assertScriptResultEquals("$lt(%foo%,%bar%,text)", "1", context) + self.assertScriptResultEquals("$lt(%bar%,%foo%,text)", "", context) + self.assertScriptResultEquals("$lt(%foo%,%baz%,text)", "1", context) + self.assertScriptResultEquals("$lt(%baz%,%foo%,text)", "", context) + self.assertScriptResultEquals("$lt(%foo%,%foo%,text)", "", context) - # Test with empty arguments (integer processing) + # Test with empty arguments (default processing) self.assertScriptResultEquals("$lt(,1)", "", context) self.assertScriptResultEquals("$lt(1,)", "", context) self.assertScriptResultEquals("$lt(,)", "", context) - # Test with empty arguments (text processing) - self.assertScriptResultEquals("$lt(,a,1)", "1", context) - self.assertScriptResultEquals("$lt(a,,1)", "", context) - self.assertScriptResultEquals("$lt(,,1)", "", context) + # Test with empty arguments ("int" processing) + self.assertScriptResultEquals("$lt(,1,int)", "", context) + self.assertScriptResultEquals("$lt(1,,int)", "", context) + self.assertScriptResultEquals("$lt(,,int)", "", context) - # Test case sensitive arguments (text processing) - self.assertScriptResultEquals("$lt(A,a,1)", "1", context) - self.assertScriptResultEquals("$lt(a,A,1)", "", context) + # Test with empty arguments ("float" processing) + self.assertScriptResultEquals("$lt(,1,float)", "", context) + self.assertScriptResultEquals("$lt(1,,float)", "", context) + self.assertScriptResultEquals("$lt(,,float)", "", context) + + # Test with empty arguments ("text" processing) + self.assertScriptResultEquals("$lt(,a,text)", "1", context) + self.assertScriptResultEquals("$lt(a,,text)", "", context) + self.assertScriptResultEquals("$lt(,,text)", "", context) + + # Test case sensitive arguments ("text" processing) + self.assertScriptResultEquals("$lt(A,a,text)", "1", context) + self.assertScriptResultEquals("$lt(a,A,text)", "", context) + + # Test unknown processing type + self.assertScriptResultEquals("$lt(1,2,unknown)", "", context) # Tests with invalid number of arguments areg = r"^\d+:\d+:\$lt: Wrong number of arguments for \$lt: Expected between 2 and 3, " @@ -745,51 +837,79 @@ class ScriptParserTest(PicardTestCase): with self.assertRaisesRegex(ScriptError, areg): self.parser.eval("$lt(1)") with self.assertRaisesRegex(ScriptError, areg): - self.parser.eval("$lt(foo,bar,1,)") + self.parser.eval("$lt(foo,bar,text,)") def test_cmd_lte(self): context = Metadata() - # Test with integer values (default processing) + # Test with default processing self.assertScriptResultEquals("$lte(10,10)", "1") + self.assertScriptResultEquals("$lte(10.1,10.2)", "") self.assertScriptResultEquals("$lte(4,10)", "1") - self.assertScriptResultEquals("$lte(4,6)", "1") self.assertScriptResultEquals("$lte(4,3)", "") self.assertScriptResultEquals("$lte(a,b)", "") - # Test date type arguments (text processing) + # 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) context["foo"] = "2020-01-01" context["bar"] = "2020-01-02" context["baz"] = "2020-02" - self.assertScriptResultEquals("$lte(%foo%,%bar%,1)", "1", context) - self.assertScriptResultEquals("$lte(%bar%,%foo%,1)", "", context) - self.assertScriptResultEquals("$lte(%foo%,%baz%,1)", "1", context) - self.assertScriptResultEquals("$lte(%baz%,%foo%,1)", "", context) - self.assertScriptResultEquals("$lte(%foo%,%foo%,1)", "1", context) + self.assertScriptResultEquals("$lte(%foo%,%bar%,text)", "1", context) + self.assertScriptResultEquals("$lte(%bar%,%foo%,text)", "", context) + self.assertScriptResultEquals("$lte(%foo%,%baz%,text)", "1", context) + self.assertScriptResultEquals("$lte(%baz%,%foo%,text)", "", context) + self.assertScriptResultEquals("$lte(%foo%,%foo%,text)", "1", context) - # Test text type arguments (text processing) + # Test text type arguments ("text" processing) context["foo"] = "abc" context["bar"] = "abcd" context["baz"] = "ac" - self.assertScriptResultEquals("$lte(%foo%,%bar%,1)", "1", context) - self.assertScriptResultEquals("$lte(%bar%,%foo%,1)", "", context) - self.assertScriptResultEquals("$lte(%foo%,%baz%,1)", "1", context) - self.assertScriptResultEquals("$lte(%baz%,%foo%,1)", "", context) - self.assertScriptResultEquals("$lte(%foo%,%foo%,1)", "1", context) + self.assertScriptResultEquals("$lte(%foo%,%bar%,text)", "1", context) + self.assertScriptResultEquals("$lte(%bar%,%foo%,text)", "", context) + self.assertScriptResultEquals("$lte(%foo%,%baz%,text)", "1", context) + self.assertScriptResultEquals("$lte(%baz%,%foo%,text)", "", context) + self.assertScriptResultEquals("$lte(%foo%,%foo%,text)", "1", context) - # Test with empty arguments (integer processing) + # Test with empty arguments (default processing) self.assertScriptResultEquals("$lte(,1)", "", context) self.assertScriptResultEquals("$lte(1,)", "", context) self.assertScriptResultEquals("$lte(,)", "", context) - # Test with empty arguments (text processing) - self.assertScriptResultEquals("$lte(,a,1)", "1", context) - self.assertScriptResultEquals("$lte(a,,1)", "", context) - self.assertScriptResultEquals("$lte(,,1)", "1", context) + # Test with empty arguments ("int" processing) + self.assertScriptResultEquals("$lte(,1,int)", "", context) + self.assertScriptResultEquals("$lte(1,,int)", "", context) + self.assertScriptResultEquals("$lte(,,int)", "", context) - # Test case sensitive arguments (text processing) - self.assertScriptResultEquals("$lte(A,a,1)", "1", context) - self.assertScriptResultEquals("$lte(a,A,1)", "", context) + # Test with empty arguments ("float" processing) + self.assertScriptResultEquals("$lte(,1,float)", "", context) + self.assertScriptResultEquals("$lte(1,,float)", "", context) + self.assertScriptResultEquals("$lte(,,float)", "", context) + + # Test with empty arguments ("text" processing) + self.assertScriptResultEquals("$lte(,a,text)", "1", context) + self.assertScriptResultEquals("$lte(a,,text)", "", context) + self.assertScriptResultEquals("$lte(,,text)", "1", context) + + # Test case sensitive arguments ("text" processing) + self.assertScriptResultEquals("$lte(A,a,text)", "1", context) + self.assertScriptResultEquals("$lte(a,A,text)", "", context) + + # Test unknown processing type + self.assertScriptResultEquals("$lte(1,2,unknown)", "", context) # Tests with invalid number of arguments areg = r"^\d+:\d+:\$lte: Wrong number of arguments for \$lte: Expected between 2 and 3, " @@ -798,7 +918,7 @@ class ScriptParserTest(PicardTestCase): with self.assertRaisesRegex(ScriptError, areg): self.parser.eval("$lte(1)") with self.assertRaisesRegex(ScriptError, areg): - self.parser.eval("$lte(foo,bar,1,)") + self.parser.eval("$lte(foo,bar,text,)") def test_cmd_len(self): self.assertScriptResultEquals("$len(abcdefg)", "7") @@ -2058,68 +2178,112 @@ class ScriptParserTest(PicardTestCase): with self.assertRaisesRegex(ScriptError, areg): self.parser.eval("$cleanmulti(foo,)") - def test_cmd_textmin(self): + def test_cmd_min(self): context = Metadata() - # Test date type arguments - context["foo"] = "2020-01-01" - context["bar"] = "2020-01-02" - context["baz"] = "2020-02" - self.assertScriptResultEquals("$textmin(%foo%)", "2020-01-01", context) - self.assertScriptResultEquals("$textmin(%foo%,%bar%,%baz%)", "2020-01-01", context) - self.assertScriptResultEquals("$textmin(%baz%,%bar%,%foo%)", "2020-01-01", context) - - # Test text type arguments + # Test "text" processing context["foo"] = "abc" context["bar"] = "abcd" context["baz"] = "ac" - self.assertScriptResultEquals("$textmin(%foo%)", "abc", context) - self.assertScriptResultEquals("$textmin(%foo%,%bar%,%baz%)", "abc", context) - self.assertScriptResultEquals("$textmin(%baz%,%bar%,%foo%)", "abc", context) + self.assertScriptResultEquals("$min(text,%foo%)", "abc", context) + self.assertScriptResultEquals("$min(text,%foo%,%bar%,%baz%)", "abc", context) + self.assertScriptResultEquals("$min(text,%baz%,%bar%,%foo%)", "abc", context) + self.assertScriptResultEquals("$min(text,,a)", "", context) + self.assertScriptResultEquals("$min(text,a,)", "", context) + self.assertScriptResultEquals("$min(text,,)", "", context) - # Test with empty arguments - self.assertScriptResultEquals("$textmin(,a)", "", context) - self.assertScriptResultEquals("$textmin(a,)", "", context) - self.assertScriptResultEquals("$textmin(,)", "", context) - - # Test case sensitive arguments - self.assertScriptResultEquals("$textmin(A,a)", "A", context) - self.assertScriptResultEquals("$textmin(a,B)", "B", context) - - # Tests with invalid number of arguments - areg = r"^\d+:\d+:\$textmin: Wrong number of arguments for \$textmin: Expected at least 1, " - with self.assertRaisesRegex(ScriptError, areg): - self.parser.eval("$textmin()") - - def test_cmd_textmax(self): - context = Metadata() - - # Test date type arguments + # Test date type arguments using "text" processing context["foo"] = "2020-01-01" context["bar"] = "2020-01-02" context["baz"] = "2020-02" - self.assertScriptResultEquals("$textmax(%foo%)", "2020-01-01", context) - self.assertScriptResultEquals("$textmax(%foo%,%bar%,%baz%)", "2020-02", context) - self.assertScriptResultEquals("$textmax(%baz%,%bar%,%foo%)", "2020-02", context) + self.assertScriptResultEquals("$min(text,%foo%)", "2020-01-01", context) + self.assertScriptResultEquals("$min(text,%foo%,%bar%,%baz%)", "2020-01-01", context) + self.assertScriptResultEquals("$min(text,%baz%,%bar%,%foo%)", "2020-01-01", context) - # Test text type arguments + # Test "int" processing + self.assertScriptResultEquals("$min(int,1)", "1", context) + self.assertScriptResultEquals("$min(int,2,3)", "2", context) + self.assertScriptResultEquals("$min(int,2,1,3)", "1", context) + self.assertScriptResultEquals("$min(int,2,1,3.1)", "", context) + self.assertScriptResultEquals("$min(int,2,1,a)", "", context) + self.assertScriptResultEquals("$min(int,2,,1)", "", context) + self.assertScriptResultEquals("$min(int,2,1,)", "", context) + + # Test "float" processing + self.assertScriptResultEquals("$min(float,1)", "1.0", context) + self.assertScriptResultEquals("$min(float,2,3)", "2.0", context) + self.assertScriptResultEquals("$min(float,2,1,3)", "1.0", context) + self.assertScriptResultEquals("$min(float,2,1.1,3)", "1.1", context) + self.assertScriptResultEquals("$min(float,2,1,a)", "", context) + self.assertScriptResultEquals("$min(float,2,,1)", "", context) + self.assertScriptResultEquals("$min(float,2,1,)", "", context) + + # Test case sensitive arguments + self.assertScriptResultEquals("$min(text,A,a)", "A", context) + self.assertScriptResultEquals("$min(text,a,B)", "B", context) + + # Test invalid processing types + self.assertScriptResultEquals("$min(,A,a)", "", context) + self.assertScriptResultEquals("$min(unknown,a,B)", "", context) + + # 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): + context = Metadata() + + # Test "text" processing context["foo"] = "abc" context["bar"] = "abcd" context["baz"] = "ac" - self.assertScriptResultEquals("$textmax(%foo%)", "abc", context) - self.assertScriptResultEquals("$textmax(%foo%,%bar%,%baz%)", "ac", context) - self.assertScriptResultEquals("$textmax(%baz%,%bar%,%foo%)", "ac", context) + self.assertScriptResultEquals("$max(text,%foo%)", "abc", context) + self.assertScriptResultEquals("$max(text,%foo%,%bar%,%baz%)", "ac", context) + self.assertScriptResultEquals("$max(text,%baz%,%bar%,%foo%)", "ac", context) + self.assertScriptResultEquals("$max(text,,a)", "a", context) + self.assertScriptResultEquals("$max(text,a,)", "a", context) + self.assertScriptResultEquals("$max(text,,)", "", context) - # Test with empty arguments - self.assertScriptResultEquals("$textmax(,a)", "a", context) - self.assertScriptResultEquals("$textmax(a,)", "a", context) - self.assertScriptResultEquals("$textmax(,)", "", context) + # Test date type arguments using "text" processing + context["foo"] = "2020-01-01" + context["bar"] = "2020-01-02" + context["baz"] = "2020-02" + self.assertScriptResultEquals("$max(text,%foo%)", "2020-01-01", context) + self.assertScriptResultEquals("$max(text,%foo%,%bar%,%baz%)", "2020-02", context) + self.assertScriptResultEquals("$max(text,%baz%,%bar%,%foo%)", "2020-02", context) + + # Test "int" processing + self.assertScriptResultEquals("$max(int,1)", "1", context) + self.assertScriptResultEquals("$max(int,2,3)", "3", context) + self.assertScriptResultEquals("$max(int,2,1,3)", "3", context) + self.assertScriptResultEquals("$max(int,2,1,3.1)", "", context) + self.assertScriptResultEquals("$max(int,2,1,a)", "", context) + self.assertScriptResultEquals("$max(int,2,,1)", "", context) + self.assertScriptResultEquals("$max(int,2,1,)", "", context) + + # Test "float" processing + self.assertScriptResultEquals("$max(float,1)", "1.0", context) + self.assertScriptResultEquals("$max(float,2,3)", "3.0", context) + self.assertScriptResultEquals("$max(float,2,1.1,3)", "3.0", context) + self.assertScriptResultEquals("$max(float,2,1,3.1)", "3.1", context) + self.assertScriptResultEquals("$max(float,2,1,a)", "", context) + self.assertScriptResultEquals("$max(float,2,,1)", "", context) + self.assertScriptResultEquals("$max(float,2,1,)", "", context) # Test case sensitive arguments - self.assertScriptResultEquals("$textmax(A,a)", "a", context) - self.assertScriptResultEquals("$textmax(a,B)", "a", context) + self.assertScriptResultEquals("$max(text,A,a)", "a", context) + self.assertScriptResultEquals("$max(text,a,B)", "a", context) + + # Test invalid processing types + self.assertScriptResultEquals("$max(,A,a)", "", context) + self.assertScriptResultEquals("$max(unknown,a,B)", "", context) # Tests with invalid number of arguments - areg = r"^\d+:\d+:\$textmax: Wrong number of arguments for \$textmax: Expected at least 1, " + areg = r"^\d+:\d+:\$max: Wrong number of arguments for \$max: Expected at least 2, " with self.assertRaisesRegex(ScriptError, areg): - self.parser.eval("$textmax()") + self.parser.eval("$max()") + with self.assertRaisesRegex(ScriptError, areg): + self.parser.eval("$max(text)")