}
    }
  }
  return result.toTypedArray()
}

/**
 * Returns true if there is an element in this array that is also in [other]. This method terminates
 * if any intersection is found. The sizes of both arguments are assumed to be so small, and the
 * likelihood of an intersection so great, that it is not worth the CPU cost of sorting or the
 * memory cost of hashing.
 */
internal fun Array<String>.hasIntersection(

/** Test how HTTP/2 interacts with HTTP features.  */
@Timeout(60)
@Flaky
@Tag("Slow")
class HttpOverHttp2Test {
  class ProtocolParamProvider : SimpleProvider() {
    override fun arguments() = listOf(Protocol.H2_PRIOR_KNOWLEDGE, Protocol.HTTP_2)
  }

  @RegisterExtension
  val platform: PlatformRule = PlatformRule()

  @RegisterExtension
  val clientTestRule = configureClientTestRule()

import org.junit.jupiter.api.extension.ExtensionContext
import org.junit.jupiter.params.provider.Arguments
import org.junit.jupiter.params.provider.ArgumentsProvider

abstract class SimpleProvider : ArgumentsProvider {
  override fun provideArguments(context: ExtensionContext) = arguments().map { Arguments.of(it) }.stream()

  @Throws(Exception::class)
  abstract fun arguments(): List<Any>

        # shellcheck disable=SC2039,SC3045
        ulimit -n "$MAX_FD" ||
            warn "Could not set maximum file descriptor limit to $MAX_FD"
    esac
fi

# Collect all arguments for the java command, stacking in reverse order:
#   * args from the command line
#   * the main class name
#   * -classpath
#   * -D...appname settings
#   * --module-path (only if needed)

    }
  }

  @ParameterizedTest
  @ArgumentsSource(SampleTestProvider::class)
  fun testParams(mode: String) {
  }
}

class SampleTestProvider : SimpleProvider() {
  override fun arguments() = listOf("A", "B")

    ).map { File(it) }

  return directories.flatMap {
    it.listFiles().orEmpty().filter { f -> f.isFile }.toList()
  }
}

internal class MainTestProvider : SimpleProvider() {
  override fun arguments(): List<Any> {
    val mainFiles = mainFiles()
    return mainFiles.map {
      val suffix = it.path.replace("${prefix}samples/guide/src/main/java/", "")
      suffix.replace("(.*)\\.java".toRegex()) { mr ->

    }
    assertThrows<IllegalArgumentException> {
      cookieBuilder.sameSite(" a ").build()
    }

    cookieBuilder.sameSite("a").build()
  }

  @ParameterizedTest(name = "{displayName}({arguments})")
  @ValueSource(strings = ["Lax", "Strict", "UnrecognizedButValid"])
  fun builderSameSite(sameSite: String) {
    val cookie =
      Cookie.Builder()
        .name("a")
        .value("b")

import org.junit.jupiter.api.io.TempDir
import org.junit.jupiter.params.ParameterizedTest
import org.junit.jupiter.params.provider.ArgumentsSource

class FileSystemParamProvider : SimpleProvider() {
  override fun arguments() =
    listOf(
      FakeFileSystem().apply { emulateUnix() } to false,
      FileSystem.SYSTEM to TestUtil.windows,
      FakeFileSystem().apply { emulateWindows() } to true,
    )
}

@Timeout(60)

    // IllegalStateException: Cannot resume session and session creation is disabled
    platform.assumeNotBouncyCastle()
  }

  @ParameterizedTest(name = "{displayName}({arguments})")
  @ValueSource(strings = ["TLSv1.2", "TLSv1.3"])
  @Flaky
  fun testSessionReuse(tlsVersion: String) {
    if (tlsVersion == TlsVersion.TLS_1_3.javaName) {
      assumeTrue(PlatformVersion.majorVersion != 8)
    }

  companion object {
    // The size of the socket buffers in bytes.
    private const val SOCKET_BUFFER_SIZE = 256 * 1024
  }
}

class CancelModelParamProvider : SimpleProvider() {
  override fun arguments() =
    CancelTest.CancelMode.values().flatMap { c ->
      CancelTest.ConnectionType.values().map { x ->
        Pair(
          c,
          x,
        )
      }
    }