calabash-android 0.4.7.pre4 → 0.4.7.pre6

data/test-server/instrumentation-backend/src/sh/calaba/org/codehaus/jackson/io/NumberInput.java

@@ -1,303 +0,0 @@
-package sh.calaba.org.codehaus.jackson.io;
-
-public final class NumberInput
-{
-    /**
-     * Textual representation of a double constant that can cause nasty problems
-     * with JDK (see http://www.exploringbinary.com/java-hangs-when-converting-2-2250738585072012e-308).
-     */
-    public final static String NASTY_SMALL_DOUBLE = "2.2250738585072012e-308";
-
-    /**
-     * Constants needed for parsing longs from basic int parsing methods
-     */
-    final static long L_BILLION = 1000000000;
-
-    final static String MIN_LONG_STR_NO_SIGN = String.valueOf(Long.MIN_VALUE).substring(1);
-    final static String MAX_LONG_STR = String.valueOf(Long.MAX_VALUE);
-    
-    /**
-     * Fast method for parsing integers that are known to fit into
-     * regular 32-bit signed int type. This means that length is
-     * between 1 and 9 digits (inclusive)
-     *<p>
-     * Note: public to let unit tests call it
-     */
-    public final static int parseInt(char[] digitChars, int offset, int len)
-    {
-        int num = digitChars[offset] - '0';
-        len += offset;
-        // This looks ugly, but appears the fastest way (as per measurements)
-        if (++offset < len) {
-            num = (num * 10) + (digitChars[offset] - '0');
-            if (++offset < len) {
-                num = (num * 10) + (digitChars[offset] - '0');
-                if (++offset < len) {
-                    num = (num * 10) + (digitChars[offset] - '0');
-                    if (++offset < len) {
-                        num = (num * 10) + (digitChars[offset] - '0');
-                        if (++offset < len) {
-                            num = (num * 10) + (digitChars[offset] - '0');
-                            if (++offset < len) {
-                                num = (num * 10) + (digitChars[offset] - '0');
-                                if (++offset < len) {
-                                    num = (num * 10) + (digitChars[offset] - '0');
-                                    if (++offset < len) {
-                                        num = (num * 10) + (digitChars[offset] - '0');
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        return num;
-    }
-
-    /**
-     * Helper method to (more) efficiently parse integer numbers from
-     * String values.
-     * 
-     * @since 1.7
-     */
-    public final static int parseInt(String str)
-    {
-        /* Ok: let's keep strategy simple: ignoring optional minus sign,
-         * we'll accept 1 - 9 digits and parse things efficiently;
-         * otherwise just defer to JDK parse functionality.
-         */
-        char c = str.charAt(0);
-        int length = str.length();
-        boolean negative = (c == '-');
-        int offset = 1;
-        // must have 1 - 9 digits after optional sign:
-        // negative?
-        if (negative) {
-            if (length == 1 || length > 10) {
-                return Integer.parseInt(str);
-            }
-            c = str.charAt(offset++);
-        } else {
-            if (length > 9) {
-                return Integer.parseInt(str);
-            }
-        }
-        if (c > '9' || c < '0') {
-            return Integer.parseInt(str);
-        }
-        int num = c - '0';
-        if (offset < length) {
-            c = str.charAt(offset++);
-            if (c > '9' || c < '0') {
-                return Integer.parseInt(str);
-            }
-            num = (num * 10) + (c - '0');
-            if (offset < length) {
-                c = str.charAt(offset++);
-                if (c > '9' || c < '0') {
-                    return Integer.parseInt(str);
-                }
-                num = (num * 10) + (c - '0');
-                // Let's just loop if we have more than 3 digits:
-                if (offset < length) {
-                    do {
-                        c = str.charAt(offset++);
-                        if (c > '9' || c < '0') {
-                            return Integer.parseInt(str);
-                        }
-                        num = (num * 10) + (c - '0');
-                    } while (offset < length);
-                }
-            }
-        }
-        return negative ? -num : num;
-    }
-    
-    public final static long parseLong(char[] digitChars, int offset, int len)
-    {
-        // Note: caller must ensure length is [10, 18]
-        int len1 = len-9;
-        long val = parseInt(digitChars, offset, len1) * L_BILLION;
-        return val + (long) parseInt(digitChars, offset+len1, 9);
-    }
-
-    public final static long parseLong(String str)
-    {
-        /* Ok, now; as the very first thing, let's just optimize case of "fake longs";
-         * that is, if we know they must be ints, call int parsing
-         */
-        int length = str.length();
-        if (length <= 9) {
-            return (long) parseInt(str);
-        }
-        // !!! TODO: implement efficient 2-int parsing...
-        return Long.parseLong(str);
-    }
-    
-    /**
-     * Helper method for determining if given String representation of
-     * an integral number would fit in 64-bit Java long or not.
-     * Note that input String must NOT contain leading minus sign (even
-     * if 'negative' is set to true).
-     *
-     * @param negative Whether original number had a minus sign (which is
-     *    NOT passed to this method) or not
-     */
-    public final static boolean inLongRange(char[] digitChars, int offset, int len,
-            boolean negative)
-    {
-        String cmpStr = negative ? MIN_LONG_STR_NO_SIGN : MAX_LONG_STR;
-        int cmpLen = cmpStr.length();
-        if (len < cmpLen) return true;
-        if (len > cmpLen) return false;
-
-        for (int i = 0; i < cmpLen; ++i) {
-            int diff = digitChars[offset+i] - cmpStr.charAt(i);
-            if (diff != 0) {
-                return (diff < 0);
-            }
-        }
-        return true;
-    }
-
-    /**
-     * Similar to {@link #inLongRange(char[],int,int,boolean)}, but
-     * with String argument
-     *
-     * @param negative Whether original number had a minus sign (which is
-     *    NOT passed to this method) or not
-     *
-     * @since 1.5.0
-     */
-    public final static boolean inLongRange(String numberStr, boolean negative)
-    {
-        String cmpStr = negative ? MIN_LONG_STR_NO_SIGN : MAX_LONG_STR;
-        int cmpLen = cmpStr.length();
-        int actualLen = numberStr.length();
-        if (actualLen < cmpLen) return true;
-        if (actualLen > cmpLen) return false;
-
-        // could perhaps just use String.compareTo()?
-        for (int i = 0; i < cmpLen; ++i) {
-            int diff = numberStr.charAt(i) - cmpStr.charAt(i);
-            if (diff != 0) {
-                return (diff < 0);
-            }
-        }
-        return true;
-    }
-
-    /**
-     * @since 1.6
-     */
-    public static int parseAsInt(String input, int defaultValue)
-    {
-        if (input == null) {
-            return defaultValue;
-        }
-        input = input.trim();
-        int len = input.length();
-        if (len == 0) {
-            return defaultValue;
-        }
-        // One more thing: use integer parsing for 'simple'
-        int i = 0;
-        if (i < len) { // skip leading sign:
-            char c = input.charAt(0);
-            if (c == '+') { // for plus, actually physically remove
-                input = input.substring(1);
-                len = input.length();
-            } else if (c == '-') { // minus, just skip for checks, must retain
-                ++i;
-            }
-        }
-        for (; i < len; ++i) {
-            char c = input.charAt(i);
-            // if other symbols, parse as Double, coerce
-            if (c > '9' || c < '0') {
-                try {
-                    return (int) parseDouble(input);
-                } catch (NumberFormatException e) {
-                    return defaultValue;
-                }
-            }
-        }
-        try {
-            return Integer.parseInt(input);
-        } catch (NumberFormatException e) { }
-        return defaultValue;
-    }
-
-    /**
-     * @since 1.6
-     */
-    public static long parseAsLong(String input, long defaultValue)
-    {
-        if (input == null) {
-            return defaultValue;
-        }
-        input = input.trim();
-        int len = input.length();
-        if (len == 0) {
-            return defaultValue;
-        }
-        // One more thing: use long parsing for 'simple'
-        int i = 0;
-        if (i < len) { // skip leading sign:
-            char c = input.charAt(0);
-            if (c == '+') { // for plus, actually physically remove
-                input = input.substring(1);
-                len = input.length();
-            } else if (c == '-') { // minus, just skip for checks, must retain
-                ++i;
-            }
-        }
-        for (; i < len; ++i) {
-            char c = input.charAt(i);
-            // if other symbols, parse as Double, coerce
-            if (c > '9' || c < '0') {
-                try {
-                    return (long) parseDouble(input);
-                } catch (NumberFormatException e) {
-                    return defaultValue;
-                }
-            }
-        }
-        try {
-            return Long.parseLong(input);
-        } catch (NumberFormatException e) { }
-        return defaultValue;
-    }
-    
-    /**
-     * @since 1.6
-     */
-    public static double parseAsDouble(String input, double defaultValue)
-    {
-        if (input == null) {
-            return defaultValue;
-        }
-        input = input.trim();
-        int len = input.length();
-        if (len == 0) {
-            return defaultValue;
-        }
-        try {
-            return parseDouble(input);
-        } catch (NumberFormatException e) { }
-        return defaultValue;
-    }
-    
-    /**
-     * @since 1.8
-     */
-    public final static double parseDouble(String numStr) throws NumberFormatException
-    {
-        // [JACKSON-486]: avoid some nasty float representations... but should it be MIN_NORMAL or MIN_VALUE?
-        if (NASTY_SMALL_DOUBLE.equals(numStr)) {
-            return 0x1.0p-1022; //Double.MIN_NORMAL; Hardcoded since MIN_NORMAL is not available until SDK level 10
-        }
-        return Double.parseDouble(numStr);
-    }
-}

data/test-server/instrumentation-backend/src/sh/calaba/org/codehaus/jackson/io/NumberOutput.java

@@ -1,398 +0,0 @@
-package sh.calaba.org.codehaus.jackson.io;
-
-public final class NumberOutput
-{
-    private final static char NULL_CHAR = (char) 0;
-
-    private static int MILLION = 1000000;
-    private static int BILLION = 1000000000;
-    private static long TEN_BILLION_L = 10000000000L;
-    private static long THOUSAND_L = 1000L;
-
-    private static long MIN_INT_AS_LONG = (long) Integer.MIN_VALUE;
-    private static long MAX_INT_AS_LONG = (long) Integer.MAX_VALUE;
-
-    final static String SMALLEST_LONG = String.valueOf(Long.MIN_VALUE);
-
-    final static char[] LEADING_TRIPLETS = new char[4000];
-    final static char[] FULL_TRIPLETS = new char[4000];
-    static {
-        /* Let's fill it with NULLs for ignorable leading digits,
-         * and digit chars for others
-         */
-        int ix = 0;
-        for (int i1 = 0; i1 < 10; ++i1) {
-            char f1 = (char) ('0' + i1);
-            char l1 = (i1 == 0) ? NULL_CHAR : f1;
-            for (int i2 = 0; i2 < 10; ++i2) {
-                char f2 = (char) ('0' + i2);
-                char l2 = (i1 == 0 && i2 == 0) ? NULL_CHAR : f2;
-                for (int i3 = 0; i3 < 10; ++i3) {
-                    // Last is never to be empty
-                    char f3 = (char) ('0' + i3);
-                    LEADING_TRIPLETS[ix] = l1;
-                    LEADING_TRIPLETS[ix+1] = l2;
-                    LEADING_TRIPLETS[ix+2] = f3;
-                    FULL_TRIPLETS[ix] = f1;
-                    FULL_TRIPLETS[ix+1] = f2;
-                    FULL_TRIPLETS[ix+2] = f3;
-                    ix += 4;
-                }
-            }
-        }
-    }
-
-    final static byte[] FULL_TRIPLETS_B = new byte[4000];
-    static {
-        for (int i = 0; i < 4000; ++i) {
-            FULL_TRIPLETS_B[i] = (byte) FULL_TRIPLETS[i];
-        }
-    }
-    
-    final static String[] sSmallIntStrs = new String[] {
-        "0","1","2","3","4","5","6","7","8","9","10"
-    };
-    final static String[] sSmallIntStrs2 = new String[] {
-        "-1","-2","-3","-4","-5","-6","-7","-8","-9","-10"
-    };
-
-    /*
-    /**********************************************************
-    /* Efficient serialization methods using raw buffers
-    /**********************************************************
-     */
-
-    /**
-     * @return Offset within buffer after outputting int
-     */
-    public static int outputInt(int value, char[] buffer, int offset)
-    {
-        if (value < 0) {
-            if (value == Integer.MIN_VALUE) {
-                /* Special case: no matching positive value within range;
-                 * let's then "upgrade" to long and output as such.
-                 */
-                return outputLong((long) value, buffer, offset);
-            }
-            buffer[offset++] = '-';
-            value = -value;
-        }
-
-        if (value < MILLION) { // at most 2 triplets...
-            if (value < 1000) {
-                if (value < 10) {
-                    buffer[offset++] = (char) ('0' + value);
-                } else {
-                    offset = outputLeadingTriplet(value, buffer, offset);
-                }
-            } else {
-                int thousands = value / 1000;
-                value -= (thousands * 1000); // == value % 1000
-                offset = outputLeadingTriplet(thousands, buffer, offset);
-                offset = outputFullTriplet(value, buffer, offset);
-            }
-            return offset;
-        }
-
-        // ok, all 3 triplets included
-        /* Let's first hand possible billions separately before
-         * handling 3 triplets. This is possible since we know we
-         * can have at most '2' as billion count.
-         */
-        boolean hasBillions = (value >= BILLION);
-        if (hasBillions) {
-            value -= BILLION;
-            if (value >= BILLION) {
-                value -= BILLION;
-                buffer[offset++] = '2';
-            } else {
-                buffer[offset++] = '1';
-            }
-        }
-        int newValue = value / 1000;
-        int ones = (value - (newValue * 1000)); // == value % 1000
-        value = newValue;
-        newValue /= 1000;
-        int thousands = (value - (newValue * 1000));
-        
-        // value now has millions, which have 1, 2 or 3 digits
-        if (hasBillions) {
-            offset = outputFullTriplet(newValue, buffer, offset);
-        } else {
-            offset = outputLeadingTriplet(newValue, buffer, offset);
-        }
-        offset = outputFullTriplet(thousands, buffer, offset);
-        offset = outputFullTriplet(ones, buffer, offset);
-        return offset;
-    }
-
-    public static int outputInt(int value, byte[] buffer, int offset)
-    {
-        if (value < 0) {
-            if (value == Integer.MIN_VALUE) {
-                return outputLong((long) value, buffer, offset);
-            }
-            buffer[offset++] = '-';
-            value = -value;
-        }
-
-        if (value < MILLION) { // at most 2 triplets...
-            if (value < 1000) {
-                if (value < 10) {
-                    buffer[offset++] = (byte) ('0' + value);
-                } else {
-                    offset = outputLeadingTriplet(value, buffer, offset);
-                }
-            } else {
-                int thousands = value / 1000;
-                value -= (thousands * 1000); // == value % 1000
-                offset = outputLeadingTriplet(thousands, buffer, offset);
-                offset = outputFullTriplet(value, buffer, offset);
-            }
-            return offset;
-        }
-        boolean hasBillions = (value >= BILLION);
-        if (hasBillions) {
-            value -= BILLION;
-            if (value >= BILLION) {
-                value -= BILLION;
-                buffer[offset++] = '2';
-            } else {
-                buffer[offset++] = '1';
-            }
-        }
-        int newValue = value / 1000;
-        int ones = (value - (newValue * 1000)); // == value % 1000
-        value = newValue;
-        newValue /= 1000;
-        int thousands = (value - (newValue * 1000));
-        
-        if (hasBillions) {
-            offset = outputFullTriplet(newValue, buffer, offset);
-        } else {
-            offset = outputLeadingTriplet(newValue, buffer, offset);
-        }
-        offset = outputFullTriplet(thousands, buffer, offset);
-        offset = outputFullTriplet(ones, buffer, offset);
-        return offset;
-    }
-    
-    /**
-     * @return Offset within buffer after outputting int
-     */
-    public static int outputLong(long value, char[] buffer, int offset)
-    {
-        // First: does it actually fit in an int?
-        if (value < 0L) {
-            /* MIN_INT is actually printed as long, just because its
-             * negation is not an int but long
-             */
-            if (value > MIN_INT_AS_LONG) {
-                return outputInt((int) value, buffer, offset);
-            }
-            if (value == Long.MIN_VALUE) {
-                // Special case: no matching positive value within range
-                int len = SMALLEST_LONG.length();
-                SMALLEST_LONG.getChars(0, len, buffer, offset);
-                return (offset + len);
-            }
-            buffer[offset++] = '-';
-            value = -value;
-        } else {
-            if (value <= MAX_INT_AS_LONG) {
-                return outputInt((int) value, buffer, offset);
-            }
-        }
-
-        /* Ok: real long print. Need to first figure out length
-         * in characters, and then print in from end to beginning
-         */
-        int origOffset = offset;
-        offset += calcLongStrLength(value);
-        int ptr = offset;
-
-        // First, with long arithmetics:
-        while (value > MAX_INT_AS_LONG) { // full triplet
-            ptr -= 3;
-            long newValue = value / THOUSAND_L;
-            int triplet = (int) (value - newValue * THOUSAND_L);
-            outputFullTriplet(triplet, buffer, ptr);
-            value = newValue;
-        }
-        // Then with int arithmetics:
-        int ivalue = (int) value;
-        while (ivalue >= 1000) { // still full triplet
-            ptr -= 3;
-            int newValue = ivalue / 1000;
-            int triplet = ivalue - (newValue * 1000);
-            outputFullTriplet(triplet, buffer, ptr);
-            ivalue = newValue;
-        }
-        // And finally, if anything remains, partial triplet
-        outputLeadingTriplet(ivalue, buffer, origOffset);
-
-        return offset;
-    }
-
-    public static int outputLong(long value, byte[] buffer, int offset)
-    {
-        if (value < 0L) {
-            if (value > MIN_INT_AS_LONG) {
-                return outputInt((int) value, buffer, offset);
-            }
-            if (value == Long.MIN_VALUE) {
-                // Special case: no matching positive value within range
-                int len = SMALLEST_LONG.length();
-                for (int i = 0; i < len; ++i) {
-                    buffer[offset++] = (byte) SMALLEST_LONG.charAt(i);
-                }
-                return offset;
-            }
-            buffer[offset++] = '-';
-            value = -value;
-        } else {
-            if (value <= MAX_INT_AS_LONG) {
-                return outputInt((int) value, buffer, offset);
-            }
-        }
-        int origOffset = offset;
-        offset += calcLongStrLength(value);
-        int ptr = offset;
-
-        // First, with long arithmetics:
-        while (value > MAX_INT_AS_LONG) { // full triplet
-            ptr -= 3;
-            long newValue = value / THOUSAND_L;
-            int triplet = (int) (value - newValue * THOUSAND_L);
-            outputFullTriplet(triplet, buffer, ptr);
-            value = newValue;
-        }
-        // Then with int arithmetics:
-        int ivalue = (int) value;
-        while (ivalue >= 1000) { // still full triplet
-            ptr -= 3;
-            int newValue = ivalue / 1000;
-            int triplet = ivalue - (newValue * 1000);
-            outputFullTriplet(triplet, buffer, ptr);
-            ivalue = newValue;
-        }
-        outputLeadingTriplet(ivalue, buffer, origOffset);
-        return offset;
-    }
-    
-    /*
-    /**********************************************************
-    /* Secondary convenience serialization methods
-    /**********************************************************
-     */
-
-    /* !!! 05-Aug-2008, tatus: Any ways to further optimize
-     *   these? (or need: only called by diagnostics methods?)
-     */
-
-    public static String toString(int value)
-    {
-        // Lookup table for small values
-        if (value < sSmallIntStrs.length) {
-            if (value >= 0) {
-                return sSmallIntStrs[value];
-            }
-            int v2 = -value - 1;
-            if (v2 < sSmallIntStrs2.length) {
-                return sSmallIntStrs2[v2];
-            }
-        }
-        return Integer.toString(value);
-    }
-
-    public static String toString(long value)
-    {
-        if (value <= Integer.MAX_VALUE &&
-            value >= Integer.MIN_VALUE) {
-            return toString((int) value);
-        }
-        return Long.toString(value);
-    }
-
-    public static String toString(double value)
-    {
-        return Double.toString(value);
-    }
-
-    /*
-    /**********************************************************
-    /* Internal methods
-    /**********************************************************
-     */
-
-    private static int outputLeadingTriplet(int triplet, char[] buffer, int offset)
-    {
-        int digitOffset = (triplet << 2);
-        char c = LEADING_TRIPLETS[digitOffset++];
-        if (c != NULL_CHAR) {
-            buffer[offset++] = c;
-        }
-        c = LEADING_TRIPLETS[digitOffset++];
-        if (c != NULL_CHAR) {
-            buffer[offset++] = c;
-        }
-        // Last is required to be non-empty
-        buffer[offset++] = LEADING_TRIPLETS[digitOffset];
-        return offset;
-    }
-
-    private static int outputLeadingTriplet(int triplet, byte[] buffer, int offset)
-    {
-        int digitOffset = (triplet << 2);
-        char c = LEADING_TRIPLETS[digitOffset++];
-        if (c != NULL_CHAR) {
-            buffer[offset++] = (byte) c;
-        }
-        c = LEADING_TRIPLETS[digitOffset++];
-        if (c != NULL_CHAR) {
-            buffer[offset++] = (byte) c;
-        }
-        // Last is required to be non-empty
-        buffer[offset++] = (byte) LEADING_TRIPLETS[digitOffset];
-        return offset;
-    }
-    
-    private static int outputFullTriplet(int triplet, char[] buffer, int offset)
-    {
-        int digitOffset = (triplet << 2);
-        buffer[offset++] = FULL_TRIPLETS[digitOffset++];
-        buffer[offset++] = FULL_TRIPLETS[digitOffset++];
-        buffer[offset++] = FULL_TRIPLETS[digitOffset];
-        return offset;
-    }
-
-    private static int outputFullTriplet(int triplet, byte[] buffer, int offset)
-    {
-        int digitOffset = (triplet << 2);
-        buffer[offset++] = FULL_TRIPLETS_B[digitOffset++];
-        buffer[offset++] = FULL_TRIPLETS_B[digitOffset++];
-        buffer[offset++] = FULL_TRIPLETS_B[digitOffset];
-        return offset;
-    }
-    
-    /**
-     *<p>
-     * Pre-conditions: posValue is positive, and larger than
-     * Integer.MAX_VALUE (about 2 billions).
-     */
-    private static int calcLongStrLength(long posValue)
-    {
-        int len = 10;
-        long comp = TEN_BILLION_L;
-
-        // 19 is longest, need to worry about overflow
-        while (posValue >= comp) {
-            if (len == 19) {
-                break;
-            }
-            ++len;
-            comp = (comp << 3) + (comp << 1); // 10x
-        }
-        return len;
-    }
-}