refactor tests to use shared SAM and dummy definitions

Author: halotukozak

analyzer/src/test/scala/com/avsystem/commons/analyzer/ImplicitFunctionParamsTest.scala

@@ -145,67 +145,72 @@ final class ImplicitFunctionParamsTest extends AnyFunSuite with AnalyzerTest {
   }
 
   // Define a SAM type (Single Abstract Method) for all SAM type tests
-  trait IntToString {
-    def apply(i: Int): String
+  private val SamDefinition = {
+    //language=Scala
+    """
+      |trait IntToString {
+      |    def apply(i: Int): String
+      |}
+      |""".stripMargin
   }
 
   test("regular parameter with SAM type should pass") {
-    assertNoErrors(
+    assertNoErrors(SamDefinition +
       //language=Scala
-        """
-          |object whatever {
-          |  def goodMethod1(f: IntToString): Unit = ???
-          |}
+      """
+        |object whatever {
+        |  def goodMethod1(f: IntToString): Unit = ???
+        |}
       """.stripMargin)
   }
 
   test("implicit parameter with SAM type should pass") {
-    assertNoErrors(
+    assertNoErrors(SamDefinition +
       //language=Scala
-        """
-          |object whatever {
-          |  def goodMethod2(implicit f: IntToString): Unit = ???
-          |}
+      """
+        |object whatever {
+        |  def goodMethod2(implicit f: IntToString): Unit = ???
+        |}
       """.stripMargin)
   }
 
   test("implicit parameter with SAM type in second parameter list should pass") {
-    assertNoErrors(
+    assertNoErrors(SamDefinition +
       //language=Scala
-        """
-          |object whatever {
-          |  def goodMethod3(x: Int)(implicit f: IntToString): Unit = ???
-          |}
+      """
+        |object whatever {
+        |  def goodMethod3(x: Int)(implicit f: IntToString): Unit = ???
+        |}
       """.stripMargin)
   }
 
   test("regular class parameter with SAM type should pass") {
-    assertNoErrors(
+    assertNoErrors(SamDefinition +
       //language=Scala
-        """
-          |object whatever {
-          |  class GoodClass1(f: IntToString)
-          |}
+      """
+        |object whatever {
+        |  class GoodClass1(f: IntToString)
+        |}
       """.stripMargin)
   }
 
   test("implicit class parameter with SAM type should pass") {
-    assertNoErrors(
+    assertNoErrors(SamDefinition +
       //language=Scala
-        """
-          |object whatever {
-          |  class GoodClass2(implicit f: IntToString)
-          |}
+      """
+        |object whatever {
+        |  class GoodClass2(implicit f: IntToString)
+        |}
       """.stripMargin)
   }
 
   test("implicit class parameter with SAM type in second parameter list should pass") {
-    assertNoErrors(
+    assertNoErrors(SamDefinition +
       //language=Scala
-        """
-          |object whatever {
-          |  class GoodClass3(x: Int)(implicit f: IntToString)
-          |}
+      """
+        |object whatever {
+        |  class GoodClass3(x: Int)(implicit f: IntToString)
+        |}
       """.stripMargin)
   }
 

analyzer/src/test/scala/com/avsystem/commons/analyzer/ImplicitParamDefaultsTest.scala

@@ -4,14 +4,18 @@ package analyzer
 import org.scalatest.funsuite.AnyFunSuite
 
 final class ImplicitParamDefaultsTest extends AnyFunSuite with AnalyzerTest {
-  // Dummy classes for the test
-  class Scheduler
-  object Scheduler {
-    val global = new Scheduler
+  private val DummyDefinition = {
+    //language=Scala
+    """
+      |class Scheduler
+      |object Scheduler {
+      | val global = new Scheduler
+      |}
+      |""".stripMargin
   }
 
   test("implicit parameter without default value should pass") {
-    assertNoErrors(
+    assertNoErrors(DummyDefinition +
       //language=Scala
       """
         |object whatever {
@@ -21,7 +25,7 @@ final class ImplicitParamDefaultsTest extends AnyFunSuite with AnalyzerTest {
   }
 
   test("regular parameter with default value should pass") {
-    assertNoErrors(
+    assertNoErrors(DummyDefinition +
       //language=Scala
       """
         |object whatever {
@@ -32,7 +36,7 @@ final class ImplicitParamDefaultsTest extends AnyFunSuite with AnalyzerTest {
   }
 
   test("implicit parameter with default value should fail") {
-    assertErrors(1,
+    assertErrors(1, DummyDefinition +
       //language=Scala
       """
         |object whatever {
@@ -42,7 +46,7 @@ final class ImplicitParamDefaultsTest extends AnyFunSuite with AnalyzerTest {
   }
 
   test("implicit parameter with default value in second parameter list should fail") {
-    assertErrors(1,
+    assertErrors(1, DummyDefinition +
       //language=Scala
       """
         |object whatever {
@@ -52,7 +56,7 @@ final class ImplicitParamDefaultsTest extends AnyFunSuite with AnalyzerTest {
   }
 
   test("generic method with implicit parameter with default value should fail") {
-    assertErrors(1,
+    assertErrors(1, DummyDefinition +
       //language=Scala
       """
         |object whatever {
@@ -62,39 +66,39 @@ final class ImplicitParamDefaultsTest extends AnyFunSuite with AnalyzerTest {
   }
 
   test("implicit class parameter without default value should pass") {
-    assertNoErrors(
+    assertNoErrors(DummyDefinition +
       //language=Scala
       """
         |class GoodClass1(implicit s: Scheduler)
       """.stripMargin)
   }
 
   test("regular class parameter with default value should pass") {
-    assertNoErrors(
+    assertNoErrors(DummyDefinition +
       //language=Scala
       """
         |class GoodClass2(s: Scheduler = Scheduler.global)
       """.stripMargin)
   }
 
   test("implicit class parameter with default value should fail") {
-    assertErrors(1,
+    assertErrors(1, DummyDefinition +
       //language=Scala
       """
         |class BadClass1(implicit s: Scheduler = Scheduler.global)
       """.stripMargin)
   }
 
   test("implicit class parameter with default value in second parameter list should fail") {
-    assertErrors(1,
+    assertErrors(1, DummyDefinition +
       //language=Scala
       """
         |class BadClass2(sth: Int)(implicit s: Scheduler = Scheduler.global)
       """.stripMargin)
   }
 
   test("generic class with implicit parameter with default value should fail") {
-    assertErrors(1,
+    assertErrors(1, DummyDefinition +
       //language=Scala
       """
         |class BadClass3[T](x: T)(implicit s: Scheduler = Scheduler.global)