}

	// xattr bar should always appear before others
	indices := []int{
		bytes.Index(buf.Bytes(), []byte("bar=bar")),
		bytes.Index(buf.Bytes(), []byte("baz=baz")),
		bytes.Index(buf.Bytes(), []byte("foo=foo")),
		bytes.Index(buf.Bytes(), []byte("qux=qux")),
	}
	if !slices.IsSorted(indices) {
		t.Fatal("PAX headers are not sorted")
	}
}

func TestUSTARLongName(t *testing.T) {

    }

    /**
     * Encodes this SPNEGO token to a byte array
     * @return the encoded token bytes
     */
    public abstract byte[] toByteArray();

    /**
     * Parses the provided token bytes to populate this SPNEGO token
     * @param token the token bytes to parse
     * @throws IOException if parsing fails
     */
    protected abstract void parse(byte[] token) throws IOException;

package cmd

import (
	"bytes"
	"testing"

	"github.com/tinylib/msgp/msgp"
)

func TestMarshalUnmarshalhealingTracker(t *testing.T) {
	v := healingTracker{}
	bts, err := v.MarshalMsg(nil)
	if err != nil {
		t.Fatal(err)
	}
	left, err := v.UnmarshalMsg(bts)
	if err != nil {
		t.Fatal(err)
	}
	if len(left) > 0 {
		t.Errorf("%d bytes left over after UnmarshalMsg(): %q", len(left), left)
	}

        this.leaseFlags = leaseFlags;
    }

    @Override
    public int size() {
        // Context header: 16 bytes
        // Name: 4 bytes ("RqLs")
        // Padding: 4 bytes (to align data to 8-byte boundary)
        // Data: 32 bytes (lease V1 structure)
        return 16 + 4 + 4 + 32;
    }

    @Override
    public int encode(byte[] dst, int dstIndex) {

        this.newLeaseState = SMBUtil.readInt4(buffer, bufferIndex);
        bufferIndex += 4;

        // BreakReason (4 bytes)
        this.breakReason = SMBUtil.readInt4(buffer, bufferIndex);
        bufferIndex += 4;

        // AccessMaskHint (4 bytes)
        this.accessMaskHint = SMBUtil.readInt4(buffer, bufferIndex);
        bufferIndex += 4;

        // ShareAccessHint (4 bytes)

	prevRune int   // index of previous rune; or < 0
}

// Len returns the number of bytes of the unread portion of the
// slice.
func (r *Reader) Len() int {
	if r.i >= int64(len(r.s)) {
		return 0
	}
	return int(int64(len(r.s)) - r.i)
}

// Size returns the original length of the underlying byte slice.
// Size is the number of bytes available for reading via [Reader.ReadAt].

  }

  @Test fun clientSimpleBinary() {
    val bytes = binaryData(256)
    data.write("827E0100".decodeHex()).write(bytes)
    clientReader.processNextFrame()
    callback.assertBinaryMessage(bytes)
  }

  @Test fun clientTwoFrameBinary() {
    val bytes = binaryData(200)
    data.write("0264".decodeHex()).write(bytes, 0, 100)
    data.write("8064".decodeHex()).write(bytes, 100, 100)
    clientReader.processNextFrame()

            // When
            byte[] bytes = message.toByteArray();

            // Then
            assertNotNull(bytes);
            assertTrue(bytes.length >= 48); // Minimum size
            // Verify signature
            assertTrue(Arrays.equals(Type2Message.NTLMSSP_SIGNATURE, Arrays.copyOfRange(bytes, 0, 8)));
            // Verify message type

        // Create message with 5 bytes of data
        byte[] data = new byte[] { 10, 20, 30, 40, 50 };
        InputStream in = new ByteArrayInputStream(concat(messageHeader(5), data));
        SocketInputStream sis = new SocketInputStream(in);

        // Skip 3 bytes
        assertEquals(3, sis.skip(3));

        // Read remaining 2 bytes
        byte[] remaining = new byte[2];

	if err != nil {
		t.Fatalf("%s: <ERROR> %s", instanceType, err)
	}
	if len(bytesBuffer1.Bytes()) != len(content) {
		t.Errorf("%s: Expected content length to be `%d`, but instead found `%d`", instanceType, len(content), len(bytesBuffer1.Bytes()))
	}

	var bytesBuffer2 bytes.Buffer
	_, err = obj.PutObject(context.Background(), "bucket", "object", mustGetPutObjReader(t, readerNoEOF, length, "", ""), opts)