If you want to return additional status codes apart from the main one, you can do that by returning a `Response` directly, like a `JSONResponse`, and set the additional status code directly.

For example, let's say that you want to have a *path operation* that allows to update items, and returns HTTP status codes of 200 "OK" when successful.

      // OkHttp doesn't reject U+FFFD encoded in Punycode.
      "xn--zn7c.com",
      // OkHttp doesn't reject a U+200D. https://www.rfc-editor.org/rfc/rfc5892.html#appendix-A.2
      "xn--1ug.example",
      // OkHttp doesn't implement CheckJoiners.
      "\u200D.example",
      // OkHttp doesn't implement CheckBidi.
      "يa",
    )

  @Test
  fun test() {
    val list = WebPlatformToAsciiData.load()

If a client tries to send some **extra** data in the **query parameters**, they will receive an **error** response.

For example, if the client tries to send a `tool` query parameter with a value of `plumbus`, like:

```http
https://example.com/items/?limit=10&tool=plumbus
```

They will receive an **error** response telling them that the query parameter `tool` is not allowed:

```json
{

            "servers": [
                {"url": "/api/v1"},
                {
                    "url": "https://stag.example.com",
                    "description": "Staging environment",
                },
                {
                    "url": "https://prod.example.com",
                    "description": "Production environment",
                },
            ],
            "paths": {

    @Test
    void getHostNameDelegatesToWrappedInetAddress() {
        InetAddress dummy = mock(InetAddress.class);
        when(dummy.getHostName()).thenReturn("host.example.com");
        UniAddress ua = new UniAddress(dummy);
        assertEquals("host.example.com", ua.getHostName(), "should forward hostName to underlying InetAddress");
    }

    @Test
    void getHostAddressDelegatesToWrappedInetAddress() {

* `allow_origins` - Список джерел, яким дозволено здійснювати міждоменні запити. Наприклад `['https://example.org', 'https://www.example.org']`. Ви можете використовувати `['*']`, щоб дозволити будь-яке джерело.
* `allow_origin_regex` - Рядок регулярного виразу для відповідності джерелам, яким дозволено здійснювати міждоменні запити. Наприклад, `'https://.*\.example\.org'`.

    }

    @Test
    public void test_user_mail() {
        final User user = new User();
        assertNull(user.getMail());

        user.setMail("test@example.com");
        assertEquals("test@example.com", user.getMail());
    }

    @Test
    public void test_user_telephoneNumber() {
        final User user = new User();
        assertNull(user.getTelephoneNumber());

import okhttp3.HttpUrl.Companion.toHttpUrl
import okhttp3.RequestBody.Companion.toRequestBody
import okhttp3.internal.EmptyTags

class RequestCommonTest {
  @Test
  fun constructorNormal() {
    val url = "https://example.com/".toHttpUrl()
    val body = "hello".toRequestBody()
    val headers = headersOf("User-Agent", "RequestTest")
    val method = "PUT"
    val request =
      Request(
        url = url,
        headers = headers,

45 bytes received in 00:00 (3.55 KiB/s)
...
```


Following example shows connecting via sftp client using `minioadmin` credentials, and list a bucket named `runner`:

```
sftp -P 8022 minioadmin@localhost
minioadmin@localhost's password:
Connected to localhost.
sftp> ls runner/
chunkdocs  testdir
```

Following example shows how to download an object locally via `sftp` client:

```

        closeHandleCaptor = ArgumentCaptor.forClass(MsrpcSamrCloseHandle.class);
    }

    @Test
    void constructor_shouldOpenDomainSuccessfully() throws IOException {
        // Arrange
        int access = 0x01; // Example access value
        // Simulate successful RPC call
        doAnswer(invocation -> {
            MsrpcSamrOpenDomain rpc = invocation.getArgument(0);
            rpc.retval = 0; // Success
            return null;