*
 * This class provides pagination functionality for various types of search logs
 * including search logs, click logs, favorite logs, and user information logs.
 * It also supports different aggregation types for analytics and reporting.
 */
public class SearchLogPager implements Serializable {

    /** Serial version UID for serialization. */
    private static final long serialVersionUID = 1L;

    #    Other properties (for Application Behavior) work when this is true.
    #   o libraryProjectPackageBase: (NotRequired - Default same as application's one)
    #    If application package base is different from library's one,
    #    set the property a value 'library's one'.
    #
    #; applicationBehaviorMap = map:{
    #    ; isApplicationBehaviorProject = false
    #    ; libraryProjectPackageBase = 
    #}

    // TODO(kevinb): check more preconditions (as bufferSize >= chunkSize) if this is ever public
    checkArgument(bufferSize % chunkSize == 0);

    // TODO(user): benchmark performance difference with longer buffer
    // always space for a single primitive
    this.buffer = ByteBuffer.allocate(bufferSize + 7).order(ByteOrder.LITTLE_ENDIAN);
    this.bufferSize = bufferSize;
    this.chunkSize = chunkSize;
  }

change unified the key-management aspect within MinIO.

The unified KMS-based approach has several advantages:

- Key management is now centralized. There is one way to change or rotate encryption keys.
   There used to be two different mechanisms - one for regular S3 objects and one for IAM data.
- Reduced server startup time. For IAM encryption with the root credentials, MinIO had

        buffer.add(e);
        added++;
      }
    }
    return added;
  }

  /**
   * Drains the queue as {@linkplain #drain(BlockingQueue, Collection, int, Duration)}, but with a
   * different behavior in case it is interrupted while waiting. In that case, the operation will
   * continue as usual, and in the end the thread's interruption status will be set (no {@code
   * InterruptedException} is thrown).
   *

        assertEquals(24L, MemoryUtil.sizeOf(1.0f));
        assertEquals(24L, MemoryUtil.sizeOf(1.0d));
    }

    @Test
    public void test_sizeOf_dateTimeTypes() {
        // Test different date/time types
        assertEquals(32L, MemoryUtil.sizeOf(new Date(0)));
        assertEquals(80L, MemoryUtil.sizeOf(LocalDateTime.of(2023, 1, 1, 0, 0)));
        assertEquals(2128L, MemoryUtil.sizeOf(ZonedDateTime.now()));

        assertNull(emptyOptional.orElse(null));
    }

    @Test
    public void test_ofNullable_multipleTypesInSequence() {
        // Test multiple different types in sequence to ensure type safety
        OptionalEntity<String> stringOpt = OptionalUtil.ofNullable("string");
        OptionalEntity<Integer> intOpt = OptionalUtil.ofNullable(42);

### Locks

We have 3 different things that we synchronize on.

#### Http2Connection

   * the behavior described in {@link #put(Range, Object) put(range, value)}, however the ranges
   * returned from {@link #asMapOfRanges} will be different if there were existing entries which
   * connect to the given range and value.
   *
   * <p>Even if the input range is empty, if it is connected on both sides by ranges mapped to the

  @AndroidIncompatible
  public void testTaskThrowsError() throws Exception {
    class MyError extends Error {}
    CyclicBarrier barrier = new CyclicBarrier(2);
    // we need to make sure the error gets thrown on a different thread.
    ExecutorService service = newSingleThreadExecutor();
    try {
      SequentialExecutor executor = new SequentialExecutor(service);
      Runnable errorTask =
          () -> {