Reverse / fix meaning of "+/-" in error diffs

The convention is "assert result is expected".  Pytest's error diffs now
reflect this. "-" means that sth. expected is missing in the result and
"+" means that there are unexpected extras in the result.

Fixes: #3333

1 files changed, 54 insertions, 54 deletions

diff --git a/testing/test_assertion.py b/testing/test_assertion.py
index e975a3fea..ffc07158d 100644
--- a/testing/test_assertion.py
+++ b/testing/test_assertion.py
@@ -316,8 +316,8 @@ class TestAssert_reprcompare:
 
     def test_text_diff(self):
         diff = callequal("spam", "eggs")[1:]
-        assert "- spam" in diff
-        assert "+ eggs" in diff
+        assert "- eggs" in diff
+        assert "+ spam" in diff
 
     def test_text_skipping(self):
         lines = callequal("a" * 50 + "spam", "a" * 50 + "eggs")
@@ -327,15 +327,15 @@ class TestAssert_reprcompare:
 
     def test_text_skipping_verbose(self):
         lines = callequal("a" * 50 + "spam", "a" * 50 + "eggs", verbose=1)
-        assert "- " + "a" * 50 + "spam" in lines
-        assert "+ " + "a" * 50 + "eggs" in lines
+        assert "- " + "a" * 50 + "eggs" in lines
+        assert "+ " + "a" * 50 + "spam" in lines
 
     def test_multiline_text_diff(self):
         left = "foo\nspam\nbar"
         right = "foo\neggs\nbar"
         diff = callequal(left, right)
-        assert "- spam" in diff
-        assert "+ eggs" in diff
+        assert "- eggs" in diff
+        assert "+ spam" in diff
 
     def test_bytes_diff_normal(self):
         """Check special handling for bytes diff (#5260)"""
@@ -354,8 +354,8 @@ class TestAssert_reprcompare:
             "b'spam' == b'eggs'",
             "At index 0 diff: b's' != b'e'",
             "Full diff:",
-            "- b'spam'",
-            "+ b'eggs'",
+            "- b'eggs'",
+            "+ b'spam'",
         ]
 
     def test_list(self):
@@ -370,9 +370,9 @@ class TestAssert_reprcompare:
                 [0, 2],
                 """
                 Full diff:
-                - [0, 1]
+                - [0, 2]
                 ?     ^
-                + [0, 2]
+                + [0, 1]
                 ?     ^
             """,
                 id="lists",
@@ -382,9 +382,9 @@ class TestAssert_reprcompare:
                 {0: 2},
                 """
                 Full diff:
-                - {0: 1}
+                - {0: 2}
                 ?     ^
-                + {0: 2}
+                + {0: 1}
                 ?     ^
             """,
                 id="dicts",
@@ -394,9 +394,9 @@ class TestAssert_reprcompare:
                 {0, 2},
                 """
                 Full diff:
-                - {0, 1}
+                - {0, 2}
                 ?     ^
-                + {0, 2}
+                + {0, 1}
                 ?     ^
             """,
                 id="sets",
@@ -433,7 +433,7 @@ class TestAssert_reprcompare:
             "   'a',",
             "   'b',",
             "   'c',",
-            "+  '" + long_d + "',",
+            "-  '" + long_d + "',",
             "  ]",
         ]
 
@@ -446,7 +446,7 @@ class TestAssert_reprcompare:
             "   'a',",
             "   'b',",
             "   'c',",
-            "-  '" + long_d + "',",
+            "+  '" + long_d + "',",
             "  ]",
         ]
 
@@ -462,10 +462,10 @@ class TestAssert_reprcompare:
             "At index 0 diff: 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' != 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb'",
             "Full diff:",
             "  [",
-            "-  'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',",
+            "+  'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',",
             "   'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb',",
             "   'cccccccccccccccccccccccccccccc',",
-            "+  'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',",
+            "-  'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',",
             "  ]",
         ]
 
@@ -480,28 +480,28 @@ class TestAssert_reprcompare:
             "Left contains 7 more items, first extra item: 'aaaaaaaaaa'",
             "Full diff:",
             "  [",
-            "+  'should not get wrapped',",
-            "-  'a',",
-            "-  'aaaaaaaaaa',",
-            "-  'aaaaaaaaaa',",
-            "-  'aaaaaaaaaa',",
-            "-  'aaaaaaaaaa',",
-            "-  'aaaaaaaaaa',",
-            "-  'aaaaaaaaaa',",
-            "-  'aaaaaaaaaa',",
+            "-  'should not get wrapped',",
+            "+  'a',",
+            "+  'aaaaaaaaaa',",
+            "+  'aaaaaaaaaa',",
+            "+  'aaaaaaaaaa',",
+            "+  'aaaaaaaaaa',",
+            "+  'aaaaaaaaaa',",
+            "+  'aaaaaaaaaa',",
+            "+  'aaaaaaaaaa',",
             "  ]",
         ]
 
     def test_dict_wrap(self):
