Get ShouldSizeSpec to pass under Scala 2.13.0-M5.

cheeseng · cheeseng · commit 913bb891c504 · 2019-04-03T11:02:09.000+08:00
diff --git a/scalatest-test/src/test/scala/org/scalatest/ShouldSizeSpec.scala b/scalatest-test/src/test/scala/org/scalatest/ShouldSizeSpec.scala
@@ -622,15 +622,15 @@ class ShouldSizeSpec extends FunSpec with PropertyChecks with ReturnsNormallyThr
         val caught1 = intercept[TestFailedException] {
           HashSet(1, 2) should have size (3)
         }
-        assert(caught1.getMessage === FailureMessages.hadSizeInsteadOfExpectedSize(prettifier, UnquotedString("Set(1, 2)"), 2, 3))
+        assert(caught1.getMessage === FailureMessages.hadSizeInsteadOfExpectedSize(prettifier, HashSet(1, 2), 2, 3))
         // check((set: Set[String]) => throwsTestFailedException(set should have size (set.size + 1)))
       }
 
       it("should throw TestFailedException with normal error message if specified size is negative") {
         val caught1 = intercept[TestFailedException] {
           HashSet(1, 2) should have size (-2)
         }
-        assert(caught1.getMessage === FailureMessages.hadSizeInsteadOfExpectedSize(prettifier, UnquotedString("Set(1, 2)"), 2, -2))
+        assert(caught1.getMessage === FailureMessages.hadSizeInsteadOfExpectedSize(prettifier, HashSet(1, 2), 2, -2))
         // check((set: Set[Int]) => throwsTestFailedException(set should have size (if (set.size == 0) -1 else -set.size)))
       }
 
@@ -639,71 +639,71 @@ class ShouldSizeSpec extends FunSpec with PropertyChecks with ReturnsNormallyThr
         val caught1 = intercept[TestFailedException] {
           HashSet(1, 2) should { have size (5) and (have size (2 - 1)) }
         }
-        assert(caught1.getMessage === FailureMessages.hadSizeInsteadOfExpectedSize(prettifier, UnquotedString("Set(1, 2)"), 2, 5))
+        assert(caught1.getMessage === FailureMessages.hadSizeInsteadOfExpectedSize(prettifier, HashSet(1, 2), 2, 5))
 
         val caught2 = intercept[TestFailedException] {
           HashSet(1, 2) should ((have size (5)) and (have size (2 - 1)))
         }
-        assert(caught2.getMessage === FailureMessages.hadSizeInsteadOfExpectedSize(prettifier, UnquotedString("Set(1, 2)"), 2, 5))
+        assert(caught2.getMessage === FailureMessages.hadSizeInsteadOfExpectedSize(prettifier, HashSet(1, 2), 2, 5))
 
         val caught3 = intercept[TestFailedException] {
           HashSet(1, 2) should (have size (5) and have size (2 - 1))
         }
