*/

package org.gradle.api.publish.maven

import org.gradle.test.fixtures.maven.MavenJavaModule

class MavenPublishJavaWithDocsIntegTest extends AbstractMavenPublishJavaIntegTest {

    boolean withDocs() {
        true
    }

    List<String> features() {
        [MavenJavaModule.MAIN_FEATURE]
    }

 */

package org.gradle.api.publish.maven

import org.gradle.test.fixtures.maven.MavenJavaModule

class MavenPublishJavaWithFeaturesIntegTest extends AbstractMavenPublishJavaIntegTest {

    boolean withDocs() {
        false
    }

    List<String> features() {
        [MavenJavaModule.MAIN_FEATURE, "feature2", "feature3"]
    }

import org.gradle.test.fixtures.archive.ZipTestFixture
import org.gradle.test.fixtures.maven.MavenJavaModule

class MavenPublishJavaWithDocsAndFeaturesIntegTest extends AbstractMavenPublishJavaIntegTest {

    boolean withDocs() {
        true
    }

    List<String> features() {
        [MavenJavaModule.MAIN_FEATURE, "feature2", "feature3"]
    }

    def "creates separate javadoc artifacts for the features"() {

import org.gradle.api.publish.maven.internal.publication.MavenComponentParser
import org.gradle.test.fixtures.maven.MavenJavaModule

class MavenPublishJavaIntegTest extends AbstractMavenPublishJavaIntegTest {

    boolean withDocs() {
        false
    }

    List<String> features() {
        [MavenJavaModule.MAIN_FEATURE]
    }

        action.run()
    }

    @Override
    Synchronizer newResource() {
        return new Synchronizer() {
            @Override
            void withLock(Runnable action) {
                action.run()
            }

            @Override
            <T> T withLock(Factory<T> action) {
                return action.create()
            }
        }
    }

    @Override
    boolean isWorkerThread() {

    return lock.withLock(action)
  }

  inline fun <T> Http2Connection.withLock(action: () -> T): T {
    contract { callsInPlace(action, InvocationKind.EXACTLY_ONCE) }
    return lock.withLock(action)
  }

  inline fun <T> Http2Stream.withLock(action: () -> T): T {
    contract { callsInPlace(action, InvocationKind.EXACTLY_ONCE) }
    return lock.withLock(action)
  }

  inline fun <T> Http2Writer.withLock(action: () -> T): T {

   */
  var idleCallback: Runnable? = null
    get() = this.withLock { field }
    set(value) {
      this.withLock { field = value }
    }

  private var executorServiceOrNull: ExecutorService? = null

  @get:JvmName("executorService")
  val executorService: ExecutorService
    get() =
      this.withLock {
        if (executorServiceOrNull == null) {
          executorServiceOrNull =

    def workerLeaseService = workerLeaseService(1)

    def "can use withLocks to execute a runnable with resources locked"() {
        boolean executed = false
        def lock1 = resourceLock("lock1", false)
        def lock2 = resourceLock("lock1", false)

        when:
        workerLeaseService.withLocks([lock1, lock2], runnable {
            assert lock1.lockedState
            assert lock2.lockedState

import org.gradle.kotlin.dsl.concurrent.pollTimeoutMillis

import java.util.*
import java.util.concurrent.TimeUnit
import java.util.concurrent.locks.ReentrantLock

import kotlin.concurrent.withLock


/**
 * A queue that gives priority to the most recently pushed element.
 */
internal
class ConcurrentGroupingQueue<T>(

    /**

    ) {
        for (registrar in registrars) {
            if (lock.readLock().withLock { application.isRegistrarRegistered(registrar) }) {
                continue
            }

            lock.writeLock().withLock {
                if (application.isRegistrarRegistered(registrar)) return@withLock
                registrar.register()
                application.serviceRegistered[registrar::class] = true