calabash-android 0.0.1

data/test-server/instrumentation-backend/src/sh/calaba/org/codehaus/jackson/node/POJONode.java

@@ -0,0 +1,145 @@
+package sh.calaba.org.codehaus.jackson.node;
+
+import java.io.IOException;
+
+import sh.calaba.org.codehaus.jackson.*;
+import sh.calaba.org.codehaus.jackson.map.SerializerProvider;
+
+/**
+ * Value node that contains a wrapped POJO, to be serialized as
+ * a JSON constructed through data mapping (usually done by
+ * calling {@link sh.calaba.org.codehaus.jackson.map.ObjectMapper}).
+ */
+public final class POJONode
+    extends ValueNode
+{
+    protected final Object _value;
+
+    public POJONode(Object v) { _value = v; }
+
+    /*
+    /**********************************************************
+    /* Base class overrides
+    /**********************************************************
+     */
+
+    @Override public JsonToken asToken() { return JsonToken.VALUE_EMBEDDED_OBJECT; }
+
+    @Override
+    public boolean isPojo() { return true; }
+
+    @Override
+    public byte[] getBinaryValue()
+        throws IOException
+    {
+        if (_value instanceof byte[]) {
+            return (byte[]) _value;
+        }
+        return super.getBinaryValue();
+    }
+    
+    /* 
+    /**********************************************************
+    /* General type coercions
+    /**********************************************************
+     */
+
+    @Override
+    public String asText() {
+        return (_value == null) ? "null" : _value.toString();
+    }
+
+    @Override
+    public boolean asBoolean(boolean defaultValue)
+    {
+        if (_value != null && _value instanceof Boolean) {
+            return ((Boolean) _value).booleanValue();
+        }
+        return defaultValue;
+    }
+    
+    @Override
+    public int asInt(int defaultValue)
+    {
+        if (_value instanceof Number) {
+            return ((Number) _value).intValue();
+        }
+        return defaultValue;
+    }
+
+    @Override
+    public long asLong(long defaultValue)
+    {
+        if (_value instanceof Number) {
+            return ((Number) _value).longValue();
+        }
+        return defaultValue;
+    }
+    
+    @Override
+    public double asDouble(double defaultValue)
+    {
+        if (_value instanceof Number) {
+            return ((Number) _value).doubleValue();
+        }
+        return defaultValue;
+    }
+    
+    /*
+    /**********************************************************
+    /* Public API, serialization
+    /**********************************************************
+     */
+
+    @Override
+    public final void serialize(JsonGenerator jg, SerializerProvider provider)
+        throws IOException, JsonProcessingException
+    {
+        if (_value == null) {
+            jg.writeNull();
+        } else {
+            jg.writeObject(_value);
+        }
+    }
+
+    /*
+    /**********************************************************
+    /* Extended API
+    /**********************************************************
+     */
+
+    /**
+     * Method that can be used to access the POJO this node wraps.
+     */
+    public Object getPojo() { return _value; }
+
+    /*
+    /**********************************************************
+    /* Overridden standard methods
+    /**********************************************************
+     */
+
+    @Override
+    public boolean equals(Object o)
+    {
+        if (o == this) return true;
+        if (o == null) return false;
+        if (o.getClass() != getClass()) { // final class, can do this
+            return false;
+        }
+        POJONode other = (POJONode) o;
+        if (_value == null) {
+            return other._value == null;
+        }
+        return _value.equals(other._value);
+    }
+
+    @Override
+    public int hashCode() { return _value.hashCode(); }
+
+    @Override
+    public String toString()
+    {
+        return String.valueOf(_value);
+    }
+}

data/test-server/instrumentation-backend/src/sh/calaba/org/codehaus/jackson/node/TextNode.java

