Monkey学习笔记

最新推荐文章于 2022-01-12 22:20:20 发布
最新推荐文章于 2022-01-12 22:20:20 发布
阅读量211 收藏
点赞数
分类专栏： Monkey 文章标签： Monkey

1、运行环境

 

base=/system
export CLASSPATH=$base/framework/monkey.jar
trap "" HUP
exec app_process $base/bin com.android.commands.monkey.Monkey $*

 monkey是一个shell脚本，在目录“/system/bin/monkey”下，通过app_process执行monkey.jar

 

2、程序入口

 

public static void main(String[] args) {
        // Set the process name showing in "ps" or "top"
        Process.setArgV0("com.android.commands.monkey");

        int resultCode = (new Monkey()).run(args);
        System.exit(resultCode);
    }

 入口主函数直接调用run方法，里面主要干了三件事

 

  1. 初始化参数
  2. 初始化事件源
  3. 执行事件

3、初始化参数

调用processOptions方法初始化

 

private boolean processOptions() {
        // quick (throwaway) check for unadorned command
        if (mArgs.length < 1) {
            showUsage();
            return false;
        }

        try {
            String opt;
            while ((opt = nextOption()) != null) {
                if (opt.equals("-s")) {
                    mSeed = nextOptionLong("Seed");
                } else if (opt.equals("-p")) {
                    mValidPackages.add(nextOptionData());
                } else if (opt.equals("-c")) {
                    mMainCategories.add(nextOptionData());
                } else if (opt.equals("-v")) {
                    mVerbose += 1;
                } else if (opt.equals("--ignore-crashes")) {
                    mIgnoreCrashes = true;
                } else if (opt.equals("--ignore-timeouts")) {
                    mIgnoreTimeouts = true;
                } else if (opt.equals("--ignore-security-exceptions")) {
                    mIgnoreSecurityExceptions = true;
                } else if (opt.equals("--monitor-native-crashes")) {
                    mMonitorNativeCrashes = true;
                } else if (opt.equals("--ignore-native-crashes")) {
                    mIgnoreNativeCrashes = true;
                } else if (opt.equals("--kill-process-after-error")) {
                    mKillProcessAfterError = true;
                } else if (opt.equals("--hprof")) {
                    mGenerateHprof = true;
                } else if (opt.equals("--pct-touch")) {
                    int i = MonkeySourceRandom.FACTOR_TOUCH;
                    mFactors[i] = -nextOptionLong("touch events percentage");
                } else if (opt.equals("--pct-motion")) {
                    int i = MonkeySourceRandom.FACTOR_MOTION;
                    mFactors[i] = -nextOptionLong("motion events percentage");
                } else if (opt.equals("--pct-trackball")) {
                    int i = MonkeySourceRandom.FACTOR_TRACKBALL;
                    mFactors[i] = -nextOptionLong("trackball events percentage");
                } else if (opt.equals("--pct-rotation")) {
                    int i = MonkeySourceRandom.FACTOR_ROTATION;
                    mFactors[i] = -nextOptionLong("screen rotation events percentage");
                } else if (opt.equals("--pct-syskeys")) {
                    int i = MonkeySourceRandom.FACTOR_SYSOPS;
                    mFactors[i] = -nextOptionLong("system (key) operations percentage");
                } else if (opt.equals("--pct-nav")) {
                    int i = MonkeySourceRandom.FACTOR_NAV;
                    mFactors[i] = -nextOptionLong("nav events percentage");
                } else if (opt.equals("--pct-majornav")) {
                    int i = MonkeySourceRandom.FACTOR_MAJORNAV;
                    mFactors[i] = -nextOptionLong("major nav events percentage");
                } else if (opt.equals("--pct-appswitch")) {
                    int i = MonkeySourceRandom.FACTOR_APPSWITCH;
                    mFactors[i] = -nextOptionLong("app switch events percentage");
                } else if (opt.equals("--pct-flip")) {
                    int i = MonkeySourceRandom.FACTOR_FLIP;
                    mFactors[i] = -nextOptionLong("keyboard flip percentage");
                } else if (opt.equals("--pct-anyevent")) {
                    int i = MonkeySourceRandom.FACTOR_ANYTHING;
                    mFactors[i] = -nextOptionLong("any events percentage");
                } else if (opt.equals("--pct-pinchzoom")) {
                    int i = MonkeySourceRandom.FACTOR_PINCHZOOM;
                    mFactors[i] = -nextOptionLong("pinch zoom events percentage");
                } else if (opt.equals("--pkg-blacklist-file")) {
                    mPkgBlacklistFile = nextOptionData();
                } else if (opt.equals("--pkg-whitelist-file")) {
                    mPkgWhitelistFile = nextOptionData();
                } else if (opt.equals("--throttle")) {
                    mThrottle = nextOptionLong("delay (in milliseconds) to wait between events");
                } else if (opt.equals("--randomize-throttle")) {
                    mRandomizeThrottle = true;
                } else if (opt.equals("--wait-dbg")) {
                    // do nothing - it's caught at the very start of run()
                } else if (opt.equals("--dbg-no-events")) {
                    mSendNoEvents = true;
                } else if (opt.equals("--port")) {
                    mServerPort = (int) nextOptionLong("Server port to listen on for commands");
                } else if (opt.equals("--setup")) {
                    mSetupFileName = nextOptionData();
                } else if (opt.equals("-f")) {
                    mScriptFileNames.add(nextOptionData());
                } else if (opt.equals("--profile-wait")) {
                    mProfileWaitTime = nextOptionLong("Profile delay" +
                                " (in milliseconds) to wait between user action");
                } else if (opt.equals("--device-sleep-time")) {
                    mDeviceSleepTime = nextOptionLong("Device sleep time" +
                                                      "(in milliseconds)");
                } else if (opt.equals("--randomize-script")) {
                    mRandomizeScript = true;
                } else if (opt.equals("--script-log")) {
                    mScriptLog = true;
                } else if (opt.equals("--bugreport")) {
                    mRequestBugreport = true;
                } else if (opt.equals("--periodic-bugreport")){
                    mGetPeriodicBugreport = true;
                    mBugreportFrequency = nextOptionLong("Number of iterations");
                } else if (opt.equals("-h")) {
                    showUsage();
                    return false;
                } else {
                    System.err.println("** Error: Unknown option: " + opt);
                    showUsage();
                    return false;
                }
            }
        } catch (RuntimeException ex) {
            System.err.println("** Error: " + ex.toString());
            showUsage();
            return false;
        }

        // If a server port hasn't been specified, we need to specify
        // a count
        if (mServerPort == -1) {
            String countStr = nextArg();
            if (countStr == null) {
                System.err.println("** Error: Count not specified");
                showUsage();
                return false;
            }

            try {
                mCount = Integer.parseInt(countStr);
            } catch (NumberFormatException e) {
                System.err.println("** Error: Count is not a number");
                showUsage();
                return false;
            }
        }

        return true;
    }

 根据命令行参数初始化对应各个参数

 

