【Android12】Monkey压力测试源码执行流程分析

于 2024-02-25 18:27:45 发布
阅读量900 收藏 12
点赞数 9
分类专栏： AndroidFramework 文章标签： 压力测试 Monkey 自动化测试 源码分析 anr crash
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zxc024000/article/details/136284851
版权

Monkey压力测试源码执行流程分析

Monkey是Android提供的用于应用程序自动化测试、压力测试的测试工具。
其源码路径(Android12)位于

/development/cmds/monkey/

部署形式为Java Binary

# development/cmds/monkey/Android.bp
// Copyright 2008 The Android Open Source Project
//

package {
    default_applicable_licenses: ["development_cmds_monkey_license"],
}

// See: http://go/android-license-faq
license {
    name: "development_cmds_monkey_license",
    visibility: [":__subpackages__"],
    license_kinds: [
        "SPDX-license-identifier-Apache-2.0",
    ],
    license_text: [
        "NOTICE",
    ],
}

//###############################################################
java_binary {
    name: "monkey",
    srcs: ["**/*.java"],
    wrapper: "monkey",
}

通过Monkey，可以模拟用户的Touch（单指、多指、手势）、按键（key）事件等，检测应用程序发生的ANR、Crash事件，并收集相关Debug信息等。
例如测试应用com.package.linduo，

adb shell monkey -p com.package.linduo --pct-touch 10 --pct-motion 20 10000
# 该命令表示，执行1万次测试事件，其中Touch事件占10%，Motion事件占20%

# 或者adb shell进入android终端，直接使用monkey命令

Monkey支持的命令

    private void showUsage() {
        StringBuffer usage = new StringBuffer();
        usage.append("usage: monkey [-p ALLOWED_PACKAGE [-p ALLOWED_PACKAGE] ...]\n");
        usage.append("              [-c MAIN_CATEGORY [-c MAIN_CATEGORY] ...]\n");
        usage.append("              [--ignore-crashes] [--ignore-timeouts]\n");
        usage.append("              [--ignore-security-exceptions]\n");
        usage.append("              [--monitor-native-crashes] [--ignore-native-crashes]\n");
        usage.append("              [--kill-process-after-error] [--hprof]\n");
        usage.append("              [--match-description TEXT]\n");
        usage.append("              [--pct-touch PERCENT] [--pct-motion PERCENT]\n");
        usage.append("              [--pct-trackball PERCENT] [--pct-syskeys PERCENT]\n");
        usage.append("              [--pct-nav PERCENT] [--pct-majornav PERCENT]\n");
        usage.append("              [--pct-appswitch PERCENT] [--pct-flip PERCENT]\n");
        usage.append("              [--pct-anyevent PERCENT] [--pct-pinchzoom PERCENT]\n");
        usage.append("              [--pct-permission PERCENT]\n");
        usage.append("              [--pkg-blacklist-file PACKAGE_BLACKLIST_FILE]\n");
        usage.append("              [--pkg-whitelist-file PACKAGE_WHITELIST_FILE]\n");
        usage.append("              [--wait-dbg] [--dbg-no-events]\n");
        usage.append("              [--setup scriptfile] [-f scriptfile [-f scriptfile] ...]\n");
        usage.append("              [--port port]\n");
        usage.append("              [-s SEED] [-v [-v] ...]\n");
        usage.append("              [--throttle MILLISEC] [--randomize-throttle]\n");
        usage.append("              [--profile-wait MILLISEC]\n");
        usage.append("              [--device-sleep-time MILLISEC]\n");
        usage.append("              [--randomize-script]\n");
        usage.append("              [--script-log]\n");
        usage.append("              [--bugreport]\n");
        usage.append("              [--periodic-bugreport]\n");
        usage.append("              [--permission-target-system]\n");
        usage.append("              COUNT\n");
        Logger.err.println(usage.toString());
    }

Monkey执行测试的源码分析

这里主要关注模式事件的执行流程

  • Monkey启动
  • Monkey生成模拟事件
  • Monkey向系统发送模拟事件
    在这里插入图片描述
Monkey启动

Monkey.java中定义了程序入口函数main，该函数中启动了Monkey程序。

// development/cmds/monkey/src/com/android/commands/monkey/Monkey.java

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

	Logger.err.println("args: " + Arrays.toString(args));
	int resultCode = (new Monkey()).run(args);
	System.exit(resultCode);
}

