calabash-android 0.4.7.pre6 → 0.4.7.pre7

data/test-server/instrumentation-backend/src/sh/calaba/org/codehaus/jackson/map/deser/std/StringDeserializer.java

@@ -0,0 +1,55 @@
+package sh.calaba.org.codehaus.jackson.map.deser.std;
+
+import java.io.IOException;
+
+import sh.calaba.org.codehaus.jackson.Base64Variants;
+import sh.calaba.org.codehaus.jackson.JsonParser;
+import sh.calaba.org.codehaus.jackson.JsonProcessingException;
+import sh.calaba.org.codehaus.jackson.JsonToken;
+import sh.calaba.org.codehaus.jackson.map.DeserializationContext;
+import sh.calaba.org.codehaus.jackson.map.TypeDeserializer;
+import sh.calaba.org.codehaus.jackson.map.annotate.JacksonStdImpl;
+
+@JacksonStdImpl
+public class StringDeserializer
+    extends StdScalarDeserializer<String>
+{
+    public StringDeserializer() { super(String.class); }
+
+    @Override
+    public String deserialize(JsonParser jp, DeserializationContext ctxt)
+        throws IOException, JsonProcessingException
+    {
+        JsonToken curr = jp.getCurrentToken();
+        // Usually should just get string value:
+        if (curr == JsonToken.VALUE_STRING) {
+            return jp.getText();
+        }
+        // [JACKSON-330]: need to gracefully handle byte[] data, as base64
+        if (curr == JsonToken.VALUE_EMBEDDED_OBJECT) {
+            Object ob = jp.getEmbeddedObject();
+            if (ob == null) {
+                return null;
+            }
+            if (ob instanceof byte[]) {
+                return Base64Variants.getDefaultVariant().encode((byte[]) ob, false);
+            }
+            // otherwise, try conversion using toString()...
+            return ob.toString();
+        }
+        // Can deserialize any scalar value, but not markers
+        if (curr.isScalarValue()) {
+            return jp.getText();
+        }
+        throw ctxt.mappingException(_valueClass, curr);
+    }
+
+    // 1.6: since we can never have type info ("natural type"; String, Boolean, Integer, Double):
+    // (is it an error to even call this version?)
+    @Override
+    public String deserializeWithType(JsonParser jp, DeserializationContext ctxt,
+            TypeDeserializer typeDeserializer)
+        throws IOException, JsonProcessingException
+    {
+        return deserialize(jp, ctxt);
+    }}

data/test-server/instrumentation-backend/src/sh/calaba/org/codehaus/jackson/map/deser/std/ThrowableDeserializer.java

