diff --git a/.github/workflows/gradle-wrapper-validation.yml b/.github/workflows/gradle-wrapper-validation.yml
deleted file mode 100644
index a95413f88c..0000000000
--- a/.github/workflows/gradle-wrapper-validation.yml
+++ /dev/null
@@ -1,10 +0,0 @@
-name: "Validate Gradle Wrapper"
-on: [push, pull_request, merge_group]
-
-jobs:
-  validation:
-    name: "Validation"
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: gradle/wrapper-validation-action@v3
diff --git a/.idea/copyright/ASLv2.xml b/.idea/copyright/ASLv2.xml
index e3cfc22148..f8de65083d 100644
--- a/.idea/copyright/ASLv2.xml
+++ b/.idea/copyright/ASLv2.xml
@@ -1,6 +1,6 @@
 <component name="CopyrightManager">
   <copyright>
-    <option name="notice" value="/*&#10; * Copyright &amp;#36;today.year the original author or authors.&#10; *&#10; * Licensed under the Apache License, Version 2.0 (the &quot;License&quot;);&#10; * you may not use this file except in compliance with the License.&#10; * You may obtain a copy of the License at&#10; *     http://www.apache.org/licenses/LICENSE-2.0&#10; * Unless required by applicable law or agreed to in writing, software&#10; * distributed under the License is distributed on an &quot;AS IS&quot; BASIS,&#10; * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.&#10; * See the License for the specific language governing permissions and&#10; * limitations under the License.&#10; */" />
+    <option name="notice" value="Copyright &amp;#36;today.year the original author or authors.&#10; *&#10;Licensed under the Apache License, Version 2.0 (the &quot;License&quot;);&#10;you may not use this file except in compliance with the License.&#10;You may obtain a copy of the License at&#10;    https://www.apache.org/licenses/LICENSE-2.0&#10;Unless required by applicable law or agreed to in writing, software&#10;distributed under the License is distributed on an &quot;AS IS&quot; BASIS,&#10;WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.&#10;See the License for the specific language governing permissions and&#10;limitations under the License.&#10;" />
     <option name="keyword" value="Copyright" />
     <option name="allowReplaceKeyword" value="" />
     <option name="myName" value="ASLv2" />
diff --git a/build-logic/settings.gradle b/build-logic/settings.gradle
index c3ff77d254..8303208fd4 100644
--- a/build-logic/settings.gradle
+++ b/build-logic/settings.gradle
@@ -5,6 +5,7 @@ pluginManagement {
   }
 }
 
