diff --git a/test/test_script.py b/test/test_script.py
index 352dc2963..64bbf4149 100644
--- a/test/test_script.py
+++ b/test/test_script.py
@@ -17,29 +17,44 @@ class ScriptParserTest(unittest.TestCase):
             return ""
         register_script_function(func_noargstest, "noargstest")
 
+    def assertScriptResultEquals(self, script, expected, context=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)
+        self.assertEqual(actual,
+                         expected,
+                         "'%s' evaluated to '%s', expected '%s'"
+                         % (script, actual, expected))
+
     def test_cmd_noop(self):
-        self.assertEqual(self.parser.eval("$noop()"), "")
-        self.assertEqual(self.parser.eval("$noop(abcdefg)"), "")
+        self.assertScriptResultEquals("$noop()", "")
+        self.assertScriptResultEquals("$noop(abcdefg)", "")
 
     def test_cmd_if(self):
-        self.assertEqual(self.parser.eval("$if(1,a,b)"), "a")
-        self.assertEqual(self.parser.eval("$if(,a,b)"), "b")
+        self.assertScriptResultEquals("$if(1,a,b)", "a")
+        self.assertScriptResultEquals("$if(,a,b)", "b")
 
     def test_cmd_if2(self):
-        self.assertEqual(self.parser.eval("$if2(,a,b)"), "a")
-        self.assertEqual(self.parser.eval("$if2($noop(),b)"), "b")
+        self.assertScriptResultEquals("$if2(,a,b)", "a")
+        self.assertScriptResultEquals("$if2($noop(),b)", "b")
 
     def test_cmd_left(self):
-        self.assertEqual(self.parser.eval("$left(abcd,2)"), "ab")
+        self.assertScriptResultEquals("$left(abcd,2)", "ab")
 
     def test_cmd_right(self):
-        self.assertEqual(self.parser.eval("$right(abcd,2)"), "cd")
+        self.assertScriptResultEquals("$right(abcd,2)", "cd")
 
     def test_cmd_set(self):
-        self.assertEqual(self.parser.eval("$set(test,aaa)%test%"), "aaa")
+        self.assertScriptResultEquals("$set(test,aaa)%test%", "aaa")
 
     def test_cmd_set_empty(self):
-        self.assertEqual(self.parser.eval("$set(test,)%test%"), "")
+        self.assertScriptResultEquals("$set(test,)%test%", "")
 
     def test_cmd_set_multi_valued(self):
         context = Metadata()
@@ -84,78 +99,78 @@ class ScriptParserTest(unittest.TestCase):
     def test_cmd_get(self):
         context = Metadata()
         context["test"] = "aaa"
-        self.assertEqual(self.parser.eval("$get(test)", context), "aaa")
+        self.assertScriptResultEquals("$get(test)", "aaa", context)
         context["test2"] = ["multi", "valued"]
-        self.assertEqual(self.parser.eval("$get(test2)", context), "multi; valued")
+        self.assertScriptResultEquals("$get(test2)", "multi; valued", context)
 
     def test_cmd_num(self):
-        self.assertEqual(self.parser.eval("$num(3,3)"), "003")
-        self.assertEqual(self.parser.eval("$num(03,3)"), "003")
-        self.assertEqual(self.parser.eval("$num(123,2)"), "123")
+        self.assertScriptResultEquals("$num(3,3)", "003")
+        self.assertScriptResultEquals("$num(03,3)", "003")
+        self.assertScriptResultEquals("$num(123,2)", "123")
 
     def test_cmd_or(self):
-        self.assertEqual(self.parser.eval("$or(,)"), "")
-        self.assertEqual(self.parser.eval("$or(,,)"), "")
-        self.assertEqual(self.parser.eval("$or(,q)"), "1")
-        self.assertEqual(self.parser.eval("$or(q,)"), "1")
-        self.assertEqual(self.parser.eval("$or(q,q)"), "1")
-        self.assertEqual(self.parser.eval("$or(q,,)"), "1")
+        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.assertEqual(self.parser.eval("$and(,)"), "")
-        self.assertEqual(self.parser.eval("$and(,q)"), "")
-        self.assertEqual(self.parser.eval("$and(q,)"), "")
-        self.assertEqual(self.parser.eval("$and(q,q,)"), "")
-        self.assertEqual(self.parser.eval("$and(q,q)"), "1")
-        self.assertEqual(self.parser.eval("$and(q,q,q)"), "1")
+        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.assertEqual(self.parser.eval("$not($noop())"), "1")
-        self.assertEqual(self.parser.eval("$not(q)"), "")
+        self.assertScriptResultEquals("$not($noop())", "1")
+        self.assertScriptResultEquals("$not(q)", "")
 
     def test_cmd_add(self):