-        assert(caught3.getMessage === FailureMessages.hadSizeInsteadOfExpectedSize(prettifier, UnquotedString("Set(1, 2)"), 2, 5))
+        assert(caught3.getMessage === FailureMessages.hadSizeInsteadOfExpectedSize(prettifier, HashSet(1, 2), 2, 5))
       }
 
       it("should throw an assertion error when set size doesn't match and used in a logical-or expression") {
 
         val caught1 = intercept[TestFailedException] {
           HashSet(1, 2) should { have size (55) or (have size (22)) }
         }
-        assert(caught1.getMessage === FailureMessages.commaAnd(prettifier, UnquotedString(FailureMessages.hadSizeInsteadOfExpectedSize(prettifier, UnquotedString("Set(1, 2)"), 2, 55)), UnquotedString(FailureMessages.hadSizeInsteadOfExpectedSize(prettifier, UnquotedString("Set(1, 2)"), 2, 22))))
+        assert(caught1.getMessage === FailureMessages.commaAnd(prettifier, UnquotedString(FailureMessages.hadSizeInsteadOfExpectedSize(prettifier, HashSet(1, 2), 2, 55)), UnquotedString(FailureMessages.hadSizeInsteadOfExpectedSize(prettifier, HashSet(1, 2), 2, 22))))
 
         val caught2 = intercept[TestFailedException] {
           HashSet(1, 2) should ((have size (55)) or (have size (22)))
         }
-        assert(caught2.getMessage === FailureMessages.commaAnd(prettifier, UnquotedString(FailureMessages.hadSizeInsteadOfExpectedSize(prettifier, UnquotedString("Set(1, 2)"), 2, 55)), UnquotedString(FailureMessages.hadSizeInsteadOfExpectedSize(prettifier, UnquotedString("Set(1, 2)"), 2, 22))))
+        assert(caught2.getMessage === FailureMessages.commaAnd(prettifier, UnquotedString(FailureMessages.hadSizeInsteadOfExpectedSize(prettifier, HashSet(1, 2), 2, 55)), UnquotedString(FailureMessages.hadSizeInsteadOfExpectedSize(prettifier, HashSet(1, 2), 2, 22))))
 
         val caught3 = intercept[TestFailedException] {
           HashSet(1, 2) should (have size (55) or have size (22))
         }
-        assert(caught3.getMessage === FailureMessages.commaAnd(prettifier, UnquotedString(FailureMessages.hadSizeInsteadOfExpectedSize(prettifier, UnquotedString("Set(1, 2)"), 2, 55)), UnquotedString(FailureMessages.hadSizeInsteadOfExpectedSize(prettifier, UnquotedString("Set(1, 2)"), 2, 22))))
+        assert(caught3.getMessage === FailureMessages.commaAnd(prettifier, UnquotedString(FailureMessages.hadSizeInsteadOfExpectedSize(prettifier, HashSet(1, 2), 2, 55)), UnquotedString(FailureMessages.hadSizeInsteadOfExpectedSize(prettifier, HashSet(1, 2), 2, 22))))
       }
 
       it("should throw an assertion error when set size matches and used in a logical-and expression with not") {
 
         val caught1 = intercept[TestFailedException] {
           HashSet(1, 2) should { not { have size (3) } and not { have size (2) }}
         }
-        assert(caught1.getMessage === FailureMessages.commaBut(prettifier, UnquotedString(FailureMessages.hadSizeInsteadOfExpectedSize(prettifier, UnquotedString("Set(1, 2)"), 2, 3)), UnquotedString(FailureMessages.hadSize(prettifier, UnquotedString("Set(1, 2)"), 2))))
+        assert(caught1.getMessage === FailureMessages.commaBut(prettifier, UnquotedString(FailureMessages.hadSizeInsteadOfExpectedSize(prettifier, HashSet(1, 2), 2, 3)), UnquotedString(FailureMessages.hadSize(prettifier, HashSet(1, 2), 2))))
 
         val caught2 = intercept[TestFailedException] {
           HashSet(1, 2) should ((not have size (3)) and (not have size (2)))
         }
-        assert(caught2.getMessage === FailureMessages.commaBut(prettifier, UnquotedString(FailureMessages.hadSizeInsteadOfExpectedSize(prettifier, UnquotedString("Set(1, 2)"), 2, 3)), UnquotedString(FailureMessages.hadSize(prettifier, UnquotedString("Set(1, 2)"), 2))))
+        assert(caught2.getMessage === FailureMessages.commaBut(prettifier, UnquotedString(FailureMessages.hadSizeInsteadOfExpectedSize(prettifier, HashSet(1, 2), 2, 3)), UnquotedString(FailureMessages.hadSize(prettifier, HashSet(1, 2), 2))))
 
         val caught3 = intercept[TestFailedException] {
           HashSet(1, 2) should (not have size (3) and not have size (2))
         }
-        assert(caught3.getMessage === FailureMessages.commaBut(prettifier, UnquotedString(FailureMessages.hadSizeInsteadOfExpectedSize(prettifier, UnquotedString("Set(1, 2)"), 2, 3)), UnquotedString(FailureMessages.hadSize(prettifier, UnquotedString("Set(1, 2)"), 2))))
+        assert(caught3.getMessage === FailureMessages.commaBut(prettifier, UnquotedString(FailureMessages.hadSizeInsteadOfExpectedSize(prettifier, HashSet(1, 2), 2, 3)), UnquotedString(FailureMessages.hadSize(prettifier, HashSet(1, 2), 2))))
       }
 
       it("should throw an assertion error when set size matches and used in a logical-or expression with not") {
 
         val caught1 = intercept[TestFailedException] {
           HashSet(1, 2) should { not { have size (2) } or not { have size (2) }}
         }
-        assert(caught1.getMessage === "Set(1, 2) had size 2, and Set(1, 2) had size 2")
+        assert(caught1.getMessage === HashSet(1, 2) + " had size 2, and " + HashSet(1, 2) + " had size 2")
 
         val caught2 = intercept[TestFailedException] {
           HashSet(1, 2) should ((not have size (2)) or (not have size (2)))
         }
-        assert(caught2.getMessage === "Set(1, 2) had size 2, and Set(1, 2) had size 2")
+        assert(caught2.getMessage === HashSet(1, 2) + " had size 2, and " + HashSet(1, 2) + " had size 2")
 
         val caught3 = intercept[TestFailedException] {
           HashSet(1, 2) should (not have size (2) or not have size (2))
         }
-        assert(caught3.getMessage === "Set(1, 2) had size 2, and Set(1, 2) had size 2")
+        assert(caught3.getMessage === HashSet(1, 2) + " had size 2, and " + HashSet(1, 2) + " had size 2")
       }
 
       // SKIP-SCALATESTJS,NATIVE-START
