Reduced test failures in ShouldContainElementSpec when built under Scala 2.13.0-M5.

Author: cheeseng

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

@@ -611,87 +611,87 @@ class ShouldContainElementSpec extends FunSpec with PropertyChecks with ReturnsN
         val caught = intercept[TestFailedException] {
           HashSet(1, 2) should contain (3)
         }
-        assert(caught.getMessage === "Set(1, 2) did not contain element 3")
+        assert(caught.getMessage === HashSet(1, 2) + " did not contain element 3")
       }
 
       it("should throw TestFailedException if set contains the specified element, when used with not") {
 
         val caught1 = intercept[TestFailedException] {
           HashSet(1, 2) should not contain (2)
         }
-        assert(caught1.getMessage === "Set(1, 2) contained element 2")
+        assert(caught1.getMessage === HashSet(1, 2) + " contained element 2")
 
         val caught2 = intercept[TestFailedException] {
           HashSet(1, 2) should not (contain (2))
         }
-        assert(caught2.getMessage === "Set(1, 2) contained element 2")
+        assert(caught2.getMessage === HashSet(1, 2) + " contained element 2")
 
         val caught3 = intercept[TestFailedException] {
           HashSet(1, 2) should (not contain (2))
         }
-        assert(caught3.getMessage === "Set(1, 2) contained element 2")
+        assert(caught3.getMessage === HashSet(1, 2) + " contained element 2")
       }
 
       it("should throw a TestFailedException when set doesn't contain the specified element and used in a logical-and expression") {
 
         val caught1 = intercept[TestFailedException] {
           HashSet(1, 2) should { contain (5) and (contain (2 - 1)) }
         }
-        assert(caught1.getMessage === "Set(1, 2) did not contain element 5")
+        assert(caught1.getMessage === HashSet(1, 2) + " did not contain element 5")
 
         val caught2 = intercept[TestFailedException] {
           HashSet(1, 2) should (contain (5) and contain (2 - 1))
         }
-        assert(caught2.getMessage === "Set(1, 2) did not contain element 5")
+        assert(caught2.getMessage === HashSet(1, 2) + " did not contain element 5")
       }
 
       it("should throw a TestFailedException when set doesn't contain the specified element and used in a logical-or expression") {
 
         val caught1 = intercept[TestFailedException] {
           HashSet(1, 2) should { contain (55) or (contain (22)) }
         }
-        assert(caught1.getMessage === "Set(1, 2) did not contain element 55, and Set(1, 2) did not contain element 22")
+        assert(caught1.getMessage === HashSet(1, 2) + " did not contain element 55, and " + HashSet(1, 2) + " did not contain element 22")
 
         val caught2 = intercept[TestFailedException] {
           HashSet(1, 2) should (contain (55) or contain (22))
         }
-        assert(caught2.getMessage === "Set(1, 2) did not contain element 55, and Set(1, 2) did not contain element 22")
+        assert(caught2.getMessage === HashSet(1, 2) + " did not contain element 55, and " + HashSet(1, 2) + " did not contain element 22")
       }
 
       it("should throw a TestFailedException when set contains the specified element and used in a logical-and expression with not") {
 
         val caught1 = intercept[TestFailedException] {
           HashSet(1, 2) should { not { contain (3) } and not { contain (2) }}
         }
-        assert(caught1.getMessage === "Set(1, 2) did not contain element 3, but Set(1, 2) contained element 2")
+        assert(caught1.getMessage === HashSet(1, 2) + " did not contain element 3, but " + HashSet(1, 2) + " contained element 2")
 
         val caught2 = intercept[TestFailedException] {
           HashSet(1, 2) should ((not contain (3)) and (not contain (2)))
         }
-        assert(caught2.getMessage === "Set(1, 2) did not contain element 3, but Set(1, 2) contained element 2")
+        assert(caught2.getMessage === HashSet(1, 2) + " did not contain element 3, but " + HashSet(1, 2) + " contained element 2")
 
         val caught3 = intercept[TestFailedException] {
           HashSet(1, 2) should (not contain (3) and not contain (2))
         }
-        assert(caught3.getMessage === "Set(1, 2) did not contain element 3, but Set(1, 2) contained element 2")
+        assert(caught3.getMessage === HashSet(1, 2) + " did not contain element 3, but " + HashSet(1, 2) + " contained element 2")
       }
 
       it("should throw a TestFailedException when set contains the specified element and used in a logical-or expression with not") {
 
         val caught1 = intercept[TestFailedException] {
           HashSet(1, 2) should { not { contain (2) } or not { contain (2) }}
         }
-        assert(caught1.getMessage === "Set(1, 2) contained element 2, and Set(1, 2) contained element 2")
+        assert(caught1.getMessage === HashSet(1, 2) + " contained element 2, and " + HashSet(1, 2) + " contained element 2")
 
         val caught2 = intercept[TestFailedException] {
           HashSet(1, 2) should ((not contain (2)) or (not contain (2)))
         }
-        assert(caught2.getMessage === "Set(1, 2) contained element 2, and Set(1, 2) contained element 2")
+        assert(caught2.getMessage === HashSet(1, 2) + " contained element 2, and " + HashSet(1, 2) + " contained element 2")
 
         val caught3 = intercept[TestFailedException] {
           HashSet(1, 2) should (not contain (2) or not contain (2))
         }
-        assert(caught3.getMessage === "Set(1, 2) contained element 2, and Set(1, 2) contained element 2")
+        assert(caught3.getMessage === HashSet(1, 2) + " contained element 2, and " + HashSet(1, 2) + " contained element 2")
       }
 
       // SKIP-SCALATESTJS,NATIVE-START