private static FileEntry staticInitial;
        private static List<FileEntry[]> staticPages;
        private static boolean staticThrowOnOpen;

        private int pageIdx = -1; // Start before first page
        private boolean done = false;
        private boolean throwOnFetch;
        private boolean throwOnCloseInternal;

        // Use static factory method to work around constructor ordering

                        success[index] = false;
                    }
                });
            }

            // When
            for (Thread thread : threads) {
                thread.start();
            }
            for (Thread thread : threads) {
                thread.join();
            }

            // Then
            for (int i = 0; i < threadCount; i++) {

     * this operation is executing, not all of those new 1's may be set in the final state of this
     * LockFreeBitArray. The ONLY guarantee provided is that all the bits that were set in the other
     * LockFreeBitArray at the start of this method will be set in this LockFreeBitArray at the end
     * of this method.
     */
    void putAll(LockFreeBitArray other) {
      checkArgument(
          data.length() == other.data.length(),

                            successCount.incrementAndGet();
                        }
                    } finally {
                        latch.countDown();
                    }
                }).start();
            }

            latch.await(5, java.util.concurrent.TimeUnit.SECONDS);
            assertEquals(5, successCount.get(), "All concurrent calls should succeed");
        }
    }

        @Override
        public int encode(byte[] dst, int dstIndex) {
            // We need to override the parent ServerMessageBlock2's encode
            // to properly simulate setting the length field
            int start = dstIndex;
            dstIndex += writeHeaderWireFormat(dst, dstIndex);
            dstIndex += writeBytesWireFormat(dst, dstIndex);

    }

    /**
     * Returns a {@link CopyOptions} with the specified prefix.
     * <p>
     * When a prefix is specified, only the properties from the source whose names start with the prefix will be copied.
     * Additionally, the prefix will be removed from the source property names to determine the target property names.
     * </p>
     *
     * @param prefix

                    msg.flags &= ~DCERPC_FIRST_FRAG;
                }

                if ((msg.flags & (DCERPC_FIRST_FRAG | DCERPC_LAST_FRAG)) != (DCERPC_FIRST_FRAG | DCERPC_LAST_FRAG)) {
                    buf.start = off;
                    buf.reset();
                    msg.encode_header(buf);
                    buf.enc_ndr_long(msg.alloc_hint);
                    buf.enc_ndr_short(0); /* context id */

                        .forPort(port)//
                        .withStartupTimeout(Duration.ofSeconds(30)));
        logger.info("Starting {}", IMAGE_NAME);
        minioServer.start();
        logger.info("Started {}", IMAGE_NAME);

        String bucketName = "fess";
        Integer mappedPort = minioServer.getFirstMappedPort();
        Testcontainers.exposeHostPorts(mappedPort);

This document explains the design, architecture and advanced use cases of the MinIO distributed server.

## Command-line

```
NAME:
  minio server - start object storage server

USAGE:
  minio server [FLAGS] DIR1 [DIR2..]
  minio server [FLAGS] DIR{1...64}
  minio server [FLAGS] DIR{1...64} DIR{65...128}

DIR:

        int offset = 16;
        int length = 32;

        Hexdump.hexdump(ps, data, offset, length);
        String output = baos.toString();

        assertNotNull(output);
        // Should start at offset 0 in display but show data from offset 16
        assertTrue(output.contains("00000:"));
        // First byte should be 0x10 (16 in decimal)
        assertTrue(output.contains(" 10 11 12"));
    }