calabash-android 0.4.7.pre4 → 0.4.7.pre6

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

@@ -1,105 +0,0 @@
-package sh.calaba.org.codehaus.jackson.map.util;
-
-import java.io.IOException;
-
-import sh.calaba.org.codehaus.jackson.*;
-import sh.calaba.org.codehaus.jackson.map.*;
-import sh.calaba.org.codehaus.jackson.map.type.TypeFactory;
-import sh.calaba.org.codehaus.jackson.type.JavaType;
-
-/**
- * Container class that can be used to wrap any Object instances (including
- * nulls), and will serialize embedded in
- * <a href="http://en.wikipedia.org/wiki/JSONP">JSONP</a> wrapping.
- * 
- * @see sh.calaba.org.codehaus.jackson.map.util.JSONWrappedObject
- * 
- * @author tatu
- * @since 1.5
- */
-public class JSONPObject
-    implements JsonSerializableWithType
-{
-    /**
-     * JSONP function name to use for serialization
-     */
-    protected final String _function;
-    
-    /**
-     * Value to be serialized as JSONP padded; can be null.
-     */
-    protected final Object _value;
-
-    /**
-     * Optional static type to use for serialization; if null, runtime
-     * type is used. Can be used to specify declared type which defines
-     * serializer to use, as well as aspects of extra type information
-     * to include (if any).
-     */
-    protected final JavaType _serializationType;
-
-    public JSONPObject(String function, Object value) {
-        this(function, value, (JavaType) null);
-    }
-
-    public JSONPObject(String function, Object value, JavaType asType)
-    {
-        _function = function;
-        _value = value;
-        _serializationType = asType;
-    }
-
-    /**
-     * @deprecated Since 1.8; instead use variant that takes JavaType: this ensures
-     *    that type information is properly resolved
-     */
-    @Deprecated
-    public JSONPObject(String function, Object value, Class<?> rawType) {
-        _function = function;
-        _value = value;
-        _serializationType = (rawType == null) ? null : TypeFactory.defaultInstance().constructType(rawType);
-    }
-    
-    /*
-    /**********************************************************
-    /* JsonSerializable(WithType) implementation
-    /**********************************************************
-     */
-    
-    @Override
-    public void serializeWithType(JsonGenerator jgen, SerializerProvider provider, TypeSerializer typeSer)
-            throws IOException, JsonProcessingException
-    {
-        // No type for JSONP wrapping: value serializer will handle typing for value:
-        serialize(jgen, provider);
-    }
-
-    @Override
-    @SuppressWarnings("deprecation")
-    public void serialize(JsonGenerator jgen, SerializerProvider provider)
-            throws IOException, JsonProcessingException
-    {
-        // First, wrapping:
-        jgen.writeRaw(_function);
-        jgen.writeRaw('(');
-        if (_value == null) {
-            provider.defaultSerializeNull(jgen);
-        } else if (_serializationType != null) {
-            provider.findTypedValueSerializer(_serializationType, true, null).serialize(_value, jgen, provider);
-        } else {
-            Class<?> cls = _value.getClass();
-            provider.findTypedValueSerializer(cls, true, null).serialize(_value, jgen, provider);
-        }
-        jgen.writeRaw(')');
-    }
-
-    /*
-    /**************************************************************
-    /* Accessors
-    /**************************************************************
-     */
-    
-    public String getFunction() { return _function; }
-    public Object getValue() { return _value; }
-    public JavaType getSerializationType() { return _serializationType; }
-}

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