-        d1 = {"common": 1, "env": {"env1": 1}}
-        d2 = {"common": 1, "env": {"env1": 1, "env2": 2}}
+        d1 = {"common": 1, "env": {"env1": 1, "env2": 2}}
+        d2 = {"common": 1, "env": {"env1": 1}}
 
         diff = callequal(d1, d2, verbose=True)
         assert diff == [
-            "{'common': 1,...: {'env1': 1}} == {'common': 1,...1, 'env2': 2}}",
+            "{'common': 1,...1, 'env2': 2}} == {'common': 1,...: {'env1': 1}}",
             "Omitting 1 identical items, use -vv to show",
             "Differing items:",
-            "{'env': {'env1': 1}} != {'env': {'env1': 1, 'env2': 2}}",
+            "{'env': {'env1': 1, 'env2': 2}} != {'env': {'env1': 1}}",
             "Full diff:",
             "- {'common': 1, 'env': {'env1': 1}}",
             "+ {'common': 1, 'env': {'env1': 1, 'env2': 2}}",
@@ -523,7 +523,7 @@ class TestAssert_reprcompare:
             "   'env': {'sub': {'long_a': '" + long_a + "',",
             "                   'sub1': {'long_a': 'substring that gets wrapped substring '",
             "                                      'that gets wrapped '}}},",
-            "+  'new': 1,",
+            "-  'new': 1,",
             "  }",
         ]
 
@@ -561,8 +561,8 @@ class TestAssert_reprcompare:
             "Right contains 2 more items:",
             "{'b': 1, 'c': 2}",
             "Full diff:",
-            "- {'a': 0}",
-            "+ {'b': 1, 'c': 2}",
+            "- {'b': 1, 'c': 2}",
+            "+ {'a': 0}",
         ]
         lines = callequal({"b": 1, "c": 2}, {"a": 0}, verbose=2)
         assert lines == [
@@ -572,8 +572,8 @@ class TestAssert_reprcompare:
             "Right contains 1 more item:",
             "{'a': 0}",
             "Full diff:",
-            "- {'b': 1, 'c': 2}",
-            "+ {'a': 0}",
+            "- {'a': 0}",
+            "+ {'b': 1, 'c': 2}",
         ]
 
     def test_sequence_different_items(self):
@@ -583,8 +583,8 @@ class TestAssert_reprcompare:
             "At index 0 diff: 1 != 3",
             "Right contains one more item: 5",
             "Full diff:",
-            "- (1, 2)",
-            "+ (3, 4, 5)",
+            "- (3, 4, 5)",
+            "+ (1, 2)",
         ]
         lines = callequal((1, 2, 3), (4,), verbose=2)
         assert lines == [
@@ -592,8 +592,8 @@ class TestAssert_reprcompare:
             "At index 0 diff: 1 != 4",
             "Left contains 2 more items, first extra item: 2",
             "Full diff:",
-            "- (1, 2, 3)",
-            "+ (4,)",
+            "- (4,)",
+            "+ (1, 2, 3)",
         ]
 
     def test_set(self):
@@ -654,12 +654,12 @@ class TestAssert_reprcompare:
         assert callequal(nums_x, nums_y) is None
 
         expl = callequal(nums_x, nums_y, verbose=1)
-        assert "-" + repr(nums_x) in expl
-        assert "+" + repr(nums_y) in expl
+        assert "+" + repr(nums_x) in expl
+        assert "-" + repr(nums_y) in expl
 
         expl = callequal(nums_x, nums_y, verbose=2)
-        assert "-" + repr(nums_x) in expl
-        assert "+" + repr(nums_y) in expl
+        assert "+" + repr(nums_x) in expl
+        assert "-" + repr(nums_y) in expl
 
     def test_list_bad_repr(self):
         class A:
@@ -693,8 +693,8 @@ class TestAssert_reprcompare:
         right = "£"
         expl = callequal(left, right)
         assert expl[0] == "'£€' == '£'"
-        assert expl[1] == "- £€"
-        assert expl[2] == "+ £"
+        assert expl[1] == "- £"
+        assert expl[2] == "+ £€"
 
     def test_nonascii_text(self):
         """
@@ -707,7 +707,7 @@ class TestAssert_reprcompare:
                 return "\xff"
 
         expl = callequal(A(), "1")
-        assert expl == ["ÿ == '1'", "+ 1"]
+        assert expl == ["ÿ == '1'", "- 1"]
 
     def test_format_nonascii_explanation(self):
         assert util.format_explanation("λ")
@@ -1007,9 +1007,9 @@ class TestTruncateExplanation:
         # without -vv, truncate the message showing a few diff lines only
         result.stdout.fnmatch_lines(
             [
-                "*- 1*",
-                "*- 3*",
-                "*- 5*",
+                "*+ 1*",
+                "*+ 3*",
+                "*+ 5*",
                 "*truncated (%d lines hidden)*use*-vv*" % expected_truncated_lines,
             ]
         )
@@ -1062,9 +1062,9 @@ def test_reprcompare_whitespaces():
     assert detail == [
         r"'\r\n' == '\n'",
         r"Strings contain only whitespace, escaping them using repr()",
-        r"- '\r\n'",
-        r"?  --",
-        r"+ '\n'",
+        r"- '\n'",
+        r"+ '\r\n'",
+        r"?  ++",
     ]
 
 
@@ -1312,8 +1312,8 @@ def test_diff_newline_at_end(testdir):
         r"""
         *assert 'asdf' == 'asdf\n'
         *  - asdf
+        *  ?     -
         *  + asdf
-        *  ?     +
     """
     )