-        self.assertEqual(self.parser.eval("$add(1,2)"), "3")
-        self.assertEqual(self.parser.eval("$add(1,2,3)"), "6")
+        self.assertScriptResultEquals("$add(1,2)", "3")
+        self.assertScriptResultEquals("$add(1,2,3)", "6")
 
     def test_cmd_sub(self):
-        self.assertEqual(self.parser.eval("$sub(1,2)"), "-1")
-        self.assertEqual(self.parser.eval("$sub(2,1)"), "1")
-        self.assertEqual(self.parser.eval("$sub(4,2,1)"), "1")
+        self.assertScriptResultEquals("$sub(1,2)", "-1")
+        self.assertScriptResultEquals("$sub(2,1)", "1")
+        self.assertScriptResultEquals("$sub(4,2,1)", "1")
 
     def test_cmd_div(self):
-        self.assertEqual(self.parser.eval("$div(9,3)"), "3")
-        self.assertEqual(self.parser.eval("$div(10,3)"), "3")
-        self.assertEqual(self.parser.eval("$div(30,3,3)"), "3")
+        self.assertScriptResultEquals("$div(9,3)", "3")
+        self.assertScriptResultEquals("$div(10,3)", "3")
+        self.assertScriptResultEquals("$div(30,3,3)", "3")
 
     def test_cmd_mod(self):
-        self.assertEqual(self.parser.eval("$mod(9,3)"), "0")
-        self.assertEqual(self.parser.eval("$mod(10,3)"), "1")
-        self.assertEqual(self.parser.eval("$mod(10,6,3)"), "1")
+        self.assertScriptResultEquals("$mod(9,3)", "0")
+        self.assertScriptResultEquals("$mod(10,3)", "1")
+        self.assertScriptResultEquals("$mod(10,6,3)", "1")
 
     def test_cmd_mul(self):
-        self.assertEqual(self.parser.eval("$mul(9,3)"), "27")
-        self.assertEqual(self.parser.eval("$mul(10,3)"), "30")
-        self.assertEqual(self.parser.eval("$mul(2,5,3)"), "30")
+        self.assertScriptResultEquals("$mul(9,3)", "27")
+        self.assertScriptResultEquals("$mul(10,3)", "30")
+        self.assertScriptResultEquals("$mul(2,5,3)", "30")
 
     def test_cmd_eq(self):
-        self.assertEqual(self.parser.eval("$eq(,)"), "1")
-        self.assertEqual(self.parser.eval("$eq(,$noop())"), "1")
-        self.assertEqual(self.parser.eval("$eq(,q)"), "")
-        self.assertEqual(self.parser.eval("$eq(q,q)"), "1")
-        self.assertEqual(self.parser.eval("$eq(q,)"), "")
+        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.assertEqual(self.parser.eval("$ne(,)"), "")
-        self.assertEqual(self.parser.eval("$ne(,$noop())"), "")
-        self.assertEqual(self.parser.eval("$ne(,q)"), "1")
-        self.assertEqual(self.parser.eval("$ne(q,q)"), "")
-        self.assertEqual(self.parser.eval("$ne(q,)"), "1")
+        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.assertEqual(self.parser.eval("$lower(AbeCeDA)"), "abeceda")
+        self.assertScriptResultEquals("$lower(AbeCeDA)", "abeceda")
 
     def test_cmd_upper(self):
-        self.assertEqual(self.parser.eval("$upper(AbeCeDA)"), "ABECEDA")
+        self.assertScriptResultEquals("$upper(AbeCeDA)", "ABECEDA")
 
     def test_cmd_rreplace(self):
         self.assertEqual(
@@ -175,77 +190,77 @@ class ScriptParserTest(unittest.TestCase):
                 r"$set(bleh,$rsearch(test \(disc 1\),\\\(disc \(\\d+\)\\\)))) $set(wer,1)"))
 
     def test_cmd_gt(self):
-        self.assertEqual(self.parser.eval("$gt(10,4)"), "1")
-        self.assertEqual(self.parser.eval("$gt(6,4)"), "1")
+        self.assertScriptResultEquals("$gt(10,4)", "1")
+        self.assertScriptResultEquals("$gt(6,4)", "1")
 
     def test_cmd_gte(self):
-        self.assertEqual(self.parser.eval("$gte(10,10)"), "1")
-        self.assertEqual(self.parser.eval("$gte(10,4)"), "1")
-        self.assertEqual(self.parser.eval("$gte(6,4)"), "1")
+        self.assertScriptResultEquals("$gte(10,10)", "1")
+        self.assertScriptResultEquals("$gte(10,4)", "1")
+        self.assertScriptResultEquals("$gte(6,4)", "1")
 
     def test_cmd_lt(self):