@@ -1,117 +0,0 @@
-package sh.calaba.org.codehaus.jackson.map.util;
-
-import java.io.IOException;
-
-import sh.calaba.org.codehaus.jackson.*;
-import sh.calaba.org.codehaus.jackson.map.*;
-import sh.calaba.org.codehaus.jackson.map.type.TypeFactory;
-import sh.calaba.org.codehaus.jackson.type.JavaType;
-
-
-/**
- * General-purpose wrapper class that can be used to decorate serialized
- * value with arbitrary literal prefix and suffix. This can be used for
- * example to construct arbitrary Javascript values (similar to how basic
- * function name and parenthesis are used with JSONP).
- * 
- * @see sh.calaba.org.codehaus.jackson.map.util.JSONPObject
- * 
- * @author tatu
- * @since 1.5
- */
-public class JSONWrappedObject
-    implements JsonSerializableWithType
-{
-    /**
-     * Literal String to output before serialized value.
-     * Will not be quoted when serializing value.
-     */
-    protected final String _prefix;
-
-    /**
-     * Literal String to output after serialized value.
-     * Will not be quoted when serializing value.
-     */
-    protected final String _suffix;
-    
-    /**
-     * Value to be serialized as JSONP padded; can be null.
-     */
-    protected final Object _value;
-
-    /**
-     * Optional static type to use for serialization; if null, runtime
-     * type is used. Can be used to specify declared type which defines
-     * serializer to use, as well as aspects of extra type information
-     * to include (if any).
-     */
-    protected final JavaType _serializationType;
-    
-    public JSONWrappedObject(String prefix, String suffix, Object value) {
-        this(prefix, suffix, value, (JavaType) null);
-    }
-
-    public JSONWrappedObject(String prefix, String suffix, Object value, JavaType asType)
-    {
-        _prefix = prefix;
-        _suffix = suffix;
-        _value = value;
-        _serializationType = asType;
-    }
-
-    /**
-     * @deprecated Since 1.8; should construct with resolved <code>JavaType</code>,
-     *   to ensure type has been properly resolved
-     */
-    @Deprecated
-    public JSONWrappedObject(String prefix, String suffix, Object value, Class<?> rawType) {
-        _prefix = prefix;
-        _suffix = suffix;
-        _value = value;
-        _serializationType = (rawType == null) ? null : TypeFactory.defaultInstance().constructType(rawType);
-    }
-    
-    /*
-    /**************************************************************
-    /* JsonSerializable(WithType) implementation
-    /**************************************************************
-     */
-    
-    @Override
-    public void serializeWithType(JsonGenerator jgen, SerializerProvider provider, TypeSerializer typeSer)
-            throws IOException, JsonProcessingException
-    {
-        // No type for JSONP wrapping: value serializer will handle typing for value:
-        serialize(jgen, provider);
-    }
-
-    @Override
-    @SuppressWarnings("deprecation")
-    public void serialize(JsonGenerator jgen, SerializerProvider provider)
-            throws IOException, JsonProcessingException
-    {
-        // First, wrapping:
-    	if (_prefix != null) jgen.writeRaw(_prefix);
-        if (_value == null) {
-            provider.defaultSerializeNull(jgen);
-        } else if (_serializationType != null) {
-            provider.findTypedValueSerializer(_serializationType, true, null).serialize(_value, jgen, provider);
-        } else {
-            Class<?> cls = _value.getClass();
-            provider.findTypedValueSerializer(cls, true, null).serialize(_value, jgen, provider);
-        }
-        if (_suffix != null) jgen.writeRaw(_suffix);
-    }
-
-    /*
-    /**************************************************************
-    /* Accessors
-    /**************************************************************
-     */
-    
-    public String getPrefix() { return _prefix; }
-    public String getSuffix() { return _suffix; }
-    public Object getValue() { return _value; }
-    public JavaType getSerializationType() { return _serializationType; }
-
-}

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

@@ -1,28 +0,0 @@
-package sh.calaba.org.codehaus.jackson.map.util;
-
-import java.util.LinkedHashMap;
-import java.util.Map;
-
-/**
- * Helper for simple bounded LRU maps used for reusing lookup values.
- * 
- * @since 1.7
- */
-@SuppressWarnings("serial")
-public class LRUMap<K,V> extends LinkedHashMap<K,V>
-{
-    protected final int _maxEntries;
-    
-    public LRUMap(int initialEntries, int maxEntries)
-    {
-        super(initialEntries, 0.8f, true);
-        _maxEntries = maxEntries;
-    }
-
-    @Override
-    protected boolean removeEldestEntry(Map.Entry<K,V> eldest)
-    {
-        return size() > _maxEntries;
-    }
-
-}

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