@@ -0,0 +1,299 @@
+package sh.calaba.org.codehaus.jackson.node;
+
+import java.io.IOException;
+
+import sh.calaba.org.codehaus.jackson.*;
+import sh.calaba.org.codehaus.jackson.io.NumberInput;
+import sh.calaba.org.codehaus.jackson.map.SerializerProvider;
+import sh.calaba.org.codehaus.jackson.util.ByteArrayBuilder;
+import sh.calaba.org.codehaus.jackson.util.CharTypes;
+
+/**
+ * Value node that contains a text value.
+ */
+public final class TextNode
+    extends ValueNode
+{
+    final static int INT_SPACE = ' ';
+
+    final static TextNode EMPTY_STRING_NODE = new TextNode("");
+
+    final String _value;
+
+    public TextNode(String v) { _value = v; }
+
+    /**
+     * Factory method that should be used to construct instances.
+     * For some common cases, can reuse canonical instances: currently
+     * this is the case for empty Strings, in future possible for
+     * others as well. If null is passed, will return null.
+     *
+     * @return Resulting {@link TextNode} object, if <b>v</b>
+     *   is NOT null; null if it is.
+     */
+    public static TextNode valueOf(String v)
+    {
+        if (v == null) {
+            return null;
+        }
+        if (v.length() == 0) {
+            return EMPTY_STRING_NODE;
+        }
+        return new TextNode(v);
+    }
+
+    @Override public JsonToken asToken() { return JsonToken.VALUE_STRING; }
+
+    /**
+     * Yes indeed it is textual
+     */
+    @Override
+    public boolean isTextual() { return true; }
+
+    @Override
+    public String getTextValue() {
+        return _value;
+    }
+
+    /**
+     * Method for accessing textual contents assuming they were
+     * base64 encoded; if so, they are decoded and resulting binary
+     * data is returned.
+     */
+    public byte[] getBinaryValue(Base64Variant b64variant)
+        throws IOException
+    {
+        ByteArrayBuilder builder = new ByteArrayBuilder(100);
+        final String str = _value;
+        int ptr = 0;
+        int len = str.length();
+
+        main_loop:
+        while (ptr < len) {
+            // first, we'll skip preceding white space, if any
+            char ch;
+            do {
+                ch = str.charAt(ptr++);
+                if (ptr >= len) {
+                    break main_loop;
+                }
+            } while (ch <= INT_SPACE);
+            int bits = b64variant.decodeBase64Char(ch);
+            if (bits < 0) {
+                _reportInvalidBase64(b64variant, ch, 0);
+            }
+            int decodedData = bits;
+            // then second base64 char; can't get padding yet, nor ws
+            if (ptr >= len) {
+                _reportBase64EOF();
+            }
+            ch = str.charAt(ptr++);
+            bits = b64variant.decodeBase64Char(ch);
+            if (bits < 0) {
+                _reportInvalidBase64(b64variant, ch, 1);
+            }
+            decodedData = (decodedData << 6) | bits;
+            // third base64 char; can be padding, but not ws
+            if (ptr >= len) {
+                // but as per [JACKSON-631] can be end-of-input, iff not using padding
+                if (!b64variant.usesPadding()) {
+                    // Got 12 bits, only need 8, need to shift
+                    decodedData >>= 4;
+                    builder.append(decodedData);
+                    break;
+                }
+                _reportBase64EOF();
+            }
+            ch = str.charAt(ptr++);
+            bits = b64variant.decodeBase64Char(ch);
+
+            // First branch: can get padding (-> 1 byte)
+            if (bits < 0) {
+                if (bits != Base64Variant.BASE64_VALUE_PADDING) {
+                    _reportInvalidBase64(b64variant, ch, 2);
+                }
+                // Ok, must get padding
+                if (ptr >= len) {
+                    _reportBase64EOF();
+                }
+                ch = str.charAt(ptr++);
+                if (!b64variant.usesPaddingChar(ch)) {
+                    _reportInvalidBase64(b64variant, ch, 3, "expected padding character '"+b64variant.getPaddingChar()+"'");
+                }
+                // Got 12 bits, only need 8, need to shift
+                decodedData >>= 4;
+                builder.append(decodedData);
+                continue;
+            }
+            // Nope, 2 or 3 bytes
+            decodedData = (decodedData << 6) | bits;
+            // fourth and last base64 char; can be padding, but not ws
+            if (ptr >= len) {
+                // but as per [JACKSON-631] can be end-of-input, iff not using padding
+                if (!b64variant.usesPadding()) {
+                    decodedData >>= 2;
+                    builder.appendTwoBytes(decodedData);
+                    break;
+                }
+                _reportBase64EOF();
+            }
+            ch = str.charAt(ptr++);
+            bits = b64variant.decodeBase64Char(ch);
+            if (bits < 0) {
+                if (bits != Base64Variant.BASE64_VALUE_PADDING) {
+                    _reportInvalidBase64(b64variant, ch, 3);
+                }
+                decodedData >>= 2;
+                builder.appendTwoBytes(decodedData);
+            } else {
+                // otherwise, our triple is now complete
+                decodedData = (decodedData << 6) | bits;
+                builder.appendThreeBytes(decodedData);
+            }
+        }
+        return builder.toByteArray();
+    }
+
+    @Override
+    public byte[] getBinaryValue() throws IOException
+    {
+        return getBinaryValue(Base64Variants.getDefaultVariant());
+    }
+    
+    /* 
+    /**********************************************************
+    /* General type coercions
+    /**********************************************************
+     */
+
+    @Override
+    public String asText() {
+        return _value;
+    }
+
+    // note: neither fast nor elegant, but these work for now:
+
+    @Override
+    public boolean asBoolean(boolean defaultValue) {
+        if (_value != null) {
+            if ("true".equals(_value.trim())) {
+                return true;
+            }
+        }
+        return defaultValue;
+    }
+    
+    @Override
+    public int asInt(int defaultValue) {
+        return NumberInput.parseAsInt(_value, defaultValue);
+    }
+
+    @Override
+    public long asLong(long defaultValue) {
+        return NumberInput.parseAsLong(_value, defaultValue);
+    }
+    
+    @Override
+    public double asDouble(double defaultValue) {
+        return NumberInput.parseAsDouble(_value, defaultValue);
+    }
+    
+    /* 
+    /**********************************************************
+    /* Serialization
+    /**********************************************************
+     */
+    
+    @Override
+    public final void serialize(JsonGenerator jg, SerializerProvider provider)
+        throws IOException, JsonProcessingException
+    {
+        if (_value == null) {
+            jg.writeNull();
+        } else {
+            jg.writeString(_value);
+        }
+    }
+
+    /*
+    /**********************************************************
+    /* Overridden standard methods
+    /**********************************************************
+     */
+    
+    @Override
+    public boolean equals(Object o)
+    {
+        if (o == this) return true;
+        if (o == null) return false;
+        if (o.getClass() != getClass()) { // final class, can do this
+            return false;
+        }
+        return ((TextNode) o)._value.equals(_value);
+    }
+    
+    @Override
+    public int hashCode() { return _value.hashCode(); }
+
+    /**
+     * Different from other values, Strings need quoting
+     */
+    @Override
+    public String toString()
+    {
+        int len = _value.length();
+        len = len + 2 + (len >> 4);
+        StringBuilder sb = new StringBuilder(len);
+        appendQuoted(sb, _value);
+        return sb.toString();
+    }
+
+    protected static void appendQuoted(StringBuilder sb, String content)
+    {
+        sb.append('"');
+        CharTypes.appendQuoted(sb, content);
+        sb.append('"');
+    }
+
+    /*
+    /**********************************************************
+    /* Helper methods
+    /**********************************************************
+     */
+    
+    protected void _reportInvalidBase64(Base64Variant b64variant, char ch, int bindex)
+        throws JsonParseException
+    {
+        _reportInvalidBase64(b64variant, ch, bindex, null);
+    }
+
+    /**
+     * @param bindex Relative index within base64 character unit; between 0
+     *   and 3 (as unit has exactly 4 characters)
+     */
+    protected void _reportInvalidBase64(Base64Variant b64variant, char ch, int bindex, String msg)
+        throws JsonParseException
+    {
+        String base;
+        if (ch <= INT_SPACE) {
+            base = "Illegal white space character (code 0x"+Integer.toHexString(ch)+") as character #"+(bindex+1)+" of 4-char base64 unit: can only used between units";
+        } else if (b64variant.usesPaddingChar(ch)) {
+            base = "Unexpected padding character ('"+b64variant.getPaddingChar()+"') as character #"+(bindex+1)+" of 4-char base64 unit: padding only legal as 3rd or 4th character";
+        } else if (!Character.isDefined(ch) || Character.isISOControl(ch)) {
+            // Not sure if we can really get here... ? (most illegal xml chars are caught at lower level)
+            base = "Illegal character (code 0x"+Integer.toHexString(ch)+") in base64 content";
+        } else {
+            base = "Illegal character '"+ch+"' (code 0x"+Integer.toHexString(ch)+") in base64 content";
+        }
+        if (msg != null) {
+            base = base + ": " + msg;
+        }
+        throw new JsonParseException(base, JsonLocation.NA);
+    }
+
+    protected void _reportBase64EOF()
+        throws JsonParseException
+    {
+        throw new JsonParseException("Unexpected end-of-String when base64 content", JsonLocation.NA);
+    }
+}

