allowHostPorts: false
allowPrivilegeEscalation: true
allowPrivilegedContainer: false
allowedCapabilities: []
readOnlyRootFilesystem: false
defaultAddCapabilities: []
requiredDropCapabilities:
- KILL
- MKNOD
- SETUID
- SETGID
fsGroup:
  type: MustRunAs
  ranges:
  - max: {{ .Values.securityContext.fsGroup }}
    min: {{ .Values.securityContext.fsGroup }}
runAsUser:
  type: MustRunAs
  uid: {{ .Values.securityContext.runAsUser }}

    /**
     * Gets the message ID.
     *
     * @return the message id
     */
    long getMid();

    /**
     * Sets the message ID.
     *
     * @param mid the message ID to set
     */
    void setMid(long mid);

    /**
     * Gets the SMB command.
     *
     * @return the command
     */
    int getCommand();

    /**

        // Mock config methods needed for SMB1
        when(config.getPid()).thenReturn(1234);

        SmbComTreeConnectAndXResponse response = mock(SmbComTreeConnectAndXResponse.class);
        when(response.getService()).thenReturn("A:");
        when(response.isValidTid()).thenReturn(true);
        when(response.getTid()).thenReturn(1);
        when(session.send(any(), any())).thenReturn(response);

class PetOut(BaseModel):
    name: str
    owner: UserBase


@app.post("/users/", response_model=UserBase)
async def create_user(user: UserCreate):
    return user


@app.get("/pets/{pet_id}", response_model=PetOut)
async def read_pet(pet_id: int):
    user = UserDB(
        email="******@****.***",
        hashed_password="secrethashed",
    )
    pet = PetDB(name="Nibbler", owner=user)
    return pet

        assertEquals(endpoint, dcerpcBinding.getEndpoint(), "Endpoint should be set correctly.");
        assertNotNull(dcerpcBinding.getUuid(), "UUID should be set for a valid pipe endpoint.");
        assertEquals("4B324FC8-1670-01D3-1278-5A47BF6EE188", dcerpcBinding.getUuid().toString(), "UUID should be parsed correctly.");
        assertEquals(3, dcerpcBinding.getMajor(), "Major version should be parsed correctly.");

        // Should return dataCount
        assertEquals(5, result);
    }

    @Test
    void testGetSid() {
        // Test the getSid method
        // By default, it should be 0
        assertEquals(0, response.getSid());
    }

    @Test
    void testGetResumeKey() {
        // Test the getResumeKey method
        // By default, it should be 0

                    th.getConfig().getListSize() - FIND_OVERHEAD), this.response);

            this.nextRequest = new Trans2FindNext2(th.getConfig(), this.response.getSid(), this.response.getResumeKey(),
                    this.response.getLastName(), th.getConfig().getListCount(), th.getConfig().getListSize() - FIND_OVERHEAD);
        } catch (final SmbException e) {

        long mid = 12345L;
        mockResponse.setMid(mid);

        // Verify that the method was called with the correct argument
        verify(mockResponse, times(1)).setMid(mid);
    }

    @Test
    void testGetMid() {
        long mid = 54321L;
        when(mockResponse.getMid()).thenReturn(mid);
        assertEquals(mid, mockResponse.getMid());

        // Verify the method was called

     */
    public int getMaximalAccess() {
        return this.maximalAccess;
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.internal.TreeConnectResponse#getTid()
     */
    @Override
    public final int getTid() {
        return getTreeId();
    }

    @Override
    public boolean isValidTid() {
        return getTreeId() != -1;
    }

    /**
     * {@inheritDoc}

        UUID uuid = UUID.randomUUID();
        HandleGuid guid1 = new HandleGuid(uuid);
        HandleGuid guid2 = new HandleGuid(guid1.toBytes());

        assertEquals(guid1, guid2);
        assertEquals(uuid, guid1.getUuid());
    }

    @Test
    public void testHandleGuidInvalidBytes() {
        assertThrows(IllegalArgumentException.class, () -> {
            new HandleGuid(new byte[8]); // Wrong length
        });