## Explore Further

- [The MinIO documentation website](https://docs.min.io/community/minio-object-store/index.html)
- [MinIO Erasure Code Overview](https://docs.min.io/community/minio-object-store/operations/concepts/erasure-coding.html)
- [Use `mc` with MinIO Server](https://docs.min.io/community/minio-object-store/reference/minio-mc.html)

 *       following code is wrong because it only captures the {@code <T>} type variable of the
 *       {@code listType()} method signature; while {@code <String>} is lost in erasure:
 *       {@snippet :
 * class Util {
 *   static <T> TypeToken<List<T>> listType() {
 *     return new TypeToken<List<T>>() {};
 *   }
 * }
 *
 * TypeToken<List<String>> stringListType = Util.<String>listType();

  private val eventsForMatching = ConcurrentLinkedDeque<CallEvent>()

  private val forbiddenLocks = mutableListOf<Any>()

  /** The timestamp of the last taken event, used to measure elapsed time between events. */
  private var lastTimestampNs: Long? = null

  /** Confirm that the thread does not hold a lock on `lock` during the callback. */
  fun forbidLock(lock: Any) {
    forbiddenLocks.add(lock)

) : ConnectionListener() {
  val eventSequence: Deque<ConnectionEvent> = ConcurrentLinkedDeque()

  private val forbiddenLocks = mutableSetOf<Any>()

  /** The timestamp of the last taken event, used to measure elapsed time between events. */
  private var lastTimestampNs: Long? = null

  /** Confirm that the thread does not hold a lock on `lock` during the callback. */
  fun forbidLock(lock: Any) {
    forbiddenLocks.add(lock)

  private void weaklyReferenceQueue() {
    frq = new FinalizableReferenceQueue();
    queueReference = new WeakReference<>(frq.queue);

    /*
     * Queue and clear a reference for good measure. We test later on that
     * the finalizer thread stopped, but we should test that it actually
     * started first.
     */
    reference =
        new FinalizableWeakReference<Object>(new Object(), frq) {

        String testField = "field999";

        // Warm up
        for (int i = 0; i < 100; i++) {
            queryCommand.isSearchField(testField);
        }

        // Measure Set-based lookup
        long startTime = System.nanoTime();
        for (int i = 0; i < 10000; i++) {
            queryCommand.isSearchField(testField);
        }
        long duration = System.nanoTime() - startTime;

    @Test
    public void test_integrationScenarios() {
        // Test realistic scenarios combining multiple methods
        String memoryLog1 = MemoryUtil.getMemoryUsageLog();

        // Create some objects and measure their sizes
        List<String> testData = new ArrayList<>();
        for (int i = 0; i < 100; i++) {
            testData.add("test data " + i);
        }

        long listSize = MemoryUtil.sizeOf(testData);

   * @param offset the offset into the array at which to start
   * @return the value found in the array in the form of a long
   */
  static int load32(byte[] source, int offset) {
    // TODO(user): Measure the benefit of delegating this to LittleEndianBytes also.
    return (source[offset] & 0xFF)
        | ((source[offset + 1] & 0xFF) << 8)
        | ((source[offset + 2] & 0xFF) << 16)

        String testField = "field999";

        // Warm up
        for (int i = 0; i < 100; i++) {
            queryFieldConfig.isSortField(testField);
        }

        // Measure Set-based lookup (current implementation)
        long setStartTime = System.nanoTime();
        for (int i = 0; i < 10000; i++) {
            queryFieldConfig.isSortField(testField);
        }

        // Data: bitSize / 8 bytes
        long predictedSize = bf.bitSize() / 8 + 6;
        assertThat(bf.serializedSize()).isEqualTo(predictedSize);

        // Serialize and measure actual size
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        bf.writeTo(out);
        int actualSize = out.size();
        assertThat(bf.serializedSize()).isEqualTo(actualSize);