List<LogNotificationEvent> events = helper.drainAll();
        assertEquals(2, events.size());
        assertEquals("message1", events.get(0).getMessage());
        assertEquals("message2", events.get(1).getMessage());
    }

    @Test
    public void test_drainAll_empty() {
        LogNotificationHelper helper = new LogNotificationHelper();

              }
              countingRunnable.integer.addAndGet(localRunnable.integer.get());
            }
          };
      threads.add(thread);
    }
  }

  @AfterExperiment
  void after() {
    for (Thread thread : threads) {
      thread.interrupt(); // try to get them to exit
    }
    threads.clear();
  }

  @Footprint
  Object measureSize() {
    return executor;

  }

  // TODO(lukes): Consider throwing InterruptedException when appropriate.
  @Override
  @ParametricNullness
  public V get() {
    return value;
  }

  @Override
  @ParametricNullness
  public V get(long timeout, TimeUnit unit) throws ExecutionException {
    checkNotNull(unit);
    return get();
  }

  @Override
  public boolean isCancelled() {
    return false;
  }

  @Override

    }

    /**
     * Get buffer offset
     *
     * @return offset within registered buffer
     */
    public long getOffset() {
        return offset;
    }

    /**
     * Get RDMA token
     *
     * @return RDMA provider token
     */
    public int getToken() {
        return token;
    }

    /**
     * Get buffer length
     *
     * @return buffer length

    /**
     * Username used to log in to the host
     */
    private String username;

    /**
     * Password associated with the login
     */
    private String password;

    /**
     * Get the user's password which is used when connecting to the repository.
     *
     * @return password of user
     */
    public String getPassword() {
        return password;
    }

    /**

But there are specific cases where it's useful to get the `Request` object.

## Use the `Request` object directly { #use-the-request-object-directly }

Let's imagine you want to get the client's IP address/host inside of your *path operation function*.

For that you need to access the request directly.

            modelProperties.put(REVISION_PROPERTY, request.getUserProperties().get(REVISION_PROPERTY));
        }
        if (request.getUserProperties().containsKey(CHANGELIST_PROPERTY)) {
            modelProperties.put(CHANGELIST_PROPERTY, request.getUserProperties().get(CHANGELIST_PROPERTY));
        }
        if (request.getUserProperties().containsKey(SHA1_PROPERTY)) {

            assertEquals(expectedModifiedCount, result.modifiedCount(), description);

            // Verify the model version and namespace - use the updated document from pomMap
            Document updatedDocument = pomMap.get(Paths.get("pom.xml"));
            Editor editor = new Editor(updatedDocument);
            Element root = editor.root();
            assertEquals(expectedNamespace, root.namespaceURI(), "Namespace should be updated: " + description);

from typing import Annotated

from fastapi import FastAPI, Path

app = FastAPI()


@app.get("/items/{item_id}")
async def read_items(
    item_id: Annotated[int, Path(title="The ID of the item to get", ge=1)], q: str
):
    results = {"item_id": item_id}
    if q:
        results.update({"q": q})

        assertArgumentNotEmpty("propertyName", propertyName);

        return propertyDescCache.get(propertyName) != null;
    }

    @Override
    public PropertyDesc getPropertyDesc(final String propertyName) {
        assertArgumentNotEmpty("propertyName", propertyName);

        final PropertyDesc pd = propertyDescCache.get(propertyName);
        if (pd == null) {