Get all tests in ShouldContainValueSpec to pass under Scala 2.13.0-M5.

Author: cheeseng

scalatest-test/src/test/scala/org/scalatest/ShouldContainValueSpec.scala

@@ -569,110 +569,97 @@ class ShouldContainValueSpec extends FunSpec with ReturnsNormallyThrowsAssertion
         val caught1 = intercept[TestFailedException] {
           HashMap("one" -> 1, "two" -> 2) should contain value (3)
         }
-        //assert(caught1.getMessage === "Map(one -> 1, two -> 2) did not contain value 3")
-        assert(caught1.getMessage.startsWith("Map("))
-        assert(caught1.getMessage.endsWith(") did not contain value 3"))
+        assert(caught1.getMessage == Prettifier.default(HashMap("one" -> 1, "two" -> 2)) + " did not contain value 3")
       }
 
       it("should throw TestFailedException if contains the specified value when used with not") {
 
         val caught1 = intercept[TestFailedException] {
           HashMap("one" -> 1, "two" -> 2) should (not contain value (2))
         }
-        caught1.getMessage should fullyMatch regex ("Map(.*) contained value 2")
+        assert(caught1.getMessage == Prettifier.default(HashMap("one" -> 1, "two" -> 2)) + " contained value 2")
 
         val caught2 = intercept[TestFailedException] {
           HashMap("one" -> 1, "two" -> 2) should not (contain value (2))
         }
-        caught1.getMessage should fullyMatch regex ("Map(.*) contained value 2")
+        assert(caught2.getMessage == Prettifier.default(HashMap("one" -> 1, "two" -> 2)) + " contained value 2")
 
         val caught3 = intercept[TestFailedException] {
           HashMap("one" -> 1, "two" -> 2) should not contain value (2)
         }
-        caught1.getMessage should fullyMatch regex ("Map(.*) contained value 2")
+        assert(caught3.getMessage == Prettifier.default(HashMap("one" -> 1, "two" -> 2)) + " contained value 2")
       }
 
       it("should throw an TestFailedException when map doesn't contain specified value and used in a logical-and expression") {
 
         val caught1 = intercept[TestFailedException] {
           HashMap("one" -> 1, "two" -> 2) should { contain value (5) and (contain value (2)) }
         }
-        caught1.getMessage should fullyMatch regex ("Map(.*) did not contain value 5")
+        assert(caught1.getMessage == Prettifier.default(HashMap("one" -> 1, "two" -> 2)) + " did not contain value 5")
 
         val caught2 = intercept[TestFailedException] {
           HashMap("one" -> 1, "two" -> 2) should ((contain value (5)) and (contain value (2)))
         }
-        //assert(caught2.getMessage === "Map(one -> 1, two -> 2) did not contain value 5")
-        caught1.getMessage should fullyMatch regex ("Map(.*) did not contain value 5")
+        assert(caught2.getMessage == Prettifier.default(HashMap("one" -> 1, "two" -> 2)) + " did not contain value 5")
 
         val caught3 = intercept[TestFailedException] {
           HashMap("one" -> 1, "two" -> 2) should (contain value (5) and contain value (2))
         }
-        //assert(caught3.getMessage === "Map(one -> 1, two -> 2) did not contain value 5")
-        caught1.getMessage should fullyMatch regex ("Map(.*) did not contain value 5")
+        assert(caught3.getMessage == Prettifier.default(HashMap("one" -> 1, "two" -> 2)) + " did not contain value 5")
       }
 
       it("should throw an TestFailedException when map doesn't contain specified value and used in a logical-or expression") {
 
         val caught1 = intercept[TestFailedException] {
           HashMap("one" -> 1, "two" -> 2) should { contain value (55) or (contain value (22)) }
         }
-        //assert(caught1.getMessage === "Map(one -> 1, two -> 2) did not contain value 55, and Map(one -> 1, two -> 2) did not contain value 22")
-        caught1.getMessage should fullyMatch regex ("Map(.*) did not contain value 55, and Map(.*) did not contain value 22")
-
+        assert(caught1.getMessage == Prettifier.default(HashMap("one" -> 1, "two" -> 2)) + " did not contain value 55, and " + Prettifier.default(HashMap("one" -> 1, "two" -> 2)) + " did not contain value 22")
+        
         val caught2 = intercept[TestFailedException] {
           HashMap("one" -> 1, "two" -> 2) should ((contain value (55)) or (contain value (22)))
         }
-        //assert(caught2.getMessage === "Map(one -> 1, two -> 2) did not contain value 55, and Map(one -> 1, two -> 2) did not contain value 22")
-        caught1.getMessage should fullyMatch regex ("Map(.*) did not contain value 55, and Map(.*) did not contain value 22")
+        assert(caught2.getMessage == Prettifier.default(HashMap("one" -> 1, "two" -> 2)) + " did not contain value 55, and " + Prettifier.default(HashMap("one" -> 1, "two" -> 2)) + " did not contain value 22")
 
         val caught3 = intercept[TestFailedException] {
           HashMap("one" -> 1, "two" -> 2) should (contain value (55) or contain value (22))
         }
-        //assert(caught3.getMessage === "Map(one -> 1, two -> 2) did not contain value 55, and Map(one -> 1, two -> 2) did not contain value 22")
-        caught1.getMessage should fullyMatch regex ("Map(.*) did not contain value 55, and Map(.*) did not contain value 22")
+        assert(caught3.getMessage == Prettifier.default(HashMap("one" -> 1, "two" -> 2)) + " did not contain value 55, and " + Prettifier.default(HashMap("one" -> 1, "two" -> 2)) + " did not contain value 22")
       }
 
       it("should throw an TestFailedException when map contains specified value and used in a logical-and expression with not") {
 
         val caught1 = intercept[TestFailedException] {
           HashMap("one" -> 1, "two" -> 2) should { not { contain value (3) } and not { contain value (2) }}
         }
-        //assert(caught1.getMessage === "Map(one -> 1, two -> 2) did not contain value 3, but Map(one -> 1, two -> 2) contained value 2")
-        caught1.getMessage should fullyMatch regex ("Map(.*) did not contain value 3, but Map(.*) contained value 2")
+        assert(caught1.getMessage == Prettifier.default(HashMap("one" -> 1, "two" -> 2)) + " did not contain value 3, but " + Prettifier.default(HashMap("one" -> 1, "two" -> 2)) + " contained value 2")
 
         val caught2 = intercept[TestFailedException] {
           HashMap("one" -> 1, "two" -> 2) should ((not contain value (3)) and (not contain value (2)))
         }
-        //assert(caught2.getMessage === "Map(one -> 1, two -> 2) did not contain value 3, but Map(one -> 1, two -> 2) contained value 2")
-        caught1.getMessage should fullyMatch regex ("Map(.*) did not contain value 3, but Map(.*) contained value 2")
+        assert(caught2.getMessage == Prettifier.default(HashMap("one" -> 1, "two" -> 2)) + " did not contain value 3, but " + Prettifier.default(HashMap("one" -> 1, "two" -> 2)) + " contained value 2")
 
         val caught3 = intercept[TestFailedException] {
           HashMap("one" -> 1, "two" -> 2) should (not contain value (3) and not contain value (2))
         }
-        //assert(caught3.getMessage === "Map(one -> 1, two -> 2) did not contain value 3, but Map(one -> 1, two -> 2) contained value 2")
-        caught1.getMessage should fullyMatch regex ("Map(.*) did not contain value 3, but Map(.*) contained value 2")
+        assert(caught3.getMessage == Prettifier.default(HashMap("one" -> 1, "two" -> 2)) + " did not contain value 3, but " + Prettifier.default(HashMap("one" -> 1, "two" -> 2)) + " contained value 2")
       }
 
       it("should throw an TestFailedException when map contains specified value and used in a logical-or expression with not") {
 
         val caught1 = intercept[TestFailedException] {
           HashMap("one" -> 1, "two" -> 2) should { not { contain value (2) } or not { contain value (2) }}
         }
-        //assert(caught1.getMessage === "Map(one -> 1, two -> 2) contained value 2, and Map(one -> 1, two -> 2) contained value 2")
-        caught1.getMessage should fullyMatch regex ("Map(.*) contained value 2, and Map(.*) contained value 2")
-
+        assert(caught1.getMessage == Prettifier.default(HashMap("one" -> 1, "two" -> 2)) + " contained value 2, and " + Prettifier.default(HashMap("one" -> 1, "two" -> 2)) + " contained value 2")
+        
         val caught2 = intercept[TestFailedException] {
           HashMap("one" -> 1, "two" -> 2) should ((not contain value (2)) or (not contain value (2)))
         }
-        //assert(caught2.getMessage === "Map(one -> 1, two -> 2) contained value 2, and Map(one -> 1, two -> 2) contained value 2")
-        caught1.getMessage should fullyMatch regex ("Map(.*) contained value 2, and Map(.*) contained value 2")
+        assert(caught2.getMessage == Prettifier.default(HashMap("one" -> 1, "two" -> 2)) + " contained value 2, and " + Prettifier.default(HashMap("one" -> 1, "two" -> 2)) + " contained value 2")
 
         val caught3 = intercept[TestFailedException] {
           HashMap("one" -> 1, "two" -> 2) should (not contain value (2) or not contain value (2))
         }
-        //assert(caught3.getMessage === "Map(one -> 1, two -> 2) contained value 2, and Map(one -> 1, two -> 2) contained value 2")
-        caught1.getMessage should fullyMatch regex ("Map(.*) contained value 2, and Map(.*) contained value 2")
+        assert(caught3.getMessage == Prettifier.default(HashMap("one" -> 1, "two" -> 2)) + " contained value 2, and " + Prettifier.default(HashMap("one" -> 1, "two" -> 2)) + " contained value 2")
       }
 
       // SKIP-SCALATESTJS,NATIVE-START