import okio.BufferedSink
import org.junit.jupiter.api.Assertions.assertTrue

/** A duplex request body that keeps the provided sinks so they can be written to later.  */
class AsyncRequestBody : RequestBody() {
  private val requestBodySinks: BlockingQueue<BufferedSink> = LinkedBlockingQueue()

  override fun contentType(): MediaType? = null

  override fun writeTo(sink: BufferedSink) {
    requestBodySinks.add(sink)
  }

 * so that they are alphabetically sorted (by type, then member).
 */
@CacheableTask
abstract class SortAcceptedApiChangesTask : AbstractAcceptedApiChangesMaintenanceTask() {

    @TaskAction
    fun execute() {
        val gson: Gson = GsonBuilder().setFormattingStyle(FormattingStyle.PRETTY.withIndent("    ")).create()
        loadChanges().mapValues {
            gson.toJson(AcceptedApiChanges(sortChanges(it.value)))
        }.forEach {

// JvmCompilation instances control the way each source set is compiled -- most importantly,
// it controls the JVM version of the compilation. This allows each source set within a project
// to compile to different JVM versions.

val jvmCompile = extensions.create<JvmCompileExtension>(JvmCompileExtension.NAME)

jvmCompile.compilations.configureEach {
    // Assume the compilation does not use any workarounds
    usesJdkInternals = false

  var output: String? = null
  var comment: String? = null

  override fun toString() = "input=$input output=$output"

  companion object {
    fun load(): List<WebPlatformToAsciiData> {
      val path = okHttpRoot / "okhttp/src/jvmTest/resources/web-platform-test-toascii.json"
      return SYSTEM_FILE_SYSTEM.read(path) {
        Json.decodeFromString<List<WebPlatformToAsciiData>>(readUtf8())
      }
    }
  }

import model.Stage

class SmokeIdeTests(
    model: CIBuildModel,
    stage: Stage,
    flakyTestStrategy: FlakyTestStrategy,
) : OsAwareBaseGradleBuildType(os = Os.LINUX, stage = stage, init = {
        val suffix = if (flakyTestStrategy == FlakyTestStrategy.ONLY)"_FlakyTestQuarantine" else ""
        id(buildTypeId(model) + suffix)
        name = "Smoke Ide Tests$suffix"
        description = "Tests against IDE sync process"

        "properties": {
            "p_val_alias": {
                "type": "array",
                "items": {"type": "string", "format": "binary"},
                "title": "P Val Alias",
            },
        },
        "required": ["p_val_alias"],
        "title": body_model_name,
        "type": "object",
    }


@pytest.mark.parametrize(
    "path",
    [

	return func(w http.ResponseWriter, r *http.Request) {
		globalHTTPStats.incS3RequestsIncoming()

		if r.Header.Get(globalObjectPerfUserMetadata) == "" {
			if val := globalServiceFreeze.Load(); val != nil {
				if unlock, ok := val.(chan struct{}); ok && unlock != nil {
					// Wait until unfrozen.
					select {
					case <-unlock:
					case <-r.Context().Done():

import promotion.RELEASE_CANDIDATE_BUILD_CONFIGURATION_ID
import vcsroots.useAbsoluteVcs

object UpdateWrapper : BuildType({
    name = "UpdateWrapper"
    id("UpdateWrapper")

    val vcsBranch = VersionedSettingsBranch.fromDslContext()

    vcs.useAbsoluteVcs(vcsBranch.vcsRootId())

    requirements {
        requiresOs(Os.LINUX)
    }

    params {
        text(

import org.gradle.api.attributes.CompatibilityCheckDetails
import org.gradle.api.provider.Provider

enum class NullawayState {
    ENABLED, DISABLED
}

object NullawayAttributes {
    val nullawayAttribute = Attribute.of("org.gradle.gradlebuild.nullaway", NullawayState::class.java)

    fun addToConfiguration(configuration: NamedDomainObjectProvider<Configuration>, value: Provider<NullawayState>) {

)
def test_required_validation_alias_schema(path: str):
    assert app.openapi()["paths"][path]["get"]["parameters"] == [
        {
            "required": True,
            "schema": {"title": "P Val Alias", "type": "string"},
            "name": "p_val_alias",
            "in": "header",
        }
    ]


@pytest.mark.parametrize(
    "path",
    [
        "/required-validation-alias",