testautoa 0.4.0.pre16

data/test-server/instrumentation-backend/src/com/jayway/android/robotium/solo/MapViewUtils.java

@@ -0,0 +1,328 @@
+package com.jayway.android.robotium.solo;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import android.app.Instrumentation;
+import android.graphics.PixelFormat;
+import android.graphics.Point;
+import android.graphics.Rect;
+import android.graphics.Region;
+import android.os.SystemClock;
+import android.util.Log;
+
+import com.google.android.maps.GeoPoint;
+import com.google.android.maps.ItemizedOverlay;
+import com.google.android.maps.MapView;
+import com.google.android.maps.Overlay;
+import com.google.android.maps.OverlayItem;
+import com.google.android.maps.Projection;
+
+/**
+ * @author Nicholas Albion
+ */
+public class MapViewUtils {
+	private final Instrumentation inst;
+	private final ViewFetcher viewFetcher;
+	private final Sleeper sleeper;
+	private final Waiter waiter;
+	
+	/**
+	 * Constructs this object.
+	 *
+	 * @param inst the {@code Instrumentation} instance.
+	 * @param viewFetcher the {@code ViewFetcher} instance.
+	 * @param sleeper the {@code Sleeper} instance
+	 */
+	public MapViewUtils( Instrumentation inst, ViewFetcher viewFetcher, Sleeper sleeper, Waiter waiter ) {
+		this.inst = inst;
+		this.viewFetcher = viewFetcher;
+		this.sleeper = sleeper;
+		this.waiter = waiter;
+	}
+	
+	private MapView getMapView() {
+		return waiter.waitForAndGetView( 0, MapView.class );
+//		final ArrayList<View> viewList = RobotiumUtils.removeInvisibleViews(viewFetcher.getAllViews(true));
+//		ArrayList<MapView> maps = RobotiumUtils.filterViews( MapView.class, viewList );
+//		if( maps.size() == 0 ) {
+//			return null;
+//		}
+//		return maps.get(0);
+	}
+	
+	/**
+	 * @param lat
+	 * @param lon
+	 */
+	public void setCenter( double lat, double lon ) {
+		MapView mapView = getMapView();
+		mapView.getController().setCenter( new GeoPoint((int)(lat * 1E6), (int)(lon * 1E6)) );
+	}
+	
+	public double[] getMapCenter() {
+		MapView mapView = getMapView();
+		GeoPoint center = mapView.getMapCenter();
+		return new double[] { center.getLatitudeE6() / 1E6, center.getLongitudeE6() / 1E6 };
+	}
+	
+	/**
+	 * @param lat
+	 * @param lon
+	 */
+	public void panTo( double lat, double lon ) {
+		MapView mapView = getMapView();
+		mapView.getController().animateTo( new GeoPoint((int)(lat * 1E6), (int)(lon * 1E6)) );
+	}
+	
+	public int getZoom() {
+		MapView mapView = getMapView();
+		return mapView.getZoomLevel();
+	}
+	
+	public int setZoom( int zoomLevel ) {
+		MapView mapView = getMapView();
+		mapView.getController().stopAnimation(true);
+		return mapView.getController().setZoom( zoomLevel );
+	}
+		
+	public boolean zoomIn() {
+		MapView mapView = getMapView();
+		return mapView.getController().zoomIn();
+	}
+	
+	public boolean zoomOut() {
+		MapView mapView = getMapView();
+		return mapView.getController().zoomOut();
+	}
+	
+	/**
+	 * @return [top, right, bottom, left] in decimal degrees
+	 */
+	public List<String> getBounds() {
+		MapView mapView = getMapView();
+		GeoPoint center = mapView.getMapCenter();
+		int latCtr = center.getLatitudeE6();
+		int lonCtr = center.getLongitudeE6();
+		int latSpan = mapView.getLatitudeSpan() >> 1;
+		int lonSpan = mapView.getLongitudeSpan() >> 1;
+		
+		Log.i("MapView", "latSpan: " + latSpan);
+		
+		ArrayList<String> bounds = new ArrayList<String>(4);
+		bounds.add( Double.toString( (latCtr + latSpan) / 1E6 ) );
+		bounds.add( Double.toString( (lonCtr + lonSpan) / 1E6 ) );
+		bounds.add( Double.toString( (latCtr - latSpan) / 1E6 ) );
+		bounds.add( Double.toString( (lonCtr - lonSpan) / 1E6 ) );
+		return bounds;
+	}
+	
+	/**
+	 * @return A list of JSON strings representing the markers.
+	 * @see #getMarkerItem(String)
+	 * @see MapViewUtils#toString(OverlayItem, boolean)
+	 */
+	public List<String> getMarkerItems() {
+		ArrayList<String> markers = new ArrayList<String>();
+		
+		MapView mapView = getMapView();
+		for( Overlay overlay : mapView.getOverlays() ) {
+			if( overlay instanceof ItemizedOverlay ) {
+				@SuppressWarnings("rawtypes")
+				ItemizedOverlay markerOverlay = ((ItemizedOverlay)overlay);
+				int noOfMarkers = markerOverlay.size();
+				int lastFocused = markerOverlay.getLastFocusedIndex();
+				
+				Log.i("MapView", "Overlay " + markerOverlay + " has " + noOfMarkers + " markers");
+				markers.ensureCapacity( markers.size() + noOfMarkers );
+				for( int i = 0; i < noOfMarkers; i++ ) {
+					OverlayItem item = markerOverlay.getItem(i);
+					String str = toString( item, lastFocused == i );
+					markers.add( str );
+				}
+			}
+		}
+		
+		Log.i("MapView", "Sending response with " + markers.size() + " markers");
+		return markers;
+	}
+	
+	/**
+	 * @param title
+	 * @return null or (for example) {"latitude":-33.123456, "longitude":151.123456, "title":"My Marker", "snippet":"More Info about my marker"}
+	 */
+	public String getMarkerItem( String title ) {
+		ArrayList<String> markers = new ArrayList<String>();
+		
+		MapView mapView = getMapView();
+		for( Overlay overlay : mapView.getOverlays() ) {
+			if( overlay instanceof ItemizedOverlay ) {
+				@SuppressWarnings("rawtypes")
+				ItemizedOverlay markerOverlay = ((ItemizedOverlay)overlay);
+				int noOfMarkers = markerOverlay.size();
+				int lastFocused = markerOverlay.getLastFocusedIndex();
+				
+				Log.i("MapView", "Overlay " + markerOverlay + " has " + noOfMarkers + " markers");
+				markers.ensureCapacity( markers.size() + noOfMarkers );
+				for( int i = 0; i < noOfMarkers; i++ ) {
+					OverlayItem item = markerOverlay.getItem(i);
+					
+					if( title.equals(item.getTitle()) ) {
+						return toString( item, lastFocused == i );
+					}
+				}
+			}
+		}
+		return null;
+	}
+	
+	/**
+	 * @param title
+	 * @param timeout in ms
+	 * @return true if the marker was found and tapped upon
+	 */
+	public boolean tapMarkerItem( String title, long timeout ) {		
+		final long endTime = SystemClock.uptimeMillis() + timeout;
+		Log.i("TapMarker", "Looking for marker '" + title + "'");
+		
+		while( SystemClock.uptimeMillis() < endTime ) {
+			MapView mapView = getMapView();
+			for( Overlay overlay : mapView.getOverlays() ) {
+				if( overlay instanceof ItemizedOverlay ) {
+					@SuppressWarnings("rawtypes")
+					ItemizedOverlay markerOverlay = ((ItemizedOverlay)overlay);
+					int noOfMarkers = markerOverlay.size();
+					for( int i = 0; i < noOfMarkers; i++ ) {
+						OverlayItem item = markerOverlay.getItem(i);
+						String itemTitle = item.getTitle();
+//						Log.i("TapMarker", "  item title: " + itemTitle);
+						if( title.equals( itemTitle ) ) {
+							markerOverlay.onTap( item.getPoint(), mapView );
+							return true;
+						}
+					}
+				}
+			}
+			
+			Log.i("TapMarker", "Could not find marker '" + title + "', try again in a moment");
+			sleeper.sleep();
+		}
+		
+		Log.i("TapMarker", "Nope, could not find marker '" + title + "'");
+		return false;
+	}
+	
+	/**
+	 * @param step - number of pixels to step when searching for an empty piece of screen
+	 * @return true if it was possible to tap on the screen without tapping on a marker
+	 */
+	 @SuppressWarnings("rawtypes")
+	public boolean tapAwayFromMarkerItems( int step ) {		
+		MapView mapView = getMapView();
+		Projection proj = mapView.getProjection();
+		ItemizedOverlay overlayToTap = null;
+		Point markerPoint = new Point();
+		int w = mapView.getWidth();
+		int h = mapView.getHeight();
+		
+		for( int x = 0; x < w; x += step ) {
+NEXT_Y:			
+			for( int y = 0; y < h; y += step ) {
+				boolean tappedMarkerAtPoint = false;
+				for( Overlay overlay : mapView.getOverlays() ) {
+					if( overlay instanceof ItemizedOverlay ) {						
+						ItemizedOverlay markerOverlay = ((ItemizedOverlay)overlay);		
+//						if( markerOverlay.onTap( geoPoint, mapView ) ) {
+//							tappedMarkerAtPoint = true;
+//							break;
+//						}
+						int noOfMarkers = markerOverlay.size();
+						for( int i = 0; i < noOfMarkers; i++ ) {
+							OverlayItem item = markerOverlay.getItem(i);
+							proj.toPixels( item.getPoint(), markerPoint );
+							Rect markerBounds = item.getMarker(0).getBounds();
+							markerBounds.offset( markerPoint.x, markerPoint.y );
+							
+							Log.d("TapAwayFromMarkers", "markerBounds: " + markerBounds);
+							if( markerBounds.contains(x, y) ) {
+								Log.d("TapAwayFromMarkers", "Tapping at " + x + ", " + y + " would tap on " + item.getTitle());
+								continue NEXT_Y;
+							}
+						}
+						overlayToTap = markerOverlay;
+					}
+				}
+				
+				if( tappedMarkerAtPoint == false && overlayToTap != null ) {
+					Log.i("TapAwayFromMarkers", "Tapping away from markers at " + x + ", " + y);
+					GeoPoint geoPoint = proj.fromPixels(x, y);
+					overlayToTap.onTap(geoPoint, mapView);
+					return true;
+				}
+			}
+		}
+		
+		Log.i("TapMarker", "Nope, could not avoid tapping on any markers");
+		return false;
+	}
+	 
+	/**
+	 * @param item
+	 * @param isLastFocused
+	 * @return eg: {"latitude":-33.123456, "longitude":151.123456, "title":"My Marker", "snippet":"More Info about my marker"}
+	 */
+	private String toString( OverlayItem item, boolean isLastFocused ) {
+		GeoPoint point = item.getPoint();
+		StringBuilder str = new StringBuilder("{\"latitude\":\"").append(Double.toString( point.getLatitudeE6() / 1E6 ))
+				 						.append("\", \"longitude\":\"").append( Double.toString( point.getLongitudeE6() / 1E6 ))
+				 						.append("\", \"title\":\"").append( item.getTitle().replaceAll("\"", "\\\"") );
+		String snippet = item.getSnippet();
+		if( snippet != null && snippet.length() != 0 ) { 
+			str.append("\", \"snippet\":\"").append( snippet.replaceAll("\"", "\\\"") );
+		}
+		if( isLastFocused ) {
+			str.append("\", \"focused\":true");
+		} else {
+			str.append("\"");
+		}
+		
+		appendTransparency( str, item );
+		
+		str.append("}");
+		return str.toString();
+	}
+	
+	private void appendTransparency( StringBuilder str, OverlayItem item ) {
+		StringBuilder transparencyStr = new StringBuilder();  
+		appendTransparency( transparencyStr, item, "default", 0 );
+		appendTransparency( transparencyStr, item, "focused", OverlayItem.ITEM_STATE_FOCUSED_MASK );
+		appendTransparency( transparencyStr, item, "pressed", OverlayItem.ITEM_STATE_PRESSED_MASK );
+		appendTransparency( transparencyStr, item, "selected", OverlayItem.ITEM_STATE_SELECTED_MASK );
+		
+		if( transparencyStr.length() != 0 ) {
+			transparencyStr.deleteCharAt( transparencyStr.length() - 1 );
+			str.append(", \"transparency\":{").append(transparencyStr).append("}");
+		}
+	}
+	
+	private void appendTransparency( StringBuilder str, OverlayItem item, String stateName, int state ) {
+		switch( item.getMarker( OverlayItem.ITEM_STATE_FOCUSED_MASK ).getOpacity() ) {
+		case PixelFormat.UNKNOWN: break;
+		case PixelFormat.TRANSPARENT: 
+			str.append("\"").append(stateName).append("\":\"transparent\",");
+			return;
+		case PixelFormat.TRANSLUCENT: 
+			str.append("\"").append(stateName).append("\":\"translucent\",");
+			return;
+		case PixelFormat.OPAQUE: 
+			str.append("\"").append(stateName).append("\":\"opaque\",");
+			return;
+		}
+		
+		
+		Region region = item.getMarker(state).getTransparentRegion();
+		if( region != null ) {
+			str.append("\"").append(stateName).append("\":true,");
+		}
+	}
+}

