}
		writers[i] = newBitrotWriter(disk, "", "testbucket", "object", erasure.ShardFileSize(size), DefaultBitrotAlgorithm, erasure.ShardSize())
	}

	content := make([]byte, size)
	buffer := make([]byte, blockSizeV2, 2*blockSizeV2)
	_, err = erasure.Encode(context.Background(), bytes.NewReader(content), writers, buffer, erasure.dataBlocks+1)
	closeBitrotWriters(writers)
	if err != nil {
		b.Fatalf("failed to create erasure test file: %v", err)
	}

        String name = "TEST            ";
        System.arraycopy(name.getBytes("US-ASCII"), 0, src, srcIndex + 13, 16);
        src[srcIndex + 28] = 0x00; // hex code
        src[srcIndex + 29] = 0x04; // flags
        // MAC address (6 bytes)
        byte[] mac = new byte[6];
        System.arraycopy(mac, 0, src, srcIndex + 31, 6);
        // Stats (6 bytes)
        byte[] stats = new byte[6];

							}

							var buf bytes.Buffer
							if err := rs.Join(&buf, splitFilled, m.size); err == nil {
								m.filled = buf.Bytes()
							}
							buf = bytes.Buffer{}
							if err := rs.Join(&buf, splitData, m.size); err == nil {
								m.mapped = buf.Bytes()
							}
							for i, v := range m.filled {
								if v == 0 {

	err = obj.MakeBucket(ctx, bucket, MakeBucketOptions{})
	if err != nil {
		t.Fatal(err)
	}

	// Put an initial object so it exists
	_, err = obj.PutObject(ctx, bucket, object,
		mustGetPutObjReader(t, bytes.NewReader([]byte("initial-value")),
			int64(len("initial-value")), "", ""), ObjectOptions{})
	if err != nil {
		t.Fatal(err)
	}

	// Get object info to capture the ETag

  }

  public void testWriteFrom_inputStream() throws IOException {
    ByteArrayInputStream in = new ByteArrayInputStream(bytes);
    sink.writeFrom(in);

    assertTrue(sink.wasStreamOpened() && sink.wasStreamClosed());
    assertArrayEquals(bytes, sink.getBytes());
  }

  public void testWriteFromStream_doesNotCloseThatStream() throws IOException {

            assertEquals(12288, response.getTotalBytesWritten());
        }

        @Test
        @DisplayName("Should return correct bytes consumed")
        void testReturnBytesConsumed() throws SMBProtocolDecodingException {
            byte[] buffer = new byte[100];
            byte[] responseData = createValidCopyChunkResponse(8, 16384, 131072);
            System.arraycopy(responseData, 0, buffer, 20, responseData.length);

      Byte[] suffix = {(byte) 86, (byte) 99};
      Byte[] all = concat(concat(prefix, elements), suffix);
      return asList(all).subList(2, elements.length + 2);
    }
  }

  private static Byte[] concat(Byte[] left, Byte[] right) {
    Byte[] result = new Byte[left.length + right.length];
    System.arraycopy(left, 0, result, 0, left.length);
    System.arraycopy(right, 0, result, left.length, right.length);

)

const (
	byteRangePrefix = "bytes="
)

// HTTPRangeSpec represents a range specification as supported by S3 GET
// object request.
//
// Case 1: Not present -> represented by a nil RangeSpec
// Case 2: bytes=1-10 (absolute start and end offsets) -> RangeSpec{false, 1, 10}
// Case 3: bytes=10- (absolute start offset with end offset unspecified) -> RangeSpec{false, 10, -1}

        );
    }

    // Creates a deterministic byte sequence [0,1,2,...,n-1]
    private static byte[] makeSeq(int n) {
        byte[] a = new byte[n];
        for (int i = 0; i < n; i++) {
            a[i] = (byte) i;
        }
        return a;
    }

    @ParameterizedTest
    @MethodSource("byteEncodableArgs")
    @DisplayName("encode() copies bytes correctly and returns size")

                // warm up
                test(listener, session, resource, 0);

                for (int i = 1; i < size; i++) {
                    final int bytes = i;

                    service.execute(() -> {
                        test(listener, session, resource, bytes);
                    });
                }

                // start all threads at once
                try {
                    startLatch.await();