assertTrue(result.contains("command=SMB_COM_TREE_CONNECT_ANDX"));
            assertTrue(result.contains("errorCode="));
            // Should show non-zero error code
            assertTrue(result.contains("errorCode=0x00000001") || result.contains("errorCode=1"));
        }

        @Test
        @DisplayName("Test toString with all command types")
        void testToStringAllCommands() {

        return 4;
    }

    @Override
    int readDataWireFormat(final byte[] buffer, int bufferIndex, final int len) {
        final int start = bufferIndex;

        if (errorCode != 0) {
            return 4;
        }

        try {
            securityDescriptor = new SecurityDescriptor();
            bufferIndex += securityDescriptor.decode(buffer, bufferIndex, len);

type SelectError interface {
	Cause() error
	ErrorCode() string
	ErrorMessage() string
	HTTPStatusCode() int
	Error() string
}

type s3Error struct {
	code       string
	message    string
	statusCode int
	cause      error
}

func (err *s3Error) Cause() error {
	return err.cause
}

func (err *s3Error) ErrorCode() string {
	return err.code
}

             */

            bufferIndex = headerStart + andxOffset;

            andx.headerStart = headerStart;
            andx.command = andxCommand;
            andx.errorCode = errorCode;
            andx.flags = flags;
            andx.flags2 = flags2;
            andx.tid = tid;
            andx.pid = pid;
            andx.uid = uid;
            andx.mid = mid;

            }
            return;
        case SessionServicePacket.NEGATIVE_SESSION_RESPONSE:
            final int errorCode = in.read() & 0xFF;
            close();
            throw new NbtException(NbtException.ERR_SSN_SRVC, errorCode);
        case -1:
            throw new NbtException(NbtException.ERR_SSN_SRVC, NbtException.CONNECTION_REFUSED);
        default:
            close();

        assertEquals(1, next.readBytesCalls);
    }

    @Test
    @DisplayName("readAndXWireFormat clears chaining when errorCode set")
    void testReadAndXWireFormatWithErrorCode() {
        DummyPlainSMB next = new DummyPlainSMB();
        DummyAndXBlock block = new DummyAndXBlock(next);
        block.errorCode = 1; // any non-zero error code should inhibit chaining
        block.headerStart = 0;

        byte[] buf = new byte[64];

            return (boolean) getFieldValue("dataDone");
        }

        boolean isHasMore() {
            return hasMore;
        }

        void setErrorCode(int code) {
            errorCode = code;
        }

        void setHasMore(boolean val) {
            hasMore = val;
        }

        boolean getParametersDone() {
            return (boolean) getFieldValue("parametersDone");

    // We may have been asked to cancel while creating the new stream and sending the request
    // headers, but there was still no stream to close.
    if (canceled) {
      stream!!.closeLater(ErrorCode.CANCEL)
      throw IOException("Canceled")
    }
    stream!!.readTimeout().timeout(chain.readTimeoutMillis.toLong(), TimeUnit.MILLISECONDS)

				Code:           "MalformedXML",
				Description:    fmt.Sprintf("%s (%s)", errorCodes[ErrMalformedXML].Description, e),
				HTTPStatusCode: errorCodes[ErrMalformedXML].HTTPStatusCode,
			}
		case url.EscapeError:
			apiErr = APIError{
				Code:           "XMinioInvalidObjectName",
				Description:    fmt.Sprintf("%s (%s)", errorCodes[ErrInvalidObjectName].Description, e),
				HTTPStatusCode: http.StatusBadRequest,
			}

import "errors"

type s3Error struct {
	code       string
	message    string
	statusCode int
	cause      error
}

func (err *s3Error) Cause() error {
	return err.cause
}

func (err *s3Error) ErrorCode() string {
	return err.code
}

func (err *s3Error) ErrorMessage() string {
	return err.message
}

func (err *s3Error) HTTPStatusCode() int {
	return err.statusCode
}