// Less than 16,384 chars, because we index on a 14-bit index in the ranges table.
    assertThat(compactTable.mappings.length).isLessThan(1 shl 14)

    // Confirm the data strings are ASCII.
    for (dataString in listOf<String>(compactTable.sections, compactTable.ranges)) {
      for (codePoint in dataString.codePoints()) {
        assertThat(codePoint and 0x7f).isEqualTo(codePoint)
      }
    }

 * limitations under the License.
 */

package gradlebuild

import org.gradle.api.tasks.testing.Test
import org.gradle.internal.os.OperatingSystem


val propagatedEnvironmentVariables = listOf(
    // Obviously necessary
    "HOME",
    "SHELL",
    "TERM",

    // Otherwise Windows complains "Unrecognized Windows Sockets error: 10106"
    "SystemRoot",
    "OS",

    // For Android tests

                .file(BuildReceipt.buildReceiptFileName)
                .let(providers::fileContents)
                .asText
        }
    }


fun isRunningInstallTask() =
    listOf("install", "installAll")
        .flatMap { listOf(":distributions-full:$it", "distributions-full:$it", it) }
        .any(gradle.startParameter.taskNames::contains)

fun isRunningDocsTestTask() =
    setOf(":docs:docsTest", "docs:docsTest")

                freeCompilerArgs.addAll(useRelease().zip(jvmTarget) { doUseRelease, targetVersion ->
                    if (doUseRelease) {
                        listOf("-Xjdk-release=${targetVersion.target}")
                    } else {
                        listOf()
                    }
                })
            }
        }
    }

    private fun useRelease(): Provider<Boolean> {

  val conscrypt =
    if (includeConscrypt) {
      Security.addProvider(Conscrypt.newProvider())
      conscrypt(ianaSuitesNew)
    } else {
      Client("Conscrypt", "Disabled", null, listOf())
    }

  val clients =
    listOf(
      okhttp,
      chrome80,
      firefox73,
      android9,
      safari12iOS,
      conscrypt,
      currentVm,
      okHttp_3_9,
      okHttp_3_11,
      okHttp_3_13,

    val socketFactory = context.socketFactory

    val sslSocket = socketFactory.createSocket() as SSLSocket
    assertTrue(adapter.matchesSocket(sslSocket))

    adapter.configureTlsExtensions(sslSocket, null, listOf(HTTP_2, HTTP_1_1))
    // not connected
    assertNull(adapter.getSelectedProtocol(sslSocket))
  }

  @Test
  fun testMatchesSupportedAndroidSocketFactory() {
    assumeTrue(adapter is StandardAndroidSocketAdapter)

    val expectedEvents2 =
      mutableListOf<String>().apply {
        add("CallStart")
        if (connectionType != H2) {
          addAll(listOf("ConnectStart", "ConnectEnd"))
        }
        addAll(listOf("ConnectionAcquired", "ConnectionReleased", "CallEnd"))
      }

    assertThat(events2).isEqualTo(expectedEvents2)
  }

  private fun isConnectionEvent(it: CallEvent?) =

    branch: VersionedSettingsBranch,
) : Project({
        val model =
            CIBuildModel(
                projectId = "Check",
                branch = branch,
                buildScanTags = listOf("Check"),
                subprojects = JsonBasedGradleSubprojectProvider(File("./subprojects.json")),
            )
        val gradleBuildBucketProvider = DefaultFunctionalTestBucketProvider(model, File("./test-buckets.json"))

            functionalTestExtraParameters(
                listOf("RerunFlakyTest"),
                os,
                arch,
                "%$testJvmVersionParameter%",
                "%$testJvmVendorParameter%",
            )
        val parameters =
            (
                buildToolGradleParameters() +
                    listOf(extraParameters) +
                    functionalTestParameters(os, arch)

  }

  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
  }
}

dependencies {