better NotImplementedError handling

jetbrains-academy · Jul 12, 2024 · 06afdd1 · 06afdd1
1 parent 7d60b22
commit 06afdd1
Show file tree

Hide file tree

Showing 56 changed files with 1,006 additions and 271 deletions.
diff --git a/AlmostDone/CompleteTheProject/test/Tests.kt b/AlmostDone/CompleteTheProject/test/Tests.kt
@@ -7,11 +7,14 @@ import org.jetbrains.academy.test.system.core.models.classes.findClassSafe
 import org.junit.jupiter.api.Assertions
 import org.junit.jupiter.api.BeforeAll
 import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.extension.ExtendWith
 import org.junit.jupiter.params.ParameterizedTest
 import org.junit.jupiter.params.provider.Arguments
 import org.junit.jupiter.params.provider.MethodSource
 import util.*
 
+@HandleNotImplementedError
+@ExtendWith(HandleNotImplementedErrorExtension::class)
 class Test {
     companion object {
         private const val SQUARED = "squared"
@@ -115,6 +118,11 @@ class Test {
         }
     }
 
+    @Test
+    fun smokeTest() {
+        runMainFunction(::main, "$YES$newLineSymbol$SIMBA$newLineSymbol$BORDERS$newLineSymbol")
+    }
+
     @Test
     fun testPhotoshopFunction() {
         mainClass.checkMethod(mainClazz, photoshop)
@@ -123,7 +131,12 @@ class Test {
     @ParameterizedTest
     @MethodSource("photoshopInputs")
     fun testPhotoshopImplementation(input: String, output: String) {
-        assert(output.replaceLineSeparator() in runMainFunction(::main, input.replaceLineSeparator())) { "You applied the photoshop filters incorrect, for the input: $input the filtered image must be$newLineSymbol$output" }
+        assert(
+            output.replaceLineSeparator() in runMainFunction(
+                ::main,
+                input.replaceLineSeparator()
+            )
+        ) { "You applied the photoshop filters incorrect, for the input: $input the filtered image must be$newLineSymbol$output" }
     }
 
     @Test
@@ -158,9 +171,9 @@ class Test {
         checkReadLineFunctions(
             testMethod = getPictureMethod,
             clazz = mainClazz,
-            input =  input,
+            input = input,
             isSystemInEmpty = isSystemInEmpty,
-            output =  output,
+            output = output,
         )
     }
 
@@ -204,7 +217,11 @@ class Test {
     fun testApplyFilterImplementationBorders(picture: Image) {
         val expectedPicture = picture.borderedImage.trimIndent().replaceLineSeparator()
         val userMethod = mainClass.findMethod(mainClazz, applyFilterMethod)
-        val userPicture = (userMethod.invokeWithArgs(picture.initialImage.trimIndent(), "borders", clazz = mainClazz) as String).trim()
+        val userPicture = (userMethod.invokeWithArgs(
+            picture.initialImage.trimIndent(),
+            "borders",
+            clazz = mainClazz
+        ) as String).trim()
         Assertions.assertEquals(
             expectedPicture, userPicture,
             "For picture:${Util.newLineSeparator}${picture.initialImage}${Util.newLineSeparator} and filter <borders> the function ${applyFilterMethod.name} should return${Util.newLineSeparator}$expectedPicture${Util.newLineSeparator}"
@@ -216,7 +233,11 @@ class Test {
     fun testApplyFilterImplementationSquare(picture: Image) {
         val expectedPicture = picture.squaredImage.trimIndent().replaceLineSeparator()
         val userMethod = mainClass.findMethod(mainClazz, applyFilterMethod)
-        val userPicture = (userMethod.invokeWithArgs(picture.initialImage.trimIndent(), "squared", clazz = mainClazz) as String).trim()
+        val userPicture = (userMethod.invokeWithArgs(
+            picture.initialImage.trimIndent(),
+            "squared",
+            clazz = mainClazz
+        ) as String).trim()
         Assertions.assertEquals(
             expectedPicture, userPicture,
             "For picture:${Util.newLineSeparator}${picture.initialImage}${Util.newLineSeparator} and filter <squared> the function ${applyFilterMethod.name} should return${Util.newLineSeparator}$expectedPicture${Util.newLineSeparator}"
@@ -228,7 +249,8 @@ class Test {
     fun testApplyBordersFilterImplementation(picture: Image) {
         val expectedPicture = picture.borderedImage.trimIndent().replaceLineSeparator()
         val userMethod = mainClass.findMethod(mainClazz, applyBordersFilterMethod)
-        val userPicture = (userMethod.invokeWithArgs(picture.initialImage.trimIndent(), clazz = mainClazz) as String).trim()
+        val userPicture =
+            (userMethod.invokeWithArgs(picture.initialImage.trimIndent(), clazz = mainClazz) as String).trim()
         Assertions.assertEquals(
             expectedPicture, userPicture,
             "For picture:${Util.newLineSeparator}${picture.initialImage}${Util.newLineSeparator} the function ${applyBordersFilterMethod.name} should return${Util.newLineSeparator}$expectedPicture${Util.newLineSeparator}"
@@ -240,7 +262,8 @@ class Test {
     fun testApplySquaredFilterImplementation(picture: Image) {
         val expectedPicture = picture.squaredImage.trimIndent().replaceLineSeparator()
         val userMethod = mainClass.findMethod(mainClazz, applySquaredFilterMethod)
-        val userPicture = (userMethod.invokeWithArgs(picture.initialImage.trimIndent(), clazz = mainClazz) as String).trim()
+        val userPicture =
+            (userMethod.invokeWithArgs(picture.initialImage.trimIndent(), clazz = mainClazz) as String).trim()
         Assertions.assertEquals(
             expectedPicture, userPicture,
             "For picture:${Util.newLineSeparator}${picture.initialImage}${Util.newLineSeparator} the function ${applySquaredFilterMethod.name} should return${Util.newLineSeparator}$expectedPicture${Util.newLineSeparator}"
@@ -272,10 +295,11 @@ class Test {
     fun testTrimPictureImplementation(picture: Image) {
         val expectedPicture = picture.initialImage.trimIndent().replaceLineSeparator()
         val userMethod = mainClass.findMethod(mainClazz, trimPictureMethod)
-        val actualResult = (userMethod.invokeWithArgs(picture.initialImage, clazz = mainClazz) as String).replaceLineSeparator()
+        val actualResult =
+            (userMethod.invokeWithArgs(picture.initialImage, clazz = mainClazz) as String).replaceLineSeparator()
         Assertions.assertEquals(
-                expectedPicture, actualResult,
-                "For picture:${Util.newLineSeparator}${picture.initialImage}${Util.newLineSeparator} the function ${trimPictureMethod.name} should return${Util.newLineSeparator}$expectedPicture${Util.newLineSeparator}"
+            expectedPicture, actualResult,
+            "For picture:${Util.newLineSeparator}${picture.initialImage}${Util.newLineSeparator} the function ${trimPictureMethod.name} should return${Util.newLineSeparator}$expectedPicture${Util.newLineSeparator}"
         )
     }
 }
diff --git a/AlmostDone/MultiRowStrings/test/Tests.kt b/AlmostDone/MultiRowStrings/test/Tests.kt
@@ -4,11 +4,17 @@ import org.jetbrains.academy.test.system.core.models.classes.findClassSafe
 import org.junit.jupiter.api.Assertions
 import org.junit.jupiter.api.BeforeAll
 import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.extension.ExtendWith
 import org.junit.jupiter.params.ParameterizedTest
 import org.junit.jupiter.params.provider.Arguments
 import org.junit.jupiter.params.provider.MethodSource
-import util.*
+import util.HandleNotImplementedError
+import util.HandleNotImplementedErrorExtension
+import util.Util
+import util.throwInternalCourseError
 
+@HandleNotImplementedError
+@ExtendWith(HandleNotImplementedErrorExtension::class)
 class Test {
     companion object {
 
@@ -41,7 +47,9 @@ class Test {
     fun testTrimPictureImplementation(picture: String) {
         val expectedPicture = picture.trimIndent()
         val userMethod = mainClass.findMethod(mainClazz, trimPictureMethod)
-        Assertions.assertEquals(expectedPicture, userMethod.invokeWithArgs(picture, clazz = mainClazz),
-            "For picture:${Util.newLineSeparator}$picture${Util.newLineSeparator} the function ${trimPictureMethod.name} should return${Util.newLineSeparator}$expectedPicture${Util.newLineSeparator}")
+        Assertions.assertEquals(
+            expectedPicture, userMethod.invokeWithArgs(picture, clazz = mainClazz),
+            "For picture:${Util.newLineSeparator}$picture${Util.newLineSeparator} the function ${trimPictureMethod.name} should return${Util.newLineSeparator}$expectedPicture${Util.newLineSeparator}"
+        )
     }
 }
diff --git a/AlmostDone/NullSafety/test/Tests.kt b/AlmostDone/NullSafety/test/Tests.kt
@@ -5,11 +5,14 @@ import org.jetbrains.academy.test.system.core.models.classes.findClassSafe
 import org.junit.jupiter.api.Assertions
 import org.junit.jupiter.api.BeforeAll
 import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.extension.ExtendWith
 import org.junit.jupiter.params.ParameterizedTest
 import org.junit.jupiter.params.provider.Arguments
 import org.junit.jupiter.params.provider.MethodSource
 import util.*
 
+@HandleNotImplementedError
+@ExtendWith(HandleNotImplementedErrorExtension::class)
 class Test {
     companion object {
         private const val SQUARED = "squared"
@@ -75,20 +78,27 @@ class Test {
         setSystemIn(input)
         val result = userMethod.invokeWithoutArgs(mainClazz)
         val errorPostfix = if (!isSystemInEmpty) "not" else ""
-        Assertions.assertEquals(isSystemInEmpty, isSystemInEmpty(),
+        Assertions.assertEquals(
+            isSystemInEmpty, isSystemInEmpty(),
             "For the user's input: $input the function ${chooseFilterMethod.name} should read $errorPostfix " +
                     "all inputs before returning the result."
         )
-        Assertions.assertEquals(output, result, "For the user's input: $input the " +
-                "function ${chooseFilterMethod.name} should return $output")
+        Assertions.assertEquals(
+            output, result, "For the user's input: $input the " +
+                    "function ${chooseFilterMethod.name} should return $output"
+        )
     }
 
     @ParameterizedTest
     @MethodSource("pictures")
     fun testApplyFilterImplementationBorders(picture: Image) {
         val expectedPicture = picture.borderedImage.trimIndent().replaceLineSeparator()
         val userMethod = mainClass.findMethod(mainClazz, applyFilterMethod)
-        val userPicture = (userMethod.invokeWithArgs(picture.initialImage.trimIndent(), "borders", clazz = mainClazz) as String).trim()
+        val userPicture = (userMethod.invokeWithArgs(
+            picture.initialImage.trimIndent(),
+            "borders",
+            clazz = mainClazz
+        ) as String).trim()
         Assertions.assertEquals(
             expectedPicture, userPicture,
             "For picture:${Util.newLineSeparator}${picture.initialImage}${Util.newLineSeparator} and filter <borders> the function ${applyFilterMethod.name} should return${Util.newLineSeparator}$expectedPicture${Util.newLineSeparator}"
@@ -100,7 +110,11 @@ class Test {
     fun testApplyFilterImplementationSquare(picture: Image) {
         val expectedPicture = picture.squaredImage.trimIndent().replaceLineSeparator()
         val userMethod = mainClass.findMethod(mainClazz, applyFilterMethod)
-        val userPicture = (userMethod.invokeWithArgs(picture.initialImage.trimIndent(), "squared", clazz = mainClazz) as String).trim()
+        val userPicture = (userMethod.invokeWithArgs(
+            picture.initialImage.trimIndent(),
+            "squared",
+            clazz = mainClazz
+        ) as String).trim()
         Assertions.assertEquals(
             expectedPicture, userPicture,
             "For picture:${Util.newLineSeparator}${picture.initialImage}${Util.newLineSeparator} and filter <squared> the function ${applyFilterMethod.name} should return${Util.newLineSeparator}$expectedPicture${Util.newLineSeparator}"
@@ -112,7 +126,8 @@ class Test {
     fun testApplyBordersFilterImplementation(picture: Image) {
         val expectedPicture = picture.borderedImage.trimIndent().replaceLineSeparator()
         val userMethod = mainClass.findMethod(mainClazz, applyBordersFilterMethod)
-        val userPicture = (userMethod.invokeWithArgs(picture.initialImage.trimIndent(), clazz = mainClazz) as String).trim()
+        val userPicture =
+            (userMethod.invokeWithArgs(picture.initialImage.trimIndent(), clazz = mainClazz) as String).trim()
         Assertions.assertEquals(
             expectedPicture, userPicture,
             "For picture:${Util.newLineSeparator}${picture.initialImage}${Util.newLineSeparator} the function ${applyBordersFilterMethod.name} should return${Util.newLineSeparator}$expectedPicture${Util.newLineSeparator}"
@@ -124,7 +139,8 @@ class Test {
     fun testApplySquaredFilterImplementation(picture: Image) {
         val expectedPicture = picture.squaredImage.trimIndent().replaceLineSeparator()
         val userMethod = mainClass.findMethod(mainClazz, applySquaredFilterMethod)
-        val userPicture = (userMethod.invokeWithArgs(picture.initialImage.trimIndent(), clazz = mainClazz) as String).trim()
+        val userPicture =
+            (userMethod.invokeWithArgs(picture.initialImage.trimIndent(), clazz = mainClazz) as String).trim()
         Assertions.assertEquals(
             expectedPicture, userPicture,
             "For picture:${Util.newLineSeparator}${picture.initialImage}${Util.newLineSeparator} the function ${applySquaredFilterMethod.name} should return${Util.newLineSeparator}$expectedPicture${Util.newLineSeparator}"
@@ -156,10 +172,11 @@ class Test {
     fun testTrimPictureImplementation(picture: Image) {
         val expectedPicture = picture.initialImage.trimIndent().replaceLineSeparator()
         val userMethod = mainClass.findMethod(mainClazz, trimPictureMethod)
-        val actualResult = (userMethod.invokeWithArgs(picture.initialImage, clazz = mainClazz) as String).replaceLineSeparator()
+        val actualResult =
+            (userMethod.invokeWithArgs(picture.initialImage, clazz = mainClazz) as String).replaceLineSeparator()
         Assertions.assertEquals(
-                expectedPicture, actualResult,
-                "For picture:${Util.newLineSeparator}${picture.initialImage}${Util.newLineSeparator} the function ${trimPictureMethod.name} should return${Util.newLineSeparator}$expectedPicture${Util.newLineSeparator}"
+            expectedPicture, actualResult,
+            "For picture:${Util.newLineSeparator}${picture.initialImage}${Util.newLineSeparator} the function ${trimPictureMethod.name} should return${Util.newLineSeparator}$expectedPicture${Util.newLineSeparator}"
         )
     }
 }