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.HashMap;
   import java.util.List;
  import java.util.Map.Entry;
  
  import com.android.ddmlib.AdbCommandRejectedException;
  import com.android.ddmlib.IDevice;
  import com.android.ddmlib.Log;
  import com.android.ddmlib.MultiLineReceiver;
  import com.android.ddmlib.ShellCommandUnresponsiveException;
  import com.android.ddmlib.TimeoutException;
  
  /**
   * Runs a Monkey test command remotely and reports results.
   */
  public class MonkeyTestRunner
  {
  
      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 MonkeyResultParser mParser;
      private final int eventCount;
      private boolean ignoreCrashes;
      private boolean debugNoEvents;
      private boolean hprof;
      private boolean ignoreTimeouts;
      private boolean ignoreSecurityExceptions;
      private boolean killProcessAfterError;
      private boolean monitorNativeCrashes;
  
      private static final String LOG_TAG = "RemoteAndroidTest";
  
      // defined instrumentation argument names
      private static final String SEED_ARG_NAME = "-s";
      private static final String THROTTLE_ARG_NAME = "--throttle";
      private static final String PERCENT_TOUCH_ARG_NAME = "--pct-touch";
      private static final String PERCENT_MOTION_ARG_NAME = "--pct-motion";
      private static final String PERCENT_TRACKBALL_ARG_NAME = "--pct-trackball";
      private static final String PERCENT_NAV_ARG_NAME = "--pct-nav";
      private static final String PERCENT_MAJORNAV_ARG_NAME = "--pct-majornav";
      private static final String PERCENT_SYSKEYS_ARG_NAME = "--pct-syskeys";
      private static final String PERCENT_APPSWITCH_ARG_NAME = "--pct-appswitch";
      private static final String PERCENT_ANYEVENT_ARG_NAME = "--pct-anyevent";
      private static final String PACKAGE_ARG_NAME = "-p";
      private static final String CATEGORY_ARG_NAME = "-c";
  
      public MonkeyTestRunner( int eventCount, IDevice remoteDevice )
      {
          this.eventCount = eventCount;
          mRemoteDevice = remoteDevice;
          mArgList = new ArrayList< Entry< String, String >>();
      }
  
      /**
       * {@inheritDoc}
       */
      public void addArg( 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 )
      {
          addArg( name, Boolean.toString( value ) );
      }
  
      /**
       * {@inheritDoc}
       */
      public void addLongArg( String name, long value )
      {
          addArg( name, Long.toString( value ) );
      }
  
      public void setSeed( long seed )
      {
          addLongArg( SEED_ARG_NAME, seed );
      }
  
      public void setThrottle( long throttle )
     {
         addLongArg( THROTTLE_ARG_NAME, throttle );
     }
 
     public void setPercentTouch( long percent )
     {
         addLongArg( PERCENT_TOUCH_ARG_NAME, percent );
     }
 
     public void setPercentMotion( long percent )
     {
         addLongArg( PERCENT_MOTION_ARG_NAME, percent );
     }
 
     public void setPercentTrackball( long percent )
     {
         addLongArg( PERCENT_TRACKBALL_ARG_NAME, percent );
     }
 
     public void setPercentNav( long percent )
     {
         addLongArg( PERCENT_NAV_ARG_NAME, percent );
     }
 
     public void setPercentMajorNav( long percent )
     {
         addLongArg( PERCENT_MAJORNAV_ARG_NAME, percent );
     }
 
     public void setPercentSyskeys( long percent )
     {
         addLongArg( PERCENT_SYSKEYS_ARG_NAME, percent );
     }
 
     public void setPercentAppswitch( long percent )
     {
         addLongArg( PERCENT_APPSWITCH_ARG_NAME, percent );
     }
 
     public void setPercentAnyEvent( int percent )
     {
         addLongArg( PERCENT_ANYEVENT_ARG_NAME, percent );
     }
 
     public void setPackages( String[] packages )
     {
         for ( String packageName : packages )
         {
             addArg( PACKAGE_ARG_NAME, packageName );
         }
     }
 
     public void setCategories( String[] categories )
     {
         for ( String category : categories )
         {
             addArg( CATEGORY_ARG_NAME, category );
         }
     }
 
     public void setDebugNoEvents( boolean debugNoEvents )
     {
         this.debugNoEvents = debugNoEvents;
     }
 
     public void setHprof( boolean hprof )
     {
         this.hprof = hprof;
     }
 
     public void setIgnoreCrashes( boolean ignoreCrashes )
     {
         this.ignoreCrashes = ignoreCrashes;
     }
 
     public void setIgnoreTimeouts( boolean ignoreTimeouts )
     {
         this.ignoreTimeouts = ignoreTimeouts;
     }
 
     public void setIgnoreSecurityExceptions( boolean ignoreSecurityExceptions )
     {
         this.ignoreSecurityExceptions = ignoreSecurityExceptions;
     }
 
     public void setKillProcessAfterError( boolean killProcessAfterError )
     {
         this.killProcessAfterError = killProcessAfterError;
     }
 
     public void setMonitorNativeCrash( boolean monitorNativeCrashes )
     {
         this.monitorNativeCrashes = monitorNativeCrashes;
     }
 
     /**
      * {@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( "monkey -v -v -v %1$s %2$s", buildArgsCommand(),
                 Long.toString( eventCount ) );
         Log.i( LOG_TAG, String.format( "Running %1$s on %2$s", runCaseCommandStr, mRemoteDevice.getSerialNumber() ) );
         mParser = new MonkeyResultParser( mRunName, listeners );
 
         try
         {
             mRemoteDevice.executeShellCommand( runCaseCommandStr, mParser, mMaxTimeToOutputResponse );
         }
         catch ( IOException e )
         {
             Log.w( LOG_TAG,
                     String.format( "IOException %1$s when running monkey tests on %3$s", e.toString(),
                             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 monkey tests on %3$s",
                             e.toString(), 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 monkey tests on %2$s",
                             mRemoteDevice.getSerialNumber() ) );
             mParser.handleTestRunFailed( e.toString() );
             throw e;
         }
         catch ( AdbCommandRejectedException e )
         {
             Log.w( LOG_TAG,
                     String.format( "AdbCommandRejectedException %1$s when running monkey tests %2$s on %3$s",
                             e.toString(), 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( " %1$s %2$s", argPair.getKey(), argPair.getValue() );
             commandBuilder.append( argCmd );
         }
 
         if ( debugNoEvents )
         {
             commandBuilder.append( " --dbg-no-events" );
         }
         if ( hprof )
         {
             commandBuilder.append( " --hprof" );
         }
         if ( ignoreCrashes )
         {
             commandBuilder.append( " --ignore-crashes" );
         }
         if ( ignoreTimeouts )
         {
             commandBuilder.append( " --ignore-timeouts" );
         }
         if ( ignoreSecurityExceptions )
         {
             commandBuilder.append( " --ignore-security-exceptions" );
         }
         if ( killProcessAfterError )
         {
             commandBuilder.append( " --kill-process-after-error" );
         }
         if ( monitorNativeCrashes )
         {
             commandBuilder.append( " --monitor-native-crashes" );
         }
         return commandBuilder.toString();
     }
 
     private class MonkeyResultParser extends MultiLineReceiver
     {
 
         private static final String CRASH_KEY = "// CRASH:";
         private static final String SHORT_MESSAGE_KEY = "// Short Msg:";
         private static final String LONG_MESSAGE_KEY = "// Long Msg:";
         private static final String BUILD_LABEL_KEY = "// Build Label:";
         private static final String BUILD_CHANGELIST_KEY = "// Build Changelist:";
         private static final String BUILD_TIME_KEY = "// Build Time:";
         private static final String EMPTY_KEY = "//";
         private static final String SENDING_KEY = ":Sending";
         private static final String SWITCHING_KEY = ":Switch";
         private static final String MONKEY_KEY = ":Monkey:";
 
         private final Collection< ITestRunListener > mTestListeners;
 
         private String runName;
         private boolean canceled;
         private TestIdentifier mCurrentTestIndentifier;
         private long elapsedTime;
         private HashMap< String, String > runMetrics = new HashMap< String, String >();
 
         private MonkeyResultParser( String runName, Collection< ITestRunListener > listeners )
         {
             this.runName = runName;
             mTestListeners = new ArrayList< ITestRunListener >( listeners );
         }
 
         public void cancel()
         {
             canceled = true;
         }
 
         @Override
         public boolean isCancelled()
         {
             return canceled;
         }
 
         @Override
         public void done()
         {
             handleTestEnd();
             handleTestRunEnded();
             super.done();
         }
 
         @Override
         public void processNewLines( String[] lines )
         {
             for ( int indexLine = 0; indexLine < lines.length; indexLine++ )
             {
                 String line = lines[ indexLine ];
                 Log.v( "monkey receiver:" + runName, line );
 
                 if ( line.startsWith( MONKEY_KEY ) )
                 {
                     handleTestRunStarted();
                 }
                 if ( line.startsWith( SHORT_MESSAGE_KEY ) )
                 {
                     runMetrics.put( "ShortMsg", line.substring( SHORT_MESSAGE_KEY.length() - 1 ) );
                 }
                 if ( line.startsWith( LONG_MESSAGE_KEY ) )
                 {
                     runMetrics.put( "LongMsg", line.substring( LONG_MESSAGE_KEY.length() - 1 ) );
                 }
                 if ( line.startsWith( BUILD_LABEL_KEY ) )
                 {
                     runMetrics.put( "BuildLabel", line.substring( BUILD_LABEL_KEY.length() - 1 ) );
                 }
                 if ( line.startsWith( BUILD_CHANGELIST_KEY ) )
                 {
                     runMetrics.put( "BuildChangeList", line.substring( BUILD_CHANGELIST_KEY.length() - 1 ) );
                 }
                 if ( line.startsWith( BUILD_TIME_KEY ) )
                 {
                     runMetrics.put( "BuildTime", line.substring( BUILD_TIME_KEY.length() - 1 ) );
                 }
 
                 if ( line.startsWith( SENDING_KEY ) || line.startsWith( SWITCHING_KEY ) )
                 {
                     handleTestEnd();
                     handleTestStarted( line );
                 }
 
                 if ( line.startsWith( CRASH_KEY ) )
                 {
                     Log.d( "monkey received crash:", line );
                     indexLine = handleCrash( lines, indexLine );
                     handleTestEnd();
                 }
             }
         }
 
         private void handleTestRunStarted()
         {
             elapsedTime = System.currentTimeMillis();
             for ( ITestRunListener listener : mTestListeners )
             {
                 listener.testRunStarted( mRunName, eventCount );
             }
         }
 
         public void handleTestRunFailed( String error )
         {
             for ( ITestRunListener listener : mTestListeners )
             {
                 listener.testRunFailed( error );
             }
         }
 
         private void handleTestRunEnded()
         {
             elapsedTime = System.currentTimeMillis() - elapsedTime;
 
             for ( ITestRunListener listener : mTestListeners )
             {
                 listener.testRunEnded( elapsedTime, runMetrics );
             }
         }
 
         private void handleTestStarted( String line )
         {
             mCurrentTestIndentifier = new TestIdentifier( "MonkeyTest", line );
             for ( ITestRunListener listener : mTestListeners )
             {
                 listener.testStarted( mCurrentTestIndentifier );
             }
         }
 
         private void handleTestEnd()
         {
             if ( mCurrentTestIndentifier != null )
             {
                 for ( ITestRunListener listener : mTestListeners )
                 {
                     listener.testEnded( mCurrentTestIndentifier, new HashMap< String, String >() );
                 }
                 mCurrentTestIndentifier = null;
             }
         }
 
         private int handleCrash( String[] lines, int indexLine )
         {
             StringBuilder errorBuilder = new StringBuilder();
             boolean errorEnd = false;
             boolean errorStart = false;
             do
             {
                 String line = lines[ indexLine ];
                 if ( line.startsWith( BUILD_TIME_KEY ) )
                 {
                     errorStart = true;
                 }
                 indexLine++;
             } while ( !errorStart );
 
             // indexLine point to the first line of the stack trace now
             int firstLine = indexLine;
 
             do
             {
                 String line = lines[ indexLine ];
                 if ( line.equals( EMPTY_KEY ) )
                 {
                     errorEnd = true;
                 }
                 else
                 {
                     String stackTraceLine = lines[ indexLine ];
                     stackTraceLine = stackTraceLine.substring( indexLine == firstLine ? 3 : 4 );
                     errorBuilder.append( stackTraceLine ).append( "\n" );
                 }
                 indexLine++;
             } while ( !errorEnd );
 
             String trace = errorBuilder.toString();
 
             for ( ITestRunListener listener : mTestListeners )
             {
                 listener.testFailed( mCurrentTestIndentifier, trace );
             }
             mCurrentTestIndentifier = null;
             return indexLine;
         }
     }
 }