@Suppress("ktlint:standard:property-naming")
class InetAddressOrderTest {
  val ipv4_10_0_0_6 = Inet4Address.getByName("10.0.0.6")
  val ipv4_10_0_0_1 = Inet4Address.getByName("10.0.0.1")
  val ipv4_10_0_0_4 = Inet4Address.getByName("10.0.0.4")
  val ipv6_ab = Inet6Address.getByName("::ac")
  val ipv6_fc = Inet6Address.getByName("::fc")

  @Test fun prioritiseIpv6Example() {
    val result =
      reorderForHappyEyeballs(
        listOf(

  bndProperties: Array<out String>,
) {
  val osgi = project.sourceSets.create("osgi")
  val osgiApi = project.configurations.getByName(osgiApiConfigurationName)

  project.dependencies {
    osgiApi(kotlinOsgi)
  }

  val jarTask = tasks.getByName<Jar>(jarTaskName)
  val bundleExtension =
    jarTask.extensions.findByType() ?: jarTask.extensions.create(
      BundleTaskExtension.NAME,

          (
            "00008180000100010000000006676f6f676c6503636f6d0000010001c00c0001000100000043" +
              "0004d83ad54e"
          ).decodeHex(),
      )
    assertThat(encoded).containsExactly(InetAddress.getByName("216.58.213.78"))
  }

  @Test
  fun testGoogleDotComDecodingFromGoogle() {
    val decoded =
      decodeAnswers(
        hostname = "test.com",
        byteString =
          (

        getByName("${prefix}TestRuntimeClasspath") {
            if (platformImplementation != null) {
                extendsFrom(platformImplementation)
            }
        }
        if (platformImplementation != null) {
            getByName("${prefix}TestCompileClasspath") {
                extendsFrom(getByName("platformImplementation"))
            }
        }

  val dns = DnsOverHttps.Builder().client(bootstrapClient)
    .url("https://dns.google/dns-query".toHttpUrl())
    .bootstrapDnsHosts(InetAddress.getByName("8.8.4.4"), InetAddress.getByName("8.8.8.8"))
    .build()

  val client = bootstrapClient.newBuilder().dns(dns).build()
```

  }

  kotlinOptions {
    jvmTarget = JavaVersion.VERSION_11.toString()
  }

  buildTypes {
    release {
      isShrinkResources = true
      isMinifyEnabled = true
      signingConfig = signingConfigs.getByName("debug")
      setProguardFiles(listOf(getDefaultProguardFile("proguard-android.txt"), "proguard-rules.pro"))
      testProguardFiles("test-proguard-rules.pro")
    }
  }

  lint {
    abortOnError = true
  }

          when {
            domainName.equals(HOSTNAME_THAT_ONLY_THE_PROXY_KNOWS, ignoreCase = true) -> {
              InetAddress.getByName("localhost")
            }
            else -> InetAddress.getByName(domainName)
          }
        }

        else -> throw ProtocolException("unsupported address type: $addressType")
      }

  configure<MultiReleaseExtension> {
    targetVersions(defaultVersion, javaModuleVersion)
  }

  tasks.named<JavaCompile>("compileJava9Java").configure {
    val compileKotlinTask = tasks.getByName("compileKotlin") as KotlinJvmCompile
    dependsOn(compileKotlinTask)

    if (enableValidation) {
      compileKotlinTask.source(file("src/main/java9"))
    }

  private var eventRecorder = EventRecorder()

  private val handshakeCertificates = platform.localhostHandshakeCertificates()

  val dns = FakeDns()

  val ipv4 = InetAddress.getByName("203.0.113.1")
  val ipv6 = InetAddress.getByName("2001:db8:ffff:ffff:ffff:ffff:ffff:1")

  val refusedStream =
    MockResponse
      .Builder()
      .onRequestStart(CloseStream(ErrorCode.REFUSED_STREAM.httpCode))
      .build()

    val httpUrl = "https://www.google.co.uk".toHttpUrl()
    assertThat(httpUrl.topPrivateDomain()).isEqualTo("google.co.uk")
  }

  private fun assumeNetwork() {
    try {
      InetAddress.getByName("www.google.com")
    } catch (uhe: UnknownHostException) {
      throw AssumptionViolatedException(uhe.message, uhe)
    }
  }