test(model): Add two tests for a recently fixed performance issue

Add two tests for the issue fixed by [1]. The issue was caused by code
which runs `.reduceOrNull(SpdxExpression::and)` on a collection of
`SpdxExpression`s which has been removed in several places [1].

While it's not possible to prevent the re-introduction of such code,
test two of the callers so we can be sure that computing the effective
license and creating the compund expression is releatively fast.

[1]: 1751f28

Signed-off-by: Frank Viernau <x9fviern@zeiss.com>

Author: fviernau

model/src/test/kotlin/licenses/ResolvedLicenseInfoTest.kt

@@ -25,12 +25,28 @@ import io.kotest.matchers.shouldBe
 
 import io.mockk.mockk
 
+import kotlin.time.Duration.Companion.seconds
+
+import kotlinx.coroutines.DelicateCoroutinesApi
+import kotlinx.coroutines.GlobalScope
+import kotlinx.coroutines.async
+
 import org.ossreviewtoolkit.model.Identifier
+import org.ossreviewtoolkit.model.LicenseFinding
 import org.ossreviewtoolkit.model.LicenseSource
+import org.ossreviewtoolkit.model.TextLocation
+import org.ossreviewtoolkit.model.UnknownProvenance
+import org.ossreviewtoolkit.model.config.CopyrightGarbage
+import org.ossreviewtoolkit.model.config.LicenseFilePatterns
+import org.ossreviewtoolkit.model.licenses.LicenseView.Companion.CONCLUDED_OR_DECLARED_AND_DETECTED
+import org.ossreviewtoolkit.utils.ort.ProcessedDeclaredLicense
+import org.ossreviewtoolkit.utils.spdx.SpdxExpression
+import org.ossreviewtoolkit.utils.spdx.SpdxLicense
 import org.ossreviewtoolkit.utils.spdx.SpdxLicenseChoice
 import org.ossreviewtoolkit.utils.spdx.SpdxSingleLicenseExpression
 import org.ossreviewtoolkit.utils.spdx.toSpdx
 
