class LocationAwareScriptEvaluationIntegrationTest : AbstractKotlinIntegrationTest() {

    private
    val boom = """throw InternalError("BOOM!")"""

    @Test
    fun `location of exception thrown from build script is reported`() {

        withSettings("""include("a")""")
        val script = withBuildScriptIn("a", boom)

        assertFailingBuildOutputOf("help") {
            """
            * Where:

    def "prints same as JVM for simple exception"() {
        def e = new RuntimeException("BOOM")
        def f = toFailure(e)

        expect:
        FailurePrinter.printToString(f) == getTraceString(e)
    }

    def "prints same as JVM for an exception with cause"() {
        def e = new RuntimeException("BOOM", SimulatedJavaException.simulateDeeperException())
        def f = toFailure(e)

        expect:

        1 * fileSnapshot.getAbsolutePath() >> file.absolutePath
        1 * apiClassExtractor.extractApiClassFrom(_) >> { args -> throw new Exception("Boom!") }

        and:
        def e = thrown(Exception)
        e.message == "Boom!"
    }

    def "does not fall back to full zip entry hashing when fallback is not requested and abi extraction fails for a zip entry"() {

        buildFile << """
            Exception selfReferencingException = new Exception("BOOM self")
            selfReferencingException.initCause(new Exception("BOOM cause", selfReferencingException))
            throw selfReferencingException
        """

        when:
        fails("help", "-s")

        then:
        failureCauseContains("BOOM self")

    plan0.tcpConnectThrowable = IOException("boom 0!")
    val plan1 = routePlanner.addPlan()
    plan1.tcpConnectThrowable = IOException("boom 1!")

    taskRunner.newQueue().execute("connect") {
      assertFailsWith<IOException> {
        finder.find()
      }.also { expected ->
        assertThat(expected).hasMessage("boom 0!")
        assertThat(expected.suppressed.single()).hasMessage("boom 1!")
      }
    }

    target: Path,
  ) {
    if (renameFaults.contains(source) || renameFaults.contains(target)) throw IOException("boom!")
    super.atomicMove(source, target)
  }

  @Throws(IOException::class)
  override fun delete(
    path: Path,
    mustExist: Boolean,
  ) {
    if (deleteFaults.contains(path)) throw IOException("boom!")
    super.delete(path, mustExist)
  }

  @Throws(IOException::class)
  override fun deleteRecursively(

                    throw new RuntimeException("Boom!", custom)
                }
            }

            class CustomException extends RuntimeException {
                CustomException(String msg) {
                    super(msg);
                }
            }
        """

        when:
        fails 'doIt', '-s'

        then:
        failureCauseContains('Boom!')

class JavaVersionCrossVersionTest extends ToolingApiSpecification {

    def setup() {
        buildFile << """
            task myTask {
                doLast {
                    throw new RuntimeException("Boom")
                }
            }
        """
    }

    @Requires([UnitTestPreconditions.Jdk11OrLater, IntegTestPreconditions.Java8HomeAvailable])

                    throw new RuntimeException("BOOM!")
                }
            }
        """
        fails "t"

        then:
        assertResolveTaskMutationsBuildOperationEmitted(":t")
    }

    def "emits operation when resolving mutations fails"() {
        when:
        buildScript """
            task t {
                outputs.files({ -> throw new RuntimeException("BOOM!") })
            }
        """

        val script = withTwoLinesScript()

        val reports = buildEditorReportsFor(
            script,
            listOf(LocationAwareException(Exception("BOOM"), script.canonicalPath, 3)),
            true
        )

        assertThat(reports.size, equalTo(1))
        reports.single().let { report ->
            assertThat(report.severity, equalTo(EditorReportSeverity.WARNING))