@@ -1655,23 +1655,17 @@ class ShouldSizeSpec extends FunSpec with PropertyChecks with ReturnsNormallyThr
         val caught1 = intercept[TestFailedException] {
           HashMap("one" -> 1, "two" -> 2) should { not { have size (2) } or not { have size (2) }}
         }
-        assert(caught1.getMessage startsWith "Map(")
-        assert(caught1.getMessage contains ") had size 2, and Map(")
-        assert(caught1.getMessage endsWith ") had size 2")
-
+        assert(caught1.getMessage == Prettifier.default(HashMap("one" -> 1, "two" -> 2)) + " had size 2, and " + Prettifier.default(HashMap("one" -> 1, "two" -> 2)) + " had size 2")
+        
         val caught2 = intercept[TestFailedException] {
           HashMap("one" -> 1, "two" -> 2) should ((not have size (2)) or (not have size (2)))
         }
-        assert(caught2.getMessage startsWith "Map(")
-        assert(caught2.getMessage contains ") had size 2, and Map(")
-        assert(caught2.getMessage endsWith ") had size 2")
-
+        assert(caught2.getMessage == Prettifier.default(HashMap("one" -> 1, "two" -> 2)) + " had size 2, and " + Prettifier.default(HashMap("one" -> 1, "two" -> 2)) + " had size 2")
+        
         val caught3 = intercept[TestFailedException] {
           HashMap("one" -> 1, "two" -> 2) should (not have size (2) or not have size (2))
         }
-        assert(caught3.getMessage startsWith "Map(")
-        assert(caught3.getMessage contains ") had size 2, and Map(")
-        assert(caught3.getMessage endsWith ") had size 2")
+        assert(caught3.getMessage == Prettifier.default(HashMap("one" -> 1, "two" -> 2)) + " had size 2, and " + Prettifier.default(HashMap("one" -> 1, "two" -> 2)) + " had size 2")
       }
 
       // SKIP-SCALATESTJS,NATIVE-START

Original file line number	Diff line number	Diff line change
`@@ -622,15 +622,15 @@ class ShouldSizeSpec extends FunSpec with PropertyChecks with ReturnsNormallyThr`
`622`	`622`	`val caught1 = intercept[TestFailedException] {`
`623`	`623`	`HashSet(1, 2) should have size (3)`
`624`	`624`	`}`
`625`		`- assert(caught1.getMessage === FailureMessages.hadSizeInsteadOfExpectedSize(prettifier, UnquotedString("Set(1, 2)"), 2, 3))`
	`625`	`+ assert(caught1.getMessage === FailureMessages.hadSizeInsteadOfExpectedSize(prettifier, HashSet(1, 2), 2, 3))`
