RequestSpecificationImpl (REST Assured 3.0.6 API)

java.lang.Object
- io.restassured.internal.RequestSpecificationImpl

All Implemented Interfaces:

groovy.lang.GroovyInterceptable, groovy.lang.GroovyObject, FilterableRequestSpecification, RequestSender, RequestSenderOptions<Response>, RequestSpecification
```
public class RequestSpecificationImpl
extends Object
implements FilterableRequestSpecification, groovy.lang.GroovyInterceptable
```

Constructor Summary

Constructors
Constructor and Description
`RequestSpecificationImpl(String baseURI, int requestPort, String basePath, AuthenticationScheme defaultAuthScheme, List<Filter> filters, RequestSpecification defaultSpec, boolean urlEncode, RestAssuredConfig restAssuredConfig, LogRepository logRepository, ProxySpecification proxySpecification)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`RequestSpecification`	`accept(ContentType contentType)` Specify the accept header of the request.
`RequestSpecification`	`accept(String mediaTypes)` Specify the accept header of the request.
`RequestSpecification`	`and()` Syntactic sugar, e.g.
`Object`	`applyEncoderConfig(HTTPBuilder httpBuilder, EncoderConfig encoderConfig)`
`Object`	`applyHttpClientConfig(HttpClientConfig httpClientConfig)`
`Object`	`applyRedirectConfig(RedirectConfig redirectConfig)`
`Object`	`applyRestAssuredConfig(HTTPBuilder http)`
`Object`	`applySessionConfig(SessionConfig sessionConfig)`
`Object`	`assembleBodyContent(Object httpMethod)`
`void`	`assertCorrectNumberOfPathParams()`
`AuthenticationSpecification`	`auth()` Specify authentication credentials when performing a request.
`AuthenticationSpecification`	`authentication()` If you need to specify some credentials when performing a request.
`RequestSpecification`	`basePath(String basePath)` Set the basePath property of the RequestSpecification instead of using static field RestAssured.basePath.
`RequestSpecification`	`baseUri(String baseUri)` Adding the baseUri Property from the RequestSpecification instead of using static field RestAssured.baseURI.
`RequestSpecification`	`body(byte... body)` Specify a byte array request body that'll be sent with the request.
`RequestSpecification`	`body(File body)` Specify file content that'll be sent with the request.
`RequestSpecification`	`body(InputStream body)` Specify file content that'll be sent with the request.
`RequestSpecification`	`body(Object object)` Specify an Object request content that will automatically be serialized to JSON or XML and sent with the request.
`RequestSpecification`	`body(Object object, ObjectMapper mapper)` Specify an Object request content that will automatically be serialized to JSON or XML and sent with the request using a specific object mapper.
`RequestSpecification`	`body(Object object, ObjectMapperType mapperType)` Specify an Object request content that will automatically be serialized to JSON or XML and sent with the request using a specific object mapper type.
`RequestSpecification`	`body(String body)` Specify a String request body (such as e.g.
`void`	`buildUnnamedPathParameterTuples(Object... unnamedPathParameterValues)`
`RequestSpecification`	`config(RestAssuredConfig config)` Define a REST Assured configuration.
`RequestSpecification`	`content(byte... content)` Specify a byte array request content that'll be sent with the request.
`RequestSpecification`	`content(File content)` Specify file content that'll be sent with the request.
`RequestSpecification`	`content(InputStream content)` Specify file content that'll be sent with the request.
`RequestSpecification`	`content(Object object)` Specify an Object request content that will automatically be serialized to JSON or XML and sent with the request.
`RequestSpecification`	`content(Object object, ObjectMapper mapper)` Specify an Object request content that will automatically be serialized to JSON or XML and sent with the request using a specific object mapper.
`RequestSpecification`	`content(Object object, ObjectMapperType mapperType)` Specify an Object request content that will automatically be serialized to JSON or XML and sent with the request using a specific object mapper type.
`RequestSpecification`	`content(String content)` Specify a String request content (such as e.g.
`RequestSpecification`	`contentType(ContentType contentType)` Specify the content type of the request.
`RequestSpecification`	`contentType(String contentType)` Specify the content type of the request.
`RequestSpecification`	`cookie(Cookie cookie)` Specify a `Cookie` to send with the request.
`RequestSpecification`	`cookie(String cookieName)` Specify a cookie with no value that'll be sent with the request e.g:
`RequestSpecification`	`cookie(String cookieName, Object value, Object... additionalValues)` Specify a cookie that'll be sent with the request e.g:
`RequestSpecification`	`cookies(Cookies cookies)` Specify the cookies that'll be sent with the request as `Cookies`:
`RequestSpecification`	`cookies(Map cookies)` Specify the cookies that'll be sent with the request as Map e.g:
`RequestSpecification`	`cookies(String firstCookieName, Object firstCookieValue, Object... cookieNameValuePairs)` Specify the cookies that'll be sent with the request.
`Response`	`delete()` Perform a DELETE request to the statically configured path (by default `http://localhost:8080`).
`Response`	`delete(String path, Map pathParams)` Perform a DELETE request to a `path`.
`Response`	`delete(String path, Object... pathParams)` Perform a DELETE request to a `path`.
`Response`	`delete(URI uri)` Perform a DELETE request to a `uri`.
`Response`	`delete(URL url)` Perform a DELETE request to a `url`.
`ResponseSpecification`	`expect()` Returns the response specification so that you can setup the expectations on the response.
`RequestSpecification`	`filter(Filter filter)` Add a filter that will be used in the request.
`RequestSpecification`	`filters(Filter filter, Filter... additionalFilter)` Add filters that will be used in the request.
`RequestSpecification`	`filters(List<Filter> filters)` Add filters that will be used in the request.
`RequestSpecification`	`formParam(String parameterName, Collection<?> parameterValues)` Specify a multi-value form parameter that'll be sent with the request e.g:
`RequestSpecification`	`formParam(String parameterName, Object... parameterValues)` Specify a form parameter that'll be sent with the request.
`RequestSpecification`	`formParameter(String parameterName, Collection<?> parameterValues)` Specify a multi-value form parameter that'll be sent with the request e.g:
`RequestSpecification`	`formParameter(String parameterName, Object... additionalParameterValues)` Specify a form parameter that'll be sent with the request.
`RequestSpecification`	`formParameters(Map parametersMap)` Specify the form parameters that'll be sent with the request.
`RequestSpecification`	`formParameters(String firstParameterName, Object firstParameterValue, Object... parameterNameValuePairs)` Specify the form parameters that'll be sent with the request.
`RequestSpecification`	`formParams(Map parametersMap)` Specify the form parameters that'll be sent with the request.
`RequestSpecification`	`formParams(String firstParameterName, Object firstParameterValue, Object... parameterNameValuePairs)` Specify the form parameters that'll be sent with the request.
`Response`	`get()` Perform a GET request to the statically configured path (by default `http://localhost:8080`).
`Response`	`get(String path, Map pathParams)` Perform a GET request to a `path`.
`Response`	`get(String path, Object... pathParams)` Perform a GET request to a `path`.
`Response`	`get(URI uri)` Perform a GET request to a `uri`.
`Response`	`get(URL url)` Perform a GET request to a `url`.
`AuthenticationScheme`	`getAuthenticationScheme()`
`String`	`getBasePath()`
`String`	`getBaseUri()`
`<T> T`	`getBody()`
`RestAssuredConfig`	`getConfig()`
`String`	`getContentType()`
`Cookies`	`getCookies()`
`List<Filter>`	`getDefinedFilters()`
`String`	`getDerivedPath()`
`static String`	`getDerivedPath(String uri)`
`Map<String,String>`	`getFormParams()`
`Headers`	`getHeaders()`
`org.apache.http.client.HttpClient`	`getHttpClient()`
`groovy.lang.MetaClass`	`getMetaClass()`
`String`	`getMethod()`
`List<MultiPartSpecification>`	`getMultiPartParams()`
`Map<String,String>`	`getNamedPathParams()`
`List<String>`	`getPathParamPlaceholders()` Returns a list of all path param placeholders that are currently undefined in the request.
`Map<String,String>`	`getPathParams()`
`static List`	`getPlaceholders(String uri)`
`int`	`getPort()`
`Object`	`getProperty(String property)`
`ProxySpecification`	`getProxySpecification()`
`Map<String,String>`	`getQueryParams()`
`Map<String,String>`	`getRedundantNamedPathParams()`
`List<String>`	`getRedundantUnnamedPathParamValues()`
`String`	`getRequestContentType()`
`Map<String,String>`	`getRequestParams()`
`List<String>`	`getUndefinedPathParamPlaceholders()` Returns a list of all path param placeholders that are currently undefined in the request.
`Map<String,String>`	`getUnnamedPathParams()` Return the unnamed path parameters defined in the request specification as a map.
`List<String>`	`getUnnamedPathParamValues()`
`String`	`getURI()`
`String`	`getURI(String uri)`
`String`	`getUserDefinedPath()` Returns the original request path as it was before any path parameters were applied.
`RequestSpecification`	`given()` Syntactic sugar, e.g.
`Response`	`head()` Perform a HEAD request to the statically configured path (by default `http://localhost:8080`).
`Response`	`head(String path, Map pathParams)` Perform a HEAD request to a `path`.
`Response`	`head(String path, Object... pathParams)` Perform a HEAD request to a `path`.
`Response`	`head(URI uri)` Perform a HEAD request to a `uri`.
`Response`	`head(URL url)` Perform a HEAD request to a `url`.
`RequestSpecification`	`header(Header header)` Specify a `Header` to send with the request.
`RequestSpecification`	`header(String headerName, Object headerValue, Object... additionalHeaderValues)` Specify a header that'll be sent with the request e.g:
`RequestSpecification`	`headers(Headers headers)` Specify the headers that'll be sent with the request as `Headers`, e.g:
`RequestSpecification`	`headers(Map headers)` Specify the headers that'll be sent with the request as Map e.g:
`RequestSpecification`	`headers(String firstHeaderName, Object firstHeaderValue, Object... headerNameValuePairs)` Specify the headers that'll be sent with the request.
`Object`	`invokeMethod(String method, Object arguments)`
`RequestSpecification`	`keyStore(File pathToJks, String password)` Use a keystore located on the file-system.
`RequestSpecification`	`keyStore(KeyStore keyStore)` Use the supplied keystore for HTTPS requests.
`RequestSpecification`	`keyStore(String pathToJks, String password)` The following documentation is taken from https://github.com/jgritman/httpbuilder/wiki/SSL:
`RequestLogSpecification`	`log()` Returns the `RequestLogSpecification` that allows you to log different parts of the `RequestSpecification`.
`Object`	`mergeMapsAndRetainOrder(Map<String,Object> map1, Map<String,Object> map2)`
`RequestSpecification`	`multiPart(File file)` Specify a file to upload to the server using multi-part form data uploading.
`RequestSpecification`	`multiPart(MultiPartSpecification multiPartSpec)` Specify a multi-part specification.
`RequestSpecification`	`multiPart(String controlName, File file)` Specify a file to upload to the server using multi-part form data uploading with a specific control name.
`RequestSpecification`	`multiPart(String controlName, File file, String mimeType)` Specify a file to upload to the server using multi-part form data uploading with a specific control name and mime-type.
`RequestSpecification`	`multiPart(String name, NoParameterValue contentBody)`
`RequestSpecification`	`multiPart(String controlName, Object object)` Specify an object that will be serialized to JSON and uploaded to the server using multi-part form data uploading with a specific control name.
`RequestSpecification`	`multiPart(String controlName, Object object, String mimeType)` Specify an object that will be serialized and uploaded to the server using multi-part form data uploading with a specific control name.
`RequestSpecification`	`multiPart(String name, String contentBody)` Specify a string to send to the server using multi-part form data.
`RequestSpecification`	`multiPart(String name, String fileName, byte... bytes)` Specify a byte-array to upload to the server using multi-part form data.
`RequestSpecification`	`multiPart(String name, String fileName, byte[] bytes, String mimeType)` Specify a byte-array to upload to the server using multi-part form data.
`RequestSpecification`	`multiPart(String name, String fileName, InputStream stream)` Specify an inputstream to upload to the server using multi-part form data.
`RequestSpecification`	`multiPart(String name, String fileName, InputStream stream, String mimeType)` Specify an inputstream to upload to the server using multi-part form data.
`RequestSpecification`	`multiPart(String controlName, String filename, Object object, String mimeType)` Specify an object that will be serialized and uploaded to the server using multi-part form data uploading with a specific control name.
`RequestSpecification`	`multiPart(String name, String contentBody, String mimeType)` Specify a string to send to the server using multi-part form data with a specific mime-type.
`Object`	`newFilterContext(Object assertionClosure, Object filters, Object properties)`
`RequestSpecification`	`noFilters()` Remove all applied filters
`<T extends Filter> RequestSpecification`	`noFiltersOfType(Class<T> filterType)` Remove all applied filters
`Response`	`options()` Perform a OPTIONS request to the statically configured path (by default `http://localhost:8080`).
`Response`	`options(String path, Map pathParams)` Perform a OPTIONS request to a `path`.
`Response`	`options(String path, Object... pathParams)` Perform a OPTIONS request to a `path`.
`Response`	`options(URI uri)` Perform a OPTIONS request to a `uri`.
`Response`	`options(URL url)` Perform a OPTIONS request to a `url`.
`RequestSpecification`	`param(String parameterName, Collection<?> parameterValues)` Specify a multi-value parameter that'll be sent with the request e.g:
`RequestSpecification`	`param(String parameterName, Object... parameterValues)` Specify a parameter that'll be sent with the request e.g:
`RequestSpecification`	`parameter(String parameterName, Collection<?> parameterValues)` Specify a multi-value parameter that'll be sent with the request e.g:
`RequestSpecification`	`parameter(String parameterName, Object... parameterValues)` Specify a parameter that'll be sent with the request e.g:
`RequestSpecification`	`parameters(Map parametersMap)` Specify the parameters that'll be sent with the request as Map e.g:
`RequestSpecification`	`parameters(String firstParameterName, Object firstParameterValue, Object... parameterNameValuePairs)` Specify the parameters that'll be sent with the request.
`RequestSpecification`	`params(Map parametersMap)` Specify the parameters that'll be sent with the request as Map e.g:
`RequestSpecification`	`params(String firstParameterName, Object firstParameterValue, Object... parameterNameValuePairs)` Specify the parameters that'll be sent with the request.
`String`	`partiallyApplyPathParams(String path, boolean encodePath, List<String> unnamedPathParams)`
`Response`	`patch()` Perform a PATCH request to the statically configured path (by default `http://localhost:8080`).
`Response`	`patch(String path, Map pathParams)` Perform a PATCH request to a `path`.
`Response`	`patch(String path, Object... pathParams)` Perform a PATCH request to a `path`.
`Response`	`patch(URI uri)` Perform a PATCH request to a `uri`.
`Response`	`patch(URL url)` Perform a PATCH request to a `url`.
`FilterableRequestSpecification`	`path(String path)` Set the request path of the request specification.
`RequestSpecification`	`pathParam(String parameterName, Object parameterValue)` Specify a path parameter.
`RequestSpecification`	`pathParameter(String parameterName, Object parameterValue)` Specify a path parameter.
`RequestSpecification`	`pathParameters(Map parameterNameValuePairs)` Specify multiple path parameter name-value pairs.
`RequestSpecification`	`pathParameters(String firstParameterName, Object firstParameterValue, Object... parameterNameValuePairs)` Specify multiple path parameter name-value pairs.
`RequestSpecification`	`pathParams(Map parameterNameValuePairs)` Specify multiple path parameter name-value pairs.
`RequestSpecification`	`pathParams(String firstParameterName, Object firstParameterValue, Object... parameterNameValuePairs)` Specify multiple path parameter name-value pairs.
`RequestSpecification`	`port(int port)` Specify the port of the URI.
`Response`	`post()` Perform a POST request to the statically configured path (by default `http://localhost:8080`).
`Response`	`post(String path, Map pathParams)` Perform a POST request to a `path`.
`Response`	`post(String path, Object... pathParams)` Perform a POST request to a `path`.
`Response`	`post(URI uri)` Perform a POST request to a `uri`.
`Response`	`post(URL url)` Perform a POST request to a `url`.
`RequestSpecification`	`proxy(int port)` Instruct REST Assured to connect to a proxy on the specified port on localhost.
`RequestSpecification`	`proxy(ProxySpecification proxySpecification)` Instruct REST Assured to connect to a proxy using a `ProxySpecification`.
`RequestSpecification`	`proxy(String host)` Instruct REST Assured to connect to a proxy on the specified host on port `8888`.
`RequestSpecification`	`proxy(String host, int port)` Instruct REST Assured to connect to a proxy on the specified host and port.
`RequestSpecification`	`proxy(String host, int port, String scheme)` Instruct REST Assured to connect to a proxy on the specified port on localhost with a specific scheme.
`RequestSpecification`	`proxy(URI uri)` Instruct REST Assured to connect to a proxy using a URI.
`Response`	`put()` Perform a PUT request to the statically configured path (by default `http://localhost:8080`).
`Response`	`put(String path, Map pathParams)` Perform a PUT request to a `path`.
`Response`	`put(String path, Object... pathParams)` Perform a PUT request to a `path`.
`Response`	`put(URI uri)` Perform a PUT request to a `uri`.
`Response`	`put(URL url)` Perform a PUT request to a `url`.
`RequestSpecification`	`queryParam(String parameterName, Collection<?> parameterValues)` Specify a multi-value query parameter that'll be sent with the request e.g:
`RequestSpecification`	`queryParam(String parameterName, Object... parameterValues)` Specify a query parameter that'll be sent with the request.
`RequestSpecification`	`queryParameter(String parameterName, Collection<?> parameterValues)` Specify a multi-value query parameter that'll be sent with the request e.g:
`RequestSpecification`	`queryParameter(String parameterName, Object... parameterValues)` Specify a query parameter that'll be sent with the request.
`RequestSpecification`	`queryParameters(Map parametersMap)` Specify the query parameters that'll be sent with the request.
`RequestSpecification`	`queryParameters(String firstParameterName, Object firstParameterValue, Object... parameterNameValuePairs)` Specify the query parameters that'll be sent with the request.
`RequestSpecification`	`queryParams(Map parametersMap)` Specify the query parameters that'll be sent with the request.
`RequestSpecification`	`queryParams(String firstParameterName, Object firstParameterValue, Object... parameterNameValuePairs)` Specify the query parameters that'll be sent with the request.
`RedirectSpecification`	`redirects()` Specify the redirect configuration for this request.
`RequestSpecification`	`relaxedHTTPSValidation()` Use relaxed HTTP validation with SSLContext protocol SSL.
`RequestSpecification`	`relaxedHTTPSValidation(String protocol)` Use relaxed HTTP validation with the given SSLContext protocol.
`FilterableRequestSpecification`	`removeCookie(Cookie cookie)` Remove a cookie
`FilterableRequestSpecification`	`removeCookie(String cookieName)` Remove a cookie with the given name.
`FilterableRequestSpecification`	`removeCookies()` Removed all defined cookies
`FilterableRequestSpecification`	`removeFormParam(String parameterName)` Remove a form parameter from the request.
`FilterableRequestSpecification`	`removeHeader(String headerName)` Remove a header with the given name.
`FilterableRequestSpecification`	`removeHeaders()` Removes all defined headers
`FilterableRequestSpecification`	`removeNamedPathParam(String parameterName)` Remove a named path parameter from the request.
`FilterableRequestSpecification`	`removeParam(String parameterName)` Remove a request parameter from the request.
`FilterableRequestSpecification`	`removePathParam(String parameterName)` Remove a path parameter from the request.
`FilterableRequestSpecification`	`removeQueryParam(String parameterName)` Remove a query parameter from the request.
`FilterableRequestSpecification`	`removeUnnamedPathParam(String parameterName)` Remove an unnamed path parameter from the request.
`void`	`removeUnnamedPathParamAtIndex(int indexOfParamName)`
`FilterableRequestSpecification`	`removeUnnamedPathParamByValue(String parameterValue)` Remove the first unnamed path parameter from the request based on its value.
`FilterableRequestSpecification`	`replaceCookie(Cookie cookie)` Replace a cookie, if it doesn't exist then it will be added.
`FilterableRequestSpecification`	`replaceCookie(String cookieName, String value)` Replace a cookie with the given name.
`FilterableRequestSpecification`	`replaceCookies(Cookies cookies)` Replace all defined cookies
`FilterableRequestSpecification`	`replaceHeader(String headerName, String newValue)` Replace a header with the new value.
`FilterableRequestSpecification`	`replaceHeaders(Headers headers)` Replace all defined headers
`RequestSpecification`	`request()` Syntactic sugar, e.g.
`Response`	`request(Method method)` Perform a request to the pre-configured path (by default `http://localhost:8080`).
`Response`	`request(Method method, String path, Object... pathParams)` Perform a HTTP request to a `path`.
`Response`	`request(Method method, URI uri)` Perform a request to a `uri`.
`Response`	`request(Method method, URL url)` Perform a request to a `url`.
`Response`	`request(String method)` Perform a custom HTTP request to the pre-configured path (by default `http://localhost:8080`).
`Response`	`request(String method, String path, Object... pathParams)` Perform a custom HTTP request to a `path`.
`Response`	`request(String method, URI uri)` Perform a custom HTTP request to a `uri`.
`Response`	`request(String method, URL url)` Perform a custom HTTP request to a `url`.
`ResponseSpecification`	`response()` Returns the response specification so that you can setup the expectations on the response.
`RestAssuredConfig`	`restAssuredConfig()`
`RequestSpecification`	`sessionId(String sessionIdValue)` Set the session id for this request.
`RequestSpecification`	`sessionId(String sessionIdName, String sessionIdValue)` Set the session id name and value for this request.
`void`	`setAuthenticationScheme(AuthenticationScheme value)`
`void`	`setMetaClass(groovy.lang.MetaClass mc)`
`void`	`setMethod(String method)`
`void`	`setProperty(String property, Object value)`
`Object`	`setRequestHeadersToHttpBuilder(HTTPBuilder http)`
`void`	`setResponseSpecification(ResponseSpecification responseSpecification)`
`boolean`	`shouldApplySSLConfig(Object http, RestAssuredConfig cfg)`
`RequestSpecification`	`spec(RequestSpecification requestSpecificationToMerge)` Add request data from a pre-defined specification.
`RequestSpecification`	`specification(RequestSpecification requestSpecificationToMerge)` Add request data from a pre-defined specification.
`RequestSpecification`	`that()` Syntactic sugar, e.g.
`ResponseSpecification`	`then()` Returns the response specification so that you can setup the expectations on the response.
`RequestSpecification`	`trustStore(File path, String password)` Use a trust store located on the file-system.
`RequestSpecification`	`trustStore(KeyStore trustStore)` Use the supplied truststore for HTTPS requests.
`RequestSpecification`	`trustStore(String path, String password)` Apply a trust store.
`RequestSpecification`	`urlEncodingEnabled(boolean isEnabled)` Specifies if Rest Assured should url encode the URL automatically.
`RequestSpecification`	`when()` Syntactic sugar, e.g.
`RequestSpecification`	`with()` Syntactic sugar, e.g.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - RequestSpecificationImpl
```
public RequestSpecificationImpl(String baseURI,
                                int requestPort,
                                String basePath,
                                AuthenticationScheme defaultAuthScheme,
                                List<Filter> filters,
                                RequestSpecification defaultSpec,
                                boolean urlEncode,
                                RestAssuredConfig restAssuredConfig,
                                LogRepository logRepository,
                                ProxySpecification proxySpecification)
```
- Method Detail
  - getMetaClass
