*
     * @param variantSelector Performs variant selection
     * @param spec Governs how artifacts are selected
     * @param lenient If true, ignore artifacts that are resolved, but unavailable
     */
    SelectedArtifactResults select(ArtifactVariantSelector variantSelector, ArtifactSelectionSpec spec, boolean lenient);

import static org.gradle.kotlin.dsl.resolver.KotlinBuildScriptModelRequestKt.newCorrelationId

class KotlinScriptModelParameters {
    static setModelParameters(modelBuilder, boolean lenient, boolean explicitlyRequestPreparationTasks = true, Iterable<File> scripts = []) {
        if (lenient) {
            modelBuilder.setJvmArguments([KotlinDslModelsParameters.CLASSPATH_MODE_SYSTEM_PROPERTY_DECLARATION])
        } else {

import org.gradle.api.artifacts.dsl.LockMode

class DependencyLockingLenientModeIntegrationTest extends AbstractLockingIntegrationTest {
    @Override
    LockMode lockMode() {
        return LockMode.LENIENT
    }

    def 'does not fail when lock file conflicts with declared strict constraint (initial unique: #unique)'() {
        given:
        mavenRepo.module('org', 'foo', '1.0').publish()

.infoBox p {
    margin: 0;
}

.counter, .percent {
    font-size: 120%;
    font-weight: bold;
    margin-bottom: 8px;
}

#duration {
    width: 125px;
}

#successRate, .summaryGroup {
    border: solid 2px #d0d0d0;
    -moz-border-radius: 10px;
    border-radius: 10px;
}

#successRate {
    width: 140px;
    margin-left: 35px;
}

#successRate .percent {
    font-size: 180%;
}

                        e -> e.getKey().toString(), e -> e.getValue().toString()));
        //        lenient().when(session.getSystemProperties()).thenReturn(map);
        //        lenient().when(session.getUserProperties()).thenReturn(Collections.emptyMap());

        Mockito.lenient()
                .when(session.getService(SettingsXmlFactory.class))
                .thenReturn(new DefaultSettingsXmlFactory());
    }

        return thrashingThreshold;
    }

    public boolean isAboveHeapUsageThreshold(int percent) {
        return heapUsageThreshold != -1 && percent >= heapUsageThreshold;
    }

    public boolean isAboveNonHeapUsageThreshold(int percent) {
        return nonHeapUsageThreshold != -1 && percent >= nonHeapUsageThreshold;
    }

    public boolean isAboveGcRateThreshold(double gcEventsPerSec) {

        selected.getArtifacts().sets == [variant1Artifacts, variant2Artifacts]

        selected.getArtifactsWithId(0) == variant1Artifacts
        selected.getArtifactsWithId(1) == variant2Artifacts
    }

    def "lenient selection includes selected variant of each node"() {
        def artifacts1 = Stub(ArtifactSet)
        def artifacts2 = Stub(ArtifactSet)
        def variant1Artifacts = Stub(ResolvedArtifactSet)

     * percent-encoded in a path.
     *
     * See https://url.spec.whatwg.org/#percent-encoded-bytes
     */
    fun newInstance(): UrlComponentEncodingTester {
      return UrlComponentEncodingTester()
        .allAscii(Encoding.IDENTITY)
        .nonPrintableAscii(Encoding.PERCENT)
        .override(
          Encoding.SKIP,
          '\t'.code,

    def "knows percentage change"() {
        expect:
        percentChange(Amount.valueOf(current, Duration.SECONDS), Amount.valueOf(previous, Duration.SECONDS)) == percent

        where:
        current  | previous | percent
        1        | 1        | 0
        3        | 1        | 200
        1        | 3        | -66.67
        2        | 3        | -33.33
        5        | 4        | 25

    },
    {
      "matchPackageNames": ["gradle"],
      "allowedVersions": "<8.0",
      "description": "Recent release, not compatible with pinned AGP and Kotlin versions yet. Wait for AGP 8?"
    },
    {
      "matchPackageNames": ["com.android.tools.build:gradle"],
      "allowedVersions": "<7.4",
      "description": "Recent release, no compatible Intellij stable release (2023.1)"
    }
  ]