UIAutomatorRemoteAndroidTestRunner.java

package com.android.ddmlib.testrunner;

import java.io.IOException;
import java.util.AbstractMap;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.Properties;
import java.util.Map.Entry;

import org.apache.commons.lang3.StringUtils;

import com.android.ddmlib.AdbCommandRejectedException;
import com.android.ddmlib.IDevice;
import com.android.ddmlib.Log;
import com.android.ddmlib.ShellCommandUnresponsiveException;
import com.android.ddmlib.TimeoutException;

/**
 * Runs a UI Automator test command remotely and reports results.
 */
public class UIAutomatorRemoteAndroidTestRunner
{

    private IDevice mRemoteDevice;
    // default to no timeout
    private int mMaxTimeToOutputResponse = 0;
    private String mRunName = null;

    /** map of name-value instrumentation argument pairs */
    private List< Entry< String, String >> mArgList;
    private InstrumentationResultParser mParser;
    private final String jarFile;
    private boolean noHup;
    private Object dumpFilePath;

    private static final String LOG_TAG = "RemoteAndroidTest";

    // defined instrumentation argument names
    private static final String CLASS_ARG_NAME = "class";
    private static final String DEBUG_ARG_NAME = "debug";

    public UIAutomatorRemoteAndroidTestRunner( String jarFile, IDevice remoteDevice )
    {
        this.jarFile = jarFile;
        mRemoteDevice = remoteDevice;
        mArgList = new ArrayList< Entry< String, String >>();
    }

    /**
     * {@inheritDoc}
     */

    public void setTestClassOrMethods( String[] testClassOrMethods )
    {
        for ( String testClassOrMethod : testClassOrMethods )
        {
            addInstrumentationArg( CLASS_ARG_NAME, testClassOrMethod );
        }
    }

    /**
     * {@inheritDoc}
     */
    public void addInstrumentationArg( String name, String value )
    {
        if ( name == null || value == null )
        {
            throw new IllegalArgumentException( "name or value arguments cannot be null" );
        }
        mArgList.add( new AbstractMap.SimpleImmutableEntry< String, String >( name, value ) );
    }

    /**
     * {@inheritDoc}
     */

    public void addBooleanArg( String name, boolean value )
    {
        addInstrumentationArg( name, Boolean.toString( value ) );
    }

    /**
     * {@inheritDoc}
     */

    /**
     * {@inheritDoc}
     */

    public void setDebug( boolean debug )
    {
        addBooleanArg( DEBUG_ARG_NAME, debug );
    }

    public void setNoHup( boolean noHup )
    {
        this.noHup = noHup;
    }

    public void setDumpFilePath( String dumpFilePath )
    {
        this.dumpFilePath = dumpFilePath;
    }

    /**
     * {@inheritDoc}
     */

    public void setMaxtimeToOutputResponse( int maxTimeToOutputResponse )
    {
        mMaxTimeToOutputResponse = maxTimeToOutputResponse;
    }

    /**
     * {@inheritDoc}
     */

    public void setRunName( String runName )
    {
        mRunName = runName;
    }

    /**
     * {@inheritDoc}
     */

    public void run( ITestRunListener... listeners ) throws TimeoutException, AdbCommandRejectedException,
            ShellCommandUnresponsiveException, IOException
    {
        run( Arrays.asList( listeners ) );
    }

    /**
     * {@inheritDoc}
     */
    public void run( Collection< ITestRunListener > listeners ) throws TimeoutException, AdbCommandRejectedException,
            ShellCommandUnresponsiveException, IOException
    {
        final String runCaseCommandStr = String.format( "uiautomator runtest %1$s %2$s", jarFile, buildArgsCommand() );
        Log.i( LOG_TAG, String.format( "Running %1$s on %2$s", runCaseCommandStr, mRemoteDevice.getSerialNumber() ) );
        mParser = new InstrumentationResultParser( mRunName, listeners );

        try
        {
            mRemoteDevice.executeShellCommand( runCaseCommandStr, mParser, mMaxTimeToOutputResponse );
        }
        catch ( IOException e )
        {
            Log.w( LOG_TAG, String.format( "IOException %1$s when running tests %2$s on %3$s", e.toString(), jarFile,
                    mRemoteDevice.getSerialNumber() ) );
            // rely on parser to communicate results to listeners
            mParser.handleTestRunFailed( e.toString() );
            throw e;
        }
        catch ( ShellCommandUnresponsiveException e )
        {
            Log.w( LOG_TAG,
                    String.format( "ShellCommandUnresponsiveException %1$s when running tests %2$s on %3$s",
                            e.toString(), jarFile, mRemoteDevice.getSerialNumber() ) );
            mParser.handleTestRunFailed( String.format( "Failed to receive adb shell test output within %1$d ms. "
                    + "Test may have timed out, or adb connection to device became unresponsive",
                    mMaxTimeToOutputResponse ) );
            throw e;
        }
        catch ( TimeoutException e )
        {
            Log.w( LOG_TAG,
                    String.format( "TimeoutException when running tests %1$s on %2$s", jarFile,
                            mRemoteDevice.getSerialNumber() ) );
            mParser.handleTestRunFailed( e.toString() );
            throw e;
        }
        catch ( AdbCommandRejectedException e )
        {
            Log.w( LOG_TAG, String.format( "AdbCommandRejectedException %1$s when running tests %2$s on %3$s",
                    e.toString(), jarFile, mRemoteDevice.getSerialNumber() ) );
            mParser.handleTestRunFailed( e.toString() );
            throw e;
        }
    }

    /**
     * {@inheritDoc}
     */
    public void cancel()
    {
        if ( mParser != null )
        {
            mParser.cancel();
        }
    }

    /**
     * Returns the full instrumentation command line syntax for the provided instrumentation arguments. Returns an empty
     * string if no arguments were specified.
     */
    private String buildArgsCommand()
    {
        StringBuilder commandBuilder = new StringBuilder();
        for ( Entry< String, String > argPair : mArgList )
        {
            final String argCmd = String.format( " -e %1$s %2$s", argPair.getKey(), argPair.getValue() );
            commandBuilder.append( argCmd );
        }

        if ( noHup )
        {
            commandBuilder.append( " --nohup" );
        }

        if ( dumpFilePath != null )
        {
            commandBuilder.append( " dump " + dumpFilePath );
        }
        return commandBuilder.toString();
    }
    
    /**
     * Adds instrumentation arguments from userProperties from keys with the propertiesKeyPrefix prefix.
     * 
     * @param userProperties
     * @param propertiesKeyPrefix
     */
    public void setUserProperties( Properties userProperties, String propertiesKeyPrefix )
    {
        if ( userProperties == null )
        {
            throw new IllegalArgumentException( "userProperties  cannot be null" );
        }
        
        if ( StringUtils.isBlank( propertiesKeyPrefix ) )
        {
            //propertiesPrefix is blank, ignore all properties
            return;
        }
        
        for ( Entry< Object, Object > property : userProperties.entrySet() )
        {
            String name = (String) property.getKey();
            
            //Check if the key starts with the parameterPrefix
            if ( StringUtils.startsWith( name, propertiesKeyPrefix ) )
            {
                String value = (String) property.getValue();
                
                //Remove the prefix
                name = StringUtils.substring( name,
                        StringUtils.length( propertiesKeyPrefix ),
                        StringUtils.length( name ) );
                
                // Verify so the key isn't blank after substring
                if ( StringUtils.isNotBlank( name ) )
                {
                    //Now its safe to add the parameter
                    addInstrumentationArg( name, value );
                }
            }
        }
    }
}