preauthService.updatePreauthHash("non-existent", "test".getBytes());
        });
    }

    @Test
    @DisplayName("Test context invalidation")
    public void testContextInvalidation() throws CIFSException {
        String sessionId = "test-session-invalidation";
        byte[] salt = preauthService.generatePreauthSalt();

     */
    public TcpMemoryRegion(ByteBuffer buffer, EnumSet<RdmaAccess> access) {
        super(buffer, access);
    }

    @Override
    public void invalidate() {
        // No real invalidation needed for TCP
        valid = false;
    }

    @Override
    protected int generateLocalKey() {
        return keyGenerator.getAndIncrement();
    }

    @Override

     */
    public static final int SMB2_CHANNEL_RDMA_V1 = 0x00000001;

    /**
     * SMB2 Channel constant for RDMA V1 invalidate
     * Used to indicate RDMA with invalidation
     */
    public static final int SMB2_CHANNEL_RDMA_V1_INVALIDATE = 0x00000002;

    /**
     * SMB2 RDMA Transform Capabilities negotiate context ID
     */

     *
     * @return true if valid, false if invalidated
     */
    public boolean isValid() {
        return valid;
    }

    /**
     * Invalidate this memory region
     *
     * After invalidation, the region cannot be used for RDMA operations.
     */
    public abstract void invalidate();

    /**
     * Generate local key for this memory region
     *
     * @return local key
     */

     */
    public void setMaxCacheAge(long maxCacheAge) {
        this.maxCacheAge = maxCacheAge;
    }

    /**
     * Checks if directory change notifications are enabled for cache invalidation
     * @return true if change notifications are enabled
     */
    public boolean isNotificationEnabled() {
        return notificationEnabled;
    }

    /**

        case FILE_MODIFIED:
            // Remove from cache to force refresh
            entry.removeChild(childName);
            break;

        case DIRECTORY_RENAMED:
            // Full invalidation needed
            entry.invalidate();
            break;

        case ATTRIBUTES_CHANGED:
            // Remove from cache to force refresh
            entry.removeChild(childName);
            break;

                // Remove from cache to force refresh
                entry.removeChild(childName);
                break;
                
            case DIRECTORY_RENAMED:
                // Full invalidation needed
                entry.invalidate();
                break;
        }
    }
    
    public void handleDirectoryLeaseBreak(Smb2LeaseKey leaseKey, int newState) {

    /**
     * Directory cache timeout in milliseconds
     */
    protected long directoryCacheTimeout = 30000L;
    /**
     * Whether directory change notifications are enabled for cache invalidation
     */
    protected boolean directoryNotificationsEnabled = true;
    /**
     * Maximum number of cached directory entries
     */
    protected int maxDirectoryCacheEntries = 1000;

@app.post(
    "/model-optional-validation-alias", operation_id="model_optional_validation_alias"
)
def read_model_optional_validation_alias(
    p: Annotated[FormModelOptionalValidationAlias, Form()],
):
    return {"p": p.p}


@pytest.mark.parametrize(
    "path",
    ["/optional-validation-alias", "/model-optional-validation-alias"],
)
def test_optional_validation_alias_schema(path: str):

# Validation alias


@app.get("/required-validation-alias")
def read_required_validation_alias(
    p: Annotated[str, Query(validation_alias="p_val_alias")],
):
    return {"p": p}


class QueryModelRequiredValidationAlias(BaseModel):
    p: str = Field(validation_alias="p_val_alias")


@app.get("/model-required-validation-alias")