-        self.assertEqual(self.parser.eval("$lt(4,10)"), "1")
-        self.assertEqual(self.parser.eval("$lt(4,6)"), "1")
+        self.assertScriptResultEquals("$lt(4,10)", "1")
+        self.assertScriptResultEquals("$lt(4,6)", "1")
 
     def test_cmd_lte(self):
-        self.assertEqual(self.parser.eval("$lte(10,10)"), "1")
-        self.assertEqual(self.parser.eval("$lte(4,10)"), "1")
-        self.assertEqual(self.parser.eval("$lte(4,6)"), "1")
+        self.assertScriptResultEquals("$lte(10,10)", "1")
+        self.assertScriptResultEquals("$lte(4,10)", "1")
+        self.assertScriptResultEquals("$lte(4,6)", "1")
 
     def test_cmd_len(self):
-        self.assertEqual(self.parser.eval("$len(abcdefg)"), "7")
-        self.assertEqual(self.parser.eval("$len(0)"), "1")
-        self.assertEqual(self.parser.eval("$len()"), "0")
+        self.assertScriptResultEquals("$len(abcdefg)", "7")
+        self.assertScriptResultEquals("$len(0)", "1")
+        self.assertScriptResultEquals("$len()", "0")
 
     def test_cmd_firstalphachar(self):
-        self.assertEqual(self.parser.eval("$firstalphachar(abc)"), "A")
-        self.assertEqual(self.parser.eval("$firstalphachar(Abc)"), "A")
-        self.assertEqual(self.parser.eval("$firstalphachar(1abc)"), "#")
-        self.assertEqual(self.parser.eval("$firstalphachar(...abc)"), "#")
-        self.assertEqual(self.parser.eval("$firstalphachar(1abc,_)"), "_")
-        self.assertEqual(self.parser.eval("$firstalphachar(...abc,_)"), "_")
-        self.assertEqual(self.parser.eval("$firstalphachar()"), "#")
-        self.assertEqual(self.parser.eval("$firstalphachar(,_)"), "_")
-        self.assertEqual(self.parser.eval("$firstalphachar( abc)"), "#")
+        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.assertEqual(self.parser.eval("$initials(Abc def Ghi)"), "AdG")
-        self.assertEqual(self.parser.eval("$initials(Abc #def Ghi)"), "AG")
-        self.assertEqual(self.parser.eval("$initials(Abc 1def Ghi)"), "AG")
-        self.assertEqual(self.parser.eval("$initials(Abc)"), "A")
-        self.assertEqual(self.parser.eval("$initials()"), "")
+        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.assertEqual(self.parser.eval("$firstwords(Abc Def Ghi,11)"), "Abc Def Ghi")
-        self.assertEqual(self.parser.eval("$firstwords(Abc Def Ghi,12)"), "Abc Def Ghi")
-        self.assertEqual(self.parser.eval("$firstwords(Abc Def Ghi,7)"), "Abc Def")
-        self.assertEqual(self.parser.eval("$firstwords(Abc Def Ghi,8)"), "Abc Def")
-        self.assertEqual(self.parser.eval("$firstwords(Abc Def Ghi,6)"), "Abc")
-        self.assertEqual(self.parser.eval("$firstwords(Abc Def Ghi,0)"), "")
-        self.assertEqual(self.parser.eval("$firstwords(Abc Def Ghi,NaN)"), "")
-        self.assertEqual(self.parser.eval("$firstwords(Abc Def Ghi,)"), "")
+        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,)", "")
 
     def test_cmd_startswith(self):
-        self.assertEqual(self.parser.eval("$startswith(abc,a)"), "1")
-        self.assertEqual(self.parser.eval("$startswith(abc,abc)"), "1")
-        self.assertEqual(self.parser.eval("$startswith(abc,)"), "1")
-        self.assertEqual(self.parser.eval("$startswith(abc,b)"), "0")
-        self.assertEqual(self.parser.eval("$startswith(abc,Ab)"), "0")
+        self.assertScriptResultEquals("$startswith(abc,a)", "1")
+        self.assertScriptResultEquals("$startswith(abc,abc)", "1")
+        self.assertScriptResultEquals("$startswith(abc,)", "1")
+        self.assertScriptResultEquals("$startswith(abc,b)", "0")
+        self.assertScriptResultEquals("$startswith(abc,Ab)", "0")
 
     def test_cmd_endswith(self):
