Get ShouldContainKeySpec to pass under Scala 2.13.0-M5.

Author: cheeseng

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

@@ -568,113 +568,97 @@ class ShouldContainKeySpec extends FunSpec with ReturnsNormallyThrowsAssertion {
         val caught1 = intercept[TestFailedException] {
           HashMap("one" -> 1, "two" -> 2) should contain key ("three")
         }
-        //assert(caught1.getMessage === "Map(one -> 1, two -> 2) did not contain key \"three\"")
-        caught1.getMessage should fullyMatch regex ("Map(.*) did not contain key \"three\"")
+        assert(caught1.getMessage == Prettifier.default(HashMap("one" -> 1, "two" -> 2)) + " did not contain key \"three\"")
       }
 
       it("should throw TestFailedException if contains the specified key when used with not") {
 
         val caught1 = intercept[TestFailedException] {
           HashMap("one" -> 1, "two" -> 2) should (not contain key ("two"))
         }
-        //assert(caught1.getMessage === "Map(one -> 1, two -> 2) contained key \"two\"")
-        caught1.getMessage should fullyMatch regex ("Map(.*) contained key \"two\"")
-
+        assert(caught1.getMessage == Prettifier.default(HashMap("one" -> 1, "two" -> 2)) + " contained key \"two\"")
+        
         val caught2 = intercept[TestFailedException] {
           HashMap("one" -> 1, "two" -> 2) should not (contain key ("two"))
         }
-        //assert(caught2.getMessage === "Map(one -> 1, two -> 2) contained key \"two\"")
-        caught1.getMessage should fullyMatch regex ("Map(.*) contained key \"two\"")
-
+        assert(caught2.getMessage == Prettifier.default(HashMap("one" -> 1, "two" -> 2)) + " contained key \"two\"")
+        
         val caught3 = intercept[TestFailedException] {
           HashMap("one" -> 1, "two" -> 2) should not contain key ("two")
         }
-        //assert(caught3.getMessage === "Map(one -> 1, two -> 2) contained key \"two\"")
-        caught1.getMessage should fullyMatch regex ("Map(.*) contained key \"two\"")
+        assert(caught3.getMessage == Prettifier.default(HashMap("one" -> 1, "two" -> 2)) + " contained key \"two\"")
       }
 
       it("should throw an TestFailedException when map doesn't contain specified key and used in a logical-and expression") {
 
         val caught1 = intercept[TestFailedException] {
           HashMap("one" -> 1, "two" -> 2) should { contain key ("five") and (contain key ("two")) }
         }
-        //assert(caught1.getMessage === "Map(one -> 1, two -> 2) did not contain key \"five\"")
-        caught1.getMessage should fullyMatch regex ("Map(.*) did not contain key \"five\"")
-
+        assert(caught1.getMessage == Prettifier.default(HashMap("one" -> 1, "two" -> 2)) + " did not contain key \"five\"")
+        
         val caught2 = intercept[TestFailedException] {
           HashMap("one" -> 1, "two" -> 2) should ((contain key ("five")) and (contain key ("two")))
         }
-        //assert(caught2.getMessage === "Map(one -> 1, two -> 2) did not contain key \"five\"")
-        caught1.getMessage should fullyMatch regex ("Map(.*) did not contain key \"five\"")
-
+        assert(caught2.getMessage == Prettifier.default(HashMap("one" -> 1, "two" -> 2)) + " did not contain key \"five\"")
+        
         val caught3 = intercept[TestFailedException] {
           HashMap("one" -> 1, "two" -> 2) should (contain key ("five") and contain key ("two"))
         }
-        //assert(caught3.getMessage === "Map(one -> 1, two -> 2) did not contain key \"five\"")
-        caught1.getMessage should fullyMatch regex ("Map(.*) did not contain key \"five\"")
+        assert(caught3.getMessage == Prettifier.default(HashMap("one" -> 1, "two" -> 2)) + " did not contain key \"five\"")
       }
 
       it("should throw an TestFailedException when map doesn't contain specified key and used in a logical-or expression") {
 
         val caught1 = intercept[TestFailedException] {
           HashMap("one" -> 1, "two" -> 2) should { contain key ("fifty five") or (contain key ("twenty two")) }
         }
-        //assert(caught1.getMessage === "Map(one -> 1, two -> 2) did not contain key \"fifty five\", and Map(one -> 1, two -> 2) did not contain key \"twenty two\"")
-        caught1.getMessage should fullyMatch regex ("Map(.*) did not contain key \"fifty five\", and Map(.*) did not contain key \"twenty two\"")
+        assert(caught1.getMessage == Prettifier.default(HashMap("one" -> 1, "two" -> 2)) + " did not contain key \"fifty five\", and " + Prettifier.default(HashMap("one" -> 1, "two" -> 2)) + " did not contain key \"twenty two\"")
 
         val caught2 = intercept[TestFailedException] {
           HashMap("one" -> 1, "two" -> 2) should ((contain key ("fifty five")) or (contain key ("twenty two")))
         }
-        //assert(caught2.getMessage === "Map(one -> 1, two -> 2) did not contain key \"fifty five\", and Map(one -> 1, two -> 2) did not contain key \"twenty two\"")
-        caught1.getMessage should fullyMatch regex ("Map(.*) did not contain key \"fifty five\", and Map(.*) did not contain key \"twenty two\"")
+        assert(caught2.getMessage == Prettifier.default(HashMap("one" -> 1, "two" -> 2)) + " did not contain key \"fifty five\", and " + Prettifier.default(HashMap("one" -> 1, "two" -> 2)) + " did not contain key \"twenty two\"")
 
         val caught3 = intercept[TestFailedException] {
           HashMap("one" -> 1, "two" -> 2) should (contain key ("fifty five") or contain key ("twenty two"))
         }
-        // assert(caught3.getMessage === "Map(one -> 1, two -> 2) did not contain key \"fifty five\", and Map(one -> 1, two -> 2) did not contain key \"twenty two\"")
-        caught1.getMessage should fullyMatch regex ("Map(.*) did not contain key \"fifty five\", and Map(.*) did not contain key \"twenty two\"")
+        assert(caught3.getMessage == Prettifier.default(HashMap("one" -> 1, "two" -> 2)) + " did not contain key \"fifty five\", and " + Prettifier.default(HashMap("one" -> 1, "two" -> 2)) + " did not contain key \"twenty two\"")
       }
 
       it("should throw an TestFailedException when map contains specified key and used in a logical-and expression with not") {
 
         val caught1 = intercept[TestFailedException] {
           HashMap("one" -> 1, "two" -> 2) should { not { contain key ("three") } and not { contain key ("two") }}
         }
-        //assert(caught1.getMessage === "Map(one -> 1, two -> 2) did not contain key \"three\", but Map(one -> 1, two -> 2) contained key \"two\"")
-        caught1.getMessage should fullyMatch regex ("Map(.*) did not contain key \"three\", but Map(.*) contained key \"two\"")
-
+        assert(caught1.getMessage == Prettifier.default(HashMap("one" -> 1, "two" -> 2)) + " did not contain key \"three\", but " + Prettifier.default(HashMap("one" -> 1, "two" -> 2)) + " contained key \"two\"")
+        
         val caught2 = intercept[TestFailedException] {
           HashMap("one" -> 1, "two" -> 2) should ((not contain key ("three")) and (not contain key ("two")))
         }
-        //assert(caught2.getMessage === "Map(one -> 1, two -> 2) did not contain key \"three\", but Map(one -> 1, two -> 2) contained key \"two\"")
-        caught1.getMessage should fullyMatch regex ("Map(.*) did not contain key \"three\", but Map(.*) contained key \"two\"")
+        assert(caught2.getMessage == Prettifier.default(HashMap("one" -> 1, "two" -> 2)) + " did not contain key \"three\", but " + Prettifier.default(HashMap("one" -> 1, "two" -> 2)) + " contained key \"two\"")
 
         val caught3 = intercept[TestFailedException] {
           HashMap("one" -> 1, "two" -> 2) should (not contain key ("three") and not contain key ("two"))
         }
-        //assert(caught3.getMessage === "Map(one -> 1, two -> 2) did not contain key \"three\", but Map(one -> 1, two -> 2) contained key \"two\"")
-        caught1.getMessage should fullyMatch regex ("Map(.*) did not contain key \"three\", but Map(.*) contained key \"two\"")
+        assert(caught3.getMessage == Prettifier.default(HashMap("one" -> 1, "two" -> 2)) + " did not contain key \"three\", but " + Prettifier.default(HashMap("one" -> 1, "two" -> 2)) + " contained key \"two\"")
       }
 
       it("should throw an TestFailedException when map contains specified key and used in a logical-or expression with not") {
 
         val caught1 = intercept[TestFailedException] {
           HashMap("one" -> 1, "two" -> 2) should { not { contain key ("two") } or not { contain key ("two") }}
         }
-        //assert(caught1.getMessage === "Map(one -> 1, two -> 2) contained key \"two\", and Map(one -> 1, two -> 2) contained key \"two\"")
-        caught1.getMessage should fullyMatch regex ("Map(.*) contained key \"two\", and Map(.*) contained key \"two\"")
-
+        assert(caught1.getMessage === Prettifier.default(HashMap("one" -> 1, "two" -> 2)) + " contained key \"two\", and " + Prettifier.default(HashMap("one" -> 1, "two" -> 2)) + " contained key \"two\"")
+        
         val caught2 = intercept[TestFailedException] {
           HashMap("one" -> 1, "two" -> 2) should ((not contain key ("two")) or (not contain key ("two")))
         }
-        //assert(caught2.getMessage === "Map(one -> 1, two -> 2) contained key \"two\", and Map(one -> 1, two -> 2) contained key \"two\"")
-        caught1.getMessage should fullyMatch regex ("Map(.*) contained key \"two\", and Map(.*) contained key \"two\"")
+        assert(caught2.getMessage === Prettifier.default(HashMap("one" -> 1, "two" -> 2)) + " contained key \"two\", and " + Prettifier.default(HashMap("one" -> 1, "two" -> 2)) + " contained key \"two\"")
 
         val caught3 = intercept[TestFailedException] {
           HashMap("one" -> 1, "two" -> 2) should (not contain key ("two") or not contain key ("two"))
         }
-        //assert(caught3.getMessage === "Map(one -> 1, two -> 2) contained key \"two\", and Map(one -> 1, two -> 2) contained key \"two\"")
-        caught1.getMessage should fullyMatch regex ("Map(.*) contained key \"two\", and Map(.*) contained key \"two\"")
+        assert(caught3.getMessage === Prettifier.default(HashMap("one" -> 1, "two" -> 2)) + " contained key \"two\", and " + Prettifier.default(HashMap("one" -> 1, "two" -> 2)) + " contained key \"two\"")
       }
 
       // SKIP-SCALATESTJS,NATIVE-START