throw new IOException( "Invalid payload size: " + size );
            }
            int errorCode = Encdec.dec_uint32le( BUF, 9 ) & 0xFFFFFFFF;
            if (resp.command == ServerMessageBlock.SMB_COM_READ_ANDX &&
                        (errorCode == 0 ||
                        errorCode == 0x80000005)) { // overflow indicator normal for pipe
                SmbComReadAndXResponse r = (SmbComReadAndXResponse)resp;

import "fmt"

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
}

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package mockwebserver3.internal.duplex

import mockwebserver3.Stream
import okhttp3.internal.http2.ErrorCode
import okhttp3.internal.http2.Http2Stream
import okio.buffer

/** Adapt OkHttp's internal [Http2Stream] type to the public [Stream] type. */
internal class RealStream(
  private val http2Stream: Http2Stream,

    }


    /**
     * @return the errorCode
     */
    @Override
    public final int getErrorCode () {
        return this.errorCode;
    }


    /**
     * @param errorCode
     *            the errorCode to set
     */
    public final void setErrorCode ( int errorCode ) {
        this.errorCode = errorCode;
    }


    /**
     * @return the path

)

func (i ErrorCode) String() string {
	switch {
	case i == -1:
		return _ErrorCode_name_0
	case 1 <= i && i <= 146:
		i -= 1
		return _ErrorCode_name_1[_ErrorCode_index_1[i]:_ErrorCode_index_1[i+1]]
	default:
		return "ErrorCode(" + strconv.FormatInt(int64(i), 10) + ")"
	}

import mockwebserver3.MockWebServer
import mockwebserver3.SocketPolicy.DoNotReadRequestBody
import okhttp3.Headers.Companion.headersOf
import okhttp3.internal.duplex.AsyncRequestBody
import okhttp3.internal.http2.ErrorCode
import okhttp3.testing.PlatformRule
import okio.BufferedSink
import okio.IOException
import org.junit.jupiter.api.BeforeEach
import org.junit.jupiter.api.Disabled
import org.junit.jupiter.api.Tag

  override fun trackFailure(
    call: RealCall,
    e: IOException?,
  ) {
    var noNewExchangesEvent = false
    lock.withLock {
      if (e is StreamResetException) {
        when {
          e.errorCode == ErrorCode.REFUSED_STREAM -> {
            // Stop using this connection on the 2nd REFUSED_STREAM error.
            refusedStreamCount++
            if (refusedStreamCount > 1) {

	binary.Write(buf, binary.BigEndian, uint16(len(errorCode)))
	buf.Write(errorCode)

	return genMessage(buf.Bytes(), nil)
}

// NewErrorMessage - creates new Request Level Error Message specified in
// https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectSELECTContent.html.
func NewErrorMessage(errorCode, errorMessage string) []byte {
	return newErrorMessage([]byte(errorCode), []byte(errorMessage))
}

ECL0068=InvalidKeyException occurred, because {0}
ECL0069=NoSuchPaddingException occurred, because {0}
ECL0070=Field({1}) of class({0}) not found
ECL0071=SQLException(Message=[{0}], ErrorCode={1}, SQLState={2}) occurred
ECL0072=SQLException(SQL=[{0}], Message=[{1}], ErrorCode={2}, SQLState={3}) occurred
ECL0091=Illegal URL({0})

                return;
            case SessionServicePacket.NEGATIVE_SESSION_RESPONSE:
                int errorCode = (int)( 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: