// Test minimum value
        event.setVersionNo(Long.MIN_VALUE);
        assertEquals(Long.valueOf(Long.MIN_VALUE), event.getVersionNo());

        // Test zero
        event.setVersionNo(0L);
        assertEquals(Long.valueOf(0L), event.getVersionNo());

        // Test maximum value
        event.setVersionNo(Long.MAX_VALUE);
        assertEquals(Long.valueOf(Long.MAX_VALUE), event.getVersionNo());
    }

        appender.append(event);

        final List<LogNotificationEvent> events = ComponentUtil.getLogNotificationHelper().drainAll();
        assertEquals(0, events.size());
    }

    @Test
    public void test_append_excludedLogger_logNotificationJob() {

            logNotificationTarget.flush();
        }
    }

    /**
     * Offers an event to the buffer. If the buffer exceeds the maximum size, the oldest event is dropped.
     *
     * @param event the log notification event to add
     */
    public void offer(final LogNotificationEvent event) {
        int maxBufferSize;
        try {

        // 11
        "id\r".encodeUtf8(),
        // 12
        "id\n".encodeUtf8(),
        // 13
        "event: ".encodeUtf8(),
        // 14
        "event:".encodeUtf8(),
        // 15
        "event\r\n".encodeUtf8(),
        // 16
        "event\r".encodeUtf8(),
        // 17
        "event\n".encodeUtf8(),
        // 18
        "retry: ".encodeUtf8(),
        // 19
        "retry:".encodeUtf8(),

    for item in items:
        yield {"name": item.name, "description": item.description}


@app.get("/items/stream-sse-event", response_class=EventSourceResponse)
async def sse_items_event():
    yield ServerSentEvent(data="hello", event="greeting", id="1")
    yield ServerSentEvent(data={"key": "value"}, event="json-data", id="2")
    yield ServerSentEvent(comment="just a comment")
    yield ServerSentEvent(data="retry-test", retry=5000)

    // We post the event, but our Executor will not deliver it until instructed.
    bus.post(EVENT);

    List<String> events = catcher.getEvents();
    assertTrue("No events should be delivered synchronously.", events.isEmpty());

    // Now we find the task in our Executor and explicitly activate it.
    List<Runnable> tasks = executor.getTasks();
    assertEquals("One event dispatch task should be queued.", 1, tasks.size());

    try {
      while (true) {
        val event = takeEvent()
        if (eventClass.isInstance(event)) {
          return eventClass.cast(event)
        }
      }
    } catch (e: NoSuchElementException) {
      throw AssertionError("full event sequence: $fullEventSequence", e)
    }
  }

  /**
   * Remove and return the next event from the recorded sequence.
   *

                    var content = document.createTextNode(event.data)
                    message.appendChild(content)
                    messages.appendChild(message)
                };
                event.preventDefault()
            }
            function sendMessage(event) {
                var input = document.getElementById("messageText")
                ws.send(input.value)

        ErrorToWarnRewritePolicy policy = new ErrorToWarnRewritePolicy(loggerNames);

        LogEvent event =
                Log4jLogEvent.newBuilder().setLoggerName(null).setLevel(Level.ERROR).setMessage(new SimpleMessage("test message")).build();

        LogEvent result = policy.rewrite(event);
        assertSame(event, result);
    }

    @Test
    public void test_rewrite_error_to_warn_matching_logger() {

        }
    }

    /**
     * Dispatches an event to all registered handlers for the event name.
     *
     * @param event the event to dispatch.
     */
    protected void dispatchEvent(final EventInfo event) {
        final List<Consumer<EventInfo>> handlers = eventHandlers.get(event.name);
        if (handlers != null) {
            for (final Consumer<EventInfo> handler : handlers) {