test_bibparse includes parsed strings with leading space, no longer included in output

ptmcg · ptmcg · commit 34be5a22a881 · 2020-10-11T23:38:33.000-05:00
diff --git a/examples/test_bibparse.py b/examples/test_bibparse.py
@@ -18,30 +18,30 @@ def test_names(self):
             (bp.cite_key, True),
         ):
             if dig1f:  # can start with digit
-                self.assertEqual(name_type.parseString("2t")[0], "2t")
+                self.assertEqual("2t", name_type.parseString("2t")[0])
             else:
                 self.assertRaises(ParseException, name_type.parseString, "2t")
             # All of the names cannot contain some characters
             for char in bad_chars:
                 self.assertRaises(ParseException, name_type.parseString, char)
             # standard strings all OK
-            self.assertEqual(name_type.parseString("simple_test")[0], "simple_test")
+            self.assertEqual("simple_test", name_type.parseString("simple_test")[0])
         # Test macro ref
         mr = bp.macro_ref
         # can't start with digit
         self.assertRaises(ParseException, mr.parseString, "2t")
         for char in bad_chars:
             self.assertRaises(ParseException, mr.parseString, char)
-        self.assertEqual(mr.parseString("simple_test")[0].name, "simple_test")
+        self.assertEqual("simple_test", mr.parseString("simple_test")[0].name)
 
     def test_numbers(self):
-        self.assertEqual(bp.number.parseString("1066")[0], "1066")
-        self.assertEqual(bp.number.parseString("0")[0], "0")
+        self.assertEqual("1066", bp.number.parseString("1066")[0])
+        self.assertEqual("0", bp.number.parseString("0")[0])
         self.assertRaises(ParseException, bp.number.parseString, "-4")
         self.assertRaises(ParseException, bp.number.parseString, "+4")
         self.assertRaises(ParseException, bp.number.parseString, ".4")
         # something point something leaves a trailing .4 unmatched
-        self.assertEqual(bp.number.parseString("0.4")[0], "0")
+        self.assertEqual("0", bp.number.parseString("0.4")[0])
 
     def test_parse_string(self):
         # test string building blocks
@@ -57,26 +57,27 @@ def test_parse_string(self):
             self.assertEqual(obj.parseString("{}").asList(), [])
             self.assertEqual(obj.parseString('{a "string}')[0], 'a "string')
             self.assertEqual(
+                ["a ", ["nested"], "string"],
                 obj.parseString("{a {nested} string}").asList(),
-                ["a ", ["nested"], " string"],
             )
             self.assertEqual(
+                ["a ", ["double ", ["nested"]], "string"],
                 obj.parseString("{a {double {nested}} string}").asList(),
-                ["a ", ["double ", ["nested"]], " string"],
             )
         for obj in (bp.quoted_string, bp.string, bp.field_value):
-            self.assertEqual(obj.parseString('""').asList(), [])
-            self.assertEqual(obj.parseString('"a string"')[0], "a string")
+            self.assertEqual([], obj.parseString('""').asList())
+            self.assertEqual( "a string", obj.parseString('"a string"')[0])
             self.assertEqual(
+                ["a ", ["nested"], "string"],
                 obj.parseString('"a {nested} string"').asList(),
-                ["a ", ["nested"], " string"],
             )
             self.assertEqual(
+                ["a ", ["double ", ["nested"]], "string"],
                 obj.parseString('"a {double {nested}} string"').asList(),
-                ["a ", ["double ", ["nested"]], " string"],
             )
+
         # check macro def in string
-        self.assertEqual(bp.string.parseString("someascii")[0], Macro("someascii"))
+        self.assertEqual(Macro("someascii"), bp.string.parseString("someascii")[0])
         self.assertRaises(ParseException, bp.string.parseString, "%#= validstring")
         # check number in string
         self.assertEqual(bp.string.parseString("1994")[0], "1994")
@@ -85,42 +86,42 @@ def test_parse_field(self):
         # test field value - hashes included
         fv = bp.field_value
         # Macro
