calabash-android 0.5.2 → 0.5.3

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

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

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

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