```
public groovy.lang.MetaClass getMetaClass()
```
    Specified by:
    
    getMetaClass in interface groovy.lang.GroovyObject
  - setMetaClass
```
public void setMetaClass(groovy.lang.MetaClass mc)
```
    Specified by:
    
    setMetaClass in interface groovy.lang.GroovyObject
  - invokeMethod
```
public Object invokeMethod(String method,
                           Object arguments)
```
    Specified by:
    
    invokeMethod in interface groovy.lang.GroovyObject
  - getProperty
```
public Object getProperty(String property)
```
    Specified by:
    
    getProperty in interface groovy.lang.GroovyObject
  - setProperty
```
public void setProperty(String property,
                        Object value)
```
    Specified by:
    
    setProperty in interface groovy.lang.GroovyObject
  - getAuthenticationScheme
```
public AuthenticationScheme getAuthenticationScheme()
```
    Specified by:
    
    getAuthenticationScheme in interface FilterableRequestSpecification
    
    Returns:
    
    The authentication scheme defined in the request specification
  - setAuthenticationScheme
```
public void setAuthenticationScheme(AuthenticationScheme value)
```
  - when
```
public RequestSpecification when()
```
    Description copied from interface: RequestSpecification
    Syntactic sugar, e.g.
```
 expect().body(containsString("OK")).when().get("/something");
 
```
    is that same as:
```
 expect().body(containsString("OK")).get("/something");
 
```
    Specified by:
    
    when in interface RequestSpecification
    
    Returns:
    
    the request specification
  - given
```
public RequestSpecification given()
```
    Description copied from interface: RequestSpecification
    Syntactic sugar, e.g.
```
 given().param("name1", "value1").and().given().param("name2", "value2").when().get("/something");
 
```
    is that same as:
```
 given().param("name1", "value1").and().param("name2", "value2").when().get("/something");
 
```
    Specified by:
    
    given in interface RequestSpecification
    
    Returns:
    
    the request specification
  - that
```
public RequestSpecification that()
```
    Description copied from interface: RequestSpecification
    Syntactic sugar, e.g.
```
 expect().that().body(containsString("OK")).when().get("/something");
 
```
    is that same as:
```
 expect().body(containsString("OK")).get("/something");
 
```
    Specified by:
    
    that in interface RequestSpecification
    
    Returns:
    
    the request specification
  - response
```
public ResponseSpecification response()
```
    Description copied from interface: RequestSpecification
    Returns the response specification so that you can setup the expectations on the response. E.g.
```
 given().param("name", "value").then().response().body(equalTo("something")).when().get("/something");
 
```
    Specified by:
    
    response in interface RequestSpecification
    
    Returns:
    
    the response specification
  - get
```
public Response get(String path,
                    Object... pathParams)
```
    Description copied from interface: RequestSenderOptions
    
    Perform a GET request to a path. Normally the path doesn't have to be fully-qualified e.g. you don't need to specify the path as http://localhost:8080/path. In this case it's enough to use /path.
    
    Specified by:
    
    get in interface RequestSenderOptions<Response>
    
    Parameters:
    
    path - The path to send the request to.
    
    pathParams - The path parameters. E.g. if path is "/book/{hotelId}/{roomNumber}" you can do get("/book/{hotelName}/{roomNumber}", "Hotels R Us", 22);.
    
    Returns:
    
    The response of the request.
  - post
```
public Response post(String path,
                     Object... pathParams)
```
    Description copied from interface: RequestSenderOptions
    
    Perform a POST request to a path. Normally the path doesn't have to be fully-qualified e.g. you don't need to specify the path as http://localhost:8080/path. In this case it's enough to use /path.
    
    Specified by:
    
    post in interface RequestSenderOptions<Response>
    
    Parameters:
    
    path - The path to send the request to.
    
    pathParams - The path parameters. E.g. if path is "/book/{hotelId}/{roomNumber}" you can do post("/book/{hotelName}/{roomNumber}", "Hotels R Us", 22);.
    
    Returns:
    
    The response of the request.
  - put
```
public Response put(String path,
                    Object... pathParams)
```
    Description copied from interface: RequestSenderOptions
    
    Perform a PUT request to a path. Normally the path doesn't have to be fully-qualified e.g. you don't need to specify the path as http://localhost:8080/path. In this case it's enough to use /path.
    
    Specified by:
    
    put in interface RequestSenderOptions<Response>
    
    Parameters:
    
    path - The path to send the request to.
    
    pathParams - The path parameters. E.g. if path is "/book/{hotelId}/{roomNumber}" you can do put("/book/{hotelName}/{roomNumber}", "Hotels R Us", 22);.
    
    Returns:
    
    The response of the request.
  - delete
```
public Response delete(String path,
                       Object... pathParams)
```
    Description copied from interface: RequestSenderOptions
    
    Perform a DELETE request to a path. Normally the path doesn't have to be fully-qualified e.g. you don't need to specify the path as http://localhost:8080/path. In this case it's enough to use /path.
    
    Specified by:
    
    delete in interface RequestSenderOptions<Response>
    
    Parameters:
    
    path - The path to send the request to.
    
    pathParams - The path parameters. E.g. if path is "/book/{hotelId}/{roomNumber}" you can do delete("/book/{hotelName}/{roomNumber}", "Hotels R Us", 22);.
    
    Returns:
    
    The response of the request.
  - head
```
public Response head(String path,
                     Object... pathParams)
```
    Description copied from interface: RequestSenderOptions
    
    Perform a HEAD request to a path. Normally the path doesn't have to be fully-qualified e.g. you don't need to specify the path as http://localhost:8080/path. In this case it's enough to use /path.
    
    Specified by:
    
    head in interface RequestSenderOptions<Response>
    
    Parameters:
    
    path - The path to send the request to.
    
    pathParams - The path parameters. E.g. if path is "/book/{hotelId}/{roomNumber}" you can do head("/book/{hotelName}/{roomNumber}", "Hotels R Us", 22);.
    
    Returns:
    
    The response of the request.
  - patch
```
public Response patch(String path,
                      Object... pathParams)
```
    Description copied from interface: RequestSenderOptions
    
    Perform a PATCH request to a path. Normally the path doesn't have to be fully-qualified e.g. you don't need to specify the path as http://localhost:8080/path. In this case it's enough to use /path.
    
    Specified by:
    
    patch in interface RequestSenderOptions<Response>
    
    Parameters:
    
    path - The path to send the request to.
    
    pathParams - The path parameters. E.g. if path is "/book/{hotelId}/{roomNumber}" you can do head("/book/{hotelName}/{roomNumber}", "Hotels R Us", 22);.
    
    Returns:
    
    The response of the request.
  - options
```
public Response options(String path,
                        Object... pathParams)
```
    Description copied from interface: RequestSenderOptions
    
    Perform a OPTIONS request to a path. Normally the path doesn't have to be fully-qualified e.g. you don't need to specify the path as http://localhost:8080/path. In this case it's enough to use /path.
    
    Specified by:
    
    options in interface RequestSenderOptions<Response>
    
    Parameters:
    
    path - The path to send the request to.
    
    pathParams - The path parameters. E.g. if path is "/book/{hotelId}/{roomNumber}" you can do head("/book/{hotelName}/{roomNumber}", "Hotels R Us", 22);.
    
    Returns:
    
    The response of the request.
  - get
```
public Response get(URI uri)
```
    Description copied from interface: RequestSenderOptions
    
    Perform a GET request to a uri.
    
    Specified by:
    
    get in interface RequestSenderOptions<Response>
    
    Parameters:
    
    uri - The uri to send the request to.
    
    Returns:
    
    The response of the GET request.
  - post
```
public Response post(URI uri)
```
    Description copied from interface: RequestSenderOptions
    
    Perform a POST request to a uri.
    
    Specified by:
    
    post in interface RequestSenderOptions<Response>
    
    Parameters:
    
    uri - The uri to send the request to.
    
    Returns:
    
    The response of the request.
  - put
```
public Response put(URI uri)
```
    Description copied from interface: RequestSenderOptions
    
    Perform a PUT request to a uri.
    
    Specified by:
    
    put in interface RequestSenderOptions<Response>
    
    Parameters:
    
    uri - The uri to send the request to.
    
    Returns:
    
    The response of the request.
  - delete
```
public Response delete(URI uri)
```
    Description copied from interface: RequestSenderOptions
    
    Perform a DELETE request to a uri.
    
    Specified by:
    
    delete in interface RequestSenderOptions<Response>
    
    Parameters:
    
    uri - The uri to send the request to.
    
    Returns:
    
    The response of the request.
  - head
```
public Response head(URI uri)
```
    Description copied from interface: RequestSenderOptions
    
    Perform a HEAD request to a uri.
    
    Specified by:
    
    head in interface RequestSenderOptions<Response>
    
    Parameters:
    
    uri - The uri to send the request to.
    
    Returns:
    
    The response of the request.
  - patch
```
public Response patch(URI uri)
```
    Description copied from interface: RequestSenderOptions
    
    Perform a PATCH request to a uri.
    
    Specified by:
    
    patch in interface RequestSenderOptions<Response>
    
    Parameters:
    
    uri - The uri to send the request to.
    
    Returns:
    
    The response of the request.
  - options
```
public Response options(URI uri)
```
    Description copied from interface: RequestSenderOptions
    
    Perform a OPTIONS request to a uri.
    
    Specified by:
    
    options in interface RequestSenderOptions<Response>
    
    Parameters:
    
    uri - The uri to send the request to.
    
    Returns:
    
    The response of the request.
  - get
```
public Response get(URL url)
```
    Description copied from interface: RequestSenderOptions
    
    Perform a GET request to a url.
    
    Specified by:
    
    get in interface RequestSenderOptions<Response>
    
    Parameters:
    
    url - The url to send the request to.
    
    Returns:
    
    The response of the GET request.
  - post
```
public Response post(URL url)
```
    Description copied from interface: RequestSenderOptions
    
    Perform a POST request to a url.
    
    Specified by:
    
    post in interface RequestSenderOptions<Response>
    
    Parameters:
    
    url - The url to send the request to.
    
    Returns:
    
    The response of the request.
  - put
```
public Response put(URL url)
```
    Description copied from interface: RequestSenderOptions
    
    Perform a PUT request to a url.
    
    Specified by:
    
    put in interface RequestSenderOptions<Response>
    
    Parameters:
    
    url - The url to send the request to.
    
    Returns:
    
    The response of the request.
  - delete