@@ -0,0 +1,164 @@
+package sh.calaba.org.codehaus.jackson.map.deser.std;
+
+import java.io.IOException;
+
+import sh.calaba.org.codehaus.jackson.*;
+import sh.calaba.org.codehaus.jackson.map.*;
+import sh.calaba.org.codehaus.jackson.map.deser.BeanDeserializer;
+import sh.calaba.org.codehaus.jackson.map.deser.SettableBeanProperty;
+
+/**
+ * Deserializer that builds on basic {@link BeanDeserializer} but
+ * override some aspects like instance construction.
+ *<p>
+ * Note that this deserializer was significantly changed in Jackson 1.7
+ * (due to massive changes in {@link BeanDeserializer}).
+ * 
+ * @since 1.9 (renamed from 'sh.calaba.org.codehaus.jackson.map.deser.ThrowableDeserializer')
+ */
+public class ThrowableDeserializer
+    extends BeanDeserializer
+{
+    protected final static String PROP_NAME_MESSAGE = "message";
+
+    /*
+    /************************************************************
+    /* Construction
+    /************************************************************
+     */
+
+    public ThrowableDeserializer(BeanDeserializer baseDeserializer)
+    {
+        super(baseDeserializer);
+    }
+
+    /**
+     * Alternative constructor used when creating "unwrapping" deserializers
+     * 
+     * @since 1.9
+     */
+    protected ThrowableDeserializer(BeanDeserializer src, boolean ignoreAllUnknown)
+    {
+        super(src, ignoreAllUnknown);
+    }
+    
+    @Override
+    public JsonDeserializer<Object> unwrappingDeserializer()
+    {
+        if (getClass() != ThrowableDeserializer.class) {
+            return this;
+        }
+        /* main thing really is to just enforce ignoring of unknown
+         * properties; since there may be multiple unwrapped values
+         * and properties for all may be interleaved...
+         */
+        return new ThrowableDeserializer(this, true);
+    }
+
+    
+    /*
+    /************************************************************
+    /* Overridden methods
+    /************************************************************
+     */
+
+    @Override
+    public Object deserializeFromObject(JsonParser jp, DeserializationContext ctxt)
+        throws IOException, JsonProcessingException
+    {
+        // 30-Sep-2010, tatu: Need to allow use of @JsonCreator, so:
+        if (_propertyBasedCreator != null) { // proper @JsonCreator
+            return _deserializeUsingPropertyBased(jp, ctxt);
+        }
+        if (_delegateDeserializer != null) {
+            return _valueInstantiator.createUsingDelegate(_delegateDeserializer.deserialize(jp, ctxt));
+        }
+        if (_beanType.isAbstract()) { // for good measure, check this too
+            throw JsonMappingException.from(jp, "Can not instantiate abstract type "+_beanType
+                    +" (need to add/enable type information?)");
+        }
+        boolean hasStringCreator = _valueInstantiator.canCreateFromString();
+        boolean hasDefaultCtor = _valueInstantiator.canCreateUsingDefault();
+        // and finally, verify we do have single-String arg constructor (if no @JsonCreator)
+        if (!hasStringCreator && !hasDefaultCtor) {
+            throw new JsonMappingException("Can not deserialize Throwable of type "+_beanType
+                    +" without having a default contructor, a single-String-arg constructor; or explicit @JsonCreator");
+        }
+        
+        Object throwable = null;
+        Object[] pending = null;
+        int pendingIx = 0;
+
+        for (; jp.getCurrentToken() != JsonToken.END_OBJECT; jp.nextToken()) {
+            String propName = jp.getCurrentName();
+            SettableBeanProperty prop = _beanProperties.find(propName);
+            jp.nextToken(); // to point to field value
+
+            if (prop != null) { // normal case
+                if (throwable != null) {
+                    prop.deserializeAndSet(jp, ctxt, throwable);
+                    continue;
+                }
+                // nope; need to defer
+                if (pending == null) {
+                    int len = _beanProperties.size();
+                    pending = new Object[len + len];
+                }
+                pending[pendingIx++] = prop;
+                pending[pendingIx++] = prop.deserialize(jp, ctxt);
+                continue;
+            }
+
+            // Maybe it's "message"?
+            if (PROP_NAME_MESSAGE.equals(propName)) {
+                if (hasStringCreator) {
+                    throwable = _valueInstantiator.createFromString(jp.getText());
+                    // any pending values?
+                    if (pending != null) {
+                        for (int i = 0, len = pendingIx; i < len; i += 2) {
+                            prop = (SettableBeanProperty)pending[i];
+                            prop.set(throwable, pending[i+1]);
+                        }
+                        pending = null;
+                    }
+                    continue;
+                }
+            }
+            /* As per [JACKSON-313], things marked as ignorable should not be
+             * passed to any setter
+             */
+            if (_ignorableProps != null && _ignorableProps.contains(propName)) {
+                jp.skipChildren();
+                continue;
+            }
+            if (_anySetter != null) {
+                _anySetter.deserializeAndSet(jp, ctxt, throwable, propName);
+                continue;
+            }
+            // Unknown: let's call handler method
+            handleUnknownProperty(jp, ctxt, throwable, propName);
+        }
+        // Sanity check: did we find "message"?
+        if (throwable == null) {
+            /* 15-Oct-2010, tatu: Can't assume missing message is an error, since it may be
+             *   suppressed during serialization, as per [JACKSON-388].
+             *   
+             *   Should probably allow use of default constructor, too...
+             */
+            //throw new JsonMappingException("No 'message' property found: could not deserialize "+_beanType);
+            if (hasStringCreator) {
+                throwable = _valueInstantiator.createFromString(null);
+            } else {
+                throwable = _valueInstantiator.createUsingDefault();
+            }
+            // any pending values?
+            if (pending != null) {
+                for (int i = 0, len = pendingIx; i < len; i += 2) {
+                    SettableBeanProperty prop = (SettableBeanProperty)pending[i];
+                    prop.set(throwable, pending[i+1]);
+                }
+            }
+        }
+        return throwable;
+    }
+}