data/test-server/instrumentation-backend/src/com/jayway/android/robotium/solo/PublicViewFetcher.java

@@ -0,0 +1,11 @@
+package com.jayway.android.robotium.solo;
+
+import android.app.Activity;
+import android.app.Instrumentation;
+
+public class PublicViewFetcher extends ViewFetcher {
+
+    public PublicViewFetcher(Instrumentation instrumentation, Activity activity) {
+        super(new ActivityUtils(instrumentation, activity, new Sleeper()));
+    }
+}

data/test-server/instrumentation-backend/src/com/jayway/android/robotium/solo/SoloEnhanced.java

@@ -0,0 +1,97 @@
+package com.jayway.android.robotium.solo;
+
+import java.util.List;
+
+import android.app.Activity;
+import android.app.Instrumentation;
+
+public class SoloEnhanced extends Solo {
+//	private Pincher pincher;
+	private MapViewUtils mapViewUtils;
+
+	public SoloEnhanced(Instrumentation instrumentation, Activity activity) {
+		super(instrumentation, activity);
+		this.mapViewUtils = new MapViewUtils(instrumentation, viewFetcher, sleeper, waiter);
+//		this.pincher = new Pincher(instrumentation, viewFetcher);
+	}
+
+	public void setMapCenter( double lat, double lon ) {
+		mapViewUtils.setCenter(lat, lon);
+	}
+	
+	/** @return {lat,lon} */
+	public double[] getMapCenter() {
+		return mapViewUtils.getMapCenter();
+	}
+	
+	public void panMapTo( double lat, double lon ) {
+		mapViewUtils.panTo(lat, lon);
+	}
+	
+	public boolean zoomInOnMap() {
+		return mapViewUtils.zoomIn();
+	}
+	
+	public boolean zoomOutOnMap() {
+		return mapViewUtils.zoomOut();
+	}
+	
+	public int setMapZoom( int zoomLevel ) {
+		return mapViewUtils.setZoom(zoomLevel);
+	}
+	
+	public int getMapZoom() {
+		return mapViewUtils.getZoom();
+	}
+	
+	public List<String> getMapMarkerItems() {
+		return mapViewUtils.getMarkerItems();
+	}
+	
+	public String getMapMarkerItem( String title ) {
+		return mapViewUtils.getMarkerItem( title );
+	}
+
+	/**
+	 * @param title
+	 * @param timeout in ms
+	 * @return
+	 */
+	public boolean tapMapMarkerItem( String title, long timeout ) {
+		return mapViewUtils.tapMarkerItem( title, timeout );
+	}
+	
+	public boolean tapMapAwayFromMarkers( int step ) {
+		return mapViewUtils.tapAwayFromMarkerItems( step );
+	}
+	
+	/**
+	 * @return [top, right, bottom, left] in decimal degrees
+	 */
+	public List<String> getMapBounds() {
+		return mapViewUtils.getBounds();
+	}
+	
+//	/**
+//	 * Sorry, doesn't work yet
+//	 * @param togetherOrApart - {@link Pincher#TOGETHER} or {@link Pincher#APART}
+//	 */
+//	public void pinch(int togetherOrApart) {
+//		switch( togetherOrApart ) {
+//		case Pincher.TOGETHER: pincher.pinch(Pincher.Direction.TOGETHER); break;
+//		case Pincher.APART: pincher.pinch(Pincher.Direction.APART); break;
+//		}
+//	}
+//	
+//	/**
+//	 * Sorry, doesn't work yet
+//	 * @param togetherOrApart - {@link Pincher#TOGETHER} or {@link Pincher#APART}
+//	 * @param view
+//	 */
+//	public void pinch(int togetherOrApart, View view) {
+//		switch( togetherOrApart ) {
+//		case Pincher.TOGETHER: pincher.pinch(Pincher.Direction.TOGETHER, view); break;
+//		case Pincher.APART: pincher.pinch(Pincher.Direction.APART, view); break;
+//		}
+//	}
+}

