if (cached != null
                // if the POM has no file, we cached a missing artifact, only return the cached data if no update forced
                && (!request.isForceUpdate() || hasFile(cached.getPomArtifact()))) {
            return cached;
        }

        List<Dependency> dependencies;

        List<Dependency> managedDependencies = null;

    assertThat(eventRecorder.recordedEventTypes().filter { it == ConnectStart::class }).hasSize(2)
    assertThat(eventRecorder.recordedEventTypes().filter { it == ConnectFailed::class }).hasSize(1)
    assertThat(eventRecorder.recordedEventTypes().filter { it == ConnectEnd::class }).hasSize(1)
  }

  @Test
  fun reachesIpv6WhenIpv4IsDown() {
    serverIpv4.close()
    serverIpv6.enqueue(

    }

    private
    fun generateSubprojectsDirectories(): List<File> {
        val subprojectRoots = platformsFolder.asFile.listFiles(File::isDirectory)
            .plus(subprojectsFolder.asFile)
            .plus(testingFolder.asFile)
            .plus(packingFolder.asFile)

        return subprojectRoots.map { it.listFiles(File::isDirectory).asList() }.flatten()
    }

    private

    is ValidatePlugins -> listOf(outputFile.get().asFile)
    is FindBrokenInternalLinks -> listOf(reportFile.get().asFile)
    is DistributionTest -> listOf(
        gradleInstallationForTest.gradleUserHomeDir.dir("test-kit-daemon").get().asFile,
        gradleInstallationForTest.gradleUserHomeDir.dir("kotlin-compiler-daemon").get().asFile,
        gradleInstallationForTest.daemonRegistry.get().asFile
    )
    else -> emptyList()
}

        ruleManager.addRule(rule1);
        ruleManager.addRule(rule2);
        ruleManager.addRule(rule3);

        assertTrue(ruleManager.hasRule(rule1));
        assertTrue(ruleManager.hasRule(rule2));
        assertTrue(ruleManager.hasRule(rule3));
        assertEquals(3, ruleManager.getRuleCount());
    }

    /**
     * Test adding null rule
     */
    public void test_addRule_null() {

        generateHtmlReport(byCategory)
        LOGGER.lifecycle("Generated incubating html report report to file://${parameters.htmlReportFile.get().asFile.absolutePath}")

        generateCsvReport(byCategory)
        LOGGER.lifecycle("Generated incubating csv report to file://${parameters.csvReportFile.get().asFile.absolutePath}")
    }

    private
    fun toCategory(version: String, gradleModule: String) = when {

      new EqualsTester()
          .addEqualityGroup(cache.asMap().keySet(), keys)
          .addEqualityGroup(ImmutableSet.of())
          .testEquals();
      assertThat(keys).hasSize(WARMUP_SIZE);
      for (int i = WARMUP_MIN; i < WARMUP_MAX; i++) {
        Object key = warmed.get(i - WARMUP_MIN).getKey();
        assertThat(keys.contains(key)).isTrue();
        assertThat(keys.remove(key)).isTrue();

import android.os.StrictMode
import android.os.StrictMode.ThreadPolicy
import android.os.strictmode.Violation
import androidx.test.filters.SdkSuppress
import assertk.assertThat
import assertk.assertions.hasSize
import assertk.assertions.isEmpty
import assertk.assertions.isEqualTo
import okhttp3.HttpUrl.Companion.toHttpUrl
import okhttp3.OkHttpClient
import okhttp3.Request
import okhttp3.internal.platform.Platform

    /*
     * TODO: cpovirk - Pre-size the HashMap based on the number of enum values? (But *not* based on
     * the number of entries in the map, as that makes it easy for hostile inputs to trigger lots of
     * allocation—not that any program should be deserializing hostile inputs to begin with!)
     */
    setDelegates(new EnumMap<>(keyTypeOrObjectUnderJ2cl), new HashMap<>());
    Serialization.populateMap(this, stream);
  }

        project,
        apiChangesJsonDirectory,
        apiSourceFolders,
        baseVersion.get(),
        mainApiChangesJsonFile.asFile,
        project.isolated.rootProject.projectDirectory,
        currentUpgradedPropertiesFile.get().asFile,
        baselineUpgradedPropertiesFile.get().asFile,
        {
            it.includedClasses = toPatterns(PublicApi.includes + PublicKotlinDslApi.includes)