server.enqueue(MockResponse(code = 204))

    val endpointUrl = server.url("/endpoint")

    var request =
      Request
        .Builder()
        .url(endpointUrl)
        .header("Content-Type", "application/xml")
        .put(ValidRequestBody())
        .build()
    client.newCall(request).execute().use {
      assertEquals(201, it.code)
    }

    request =
      Request
        .Builder()

type onlyReader struct {
	io.Reader
}

// An onlyWriter only implements io.Writer, no matter what other methods the underlying implementation may have.
type onlyWriter struct {
	io.Writer
}

// A scriptedReader is an io.Reader that executes its steps sequentially.
type scriptedReader []func(p []byte) (n int, err error)

        assertTrue(locator("smb://server/IPC$/").isIPC());
        assertTrue(locator("smb://server/").isIPC());
        assertFalse(locator("smb://server/share/").isIPC());
    }

    @Test
    @DisplayName("Type detection covers filesystem/share/IPC/workgroup/server")
    void testGetType() throws Exception {
        // Filesystem when there is a path beyond share

}

// client to talk to peer Nodes.
type remotePeerS3Client struct {
	node  Node
	pools []int

	// Function that returns the grid connection for this peer when initialized.
	// Will return nil if the grid connection is not initialized yet.
	gridConn func() *grid.Connection
}

// S3PeerSys - S3 peer call system.
type S3PeerSys struct {
	peerClients []peerS3Client // Excludes self

# Background Tasks - `BackgroundTasks`

You can declare a parameter in a *path operation function* or dependency function with the type `BackgroundTasks`, and then you can use it to schedule the execution of background tasks after the response is sent.

You can import it directly from `fastapi`:

```python
from fastapi import BackgroundTasks
```

            final String type;
            if (arrayFieldSet.contains(key)) {
                type = "array";
            } else if (dateFieldSet.contains(key)) {
                type = "date";
            } else if (integerFieldSet.contains(key) || longFieldSet.contains(key) || floatFieldSet.contains(key)
                    || doubleFieldSet.contains(key)) {
                type = "number";
            } else {

# Модель відповіді — Тип, що повертається { #response-model-return-type }

Ви можете оголосити тип, який використовуватиметься у відповіді, анотувавши **тип повернення** *функції операції шляху*.

**Анотації типів** можна використовувати так само, як і для вхідних даних у **параметрах** функції: можна використовувати моделі Pydantic, списки, словники, скалярні значення, як-от цілі числа, булеві значення тощо.

# Модель ответа — Возвращаемый тип { #response-model-return-type }

Вы можете объявить тип, используемый для ответа, указав аннотацию **возвращаемого значения** для *функции-обработчика пути*.

Вы можете использовать **аннотации типов** так же, как и для входных данных в **параметрах** функции: Pydantic-модели, списки, словари, скалярные значения (целые числа, булевы и т.д.).

{* ../../docs_src/response_model/tutorial001_01_py310.py hl[16,21] *}

		}
		err := s.Err()
		if err != nil {
			t.Errorf("#%d: %v", n, err)
		}
	}
}

// slowReader is a reader that returns only a few bytes at a time, to test the incremental
// reads in Scanner.Scan.
type slowReader struct {
	max int
	buf io.Reader
}

func (sr *slowReader) Read(p []byte) (n int, err error) {
	if len(p) > sr.max {
		p = p[0:sr.max]
	}
	return sr.buf.Read(p)
}

                out.write(in);
            }
        });
    }

    /**
     * Determines the MIME type of an image file based on its file extension.
     *
     * @param imageFile the image file
     * @return the MIME type string
     */
    protected String getImageMimeType(final File imageFile) {
        final String path = imageFile.getAbsolutePath();