// development/cmds/monkey/src/com/android/commands/monkey/Monkey.java

/**
 * Run the command!
 *
 * @param args The command-line arguments
 * @return Returns a posix-style result code. 0 for no error.
 */
private int run(String[] args) {
	// Default values for some command-line options
	mVerbose = 0;
	// 默认的测试次数
	mCount = 1000;
	// 生成radom的seed
	mSeed = 0;
	// 记录事件之间的延迟，就是每个事件执行的间隔
	mThrottle = 0;

	// prepare for command-line processing
	mArgs = args;
	
	// 解析参数
	if (!processOptions()) {
		return -1;
	}
	
	// 确定待测试的Package
	if (!loadPackageLists()) {
		return -1;
	}
	
	// now set up additional data in preparation for launch
	if (mMainCategories.size() == 0) {
		mMainCategories.add(Intent.CATEGORY_LAUNCHER);
		mMainCategories.add(Intent.CATEGORY_MONKEY);
	}
	
	if (mSeed == 0) {
		mSeed = System.currentTimeMillis() + System.identityHashCode(this);
	}
	// 获取系统服务接口（AMS、PMS、WMS)
	if (!getSystemInterfaces()) {
		return -3;
	}
	// 获取用于启动应用的Activity
	if (!getMainApps()) {
		return -4;
	}
	
	if (mScriptFileNames != null && mScriptFileNames.size() == 1) {
		// script mode, ignore other options
	} else if (mScriptFileNames != null && mScriptFileNames.size() > 1) {
	} else if (mServerPort != -1) {
	} else {
		// 创建用于产生模拟器事件的Source对象
		mEventSource = new MonkeySourceRandom(mRandom, mMainApps,
				mThrottle, mRandomizeThrottle, mPermissionTargetSystem);
		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]);
			}
		}
		
		// 产生activity事件，该事件用来启动应用
		// in random mode, we start with a random activity
		((MonkeySourceRandom) mEventSource).generateActivity();
	}
	
	try {
		// 执行模拟测试事件
		crashedAtCycle = runMonkeyCycles();
	} finally {
		// Release the rotation lock if it's still held and restore the
		// original orientation.
		new MonkeyRotationEvent(Surface.ROTATION_0, false).injectEvent(
			mWm, mAm, mVerbose);
	}

}
Monkey解析输入参数

processOptions函数解析输入参数（就是monkey命令后跟着的参数信息），根据入参设置Monkey类中相关成员变量。

// development/cmds/monkey/src/com/android/commands/monkey/Monkey.java
private boolean processOptions() {
	// quick (throwaway) check for unadorned command
	if (mArgs.length < 1) {
		showUsage();
		return false;
	}

	try {
		String opt;
		Set<String> validPackages = new HashSet<>();
		while ((opt = nextOption()) != null) {
			if (opt.equals("-s")) {
				mSeed = nextOptionLong("Seed");
			} else if (opt.equals("-p")) {
				validPackages.add(nextOptionData());
			} else if (opt.equals("-c")) {
				// 省略
			} else {
				Logger.err.println("** Error: Unknown option: " + opt);
				showUsage();
				return false;
			}
		}
		// 根据输入参数，设置待测试的应用
		MonkeyUtils.getPackageFilter().addValidPackages(validPackages);
	} catch (RuntimeException ex) {
		Logger.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) {
		// 省略
	}

	return true;
}
Monkey获取系统服务

getSystemInterfaces函数用于获取Android系统服务，包括AMS、PMS、WMS服务。调用AMS服务的setActivityController接口，通过该接口向AMS设置IActivityController.Stub对象，通过该对象监听应用（Activity）的ANR和Crash事件。

/**
 * Attach to the required system interfaces.
 *
 * @return Returns true if all system interfaces were available.
 */
private boolean getSystemInterfaces() {
	mAm = ActivityManager.getService();
	if (mAm == null) {
		Logger.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) {
		Logger.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) {
		Logger.err.println("** Error: Unable to connect to package manager; is the system "
				+ "running?");
		return false;
	}

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

	return true;
}

/**
 * Monitor operations happening in the system.
 */
private class ActivityController extends IActivityController.Stub {
	public boolean activityStarting(Intent intent, String pkg) {
		// 省略
	}