-        self.assertEqual(self.parser.eval("$endswith(abc,c)"), "1")
-        self.assertEqual(self.parser.eval("$endswith(abc,abc)"), "1")
-        self.assertEqual(self.parser.eval("$endswith(abc,)"), "1")
-        self.assertEqual(self.parser.eval("$endswith(abc,b)"), "0")
-        self.assertEqual(self.parser.eval("$endswith(abc,bC)"), "0")
+        self.assertScriptResultEquals("$endswith(abc,c)", "1")
+        self.assertScriptResultEquals("$endswith(abc,abc)", "1")
+        self.assertScriptResultEquals("$endswith(abc,)", "1")
+        self.assertScriptResultEquals("$endswith(abc,b)", "0")
+        self.assertScriptResultEquals("$endswith(abc,bC)", "0")
 
     def test_cmd_truncate(self):
-        self.assertEqual(self.parser.eval("$truncate(abcdefg,0)"), "")
-        self.assertEqual(self.parser.eval("$truncate(abcdefg,7)"), "abcdefg")
-        self.assertEqual(self.parser.eval("$truncate(abcdefg,3)"), "abc")
-        self.assertEqual(self.parser.eval("$truncate(abcdefg,10)"), "abcdefg")
-        self.assertEqual(self.parser.eval("$truncate(abcdefg,)"), "abcdefg")
-        self.assertEqual(self.parser.eval("$truncate(abcdefg,NaN)"), "abcdefg")
+        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()
@@ -284,40 +299,40 @@ class ScriptParserTest(unittest.TestCase):
         self._eval_and_check_copymerge(context, ["targetval", "sourceval"])
 
     def test_cmd_eq_any(self):
-        self.assertEqual(self.parser.eval("$eq_any(abc,def,ghi,jkl)"), "")
-        self.assertEqual(self.parser.eval("$eq_any(abc,def,ghi,jkl,abc)"), "1")
+        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.assertEqual(self.parser.eval("$ne_all(abc,def,ghi,jkl)"), "1")
-        self.assertEqual(self.parser.eval("$ne_all(abc,def,ghi,jkl,abc)"), "")
+        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.assertEqual(self.parser.eval("$eq_all(abc,abc,abc,abc)"), "1")
-        self.assertEqual(self.parser.eval("$eq_all(abc,abc,def,ghi)"), "")
+        self.assertScriptResultEquals("$eq_all(abc,abc,abc,abc)", "1")
+        self.assertScriptResultEquals("$eq_all(abc,abc,def,ghi)", "")
 
     def test_cmd_ne_any(self):
-        self.assertEqual(self.parser.eval("$ne_any(abc,abc,abc,abc)"), "")
-        self.assertEqual(self.parser.eval("$ne_any(abc,abc,def,ghi)"), "1")
+        self.assertScriptResultEquals("$ne_any(abc,abc,abc,abc)", "")
+        self.assertScriptResultEquals("$ne_any(abc,abc,def,ghi)", "1")
 
     def test_cmd_swapprefix(self):
-        self.assertEqual(self.parser.eval("$swapprefix(A stitch in time)"), "stitch in time, A")
-        self.assertEqual(self.parser.eval("$swapprefix(The quick brown fox)"), "quick brown fox, The")
-        self.assertEqual(self.parser.eval("$swapprefix(How now brown cow)"), "How now brown cow")
-        self.assertEqual(self.parser.eval("$swapprefix(When the red red robin)"), "When the red red robin")
-        self.assertEqual(self.parser.eval("$swapprefix(A stitch in time,How,When,Who)"), "A stitch in time")
-        self.assertEqual(self.parser.eval("$swapprefix(The quick brown fox,How,When,Who)"), "The quick brown fox")
-        self.assertEqual(self.parser.eval("$swapprefix(How now brown cow,How,When,Who)"), "now brown cow, How")
-        self.assertEqual(self.parser.eval("$swapprefix(When the red red robin,How,When,Who)"), "the red red robin, When")
+        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.assertEqual(self.parser.eval("$delprefix(A stitch in time)"), "stitch in time")
-        self.assertEqual(self.parser.eval("$delprefix(The quick brown fox)"), "quick brown fox")
-        self.assertEqual(self.parser.eval("$delprefix(How now brown cow)"), "How now brown cow")
-        self.assertEqual(self.parser.eval("$delprefix(When the red red robin)"), "When the red red robin")
-        self.assertEqual(self.parser.eval("$delprefix(A stitch in time,How,When,Who)"), "A stitch in time")
-        self.assertEqual(self.parser.eval("$delprefix(The quick brown fox,How,When,Who)"), "The quick brown fox")
-        self.assertEqual(self.parser.eval("$delprefix(How now brown cow,How,When,Who)"), "now brown cow")
-        self.assertEqual(self.parser.eval("$delprefix(When the red red robin,How,When,Who)"), "the red red robin")
+        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()