Fix RequirementsSpec for Dotty

liufengyun · liufengyun · commit e8ab5db067d2 · 2019-06-18T22:39:36.000+02:00
diff --git a/project/GenScalacticDotty.scala b/project/GenScalacticDotty.scala
@@ -149,7 +149,6 @@ object GenScalacticDotty {
   def genTest(targetDir: File, version: String, scalaVersion: String): Seq[File] =
     copyDir("scalactic-test/src/test/scala/org/scalactic", "org/scalactic", targetDir,
       List(
-        "RequirementsSpec.scala",  // Error during macro expansion
         "TolerantEquivalenceSpec.scala",   // Compilation error to be investigated further.
         "TripleEqualsSpec.for210",  // Old staff, we shall delete this soon.
         "FutureSugarSpec.scala"     // instability, occasional timeout in CI
diff --git a/scalactic-test/src/test/scala/org/scalactic/RequirementsSpec.scala b/scalactic-test/src/test/scala/org/scalactic/RequirementsSpec.scala
@@ -61,10 +61,16 @@ class RequirementsSpec extends FunSpec with Requirements with OptionValues {
     FailureMessages.wasLessThanOrEqualTo(prettifier, left, right)
 
   def commaAnd(left: String, right: String): String =
+  // SKIP-DOTTY-START
     FailureMessages.commaAnd(prettifier, UnquotedString(left), UnquotedString(right))
+  // SKIP-DOTTY-END
+  //DOTTY-ONLY FailureMessages.commaAnd(prettifier, left, right)
 
   def commaBut(left: String, right: String): String =
+  // SKIP-DOTTY-START
     FailureMessages.commaBut(prettifier, UnquotedString(left), UnquotedString(right))
+  // SKIP-DOTTY-END
+  //DOTTY-ONLY FailureMessages.commaBut(prettifier, left, right)
 
   def wasFalse(left: String): String =
     left + " was false"
@@ -215,18 +221,18 @@ class RequirementsSpec extends FunSpec with Requirements with OptionValues {
       assert(e.getMessage == didNotEqual(a, b))
     }
 
-    it("should throw IllegalArgumentException when is used to check a == null") {
+    it("should throw IllegalArgumentException when is used to check a == -1") {
       val e = intercept[IllegalArgumentException] {
-        require(a == null)
+        require(a == -1)
       }
-      assert(e.getMessage == didNotEqual(a, null))
+      assert(e.getMessage == didNotEqual(a, -1))
     }
 
-    it("should throw IllegalArgumentException when is used to check null == a") {
+    it("should throw IllegalArgumentException when is used to check -1 == a") {
       val e = intercept[IllegalArgumentException] {
-        require(null == a)
+        require(-1 == a)
       }
-      assert(e.getMessage == didNotEqual(null, a))
+      assert(e.getMessage == didNotEqual(-1, a))
     }
 
     it("should do nothing when is used to check a === 3") {
@@ -527,6 +533,8 @@ class RequirementsSpec extends FunSpec with Requirements with OptionValues {
       }
       if (ScalacticVersions.BuiltForScalaVersion == "2.12" || ScalacticVersions.BuiltForScalaVersion == "2.13")
         assert(e.getMessage == commaBut(equaled(3, 3), wasFalse("{" + lineSeparator + "  scala.Predef.println(\"hi\");" + lineSeparator + "  b.==(3)" + lineSeparator + "}")))
+      else if (ScalacticVersions.BuiltForScalaVersion.startsWith("0."))
+        assert(e.getMessage == commaBut(equaled(3, 3), wasFalse("{" + lineSeparator + "  scala.Predef.println(\"hi\")" + lineSeparator + "  b.==(3)" + lineSeparator + "}")))
       else
         assert(e.getMessage == commaBut(equaled(3, 3), wasFalse("{" + lineSeparator + "  scala.this.Predef.println(\"hi\");" + lineSeparator + "  b.==(3)" + lineSeparator + "}")))
     }
@@ -541,6 +549,8 @@ class RequirementsSpec extends FunSpec with Requirements with OptionValues {
       }
       if (ScalacticVersions.BuiltForScalaVersion == "2.12" || ScalacticVersions.BuiltForScalaVersion == "2.13")
         assert(e.getMessage == commaBut(wasTrue("{" + lineSeparator + "  scala.Predef.println(\"hi\");" + lineSeparator + "  b.==(5)" + lineSeparator + "}"), didNotEqual(3, 5)))
+      else if (ScalacticVersions.BuiltForScalaVersion.startsWith("0."))
+        assert(e.getMessage == commaBut(wasTrue("{" + lineSeparator + "  scala.Predef.println(\"hi\")" + lineSeparator + "  b.==(5)" + lineSeparator + "}"), didNotEqual(3, 5)))
       else
         assert(e.getMessage == commaBut(wasTrue("{" + lineSeparator + "  scala.this.Predef.println(\"hi\");" + lineSeparator + "  b.==(5)" + lineSeparator + "}"), didNotEqual(3, 5)))
     }
@@ -868,6 +878,8 @@ class RequirementsSpec extends FunSpec with Requirements with OptionValues {
       require(s4.isEmpty)
     }
 
+    // SKIP-DOTTY-START
+    // TODO: missing support for `.isEmpty`, `.length`, `.size`, `.exists`, `.isInstanceOf`
     it("should throw IllegalArgumentException with correct message and stack depth when is used to check s3.isEmpty") {
       val e = intercept[IllegalArgumentException] {
         require(s3.isEmpty)
@@ -1170,6 +1182,7 @@ class RequirementsSpec extends FunSpec with Requirements with OptionValues {
       }
       assert(e.getMessage == wasFalse("ci1.exists(321)"))
     }
+    // SKIP-DOTTY-END
 
     def woof(f: => Unit) = "woof"
     def meow(x: Int = 0, y: Int = 3) = "meow"
@@ -1201,6 +1214,9 @@ class RequirementsSpec extends FunSpec with Requirements with OptionValues {
         """.stripMargin)
     }
 
+    // SKIP-DOTTY-START
+    // ambiguous implicit:
+    //   both method convertToCheckingEqualizer in trait TypeCheckedTripleEquals and method convertToEqualizer in trait TripleEquals provide an extension method `===` on String(org)
     it("should compile when used with org === xxx with TypeCheckedTripleEquals that shadow org.scalactic") {
       assertCompiles(
         """
@@ -1212,6 +1228,7 @@ class RequirementsSpec extends FunSpec with Requirements with OptionValues {
           |}
         """.stripMargin)
     }
+    // SKIP-DOTTY-END
 
     it("should compile when used with org.aCustomMethod that shadow org.scalactic") {
       assertCompiles(
@@ -1350,18 +1367,18 @@ class RequirementsSpec extends FunSpec with Requirements with OptionValues {
       assert(e.getMessage == didNotEqual(a, b) + ", dude")
     }
 
-    it("should throw IllegalArgumentException when is used to check a == null") {
+    it("should throw IllegalArgumentException when is used to check a == -1") {
       val e = intercept[IllegalArgumentException] {
-        require(a == null, ". dude")
+        require(a == -1, ". dude")
       }
-      assert(e.getMessage == didNotEqual(a, null) + ". dude")
+      assert(e.getMessage == didNotEqual(a, -1) + ". dude")
     }
 
-    it("should throw IllegalArgumentException when is used to check null == a") {
+    it("should throw IllegalArgumentException when is used to check -1 == a") {
       val e = intercept[IllegalArgumentException] {
-        require(null == a, "; dude")
+        require(-1 == a, "; dude")
       }
-      assert(e.getMessage == didNotEqual(null, a) + "; dude")
+      assert(e.getMessage == didNotEqual(-1, a) + "; dude")
     }
 
     it("should throw IllegalArgumentException when is used to check 3 != a") {
@@ -1673,6 +1690,8 @@ class RequirementsSpec extends FunSpec with Requirements with OptionValues {
       }
       if (ScalacticVersions.BuiltForScalaVersion == "2.12" || ScalacticVersions.BuiltForScalaVersion == "2.13")
         assert(e.getMessage == commaBut(equaled(3, 3), wasFalse("{" + lineSeparator + "  scala.Predef.println(\"hi\");" + lineSeparator + "  b.==(3)" + lineSeparator + "}")) + ", dude")
+      else if (ScalacticVersions.BuiltForScalaVersion.startsWith("0."))
+        assert(e.getMessage == commaBut(equaled(3, 3), wasFalse("{" + lineSeparator + "  scala.Predef.println(\"hi\")" + lineSeparator + "  b.==(3)" + lineSeparator + "}")) + ", dude")
       else
         assert(e.getMessage == commaBut(equaled(3, 3), wasFalse("{" + lineSeparator + "  scala.this.Predef.println(\"hi\");" + lineSeparator + "  b.==(3)" + lineSeparator + "}")) + ", dude")
     }
@@ -1687,6 +1706,8 @@ class RequirementsSpec extends FunSpec with Requirements with OptionValues {
       }
       if (ScalacticVersions.BuiltForScalaVersion == "2.12" || ScalacticVersions.BuiltForScalaVersion == "2.13")
         assert(e.getMessage == commaBut(wasTrue("{" + lineSeparator + "  scala.Predef.println(\"hi\");" + lineSeparator + "  b.==(5)" + lineSeparator + "}"), didNotEqual(3, 5)) + ", dude")
+      else if (ScalacticVersions.BuiltForScalaVersion.startsWith("0."))
+        assert(e.getMessage == commaBut(wasTrue("{" + lineSeparator + "  scala.Predef.println(\"hi\")" + lineSeparator + "  b.==(5)" + lineSeparator + "}"), didNotEqual(3, 5)) + ", dude")
       else
         assert(e.getMessage == commaBut(wasTrue("{" + lineSeparator + "  scala.this.Predef.println(\"hi\");" + lineSeparator + "  b.==(5)" + lineSeparator + "}"), didNotEqual(3, 5)) + ", dude")
     }
@@ -2014,6 +2035,8 @@ class RequirementsSpec extends FunSpec with Requirements with OptionValues {
       require(s4.isEmpty, ", dude")
     }
 
+    // SKIP-DOTTY-START
+    // TODO: missing support for `.isEmpty`, `.length`, `.size`, `.exists`, `.isInstanceOf`
     it("should throw IllegalArgumentException with correct message and stack depth when is used to check s3.isEmpty") {
       val e = intercept[IllegalArgumentException] {
         require(s3.isEmpty, ", dude")
@@ -2316,6 +2339,7 @@ class RequirementsSpec extends FunSpec with Requirements with OptionValues {
       }
       assert(e.getMessage == wasFalse("ci1.exists(321)") + ", dude")
     }
+    // SKIP-DOTTY-END
 
     def woof(f: => Unit) = "woof"
     def meow(x: Int = 0, y: Int = 3) = "meow"
@@ -2347,6 +2371,9 @@ class RequirementsSpec extends FunSpec with Requirements with OptionValues {
         """.stripMargin)
     }
 
+    // SKIP-DOTTY-START
+    // ambiguous implicit:
+    //   both method convertToCheckingEqualizer in trait TypeCheckedTripleEquals and method convertToEqualizer in trait TripleEquals provide an extension method `===` on String(org)
     it("should compile when used with org === xxx with TypeCheckedTripleEquals that shadow org.scalactic") {
       assertCompiles(
         """
@@ -2358,6 +2385,7 @@ class RequirementsSpec extends FunSpec with Requirements with OptionValues {
           |}
         """.stripMargin)
     }
+    // SKIP-DOTTY-END
 
     it("should compile when used with org.aCustomMethod that shadow org.scalactic") {
       assertCompiles(
@@ -2467,18 +2495,18 @@ class RequirementsSpec extends FunSpec with Requirements with OptionValues {
       assert(e.getMessage == didNotEqual(a, b))
     }
 
-    it("should throw IllegalStateException when is used to check a == null") {
+    it("should throw IllegalStateException when is used to check a == -1") {
       val e = intercept[IllegalStateException] {
-        requireState(a == null)
+        requireState(a == -1)
       }
-      assert(e.getMessage == didNotEqual(a, null))
+      assert(e.getMessage == didNotEqual(a, -1))
     }
 
-    it("should throw IllegalStateException when is used to check null == a") {
+    it("should throw IllegalStateException when is used to check -1 == a") {
       val e = intercept[IllegalStateException] {
-        requireState(null == a)
+        requireState(-1 == a)
       }
-      assert(e.getMessage == didNotEqual(null, a))
+      assert(e.getMessage == didNotEqual(-1, a))
     }
 
     it("should do nothing when is used to check a === 3") {
@@ -2779,6 +2807,8 @@ class RequirementsSpec extends FunSpec with Requirements with OptionValues {
       }
       if (ScalacticVersions.BuiltForScalaVersion == "2.12" || ScalacticVersions.BuiltForScalaVersion == "2.13")
         assert(e.getMessage == commaBut(equaled(3, 3), wasFalse("{" + lineSeparator + "  scala.Predef.println(\"hi\");" + lineSeparator + "  b.==(3)" + lineSeparator + "}")))
+      else if (ScalacticVersions.BuiltForScalaVersion.startsWith("0."))
+        assert(e.getMessage == commaBut(equaled(3, 3), wasFalse("{" + lineSeparator + "  scala.Predef.println(\"hi\")" + lineSeparator + "  b.==(3)" + lineSeparator + "}")))
       else
         assert(e.getMessage == commaBut(equaled(3, 3), wasFalse("{" + lineSeparator + "  scala.this.Predef.println(\"hi\");" + lineSeparator + "  b.==(3)" + lineSeparator + "}")))
     }
@@ -2793,6 +2823,8 @@ class RequirementsSpec extends FunSpec with Requirements with OptionValues {
       }
       if (ScalacticVersions.BuiltForScalaVersion == "2.12" || ScalacticVersions.BuiltForScalaVersion == "2.13")
         assert(e.getMessage == commaBut(wasTrue("{" + lineSeparator + "  scala.Predef.println(\"hi\");" + lineSeparator + "  b.==(5)" + lineSeparator + "}"), didNotEqual(3, 5)))
+      else if (ScalacticVersions.BuiltForScalaVersion.startsWith("0."))
+        assert(e.getMessage == commaBut(wasTrue("{" + lineSeparator + "  scala.Predef.println(\"hi\")" + lineSeparator + "  b.==(5)" + lineSeparator + "}"), didNotEqual(3, 5)))
       else
         assert(e.getMessage == commaBut(wasTrue("{" + lineSeparator + "  scala.this.Predef.println(\"hi\");" + lineSeparator + "  b.==(5)" + lineSeparator + "}"), didNotEqual(3, 5)))
     }
@@ -3120,6 +3152,8 @@ class RequirementsSpec extends FunSpec with Requirements with OptionValues {
       requireState(s4.isEmpty)
     }
 
+    // SKIP-DOTTY-START
+    // TODO: missing support for `.isEmpty`, `.length`, `.size`, `.exists`, `.isInstanceOf`
     it("should throw IllegalStateException with correct message and stack depth when is used to check s3.isEmpty") {
       val e = intercept[IllegalStateException] {
         requireState(s3.isEmpty)
@@ -3422,6 +3456,7 @@ class RequirementsSpec extends FunSpec with Requirements with OptionValues {
       }
       assert(e.getMessage == wasFalse("ci1.exists(321)"))
     }
+    // SKIP-DOTTY-END
 
     def woof(f: => Unit) = "woof"
     def meow(x: Int = 0, y: Int = 3) = "meow"
@@ -3453,6 +3488,9 @@ class RequirementsSpec extends FunSpec with Requirements with OptionValues {
         """.stripMargin)
     }
 
+    // SKIP-DOTTY-START
+    // ambiguous implicit:
+    //   both method convertToCheckingEqualizer in trait TypeCheckedTripleEquals and method convertToEqualizer in trait TripleEquals provide an extension method `===` on String(org)
     it("should compile when used with org === xxx with TypeCheckedTripleEquals that shadow org.scalactic") {
       assertCompiles(
         """
@@ -3464,6 +3502,7 @@ class RequirementsSpec extends FunSpec with Requirements with OptionValues {
           |}
         """.stripMargin)
     }
+    // SKIP-DOTTY-END
 
     it("should compile when used with org.aCustomMethod that shadow org.scalactic") {
       assertCompiles(
@@ -3602,18 +3641,18 @@ class RequirementsSpec extends FunSpec with Requirements with OptionValues {
       assert(e.getMessage == didNotEqual(a, b) + ", dude")
     }
 
-    it("should throw IllegalStateException when is used to check a == null") {
+    it("should throw IllegalStateException when is used to check a == -1") {
       val e = intercept[IllegalStateException] {
-        requireState(a == null, ". dude")
+        requireState(a == -1, ". dude")
       }
-      assert(e.getMessage == didNotEqual(a, null) + ". dude")
+      assert(e.getMessage == didNotEqual(a, -1) + ". dude")
     }
 
-    it("should throw IllegalStateException when is used to check null == a") {
+    it("should throw IllegalStateException when is used to check -1 == a") {
       val e = intercept[IllegalStateException] {
-        requireState(null == a, "; dude")
+        requireState(-1 == a, "; dude")
       }
-      assert(e.getMessage == didNotEqual(null, a) + "; dude")
+      assert(e.getMessage == didNotEqual(-1, a) + "; dude")
     }
 
     it("should throw IllegalStateException when is used to check 3 != a") {
@@ -3925,6 +3964,8 @@ class RequirementsSpec extends FunSpec with Requirements with OptionValues {
       }
       if (ScalacticVersions.BuiltForScalaVersion == "2.12" || ScalacticVersions.BuiltForScalaVersion == "2.13")
         assert(e.getMessage == commaBut(equaled(3, 3), wasFalse("{" + lineSeparator + "  scala.Predef.println(\"hi\");" + lineSeparator + "  b.==(3)" + lineSeparator + "}")) + ", dude")
+      else if (ScalacticVersions.BuiltForScalaVersion.startsWith("0."))
+        assert(e.getMessage == commaBut(equaled(3, 3), wasFalse("{" + lineSeparator + "  scala.Predef.println(\"hi\")" + lineSeparator + "  b.==(3)" + lineSeparator + "}")) + ", dude")
       else
         assert(e.getMessage == commaBut(equaled(3, 3), wasFalse("{" + lineSeparator + "  scala.this.Predef.println(\"hi\");" + lineSeparator + "  b.==(3)" + lineSeparator + "}")) + ", dude")
     }
@@ -3939,6 +3980,8 @@ class RequirementsSpec extends FunSpec with Requirements with OptionValues {
       }
       if (ScalacticVersions.BuiltForScalaVersion == "2.12" || ScalacticVersions.BuiltForScalaVersion == "2.13")
         assert(e.getMessage == commaBut(wasTrue("{" + lineSeparator + "  scala.Predef.println(\"hi\");" + lineSeparator + "  b.==(5)" + lineSeparator + "}"), didNotEqual(3, 5)) + ", dude")
+      else if (ScalacticVersions.BuiltForScalaVersion.startsWith("0."))
+        assert(e.getMessage == commaBut(wasTrue("{" + lineSeparator + "  scala.Predef.println(\"hi\")" + lineSeparator + "  b.==(5)" + lineSeparator + "}"), didNotEqual(3, 5)) + ", dude")
       else
         assert(e.getMessage == commaBut(wasTrue("{" + lineSeparator + "  scala.this.Predef.println(\"hi\");" + lineSeparator + "  b.==(5)" + lineSeparator + "}"), didNotEqual(3, 5)) + ", dude")
     }
@@ -4266,6 +4309,8 @@ class RequirementsSpec extends FunSpec with Requirements with OptionValues {
       requireState(s4.isEmpty, ", dude")
     }
 
+    // SKIP-DOTTY-START
+    // TODO: missing support for `.isEmpty`, `.length`, `.size`, `.exists`, `.isInstanceOf`
     it("should throw IllegalStateException with correct message and stack depth when is used to check s3.isEmpty") {
       val e = intercept[IllegalStateException] {
         requireState(s3.isEmpty, ", dude")
@@ -4568,6 +4613,7 @@ class RequirementsSpec extends FunSpec with Requirements with OptionValues {
       }
       assert(e.getMessage == wasFalse("ci1.exists(321)") + ", dude")
     }
+    // SKIP-DOTTY-END
 
     def woof(f: => Unit) = "woof"
     def meow(x: Int = 0, y: Int = 3) = "meow"
@@ -4599,6 +4645,9 @@ class RequirementsSpec extends FunSpec with Requirements with OptionValues {
         """.stripMargin)
     }
 
+    // SKIP-DOTTY-START
+    // ambiguous implicit:
+    //   both method convertToCheckingEqualizer in trait TypeCheckedTripleEquals and method convertToEqualizer in trait TripleEquals provide an extension method `===` on String(org)
     it("should compile when used with org === xxx with TypeCheckedTripleEquals that shadow org.scalactic") {
       assertCompiles(
         """
@@ -4610,6 +4659,7 @@ class RequirementsSpec extends FunSpec with Requirements with OptionValues {
           |}
         """.stripMargin)
     }
+    // SKIP-DOTTY-END
 
     it("should compile when used with org.aCustomMethod that shadow org.scalactic") {
       assertCompiles(

Original file line number	Diff line number	Diff line change
`@@ -61,10 +61,16 @@ class RequirementsSpec extends FunSpec with Requirements with OptionValues {`
`61`	`61`	`FailureMessages.wasLessThanOrEqualTo(prettifier, left, right)`
`62`	`62`
`63`	`63`	`def commaAnd(left: String, right: String): String =`
	`64`	`+ // SKIP-DOTTY-START`
`64`	`65`	`FailureMessages.commaAnd(prettifier, UnquotedString(left), UnquotedString(right))`
	`66`	`+ // SKIP-DOTTY-END`
	`67`	`+ //DOTTY-ONLY FailureMessages.commaAnd(prettifier, left, right)`
`65`	`68`
`66`	`69`	`def commaBut(left: String, right: String): String =`
	`70`	`+ // SKIP-DOTTY-START`
`67`	`71`	`FailureMessages.commaBut(prettifier, UnquotedString(left), UnquotedString(right))`
	`72`	`+ // SKIP-DOTTY-END`
	`73`	`+ //DOTTY-ONLY FailureMessages.commaBut(prettifier, left, right)`
`68`	`74`
`69`	`75`	`def wasFalse(left: String): String =`
`70`	`76`	`left + " was false"`
`@@ -215,18 +221,18 @@ class RequirementsSpec extends FunSpec with Requirements with OptionValues {`
`215`	`221`	`assert(e.getMessage == didNotEqual(a, b))`
`216`	`222`	`}`
`217`	`223`
`218`		`- it("should throw IllegalArgumentException when is used to check a == null") {`
	`224`	`+ it("should throw IllegalArgumentException when is used to check a == -1") {`
`219`	`225`	`val e = intercept[IllegalArgumentException] {`
`220`		`- require(a == null)`
	`226`	`+ require(a == -1)`
`221`	`227`	`}`
`222`		`- assert(e.getMessage == didNotEqual(a, null))`
	`228`	`+ assert(e.getMessage == didNotEqual(a, -1))`
`223`	`229`	`}`
`224`	`230`
`225`		`- it("should throw IllegalArgumentException when is used to check null == a") {`
	`231`	`+ it("should throw IllegalArgumentException when is used to check -1 == a") {`
`226`	`232`	`val e = intercept[IllegalArgumentException] {`
`227`		`- require(null == a)`
	`233`	`+ require(-1 == a)`
`228`	`234`	`}`
`229`		`- assert(e.getMessage == didNotEqual(null, a))`
	`235`	`+ assert(e.getMessage == didNotEqual(-1, a))`
`230`	`236`	`}`
`231`	`237`
`232`	`238`	`it("should do nothing when is used to check a === 3") {`
`@@ -527,6 +533,8 @@ class RequirementsSpec extends FunSpec with Requirements with OptionValues {`
`527`	`533`	`}`
`528`	`534`	`if (ScalacticVersions.BuiltForScalaVersion == "2.12" \|\| ScalacticVersions.BuiltForScalaVersion == "2.13")`
`529`	`535`	`assert(e.getMessage == commaBut(equaled(3, 3), wasFalse("{" + lineSeparator + " scala.Predef.println(\"hi\");" + lineSeparator + " b.==(3)" + lineSeparator + "}")))`
	`536`	`+ else if (ScalacticVersions.BuiltForScalaVersion.startsWith("0."))`
	`537`	`+ assert(e.getMessage == commaBut(equaled(3, 3), wasFalse("{" + lineSeparator + " scala.Predef.println(\"hi\")" + lineSeparator + " b.==(3)" + lineSeparator + "}")))`
`530`	`538`	`else`
`531`	`539`	`assert(e.getMessage == commaBut(equaled(3, 3), wasFalse("{" + lineSeparator + " scala.this.Predef.println(\"hi\");" + lineSeparator + " b.==(3)" + lineSeparator + "}")))`
`532`	`540`	`}`
`@@ -541,6 +549,8 @@ class RequirementsSpec extends FunSpec with Requirements with OptionValues {`
`541`	`549`	`}`
`542`	`550`	`if (ScalacticVersions.BuiltForScalaVersion == "2.12" \|\| ScalacticVersions.BuiltForScalaVersion == "2.13")`
`543`	`551`	`assert(e.getMessage == commaBut(wasTrue("{" + lineSeparator + " scala.Predef.println(\"hi\");" + lineSeparator + " b.==(5)" + lineSeparator + "}"), didNotEqual(3, 5)))`
	`552`	`+ else if (ScalacticVersions.BuiltForScalaVersion.startsWith("0."))`
	`553`	`+ assert(e.getMessage == commaBut(wasTrue("{" + lineSeparator + " scala.Predef.println(\"hi\")" + lineSeparator + " b.==(5)" + lineSeparator + "}"), didNotEqual(3, 5)))`
`544`	`554`	`else`
`545`	`555`	`assert(e.getMessage == commaBut(wasTrue("{" + lineSeparator + " scala.this.Predef.println(\"hi\");" + lineSeparator + " b.==(5)" + lineSeparator + "}"), didNotEqual(3, 5)))`
`546`	`556`	`}`
`@@ -868,6 +878,8 @@ class RequirementsSpec extends FunSpec with Requirements with OptionValues {`
`868`	`878`	`require(s4.isEmpty)`
`869`	`879`	`}`
`870`	`880`
	`881`	`+ // SKIP-DOTTY-START`
	`882`	+ // TODO: missing support for `.isEmpty`, `.length`, `.size`, `.exists`, `.isInstanceOf`
`871`	`883`	`it("should throw IllegalArgumentException with correct message and stack depth when is used to check s3.isEmpty") {`
`872`	`884`	`val e = intercept[IllegalArgumentException] {`
`873`	`885`	`require(s3.isEmpty)`
`@@ -1170,6 +1182,7 @@ class RequirementsSpec extends FunSpec with Requirements with OptionValues {`
`1170`	`1182`	`}`
`1171`	`1183`	`assert(e.getMessage == wasFalse("ci1.exists(321)"))`
`1172`	`1184`	`}`
	`1185`	`+ // SKIP-DOTTY-END`
`1173`	`1186`
`1174`	`1187`	`def woof(f: => Unit) = "woof"`
`1175`	`1188`	`def meow(x: Int = 0, y: Int = 3) = "meow"`
`@@ -1201,6 +1214,9 @@ class RequirementsSpec extends FunSpec with Requirements with OptionValues {`
`1201`	`1214`	`""".stripMargin)`
`1202`	`1215`	`}`
`1203`	`1216`
	`1217`	`+ // SKIP-DOTTY-START`
	`1218`	`+ // ambiguous implicit:`
	`1219`	+ // both method convertToCheckingEqualizer in trait TypeCheckedTripleEquals and method convertToEqualizer in trait TripleEquals provide an extension method `===` on String(org)
`1204`	`1220`	`it("should compile when used with org === xxx with TypeCheckedTripleEquals that shadow org.scalactic") {`
`1205`	`1221`	`assertCompiles(`
`1206`	`1222`	`"""`
`@@ -1212,6 +1228,7 @@ class RequirementsSpec extends FunSpec with Requirements with OptionValues {`
`1212`	`1228`	`\|}`
`1213`	`1229`	`""".stripMargin)`
`1214`	`1230`	`}`
	`1231`	`+ // SKIP-DOTTY-END`
`1215`	`1232`
`1216`	`1233`	`it("should compile when used with org.aCustomMethod that shadow org.scalactic") {`
`1217`	`1234`	`assertCompiles(`
`@@ -1350,18 +1367,18 @@ class RequirementsSpec extends FunSpec with Requirements with OptionValues {`
`1350`	`1367`	`assert(e.getMessage == didNotEqual(a, b) + ", dude")`
`1351`	`1368`	`}`
`1352`	`1369`
`1353`		`- it("should throw IllegalArgumentException when is used to check a == null") {`
	`1370`	`+ it("should throw IllegalArgumentException when is used to check a == -1") {`
`1354`	`1371`	`val e = intercept[IllegalArgumentException] {`
`1355`		`- require(a == null, ". dude")`
	`1372`	`+ require(a == -1, ". dude")`
`1356`	`1373`	`}`
`1357`		`- assert(e.getMessage == didNotEqual(a, null) + ". dude")`
	`1374`	`+ assert(e.getMessage == didNotEqual(a, -1) + ". dude")`
`1358`	`1375`	`}`
`1359`	`1376`
`1360`		`- it("should throw IllegalArgumentException when is used to check null == a") {`
	`1377`	`+ it("should throw IllegalArgumentException when is used to check -1 == a") {`
`1361`	`1378`	`val e = intercept[IllegalArgumentException] {`
`1362`		`- require(null == a, "; dude")`
	`1379`	`+ require(-1 == a, "; dude")`
`1363`	`1380`	`}`
`1364`		`- assert(e.getMessage == didNotEqual(null, a) + "; dude")`
	`1381`	`+ assert(e.getMessage == didNotEqual(-1, a) + "; dude")`
`1365`	`1382`	`}`
`1366`	`1383`
`1367`	`1384`	`it("should throw IllegalArgumentException when is used to check 3 != a") {`
`@@ -1673,6 +1690,8 @@ class RequirementsSpec extends FunSpec with Requirements with OptionValues {`
`1673`	`1690`	`}`
`1674`	`1691`	`if (ScalacticVersions.BuiltForScalaVersion == "2.12" \|\| ScalacticVersions.BuiltForScalaVersion == "2.13")`
`1675`	`1692`	`assert(e.getMessage == commaBut(equaled(3, 3), wasFalse("{" + lineSeparator + " scala.Predef.println(\"hi\");" + lineSeparator + " b.==(3)" + lineSeparator + "}")) + ", dude")`
	`1693`	`+ else if (ScalacticVersions.BuiltForScalaVersion.startsWith("0."))`
	`1694`	`+ assert(e.getMessage == commaBut(equaled(3, 3), wasFalse("{" + lineSeparator + " scala.Predef.println(\"hi\")" + lineSeparator + " b.==(3)" + lineSeparator + "}")) + ", dude")`
`1676`	`1695`	`else`
`1677`	`1696`	`assert(e.getMessage == commaBut(equaled(3, 3), wasFalse("{" + lineSeparator + " scala.this.Predef.println(\"hi\");" + lineSeparator + " b.==(3)" + lineSeparator + "}")) + ", dude")`
`1678`	`1697`	`}`
`@@ -1687,6 +1706,8 @@ class RequirementsSpec extends FunSpec with Requirements with OptionValues {`
`1687`	`1706`	`}`
`1688`	`1707`	`if (ScalacticVersions.BuiltForScalaVersion == "2.12" \|\| ScalacticVersions.BuiltForScalaVersion == "2.13")`
`1689`	`1708`	`assert(e.getMessage == commaBut(wasTrue("{" + lineSeparator + " scala.Predef.println(\"hi\");" + lineSeparator + " b.==(5)" + lineSeparator + "}"), didNotEqual(3, 5)) + ", dude")`
	`1709`	`+ else if (ScalacticVersions.BuiltForScalaVersion.startsWith("0."))`
	`1710`	`+ assert(e.getMessage == commaBut(wasTrue("{" + lineSeparator + " scala.Predef.println(\"hi\")" + lineSeparator + " b.==(5)" + lineSeparator + "}"), didNotEqual(3, 5)) + ", dude")`
`1690`	`1711`	`else`
`1691`	`1712`	`assert(e.getMessage == commaBut(wasTrue("{" + lineSeparator + " scala.this.Predef.println(\"hi\");" + lineSeparator + " b.==(5)" + lineSeparator + "}"), didNotEqual(3, 5)) + ", dude")`
`1692`	`1713`	`}`
`@@ -2014,6 +2035,8 @@ class RequirementsSpec extends FunSpec with Requirements with OptionValues {`
`2014`	`2035`	`require(s4.isEmpty, ", dude")`
`2015`	`2036`	`}`
`2016`	`2037`
	`2038`	`+ // SKIP-DOTTY-START`
	`2039`	+ // TODO: missing support for `.isEmpty`, `.length`, `.size`, `.exists`, `.isInstanceOf`
`2017`	`2040`	`it("should throw IllegalArgumentException with correct message and stack depth when is used to check s3.isEmpty") {`
`2018`	`2041`	`val e = intercept[IllegalArgumentException] {`
`2019`	`2042`	`require(s3.isEmpty, ", dude")`
`@@ -2316,6 +2339,7 @@ class RequirementsSpec extends FunSpec with Requirements with OptionValues {`
`2316`	`2339`	`}`
`2317`	`2340`	`assert(e.getMessage == wasFalse("ci1.exists(321)") + ", dude")`
`2318`	`2341`	`}`
	`2342`	`+ // SKIP-DOTTY-END`
`2319`	`2343`
`2320`	`2344`	`def woof(f: => Unit) = "woof"`
`2321`	`2345`	`def meow(x: Int = 0, y: Int = 3) = "meow"`
`@@ -2347,6 +2371,9 @@ class RequirementsSpec extends FunSpec with Requirements with OptionValues {`
`2347`	`2371`	`""".stripMargin)`
`2348`	`2372`	`}`
`2349`	`2373`
	`2374`	`+ // SKIP-DOTTY-START`
	`2375`	`+ // ambiguous implicit:`
	`2376`	+ // both method convertToCheckingEqualizer in trait TypeCheckedTripleEquals and method convertToEqualizer in trait TripleEquals provide an extension method `===` on String(org)
`2350`	`2377`	`it("should compile when used with org === xxx with TypeCheckedTripleEquals that shadow org.scalactic") {`
`2351`	`2378`	`assertCompiles(`
`2352`	`2379`	`"""`
`@@ -2358,6 +2385,7 @@ class RequirementsSpec extends FunSpec with Requirements with OptionValues {`
`2358`	`2385`	`\|}`
`2359`	`2386`	`""".stripMargin)`
`2360`	`2387`	`}`
	`2388`	`+ // SKIP-DOTTY-END`
`2361`	`2389`
`2362`	`2390`	`it("should compile when used with org.aCustomMethod that shadow org.scalactic") {`
`2363`	`2391`	`assertCompiles(`
`@@ -2467,18 +2495,18 @@ class RequirementsSpec extends FunSpec with Requirements with OptionValues {`
`2467`	`2495`	`assert(e.getMessage == didNotEqual(a, b))`
`2468`	`2496`	`}`
`2469`	`2497`
`2470`		`- it("should throw IllegalStateException when is used to check a == null") {`
	`2498`	`+ it("should throw IllegalStateException when is used to check a == -1") {`
`2471`	`2499`	`val e = intercept[IllegalStateException] {`
`2472`		`- requireState(a == null)`
	`2500`	`+ requireState(a == -1)`
`2473`	`2501`	`}`
`2474`		`- assert(e.getMessage == didNotEqual(a, null))`
	`2502`	`+ assert(e.getMessage == didNotEqual(a, -1))`
`2475`	`2503`	`}`
`2476`	`2504`
`2477`		`- it("should throw IllegalStateException when is used to check null == a") {`
	`2505`	`+ it("should throw IllegalStateException when is used to check -1 == a") {`
`2478`	`2506`	`val e = intercept[IllegalStateException] {`
`2479`		`- requireState(null == a)`
	`2507`	`+ requireState(-1 == a)`
`2480`	`2508`	`}`
`2481`		`- assert(e.getMessage == didNotEqual(null, a))`
	`2509`	`+ assert(e.getMessage == didNotEqual(-1, a))`
`2482`	`2510`	`}`
`2483`	`2511`
`2484`	`2512`	`it("should do nothing when is used to check a === 3") {`
`@@ -2779,6 +2807,8 @@ class RequirementsSpec extends FunSpec with Requirements with OptionValues {`
`2779`	`2807`	`}`
`2780`	`2808`	`if (ScalacticVersions.BuiltForScalaVersion == "2.12" \|\| ScalacticVersions.BuiltForScalaVersion == "2.13")`
`2781`	`2809`	`assert(e.getMessage == commaBut(equaled(3, 3), wasFalse("{" + lineSeparator + " scala.Predef.println(\"hi\");" + lineSeparator + " b.==(3)" + lineSeparator + "}")))`
	`2810`	`+ else if (ScalacticVersions.BuiltForScalaVersion.startsWith("0."))`
	`2811`	`+ assert(e.getMessage == commaBut(equaled(3, 3), wasFalse("{" + lineSeparator + " scala.Predef.println(\"hi\")" + lineSeparator + " b.==(3)" + lineSeparator + "}")))`
`2782`	`2812`	`else`
`2783`	`2813`	`assert(e.getMessage == commaBut(equaled(3, 3), wasFalse("{" + lineSeparator + " scala.this.Predef.println(\"hi\");" + lineSeparator + " b.==(3)" + lineSeparator + "}")))`
`2784`	`2814`	`}`
`@@ -2793,6 +2823,8 @@ class RequirementsSpec extends FunSpec with Requirements with OptionValues {`
`2793`	`2823`	`}`
`2794`	`2824`	`if (ScalacticVersions.BuiltForScalaVersion == "2.12" \|\| ScalacticVersions.BuiltForScalaVersion == "2.13")`
`2795`	`2825`	`assert(e.getMessage == commaBut(wasTrue("{" + lineSeparator + " scala.Predef.println(\"hi\");" + lineSeparator + " b.==(5)" + lineSeparator + "}"), didNotEqual(3, 5)))`
	`2826`	`+ else if (ScalacticVersions.BuiltForScalaVersion.startsWith("0."))`
	`2827`	`+ assert(e.getMessage == commaBut(wasTrue("{" + lineSeparator + " scala.Predef.println(\"hi\")" + lineSeparator + " b.==(5)" + lineSeparator + "}"), didNotEqual(3, 5)))`
`2796`	`2828`	`else`
`2797`	`2829`	`assert(e.getMessage == commaBut(wasTrue("{" + lineSeparator + " scala.this.Predef.println(\"hi\");" + lineSeparator + " b.==(5)" + lineSeparator + "}"), didNotEqual(3, 5)))`
`2798`	`2830`	`}`
`@@ -3120,6 +3152,8 @@ class RequirementsSpec extends FunSpec with Requirements with OptionValues {`
`3120`	`3152`	`requireState(s4.isEmpty)`
`3121`	`3153`	`}`
`3122`	`3154`
	`3155`	`+ // SKIP-DOTTY-START`
	`3156`	+ // TODO: missing support for `.isEmpty`, `.length`, `.size`, `.exists`, `.isInstanceOf`
`3123`	`3157`	`it("should throw IllegalStateException with correct message and stack depth when is used to check s3.isEmpty") {`
`3124`	`3158`	`val e = intercept[IllegalStateException] {`
`3125`	`3159`	`requireState(s3.isEmpty)`
`@@ -3422,6 +3456,7 @@ class RequirementsSpec extends FunSpec with Requirements with OptionValues {`
`3422`	`3456`	`}`
`3423`	`3457`	`assert(e.getMessage == wasFalse("ci1.exists(321)"))`
`3424`	`3458`	`}`
	`3459`	`+ // SKIP-DOTTY-END`
`3425`	`3460`
`3426`	`3461`	`def woof(f: => Unit) = "woof"`
`3427`	`3462`	`def meow(x: Int = 0, y: Int = 3) = "meow"`
`@@ -3453,6 +3488,9 @@ class RequirementsSpec extends FunSpec with Requirements with OptionValues {`
`3453`	`3488`	`""".stripMargin)`
`3454`	`3489`	`}`
`3455`	`3490`
	`3491`	`+ // SKIP-DOTTY-START`
	`3492`	`+ // ambiguous implicit:`
	`3493`	+ // both method convertToCheckingEqualizer in trait TypeCheckedTripleEquals and method convertToEqualizer in trait TripleEquals provide an extension method `===` on String(org)
`3456`	`3494`	`it("should compile when used with org === xxx with TypeCheckedTripleEquals that shadow org.scalactic") {`
`3457`	`3495`	`assertCompiles(`
`3458`	`3496`	`"""`
`@@ -3464,6 +3502,7 @@ class RequirementsSpec extends FunSpec with Requirements with OptionValues {`
`3464`	`3502`	`\|}`
`3465`	`3503`	`""".stripMargin)`
`3466`	`3504`	`}`
	`3505`	`+ // SKIP-DOTTY-END`
`3467`	`3506`
`3468`	`3507`	`it("should compile when used with org.aCustomMethod that shadow org.scalactic") {`
`3469`	`3508`	`assertCompiles(`
`@@ -3602,18 +3641,18 @@ class RequirementsSpec extends FunSpec with Requirements with OptionValues {`
`3602`	`3641`	`assert(e.getMessage == didNotEqual(a, b) + ", dude")`
`3603`	`3642`	`}`
`3604`	`3643`
`3605`		`- it("should throw IllegalStateException when is used to check a == null") {`
	`3644`	`+ it("should throw IllegalStateException when is used to check a == -1") {`
`3606`	`3645`	`val e = intercept[IllegalStateException] {`
`3607`		`- requireState(a == null, ". dude")`
	`3646`	`+ requireState(a == -1, ". dude")`
`3608`	`3647`	`}`
`3609`		`- assert(e.getMessage == didNotEqual(a, null) + ". dude")`
	`3648`	`+ assert(e.getMessage == didNotEqual(a, -1) + ". dude")`
`3610`	`3649`	`}`
`3611`	`3650`
`3612`		`- it("should throw IllegalStateException when is used to check null == a") {`
	`3651`	`+ it("should throw IllegalStateException when is used to check -1 == a") {`
`3613`	`3652`	`val e = intercept[IllegalStateException] {`
`3614`		`- requireState(null == a, "; dude")`
	`3653`	`+ requireState(-1 == a, "; dude")`
`3615`	`3654`	`}`
`3616`		`- assert(e.getMessage == didNotEqual(null, a) + "; dude")`
	`3655`	`+ assert(e.getMessage == didNotEqual(-1, a) + "; dude")`
`3617`	`3656`	`}`
`3618`	`3657`
`3619`	`3658`	`it("should throw IllegalStateException when is used to check 3 != a") {`
`@@ -3925,6 +3964,8 @@ class RequirementsSpec extends FunSpec with Requirements with OptionValues {`
`3925`	`3964`	`}`
`3926`	`3965`	`if (ScalacticVersions.BuiltForScalaVersion == "2.12" \|\| ScalacticVersions.BuiltForScalaVersion == "2.13")`
`3927`	`3966`	`assert(e.getMessage == commaBut(equaled(3, 3), wasFalse("{" + lineSeparator + " scala.Predef.println(\"hi\");" + lineSeparator + " b.==(3)" + lineSeparator + "}")) + ", dude")`
	`3967`	`+ else if (ScalacticVersions.BuiltForScalaVersion.startsWith("0."))`
	`3968`	`+ assert(e.getMessage == commaBut(equaled(3, 3), wasFalse("{" + lineSeparator + " scala.Predef.println(\"hi\")" + lineSeparator + " b.==(3)" + lineSeparator + "}")) + ", dude")`
`3928`	`3969`	`else`
`3929`	`3970`	`assert(e.getMessage == commaBut(equaled(3, 3), wasFalse("{" + lineSeparator + " scala.this.Predef.println(\"hi\");" + lineSeparator + " b.==(3)" + lineSeparator + "}")) + ", dude")`
`3930`	`3971`	`}`
`@@ -3939,6 +3980,8 @@ class RequirementsSpec extends FunSpec with Requirements with OptionValues {`
`3939`	`3980`	`}`
`3940`	`3981`	`if (ScalacticVersions.BuiltForScalaVersion == "2.12" \|\| ScalacticVersions.BuiltForScalaVersion == "2.13")`
`3941`	`3982`	`assert(e.getMessage == commaBut(wasTrue("{" + lineSeparator + " scala.Predef.println(\"hi\");" + lineSeparator + " b.==(5)" + lineSeparator + "}"), didNotEqual(3, 5)) + ", dude")`
	`3983`	`+ else if (ScalacticVersions.BuiltForScalaVersion.startsWith("0."))`
	`3984`	`+ assert(e.getMessage == commaBut(wasTrue("{" + lineSeparator + " scala.Predef.println(\"hi\")" + lineSeparator + " b.==(5)" + lineSeparator + "}"), didNotEqual(3, 5)) + ", dude")`
`3942`	`3985`	`else`
`3943`	`3986`	`assert(e.getMessage == commaBut(wasTrue("{" + lineSeparator + " scala.this.Predef.println(\"hi\");" + lineSeparator + " b.==(5)" + lineSeparator + "}"), didNotEqual(3, 5)) + ", dude")`
`3944`	`3987`	`}`
`@@ -4266,6 +4309,8 @@ class RequirementsSpec extends FunSpec with Requirements with OptionValues {`
`4266`	`4309`	`requireState(s4.isEmpty, ", dude")`
`4267`	`4310`	`}`
`4268`	`4311`
	`4312`	`+ // SKIP-DOTTY-START`
	`4313`	+ // TODO: missing support for `.isEmpty`, `.length`, `.size`, `.exists`, `.isInstanceOf`
`4269`	`4314`	`it("should throw IllegalStateException with correct message and stack depth when is used to check s3.isEmpty") {`
`4270`	`4315`	`val e = intercept[IllegalStateException] {`
`4271`	`4316`	`requireState(s3.isEmpty, ", dude")`
`@@ -4568,6 +4613,7 @@ class RequirementsSpec extends FunSpec with Requirements with OptionValues {`
`4568`	`4613`	`}`
`4569`	`4614`	`assert(e.getMessage == wasFalse("ci1.exists(321)") + ", dude")`
`4570`	`4615`	`}`
	`4616`	`+ // SKIP-DOTTY-END`
`4571`	`4617`
`4572`	`4618`	`def woof(f: => Unit) = "woof"`
`4573`	`4619`	`def meow(x: Int = 0, y: Int = 3) = "meow"`
`@@ -4599,6 +4645,9 @@ class RequirementsSpec extends FunSpec with Requirements with OptionValues {`
`4599`	`4645`	`""".stripMargin)`
`4600`	`4646`	`}`
`4601`	`4647`
	`4648`	`+ // SKIP-DOTTY-START`
	`4649`	`+ // ambiguous implicit:`
	`4650`	+ // both method convertToCheckingEqualizer in trait TypeCheckedTripleEquals and method convertToEqualizer in trait TripleEquals provide an extension method `===` on String(org)
`4602`	`4651`	`it("should compile when used with org === xxx with TypeCheckedTripleEquals that shadow org.scalactic") {`
`4603`	`4652`	`assertCompiles(`
`4604`	`4653`	`"""`
`@@ -4610,6 +4659,7 @@ class RequirementsSpec extends FunSpec with Requirements with OptionValues {`
`4610`	`4659`	`\|}`
`4611`	`4660`	`""".stripMargin)`
`4612`	`4661`	`}`
	`4662`	`+ // SKIP-DOTTY-END`
`4613`	`4663`
`4614`	`4664`	`it("should compile when used with org.aCustomMethod that shadow org.scalactic") {`
`4615`	`4665`	`assertCompiles(`