data/test-server/instrumentation-backend/src/org/antlr/runtime/ANTLRFileStream.java

@@ -0,0 +1,78 @@
+/*
+ [The "BSD license"]
+ Copyright (c) 2005-2009 Terence Parr
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions
+ are met:
+ 1. Redistributions of source code must retain the above copyright
+     notice, this list of conditions and the following disclaimer.
+ 2. Redistributions in binary form must reproduce the above copyright
+     notice, this list of conditions and the following disclaimer in the
+     documentation and/or other materials provided with the distribution.
+ 3. The name of the author may not be used to endorse or promote products
+     derived from this software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+package org.antlr.runtime;
+
+import java.io.*;
+
+/** This is a char buffer stream that is loaded from a file
+ *  all at once when you construct the object.  This looks very
+ *  much like an ANTLReader or ANTLRInputStream, but it's a special case
+ *  since we know the exact size of the object to load.  We can avoid lots
+ *  of data copying. 
+ */
+public class ANTLRFileStream extends ANTLRStringStream {
+	protected String fileName;
+
+	public ANTLRFileStream(String fileName) throws IOException {
+		this(fileName, null);
+	}
+
+	public ANTLRFileStream(String fileName, String encoding) throws IOException {
+		this.fileName = fileName;
+		load(fileName, encoding);
+	}
+
+	public void load(String fileName, String encoding)
+		throws IOException
+	{
+		if ( fileName==null ) {
+			return;
+		}
+		File f = new File(fileName);
+		int size = (int)f.length();
+		InputStreamReader isr;
+		FileInputStream fis = new FileInputStream(fileName);
+		if ( encoding!=null ) {
+			isr = new InputStreamReader(fis, encoding);
+		}
+		else {
+			isr = new InputStreamReader(fis);
+		}
+		try {
+			data = new char[size];
+			super.n = isr.read(data);
+		}
+		finally {
+			isr.close();
+		}
+	}
+
+	public String getSourceName() {
+		return fileName;
+	}
+}

