Fields: []schema.IndexOption{{
				Field: &schema.Field{Name: "Data0A"},
			}, {
				Field: &schema.Field{Name: "Data0B"},
			}},
		},
		{
			Name: "idx_user_indices_comp_id1",
			Fields: []schema.IndexOption{{
				Field: &schema.Field{Name: "Data1A"},
			}, {
				Field: &schema.Field{Name: "Data1B"},
			}, {
				Field: &schema.Field{Name: "Data1C"},
			}},
		},
		{

```sh
minio server /data{1...12}
```

Example: Start MinIO server in a 8 drives setup, using MinIO Docker image.

```sh
podman run \
  -p 9000:9000 \
  -p 9001:9001 \
  --name minio \
  -v /mnt/data1:/data1 \
  -v /mnt/data2:/data2 \
  -v /mnt/data3:/data3 \
  -v /mnt/data4:/data4 \
  -v /mnt/data5:/data5 \
  -v /mnt/data6:/data6 \
  -v /mnt/data7:/data7 \
  -v /mnt/data8:/data8 \

	docker exec resiliency-minio3-1 /bin/sh -c "rm -rf /data1/.minio.sys && mv /data1/.minio.bkp /data1/.minio.sys"
	docker exec resiliency-minio4-1 /bin/sh -c "rm -rf /data1/.minio.sys && mv /data1/.minio.bkp /data1/.minio.sys"
	docker exec resiliency-minio1-1 /bin/sh -c "rm -rf /data5/.minio.sys && mv /data5/.minio.bkp /data5/.minio.sys"

    volumes:
      - data2-1:/data1
      - data2-2:/data2
      - data2-3:/data3

  minio3:
    <<: *minio-common
    hostname: minio3
    volumes:
      - data3-1:/data1
      - data3-2:/data2
      - data3-3:/data3

  minio4:
    <<: *minio-common
    hostname: minio4
    volumes:
      - data4-1:/data1
      - data4-2:/data2
      - data4-3:/data3

  nginx:

        byte[] data1 = { 0x00, 0x01, 0x02, 0x03 };
        assertEquals("00", Hexdump.toHexString(data1, 0, 2)); // 2 chars = 1 byte
        assertEquals("000", Hexdump.toHexString(data1, 0, 3)); // 3 chars = 1.5 bytes (rounds up to 2)
        assertEquals("0001", Hexdump.toHexString(data1, 0, 4)); // 4 chars = 2 bytes
        assertEquals("000102", Hexdump.toHexString(data1, 0, 6)); // 6 chars = 3 bytes

    hostname: minio1
    volumes:
      - data1-1:/data1
      - data1-2:/data2
      - data1-3:/data3
      - data1-4:/data4
      - data1-5:/data5
      - data1-6:/data6
      - data1-7:/data7
      - data1-8:/data8

  minio2:
    <<: *minio-common
    hostname: minio2
    volumes:
      - data2-1:/data1
      - data2-2:/data2
      - data2-3:/data3
      - data2-4:/data4
      - data2-5:/data5

      - pdata4-1:/pdata1
      - pdata4-2:/pdata2

  minio5:
    <<: *minio-common
    hostname: minio5
    volumes:
      - pdata5-1:/pdata1
      - pdata5-2:/pdata2

  minio6:
    <<: *minio-common
    hostname: minio6
    volumes:
      - pdata6-1:/pdata1
      - pdata6-2:/pdata2

  minio7:
    <<: *minio-common
    hostname: minio7
    volumes:
      - pdata7-1:/pdata1
      - pdata7-2:/pdata2

		{data1[:511], 0, io.ErrUnexpectedEOF},
		{data1[:512], 1, io.ErrUnexpectedEOF},
		{data1[:1024], 1, io.EOF},
		{data1[:1536], 2, io.ErrUnexpectedEOF},
		{data1[:2048], 2, io.EOF},
		{data1, 2, io.EOF},
		{data1[:2048] + data2[:1536], 3, io.EOF},
		{data2[:511], 0, io.ErrUnexpectedEOF},
		{data2[:512], 1, io.ErrUnexpectedEOF},
		{data2[:1195], 1, io.ErrUnexpectedEOF},

        // First cycle
        byte[] data1 = new byte[] { 0x01, 0x02, 0x03, 0x04 };
        digest.update(data1, 0, data1.length);
        byte[] result1 = digest.digest();
        assertNotNull(result1);

        // Second cycle
        byte[] data2 = new byte[] { 0x05, 0x06, 0x07, 0x08 };
        digest.update(data2, 0, data2.length);
        byte[] result2 = digest.digest();

                SmbConstants.DEFAULT_SHARING);

        byte[] data1 = "Hello ".getBytes();
        byte[] data2 = "World".getBytes();

        // When
        outputStream.write(data1);
        outputStream.write(data2);

        // Then - verify two write requests were sent
        verify(mockTreeHandle, times(2)).send(any(Smb2WriteRequest.class), any());