@@ -1,45 +0,0 @@
-package sh.calaba.org.codehaus.jackson.map.util;
-
-/**
- * Node of a forward-only linked list.
- * 
- * @author tatu
- *
- * @param <T> Type of contained object
- */
-public final class LinkedNode<T>
-{
-    final T _value;
-    final LinkedNode<T> _next;
-    
-    public LinkedNode(T value, LinkedNode<T> next)
-    {
-        _value = value;
-        _next = next;
-    }
-    
-    public LinkedNode<T> next() { return _next; }
-    
-    public T value() { return _value; }
-    
-    /**
-     * Convenience method that can be used to check if a linked list
-     * with given head node (which may be null to indicate empty list)
-     * contains given value
-     * 
-     * @param <ST> Type argument that defines contents of the linked list parameter
-     * @param node Head node of the linked list
-     * @param value Value to look for
-     * @return True if linked list contains the value, false otherwise
-     */
-    public static <ST> boolean contains(LinkedNode<ST> node, ST value)
-    {
-        while (node != null) {
-            if (node.value() == value) {
-                return true;
-            }
-            node = node.next();
-        }
-        return false;
-    }
-}

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

@@ -1,10 +0,0 @@
-package sh.calaba.org.codehaus.jackson.map.util;
-
-/**
- * Simple tag interface mostly to allow sorting by name
- *
- * @since 1.9
- */
-public interface Named {
-    public String getName();
-}

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

