if (buildCacheEnabled()) {
    registerBuildScanInfoCollectingService(CacheMissMonitorBuildService::class.java, ::isCacheMissMonitoredTask) { gradleRootProject, cacheMissInBuildLogic, cacheMissInMainBuild ->
        gradleRootProject.extensions.findByType<BuildScanConfiguration>()?.run {
            buildFinished {
                if ((cacheMissInBuildLogic as AtomicBoolean).get() || (cacheMissInMainBuild as AtomicBoolean).get()) {
                    tag("CACHE_MISS")

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package gradlebuild.jvm.extension

import org.gradle.api.tasks.TaskContainer
import org.gradle.api.tasks.compile.JavaCompile
import org.gradle.kotlin.dsl.*


/**
 * Strict compilation options honored by [gradlebuild.Strict_compile_gradle].

        because("Required by IncubatingApiReportTask")
    }
    implementation("com.gradle:develocity-gradle-plugin") {
        because("Arch-test plugin configures the PTS extension")
    }

    testImplementation("org.junit.jupiter:junit-jupiter-engine")
    testImplementation("org.apache.commons:commons-lang3")

 * <h3>Apply All Upgrades</h3>
 * <pre>{@code
 * mvnup apply --all
 * }</pre>
 *
 * <h3>Upgrade to Maven 4.1.0 with Inference</h3>
 * <pre>{@code
 * mvnup apply --model 4.1.0 --infer
 * }</pre>
 *
 * <h2>Extension Points</h2>
 *
 * <p>To add new upgrade strategies:</p>
 * <ol>
 *   <li>Implement {@link org.apache.maven.cling.invoker.mvnup.goals.UpgradeStrategy}</li>

package okhttp3

import assertk.assertThat
import assertk.assertions.isEqualTo
import assertk.assertions.isNull
import okhttp3.HttpUrl.Companion.toHttpUrl
import org.junit.jupiter.api.Test
import org.junit.jupiter.api.extension.RegisterExtension

class CallTagsTest {
  @JvmField @RegisterExtension
  val clientTestRule = OkHttpClientTestRule()

  private var client = clientTestRule.newClient()

  @Test
  fun tagsSeededFromRequest() {

import gradlebuild.basics.tasks.ClasspathManifest
import gradlebuild.identity.extension.GradleModuleExtension
import java.util.jar.Attributes

plugins {
    id("gradlebuild.module-identity")
}

val gradleModule = the<GradleModuleExtension>()

configureJarTasks()

pluginManager.withPlugin("java-base") {
    configureClasspathManifestGeneration()
}

fun configureJarTasks() {
    tasks.withType<Jar>().configureEach {

        return plugins.keySet();
    }

    /**
     * Performs a lookup using Plexus API to make sure we can look up only "visible" (see Maven classloading) components
     * from current module and for example not extensions coming from other modules.
     */
    private LifecycleMapping lookupLifecycleMapping(final String packaging) {
        return lookup.lookupOptional(LifecycleMapping.class, packaging).orElse(null);
    }

 -----
 Introduction
 -----
 Hervé Boutemy
 -----
 2012-09-29
 -----

Maven Artifact Resolver Provider

 Maven Artifact Resolver Provider is a {{{/resolver/}Maven Artifact Resolver}} extension to support
 Maven POMs and local+remote repositories.

 Main component is <<<MavenRepositorySystemUtils>>>
 ({{{./apidocs/org/apache/maven/repository/internal/MavenRepositorySystemUtils.html}javadoc}},

            Versioning versioning, String extension, Date timestamp, String version, int buildNumber) {
        Snapshot snapshot = new Snapshot();
        snapshot.setBuildNumber(buildNumber);
        snapshot.setTimestamp(formatDate(timestamp, true));

        SnapshotVersion sv = new SnapshotVersion();
        sv.setExtension(extension);
        sv.setVersion(version);

        // however, SISU visibility filtering can only happen when an explicit
        // lookup is performed. The whole problem here is caused by "project extensions"
        // which are bound to a project's classloader, without any clear definition
        // of a "project scope"
        LifecycleMapping lifecycleMapping =