*/

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"() {

    MavenFileModule module = mavenRepo.module("org.gradle.test", "publishTest", "1.9")
    MavenJavaModule javaLibrary = javaLibrary(module, features(), withDocs())

    abstract boolean withDocs()

    abstract List<String> features()

    def "can publish java-library with no dependencies"() {
        createBuildScripts("""
            publishing {
                publications {

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 {

        def projectLock = workerLeaseService.getProjectLock(path("build"), path("project"))

        expect:
        workerLeaseService.withLocks([projectLock]) {
            assert !lockIsHeld(taskLease)
            assert lockIsHeld(projectLock)
            workerLeaseService.withLocks([taskLease]) {
                assert lockIsHeld(taskLease)
                assert lockIsHeld(projectLock)
            }

      writerQueue.schedule("$connectionName ping", pingIntervalNanos) {
        val failDueToMissingPong =
          this.withLock {
            if (intervalPongsReceived < intervalPingsSent) {
              return@withLock true
            } else {
              intervalPingsSent++
              return@withLock false
            }
          }
        if (failDueToMissingPong) {
          failConnection(null)

    }
  }

  @Throws(IOException::class)
  fun flush() {
    this.withLock {
      if (closed) throw IOException("closed")
      sink.flush()
    }
  }

  @Throws(IOException::class)
  fun rstStream(
    streamId: Int,
    errorCode: ErrorCode,
  ) {
    this.withLock {
      if (closed) throw IOException("closed")
      require(errorCode.httpCode != -1)