data/test-server/instrumentation-backend/src/org/antlr/runtime/ANTLRInputStream.java

@@ -0,0 +1,70 @@
+/*
+ [The "BSD license"]
+ Copyright (c) 2005-2009 Terence Parr
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions
+ are met:
+ 1. Redistributions of source code must retain the above copyright
+     notice, this list of conditions and the following disclaimer.
+ 2. Redistributions in binary form must reproduce the above copyright
+     notice, this list of conditions and the following disclaimer in the
+     documentation and/or other materials provided with the distribution.
+ 3. The name of the author may not be used to endorse or promote products
+     derived from this software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+package org.antlr.runtime;
+
+import java.io.*;
+
+/** A kind of ReaderStream that pulls from an InputStream.
+ *  Useful for reading from stdin and specifying file encodings etc...
+  */
+public class ANTLRInputStream extends ANTLRReaderStream {
+	public ANTLRInputStream() {
+	}
+
+	public ANTLRInputStream(InputStream input) throws IOException {
+		this(input, null);
+	}
+
+	public ANTLRInputStream(InputStream input, int size) throws IOException {
+		this(input, size, null);
+	}
+
+	public ANTLRInputStream(InputStream input, String encoding) throws IOException {
+		this(input, INITIAL_BUFFER_SIZE, encoding);
+	}
+
+	public ANTLRInputStream(InputStream input, int size, String encoding) throws IOException {
+		this(input, size, READ_BUFFER_SIZE, encoding);
+	}
+
+	public ANTLRInputStream(InputStream input,
+							int size,
+							int readBufferSize,
+							String encoding)
+		throws IOException
+	{
+		InputStreamReader isr;
+		if ( encoding!=null ) {
+			isr = new InputStreamReader(input, encoding);
+		}
+		else {
+			isr = new InputStreamReader(input);
+		}
+		load(isr, size, readBufferSize);
+	}
+}

