diff --git a/slope-evaluator/Dockerfile b/slope-evaluator/Dockerfile
new file mode 100644
index 0000000000000000000000000000000000000000..032b8153a6989ca04631ba553289dacb3620a38d
--- /dev/null
+++ b/slope-evaluator/Dockerfile
@@ -0,0 +1,6 @@
+FROM tiangolo/uvicorn-gunicorn-fastapi:python3.7
+
+COPY requirements.txt requirements.txt
+RUN pip install -r requirements.txt
+
+COPY ./app /app
\ No newline at end of file
diff --git a/slope-evaluator/README.md b/slope-evaluator/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..25c02b42e6a6eb4611972febf935403b8b8703c8
--- /dev/null
+++ b/slope-evaluator/README.md
@@ -0,0 +1,26 @@
+# Lag Trend SLO Evaluator
+
+## Execution
+
+For development:
+
+```sh
+uvicorn main:app --reload
+```
+
+Build the docker image:
+
+```sh
+docker build . -t theodolite-evaluator
+```
+
+Run the Docker image:
+
+```sh
+ docker run -p 80:80 theodolite-evaluator
+```
+
+## Configuration
+
+You can set the `HOST` and the `PORT` (and a lot of more parameters) via environment variables. Default is `0.0.0.0:80`.
+For more information see [here](https://github.com/tiangolo/uvicorn-gunicorn-fastapi-docker#advanced-usage).
diff --git a/slope-evaluator/app/main.py b/slope-evaluator/app/main.py
new file mode 100644
index 0000000000000000000000000000000000000000..83709c0f71563d9bd1c29c5f064645144163ea72
--- /dev/null
+++ b/slope-evaluator/app/main.py
@@ -0,0 +1,51 @@
+from fastapi import FastAPI,Request
+import trend_slope_computer as trend_slope_computer
+import logging
+import os
+import pandas as pd
+import json
+import sys
+
+app = FastAPI()
+
+logging.basicConfig(stream=sys.stdout,
+                    format="%(asctime)s %(levelname)s %(name)s: %(message)s")
+logger = logging.getLogger("API")
+
+
+if os.getenv('LOG_LEVEL') == 'INFO':
+    logger.setLevel(logging.INFO)
+elif os.getenv('LOG_LEVEL') == 'WARNING':
+    logger.setLevel(logging.WARNING)
+elif os.getenv('LOG_LEVEL') == 'DEBUG':
+    logger.setLevel((logging.DEBUG))
+
+def execute(results, threshold, warmup):
+    d = []
+    for result in results:
+        group = result['metric']['group']
+        for value in result['values']:
+            d.append({'group': group, 'timestamp': int(
+                value[0]), 'value': int(value[1]) if value[1] != 'NaN' else 0})
+
+    df = pd.DataFrame(d)
+
+    logger.info(df)
+    try:
+        trend_slope = trend_slope_computer.compute(df, warmup)
+    except Exception as e:
+        err_msg = 'Computing trend slope failed'
+        logger.exception(err_msg)
+        logger.error('Mark this subexperiment as not successful and continue benchmark')
+        return False
+
+    logger.info("Trend Slope: %s", trend_slope)
+
+    return trend_slope < threshold
+
+@app.post("/evaluate-slope",response_model=bool)
+async def evaluate_slope(request: Request):
+    data = json.loads(await request.body())
+    return execute(data['total_lag'], data['threshold'], data['warmup'])
+
+logger.info("Slope evaluator is online")
\ No newline at end of file
diff --git a/slope-evaluator/app/trend_slope_computer.py b/slope-evaluator/app/trend_slope_computer.py
new file mode 100644
index 0000000000000000000000000000000000000000..c128d9f48c1e7ba20e43dfbfd6a0391eeec2b60b
--- /dev/null
+++ b/slope-evaluator/app/trend_slope_computer.py
@@ -0,0 +1,18 @@
+from sklearn.linear_model import LinearRegression
+import pandas as pd
+import os
+
+def compute(x, warmup_sec):
+    input = x
+    input['sec_start'] = input.loc[0:, 'timestamp'] - input.iloc[0]['timestamp']
+    regress = input.loc[input['sec_start'] >= warmup_sec] # Warm-Up
+
+    X = regress.iloc[:, 2].values.reshape(-1, 1)  # values converts it into a numpy array
+    Y = regress.iloc[:, 3].values.reshape(-1, 1)  # -1 means that calculate the dimension of rows, but have 1 column
+    linear_regressor = LinearRegression()  # create object for the class
+    linear_regressor.fit(X, Y)  # perform linear regression
+    Y_pred = linear_regressor.predict(X)  # make predictions
+
+    trend_slope = linear_regressor.coef_[0][0]
+
+    return trend_slope
diff --git a/slope-evaluator/requirements.txt b/slope-evaluator/requirements.txt
new file mode 100644
index 0000000000000000000000000000000000000000..ca77b6c891136b1388aaf56c5ae269d6ee4b5729
--- /dev/null
+++ b/slope-evaluator/requirements.txt
@@ -0,0 +1,3 @@
+fastapi==0.55.1
+scikit-learn==0.20.3
+pandas==1.0.3
diff --git a/theodolite-quarkus/build.gradle b/theodolite-quarkus/build.gradle
index ba80ced4b1e4e58f34d5b316f4a46f4e032654a9..1ceb0937776299e6fc9a3c0ec470c9e320e6790f 100644
--- a/theodolite-quarkus/build.gradle
+++ b/theodolite-quarkus/build.gradle
@@ -20,12 +20,13 @@ dependencies {
     implementation 'io.quarkus:quarkus-resteasy'
     testImplementation 'io.quarkus:quarkus-junit5'
     testImplementation 'io.rest-assured:rest-assured'
+    implementation 'com.google.code.gson:gson:2.8.5'
 
     implementation 'org.slf4j:slf4j-simple:1.7.29'
     implementation 'io.github.microutils:kotlin-logging:1.12.0'
     implementation 'io.fabric8:kubernetes-client:5.0.0-alpha-2'
-    compile group: 'org.apache.kafka', name: 'kafka-clients', version: '2.7.0'
-    compile group: 'org.apache.zookeeper', name: 'zookeeper', version: '3.6.2'
+    implementation 'org.apache.kafka:kafka-clients:2.7.0'
+    implementation 'khttp:khttp:1.0.0'
 }
 
 group 'theodolite'
diff --git a/theodolite-quarkus/src/main/kotlin/theodolite/benchmark/BenchmarkExecution.kt b/theodolite-quarkus/src/main/kotlin/theodolite/benchmark/BenchmarkExecution.kt
index 32b06d10f609b8898ac94d514baf4f293b1a2c97..25535e1a64db9641cd47747cf8676b3994964690 100644
--- a/theodolite-quarkus/src/main/kotlin/theodolite/benchmark/BenchmarkExecution.kt
+++ b/theodolite-quarkus/src/main/kotlin/theodolite/benchmark/BenchmarkExecution.kt
@@ -22,6 +22,10 @@ class BenchmarkExecution {
     class Slo {
         lateinit var sloType: String
         var threshold by Delegates.notNull<Int>()
+        lateinit var prometheusUrl: String
+        lateinit var externalSloUrl: String
+        var offset by Delegates.notNull<Int>()
+        var warmup by Delegates.notNull<Int>()
     }
 
     class LoadDefinition {
diff --git a/theodolite-quarkus/src/main/kotlin/theodolite/evaluation/ExternalSloChecker.kt b/theodolite-quarkus/src/main/kotlin/theodolite/evaluation/ExternalSloChecker.kt
new file mode 100644
index 0000000000000000000000000000000000000000..2de8e2dc9c03ec5449c9f04585622d6730644aa2
--- /dev/null
+++ b/theodolite-quarkus/src/main/kotlin/theodolite/evaluation/ExternalSloChecker.kt
@@ -0,0 +1,40 @@
+package theodolite.evaluation
+
+import com.google.gson.Gson
+import khttp.post
+import java.net.ConnectException
+import java.time.Duration
+import java.time.Instant
+
+class ExternalSloChecker(
+    private val prometheusURL: String,
+    private val query: String,
+    private val externalSlopeURL: String,
+    private val threshold: Int,
+    private val offset: Duration,
+    private val warmup: Int
+) :
+    SloChecker {
+
+    private val RETRIES = 2
+    private val TIMEOUT = 60.0
+
+    override fun evaluate(start: Instant, end: Instant): Boolean {
+        var counter = 0
+        val metricFetcher = MetricFetcher(prometheusURL = prometheusURL, offset = offset)
+        val fetchedData = metricFetcher.fetchMetric(start, end, query)
+        val data =
+            Gson().toJson(mapOf("total_lag" to fetchedData.data?.result, "threshold" to threshold, "warmup" to warmup))
+
+        while (counter < RETRIES) {
+            val result = post(externalSlopeURL, data = data, timeout = TIMEOUT)
+            if (result.statusCode != 200) {
+                counter++
+            } else {
+                return result.text.toBoolean()
+            }
+        }
+
+        throw ConnectException("Could not reach slope evaluation")
+    }
+}
diff --git a/theodolite-quarkus/src/main/kotlin/theodolite/evaluation/MetricFetcher.kt b/theodolite-quarkus/src/main/kotlin/theodolite/evaluation/MetricFetcher.kt
new file mode 100644
index 0000000000000000000000000000000000000000..7dbaf568c3452e7ae565002ae00e5314502f8930
--- /dev/null
+++ b/theodolite-quarkus/src/main/kotlin/theodolite/evaluation/MetricFetcher.kt
@@ -0,0 +1,55 @@
+package theodolite.evaluation
+
+import com.google.gson.Gson
+import khttp.get
+import khttp.responses.Response
+import mu.KotlinLogging
+import theodolite.util.PrometheusResponse
+import java.net.ConnectException
+import java.time.Duration
+import java.time.Instant
+
+private val logger = KotlinLogging.logger {}
+
+class MetricFetcher(private val prometheusURL: String, private val offset: Duration) {
+    private val RETRIES = 2
+    private val TIMEOUT = 60.0
+
+    fun fetchMetric(start: Instant, end: Instant, query: String): PrometheusResponse {
+
+        val offsetStart = start.minus(offset)
+        val offsetEnd = end.minus(offset)
+
+        var counter = 0
+        val parameter = mapOf(
+            "query" to query,
+            "start" to offsetStart.toString(),
+            "end" to offsetEnd.toString(),
+            "step" to "5s"
+        )
+
+        while (counter < RETRIES) {
+            val response = get("$prometheusURL/api/v1/query_range", params = parameter, timeout = TIMEOUT)
+            if (response.statusCode != 200) {
+                val message = response.jsonObject.toString()
+                logger.warn { "Could not connect to Prometheus: $message, retrying now" }
+                counter++
+            } else {
+                val values = parseValues(response)
+                if (values.data?.result.isNullOrEmpty()) {
+                    logger.error { "Empty query result: $values" }
+                    throw NoSuchFieldException()
+                }
+                return parseValues(response)
+            }
+        }
+        throw ConnectException("No answer from Prometheus received")
+    }
+
+    private fun parseValues(values: Response): PrometheusResponse {
+        return Gson().fromJson<PrometheusResponse>(
+            values.jsonObject.toString(),
+            PrometheusResponse::class.java
+        )
+    }
+}
diff --git a/theodolite-quarkus/src/main/kotlin/theodolite/evaluation/SLOChecker.kt b/theodolite-quarkus/src/main/kotlin/theodolite/evaluation/SLOChecker.kt
deleted file mode 100644
index 396e1864b491e15d44881439c10847a39ea18286..0000000000000000000000000000000000000000
--- a/theodolite-quarkus/src/main/kotlin/theodolite/evaluation/SLOChecker.kt
+++ /dev/null
@@ -1,3 +0,0 @@
-package theodolite.evaluation
-
-interface SLOChecker {}
diff --git a/theodolite-quarkus/src/main/kotlin/theodolite/evaluation/SloChecker.kt b/theodolite-quarkus/src/main/kotlin/theodolite/evaluation/SloChecker.kt
new file mode 100644
index 0000000000000000000000000000000000000000..53ed1b7fa02681f97b121f93d690c0654f961a94
--- /dev/null
+++ b/theodolite-quarkus/src/main/kotlin/theodolite/evaluation/SloChecker.kt
@@ -0,0 +1,7 @@
+package theodolite.evaluation
+
+import java.time.Instant
+
+interface SloChecker {
+    fun evaluate(start: Instant, end: Instant): Boolean
+}
diff --git a/theodolite-quarkus/src/main/kotlin/theodolite/evaluation/SloCheckerFactory.kt b/theodolite-quarkus/src/main/kotlin/theodolite/evaluation/SloCheckerFactory.kt
new file mode 100644
index 0000000000000000000000000000000000000000..2170ef7b6abdb74499d05ac623c7892ac36b72d9
--- /dev/null
+++ b/theodolite-quarkus/src/main/kotlin/theodolite/evaluation/SloCheckerFactory.kt
@@ -0,0 +1,29 @@
+package theodolite.evaluation
+
+import java.time.Duration
+
+class SloCheckerFactory {
+
+    fun create(
+        slotype: String,
+        prometheusURL: String,
+        query: String,
+        externalSlopeURL: String,
+        threshold: Int,
+        offset: Duration,
+        warmup: Int
+    ): SloChecker {
+
+        return when (slotype) {
+            "lag trend" -> ExternalSloChecker(
+                prometheusURL = prometheusURL,
+                query = query,
+                externalSlopeURL = externalSlopeURL,
+                threshold = threshold,
+                offset = offset,
+                warmup = warmup
+            )
+            else -> throw IllegalArgumentException("Slotype $slotype not found.")
+        }
+    }
+}
diff --git a/theodolite-quarkus/src/main/kotlin/theodolite/execution/BenchmarkExecutor.kt b/theodolite-quarkus/src/main/kotlin/theodolite/execution/BenchmarkExecutor.kt
index 1e939812298da33c47513b3322ff33c00ea001be..d3c2fdcbc0274066e62dd2dfe01fd2a8cf940f13 100644
--- a/theodolite-quarkus/src/main/kotlin/theodolite/execution/BenchmarkExecutor.kt
+++ b/theodolite-quarkus/src/main/kotlin/theodolite/execution/BenchmarkExecutor.kt
@@ -2,6 +2,7 @@ package theodolite.execution
 
 import mu.KotlinLogging
 import theodolite.benchmark.Benchmark
+import theodolite.benchmark.BenchmarkExecution
 import theodolite.util.ConfigurationOverride
 import theodolite.util.LoadDimension
 import theodolite.util.Resource
@@ -22,7 +23,8 @@ abstract class BenchmarkExecutor(
     val benchmark: Benchmark,
     val results: Results,
     val executionDuration: Duration,
-    configurationOverrides: List<ConfigurationOverride>
+    configurationOverrides: List<ConfigurationOverride>,
+    val slo: BenchmarkExecution.Slo
 ) {
 
     /**
@@ -39,9 +41,13 @@ abstract class BenchmarkExecutor(
      *
      */
     fun waitAndLog() {
-        for (i in 1.rangeTo(executionDuration.toMinutes())) {
-            Thread.sleep(Duration.ofMinutes(1).toMillis())
-            logger.info { "Executed: $i minutes" }
+        logger.info { "Execution of a new benchmark started." }
+        for (i in 1.rangeTo(executionDuration.toSeconds())) {
+
+            Thread.sleep(Duration.ofSeconds(1).toMillis())
+            if ((i % 60) == 0L) {
+                logger.info { "Executed: ${i / 60} minutes" }
+            }
         }
     }
 }
diff --git a/theodolite-quarkus/src/main/kotlin/theodolite/execution/BenchmarkExecutorImpl.kt b/theodolite-quarkus/src/main/kotlin/theodolite/execution/BenchmarkExecutorImpl.kt
index 45616a100a8ed067237413ac5afa9fd32f4865e1..19a0cb61c7bc24a00b1c769e77f4174d2f09d2d9 100644
--- a/theodolite-quarkus/src/main/kotlin/theodolite/execution/BenchmarkExecutorImpl.kt
+++ b/theodolite-quarkus/src/main/kotlin/theodolite/execution/BenchmarkExecutorImpl.kt
@@ -1,25 +1,51 @@
 package theodolite.execution
 
+import mu.KotlinLogging
 import theodolite.benchmark.Benchmark
+import theodolite.benchmark.BenchmarkExecution
+import theodolite.evaluation.SloCheckerFactory
 import theodolite.util.ConfigurationOverride
 import theodolite.util.LoadDimension
 import theodolite.util.Resource
 import theodolite.util.Results
 import java.time.Duration
+import java.time.Instant
+
+private val logger = KotlinLogging.logger {}
 
 class BenchmarkExecutorImpl(
     benchmark: Benchmark,
     results: Results,
     executionDuration: Duration,
-    private val configurationOverrides: List<ConfigurationOverride>
-) : BenchmarkExecutor(benchmark, results, executionDuration, configurationOverrides) {
+    private val configurationOverrides: List<ConfigurationOverride>,
+    slo: BenchmarkExecution.Slo
+) : BenchmarkExecutor(benchmark, results, executionDuration, configurationOverrides, slo) {
+    //TODO ADD SHUTDOWN HOOK HERE
     override fun runExperiment(load: LoadDimension, res: Resource): Boolean {
         val benchmarkDeployment = benchmark.buildDeployment(load, res, this.configurationOverrides)
         benchmarkDeployment.setup()
         this.waitAndLog()
         benchmarkDeployment.teardown()
-        // todo evaluate
-        val result = false // if success else false
+
+        var result = false
+        try {
+            result = SloCheckerFactory().create(
+                slotype = slo.sloType,
+                prometheusURL = slo.prometheusUrl,
+                query = "sum by(group)(kafka_consumergroup_group_lag >= 0)",
+                externalSlopeURL = slo.externalSloUrl,
+                threshold = slo.threshold,
+                offset = Duration.ofHours(slo.offset.toLong()),
+                warmup = slo.warmup
+            )
+                .evaluate(
+                    Instant.now().minus(executionDuration),
+                    Instant.now()
+                )
+        } catch (e: Exception) {
+            logger.error { "Evaluation failed for resource: ${res.get()} and load: ${load.get()} error: $e" }
+        }
+
         this.results.setResult(Pair(load, res), result)
         return result
     }
diff --git a/theodolite-quarkus/src/main/kotlin/theodolite/execution/TheodoliteExecutor.kt b/theodolite-quarkus/src/main/kotlin/theodolite/execution/TheodoliteExecutor.kt
index 87388cb61cf8fcb93a1028d20d2e3b68d322ab3d..d1d66af6afdf2f207742b86c89e0771cd2467012 100644
--- a/theodolite-quarkus/src/main/kotlin/theodolite/execution/TheodoliteExecutor.kt
+++ b/theodolite-quarkus/src/main/kotlin/theodolite/execution/TheodoliteExecutor.kt
@@ -20,7 +20,14 @@ class TheodoliteExecutor(
         val strategyFactory = StrategyFactory()
 
         val executionDuration = Duration.ofSeconds(config.execution.duration)
-        val executor = BenchmarkExecutorImpl(kubernetesBenchmark, results, executionDuration, config.configOverrides)
+        val executor =
+            BenchmarkExecutorImpl(
+                kubernetesBenchmark,
+                results,
+                executionDuration,
+                config.configOverrides,
+                config.slos[0]
+            )
 
         return Config(
             loads = config.load.loadValues.map { load -> LoadDimension(load, config.load.loadType) },
diff --git a/theodolite-quarkus/src/main/kotlin/theodolite/execution/TheodoliteYamlExecutor.kt b/theodolite-quarkus/src/main/kotlin/theodolite/execution/TheodoliteYamlExecutor.kt
index ecc202542a0472808f70f9c5dd9696e2de370ea1..f6c109dac52ea4a4faeb30b8041329bc86812552 100644
--- a/theodolite-quarkus/src/main/kotlin/theodolite/execution/TheodoliteYamlExecutor.kt
+++ b/theodolite-quarkus/src/main/kotlin/theodolite/execution/TheodoliteYamlExecutor.kt
@@ -5,6 +5,8 @@ import mu.KotlinLogging
 import theodolite.benchmark.BenchmarkExecution
 import theodolite.benchmark.KubernetesBenchmark
 import theodolite.util.YamlParser
+import kotlin.system.exitProcess
+
 private val logger = KotlinLogging.logger {}
 
 @QuarkusMain(name = "TheodoliteYamlExecutor")
@@ -23,5 +25,6 @@ object TheodoliteYamlExecutor {
         val executor = TheodoliteExecutor(benchmarkExecution, benchmark)
         executor.run()
         logger.info { "Theodolite finished" }
+        exitProcess(0)
     }
 }
diff --git a/theodolite-quarkus/src/main/kotlin/theodolite/k8s/TopicManager.kt b/theodolite-quarkus/src/main/kotlin/theodolite/k8s/TopicManager.kt
index 9cdf1c43fae9a72bd78126d420522b2d41a399ee..1336f57517ef74d8c781cc3b51bf130dbf8d99c5 100644
--- a/theodolite-quarkus/src/main/kotlin/theodolite/k8s/TopicManager.kt
+++ b/theodolite-quarkus/src/main/kotlin/theodolite/k8s/TopicManager.kt
@@ -4,6 +4,7 @@ import mu.KotlinLogging
 import org.apache.kafka.clients.admin.AdminClient
 import org.apache.kafka.clients.admin.ListTopicsResult
 import org.apache.kafka.clients.admin.NewTopic
+import java.util.*
 
 private val logger = KotlinLogging.logger {}
 
diff --git a/theodolite-quarkus/src/main/kotlin/theodolite/util/PrometheusResponse.kt b/theodolite-quarkus/src/main/kotlin/theodolite/util/PrometheusResponse.kt
new file mode 100644
index 0000000000000000000000000000000000000000..e512bd7efb534c705afa3fe17dbc77396a8741db
--- /dev/null
+++ b/theodolite-quarkus/src/main/kotlin/theodolite/util/PrometheusResponse.kt
@@ -0,0 +1,20 @@
+package theodolite.util
+
+data class PrometheusResponse(
+    var status: String? = null,
+    var data: PromData? = null
+)
+
+data class PromData(
+    var resultType: String? = null,
+    var result: List<PromResult>? = null
+)
+
+data class PromResult(
+    var metric: PromMetric? = null,
+    var values: List<Any>? = null
+)
+
+data class PromMetric(
+    var group: String? = null
+)
diff --git a/theodolite-quarkus/src/main/resources/yaml/BenchmarkExecution.yaml b/theodolite-quarkus/src/main/resources/yaml/BenchmarkExecution.yaml
index 270daee1708ca4791c65ff9f4a9e1a1e7e78c4d3..a91d123628a03bb7fd82821d6f34d7bf1239c154 100644
--- a/theodolite-quarkus/src/main/resources/yaml/BenchmarkExecution.yaml
+++ b/theodolite-quarkus/src/main/resources/yaml/BenchmarkExecution.yaml
@@ -3,17 +3,21 @@ benchmark: "benchmarkType"
 load:
   loadType: "NumSensors"
   loadValues:
-    - 10000
+    - 50000
 resources:
   resourceType: "Instances"
   resourceValues:
-    - 2
+    - 1
 slos:
-  - sloType: "slo type"
+  - sloType: "lag trend"
     threshold: 1000
+    prometheusUrl: "http://localhost:32656"
+    externalSloUrl: "http://localhost:80/evaluate-slope"
+    offset: 0
+    warmup: 0
 execution:
   strategy: "LinearSearch"
-  duration: 300
+  duration: 60
   repetitions: 1
   restrictions:
     - "LowerBound"
@@ -33,7 +37,7 @@ configOverrides:
       resource: "uc1-kstreams-deployment.yaml"
       container: "uc-application"
       variableName: "cpu"
-    value: "50m"
+    value: "1000m"
   - patcher:
       type: "ResourceLimitPatcher"
       resource: "uc1-kstreams-deployment.yaml"
diff --git a/theodolite-quarkus/src/test/kotlin/theodolite/CompositeStrategyTest.kt b/theodolite-quarkus/src/test/kotlin/theodolite/CompositeStrategyTest.kt
index 31eaa40fbe5424cf4df00860623e91fa5f1a9408..f269768cbcebfb778ee41f367ee5cc9b6fee1f19 100644
--- a/theodolite-quarkus/src/test/kotlin/theodolite/CompositeStrategyTest.kt
+++ b/theodolite-quarkus/src/test/kotlin/theodolite/CompositeStrategyTest.kt
@@ -3,6 +3,7 @@ package theodolite
 import io.quarkus.test.junit.QuarkusTest
 import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.api.Test
+import theodolite.benchmark.BenchmarkExecution
 import theodolite.strategies.restriction.LowerBoundRestriction
 import theodolite.strategies.searchstrategy.BinarySearch
 import theodolite.strategies.searchstrategy.CompositeStrategy
@@ -29,7 +30,8 @@ class CompositeStrategyTest {
         val mockResources: List<Resource> = (0..6).map { number -> Resource(number, "Instances") }
         val results = Results()
         val benchmark = TestBenchmark()
-        val benchmarkExecutor = TestBenchmarkExecutorImpl(mockResults, benchmark, results)
+        val sloChecker: BenchmarkExecution.Slo = BenchmarkExecution.Slo()
+        val benchmarkExecutor = TestBenchmarkExecutorImpl(mockResults, benchmark, results, sloChecker)
         val linearSearch = LinearSearch(benchmarkExecutor)
         val lowerBoundRestriction = LowerBoundRestriction(results)
         val strategy =
@@ -61,8 +63,9 @@ class CompositeStrategyTest {
         val mockResources: List<Resource> = (0..6).map { number -> Resource(number, "Instances") }
         val results = Results()
         val benchmark = TestBenchmark()
+        val sloChecker: BenchmarkExecution.Slo = BenchmarkExecution.Slo()
         val benchmarkExecutorImpl =
-            TestBenchmarkExecutorImpl(mockResults, benchmark, results)
+            TestBenchmarkExecutorImpl(mockResults, benchmark, results, sloChecker)
         val binarySearch = BinarySearch(benchmarkExecutorImpl)
         val lowerBoundRestriction = LowerBoundRestriction(results)
         val strategy =
@@ -94,7 +97,8 @@ class CompositeStrategyTest {
         val mockResources: List<Resource> = (0..7).map { number -> Resource(number, "Instances") }
         val results = Results()
         val benchmark = TestBenchmark()
-        val benchmarkExecutor = TestBenchmarkExecutorImpl(mockResults, benchmark, results)
+        val sloChecker: BenchmarkExecution.Slo = BenchmarkExecution.Slo()
+        val benchmarkExecutor = TestBenchmarkExecutorImpl(mockResults, benchmark, results, sloChecker)
         val binarySearch = BinarySearch(benchmarkExecutor)
         val lowerBoundRestriction = LowerBoundRestriction(results)
         val strategy =
diff --git a/theodolite-quarkus/src/test/kotlin/theodolite/TestBenchmarkExecutorImpl.kt b/theodolite-quarkus/src/test/kotlin/theodolite/TestBenchmarkExecutorImpl.kt
index bab20b7b56a6b95efd7e616338419b632a8f42d7..2de07d48dbe59313506745e6c97b2ae9a5ed114e 100644
--- a/theodolite-quarkus/src/test/kotlin/theodolite/TestBenchmarkExecutorImpl.kt
+++ b/theodolite-quarkus/src/test/kotlin/theodolite/TestBenchmarkExecutorImpl.kt
@@ -1,6 +1,7 @@
 package theodolite
 
 import theodolite.benchmark.Benchmark
+import theodolite.benchmark.BenchmarkExecution
 import theodolite.execution.BenchmarkExecutor
 import theodolite.util.LoadDimension
 import theodolite.util.Resource
@@ -10,16 +11,19 @@ import java.time.Duration
 class TestBenchmarkExecutorImpl(
     private val mockResults: Array<Array<Boolean>>,
     benchmark: Benchmark,
-    results: Results
+    results: Results,
+    slo: BenchmarkExecution.Slo
 ) :
     BenchmarkExecutor(
-        benchmark, results, executionDuration = Duration.ofSeconds(1),
-        configurationOverrides = emptyList()
+        benchmark,
+        results,
+        executionDuration = Duration.ofSeconds(1),
+        configurationOverrides = emptyList(),
+        slo = slo
     ) {
 
     override fun runExperiment(load: LoadDimension, res: Resource): Boolean {
         val result = this.mockResults[load.get()][res.get()]
-
         this.results.setResult(Pair(load, res), result)
         return result
     }