	private boolean isActivityStartingAllowed(Intent intent, String pkg) {
		// 省略
	}

	public boolean activityResuming(String pkg) {
		// 省略
	}

	public boolean appCrashed(String processName, int pid,
			String shortMsg, String longMsg,
			long timeMillis, String stackTrace) {
		// 省略
	}

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

	public int appNotResponding(String processName, int pid, String processStats) {
		// 省略
	}

	public int systemNotResponding(String message) {
		// 省略
	}
}
Monkey获取待测试应用的Activity

monkey通过PackageManager的queryIntentActivities接口，查询带有 Intent.CATEGORY_LAUNCHER和Intent.CATEGORY_MONKEY信息的Activity，并判断Activity是否属于待测试应用。将待测试应用的Activity添加到mMainApps变量中。

// development/cmds/monkey/src/com/android/commands/monkey/Monkey.java
/**
 * Using the restrictions provided (categories & packages), generate a list
 * of activities that we can actually switch to.
 *
 * @return Returns true if it could successfully build a list of target
 *         activities
 */
private boolean getMainApps() {
	try {
		final int N = mMainCategories.size();
		for (int i = 0; i < N; i++) {
			Intent intent = new Intent(Intent.ACTION_MAIN);
			String category = mMainCategories.get(i);
			if (category.length() > 0) {
				intent.addCategory(category);
			}
			// 查找带有 Intent.CATEGORY_LAUNCHER、Intent.CATEGORY_MONKEY的Activity
			List<ResolveInfo> mainApps = mPm.queryIntentActivities(intent, null, 0,
					ActivityManager.getCurrentUser()).getList();
			
			final int NA = mainApps.size();
			for (int a = 0; a < NA; a++) {
				ResolveInfo r = mainApps.get(a);
				String packageName = r.activityInfo.applicationInfo.packageName;
				if (MonkeyUtils.getPackageFilter().checkEnteringPackage(packageName)) {
					// 如果Activity属于待测试Package，将其添加到mMainApps中。
					mMainApps.add(new ComponentName(packageName, r.activityInfo.name));
				} else {
				}
			}
		}
	} catch (RemoteException e) {
		Logger.err.println("** Failed talking with package manager!");
		return false;
	}

	if (mMainApps.size() == 0) {
		Logger.out.println("** No activities found to run, monkey aborted.");
		return false;
	}

	return true;
}
Monkey生成模拟测试事件，并执行
// development/cmds/monkey/src/com/android/commands/monkey/Monkey.java
private int run(String[] args) {
	// 创建该对象，用于产生测试事件
	mEventSource = new MonkeySourceRandom(mRandom, mMainApps,
			mThrottle, mRandomizeThrottle, mPermissionTargetSystem);

	for (int i = 0; i < MonkeySourceRandom.FACTORZ_COUNT; i++) {
		if (mFactors[i] <= 0.0f) {
			((MonkeySourceRandom) mEventSource).setFactors(i, mFactors[i]);
		}
	}

	try {
		// 执行Monkey测试
		crashedAtCycle = runMonkeyCycles();
	} finally {
		// Release the rotation lock if it's still held and restore the
		// original orientation.
		new MonkeyRotationEvent(Surface.ROTATION_0, false).injectEvent(
			mWm, mAm, mVerbose);
	}
}

runMonkeyCycles函数中调用MonkeySourceRandom的getNextEvent函数生成模拟测试事件（MonkeyEvent），调用MonkeyEvent的injectEvent执行模拟测试。

private int runMonkeyCycles() {
	int eventCounter = 0;
	int cycleCounter = 0;

	boolean shouldReportAnrTraces = false;
	boolean shouldReportDumpsysMemInfo = false;
	boolean shouldAbort = false;
	boolean systemCrashed = false;

	try {
		// TO DO : The count should apply to each of the script file.
		while (!systemCrashed && cycleCounter < mCount) {
			synchronized (this) {
			// 注意:因为先执行过generateActivity，所以第一次调用会，会获得启动Activity的模拟测试事件
			MonkeyEvent ev = mEventSource.getNextEvent();
			if (ev != null) {
				int injectCode = ev.injectEvent(mWm, mAm, mVerbose);

			} else {
			}
		}
	} catch (RuntimeException e) {
		Logger.error("** Error: A RuntimeException occurred:", e);
	}
	Logger.out.println("Events injected: " + eventCounter);
	return eventCounter;
}

MonkeySourceRandom的getNextEvent，会在事件队列（存储模拟测试事件）为空时，产生测试对象。生成测试事件时，先生成一个随机数，然后根据测试类型所占比例（比例越大，生成该测试类型的概率越大），生成不同测试类型。

// development/cmds/monkey/src/com/android/commands/monkey/MonkeySourceRandom.java
/**
 * generate an activity event
 */
public void generateActivity() {
	MonkeyActivityEvent e = new MonkeyActivityEvent(mMainApps.get(
			mRandom.nextInt(mMainApps.size())));
	mQ.addLast(e);
}

/**
 * if the queue is empty, we generate events first
 * @return the first event in the queue
 */
public MonkeyEvent getNextEvent() {
	if (mQ.isEmpty()) {
		generateEvents();
	}
	mEventCount++;
	MonkeyEvent e = mQ.getFirst();
	mQ.removeFirst();
	return e;
}

/**
 * generate a random event based on mFactor
 */
private void generateEvents() {
	// 生成随机数
	float cls = mRandom.nextFloat();
	int lastKey = 0;
	// 根据Factor，即不同测试类型所占的比例，生成测试事件
	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;
	} else if (cls < mFactors[FACTOR_PERMISSION]) {
		mQ.add(mPermissionUtil.generateRandomPermissionEvent(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
				&& lastKey != KeyEvent.KEYCODE_SLEEP
				&& lastKey != KeyEvent.KEYCODE_SOFT_SLEEP
				&& 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);
}

以Ttouch事件为例子，调用generatePointerEvent函数。通过DMS获取Display对象（用于得知屏幕大小），生成MonkeyTouchEvent对象。

// development/cmds/monkey/src/com/android/commands/monkey/MonkeySourceRandom.java
private void generatePointerEvent(Random random, int gesture) {
	Display display = DisplayManagerGlobal.getInstance().getRealDisplay(Display.DEFAULT_DISPLAY);

	PointF p1 = randomPoint(random, display);
	PointF v1 = randomVector(random);

	long downAt = SystemClock.uptimeMillis();

	mQ.addLast(new MonkeyTouchEvent(MotionEvent.ACTION_DOWN)
			.setDownTime(downAt)
			.addPointer(0, p1.x, p1.y)
			.setIntermediateNote(false));

	// 省略

	randomWalk(random, display, p1, v1);
	mQ.addLast(new MonkeyTouchEvent(MotionEvent.ACTION_UP)
			.setDownTime(downAt)
			.addPointer(0, p1.x, p1.y)
			.setIntermediateNote(false));
}

调用MonkeyTouchEvent的injectEvent函数，使用InputManager向系统派发TouchEvent。

// development/cmds/monkey/src/com/android/commands/monkey/MonkeyMotionEvent.java
@Override
public int injectEvent(IWindowManager iwm, IActivityManager iam, int verbose) {
	MotionEvent me = getEvent();
	if ((verbose > 0 && !mIntermediateNote) || verbose > 1) {
		StringBuilder msg = new StringBuilder(":Sending ");
		msg.append(getTypeLabel()).append(" (");
		switch (me.getActionMasked()) {
			case MotionEvent.ACTION_DOWN:
				msg.append("ACTION_DOWN");
				break;
			case MotionEvent.ACTION_MOVE:
				msg.append("ACTION_MOVE");
				break;
			case MotionEvent.ACTION_UP:
				msg.append("ACTION_UP");
				break;
			case MotionEvent.ACTION_CANCEL:
				msg.append("ACTION_CANCEL");
				break;
			case MotionEvent.ACTION_POINTER_DOWN:
				msg.append("ACTION_POINTER_DOWN ").append(me.getPointerId(me.getActionIndex()));
				break;
			case MotionEvent.ACTION_POINTER_UP:
				msg.append("ACTION_POINTER_UP ").append(me.getPointerId(me.getActionIndex()));
				break;
			default:
				msg.append(me.getAction());
				break;
		}
		msg.append("):");

		int pointerCount = me.getPointerCount();
		for (int i = 0; i < pointerCount; i++) {
			msg.append(" ").append(me.getPointerId(i));
			msg.append(":(").append(me.getX(i)).append(",").append(me.getY(i)).append(")");
		}
		Logger.out.println(msg.toString());
	}
	try {
		// 派发TouchEvent
		if (!InputManager.getInstance().injectInputEvent(me,
				InputManager.INJECT_INPUT_EVENT_MODE_WAIT_FOR_RESULT)) {
			return MonkeyEvent.INJECT_FAIL;
		}
	} finally {
		me.recycle();
	}
	return MonkeyEvent.INJECT_SUCCESS;
}
Monkey主要相关类图

在这里插入图片描述

林多
关注
  • 9
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Monkey源码分析3—Monkey源码的整体设计结构
alzhang5220的博客
06-28 3735
Monkey整体设计结构。核心类的作用等。
Android单元测试
Makenna's World
08-08 2325
全面了解Android单元测试
Android自动化测试Monkey, UiAutomator使用详解
yaoyaoyao_123的博客
04-12 1252
Android程序开发迭代周期短，测试case重复度高，大部分case属于功能验证，常规的测试方法是测试人员按照预先写好的Case手顺进行测试，人工比对操作结果和预期结果。这种测试手段重复度高，效率低，无趣，易出错，并且对测试人员能力提升帮助有限。Android手机机型狂多，屏幕尺寸各异，语言各异，因此测试重复度很高，完全依赖人力并不现实。 Androi...
Monkey概述及命令
Cpgm_AH的博客
10-11 1069
Money
monkey环境搭建及执行
weixin_44370919的博客
11-28 1820
一、环境准备 1、JDK 2、Android SDK 二、JAVA环境的搭建 1、JDK 下载地址：https://www.oracle.com/technetwork/java/javase/downloads/index.html 2、JDK 配置环境变量，此处就不多叙述了，不会的可以查看小编以前写的关于JDK环境变量配置的教程。 链接地址：https://www.jianshu.com/p/ee18a69e137d 三、Android SDK环境 1、下载Android SDK（最新版） 下载地址：h
monkey命令的使用
m0_59315964的博客
03-09 1万+
一、monkey的概念 Monkey是Android中的一个命令行工具，可以运行在模拟器里或者现实设备中，向系统发送伪随机的用户事件流（点击、滑动、Application切换、横竖屏、应用关闭）实现对正在开发的应用程序进行压力测试。monkey测试是一种为了测试软件的稳定性，健壮性的快速有效的方法，只针对Activity做测试，不能对Service做测试。 二、monkey的使用 1、运行原理 adb shell monkey 2、monkey的基本命令 1、help命令 adb shel
Python如何实现Monkey自动化测试？
Liuxm
11-13 3975
通过输入以下信息，进行moneky测试。 测试机(phone)：可以通过adb devices命令获取。 测试包(packageName) 测试事件次数(monkeyClickCount) ADB命令 monkey测试ADB命令 设置monkey测试ADB命令，这里已华为手机的相机APP进行monkey测试，执行1000次。 adb shell monkey -p com.huawei.camera -s 901 --ignore-timeouts --ignore-crashes --ignore-s
Monkey脚本，一键执行
09-08
Monkey脚本，一键执行
AndroidMonkey压力测试
02-24
本文主要介绍JAVA环境的搭建、AndroidSDK工具安装、启动一个Android环境、AndroidMonkey压力测试、分析测试报告。本文来自于博客园，由火龙果软件Alice编辑、推荐。1.安装jdk-8u151-windows-x64,可以到官网或者应用...
Android Monkey压力测试详细介绍
09-01
本文主要介绍Android Monkey压力测试,这里整理了详细的Monkey资料，有需要的小伙伴可以参考下
AndroidApp压力测试方法（Monkey）
02-24
3.3MonkeyScript测试命令集合介绍3.4异常测试结果分析4.1一次AndroidApp的压测实践需要准备的环境：1.AndroidSDK环境；2.python环境压测过程：Step1.Step2.Step3.Step4.Step5.Step6.4.2Monkey高级参数——throttle...
Android稳定性测试——Monkey测试命令及执行
ezreal_tao的博客
06-25 1万+
附上Money命令执行文件，保存在txt文件后，把文件后缀.txt改成.cmd 双击执行该文件，就可以执行adb shell monkey -p com.nuomi -s 200 --throttle 500  --ignore-crashes  --ignore-timeouts  --ignore-security-exceptions  --monitor-native-crashes ...
Monkey 常用执行命令
李明月的博客
03-31 1391
Monkey 是安卓平台自动化测试的一种手段,通过Monkey模拟用户触碰屏幕 点击 滑动 等事件,对设备上的程序进行压力测试也就是稳定性测试,检测程序多久会发生异常. Monkey程序介绍 Monkey 程序由Android 系统自带,使用java语言编写,在Android 的系统存放路径:/system/framework/monkey.jar,Monke...
APP自动化测试工具——Monkey脚本执行
qq_28585471的博客
07-04 4167
一些sdk配置及adb命令基础暂时省略 本实验目的：写monkey脚本实现QQ登录 1、下载apk 1）将apk文件放到电脑某个目录下 2）将apk传到真机/模拟器设备上（adb install apk地址） 2、aapt命令获取apk包名和启动Activity 1）打开cmd 2）输入命令 aapt dump badging apk地址 3）找到apk package name ...
monkey运行实例
weixin_39782286的博客
11-20 936
注：以下为平时学习的笔记的整合总结~方便自己平时查阅理解~仅供参考 Monkey 是Android SDK（Android SDK 指的是Android专属的软件开发工具包。）提供的一个命令行工具， 可以简单，方便地运行在任何版本的Android模拟器和实体设备上。Monkey会发送伪随机的用户事件流，适合对app做压力测试 一、monkey测试的主要目的： 主要是用于Android的压力...
Monkey使用详解
热门推荐
寻鱼的猫博客
09-14 5万+
QQ群：234922431 这是一个从0到1的过程，一步一步搭建的测试接口框架，本教程从开始写框架的思路，和实现过程深入解析，并且深入到了每个相关的的各个细节，不论你是刚入门的菜鸟，还是一个懂编码经验的工程师，相信本系列的文章都会对你有所帮助。 你即可以学到从0到1搭建自动化的编码思想，也可以改变成一个接口自动化工具，在需要的时候可以自己更改代码和维护。 你可以收获什么？ 1.完善py...
monkey运行日志基础分析
沈伟-测试前行者
07-25 4444
之前有写过：  Monkey测试环境搭建---更新时间截止20170724可用： http://blog.csdn.net/a136332462/article/details/75967719 monkey命令详解：  http://blog.csdn.net/a136332462/article/details/76014412 要看的移步
monkey如何执行入门基础
测试领域专家，多领域测试技术、管理、工具都略懂，略懂一二
10-26 545
monkey资料很多，我不细讲，现在我就执告诉大家，执行monkey就一句话而已 adb shell monkey -p com.dengshengyu -s 500 --ignore-crashes --ignore-timeouts --monitor-native-crashes -v -v 10000 > E:\java_monkey_log.txt 我们知
具体分析出monkey测试报错流程
最新发布
05-26
Monkey测试是一种随机化的测试方法，通常用于测试应用程序的稳定性和兼容性。它会在应用程序中随机生成触摸、滑动、按键等事件，以模拟用户的操作。如果应用程序不能正确处理这些事件，就会导致程序崩溃或出现其他异常情况。 下面是一般的monkey测试报错流程： 1. 生成随机事件：Monkey测试工具会生成随机的触摸、滑动、按键等事件，以模拟用户的操作。 2. 执行随机事件：应用程序会接收到这些随机事件，并进行相应处理。 3. 检查应用程序的响应：Monkey测试工具会检查应用程序的响应，包括界面响应、功能是否正常等。 4. 记录错误：如果应用程序出现了异常情况，Monkey测试工具会记录错误信息并输出日志。 5. 分析错误：测试人员会根据错误信息和日志，分析问题的原因。 6. 修复错误：开发人员根据测试人员提供的错误信息，修复应用程序中的问题。 7. 再次测试：修复后的应用程序会再次进行Monkey测试，以确认问题是否已经解决。 根据上述流程，如果应用程序不能正确地处理随机事件，就会导致程序崩溃或出现其他异常情况。在这种情况下，Monkey测试工具会记录错误信息并输出日志，测试人员根据错误信息和日志，分析问题的原因，开发人员再根据测试人员提供的错误信息，修复应用程序中的问题。最后，修复后的应用程序会再次进行Monkey测试，以确认问题是否已经解决。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

林多

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值