* limitations under the License.
 */

package gradlebuild.buildutils.tasks

import org.gradle.api.file.RegularFileProperty
import org.gradle.api.provider.Property
import org.gradle.api.tasks.Internal
import org.gradle.api.tasks.TaskAction
import org.gradle.api.tasks.UntrackedTask
import org.gradle.util.internal.VersionNumber
import org.jetbrains.annotations.VisibleForTesting

/**

  }
}

tasks.withType<KotlinCompile>().configureEach {
  friendPaths.from(friendsApi.incoming.artifactView { }.files)
  friendPaths.from(friendsImplementation.incoming.artifactView { }.files)
  friendPaths.from(friendsTestImplementation.incoming.artifactView { }.files)
}

val resolvableConfigurations = configurations.filter { it.isCanBeResolved }
tasks.register("downloadDependencies") {

        } finally {
            if (task != null) {
                task.cancel();
            }
            if (p != null && p.isAlive()) {
                logger.warn("Process {} is still alive in finally block. Forcing destruction.", p);
                if (task == null) {
                    task = new ProcessDestroyer(p, ist, commandDestroyTimeout);
                }

  private volatile boolean taskDone;

  public void testNoOpScheduledExecutor() throws InterruptedException {
    taskDone = false;
    Runnable task = () -> taskDone = true;
    ScheduledFuture<?> future =
        TestingExecutors.noOpScheduledExecutor().schedule(task, 10, MILLISECONDS);
    Thread.sleep(20);
    assertFalse(taskDone);
    assertFalse(future.isDone());
  }

  private volatile boolean taskDone;

  public void testNoOpScheduledExecutor() throws InterruptedException {
    taskDone = false;
    Runnable task = () -> taskDone = true;
    ScheduledFuture<?> future =
        TestingExecutors.noOpScheduledExecutor().schedule(task, 10, MILLISECONDS);
    Thread.sleep(20);
    assertFalse(taskDone);
    assertFalse(future.isDone());
  }

import org.gradle.api.file.RegularFileProperty
import org.gradle.api.tasks.CacheableTask
import org.gradle.api.tasks.InputDirectory
import org.gradle.api.tasks.InputFile
import org.gradle.api.tasks.OutputFile
import org.gradle.api.tasks.PathSensitive
import org.gradle.api.tasks.PathSensitivity
import org.gradle.api.tasks.TaskAction
import gradlebuild.docs.BuildableDOMCategory
import gradlebuild.docs.DocGenerationException

    id("gradlebuild.module-identity")
    `maven-publish`
    signing
    `java-gradle-plugin`
    id("com.gradle.plugin-publish")
}

extensions.create<PluginPublishExtension>("pluginPublish", gradlePlugin)

tasks.validatePlugins {
    enableStricterValidation = true
}

// Remove gradleApi() and gradleTestKit() as we want to compile/run against Gradle modules

import gradlebuild.basics.capitalize
import gradlebuild.incubation.tasks.IncubatingApiAggregateReportTask

plugins {
    id("base")
}

val reports by configurations.creating {
    isCanBeResolved = false
    isCanBeConsumed = false
    description = "Dependencies to aggregate reports from"
}

val allIncubationReports = tasks.register<IncubatingApiAggregateReportTask>("allIncubationReports") {

    description = "Sanity check for promotion project"

    vcs.useAbsoluteVcs(VersionedSettingsBranch.fromDslContext().gradlePromoteVcsRootId())

    steps {
        gradleWrapper {
            tasks = "tasks"
            gradleParams = ""
        }
    }

    triggers {
        vcs {
            branchFilter = ""
            enabled = VersionedSettingsBranch.fromDslContext().isMainBranch
        }
    }

import org.gradle.api.logging.Logging
import org.gradle.api.services.BuildService
import org.gradle.api.services.BuildServiceParameters
import org.gradle.api.tasks.testing.TestDescriptor
import org.gradle.api.tasks.testing.TestListener
import org.gradle.api.tasks.testing.TestResult
import org.gradle.process.ExecOperations
import org.slf4j.LoggerFactory
import java.util.concurrent.ConcurrentHashMap
import javax.inject.Inject