```
public Response delete(URL url)
```
    Description copied from interface: RequestSenderOptions
    
    Perform a DELETE request to a url.
    
    Specified by:
    
    delete in interface RequestSenderOptions<Response>
    
    Parameters:
    
    url - The url to send the request to.
    
    Returns:
    
    The response of the request.
  - head
```
public Response head(URL url)
```
    Description copied from interface: RequestSenderOptions
    
    Perform a HEAD request to a url.
    
    Specified by:
    
    head in interface RequestSenderOptions<Response>
    
    Parameters:
    
    url - The url to send the request to.
    
    Returns:
    
    The response of the request.
  - patch
```
public Response patch(URL url)
```
    Description copied from interface: RequestSenderOptions
    
    Perform a PATCH request to a url.
    
    Specified by:
    
    patch in interface RequestSenderOptions<Response>
    
    Parameters:
    
    url - The url to send the request to.
    
    Returns:
    
    The response of the request.
  - options
```
public Response options(URL url)
```
    Description copied from interface: RequestSenderOptions
    
    Perform a OPTIONS request to a url.
    
    Specified by:
    
    options in interface RequestSenderOptions<Response>
    
    Parameters:
    
    url - The url to send the request to.
    
    Returns:
    
    The response of the request.
  - get
```
public Response get()
```
    Description copied from interface: RequestSenderOptions
    
    Perform a GET request to the statically configured path (by default http://localhost:8080).
    
    Specified by:
    
    get in interface RequestSenderOptions<Response>
    
    Returns:
    
    The response of the GET request.
  - post
```
public Response post()
```
    Description copied from interface: RequestSenderOptions
    
    Perform a POST request to the statically configured path (by default http://localhost:8080).
    
    Specified by:
    
    post in interface RequestSenderOptions<Response>
    
    Returns:
    
    The response of the request.
  - put
```
public Response put()
```
    Description copied from interface: RequestSenderOptions
    
    Perform a PUT request to the statically configured path (by default http://localhost:8080).
    
    Specified by:
    
    put in interface RequestSenderOptions<Response>
    
    Returns:
    
    The response of the request.
  - delete
```
public Response delete()
```
    Description copied from interface: RequestSenderOptions
    
    Perform a DELETE request to the statically configured path (by default http://localhost:8080).
    
    Specified by:
    
    delete in interface RequestSenderOptions<Response>
    
    Returns:
    
    The response of the request.
  - head
```
public Response head()
```
    Description copied from interface: RequestSenderOptions
    
    Perform a HEAD request to the statically configured path (by default http://localhost:8080).
    
    Specified by:
    
    head in interface RequestSenderOptions<Response>
    
    Returns:
    
    The response of the request.
  - patch
```
public Response patch()
```
    Description copied from interface: RequestSenderOptions
    
    Perform a PATCH request to the statically configured path (by default http://localhost:8080).
    
    Specified by:
    
    patch in interface RequestSenderOptions<Response>
    
    Returns:
    
    The response of the request.
  - options
```
public Response options()
```
    Description copied from interface: RequestSenderOptions
    
    Perform a OPTIONS request to the statically configured path (by default http://localhost:8080).
    
    Specified by:
    
    options in interface RequestSenderOptions<Response>
    
    Returns:
    
    The response of the request.
  - request
```
public Response request(Method method)
```
    Description copied from interface: RequestSenderOptions
    
    Perform a request to the pre-configured path (by default http://localhost:8080).
    
    Specified by:
    
    request in interface RequestSenderOptions<Response>
    
    Parameters:
    
    method - The HTTP method to use
    
    Returns:
    
    The response of the request.
  - request
```
public Response request(String method)
```
    Description copied from interface: RequestSenderOptions
    
    Perform a custom HTTP request to the pre-configured path (by default http://localhost:8080).
    
    Specified by:
    
    request in interface RequestSenderOptions<Response>
    
    Parameters:
    
    method - The HTTP method to use
    
    Returns:
    
    The response of the request.
  - request
```
public Response request(Method method,
                        String path,
                        Object... pathParams)
```
    Description copied from interface: RequestSenderOptions
    
    Perform a HTTP request to a path. Normally the path doesn't have to be fully-qualified e.g. you don't need to specify the path as http://localhost:8080/path. In this case it's enough to use /path.
    
    Specified by:
    
    request in interface RequestSenderOptions<Response>
    
    Parameters:
    
    method - The HTTP method to use
    
    path - The path to send the request to.
    
    pathParams - The path parameters. E.g. if path is "/book/{hotelId}/{roomNumber}" you can do request(Method.TRACE,"/book/{hotelName}/{roomNumber}", "Hotels R Us", 22);.
    
    Returns:
    
    The response of the request.
  - request
```
public Response request(String method,
                        String path,
                        Object... pathParams)
```
    Description copied from interface: RequestSenderOptions
    
    Perform a custom HTTP request to a path. Normally the path doesn't have to be fully-qualified e.g. you don't need to specify the path as http://localhost:8080/path. In this case it's enough to use /path.
    
    Specified by:
    
    request in interface RequestSenderOptions<Response>
    
    Parameters:
    
    method - The HTTP method to use
    
    path - The path to send the request to.
    
    pathParams - The path parameters. E.g. if path is "/book/{hotelId}/{roomNumber}" you can do request("method","/book/{hotelName}/{roomNumber}", "Hotels R Us", 22);.
    
    Returns:
    
    The response of the request.
  - request
```
public Response request(Method method,
                        URI uri)
```
    Description copied from interface: RequestSenderOptions
    
    Perform a request to a uri.
    
    Specified by:
    
    request in interface RequestSenderOptions<Response>
    
    Parameters:
    
    method - The HTTP method to use
    
    uri - The uri to send the request to.
    
    Returns:
    
    The response of the GET request.
  - request
```
public Response request(Method method,
                        URL url)
```
    Description copied from interface: RequestSenderOptions
    
    Perform a request to a url.
    
    Specified by:
    
    request in interface RequestSenderOptions<Response>
    
    Parameters:
    
    method - The HTTP method to use
    
    url - The url to send the request to.
    
    Returns:
    
    The response of the GET request.
  - request
```
public Response request(String method,
                        URI uri)
```
    Description copied from interface: RequestSenderOptions
    
    Perform a custom HTTP request to a uri.
    
    Specified by:
    
    request in interface RequestSenderOptions<Response>
    
    Parameters:
    
    method - The HTTP method to use
    
    uri - The uri to send the request to.
    
    Returns:
    
    The response of the GET request.
  - request
```
public Response request(String method,
                        URL url)
```
    Description copied from interface: RequestSenderOptions
    
    Perform a custom HTTP request to a url.
    
    Specified by:
    
    request in interface RequestSenderOptions<Response>
    
    Parameters:
    
    method - The HTTP method to use
    
    url - The url to send the request to.
    
    Returns:
    
    The response of the GET request.
  - get
```
public Response get(String path,
                    Map pathParams)
```
    Description copied from interface: RequestSenderOptions
    
    Perform a GET request to a path. Normally the path doesn't have to be fully-qualified e.g. you don't need to specify the path as http://localhost:8080/path. In this case it's enough to use /path.
    
    Specified by:
    
    get in interface RequestSenderOptions<Response>
    
    Parameters:
    
    path - The path to send the request to.
    
    pathParams - The path parameters.
    
    Returns:
    
    The response of the request.
  - post
```
public Response post(String path,
                     Map pathParams)
```
    Description copied from interface: RequestSenderOptions
    
    Perform a POST request to a path. Normally the path doesn't have to be fully-qualified e.g. you don't need to specify the path as http://localhost:8080/path. In this case it's enough to use /path.
    
    Specified by:
    
    post in interface RequestSenderOptions<Response>
    
    Parameters:
    
    path - The path to send the request to.
    
    pathParams - The path parameters.
    
    Returns:
    
    The response of the request.
  - put
```
public Response put(String path,
                    Map pathParams)
```
    Description copied from interface: RequestSenderOptions
    
    Perform a PUT request to a path. Normally the path doesn't have to be fully-qualified e.g. you don't need to specify the path as http://localhost:8080/path. In this case it's enough to use /path.
    
    Specified by:
    
    put in interface RequestSenderOptions<Response>
    
    Parameters:
    
    path - The path to send the request to.
    
    pathParams - The path parameters.
    
    Returns:
    
    The response of the request.
  - delete
```
public Response delete(String path,
                       Map pathParams)
```
    Description copied from interface: RequestSenderOptions
    
    Perform a DELETE request to a path. Normally the path doesn't have to be fully-qualified e.g. you don't need to specify the path as http://localhost:8080/path. In this case it's enough to use /path.
    
    Specified by:
    
    delete in interface RequestSenderOptions<Response>
    
    Parameters:
    
    path - The path to send the request to.
    
    pathParams - The path parameters.
    
    Returns:
    
    The response of the request.
  - head
```
public Response head(String path,
                     Map pathParams)
```
    Description copied from interface: RequestSenderOptions
    
    Perform a HEAD request to a path. Normally the path doesn't have to be fully-qualified e.g. you don't need to specify the path as http://localhost:8080/path. In this case it's enough to use /path.
    
    Specified by:
    
    head in interface RequestSenderOptions<Response>
    
    Parameters:
    
    path - The path to send the request to.
    
    pathParams - The path parameters.
    
    Returns:
    
    The response of the request.
  - patch
```
public Response patch(String path,
                      Map pathParams)
```
    Description copied from interface: RequestSenderOptions
    
    Perform a PATCH request to a path. Normally the path doesn't have to be fully-qualified e.g. you don't need to specify the path as http://localhost:8080/path. In this case it's enough to use /path.
    
    Specified by:
    
    patch in interface RequestSenderOptions<Response>
    
    Parameters:
    
    path - The path to send the request to.
    
    pathParams - The path parameters.
    
    Returns:
    
    The response of the request.
  - options
```
public Response options(String path,
                        Map pathParams)
```
    Description copied from interface: RequestSenderOptions
    
    Perform a OPTIONS request to a path. Normally the path doesn't have to be fully-qualified e.g. you don't need to specify the path as http://localhost:8080/path. In this case it's enough to use /path.
    
    Specified by:
    
    options in interface RequestSenderOptions<Response>
    
    Parameters:
    
    path - The path to send the request to.
    
    pathParams - The path parameters.
    
    Returns:
    
    The response of the request.
  - parameters
```
public RequestSpecification parameters(String firstParameterName,
                                       Object firstParameterValue,
                                       Object... parameterNameValuePairs)
```
    Description copied from interface: RequestSpecification
    Specify the parameters that'll be sent with the request. This is done by specifying the parameters in name-value pairs, e.g:
```
 given().parameters("username", "John", "token", "1234").then().expect().body(equalTo("username, token")).when().get("/parameters");
 
```
    This will send a GET request to "/parameters" with two parameters:
    1. username=John
    2. token=1234
    and expect that the response body is equal to "username, token".
    Specified by:
    
    parameters in interface RequestSpecification
    
    Parameters:
    
    firstParameterName - The name of the first parameter
    
    firstParameterValue - The value of the first parameter
    
    parameterNameValuePairs - Additional parameters in name-value pairs.
    
    Returns:
    
    The request specification
  - parameters
```
public RequestSpecification parameters(Map parametersMap)
```
    Description copied from interface: RequestSpecification
    Specify the parameters that'll be sent with the request as Map e.g:
```
 Map<String, String> parameters = new HashMap<String, String>();
 parameters.put("username", "John");
 parameters.put("token", "1234");
 given().parameters(parameters).then().expect().body(equalTo("username, token")).when().get("/cookie");
 
```
    This will send a GET request to "/cookie" with two parameters:
    1. username=John
    2. token=1234
    and expect that the response body is equal to "username, token".
    Specified by:
    
    parameters in interface RequestSpecification
    
    Parameters:
    
    parametersMap - The Map containing the parameter names and their values to send with the request.
    
    Returns:
    
    The request specification
  - params
```
public RequestSpecification params(String firstParameterName,
                                   Object firstParameterValue,
                                   Object... parameterNameValuePairs)
```
    Description copied from interface: RequestSpecification
    Specify the parameters that'll be sent with the request. This is done by specifying the parameters in name-value pairs, e.g:
```
 given().params("username", "John", "token", "1234").when().get("/parameters").then().assertThat().body(equalTo("username, token"));
 
```
    This will send a GET request to "/parameters" with two parameters:
    1. username=John
    2. token=1234
    and expect that the response body is equal to "username, token".
    Specified by:
    
    params in interface RequestSpecification
    
    Parameters:
    
    firstParameterName - The name of the first parameter
    
    firstParameterValue - The value of the first parameter
    
    parameterNameValuePairs - Additional parameters in name-value pairs.
    
    Returns:
    
    The request specification
  - params
```
public RequestSpecification params(Map parametersMap)
```
    Description copied from interface: RequestSpecification
    Specify the parameters that'll be sent with the request as Map e.g:
```
 Map<String, String> parameters = new HashMap<String, String>();
 parameters.put("username", "John");
 parameters.put("token", "1234");
 given().params(parameters).when().get("/cookie").then().assertThat().body(equalTo("username, token"));
 
```
    This will send a GET request to "/cookie" with two parameters:
    1. username=John
    2. token=1234
    and expect that the response body is equal to "username, token".
    Specified by:
    
    params in interface RequestSpecification
    
    Parameters:
    
    parametersMap - The Map containing the parameter names and their values to send with the request.
    
    Returns:
    
    The request specification
  - param
```
public RequestSpecification param(String parameterName,
                                  Object... parameterValues)
```
    Description copied from interface: RequestSpecification
    Specify a parameter that'll be sent with the request e.g:
```
 given().param("username", "John").when().get("/cookie").then().assertThat().body(equalTo("username"));
 
```
    This will set the parameter username=John in the GET request to "/cookie".
    
    You can also specify several parameters like this:
```
 given().param("username", "John").and().param("password", "1234").when().get("/cookie").then().assertThat().body(equalTo("username"));
 
```
    Specified by:
    
    param in interface RequestSpecification
    
    Parameters:
    
    parameterName - The parameter name
    
    parameterValues - Parameter values, one to many if you want to specify multiple values for the same parameter.
    
    Returns:
    
    The request specification
    
    See Also:
    
    RequestSpecification.param(String, Object...)
  - removeParam
```
public FilterableRequestSpecification removeParam(String parameterName)
```
    Description copied from interface: FilterableRequestSpecification
    
    Remove a request parameter from the request.
    
    Specified by:
    
    removeParam in interface FilterableRequestSpecification
    
    Parameters:
    
    parameterName - The parameter key
    
    Returns:
    
    The FilterableRequestSpecification without the parameter
  - parameter
```
public RequestSpecification parameter(String parameterName,
                                      Collection<?> parameterValues)
```
    Description copied from interface: RequestSpecification
    Specify a multi-value parameter that'll be sent with the request e.g:
```
 given().parameter("cars", asList("Volvo", "Saab"))..;
 
```
    This will set the parameter cars=Volvo and cars=Saab.
    Specified by:
    
    parameter in interface RequestSpecification
    
    Parameters:
    
    parameterName - The parameter name
    
    parameterValues - The parameter values
    
    Returns:
    
    The request specification
  - param
```
public RequestSpecification param(String parameterName,
                                  Collection<?> parameterValues)
```
    Description copied from interface: RequestSpecification
    Specify a multi-value parameter that'll be sent with the request e.g:
```
 given().param("cars", asList("Volvo", "Saab"))..;
 
```
    This will set the parameter cars=Volvo and cars=Saab.
    Specified by:
    
    param in interface RequestSpecification
    
    Parameters:
    
    parameterName - The parameter name
    
    parameterValues - The parameter values
    
    Returns:
    
    The request specification
  - queryParameter
```
public RequestSpecification queryParameter(String parameterName,
                                           Collection<?> parameterValues)
```
    Description copied from interface: RequestSpecification
    Specify a multi-value query parameter that'll be sent with the request e.g:
```
 given().queryParameter("cars", asList("Volvo", "Saab"))..;
 
```
    This will set the parameter cars=Volvo and cars=Saab.
    
    Note that this method is the same as RequestSpecification.parameter(String, java.util.Collection) for all http methods except for POST where RequestSpecification.parameter(String, java.util.Collection) adds a form parameter and this method sets a query parameter.
    Specified by:
    
    queryParameter in interface RequestSpecification
    
    Parameters:
    
    parameterName - The parameter name
    
    parameterValues - The parameter values
    
    Returns:
    
    The request specification
  - queryParam
```
public RequestSpecification queryParam(String parameterName,
                                       Collection<?> parameterValues)
```
    Description copied from interface: RequestSpecification
    Specify a multi-value query parameter that'll be sent with the request e.g:
```
 given().queryParam("cars", asList("Volvo", "Saab"))..;
 
```
    This will set the parameter cars=Volvo and cars=Saab.
    
    Note that this method is the same as RequestSpecification.param(String, java.util.Collection) for all http methods except for POST where RequestSpecification.param(String, java.util.Collection) adds a form parameter and this method sets a query parameter.
    Specified by:
    
    queryParam in interface RequestSpecification
    
    Parameters:
    
    parameterName - The parameter name
    
    parameterValues - The parameter values
    
    Returns:
    
    The request specification
  - removeQueryParam
```
public FilterableRequestSpecification removeQueryParam(String parameterName)
```
    Description copied from interface: FilterableRequestSpecification
    
    Remove a query parameter from the request.
    
    Specified by:
    
    removeQueryParam in interface FilterableRequestSpecification
    
    Parameters:
    
    parameterName - The parameter key
    
    Returns:
    
    The FilterableRequestSpecification without the parameter
  - removeHeader
```
public FilterableRequestSpecification removeHeader(String headerName)
```
    Description copied from interface: FilterableRequestSpecification
    
    Remove a header with the given name.
    
    Specified by:
    
    removeHeader in interface FilterableRequestSpecification
    
    Parameters:
    
    headerName - The header name
    
    Returns:
    
    The FilterableRequestSpecification without the specified header
  - removeCookie
```
public FilterableRequestSpecification removeCookie(String cookieName)
```
    Description copied from interface: FilterableRequestSpecification
    
    Remove a cookie with the given name.
    
    Specified by:
    
    removeCookie in interface FilterableRequestSpecification
    
    Parameters:
    
    cookieName - The cookie name
    
    Returns:
    
    The FilterableRequestSpecification without the specified cookie
  - removeCookie
```
public FilterableRequestSpecification removeCookie(Cookie cookie)
```
    Description copied from interface: FilterableRequestSpecification
    
    Remove a cookie
    
    Specified by:
    
    removeCookie in interface FilterableRequestSpecification
    
    Parameters:
    
    cookie - The cookie
    
    Returns:
    
    The FilterableRequestSpecification without the specified cookie
  - replaceHeader
```
public FilterableRequestSpecification replaceHeader(String headerName,
                                                    String newValue)
```
    Description copied from interface: FilterableRequestSpecification
    
    Replace a header with the new value. If the headerName doesn't exist the will be added.
    
    Specified by:
    
    replaceHeader in interface FilterableRequestSpecification
    
    Parameters:
    
    headerName - The header name to replace
    
    Returns:
    
    The FilterableRequestSpecification with the replaced header
  - replaceCookie
```
public FilterableRequestSpecification replaceCookie(String cookieName,
                                                    String value)
```
    Description copied from interface: FilterableRequestSpecification
    
    Replace a cookie with the given name. If the cookieName doesn't exist it will be added.
    
    Specified by:
    
    replaceCookie in interface FilterableRequestSpecification
    
    Parameters:
    
    cookieName - The cookie name
    
    Returns:
    
    The FilterableRequestSpecification with the replaced cookie
  - replaceCookie
```
public FilterableRequestSpecification replaceCookie(Cookie cookie)
```
    Description copied from interface: FilterableRequestSpecification
    
    Replace a cookie, if it doesn't exist then it will be added.
    
    Specified by:
    
    replaceCookie in interface FilterableRequestSpecification
    
    Parameters:
    
    cookie - The cookie
    
    Returns:
    
    The FilterableRequestSpecification with the replaced cookie
  - replaceHeaders
```
public FilterableRequestSpecification replaceHeaders(Headers headers)
```
    Description copied from interface: FilterableRequestSpecification
    
    Replace all defined headers
    
    Specified by:
    
    replaceHeaders in interface FilterableRequestSpecification
    
    Parameters:
    
    headers - The new headers
    
    Returns:
    
    The FilterableRequestSpecification with the replaced headers
  - replaceCookies
```
public FilterableRequestSpecification replaceCookies(Cookies cookies)
```
    Description copied from interface: FilterableRequestSpecification
    
    Replace all defined cookies
    
    Specified by:
    
    replaceCookies in interface FilterableRequestSpecification
    
    Parameters:
    
    cookies - The new cookies
    
    Returns:
    
    The FilterableRequestSpecification with the replaced cookies
  - removeHeaders
```
public FilterableRequestSpecification removeHeaders()
```
    Description copied from interface: FilterableRequestSpecification
    
    Removes all defined headers
    
    Specified by:
    
    removeHeaders in interface FilterableRequestSpecification
    
    Returns:
    
    The FilterableRequestSpecification without
  - removeCookies
```
public FilterableRequestSpecification removeCookies()
```
    Description copied from interface: FilterableRequestSpecification
    
    Removed all defined cookies
    
    Specified by:
    
    removeCookies in interface FilterableRequestSpecification
    
    Returns:
    
    The FilterableRequestSpecification with the replaced cookies
  - parameter
```
public RequestSpecification parameter(String parameterName,
                                      Object... parameterValues)
```
    Description copied from interface: RequestSpecification
    Specify a parameter that'll be sent with the request e.g:
```
 given().parameter("username", "John").and().expect().body(equalTo("username")).when().get("/cookie");
 
```
    This will set the parameter username=John in the GET request to "/cookie".
    
    You can also specify several parameters like this:
```
 given().parameter("username", "John").and().parameter("password", "1234").and().expect().body(equalTo("username")).when().get("/cookie");
 
```
    Specified by:
    
    parameter in interface RequestSpecification
    
    Parameters:
    
    parameterName - The parameter name
    
    parameterValues - Zero to many parameter values for this parameter name
    
    Returns:
    
    The request specification
    
    See Also:
    
    RequestSpecification.parameters(String, Object, Object...)
  - queryParameters
```
public RequestSpecification queryParameters(String firstParameterName,
                                            Object firstParameterValue,
                                            Object... parameterNameValuePairs)
```
    Description copied from interface: RequestSpecification
    
    Specify the query parameters that'll be sent with the request. Note that this method is the same as RequestSpecification.parameters(String, Object, Object...) for all http methods except for POST where RequestSpecification.parameters(String, Object, Object...) sets the form parameters and this method sets the query parameters.
    
    Specified by:
    
    queryParameters in interface RequestSpecification
    
    Parameters:
    
    firstParameterName - The name of the first parameter
    
    firstParameterValue - The value of the first parameter
    
    parameterNameValuePairs - The value of the first parameter followed by additional parameters in name-value pairs.
    
    Returns:
    
    The request specification
  - queryParameters
```
public RequestSpecification queryParameters(Map parametersMap)
```
    Description copied from interface: RequestSpecification
    
    Specify the query parameters that'll be sent with the request. Note that this method is the same as RequestSpecification.parameters(Map) for all http methods except for POST where RequestSpecification.parameters(Map) sets the form parameters and this method sets the query parameters.
    
    Specified by:
    
    queryParameters in interface RequestSpecification
    
    Parameters:
    
    parametersMap - The Map containing the parameter names and their values to send with the request.
    
    Returns:
    
    The request specification
  - queryParameter
```
public RequestSpecification queryParameter(String parameterName,
                                           Object... parameterValues)
```
    Description copied from interface: RequestSpecification
    
    Specify a query parameter that'll be sent with the request. Note that this method is the same as RequestSpecification.parameter(String, Object...) for all http methods except for POST where RequestSpecification.parameter(String, Object...) adds a form parameter and this method sets a query parameter.
    
    Specified by:
    
    queryParameter in interface RequestSpecification
    
    Parameters:
    
    parameterName - The parameter name
    
    parameterValues - Zero to many parameter values, i.e. you can specify multiple values for the same parameter
    
    Returns:
    
    The request specification
  - queryParams
```
public RequestSpecification queryParams(String firstParameterName,
                                        Object firstParameterValue,
                                        Object... parameterNameValuePairs)
```
    Description copied from interface: RequestSpecification
    
    Specify the query parameters that'll be sent with the request. Note that this method is the same as RequestSpecification.params(String, Object, Object...) for all http methods except for POST where RequestSpecification.params(String, Object, Object...) sets the form parameters and this method sets the query parameters.
    
    Specified by:
    
    queryParams in interface RequestSpecification
    
    Parameters:
    
    firstParameterName - The name of the first parameter
    
    firstParameterValue - The value of the first parameter
    
    parameterNameValuePairs - The value of the first parameter followed by additional parameters in name-value pairs.
    
    Returns:
    
    The request specification
    
    See Also:
    
    RequestSpecification.queryParameters(String, Object, Object...)
  - queryParams
```
public RequestSpecification queryParams(Map parametersMap)
```
    Description copied from interface: RequestSpecification
    
    Specify the query parameters that'll be sent with the request. Note that this method is the same as RequestSpecification.params(Map) for all http methods except for POST where RequestSpecification.params(Map) sets the form parameters and this method sets the query parameters.
    
    Specified by:
    
    queryParams in interface RequestSpecification
    
    Parameters:
    
    parametersMap - The Map containing the parameter names and their values to send with the request.
    
    Returns:
    
    The request specification
  - queryParam
```
public RequestSpecification queryParam(String parameterName,
                                       Object... parameterValues)
```
    Description copied from interface: RequestSpecification
    
    Specify a query parameter that'll be sent with the request. Note that this method is the same as RequestSpecification.param(String, Object...) for all http methods except for POST where RequestSpecification.param(String, Object...) adds a form parameter and this method sets a query parameter.
    
    Specified by:
    
    queryParam in interface RequestSpecification
    
    Parameters:
    
    parameterName - The parameter name
    
    parameterValues - Zero to many parameter values. Use additional parameter values if you want to specify multiple values for the same parameter
    
    Returns:
    
    The request specification
    
    See Also:
    
    RequestSpecification.param(String, Object...)
  - formParameter
```
public RequestSpecification formParameter(String parameterName,
                                          Collection<?> parameterValues)
```
    Description copied from interface: RequestSpecification
    Specify a multi-value form parameter that'll be sent with the request e.g:
```
 given().formParameter("cars", asList("Volvo", "Saab"))..;
 
```
    This will set the parameter cars=Volvo and cars=Saab.
    
    Note that this method is the same as RequestSpecification.parameter(String, java.util.Collection) for all http methods except for PUT where RequestSpecification.parameter(String, java.util.Collection) adds a query parameter and this method sets a form parameter.
    Specified by:
    
    formParameter in interface RequestSpecification
    
    Parameters:
    
    parameterName - The parameter name
    
    parameterValues - The parameter values
    
    Returns:
    
    The request specification
  - formParam
```
public RequestSpecification formParam(String parameterName,
                                      Collection<?> parameterValues)
```
    Description copied from interface: RequestSpecification
    Specify a multi-value form parameter that'll be sent with the request e.g:
```
 given().formParam("cars", asList("Volvo", "Saab"))..;
 
```
    This will set the parameter cars=Volvo and cars=Saab.
    
    Note that this method is the same as RequestSpecification.param(String, java.util.Collection) for all http methods except for PUT where RequestSpecification.param(String, java.util.Collection) adds a query parameter and this method sets a form parameter.
    Specified by:
    
    formParam in interface RequestSpecification
    
    Parameters:
    
    parameterName - The parameter name
    
    parameterValues - The parameter values
    
    Returns:
    
    The request specification
    
    See Also:
    
    RequestSpecification.formParam(String, java.util.Collection)
  - removeFormParam
```
public FilterableRequestSpecification removeFormParam(String parameterName)
```
    Description copied from interface: FilterableRequestSpecification
    
    Remove a form parameter from the request.
    
    Specified by:
    
    removeFormParam in interface FilterableRequestSpecification
    
    Parameters:
    
    parameterName - The parameter key
    
    Returns:
    
    The FilterableRequestSpecification without the parameter
  - formParameters
```
public RequestSpecification formParameters(String firstParameterName,
                                           Object firstParameterValue,
                                           Object... parameterNameValuePairs)
```
    Description copied from interface: RequestSpecification
    
    Specify the form parameters that'll be sent with the request. Note that this method is the same as RequestSpecification.parameters(String, Object, Object...) for all http methods except for PUT where RequestSpecification.parameters(String, Object, Object...) sets the query parameters and this method sets the form parameters.
    
    Specified by:
    
    formParameters in interface RequestSpecification
    
    Parameters:
    
    firstParameterName - The name of the first parameter
    
    firstParameterValue - The value of the first parameter
    
    parameterNameValuePairs - The value of the first parameter followed by additional parameters in name-value pairs.
    
    Returns:
    
    The request specification
  - formParameters
```
public RequestSpecification formParameters(Map parametersMap)
```
    Description copied from interface: RequestSpecification
    
    Specify the form parameters that'll be sent with the request. Note that this method is the same as RequestSpecification.parameters(Map) for all http methods except for PUT where RequestSpecification.parameters(Map) sets the query parameters and this method sets the form parameters.
    
    Specified by:
    
    formParameters in interface RequestSpecification
    
    Parameters:
    
    parametersMap - The Map containing the parameter names and their values to send with the request.
    
    Returns:
    
    The request specification
  - formParameter
```
public RequestSpecification formParameter(String parameterName,
                                          Object... additionalParameterValues)
```
    Description copied from interface: RequestSpecification
    
    Specify a form parameter that'll be sent with the request. Note that this method is the same as RequestSpecification.parameter(String, Object...) for all http methods except for PUT where RequestSpecification.parameter(String, Object...) adds a query parameter and this method sets a form parameter.
    
    Specified by:
    
    formParameter in interface RequestSpecification
    
    Parameters:
    
    parameterName - The parameter name
    
    additionalParameterValues - Zero to many parameter values for this parameter.
    
    Returns:
    
    The request specification
    
    See Also:
    
    RequestSpecification.parameter(String, Object...)
  - formParams
```
public RequestSpecification formParams(String firstParameterName,
                                       Object firstParameterValue,
                                       Object... parameterNameValuePairs)
```
    Description copied from interface: RequestSpecification
    
    Specify the form parameters that'll be sent with the request. Note that this method is the same as RequestSpecification.params(String, Object, Object...) for all http methods except for PUT where RequestSpecification.params(String, Object, Object...) sets the query parameters and this method sets the form parameters.
    
    Specified by:
    
    formParams in interface RequestSpecification
    
    Parameters:
    
    firstParameterName - The name of the first parameter
    
    firstParameterValue - The value of the first parameter
    
    parameterNameValuePairs - The value of the first parameter followed by additional parameters in name-value pairs.
    
    Returns:
    
    The request specification
    
    See Also:
    
    RequestSpecification.formParameters(String, Object, Object...)
  - formParams
```
public RequestSpecification formParams(Map parametersMap)
```
    Description copied from interface: RequestSpecification
    
    Specify the form parameters that'll be sent with the request. Note that this method is the same as RequestSpecification.parameters(Map) for all http methods except for PUT where RequestSpecification.params(Map) sets the query parameters and this method sets the form parameters.
    
    Specified by:
    
    formParams in interface RequestSpecification
    
    Parameters:
    
    parametersMap - The Map containing the form parameter names and their values to send with the request.
    
    Returns:
    
    The request specification
    
    See Also:
    
    RequestSpecification.formParams(java.util.Map)
  - formParam
```
public RequestSpecification formParam(String parameterName,
                                      Object... parameterValues)
```
    Description copied from interface: RequestSpecification
    
    Specify a form parameter that'll be sent with the request. Note that this method is the same as RequestSpecification.parameter(String, Object...) for all http methods except for PUT where RequestSpecification.param(String, Object...) adds a query parameter and this method sets a form parameter.
    
    Specified by:
    
    formParam in interface RequestSpecification
    
    Parameters:
    
    parameterName - The parameter name
    
    parameterValues - Zero to many parameter values. You can specify multiple values for the same parameter.
    
    Returns:
    
    The request specification
    
    See Also:
    
    RequestSpecification.param(String, Object...)
  - urlEncodingEnabled
```
public RequestSpecification urlEncodingEnabled(boolean isEnabled)
```
    Description copied from interface: RequestSpecification
    
    Specifies if Rest Assured should url encode the URL automatically. Usually this is a recommended but in some cases e.g. the query parameters are already be encoded before you provide them to Rest Assured then it's useful to disable URL encoding.
    
    Specified by:
    
    urlEncodingEnabled in interface RequestSpecification
    
    Parameters:
    
    isEnabled - Specify whether or not URL encoding should be enabled or disabled.
    
    Returns:
    
    the request specification
  - pathParameter
```
public RequestSpecification pathParameter(String parameterName,
                                          Object parameterValue)
```
    Description copied from interface: RequestSpecification
    Specify a path parameter. Path parameters are used to improve readability of the request path. E.g. instead of writing:
```
 expect().statusCode(200).when().get("/item/"+myItem.getItemNumber()+"/buy/"+2);
 
```
    you can write:
```
 given().
         pathParameter("itemNumber", myItem.getItemNumber()).
         pathParameter("amount", 2).
 expect().
          statusCode(200).
 when().
        get("/item/{itemNumber}/buy/{amount}");
 
```
    which improves readability and allows the path to be reusable in many tests. Another alternative is to use:
```
 expect().statusCode(200).when().get("/item/{itemNumber}/buy/{amount}", myItem.getItemNumber(), 2);
 
```
    Specified by:
    
    pathParameter in interface RequestSpecification
    
    Parameters:
    
    parameterName - The parameter name
    
    parameterValue - The parameter value
    
    Returns:
    
    The request specification
  - pathParameters
```
public RequestSpecification pathParameters(String firstParameterName,
                                           Object firstParameterValue,
                                           Object... parameterNameValuePairs)
```
    Description copied from interface: RequestSpecification
    Specify multiple path parameter name-value pairs. Path parameters are used to improve readability of the request path. E.g. instead of writing:
```
 expect().statusCode(200).when().get("/item/"+myItem.getItemNumber()+"/buy/"+2);
 
```
    you can write:
```
 given().
         pathParameters("itemNumber", myItem.getItemNumber(), "amount", 2).
 expect().
          statusCode(200).
 when().
        get("/item/{itemNumber}/buy/{amount}");
 
```
    which improves readability and allows the path to be reusable in many tests. Another alternative is to use:
```
 expect().statusCode(200).when().get("/item/{itemNumber}/buy/{amount}", myItem.getItemNumber(), 2);
 
```
    Specified by:
    
    pathParameters in interface RequestSpecification
    
    Parameters:
    
    firstParameterName - The name of the first parameter
    
    firstParameterValue - The value of the first parameter
    
    parameterNameValuePairs - Additional parameters in name-value pairs.
    
    Returns:
    
    The request specification
  - pathParameters
```
public RequestSpecification pathParameters(Map parameterNameValuePairs)
```
    Description copied from interface: RequestSpecification
    Specify multiple path parameter name-value pairs. Path parameters are used to improve readability of the request path. E.g. instead of writing:
```
 expect().statusCode(200).when().get("/item/"+myItem.getItemNumber()+"/buy/"+2);
 
```
    you can write:
```
 Map<String,Object> pathParams = new HashMap<String,Object>();
 pathParams.add("itemNumber",myItem.getItemNumber());
 pathParams.add("amount",2);

 given().
         pathParameters(pathParams).
 expect().
          statusCode(200).
 when().
        get("/item/{itemNumber}/buy/{amount}");
 
```
    which improves readability and allows the path to be reusable in many tests. Another alternative is to use:
```
 expect().statusCode(200).when().get("/item/{itemNumber}/buy/{amount}", myItem.getItemNumber(), 2);
 
```
    Specified by:
    
    pathParameters in interface RequestSpecification
    
    Parameters:
    
    parameterNameValuePairs - A map containing the path parameters.
    
    Returns:
    
    The request specification
  - pathParam
```
public RequestSpecification pathParam(String parameterName,
                                      Object parameterValue)
```
    Description copied from interface: RequestSpecification
    Specify a path parameter. Path parameters are used to improve readability of the request path. E.g. instead of writing:
```
 when().
        get("/item/"+myItem.getItemNumber()+"/buy/"+2).
 then().
        statusCode(200);
 
```
    you can write:
```
 given().
         pathParameter("itemNumber", myItem.getItemNumber()).
         pathParameter("amount", 2).
 when().
        get("/item/{itemNumber}/buy/{amount}").
 then().
          statusCode(200);
 
```
    which improves readability and allows the path to be reusable in many tests. Another alternative is to use:
```
 when().get("/item/{itemNumber}/buy/{amount}", myItem.getItemNumber(), 2).then().statusCode(200).;
 
```
    Specified by:
    
    pathParam in interface RequestSpecification
    
    Parameters:
    
    parameterName - The parameter name
    
    parameterValue - The parameter value
    
    Returns:
    
    The request specification
  - pathParams
```
public RequestSpecification pathParams(String firstParameterName,
                                       Object firstParameterValue,
                                       Object... parameterNameValuePairs)
```
    Description copied from interface: RequestSpecification
    Specify multiple path parameter name-value pairs. Path parameters are used to improve readability of the request path. E.g. instead of writing:
```
 when().
        get("/item/"+myItem.getItemNumber()+"/buy/"+2).
 then().
        statusCode(200).
 
```
    you can write:
```
 given().
         pathParams("itemNumber", myItem.getItemNumber(), "amount", 2).
 when().
        get("/item/{itemNumber}/buy/{amount}").
 then().
          statusCode(200);
 
```
    which improves readability and allows the path to be reusable in many tests. Another alternative is to use:
```
 when().get("/item/{itemNumber}/buy/{amount}", myItem.getItemNumber(), 2).then().statusCode(200);
 
```
    Specified by:
    
    pathParams in interface RequestSpecification
    
    Parameters:
    
    firstParameterName - The name of the first parameter
    
    firstParameterValue - The value of the first parameter
    
    parameterNameValuePairs - Additional parameters in name-value pairs.
    
    Returns:
    
    The request specification
  - pathParams
```
public RequestSpecification pathParams(Map parameterNameValuePairs)
```
    Description copied from interface: RequestSpecification
    Specify multiple path parameter name-value pairs. Path parameters are used to improve readability of the request path. E.g. instead of writing:
```
 when().
        get("/item/"+myItem.getItemNumber()+"/buy/"+2).
 then().
        statusCode(200);
 
```
    you can write:
```
 Map<String,Object> pathParams = new HashMap<String,Object>();
 pathParams.add("itemNumber",myItem.getItemNumber());
 pathParams.add("amount",2);

 given().
         pathParams(pathParams).
 when().
        get("/item/{itemNumber}/buy/{amount}").
 then().
          statusCode(200);
 
```
    which improves readability and allows the path to be reusable in many tests. Another alternative is to use:
```
 when().get("/item/{itemNumber}/buy/{amount}", myItem.getItemNumber(), 2).then().statusCode(200);
 
```
    Specified by:
    
    pathParams in interface RequestSpecification
    
    Parameters:
    
    parameterNameValuePairs - A map containing the path parameters.
    
    Returns:
    
    The request specification
    
    See Also:
    
    RequestSpecification.pathParameters(java.util.Map)
  - removePathParam
```
public FilterableRequestSpecification removePathParam(String parameterName)
```
    Description copied from interface: FilterableRequestSpecification
    
    Remove a path parameter from the request. It will remove both named and unnamed path parameters.
    
    Specified by:
    
    removePathParam in interface FilterableRequestSpecification
    
    Parameters:
    
    parameterName - The parameter key
    
    Returns:
    
    The FilterableRequestSpecification without the parameter
  - removeNamedPathParam
```
public FilterableRequestSpecification removeNamedPathParam(String parameterName)
```
    Description copied from interface: FilterableRequestSpecification
    
    Remove a named path parameter from the request. It will remove both named and unnamed path parameters.
    
    Specified by:
    
    removeNamedPathParam in interface FilterableRequestSpecification
    
    Parameters:
    
    parameterName - The parameter key
    
    Returns:
    
    The FilterableRequestSpecification without the parameter
  - removeUnnamedPathParam
```
public FilterableRequestSpecification removeUnnamedPathParam(String parameterName)
```
    Description copied from interface: FilterableRequestSpecification
    
    Remove an unnamed path parameter from the request.
    
    Specified by:
    
    removeUnnamedPathParam in interface FilterableRequestSpecification
    
    Parameters:
    
    parameterName - The parameter key
    
    Returns:
    
    The FilterableRequestSpecification without the parameter
  - removeUnnamedPathParamByValue
```
public FilterableRequestSpecification removeUnnamedPathParamByValue(String parameterValue)
```
    Description copied from interface: FilterableRequestSpecification
    
    Remove the first unnamed path parameter from the request based on its value.
    
    Specified by:
    
    removeUnnamedPathParamByValue in interface FilterableRequestSpecification
    
    Parameters:
    
    parameterValue - The parameter key
    
    Returns:
    
    The FilterableRequestSpecification without the parameter
  - config
```
public RequestSpecification config(RestAssuredConfig config)
```
    Description copied from interface: RequestSpecification
    Define a REST Assured configuration. E.g.
```
 given().config(config().redirect(redirectConfig().followRedirects(true).and().maxRedirects(0))). ..
 
```
    config() can be statically imported from RestAssuredConfig.
    Specified by:
    
    config in interface RequestSpecification
    
    Parameters:
    
    config - The configuration to use for this request. If null no config will be used.
    
    Returns:
    
    The request specification
  - keyStore
```
public RequestSpecification keyStore(String pathToJks,
                                     String password)
```
    Description copied from interface: RequestSpecification
    The following documentation is taken from https://github.com/jgritman/httpbuilder/wiki/SSL:
    
    SSL Configuration
    
    SSL should, for the most part, "just work." There are a few situations where it is not completely intuitive. You can follow the example below, or see HttpClient's SSLSocketFactory documentation for more information.
    
    SSLPeerUnverifiedException
    
    If you can't connect to an SSL website, it is likely because the certificate chain is not trusted. This is an Apache HttpClient issue, but explained here for convenience. To correct the untrusted certificate, you need to import a certificate into an SSL truststore.
    First, export a certificate from the website using your browser. For example, if you go to https://dev.java.net in Firefox, you will probably get a warning in your browser. Choose "Add Exception," "Get Certificate," "View," "Details tab." Choose a certificate in the chain and export it as a PEM file. You can view the details of the exported certificate like so:
```
 $ keytool -printcert -file EquifaxSecureGlobaleBusinessCA-1.crt
 Owner: CN=Equifax Secure Global eBusiness CA-1, O=Equifax Secure Inc., C=US
 Issuer: CN=Equifax Secure Global eBusiness CA-1, O=Equifax Secure Inc., C=US
 Serial number: 1
 Valid from: Mon Jun 21 00:00:00 EDT 1999 until: Sun Jun 21 00:00:00 EDT 2020
 Certificate fingerprints:
 MD5:  8F:5D:77:06:27:C4:98:3C:5B:93:78:E7:D7:7D:9B:CC
 SHA1: 7E:78:4A:10:1C:82:65:CC:2D:E1:F1:6D:47:B4:40:CA:D9:0A:19:45
 Signature algorithm name: MD5withRSA
 Version: 3
 ....
 
```
    Now, import that into a Java keystore file:
```
 $ keytool -importcert -alias "equifax-ca" -file EquifaxSecureGlobaleBusinessCA-1.crt -keystore truststore_javanet.jks -storepass test1234
 Owner: CN=Equifax Secure Global eBusiness CA-1, O=Equifax Secure Inc., C=US
 Issuer: CN=Equifax Secure Global eBusiness CA-1, O=Equifax Secure Inc., C=US
 Serial number: 1
 Valid from: Mon Jun 21 00:00:00 EDT 1999 until: Sun Jun 21 00:00:00 EDT 2020
 Certificate fingerprints:
 MD5:  8F:5D:77:06:27:C4:98:3C:5B:93:78:E7:D7:7D:9B:CC
 SHA1: 7E:78:4A:10:1C:82:65:CC:2D:E1:F1:6D:47:B4:40:CA:D9:0A:19:45
 Signature algorithm name: MD5withRSA
 Version: 3
 ...
 Trust this certificate? [no]:  yes
 Certificate was added to keystore
 
```
    Now you want to use this truststore in your client:
```
 RestAssured.keyStore("/truststore_javanet.jks", "test1234");
 
```
    or
```
 given().keyStore("/truststore_javanet.jks", "test1234"). ..
 
```
    Note that this is just a shortcut for:
```
 given().config(RestAssured.config().sslConfig(sslConfig().keyStore(pathToJks, password));
 
```
    Specified by:
    
    keyStore in interface RequestSpecification
    
    Parameters:
    
    pathToJks - The path to the JKS. The path to the JKS. REST Assured will first look in the classpath and if not found it will look for the JKS in the local file-system.
    
    password - The store pass
    
    Returns:
    
    The request specification
  - keyStore
```
public RequestSpecification keyStore(File pathToJks,
                                     String password)
```
    Description copied from interface: RequestSpecification
    Use a keystore located on the file-system. See RequestSpecification.keyStore(String, String) for more details.
    Note that this is just a shortcut for:
```
 given().config(RestAssured.config().sslConfig(sslConfig().keyStore(pathToJks, password));
 
```
    Specified by:
    
    keyStore in interface RequestSpecification
    
    Parameters:
    
    pathToJks - The path to JKS file on the file-system
    
    password - The password for the keystore
    
    Returns:
    
    The request specification
    
    See Also:
    
    RequestSpecification.keyStore(String, String)
  - trustStore
```
public RequestSpecification trustStore(String path,
                                       String password)
```
    Description copied from interface: RequestSpecification
    Apply a trust store. For example
```
 given().trustStore("/truststore_javanet.jks", "test1234"). ..
 
```
    Note that this is just a shortcut for:
```
 given().config(RestAssured.config().sslConfig(sslConfig().trustStore(pathToJks, password));
 
```
    Specified by:
    
    trustStore in interface RequestSpecification
    
    Parameters:
    
    path - The path to the trust store. REST Assured will first look in the classpath and if not found it will look for the JKS in the local file-system.
    
    password - The store pass
    
    Returns:
    
    The request specification
  - trustStore
```
public RequestSpecification trustStore(File path,
                                       String password)
```
    Description copied from interface: RequestSpecification
    Use a trust store located on the file-system. See RequestSpecification.trustStore(String, String) for more details.
    Note that this is just a shortcut for:
```
 given().config(RestAssured.config().sslConfig(sslConfig().trustStore(pathToJks, password));
 
```
    Specified by:
    
    trustStore in interface RequestSpecification
    
    Parameters:
    
    path - The path to trust storefile on the file-system
    
    password - The password for the keystore
    
    Returns:
    
    The request specification
    
    See Also:
    
    RequestSpecification.keyStore(String, String)
  - trustStore
```
public RequestSpecification trustStore(KeyStore trustStore)
```
    Description copied from interface: RequestSpecification
    Use the supplied truststore for HTTPS requests. Shortcut for:
```
 given().config(RestAssured.config().sslConfig(sslConfig().trustStore(truststore));
 
```
    Specified by:
    
    trustStore in interface RequestSpecification
    
    Parameters:
    
    trustStore - The truststore.
    
    Returns:
    
    The request specification
    
    See Also:
    
    RequestSpecification.keyStore(String, String)
  - keyStore
```
public RequestSpecification keyStore(KeyStore keyStore)
```
    Description copied from interface: RequestSpecification
    Use the supplied keystore for HTTPS requests. Shortcut for:
```
 given().config(RestAssured.config().sslConfig(sslConfig().keyStore(keyStore));
 
```
    Specified by:
    
    keyStore in interface RequestSpecification
    
    Parameters:
    
    keyStore - The keyStore.
    
    Returns:
    
    The request specification
    
    See Also:
    
    RequestSpecification.keyStore(String, String)
  - relaxedHTTPSValidation
```
public RequestSpecification relaxedHTTPSValidation()
```
    Description copied from interface: RequestSpecification
    Use relaxed HTTP validation with SSLContext protocol SSL. This means that you'll trust all hosts regardless if the SSL certificate is invalid. By using this method you don't need to specify a keystore (see RequestSpecification.keyStore(String, String) or trust store (see RequestSpecification.trustStore(java.security.KeyStore).
    This is just a shortcut for:
```
 given().config(RestAssured.config().sslConfig(sslConfig().relaxedHTTPSValidation())). ..;
 
```
    Specified by:
    
    relaxedHTTPSValidation in interface RequestSpecification
    
    Returns:
    
    The request specification
  - relaxedHTTPSValidation
```
public RequestSpecification relaxedHTTPSValidation(String protocol)
```
    Description copied from interface: RequestSpecification
    Use relaxed HTTP validation with the given SSLContext protocol. This means that you'll trust all hosts regardless if the SSL certificate is invalid. By using this method you don't need to specify a keystore (see RequestSpecification.keyStore(String, String) or trust store (see RequestSpecification.trustStore(java.security.KeyStore).
    This is just a shortcut for:
```
 given().config(RestAssured.config().sslConfig(sslConfig().relaxedHTTPSValidation(<protocol>))). ..;
 
```
    Specified by:
    
    relaxedHTTPSValidation in interface RequestSpecification
    
    Parameters:
    
    protocol - The standard name of the requested protocol. See the SSLContext section in the Java Cryptography Architecture Standard Algorithm Name Documentation for information about standard protocol names.
    
    Returns:
    
    The request specification
  - filter
```
public RequestSpecification filter(Filter filter)
```
    Description copied from interface: RequestSpecification
    
    Add a filter that will be used in the request.
    
    Specified by:
    
    filter in interface RequestSpecification
    
    Parameters:
    
    filter - The filter to add
    
    Returns:
    
    the request specification
  - filters
```
public RequestSpecification filters(List<Filter> filters)
```
    Description copied from interface: RequestSpecification
    
    Add filters that will be used in the request.
    
    Specified by:
    
    filters in interface RequestSpecification
    
    Parameters:
    
    filters - The filters to add
    
    Returns:
    
    the request specification
  - filters
```
public RequestSpecification filters(Filter filter,
                                    Filter... additionalFilter)
```
    Description copied from interface: RequestSpecification
    
    Add filters that will be used in the request.
    
    Specified by:
    
    filters in interface RequestSpecification
    
    Parameters:
    
    filter - The filter to add
    
    additionalFilter - Additional filters to add
    
    Returns:
    
    the request specification
  - log
```
public RequestLogSpecification log()
```
    Description copied from interface: RequestSpecification
    Returns the RequestLogSpecification that allows you to log different parts of the RequestSpecification. This is mainly useful for debug purposes when writing your tests. It's a shortcut for:
```
 given().filter(new RequestLoggingFilter(..))). ..
 
```
    Specified by:
    
    log in interface RequestSpecification
    
    Returns:
    
    the request log specification
  - and
```
public RequestSpecification and()
```
    Description copied from interface: RequestSpecification
    Syntactic sugar, e.g.
```
 expect().body(containsString("OK")).and().body(containsString("something else")).when().get("/something");
 
```
    is that same as:
```
 expect().body(containsString("OK")).body(containsString("something else")).when().get("/something");
 
```
    Specified by:
    
    and in interface RequestSpecification
    
    Returns:
    
    the request specification
  - request
```
public RequestSpecification request()
```
    Description copied from interface: RequestSpecification
    Syntactic sugar, e.g.
```
 given().request().param("name", "John").then().expect().body(containsString("OK")).when().get("/something");
 
```
    is that same as:
```
 given().param("name", "John").then().expect().body(containsString("OK")).when().get("/something");
 
```
    Specified by:
    
    request in interface RequestSpecification
    
    Returns:
    
    the request specification
  - with
```
public RequestSpecification with()
```
    Description copied from interface: RequestSpecification
    Syntactic sugar, e.g.
```
 expect().body(containsString("OK")).and().with().request().parameters("param1", "value1").get("/something");
 
```
    is that same as:
```
 expect().body(containsString("OK")).and().request().parameters("param1", "value1").get("/something");
 
```
    Specified by:
    
    with in interface RequestSpecification
    
    Returns:
    
    the request specification
  - then
```
public ResponseSpecification then()
```
    Description copied from interface: RequestSpecification
    Returns the response specification so that you can setup the expectations on the response. E.g.
```
 given().param("name", "value").then().body(equalTo("something")).when().get("/something");
 
```
    Specified by:
    
    then in interface RequestSpecification
    
    Returns:
    
    the response specification
  - expect
```
public ResponseSpecification expect()
```
    Description copied from interface: RequestSpecification
    Returns the response specification so that you can setup the expectations on the response. E.g.
```
 given().param("name", "value").and().expect().body(equalTo("something")).when().get("/something");
 
```
    Specified by:
    
    expect in interface RequestSpecification
    
    Returns:
    
    the response specification
  - auth
```
public AuthenticationSpecification auth()
```
    Description copied from interface: RequestSpecification
    
    Specify authentication credentials when performing a request.
    
    Specified by:
    
    auth in interface RequestSpecification
    
    Returns:
    
    The authentication specification
    
    See Also:
    
    AuthenticationSpecification
  - authentication
```
public AuthenticationSpecification authentication()
```
    Description copied from interface: RequestSpecification
    
    If you need to specify some credentials when performing a request.
    
    Specified by:
    
    authentication in interface RequestSpecification
    
    Returns:
    
    The authentication specification
    
    See Also:
    
    AuthenticationSpecification
  - port
```
public RequestSpecification port(int port)
```
    Description copied from interface: RequestSpecification
    Specify the port of the URI. E.g.
```
 given().port(8081).and().expect().statusCode(200).when().get("/something");
 
```
    will perform a GET request to http;//localhost:8081/something. It will override the default port of REST assured for this request only.
    
    Note that it's also possible to specify the port like this:
```
 expect().statusCode(200).when().get("http://localhost:8081/something");
 
```
    Specified by:
    
    port in interface RequestSpecification
    
    Parameters:
    
    port - The port of URI
    
    Returns:
    
    The request specification
  - body
```
public RequestSpecification body(String body)
```
    Description copied from interface: RequestSpecification
    Specify a String request body (such as e.g. JSON or XML) that'll be sent with the request. This works for the POST and PUT methods only. Trying to do this for the other http methods will cause an exception to be thrown.
    Example of use:
```
 given().body("{ \"message\" : \"hello world\"}").when().post("/json").then().assertThat().body(equalTo("hello world"));
 
```
    This will POST a request containing JSON to "/json" and expect that the response body equals to "hello world".
    Specified by:
    
    body in interface RequestSpecification
    
    Parameters:
    
    body - The body to send.
    
    Returns:
    
    The request specification
  - content
```
public RequestSpecification content(String content)
```
    Description copied from interface: RequestSpecification
    Specify a String request content (such as e.g. JSON or XML) that'll be sent with the request. This works for the POST, PATCH and PUT methods only. Trying to do this for the other http methods will cause an exception to be thrown.
    Example of use:
```
 given().content("{ \"message\" : \"hello world\"}").then().expect().content(equalTo("hello world")).when().post("/json");
 
```
    This will POST a request containing JSON to "/json" and expect that the response content equals to "hello world".
    
    Note that RequestSpecification.body(String) and this method are the same except for the syntactic difference.
    Specified by:
    
    content in interface RequestSpecification
    
    Parameters:
    
    content - The content to send.
    
    Returns:
    
    The request specification
  - baseUri
```
public RequestSpecification baseUri(String baseUri)
```
    Description copied from interface: RequestSpecification
    
    Adding the baseUri Property from the RequestSpecification instead of using static field RestAssured.baseURI.
    
    Specified by:
    
    baseUri in interface RequestSpecification
    
    Parameters:
    
    baseUri - The uri
    
    Returns:
    
    the request specification
  - basePath
```
public RequestSpecification basePath(String basePath)
```
    Description copied from interface: RequestSpecification
    
    Set the basePath property of the RequestSpecification instead of using static field RestAssured.basePath.
    
    Specified by:
    
    basePath in interface RequestSpecification
    
    Parameters:
    
    basePath - The base path
    
    Returns:
    
    the request specification
  - proxy
```
public RequestSpecification proxy(String host,
                                  int port)
```
    Description copied from interface: RequestSpecification
    
    Instruct REST Assured to connect to a proxy on the specified host and port.
    
    Specified by:
    
    proxy in interface RequestSpecification
    
    Parameters:
    
    host - The hostname of the proxy to connect to (for example 127.0.0.1)
    
    port - The port of the proxy to connect to (for example 8888)
    
    Returns:
    
    the request specification
  - proxy
```
public RequestSpecification proxy(String host)
```
    Description copied from interface: RequestSpecification
    
    Instruct REST Assured to connect to a proxy on the specified host on port 8888.
    
    Specified by:
    
    proxy in interface RequestSpecification
    
    Parameters:
    
    host - The hostname of the proxy to connect to (for example 127.0.0.1). Can also be a URI represented as a String.
    
    Returns:
    
    the request specification
    
    See Also:
    
    RequestSpecification.proxy(String, int)
  - proxy
```
public RequestSpecification proxy(int port)
```
    Description copied from interface: RequestSpecification
    
    Instruct REST Assured to connect to a proxy on the specified port on localhost.
    
    Specified by:
    
    proxy in interface RequestSpecification
    
    Parameters:
    
    port - The port of the proxy to connect to (for example 8888)
    
    Returns:
    
    the request specification
    
    See Also:
    
    RequestSpecification.proxy(String, int)
  - proxy
```
public RequestSpecification proxy(String host,
                                  int port,
                                  String scheme)
```
    Description copied from interface: RequestSpecification
    
    Instruct REST Assured to connect to a proxy on the specified port on localhost with a specific scheme.
    
    Specified by:
    
    proxy in interface RequestSpecification
    
    Parameters:
    
    host - The hostname of the proxy to connect to (for example 127.0.0.1)
    
    port - The port of the proxy to connect to (for example 8888)
    
    scheme - The http scheme (http or https)
    
    Returns:
    
    the request specification
  - proxy
```
public RequestSpecification proxy(URI uri)
```
    Description copied from interface: RequestSpecification
    
    Instruct REST Assured to connect to a proxy using a URI.
    
    Specified by:
    
    proxy in interface RequestSpecification
    
    Parameters:
    
    uri - The URI of the proxy
    
    Returns:
    
    the request specification
  - proxy
```
public RequestSpecification proxy(ProxySpecification proxySpecification)
```
    Description copied from interface: RequestSpecification
    Instruct REST Assured to connect to a proxy using a ProxySpecification. For example:
```
 given().
         proxy(host("localhost").and().withPort(8888).and().withScheme("http")).
         param("firstName", "John").
         param("lastName", "Doe").
 when().
         get("/greetJSON").
 then().
         body("greeting.firstName", equalTo("John")).
         body("greeting.lastName", equalTo("Doe"));
 
```
    where host is statically imported from ProxySpecification.host(String).
    Specified by:
    
    proxy in interface RequestSpecification
    
    Parameters:
    
    proxySpecification - The proxy specification to use.
    
    Returns:
    
    the request specification
  - body
```
public RequestSpecification body(byte... body)
```
    Description copied from interface: RequestSpecification
    Specify a byte array request body that'll be sent with the request. This only works for the POST http method. Trying to do this for the other http methods will cause an exception to be thrown.
    Example of use:
```
 byte[] someBytes = ..
 given().body(someBytes).then().expect().body(equalTo("hello world")).when().post("/json");
 
```
    This will POST a request containing someBytes to "/json" and expect that the response body equals to "hello world".
    
    Note that this method and RequestSpecification.content(byte[]) are the same except for the syntactic difference.
    Specified by:
    
    body in interface RequestSpecification
    
    Parameters:
    
    body - The body to send.
    
    Returns:
    
    The request specification
  - body
```
public RequestSpecification body(File body)
```
    Description copied from interface: RequestSpecification
    Specify file content that'll be sent with the request. This only works for the POST, PATCH and PUT http method. Trying to do this for the other http methods will cause an exception to be thrown.
    Example of use:
```
 File myFile = ..
 given().body(myFile).when().post("/json").then().content(equalTo("hello world"));
 
```
    This will POST a request containing myFile to "/json" and expect that the response content equals to "hello world".
    Specified by:
    
    body in interface RequestSpecification
    
    Parameters:
    
    body - The content to send.
    
    Returns:
    
    The request specification
  - body
```
public RequestSpecification body(InputStream body)
```
    Description copied from interface: RequestSpecification
    Specify file content that'll be sent with the request. This only works for the POST, PATCH and PUT http method. Trying to do this for the other http methods will cause an exception to be thrown.
    Example of use:
```
 InputStream myInputStream = ..
 given().body(myInputStream).when().post("/json").then().content(equalTo("hello world"));
 
```
    This will POST a request containing myInputStream to "/json" and expect that the response content equals to "hello world".
    Specified by:
    
    body in interface RequestSpecification
    
    Parameters:
    
    body - The content to send.
    
    Returns:
    
    The request specification
  - content
```
public RequestSpecification content(byte... content)
```
    Description copied from interface: RequestSpecification
    Specify a byte array request content that'll be sent with the request. This only works for the POST, PATCH and PUT http method. Trying to do this for the other http methods will cause an exception to be thrown.
    Example of use:
```
 byte[] someBytes = ..
 given().content(someBytes).then().expect().content(equalTo("hello world")).when().post("/json");
 
```
    This will POST a request containing someBytes to "/json" and expect that the response content equals to "hello world".
    
    Note that RequestSpecification.body(byte[]) and this method are the same except for the syntactic difference.
    Specified by:
    
    content in interface RequestSpecification
    
    Parameters:
    
    content - The content to send.
    
    Returns:
    
    The request specification
  - content
```
public RequestSpecification content(File content)
```
    Description copied from interface: RequestSpecification
    Specify file content that'll be sent with the request. This only works for the POST, PATCH and PUT http method. Trying to do this for the other http methods will cause an exception to be thrown.
    Example of use:
```
 File myFile = ..
 given().content(myFile).when().post("/json").then().content(equalTo("hello world"));
 
```
    This will POST a request containing myFile to "/json" and expect that the response content equals to "hello world".
    
    Note that RequestSpecification.body(File) and this method are the same except for the syntactic difference.
    Specified by:
    
    content in interface RequestSpecification
    
    Parameters:
    
    content - The content to send.
    
    Returns:
    
    The request specification
  - content
```
public RequestSpecification content(InputStream content)
```
    Description copied from interface: RequestSpecification
    Specify file content that'll be sent with the request. This only works for the POST, PATCH and PUT http method. Trying to do this for the other http methods will cause an exception to be thrown.
    Example of use:
```
 InputStream myInputStream = ..
 given().content(myInputStream).when().post("/json").then().content(equalTo("hello world"));
 
```
    This will POST a request containing myInputStream to "/json" and expect that the response content equals to "hello world".
    
    Note that RequestSpecification.body(java.io.InputStream) and this method are the same except for the syntactic difference.
    Specified by:
    
    content in interface RequestSpecification
    
    Parameters:
    
    content - The content to send.
    
    Returns:
    
    The request specification
  - body
```
public RequestSpecification body(Object object)
```
    Description copied from interface: RequestSpecification
    Specify an Object request content that will automatically be serialized to JSON or XML and sent with the request. If the object is a primitive or Number the object will be converted to a String and put in the request body. This works for the POST and PUT methods only. Trying to do this for the other http methods will cause an exception to be thrown.
    Example of use:
```
 Message message = new Message();
 message.setMessage("My beautiful message");

 given().
         contentType("application/json").
         body(message).
 when().
         post("/beautiful-message").
 then().
         body(equalTo("Response to a beautiful message")).
 
```
    Since the content-type is "application/json" then REST Assured will automatically try to serialize the object using Jackson or Gson if they are available in the classpath. If any of these frameworks are not in the classpath then an exception is thrown.
    If the content-type is "application/xml" then REST Assured will automatically try to serialize the object using JAXB if it's available in the classpath. Otherwise an exception will be thrown.
    If no request content-type is specified then REST Assured determine the parser in the following order:
    1. Jackson
    2. Gson
    3. JAXB
    Specified by:
    
    body in interface RequestSpecification
    
    Parameters:
    
    object - The object to serialize and send with the request
    
    Returns:
    
    The request specification
  - content
```
public RequestSpecification content(Object object)
```
    Description copied from interface: RequestSpecification
    Specify an Object request content that will automatically be serialized to JSON or XML and sent with the request. If the object is a primitive or Number the object will be converted to a String and put in the request body. This works for the POST and PUT methods only. Trying to do this for the other http methods will cause an exception to be thrown.
    Example of use:
```
 Message message = new Message();
 message.setMessage("My beautiful message");

 given().
         contentType("application/json").
         content(message).
 expect().
         content(equalTo("Response to a beautiful message")).
 when().
         post("/beautiful-message");
 
```
    Since the content-type is "application/json" then REST Assured will automatically try to serialize the object using Jackson or Gson if they are available in the classpath. If any of these frameworks are not in the classpath then an exception is thrown.
    If the content-type is "application/xml" then REST Assured will automatically try to serialize the object using JAXB if it's available in the classpath. Otherwise an exception will be thrown.
    If no request content-type is specified then REST Assured determine the parser in the following order:
    1. Jackson
    2. Gson
    3. JAXB
    Note that RequestSpecification.body(Object) and this method are the same except for the syntactic difference.
    Specified by:
    
    content in interface RequestSpecification
    
    Parameters:
    
    object - The object to serialize and send with the request
    
    Returns:
    
    The request specification
  - body
```
public RequestSpecification body(Object object,
                                 ObjectMapper mapper)
```
    Description copied from interface: RequestSpecification
    Specify an Object request content that will automatically be serialized to JSON or XML and sent with the request using a specific object mapper. This works for the POST, PATCH and PUT methods only. Trying to do this for the other http methods will cause an exception to be thrown.
    Example of use:
```
 Message message = new Message();
 message.setMessage("My beautiful message");

 given().
         body(message, new MyObjectMapper()).
 when().
         post("/beautiful-message").
 then().
         body(equalTo("Response to a beautiful message")).
 
```
    Note that this method and RequestSpecification.content(Object, ObjectMapperType) are the same except for the syntactic difference.
    Specified by:
    
    body in interface RequestSpecification
    
    Parameters:
    
    object - The object to serialize and send with the request
    
    mapper - The object mapper
    
    Returns:
    
    The request specification
  - body
```
public RequestSpecification body(Object object,
                                 ObjectMapperType mapperType)
```
    Description copied from interface: RequestSpecification
    Specify an Object request content that will automatically be serialized to JSON or XML and sent with the request using a specific object mapper type. This works for the POST, PATCH and PUT methods only. Trying to do this for the other http methods will cause an exception to be thrown.
    Example of use:
```
 Message message = new Message();
 message.setMessage("My beautiful message");

 given().
         body(message, ObjectMapper.GSON).
 when().
         post("/beautiful-message").
 when().
         body(equalTo("Response to a beautiful message")).
 
```
    Specified by:
    
    body in interface RequestSpecification
    
    Parameters:
    
    object - The object to serialize and send with the request
    
    mapperType - The object mapper type to be used
    
    Returns:
    
    The request specification
  - content
```
public RequestSpecification content(Object object,
                                    ObjectMapper mapper)
```
    Description copied from interface: RequestSpecification
    Specify an Object request content that will automatically be serialized to JSON or XML and sent with the request using a specific object mapper. This works for the POST, PATCH and PUT methods only. Trying to do this for the other http methods will cause an exception to be thrown.
    Example of use:
```
 Message message = new Message();
 message.setMessage("My beautiful message");

 given().
         content(message, new MyObjectMapper()).
 expect().
         content(equalTo("Response to a beautiful message")).
 when().
         post("/beautiful-message");
 
```
    Note that RequestSpecification.body(Object, ObjectMapper) and this method are the same except for the syntactic difference.
    Specified by:
    
    content in interface RequestSpecification
    
    Parameters:
    
    object - The object to serialize and send with the request
    
    Returns:
    
    The request specification
  - content
```
public RequestSpecification content(Object object,
                                    ObjectMapperType mapperType)
```
    Description copied from interface: RequestSpecification
    Specify an Object request content that will automatically be serialized to JSON or XML and sent with the request using a specific object mapper type. This works for the POST, PATCH and PUT methods only. Trying to do this for the other http methods will cause an exception to be thrown.
    Example of use:
```
 Message message = new Message();
 message.setMessage("My beautiful message");

 given().
         content(message, ObjectMapperType.GSON).
 expect().
         content(equalTo("Response to a beautiful message")).
 when().
         post("/beautiful-message");
 
```
    Note that RequestSpecification.body(Object, ObjectMapperType) and this method are the same except for the syntactic difference.
    Specified by:
    
    content in interface RequestSpecification
    
    Parameters:
    
    object - The object to serialize and send with the request
    
    mapperType - The object mapper type to use
    
    Returns:
    
    The request specification
  - contentType
```
public RequestSpecification contentType(ContentType contentType)
```
    Description copied from interface: RequestSpecification
    
    Specify the content type of the request.
    
    Specified by:
    
    contentType in interface RequestSpecification
    
    Parameters:
    
    contentType - The content type of the request
    
    Returns:
    
    The request specification
    
    See Also:
    
    ContentType
  - contentType
```
public RequestSpecification contentType(String contentType)
```
    Description copied from interface: RequestSpecification
    
    Specify the content type of the request.
    
    Specified by:
    
    contentType in interface RequestSpecification
    
    Parameters:
    
    contentType - The content type of the request
    
    Returns:
    
    The request specification
    
    See Also:
    
    ContentType
  - accept
```
public RequestSpecification accept(ContentType contentType)
```
    Description copied from interface: RequestSpecification
    Specify the accept header of the request. This just a shortcut for:
```
 header("Accept", contentType);
 
```
    Specified by:
    
    accept in interface RequestSpecification
    
    Parameters:
    
    contentType - The content type whose accept header ContentType.getAcceptHeader() will be used as Accept header in the request.
    
    Returns:
    
    The request specification
    
    See Also:
    
    ContentType, RequestSpecification.header(String, Object, Object...)
  - accept
```
public RequestSpecification accept(String mediaTypes)
```
    Description copied from interface: RequestSpecification
    Specify the accept header of the request. This just a shortcut for:
```
 header("Accept", contentType);
 
```
    Specified by:
    
    accept in interface RequestSpecification
    
    Parameters:
    
    mediaTypes - The media type(s) that will be used as Accept header in the request.
    
    Returns:
    
    The request specification
    
    See Also:
    
    ContentType, RequestSpecification.header(String, Object, Object...)
  - headers
```
public RequestSpecification headers(Map headers)
```
    Description copied from interface: RequestSpecification
    Specify the headers that'll be sent with the request as Map e.g:
```
 Map<String, String> headers = new HashMap<String, String>();
 parameters.put("headerName1", "headerValue1");
 parameters.put("headerName2", "headerValue2");
 given().headers(headers).then().expect().body(equalTo("something")).when().get("/headers");
 
```
    This will send a GET request to "/headers" with two headers:
    1. headerName1=headerValue1
    2. headerName2=headerValue2
    and expect that the response body is equal to "something".
    Specified by:
    
    headers in interface RequestSpecification
    
    Parameters:
    
    headers - The Map containing the header names and their values to send with the request.
    
    Returns:
    
    The request specification
  - headers
```
public RequestSpecification headers(Headers headers)
```
    Description copied from interface: RequestSpecification
    Specify the headers that'll be sent with the request as Headers, e.g:
```
 Header first = new Header("headerName1", "headerValue1");
 Header second = new Header("headerName2", "headerValue2");
 Headers headers = new Header(first, second);
 given().headers(headers).then().expect().body(equalTo("something")).when().get("/headers");
 
```
    This will send a GET request to "/headers" with two headers:
    1. headerName1=headerValue1
    2. headerName2=headerValue2
    and expect that the response body is equal to "something".
    Specified by:
    
    headers in interface RequestSpecification
    
    Parameters:
    
    headers - The headers to use in the request
    
    Returns:
    
    The request specification
  - header
```
public RequestSpecification header(String headerName,
                                   Object headerValue,
                                   Object... additionalHeaderValues)
```
    Description copied from interface: RequestSpecification
    Specify a header that'll be sent with the request e.g:
```
 given().header("username", "John").and().expect().body(equalTo("something")).when().get("/header");
 
```
    This will set the header username=John in the GET request to "/header".
    
    You can also specify several headers like this:
```
 given().header("username", "John").and().header("zipCode", "12345").and().expect().body(equalTo("something")).when().get("/header");
 
```
    If you specify additionalHeaderValues then the Header will be a multi-value header. This means that you'll create several headers with the same name but with different values.
    Specified by:
    
    header in interface RequestSpecification
    
    Parameters:
    
    headerName - The header name
    
    headerValue - The header value
    
    additionalHeaderValues - Additional header values. This will actually create two headers with the same name but with different values.
    
    Returns:
    
    The request specification
    
    See Also:
    
    RequestSpecification.headers(String, Object, Object...)
  - header
```
public RequestSpecification header(Header header)
```
    Description copied from interface: RequestSpecification
    Specify a Header to send with the request.
```
 Header someHeader = new Header("some_name", "some_value");
 given().header(someHeader).and().expect().body(equalTo("x")).when().get("/header");
 
```
    This will set the header some_name=some_value in the GET request to "/header".
    Specified by:
    
    header in interface RequestSpecification
    
    Parameters:
    
    header - The header to add to the request
    
    Returns:
    
    The request specification
    
    See Also:
    
    RequestSpecification.headers(Headers)
  - headers
```
public RequestSpecification headers(String firstHeaderName,
                                    Object firstHeaderValue,
                                    Object... headerNameValuePairs)
```
    Description copied from interface: RequestSpecification
    Specify the headers that'll be sent with the request. This is done by specifying the headers in name-value pairs, e.g:
```
 given().headers("headerName1", "headerValue1", "headerName2", "headerValue2").then().expect().body(equalTo("something")).when().get("/headers");
 
```
    This will send a GET request to "/headers" with two headers:
    1. headerName1=headerValue1
    2. headerName2=headerValue2
    and expect that the response body is equal to "something".
    Specified by:
    
    headers in interface RequestSpecification
    
    Parameters:
    
    firstHeaderName - The name of the first header
    
    firstHeaderValue - The value of the first header
    
    headerNameValuePairs - Additional headers in name-value pairs.
    
    Returns:
    
    The request specification
  - cookies
```
public RequestSpecification cookies(String firstCookieName,
                                    Object firstCookieValue,
                                    Object... cookieNameValuePairs)
```
    Description copied from interface: RequestSpecification
    Specify the cookies that'll be sent with the request. This is done by specifying the cookies in name-value pairs, e.g:
```
 given().cookies("username", "John", "token", "1234").then().expect().body(equalTo("username, token")).when().get("/cookie");
 
```
    This will send a GET request to "/cookie" with two cookies:
    1. username=John
    2. token=1234
    and expect that the response body is equal to "username, token".
    Specified by:
    
    cookies in interface RequestSpecification
    
    Parameters:
    
    firstCookieName - The name of the first cookie
    
    firstCookieValue - The value of the first cookie
    
    cookieNameValuePairs - Additional cookies in name-value pairs.
    
    Returns:
    
    The request specification
  - cookies
```
public RequestSpecification cookies(Map cookies)
```
    Description copied from interface: RequestSpecification
    Specify the cookies that'll be sent with the request as Map e.g:
```
 Map<String, String> cookies = new HashMap<String, String>();
 cookies.put("username", "John");
 cookies.put("token", "1234");
 given().cookies(cookies).then().expect().body(equalTo("username, token")).when().get("/cookie");
 
```
    This will send a GET request to "/cookie" with two cookies:
    1. username=John
    2. token=1234
    and expect that the response body is equal to "username, token".
    Specified by:
    
    cookies in interface RequestSpecification
    
    Parameters:
    
    cookies - The Map containing the cookie names and their values to set in the request.
    
    Returns:
    
    The request specification
  - cookies
```
public RequestSpecification cookies(Cookies cookies)
```
    Description copied from interface: RequestSpecification
    Specify the cookies that'll be sent with the request as Cookies:
```
 Cookie cookie1 = Cookie.Builder("username", "John").setComment("comment 1").build();
 Cookie cookie2 = Cookie.Builder("token", 1234).setComment("comment 2").build();
 Cookies cookies = new Cookies(cookie1, cookie2);
 given().cookies(cookies).then().expect().body(equalTo("username, token")).when().get("/cookie");
 
```
    This will send a GET request to "/cookie" with two cookies:
    1. username=John
    2. token=1234
    and expect that the response body is equal to "username, token".
    Specified by:
    
    cookies in interface RequestSpecification
    
    Parameters:
    
    cookies - The cookies to set in the request.
    
    Returns:
    
    The request specification
  - cookie
```
public RequestSpecification cookie(String cookieName,
                                   Object value,
                                   Object... additionalValues)
```
    Description copied from interface: RequestSpecification
    Specify a cookie that'll be sent with the request e.g:
```
 given().cookie("username", "John").and().expect().body(equalTo("username")).when().get("/cookie");
 
```
    This will set the cookie username=John in the GET request to "/cookie".
    
    You can also specify several cookies like this:
```
 given().cookie("username", "John").and().cookie("password", "1234").and().expect().body(equalTo("username")).when().get("/cookie");
 
```
    If you specify additionalValues then the Cookie will be a multi-value cookie. This means that you'll create several cookies with the same name but with different values.
    Specified by:
    
    cookie in interface RequestSpecification
    
    Parameters:
    
    cookieName - The cookie cookieName
    
    value - The cookie value
    
    additionalValues - Additional cookies values. This will actually create two cookies with the same name but with different values.
    
    Returns:
    
    The request specification
    
    See Also:
    
    RequestSpecification.cookies(String, Object, Object...)
  - cookie
```
public RequestSpecification cookie(Cookie cookie)
```
    Description copied from interface: RequestSpecification
    Specify a Cookie to send with the request.
```
 Cookie someCookie = new Cookie.Builder("some_cookie", "some_value").setSecured(true).build();
 given().cookie(someCookie).and().expect().body(equalTo("x")).when().get("/cookie");
 
```
    This will set the cookie someCookie in the GET request to "/cookie".
    Specified by:
    
    cookie in interface RequestSpecification
    
    Parameters:
    
    cookie - The cookie to add to the request
    
    Returns:
    
    The request specification
    
    See Also:
    
    RequestSpecification.cookies(Cookies)
  - cookie
```
public RequestSpecification cookie(String cookieName)
```
    Description copied from interface: RequestSpecification
    Specify a cookie with no value that'll be sent with the request e.g:
```
 given().cookie("some_cookie").and().expect().body(equalTo("x")).when().get("/cookie");
 
```
    This will set the cookie some_cookie in the GET request to "/cookie".
    Specified by:
    
    cookie in interface RequestSpecification
    
    Parameters:
    
    cookieName - The cookie cookieName
    
    Returns:
    
    The request specification
    
    See Also:
    
    RequestSpecification.cookies(String, Object, Object...)
  - redirects
```
public RedirectSpecification redirects()
```
    Description copied from interface: RequestSpecification
    Specify the redirect configuration for this request. E.g.
```
  given().redirects().max(12).and().redirects().follow(true).when(). ..
 
```
    Specified by:
    
    redirects in interface RequestSpecification
    
    Returns:
    
    The redirect specification
  - spec
```
public RequestSpecification spec(RequestSpecification requestSpecificationToMerge)
```
    Description copied from interface: RequestSpecification
    Add request data from a pre-defined specification. E.g.
```
 RequestSpecification requestSpec = new RequestSpecBuilder().addParam("parameter1", "value1").build();

 given().
         spec(requestSpec).
         param("parameter2", "value2").
 when().
        get("/something");
 
```
    This is useful when you want to reuse an entire specification across multiple requests.
    The specification passed to this method is merged with the current specification. Note that the supplied specification can overwrite data in the current specification. The following settings are overwritten:
    - Port
    - Authentication schemeContent type
    - Request body
    The following settings are merged:
    - Parameters
    - Cookies
    - Headers
    This method is the same as RequestSpecification.specification(RequestSpecification) but the name is a bit shorter.
    Specified by:
    
    spec in interface RequestSpecification
    
    Parameters:
    
    requestSpecificationToMerge - The specification to merge with.
    
    Returns:
    
    the request specification
  - specification
```
public RequestSpecification specification(RequestSpecification requestSpecificationToMerge)
```
    Description copied from interface: RequestSpecification
    Add request data from a pre-defined specification. E.g.
```
 RequestSpecification requestSpec = new RequestSpecBuilder().addParam("parameter1", "value1").build();

 given().
         spec(requestSpec).
         param("parameter2", "value2").
 when().
        get("/something");
 
```
    This is useful when you want to reuse an entire specification across multiple requests.
    The specification passed to this method is merged with the current specification. Note that the supplied specification can overwrite data in the current specification. The following settings are overwritten:
    - Port
    - Authentication schemeContent type
    - Request body
    The following settings are merged:
    - Parameters
    - Cookies
    - Headers
    This method is the same as RequestSpecification.spec(RequestSpecification) but the name is a bit longer and thus more descriptive.
    Specified by:
    
    specification in interface RequestSpecification
    
    Parameters:
    
    requestSpecificationToMerge - The specification to merge with.
    
    Returns:
    
    the request specification
  - sessionId
```
public RequestSpecification sessionId(String sessionIdValue)
```
    Description copied from interface: RequestSpecification
    Set the session id for this request. It will use the configured session id name from the configuration (by default this is ). You can configure the session id name by using:
```
     RestAssured.config = newConfig().sessionConfig(new SessionConfig().sessionIdName(<sessionIdName>));
 
```
    or you can use the RequestSpecification.sessionId(String, String) method to set it for this request only.
    Specified by:
    
    sessionId in interface RequestSpecification
    
    Parameters:
    
    sessionIdValue - The session id value.
    
    Returns:
    
    The request specification
  - sessionId
```
public RequestSpecification sessionId(String sessionIdName,
                                      String sessionIdValue)
```
    Description copied from interface: RequestSpecification
    Set the session id name and value for this request. It'll override the default session id name from the configuration (by default this is ). You can configure the default session id name by using:
```
     RestAssured.config = newConfig().sessionConfig(new SessionConfig().sessionIdName(<sessionIdName>));
 
```
    and then you can use the RequestSpecification.sessionId(String) method to set the session id value without specifying the name for each request.
    Specified by:
    
    sessionId in interface RequestSpecification
    
    Parameters:
    
    sessionIdName - The session id name
    
    sessionIdValue - The session id value.
    
    Returns:
    
    The request specification
  - multiPart
```
public RequestSpecification multiPart(MultiPartSpecification multiPartSpec)
```
    Description copied from interface: RequestSpecification
    
    Specify a multi-part specification. Use this method if you need to specify content-type etc.
    
    Specified by:
    
    multiPart in interface RequestSpecification
    
    Parameters:
    
    multiPartSpec - Multipart specification
    
    Returns:
    
    The request specification
  - multiPart
```
public RequestSpecification multiPart(String controlName,
                                      File file)
```
    Description copied from interface: RequestSpecification
    
    Specify a file to upload to the server using multi-part form data uploading with a specific control name. It will use the mime-type application/octet-stream. If this is not what you want please use an overloaded method.
    
    Specified by:
    
    multiPart in interface RequestSpecification
    
    Parameters:
    
    controlName - Defines the control name of the body part. In HTML this is the attribute name of the input tag.
    
    file - The file to upload
    
    Returns:
    
    The request specification
  - multiPart
```
public RequestSpecification multiPart(File file)
```
    Description copied from interface: RequestSpecification
    
    Specify a file to upload to the server using multi-part form data uploading. It will assume that the control name is file and the mime-type is application/octet-stream. If this is not what you want please use an overloaded method.
    
    Specified by:
    
    multiPart in interface RequestSpecification
    
    Parameters:
    
    file - The file to upload
    
    Returns:
    
    The request specification
  - multiPart
```
public RequestSpecification multiPart(String controlName,
                                      File file,
                                      String mimeType)
```
    Description copied from interface: RequestSpecification
    
    Specify a file to upload to the server using multi-part form data uploading with a specific control name and mime-type.
    
    Specified by:
    
    multiPart in interface RequestSpecification
    
    Parameters:
    
    controlName - Defines the control name of the body part. In HTML this is the attribute name of the input tag.
    
    file - The file to upload
    
    mimeType - The mime-type
    
    Returns:
    
    The request specification
  - multiPart
```
public RequestSpecification multiPart(String controlName,
                                      Object object)
```
    Description copied from interface: RequestSpecification
    
    Specify an object that will be serialized to JSON and uploaded to the server using multi-part form data uploading with a specific control name. It will use mime-type application/json. If this is not what you want please use an overloaded method.
    
    Specified by:
    
    multiPart in interface RequestSpecification
    
    Parameters:
    
    controlName - Defines the control name of the body part. In HTML this is the attribute name of the input tag.
    
    object - The object to serialize to JSON or XML and send to the server
    
    Returns:
    
    The request specification
  - multiPart
```
public RequestSpecification multiPart(String controlName,
                                      Object object,
                                      String mimeType)
```
    Description copied from interface: RequestSpecification
    
    Specify an object that will be serialized and uploaded to the server using multi-part form data uploading with a specific control name.
    
    Specified by:
    
    multiPart in interface RequestSpecification
    
    Parameters:
    
    controlName - Defines the control name of the body part. In HTML this is the attribute name of the input tag.
    
    object - The object to serialize to JSON or XML and send to the server
    
    mimeType - The mime-type
    
    Returns:
    
    The request specification
  - multiPart
```
public RequestSpecification multiPart(String controlName,
                                      String filename,
                                      Object object,
                                      String mimeType)
```
    Description copied from interface: RequestSpecification
    
    Specify an object that will be serialized and uploaded to the server using multi-part form data uploading with a specific control name.
    
    Specified by:
    
    multiPart in interface RequestSpecification
    
    Parameters:
    
    controlName - Defines the control name of the body part. In HTML this is the attribute name of the input tag.
    
    filename - The name of the content you're uploading
    
    object - The object to serialize to JSON or XML and send to the server
    
    mimeType - The mime-type
    
    Returns:
    
    The request specification
  - multiPart
```
public RequestSpecification multiPart(String name,
                                      String fileName,
                                      byte... bytes)
```
    Description copied from interface: RequestSpecification
    
    Specify a byte-array to upload to the server using multi-part form data. It will use the mime-type application/octet-stream. If this is not what you want please use an overloaded method.
    
    Specified by:
    
    multiPart in interface RequestSpecification
    
    Parameters:
    
    name - Defines the control name of the body part. In HTML this is the attribute name of the input tag.
    
    fileName - The name of the content you're uploading
    
    bytes - The bytes you want to send
    
    Returns:
    
    The request specification
  - multiPart
```
public RequestSpecification multiPart(String name,
                                      String fileName,
                                      byte[] bytes,
                                      String mimeType)
```
    Description copied from interface: RequestSpecification
    
    Specify a byte-array to upload to the server using multi-part form data.
    
    Specified by:
    
    multiPart in interface RequestSpecification
    
    Parameters:
    
    name - Defines the control name of the body part. In HTML this is the attribute name of the input tag.
    
    fileName - The name of the content you're uploading
    
    bytes - The bytes you want to send
    
    mimeType - The mime-type
    
    Returns:
    
    The request specification
  - multiPart
```
public RequestSpecification multiPart(String name,
                                      String fileName,
                                      InputStream stream)
```
    Description copied from interface: RequestSpecification
    
    Specify an inputstream to upload to the server using multi-part form data. It will use the mime-type application/octet-stream. If this is not what you want please use an overloaded method.
    
    Specified by:
    
    multiPart in interface RequestSpecification
    
    Parameters:
    
    name - Defines the control name of the body part. In HTML this is the attribute name of the input tag.
    
    fileName - The name of the content you're uploading
    
    stream - The stream you want to send
    
    Returns:
    
    The request specification
  - multiPart
```
public RequestSpecification multiPart(String name,
                                      String fileName,
                                      InputStream stream,
                                      String mimeType)
```
    Description copied from interface: RequestSpecification
    
    Specify an inputstream to upload to the server using multi-part form data.
    
    Specified by:
    
    multiPart in interface RequestSpecification
    
    Parameters:
    
    name - Defines the control name of the body part. In HTML this is the attribute name of the input tag.
    
    fileName - The name of the content you're uploading
    
    stream - The stream you want to send
    
    mimeType - The mime-type
    
    Returns:
    
    The request specification
  - multiPart
```
public RequestSpecification multiPart(String name,
                                      String contentBody)
```
    Description copied from interface: RequestSpecification
    
    Specify a string to send to the server using multi-part form data. It will use the mime-type text/plain. If this is not what you want please use an overloaded method.
    
    Specified by:
    
    multiPart in interface RequestSpecification
    
    Parameters:
    
    name - Defines the control name of the body part. In HTML this is the attribute name of the input tag.
    
    contentBody - The string to send
    
    Returns:
    
    The request specification
  - multiPart
```
public RequestSpecification multiPart(String name,
                                      NoParameterValue contentBody)
```
  - multiPart
```
public RequestSpecification multiPart(String name,
                                      String contentBody,
                                      String mimeType)
```
    Description copied from interface: RequestSpecification
    
    Specify a string to send to the server using multi-part form data with a specific mime-type.
    
    Specified by:
    
    multiPart in interface RequestSpecification
    
    Parameters:
    
    name - Defines the control name of the body part. In HTML this is the attribute name of the input tag.
    
    contentBody - The string to send
    
    mimeType - The mime-type
    
    Returns:
    
    The request specification
  - newFilterContext
```
public Object newFilterContext(Object assertionClosure,
                               Object filters,
                               Object properties)
```
  - assertCorrectNumberOfPathParams
```
public void assertCorrectNumberOfPathParams()
```
  - shouldApplySSLConfig
```
public boolean shouldApplySSLConfig(Object http,
                                    RestAssuredConfig cfg)
```
  - applyRestAssuredConfig
```
public Object applyRestAssuredConfig(HTTPBuilder http)
```
  - applySessionConfig
```
public Object applySessionConfig(SessionConfig sessionConfig)
```
  - applyEncoderConfig
```
public Object applyEncoderConfig(HTTPBuilder httpBuilder,
                                 EncoderConfig encoderConfig)
```
  - applyHttpClientConfig
```
public Object applyHttpClientConfig(HttpClientConfig httpClientConfig)
```
  - applyRedirectConfig
```
public Object applyRedirectConfig(RedirectConfig redirectConfig)
```
  - assembleBodyContent
```
public Object assembleBodyContent(Object httpMethod)
```
  - mergeMapsAndRetainOrder
```
public Object mergeMapsAndRetainOrder(Map<String,Object> map1,
                                      Map<String,Object> map2)
```
  - setRequestHeadersToHttpBuilder
```
public Object setRequestHeadersToHttpBuilder(HTTPBuilder http)
```
  - buildUnnamedPathParameterTuples
```
public void buildUnnamedPathParameterTuples(Object... unnamedPathParameterValues)
```
  - partiallyApplyPathParams
```
public String partiallyApplyPathParams(String path,
                                       boolean encodePath,
                                       List<String> unnamedPathParams)
```
  - setResponseSpecification
```
public void setResponseSpecification(ResponseSpecification responseSpecification)
```
  - getBaseUri
```
public String getBaseUri()
```
    Specified by:
    
    getBaseUri in interface FilterableRequestSpecification
    
    Returns:
    
    The base URI defined in the request specification
  - getBasePath
```
public String getBasePath()
```
    Specified by:
    
    getBasePath in interface FilterableRequestSpecification
    
    Returns:
    
    The base path defined in the request specification
  - getDerivedPath
```
public String getDerivedPath()
```
    Specified by:
    
    getDerivedPath in interface FilterableRequestSpecification
    
    Returns:
    
    The derived request path with path parameters and base path etc applied
  - getUserDefinedPath
```
public String getUserDefinedPath()
```
    Description copied from interface: FilterableRequestSpecification
    Returns the original request path as it was before any path parameters were applied. For example if you made the following request to REST Assured:
```
 get("/something/{x}", x);
 
```
    Then this method would return "/something/{x}".
    Specified by:
    
    getUserDefinedPath in interface FilterableRequestSpecification
    
    Returns:
    
    The original request path
  - getMethod
```
public String getMethod()
```
    Specified by:
    
    getMethod in interface FilterableRequestSpecification
    
    Returns:
    
    The request method of the request (E.g. POST, GET etc)
  - getURI
```
public String getURI()
```
    Specified by:
    
    getURI in interface FilterableRequestSpecification
    
    Returns:
    
    The request URI as a string. This is the fully-qualified path including host, port number, scheme, path and query params.
  - getPort
```
public int getPort()
```
    Specified by:
    
    getPort in interface FilterableRequestSpecification
    
    Returns:
    
    The port defined in the request specification
  - getFormParams
```
public Map<String,String> getFormParams()
```
    Specified by:
    
    getFormParams in interface FilterableRequestSpecification
    
    Returns:
    
    The form parameters defined in the request specification
  - getPathParams
```
public Map<String,String> getPathParams()
```
    Specified by:
    
    getPathParams in interface FilterableRequestSpecification
    
    Returns:
    
    The all path parameters defined in the request specification (both named and unnamed)
  - getNamedPathParams
```
public Map<String,String> getNamedPathParams()
```
    Specified by:
    
    getNamedPathParams in interface FilterableRequestSpecification
    
    Returns:
    
    The named path parameters defined in the request specification
  - getUnnamedPathParams
```
public Map<String,String> getUnnamedPathParams()
```
    Description copied from interface: FilterableRequestSpecification
    Return the unnamed path parameters defined in the request specification as a map. Note that this only works when the unnamed path parameters are balanced (meaning that a place holder was defined in the user defined path and a value exists for this placeholder as an unnamed path parameter). For example when the request is defined as:
```
 get("/{x}/{y}", "one", "two");
 
```
    then this method will return { "x" : "one, "y" : "two" }. But if the request is missing the an unnamed path param for "y":
```
 get("/{x}/{y}", "one");
 
```
    then this method will return { "x" : "one" }. If the request is defined like this:
```
 get("/{x}/{y}", "one", "two", "three");
 
```
    then this method will return { "x" : "one, "y" : "two" }.
    If all you want is a list of the supplied unnamed path parameter (values) use FilterableRequestSpecification.getUnnamedPathParamValues().
    Specified by:
    
    getUnnamedPathParams in interface FilterableRequestSpecification
    
    Returns:
    
    The unnamed path parameters defined in the request specification.
  - getUnnamedPathParamValues
```
public List<String> getUnnamedPathParamValues()
```
    Specified by:
    
    getUnnamedPathParamValues in interface FilterableRequestSpecification
    
    Returns:
    
    A list of all unnamed path parameters supplied to the request
    
    See Also:
    
    FilterableRequestSpecification.getUnnamedPathParams()
  - getRequestParams
```
public Map<String,String> getRequestParams()
```
    Specified by:
    
    getRequestParams in interface FilterableRequestSpecification
    
    Returns:
    
    The request parameters defined in the request specification
  - getQueryParams
```
public Map<String,String> getQueryParams()
```
    Specified by:
    
    getQueryParams in interface FilterableRequestSpecification
    
    Returns:
    
    The query parameters defined in the request specification
  - getMultiPartParams
```
public List<MultiPartSpecification> getMultiPartParams()
```
    Specified by:
    
    getMultiPartParams in interface FilterableRequestSpecification
    
    Returns:
    
    The multipart segments defined in the request specification
  - getHeaders
```
public Headers getHeaders()
```
    Specified by:
    
    getHeaders in interface FilterableRequestSpecification
    
    Returns:
    
    The headers defined in the request specification
  - getCookies
```
public Cookies getCookies()
```
    Specified by:
    
    getCookies in interface FilterableRequestSpecification
    
    Returns:
    
    The cookies defined in the request specification
  - getBody
```
public <T> T getBody()
```
    Specified by:
    
    getBody in interface FilterableRequestSpecification
    
    Returns:
    
    The request body
  - getDefinedFilters
```
public List<Filter> getDefinedFilters()
```
    Specified by:
    
    getDefinedFilters in interface FilterableRequestSpecification
    
    Returns:
    
    The filters (unmodifiable)
  - getConfig
```
public RestAssuredConfig getConfig()
```
    Specified by:
    
    getConfig in interface FilterableRequestSpecification
    
    Returns:
    
    The Rest Assured configurations
  - getHttpClient
```
public org.apache.http.client.HttpClient getHttpClient()
```
    Specified by:
    
    getHttpClient in interface FilterableRequestSpecification
    
    Returns:
    
    The underlying http client. Only use this for advanced configuration which is not accessible from Rest Assured! By default an instance of AbstractHttpClient is used by REST Assured.
  - getProxySpecification
```
public ProxySpecification getProxySpecification()
```
    Specified by:
    
    getProxySpecification in interface FilterableRequestSpecification
    
    Returns:
    
    The defined proxy specification or null if undefined.
  - path
```
public FilterableRequestSpecification path(String path)
```
    Description copied from interface: FilterableRequestSpecification
    Set the request path of the request specification. For example if the request was defined like this:
```
 get("/x");
 
```
    You can change to path to "/y" instead using this method. This will result in a request that looks like this:
```
 get("/y");
 
```
    Specified by:
    
    path in interface FilterableRequestSpecification
    
    Parameters:
    
    path - The path
    
    Returns:
    
    the filterable request specification
  - getUndefinedPathParamPlaceholders
```
public List<String> getUndefinedPathParamPlaceholders()
```
    Description copied from interface: FilterableRequestSpecification
    Returns a list of all path param placeholders that are currently undefined in the request. For example if consider the following request:
```
 get("/{x}/{y}");
 
```
    Calling getPathParamPlaceholder() will return a list with "x" and "y". Note that if you have a path like this:
```
 get("/{x}/{x}");
 
```
    the list will include "x" twice. Also note that this function will only return those placeholders that are not yet defined. I.e. calling this method when the request is defined like this:
```
 get("/{x}/{y}", "something");
 
```
    will only return a list of "y". Use FilterableRequestSpecification.getPathParamPlaceholders() to get ALL placeholders.
    Specified by:
    
    getUndefinedPathParamPlaceholders in interface FilterableRequestSpecification
    
    Returns:
    
    A list of all path param templates that were defined in the request
    
    See Also:
    
    FilterableRequestSpecification.getPathParamPlaceholders()
  - getPathParamPlaceholders
```
public List<String> getPathParamPlaceholders()
```
    Description copied from interface: FilterableRequestSpecification
    Returns a list of all path param placeholders that are currently undefined in the request. For example if consider the following request:
```
 get("/{x}/{y}");
 
```
    Calling getPathParamPlaceholders() will return a list with "x" and "y". Note that if you have a path like this:
```
 get("/{x}/{x}");
 
```
    the list will include "x" twice. Note that this function will return all placeholders as they were when the user issued the request. I.e. calling this method when the request is defined like this:
```
 get("/{x}/{y}", "something");
 
```
    will return a list of "x" and "y". Use FilterableRequestSpecification.getUndefinedPathParamPlaceholders() to get a list of only the placeholders that are currently undefined ("y" in this case).
    Specified by:
    
    getPathParamPlaceholders in interface FilterableRequestSpecification
    
    Returns:
    
    A list of all path param templates that were defined in the request
    
    See Also:
    
    FilterableRequestSpecification.getUndefinedPathParamPlaceholders()
  - getRequestContentType
```
public String getRequestContentType()
```
  - getContentType
```
public String getContentType()
```
    Specified by:
    
    getContentType in interface FilterableRequestSpecification
    
    Returns:
    
    The request content type defined in the request specification
  - noFilters
```
public RequestSpecification noFilters()
```
    Description copied from interface: RequestSpecification
    
    Remove all applied filters
    
    Specified by:
    
    noFilters in interface RequestSpecification
    
    Returns:
    
    the request specification
  - noFiltersOfType
```
public <T extends Filter> RequestSpecification noFiltersOfType(Class<T> filterType)
```
    Description copied from interface: RequestSpecification
    
    Remove all applied filters
    
    Specified by:
    
    noFiltersOfType in interface RequestSpecification
    
    Returns:
    
    the request specification
  - restAssuredConfig
```
public RestAssuredConfig restAssuredConfig()
```
  - getPlaceholders
```
public static List getPlaceholders(String uri)
```
  - getDerivedPath
```
public static String getDerivedPath(String uri)
```
  - getURI
```
public String getURI(String uri)
```
  - getRedundantNamedPathParams
```
public Map<String,String> getRedundantNamedPathParams()
```
  - getRedundantUnnamedPathParamValues
```
public List<String> getRedundantUnnamedPathParamValues()
```
  - removeUnnamedPathParamAtIndex
```
public void removeUnnamedPathParamAtIndex(int indexOfParamName)
```
  - setMethod
```
public void setMethod(String method)
```

Class RequestSpecificationImpl

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

RequestSpecificationImpl

Method Detail

getMetaClass

setMetaClass

invokeMethod

getProperty

setProperty

getAuthenticationScheme

setAuthenticationScheme

when

given

that

response

get

post

put

delete

head

patch

options

get

post

put

delete

head

patch

options

get

post

put

delete

head

patch

options

get

post

put

delete

head

patch

options

request

request

request

request

request

request

request

request

get

post

put

delete

head

patch

options

parameters

parameters

params

params

param

removeParam

parameter

param

queryParameter

queryParam

removeQueryParam

removeHeader

removeCookie

removeCookie

replaceHeader

replaceCookie

replaceCookie

replaceHeaders

replaceCookies