calabash-android 0.4.7.pre6 → 0.4.7.pre7

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

@@ -0,0 +1,303 @@
+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

@@ -0,0 +1,398 @@
+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;
+    }
+}