data/test-server/instrumentation-backend/src/sh/calaba/org/codehaus/jackson/node/TreeTraversingParser.java

@@ -0,0 +1,383 @@
+package sh.calaba.org.codehaus.jackson.node;
+
+import java.io.IOException;
+import java.math.BigDecimal;
+import java.math.BigInteger;
+
+import sh.calaba.org.codehaus.jackson.*;
+import sh.calaba.org.codehaus.jackson.impl.JsonParserMinimalBase;
+
+/**
+ * Facade over {@link JsonNode} that implements {@link JsonParser} to allow
+ * accessing contents of JSON tree in alternate form (stream of tokens).
+ * Useful when a streaming source is expected by code, such as data binding
+ * functionality.
+ * 
+ * @author tatu
+ * 
+ * @since 1.3
+ */
+public class TreeTraversingParser extends JsonParserMinimalBase
+{
+    /*
+    /**********************************************************
+    /* Configuration
+    /**********************************************************
+     */
+
+    protected ObjectCodec _objectCodec;
+
+    /**
+     * Traversal context within tree
+     */
+    protected NodeCursor _nodeCursor;
+
+    /*
+    /**********************************************************
+    /* State
+    /**********************************************************
+     */
+
+    /**
+     * Sometimes parser needs to buffer a single look-ahead token; if so,
+     * it'll be stored here. This is currently used for handling 
+     */
+    protected JsonToken _nextToken;
+
+    /**
+     * Flag needed to handle recursion into contents of child
+     * Array/Object nodes.
+     */
+    protected boolean _startContainer;
+    
+    /**
+     * Flag that indicates whether parser is closed or not. Gets
+     * set when parser is either closed by explicit call
+     * ({@link #close}) or when end-of-input is reached.
+     */
+    protected boolean _closed;
+
+    /*
+    /**********************************************************
+    /* Life-cycle
+    /**********************************************************
+     */
+
+    public TreeTraversingParser(JsonNode n) { this(n, null); }
+
+    public TreeTraversingParser(JsonNode n, ObjectCodec codec)
+    {
+        super(0);
+        _objectCodec = codec;
+        if (n.isArray()) {
+            _nextToken = JsonToken.START_ARRAY;
+            _nodeCursor = new NodeCursor.Array(n, null);
+        } else if (n.isObject()) {
+            _nextToken = JsonToken.START_OBJECT;
+            _nodeCursor = new NodeCursor.Object(n, null);
+        } else { // value node
+            _nodeCursor = new NodeCursor.RootValue(n, null);
+        }
+    }
+
+    @Override
+    public void setCodec(ObjectCodec c) {
+        _objectCodec = c;
+    }
+
+    @Override
+    public ObjectCodec getCodec() {
+        return _objectCodec;
+    }
+
+    /*
+    /**********************************************************
+    /* Closeable implementation
+    /**********************************************************
+     */
+
+    @Override
+    public void close() throws IOException
+    {
+        if (!_closed) {
+            _closed = true;
+            _nodeCursor = null;
+            _currToken = null;
+        }
+    }
+
+    /*
+    /**********************************************************
+    /* Public API, traversal
+    /**********************************************************
+     */
+
+    @Override
+    public JsonToken nextToken() throws IOException, JsonParseException
+    {
+        if (_nextToken != null) {
+            _currToken = _nextToken;
+            _nextToken = null;
+            return _currToken;
+        }
+        // are we to descend to a container child?
+        if (_startContainer) {
+            _startContainer = false;
+            // minor optimization: empty containers can be skipped
+            if (!_nodeCursor.currentHasChildren()) {
+                _currToken = (_currToken == JsonToken.START_OBJECT) ?
+                    JsonToken.END_OBJECT : JsonToken.END_ARRAY;
+                return _currToken;
+            }
+            _nodeCursor = _nodeCursor.iterateChildren();
+            _currToken = _nodeCursor.nextToken();
+            if (_currToken == JsonToken.START_OBJECT || _currToken == JsonToken.START_ARRAY) {
+                _startContainer = true;
+            }
+            return _currToken;
+        }
+        // No more content?
+        if (_nodeCursor == null) {
+            _closed = true; // if not already set
+            return null;
+        }
+        // Otherwise, next entry from current cursor
+        _currToken = _nodeCursor.nextToken();
+        if (_currToken != null) {
+            if (_currToken == JsonToken.START_OBJECT || _currToken == JsonToken.START_ARRAY) {
+                _startContainer = true;
+            }
+            return _currToken;
+        }
+        // null means no more children; need to return end marker
+        _currToken = _nodeCursor.endToken();
+        _nodeCursor = _nodeCursor.getParent();
+        return _currToken;
+    }
+    
+    // default works well here:
+    //public JsonToken nextValue() throws IOException, JsonParseException
+
+    @Override
+    public JsonParser skipChildren() throws IOException, JsonParseException
+    {
+        if (_currToken == JsonToken.START_OBJECT) {
+            _startContainer = false;
+            _currToken = JsonToken.END_OBJECT;
+        } else if (_currToken == JsonToken.START_ARRAY) {
+            _startContainer = false;
+            _currToken = JsonToken.END_ARRAY;
+        }
+        return this;
+    }
+
+    @Override
+    public boolean isClosed() {
+        return _closed;
+    }
+
+    /*
+    /**********************************************************
+    /* Public API, token accessors
+    /**********************************************************
+     */
+
+    @Override
+    public String getCurrentName() {
+        return (_nodeCursor == null) ? null : _nodeCursor.getCurrentName();
+    }
+
+    @Override
+    public JsonStreamContext getParsingContext() {
+        return _nodeCursor;
+    }
+
+    @Override
+    public JsonLocation getTokenLocation() {
+        return JsonLocation.NA;
+    }
+
+    @Override
+    public JsonLocation getCurrentLocation() {
+        return JsonLocation.NA;
+    }
+
+    /*
+    /**********************************************************
+    /* Public API, access to textual content
+    /**********************************************************
+     */
+
+    @Override
+    public String getText()
+    {
+        if (_closed) {
+            return null;
+        }
+        // need to separate handling a bit...
+        switch (_currToken) {
+        case FIELD_NAME:
+            return _nodeCursor.getCurrentName();
+        case VALUE_STRING:
+            return currentNode().getTextValue();
+        case VALUE_NUMBER_INT:
+        case VALUE_NUMBER_FLOAT:
+            return String.valueOf(currentNode().getNumberValue());
+        case VALUE_EMBEDDED_OBJECT:
+            JsonNode n = currentNode();
+            if (n != null && n.isBinary()) {
+                // this will convert it to base64
+                return n.asText();
+            }
+        }
+
+        return (_currToken == null) ? null : _currToken.asString();
+    }
+
+    @Override
+    public char[] getTextCharacters() throws IOException, JsonParseException {
+        return getText().toCharArray();
+    }
+
+    @Override
+    public int getTextLength() throws IOException, JsonParseException {
+        return getText().length();
+    }
+
+    @Override
+    public int getTextOffset() throws IOException, JsonParseException {
+        return 0;
+    }
+
+    @Override
+    public boolean hasTextCharacters() {
+        // generally we do not have efficient access as char[], hence:
+        return false;
+    }
+    
+    /*
+    /**********************************************************
+    /* Public API, typed non-text access
+    /**********************************************************
+     */
+
+    //public byte getByteValue() throws IOException, JsonParseException
+
+    @Override
+    public NumberType getNumberType() throws IOException, JsonParseException {
+        JsonNode n = currentNumericNode();
+        return (n == null) ? null : n.getNumberType();
+    }
+
+    @Override
+    public BigInteger getBigIntegerValue() throws IOException, JsonParseException
+    {
+        return currentNumericNode().getBigIntegerValue();
+    }
+
+    @Override
+    public BigDecimal getDecimalValue() throws IOException, JsonParseException {
+        return currentNumericNode().getDecimalValue();
+    }
+
+    @Override
+    public double getDoubleValue() throws IOException, JsonParseException {
+        return currentNumericNode().getDoubleValue();
+    }
+
+    @Override
+    public float getFloatValue() throws IOException, JsonParseException {
+        return (float) currentNumericNode().getDoubleValue();
+    }
+
+    @Override
+    public long getLongValue() throws IOException, JsonParseException {
+        return currentNumericNode().getLongValue();
+    }
+
+    @Override
+    public int getIntValue() throws IOException, JsonParseException {
+        return currentNumericNode().getIntValue();
+    }
+
+    @Override
+    public Number getNumberValue() throws IOException, JsonParseException {
+        return currentNumericNode().getNumberValue();
+    }
+
+    @Override
+    public Object getEmbeddedObject()
+    {
+        if (!_closed) {
+            JsonNode n = currentNode();
+            if (n != null) {
+                if (n.isPojo()) {
+                    return ((POJONode) n).getPojo();
+                }
+                if (n.isBinary()) {
+                    return ((BinaryNode) n).getBinaryValue();
+                }
+            }
+        }
+        return null;
+    }
+
+    /*
+    /**********************************************************
+    /* Public API, typed binary (base64) access
+    /**********************************************************
+     */
+
+    @Override
+    public byte[] getBinaryValue(Base64Variant b64variant)
+        throws IOException, JsonParseException
+    {
+        // Multiple possibilities...
+        JsonNode n = currentNode();
+        if (n != null) { // binary node?
+            byte[] data = n.getBinaryValue();
+            // (or TextNode, which can also convert automatically!)
+            if (data != null) {
+                return data;
+            }
+            // Or maybe byte[] as POJO?
+            if (n.isPojo()) {
+                Object ob = ((POJONode) n).getPojo();
+                if (ob instanceof byte[]) {
+                    return (byte[]) ob;
+                }
+            }
+        }
+        // otherwise return null to mark we have no binary content
+        return null;
+    }
+
+    /*
+    /**********************************************************
+    /* Internal methods
+    /**********************************************************
+     */
+
+    protected JsonNode currentNode() {
+        if (_closed || _nodeCursor == null) {
+            return null;
+        }
+        return _nodeCursor.currentNode();
+    }
+
+    protected JsonNode currentNumericNode()
+        throws JsonParseException
+    {
+        JsonNode n = currentNode();
+        if (n == null || !n.isNumber()) {
+            JsonToken t = (n == null) ? null : n.asToken();
+            throw _constructError("Current token ("+t+") not numeric, can not use numeric value accessors");
+        }
+        return n;
+    }
+
+    @Override
+    protected void _handleEOF() throws JsonParseException {
+        _throwInternal(); // should never get called
+    }
+}