4、初始化系统接口

调用getSystemInterfaces初始化系统接口

 

private boolean getSystemInterfaces() {
        mAm = ActivityManagerNative.getDefault();
        if (mAm == null) {
            System.err.println("** Error: Unable to connect to activity manager; is the system "
                    + "running?");
            return false;
        }

        mWm = IWindowManager.Stub.asInterface(ServiceManager.getService("window"));
        if (mWm == null) {
            System.err.println("** Error: Unable to connect to window manager; is the system "
                    + "running?");
            return false;
        }

        mPm = IPackageManager.Stub.asInterface(ServiceManager.getService("package"));
        if (mPm == null) {
            System.err.println("** Error: Unable to connect to package manager; is the system "
                    + "running?");
            return false;
        }

        try {
            mAm.setActivityController(new ActivityController());
            mNetworkMonitor.register(mAm);
        } catch (RemoteException e) {
            System.err.println("** Failed talking with activity manager!");
            return false;
        }

        return true;
    }

 主要初始化IActivityManager、IWindowManager、IPackageManager三个接口，还有添加监控和注册广播

 

 

mAm.setActivityController(new ActivityController());

 

 private class ActivityController extends IActivityController.Stub {
        public boolean activityStarting(Intent intent, String pkg) {
            boolean allow = checkEnteringPackage(pkg) || (DEBUG_ALLOW_ANY_STARTS != 0);
            if (mVerbose > 0) {
                // StrictMode's disk checks end up catching this on
                // userdebug/eng builds due to PrintStream going to a
                // FileOutputStream in the end (perhaps only when
                // redirected to a file?)  So we allow disk writes
                // around this region for the monkey to minimize
                // harmless dropbox uploads from monkeys.
                StrictMode.ThreadPolicy savedPolicy = StrictMode.allowThreadDiskWrites();
                System.out.println("    // " + (allow ? "Allowing" : "Rejecting") + " start of "
                        + intent + " in package " + pkg);
                StrictMode.setThreadPolicy(savedPolicy);
            }
            currentPackage = pkg;
            currentIntent = intent;
            return allow;
        }

        public boolean activityResuming(String pkg) {
            StrictMode.ThreadPolicy savedPolicy = StrictMode.allowThreadDiskWrites();
            System.out.println("    // activityResuming(" + pkg + ")");
            boolean allow = checkEnteringPackage(pkg) || (DEBUG_ALLOW_ANY_RESTARTS != 0);
            if (!allow) {
                if (mVerbose > 0) {
                    System.out.println("    // " + (allow ? "Allowing" : "Rejecting")
                            + " resume of package " + pkg);
                }
            }
            currentPackage = pkg;
            StrictMode.setThreadPolicy(savedPolicy);
            return allow;
        }

        public boolean appCrashed(String processName, int pid,
                String shortMsg, String longMsg,
                long timeMillis, String stackTrace) {
            StrictMode.ThreadPolicy savedPolicy = StrictMode.allowThreadDiskWrites();
            System.err.println("// CRASH: " + processName + " (pid " + pid + ")");
            System.err.println("// Short Msg: " + shortMsg);
            System.err.println("// Long Msg: " + longMsg);
            System.err.println("// Build Label: " + Build.FINGERPRINT);
            System.err.println("// Build Changelist: " + Build.VERSION.INCREMENTAL);
            System.err.println("// Build Time: " + Build.TIME);
            System.err.println("// " + stackTrace.replace("\n", "\n// "));
            StrictMode.setThreadPolicy(savedPolicy);

            if (!mIgnoreCrashes || mRequestBugreport) {
                synchronized (Monkey.this) {
                    if (!mIgnoreCrashes) {
                        mAbort = true;
                    }
                    if (mRequestBugreport){
                        mRequestAppCrashBugreport = true;
                        mReportProcessName = processName;
                    }
                }
                return !mKillProcessAfterError;
            }
            return false;
        }

        public int appEarlyNotResponding(String processName, int pid, String annotation) {
            return 0;
        }

        public int appNotResponding(String processName, int pid, String processStats) {
            StrictMode.ThreadPolicy savedPolicy = StrictMode.allowThreadDiskWrites();
            System.err.println("// NOT RESPONDING: " + processName + " (pid " + pid + ")");
            System.err.println(processStats);
            StrictMode.setThreadPolicy(savedPolicy);

            synchronized (Monkey.this) {
                mRequestAnrTraces = true;
                mRequestDumpsysMemInfo = true;
                mRequestProcRank = true;
                if (mRequestBugreport){
                  mRequestAnrBugreport = true;
                  mReportProcessName = processName;
                }
            }
            if (!mIgnoreTimeouts) {
                synchronized (Monkey.this) {
                    mAbort = true;
                }
            }
            return (mKillProcessAfterError) ? -1 : 1;
        }
    }

 

 public void register(IActivityManager am) throws RemoteException {
        if (LDEBUG) System.out.println("registering Receiver");
        am.registerReceiver(null, null, this, filter, null, UserHandle.USER_ALL); 
    }

 

public void performReceive(Intent intent, int resultCode, String data, Bundle extras,
            boolean ordered, boolean sticky, int sendingUser) throws RemoteException {
        NetworkInfo ni = (NetworkInfo) intent.getParcelableExtra(
                ConnectivityManager.EXTRA_NETWORK_INFO);
        if (LDEBUG) System.out.println("Network state changed: " 
                + "type=" + ni.getType() + ", state="  + ni.getState());
        updateNetworkStats();
        if (NetworkInfo.State.CONNECTED == ni.getState()) {
            if (LDEBUG) System.out.println("Network connected");
            mLastNetworkType = ni.getType();
        } else if (NetworkInfo.State.DISCONNECTED == ni.getState()) {
            if (LDEBUG) System.out.println("Network not connected");
            mLastNetworkType = -1; // unknown since we're disconnected
        }
        mEventTime = SystemClock.elapsedRealtime();
    }

 

 

  • 添加对activity的监控
  • 添加对网络的监控

5、初始化事件源

 

if (mScriptFileNames != null && mScriptFileNames.size() == 1) {
            // script mode, ignore other options
            mEventSource = new MonkeySourceScript(mRandom, mScriptFileNames.get(0), mThrottle,
                    mRandomizeThrottle, mProfileWaitTime, mDeviceSleepTime);
            mEventSource.setVerbose(mVerbose);

            mCountEvents = false;
        } else if (mScriptFileNames != null && mScriptFileNames.size() > 1) {
            if (mSetupFileName != null) {
                mEventSource = new MonkeySourceRandomScript(mSetupFileName,
                        mScriptFileNames, mThrottle, mRandomizeThrottle, mRandom,
                        mProfileWaitTime, mDeviceSleepTime, mRandomizeScript);
                mCount++;
            } else {
                mEventSource = new MonkeySourceRandomScript(mScriptFileNames,
                        mThrottle, mRandomizeThrottle, mRandom,
                        mProfileWaitTime, mDeviceSleepTime, mRandomizeScript);
            }
            mEventSource.setVerbose(mVerbose);
            mCountEvents = false;
        } else if (mServerPort != -1) {
            try {
                mEventSource = new MonkeySourceNetwork(mServerPort);
            } catch (IOException e) {
                System.out.println("Error binding to network socket.");
                return -5;
            }
            mCount = Integer.MAX_VALUE;
        } else {
            // random source by default
            if (mVerbose >= 2) { // check seeding performance
                System.out.println("// Seeded: " + mSeed);
            }
            mEventSource = new MonkeySourceRandom(mRandom, mMainApps, mThrottle, mRandomizeThrottle);
            mEventSource.setVerbose(mVerbose);
            // set any of the factors that has been set
            for (int i = 0; i < MonkeySourceRandom.FACTORZ_COUNT; i++) {
                if (mFactors[i] <= 0.0f) {
                    ((MonkeySourceRandom) mEventSource).setFactors(i, mFactors[i]);
                }
            }

            // in random mode, we start with a random activity
            ((MonkeySourceRandom) mEventSource).generateActivity();
        }

 事件源代表测试数据的事件是从哪里过来的，不同的event source会有不同的类来做相应的实现：

 

  • MonkeySourceNetwork.java: 事件是从网络如monkeyrunner过来的，处理的是界面控制操作事件
  • MonkeySourceNetworkVars.java: 事件也是从网络如monkeyrunner过来的，处理的是getPropery事件
  • MonkeySourceNetworkViews.java:事件也是从网络如monkeyrunner过来的，处理的是Views相关的事件
  • MonkeySourceRandom.java:事件是从monkey内部生成的随机事件集，也就是我们通过命令行启动monkey测试目标app的常用方式
  • MonkeySourceRanodomeScript.java: 上面的随机内部数据源也可以通过指定setup脚本来创建
  • MonkeySourceScript.java: 用户也可以遵循一定的规则编写monkey脚本来驱动monkey进行相关测试，与上面不同的是它不再是随机的

6、执行事件

调用runMonkeyCycles方法循环执行事件

把命令翻译成monkey事件然后放到命令队列EventQueue

以monkey自身随机事件源为例

 

...
((MonkeySourceRandom) mEventSource).generateActivity();
 public void generateActivity() {
        MonkeyActivityEvent e = new MonkeyActivityEvent(mMainApps.get(
                mRandom.nextInt(mMainApps.size())));
        mQ.addLast(e);
    }
 

 

   首先在初始化事件源时，会初始化一个MonkeyActivityEvent事件添加到EventQueue

 

MonkeyEvent ev = mEventSource.getNextEvent();

 

 

public MonkeyEvent getNextEvent() {
        if (mQ.isEmpty()) {
            generateEvents();
        }
        mEventCount++;
        MonkeyEvent e = mQ.getFirst();
        mQ.removeFirst();
        return e;
    }
private void generateEvents() {
        float cls = mRandom.nextFloat();
        int lastKey = 0;

        if (cls < mFactors[FACTOR_TOUCH]) {
            generatePointerEvent(mRandom, GESTURE_TAP);
            return;
        } else if (cls < mFactors[FACTOR_MOTION]) {
            generatePointerEvent(mRandom, GESTURE_DRAG);
            return;
        } else if (cls < mFactors[FACTOR_PINCHZOOM]) {
            generatePointerEvent(mRandom, GESTURE_PINCH_OR_ZOOM);
            return;
        } else if (cls < mFactors[FACTOR_TRACKBALL]) {
            generateTrackballEvent(mRandom);
            return;
        } else if (cls < mFactors[FACTOR_ROTATION]) {
            generateRotationEvent(mRandom);
            return;
        }

        // The remaining event categories are injected as key events
        for (;;) {
            if (cls < mFactors[FACTOR_NAV]) {
                lastKey = NAV_KEYS[mRandom.nextInt(NAV_KEYS.length)];
            } else if (cls < mFactors[FACTOR_MAJORNAV]) {
                lastKey = MAJOR_NAV_KEYS[mRandom.nextInt(MAJOR_NAV_KEYS.length)];
            } else if (cls < mFactors[FACTOR_SYSOPS]) {
                lastKey = SYS_KEYS[mRandom.nextInt(SYS_KEYS.length)];
            } else if (cls < mFactors[FACTOR_APPSWITCH]) {
                MonkeyActivityEvent e = new MonkeyActivityEvent(mMainApps.get(
                        mRandom.nextInt(mMainApps.size())));
                mQ.addLast(e);
                return;
            } else if (cls < mFactors[FACTOR_FLIP]) {
                MonkeyFlipEvent e = new MonkeyFlipEvent(mKeyboardOpen);
                mKeyboardOpen = !mKeyboardOpen;
                mQ.addLast(e);
                return;
            } else {
                lastKey = 1 + mRandom.nextInt(KeyEvent.getMaxKeyCode() - 1);
            }

            if (lastKey != KeyEvent.KEYCODE_POWER
                    && lastKey != KeyEvent.KEYCODE_ENDCALL
                    && PHYSICAL_KEY_EXISTS[lastKey]) {
                break;
            }
        }

        MonkeyKeyEvent e = new MonkeyKeyEvent(KeyEvent.ACTION_DOWN, lastKey);
        mQ.addLast(e);

        e = new MonkeyKeyEvent(KeyEvent.ACTION_UP, lastKey);
        mQ.addLast(e);
    }

 

    循环到EventQueue获取事件并执行，如果为空的话，就随机生成事件并添加到EventQueue中

事件执行完毕就从EventQueue中删除

3、执行事件通过事件注入方式执行，MonkeyEvent实现类都实现了父类的injectEvent方法

 

这次学习借鉴：http://blog.csdn.net/zhubaitian/article/details/40395327

jxqsltf
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Android测试工具Monkey学习笔记
05-28
Monkey是Android自带的稳定性测试工具，总结了monkey的安装与环境配置、参数详解、日志分析与测试运行。
Android之Monkey源码分析（第四篇：命令行参数解析过程分析与参数作用阐述）
王员外的博客
09-14 1168
前言 在第三篇文章中，我分析Monkey程序的主线程执行过程，其中Monkey的run（）方法包含了大部分执行流程，今天这篇文章主要分析命令行参数是如何解析到内存中，在monkey程序中使用的！ run（）方法分析 private int run(String[] args) { ………………省略代码………… mArgs = args; ………………省略代码………… mNextArg..
Can't connect to activity manager; is the system running 问题探究及解决
qq_37101453的博客
05-03 3216
一、文档概述本文旨在记录错误信息Error type 2: android.util.AndroidException: Can't connect to activity manager; is the system running?问题分析及解决方式。二、问题描述在今天测试过程中发现任务卡在某一阶段无法通过，其中提示信息如下：错误信息提示信息显示Android系统没有运行。出现这个问题很奇怪的...
【Android M】Monkey命令源码及是否处于monkey测试的判断方法
好久不见
02-28 4786
【Android M】Monkey命令源码及是否在monkey测试的判断方法
android获取版本号报错,Android 7.1 Industry版本有概率启动报错（无法获取EGLConfig）...
weixin_39593718的博客
05-26 448
本帖最后由 prece 于 2020-7-22 11:48 编辑在RK3399开发板/Station P1上，运行Android 7.1 Industry版本有概率启动报如下错误：07-22 11:36:31.746 595 595 F libc : Fatal signal 6 (SIGABRT), code -6 in tid 595 (surfaceflinger)07-22 ...
手机录像出现arn无响应
chongyang198999的专栏
07-16 6409
个人总结，仅供参考 手机录像卡死出现anr，由于公司外卡通常比较低廉，经常出现存储相关问题，分析过程仅供参考。。。 kernel log info: // NOT RESPONDING: com.android.camera2 (pid 3221) Time Longth Since Monkey Start: 19814808 ANR in com.android.camera2 (co
monkey笔记
12-06
monkey学习笔记 monkey学习笔记 monkey学习笔记 monkey学习笔记
学习笔记之Android自动化测试工具Monkey
02-25
Monkey测试是Android平台下自动化测试的一种快速有效的手段，通过Monkey工具可以模拟用户触摸屏幕、滑动轨迹球、按键等操作来对模拟器或者手机设备上的软件进行压力测试，检测该软件的稳定性、健壮性。它的原理是向...
APP自动化学习笔记之一：monkey基本操作
01-03
monkey是安卓系统自带的，其启动脚本位于安卓系统的system/bin目录下的monkey文件 monkey是一个程序，运行在模拟器或设备上，并生成伪随机的用户事件流。如点击、触摸、手势，以及一些系统级事件，可以使用monkey...
java.lang.NumberFormatException 错误及解决办法
热门推荐
just_do_it_one的博客
05-13 11万+
总结几个java.lang.NumberFormatException 错误及解决办法方法转载https://blog.csdn.net/xiaodongvtion/article/details/8835668/转载https://blog.csdn.net/yxh6533/article/details/79376821第一种1. package com.geelou.test;2. 3. p...
在源码中监听activity启动
android 开发专栏
06-25 5976
上周做一个小的功能，修改statusbar，在launcher界面和其它应用界面显示不同的背景色和icon，最初想的就是接受系统activity启动的广播，进行判断，研究了一段时间，发现接受不到广播，最后在网上搜索资料，发现monkey代码中有一段代码可以接受activity启动和resume事件。最终满足要求。代码如下   1.设置观察者   mAm = ActivityManagerNat
Android之Monkey源码分析（第七篇：Monkey程序如何获知App崩溃，然后自己停止运行的逻辑分析）
王员外的博客
01-12 4294
前言 Monkey程序是用来执行稳定性测试的，被测App如果出现崩溃，Monkey程序会第一时间收集日志，App出现ANR，Monkey程序也会第一时间收集日志，这些都究竟是怎么做到的呢？这就依靠的是ActivityController ...
Android虚拟机无法正常工作几例及解决办法
DebugLog的专栏
02-20 3万+
Android 2.3.3 Eclipse Version: 3.7.0 Console Eclipse下运行Android虚拟机，Run应用，正常的Console一般如下： [2012-02-20 15:01:28 - taobaohtc] ------------------------------ [2012-02-20 15:01:28 - taobaohtc] Androi
Android monkey 命令详解
github_2011的博客
01-11 3万+
monkey 是一个运行在模拟器或者Android设备中可以产生类似用户点击、触摸、手势以及一些系统级的伪随机事件流的程序。 我们可以通过命令让monkey向模拟器或者Android设备发送伪随机事件流来对我们开发的App进行压力测试。 monkey的基本用法： adb shell monkey [options] adb shell monkey 为固定语句， 这里是指让monkey向系统发
关于Android无线调试unable to connect的一般解决方法
06-07 7197
1、将手机连接至电脑2、打开电脑cmd窗口，输入adb tcpip 5555该操作完，可以拔掉手机了，再输入adb connect x.x.x.x一般都可以连上手机了。
Monkey之processOptions方法
北极的冰箱
12-30 2603
/** * Process the command-line options * * @return Returns true if options were parsed with no apparent errors. */ private boolean processOptions() { // quick (throwawa
adb monkey
最新发布
07-27
ADB Monkey 是 Android Debug Bridge（ADB）工具的一个子命令，用于在设备上执行随机事件来进行压力测试和探索应用程序的稳定性。 使用 ADB Monkey，可以模拟各种用户操作，如点击、滑动、触摸等，以随机和大量的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值