diff --git a/checksum.xml b/checksum.xml
index a29e0ba..ce13b9d 100644
--- a/checksum.xml
+++ b/checksum.xml
@@ -94,6 +94,7 @@
     <trusted-key id='d477d51812e692011db11e66a6ea2e2bf22e0543' group='io.github.java-diff-utils' />
     <trusted-key id='e52567d2589415bd74eb4c2867631bc0568801c3' group='io.github.microutils' />
     <trusted-key id='050a37a2e0577f4baa095b52602ec18d20c4661c' group='io.github.x-stream' />
+    <trusted-key id='59b06224fd8912e36603be79fefe78456eddc34a' group='io.mockk' />
     <trusted-key id='6dd3b8c64ef75253beb2c53ad908a43fb7ec07ac' group='jakarta.activation' />
     <trusted-key id='a1483f88ba771993ab609c43590c2310cee1c9be' group='jakarta.jms' />
     <trusted-key id='fc411cd3cb7dcb0abc9801058118b3bcdb1a5000' group='jakarta.xml.bind' />
diff --git a/gradle/checksum-dependency-plugin/cached-pgp-keys/4a/59b06224fd8912e36603be79fefe78456eddc34a.asc b/gradle/checksum-dependency-plugin/cached-pgp-keys/4a/59b06224fd8912e36603be79fefe78456eddc34a.asc
new file mode 100644
index 0000000..9768ac8
--- /dev/null
+++ b/gradle/checksum-dependency-plugin/cached-pgp-keys/4a/59b06224fd8912e36603be79fefe78456eddc34a.asc
@@ -0,0 +1,21 @@
+-----BEGIN PGP PUBLIC KEY BLOCK-----
+
+mQGNBF+y5lsBDAC5h0qk+OBAscHc/ac3A9C8ZPohXcTVpsOjds73soUAH+QCKO0y
+gAUuG/hUUU9xkm9PgTwWOEl2qDDcOFXY+9ykeYNUUcCWfs+JmVRfRod4W5pntaT4
+g9Z+T6LbXKNAfZgPvTv4rr7UjD05N4XS4vckrS4taYLtBRJAmqT3pt43KxlyoTbh
+f4xcO2rWeXsPqgzTYIHH7M5mYPeqA2gc9NBAhkHjesFuYfWXqUfOVcOLvzULxrra
+pZDOyrINr83WikC8DkuDrAav4mIWjIhYmfBWzuNeYJsusVnFENeOxpEHV8RT+8uE
+v1gPjbjAKUPfZoa7egvz3EmDkshpNIIym0XxNGTj5ntJWR2SLT7mDrSYPeHrZKW6
+/aKuAcOxpGLpdVOMM+y4N5mTQfdlL81G9kbGQarMmwGaJb2a82PaF20wRwVgiVfO
+p/GWgwXr0XdJNLqx13LdM8BMM5vmLomOQOjnpQBOlJWRgrYUJQOReKAEAQqNMsxS
+IW9laXkrewJtblEAEQEAAbkBjQRfsuZbAQwAr/owOCxebZMTjp9coUsDjFabJowZ
+H0F++vuh73UY/v2z+vqwug89ABjrPUIccE9/t5dRyEjBt0ED2KFM3mi692QhyYE8
+uRaUKWz0kYaMPuw0W7RTblhhXErBror1m00ibNDGSf3fIr9FZ7u5ep/RTFDCDaZg
+qtWQGVD+uLnqA5EHdwUyieWDSgeThRddM3hKXB1eld4JKJPzQ0XwXLgv8MmbOc9W
+5pxb1ULD44s17SKDjlBtRvrSRdgExgfpKU63HH0D6mn+kJP066knYddunNw7HsKg
+v2mPudTVIQXYGb8xDLhP6UYJowdvJEbM8vp1t/d/CgCMXyVVJOlTZwdJaECE0n4g
+MJ2ihDZ8qbDl81OQhTiWvgoKOFHLTwZgmyhKpt36RvkXkoywqlKNGaZVNi9Ct1Xx
+fprj4sozA5Mcf8BAaxXV9sQfZLKH7NhGrFzc/r1v2R37RYWfmYL79dJj1xsrcEN8
+26cSoyLi69+XOxvbdo4KfyopRxECTdd6Oqk/ABEBAAE=
+=+/j7
+-----END PGP PUBLIC KEY BLOCK-----
diff --git a/gradle/checksum-dependency-plugin/cached-pgp-keys/4a/fefe78456eddc34a.fingerprints b/gradle/checksum-dependency-plugin/cached-pgp-keys/4a/fefe78456eddc34a.fingerprints
new file mode 100644
index 0000000..cc05455
--- /dev/null
+++ b/gradle/checksum-dependency-plugin/cached-pgp-keys/4a/fefe78456eddc34a.fingerprints
@@ -0,0 +1 @@
+59b06224fd8912e36603be79fefe78456eddc34a
diff --git a/gradle/checksum-dependency-plugin/cached-pgp-keys/7c/c3720ddc2e713b7c.fingerprints b/gradle/checksum-dependency-plugin/cached-pgp-keys/7c/c3720ddc2e713b7c.fingerprints
new file mode 100644
index 0000000..cc05455
--- /dev/null
+++ b/gradle/checksum-dependency-plugin/cached-pgp-keys/7c/c3720ddc2e713b7c.fingerprints
@@ -0,0 +1 @@
+59b06224fd8912e36603be79fefe78456eddc34a
diff --git a/src/bom-testing/build.gradle.kts b/src/bom-testing/build.gradle.kts
index 0f28bf8..65ddd38 100644
--- a/src/bom-testing/build.gradle.kts
+++ b/src/bom-testing/build.gradle.kts
@@ -38,6 +38,7 @@
         // then it should be declared as "api" here since we use useCompileClasspathVersions
         // to make runtime classpath consistent with the compile one.
         api("com.github.tomakehurst:wiremock-jre8:2.35.1")
+        api("io.mockk:mockk:1.13.7")
         api("junit:junit:4.13.2")
         api("net.bytebuddy:byte-buddy:1.14.11")
         api("nl.jqno.equalsverifier:equalsverifier:3.15.5")
diff --git a/src/core/build.gradle.kts b/src/core/build.gradle.kts
index 1d3e73d..b5e0d3d 100644
--- a/src/core/build.gradle.kts
+++ b/src/core/build.gradle.kts
@@ -120,6 +120,7 @@
     runtimeOnly("xml-apis:xml-apis")
 
     testImplementation("commons-net:commons-net")
+    testImplementation("io.mockk:mockk")
     testRuntimeOnly("org.spockframework:spock-core")
 
     testFixturesApi(testFixtures(projects.src.jorphan))
diff --git a/src/core/src/main/java/org/apache/jmeter/services/FileServer.java b/src/core/src/main/java/org/apache/jmeter/services/FileServer.java
index 1f9b836..efd4ad7 100644
--- a/src/core/src/main/java/org/apache/jmeter/services/FileServer.java
+++ b/src/core/src/main/java/org/apache/jmeter/services/FileServer.java
@@ -81,7 +81,7 @@
     private volatile String scriptName;
 
     // Cannot be instantiated
