* limitations under the License.
 */
package org.gradle.util

import org.gradle.test.fixtures.ConcurrentTestUtil
import org.junit.Rule
import spock.lang.Specification

class ConcurrentSpecification extends Specification {
    @Rule @Delegate ConcurrentTestUtil concurrent = new ConcurrentTestUtil()

import org.gradle.launcher.daemon.protocol.Cancel
import org.gradle.internal.dispatch.Dispatch
import org.gradle.util.ConcurrentSpecification

import java.util.concurrent.LinkedBlockingQueue
import java.util.concurrent.TimeUnit

class DaemonCancelForwarderTest extends ConcurrentSpecification {

    def cancellationToken = new DefaultBuildCancellationToken()

    def received = new LinkedBlockingQueue()

 */

package org.gradle.cache.internal

import org.gradle.util.ConcurrentSpecification
import spock.lang.Subject

import java.util.concurrent.atomic.AtomicInteger

import static org.gradle.test.fixtures.ConcurrentTestUtil.poll

class DefaultFileLockManagerAwaitableFileLockReleasedSignalTest extends ConcurrentSpecification {

    @Subject def signal = new DefaultFileLockManager.AwaitableFileLockReleasedSignal()

 * limitations under the License.
 */

package org.gradle.cache.internal.cacheops

import org.gradle.util.ConcurrentSpecification

class CacheAccessOperationsStackTest extends ConcurrentSpecification {

    def stack = new CacheAccessOperationsStack()

    def "maintains operations per thread #count"() {
        expect:
        start {

package org.gradle.cache.internal.locklistener

import org.gradle.internal.remote.internal.inet.InetAddressFactory
import org.gradle.util.ConcurrentSpecification

import static org.gradle.test.fixtures.ConcurrentTestUtil.poll

class FileLockCommunicatorTest extends ConcurrentSpecification {

    def addressFactory = new InetAddressFactory()
    def communicator = new FileLockCommunicator(new InetAddressProvider() {
        @Override

 */

package org.gradle.internal.resource.transport.http

import org.gradle.internal.resource.ExternalResourceName
import org.gradle.util.ConcurrentSpecification
import spock.lang.Issue

class HttpResourceAccessorIntegrationTest extends ConcurrentSpecification {
    def uri = new URI("http://somewhere")
    def name = new ExternalResourceName(uri)

    @Issue("GRADLE-3574")

import org.gradle.launcher.daemon.protocol.Stop
import org.gradle.launcher.daemon.protocol.StopWhenIdle
import org.gradle.launcher.daemon.protocol.Success
import org.gradle.util.ConcurrentSpecification

class DaemonStopClientTest extends ConcurrentSpecification {
    final DaemonConnector connector = Mock()
    final DaemonClientConnection connection = Mock()
    final def idGenerator = new UUIDGenerator()

    implementation(libs.asm)
    implementation(libs.slf4jApi)
    implementation(project(":stdlib-java-extensions"))

    testImplementation(testFixtures(project(":core"))) {
        because("ConcurrentSpecification")
    }
    testImplementation(project(":tooling-api")) {
        because("Unit tests verify serialization works with TAPI types")
    }
    testImplementation(testFixtures(project(":daemon-protocol")))

import org.gradle.launcher.daemon.protocol.UserResponse
import org.gradle.util.ConcurrentSpecification

import java.util.concurrent.LinkedBlockingQueue
import java.util.concurrent.TimeUnit

import static org.gradle.util.internal.TextUtil.toPlatformLineSeparators

class DaemonClientInputForwarderTest extends ConcurrentSpecification {
    def source = new PipedOutputStream()
    def inputStream = new PipedInputStream(source)

import org.gradle.internal.remote.internal.inet.InetAddressFactory
import org.gradle.util.ConcurrentSpecification

import java.util.concurrent.atomic.AtomicBoolean

import static org.gradle.test.fixtures.ConcurrentTestUtil.poll

class DefaultFileLockContentionHandlerTest extends ConcurrentSpecification {
    def addressFactory = new InetAddressFactory()
    def addressProvider = new InetAddressProvider() {