+rootProject.name = "build-logic"
 rootProject.buildFileName = 'build-logic.gradle'
 
 dependencyResolutionManagement {
diff --git a/build.gradle b/build.gradle
index 941719f982..1582dfd9f5 100644
--- a/build.gradle
+++ b/build.gradle
@@ -1,3 +1,5 @@
+import java.time.Duration
+
 import static org.spockframework.gradle.AsciiDocLinkVerifier.verifyAnchorlessCrossDocumentLinks
 import static org.spockframework.gradle.AsciiDocLinkVerifier.verifyLinksAndAnchors
 
@@ -127,6 +129,9 @@ subprojects {
       groovy {
         srcDir "src/${ss.name}-groovy-le-$gv/groovy"
       }
+      resources {
+        srcDir "src/${ss.name}-groovy-le-$gv/resources"
+      }
     }
     for (jv in javaVersions.findAll { javaVersion <= it }) {
       java {
@@ -135,6 +140,9 @@ subprojects {
       groovy {
         srcDir "src/${ss.name}-java-le-$jv/groovy"
       }
+      resources {
+        srcDir "src/${ss.name}-java-le-$jv/resources"
+      }
     }
     for (gv in variants.findAll { variant >= it }) {
       java {
@@ -143,6 +151,9 @@ subprojects {
       groovy {
         srcDir "src/${ss.name}-groovy-ge-$gv/groovy"
       }
+      resources {
+        srcDir "src/${ss.name}-groovy-ge-$gv/resources"
+      }
     }
     for (jv in javaVersions.findAll { javaVersion >= it }) {
       java {
@@ -151,6 +162,9 @@ subprojects {
       groovy {
         srcDir "src/${ss.name}-java-ge-$jv/groovy"
       }
+      resources {
+        srcDir "src/${ss.name}-java-ge-$jv/resources"
+      }
     }
   }
 
@@ -190,9 +204,8 @@ subprojects {
         outputLocation = file("${outputLocation.get()}/$taskName-$variant")
       }
     }
-    //Required for building on Travis' container-based infrastructure to not be killed with
-    //'exit code 137' - https://github.com/travis-ci/travis-ci/issues/5582
-    jvmArgs '-Xmx512m'
+    // As a generous general timeout, instead of the 6h of GHA.
+    timeout = Duration.ofMinutes(15)
   }
 
   tasks.register("allDependencyInsight", DependencyInsightReportTask) {}
@@ -210,7 +223,7 @@ tasks.register("collectTestXml") {
 
 
   doFirst {
-    def target = file("$buildDir/collected-test-results")
+    def target = layout.buildDirectory.dir("collected-test-results").get().asFile
     target.mkdirs()
     reportingProjects.each { rp ->
       rp.tasks.withType(Test).each { testTask ->
@@ -242,7 +255,7 @@ tasks.register("codeCoverageReport", JacocoReport) {
   reports {
     html.required = true
     xml.required = true
-    xml.outputLocation = file("${buildDir}/reports/jacoco/report.xml") // report must be here for codecov to pick it up
+    xml.outputLocation = layout.buildDirectory.file("reports/jacoco/report.xml") // report must be here for codecov to pick it up
     csv.required = false
   }
 }
diff --git a/docs/extensions.adoc b/docs/extensions.adoc
index 22bb4793d5..223c45f625 100644
--- a/docs/extensions.adoc
+++ b/docs/extensions.adoc
@@ -311,8 +311,7 @@ def "I fail if I run for more than five seconds"() { ... }
 def "I better be quick" { ... }
 ----
 
-Applying `Timeout` to a spec class has the same effect as applying it to each feature that is not already annotated
-with `Timeout`, excluding time spent in fixtures:
+Applying `@Timeout` to a spec class has the same effect as applying it to each feature and fixture method that is not already annotated with `@Timeout`:
 
 [source,groovy]
 ----
@@ -323,6 +322,11 @@ class TimedSpec extends Specification {
 
   @Timeout(value = 250, unit = MILLISECONDS)
   def "I fail much faster"() { ... }
+
+  def setup() { /* I have 10 seconds */}
+
+  @Timeout(value = 25, unit = SECONDS)
+  def cleanup() { /* I have 25 seconds */ }
 }
 ----
 
@@ -337,6 +341,11 @@ the timeout was exceeded. Additionally, thread dumps can be captured and logged
 include::{sourcedir}/timeout/TimeoutConfigurationDoc.groovy[tag=example]
 ----
 
+Since Spock 2.4, you can also configure a global timeout via the configuration file.
+This will apply to all features that are not already annotated with `@Timeout`.
+Setting the global to non-null will have the same effect as applying `@Timeout` it to all features.
+With the flag `applyGlobalTimeoutToFixtures` you can control if the global timeout should also be applied to fixture methods.
+
 === Retry
 
 The `@Retry` extensions can be used for flaky integration tests, where remote systems can fail sometimes.
@@ -1345,3 +1354,26 @@ The extension generates the following output for the example code above.
 ----
 include::{sourcedir}/extension/ExtensionStoreSpec.groovy[tag=example-result]
 ----
+
+
+[[default-value-provider]]
+=== Default Value Provider Extensions
+
+Stubs use the `EmptyOrDummyResponse` to return a default value for a method call.
+If the `EmptyOrDummyResponse` doesn't have specific instructions for a type it will return a new `Stub` for that type.
+This works for most cases, but can lead to unexpected behavior if the type does have a behavioral contract that is not fulfilled by the `Stub`.
+Another problematic case is when the type is `final` or `sealed` as those are not mockable by default.
+
+To address these issues, Spock 2.4 introduces the `org.spockframework.runtime.extension.IDefaultValueProviderExtension` that is loaded via Java's `ServiceLoader` mechanism.
+This extension allows you to provide a default value if the `EmptyOrDummyResponse` doesn't have specific instructions for a type.
+
+.Example Implementation
+[source,groovy,indent=0]
+----
+include::{sourcedir-java}/smoke/mock/MaybeDefaultValueProvider.java[tag=sample-implementation]
+----
+
+It is primarily for framework developers who want to provide a default value for their framework types.
+Or users of a framework that doesn't provide default values for their special types.
+
+If you want to change the default response behavior for `Stub` have a look at <<interaction_based_testing.adoc#ALaCarteMocks,A la Carte Mocks>> and how to use your own `org.spockframework.mock.IDefaultResponse`.
diff --git a/docs/include.adoc b/docs/include.adoc
index 54ddcb052c..713bcaf665 100644
--- a/docs/include.adoc
+++ b/docs/include.adoc
@@ -10,6 +10,10 @@
 :github-base: https://github.com/spockframework/spock
 :github-blob-base: {github-base}/blob
 :commit-ish: master
+// source java dir
+:base-sourcedir-java: spock-specs/src/test/java/org/spockframework
+:sourcedir-java: ../{base-sourcedir-java}
+:github-sourcedir-java: {github-blob-base}/{commit-ish}/{base-sourcedir-java}
 // source dir
 :base-sourcedir: spock-specs/src/test/groovy/org/spockframework/docs
 :sourcedir: ../{base-sourcedir}
diff --git a/docs/release_notes.adoc b/docs/release_notes.adoc
index ea7d9e60bb..a5915facbb 100644
--- a/docs/release_notes.adoc
+++ b/docs/release_notes.adoc
@@ -8,11 +8,21 @@ include::include.adoc[]
 === Highlights
 
 * Add support for combining two or more data providers using cartesian product spockIssue:1062[]
-* Add support for a `filter` block after a `where` block to filter out unwanted iterations
+* Add support for a `filter` block after a `where` block to filter out unwanted iterations spockPull:1927[]
 
 === Misc
 
-* Types constraints or arguments in interactions can now handle primitive types like `_ as int` spockIssue:1974[]
+* Add `globalTimeout` to  `@Timeout` extension, to apply a timeout to all features in a specification, configurable via the spock configuration file spockPull:1986[]
+* Add new <<extensions.adoc#default-value-provider,`IDefaultValueProviderExtension`>> extension point to add support for special classes in the Stub's default `EmptyOrDummyResponse` spockPull:1994[]
+* Add support for Groovy-4-style range expressions spockIssue:1956[]
+* Improve `@Timeout` extension will now use virtual threads if available spockPull:1986[]
+* Improve mock argument matching, types constraints or arguments in interactions can now handle primitive types like `_ as int` spockIssue:1974[]
+* Support ContextClassLoader when loading optional classes via `ReflectionUtil` spockPull:1995[]
+** This enables loading of optional classes in e.g. OSGi environments
+* `EmbeddedSpecRunner` and `EmbeddedSpecCompiler` now support the construction with a custom `ClassLoader` spockPull:1988[]
+** This allows the use of these classes in an OSGi environment, where the class imports in the embedded spec are not visible to the Spock OSGi bundle ClassLoader
+* Fix mocking issue with the ByteBuddy MockMaker when using multiple classloaders in Java 21 spockIssue:2017[]
+* Fix mocking of final classes via `@SpringBean` and `@SpringSpy` spockIssue:1960[]
 
 == 2.4-M4 (2024-03-21)
 
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index 3a451955ab..006d9a8133 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -2,23 +2,23 @@
 asciidoctorj = '2.5.13'
 groovy2 = '2.5.23'
 groovy3 = '3.0.22'
-groovy4 = '4.0.22'
+groovy4 = '4.0.23'
 jacoco = '0.8.12'
-junit = '5.10.3'
-asm = '9.7'
+junit = '5.11.3'
+asm = '9.7.1'
 mockito4 = '4.11.0'
-mockito5 = '5.12.0'
+mockito5 = '5.14.2'
 
 [libraries]
-jetbrains-annotations = "org.jetbrains:annotations:24.1.0"
+jetbrains-annotations = "org.jetbrains:annotations:26.0.1"
 asciidoctorj = { module = "org.asciidoctor:asciidoctorj", version.ref = "asciidoctorj" }
 asm = { module = "org.ow2.asm:asm", version.ref = "asm" }
 asmUtil = { module = "org.ow2.asm:asm-util", version.ref = "asm" }
-bytebuddy = "net.bytebuddy:byte-buddy:1.14.18"
+bytebuddy = "net.bytebuddy:byte-buddy:1.15.5"
 cglib = "cglib:cglib-nodep:3.3.0"
-geantyref = "io.leangen.geantyref:geantyref:1.3.15"
+geantyref = "io.leangen.geantyref:geantyref:1.3.16"
 h2database = "com.h2database:h2:2.2.224"
-hamcrest = "org.hamcrest:hamcrest:2.2"
+hamcrest = "org.hamcrest:hamcrest:3.0"
 jaxb = "javax.xml.bind:jaxb-api:2.3.1"
 junit4 = "junit:junit:4.13.2"
 log4j = "log4j:log4j:1.2.17"
diff --git a/gradle/wrapper/gradle-wrapper.jar b/gradle/wrapper/gradle-wrapper.jar
index 2c3521197d..a4b76b9530 100644
Binary files a/gradle/wrapper/gradle-wrapper.jar and b/gradle/wrapper/gradle-wrapper.jar differ
diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
index 68e8816d71..fb602ee2af 100644
--- a/gradle/wrapper/gradle-wrapper.properties
+++ b/gradle/wrapper/gradle-wrapper.properties
@@ -1,7 +1,7 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionSha256Sum=d725d707bfabd4dfdc958c624003b3c80accc03f7037b5122c4b1d0ef15cecab
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.9-bin.zip
+distributionSha256Sum=31c55713e40233a8303827ceb42ca48a47267a0ad4bab9177123121e71524c26
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.10.2-bin.zip
 networkTimeout=10000
 validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME
diff --git a/settings.gradle b/settings.gradle
index aa33cf3510..3e4f773166 100644
--- a/settings.gradle
+++ b/settings.gradle
@@ -7,9 +7,9 @@ pluginManagement {
   }
 
   plugins {
-    id "com.gradle.develocity" version "3.17.6"
+    id "com.gradle.develocity" version "3.18.1"
     id "com.gradle.common-custom-user-data-gradle-plugin" version "2.0.2"
-    id "org.asciidoctor.jvm.convert" version "4.0.2"
+    id "org.asciidoctor.jvm.convert" version "4.0.3"
     id "net.nemerosa.versioning" version "3.1.0"
     id "io.github.gradle-nexus.publish-plugin" version "2.0.0"
     id "com.github.ben-manes.versions" version "0.51.0"
diff --git a/spock-core/core.gradle b/spock-core/core.gradle
index 242ce46172..7db47aa758 100644
--- a/spock-core/core.gradle
+++ b/spock-core/core.gradle
@@ -28,7 +28,7 @@ dependencies {
   if (variant == 2.5) {
     api projects.spockGroovy2Compat
   }
-  
+
   implementation libs.geantyref
 
   compileOnly libs.jetbrains.annotations
@@ -69,7 +69,10 @@ tasks.named("jar", Jar) {
         'net.bytebuddy.*;resolution:=optional',
         'net.sf.cglib.*;resolution:=optional',
         'org.objectweb.asm.*;resolution:=optional',
-        'org.mockito.*;resolution:=optional',
+        /* We need to override the OSGi version for Mockito here, otherwise the version range would be [4.11,5)
+         * which would exclude Mockito 5 in the OSGi case.
+         */
+        'org.mockito.*;resolution:=optional;version="[4.11,6)"',
         '*'
       ].join(','),
       '-noclassforname': 'true',
@@ -92,10 +95,10 @@ tasks.named("processResources") {
 
 tasks.register("coreConsole", JavaExec) {
   description = 'Start a groovy Console with Spock Core Classpath, useful for AST-Inspection'
-  main = variant == 2.5 ? "groovy.ui.Console" : "groovy.console.ui.Console"
+  mainClass = variant == 2.5 ? "groovy.ui.Console" : "groovy.console.ui.Console"
   classpath(sourceSets.named("main").map {it.runtimeClasspath }, configurations.named("coreConsoleRuntime"))
   workingDir = file('build/console')
-  ignoreExitValue = true
+  ignoreExitValue true
   args file('CoreConsole.groovy').absolutePath
   doFirst {
     workingDir.mkdirs()
@@ -106,7 +109,7 @@ tasks.register("coreConsole", JavaExec) {
 // task writes out the properties necessary for it to verify the OSGi
 // metadata.
 def osgiProperties = tasks.register('osgiProperties', WriteProperties) {
-  outputFile = layout.getBuildDirectory().file("verifyOSGiProperties.bndrun")
+  destinationFile = layout.getBuildDirectory().file("verifyOSGiProperties.bndrun")
   property('-standalone', true)
   property('-runee', "JavaSE-${javaVersion < 9 ? '1.' + javaVersion : javaVersion}")
   property('-runrequires', "osgi.identity;filter:='(osgi.identity=${project.name})'")
diff --git a/spock-core/src/main/groovy/spock/util/EmbeddedSpecCompiler.groovy b/spock-core/src/main/groovy/spock/util/EmbeddedSpecCompiler.groovy
index ae52803ecc..63f4efd344 100644
--- a/spock-core/src/main/groovy/spock/util/EmbeddedSpecCompiler.groovy
+++ b/spock-core/src/main/groovy/spock/util/EmbeddedSpecCompiler.groovy
@@ -38,11 +38,36 @@ class EmbeddedSpecCompiler {
   final CompilerConfiguration compilerConfigurationWithImports = new CompilerConfiguration().tap {
     it.addCompilationCustomizers(importCustomizer)
   }
-  final GroovyClassLoader loaderWithImports = new GroovyClassLoader(getClass().classLoader, compilerConfigurationWithImports)
-  final GroovyClassLoader loader = new GroovyClassLoader(getClass().classLoader)
+  final GroovyClassLoader loaderWithImports
+  final GroovyClassLoader loader
 
   boolean unwrapCompileException = true
 
+  /**
+   * Creates a new {@link EmbeddedSpecCompiler} with default settings using the Spock {@link ClassLoader} for resolving imports.
+   */
+  EmbeddedSpecCompiler() {
+    //We can't use the new constructor EmbeddedSpecCompiler(ClassLoader) here, because we can't call this before super
+    //and someone could have subclassed the EmbeddedSpecCompiler with a different classloader,
+    //which would break the existing code, if we use "EmbeddedSpecCompiler.class.classLoader"
+    def classLoader = this.class.classLoader
+    this.loaderWithImports = new GroovyClassLoader(classLoader, compilerConfigurationWithImports)
+    this.loader = new GroovyClassLoader(classLoader)
+  }
+
+  /**
+   * Creates a new {@link EmbeddedSpecCompiler} with a custom classloader to load imports of the spec.
+   * Note: The classloader need to be able to load Spock classes.
+   *
+   * @param classLoader the ClassLoader to use to load the spec imports
+   * @since 2.4
+   */
+  @Beta
+  EmbeddedSpecCompiler(ClassLoader classLoader) {
+    Objects.requireNonNull(classLoader)
+    this.loaderWithImports = new GroovyClassLoader(classLoader, compilerConfigurationWithImports)
+    this.loader = new GroovyClassLoader(classLoader)
+  }
 
   void addPackageImport(String pkg) {
     importCustomizer.addStarImports(pkg)
diff --git a/spock-core/src/main/groovy/spock/util/EmbeddedSpecRunner.groovy b/spock-core/src/main/groovy/spock/util/EmbeddedSpecRunner.groovy
index 7e50339864..ac9ac97111 100644
--- a/spock-core/src/main/groovy/spock/util/EmbeddedSpecRunner.groovy
+++ b/spock-core/src/main/groovy/spock/util/EmbeddedSpecRunner.groovy
@@ -41,7 +41,7 @@ import static org.junit.platform.engine.discovery.DiscoverySelectors.selectClass
  */
 @NotThreadSafe
 class EmbeddedSpecRunner {
-  private final EmbeddedSpecCompiler compiler = new EmbeddedSpecCompiler(unwrapCompileException: false)
+  private final EmbeddedSpecCompiler compiler
 
   boolean throwFailure = true
 
@@ -50,6 +50,38 @@ class EmbeddedSpecRunner {
   List<Class> configClasses = []
   boolean inheritParentExtensions = true
 
+  /**
+   * Creates a new {@link EmbeddedSpecRunner} with a default {@link EmbeddedSpecCompiler}.
+   */
+  EmbeddedSpecRunner() {
+    this(new EmbeddedSpecCompiler())
+    this.compiler.unwrapCompileException = false
+  }
+
+  /**
+   * Creates a new {@link EmbeddedSpecRunner} with a custom classloader to load imports of the spec.
+   * Note: The classloader need to be able to load Spock classes.
+   *
+   * @param classLoader the ClassLoader to use to load the spec imports
+   * @since 2.4
+   */
+  @Beta
+  EmbeddedSpecRunner(ClassLoader classLoader) {
+    this(new EmbeddedSpecCompiler(classLoader))
+    this.compiler.unwrapCompileException = false
+  }
+
+  /**
+   * Creates a new {@link EmbeddedSpecRunner} with a custom {@link EmbeddedSpecCompiler}.
+   *
+   * @param compiler the compiler to use
+   * @since 2.4
+   */
+  @Beta
+  EmbeddedSpecRunner(EmbeddedSpecCompiler compiler) {
+    this.compiler = Objects.requireNonNull(compiler)
+  }
+
   void configurationScript(Closure configurationScript) {
     this.configurationScript = configurationScript
   }
diff --git a/spock-core/src/main/java/org/spockframework/mock/EmptyOrDummyResponse.java b/spock-core/src/main/java/org/spockframework/mock/EmptyOrDummyResponse.java
index 4faf562230..b788ef3b08 100644
--- a/spock-core/src/main/java/org/spockframework/mock/EmptyOrDummyResponse.java
+++ b/spock-core/src/main/java/org/spockframework/mock/EmptyOrDummyResponse.java
@@ -14,6 +14,7 @@
 
 package org.spockframework.mock;
 
+import org.spockframework.runtime.extension.IDefaultValueProviderExtension;
 import org.spockframework.util.ReflectionUtil;
 import org.spockframework.util.ThreadSafe;
 import spock.lang.Specification;
@@ -35,8 +36,17 @@
 @ThreadSafe
 public class EmptyOrDummyResponse implements IDefaultResponse {
   public static final EmptyOrDummyResponse INSTANCE = new EmptyOrDummyResponse();
+  private final List<IDefaultValueProviderExtension> defaultValueProviders;
 
-  private EmptyOrDummyResponse() {}
+  private EmptyOrDummyResponse() {
+    ServiceLoader<IDefaultValueProviderExtension> serviceLoader = ServiceLoader.load(IDefaultValueProviderExtension.class);
+    List<IDefaultValueProviderExtension> providers = new ArrayList<>();
+    for (IDefaultValueProviderExtension provider : serviceLoader) {
+      providers.add(provider);
+    }
+    providers.sort(Comparator.comparing(p -> p.getClass().getName()));
+    defaultValueProviders = Collections.unmodifiableList(providers);
+  }
 
   @Override
   @SuppressWarnings("rawtypes")
@@ -72,6 +82,8 @@ public Object respond(IMockInvocation invocation) {
       if (returnType == IntStream.class) return IntStream.empty();
       if (returnType == DoubleStream.class) return DoubleStream.empty();
       if (returnType == LongStream.class) return LongStream.empty();
+      Object providedValue = askDefaultValueProviders(invocation);
+      if (providedValue != null) return providedValue;
       return createDummy(invocation);
     }
 
@@ -98,6 +110,9 @@ public Object respond(IMockInvocation invocation) {
     Object emptyWrapper = createEmptyWrapper(returnType);
     if (emptyWrapper != null) return emptyWrapper;
 
+    Object providedValue = askDefaultValueProviders(invocation);
+    if (providedValue != null) return providedValue;
+
     Object emptyObject = createEmptyObject(returnType);
     if (emptyObject != null) return emptyObject;
 
@@ -128,6 +143,19 @@ private Object createEmptyObject(Class<?> type) {
     }
   }
 
+  private Object askDefaultValueProviders(IMockInvocation invocation) {
+    if (defaultValueProviders.isEmpty()) {
+      return null;
+    }
+    Class<?> returnType = invocation.getMethod().getReturnType();
+    Type exactReturnType = invocation.getMethod().getExactReturnType();
+    return defaultValueProviders.stream()
+        .map(provider -> provider.provideDefaultValue(returnType, exactReturnType))
+        .filter(Objects::nonNull)
+        .findFirst()
+        .orElse(null);
+  }
+
   private Object createDummy(IMockInvocation invocation) {
     Class<?> type = invocation.getMethod().getReturnType();
     Type genericType = invocation.getMethod().getExactReturnType();
diff --git a/spock-core/src/main/java/org/spockframework/mock/runtime/ByteBuddyMockFactory.java b/spock-core/src/main/java/org/spockframework/mock/runtime/ByteBuddyMockFactory.java
index 24d963d044..0e4086aa5f 100644
--- a/spock-core/src/main/java/org/spockframework/mock/runtime/ByteBuddyMockFactory.java
+++ b/spock-core/src/main/java/org/spockframework/mock/runtime/ByteBuddyMockFactory.java
@@ -28,6 +28,7 @@
 import net.bytebuddy.dynamic.Transformer;
 import net.bytebuddy.dynamic.loading.ClassInjector;
 import net.bytebuddy.dynamic.loading.ClassLoadingStrategy;
+import net.bytebuddy.dynamic.loading.MultipleParentClassLoader;
 import net.bytebuddy.dynamic.scaffold.TypeValidation;
 import net.bytebuddy.implementation.FieldAccessor;
 import net.bytebuddy.implementation.MethodDelegation;
@@ -37,10 +38,9 @@
 import org.jetbrains.annotations.VisibleForTesting;
 import org.spockframework.mock.ISpockMockObject;
 import org.spockframework.mock.codegen.Target;
-import org.spockframework.util.Nullable;
 
 import java.lang.reflect.Method;
-import java.util.List;
+import java.util.Collection;
 import java.util.concurrent.Callable;
 import java.util.concurrent.ThreadLocalRandom;
 
@@ -83,6 +83,27 @@ class ByteBuddyMockFactory {
     }
   }
 
+  /**
+   * Returns {@code true}, if the mock is considered local
+   * <p>
+   * A mock is considered local, if all additional interfaces of the mock (including {@link ISpockMockObject}) are
+   * loadable by the target class' classloader.
+   *
+   * @param targetClass The to-be-mocked class
+   * @param additionalInterfaces Additional interfaces of the to-be-mocked type
+   * @return true, if this is a local mock. Otherwise false
+   */
+  @VisibleForTesting
+  static boolean isLocalMock(Class<?> targetClass, Collection<Class<?>> additionalInterfaces) {
+    // Inspired by https://github.com/mockito/mockito/blob/99426415c0ceb30e55216c3934854528c83f410e/mockito-core/src/main/java/org/mockito/internal/creation/bytebuddy/SubclassBytecodeGenerator.java#L165-L166
+    ClassLoader cl = new MultipleParentClassLoader.Builder()
+      .appendMostSpecific(targetClass)
+      .appendMostSpecific(additionalInterfaces)
+      .appendMostSpecific(ISpockMockObject.class)
+      .build();
+    return cl == targetClass.getClassLoader();
+  }
+
   Object createMock(IMockMaker.IMockCreationSettings settings) {
     final Class<?> type = settings.getMockType();
     TypeCache.SimpleKey key = new TypeCache.SimpleKey(type, settings.getAdditionalInterface());
@@ -99,7 +120,8 @@ Object createMock(IMockMaker.IMockCreationSettings settings) {
         }
         int randomNumber = Math.abs(ThreadLocalRandom.current().nextInt());
         String name = String.format("%s$%s$%d", typeName, "SpockMock", randomNumber);
-        ClassLoadingStrategy<ClassLoader> strategy = determineBestClassLoadingStrategy(targetClass);
+        ClassLoadingStrategy<ClassLoader> strategy = determineBestClassLoadingStrategy(targetClass, settings);
+        //noinspection resource
         return new ByteBuddy()
           .with(TypeValidation.DISABLED) // https://github.com/spockframework/spock/issues/776
           .ignore(none())
@@ -190,8 +212,8 @@ private static boolean isComingFromSignedJar(Class<?> type) {
   }
 
   @NotNull
-  private static ClassLoadingStrategy<ClassLoader> determineBestClassLoadingStrategy(Class<?> targetClass) throws Exception {
-    if (ClassInjector.UsingLookup.isAvailable()) {
+  private static ClassLoadingStrategy<ClassLoader> determineBestClassLoadingStrategy(Class<?> targetClass, IMockMaker.IMockCreationSettings settings) throws Exception {
+    if (ClassInjector.UsingLookup.isAvailable() && isLocalMock(targetClass, settings.getAdditionalInterface())) {
       Class<?> methodHandlesClass = Class.forName("java.lang.invoke.MethodHandles");
       Class<?> lookupClass = Class.forName("java.lang.invoke.MethodHandles$Lookup");
       Method lookupMethod = methodHandlesClass.getMethod("lookup");
diff --git a/spock-core/src/main/java/org/spockframework/runtime/ExtensionClassesLoader.java b/spock-core/src/main/java/org/spockframework/runtime/ExtensionClassesLoader.java
index 86f3c4fdf6..0c28a1e8a0 100644
--- a/spock-core/src/main/java/org/spockframework/runtime/ExtensionClassesLoader.java
+++ b/spock-core/src/main/java/org/spockframework/runtime/ExtensionClassesLoader.java
@@ -15,6 +15,7 @@
 package org.spockframework.runtime;
 
 import org.spockframework.runtime.extension.*;
+import org.spockframework.util.ReflectionUtil;
 import spock.config.ConfigurationObject;
 
 import java.io.*;
@@ -53,9 +54,9 @@ public <T> List<Class<? extends T>> loadClasses(String descriptorPath, Class<T>
     return extClasses;
   }
 
-  private List<URL> locateDescriptors(String descriptorPath) {
+  private Collection<URL> locateDescriptors(String descriptorPath) {
     try {
-      return Collections.list(RunContext.class.getClassLoader().getResources(descriptorPath));
+      return ReflectionUtil.getResourcesFromClassLoaders(descriptorPath);
     } catch (Exception e) {
       throw new ExtensionException("Failed to locate extension descriptors", e);
     }
@@ -80,7 +81,7 @@ private List<String> readDescriptor(URL url) {
   @SuppressWarnings("unchecked")
   private <T> Class<? extends T> loadExtensionClass(String className, Class<T> baseClass) {
     try {
-      Class<?> loadedClass = RunContext.class.getClassLoader().loadClass(className);
+      Class<?> loadedClass = ReflectionUtil.loadClass(className);
       if (!baseClass.isAssignableFrom(loadedClass)) {
         throw new ExtensionException("Failed to load extension class '%s' as it is not assignable to '%s'")
           .withArgs(className, baseClass.getName());
diff --git a/spock-core/src/main/java/org/spockframework/runtime/extension/IDefaultValueProviderExtension.java b/spock-core/src/main/java/org/spockframework/runtime/extension/IDefaultValueProviderExtension.java
new file mode 100644
index 0000000000..f909e80b9b
--- /dev/null
+++ b/spock-core/src/main/java/org/spockframework/runtime/extension/IDefaultValueProviderExtension.java
@@ -0,0 +1,53 @@
+/*
+ *  Copyright 2024 the original author or authors.
+ *
+ *  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
+ *      https://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.spockframework.runtime.extension;
+
+import java.lang.reflect.Type;
+
+import org.spockframework.mock.IMockMethod;
+import org.spockframework.util.Beta;
+import org.spockframework.util.Nullable;
+import org.spockframework.util.ThreadSafe;
+
+/**
+ * Allows to enhance {@link org.spockframework.mock.EmptyOrDummyResponse} with custom default values.
+ * <p>
+ * Will be instantiated via the {@link java.util.ServiceLoader} mechanism.
+ * <p>
+ * Implementations must be thread-safe and should not have any state.
+ * <p>
+ * This extension is intended for framework authors and users who want to provide default values for their own types.
+ * The extension will only be called if no sensible default value can be provided by the default mechanism.
+ * If you want to change the default behavior for all types, you should implement a custom {@link org.spockframework.mock.IDefaultResponse}.
+ *
+ * @since 2.4
+ * @see org.spockframework.mock.EmptyOrDummyResponse
+ * @see org.spockframework.mock.IDefaultResponse
+ */
+@Beta
+@ThreadSafe
+public interface IDefaultValueProviderExtension {
+  /**
+   * Provides a default value for the given type.
+   * <p>
+   * This method will be called for every `EmptyOrDummyResponse` non-default type, the returned values are not cached.
+   *
+   * @param type the type for which a default value should be provided, see {@link IMockMethod#getReturnType()}
+   * @param exactType the exact type for which a default value should be provided, see {@link IMockMethod#getExactReturnType()}
+   * @return the value or null if no default value can be provided
+   */
+  @Nullable
+  Object provideDefaultValue(Class<?> type, Type exactType);
+}
diff --git a/spock-core/src/main/java/org/spockframework/runtime/extension/builtin/GlobalTimeoutExtension.java b/spock-core/src/main/java/org/spockframework/runtime/extension/builtin/GlobalTimeoutExtension.java
new file mode 100644
index 0000000000..fe90e3f88d
--- /dev/null
+++ b/spock-core/src/main/java/org/spockframework/runtime/extension/builtin/GlobalTimeoutExtension.java
@@ -0,0 +1,71 @@
+/*
+ *  Copyright 2024 the original author or authors.
+ *
+ *  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
+ *      https://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.spockframework.runtime.extension.builtin;
+
+import spock.lang.Timeout;
+
+import java.util.stream.Stream;
+import java.util.stream.StreamSupport;
+
+import org.spockframework.runtime.extension.IGlobalExtension;
+import org.spockframework.runtime.model.FeatureInfo;
+import org.spockframework.runtime.model.MethodInfo;
+import org.spockframework.runtime.model.SpecInfo;
+import org.spockframework.util.Assert;
+import org.spockframework.util.Beta;
+import org.spockframework.util.Nullable;
+
+/**
+ * Applies a timeout to every feature and fixture depending on the configuration.
+ *
+ * @author Leonard Brünings
+ * @since 2.4
+ */
+@Beta
+public class GlobalTimeoutExtension implements IGlobalExtension {
+  private final TimeoutConfiguration timeoutConfiguration;
+  private @Nullable TimeoutInterceptor timeoutInterceptor;
+
+  public GlobalTimeoutExtension(TimeoutConfiguration timeoutConfiguration) {
+    // TimeoutConfiguration is mutable and will be configured after the extension is created,
+    // so we need to store a reference to it and delay until the extension is started to create the interceptor.
+    this.timeoutConfiguration = Assert.notNull(timeoutConfiguration, "timeoutConfiguration is null");
+  }
+
+  @Override
+  public void start() {
+    timeoutInterceptor = timeoutConfiguration.globalTimeout == null
+        ? null
+        : new TimeoutInterceptor(timeoutConfiguration.globalTimeout, timeoutConfiguration);
+  }
+
+  @Override
+  public void visitSpec(SpecInfo spec) {
+    if (timeoutInterceptor == null
+        || spec.getReflection().isAnnotationPresent(Timeout.class)) {
+      return;
+    }
+
+    Stream<MethodInfo> features = spec.getAllFeatures().stream()
+        .map(FeatureInfo::getFeatureMethod);
+    Stream<MethodInfo> fixtures = timeoutConfiguration.applyGlobalTimeoutToFixtures
+        ? StreamSupport.stream(spec.getAllFixtureMethods().spliterator(), false)
+        : Stream.empty();
+
+    Stream.concat(features, fixtures)
+        .filter(method -> !method.getReflection().isAnnotationPresent(Timeout.class))
+        .forEach(method -> method.addInterceptor(timeoutInterceptor));
+  }
+}
diff --git a/spock-core/src/main/java/org/spockframework/runtime/extension/builtin/TimeoutConfiguration.java b/spock-core/src/main/java/org/spockframework/runtime/extension/builtin/TimeoutConfiguration.java
index ec30dac39f..c573c93eb7 100644
--- a/spock-core/src/main/java/org/spockframework/runtime/extension/builtin/TimeoutConfiguration.java
+++ b/spock-core/src/main/java/org/spockframework/runtime/extension/builtin/TimeoutConfiguration.java
@@ -1,24 +1,25 @@
 /*
- * Copyright 2023 the original author or authors.
+ *  Copyright 2024 the original author or authors.
  *
- * 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
- *
- *     https://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.
+ *  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
+ *      https://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.spockframework.runtime.extension.builtin;
 
 import org.spockframework.util.Beta;
+import org.spockframework.util.Nullable;
+
 import spock.config.ConfigurationObject;
 
+import java.time.Duration;
 import java.util.ArrayList;
 import java.util.List;
 
@@ -45,6 +46,18 @@
 @ConfigurationObject("timeout")
 public class TimeoutConfiguration {
 
+  /**
+   * If set to a valid duration, it will apply for all features that do not have a specific timeout set, default null.
+   * @since 2.4
+   */
+  public @Nullable Duration globalTimeout = null;
+
+  /**
+   * Determines whether the global timeout will be applied to fixtures, default false.
+   * @since 2.4
+   */
+  public boolean applyGlobalTimeoutToFixtures = false;
+
   /**
    * Determines whether thread dumps will be captured and logged on feature timeout or unsuccessful interrupt attempts, default false.
    */
diff --git a/spock-core/src/main/java/org/spockframework/runtime/extension/builtin/TimeoutExtension.java b/spock-core/src/main/java/org/spockframework/runtime/extension/builtin/TimeoutExtension.java
index d3f2f587e5..34b28b164a 100644
--- a/spock-core/src/main/java/org/spockframework/runtime/extension/builtin/TimeoutExtension.java
+++ b/spock-core/src/main/java/org/spockframework/runtime/extension/builtin/TimeoutExtension.java
@@ -1,17 +1,15 @@
 /*
- * Copyright 2009 the original author or authors.
+ *  Copyright 2024 the original author or authors.
  *
- * 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
- *
- *     https://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.
+ *  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
+ *      https://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.spockframework.runtime.extension.builtin;
@@ -22,6 +20,8 @@
 import org.spockframework.runtime.model.SpecInfo;
 import spock.lang.Timeout;
 
+import java.time.Duration;
+
 /**
  * @author Peter Niederwieser
  */
@@ -44,11 +44,11 @@ public void visitSpecAnnotation(Timeout timeout, SpecInfo spec) {
 
   @Override
   public void visitFeatureAnnotation(Timeout timeout, FeatureInfo feature) {
-    feature.getFeatureMethod().addInterceptor(new TimeoutInterceptor(timeout, configuration));
+    feature.getFeatureMethod().addInterceptor(new TimeoutInterceptor(Duration.ofNanos(timeout.unit().toNanos(timeout.value())), configuration));
   }
 
   @Override
   public void visitFixtureAnnotation(Timeout timeout, MethodInfo fixtureMethod) {
-    fixtureMethod.addInterceptor(new TimeoutInterceptor(timeout, configuration));
+    fixtureMethod.addInterceptor(new TimeoutInterceptor(Duration.ofNanos(timeout.unit().toNanos(timeout.value())), configuration));
   }
 }
diff --git a/spock-core/src/main/java/org/spockframework/runtime/extension/builtin/TimeoutInterceptor.java b/spock-core/src/main/java/org/spockframework/runtime/extension/builtin/TimeoutInterceptor.java
index 28bc6da492..7891eb7220 100644
--- a/spock-core/src/main/java/org/spockframework/runtime/extension/builtin/TimeoutInterceptor.java
+++ b/spock-core/src/main/java/org/spockframework/runtime/extension/builtin/TimeoutInterceptor.java
@@ -1,17 +1,15 @@
 /*
- * Copyright 2009 the original author or authors.
+ *  Copyright 2024 the original author or authors.
  *
- * 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
- *
- *     https://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.
+ *  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
+ *      https://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.spockframework.runtime.extension.builtin;
@@ -20,7 +18,6 @@
 import org.spockframework.runtime.extension.IMethodInterceptor;
 import org.spockframework.runtime.extension.IMethodInvocation;
 import org.spockframework.util.*;
-import spock.lang.Timeout;
 
 import java.io.ByteArrayOutputStream;
 import java.io.PrintStream;
@@ -40,14 +37,15 @@
  *
  * @author Peter Niederwieser
  */
-
+@ThreadSafe
 public class TimeoutInterceptor implements IMethodInterceptor {
 
-  private final Timeout timeout;
+  private final Duration timeout;
   private final TimeoutConfiguration configuration;
   private final JavaProcessThreadDumpCollector threadDumpCollector;
 
-  public TimeoutInterceptor(Timeout timeout, TimeoutConfiguration configuration) {
+  public TimeoutInterceptor(Duration timeout, TimeoutConfiguration configuration) {
+    Checks.checkArgument(timeout.toNanos() > 0, () -> "timeout must be positive but was " + timeout);
     this.timeout = timeout;
     this.configuration = configuration;
     this.threadDumpCollector = JavaProcessThreadDumpCollector.create(configuration.threadDumpUtilityType);
@@ -59,13 +57,11 @@ public void intercept(final IMethodInvocation invocation) throws Throwable {
     final SynchronousQueue<StackTraceElement[]> sync = new SynchronousQueue<>();
     final CountDownLatch startLatch = new CountDownLatch(2);
     final String methodName = invocation.getMethod().getName();
-    final double timeoutSeconds = TimeUtil.toSeconds(timeout.value(), timeout.unit());
+    final double timeoutSeconds = TimeUtil.toSeconds(timeout);
 
-    new Thread(String.format("[spock.lang.Timeout] Watcher for method '%s'", methodName)) {
-      @Override
-      public void run() {
+    ThreadSupport.virtualThreadIfSupported(String.format("[spock.lang.Timeout] Watcher for method '%s'", methodName), () -> {
         StackTraceElement[] stackTrace = new StackTraceElement[0];
-        long waitMillis = timeout.unit().toMillis(timeout.value());
+        long waitMillis = timeout.toMillis();
         boolean synced = false;
         long timeoutAt = 0;
         int unsuccessfulInterruptAttempts = 0;
@@ -92,9 +88,8 @@ public void run() {
             }
             mainThread.interrupt();
           }
-        }
       }
-    }.start();
+    }).start();
 
     syncWithThread(startLatch, "watcher", methodName);
 
@@ -137,7 +132,7 @@ private void logUnsuccessfulInterrupt(String methodName, long now, long timeoutA
     System.err.printf(
       "[spock.lang.Timeout] Method '%s' has not stopped after timing out %1.2f seconds ago - interrupting. Next try in %1.2f seconds.\n%n",
       methodName,
-      Duration.ofNanos(now - timeoutAt).toMillis() / 1000d,
+      TimeUtil.toSeconds(Duration.ofNanos(now - timeoutAt)),
       waitMillis / 1000d
     );
 
diff --git a/spock-core/src/main/java/org/spockframework/util/ReflectionUtil.java b/spock-core/src/main/java/org/spockframework/util/ReflectionUtil.java
index d387cf5344..9ba817b38f 100644
--- a/spock-core/src/main/java/org/spockframework/util/ReflectionUtil.java
+++ b/spock-core/src/main/java/org/spockframework/util/ReflectionUtil.java
@@ -18,8 +18,10 @@
 import static java.util.Arrays.asList;
 
 import java.io.File;
+import java.io.IOException;
 import java.lang.annotation.Annotation;
 import java.lang.reflect.*;
+import java.net.URL;
 import java.security.CodeSource;
 import java.util.*;
 
@@ -38,30 +40,88 @@ public static String getPackageName(Class<?> clazz) {
   public static Class<?> loadFirstAvailableClass(String... classNames) {
     for (String className : classNames) {
       Class<?> clazz = loadClassIfAvailable(className);
-      if (clazz != null) {return clazz;}
+      if (clazz != null) {
+        return clazz;
+      }
     }
     return null;
   }
 
   public static Class<?> loadClassIfAvailable(String className) {
     try {
-      return ReflectionUtil.class.getClassLoader().loadClass(className);
+      return loadClass(className);
     } catch (ClassNotFoundException e) {
       return null;
     }
   }
 
+  /**
+   * Loads the className in the following order:
+   * <ul>
+   * <li>Spock {@link ClassLoader}</li>
+   * <li>{@code Thread.currentThread().getContextClassLoader()}</li>
+   * </ul>
+   *
+   * @param className the class to load
+   * @return the loaded class
+   * @throws ClassNotFoundException if the class could not be found
+   */
+  public static Class<?> loadClass(String className) throws ClassNotFoundException {
+    ClassLoader spockClassLoader = ReflectionUtil.class.getClassLoader();
+    try {
+      return spockClassLoader.loadClass(className);
+    } catch (ClassNotFoundException outerEx) {
+      ClassLoader contextClassLoader;
+      try {
+        //Try ContextClassLoader to better support for runtimes like OSGi
+        contextClassLoader = Thread.currentThread().getContextClassLoader();
+      } catch (SecurityException ex) {
+        throw outerEx;
+      }
+      if (contextClassLoader != null && contextClassLoader != spockClassLoader) {
+        return contextClassLoader.loadClass(className);
+      }
+      throw outerEx;
+    }
+  }
+
+  /**
+   * Returns the resources from the following classloaders:
+   * <ul>
+   * <li>Spock {@link ClassLoader}</li>
+   * <li>{@code Thread.currentThread().getContextClassLoader()}</li>
+   * </ul>
+   *
+   * @param resourcePath the path of the resource
+   * @return the list of resources
+   * @throws IOException if the resources can't be loaded
+   */
+  public static Collection<URL> getResourcesFromClassLoaders(String resourcePath) throws IOException {
+    ClassLoader spockClassLoader = ReflectionUtil.class.getClassLoader();
+    // We need to use a sorted Set here, to filter out duplicates, if the ContextClassLoader can also reach the Spock classloader
+    TreeSet<URL> set = new TreeSet<>(Comparator.comparing(URL::toString));
+    set.addAll(Collections.list(spockClassLoader.getResources(resourcePath)));
+    try {
+      //Also resolve resources via ContextClassLoader to better support for runtimes like OSGi
+      ClassLoader contextClassLoader = Thread.currentThread().getContextClassLoader();
+      if (contextClassLoader != null && spockClassLoader != contextClassLoader) {
+        set.addAll(Collections.list(contextClassLoader.getResources(resourcePath)));
+      }
+    } catch (SecurityException ignored) {
+    }
+    return set;
+  }
+
   public static boolean isClassAvailable(String className) {
     return loadClassIfAvailable(className) != null;
   }
 
   public static boolean isMethodAvailable(String className, String methodName) {
-    try {
-      Class clazz = ReflectionUtil.class.getClassLoader().loadClass(className);
-      return getMethodByName(clazz, methodName) != null;
-    } catch (ClassNotFoundException e) {
+    Class<?> clazz = loadClassIfAvailable(className);
+    if (clazz == null) {
       return false;
     }
+    return getMethodByName(clazz, methodName) != null;
   }
 
   public static boolean isAnnotationPresent(AnnotatedElement element, String className) {
@@ -71,6 +131,7 @@ public static boolean isAnnotationPresent(AnnotatedElement element, String class
 
     return false;
   }
+
   public static boolean isArray(Object obj) {
     return (obj != null && obj.getClass().isArray());
   }
diff --git a/spock-core/src/main/java/org/spockframework/util/ThreadSupport.java b/spock-core/src/main/java/org/spockframework/util/ThreadSupport.java
new file mode 100644
index 0000000000..36bb0cc917
--- /dev/null
+++ b/spock-core/src/main/java/org/spockframework/util/ThreadSupport.java
@@ -0,0 +1,40 @@
+/*
+ *  Copyright 2024 the original author or authors.
+ *
+ *  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
+ *      https://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.spockframework.util;
+
+import java.lang.reflect.Method;
+
+public class ThreadSupport {
+  private static final @Nullable Class<?> THREAD_OF_VIRTUAL_CLASS = ReflectionUtil.loadClassIfAvailable("java.lang.Thread$Builder$OfVirtual");
+  private static final @Nullable Method OF_VIRTUAL = THREAD_OF_VIRTUAL_CLASS != null ? ReflectionUtil.getMethodByName(Thread.class, "ofVirtual") : null;
+  private static final @Nullable Method THREAD_OF_VIRTUAL_NAME = THREAD_OF_VIRTUAL_CLASS != null ? ReflectionUtil.getMethodBySignature(THREAD_OF_VIRTUAL_CLASS, "name", String.class) : null;
+  private static final @Nullable Method THREAD_OF_VIRTUAL_UNSTARTED = THREAD_OF_VIRTUAL_CLASS != null ? ReflectionUtil.getMethodBySignature(THREAD_OF_VIRTUAL_CLASS, "unstarted", Runnable.class) : null;
+
+  /**
+   * Creates a virtual thread if supported by the current JVM.
+   *
+   * @param name the name of the thread
+   * @param target the target to run on the thread
+   * @return the created thread
+   */
+  public static Thread virtualThreadIfSupported(String name, Runnable target) {
+    if (THREAD_OF_VIRTUAL_CLASS == null) {
+      return new Thread(target, name);
+    }
+    Object builder = ReflectionUtil.invokeMethod(Thread.class, OF_VIRTUAL);
+    ReflectionUtil.invokeMethod(builder, THREAD_OF_VIRTUAL_NAME, name);
+    return (Thread) ReflectionUtil.invokeMethod(builder, THREAD_OF_VIRTUAL_UNSTARTED, target);
+  }
+}
diff --git a/spock-core/src/main/java/org/spockframework/util/TimeUtil.java b/spock-core/src/main/java/org/spockframework/util/TimeUtil.java
index 9a927dc487..8e788b0e2e 100644
--- a/spock-core/src/main/java/org/spockframework/util/TimeUtil.java
+++ b/spock-core/src/main/java/org/spockframework/util/TimeUtil.java
@@ -1,19 +1,20 @@
 /*
- * Copyright 2012 the original author or authors.
+ *  Copyright 2024 the original author or authors.
  *
- * 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
- *     https://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.
+ *  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
+ *      https://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.spockframework.util;
 
+import java.time.Duration;
 import java.util.concurrent.TimeUnit;
 
 public abstract class TimeUtil {
@@ -23,4 +24,8 @@ public static double toSeconds(long value, TimeUnit unit) {
     }
     return value / (double) unit.convert(1, TimeUnit.SECONDS);
   }
+
+  public static double toSeconds(Duration duration) {
+    return duration.toMillis() / 1000d;
+  }
 }
diff --git a/spock-core/src/main/resources/META-INF/services/org.spockframework.runtime.extension.IGlobalExtension b/spock-core/src/main/resources/META-INF/services/org.spockframework.runtime.extension.IGlobalExtension
index 778826130b..86b823c7f4 100644
--- a/spock-core/src/main/resources/META-INF/services/org.spockframework.runtime.extension.IGlobalExtension
+++ b/spock-core/src/main/resources/META-INF/services/org.spockframework.runtime.extension.IGlobalExtension
@@ -1,3 +1,4 @@
+org.spockframework.runtime.extension.builtin.GlobalTimeoutExtension
 org.spockframework.runtime.extension.builtin.IncludeExcludeExtension
 org.spockframework.runtime.extension.builtin.OptimizeRunOrderExtension
 org.spockframework.runtime.extension.builtin.UnrollExtension
diff --git a/spock-specs/SpockTestConfig.groovy b/spock-specs/SpockTestConfig.groovy
index cfa0ebc263..3ccd339282 100644
--- a/spock-specs/SpockTestConfig.groovy
+++ b/spock-specs/SpockTestConfig.groovy
@@ -1,5 +1,14 @@
+import java.time.Duration
+
 runner {
   parallel {
     enabled true
   }
 }
+
+timeout {
+  globalTimeout Duration.ofMinutes(1)
+  applyGlobalTimeoutToFixtures true
+  maxInterruptAttemptsWithThreadDumps 1
+  printThreadDumpsOnInterruptAttempts true
+}
diff --git a/spock-specs/mock-integration/mock-integration.gradle b/spock-specs/mock-integration/mock-integration.gradle
index 11045f4dc1..00f1066784 100644
--- a/spock-specs/mock-integration/mock-integration.gradle
+++ b/spock-specs/mock-integration/mock-integration.gradle
@@ -57,6 +57,8 @@ def configureTaskFilters = { String key, Test t ->
 codeGenerationLibraries.each { key, config ->
   tasks.register("test${key.capitalize()}WithoutObjenesis", Test) {
     systemProperty("org.spockframework.mock.testType", "${key.toLowerCase()} - objenesis")
+    testClassesDirs = testing.suites.test.sources.output.classesDirs
+    classpath = testing.suites.test.sources.runtimeClasspath
     classpath += config
 
     configureTaskFilters(key, it)
@@ -64,6 +66,8 @@ codeGenerationLibraries.each { key, config ->
 
   tasks.register("test${key.capitalize()}WithObjenesis", Test) {
     systemProperty("org.spockframework.mock.testType", "${key.toLowerCase()} + objenesis")
+    testClassesDirs = testing.suites.test.sources.output.classesDirs
+    classpath = testing.suites.test.sources.runtimeClasspath
     classpath += config
     classpath += configurations.objenesis
 
diff --git a/spock-specs/specs.gradle b/spock-specs/specs.gradle
index 898fe4ae04..0111b2fc31 100644
--- a/spock-specs/specs.gradle
+++ b/spock-specs/specs.gradle
@@ -89,7 +89,7 @@ tasks.named("test", Test) {
 }
 
 tasks.register("groovyConsole", JavaExec) {
-  main = variant == 2.5 ? "groovy.ui.Console" : "groovy.console.ui.Console"
+  mainClass = variant == 2.5 ? "groovy.ui.Console" : "groovy.console.ui.Console"
   classpath(sourceSets.named("test").map {it.runtimeClasspath }, configurations.named("groovyConsole"))
 }
 
diff --git a/spock-specs/src/test-java-ge-17/java/org/spockframework/smoke/mock/IEither.java b/spock-specs/src/test-java-ge-17/java/org/spockframework/smoke/mock/IEither.java
new file mode 100644
index 0000000000..2c2213d825
--- /dev/null
+++ b/spock-specs/src/test-java-ge-17/java/org/spockframework/smoke/mock/IEither.java
@@ -0,0 +1,31 @@
+/*
+ *  Copyright 2024 the original author or authors.
+ *
+ *  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
+ *      https://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.spockframework.smoke.mock;
+
+public sealed interface IEither<L, R> {
+  record Left<L, R>(L value) implements IEither<L, R> {
+  }
+
+  record Right<L, R>(R value) implements IEither<L, R> {
+  }
+
+  static <L, R> IEither<L, R> left(L value) {
+    return new Left<>(value);
+  }
+
+  static <L, R> IEither<L, R> right(R value) {
+    return new Right<>(value);
+  }
+}
diff --git a/spock-specs/src/test-java-ge-17/java/org/spockframework/smoke/mock/IMaybe.java b/spock-specs/src/test-java-ge-17/java/org/spockframework/smoke/mock/IMaybe.java
new file mode 100644
index 0000000000..e883c6c963
--- /dev/null
+++ b/spock-specs/src/test-java-ge-17/java/org/spockframework/smoke/mock/IMaybe.java
@@ -0,0 +1,32 @@
+/*
+ *  Copyright 2024 the original author or authors.
+ *
+ *  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
+ *      https://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.spockframework.smoke.mock;
+
+public sealed interface IMaybe<T> {
+
+  record Some<T>(T value) implements IMaybe<T> {
+  }
+
+  record None<T>() implements IMaybe<T> {
+  }
+
+  static <T> IMaybe<T> some(T value) {
+    return new Some<>(value);
+  }
+
+  static <T> IMaybe<T> none() {
+    return new None<>();
+  }
+}
diff --git a/spock-specs/src/test-java-le-11/java/org/spockframework/smoke/mock/IEither.java b/spock-specs/src/test-java-le-11/java/org/spockframework/smoke/mock/IEither.java
new file mode 100644
index 0000000000..c439cd6fcc
--- /dev/null
+++ b/spock-specs/src/test-java-le-11/java/org/spockframework/smoke/mock/IEither.java
@@ -0,0 +1,49 @@
+/*
+ *  Copyright 2024 the original author or authors.
+ *
+ *  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
+ *      https://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.spockframework.smoke.mock;
+
+public interface IEither<L, R> {
+  class Left<L, R> implements IEither<L, R> {
+    private final L value;
+
+    public Left(L value) {
+      this.value = value;
+    }
+
+    public L value() {
+      return value;
+    }
+  }
+
+  class Right<L, R> implements IEither<L, R> {
+    private final R value;
+
+    public Right(R value) {
+      this.value = value;
+    }
+
+    public R value() {
+      return value;
+    }
+  }
+
+  static <L, R> IEither<L, R> left(L value) {
+    return new Left<>(value);
+  }
+
+  static <L, R> IEither<L, R> right(R value) {
+    return new Right<>(value);
+  }
+}
diff --git a/spock-specs/src/test-java-le-11/java/org/spockframework/smoke/mock/IMaybe.java b/spock-specs/src/test-java-le-11/java/org/spockframework/smoke/mock/IMaybe.java
new file mode 100644
index 0000000000..2ca8baad22
--- /dev/null
+++ b/spock-specs/src/test-java-le-11/java/org/spockframework/smoke/mock/IMaybe.java
@@ -0,0 +1,41 @@
+/*
+ *  Copyright 2024 the original author or authors.
+ *
+ *  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
+ *      https://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.spockframework.smoke.mock;
+
+public interface IMaybe<T> {
+
+  class Some<T> implements IMaybe<T> {
+    private final T value;
+
+    Some(T value) {
+      this.value = value;
+    }
+
+    public T getValue() {
+      return value;
+    }
+  }
+
+  class None<T> implements IMaybe<T> {
+  }
+
+  static <T> IMaybe<T> some(T value) {
+    return new Some<>(value);
+  }
+
+  static <T> IMaybe<T> none() {
+    return new None<>();
+  }
+}
diff --git a/spock-specs/src/test/groovy/org/spockframework/docs/timeout/TimeoutConfigurationDoc.groovy b/spock-specs/src/test/groovy/org/spockframework/docs/timeout/TimeoutConfigurationDoc.groovy
index b41ede85fa..131af103d4 100644
--- a/spock-specs/src/test/groovy/org/spockframework/docs/timeout/TimeoutConfigurationDoc.groovy
+++ b/spock-specs/src/test/groovy/org/spockframework/docs/timeout/TimeoutConfigurationDoc.groovy
@@ -13,6 +13,10 @@ class TimeoutConfigurationDoc extends BaseTimeoutExtensionSpecification {
     runner.configurationScript {
       // tag::example[]
       timeout {
+        // java.time.Duration, default null: If set applies global timeout for all features, unless overridden
+        globalTimeout java.time.Duration.ofMinutes(1);
+        // boolean, default false: Determines whether the global timeout will be applied to fixtures
+        applyGlobalTimeoutToFixtures false
         // boolean, default false
         printThreadDumpsOnInterruptAttempts true
         // integer, default 3
diff --git a/spock-specs/src/test/groovy/org/spockframework/mock/runtime/ByteBuddyMockMakerSpec.groovy b/spock-specs/src/test/groovy/org/spockframework/mock/runtime/ByteBuddyMockMakerSpec.groovy
index 6c59a4f007..ae2a75e74b 100644
--- a/spock-specs/src/test/groovy/org/spockframework/mock/runtime/ByteBuddyMockMakerSpec.groovy
+++ b/spock-specs/src/test/groovy/org/spockframework/mock/runtime/ByteBuddyMockMakerSpec.groovy
@@ -16,10 +16,14 @@
 
 package org.spockframework.mock.runtime
 
+import net.bytebuddy.dynamic.loading.MultipleParentClassLoader
 import org.spockframework.mock.CannotCreateMockException
+import spock.lang.Issue
 import spock.lang.Specification
+import spock.lang.Unroll
 import spock.mock.DetachedMockFactory
 import spock.mock.MockMakers
+import spock.util.EmbeddedSpecRunner
 
 import java.lang.reflect.Proxy
 import java.util.concurrent.Callable
@@ -132,7 +136,7 @@ class ByteBuddyMockMakerSpec extends Specification {
 
     when:
     Mock(interfaceClass, mockMaker: MockMakers.byteBuddy)
-    
+
     then:
     CannotCreateMockException ex = thrown()
     ex.message.startsWith("Cannot create mock for interface Interface. byte-buddy: The class Interface is not visible by the classloader")
@@ -150,6 +154,40 @@ class ByteBuddyMockMakerSpec extends Specification {
     CannotCreateMockException ex = thrown()
     ex.message.startsWith("Cannot create mock for interface java.lang.Runnable. byte-buddy: The class AdditionalInterface is not visible by the classloader")
   }
+
+  @Issue("https://github.com/spockframework/spock/issues/2017")
+  def "ByteBuddy Mocks with interfaces that are not visible to the mocked type's classloader"() {
+    given:
+    def testCl1 = new ByteBuddyTestClassLoader()
+    def testCl2 = new ByteBuddyTestClassLoader()
+    testCl1.defineInterface("foo.Bar")
+    testCl2.defineClass("iam.Mocked")
+    def cl = new MultipleParentClassLoader([getClass().classLoader, testCl1, testCl2])
+    def runner = new EmbeddedSpecRunner(cl)
+
+    when: "A type is mocked with an additional interface from a classloader outside the mocked type's parent chain"
+    runner.addClassImport(MockMakers)
+    runner.runFeatureBody("""
+def mock = Mock(iam.Mocked, mockMaker: MockMakers.byteBuddy, additionalInterfaces: [foo.Bar])
+expect:
+true
+""")
+
+    then:
+    noExceptionThrown()
+  }
+
+  @Unroll("For target class #targetClass with additional interfaces #additionalInterfaces, isLocal() == #expected")
+  def "Local mocks are detected correctly"(Class<?> targetClass, Collection<Class<?>> additionalInterfaces, boolean expected) {
+    expect:
+    ByteBuddyMockFactory.isLocalMock(targetClass, additionalInterfaces) == expected
+
+    where:
+    targetClass | additionalInterfaces                                    | expected
+    DataClass   | []                                                      | true
+    DataClass   | [Serializable]                                          | true
+    DataClass   | [new ByteBuddyTestClassLoader().defineInterface("foo")] | false
+  }
 }
 
 @SuppressWarnings('unused')
diff --git a/spock-specs/src/test/groovy/org/spockframework/mock/runtime/ByteBuddyTestClassLoader.java b/spock-specs/src/test/groovy/org/spockframework/mock/runtime/ByteBuddyTestClassLoader.java
index 8f106dad9f..b57a9e004a 100644
--- a/spock-specs/src/test/groovy/org/spockframework/mock/runtime/ByteBuddyTestClassLoader.java
+++ b/spock-specs/src/test/groovy/org/spockframework/mock/runtime/ByteBuddyTestClassLoader.java
@@ -50,7 +50,7 @@ public static ByteBuddyTestClassLoader withInterface(String name) {
   }
 
   /**
-   * Defines an empty interface with the passed {@code node}.
+   * Defines an empty interface with the passed {@code name}.
    *
    * @param name the name of the interface
    * @return the loaded {@code Class}
@@ -64,4 +64,20 @@ public synchronized Class<?> defineInterface(String name) {
       .load(this, loadingStrategy)
       .getLoaded());
   }
+
+  /**
+   * Defines an empty class with the passed {@code name}
+   *
+   * @param name the name of the class
+   * @return the loaded {@link  Class}
+   */
+  public synchronized Class<?> defineClass(String name) {
+    //noinspection resource
+    return cache.computeIfAbsent(name, nameKey -> new ByteBuddy()
+      .subclass(Object.class)
+      .name(nameKey)
+      .make()
+      .load(this, loadingStrategy)
+      .getLoaded());
+  }
 }
diff --git a/spock-specs/src/test/groovy/org/spockframework/runtime/ExtensionClassesLoaderSpec.groovy b/spock-specs/src/test/groovy/org/spockframework/runtime/ExtensionClassesLoaderSpec.groovy
index eff12ef629..7cc2191472 100644
--- a/spock-specs/src/test/groovy/org/spockframework/runtime/ExtensionClassesLoaderSpec.groovy
+++ b/spock-specs/src/test/groovy/org/spockframework/runtime/ExtensionClassesLoaderSpec.groovy
@@ -17,6 +17,7 @@ package org.spockframework.runtime
 
 import org.spockframework.mock.runtime.MockMakerConfiguration
 import org.spockframework.report.log.ReportLogConfiguration
+import org.spockframework.runtime.extension.builtin.GlobalTimeoutExtension
 import org.spockframework.runtime.extension.builtin.IncludeExcludeExtension
 import org.spockframework.runtime.extension.builtin.OptimizeRunOrderExtension
 import org.spockframework.runtime.extension.builtin.SnapshotConfig
@@ -33,7 +34,7 @@ class ExtensionClassesLoaderSpec extends Specification {
     def result = new ExtensionClassesLoader().loadExtensionClassesFromDefaultLocation()
 
     then:
-    result == [IncludeExcludeExtension, OptimizeRunOrderExtension, UnrollExtension]
+    result == [GlobalTimeoutExtension, IncludeExcludeExtension, OptimizeRunOrderExtension, UnrollExtension]
   }
 
   def "loads global ConfigObjects"() {
diff --git a/spock-specs/src/test/groovy/org/spockframework/runtime/StandardStreamsCapturerSpec.groovy b/spock-specs/src/test/groovy/org/spockframework/runtime/StandardStreamsCapturerSpec.groovy
index 295bda80ea..24f7fe999c 100644
--- a/spock-specs/src/test/groovy/org/spockframework/runtime/StandardStreamsCapturerSpec.groovy
+++ b/spock-specs/src/test/groovy/org/spockframework/runtime/StandardStreamsCapturerSpec.groovy
@@ -28,6 +28,7 @@ class StandardStreamsCapturerSpec extends Specification {
   def setup() {
     capturer.addStandardStreamsListener(listener)
     capturer.start()
+    capturer.muteStandardStreams()
   }
 
   def cleanup() {
@@ -60,7 +61,6 @@ class StandardStreamsCapturerSpec extends Specification {
     capturer.addStandardStreamsListener(listener2)
 
     when:
-    capturer.start()
     println("some message")
 
     then:
diff --git a/spock-specs/src/test/groovy/org/spockframework/smoke/extension/GlobalTimeoutExtension.groovy b/spock-specs/src/test/groovy/org/spockframework/smoke/extension/GlobalTimeoutExtension.groovy
new file mode 100644
index 0000000000..cc39e73fd1
--- /dev/null
+++ b/spock-specs/src/test/groovy/org/spockframework/smoke/extension/GlobalTimeoutExtension.groovy
@@ -0,0 +1,192 @@
+package org.spockframework.smoke.extension
+
+
+import spock.timeout.BaseTimeoutExtensionSpecification
+
+import java.time.Duration
+
+import org.spockframework.runtime.SpockTimeoutError
+
+class GlobalTimeoutExtension extends BaseTimeoutExtensionSpecification {
+  def "applies timeout to features"() {
+    given:
+    enableGlobalTimeout()
+
+    when:
+    runner.runFeatureBody("""
+        given: Thread.sleep 99999999999
+        expect: true
+    """)
+
+    then:
+    thrown SpockTimeoutError
+  }
+
+  def "supports inheritance for features"() {
+    given:
+    enableGlobalTimeout()
+
+    when:
+    runner.runWithImports("""
+        abstract class A extends Specification {
+            def "a test"() {
+                given: Thread.sleep 99999999999
+                expect: true
+            }
+        }
+        
+        class B extends A {
+            def "normal test"() {
+                expect: true
+            }
+        }
+    """)
+
+    then:
+    thrown SpockTimeoutError
+  }
+
+  def "applies timeout to fixtures"() {
+    given:
+    enableGlobalTimeout(true)
+
+    when:
+    runner.runSpecBody("""
+        def "$fixtureMethod"() {
+            Thread.sleep 99999999999
+        }
+        
+        def "a test"() {
+            expect: true
+        }
+    """)
+
+    then:
+    thrown SpockTimeoutError
+
+    where:
+    fixtureMethod << ["setupSpec", "setup", "cleanup", "cleanupSpec"]
+  }
+
+  def "supports inheritance for fixtures"() {
+    given:
+    enableGlobalTimeout(true)
+
+    when:
+    runner.runWithImports("""
+        abstract class A extends Specification {
+            def "$fixtureMethod"() {
+                Thread.sleep 99999999999
+            }
+        }
+        
+        class B extends A {
+            def "normal test"() {
+                expect: true
+            }
+        }
+    """)
+
+    then:
+    thrown SpockTimeoutError
+
+    where:
+    fixtureMethod << ["setupSpec", "setup", "cleanup", "cleanupSpec"]
+  }
+
+  def "can be overwritten by feature annotation"() {
+    given:
+    enableGlobalTimeout()
+
+    when:
+    runner.runSpecBody("""
+        @Timeout(value = 10, unit = SECONDS)
+        def "a test"() {
+            given: 
+            
+            Thread.sleep 100
+            expect: true
+        }
+    """)
+
+    then:
+    noExceptionThrown()
+  }
+
+  def "can be overwritten by class-level annotation"() {
+    given:
+    enableGlobalTimeout()
+
+    when:
+    runner.runWithImports("""
+        @Timeout(value = 10, unit = SECONDS)
+        class A extends Specification {
+          def setupSpec() {
+              Thread.sleep 25
+          }
+          
+          def setup() {
+              Thread.sleep 25
+          }
+        
+          def "a test"() {
+              given: 
+              Thread.sleep 25
+              expect: true
+          }
+          
+          def cleanup() {
+              Thread.sleep 25
+          }
+          
+          def cleanupSpec() {
+              Thread.sleep 25
+          }
+        }
+    """)
+
+    then:
+    noExceptionThrown()
+  }
+
+  def "can exclude fixture methods from global timeout"() {
+    given:
+    enableGlobalTimeout(false, Duration.ofMillis(5))
+
+    when:
+    runner.runSpecBody("""
+        def setupSpec() {
+            Thread.sleep 25
+        }
+        
+        def setup() {
+            Thread.sleep 25
+        }
+      
+        def "a test"() {
+            expect: true
+        }
+        
+        def cleanup() {
+            Thread.sleep 25
+        }
+        
+        def cleanupSpec() {
+            Thread.sleep 25
+        }
+    """)
+
+    then:
+    noExceptionThrown()
+  }
+
+  def enableGlobalTimeout(boolean applyToFixtureMethods = false, Duration globalTimeoutDuration = Duration.ofNanos(1)) {
+    runner.configurationScript {
+      timeout {
+        globalTimeout globalTimeoutDuration
+        printThreadDumpsOnInterruptAttempts false
+        applyGlobalTimeoutToFixtures applyToFixtureMethods
+      }
+    }
+  }
+}
diff --git a/spock-specs/src/test/groovy/org/spockframework/smoke/extension/TimeoutExtension.groovy b/spock-specs/src/test/groovy/org/spockframework/smoke/extension/TimeoutExtension.groovy
index 2d55363e3e..1f54029ec0 100644
--- a/spock-specs/src/test/groovy/org/spockframework/smoke/extension/TimeoutExtension.groovy
+++ b/spock-specs/src/test/groovy/org/spockframework/smoke/extension/TimeoutExtension.groovy
@@ -16,6 +16,8 @@
 
 package org.spockframework.smoke.extension
 
+import java.util.concurrent.CountDownLatch
+
 import org.spockframework.runtime.SpockTimeoutError
 import org.spockframework.runtime.extension.builtin.ThreadDumpUtilityType
 import spock.lang.*
@@ -295,6 +297,10 @@ class TimeoutExtension extends BaseTimeoutExtensionSpecification {
   }
 
   @Timeout(1)
+  @IgnoreIf(
+      value = { jvm.java21Compatible },
+      reason = "The TimeoutExtension uses virtual threads if available, which can't be enumerated"
+  )
   def "watcher thread has descriptive name"() {
     def group = Thread.currentThread().threadGroup
     def threads = new Thread[group.activeCount()]
diff --git a/spock-specs/src/test/groovy/org/spockframework/smoke/mock/DefaultValueProvider.groovy b/spock-specs/src/test/groovy/org/spockframework/smoke/mock/DefaultValueProvider.groovy
new file mode 100644
index 0000000000..82f8bb8306
--- /dev/null
+++ b/spock-specs/src/test/groovy/org/spockframework/smoke/mock/DefaultValueProvider.groovy
@@ -0,0 +1,70 @@
+/*
+ *  Copyright 2024 the original author or authors.
+ *
+ *  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
+ *      https://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.spockframework.smoke.mock
+
+import spock.lang.Requires
+import spock.lang.Specification
+
+import org.spockframework.mock.FinalClass
+
+class DefaultValueProvider extends Specification {
+
+  @Requires(
+      value = { jvm.isJava17Compatible() },
+      reason = "Sealed interfaces are only supported in Java 17+"
+  )
+  def "Stub's EmptyOrDummyResponse does not support sealed interfaces by default"() {
+    given:
+    def holder = Stub(StubHolder)
+
+    when:
+    holder.getEither()
+
+    then:
+    IllegalArgumentException e = thrown()
+    e.message == 'org.spockframework.smoke.mock.IEither is a sealed interface'
+  }
+
+  def "Stub's EmptyOrDummyResponse can be extended via IDefaultValueProviderExtension"() {
+    given:
+    def holder = Stub(StubHolder)
+
+    when:
+    def maybe = holder.getMaybe()
+
+    then:
+    maybe instanceof IMaybe.None
+  }
+
+  def "Stub's EmptyOrDummyResponse can be extended via IDefaultValueProviderExtension for final classes"() {
+    given:
+    def holder = Stub(StubHolder)
+
+    when:
+    def finalClass = holder.getFinal()
+
+    then:
+    finalClass instanceof FinalClass
+    finalClass.value == "default"
+  }
+
+  interface StubHolder {
+    IMaybe<String> getMaybe()
+
+    IEither<String, Exception> getEither()
+
+    FinalClass getFinal()
+  }
+}
diff --git a/spock-specs/src/test/groovy/org/spockframework/util/ReflectionUtilSpec.groovy b/spock-specs/src/test/groovy/org/spockframework/util/ReflectionUtilSpec.groovy
index f8fc2d1b81..b85872d301 100644
--- a/spock-specs/src/test/groovy/org/spockframework/util/ReflectionUtilSpec.groovy
+++ b/spock-specs/src/test/groovy/org/spockframework/util/ReflectionUtilSpec.groovy
@@ -20,6 +20,7 @@ import spock.lang.*
 
 import java.lang.annotation.Annotation
 import java.lang.reflect.Method
+import java.util.jar.JarFile
 
 class ReflectionUtilSpec extends Specification {
   def "get package name"() {
@@ -37,6 +38,67 @@ class ReflectionUtilSpec extends Specification {
     ReflectionUtil.loadClassIfAvailable("not.AvailableClass") == null
   }
 
+  def "load class from ContextClassloader"() {
+    given:
+    def oldLoader = Thread.currentThread().getContextClassLoader()
+
+    def className = "test.TestIf"
+    def cl = new ByteBuddyTestClassLoader()
+    cl.defineInterface(className)
+
+    expect:
+    ReflectionUtil.loadClassIfAvailable(className) == null
+
+    when:
+    Thread.currentThread().setContextClassLoader(cl)
+    then:
+    ReflectionUtil.loadClassIfAvailable(className).classLoader == cl
+
+    cleanup:
+    Thread.currentThread().setContextClassLoader(oldLoader)
+  }
+
+  def "getResourcesFromClassLoaders"() {
+    when:
+    def res = ReflectionUtil.getResourcesFromClassLoaders(JarFile.MANIFEST_NAME)
+    then:
+    res.size() >= 1
+  }
+
+  def "getResourcesFromClassLoaders - ContextClassLoader"() {
+    given:
+    def oldLoader = Thread.currentThread().getContextClassLoader()
+
+    def resPath = "TestResourceFileName"
+    def resCl = new ClassLoader() {
+      @Override
+      Enumeration<URL> getResources(String name) throws IOException {
+        if (name == resPath) {
+          def url = new URL("file:/" + resPath)
+          return new Vector([
+            //Check that we filter out duplicates
+            url,
+            url
+          ]).elements()
+        }
+        return super.getResources(name)
+      }
+    }
+
+    expect:
+    ReflectionUtil.getResourcesFromClassLoaders(resPath).isEmpty()
+
+    when:
+    Thread.currentThread().setContextClassLoader(resCl)
+    def res = ReflectionUtil.getResourcesFromClassLoaders(resPath)
+    then:
+    res.size() == 1
+    res[0].toString().contains(resPath)
+
+    cleanup:
+    Thread.currentThread().setContextClassLoader(oldLoader)
+  }
+
   def "check if class exists"() {
     expect:
     ReflectionUtil.isClassAvailable("java.util.List")
diff --git a/spock-specs/src/test/groovy/org/spockframework/util/ThreadSupportSpec.groovy b/spock-specs/src/test/groovy/org/spockframework/util/ThreadSupportSpec.groovy
new file mode 100644
index 0000000000..0af5d6402b
--- /dev/null
+++ b/spock-specs/src/test/groovy/org/spockframework/util/ThreadSupportSpec.groovy
@@ -0,0 +1,29 @@
+package org.spockframework.util
+
+import spock.lang.IgnoreIf
+import spock.lang.Requires
+import spock.lang.Specification
+
+class ThreadSupportSpec extends Specification {
+
+  @Requires({ jvm.java21Compatible })
+  def "creates virtual threads if available"() {
+    when:
+    def thread = ThreadSupport.virtualThreadIfSupported("test", {  })
+
+    then:
+    thread.virtual
+    thread.class != Thread
+    thread.name == "test"
+  }
+
+  @IgnoreIf({ jvm.java21Compatible })
+  def "creates regular threads if not available"() {
+    when:
+    def thread = ThreadSupport.virtualThreadIfSupported("test", {  })
+
+    then:
+    thread.class == Thread
+    thread.name == "test"
+  }
+}
diff --git a/spock-specs/src/test/groovy/spock/util/EmbeddedSpecRunnerClassLoaderSpec.groovy b/spock-specs/src/test/groovy/spock/util/EmbeddedSpecRunnerClassLoaderSpec.groovy
new file mode 100644
index 0000000000..57005de225
--- /dev/null
+++ b/spock-specs/src/test/groovy/spock/util/EmbeddedSpecRunnerClassLoaderSpec.groovy
@@ -0,0 +1,61 @@
+/*
+ * Copyright 2024 the original author or authors.
+ *
+ * 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
+ *
+ *     https://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 spock.util
+
+import org.codehaus.groovy.control.MultipleCompilationErrorsException
+import org.spockframework.mock.runtime.ByteBuddyTestClassLoader
+import spock.lang.Specification
+
+class EmbeddedSpecRunnerClassLoaderSpec extends Specification {
+
+  def "EmbeddedSpecRunner with different ClassLoader"() {
+    given:
+    def cl = new ByteBuddyTestClassLoader()
+    def testInterfaceName = "test.TestIf"
+    cl.defineInterface(testInterfaceName)
+    def runner = new EmbeddedSpecRunner(cl)
+
+    expect:
+    //noinspection GroovyAccessibility
+    !runner.compiler.unwrapCompileException
+
+    when:
+    def result = runner.runFeatureBody("""
+expect:
+${testInterfaceName}.class != null
+""")
+    then:
+    result.testsSucceededCount == 1
+  }
+
+  def "EmbeddedSpecRunner with different ClassLoader - unable to see Spock"() {
+    given:
+    def cl = new URLClassLoader([] as URL[], null as ClassLoader)
+    def runner = new EmbeddedSpecRunner(cl)
+
+    when: "This should fail, because the Specification class is not visible in the ClassLoader"
+    runner.runFeatureBody("""
+expect:
+true
+""")
+    then:
+    def ex = thrown(MultipleCompilationErrorsException)
+    ex.message.contains("unable to resolve class Specification")
+
+    cleanup:
+    cl?.close()
+  }
+}
diff --git a/spock-specs/src/test/groovy/spock/util/time/MutableClockSpec.groovy b/spock-specs/src/test/groovy/spock/util/time/MutableClockSpec.groovy
index 4a46c14d9c..2d3f6f54e8 100644
--- a/spock-specs/src/test/groovy/spock/util/time/MutableClockSpec.groovy
+++ b/spock-specs/src/test/groovy/spock/util/time/MutableClockSpec.groovy
@@ -195,7 +195,7 @@ class MutableClockSpec extends Specification {
     thrown(NullPointerException)
   }
 
-  def "MutableClock can be adjusted with TemporalAdjuster"(TemporalAdjuster adjuster, ZonedDateTime expected) {
+  def "MutableClock can be adjusted with TemporalAdjuster #adjusterName"(TemporalAdjuster adjuster, ZonedDateTime expected) {
     expect:
     mutableClock.instant() == defaultInstant
 
@@ -206,14 +206,14 @@ class MutableClockSpec extends Specification {
     mutableClock.instant() == expected.toInstant()
 
     where:
-    adjuster                            | expected
-    TemporalAdjusters.firstDayOfMonth() | ZonedDateTime.of(2000, 6, 1, 12, 30, 30, 100, UTC)
-    TemporalAdjusters.firstDayOfYear()  | ZonedDateTime.of(2000, 1, 1, 12, 30, 30, 100, UTC)
-    TemporalAdjusters.lastDayOfMonth()  | ZonedDateTime.of(2000, 6, 30, 12, 30, 30, 100, UTC)
-    TemporalAdjusters.lastDayOfYear()   | ZonedDateTime.of(2000, 12, 31, 12, 30, 30, 100, UTC)
+    adjuster                            | adjusterName      | expected
+    TemporalAdjusters.firstDayOfMonth() | "firstDayOfMonth" | ZonedDateTime.of(2000, 6, 1, 12, 30, 30, 100, UTC)
+    TemporalAdjusters.firstDayOfYear()  | "firstDayOfYear"  | ZonedDateTime.of(2000, 1, 1, 12, 30, 30, 100, UTC)
+    TemporalAdjusters.lastDayOfMonth()  | "lastDayOfMonth"  | ZonedDateTime.of(2000, 6, 30, 12, 30, 30, 100, UTC)
+    TemporalAdjusters.lastDayOfYear()   | "lastDayOfYear"   | ZonedDateTime.of(2000, 12, 31, 12, 30, 30, 100, UTC)
   }
 
-  def "MutableClock can be modified with a function"(Closure modification, Instant expected) {
+  def "MutableClock can be modified with a function #description"(Closure modification, Instant expected) {
     expect:
     mutableClock.instant() == defaultInstant
 
@@ -224,8 +224,8 @@ class MutableClockSpec extends Specification {
     mutableClock.instant() == expected
 
     where:
-    _ | modification                                                                                                  | expected
-    _ | { Instant i, ZoneId z -> i.plusSeconds(1) }                                                                   | defaultInstant.plusSeconds(1)
-    _ | { Instant i, ZoneId z -> ZonedDateTime.ofInstant(i, z).with(TemporalAdjusters.firstDayOfYear()).toInstant() } | ZonedDateTime.of(2000, 1, 1, 12, 30, 30, 100, UTC).toInstant()
+    description      | modification                                                                                                  | expected
+    'plusSeconds'    | { Instant i, ZoneId z -> i.plusSeconds(1) }                                                                   | defaultInstant.plusSeconds(1)
+    'firstDayOfYear' | { Instant i, ZoneId z -> ZonedDateTime.ofInstant(i, z).with(TemporalAdjusters.firstDayOfYear()).toInstant() } | ZonedDateTime.of(2000, 1, 1, 12, 30, 30, 100, UTC).toInstant()
   }
 }
diff --git a/spock-specs/src/test/java/org/spockframework/mock/FinalClass.java b/spock-specs/src/test/java/org/spockframework/mock/FinalClass.java
new file mode 100644
index 0000000000..184e06b5f2
--- /dev/null
+++ b/spock-specs/src/test/java/org/spockframework/mock/FinalClass.java
@@ -0,0 +1,27 @@
+/*
+ *  Copyright 2024 the original author or authors.
+ *
+ *  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
+ *      https://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.spockframework.mock;
+
+public final class FinalClass {
+  private final String value;
+
+  public FinalClass(String value) {
+    this.value = value;
+  }
+
+  public String getValue() {
+    return value;
+  }
+}
diff --git a/spock-specs/src/test/java/org/spockframework/mock/FinalClassDefaultValueProvider.java b/spock-specs/src/test/java/org/spockframework/mock/FinalClassDefaultValueProvider.java
new file mode 100644
index 0000000000..0cd817b2e2
--- /dev/null
+++ b/spock-specs/src/test/java/org/spockframework/mock/FinalClassDefaultValueProvider.java
@@ -0,0 +1,29 @@
+/*
+ *  Copyright 2024 the original author or authors.
+ *
+ *  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
+ *      https://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.spockframework.mock;
+
+import java.lang.reflect.Type;
+
+import org.spockframework.runtime.extension.IDefaultValueProviderExtension;
+
+public class FinalClassDefaultValueProvider implements IDefaultValueProviderExtension {
+  @Override
+  public Object provideDefaultValue(Class<?> type, Type exactType) {
+    if (FinalClass.class.equals(type)) {
+      return new FinalClass("default");
+    }
+    return null;
+  }
+}
diff --git a/spock-specs/src/test/java/org/spockframework/smoke/mock/MaybeDefaultValueProvider.java b/spock-specs/src/test/java/org/spockframework/smoke/mock/MaybeDefaultValueProvider.java
new file mode 100644
index 0000000000..482add42d9
--- /dev/null
+++ b/spock-specs/src/test/java/org/spockframework/smoke/mock/MaybeDefaultValueProvider.java
@@ -0,0 +1,32 @@
+/*
+ *  Copyright 2024 the original author or authors.
+ *
+ *  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
+ *      https://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.spockframework.smoke.mock;
+
+import java.lang.reflect.Type;
+
+import org.spockframework.runtime.extension.IDefaultValueProviderExtension;
+import org.spockframework.util.Nullable;
+
+// tag::sample-implementation[]
+public class MaybeDefaultValueProvider implements IDefaultValueProviderExtension {
+  @Override
+  public @Nullable Object provideDefaultValue(Class<?> type, Type exactType) {
+    if (type == IMaybe.class) {
+      return IMaybe.none();
+    }
+    return null;
+  }
+}
+// end::sample-implementation[]
diff --git a/spock-specs/src/test/resources/META-INF/services/org.spockframework.runtime.extension.IDefaultValueProviderExtension b/spock-specs/src/test/resources/META-INF/services/org.spockframework.runtime.extension.IDefaultValueProviderExtension
new file mode 100644
index 0000000000..39f8db431f
--- /dev/null
+++ b/spock-specs/src/test/resources/META-INF/services/org.spockframework.runtime.extension.IDefaultValueProviderExtension
@@ -0,0 +1,2 @@
+org.spockframework.mock.FinalClassDefaultValueProvider
+org.spockframework.smoke.mock.MaybeDefaultValueProvider
diff --git a/spock-spring/src/main/java/org/spockframework/spring/mock/SpockSpringProxy.java b/spock-spring/src/main/java/org/spockframework/spring/mock/SpockSpringProxy.java
deleted file mode 100644
index 3342e53edd..0000000000
--- a/spock-spring/src/main/java/org/spockframework/spring/mock/SpockSpringProxy.java
+++ /dev/null
@@ -1,20 +0,0 @@
-/*
- * Copyright 2017 the original author or authors.
- *
- * 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
- *
- *     https://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.spockframework.spring.mock;
-
-public interface SpockSpringProxy {
-}
diff --git a/spock-spring/src/main/java/org/spockframework/spring/mock/SpockSpringProxyCreator.java b/spock-spring/src/main/java/org/spockframework/spring/mock/SpockSpringProxyCreator.java
index fb184e01fd..7766c94e0a 100644
--- a/spock-spring/src/main/java/org/spockframework/spring/mock/SpockSpringProxyCreator.java
+++ b/spock-spring/src/main/java/org/spockframework/spring/mock/SpockSpringProxyCreator.java
@@ -22,16 +22,16 @@
 
 import java.util.List;
 
+import static java.util.Collections.emptyList;
 import static java.util.Collections.singletonList;
 
 abstract class SpockSpringProxyCreator {
 
   static Object create(FieldInfo fieldInfo) {
-    List<Class<?>> additionalInterfaces = singletonList(SpockSpringProxy.class);
     DelegatingInterceptor delegatingInterceptor = new DelegatingInterceptor(fieldInfo);
     MockCreationSettings settings = MockCreationSettings.settings(
       fieldInfo.getType(),
-      additionalInterfaces,
+      emptyList(),
       delegatingInterceptor,
       SpockSpringProxyCreator.class.getClassLoader(),
       true);
diff --git a/spock-spring/src/test/groovy/org/spockframework/spring/mock/imported/SpringBeanOnTestFieldForExistingBeanWithQualifierIntegrationSpec.groovy b/spock-spring/src/test/groovy/org/spockframework/spring/mock/imported/SpringBeanOnTestFieldForExistingBeanWithQualifierIntegrationSpec.groovy
index 918fb77c3d..04e3602f35 100644
--- a/spock-spring/src/test/groovy/org/spockframework/spring/mock/imported/SpringBeanOnTestFieldForExistingBeanWithQualifierIntegrationSpec.groovy
+++ b/spock-spring/src/test/groovy/org/spockframework/spring/mock/imported/SpringBeanOnTestFieldForExistingBeanWithQualifierIntegrationSpec.groovy
@@ -16,8 +16,9 @@
 
 package org.spockframework.spring.mock.imported
 
+import org.spockframework.mock.MockUtil
 import org.spockframework.spring.SpringBean
-import org.spockframework.spring.mock.SpockSpringProxy
+
 import org.spockframework.spring.mock.imported.example.*
 import spock.lang.Specification
 
@@ -54,12 +55,16 @@ class SpringBeanOnTestFieldForExistingBeanWithQualifierIntegrationSpec extends S
     1 * service.greeting()
   }
 
-  def 'only qualified bean ss replaced'() {
+  def 'only qualified bean is replaced'() {
+    given:
+    def util = new MockUtil()
+
     expect:
-    applicationContext.getBean("service") instanceof SpockSpringProxy
+    util.isMock(applicationContext.getBean("service"))
 
     and:
     ExampleService anotherService = applicationContext.getBean("anotherService", ExampleService)
+    !util.isMock(anotherService)
     anotherService.greeting() == "Another"
   }
 
diff --git a/spock-testkit/testkit.gradle b/spock-testkit/testkit.gradle
index c1f34e97c2..20aaa7d3ae 100644
--- a/spock-testkit/testkit.gradle
+++ b/spock-testkit/testkit.gradle
@@ -34,10 +34,10 @@ tasks.named("test", Test) {
 
 tasks.register("consoleLauncherTest", JavaExec) {
   dependsOn(testClasses)
-  def reportsDir = file("$buildDir/test-results")
+  def reportsDir = layout.buildDirectory.dir("test-results")
   outputs.dir(reportsDir)
   classpath(sourceSets.named("test").map { it.runtimeClasspath })
-  main = "org.junit.platform.console.ConsoleLauncher"
+  mainClass = "org.junit.platform.console.ConsoleLauncher"
 //  jvmArgs "-agentlib:jdwp=transport=dt_socket,server=y,suspend=y,address=5005"
 //  args("--select-class", "spock.testkit.testsources.ExampleTestCase")
   args("--select-class", "spock.testkit.testsources.UnrollTestCase")