Added check for registering metric providers after prepare() has been called.

Author: dominikmaeckel

stars-core/src/main/kotlin/tools/aqua/stars/core/evaluation/TSCEvaluation.kt

@@ -80,22 +80,25 @@ class TSCEvaluation<E : EntityType<E, T, S>, T : TickDataType<E, T, S>, S : Segm
    * Registers new [MetricProvider]s to the list of metrics that should be called during evaluation.
    *
    * @param metricProviders The [MetricProvider]s that should be registered.
+   * @throws IllegalArgumentException If [prepare] has already been called.
    */
   fun registerMetricProviders(vararg metricProviders: MetricProvider<E, T, S>) {
-    evaluationMetrics.register(
-        metricProviders.filterIsInstance<EvaluationMetricProvider<E, T, S>>())
-    postEvaluationMetrics.register(
-        metricProviders.filterIsInstance<PostEvaluationMetricProvider<E, T, S>>())
+    registerEvaluationMetricProviders(
+        metricProviders.filterIsInstance<EvaluationMetricProvider<E, T, S>>().toList())
+    registerPostEvaluationMetricProviders(
+        metricProviders.filterIsInstance<PostEvaluationMetricProvider<E, T, S>>().toList())
   }
 
   /**
    * Registers new [EvaluationMetricProvider]s to the list of metrics that should be called during
    * evaluation.
    *
    * @param metricProviders The [EvaluationMetricProvider]s that should be registered.
+   * @throws IllegalArgumentException If [prepare] has already been called.
    */
-  fun registerEvaluationMetricProviders(vararg metricProviders: EvaluationMetricProvider<E, T, S>) {
-    this.evaluationMetrics.register(metricProviders.toList())
+  fun registerEvaluationMetricProviders(metricProviders: List<EvaluationMetricProvider<E, T, S>>) {
+    check(tscProjections.isEmpty()) { "TSCEvaluation.prepare() has already been called." }
+    this.evaluationMetrics.register(metricProviders)
   }
 
   /**
@@ -105,9 +108,9 @@ class TSCEvaluation<E : EntityType<E, T, S>, T : TickDataType<E, T, S>, S : Segm
    * @param metricProviders The [PostEvaluationMetricProvider]s that should be registered.
    */
   fun registerPostEvaluationMetricProviders(
-      vararg metricProviders: PostEvaluationMetricProvider<E, T, S>
+      metricProviders: List<PostEvaluationMetricProvider<E, T, S>>
   ) {
-    this.postEvaluationMetrics.register(metricProviders.toList())
+    this.postEvaluationMetrics.register(metricProviders)
   }
 
   /**

stars-core/src/test/kotlin/tools/aqua/stars/core/evaluation/TSCEvaluationTest.kt

@@ -0,0 +1,99 @@
+/*
+ * Copyright 2023 The STARS Project Authors
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package tools.aqua.stars.core.evaluation
+
+import kotlin.test.BeforeTest
+import kotlin.test.Test
+import kotlin.test.assertFailsWith
+import tools.aqua.stars.core.metric.metrics.evaluation.SegmentCountMetric
+import tools.aqua.stars.core.tsc.TSC
+import tools.aqua.stars.core.tsc.builder.*
+import tools.aqua.stars.core.tsc.projection.proj
+import tools.aqua.stars.core.tsc.projection.projRec
+import tools.aqua.stars.core.types.EntityType
+import tools.aqua.stars.core.types.SegmentType
+import tools.aqua.stars.core.types.TickDataType
+
+/** Tests for list extension functions. */
+class TSCEvaluationTest {
+
+  /** Placeholder [EntityType] type. */
+  class EType(override val id: Int, override val tickData: TType) : EntityType<EType, TType, SType>
+
+  /** Placeholder [TickDataType] type. */
+  class TType(
+      override val currentTick: Double,
+      override var entities: List<EType>,
+      override var segment: SType
+  ) : TickDataType<EType, TType, SType>
+
+  /** Placeholder [SegmentType] type. */
+  class SType(
+      override val tickData: List<TType>,
+      override val ticks: Map<Double, TType>,
+      override val tickIDs: List<Double>,
+      override val segmentSource: String,
+      override val firstTickId: Double,
+      override val primaryEntityId: Int
+  ) : SegmentType<EType, TType, SType>
+
+  private lateinit var tscEvaluation: TSCEvaluation<EType, TType, SType>
+
+  /** Sets up a [TSC] and [TSCEvaluation]. */
+  @BeforeTest
+  fun prepare() {
+    val tsc =
+        TSC(
+            root<EType, TType, SType> {
+              all("TSCRoot") {
+                valueFunction = { "TSCRoot" }
+                projectionIDs = mapOf(projRec("all"), proj("projection"))
+                exclusive("Weather") {
+                  projectionIDs = mapOf(projRec("projection"))
+                  leaf("Truth") { condition = { _ -> true } }
+                  leaf("Falseness") { condition = { _ -> false } }
+                }
+              }
+            })
+    tscEvaluation = TSCEvaluation(tsc = tsc, numThreads = 1)
+  }
+
+  /** Tests calling prepare() without registered metric provider. */
+  @Test
+  fun testPrepareWithoutMetricProvider() {
+    assertFailsWith<IllegalStateException> { tscEvaluation.prepare() }
+  }
+
+  /** Tests calling prepare() multiple times. */
+  @Test
+  fun testMultiplePrepare() {
+    tscEvaluation.registerMetricProviders(SegmentCountMetric())
+    tscEvaluation.prepare()
+    assertFailsWith<IllegalStateException> { tscEvaluation.prepare() }
+  }
+
+  /** Tests registerMetricProvider() after calling prepare(). */
+  @Test
+  fun testRegisterMetricProvidersAfterPrepare() {
+    tscEvaluation.registerMetricProviders(SegmentCountMetric())
+    tscEvaluation.prepare()
+    assertFailsWith<IllegalStateException> {
+      tscEvaluation.registerMetricProviders(SegmentCountMetric())
+    }
+  }
+}