val certificatePinner =
      CertificatePinner
        .Builder()
        .add("EXAMPLE.com", certA1Sha256Pin)
        .add("*.MyExample.Com", certB1Sha256Pin)
        .build()

    val expectedPin1 = listOf(Pin("EXAMPLE.com", certA1Sha256Pin))
    assertThat(certificatePinner.findMatchingPins("example.com")).isEqualTo(expectedPin1)

    if (limit == -1L && source.exhausted()) return END_OF_DATA

    // Read the tag.
    val tagAndClass = source.readByte().toInt() and 0xff
    val tagClass = tagAndClass and 0b1100_0000
    val constructed = (tagAndClass and 0b0010_0000) == 0b0010_0000
    val tag =
      when (val tag0 = tagAndClass and 0b0001_1111) {
        0b0001_1111 -> readVariableLengthLong()
        else -> tag0.toLong()
      }

  /** The request to send on the network, or null if this call doesn't use the network. */
  val networkRequest: Request?,
  /** The cached response to return or validate; or null if this call doesn't use a cache. */
  val cacheResponse: Response?,
) {
  class Factory(
    private val nowMillis: Long,
    internal val request: Request,
    private val cacheResponse: Response?,
  ) {

import okhttp3.RequestBody.Companion.toRequestBody

class PostString {
  private val client = OkHttpClient()

  fun run() {
    val postBody =
      """
      |Releases
      |--------
      |
      | * _1.0_ May 6, 2013
      | * _1.1_ June 15, 2013
      | * _1.2_ August 11, 2013
      |
      """.trimMargin()

    val request =
      Request(
        url = "https://api.github.com/markdown/raw".toHttpUrl(),

		k := strings.TrimSpace(strings.ToUpper(values[0]))
		if len(values) >= 2 {
			val := strings.Join(values[1:], ":")
			val = strings.ReplaceAll(val, `\"`, `"`)
			settings[k] = val
		} else if k != "" {
			settings[k] = k
		}
	}

	return settings
}

func toColumns(val string) (results []string) {
	if val != "" {
		for _, v := range strings.Split(val, ",") {
			results = append(results, strings.TrimSpace(v))
		}
	}

                    ]
                }
            """.trimIndent()
        )

        val initialVerifyResult = run(":verifyAcceptedApiChangesOrdering").buildAndFail()
        assertEquals(TaskOutcome.FAILED, initialVerifyResult.task(":verifyAcceptedApiChangesOrdering")!!.outcome)

        val sortingResult = run(":sortAcceptedApiChanges").build()

import okhttp3.OkHttpClient
import okhttp3.Request

class PerCallSettings {
  private val client = OkHttpClient()

  fun run() {
    val request =
      Request
        .Builder()
        .url("http://httpbin.org/delay/1") // This URL is served with a 1 second delay.
        .build()

    // Copy to customize OkHttp for this request.
    val client1 =
      client
        .newBuilder()

internal class IdnaMappingTable internal constructor(
  val sections: String,
  val ranges: String,
  val mappings: String,
) {
  /**
   * Returns true if the [codePoint] was applied successfully. Returns false if it was disallowed.
   */
  fun map(
    codePoint: Int,
    sink: BufferedSink,
  ): Boolean {
    val sectionsIndex = findSectionsIndex(codePoint)

    val rangesPosition = sections.read14BitInt(sectionsIndex + 2)

@Suppress("UnusedPrivateProperty")
internal
fun Project.createGenerateAutoTestedSamplesTestTask(sourceSet: SourceSet, testType: TestType) {
    val prefix = testType.prefix
    val sourceSets = the<SourceSetContainer>()
    val main by sourceSets.getting
    val sourceSet = sourceSets.getByName("${prefix}Test")

    val groovySourceDir = sourceSet.extensions.findByType<GroovySourceDirectorySet>()

import okio.Path
import okio.Sink

class FaultyFileSystem constructor(
  delegate: FileSystem?,
) : ForwardingFileSystem(delegate!!) {
  private val writeFaults: MutableSet<Path> = LinkedHashSet()
  private val deleteFaults: MutableSet<Path> = LinkedHashSet()
  private val renameFaults: MutableSet<Path> = LinkedHashSet()

  fun setFaultyWrite(
    file: Path,
    faulty: Boolean,
  ) {
    if (faulty) {