-    private FileServer() {
+    FileServer() {
         base = new File(DEFAULT_BASE);
         log.info("Default base='{}'", DEFAULT_BASE);
     }
diff --git a/src/core/src/test/groovy/org/apache/jmeter/gui/HtmlReportGUISpec.groovy b/src/core/src/test/groovy/org/apache/jmeter/gui/HtmlReportGUISpec.groovy
deleted file mode 100644
index a0caec0..0000000
--- a/src/core/src/test/groovy/org/apache/jmeter/gui/HtmlReportGUISpec.groovy
+++ /dev/null
@@ -1,47 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to you 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 org.apache.jmeter.gui;
-
-import org.apache.jmeter.gui.tree.JMeterTreeListener
-import org.apache.jmeter.gui.tree.JMeterTreeModel
-import org.apache.jmeter.junit.spock.JMeterSpec
-
-import spock.lang.IgnoreIf
-
-@IgnoreIf({ JMeterSpec.isHeadless() })
-class HtmlReportGUISpec extends JMeterSpec {
-
-    def "test HtmlReportUI initialization"() {
-        given:
-            def sut = new HtmlReportUI();
-            def treeModel = new JMeterTreeModel();
-            def treeListener = new JMeterTreeListener(treeModel);
-            GuiPackage.initInstance(treeListener, treeModel);
-            GuiPackage.getInstance().setMainFrame(new MainFrame(treeModel, treeListener));
-        when:
-            sut.showInputDialog(GuiPackage.getInstance().getMainFrame())
-            Thread.sleep(50) // https://bugs.openjdk.java.net/browse/JDK-5109571
-            sut.messageDialog.setVisible(false)
-        then:
-            sut.csvFilePathTextField.getText() == ""
-            sut.userPropertiesFilePathTextField.getText() == ""
-            sut.outputDirectoryPathTextField.getText() == ""
-            sut.reportArea.getText() == ""
-            sut.messageDialog.getComponents().length == 1;
-    }
-}
diff --git a/src/core/src/test/groovy/org/apache/jmeter/testelement/AbstractTestElementSpec.groovy b/src/core/src/test/groovy/org/apache/jmeter/testelement/AbstractTestElementSpec.groovy
deleted file mode 100644
index 91ddecf..0000000
--- a/src/core/src/test/groovy/org/apache/jmeter/testelement/AbstractTestElementSpec.groovy
+++ /dev/null
@@ -1,99 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to you 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 org.apache.jmeter.testelement
-
-import org.apache.commons.lang3.NotImplementedException
-import org.apache.jmeter.junit.spock.JMeterSpec
-import org.apache.jmeter.testelement.property.JMeterProperty
-import org.apache.jmeter.testelement.property.MultiProperty
-import org.apache.jmeter.testelement.property.PropertyIterator
-import org.apache.jmeter.testelement.property.TestElementProperty
-
-import spock.lang.Unroll
-
-@Unroll
-class AbstractTestElementSpec extends JMeterSpec {
-
-    def "set outer properties as temporary when using a TestElementProperty"() {
-        given:
-            AbstractTestElement sut = Spy(AbstractTestElement.class)
-            def outerElement = Mock(TestElement.class)
-            def innerElement = Mock(TestElement.class)
-            def outerProp = new TestElementProperty("outerProp", outerElement)
-            def innerProp = new TestElementProperty("innerProp", innerElement)
-            outerProp.addProperty(innerProp)
-        when:
-            sut.setTemporary(outerProp)
-        then:
-            sut.isTemporary(outerProp)
-            !sut.isTemporary(innerProp)
-    }
-
-    def "set all properties as temporary when using a MultiProperty"() {
-        given:
-            AbstractTestElement sut = Spy(AbstractTestElement.class)
-            def outerProp = new MinimalMultiProperty()
-            def innerProp = new MinimalMultiProperty()
-            outerProp.addProperty(innerProp)
-        when:
-            sut.setTemporary(outerProp)
-        then:
-            sut.isTemporary(outerProp)
-            sut.isTemporary(innerProp)
-    }
-
-    private class MinimalMultiProperty extends MultiProperty {
-
-        Set<JMeterProperty> props = new HashSet<>()
-
-        @Override
-        void recoverRunningVersion(TestElement owner) {
-            throw new NotImplementedException()
-        }
-
-        @Override
-        String getStringValue() {
-            throw new NotImplementedException()
-        }
-
-        @Override
-        Object getObjectValue() {
-            return null
-        }
-
-        @Override
-        void setObjectValue(Object value) {
-            throw new NotImplementedException()
-        }
-
-        @Override
-        PropertyIterator iterator() {
-            return props.iterator() as PropertyIterator
-        }
-
-        @Override
-        void addProperty(JMeterProperty prop) {
-            props.add(prop)
-        }
-
-        @Override
-        void clear() {
-            props.clear()
-        }
-    }
-}
diff --git a/src/core/src/test/kotlin/org/apache/jmeter/engine/util/FunctionParserTest.kt b/src/core/src/test/kotlin/org/apache/jmeter/engine/util/FunctionParserTest.kt
index 039f123..0b4d0f7 100644
--- a/src/core/src/test/kotlin/org/apache/jmeter/engine/util/FunctionParserTest.kt
+++ b/src/core/src/test/kotlin/org/apache/jmeter/engine/util/FunctionParserTest.kt
@@ -17,46 +17,53 @@
 
 package org.apache.jmeter.engine.util
 
+import com.google.auto.service.AutoService
 import org.apache.jmeter.functions.Function
 import org.apache.jmeter.samplers.SampleResult
 import org.apache.jmeter.samplers.Sampler
+import org.junit.jupiter.api.Assertions
+import org.junit.jupiter.params.ParameterizedTest
+import org.junit.jupiter.params.provider.ValueSource
 
-import spock.lang.Specification
-import spock.lang.Unroll
+class FunctionParserTest {
+    @ParameterizedTest
+    @ValueSource(
+        strings = [
+            "\${__func()}",
+            "\${ __func()}",
+            "\${__func() }",
+            "\${ __func() }",
+        ]
+    )
+    fun `simple function call`(input: String) {
+        val parser = FunctionParser()
+        val result = parser.compileString(input)
 
-@Unroll
-class FunctionParserSpec extends Specification {
-    def "function '#value' gets compiled"() {
-        given:
-            CompoundVariable.functions.put('__func', Func.class)
-            def parser = new FunctionParser()
-        when:
-            def result = parser.compileString(value)
-        then:
-            "$result" == "$expected"
-        where:
-            value           | expected
-            '${__func()}'   | [new Func()]
-            '${ __func()}'  | [new Func()]
-            '${__func() }'  | [new Func()]
-            '${ __func() }' | [new Func()]
+        Assertions.assertEquals(arrayListOf(Func()), result) {
+            "FunctionParser.compileString($input)"
+        }
     }
 
-    public static class Func implements Function {
-        void setParameters(Collection params) {
-            // do nothing
+    @AutoService(Function::class)
+    class Func : Function {
+        override fun execute(previousResult: SampleResult?, currentSampler: Sampler?): String {
+            TODO()
         }
-        String getReferenceKey() {
-            return "__func"
+
+        override fun setParameters(parameters: MutableCollection<CompoundVariable>) {
         }
-        List<String> getArgumentDesc() {
-            return Collections.emptyList()
+
+        override fun getReferenceKey(): String = "__func"
+
+        override fun getArgumentDesc(): List<String> = listOf()
+        override fun equals(other: Any?): Boolean {
+            if (this === other) return true
+            if (javaClass != other?.javaClass) return false
+            return true
         }
-        String execute(SampleResult result, Sampler sampler) {
-            return "done"
-        }
-        String toString() {
-            return "__func()"
+
+        override fun hashCode(): Int {
+            return javaClass.hashCode()
         }
     }
 }
diff --git a/src/core/src/test/kotlin/org/apache/jmeter/report/core/ConvertersTest.kt b/src/core/src/test/kotlin/org/apache/jmeter/report/core/ConvertersTest.kt
index 7ed9bcd..118a913 100644
--- a/src/core/src/test/kotlin/org/apache/jmeter/report/core/ConvertersTest.kt
+++ b/src/core/src/test/kotlin/org/apache/jmeter/report/core/ConvertersTest.kt
@@ -17,46 +17,57 @@
 
 package org.apache.jmeter.report.core
 
-import spock.lang.Specification
-import spock.lang.Unroll
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.params.ParameterizedTest
+import org.junit.jupiter.params.provider.MethodSource
 
-@Unroll
-class ConvertersSpec extends Specification {
+class ConvertersTest {
+    data class NumberCase(val input: String, val type: Class<*>?, val expected: Number, val precision: Number)
+    data class SimpleCase(val input: String, val type: Class<*>?, val expected: Any)
+    companion object {
+        @JvmStatic
+        fun numberCases() = listOf(
+            NumberCase(" 42", Int::class.javaObjectType, Integer.valueOf(42), 0),
+            NumberCase("-5", Int::class.javaPrimitiveType, Integer.valueOf(-5), 0),
+            NumberCase("5000000", Long::class.javaObjectType, java.lang.Long.valueOf(5_000_000), 0),
+            NumberCase("500 ", Long::class.javaPrimitiveType, java.lang.Long.valueOf(500), 0),
+            NumberCase("3.14", Double::class.javaObjectType, java.lang.Double.valueOf(3.14), 0.0001),
+            NumberCase(" 100 ", Double::class.javaPrimitiveType, java.lang.Double.valueOf(100.0), 0.0001),
+            NumberCase("+5", Float::class.javaObjectType, java.lang.Float.valueOf(5.0f), 0.0001),
+            NumberCase(" 1.2E16 ", Float::class.javaPrimitiveType, java.lang.Float.valueOf(1.2E16f), 0.0001),
+        )
 
-    def "Convert number-like (#input) to instance of (#conversionDestClass)"() {
-        given:
-            def converter = Converters.getConverter(conversionDestClass)
-        when:
-            def result = converter.convert(input)
-        then:
-            result.class == expectedResult.class
-            result == expectedResult || Math.abs(expectedResult - result) < precision
-        where:
-            input      | conversionDestClass | expectedResult          | precision
-            " 42"      | Integer.class       | Integer.valueOf(42)     | 0
-            "-5"       | int.class           | Integer.valueOf(-5)     | 0
-            "5000000"  | Long.class          | Long.valueOf(5_000_000) | 0
-            "500 "     | long.class          | Long.valueOf(500)       | 0
-            "3.14"     | Double.class        | Double.valueOf(3.14)    | 0.0001
-            " 100 "    | double.class        | Double.valueOf(100)     | 0.0001
-            "+5"       | Float.class         | Float.valueOf(5)        | 0.0001
-            " 1.2E16 " | float.class         | Float.valueOf(1.2E16)   | 0.0001
+        @JvmStatic
+        fun simpleCases() = listOf(
+            SimpleCase("FALSE", Boolean::class.javaObjectType, false),
+            SimpleCase("true", Boolean::class.javaPrimitiveType, true),
+            SimpleCase(" true", Boolean::class.javaPrimitiveType, false),
+            SimpleCase("fAlSe ", Boolean::class.javaPrimitiveType, false),
+            SimpleCase("a", Char::class.javaObjectType, 'a'),
+            SimpleCase("ä", Char::class.javaPrimitiveType, 'ä'),
+        )
     }
 
-    def "Convert (#input) to instance of (#conversionDestClass)"() {
-        given:
-            def converter = Converters.getConverter(conversionDestClass)
-        when:
-            def result = converter.convert(input)
-        then:
-            result == expectedResult
-        where:
-            input    | conversionDestClass | expectedResult
-            "FALSE"  | Boolean.class       | Boolean.FALSE
-            "true"   | boolean.class       | Boolean.TRUE
-            " true"  | boolean.class       | Boolean.FALSE
-            "fAlSe " | boolean.class       | Boolean.FALSE
-            "a"      | Character.class     | 'a'
-            "ä"      | char.class          | 'ä'
+    @ParameterizedTest
+    @MethodSource("numberCases")
+    fun convertNumbers(case: NumberCase) {
+        val result = Converters.getConverter(case.type).convert(case.input)
+        if (result != case.expected) {
+            assertEquals(case.expected.toDouble(), (result as Number).toDouble(), case.precision.toDouble()) {
+                "Converters.getConverter(${case.type}).convert(${case.input}) should be within ${case.precision} of ${case.expected}"
+            }
+        }
+        assertEquals(case.expected::class.java, result::class.java) {
+            "type of Converters.getConverter(${case.type}).convert(${case.input})"
+        }
+    }
+
+    @ParameterizedTest
+    @MethodSource("simpleCases")
+    fun convertSimple(case: SimpleCase) {
+        val result = Converters.getConverter(case.type).convert(case.input)
+        assertEquals(case.expected, result) {
+            "Converters.getConverter(${case.type}).convert(${case.input})"
+        }
     }
 }
diff --git a/src/core/src/test/kotlin/org/apache/jmeter/report/core/SampleMetadataParserTest.kt b/src/core/src/test/kotlin/org/apache/jmeter/report/core/SampleMetadataParserTest.kt
index fe1ed72..6806ac6 100644
--- a/src/core/src/test/kotlin/org/apache/jmeter/report/core/SampleMetadataParserTest.kt
+++ b/src/core/src/test/kotlin/org/apache/jmeter/report/core/SampleMetadataParserTest.kt
@@ -17,42 +17,37 @@
 
 package org.apache.jmeter.report.core
 
-import spock.lang.Specification
-import spock.lang.Unroll
+import org.junit.jupiter.api.Assertions
+import org.junit.jupiter.params.ParameterizedTest
+import org.junit.jupiter.params.provider.MethodSource
 
-@Unroll
-class SampleMetadataParserSpec extends Specification {
-
-    def "Parse headers (#headers) with separator (#separator) and get (#expectedColumns)"() {
-        given:
-            def sut = new SampleMetaDataParser(separator as char)
-        when:
-            def columns = sut.parse(headers).columns
-        then:
-            columns == expectedColumns
-        where:
-            separator | headers           | expectedColumns
-            ';'       | "a;b;c;d;e"       | ["a", "b", "c", "d", "e"]
-            '|'       | "a|b|c|d|e"       | ["a", "b", "c", "d", "e"]
-            '|'       | "aa|bb|cc|dd|eef" | ["aa", "bb", "cc", "dd", "eef"]
-            '&'       | "a&b&c&d&e"       | ["a", "b", "c", "d", "e"]
-            '\t'      | "a\tb c\td\te"    | ["a", "b c", "d", "e"]
-            ','       | "abcdef"          | ["abcdef"]
+class SampleMetadataParserTest {
+    data class ParseCase(val separator: Char, val headers: String, val expected: List<String>)
+    companion object {
+        @JvmStatic
+        fun headerCases() = listOf(
+            ParseCase(';', "a;b;c;d;e", listOf("a", "b", "c", "d", "e")),
+            ParseCase(',', "a|b|c|d|e", listOf("a", "b", "c", "d", "e")),
+            ParseCase(',', "aa|bb|cc|dd|eef", listOf("aa", "bb", "cc", "dd", "eef")),
+            ParseCase('&', "a&b&c&d&e", listOf("a", "b", "c", "d", "e")),
+            ParseCase('\t', "a\tb c\td\te", listOf("a", "b c", "d", "e")),
+            ParseCase(',', "abcdef", listOf("abcdef")),
+            // Wrong separator
+            ParseCase(',', "a;b;c;d;e", listOf("a", "b", "c", "d", "e")),
+            ParseCase(',', "a|b|c|d|e", listOf("a", "b", "c", "d", "e")),
+            ParseCase(',', "aa|bb|cc|dd|eef", listOf("aa", "bb", "cc", "dd", "eef")),
+            ParseCase(',', "a&b&c&d&e", listOf("a", "b", "c", "d", "e")),
+            ParseCase(',', "a\tb c\td\te", listOf("a", "b c", "d", "e")),
+            ParseCase(',', "abcdef", listOf("abcdef")),
+        )
     }
 
-    def "Parse headers (#headers) with wrong separator (#separator) and get (#expectedColumns)"() {
-        given:
-        def sut = new SampleMetaDataParser(separator as char)
-        when:
-        def columns = sut.parse(headers).columns
-        then:
-        columns == expectedColumns
-        where:
-        separator | headers           | expectedColumns
-        ','       | "a;b;c;d;e"       | ["a", "b", "c", "d", "e"]
-        ','       | "a|b|c|d|e"       | ["a", "b", "c", "d", "e"]
-        ','       | "aa|bb|cc|dd|eef" | ["aa", "bb", "cc", "dd", "eef"]
-        ','       | "a&b&c&d&e"       | ["a", "b", "c", "d", "e"]
-        ','       | "a\tb c\td\te"    | ["a", "b c", "d", "e"]
+    @ParameterizedTest
+    @MethodSource("headerCases")
+    fun parseHeaders(case: ParseCase) {
+        val result = SampleMetaDataParser(case.separator).parse(case.headers).columns
+        Assertions.assertEquals(case.expected, result) {
+            "SampleMetaDataParser(${case.separator}).parse(${case.headers})"
+        }
     }
 }
diff --git a/src/core/src/test/kotlin/org/apache/jmeter/report/processor/ApdexSummaryConsumerTest.kt b/src/core/src/test/kotlin/org/apache/jmeter/report/processor/ApdexSummaryConsumerTest.kt
index 595085e..179003b 100644
--- a/src/core/src/test/kotlin/org/apache/jmeter/report/processor/ApdexSummaryConsumerTest.kt
+++ b/src/core/src/test/kotlin/org/apache/jmeter/report/processor/ApdexSummaryConsumerTest.kt
@@ -17,29 +17,32 @@
 
 package org.apache.jmeter.report.processor
 
-import spock.lang.Specification
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Test
 
-class ApdexSummaryConsumerSpec extends Specification {
+class ApdexSummaryConsumerTest {
+    val sut = ApdexSummaryConsumer()
 
-    def sut = new ApdexSummaryConsumer()
+    @Test
+    fun `createDataResult contains apdex, satisfied, tolerated, key`() {
+        val info = ApdexThresholdsInfo()
+        info.satisfiedThreshold = 3L
+        info.toleratedThreshold = 12L
+        val data = ApdexSummaryData(info).apply {
+            satisfiedCount = 60L
+            toleratedCount = 30L
+            totalCount = 100L
+        }
+        val expectedApdex = 0.75
 
-    def "createDataResult contains apdex, satisfied, tolerated, key"() {
-        given:
-            def info = new ApdexThresholdsInfo()
-            info.setSatisfiedThreshold(3L)
-            info.setToleratedThreshold(12L)
-            def data = new ApdexSummaryData(info)
-            data.satisfiedCount = 60L
-            data.toleratedCount = 30L
-            data.totalCount = 100L
-            def expectedApdex = 0.75
-        when:
-            def result = sut.createDataResult("key", data)
-        then:
-            def resultValues = result.asList().collect {
-                ((ValueResultData) it).value
-            }
-            // [apdex, satisfied, tolerated, key]
-            resultValues == [expectedApdex, 3L, 12L, "key"]
+        val result = sut.createDataResult("key", data)
+
+        val resultValues = result.map { (it as ValueResultData).value }
+        assertEquals(
+            listOf(expectedApdex, 3L, 12L, "key"),
+            resultValues
+        ) {
+            "ApdexSummaryConsumer().createDataResult(\"key\", $data) should yield [apdex, satisfied, tolerated, key]"
+        }
     }
 }
diff --git a/src/core/src/test/kotlin/org/apache/jmeter/report/processor/FieldSampleComparatorTest.kt b/src/core/src/test/kotlin/org/apache/jmeter/report/processor/FieldSampleComparatorTest.kt
index d645cf0..9346f8e 100644
--- a/src/core/src/test/kotlin/org/apache/jmeter/report/processor/FieldSampleComparatorTest.kt
+++ b/src/core/src/test/kotlin/org/apache/jmeter/report/processor/FieldSampleComparatorTest.kt
@@ -19,45 +19,52 @@
 
 import org.apache.jmeter.report.core.Sample
 import org.apache.jmeter.report.core.SampleMetadata
+import org.junit.jupiter.api.Assertions
+import org.junit.jupiter.api.Test
+import kotlin.math.sign
 
-import spock.lang.Specification
+class FieldSampleComparatorTest {
+    companion object {
+        const val separator = ','
+    }
+    private val multiColSampleMeta = SampleMetadata(separator, "col1", "col2")
 
-class FieldSampleComparatorSpec extends Specification {
-
-    static char separator = ',' as char
-    def multiColSampleMeta = new SampleMetadata(separator, "col1", "col2")
-
-    def testCompare() {
-        given:
-            def sampleMetadata = new SampleMetadata(separator, "col1")
-            def firstRow = new Sample(0, sampleMetadata, "1")
-            def secondRow = new Sample(1, sampleMetadata, "2")
-            def sut = new FieldSampleComparator("col1")
-            sut.initialize(sampleMetadata)
-        expect:
-            sut.compare(firstRow, secondRow) < 0
-            sut.compare(secondRow, firstRow) > 0
-            sut.compare(firstRow, firstRow) == 0
-            sut.compare(secondRow, secondRow) == 0
+    fun assertCompare(comparator: FieldSampleComparator, a: Sample, b: Sample, expectedSign: Int) {
+        Assertions.assertEquals(expectedSign.sign, comparator.compare(a, b).sign) {
+            "$comparator.compare($a, $b)"
+        }
     }
 
-    def "initialize ensures correct column is compared"() {
-        given:
-            def sut = new FieldSampleComparator("col2")
-            def firstRow = new Sample(0, multiColSampleMeta, "1", "3")
-            def secondRow = new Sample(1, multiColSampleMeta, "2", "3")
-            sut.initialize(multiColSampleMeta)
-        expect:
-            sut.compare(firstRow, secondRow) == 0
+    @Test
+    fun testCompare() {
+        val sampleMetadata = SampleMetadata(separator, "col1")
+        val firstRow = Sample(0, sampleMetadata, "1")
+        val secondRow = Sample(1, sampleMetadata, "2")
+        val sut = FieldSampleComparator("col1")
+        sut.initialize(sampleMetadata)
+
+        assertCompare(sut, firstRow, secondRow, -1)
+        assertCompare(sut, secondRow, firstRow, 1)
+        assertCompare(sut, firstRow, firstRow, 0)
+        assertCompare(sut, secondRow, secondRow, 0)
     }
 
-    def "Incorrectly uses first column if initialize isn't called"() {
-        given:
-            def sut = new FieldSampleComparator("col2")
-            def firstRow = new Sample(0, multiColSampleMeta, "1", "3")
-            def secondRow = new Sample(1, multiColSampleMeta, "2", "3")
-        expect:
-            sut.compare(firstRow, secondRow) != 0
+    @Test
+    fun `initialize ensures correct column is compared`() {
+        val sut = FieldSampleComparator("col2")
+        val firstRow = Sample(0, multiColSampleMeta, "1", "3")
+        val secondRow = Sample(1, multiColSampleMeta, "2", "3")
+        sut.initialize(multiColSampleMeta)
+
+        assertCompare(sut, firstRow, secondRow, 0)
     }
 
+    @Test
+    fun `Incorrectly uses first column if initialize isn't called`() {
+        val sut = FieldSampleComparator("col2")
+        val firstRow = Sample(0, multiColSampleMeta, "1", "3")
+        val secondRow = Sample(1, multiColSampleMeta, "2", "3")
+
+        assertCompare(sut, firstRow, secondRow, -1)
+    }
 }
diff --git a/src/core/src/test/kotlin/org/apache/jmeter/report/processor/ListResultDataTest.kt b/src/core/src/test/kotlin/org/apache/jmeter/report/processor/ListResultDataTest.kt
index 9f4e574..7dc6452 100644
--- a/src/core/src/test/kotlin/org/apache/jmeter/report/processor/ListResultDataTest.kt
+++ b/src/core/src/test/kotlin/org/apache/jmeter/report/processor/ListResultDataTest.kt
@@ -17,27 +17,36 @@
 
 package org.apache.jmeter.report.processor
 
-import spock.lang.Specification
-import spock.lang.Unroll
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Assertions.assertTrue
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.params.ParameterizedTest
+import org.junit.jupiter.params.provider.MethodSource
 
-@Unroll
-class ListResultDataSpec extends Specification {
-
-    def sut = new ListResultData()
-
-    def "a new ListResultData is empty"() {
-        expect:
-            new ListResultData().size() == 0
+class ListResultDataTest {
+    companion object {
+        @JvmStatic
+        fun addResultInputs() = listOf(
+            null,
+            ValueResultData(),
+            ListResultData(),
+        )
     }
 
-    def "addResult adds #object to list and returns true"() {
-        when:
-            def result = sut.addResult(object)
-        then:
-            result
-            sut.getSize() == 1
-            sut.get(0) == object
-        where:
-            object << [null, Mock(ResultData), new ListResultData()]
+    val sut = ListResultData()
+
+    @Test
+    fun `a new ListResultData is empty`() {
+        assertEquals(0, sut.size)
+        assertEquals(listOf<Any>(), sut.toList())
+    }
+
+    @ParameterizedTest
+    @MethodSource("addResultInputs")
+    fun addResult(input: ResultData?) {
+        assertTrue(sut.addResult(input), "addResult should return true")
+        assertEquals(listOf(input), sut.toList()) {
+            "ListResultData().add($input).toList()"
+        }
     }
 }
diff --git a/src/core/src/test/kotlin/org/apache/jmeter/report/processor/Top5ErrorsBySamplerConsumerTest.kt b/src/core/src/test/kotlin/org/apache/jmeter/report/processor/Top5ErrorsBySamplerConsumerTest.kt
index f43c41d..f4284f9 100644
--- a/src/core/src/test/kotlin/org/apache/jmeter/report/processor/Top5ErrorsBySamplerConsumerTest.kt
+++ b/src/core/src/test/kotlin/org/apache/jmeter/report/processor/Top5ErrorsBySamplerConsumerTest.kt
@@ -17,62 +17,74 @@
 
 package org.apache.jmeter.report.processor
 
-
+import io.mockk.every
+import io.mockk.mockk
 import org.apache.jmeter.report.core.Sample
 import org.apache.jmeter.report.utils.MetricUtils
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Test
 
-import spock.lang.Specification
+class Top5ErrorsBySamplerConsumerTest {
+    val sut = Top5ErrorsBySamplerConsumer()
 
-class Top5ErrorsBySamplerConsumerSpec extends Specification {
+    @Test
+    fun `summary info data updated with non-controller passing sample`() {
+        val mockSummaryInfo = mockk<AbstractSummaryConsumer<Top5ErrorsSummaryData>.SummaryInfo> {
+            every { getData() } answers { callOriginal() }
+            every { setData(any()) } answers { callOriginal() }
+        }
+        val mockSample = mockk<Sample>(relaxed = true) {
+            every { success } returns true
+        }
+        sut.updateData(mockSummaryInfo, mockSample)
 
-    def sut = new Top5ErrorsBySamplerConsumer()
-
-    def "summary info data updated with non-controller passing sample"() {
-        given:
-            def mockSummaryInfo = Mock(AbstractSummaryConsumer.SummaryInfo)
-            def mockSample = Mock(Sample) {
-                getSuccess() >> true
-            }
-        when:
-            sut.updateData(mockSummaryInfo, mockSample)
-        then:
-            def data = (Top5ErrorsSummaryData) mockSummaryInfo.getData()
-            data.getTotal() == 1
+        val data = mockSummaryInfo.getData()
+        assertEquals(1, data.total, "data.total")
     }
 
-    def "summary info data updated with non-controller failing sample"() {
-        given:
-            def mockSummaryInfo = Mock(AbstractSummaryConsumer.SummaryInfo)
-            def mockSample = Mock(Sample) {
-                getResponseCode() >> "200"
-            }
-        when:
-            sut.updateData(mockSummaryInfo, mockSample)
-        then:
-            def data = (Top5ErrorsSummaryData) mockSummaryInfo.getData()
-            data.getTotal() == 1
-            data.getErrors() == 1
-            data.top5ErrorsMetrics[0][0] == MetricUtils.ASSERTION_FAILED
-            def overallData = (Top5ErrorsSummaryData) sut.getOverallInfo().getData()
-            overallData.getTotal() == 1
-            overallData.getErrors() == 1
-            overallData.top5ErrorsMetrics[0][0] == MetricUtils.ASSERTION_FAILED
+    @Test
+    fun `summary info data updated with non-controller failing sample`() {
+        val mockSummaryInfo = mockk<AbstractSummaryConsumer<Top5ErrorsSummaryData>.SummaryInfo> {
+            every { getData() } answers { callOriginal() }
+            every { setData(any()) } answers { callOriginal() }
+        }
+        val mockSample = mockk<Sample>(relaxed = true) {
+            every { responseCode } returns "200"
+        }
+        sut.updateData(mockSummaryInfo, mockSample)
+
+        val data = mockSummaryInfo.getData()
+        assertEquals(1, data.total, "data.total")
+        assertEquals(1, data.errors, "data.errors")
+        assertEquals(MetricUtils.ASSERTION_FAILED, data.top5ErrorsMetrics[0][0], "data.top5ErrorsMetrics[0][0]")
+
+        val overallData = sut.overallInfo.getData()
+        assertEquals(1, overallData.total, "data.total")
+        assertEquals(1, overallData.errors, "data.errors")
+        assertEquals(
+            MetricUtils.ASSERTION_FAILED,
+            overallData.top5ErrorsMetrics[0][0],
+            "overallData.top5ErrorsMetrics[0][0]"
+        )
     }
 
-    def "key from sample is name"() {
-        given:
-            def mockSample = Mock(Sample)
-        when:
-            def key = sut.getKeyFromSample(mockSample)
-        then:
-            1 * mockSample.getName() >> "name"
-            key == "name"
+    @Test
+    fun `key from sample is name`() {
+        val sample = mockk<Sample> {
+            every { name } returns "name"
+        }
+        assertEquals("name", sut.getKeyFromSample(sample)) {
+            "getKeyFromSample(sample) should return the name of the sample"
+        }
     }
 
-    def "there are 3 + 2n expected results title columns"() {
-        expect:
-            sut.createResultTitles().size ==
-                    3 + 2 * sut.MAX_NUMBER_OF_ERRORS_IN_TOP
+    @Test
+    fun `there are 3 + 2n expected results title columns`() {
+        assertEquals(
+            3 + 2 * Top5ErrorsBySamplerConsumer.MAX_NUMBER_OF_ERRORS_IN_TOP,
+            sut.createResultTitles().size
+        ) {
+            ".createResultTitles().size should be 3 + 2 * ${Top5ErrorsBySamplerConsumer.MAX_NUMBER_OF_ERRORS_IN_TOP}"
+        }
     }
-
 }
diff --git a/src/core/src/test/kotlin/org/apache/jmeter/report/processor/Top5ErrorsSummaryDataTest.kt b/src/core/src/test/kotlin/org/apache/jmeter/report/processor/Top5ErrorsSummaryDataTest.kt
index 3ffd87c..f47fb67 100644
--- a/src/core/src/test/kotlin/org/apache/jmeter/report/processor/Top5ErrorsSummaryDataTest.kt
+++ b/src/core/src/test/kotlin/org/apache/jmeter/report/processor/Top5ErrorsSummaryDataTest.kt
@@ -17,44 +17,59 @@
 
 package org.apache.jmeter.report.processor
 
-import spock.lang.Specification
+import org.junit.jupiter.api.Assertions.assertArrayEquals
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Test
 
-class Top5ErrorsSummaryDataSpec extends Specification {
+class Top5ErrorsSummaryDataTest {
+    val sut = Top5ErrorsSummaryData()
 
-    def sut = new Top5ErrorsSummaryData()
-
-    def "error and total count start at 0"() {
-        expect:
-            sut.getErrors() == 0
-            sut.getTotal() == 0
+    @Test
+    fun `error and total count start at 0`() {
+        assertEquals(0, sut.errors, "errors")
+        assertEquals(0, sut.total, "total")
     }
 
-    def "error and total count increment by one each time"() {
-        when:
-            sut.incErrors()
-            sut.incTotal()
-        then:
-            sut.getErrors() == 1
-            sut.getTotal() == 1
+    @Test
+    fun `incErrors increments errors`() {
+        sut.incErrors()
+        assertEquals(1, sut.errors, "errors")
     }
 
-    def "when no errors are registered an array with null values is returned"() {
-        expect:
-            sut.getTop5ErrorsMetrics() == new Object[0][0]
+    @Test
+    fun `incTotal increments total`() {
+        sut.incTotal()
+        assertEquals(1, sut.total, "total")
     }
 
-    def "error messages with the same frequency are preserved up until the size limit"() {
-        given:
-            ["A", "B", "C", "D", "E", "F"].each { sut.registerError(it) }
-        expect:
-            sut.getTop5ErrorsMetrics() == [["A", 1], ["B", 1], ["C", 1], ["D", 1], ["E", 1]]
+    @Test
+    fun `when no errors are registered an array with null values is returned`() {
+        assertArrayEquals(arrayOf<Array<Any>>(), sut.getTop5ErrorsMetrics(), "getTop5ErrorsMetrics")
     }
 
-    def "error messages are sorted by size, descending"() {
-        given:
-            ["A", "A", "A", "B", "B", "C"].each { sut.registerError(it) }
-        expect:
-            sut.getTop5ErrorsMetrics() == [["A", 3], ["B", 2], ["C", 1]]
+    @Test
+    fun `error messages with the same frequency are preserved up until the size limit`() {
+        val input = listOf("A", "B", "C", "D", "E", "F")
+        input.forEach { sut.registerError(it) }
+        assertArrayEquals(
+            input.take(5).map { arrayOf(it, 1L) }.toTypedArray(),
+            sut.getTop5ErrorsMetrics(),
+            "registerErrors $input, then call getTop5ErrorsMetrics"
+        )
     }
 
+    @Test
+    fun `error messages are sorted by size, descending`() {
+        val input = listOf("A", "A", "A", "B", "B", "C")
+        input.forEach { sut.registerError(it) }
+        assertArrayEquals(
+            arrayOf(
+                arrayOf("A", 3L),
+                arrayOf("B", 2L),
+                arrayOf("C", 1L)
+            ),
+            sut.top5ErrorsMetrics,
+            "registerErrors $input, then call getTop5ErrorsMetrics"
+        )
+    }
 }
diff --git a/src/core/src/test/kotlin/org/apache/jmeter/report/processor/graph/impl/ResponseTimePercentilesOverTimeGraphConsumerTest.kt b/src/core/src/test/kotlin/org/apache/jmeter/report/processor/graph/impl/ResponseTimePercentilesOverTimeGraphConsumerTest.kt
index 2036bf0..918764e 100644
--- a/src/core/src/test/kotlin/org/apache/jmeter/report/processor/graph/impl/ResponseTimePercentilesOverTimeGraphConsumerTest.kt
+++ b/src/core/src/test/kotlin/org/apache/jmeter/report/processor/graph/impl/ResponseTimePercentilesOverTimeGraphConsumerTest.kt
@@ -17,39 +17,37 @@
 
 package org.apache.jmeter.report.processor.graph.impl
 
-import java.util.stream.Collectors
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Assertions.assertFalse
+import org.junit.jupiter.api.Test
 
-import org.apache.jmeter.junit.spock.JMeterSpec
+class ResponseTimePercentilesOverTimeGraphConsumerTest {
+    val sut = ResponseTimePercentilesOverTimeGraphConsumer()
 
-class ResponseTimePercentilesOverTimeGraphConsumerSpec extends JMeterSpec {
+    @Test
+    fun `GroupInfos have only the required keys`() {
+        val groupInfosMap = sut.createGroupInfos()
 
-    static def EXPECTED_KEYS =
-            ['aggregate_report_min',
-             'aggregate_report_max',
-             'aggregate_rpt_pct1',
-             'aggregate_rpt_pct2',
-             'aggregate_rpt_pct3',
-            'aggregate_report_median'] as Set
-
-    def sut = new ResponseTimePercentilesOverTimeGraphConsumer()
-
-    def "GroupInfos have only the required keys"() {
-        when:
-            def groupInfosMap = sut.createGroupInfos()
-        then:
-            groupInfosMap.keySet() == EXPECTED_KEYS
+        assertEquals(
+            setOf(
+                "aggregate_report_min",
+                "aggregate_report_max",
+                "aggregate_rpt_pct1",
+                "aggregate_rpt_pct2",
+                "aggregate_rpt_pct3",
+                "aggregate_report_median",
+            ),
+            groupInfosMap.keys,
+            "createGroupInfos().keys"
+        )
     }
 
-    def "GroupInfos have the expected settings"() {
-        when:
-            def groupInfos = sut.createGroupInfos()
-            def groupInfoValues = groupInfos
-                    .entrySet().stream()
-                    .map { it.value }
-                    .collect(Collectors.toList())
-        then:
-            groupInfoValues.every { !it.enablesAggregatedKeysSeries() }
-            groupInfoValues.every { !it.enablesOverallSeries() }
+    @Test
+    fun `GroupInfos have the expected settings`() {
+        val groupInfos = sut.createGroupInfos()
+        groupInfos.values.forEach {
+            assertFalse(it.enablesAggregatedKeysSeries(), "enablesAggregatedKeysSeries()")
+            assertFalse(it.enablesOverallSeries(), "enablesOverallSeries()")
+        }
     }
-
 }
diff --git a/src/core/src/test/kotlin/org/apache/jmeter/services/FileServerTest.kt b/src/core/src/test/kotlin/org/apache/jmeter/services/FileServerTest.kt
index d02c2dc..c48e619 100644
--- a/src/core/src/test/kotlin/org/apache/jmeter/services/FileServerTest.kt
+++ b/src/core/src/test/kotlin/org/apache/jmeter/services/FileServerTest.kt
@@ -17,221 +17,249 @@
 
 package org.apache.jmeter.services
 
-import org.apache.jmeter.junit.spock.JMeterSpec
+import org.apache.jmeter.junit.JMeterTestCase
+import org.junit.jupiter.api.AfterEach
+import org.junit.jupiter.api.Assertions.assertArrayEquals
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Assertions.assertFalse
+import org.junit.jupiter.api.Assertions.assertTrue
+import org.junit.jupiter.api.BeforeEach
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.assertThrows
+import org.junit.jupiter.api.fail
+import org.junit.jupiter.params.ParameterizedTest
+import org.junit.jupiter.params.provider.MethodSource
+import java.io.EOFException
+import java.io.File
+import java.io.IOException
 
-import spock.lang.Unroll
+class FileServerTest : JMeterTestCase() {
+    val sut = FileServer()
 
-@Unroll
-class FileServerSpec extends JMeterSpec {
+    val testFile = getResourceFilePath("testfiles/unit/FileServerSpec.csv")
+    val emptyFile = getResourceFilePath("testfiles/empty.csv")
+    val bomFile = getResourceFilePath("testfiles/bomData.csv")
 
-    def sut = new FileServer()
+    data class SetBaseForScriptCase(val file: File, val expectedBaseDirRelative: String)
 
-    def testFile = getResourceFilePath("testfiles/unit/FileServerSpec.csv")
-    def emptyFile = getResourceFilePath("testfiles/empty.csv")
-    def bomFile = getResourceFilePath("testfiles/bomData.csv")
+    companion object {
+        @JvmStatic
+        fun setBaseForScript(): List<SetBaseForScriptCase> {
+            val baseFile = File(FileServer.getDefaultBase())
+            return listOf(
+                SetBaseForScriptCase(baseFile, "."),
+                SetBaseForScriptCase(baseFile.getParentFile(), "."),
+                SetBaseForScriptCase(File(baseFile.getParentFile(), "abcd/defg.jmx"), "."),
+                SetBaseForScriptCase(File(baseFile, "abcd/defg.jmx"), "abcd"),
+            )
+        }
+    }
 
-    def setup() {
+    @BeforeEach
+    fun setup() {
         sut.resetBase()
     }
 
-    def tearDown() {
+    @AfterEach
+    fun tearDown() {
         sut.closeFiles()
     }
 
-    def "reading a non-existent file throws an exception"() {
-        when:
+    @Test
+    fun `reading a non-existent file throws an exception`() {
+        assertThrows<IOException> {
             sut.readLine("test")
-        then:
-            thrown(IOException)
+        }
     }
 
-    def "writing to a non-exisent file throws an exception"() {
-        when:
+    @Test
+    fun `writing to a non-exisent file throws an exception`() {
+        assertThrows<IOException> {
             sut.write("test", "")
-        then:
-            thrown(IOException)
+        }
     }
 
-    def "no files should be open following resetBase"() {
-        expect:
-            !sut.filesOpen()
+    @Test
+    fun `no files should be open following resetBase`() {
+        assertNoFilesOpen()
     }
 
-    def "closing unrecognised files are ignored"() {
-        when:
-            sut.closeFile("xxx")
-        then:
-            !sut.filesOpen()
-            noExceptionThrown()
+    @Test
+    fun `closing unrecognised files are ignored`() {
+        sut.closeFile("xxx")
+        assertNoFilesOpen()
     }
 
-    def "file is not opened until read from"() {
-        given:
-            sut.reserveFile(testFile) // Does not open file
-            assert !sut.filesOpen()
-        when:
-            def line = sut.readLine(testFile)
-        then:
-            line == "a1,b1,c1,d1"
-            sut.filesOpen()
+    @Test
+    fun `file is not opened until read from`() {
+        sut.reserveFile(testFile) // Does not open file
+        assertNoFilesOpen()
+        assertEquals("a1,b1,c1,d1", sut.readLine(testFile)) {
+            "readLine($testFile)"
+        }
+        assertFilesOpen()
     }
 
-    def "reading lines loops to start once last line is read"() {
-        given:
-            sut.reserveFile(testFile)
-        when:
-            def firstPass = [sut.readLine(testFile), sut.readLine(testFile), sut.readLine(testFile), sut.readLine(testFile)]
-            def secondPass = [sut.readLine(testFile), sut.readLine(testFile), sut.readLine(testFile), sut.readLine(testFile)]
-        then:
-            firstPass == secondPass
+    private fun assertNoFilesOpen() {
+        assertFalse(sut.filesOpen(), "filesOpen")
     }
 
-    def "cannot write to reserved file after reading"() {
-        given:
-            sut.reserveFile(testFile)
-            sut.readLine(testFile)
-        when:
+    private fun assertFilesOpen() {
+        assertTrue(sut.filesOpen(), "filesOpen")
+    }
+
+    @Test
+    fun `reading lines loops to start once last line is read`() {
+        sut.reserveFile(testFile)
+        val firstPass = Array(4) { sut.readLine(testFile) }
+        val secondPass = Array(4) { sut.readLine(testFile) }
+        assertArrayEquals(firstPass, secondPass)
+    }
+
+    @Test
+    fun `cannot write to reserved file after reading`() {
+        sut.reserveFile(testFile)
+        sut.readLine(testFile)
+        assertThrows<IOException> {
             sut.write(testFile, "")
-        then:
-            thrown(IOException)
+        }
     }
 
-    def "closing reserved file after reading resets"() {
-        given:
-            sut.reserveFile(testFile)
+    @Test
+    fun `closing reserved file after reading resets`() {
+        sut.reserveFile(testFile)
+        sut.readLine(testFile)
+        sut.closeFile(testFile) // does not remove the entry
+        assertNoFilesOpen()
+        assertEquals("a1,b1,c1,d1", sut.readLine(testFile), "re-read first line")
+        assertFilesOpen()
+    }
+
+    @Test
+    fun `closeFiles() prevents reading of reserved file`() {
+        sut.reserveFile(testFile)
+        sut.readLine(testFile)
+        sut.closeFiles() // removes all entries
+        assertThrows<IOException> {
             sut.readLine(testFile)
-        when:
-            sut.closeFile(testFile) // does not remove the entry
-        then:
-            !sut.filesOpen()
-            sut.readLine(testFile) == "a1,b1,c1,d1" // Re-read first line
-            sut.filesOpen()
+        }
+        assertNoFilesOpen()
     }
 
-    def "closeFiles() prevents reading of reserved file"() {
-        given:
-            sut.reserveFile(testFile)
-            sut.readLine(testFile)
-        when:
-            sut.closeFiles() // removes all entries
-            sut.readLine(testFile)
-        then:
-            !sut.filesOpen()
-            thrown(IOException)
+    @Test
+    fun `baseDir is the defaultBasedir`() {
+        assertEquals(FileServer.getDefaultBase(), sut.getBaseDir()) {
+            "getBaseDir should be FileServer.getDefaultBase()"
+        }
     }
 
-    def "baseDir is the defaultBasedir"() {
-        expect:
-            sut.getBaseDir() == FileServer.getDefaultBase()
-    }
+    @Test
+    fun `setBaseDir doesn't error when no files are open`() {
+        sut.setBasedir("testfiles/unit/FileServerSpec.csv")
 
-    def "setBaseDir doesn't error when no files are open"() {
-        when:
-            sut.setBasedir("testfiles/unit/FileServerSpec.csv")
-        then:
-            sut.getBaseDir().replaceAll("\\\\", "/").endsWith("testfiles/unit")
+        val result = sut.baseDir.replace("\\", "/")
+        if (!result.endsWith("testfiles/unit")) {
+            fail("baseDir should start with testfiles/unit, but was $result")
+        }
     }
 
     // TODO: what about throwing an exception in setBaseDir?
-    def "setBaseDir doesn't set base when passed a directory"() {
-        def dir = "does-not-exist"
-        given:
-            sut.setBasedir(dir)
-        when:
-            sut.getBaseDir().endsWith(dir)
-        then:
-            thrown(NullPointerException)
+    @Test
+    fun `setBaseDir doesn't set base when passed a directory`() {
+        val dir = "does-not-exist"
+        sut.setBasedir(dir)
+        assertThrows<NullPointerException> {
+            sut.baseDir.endsWith(dir)
+        }
     }
 
-    def "cannot set baseDir when files are open"() {
-        given:
-            sut.reserveFile(testFile)
-            sut.readLine(testFile) == "a1,b1,c1,d1"
-        when:
+    @Test
+    fun `cannot set baseDir when files are open`() {
+        sut.reserveFile(testFile)
+        assertEquals("a1,b1,c1,d1", sut.readLine(testFile), "sut.readLine($testFile)")
+        assertThrows<IllegalStateException> {
             sut.setBasedir("testfiles")
-        then:
-            thrown(IllegalStateException)
+        }
     }
 
-    static def baseFile = new File(FileServer.getDefaultBase())
-
-    def "setting base to #file gives getBaseDirRelative == #expectedBaseDirRelative"() {
-        when:
-            sut.setBaseForScript(file)
-        then:
-            sut.getBaseDirRelative().toString() == expectedBaseDirRelative
-        where:
-            file                                                | expectedBaseDirRelative
-            baseFile                                            | "."
-            baseFile.getParentFile()                            | "."
-            new File(baseFile.getParentFile(), "abcd/defg.jmx") | "."
-            new File(baseFile, "abcd/defg.jmx")                 | "abcd"
+    @ParameterizedTest
+    @MethodSource("setBaseForScript")
+    fun `setting base to #file gives getBaseDirRelative == #expectedBaseDirRelative`(case: SetBaseForScriptCase) {
+        sut.setBaseForScript(case.file)
+        assertEquals(case.expectedBaseDirRelative, sut.getBaseDirRelative().toString())
     }
 
-    def "non-existent filename to reserveFile will throw exception"() {
-        given:
-            def missing = "no-such-file"
-            def alias = "missing"
-            def charsetName = "UTF-8"
-            def hasHeader = true
-        when:
+    @Test
+    fun `non-existent filename to reserveFile will throw exception`() {
+        val missing = "no-such-file"
+        val alias = "missing"
+        val charsetName = "UTF-8"
+        val hasHeader = true
+        val ex = assertThrows<IllegalArgumentException> {
             sut.reserveFile(missing, charsetName, alias, hasHeader)
-        then:
-            def ex = thrown(IllegalArgumentException)
-            ex.getMessage() == "Could not read file header line for file $missing"
-            ex.getCause().getMessage() == "File $missing must exist and be readable"
+        }
+        assertEquals("Could not read file header line for file $missing", ex.message) {
+            "ex.message"
+        }
+        assertEquals("File $missing must exist and be readable", ex.cause?.message) {
+            "ex.cause?.message"
+        }
     }
 
-    def "reserving a file with no header will throw an exception if the header is expected"() {
-        given:
-            def alias = "empty"
-            def charsetName = "UTF-8"
-        when:
+    @Test
+    fun `reserving a file with no header will throw an exception if the header is expected`() {
+        val alias = "empty"
+        val charsetName = "UTF-8"
+        val e = assertThrows<IllegalArgumentException> {
             sut.reserveFile(emptyFile, charsetName, alias, true)
-        then:
-            def e = thrown(IllegalArgumentException)
-            e.getCause() instanceof EOFException
+        }
+        if (e.cause !is EOFException) {
+            fail("reserveFile(emptyFile) should throw IllegalArgumentException(cause=EOFException), got cause=${e.cause}")
+        }
     }
 
-    def "resolvedFile returns absolute and relative files"() {
-        given:
-            def testFile = new File(emptyFile)
-        expect:
-            // absolute
-            sut.getResolvedFile(testFile.getAbsolutePath())
-                    .getCanonicalFile() == testFile.getCanonicalFile()
-            // relative
-            sut.getResolvedFile(testFile.getParentFile().getPath() + "/../testfiles/empty.csv")
-                    .getCanonicalFile() == testFile.getCanonicalFile()
+    @Test
+    fun `resolvedFile returns absolute and relative files`() {
+        val testFile = File(emptyFile)
+        assertEquals(
+            testFile.getCanonicalFile(),
+            sut.getResolvedFile(testFile.absolutePath).getCanonicalFile(),
+            "sut.getResolvedFile(testFile.absolutePath)"
+        )
+        // relative
+        assertEquals(
+            testFile.getCanonicalFile(),
+            sut.getResolvedFile(testFile.getParentFile().path + "/../testfiles/empty.csv")
+                .getCanonicalFile(),
+            "sut.getResolvedFile(testFile.getParentFile().path + \"/../testfiles/empty.csv\")"
+        )
     }
 
-    def "resolvedFile returns relative files with BaseForScript set"() {
-        given:
-            def testFile = new File(emptyFile)
-        when:
-            sut.setBaseForScript(testFile)
-        then:
-            sut.getResolvedFile(testFile.getName())
-                    .getCanonicalFile() == testFile.getCanonicalFile()
+    @Test
+    fun `resolvedFile returns relative files with BaseForScript set`() {
+        val testFile = File(emptyFile)
+        sut.setBaseForScript(testFile)
+        assertEquals(
+            testFile.getCanonicalFile(),
+            sut.getResolvedFile(testFile.getName()).getCanonicalFile()
+        ) {
+            ".getResolvedFile(${testFile.name}).getCanonicalFile()"
+        }
     }
 
-    def "skip bom at start of file and set correct encoding"() {
-        given:
-            sut.reserveFile(bomFile)
-        when:
-            def header = sut.readLine(bomFile)
-        then:
-            header == '"äöü"'
+    @Test
+    fun `skip bom at start of file and set correct encoding`() {
+        sut.reserveFile(bomFile)
+        val header = sut.readLine(bomFile)
+        assertEquals("\"äöü\"", header)
     }
 
-    def "fail to read a line from a directory"() {
-        given:
-            def directory = new File(bomFile).parent
-            sut.reserveFile(directory)
-        when:
+    @Test
+    fun `fail to read a line from a directory`() {
+        val directory = File(bomFile).parent
+        sut.reserveFile(directory)
+        assertThrows<IllegalArgumentException> {
             sut.readLine(directory)
-        then:
-            thrown(IllegalArgumentException)
+        }
     }
-
 }
diff --git a/src/core/src/test/kotlin/org/apache/jmeter/testelement/AbstractTestElementTest.kt b/src/core/src/test/kotlin/org/apache/jmeter/testelement/AbstractTestElementTest.kt
index 10347c2..61e0e26 100644
--- a/src/core/src/test/kotlin/org/apache/jmeter/testelement/AbstractTestElementTest.kt
+++ b/src/core/src/test/kotlin/org/apache/jmeter/testelement/AbstractTestElementTest.kt
@@ -17,7 +17,13 @@
 
 package org.apache.jmeter.testelement
 
+import io.mockk.mockk
+import io.mockk.spyk
+import org.apache.jmeter.testelement.property.CollectionProperty
+import org.apache.jmeter.testelement.property.TestElementProperty
 import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Assertions.assertFalse
+import org.junit.jupiter.api.Assertions.assertTrue
 import org.junit.jupiter.api.Test
 
 class AbstractTestElementTest {
@@ -50,4 +56,40 @@
                 "Note that comments is added in constructor, however, we remove <<comments>> property before cloning"
         }
     }
+
+    @Test
+    fun `set outer properties as temporary when using a TestElementProperty`() {
+        val sut = spyk<AbstractTestElement>()
+        val outerElement = mockk<TestElement>(relaxed = true)
+        val innerElement = mockk<TestElement>(relaxed = true)
+        val outerProp = TestElementProperty("outerProp", outerElement)
+        val innerProp = TestElementProperty("innerProp", innerElement)
+        outerProp.addProperty(innerProp)
+
+        sut.setTemporary(outerProp)
+
+        assertTrue(sut.isTemporary(outerProp)) {
+            "isTemporary($outerProp)"
+        }
+        assertFalse(sut.isTemporary(innerProp)) {
+            "isTemporary($innerProp)"
+        }
+    }
+
+    @Test
+    fun `set all properties as temporary when using a MultiProperty`() {
+        val sut = spyk<AbstractTestElement>()
+        val outerProp = CollectionProperty()
+        val innerProp = CollectionProperty()
+
+        outerProp.addProperty(innerProp)
+        sut.setTemporary(outerProp)
+
+        assertTrue(sut.isTemporary(outerProp)) {
+            "isTemporary($outerProp)"
+        }
+        assertTrue(sut.isTemporary(innerProp)) {
+            "isTemporary($innerProp)"
+        }
+    }
 }
diff --git a/src/core/src/test/kotlin/org/apache/jmeter/util/keystore/JmeterKeyStoreTest.kt b/src/core/src/test/kotlin/org/apache/jmeter/util/keystore/JmeterKeyStoreTest.kt
index 0ca8fe8..5f906cf 100644
--- a/src/core/src/test/kotlin/org/apache/jmeter/util/keystore/JmeterKeyStoreTest.kt
+++ b/src/core/src/test/kotlin/org/apache/jmeter/util/keystore/JmeterKeyStoreTest.kt
@@ -17,24 +17,29 @@
 
 package org.apache.jmeter.util.keystore
 
+import org.junit.jupiter.api.assertThrows
+import org.junit.jupiter.params.ParameterizedTest
+import org.junit.jupiter.params.provider.MethodSource
 import java.security.KeyStore
 
-import spock.lang.Specification
-import spock.lang.Unroll
-
-@Unroll
-class JmeterKeyStoreSpec extends Specification {
-
-    def "IllegalArgumentException expected when (#startIndex, #endIndex) startIndex < 0, endIndex < -1, or endIndex < startIndex"() {
-        when:
-            JmeterKeyStore.getInstance(KeyStore.defaultType, startIndex, endIndex, "defaultName")
-        then:
-            thrown IllegalArgumentException
-        where:
-            startIndex | endIndex
-            -1         | 0
-            0          | -2 // -1 indicates to return the first alias only
-            1          | 0
+class JmeterKeyStoreTest {
+    data class Case(val startIndex: Int, val endIndex: Int, val message: String? = null)
+    companion object {
+        @JvmStatic
+        fun inputs() = listOf(
+            Case(-1, 0),
+            Case(0, -2, "-1 indicates to return the first alias only"),
+            Case(1, 0),
+        )
     }
 
+    @ParameterizedTest
+    @MethodSource("inputs")
+    fun `throws IllegalArgumentException`(case: Case) {
+        assertThrows<IllegalArgumentException> {
+            JmeterKeyStore.getInstance(
+                KeyStore.getDefaultType(), case.startIndex, case.endIndex, "defaultName"
+            )
+        }
+    }
 }