switch (mode) {
        case DOWN:
        case HALF_EVEN:
        case HALF_DOWN:
        case HALF_UP:
          return Double.MAX_VALUE * sign(x);
        case FLOOR:
          return (roundArbitrarily == Double.POSITIVE_INFINITY)
              ? Double.MAX_VALUE
              : Double.NEGATIVE_INFINITY;
        case CEILING:
          return (roundArbitrarily == Double.POSITIVE_INFINITY)

        switch ( tc.getConfig().getLanManCompatibility() ) {
        case 0:
        case 1:
            return NtlmUtil.getPreNTLMResponse(tc, this.password, chlng);
        case 2:
            return NtlmUtil.getNTLMResponse(this.password, chlng);
        case 3:
        case 4:
        case 5:
            if ( this.clientChallenge == null ) {
                this.clientChallenge = new byte[8];

                case '0': case '1': case '2': case '3': case '4':
                case '5': case '6': case '7': case '8': case '9':
                    value += arr[ai] - '0';
                    break;
                case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
                    value += 10 + (arr[ai] - 'A');
                    break;
                case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':

            switch (c) {
            case '\\':
            case '"':
                buf.append('\\');
                buf.append(c);
                break;
            case '/':
                buf.append('\\');
                buf.append(c);
                break;
            case '\b':
                buf.append("\\b");
                break;
            case '\t':
                buf.append("\\t");

	}
	return
}

func (e *ConditionRHS) analyze(s *Select) (result qProp) {
	switch {
	case e.Compare != nil:
		result = e.Compare.Operand.analyze(s)
	case e.Between != nil:
		result.combine(e.Between.Start.analyze(s))
		result.combine(e.Between.End.analyze(s))
	case e.In != nil:
		result.combine(e.In.analyze(s))
	case e.Like != nil:
		result.combine(e.Like.Pattern.analyze(s))
		if e.Like.EscapeChar != nil {

            switch ( arr[ ai ] ) {
            case '0':
            case '1':
            case '2':
            case '3':
            case '4':
            case '5':
            case '6':
            case '7':
            case '8':
            case '9':
                value += arr[ ai ] - '0';
                break;
            case 'A':
            case 'B':
            case 'C':
            case 'D':

			return
		}
		switch msgp.UnsafeString(field) {
		case "DeploymentID":
			z.DeploymentID, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "DeploymentID")
				return
			}
		case "Endpoint":
			z.Endpoint, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "Endpoint")
				return
			}
		case "TotalDowntime":
			z.TotalDowntime, err = dc.ReadDuration()

				return err
			}
			switch se.Name.Local {
			case "QuoteFields":
				args.QuoteFields = strings.ToLower(s)
			case "RecordDelimiter":
				args.RecordDelimiter = s
			case "FieldDelimiter":
				args.FieldDelimiter = s
			case "QuoteCharacter":
				switch utf8.RuneCountInString(s) {
				case 0:
					args.QuoteCharacter = "\x00"
				case 1:
					args.QuoteCharacter = s
				default:

		expectedCredentials credentialHeader
		expectedErrCode     APIErrorCode
	}{
		// Test Case - 1.
		// Test case with no '=' in te inputCredentialStr.
		{
			inputCredentialStr:  "Credential",
			expectedCredentials: credentialHeader{},
			expectedErrCode:     ErrMissingFields,
		},
		// Test Case - 2.
		// Test case with no "Credential" string in te inputCredentialStr.
		{
			inputCredentialStr:  "Cred=",

	case "FCR":
		if 0 <= n && n <= 31 {
			return mips.REG_FCR0 + n, true
		}
	case "M":
		if 0 <= n && n <= 31 {
			return mips.REG_M0 + n, true
		}
	case "R":
		if 0 <= n && n <= 31 {
			return mips.REG_R0 + n, true
		}
	case "W":
		if 0 <= n && n <= 31 {
			return mips.REG_W0 + n, true
		}
	}
	return 0, false