`626`	`626`	`// check((set: Set[String]) => throwsTestFailedException(set should have size (set.size + 1)))`
`627`	`627`	`}`
`628`	`628`
`629`	`629`	`it("should throw TestFailedException with normal error message if specified size is negative") {`
`630`	`630`	`val caught1 = intercept[TestFailedException] {`
`631`	`631`	`HashSet(1, 2) should have size (-2)`
`632`	`632`	`}`
`633`		`- assert(caught1.getMessage === FailureMessages.hadSizeInsteadOfExpectedSize(prettifier, UnquotedString("Set(1, 2)"), 2, -2))`
	`633`	`+ assert(caught1.getMessage === FailureMessages.hadSizeInsteadOfExpectedSize(prettifier, HashSet(1, 2), 2, -2))`
`634`	`634`	`// check((set: Set[Int]) => throwsTestFailedException(set should have size (if (set.size == 0) -1 else -set.size)))`
`635`	`635`	`}`
`636`	`636`
`@@ -639,71 +639,71 @@ class ShouldSizeSpec extends FunSpec with PropertyChecks with ReturnsNormallyThr`
`639`	`639`	`val caught1 = intercept[TestFailedException] {`
`640`	`640`	`HashSet(1, 2) should { have size (5) and (have size (2 - 1)) }`
`641`	`641`	`}`
`642`		`- assert(caught1.getMessage === FailureMessages.hadSizeInsteadOfExpectedSize(prettifier, UnquotedString("Set(1, 2)"), 2, 5))`
	`642`	`+ assert(caught1.getMessage === FailureMessages.hadSizeInsteadOfExpectedSize(prettifier, HashSet(1, 2), 2, 5))`
`643`	`643`
`644`	`644`	`val caught2 = intercept[TestFailedException] {`
`645`	`645`	`HashSet(1, 2) should ((have size (5)) and (have size (2 - 1)))`
`646`	`646`	`}`
`647`		`- assert(caught2.getMessage === FailureMessages.hadSizeInsteadOfExpectedSize(prettifier, UnquotedString("Set(1, 2)"), 2, 5))`
	`647`	`+ assert(caught2.getMessage === FailureMessages.hadSizeInsteadOfExpectedSize(prettifier, HashSet(1, 2), 2, 5))`
`648`	`648`
`649`	`649`	`val caught3 = intercept[TestFailedException] {`
`650`	`650`	`HashSet(1, 2) should (have size (5) and have size (2 - 1))`
`651`	`651`	`}`
`652`		`- assert(caught3.getMessage === FailureMessages.hadSizeInsteadOfExpectedSize(prettifier, UnquotedString("Set(1, 2)"), 2, 5))`
	`652`	`+ assert(caught3.getMessage === FailureMessages.hadSizeInsteadOfExpectedSize(prettifier, HashSet(1, 2), 2, 5))`
`653`	`653`	`}`
`654`	`654`
`655`	`655`	`it("should throw an assertion error when set size doesn't match and used in a logical-or expression") {`
`656`	`656`
`657`	`657`	`val caught1 = intercept[TestFailedException] {`
`658`	`658`	`HashSet(1, 2) should { have size (55) or (have size (22)) }`
`659`	`659`	`}`
`660`		`- assert(caught1.getMessage === FailureMessages.commaAnd(prettifier, UnquotedString(FailureMessages.hadSizeInsteadOfExpectedSize(prettifier, UnquotedString("Set(1, 2)"), 2, 55)), UnquotedString(FailureMessages.hadSizeInsteadOfExpectedSize(prettifier, UnquotedString("Set(1, 2)"), 2, 22))))`
	`660`	`+ assert(caught1.getMessage === FailureMessages.commaAnd(prettifier, UnquotedString(FailureMessages.hadSizeInsteadOfExpectedSize(prettifier, HashSet(1, 2), 2, 55)), UnquotedString(FailureMessages.hadSizeInsteadOfExpectedSize(prettifier, HashSet(1, 2), 2, 22))))`
`661`	`661`
`662`	`662`	`val caught2 = intercept[TestFailedException] {`
`663`	`663`	`HashSet(1, 2) should ((have size (55)) or (have size (22)))`
`664`	`664`	`}`
`665`		`- assert(caught2.getMessage === FailureMessages.commaAnd(prettifier, UnquotedString(FailureMessages.hadSizeInsteadOfExpectedSize(prettifier, UnquotedString("Set(1, 2)"), 2, 55)), UnquotedString(FailureMessages.hadSizeInsteadOfExpectedSize(prettifier, UnquotedString("Set(1, 2)"), 2, 22))))`
	`665`	`+ assert(caught2.getMessage === FailureMessages.commaAnd(prettifier, UnquotedString(FailureMessages.hadSizeInsteadOfExpectedSize(prettifier, HashSet(1, 2), 2, 55)), UnquotedString(FailureMessages.hadSizeInsteadOfExpectedSize(prettifier, HashSet(1, 2), 2, 22))))`
`666`	`666`
`667`	`667`	`val caught3 = intercept[TestFailedException] {`
`668`	`668`	`HashSet(1, 2) should (have size (55) or have size (22))`
`669`	`669`	`}`
`670`		`- assert(caught3.getMessage === FailureMessages.commaAnd(prettifier, UnquotedString(FailureMessages.hadSizeInsteadOfExpectedSize(prettifier, UnquotedString("Set(1, 2)"), 2, 55)), UnquotedString(FailureMessages.hadSizeInsteadOfExpectedSize(prettifier, UnquotedString("Set(1, 2)"), 2, 22))))`
	`670`	`+ assert(caught3.getMessage === FailureMessages.commaAnd(prettifier, UnquotedString(FailureMessages.hadSizeInsteadOfExpectedSize(prettifier, HashSet(1, 2), 2, 55)), UnquotedString(FailureMessages.hadSizeInsteadOfExpectedSize(prettifier, HashSet(1, 2), 2, 22))))`
`671`	`671`	`}`
`672`	`672`
`673`	`673`	`it("should throw an assertion error when set size matches and used in a logical-and expression with not") {`
`674`	`674`
`675`	`675`	`val caught1 = intercept[TestFailedException] {`
`676`	`676`	`HashSet(1, 2) should { not { have size (3) } and not { have size (2) }}`
`677`	`677`	`}`
`678`		`- assert(caught1.getMessage === FailureMessages.commaBut(prettifier, UnquotedString(FailureMessages.hadSizeInsteadOfExpectedSize(prettifier, UnquotedString("Set(1, 2)"), 2, 3)), UnquotedString(FailureMessages.hadSize(prettifier, UnquotedString("Set(1, 2)"), 2))))`
	`678`	`+ assert(caught1.getMessage === FailureMessages.commaBut(prettifier, UnquotedString(FailureMessages.hadSizeInsteadOfExpectedSize(prettifier, HashSet(1, 2), 2, 3)), UnquotedString(FailureMessages.hadSize(prettifier, HashSet(1, 2), 2))))`
`679`	`679`
`680`	`680`	`val caught2 = intercept[TestFailedException] {`
`681`	`681`	`HashSet(1, 2) should ((not have size (3)) and (not have size (2)))`
`682`	`682`	`}`
`683`		`- assert(caught2.getMessage === FailureMessages.commaBut(prettifier, UnquotedString(FailureMessages.hadSizeInsteadOfExpectedSize(prettifier, UnquotedString("Set(1, 2)"), 2, 3)), UnquotedString(FailureMessages.hadSize(prettifier, UnquotedString("Set(1, 2)"), 2))))`
	`683`	`+ assert(caught2.getMessage === FailureMessages.commaBut(prettifier, UnquotedString(FailureMessages.hadSizeInsteadOfExpectedSize(prettifier, HashSet(1, 2), 2, 3)), UnquotedString(FailureMessages.hadSize(prettifier, HashSet(1, 2), 2))))`
`684`	`684`
`685`	`685`	`val caught3 = intercept[TestFailedException] {`
`686`	`686`	`HashSet(1, 2) should (not have size (3) and not have size (2))`
`687`	`687`	`}`
`688`		`- assert(caught3.getMessage === FailureMessages.commaBut(prettifier, UnquotedString(FailureMessages.hadSizeInsteadOfExpectedSize(prettifier, UnquotedString("Set(1, 2)"), 2, 3)), UnquotedString(FailureMessages.hadSize(prettifier, UnquotedString("Set(1, 2)"), 2))))`
	`688`	`+ assert(caught3.getMessage === FailureMessages.commaBut(prettifier, UnquotedString(FailureMessages.hadSizeInsteadOfExpectedSize(prettifier, HashSet(1, 2), 2, 3)), UnquotedString(FailureMessages.hadSize(prettifier, HashSet(1, 2), 2))))`
