per.mozilla.org/en-US/docs/Web/HTTP/Headers" class="external-link" target="_blank">using the 'X-' prefix</a>.

    But if you have custom headers that you want a client in a browser to be able to see, you need to add them to your CORS configurations ([CORS (Cross-Origin Resource Sharing)](cors.md){.internal-link target=_blank}) using the parameter `expose_headers` documented in <a href="https://www.starlette.io/middleware/#corsmiddleware" class="external-link" target="_blank">Starlette's...

href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers" class="external-link" target="_blank">using the 'X-' prefix</a>.

But if you have custom headers that you want a client in a browser to be able to see, you need to add them to your CORS configurations (read more in [CORS (Cross-Origin Resource Sharing)](../tutorial/cors.md){.internal-link target=_blank}), using the parameter `expose_headers` documented in <a href="https://www.starlette.io/middleware/#corsmiddleware" class="external-link" t...

The <abbr title="specification">spec</abbr> requires the fields to be exactly named `username` and `password`, and to be sent as form fields, not JSON.

With `Form` you can declare the same configurations as with `Body` (and `Query`, `Path`, `Cookie`), including validation, examples, an alias (e.g. `user-name` instead of `username`), etc.

!!! info
    `Form` is a class that inherits directly from `Body`.

!!! tip

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package configurations

import common.requiresNotEc2Agent
import model.CIBuildModel
import model.Stage

class SmokeIdeTests(model: CIBuildModel, stage: Stage) : BaseGradleBuildType(stage = stage, init = {
    id(buildTypeId(model))

    }

    private
    fun findLatest(name: String, notation: String, dest: Properties) {
        val libDependencies = arrayOf(project.dependencies.create(notation))
        val templateVersionConfiguration = project.configurations.detachedConfiguration(*libDependencies)
        templateVersionConfiguration.resolutionStrategy.componentSelection.all {
            devSuffixes.forEach {
                if (it.containsMatchIn(candidate.version)) {

version: '3.7'

# Settings and configurations that are common for all containers
x-minio-common: &minio-common
  image: quay.io/minio/minio:${JOB_NAME}
  command: server --console-address ":9001" http://minio{1...4}/cdata{1...2}
  expose:
    - "9000"
    - "9001"
  environment:
    MINIO_CI_CD: "on"
    MINIO_ROOT_USER: "minio"
    MINIO_ROOT_PASSWORD: "minio123"
    MINIO_COMPRESSION_ENABLE: "on"
    MINIO_COMPRESSION_MIME_TYPES: "*"

  In order to really achieve this, we need mojo configurations (which are
  provided both in terms of static expressions that are just looked up, and
  in terms of user-provided configuration from properties or the POM).
  If these mojos are to be first-class components, the configuration from these
  various sources must be consolidated and injected using the container.

  Currently, mojo configuration is done externally to the container, in the

package configurations

import common.BuildToolBuildJvm
import common.Jvm
import common.Os
import common.buildToolGradleParameters
import common.customGradle
import common.dependsOn
import common.functionalTestParameters
import common.gradleWrapper
import common.requiresNotEc2Agent
import common.requiresNotSharedHost
import common.skipConditionally
import jetbrains.buildServer.configs.kotlin.BuildSteps

package model

import com.alibaba.fastjson.JSON
import com.alibaba.fastjson.JSONArray
import com.alibaba.fastjson.JSONObject
import common.Os
import configurations.FunctionalTest
import configurations.ParallelizationMethod
import java.io.File

/**
 * QuickCrossVersionTest only tests the last minor for each major version in the range.
 */
val QUICK_CROSS_VERSION_BUCKETS = listOf(
    listOf("0.0", "3.0"), // 0.0 <= version < 3.0

  virtual ~ImmediateExecutionDistributedManager() {}

  // Set up distributed execution environment on local and remote tasks.
  // When `reset_context` is true, initialize new cluster context state based
  // on cluster configurations provided in `server_def`; otherwise, update
  // existing context state with the provided `server_def`. Contexts created
  // on remote tasks will be considered stale and garbage collected after