@Test
    @DisplayName("Mockito mock of WinError")
    void mockInterfaceNoOps() {
        WinError mock = Mockito.mock(WinError.class);
        assertNotNull(mock);
        assertTrue(Mockito.mockingDetails(mock).isMock(), "Object should be a Mockito mock");
        Mockito.verifyNoInteractions(mock);
    }

tasks.withType<GroovyCompile>().configureEach {
    groovyOptions.apply {
        encoding = "utf-8"
        forkOptions.jvmArgs?.add("-XX:+HeapDumpOnOutOfMemoryError")
    }
    options.apply {
        isFork = true
        encoding = "utf-8"
        compilerArgs = mutableListOf("-Xlint:-options", "-Xlint:-path")
    }
}

tasks.withType<Test>().configureEach {
    val testVersionProvider = javaLauncher.map { it.metadata.languageVersion }

	nsMutex := nsLockMap{
		isDistErasure: isDistErasure,
	}
	if isDistErasure {
		return &nsMutex
	}
	nsMutex.lockMap = make(map[string]*nsLock)
	return &nsMutex
}

// nsLock - provides primitives for locking critical namespace regions.
type nsLock struct {
	ref int32
	*lsync.LRWMutex
}

// nsLockMap - namespace lock map, provides primitives to Lock,
// Unlock, RLock and RUnlock.

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package gradlebuild.binarycompatibility

import spock.lang.Specification
import spock.lang.Subject
import spock.lang.TempDir

class AcceptedApiChangesJsonFileManagerTest extends Specification {

    @TempDir
    File temporaryFolder

}


fun Test.includeSpockAnnotation(fqcn: String) {
    systemProperties.compute("include.spock.annotation") { _, oldValue ->
        if (oldValue == null) fqcn else "$oldValue,$fqcn"
    }
}


fun Test.excludeSpockAnnotation(fqcn: String) {
    systemProperties.compute("exclude.spock.annotation") { _, oldValue ->
        if (oldValue == null) fqcn else "$oldValue,$fqcn"
    }

 */

package gradlebuild.binarycompatibility.rules

import japicmp.model.JApiClass
import javassist.ClassPool
import me.champeau.gradle.japicmp.report.ViolationCheckContext
import spock.lang.Specification
import spock.lang.TempDir

abstract class AbstractContextAwareRuleSpecification extends Specification {
    @TempDir
    File testDir

    ViolationCheckContext context = new ViolationCheckContext() {

 * limitations under the License.
 */

package gradlebuild.buildutils.tasks

import gradlebuild.buildutils.model.ReleasedVersion
import spock.lang.Specification
import spock.lang.TempDir

class PreparePatchReleaseIntegrationTest extends Specification {

    @TempDir
    File tmpDir

    def "version file is bumped and previous version is added to released versions"() {

 * limitations under the License.
 */

package gradlebuild.buildutils.tasks

import gradlebuild.buildutils.model.ReleasedVersion
import spock.lang.Specification
import spock.lang.TempDir

import java.text.SimpleDateFormat

class UpdateReleasedVersionsIntegrationTest extends Specification {

    def format = new SimpleDateFormat('yyyyMMddHHmmssZ')

    @TempDir

package org.elasticsearch.gradle.internal

import org.elasticsearch.gradle.Architecture
import org.elasticsearch.gradle.fixtures.AbstractGitAwareGradleFuncTest
import org.gradle.testkit.runner.TaskOutcome
import spock.lang.IgnoreIf
import spock.lang.Unroll

/*
 * Test is ignored on ARM since this test case tests the ability to build certain older BWC branches that we don't support on ARM
 */

		return
	}

	nsLock := objectAPI.NewNSLock(minioMetaBucket, "site-net-perf")
	lkctx, err := nsLock.GetLock(ctx, globalOperationTimeout)
	if err != nil {
		writeErrorResponseJSON(ctx, w, errorCodes.ToAPIErr(toAPIErrorCode(ctx, err)), r.URL)
		return
	}
	ctx = lkctx.Context()
	defer nsLock.Unlock(lkctx)

	durationStr := r.Form.Get(peerRESTDuration)