`689`	`689`	`}`
`690`	`690`
`691`	`691`	`it("should throw an assertion error when set size matches and used in a logical-or expression with not") {`
`692`	`692`
`693`	`693`	`val caught1 = intercept[TestFailedException] {`
`694`	`694`	`HashSet(1, 2) should { not { have size (2) } or not { have size (2) }}`
`695`	`695`	`}`
`696`		`- assert(caught1.getMessage === "Set(1, 2) had size 2, and Set(1, 2) had size 2")`
	`696`	`+ assert(caught1.getMessage === HashSet(1, 2) + " had size 2, and " + HashSet(1, 2) + " had size 2")`
`697`	`697`
`698`	`698`	`val caught2 = intercept[TestFailedException] {`
`699`	`699`	`HashSet(1, 2) should ((not have size (2)) or (not have size (2)))`
`700`	`700`	`}`
`701`		`- assert(caught2.getMessage === "Set(1, 2) had size 2, and Set(1, 2) had size 2")`
	`701`	`+ assert(caught2.getMessage === HashSet(1, 2) + " had size 2, and " + HashSet(1, 2) + " had size 2")`
`702`	`702`
`703`	`703`	`val caught3 = intercept[TestFailedException] {`
`704`	`704`	`HashSet(1, 2) should (not have size (2) or not have size (2))`
`705`	`705`	`}`
`706`		`- assert(caught3.getMessage === "Set(1, 2) had size 2, and Set(1, 2) had size 2")`
	`706`	`+ assert(caught3.getMessage === HashSet(1, 2) + " had size 2, and " + HashSet(1, 2) + " had size 2")`
`707`	`707`	`}`
`708`	`708`
`709`	`709`	`// SKIP-SCALATESTJS,NATIVE-START`
`@@ -1655,23 +1655,17 @@ class ShouldSizeSpec extends FunSpec with PropertyChecks with ReturnsNormallyThr`
`1655`	`1655`	`val caught1 = intercept[TestFailedException] {`
`1656`	`1656`	`HashMap("one" -> 1, "two" -> 2) should { not { have size (2) } or not { have size (2) }}`
`1657`	`1657`	`}`
`1658`		`- assert(caught1.getMessage startsWith "Map(")`
`1659`		`- assert(caught1.getMessage contains ") had size 2, and Map(")`
`1660`		`- assert(caught1.getMessage endsWith ") had size 2")`
`1661`		`-`
	`1658`	`+ assert(caught1.getMessage == Prettifier.default(HashMap("one" -> 1, "two" -> 2)) + " had size 2, and " + Prettifier.default(HashMap("one" -> 1, "two" -> 2)) + " had size 2")`
	`1659`	`+`
`1662`	`1660`	`val caught2 = intercept[TestFailedException] {`
`1663`	`1661`	`HashMap("one" -> 1, "two" -> 2) should ((not have size (2)) or (not have size (2)))`
`1664`	`1662`	`}`
`1665`		`- assert(caught2.getMessage startsWith "Map(")`
`1666`		`- assert(caught2.getMessage contains ") had size 2, and Map(")`
`1667`		`- assert(caught2.getMessage endsWith ") had size 2")`
`1668`		`-`
	`1663`	`+ assert(caught2.getMessage == Prettifier.default(HashMap("one" -> 1, "two" -> 2)) + " had size 2, and " + Prettifier.default(HashMap("one" -> 1, "two" -> 2)) + " had size 2")`
	`1664`	`+`
`1669`	`1665`	`val caught3 = intercept[TestFailedException] {`
`1670`	`1666`	`HashMap("one" -> 1, "two" -> 2) should (not have size (2) or not have size (2))`
`1671`	`1667`	`}`
`1672`		`- assert(caught3.getMessage startsWith "Map(")`
`1673`		`- assert(caught3.getMessage contains ") had size 2, and Map(")`
`1674`		`- assert(caught3.getMessage endsWith ") had size 2")`
	`1668`	`+ assert(caught3.getMessage == Prettifier.default(HashMap("one" -> 1, "two" -> 2)) + " had size 2, and " + Prettifier.default(HashMap("one" -> 1, "two" -> 2)) + " had size 2")`
`1675`	`1669`	`}`
`1676`	`1670`
`1677`	`1671`	`// SKIP-SCALATESTJS,NATIVE-START`