data/test-server/instrumentation-backend/src/org/antlr/runtime/ANTLRReaderStream.java

@@ -0,0 +1,95 @@
+/*
+ [The "BSD license"]
+ Copyright (c) 2005-2009 Terence Parr
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions
+ are met:
+ 1. Redistributions of source code must retain the above copyright
+     notice, this list of conditions and the following disclaimer.
+ 2. Redistributions in binary form must reproduce the above copyright
+     notice, this list of conditions and the following disclaimer in the
+     documentation and/or other materials provided with the distribution.
+ 3. The name of the author may not be used to endorse or promote products
+     derived from this software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+package org.antlr.runtime;
+
+import java.io.*;
+
+/** Vacuum all input from a Reader and then treat it like a StringStream.
+ *  Manage the buffer manually to avoid unnecessary data copying.
+ *
+ *  If you need encoding, use ANTLRInputStream.
+ */
+public class ANTLRReaderStream extends ANTLRStringStream {
+	public static final int READ_BUFFER_SIZE = 1024;
+	public static final int INITIAL_BUFFER_SIZE = 1024;
+
+	public ANTLRReaderStream() {
+	}
+
+	public ANTLRReaderStream(Reader r) throws IOException {
+		this(r, INITIAL_BUFFER_SIZE, READ_BUFFER_SIZE);
+	}
+
+	public ANTLRReaderStream(Reader r, int size) throws IOException {
+		this(r, size, READ_BUFFER_SIZE);
+	}
+
+	public ANTLRReaderStream(Reader r, int size, int readChunkSize) throws IOException {
+		load(r, size, readChunkSize);
+	}
+
+	public void load(Reader r, int size, int readChunkSize)
+		throws IOException
+	{
+		if ( r==null ) {
+			return;
+		}
+		if ( size<=0 ) {
+			size = INITIAL_BUFFER_SIZE;
+		}
+		if ( readChunkSize<=0 ) {
+			readChunkSize = READ_BUFFER_SIZE;
+		}
+		// System.out.println("load "+size+" in chunks of "+readChunkSize);
+		try {
+			// alloc initial buffer size.
+			data = new char[size];
+			// read all the data in chunks of readChunkSize
+			int numRead=0;
+			int p = 0;
+			do {
+				if ( p+readChunkSize > data.length ) { // overflow?
+					// System.out.println("### overflow p="+p+", data.length="+data.length);
+					char[] newdata = new char[data.length*2]; // resize
+					System.arraycopy(data, 0, newdata, 0, data.length);
+					data = newdata;
+				}
+				numRead = r.read(data, p, readChunkSize);
+				// System.out.println("read "+numRead+" chars; p was "+p+" is now "+(p+numRead));
+				p += numRead;
+			} while (numRead!=-1); // while not EOF
+			// set the actual size of the data available;
+			// EOF subtracted one above in p+=numRead; add one back
+			super.n = p+1;
+			//System.out.println("n="+n);
+		}
+		finally {
+			r.close();
+		}
+	}
+}