data/test-server/instrumentation-backend/src/sh/calaba/org/codehaus/jackson/map/deser/std/TimestampDeserializer.java

@@ -0,0 +1,30 @@
+package sh.calaba.org.codehaus.jackson.map.deser.std;
+
+import java.io.IOException;
+import java.sql.Timestamp;
+
+import sh.calaba.org.codehaus.jackson.JsonParser;
+import sh.calaba.org.codehaus.jackson.JsonProcessingException;
+import sh.calaba.org.codehaus.jackson.map.DeserializationContext;
+
+/**
+ * Simple deserializer for handling {@link java.sql.Timestamp} values.
+ *<p>
+ * One way to customize Timestamp formats accepted is to override method
+ * {@link DeserializationContext#parseDate} that this basic
+ * deserializer calls.
+ *
+ * @since 1.9 (moved from higher-level package)
+ */
+public class TimestampDeserializer
+    extends StdScalarDeserializer<Timestamp>
+{
+    public TimestampDeserializer() { super(Timestamp.class); }
+
+    @Override
+    public java.sql.Timestamp deserialize(JsonParser jp, DeserializationContext ctxt)
+        throws IOException, JsonProcessingException
+    {
+        return new Timestamp(_parseDate(jp, ctxt).getTime());
+    }
+}

data/test-server/instrumentation-backend/src/sh/calaba/org/codehaus/jackson/map/deser/std/TokenBufferDeserializer.java

@@ -0,0 +1,36 @@
+package sh.calaba.org.codehaus.jackson.map.deser.std;
+
+import java.io.IOException;
+
+import sh.calaba.org.codehaus.jackson.JsonParser;
+import sh.calaba.org.codehaus.jackson.JsonProcessingException;
+import sh.calaba.org.codehaus.jackson.map.DeserializationContext;
+import sh.calaba.org.codehaus.jackson.map.annotate.JacksonStdImpl;
+import sh.calaba.org.codehaus.jackson.util.TokenBuffer;
+
+/**
+ * We also want to directly support deserialization of
+ * {@link TokenBuffer}.
+ *<p>
+ * Note that we use scalar deserializer base just because we claim
+ * to be of scalar for type information inclusion purposes; actual
+ * underlying content can be of any (Object, Array, scalar) type.
+ *
+ * @since 1.9 (moved from higher-level package)
+ */
+@JacksonStdImpl
+public class TokenBufferDeserializer
+    extends StdScalarDeserializer<TokenBuffer>
+{
+    public TokenBufferDeserializer() { super(TokenBuffer.class); }
+
+    @Override
+    public TokenBuffer deserialize(JsonParser jp, DeserializationContext ctxt)
+        throws IOException, JsonProcessingException
+    {
+        TokenBuffer tb = new TokenBuffer(jp.getCodec());
+        // quite simple, given that TokenBuffer is a JsonGenerator:
+        tb.copyCurrentStructure(jp);
+        return tb;
+    }
+}

data/test-server/instrumentation-backend/src/sh/calaba/org/codehaus/jackson/map/deser/std/UntypedObjectDeserializer.java

@@ -0,0 +1,248 @@
+package sh.calaba.org.codehaus.jackson.map.deser.std;
+
+import java.io.IOException;
+import java.util.*;
+
+import sh.calaba.org.codehaus.jackson.JsonParser;
+import sh.calaba.org.codehaus.jackson.JsonProcessingException;
+import sh.calaba.org.codehaus.jackson.JsonToken;
+import sh.calaba.org.codehaus.jackson.map.DeserializationConfig;
+import sh.calaba.org.codehaus.jackson.map.DeserializationContext;
+import sh.calaba.org.codehaus.jackson.map.TypeDeserializer;
+import sh.calaba.org.codehaus.jackson.map.annotate.JacksonStdImpl;
+import sh.calaba.org.codehaus.jackson.map.util.ObjectBuffer;
+
+/**
+ * Deserializer implementation that is used if it is necessary to bind content of
+ * "unknown" type; something declared as basic {@link java.lang.Object}
+ * (either explicitly, or due to type erasure).
+ * If so, "natural" mapping is used to convert JSON values to their natural
+ * Java object matches: JSON arrays to Java {@link java.util.List}s (or, if configured,
+ * Object[]), JSON objects to {@link java.util.Map}s, numbers to
+ * {@link java.lang.Number}s, booleans to {@link java.lang.Boolean}s and
+ * strings to {@link java.lang.String} (and nulls to nulls).
+ *
+ * @since 1.9 (moved from higher-level package)
+ */
+@JacksonStdImpl
+public class UntypedObjectDeserializer
+    extends StdDeserializer<Object>
+{
+    private final static Object[] NO_OBJECTS = new Object[0];
+    
+    public UntypedObjectDeserializer() { super(Object.class); }
+
+    /*
+    /**********************************************************
+    /* Deserializer API
+    /**********************************************************
+     */
+    
+    @Override
+    public Object deserialize(JsonParser jp, DeserializationContext ctxt)
+        throws IOException, JsonProcessingException
+    {
+        switch (jp.getCurrentToken()) {
+        case START_OBJECT:
+            return mapObject(jp, ctxt);
+        case END_OBJECT: // invalid
+            break;
+        case START_ARRAY:
+            return mapArray(jp, ctxt);
+        case END_ARRAY: // invalid
+            break;
+        case FIELD_NAME:
+            return mapObject(jp, ctxt);
+        case VALUE_EMBEDDED_OBJECT:
+            return jp.getEmbeddedObject();
+        case VALUE_STRING:
+            return jp.getText();
+
+        case VALUE_NUMBER_INT:
+            /* [JACKSON-100]: caller may want to get all integral values
+             * returned as BigInteger, for consistency
+             */
+            if (ctxt.isEnabled(DeserializationConfig.Feature.USE_BIG_INTEGER_FOR_INTS)) {
+                return jp.getBigIntegerValue(); // should be optimal, whatever it is
+            }
+            return jp.getNumberValue(); // should be optimal, whatever it is
+
+        case VALUE_NUMBER_FLOAT:
+            /* [JACKSON-72]: need to allow overriding the behavior regarding
+             *   which type to use
+             */
+            if (ctxt.isEnabled(DeserializationConfig.Feature.USE_BIG_DECIMAL_FOR_FLOATS)) {
+                return jp.getDecimalValue();
+            }
+            return Double.valueOf(jp.getDoubleValue());
+
+        case VALUE_TRUE:
+            return Boolean.TRUE;
+        case VALUE_FALSE:
+            return Boolean.FALSE;
+
+        case VALUE_NULL: // should not get this but...
+            return null;
+            
+         }
+
+        throw ctxt.mappingException(Object.class);
+    }
+
+    @Override
+    public Object deserializeWithType(JsonParser jp, DeserializationContext ctxt,
+            TypeDeserializer typeDeserializer)
+        throws IOException, JsonProcessingException
+    {
+        JsonToken t = jp.getCurrentToken();
+        switch (t) {
+        // First: does it look like we had type id wrapping of some kind?
+        case START_ARRAY:
+        case START_OBJECT:
+        case FIELD_NAME:
+            /* Output can be as JSON Object, Array or scalar: no way to know
+             * a this point:
+             */
+            return typeDeserializer.deserializeTypedFromAny(jp, ctxt);
+
+        /* Otherwise we probably got a "native" type (ones that map
+         * naturally and thus do not need or use type ids)
+         */
+        case VALUE_STRING:
+            return jp.getText();
+
+        case VALUE_NUMBER_INT:
+            // For [JACKSON-100], see above:
+            if (ctxt.isEnabled(DeserializationConfig.Feature.USE_BIG_INTEGER_FOR_INTS)) {
+                return jp.getBigIntegerValue();
+            }
+            return jp.getIntValue();
+
+        case VALUE_NUMBER_FLOAT:
+            // For [JACKSON-72], see above
+            if (ctxt.isEnabled(DeserializationConfig.Feature.USE_BIG_DECIMAL_FOR_FLOATS)) {
+                return jp.getDecimalValue();
+            }
+            return Double.valueOf(jp.getDoubleValue());
+
+        case VALUE_TRUE:
+            return Boolean.TRUE;
+        case VALUE_FALSE:
+            return Boolean.FALSE;
+        case VALUE_EMBEDDED_OBJECT:
+            return jp.getEmbeddedObject();
+
+        case VALUE_NULL: // should not get this far really but...
+            return null;
+        }
+        throw ctxt.mappingException(Object.class);
+    }
+
+    /*
+    /**********************************************************
+    /* Internal methods
+    /**********************************************************
+     */
+    
+    /**
+     * Method called to map a JSON Array into a Java value.
+     */
+    protected Object mapArray(JsonParser jp, DeserializationContext ctxt)
+        throws IOException, JsonProcessingException
+    {
+        if (ctxt.isEnabled(DeserializationConfig.Feature.USE_JAVA_ARRAY_FOR_JSON_ARRAY)) {
+            return mapArrayToArray(jp, ctxt);
+        }
+        // Minor optimization to handle small lists (default size for ArrayList is 10)
+        if (jp.nextToken()  == JsonToken.END_ARRAY) {
+            return new ArrayList<Object>(4);
+        }
+        ObjectBuffer buffer = ctxt.leaseObjectBuffer();
+        Object[] values = buffer.resetAndStart();
+        int ptr = 0;
+        int totalSize = 0;
+        do {
+            Object value = deserialize(jp, ctxt);
+            ++totalSize;
+            if (ptr >= values.length) {
+                values = buffer.appendCompletedChunk(values);
+                ptr = 0;
+            }
+            values[ptr++] = value;
+        } while (jp.nextToken() != JsonToken.END_ARRAY);
+        // let's create almost full array, with 1/8 slack
+        ArrayList<Object> result = new ArrayList<Object>(totalSize + (totalSize >> 3) + 1);
+        buffer.completeAndClearBuffer(values, ptr, result);
+        return result;
+    }
+
+    /**
+     * Method called to map a JSON Object into a Java value.
+     */
+    protected Object mapObject(JsonParser jp, DeserializationContext ctxt)
+        throws IOException, JsonProcessingException
+    {
+        JsonToken t = jp.getCurrentToken();
+        if (t == JsonToken.START_OBJECT) {
+            t = jp.nextToken();
+        }
+        // 1.6: minor optimization; let's handle 1 and 2 entry cases separately
+        if (t != JsonToken.FIELD_NAME) { // and empty one too
+            // empty map might work; but caller may want to modify... so better just give small modifiable
+            return new LinkedHashMap<String,Object>(4);
+        }
+        String field1 = jp.getText();
+        jp.nextToken();
+        Object value1 = deserialize(jp, ctxt);
+        if (jp.nextToken() != JsonToken.FIELD_NAME) { // single entry; but we want modifiable
+            LinkedHashMap<String, Object> result = new LinkedHashMap<String, Object>(4);
+            result.put(field1, value1);
+            return result;
+        }
+        String field2 = jp.getText();
+        jp.nextToken();
+        Object value2 = deserialize(jp, ctxt);
+        if (jp.nextToken() != JsonToken.FIELD_NAME) {
+            LinkedHashMap<String, Object> result = new LinkedHashMap<String, Object>(4);
+            result.put(field1, value1);
+            result.put(field2, value2);
+            return result;
+        }
+        // And then the general case; default map size is 16
+        LinkedHashMap<String, Object> result = new LinkedHashMap<String, Object>();
+        result.put(field1, value1);
+        result.put(field2, value2);
+        do {
+            String fieldName = jp.getText();
+            jp.nextToken();
+            result.put(fieldName, deserialize(jp, ctxt));
+        } while (jp.nextToken() != JsonToken.END_OBJECT);
+        return result;
+    }
+
+    /**
+     * Method called to map a JSON Array into a Java Object array (Object[]).
+     * 
+     * @since 1.9
+     */
+    protected Object[] mapArrayToArray(JsonParser jp, DeserializationContext ctxt)
+        throws IOException, JsonProcessingException
+    {
+        // Minor optimization to handle small lists (default size for ArrayList is 10)
+        if (jp.nextToken()  == JsonToken.END_ARRAY) {
+            return NO_OBJECTS;
+        }
+        ObjectBuffer buffer = ctxt.leaseObjectBuffer();
+        Object[] values = buffer.resetAndStart();
+        int ptr = 0;
+        do {
+            Object value = deserialize(jp, ctxt);
+            if (ptr >= values.length) {
+                values = buffer.appendCompletedChunk(values);
+                ptr = 0;
+            }
+            values[ptr++] = value;
+        } while (jp.nextToken() != JsonToken.END_ARRAY);
+        return buffer.completeAndClearBuffer(values, ptr);
+    }
+}