+@DelicateCoroutinesApi
 class ResolvedLicenseInfoTest : WordSpec({
     "effectiveLicense()" should {
         "apply choices for LicenseView.ALL on all resolved licenses" {
@@ -81,7 +97,7 @@ class ResolvedLicenseInfoTest : WordSpec({
             )
 
             val effectiveLicense = RESOLVED_LICENSE_INFO.effectiveLicense(
-                LicenseView.CONCLUDED_OR_DECLARED_AND_DETECTED,
+                CONCLUDED_OR_DECLARED_AND_DETECTED,
                 choices
             )
 
@@ -119,6 +135,28 @@ class ResolvedLicenseInfoTest : WordSpec({
 
             effectiveLicense shouldBe "$APACHE and ($MIT or $GPL) and $BSD".toSpdx()
         }
+
+        "execute in reasonable time for large license info with several OR operators".config(
+            blockingTest = true,
+            timeout = 1.seconds
+        ) {
+            runCancellable {
+                COMPUTATION_HEAVY_RESOLVED_LICENSE_INFO.effectiveLicense(CONCLUDED_OR_DECLARED_AND_DETECTED)
+            }
+        }
+    }
+
+    "toCompoundExpression()" should {
+        "execute in reasonable time for large license info with several OR operators".config(
+            blockingTest = true,
+            timeout = 1.seconds
+        ) {
+            // Run non-cancellable operation in such a way that cancellation does not wait for completion, see also
+            // https://github.com/Kotlin/kotlinx.coroutines/issues/1449#issuecomment-522907869.
+            runCancellable {
+                COMPUTATION_HEAVY_RESOLVED_LICENSE_INFO.toCompoundExpression()
+            }
+        }
     }
 
     "applyChoices(licenseChoices)" should {
@@ -187,3 +225,99 @@ private val RESOLVED_LICENSE_INFO: ResolvedLicenseInfo by lazy {
         unmatchedCopyrights = emptyMap()
     )
 }
+
+/**
+ * A (detected) resolved license info found in a real world scan, which makes several class members, for example
+ * effectiveLicense(), rather computation-heavy.
+ */
+private val COMPUTATION_HEAVY_RESOLVED_LICENSE_INFO: ResolvedLicenseInfo by lazy {
+    val licensesWithoutChoice = SpdxLicense.values()
+        .toList()
+        .subList(0, 200)
+        .map { SpdxExpression.parse(it.id) }
+
+    // expressions take from a real world scan with swapped identifiers.
+    val licensesWithChoice = listOf(
+        "AAL OR Abstyles",
+        "AdaCore-doc OR Adobe-2006",
+        "Adobe-Display-PostScript OR Adobe-Glyph",
+        "Adobe-Display-PostScript OR AAL",
+        "Adobe-Utopia OR Adobe-2006",
+        "Adobe-Display-PostScript OR Adobe-2006",
+        "(Adobe-2006 OR AdaCore-doc) AND ADSL AND AFL-1.1 AND AFL-1.2 AND AFL-2.0 AND AFL-2.1",
+        "AFL-3.0 OR Afmparse",
+        "AGPL-1.0 OR Abstyles",
+        "AFL-3.0 OR AGPL-1.0-only",
+        "AGPL-1.0-or-later OR AGPL-3.0",
+        "AAL OR Adobe-Glyph",
+        "(AGPL-3.0-only OR AAL) AND AAL",
+        "AGPL-3.0-or-later OR AGPL-1.0-or-later",
+        "AAL OR AGPL-1.0-or-later",
+        "AGPL-3.0-only OR Adobe-2006",
+        "Adobe-Display-PostScript OR Aladdin",
+        "AMDPLPA OR AFL-3.0",
+        "AMD-newlib OR AAL",
+        "AML OR AML OR AML OR AML OR AML OR AML",
+        "AML-glslang OR AAL",
+        "AMPAS OR ANTLR-PD",
+        "AAL OR ANTLR-PD-fallback",
+        "any-OSI OR AML-glslang",
+        "Adobe-2006 OR AML-glslang"
+    ).map { SpdxExpression.parse(it) }
+
+    val licenseFindings = (licensesWithoutChoice + licensesWithChoice).mapTo(mutableSetOf()) { license ->
+        LicenseFinding(
+            license = license,
+            location = TextLocation(
+                path = "path",
+                startLine = 1,
+                endLine = 2
+            )
+        )
+    }
+
+    val licenseInfo = LicenseInfo(
+        id = Identifier.EMPTY,
+        declaredLicenseInfo = DeclaredLicenseInfo(
+            authors = emptySet(),
+            licenses = emptySet(),
+            appliedCurations = emptyList(),
+            processed = ProcessedDeclaredLicense(SpdxExpression.parse("NONE"))
+        ),
+        detectedLicenseInfo = DetectedLicenseInfo(
+            findings = listOf(
+                Findings(
+                    provenance = UnknownProvenance,
+                    licenses = licenseFindings,
+                    copyrights = emptySet(),
+                    licenseFindingCurations = emptyList(),
+                    pathExcludes = emptyList(),
+                    relativeFindingsPath = ""
+                )
+            )
+        ),
+        concludedLicenseInfo = ConcludedLicenseInfo(
+            concludedLicense = null,
+            appliedCurations = emptyList()
+        )
+    )
+
+    val resolver = LicenseInfoResolver(
+        provider = SimpleLicenseInfoProvider(listOf(licenseInfo)),
+        copyrightGarbage = CopyrightGarbage(emptySet()),
+        archiver = null,
+        licenseFilePatterns = LicenseFilePatterns.DEFAULT,
+        addAuthorsToCopyrights = false
+    )
+
+    resolver.resolveLicenseInfo(licenseInfo.id)
+}
+
+@DelicateCoroutinesApi
+private suspend fun runCancellable(nonCancellableBlock: () -> Unit) {
+    // Run non-cancellable operation in such a way that cancellation does not wait for completion, see also
+    // https://github.com/Kotlin/kotlinx.coroutines/issues/1449#issuecomment-522907869.
+    GlobalScope.async {
+        nonCancellableBlock()
+    }.await()
+}