forked from loafle/openapi-generator-original
980062f2bb
* improve java native, apache client with better spec * fix java native async tests * regenerate java native tests
94 KiB
94 KiB
FakeApi
All URIs are relative to http://petstore.swagger.io:80/v2
| Method | HTTP request | Description |
|---|---|---|
| fakeHealthGet | GET /fake/health | Health check endpoint |
| fakeHealthGetWithHttpInfo | GET /fake/health | Health check endpoint |
| fakeHttpSignatureTest | GET /fake/http-signature-test | test http signature authentication |
| fakeHttpSignatureTestWithHttpInfo | GET /fake/http-signature-test | test http signature authentication |
| fakeOuterBooleanSerialize | POST /fake/outer/boolean | |
| fakeOuterBooleanSerializeWithHttpInfo | POST /fake/outer/boolean | |
| fakeOuterCompositeSerialize | POST /fake/outer/composite | |
| fakeOuterCompositeSerializeWithHttpInfo | POST /fake/outer/composite | |
| fakeOuterNumberSerialize | POST /fake/outer/number | |
| fakeOuterNumberSerializeWithHttpInfo | POST /fake/outer/number | |
| fakeOuterStringSerialize | POST /fake/outer/string | |
| fakeOuterStringSerializeWithHttpInfo | POST /fake/outer/string | |
| fakePropertyEnumIntegerSerialize | POST /fake/property/enum-int | |
| fakePropertyEnumIntegerSerializeWithHttpInfo | POST /fake/property/enum-int | |
| testBodyWithBinary | PUT /fake/body-with-binary | |
| testBodyWithBinaryWithHttpInfo | PUT /fake/body-with-binary | |
| testBodyWithFileSchema | PUT /fake/body-with-file-schema | |
| testBodyWithFileSchemaWithHttpInfo | PUT /fake/body-with-file-schema | |
| testBodyWithQueryParams | PUT /fake/body-with-query-params | |
| testBodyWithQueryParamsWithHttpInfo | PUT /fake/body-with-query-params | |
| testClientModel | PATCH /fake | To test "client" model |
| testClientModelWithHttpInfo | PATCH /fake | To test "client" model |
| testEndpointParameters | POST /fake | Fake endpoint for testing various parameters 假端點 偽のエンドポイント 가짜 엔드 포인트 |
| testEndpointParametersWithHttpInfo | POST /fake | Fake endpoint for testing various parameters 假端點 偽のエンドポイント 가짜 엔드 포인트 |
| testEnumParameters | GET /fake | To test enum parameters |
| testEnumParametersWithHttpInfo | GET /fake | To test enum parameters |
| testGroupParameters | DELETE /fake | Fake endpoint to test group parameters (optional) |
| testGroupParametersWithHttpInfo | DELETE /fake | Fake endpoint to test group parameters (optional) |
| testInlineAdditionalProperties | POST /fake/inline-additionalProperties | test inline additionalProperties |
| testInlineAdditionalPropertiesWithHttpInfo | POST /fake/inline-additionalProperties | test inline additionalProperties |
| testJsonFormData | GET /fake/jsonFormData | test json serialization of form data |
| testJsonFormDataWithHttpInfo | GET /fake/jsonFormData | test json serialization of form data |
| testQueryParameterCollectionFormat | PUT /fake/test-query-parameters | |
| testQueryParameterCollectionFormatWithHttpInfo | PUT /fake/test-query-parameters |
fakeHealthGet
CompletableFuture fakeHealthGet()
Health check endpoint
Example
// Import classes:
import org.openapitools.client.ApiClient;
import org.openapitools.client.ApiException;
import org.openapitools.client.Configuration;
import org.openapitools.client.models.*;
import org.openapitools.client.api.FakeApi;
import java.util.concurrent.CompletableFuture;
public class Example {
public static void main(String[] args) {
ApiClient defaultClient = Configuration.getDefaultApiClient();
defaultClient.setBasePath("http://petstore.swagger.io:80/v2");
FakeApi apiInstance = new FakeApi(defaultClient);
try {
CompletableFuture<HealthCheckResult> result = apiInstance.fakeHealthGet();
System.out.println(result.get());
} catch (ApiException e) {
System.err.println("Exception when calling FakeApi#fakeHealthGet");
System.err.println("Status code: " + e.getCode());
System.err.println("Reason: " + e.getResponseBody());
System.err.println("Response headers: " + e.getResponseHeaders());
e.printStackTrace();
}
}
}
Parameters
This endpoint does not need any parameter.
Return type
CompletableFuture<HealthCheckResult>
Authorization
No authorization required
HTTP request headers
- Content-Type: Not defined
- Accept: application/json
HTTP response details
| Status code | Description | Response headers |
|---|---|---|
| 200 | The instance started successfully | - |
fakeHealthGetWithHttpInfo
CompletableFuture<ApiResponse> fakeHealthGet fakeHealthGetWithHttpInfo()
Health check endpoint
Example
// Import classes:
import org.openapitools.client.ApiClient;
import org.openapitools.client.ApiException;
import org.openapitools.client.ApiResponse;
import org.openapitools.client.Configuration;
import org.openapitools.client.models.*;
import org.openapitools.client.api.FakeApi;
import java.util.concurrent.CompletableFuture;
public class Example {
public static void main(String[] args) {
ApiClient defaultClient = Configuration.getDefaultApiClient();
defaultClient.setBasePath("http://petstore.swagger.io:80/v2");
FakeApi apiInstance = new FakeApi(defaultClient);
try {
CompletableFuture<ApiResponse<HealthCheckResult>> response = apiInstance.fakeHealthGetWithHttpInfo();
System.out.println("Status code: " + response.get().getStatusCode());
System.out.println("Response headers: " + response.get().getHeaders());
System.out.println("Response body: " + response.get().getData());
} catch (InterruptedException | ExecutionException e) {
ApiException apiException = (ApiException)e.getCause();
System.err.println("Exception when calling FakeApi#fakeHealthGet");
System.err.println("Status code: " + apiException.getCode());
System.err.println("Response headers: " + apiException.getResponseHeaders());
System.err.println("Reason: " + apiException.getResponseBody());
e.printStackTrace();
} catch (ApiException e) {
System.err.println("Exception when calling FakeApi#fakeHealthGet");
System.err.println("Status code: " + e.getCode());
System.err.println("Response headers: " + e.getResponseHeaders());
System.err.println("Reason: " + e.getResponseBody());
e.printStackTrace();
}
}
}
Parameters
This endpoint does not need any parameter.
Return type
CompletableFuture<ApiResponse<HealthCheckResult>>
Authorization
No authorization required
HTTP request headers
- Content-Type: Not defined
- Accept: application/json
HTTP response details
| Status code | Description | Response headers |
|---|---|---|
| 200 | The instance started successfully | - |
fakeHttpSignatureTest
CompletableFuture fakeHttpSignatureTest(pet, query1, header1)
test http signature authentication
Example
// Import classes:
import org.openapitools.client.ApiClient;
import org.openapitools.client.ApiException;
import org.openapitools.client.Configuration;
import org.openapitools.client.auth.*;
import org.openapitools.client.models.*;
import org.openapitools.client.api.FakeApi;
import java.util.concurrent.CompletableFuture;
public class Example {
public static void main(String[] args) {
ApiClient defaultClient = Configuration.getDefaultApiClient();
defaultClient.setBasePath("http://petstore.swagger.io:80/v2");
FakeApi apiInstance = new FakeApi(defaultClient);
Pet pet = new Pet(); // Pet | Pet object that needs to be added to the store
String query1 = "query1_example"; // String | query parameter
String header1 = "header1_example"; // String | header parameter
try {
CompletableFuture<Void> result = apiInstance.fakeHttpSignatureTest(pet, query1, header1);
} catch (ApiException e) {
System.err.println("Exception when calling FakeApi#fakeHttpSignatureTest");
System.err.println("Status code: " + e.getCode());
System.err.println("Reason: " + e.getResponseBody());
System.err.println("Response headers: " + e.getResponseHeaders());
e.printStackTrace();
}
}
}
Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| pet | Pet | Pet object that needs to be added to the store | |
| query1 | String | query parameter | [optional] |
| header1 | String | header parameter | [optional] |
Return type
CompletableFuture (empty response body)
Authorization
HTTP request headers
- Content-Type: application/json, application/xml
- Accept: Not defined
HTTP response details
| Status code | Description | Response headers |
|---|---|---|
| 200 | The instance started successfully | - |
fakeHttpSignatureTestWithHttpInfo
CompletableFuture<ApiResponse> fakeHttpSignatureTest fakeHttpSignatureTestWithHttpInfo(pet, query1, header1)
test http signature authentication
Example
// Import classes:
import org.openapitools.client.ApiClient;
import org.openapitools.client.ApiException;
import org.openapitools.client.ApiResponse;
import org.openapitools.client.Configuration;
import org.openapitools.client.auth.*;
import org.openapitools.client.models.*;
import org.openapitools.client.api.FakeApi;
import java.util.concurrent.CompletableFuture;
public class Example {
public static void main(String[] args) {
ApiClient defaultClient = Configuration.getDefaultApiClient();
defaultClient.setBasePath("http://petstore.swagger.io:80/v2");
FakeApi apiInstance = new FakeApi(defaultClient);
Pet pet = new Pet(); // Pet | Pet object that needs to be added to the store
String query1 = "query1_example"; // String | query parameter
String header1 = "header1_example"; // String | header parameter
try {
CompletableFuture<ApiResponse<Void>> response = apiInstance.fakeHttpSignatureTestWithHttpInfo(pet, query1, header1);
System.out.println("Status code: " + response.get().getStatusCode());
System.out.println("Response headers: " + response.get().getHeaders());
} catch (InterruptedException | ExecutionException e) {
ApiException apiException = (ApiException)e.getCause();
System.err.println("Exception when calling FakeApi#fakeHttpSignatureTest");
System.err.println("Status code: " + apiException.getCode());
System.err.println("Response headers: " + apiException.getResponseHeaders());
System.err.println("Reason: " + apiException.getResponseBody());
e.printStackTrace();
} catch (ApiException e) {
System.err.println("Exception when calling FakeApi#fakeHttpSignatureTest");
System.err.println("Status code: " + e.getCode());
System.err.println("Response headers: " + e.getResponseHeaders());
System.err.println("Reason: " + e.getResponseBody());
e.printStackTrace();
}
}
}
Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| pet | Pet | Pet object that needs to be added to the store | |
| query1 | String | query parameter | [optional] |
| header1 | String | header parameter | [optional] |
Return type
CompletableFuture<ApiResponse>
Authorization
HTTP request headers
- Content-Type: application/json, application/xml
- Accept: Not defined
HTTP response details
| Status code | Description | Response headers |
|---|---|---|
| 200 | The instance started successfully | - |
fakeOuterBooleanSerialize
CompletableFuture fakeOuterBooleanSerialize(body)
Test serialization of outer boolean types
Example
// Import classes:
import org.openapitools.client.ApiClient;
import org.openapitools.client.ApiException;
import org.openapitools.client.Configuration;
import org.openapitools.client.models.*;
import org.openapitools.client.api.FakeApi;
import java.util.concurrent.CompletableFuture;
public class Example {
public static void main(String[] args) {
ApiClient defaultClient = Configuration.getDefaultApiClient();
defaultClient.setBasePath("http://petstore.swagger.io:80/v2");
FakeApi apiInstance = new FakeApi(defaultClient);
Boolean body = true; // Boolean | Input boolean as post body
try {
CompletableFuture<Boolean> result = apiInstance.fakeOuterBooleanSerialize(body);
System.out.println(result.get());
} catch (ApiException e) {
System.err.println("Exception when calling FakeApi#fakeOuterBooleanSerialize");
System.err.println("Status code: " + e.getCode());
System.err.println("Reason: " + e.getResponseBody());
System.err.println("Response headers: " + e.getResponseHeaders());
e.printStackTrace();
}
}
}
Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| body | Boolean | Input boolean as post body | [optional] |
Return type
CompletableFuture<Boolean>
Authorization
No authorization required
HTTP request headers
- Content-Type: application/json
- Accept: /
HTTP response details
| Status code | Description | Response headers |
|---|---|---|
| 200 | Output boolean | - |
fakeOuterBooleanSerializeWithHttpInfo
CompletableFuture<ApiResponse> fakeOuterBooleanSerialize fakeOuterBooleanSerializeWithHttpInfo(body)
Test serialization of outer boolean types
Example
// Import classes:
import org.openapitools.client.ApiClient;
import org.openapitools.client.ApiException;
import org.openapitools.client.ApiResponse;
import org.openapitools.client.Configuration;
import org.openapitools.client.models.*;
import org.openapitools.client.api.FakeApi;
import java.util.concurrent.CompletableFuture;
public class Example {
public static void main(String[] args) {
ApiClient defaultClient = Configuration.getDefaultApiClient();
defaultClient.setBasePath("http://petstore.swagger.io:80/v2");
FakeApi apiInstance = new FakeApi(defaultClient);
Boolean body = true; // Boolean | Input boolean as post body
try {
CompletableFuture<ApiResponse<Boolean>> response = apiInstance.fakeOuterBooleanSerializeWithHttpInfo(body);
System.out.println("Status code: " + response.get().getStatusCode());
System.out.println("Response headers: " + response.get().getHeaders());
System.out.println("Response body: " + response.get().getData());
} catch (InterruptedException | ExecutionException e) {
ApiException apiException = (ApiException)e.getCause();
System.err.println("Exception when calling FakeApi#fakeOuterBooleanSerialize");
System.err.println("Status code: " + apiException.getCode());
System.err.println("Response headers: " + apiException.getResponseHeaders());
System.err.println("Reason: " + apiException.getResponseBody());
e.printStackTrace();
} catch (ApiException e) {
System.err.println("Exception when calling FakeApi#fakeOuterBooleanSerialize");
System.err.println("Status code: " + e.getCode());
System.err.println("Response headers: " + e.getResponseHeaders());
System.err.println("Reason: " + e.getResponseBody());
e.printStackTrace();
}
}
}
Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| body | Boolean | Input boolean as post body | [optional] |
Return type
CompletableFuture<ApiResponse<Boolean>>
Authorization
No authorization required
HTTP request headers
- Content-Type: application/json
- Accept: /
HTTP response details
| Status code | Description | Response headers |
|---|---|---|
| 200 | Output boolean | - |
fakeOuterCompositeSerialize
CompletableFuture fakeOuterCompositeSerialize(outerComposite)
Test serialization of object with outer number type
Example
// Import classes:
import org.openapitools.client.ApiClient;
import org.openapitools.client.ApiException;
import org.openapitools.client.Configuration;
import org.openapitools.client.models.*;
import org.openapitools.client.api.FakeApi;
import java.util.concurrent.CompletableFuture;
public class Example {
public static void main(String[] args) {
ApiClient defaultClient = Configuration.getDefaultApiClient();
defaultClient.setBasePath("http://petstore.swagger.io:80/v2");
FakeApi apiInstance = new FakeApi(defaultClient);
OuterComposite outerComposite = new OuterComposite(); // OuterComposite | Input composite as post body
try {
CompletableFuture<OuterComposite> result = apiInstance.fakeOuterCompositeSerialize(outerComposite);
System.out.println(result.get());
} catch (ApiException e) {
System.err.println("Exception when calling FakeApi#fakeOuterCompositeSerialize");
System.err.println("Status code: " + e.getCode());
System.err.println("Reason: " + e.getResponseBody());
System.err.println("Response headers: " + e.getResponseHeaders());
e.printStackTrace();
}
}
}
Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| outerComposite | OuterComposite | Input composite as post body | [optional] |
Return type
CompletableFuture<OuterComposite>
Authorization
No authorization required
HTTP request headers
- Content-Type: application/json
- Accept: /
HTTP response details
| Status code | Description | Response headers |
|---|---|---|
| 200 | Output composite | - |
fakeOuterCompositeSerializeWithHttpInfo
CompletableFuture<ApiResponse> fakeOuterCompositeSerialize fakeOuterCompositeSerializeWithHttpInfo(outerComposite)
Test serialization of object with outer number type
Example
// Import classes:
import org.openapitools.client.ApiClient;
import org.openapitools.client.ApiException;
import org.openapitools.client.ApiResponse;
import org.openapitools.client.Configuration;
import org.openapitools.client.models.*;
import org.openapitools.client.api.FakeApi;
import java.util.concurrent.CompletableFuture;
public class Example {
public static void main(String[] args) {
ApiClient defaultClient = Configuration.getDefaultApiClient();
defaultClient.setBasePath("http://petstore.swagger.io:80/v2");
FakeApi apiInstance = new FakeApi(defaultClient);
OuterComposite outerComposite = new OuterComposite(); // OuterComposite | Input composite as post body
try {
CompletableFuture<ApiResponse<OuterComposite>> response = apiInstance.fakeOuterCompositeSerializeWithHttpInfo(outerComposite);
System.out.println("Status code: " + response.get().getStatusCode());
System.out.println("Response headers: " + response.get().getHeaders());
System.out.println("Response body: " + response.get().getData());
} catch (InterruptedException | ExecutionException e) {
ApiException apiException = (ApiException)e.getCause();
System.err.println("Exception when calling FakeApi#fakeOuterCompositeSerialize");
System.err.println("Status code: " + apiException.getCode());
System.err.println("Response headers: " + apiException.getResponseHeaders());
System.err.println("Reason: " + apiException.getResponseBody());
e.printStackTrace();
} catch (ApiException e) {
System.err.println("Exception when calling FakeApi#fakeOuterCompositeSerialize");
System.err.println("Status code: " + e.getCode());
System.err.println("Response headers: " + e.getResponseHeaders());
System.err.println("Reason: " + e.getResponseBody());
e.printStackTrace();
}
}
}
Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| outerComposite | OuterComposite | Input composite as post body | [optional] |
Return type
CompletableFuture<ApiResponse<OuterComposite>>
Authorization
No authorization required
HTTP request headers
- Content-Type: application/json
- Accept: /
HTTP response details
| Status code | Description | Response headers |
|---|---|---|
| 200 | Output composite | - |
fakeOuterNumberSerialize
CompletableFuture fakeOuterNumberSerialize(body)
Test serialization of outer number types
Example
// Import classes:
import org.openapitools.client.ApiClient;
import org.openapitools.client.ApiException;
import org.openapitools.client.Configuration;
import org.openapitools.client.models.*;
import org.openapitools.client.api.FakeApi;
import java.util.concurrent.CompletableFuture;
public class Example {
public static void main(String[] args) {
ApiClient defaultClient = Configuration.getDefaultApiClient();
defaultClient.setBasePath("http://petstore.swagger.io:80/v2");
FakeApi apiInstance = new FakeApi(defaultClient);
BigDecimal body = new BigDecimal(78); // BigDecimal | Input number as post body
try {
CompletableFuture<BigDecimal> result = apiInstance.fakeOuterNumberSerialize(body);
System.out.println(result.get());
} catch (ApiException e) {
System.err.println("Exception when calling FakeApi#fakeOuterNumberSerialize");
System.err.println("Status code: " + e.getCode());
System.err.println("Reason: " + e.getResponseBody());
System.err.println("Response headers: " + e.getResponseHeaders());
e.printStackTrace();
}
}
}
Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| body | BigDecimal | Input number as post body | [optional] |
Return type
CompletableFuture<BigDecimal>
Authorization
No authorization required
HTTP request headers
- Content-Type: application/json
- Accept: /
HTTP response details
| Status code | Description | Response headers |
|---|---|---|
| 200 | Output number | - |
fakeOuterNumberSerializeWithHttpInfo
CompletableFuture<ApiResponse> fakeOuterNumberSerialize fakeOuterNumberSerializeWithHttpInfo(body)
Test serialization of outer number types
Example
// Import classes:
import org.openapitools.client.ApiClient;
import org.openapitools.client.ApiException;
import org.openapitools.client.ApiResponse;
import org.openapitools.client.Configuration;
import org.openapitools.client.models.*;
import org.openapitools.client.api.FakeApi;
import java.util.concurrent.CompletableFuture;
public class Example {
public static void main(String[] args) {
ApiClient defaultClient = Configuration.getDefaultApiClient();
defaultClient.setBasePath("http://petstore.swagger.io:80/v2");
FakeApi apiInstance = new FakeApi(defaultClient);
BigDecimal body = new BigDecimal(78); // BigDecimal | Input number as post body
try {
CompletableFuture<ApiResponse<BigDecimal>> response = apiInstance.fakeOuterNumberSerializeWithHttpInfo(body);
System.out.println("Status code: " + response.get().getStatusCode());
System.out.println("Response headers: " + response.get().getHeaders());
System.out.println("Response body: " + response.get().getData());
} catch (InterruptedException | ExecutionException e) {
ApiException apiException = (ApiException)e.getCause();
System.err.println("Exception when calling FakeApi#fakeOuterNumberSerialize");
System.err.println("Status code: " + apiException.getCode());
System.err.println("Response headers: " + apiException.getResponseHeaders());
System.err.println("Reason: " + apiException.getResponseBody());
e.printStackTrace();
} catch (ApiException e) {
System.err.println("Exception when calling FakeApi#fakeOuterNumberSerialize");
System.err.println("Status code: " + e.getCode());
System.err.println("Response headers: " + e.getResponseHeaders());
System.err.println("Reason: " + e.getResponseBody());
e.printStackTrace();
}
}
}
Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| body | BigDecimal | Input number as post body | [optional] |
Return type
CompletableFuture<ApiResponse<BigDecimal>>
Authorization
No authorization required
HTTP request headers
- Content-Type: application/json
- Accept: /
HTTP response details
| Status code | Description | Response headers |
|---|---|---|
| 200 | Output number | - |
fakeOuterStringSerialize
CompletableFuture fakeOuterStringSerialize(body)
Test serialization of outer string types
Example
// Import classes:
import org.openapitools.client.ApiClient;
import org.openapitools.client.ApiException;
import org.openapitools.client.Configuration;
import org.openapitools.client.models.*;
import org.openapitools.client.api.FakeApi;
import java.util.concurrent.CompletableFuture;
public class Example {
public static void main(String[] args) {
ApiClient defaultClient = Configuration.getDefaultApiClient();
defaultClient.setBasePath("http://petstore.swagger.io:80/v2");
FakeApi apiInstance = new FakeApi(defaultClient);
String body = "body_example"; // String | Input string as post body
try {
CompletableFuture<String> result = apiInstance.fakeOuterStringSerialize(body);
System.out.println(result.get());
} catch (ApiException e) {
System.err.println("Exception when calling FakeApi#fakeOuterStringSerialize");
System.err.println("Status code: " + e.getCode());
System.err.println("Reason: " + e.getResponseBody());
System.err.println("Response headers: " + e.getResponseHeaders());
e.printStackTrace();
}
}
}
Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| body | String | Input string as post body | [optional] |
Return type
CompletableFuture<String>
Authorization
No authorization required
HTTP request headers
- Content-Type: application/json
- Accept: /
HTTP response details
| Status code | Description | Response headers |
|---|---|---|
| 200 | Output string | - |
fakeOuterStringSerializeWithHttpInfo
CompletableFuture<ApiResponse> fakeOuterStringSerialize fakeOuterStringSerializeWithHttpInfo(body)
Test serialization of outer string types
Example
// Import classes:
import org.openapitools.client.ApiClient;
import org.openapitools.client.ApiException;
import org.openapitools.client.ApiResponse;
import org.openapitools.client.Configuration;
import org.openapitools.client.models.*;
import org.openapitools.client.api.FakeApi;
import java.util.concurrent.CompletableFuture;
public class Example {
public static void main(String[] args) {
ApiClient defaultClient = Configuration.getDefaultApiClient();
defaultClient.setBasePath("http://petstore.swagger.io:80/v2");
FakeApi apiInstance = new FakeApi(defaultClient);
String body = "body_example"; // String | Input string as post body
try {
CompletableFuture<ApiResponse<String>> response = apiInstance.fakeOuterStringSerializeWithHttpInfo(body);
System.out.println("Status code: " + response.get().getStatusCode());
System.out.println("Response headers: " + response.get().getHeaders());
System.out.println("Response body: " + response.get().getData());
} catch (InterruptedException | ExecutionException e) {
ApiException apiException = (ApiException)e.getCause();
System.err.println("Exception when calling FakeApi#fakeOuterStringSerialize");
System.err.println("Status code: " + apiException.getCode());
System.err.println("Response headers: " + apiException.getResponseHeaders());
System.err.println("Reason: " + apiException.getResponseBody());
e.printStackTrace();
} catch (ApiException e) {
System.err.println("Exception when calling FakeApi#fakeOuterStringSerialize");
System.err.println("Status code: " + e.getCode());
System.err.println("Response headers: " + e.getResponseHeaders());
System.err.println("Reason: " + e.getResponseBody());
e.printStackTrace();
}
}
}
Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| body | String | Input string as post body | [optional] |
Return type
CompletableFuture<ApiResponse<String>>
Authorization
No authorization required
HTTP request headers
- Content-Type: application/json
- Accept: /
HTTP response details
| Status code | Description | Response headers |
|---|---|---|
| 200 | Output string | - |
fakePropertyEnumIntegerSerialize
CompletableFuture fakePropertyEnumIntegerSerialize(outerObjectWithEnumProperty)
Test serialization of enum (int) properties with examples
Example
// Import classes:
import org.openapitools.client.ApiClient;
import org.openapitools.client.ApiException;
import org.openapitools.client.Configuration;
import org.openapitools.client.models.*;
import org.openapitools.client.api.FakeApi;
import java.util.concurrent.CompletableFuture;
public class Example {
public static void main(String[] args) {
ApiClient defaultClient = Configuration.getDefaultApiClient();
defaultClient.setBasePath("http://petstore.swagger.io:80/v2");
FakeApi apiInstance = new FakeApi(defaultClient);
OuterObjectWithEnumProperty outerObjectWithEnumProperty = new OuterObjectWithEnumProperty(); // OuterObjectWithEnumProperty | Input enum (int) as post body
try {
CompletableFuture<OuterObjectWithEnumProperty> result = apiInstance.fakePropertyEnumIntegerSerialize(outerObjectWithEnumProperty);
System.out.println(result.get());
} catch (ApiException e) {
System.err.println("Exception when calling FakeApi#fakePropertyEnumIntegerSerialize");
System.err.println("Status code: " + e.getCode());
System.err.println("Reason: " + e.getResponseBody());
System.err.println("Response headers: " + e.getResponseHeaders());
e.printStackTrace();
}
}
}
Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| outerObjectWithEnumProperty | OuterObjectWithEnumProperty | Input enum (int) as post body |
Return type
CompletableFuture<OuterObjectWithEnumProperty>
Authorization
No authorization required
HTTP request headers
- Content-Type: application/json
- Accept: /
HTTP response details
| Status code | Description | Response headers |
|---|---|---|
| 200 | Output enum (int) | - |
fakePropertyEnumIntegerSerializeWithHttpInfo
CompletableFuture<ApiResponse> fakePropertyEnumIntegerSerialize fakePropertyEnumIntegerSerializeWithHttpInfo(outerObjectWithEnumProperty)
Test serialization of enum (int) properties with examples
Example
// Import classes:
import org.openapitools.client.ApiClient;
import org.openapitools.client.ApiException;
import org.openapitools.client.ApiResponse;
import org.openapitools.client.Configuration;
import org.openapitools.client.models.*;
import org.openapitools.client.api.FakeApi;
import java.util.concurrent.CompletableFuture;
public class Example {
public static void main(String[] args) {
ApiClient defaultClient = Configuration.getDefaultApiClient();
defaultClient.setBasePath("http://petstore.swagger.io:80/v2");
FakeApi apiInstance = new FakeApi(defaultClient);
OuterObjectWithEnumProperty outerObjectWithEnumProperty = new OuterObjectWithEnumProperty(); // OuterObjectWithEnumProperty | Input enum (int) as post body
try {
CompletableFuture<ApiResponse<OuterObjectWithEnumProperty>> response = apiInstance.fakePropertyEnumIntegerSerializeWithHttpInfo(outerObjectWithEnumProperty);
System.out.println("Status code: " + response.get().getStatusCode());
System.out.println("Response headers: " + response.get().getHeaders());
System.out.println("Response body: " + response.get().getData());
} catch (InterruptedException | ExecutionException e) {
ApiException apiException = (ApiException)e.getCause();
System.err.println("Exception when calling FakeApi#fakePropertyEnumIntegerSerialize");
System.err.println("Status code: " + apiException.getCode());
System.err.println("Response headers: " + apiException.getResponseHeaders());
System.err.println("Reason: " + apiException.getResponseBody());
e.printStackTrace();
} catch (ApiException e) {
System.err.println("Exception when calling FakeApi#fakePropertyEnumIntegerSerialize");
System.err.println("Status code: " + e.getCode());
System.err.println("Response headers: " + e.getResponseHeaders());
System.err.println("Reason: " + e.getResponseBody());
e.printStackTrace();
}
}
}
Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| outerObjectWithEnumProperty | OuterObjectWithEnumProperty | Input enum (int) as post body |
Return type
CompletableFuture<ApiResponse<OuterObjectWithEnumProperty>>
Authorization
No authorization required
HTTP request headers
- Content-Type: application/json
- Accept: /
HTTP response details
| Status code | Description | Response headers |
|---|---|---|
| 200 | Output enum (int) | - |
testBodyWithBinary
CompletableFuture testBodyWithBinary(body)
For this test, the body has to be a binary file.
Example
// Import classes:
import org.openapitools.client.ApiClient;
import org.openapitools.client.ApiException;
import org.openapitools.client.Configuration;
import org.openapitools.client.models.*;
import org.openapitools.client.api.FakeApi;
import java.util.concurrent.CompletableFuture;
public class Example {
public static void main(String[] args) {
ApiClient defaultClient = Configuration.getDefaultApiClient();
defaultClient.setBasePath("http://petstore.swagger.io:80/v2");
FakeApi apiInstance = new FakeApi(defaultClient);
File body = new File("/path/to/file"); // File | image to upload
try {
CompletableFuture<Void> result = apiInstance.testBodyWithBinary(body);
} catch (ApiException e) {
System.err.println("Exception when calling FakeApi#testBodyWithBinary");
System.err.println("Status code: " + e.getCode());
System.err.println("Reason: " + e.getResponseBody());
System.err.println("Response headers: " + e.getResponseHeaders());
e.printStackTrace();
}
}
}
Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| body | File | image to upload |
Return type
CompletableFuture (empty response body)
Authorization
No authorization required
HTTP request headers
- Content-Type: image/png
- Accept: Not defined
HTTP response details
| Status code | Description | Response headers |
|---|---|---|
| 200 | Success | - |
testBodyWithBinaryWithHttpInfo
CompletableFuture<ApiResponse> testBodyWithBinary testBodyWithBinaryWithHttpInfo(body)
For this test, the body has to be a binary file.
Example
// Import classes:
import org.openapitools.client.ApiClient;
import org.openapitools.client.ApiException;
import org.openapitools.client.ApiResponse;
import org.openapitools.client.Configuration;
import org.openapitools.client.models.*;
import org.openapitools.client.api.FakeApi;
import java.util.concurrent.CompletableFuture;
public class Example {
public static void main(String[] args) {
ApiClient defaultClient = Configuration.getDefaultApiClient();
defaultClient.setBasePath("http://petstore.swagger.io:80/v2");
FakeApi apiInstance = new FakeApi(defaultClient);
File body = new File("/path/to/file"); // File | image to upload
try {
CompletableFuture<ApiResponse<Void>> response = apiInstance.testBodyWithBinaryWithHttpInfo(body);
System.out.println("Status code: " + response.get().getStatusCode());
System.out.println("Response headers: " + response.get().getHeaders());
} catch (InterruptedException | ExecutionException e) {
ApiException apiException = (ApiException)e.getCause();
System.err.println("Exception when calling FakeApi#testBodyWithBinary");
System.err.println("Status code: " + apiException.getCode());
System.err.println("Response headers: " + apiException.getResponseHeaders());
System.err.println("Reason: " + apiException.getResponseBody());
e.printStackTrace();
} catch (ApiException e) {
System.err.println("Exception when calling FakeApi#testBodyWithBinary");
System.err.println("Status code: " + e.getCode());
System.err.println("Response headers: " + e.getResponseHeaders());
System.err.println("Reason: " + e.getResponseBody());
e.printStackTrace();
}
}
}
Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| body | File | image to upload |
Return type
CompletableFuture<ApiResponse>
Authorization
No authorization required
HTTP request headers
- Content-Type: image/png
- Accept: Not defined
HTTP response details
| Status code | Description | Response headers |
|---|---|---|
| 200 | Success | - |
testBodyWithFileSchema
CompletableFuture testBodyWithFileSchema(fileSchemaTestClass)
For this test, the body for this request must reference a schema named `File`.
Example
// Import classes:
import org.openapitools.client.ApiClient;
import org.openapitools.client.ApiException;
import org.openapitools.client.Configuration;
import org.openapitools.client.models.*;
import org.openapitools.client.api.FakeApi;
import java.util.concurrent.CompletableFuture;
public class Example {
public static void main(String[] args) {
ApiClient defaultClient = Configuration.getDefaultApiClient();
defaultClient.setBasePath("http://petstore.swagger.io:80/v2");
FakeApi apiInstance = new FakeApi(defaultClient);
FileSchemaTestClass fileSchemaTestClass = new FileSchemaTestClass(); // FileSchemaTestClass |
try {
CompletableFuture<Void> result = apiInstance.testBodyWithFileSchema(fileSchemaTestClass);
} catch (ApiException e) {
System.err.println("Exception when calling FakeApi#testBodyWithFileSchema");
System.err.println("Status code: " + e.getCode());
System.err.println("Reason: " + e.getResponseBody());
System.err.println("Response headers: " + e.getResponseHeaders());
e.printStackTrace();
}
}
}
Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| fileSchemaTestClass | FileSchemaTestClass |
Return type
CompletableFuture (empty response body)
Authorization
No authorization required
HTTP request headers
- Content-Type: application/json
- Accept: Not defined
HTTP response details
| Status code | Description | Response headers |
|---|---|---|
| 200 | Success | - |
testBodyWithFileSchemaWithHttpInfo
CompletableFuture<ApiResponse> testBodyWithFileSchema testBodyWithFileSchemaWithHttpInfo(fileSchemaTestClass)
For this test, the body for this request must reference a schema named `File`.
Example
// Import classes:
import org.openapitools.client.ApiClient;
import org.openapitools.client.ApiException;
import org.openapitools.client.ApiResponse;
import org.openapitools.client.Configuration;
import org.openapitools.client.models.*;
import org.openapitools.client.api.FakeApi;
import java.util.concurrent.CompletableFuture;
public class Example {
public static void main(String[] args) {
ApiClient defaultClient = Configuration.getDefaultApiClient();
defaultClient.setBasePath("http://petstore.swagger.io:80/v2");
FakeApi apiInstance = new FakeApi(defaultClient);
FileSchemaTestClass fileSchemaTestClass = new FileSchemaTestClass(); // FileSchemaTestClass |
try {
CompletableFuture<ApiResponse<Void>> response = apiInstance.testBodyWithFileSchemaWithHttpInfo(fileSchemaTestClass);
System.out.println("Status code: " + response.get().getStatusCode());
System.out.println("Response headers: " + response.get().getHeaders());
} catch (InterruptedException | ExecutionException e) {
ApiException apiException = (ApiException)e.getCause();
System.err.println("Exception when calling FakeApi#testBodyWithFileSchema");
System.err.println("Status code: " + apiException.getCode());
System.err.println("Response headers: " + apiException.getResponseHeaders());
System.err.println("Reason: " + apiException.getResponseBody());
e.printStackTrace();
} catch (ApiException e) {
System.err.println("Exception when calling FakeApi#testBodyWithFileSchema");
System.err.println("Status code: " + e.getCode());
System.err.println("Response headers: " + e.getResponseHeaders());
System.err.println("Reason: " + e.getResponseBody());
e.printStackTrace();
}
}
}
Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| fileSchemaTestClass | FileSchemaTestClass |
Return type
CompletableFuture<ApiResponse>
Authorization
No authorization required
HTTP request headers
- Content-Type: application/json
- Accept: Not defined
HTTP response details
| Status code | Description | Response headers |
|---|---|---|
| 200 | Success | - |
testBodyWithQueryParams
CompletableFuture testBodyWithQueryParams(query, user)
Example
// Import classes:
import org.openapitools.client.ApiClient;
import org.openapitools.client.ApiException;
import org.openapitools.client.Configuration;
import org.openapitools.client.models.*;
import org.openapitools.client.api.FakeApi;
import java.util.concurrent.CompletableFuture;
public class Example {
public static void main(String[] args) {
ApiClient defaultClient = Configuration.getDefaultApiClient();
defaultClient.setBasePath("http://petstore.swagger.io:80/v2");
FakeApi apiInstance = new FakeApi(defaultClient);
String query = "query_example"; // String |
User user = new User(); // User |
try {
CompletableFuture<Void> result = apiInstance.testBodyWithQueryParams(query, user);
} catch (ApiException e) {
System.err.println("Exception when calling FakeApi#testBodyWithQueryParams");
System.err.println("Status code: " + e.getCode());
System.err.println("Reason: " + e.getResponseBody());
System.err.println("Response headers: " + e.getResponseHeaders());
e.printStackTrace();
}
}
}
Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| query | String | ||
| user | User |
Return type
CompletableFuture (empty response body)
Authorization
No authorization required
HTTP request headers
- Content-Type: application/json
- Accept: Not defined
HTTP response details
| Status code | Description | Response headers |
|---|---|---|
| 200 | Success | - |
testBodyWithQueryParamsWithHttpInfo
CompletableFuture<ApiResponse> testBodyWithQueryParams testBodyWithQueryParamsWithHttpInfo(query, user)
Example
// Import classes:
import org.openapitools.client.ApiClient;
import org.openapitools.client.ApiException;
import org.openapitools.client.ApiResponse;
import org.openapitools.client.Configuration;
import org.openapitools.client.models.*;
import org.openapitools.client.api.FakeApi;
import java.util.concurrent.CompletableFuture;
public class Example {
public static void main(String[] args) {
ApiClient defaultClient = Configuration.getDefaultApiClient();
defaultClient.setBasePath("http://petstore.swagger.io:80/v2");
FakeApi apiInstance = new FakeApi(defaultClient);
String query = "query_example"; // String |
User user = new User(); // User |
try {
CompletableFuture<ApiResponse<Void>> response = apiInstance.testBodyWithQueryParamsWithHttpInfo(query, user);
System.out.println("Status code: " + response.get().getStatusCode());
System.out.println("Response headers: " + response.get().getHeaders());
} catch (InterruptedException | ExecutionException e) {
ApiException apiException = (ApiException)e.getCause();
System.err.println("Exception when calling FakeApi#testBodyWithQueryParams");
System.err.println("Status code: " + apiException.getCode());
System.err.println("Response headers: " + apiException.getResponseHeaders());
System.err.println("Reason: " + apiException.getResponseBody());
e.printStackTrace();
} catch (ApiException e) {
System.err.println("Exception when calling FakeApi#testBodyWithQueryParams");
System.err.println("Status code: " + e.getCode());
System.err.println("Response headers: " + e.getResponseHeaders());
System.err.println("Reason: " + e.getResponseBody());
e.printStackTrace();
}
}
}
Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| query | String | ||
| user | User |
Return type
CompletableFuture<ApiResponse>
Authorization
No authorization required
HTTP request headers
- Content-Type: application/json
- Accept: Not defined
HTTP response details
| Status code | Description | Response headers |
|---|---|---|
| 200 | Success | - |
testClientModel
CompletableFuture testClientModel(client)
To test "client" model
To test "client" model
Example
// Import classes:
import org.openapitools.client.ApiClient;
import org.openapitools.client.ApiException;
import org.openapitools.client.Configuration;
import org.openapitools.client.models.*;
import org.openapitools.client.api.FakeApi;
import java.util.concurrent.CompletableFuture;
public class Example {
public static void main(String[] args) {
ApiClient defaultClient = Configuration.getDefaultApiClient();
defaultClient.setBasePath("http://petstore.swagger.io:80/v2");
FakeApi apiInstance = new FakeApi(defaultClient);
Client client = new Client(); // Client | client model
try {
CompletableFuture<Client> result = apiInstance.testClientModel(client);
System.out.println(result.get());
} catch (ApiException e) {
System.err.println("Exception when calling FakeApi#testClientModel");
System.err.println("Status code: " + e.getCode());
System.err.println("Reason: " + e.getResponseBody());
System.err.println("Response headers: " + e.getResponseHeaders());
e.printStackTrace();
}
}
}
Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| client | Client | client model |
Return type
CompletableFuture<Client>
Authorization
No authorization required
HTTP request headers
- Content-Type: application/json
- Accept: application/json
HTTP response details
| Status code | Description | Response headers |
|---|---|---|
| 200 | successful operation | - |
testClientModelWithHttpInfo
CompletableFuture<ApiResponse> testClientModel testClientModelWithHttpInfo(client)
To test "client" model
To test "client" model
Example
// Import classes:
import org.openapitools.client.ApiClient;
import org.openapitools.client.ApiException;
import org.openapitools.client.ApiResponse;
import org.openapitools.client.Configuration;
import org.openapitools.client.models.*;
import org.openapitools.client.api.FakeApi;
import java.util.concurrent.CompletableFuture;
public class Example {
public static void main(String[] args) {
ApiClient defaultClient = Configuration.getDefaultApiClient();
defaultClient.setBasePath("http://petstore.swagger.io:80/v2");
FakeApi apiInstance = new FakeApi(defaultClient);
Client client = new Client(); // Client | client model
try {
CompletableFuture<ApiResponse<Client>> response = apiInstance.testClientModelWithHttpInfo(client);
System.out.println("Status code: " + response.get().getStatusCode());
System.out.println("Response headers: " + response.get().getHeaders());
System.out.println("Response body: " + response.get().getData());
} catch (InterruptedException | ExecutionException e) {
ApiException apiException = (ApiException)e.getCause();
System.err.println("Exception when calling FakeApi#testClientModel");
System.err.println("Status code: " + apiException.getCode());
System.err.println("Response headers: " + apiException.getResponseHeaders());
System.err.println("Reason: " + apiException.getResponseBody());
e.printStackTrace();
} catch (ApiException e) {
System.err.println("Exception when calling FakeApi#testClientModel");
System.err.println("Status code: " + e.getCode());
System.err.println("Response headers: " + e.getResponseHeaders());
System.err.println("Reason: " + e.getResponseBody());
e.printStackTrace();
}
}
}
Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| client | Client | client model |
Return type
CompletableFuture<ApiResponse<Client>>
Authorization
No authorization required
HTTP request headers
- Content-Type: application/json
- Accept: application/json
HTTP response details
| Status code | Description | Response headers |
|---|---|---|
| 200 | successful operation | - |
testEndpointParameters
CompletableFuture testEndpointParameters(number, _double, patternWithoutDelimiter, _byte, integer, int32, int64, _float, string, binary, date, dateTime, password, paramCallback)
Fake endpoint for testing various parameters 假端點 偽のエンドポイント 가짜 엔드 포인트
Fake endpoint for testing various parameters 假端點 偽のエンドポイント 가짜 엔드 포인트
Example
// Import classes:
import org.openapitools.client.ApiClient;
import org.openapitools.client.ApiException;
import org.openapitools.client.Configuration;
import org.openapitools.client.auth.*;
import org.openapitools.client.models.*;
import org.openapitools.client.api.FakeApi;
import java.util.concurrent.CompletableFuture;
public class Example {
public static void main(String[] args) {
ApiClient defaultClient = Configuration.getDefaultApiClient();
defaultClient.setBasePath("http://petstore.swagger.io:80/v2");
// Configure HTTP basic authorization: http_basic_test
HttpBasicAuth http_basic_test = (HttpBasicAuth) defaultClient.getAuthentication("http_basic_test");
http_basic_test.setUsername("YOUR USERNAME");
http_basic_test.setPassword("YOUR PASSWORD");
FakeApi apiInstance = new FakeApi(defaultClient);
BigDecimal number = new BigDecimal(78); // BigDecimal | None
Double _double = 3.4D; // Double | None
String patternWithoutDelimiter = "patternWithoutDelimiter_example"; // String | None
byte[] _byte = null; // byte[] | None
Integer integer = 56; // Integer | None
Integer int32 = 56; // Integer | None
Long int64 = 56L; // Long | None
Float _float = 3.4F; // Float | None
String string = "string_example"; // String | None
File binary = new File("/path/to/file"); // File | None
LocalDate date = LocalDate.now(); // LocalDate | None
OffsetDateTime dateTime = OffsetDateTime.now(); // OffsetDateTime | None
String password = "password_example"; // String | None
String paramCallback = "paramCallback_example"; // String | None
try {
CompletableFuture<Void> result = apiInstance.testEndpointParameters(number, _double, patternWithoutDelimiter, _byte, integer, int32, int64, _float, string, binary, date, dateTime, password, paramCallback);
} catch (ApiException e) {
System.err.println("Exception when calling FakeApi#testEndpointParameters");
System.err.println("Status code: " + e.getCode());
System.err.println("Reason: " + e.getResponseBody());
System.err.println("Response headers: " + e.getResponseHeaders());
e.printStackTrace();
}
}
}
Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| number | BigDecimal | None | |
| _double | Double | None | |
| patternWithoutDelimiter | String | None | |
| _byte | byte[] | None | |
| integer | Integer | None | [optional] |
| int32 | Integer | None | [optional] |
| int64 | Long | None | [optional] |
| _float | Float | None | [optional] |
| string | String | None | [optional] |
| binary | File | None | [optional] |
| date | LocalDate | None | [optional] |
| dateTime | OffsetDateTime | None | [optional] |
| password | String | None | [optional] |
| paramCallback | String | None | [optional] |
Return type
CompletableFuture (empty response body)
Authorization
HTTP request headers
- Content-Type: application/x-www-form-urlencoded
- Accept: Not defined
HTTP response details
| Status code | Description | Response headers |
|---|---|---|
| 400 | Invalid username supplied | - |
| 404 | User not found | - |
testEndpointParametersWithHttpInfo
CompletableFuture<ApiResponse> testEndpointParameters testEndpointParametersWithHttpInfo(number, _double, patternWithoutDelimiter, _byte, integer, int32, int64, _float, string, binary, date, dateTime, password, paramCallback)
Fake endpoint for testing various parameters 假端點 偽のエンドポイント 가짜 엔드 포인트
Fake endpoint for testing various parameters 假端點 偽のエンドポイント 가짜 엔드 포인트
Example
// Import classes:
import org.openapitools.client.ApiClient;
import org.openapitools.client.ApiException;
import org.openapitools.client.ApiResponse;
import org.openapitools.client.Configuration;
import org.openapitools.client.auth.*;
import org.openapitools.client.models.*;
import org.openapitools.client.api.FakeApi;
import java.util.concurrent.CompletableFuture;
public class Example {
public static void main(String[] args) {
ApiClient defaultClient = Configuration.getDefaultApiClient();
defaultClient.setBasePath("http://petstore.swagger.io:80/v2");
// Configure HTTP basic authorization: http_basic_test
HttpBasicAuth http_basic_test = (HttpBasicAuth) defaultClient.getAuthentication("http_basic_test");
http_basic_test.setUsername("YOUR USERNAME");
http_basic_test.setPassword("YOUR PASSWORD");
FakeApi apiInstance = new FakeApi(defaultClient);
BigDecimal number = new BigDecimal(78); // BigDecimal | None
Double _double = 3.4D; // Double | None
String patternWithoutDelimiter = "patternWithoutDelimiter_example"; // String | None
byte[] _byte = null; // byte[] | None
Integer integer = 56; // Integer | None
Integer int32 = 56; // Integer | None
Long int64 = 56L; // Long | None
Float _float = 3.4F; // Float | None
String string = "string_example"; // String | None
File binary = new File("/path/to/file"); // File | None
LocalDate date = LocalDate.now(); // LocalDate | None
OffsetDateTime dateTime = OffsetDateTime.now(); // OffsetDateTime | None
String password = "password_example"; // String | None
String paramCallback = "paramCallback_example"; // String | None
try {
CompletableFuture<ApiResponse<Void>> response = apiInstance.testEndpointParametersWithHttpInfo(number, _double, patternWithoutDelimiter, _byte, integer, int32, int64, _float, string, binary, date, dateTime, password, paramCallback);
System.out.println("Status code: " + response.get().getStatusCode());
System.out.println("Response headers: " + response.get().getHeaders());
} catch (InterruptedException | ExecutionException e) {
ApiException apiException = (ApiException)e.getCause();
System.err.println("Exception when calling FakeApi#testEndpointParameters");
System.err.println("Status code: " + apiException.getCode());
System.err.println("Response headers: " + apiException.getResponseHeaders());
System.err.println("Reason: " + apiException.getResponseBody());
e.printStackTrace();
} catch (ApiException e) {
System.err.println("Exception when calling FakeApi#testEndpointParameters");
System.err.println("Status code: " + e.getCode());
System.err.println("Response headers: " + e.getResponseHeaders());
System.err.println("Reason: " + e.getResponseBody());
e.printStackTrace();
}
}
}
Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| number | BigDecimal | None | |
| _double | Double | None | |
| patternWithoutDelimiter | String | None | |
| _byte | byte[] | None | |
| integer | Integer | None | [optional] |
| int32 | Integer | None | [optional] |
| int64 | Long | None | [optional] |
| _float | Float | None | [optional] |
| string | String | None | [optional] |
| binary | File | None | [optional] |
| date | LocalDate | None | [optional] |
| dateTime | OffsetDateTime | None | [optional] |
| password | String | None | [optional] |
| paramCallback | String | None | [optional] |
Return type
CompletableFuture<ApiResponse>
Authorization
HTTP request headers
- Content-Type: application/x-www-form-urlencoded
- Accept: Not defined
HTTP response details
| Status code | Description | Response headers |
|---|---|---|
| 400 | Invalid username supplied | - |
| 404 | User not found | - |
testEnumParameters
CompletableFuture testEnumParameters(enumHeaderStringArray, enumHeaderString, enumQueryStringArray, enumQueryString, enumQueryInteger, enumQueryDouble, enumQueryModelArray, enumFormStringArray, enumFormString)
To test enum parameters
To test enum parameters
Example
// Import classes:
import org.openapitools.client.ApiClient;
import org.openapitools.client.ApiException;
import org.openapitools.client.Configuration;
import org.openapitools.client.models.*;
import org.openapitools.client.api.FakeApi;
import java.util.concurrent.CompletableFuture;
public class Example {
public static void main(String[] args) {
ApiClient defaultClient = Configuration.getDefaultApiClient();
defaultClient.setBasePath("http://petstore.swagger.io:80/v2");
FakeApi apiInstance = new FakeApi(defaultClient);
List<String> enumHeaderStringArray = Arrays.asList("$"); // List<String> | Header parameter enum test (string array)
String enumHeaderString = "_abc"; // String | Header parameter enum test (string)
List<String> enumQueryStringArray = Arrays.asList("$"); // List<String> | Query parameter enum test (string array)
String enumQueryString = "_abc"; // String | Query parameter enum test (string)
Integer enumQueryInteger = 1; // Integer | Query parameter enum test (double)
Double enumQueryDouble = 1.1D; // Double | Query parameter enum test (double)
List<EnumClass> enumQueryModelArray = Arrays.asList(-efg); // List<EnumClass> |
List<String> enumFormStringArray = Arrays.asList("$"); // List<String> | Form parameter enum test (string array)
String enumFormString = "_abc"; // String | Form parameter enum test (string)
try {
CompletableFuture<Void> result = apiInstance.testEnumParameters(enumHeaderStringArray, enumHeaderString, enumQueryStringArray, enumQueryString, enumQueryInteger, enumQueryDouble, enumQueryModelArray, enumFormStringArray, enumFormString);
} catch (ApiException e) {
System.err.println("Exception when calling FakeApi#testEnumParameters");
System.err.println("Status code: " + e.getCode());
System.err.println("Reason: " + e.getResponseBody());
System.err.println("Response headers: " + e.getResponseHeaders());
e.printStackTrace();
}
}
}
Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| enumHeaderStringArray | List<String> | Header parameter enum test (string array) | [optional] [enum: >, $] |
| enumHeaderString | String | Header parameter enum test (string) | [optional] [default to -efg] [enum: _abc, -efg, (xyz)] |
| enumQueryStringArray | List<String> | Query parameter enum test (string array) | [optional] [enum: >, $] |
| enumQueryString | String | Query parameter enum test (string) | [optional] [default to -efg] [enum: _abc, -efg, (xyz)] |
| enumQueryInteger | Integer | Query parameter enum test (double) | [optional] [enum: 1, -2] |
| enumQueryDouble | Double | Query parameter enum test (double) | [optional] [enum: 1.1, -1.2] |
| enumQueryModelArray | List<EnumClass> | [optional] | |
| enumFormStringArray | List<String> | Form parameter enum test (string array) | [optional] [enum: >, $] |
| enumFormString | String | Form parameter enum test (string) | [optional] [default to -efg] [enum: _abc, -efg, (xyz)] |
Return type
CompletableFuture (empty response body)
Authorization
No authorization required
HTTP request headers
- Content-Type: application/x-www-form-urlencoded
- Accept: Not defined
HTTP response details
| Status code | Description | Response headers |
|---|---|---|
| 400 | Invalid request | - |
| 404 | Not found | - |
testEnumParametersWithHttpInfo
CompletableFuture<ApiResponse> testEnumParameters testEnumParametersWithHttpInfo(enumHeaderStringArray, enumHeaderString, enumQueryStringArray, enumQueryString, enumQueryInteger, enumQueryDouble, enumQueryModelArray, enumFormStringArray, enumFormString)
To test enum parameters
To test enum parameters
Example
// Import classes:
import org.openapitools.client.ApiClient;
import org.openapitools.client.ApiException;
import org.openapitools.client.ApiResponse;
import org.openapitools.client.Configuration;
import org.openapitools.client.models.*;
import org.openapitools.client.api.FakeApi;
import java.util.concurrent.CompletableFuture;
public class Example {
public static void main(String[] args) {
ApiClient defaultClient = Configuration.getDefaultApiClient();
defaultClient.setBasePath("http://petstore.swagger.io:80/v2");
FakeApi apiInstance = new FakeApi(defaultClient);
List<String> enumHeaderStringArray = Arrays.asList("$"); // List<String> | Header parameter enum test (string array)
String enumHeaderString = "_abc"; // String | Header parameter enum test (string)
List<String> enumQueryStringArray = Arrays.asList("$"); // List<String> | Query parameter enum test (string array)
String enumQueryString = "_abc"; // String | Query parameter enum test (string)
Integer enumQueryInteger = 1; // Integer | Query parameter enum test (double)
Double enumQueryDouble = 1.1D; // Double | Query parameter enum test (double)
List<EnumClass> enumQueryModelArray = Arrays.asList(-efg); // List<EnumClass> |
List<String> enumFormStringArray = Arrays.asList("$"); // List<String> | Form parameter enum test (string array)
String enumFormString = "_abc"; // String | Form parameter enum test (string)
try {
CompletableFuture<ApiResponse<Void>> response = apiInstance.testEnumParametersWithHttpInfo(enumHeaderStringArray, enumHeaderString, enumQueryStringArray, enumQueryString, enumQueryInteger, enumQueryDouble, enumQueryModelArray, enumFormStringArray, enumFormString);
System.out.println("Status code: " + response.get().getStatusCode());
System.out.println("Response headers: " + response.get().getHeaders());
} catch (InterruptedException | ExecutionException e) {
ApiException apiException = (ApiException)e.getCause();
System.err.println("Exception when calling FakeApi#testEnumParameters");
System.err.println("Status code: " + apiException.getCode());
System.err.println("Response headers: " + apiException.getResponseHeaders());
System.err.println("Reason: " + apiException.getResponseBody());
e.printStackTrace();
} catch (ApiException e) {
System.err.println("Exception when calling FakeApi#testEnumParameters");
System.err.println("Status code: " + e.getCode());
System.err.println("Response headers: " + e.getResponseHeaders());
System.err.println("Reason: " + e.getResponseBody());
e.printStackTrace();
}
}
}
Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| enumHeaderStringArray | List<String> | Header parameter enum test (string array) | [optional] [enum: >, $] |
| enumHeaderString | String | Header parameter enum test (string) | [optional] [default to -efg] [enum: _abc, -efg, (xyz)] |
| enumQueryStringArray | List<String> | Query parameter enum test (string array) | [optional] [enum: >, $] |
| enumQueryString | String | Query parameter enum test (string) | [optional] [default to -efg] [enum: _abc, -efg, (xyz)] |
| enumQueryInteger | Integer | Query parameter enum test (double) | [optional] [enum: 1, -2] |
| enumQueryDouble | Double | Query parameter enum test (double) | [optional] [enum: 1.1, -1.2] |
| enumQueryModelArray | List<EnumClass> | [optional] | |
| enumFormStringArray | List<String> | Form parameter enum test (string array) | [optional] [enum: >, $] |
| enumFormString | String | Form parameter enum test (string) | [optional] [default to -efg] [enum: _abc, -efg, (xyz)] |
Return type
CompletableFuture<ApiResponse>
Authorization
No authorization required
HTTP request headers
- Content-Type: application/x-www-form-urlencoded
- Accept: Not defined
HTTP response details
| Status code | Description | Response headers |
|---|---|---|
| 400 | Invalid request | - |
| 404 | Not found | - |
testGroupParameters
CompletableFuture testGroupParameters(testGroupParametersRequest)
Fake endpoint to test group parameters (optional)
Fake endpoint to test group parameters (optional)
Example
// Import classes:
import org.openapitools.client.ApiClient;
import org.openapitools.client.ApiException;
import org.openapitools.client.Configuration;
import org.openapitools.client.auth.*;
import org.openapitools.client.models.*;
import org.openapitools.client.api.FakeApi;
import org.openapitools.client.api.FakeApi.*;
import java.util.concurrent.CompletableFuture;
public class Example {
public static void main(String[] args) {
ApiClient defaultClient = Configuration.getDefaultApiClient();
defaultClient.setBasePath("http://petstore.swagger.io:80/v2");
// Configure HTTP bearer authorization: bearer_test
HttpBearerAuth bearer_test = (HttpBearerAuth) defaultClient.getAuthentication("bearer_test");
bearer_test.setBearerToken("BEARER TOKEN");
FakeApi apiInstance = new FakeApi(defaultClient);
Integer requiredStringGroup = 56; // Integer | Required String in group parameters
Boolean requiredBooleanGroup = true; // Boolean | Required Boolean in group parameters
Long requiredInt64Group = 56L; // Long | Required Integer in group parameters
Integer stringGroup = 56; // Integer | String in group parameters
Boolean booleanGroup = true; // Boolean | Boolean in group parameters
Long int64Group = 56L; // Long | Integer in group parameters
try {
APItestGroupParametersRequest request = APItestGroupParametersRequest.newBuilder()
.requiredStringGroup(requiredStringGroup)
.requiredBooleanGroup(requiredBooleanGroup)
.requiredInt64Group(requiredInt64Group)
.stringGroup(stringGroup)
.booleanGroup(booleanGroup)
.int64Group(int64Group)
.build();
CompletableFuture<Void> result = apiInstance.testGroupParameters(request);
} catch (ApiException e) {
System.err.println("Exception when calling FakeApi#testGroupParameters");
System.err.println("Status code: " + e.getCode());
System.err.println("Reason: " + e.getResponseBody());
System.err.println("Response headers: " + e.getResponseHeaders());
e.printStackTrace();
}
}
}
Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| testGroupParametersRequest | APItestGroupParametersRequest | - | - |
Return type
CompletableFuture (empty response body)
Authorization
HTTP request headers
- Content-Type: Not defined
- Accept: Not defined
HTTP response details
| Status code | Description | Response headers |
|---|---|---|
| 400 | Something wrong | - |
testGroupParametersWithHttpInfo
CompletableFuture<ApiResponse> testGroupParameters testGroupParametersWithHttpInfo(testGroupParametersRequest)
Fake endpoint to test group parameters (optional)
Fake endpoint to test group parameters (optional)
Example
// Import classes:
import org.openapitools.client.ApiClient;
import org.openapitools.client.ApiException;
import org.openapitools.client.ApiResponse;
import org.openapitools.client.Configuration;
import org.openapitools.client.auth.*;
import org.openapitools.client.models.*;
import org.openapitools.client.api.FakeApi;
import org.openapitools.client.api.FakeApi.*;
import java.util.concurrent.CompletableFuture;
public class Example {
public static void main(String[] args) {
ApiClient defaultClient = Configuration.getDefaultApiClient();
defaultClient.setBasePath("http://petstore.swagger.io:80/v2");
// Configure HTTP bearer authorization: bearer_test
HttpBearerAuth bearer_test = (HttpBearerAuth) defaultClient.getAuthentication("bearer_test");
bearer_test.setBearerToken("BEARER TOKEN");
FakeApi apiInstance = new FakeApi(defaultClient);
Integer requiredStringGroup = 56; // Integer | Required String in group parameters
Boolean requiredBooleanGroup = true; // Boolean | Required Boolean in group parameters
Long requiredInt64Group = 56L; // Long | Required Integer in group parameters
Integer stringGroup = 56; // Integer | String in group parameters
Boolean booleanGroup = true; // Boolean | Boolean in group parameters
Long int64Group = 56L; // Long | Integer in group parameters
try {
APItestGroupParametersRequest request = APItestGroupParametersRequest.newBuilder()
.requiredStringGroup(requiredStringGroup)
.requiredBooleanGroup(requiredBooleanGroup)
.requiredInt64Group(requiredInt64Group)
.stringGroup(stringGroup)
.booleanGroup(booleanGroup)
.int64Group(int64Group)
.build();
CompletableFuture<ApiResponse<Void>> response = apiInstance.testGroupParametersWithHttpInfo(request);
System.out.println("Status code: " + response.get().getStatusCode());
System.out.println("Response headers: " + response.get().getHeaders());
} catch (InterruptedException | ExecutionException e) {
ApiException apiException = (ApiException)e.getCause();
System.err.println("Exception when calling FakeApi#testGroupParameters");
System.err.println("Status code: " + apiException.getCode());
System.err.println("Response headers: " + apiException.getResponseHeaders());
System.err.println("Reason: " + apiException.getResponseBody());
e.printStackTrace();
} catch (ApiException e) {
System.err.println("Exception when calling FakeApi#testGroupParameters");
System.err.println("Status code: " + e.getCode());
System.err.println("Response headers: " + e.getResponseHeaders());
System.err.println("Reason: " + e.getResponseBody());
e.printStackTrace();
}
}
}
Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| testGroupParametersRequest | APItestGroupParametersRequest | - | - |
Return type
CompletableFuture<ApiResponse>
Authorization
HTTP request headers
- Content-Type: Not defined
- Accept: Not defined
HTTP response details
| Status code | Description | Response headers |
|---|---|---|
| 400 | Something wrong | - |
APItestGroupParametersRequest
Properties
| Name | Type | Description | Notes |
|---|---|---|---|
| requiredStringGroup | Integer | Required String in group parameters | |
| requiredBooleanGroup | Boolean | Required Boolean in group parameters | |
| requiredInt64Group | Long | Required Integer in group parameters | |
| stringGroup | Integer | String in group parameters | [optional] |
| booleanGroup | Boolean | Boolean in group parameters | [optional] |
| int64Group | Long | Integer in group parameters | [optional] |
testInlineAdditionalProperties
CompletableFuture testInlineAdditionalProperties(requestBody)
test inline additionalProperties
Example
// Import classes:
import org.openapitools.client.ApiClient;
import org.openapitools.client.ApiException;
import org.openapitools.client.Configuration;
import org.openapitools.client.models.*;
import org.openapitools.client.api.FakeApi;
import java.util.concurrent.CompletableFuture;
public class Example {
public static void main(String[] args) {
ApiClient defaultClient = Configuration.getDefaultApiClient();
defaultClient.setBasePath("http://petstore.swagger.io:80/v2");
FakeApi apiInstance = new FakeApi(defaultClient);
Map<String, String> requestBody = new HashMap(); // Map<String, String> | request body
try {
CompletableFuture<Void> result = apiInstance.testInlineAdditionalProperties(requestBody);
} catch (ApiException e) {
System.err.println("Exception when calling FakeApi#testInlineAdditionalProperties");
System.err.println("Status code: " + e.getCode());
System.err.println("Reason: " + e.getResponseBody());
System.err.println("Response headers: " + e.getResponseHeaders());
e.printStackTrace();
}
}
}
Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| requestBody | Map<String, String> | request body |
Return type
CompletableFuture (empty response body)
Authorization
No authorization required
HTTP request headers
- Content-Type: application/json
- Accept: Not defined
HTTP response details
| Status code | Description | Response headers |
|---|---|---|
| 200 | successful operation | - |
testInlineAdditionalPropertiesWithHttpInfo
CompletableFuture<ApiResponse> testInlineAdditionalProperties testInlineAdditionalPropertiesWithHttpInfo(requestBody)
test inline additionalProperties
Example
// Import classes:
import org.openapitools.client.ApiClient;
import org.openapitools.client.ApiException;
import org.openapitools.client.ApiResponse;
import org.openapitools.client.Configuration;
import org.openapitools.client.models.*;
import org.openapitools.client.api.FakeApi;
import java.util.concurrent.CompletableFuture;
public class Example {
public static void main(String[] args) {
ApiClient defaultClient = Configuration.getDefaultApiClient();
defaultClient.setBasePath("http://petstore.swagger.io:80/v2");
FakeApi apiInstance = new FakeApi(defaultClient);
Map<String, String> requestBody = new HashMap(); // Map<String, String> | request body
try {
CompletableFuture<ApiResponse<Void>> response = apiInstance.testInlineAdditionalPropertiesWithHttpInfo(requestBody);
System.out.println("Status code: " + response.get().getStatusCode());
System.out.println("Response headers: " + response.get().getHeaders());
} catch (InterruptedException | ExecutionException e) {
ApiException apiException = (ApiException)e.getCause();
System.err.println("Exception when calling FakeApi#testInlineAdditionalProperties");
System.err.println("Status code: " + apiException.getCode());
System.err.println("Response headers: " + apiException.getResponseHeaders());
System.err.println("Reason: " + apiException.getResponseBody());
e.printStackTrace();
} catch (ApiException e) {
System.err.println("Exception when calling FakeApi#testInlineAdditionalProperties");
System.err.println("Status code: " + e.getCode());
System.err.println("Response headers: " + e.getResponseHeaders());
System.err.println("Reason: " + e.getResponseBody());
e.printStackTrace();
}
}
}
Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| requestBody | Map<String, String> | request body |
Return type
CompletableFuture<ApiResponse>
Authorization
No authorization required
HTTP request headers
- Content-Type: application/json
- Accept: Not defined
HTTP response details
| Status code | Description | Response headers |
|---|---|---|
| 200 | successful operation | - |
testJsonFormData
CompletableFuture testJsonFormData(param, param2)
test json serialization of form data
Example
// Import classes:
import org.openapitools.client.ApiClient;
import org.openapitools.client.ApiException;
import org.openapitools.client.Configuration;
import org.openapitools.client.models.*;
import org.openapitools.client.api.FakeApi;
import java.util.concurrent.CompletableFuture;
public class Example {
public static void main(String[] args) {
ApiClient defaultClient = Configuration.getDefaultApiClient();
defaultClient.setBasePath("http://petstore.swagger.io:80/v2");
FakeApi apiInstance = new FakeApi(defaultClient);
String param = "param_example"; // String | field1
String param2 = "param2_example"; // String | field2
try {
CompletableFuture<Void> result = apiInstance.testJsonFormData(param, param2);
} catch (ApiException e) {
System.err.println("Exception when calling FakeApi#testJsonFormData");
System.err.println("Status code: " + e.getCode());
System.err.println("Reason: " + e.getResponseBody());
System.err.println("Response headers: " + e.getResponseHeaders());
e.printStackTrace();
}
}
}
Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| param | String | field1 | |
| param2 | String | field2 |
Return type
CompletableFuture (empty response body)
Authorization
No authorization required
HTTP request headers
- Content-Type: application/x-www-form-urlencoded
- Accept: Not defined
HTTP response details
| Status code | Description | Response headers |
|---|---|---|
| 200 | successful operation | - |
testJsonFormDataWithHttpInfo
CompletableFuture<ApiResponse> testJsonFormData testJsonFormDataWithHttpInfo(param, param2)
test json serialization of form data
Example
// Import classes:
import org.openapitools.client.ApiClient;
import org.openapitools.client.ApiException;
import org.openapitools.client.ApiResponse;
import org.openapitools.client.Configuration;
import org.openapitools.client.models.*;
import org.openapitools.client.api.FakeApi;
import java.util.concurrent.CompletableFuture;
public class Example {
public static void main(String[] args) {
ApiClient defaultClient = Configuration.getDefaultApiClient();
defaultClient.setBasePath("http://petstore.swagger.io:80/v2");
FakeApi apiInstance = new FakeApi(defaultClient);
String param = "param_example"; // String | field1
String param2 = "param2_example"; // String | field2
try {
CompletableFuture<ApiResponse<Void>> response = apiInstance.testJsonFormDataWithHttpInfo(param, param2);
System.out.println("Status code: " + response.get().getStatusCode());
System.out.println("Response headers: " + response.get().getHeaders());
} catch (InterruptedException | ExecutionException e) {
ApiException apiException = (ApiException)e.getCause();
System.err.println("Exception when calling FakeApi#testJsonFormData");
System.err.println("Status code: " + apiException.getCode());
System.err.println("Response headers: " + apiException.getResponseHeaders());
System.err.println("Reason: " + apiException.getResponseBody());
e.printStackTrace();
} catch (ApiException e) {
System.err.println("Exception when calling FakeApi#testJsonFormData");
System.err.println("Status code: " + e.getCode());
System.err.println("Response headers: " + e.getResponseHeaders());
System.err.println("Reason: " + e.getResponseBody());
e.printStackTrace();
}
}
}
Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| param | String | field1 | |
| param2 | String | field2 |
Return type
CompletableFuture<ApiResponse>
Authorization
No authorization required
HTTP request headers
- Content-Type: application/x-www-form-urlencoded
- Accept: Not defined
HTTP response details
| Status code | Description | Response headers |
|---|---|---|
| 200 | successful operation | - |
testQueryParameterCollectionFormat
CompletableFuture testQueryParameterCollectionFormat(pipe, ioutil, http, url, context, allowEmpty, language)
To test the collection format in query parameters
Example
// Import classes:
import org.openapitools.client.ApiClient;
import org.openapitools.client.ApiException;
import org.openapitools.client.Configuration;
import org.openapitools.client.models.*;
import org.openapitools.client.api.FakeApi;
import java.util.concurrent.CompletableFuture;
public class Example {
public static void main(String[] args) {
ApiClient defaultClient = Configuration.getDefaultApiClient();
defaultClient.setBasePath("http://petstore.swagger.io:80/v2");
FakeApi apiInstance = new FakeApi(defaultClient);
List<String> pipe = Arrays.asList(); // List<String> |
List<String> ioutil = Arrays.asList(); // List<String> |
List<String> http = Arrays.asList(); // List<String> |
List<String> url = Arrays.asList(); // List<String> |
List<String> context = Arrays.asList(); // List<String> |
String allowEmpty = "allowEmpty_example"; // String |
Map<String, String> language = new HashMap(); // Map<String, String> |
try {
CompletableFuture<Void> result = apiInstance.testQueryParameterCollectionFormat(pipe, ioutil, http, url, context, allowEmpty, language);
} catch (ApiException e) {
System.err.println("Exception when calling FakeApi#testQueryParameterCollectionFormat");
System.err.println("Status code: " + e.getCode());
System.err.println("Reason: " + e.getResponseBody());
System.err.println("Response headers: " + e.getResponseHeaders());
e.printStackTrace();
}
}
}
Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| pipe | List<String> | ||
| ioutil | List<String> | ||
| http | List<String> | ||
| url | List<String> | ||
| context | List<String> | ||
| allowEmpty | String | ||
| language | Map<String, String> | [optional] |
Return type
CompletableFuture (empty response body)
Authorization
No authorization required
HTTP request headers
- Content-Type: Not defined
- Accept: Not defined
HTTP response details
| Status code | Description | Response headers |
|---|---|---|
| 200 | Success | - |
testQueryParameterCollectionFormatWithHttpInfo
CompletableFuture<ApiResponse> testQueryParameterCollectionFormat testQueryParameterCollectionFormatWithHttpInfo(pipe, ioutil, http, url, context, allowEmpty, language)
To test the collection format in query parameters
Example
// Import classes:
import org.openapitools.client.ApiClient;
import org.openapitools.client.ApiException;
import org.openapitools.client.ApiResponse;
import org.openapitools.client.Configuration;
import org.openapitools.client.models.*;
import org.openapitools.client.api.FakeApi;
import java.util.concurrent.CompletableFuture;
public class Example {
public static void main(String[] args) {
ApiClient defaultClient = Configuration.getDefaultApiClient();
defaultClient.setBasePath("http://petstore.swagger.io:80/v2");
FakeApi apiInstance = new FakeApi(defaultClient);
List<String> pipe = Arrays.asList(); // List<String> |
List<String> ioutil = Arrays.asList(); // List<String> |
List<String> http = Arrays.asList(); // List<String> |
List<String> url = Arrays.asList(); // List<String> |
List<String> context = Arrays.asList(); // List<String> |
String allowEmpty = "allowEmpty_example"; // String |
Map<String, String> language = new HashMap(); // Map<String, String> |
try {
CompletableFuture<ApiResponse<Void>> response = apiInstance.testQueryParameterCollectionFormatWithHttpInfo(pipe, ioutil, http, url, context, allowEmpty, language);
System.out.println("Status code: " + response.get().getStatusCode());
System.out.println("Response headers: " + response.get().getHeaders());
} catch (InterruptedException | ExecutionException e) {
ApiException apiException = (ApiException)e.getCause();
System.err.println("Exception when calling FakeApi#testQueryParameterCollectionFormat");
System.err.println("Status code: " + apiException.getCode());
System.err.println("Response headers: " + apiException.getResponseHeaders());
System.err.println("Reason: " + apiException.getResponseBody());
e.printStackTrace();
} catch (ApiException e) {
System.err.println("Exception when calling FakeApi#testQueryParameterCollectionFormat");
System.err.println("Status code: " + e.getCode());
System.err.println("Response headers: " + e.getResponseHeaders());
System.err.println("Reason: " + e.getResponseBody());
e.printStackTrace();
}
}
}
Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| pipe | List<String> | ||
| ioutil | List<String> | ||
| http | List<String> | ||
| url | List<String> | ||
| context | List<String> | ||
| allowEmpty | String | ||
| language | Map<String, String> | [optional] |
Return type
CompletableFuture<ApiResponse>
Authorization
No authorization required
HTTP request headers
- Content-Type: Not defined
- Accept: Not defined
HTTP response details
| Status code | Description | Response headers |
|---|---|---|
| 200 | Success | - |