-        self.assertEqual(fv.parseString("aname")[0], Macro("aname"))
-        self.assertEqual(fv.parseString("ANAME")[0], Macro("aname"))
+        self.assertEqual(Macro("aname"), fv.parseString("aname")[0])
+        self.assertEqual(Macro("aname"), fv.parseString("ANAME")[0])
         # String and macro
         self.assertEqual(
-            fv.parseString('aname # "some string"').asList(),
             [Macro("aname"), "some string"],
+            fv.parseString('aname # "some string"').asList(),
         )
         # Nested string
         self.assertEqual(
-            fv.parseString("aname # {some {string}}").asList(),
             [Macro("aname"), "some ", ["string"]],
+            fv.parseString("aname # {some {string}}").asList(),
         )
         # String and number
         self.assertEqual(
-            fv.parseString('"a string" # 1994').asList(), ["a string", "1994"]
+            ["a string", "1994"], fv.parseString('"a string" # 1994').asList()
         )
         # String and number and macro
         self.assertEqual(
-            fv.parseString('"a string" # 1994 # a_macro').asList(),
             ["a string", "1994", Macro("a_macro")],
+            fv.parseString('"a string" # 1994 # a_macro').asList(),
         )
 
     def test_comments(self):
         res = bp.comment.parseString("@Comment{about something}")
         self.assertEqual(res.asList(), ["comment", "{about something}"])
         self.assertEqual(
-            bp.comment.parseString("@COMMENT{about something").asList(),
             ["comment", "{about something"],
+            bp.comment.parseString("@COMMENT{about something").asList(),
         )
         self.assertEqual(
-            bp.comment.parseString("@comment(about something").asList(),
             ["comment", "(about something"],
+            bp.comment.parseString("@comment(about something").asList(),
         )
         self.assertEqual(
-            bp.comment.parseString("@COMment about something").asList(),
             ["comment", " about something"],
+            bp.comment.parseString("@COMment about something").asList(),
         )
         self.assertRaises(
             ParseException, bp.comment.parseString, "@commentabout something"
@@ -136,59 +137,58 @@ def test_preamble(self):
         res = bp.preamble.parseString('@preamble{"about something"}')
         self.assertEqual(res.asList(), ["preamble", "about something"])
         self.assertEqual(
-            bp.preamble.parseString("@PREamble{{about something}}").asList(),
             ["preamble", "about something"],
+            bp.preamble.parseString("@PREamble{{about something}}").asList(),
         )
         self.assertEqual(
+            ["preamble", "about something"],
             bp.preamble.parseString(
                 """@PREamble{
             {about something}
         }"""
             ).asList(),
-            ["preamble", "about something"],
         )
 
     def test_macro(self):
         res = bp.macro.parseString('@string{ANAME = "about something"}')
         self.assertEqual(res.asList(), ["string", "aname", "about something"])
         self.assertEqual(
-            bp.macro.parseString("@string{aname = {about something}}").asList(),
             ["string", "aname", "about something"],
+            bp.macro.parseString("@string{aname = {about something}}").asList(),
         )
 
     def test_entry(self):
         txt = """@some_entry{akey, aname = "about something",
         another={something else}}"""
         res = bp.entry.parseString(txt)
         self.assertEqual(
-            res.asList(),
             [
                 "some_entry",
                 "akey",
                 ["aname", "about something"],
                 ["another", "something else"],
             ],
+            res.asList(),
         )
         # Case conversion
         txt = """@SOME_ENTRY{akey, ANAME = "about something",
         another={something else}}"""
         res = bp.entry.parseString(txt)
         self.assertEqual(
-            res.asList(),
             [
                 "some_entry",
                 "akey",
                 ["aname", "about something"],
                 ["another", "something else"],
             ],
+            res.asList(),
         )
 
     def test_bibfile(self):
         txt = """@some_entry{akey, aname = "about something",
         another={something else}}"""
         res = bp.bibfile.parseString(txt)
         self.assertEqual(
-            res.asList(),
             [
                 [
                     "some_entry",
@@ -197,6 +197,7 @@ def test_bibfile(self):
                     ["another", "something else"],
                 ]
             ],
+            res.asList(),
         )
 
     def test_bib1(self):
