}
    }

    @Nested
    @DisplayName("Tests requiring mocks")
    @ExtendWith(MockitoExtension.class)
    class MockedTests {
        @Mock
        CIFSContext mockCtx;

        @Mock
        SidResolver mockResolver;

        @BeforeEach
        void setup() {
            lenient().when(mockCtx.getSIDResolver()).thenReturn(mockResolver);
        }

import jcifs.internal.util.SMBUtil;

/**
 * Test class for AndXServerMessageBlock
 */
class AndXServerMessageBlockTest {

    @Mock
    private Configuration mockConfig;

    @Mock
    private ServerMessageBlock mockAndxCommand;

    @Mock
    private SMB1SigningDigest mockDigest;

    private TestAndXServerMessageBlock testBlock;

    /**
     * Test implementation of AndXServerMessageBlock for testing
     */

import org.junit.jupiter.params.provider.ValueSource;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;

import jcifs.Configuration;
import jcifs.internal.SMBProtocolDecodingException;
import jcifs.internal.util.SMBUtil;
import jcifs.smb.NtStatus;

class Smb2EchoResponseTest {

    @Mock
    private Configuration mockConfig;

    @Mock
    private Smb2SigningDigest mockDigest;

Esto significaría que **FastAPI** esperaría un cuerpo similar a:

```JSON
{
    "name": "Foo",
    "description": "The pretender",
    "price": 42.0,
    "tax": 3.2,
    "tags": ["rock", "metal", "bar"],
    "image": {
        "url": "http://example.com/baz.jpg",
        "name": "The Foo live"
    }
}
```

Nuevamente, haciendo solo esa declaración, con **FastAPI** obtienes:

import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
import org.mockito.MockedStatic;
import org.mockito.Mockito;
import org.mockito.junit.jupiter.MockitoExtension;

import jcifs.pac.PACDecodingException;

/**
 * Unit tests for the KerberosTicket class.
 */
@ExtendWith(MockitoExtension.class)
class KerberosTicketTest {

    @Mock
    private KerberosKey kerberosKey;

import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;

import jcifs.Configuration;

@ExtendWith(MockitoExtension.class)
class NameQueryResponseTest {

    @Mock
    private Configuration mockConfig;

    private NameQueryResponse nameQueryResponse;

    @BeforeEach
    void setUp() {
        // Mock the OEM encoding configuration with lenient stubbing

        super.setUp();
        curtainFinallyHook = new FessCurtainFinallyHook();
    }

    // Test normal execution of hook method
    public void test_hook_normalExecution() {
        // Create a mock FwAssistantDirector
        FwAssistantDirector assistantDirector = createMockAssistantDirector();

        // Should not throw any exception during normal execution
        curtainFinallyHook.hook(assistantDirector);

			return
		}
		if lockEnabled {
			lock, _, _, _, err := clnt.GetObjectLockConfig(ctx, clnt.Bucket)
			if err != nil {
				writeErrorResponse(ctx, w, errorCodes.ToAPIErrWithErr(ErrReplicationValidationError, err), r.URL)
				return
			}
			if lock != objectlock.Enabled {

import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;

import jcifs.dcerpc.ndr.NdrBuffer;

/**
 * Comprehensive test suite for jcifs.dcerpc.DcerpcBind class.
 * Tests DCE/RPC bind message functionality for MSRPC protocol compliance.
 */
@ExtendWith(MockitoExtension.class)
@DisplayName("DcerpcBind Tests")
class DcerpcBindTest {

    @Mock
    private DcerpcBinding mockBinding;

Це означатиме, що  **FastAPI**  очікуватиме тіло запиту такого вигляду:

```JSON
{
    "name": "Foo",
    "description": "The pretender",
    "price": 42.0,
    "tax": 3.2,
    "tags": ["rock", "metal", "bar"],
    "image": {
        "url": "http://example.com/baz.jpg",
        "name": "The Foo live"
    }
}
```

Завдяки такій декларації у **FastAPI** Ви отримуєте: