// Then: Verify the decoding sequence and values
            verify(mockNdrBuffer, times(2)).align(4);
            verify(mockNdrBuffer, times(2)).dec_ndr_long();
            verify(mockNdrBuffer, times(2)).dec_ndr_short();
            verify(mockNdrBuffer, times(8)).dec_ndr_small();
            verify(mockNdrBuffer).advance(6);
            verify(mockNdrBuffer).derive(anyInt());

    }

    @Test
    @DisplayName("Test size returns positive message size")
    void testSizeReturnsPositiveValue() {
        // Given
        int expectedSize = 1024;
        when(request.size()).thenReturn(expectedSize);

        // When
        int result = request.size();

        // Then
        assertEquals(expectedSize, result);
        verify(request, times(1)).size();

        };

        for (long[] times : timeValues) {
            // Given
            FileBasicInfo info = new FileBasicInfo(times[0], // create time
                    times[1], // last access time
                    times[2], // last write time
                    times[3], // change time
                    TEST_ATTRIBUTES);

import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.atLeast;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

import java.util.ArrayList;
import java.util.List;

import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;

            assertArrayEquals(finalDigest, result);
            verify(mockMd5, times(1)).digest(); // First call for inner digest
            verify(mockMd5, times(2)).update(any(byte[].class)); // Once in constructor with ipad, once in engineDigest with opad
            verify(mockMd5, times(1)).digest(innerDigest); // Second call for final digest
        }
    }

    @Test

        verify(file, times(1)).getAttributes();
    }

    @Test
    public void testAcceptReturnsFalseWhenAttributesDoNotMatch() throws Exception {
        SmbFile file = mock(SmbFile.class);
        when(file.getAttributes()).thenReturn(SmbFile.ATTR_HIDDEN);
        assertFalse(filter.accept(file), "Attributes not matching should be rejected");
        verify(file, times(1)).getAttributes();
    }

    @Test

        // Act
        handle.close();

        // Assert
        // Verify sendrecv was called once for open and once for close
        verify(mockDcerpcHandle, times(1)).sendrecv(any(MsrpcLsarOpenPolicy2.class));
        verify(mockDcerpcHandle, times(1)).sendrecv(any(MsrpcLsarClose.class));
    }

    @Test
    void close_shouldThrowSmbExceptionOnRpcError() throws IOException {
        // Arrange

read_query["/items/"]

query_extractor --> query_or_cookie_extractor --> read_query
```

## Using the same dependency multiple times { #using-the-same-dependency-multiple-times }

If one of your dependencies is declared multiple times for the same *path operation*, for example, multiple dependencies have a common sub-dependency, **FastAPI** will know to call that sub-dependency only once per request.

import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;

        verify(mockRequest, times(1)).getCreditCost(); // Verify method was called once
    }

    @Test
    void testSetRequestCredits() {
        // Test case for setRequestCredits method
        int credits = 5;
        mockRequest.setRequestCredits(credits);

        // Verify that setRequestCredits was called with the correct argument
        verify(mockRequest, times(1)).setRequestCredits(credits);
    }