assertEquals(NtStatus.NT_STATUS_UNSUCCESSFUL, ex.getNtStatus(), "Default NT status should be UNSUCCESSFUL");
        assertNull(ex.getCause(), "Cause should be null by default");
        assertNull(ex.getRootCause(), "Root cause should be null by default");
        assertTrue(ex instanceof SmbException, "Should be an SmbException subtype");
    }

    /**

			err = msgp.WrapError(err)
			return
		}
		switch msgp.UnsafeString(field) {
		case "ID":
			z.ID, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "ID")
				return
			}
		case "PoolIndex":
			z.PoolIndex, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "PoolIndex")
				return
			}
		case "SetIndex":
			z.SetIndex, err = dc.ReadInt()
			if err != nil {

	switch what {
	case timePartYear:
		return FromInt(int64(t.Year())), nil
	case timePartMonth:
		return FromInt(int64(t.Month())), nil
	case timePartDay:
		return FromInt(int64(t.Day())), nil
	case timePartHour:
		return FromInt(int64(t.Hour())), nil
	case timePartMinute:
		return FromInt(int64(t.Minute())), nil
	case timePartSecond:
		return FromInt(int64(t.Second())), nil

			case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
				vars[idx] = fmt.Sprintf("%d", reflectValue.Interface())
			case reflect.Float32, reflect.Float64:
				vars[idx] = fmt.Sprintf("%.6f", reflectValue.Interface())
			case reflect.Bool:
				vars[idx] = fmt.Sprintf("%t", reflectValue.Interface())
			case reflect.String:

				var duration time.Duration
				// Only support UTC normalized timestamps.
				if ts.IsAdjustedToUTC {
					switch {
					case ts.Unit.IsSetNANOS():
						duration = time.Duration(val) * time.Nanosecond
					case ts.Unit.IsSetMILLIS():
						duration = time.Duration(val) * time.Millisecond
					case ts.Unit.IsSetMICROS():
						duration = time.Duration(val) * time.Microsecond
					default:

            }
            break;
        case ERR_SSN_SRVC:
            result.append("ERR_SSN_SRVC/");
            switch (errorCode) {
            case CONNECTION_REFUSED:
                result.append("Connection refused");
                break;
            case NOT_LISTENING_CALLED:
                result.append("Not listening on called name");
                break;
            case NOT_LISTENING_CALLING:

			return
		}
		switch msgp.UnsafeString(field) {
		case "APIVersion":
			z.APIVersion, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "APIVersion")
				return
			}
		case "Bucket":
			z.Bucket, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "Bucket")
				return
			}
		case "Prefix":
			err = z.Prefix.DecodeMsg(dc)
			if err != nil {

    /**
     * Constructs a new SsoLoginException with the specified detail message and cause.
     *
     * @param message The detail message explaining the SSO login failure
     * @param cause The underlying exception that caused this SSO login failure
     */
    public SsoLoginException(final String message, final Throwable cause) {
        super(message, cause);
    }

			err = msgp.WrapError(err)
			return
		}
		switch msgp.UnsafeString(field) {
		case "Total":
			z.Total, err = dc.ReadInt64()
			if err != nil {
				err = msgp.WrapError(err, "Total")
				return
			}
		case "Size":
			z.Size, err = dc.ReadInt64()
			if err != nil {
				err = msgp.WrapError(err, "Size")
				return
			}
		case "N":
			z.N, err = dc.ReadInt64()
			if err != nil {
				err = msgp.WrapError(err, "N")

    public String getAlgorithmName(int algorithm) {
        switch (algorithm) {
        case COMPRESSION_NONE:
            return "None";
        case COMPRESSION_LZ77:
            return "LZ77";
        case COMPRESSION_LZ77_HUFFMAN:
            return "LZ77+Huffman";
        case COMPRESSION_LZNT1:
            return "LZNT1";
        case COMPRESSION_PATTERN_V1:
            return "Pattern_V1";
        default: