calabash-android 0.0.1

data/test-server/instrumentation-backend/src/sh/calaba/org/codehaus/jackson/map/util/Comparators.java

@@ -0,0 +1,48 @@
+package sh.calaba.org.codehaus.jackson.map.util;
+
+import java.lang.reflect.Array;
+
+/**
+ * Helper class for constructing objects for comparing content values
+ * 
+ * @since 1.9.0
+ */
+public class Comparators
+{
+    /**
+     * Helper method used for constructing simple value comparator used for
+     * comparing arrays for content equality.
+     *<p>
+     * Note: current implementation is not optimized for speed; if performance
+     * ever becomes an issue, it is possible to construct much more efficient
+     * typed instances (one for Object[] and sub-types; one per primitive type)
+     * 
+     * @since 1.9
+     */
+    public static Object getArrayComparator(final Object defaultValue)
+    {
+        final int length = Array.getLength(defaultValue);
+        return new Object() {
+            @Override
+            public boolean equals(Object other) {
+                if (other == this) return true;
+                if (other == null || other.getClass() != defaultValue.getClass()) {
+                    return false;
+                }
+                if (Array.getLength(other) != length) return false;
+                // so far so good: compare actual equality; but only shallow one
+                for (int i = 0; i < length; ++i) {
+                    Object value1 = Array.get(defaultValue, i);
+                    Object value2 = Array.get(other, i);
+                    if (value1 == value2) continue;
+                    if (value1 != null) {
+                        if (!value1.equals(value2)) {
+                            return false;
+                        }
+                    }
+                }
+                return true;
+            }
+        };
+    }
+}

data/test-server/instrumentation-backend/src/sh/calaba/org/codehaus/jackson/map/util/EnumResolver.java

@@ -0,0 +1,108 @@
+package sh.calaba.org.codehaus.jackson.map.util;
+
+import sh.calaba.org.codehaus.jackson.map.AnnotationIntrospector;
+
+import java.util.*;
+
+/**
+ * Helper class used to resolve String values (either JSON Object field
+ * names or regular String values) into Java Enum instances.
+ * 
+ * @since 1.9 renamed from 'sh.calaba.org.codehaus.jackson.map.deser.EnumResolver'
+ */
+public class EnumResolver<T extends Enum<T>>
+{
+    protected final Class<T> _enumClass;
+
+    protected final T[] _enums;
+
+    protected final HashMap<String, T> _enumsById;
+
+    protected EnumResolver(Class<T> enumClass, T[] enums, HashMap<String, T> map)
+    {
+        _enumClass = enumClass;
+        _enums = enums;
+        _enumsById = map;
+    }
+
+    /**
+     * Factory method for constructing resolver that maps from Enum.name() into
+     * Enum value
+     */
+    public static <ET extends Enum<ET>> EnumResolver<ET> constructFor(Class<ET> enumCls, AnnotationIntrospector ai)
+    {
+        ET[] enumValues = enumCls.getEnumConstants();
+        if (enumValues == null) {
+            throw new IllegalArgumentException("No enum constants for class "+enumCls.getName());
+        }
+        HashMap<String, ET> map = new HashMap<String, ET>();
+        for (ET e : enumValues) {
+            map.put(ai.findEnumValue(e), e);
+        }
+        return new EnumResolver<ET>(enumCls, enumValues, map);
+    }
+
+    /**
+     * Factory method for constructing resolver that maps from Enum.toString() into
+     * Enum value
+     * 
+     * @since 1.6
+     */
+    public static <ET extends Enum<ET>> EnumResolver<ET> constructUsingToString(Class<ET> enumCls)
+    {
+        ET[] enumValues = enumCls.getEnumConstants();
+        HashMap<String, ET> map = new HashMap<String, ET>();
+        // from last to first, so that in case of duplicate values, first wins
+        for (int i = enumValues.length; --i >= 0; ) {
+            ET e = enumValues[i];
+            map.put(e.toString(), e);
+        }
+        return new EnumResolver<ET>(enumCls, enumValues, map);
+    }    
+    
+    /**
+     * This method is needed because of the dynamic nature of constructing Enum
+     * resolvers.
+     */
+    @SuppressWarnings({ "unchecked", "rawtypes" })
+    public static EnumResolver<?> constructUnsafe(Class<?> rawEnumCls, AnnotationIntrospector ai)
+    {            
+        /* This is oh so wrong... but at least ugliness is mostly hidden in just
+         * this one place.
+         */
+        Class<Enum> enumCls = (Class<Enum>) rawEnumCls;
+        return constructFor(enumCls, ai);
+    }
+
+    /**
+     * Method that needs to be used instead of {@link #constructUsingToString}
+     * if static type of enum is not known.
+     * 
+     * @since 1.6
+     */
+    @SuppressWarnings({ "unchecked", "rawtypes" })
+    public static EnumResolver<?> constructUnsafeUsingToString(Class<?> rawEnumCls)
+    {            
+        // oh so wrong... not much that can be done tho
+        Class<Enum> enumCls = (Class<Enum>) rawEnumCls;
+        return constructUsingToString(enumCls);
+    }
+    
+    public T findEnum(String key)
+    {
+        return _enumsById.get(key);
+    }
+
+    public T getEnum(int index)
+    {
+        if (index < 0 || index >= _enums.length) {
+            return null;
+        }
+        return _enums[index];
+    }
+
+    public Class<T> getEnumClass() { return _enumClass; }
+
+    public int lastValidIndex() { return _enums.length-1; }
+}
+

data/test-server/instrumentation-backend/src/sh/calaba/org/codehaus/jackson/map/util/EnumValues.java

@@ -0,0 +1,82 @@
+package sh.calaba.org.codehaus.jackson.map.util;
+
+import java.util.*;
+
+import sh.calaba.org.codehaus.jackson.io.SerializedString;
+import sh.calaba.org.codehaus.jackson.map.*;
+
+/**
+ * Helper class used for storing String serializations of
+ * enumerations.
+ */
+public final class EnumValues
+{
+    /**
+     * Since 1.7, we are storing values as SerializedStrings, to further
+     * speed up serialization.
+     */
+    private final EnumMap<?,SerializedString> _values;
+
+    @SuppressWarnings({ "unchecked", "rawtypes" })
+    private EnumValues(Map<Enum<?>,SerializedString> v) {
+        _values = new EnumMap(v);
+    }
+
+    public static EnumValues construct(Class<Enum<?>> enumClass, AnnotationIntrospector intr)
+    {
+        return constructFromName(enumClass, intr);
+    }
+
+    public static EnumValues constructFromName(Class<Enum<?>> enumClass, AnnotationIntrospector intr)
+    {
+        /* [JACKSON-214]: Enum types with per-instance sub-classes
+         *   need special handling
+         */
+    	Class<? extends Enum<?>> cls = ClassUtil.findEnumType(enumClass);
+        Enum<?>[] values = cls.getEnumConstants();
+        if (values != null) {
+            // Type juggling... unfortunate
+            Map<Enum<?>,SerializedString> map = new HashMap<Enum<?>,SerializedString>();
+            for (Enum<?> en : values) {
+                String value = intr.findEnumValue(en);
+                map.put(en, new SerializedString(value));
+            }
+            return new EnumValues(map);
+        }
+        throw new IllegalArgumentException("Can not determine enum constants for Class "+enumClass.getName());
+    }
+
+    public static EnumValues constructFromToString(Class<Enum<?>> enumClass, AnnotationIntrospector intr)
+    {
+        Class<? extends Enum<?>> cls = ClassUtil.findEnumType(enumClass);
+        Enum<?>[] values = cls.getEnumConstants();
+        if (values != null) {
+            // Type juggling... unfortunate
+            Map<Enum<?>,SerializedString> map = new HashMap<Enum<?>,SerializedString>();
+            for (Enum<?> en : values) {
+                map.put(en, new SerializedString(en.toString()));
+            }
+            return new EnumValues(map);
+        }
+        throw new IllegalArgumentException("Can not determine enum constants for Class "+enumClass.getName());
+    }
+
+    /**
+     * @deprecated since 1.7, use {@link #serializedValueFor} instead
+     */
+    @Deprecated
+    public String valueFor(Enum<?> key)
+    {
+        SerializedString sstr = _values.get(key);
+        return (sstr == null) ? null : sstr.getValue();
+    }
+
+    public SerializedString serializedValueFor(Enum<?> key)
+    {
+        return _values.get(key);
+    }
+    
+    public Collection<SerializedString> values() {
+        return _values.values();
+    }
+}

data/test-server/instrumentation-backend/src/sh/calaba/org/codehaus/jackson/map/util/ISO8601DateFormat.java

@@ -0,0 +1,52 @@
+package sh.calaba.org.codehaus.jackson.map.util;
+
+import java.text.*;
+import java.util.Calendar;
+import java.util.Date;
+import java.util.GregorianCalendar;
+
+/**
+ * Provide a fast thread-safe formatter/parser DateFormat for ISO8601 dates ONLY.
+ * It was mainly done to be used with Jackson JSON Processor.
+ * <p/>
+ * Watch out for clone implementation that returns itself.
+ * <p/>
+ * All other methods but parse and format and clone are undefined behavior.
+ *
+ * @see ISO8601Utils
+ */
+public class ISO8601DateFormat extends DateFormat
+{
+    private static final long serialVersionUID = 1L;
+
+    // those classes are to try to allow a consistent behavior for hascode/equals and other methods
+    private static Calendar CALENDAR = new GregorianCalendar();
+    private static NumberFormat NUMBER_FORMAT = new DecimalFormat();
+
+    public ISO8601DateFormat() {
+        this.numberFormat = NUMBER_FORMAT;
+        this.calendar = CALENDAR;
+    }
+
+    @Override
+    public StringBuffer format(Date date, StringBuffer toAppendTo, FieldPosition fieldPosition)
+    {
+        String value = ISO8601Utils.format(date);
+        toAppendTo.append(value);
+        return toAppendTo;
+    }
+
+    @Override
+    public Date parse(String source, ParsePosition pos)
+    {
+        // index must be set to other than 0, I would swear this requirement is not there in
+        // some version of jdk 6.
+        pos.setIndex(source.length());
+        return ISO8601Utils.parse(source);
+    }
+
+    @Override
+    public Object clone() {
+        return this;    // jackson calls clone everytime. We are threadsafe so just returns the instance
+    }
+}

data/test-server/instrumentation-backend/src/sh/calaba/org/codehaus/jackson/map/util/ISO8601Utils.java

@@ -0,0 +1,230 @@
+package sh.calaba.org.codehaus.jackson.map.util;
+
+import java.util.*;
+
+/**
+ * Utilities methods for manipulating dates in iso8601 format. This is much much faster and GC friendly than
+ * using SimpleDateFormat so highly suitable if you (un)serialize lots of date objects.
+ */
+public class ISO8601Utils {
+
+    /**
+     * ID to represent the 'GMT' string
+     */
+    private static final String GMT_ID = "GMT";
+
+    /**
+     * The GMT timezone
+     */
+    private static final TimeZone TIMEZONE_GMT = TimeZone.getTimeZone(GMT_ID);
+
+    /**
+     * Format a date into 'yyyy-MM-ddThh:mm:ssZ' (GMT timezone, no milliseconds precision)
+     *
+     * @param date the date to format
+     * @return the date formatted as 'yyyy-MM-ddThh:mm:ssZ'
+     */
+    public static String format(Date date) {
+        return format(date, false, TIMEZONE_GMT);
+    }
+
+    /**
+     * Format a date into 'yyyy-MM-ddThh:mm:ss[.sss]Z' (GMT timezone)
+     *
+     * @param date   the date to format
+     * @param millis true to include millis precision otherwise false
+     * @return the date formatted as 'yyyy-MM-ddThh:mm:ss[.sss]Z'
+     */
+    public static String format(Date date, boolean millis) {
+        return format(date, millis, TIMEZONE_GMT);
+    }
+
+    /**
+     * Format date into yyyy-MM-ddThh:mm:ss[.sss][Z|[+-]hh:mm]
+     *
+     * @param date   the date to format
+     * @param millis true to include millis precision otherwise false
+     * @param tz     timezone to use for the formatting (GMT will produce 'Z')
+     * @return the date formatted as yyyy-MM-ddThh:mm:ss[.sss][Z|[+-]hh:mm]
+     */
+    public static String format(Date date, boolean millis, TimeZone tz) {
+        Calendar calendar = new GregorianCalendar(tz, Locale.US);
+        calendar.setTime(date);
+
+        // estimate capacity of buffer as close as we can (yeah, that's pedantic ;)
+        int capacity = "yyyy-MM-ddThh:mm:ss".length();
+        capacity += millis ? ".sss".length() : 0;
+        capacity += tz.getRawOffset() == 0 ? "Z".length() : "+hh:mm".length();
+        StringBuilder formatted = new StringBuilder(capacity);
+
+        padInt(formatted, calendar.get(Calendar.YEAR), "yyyy".length());
+        formatted.append('-');
+        padInt(formatted, calendar.get(Calendar.MONTH) + 1, "MM".length());
+        formatted.append('-');
+        padInt(formatted, calendar.get(Calendar.DAY_OF_MONTH), "dd".length());
+        formatted.append('T');
+        padInt(formatted, calendar.get(Calendar.HOUR_OF_DAY), "hh".length());
+        formatted.append(':');
+        padInt(formatted, calendar.get(Calendar.MINUTE), "mm".length());
+        formatted.append(':');
+        padInt(formatted, calendar.get(Calendar.SECOND), "ss".length());
+        if (millis) {
+            formatted.append('.');
+            padInt(formatted, calendar.get(Calendar.MILLISECOND), "sss".length());
+        }
+
+        int offset = tz.getOffset(calendar.getTimeInMillis());
+        if (offset != 0) {
+            int hours = Math.abs((offset / (60 * 1000)) / 60);
+            int minutes = Math.abs((offset / (60 * 1000)) % 60);
+            formatted.append(offset < 0 ? '-' : '+');
+            padInt(formatted, hours, "hh".length());
+            formatted.append(':');
+            padInt(formatted, minutes, "mm".length());
+        } else {
+            formatted.append('Z');
+        }
+
+        return formatted.toString();
+    }
+
+
+    /**
+     * Parse a date from ISO-8601 formatted string. It expects a format yyyy-MM-ddThh:mm:ss[.sss][Z|[+-]hh:mm]
+     *
+     * @param date ISO string to parse in the appropriate format.
+     * @return the parsed date
+     * @throws IllegalArgumentException if the date is not in the appropriate format
+     */
+    public static Date parse(String date) {
+        try {
+            int offset = 0;
+
+            // extract year
+            int year = parseInt(date, offset, offset += 4);
+            checkOffset(date, offset, '-');
+
+            // extract month
+            int month = parseInt(date, offset += 1, offset += 2);
+            checkOffset(date, offset, '-');
+
+            // extract day
+            int day = parseInt(date, offset += 1, offset += 2);
+            checkOffset(date, offset, 'T');
+
+            // extract hours, minutes, seconds and milliseconds
+            int hour = parseInt(date, offset += 1, offset += 2);
+            checkOffset(date, offset, ':');
+
+            int minutes = parseInt(date, offset += 1, offset += 2);
+            checkOffset(date, offset, ':');
+
+            int seconds = parseInt(date, offset += 1, offset += 2);
+            // milliseconds can be optional in the format
+            int milliseconds = 0; // always use 0 otherwise returned date will include millis of current time
+            if (date.charAt(offset) == '.') {
+                checkOffset(date, offset, '.');
+                milliseconds = parseInt(date, offset += 1, offset += 3);
+            }
+
+            // extract timezone
+            String timezoneId;
+            char timezoneIndicator = date.charAt(offset);
+            if (timezoneIndicator == '+' || timezoneIndicator == '-') {
+                timezoneId = GMT_ID + date.substring(offset);
+            } else if (timezoneIndicator == 'Z') {
+                timezoneId = GMT_ID;
+            } else {
+                throw new IndexOutOfBoundsException("Invalid time zone indicator " + timezoneIndicator);
+            }
+            TimeZone timezone = TimeZone.getTimeZone(timezoneId);
+            if (!timezone.getID().equals(timezoneId)) {
+                throw new IndexOutOfBoundsException();
+            }
+
+            Calendar calendar = new GregorianCalendar(timezone);
+            calendar.setLenient(false);
+            calendar.set(Calendar.YEAR, year);
+            calendar.set(Calendar.MONTH, month - 1);
+            calendar.set(Calendar.DAY_OF_MONTH, day);
+            calendar.set(Calendar.HOUR_OF_DAY, hour);
+            calendar.set(Calendar.MINUTE, minutes);
+            calendar.set(Calendar.SECOND, seconds);
+            calendar.set(Calendar.MILLISECOND, milliseconds);
+
+            return calendar.getTime();
+        } catch (IndexOutOfBoundsException e) {
+            throw new IllegalArgumentException("Failed to parse date " + date, e);
+        } catch (NumberFormatException e) {
+            throw new IllegalArgumentException("Failed to parse date " + date, e);
+        } catch (IllegalArgumentException e) {
+            throw new IllegalArgumentException("Failed to parse date " + date, e);
+        }
+    }
+
+    /**
+     * Check if the expected character exist at the given offset of the
+     *
+     * @param value    the string to check at the specified offset
+     * @param offset   the offset to look for the expected character
+     * @param expected the expected character
+     * @throws IndexOutOfBoundsException if the expected character is not found
+     */
+    private static void checkOffset(String value, int offset, char expected) throws IndexOutOfBoundsException {
+        char found = value.charAt(offset);
+        if (found != expected) {
+            throw new IndexOutOfBoundsException("Expected '" + expected + "' character but found '" + found + "'");
+        }
+    }
+
+    /**
+     * Parse an integer located between 2 given offsets in a string
+     *
+     * @param value      the string to parse
+     * @param beginIndex the start index for the integer in the string
+     * @param endIndex   the end index for the integer in the string
+     * @return the int
+     * @throws NumberFormatException if the value is not a number
+     */
+    private static int parseInt(String value, int beginIndex, int endIndex) throws NumberFormatException {
+        if (beginIndex < 0 || endIndex > value.length() || beginIndex > endIndex) {
+            throw new NumberFormatException(value);
+        }
+        // use same logic as in Integer.parseInt() but less generic we're not supporting negative values
+        int i = beginIndex;
+        int result = 0;
+        int digit;
+        if (i < endIndex) {
+            digit = Character.digit(value.charAt(i++), 10);
+            if (digit < 0) {
+                throw new NumberFormatException("Invalid number: " + value);
+            }
+            result = -digit;
+        }
+        while (i < endIndex) {
+            digit = Character.digit(value.charAt(i++), 10);
+            if (digit < 0) {
+                throw new NumberFormatException("Invalid number: " + value);
+            }
+            result *= 10;
+            result -= digit;
+        }
+        return -result;
+    }
+
+    /**
+     * Zero pad a number to a specified length
+     *
+     * @param buffer buffer to use for padding
+     * @param value  the integer value to pad if necessary.
+     * @param length the length of the string we should zero pad
+     */
+    private static void padInt(StringBuilder buffer, int value, int length) {
+        String strValue = Integer.toString(value);
+        for (int i = length - strValue.length(); i > 0; i--) {
+            buffer.append('0');
+        }
+        buffer.append(strValue);
+    }
+}
+