@@ -1,257 +0,0 @@
-package sh.calaba.org.codehaus.jackson.map.util;
-
-import java.lang.reflect.Array;
-import java.util.List;
-
-/**
- * Helper class to use for constructing Object arrays by appending entries
- * to create arrays of various lengths (length that is not known a priori). 
- */
-public final class ObjectBuffer
-{
-    // // // Config constants
-
-    /**
-     * Let's start with small chunks; typical usage is for small arrays anyway.
-     */
-    final static int INITIAL_CHUNK_SIZE = 12;
-
-    /**
-     * Also: let's expand by doubling up until 64k chunks (which is 16k entries for
-     * 32-bit machines)
-     */
-    final static int SMALL_CHUNK_SIZE = (1 << 14);
-
-    /**
-     * Let's limit maximum size of chunks we use; helps avoid excessive allocation
-     * overhead for huge data sets.
-     * For now, let's limit to quarter million entries, 1 meg chunks for 32-bit
-     * machines.
-     */
-    final static int MAX_CHUNK_SIZE = (1 << 18);
-
-    // // // Data storage
-
-    private Node _bufferHead;
-
-    private Node _bufferTail;
-
-    /**
-     * Number of total buffered entries in this buffer, counting all instances
-     * within linked list formed by following {@link #_bufferHead}.
-     */
-    private int _bufferedEntryCount;
-
-    // // // Simple reuse
-
-    /**
-     * Reusable Object array, stored here after buffer has been released having
-     * been used previously.
-     */
-    private Object[] _freeBuffer;
-
-    /*
-    /**********************************************************
-    /* Construction
-    /**********************************************************
-     */
-
-    public ObjectBuffer() { }
-
-    /*
-    /**********************************************************
-    /* Public API
-    /**********************************************************
-     */
-
-    /**
-     * Method called to start buffering process. Will ensure that the buffer
-     * is empty, and then return an object array to start chunking content on
-     */
-    public Object[] resetAndStart()
-    {
-        _reset();
-        if (_freeBuffer == null) {
-            return new Object[INITIAL_CHUNK_SIZE];
-        }
-        return _freeBuffer;
-    }
-
-    /**
-     * Method called to add a full Object array as a chunk buffered within
-     * this buffer, and to obtain a new array to fill. Caller is not to use
-     * the array it gives; but to use the returned array for continued
-     * buffering.
-     *
-     * @param fullChunk Completed chunk that the caller is requesting
-     *   to append to this buffer. It is generally chunk that was
-     *   returned by an earlier call to {@link #resetAndStart} or
-     *   {@link #appendCompletedChunk} (although this is not required or
-     *   enforced)
-     *
-     * @return New chunk buffer for caller to fill
-     */
-    public Object[] appendCompletedChunk(Object[] fullChunk)
-    {
-        Node next = new Node(fullChunk);
-        if (_bufferHead == null) { // first chunk
-            _bufferHead = _bufferTail = next;
-        } else { // have something already
-            _bufferTail.linkNext(next);
-            _bufferTail = next;
-        }
-        int len = fullChunk.length;
-        _bufferedEntryCount += len;
-        // double the size for small chunks
-        if (len < SMALL_CHUNK_SIZE) {
-            len += len;
-        } else { // but by +25% for larger (to limit overhead)
-            len += (len >> 2);
-        }
-        return new Object[len];
-    }
-
-    /**
-     * Method called to indicate that the buffering process is now
-     * complete; and to construct a combined exactly-sized result
-     * array. Additionally the buffer itself will be reset to
-     * reduce memory retention.
-     *<p>
-     * Resulting array will be of generic <code>Object[]</code> type:
-     * if a typed array is needed, use the method with additional
-     * type argument.
-     */
-    public Object[] completeAndClearBuffer(Object[] lastChunk, int lastChunkEntries)
-    {
-        int totalSize = lastChunkEntries + _bufferedEntryCount;
-        Object[] result = new Object[totalSize];
-        _copyTo(result, totalSize, lastChunk, lastChunkEntries);
-        return result;
-    }
-
-    /**
-     * Type-safe alternative to
-     * {@link #completeAndClearBuffer(Object[], int)}, to allow
-     * for constructing explicitly typed result array.
-     *
-     * @param componentType Type of elements included in the buffer. Will be
-     *   used for constructing the result array.
-     */
-    public <T> T[] completeAndClearBuffer(Object[] lastChunk, int lastChunkEntries, Class<T> componentType)
-    {
-       int totalSize = lastChunkEntries + _bufferedEntryCount;
- 	   @SuppressWarnings("unchecked")
-        T[] result = (T[]) Array.newInstance(componentType, totalSize);
-        _copyTo(result, totalSize, lastChunk, lastChunkEntries);
-        _reset();
-        return result;
-    }
-
-    /**
-     * Another
-     * 
-     * @since 1.6
-     */
-    public void completeAndClearBuffer(Object[] lastChunk, int lastChunkEntries, List<Object> resultList)
-    {
-        for (Node n = _bufferHead; n != null; n = n.next()) {
-            Object[] curr = n.getData();
-            for (int i = 0, len = curr.length; i < len; ++i) {
-                resultList.add(curr[i]);
-            }
-        }
-        // and then the last one
-        for (int i = 0; i < lastChunkEntries; ++i) {
-            resultList.add(lastChunk[i]);
-        }
-    }
-    
-    /**
-     * Helper method that can be used to check how much free capacity
-     * will this instance start with. Can be used to choose the best
-     * instance to reuse, based on size of reusable object chunk
-     * buffer holds reference to.
-     */
-    public int initialCapacity()
-    {
-        return (_freeBuffer == null) ? 0 : _freeBuffer.length;
-    }
-
-    /**
-     * Method that can be used to check how many Objects have been buffered
-     * within this buffer.
-     */
-    public int bufferedSize() { return _bufferedEntryCount; }
-
-    /*
-    /**********************************************************
-    /* Internal methods
-    /**********************************************************
-     */
-
-    protected void _reset()
-    {
-        // can we reuse the last (and thereby biggest) array for next time?
-        if (_bufferTail != null) {
-            _freeBuffer = _bufferTail.getData();
-        }
-        // either way, must discard current contents
-        _bufferHead = _bufferTail = null;
-        _bufferedEntryCount = 0;
-    }
-
-    protected final void _copyTo(Object resultArray, int totalSize,
-                                 Object[] lastChunk, int lastChunkEntries)
-    {
-        int ptr = 0;
-
-        for (Node n = _bufferHead; n != null; n = n.next()) {
-            Object[] curr = n.getData();
-            int len = curr.length;
-            System.arraycopy(curr, 0, resultArray, ptr, len);
-            ptr += len;
-        }
-        System.arraycopy(lastChunk, 0, resultArray, ptr, lastChunkEntries);
-        ptr += lastChunkEntries;
-
-        // sanity check (could have failed earlier due to out-of-bounds, too)
-        if (ptr != totalSize) {
-            throw new IllegalStateException("Should have gotten "+totalSize+" entries, got "+ptr);
-        }
-    }
-
-    /*
-    /**********************************************************
-    /* Helper classes
-    /**********************************************************
-     */
-
-    /**
-     * Helper class used to store actual data, in a linked list.
-     */
-    final static class Node
-    {
-        /**
-         * Data stored in this node. Array is considered to be full.
-         */
-        final Object[] _data;
-
-        Node _next;
-
-        public Node(Object[] data) {
-            _data = data;
-        }
-
-        public Object[] getData() { return _data; }
-
-        public Node next() { return _next; }
-
-        public void linkNext(Node next)
-        {
-            if (_next != null) { // sanity check
-                throw new IllegalStateException();
-            }
-            _next = next;
-        }
-    }
-}