（任意事件）
30 | '''
31 | #动作百分比配置，合计100%
32 | self.events = {"--pct-touch":35, "--pct-motion":15, "--pct-trackball":15,"--pct-nav":7,"--pct-majornav":8,
33 | "--pct-syskeys":10,"--pct-appswitch":5, "--pct-anyevent":5,"--pct-flip":0}
34 |
35 |
36 | def generateEventStr(self):
37 | "生成action字符串"
38 | eventStr = ""
39 | for key in self.events:
40 | eventStr = eventStr + " %s %s"%(key, self.events[key])
41 | return eventStr
42 |
43 | def generateCommand(self):
44 | "生成monkey命令行"
45 | seed = randint(100000000000, 200000000000)#随机事件种子值
46 |
47 | command = "adb -s %s shell monkey -p %s -s %d -v --throttle %s %s --ignore-crashes --ignore-timeouts\
48 | --ignore-security-exceptions --ignore-native-crashes --monitor-native-crashes "%(self.device_id,self.pkgName, seed, self.throttle, self.generateEventStr())
49 |
50 | command = command + str(self.runNum)
51 | return command
52 |
53 | @staticmethod
54 | def terminateMonkey(deviceID):
55 | def getMonekyPid():
56 | top = os.popen("adb -s %s shell top -n 1"%deviceID).read()
57 | for topItem in top.split("\n"):
58 | if "com.android.commands.monkey" in topItem:
59 | return topItem.split()[0]
60 | pid = getMonekyPid()
61 | while pid:
62 | os.system("adb -s %s shell kill -9 %s"%(deviceID,pid))
63 | pid = getMonekyPid()
64 |
65 | def startMonkey(self):
66 | command = self.generateCommand()
67 | print(command)
68 | os.system("%s >> %s"%(command, os.path.join(self.logPath, "monkey.log")))
69 |
--------------------------------------------------------------------------------
/MonkeyTest/monkey.pyc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/BaiCe/AndroidAppPerformance/1612e90d020d22397ba7bbfdb3875f5d4dcec872/MonkeyTest/monkey.pyc
--------------------------------------------------------------------------------
/MonkeyTest/utils.py:
--------------------------------------------------------------------------------
1 | #coding=utf-8
2 |
3 | import os
4 | import zipfile
5 |
6 |
7 | def clearLog(deviceID):
8 | os.system("adb -s %s shell logcat -c"%deviceID)
9 |
10 | def getLog(logPath,deviceID):
11 | logcatPath = os.path.join(logPath, "logcat.log")
12 | os.system("adb -s %s shell logcat -d > %s"%(deviceID,logcatPath))
13 |
14 | def dumpState(logPath,deviceID):
15 | dumpStateLogPath = os.path.join(logPath, "dumpState.log")
16 | os.system("adb -s %s shell dumpstate > %s"%(deviceID,dumpStateLogPath))
17 |
18 | def getTraceData(logPath,deviceID):
19 | os.system("adb -s %s pull /data/anr %s"%(deviceID,logPath))
20 |
21 | #可能获取到多个设备
22 | def getDeviceInfo():
23 | return os.popen("adb shell getprop ro.build.fingerprint").read().strip()
24 |
25 | def compressFolder(folderPath):
26 |
27 | f = zipfile.ZipFile('abc.zip', 'w')
28 | for item in os.listdir(folderPath):
29 | f.write(os.path.join(folderPath, item))
30 | f.close()
31 |
32 | def forceStop(packageName,deviceID):
33 | os.system("adb -s %s shell am force-stop %s"%(deviceID,packageName))
34 | cmd1 = 'adb -s %s shell ps | grep %s'%(deviceID,packageName)
35 | cmd2 = 'adb -s %s shell ps | find %s'%(deviceID,packageName)
36 | result = os.popen(cmd1).read()
37 | if result is None or result == "":
38 | result = os.popen(cmd2).read()
39 | if result is not None and result != "":
40 | lines = result.split("\n")
41 | for i in xrange(len(lines)):
42 | infos = lines[i].split()
43 | if infos[8]==packageName:
44 | pid = infos[1]
45 | break
46 | os.system('adb -s %s shell su -c "kill -9 %s"'%(deviceID,pid))
47 |
48 | def reboot(deviceID=None):
49 | if deviceID is None:
50 | os.system("adb reboot")
51 | else:
52 | os.system("adb -s %s reboot"%deviceID)
53 |
54 |
--------------------------------------------------------------------------------
/MonkeyTest/utils.pyc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/BaiCe/AndroidAppPerformance/1612e90d020d22397ba7bbfdb3875f5d4dcec872/MonkeyTest/utils.pyc
--------------------------------------------------------------------------------
/Report/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/BaiCe/AndroidAppPerformance/1612e90d020d22397ba7bbfdb3875f5d4dcec872/Report/__init__.py
--------------------------------------------------------------------------------
/Report/__init__.pyc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/BaiCe/AndroidAppPerformance/1612e90d020d22397ba7bbfdb3875f5d4dcec872/Report/__init__.pyc
--------------------------------------------------------------------------------
/Report/base.py:
--------------------------------------------------------------------------------
1 | # -* - coding: UTF-8 -* -
2 |
3 | import re
4 | import operator
5 | import ast
6 |
7 | VAR_FRAGMENT = 0
8 | OPEN_BLOCK_FRAGMENT = 1
9 | CLOSE_BLOCK_FRAGMENT = 2
10 | TEXT_FRAGMENT = 3
11 |
12 | VAR_TOKEN_START = '{{'
13 | VAR_TOKEN_END = '}}'
14 | BLOCK_TOKEN_START = '{%'
15 | BLOCK_TOKEN_END = '%}'
16 |
17 | TOK_REGEX = re.compile(r"(%s.*?%s|%s.*?%s)" % (
18 | VAR_TOKEN_START,
19 | VAR_TOKEN_END,
20 | BLOCK_TOKEN_START,
21 | BLOCK_TOKEN_END
22 | ))
23 |
24 | WHITESPACE = re.compile('\s+')
25 |
26 | operator_lookup_table = {
27 | '<': operator.lt,
28 | '>': operator.gt,
29 | '==': operator.eq,
30 | '!=': operator.ne,
31 | '<=': operator.le,
32 | '>=': operator.ge
33 | }
34 |
35 |
36 | class TemplateError(Exception):
37 | pass
38 |
39 |
40 | class TemplateContextError(TemplateError):
41 |
42 | def __init__(self, context_var):
43 | self.context_var = context_var
44 |
45 | def __str__(self):
46 | return "cannot resolve '%s'" % self.context_var
47 |
48 |
49 | class TemplateSyntaxError(TemplateError):
50 |
51 | def __init__(self, error_syntax):
52 | self.error_syntax = error_syntax
53 |
54 | def __str__(self):
55 | return "'%s' seems like invalid syntax" % self.error_syntax
56 |
57 |
58 | def eval_expression(expr):
59 | try:
60 | return 'literal', ast.literal_eval(expr)
61 | except ValueError, SyntaxError:
62 | return 'name', expr
63 |
64 |
65 | def resolve(name, context):
66 | if name.startswith('..'):
67 | context = context.get('..', {})
68 | name = name[2:]
69 | try:
70 | for tok in name.split('.'):
71 | context = context[tok]
72 | return context
73 | except KeyError:
74 | raise TemplateContextError(name)
75 |
76 |
77 | class _Fragment(object):
78 | def __init__(self, raw_text):
79 | self.raw = raw_text
80 | self.clean = self.clean_fragment()
81 |
82 | def clean_fragment(self):
83 | if self.raw[:2] in (VAR_TOKEN_START, BLOCK_TOKEN_START):
84 | return self.raw.strip()[2:-2].strip()
85 | return self.raw
86 |
87 | @property
88 | def type(self):
89 | raw_start = self.raw[:2]
90 | if raw_start == VAR_TOKEN_START:
91 | return VAR_FRAGMENT
92 | elif raw_start == BLOCK_TOKEN_START:
93 | return CLOSE_BLOCK_FRAGMENT if self.clean[:3] == 'end' else OPEN_BLOCK_FRAGMENT
94 | else:
95 | return TEXT_FRAGMENT
96 |
97 |
98 | class _Node(object):
99 | creates_scope = False
100 |
101 | def __init__(self, fragment=None):
102 | self.children = []
103 | self.process_fragment(fragment)
104 |
105 | def process_fragment(self, fragment):
106 | pass
107 |
108 | def enter_scope(self):
109 | pass
110 |
111 | def render(self, context):
112 | pass
113 |
114 | def exit_scope(self):
115 | pass
116 |
117 | def render_children(self, context, children=None):
118 | if children is None:
119 | children = self.children
120 | def render_child(child):
121 | child_html = child.render(context)
122 | return '' if not child_html else str(child_html)
123 | return ''.join(map(render_child, children))
124 |
125 |
126 | class _ScopableNode(_Node):
127 | creates_scope = True
128 |
129 | class _Root(_Node):
130 | def render(self, context):
131 | return self.render_children(context)
132 |
133 |
134 | class _Variable(_Node):
135 | def process_fragment(self, fragment):
136 | self.name = fragment
137 |
138 | def render(self, context):
139 | return resolve(self.name, context)
140 |
141 |
142 | class _Each(_ScopableNode):
143 | def process_fragment(self, fragment):
144 | try:
145 | _, it = WHITESPACE.split(fragment, 1)
146 | self.it = eval_expression(it)
147 | except ValueError:
148 | raise TemplateSyntaxError(fragment)
149 |
150 | def render(self, context):
151 | items = self.it[1] if self.it[0] == 'literal' else resolve(self.it[1], context)
152 | def render_item(item):
153 | return self.render_children({'..': context, 'it': item})
154 | return ''.join(map(render_item, items))
155 |
156 |
157 | class _If(_ScopableNode):
158 | def process_fragment(self, fragment):
159 | bits = fragment.split()[1:]
160 | if len(bits) not in (1, 3):
161 | raise TemplateSyntaxError(fragment)
162 | self.lhs = eval_expression(bits[0])
163 | if len(bits) == 3:
164 | self.op = bits[1]
165 | self.rhs = eval_expression(bits[2])
166 |
167 | def render(self, context):
168 | lhs = self.resolve_side(self.lhs, context)
169 | if hasattr(self, 'op'):
170 | op = operator_lookup_table.get(self.op)
171 | if op is None:
172 | raise TemplateSyntaxError(self.op)
173 | rhs = self.resolve_side(self.rhs, context)
174 | exec_if_branch = op(lhs, rhs)
175 | else:
176 | exec_if_branch = operator.truth(lhs)
177 | if_branch, else_branch = self.split_children()
178 | return self.render_children(context,
179 | self.if_branch if exec_if_branch else self.else_branch)
180 |
181 | def resolve_side(self, side, context):
182 | return side[1] if side[0] == 'literal' else resolve(side[1], context)
183 |
184 | def exit_scope(self):
185 | self.if_branch, self.else_branch = self.split_children()
186 |
187 | def split_children(self):
188 | if_branch, else_branch = [], []
189 | curr = if_branch
190 | for child in self.children:
191 | if isinstance(child, _Else):
192 | curr = else_branch
193 | continue
194 | curr.append(child)
195 | return if_branch, else_branch
196 |
197 |
198 | class _Else(_Node):
199 | def render(self, context):
200 | pass
201 |
202 |
203 | class _Call(_Node):
204 | def process_fragment(self, fragment):
205 | try:
206 | bits = WHITESPACE.split(fragment)
207 | self.callable = bits[1]
208 | self.args, self.kwargs = self._parse_params(bits[2:])
209 | except ValueError, IndexError:
210 | raise TemplateSyntaxError(fragment)
211 |
212 | def _parse_params(self, params):
213 | args, kwargs = [], {}
214 | for param in params:
215 | if '=' in param:
216 | name, value = param.split('=')
217 | kwargs[name] = eval_expression(value)
218 | else:
219 | args.append(eval_expression(param))
220 | return args, kwargs
221 |
222 | def render(self, context):
223 | resolved_args, resolved_kwargs = [], {}
224 | for kind, value in self.args:
225 | if kind == 'name':
226 | value = resolve(value, context)
227 | resolved_args.append(value)
228 | for key, (kind, value) in self.kwargs.iteritems():
229 | if kind == 'name':
230 | value = resolve(value, context)
231 | resolved_kwargs[key] = value
232 | resolved_callable = resolve(self.callable, context)
233 | if hasattr(resolved_callable, '__call__'):
234 | return resolved_callable(*resolved_args, **resolved_kwargs)
235 | else:
236 | raise TemplateError("'%s' is not a callable" % self.callable)
237 |
238 |
239 | class _Text(_Node):
240 | def process_fragment(self, fragment):
241 | self.text = fragment
242 |
243 | def render(self, context):
244 | return self.text
245 |
246 |
247 | class Compiler(object):
248 | def __init__(self, template_string):
249 | self.template_string = template_string
250 |
251 | def each_fragment(self):
252 | for fragment in TOK_REGEX.split(self.template_string):
253 | if fragment:
254 | yield _Fragment(fragment)
255 |
256 | def compile(self):
257 | root = _Root()
258 | scope_stack = [root]
259 | for fragment in self.each_fragment():
260 | if not scope_stack:
261 | raise TemplateError('nesting issues')
262 | parent_scope = scope_stack[-1]
263 | if fragment.type == CLOSE_BLOCK_FRAGMENT:
264 | parent_scope.exit_scope()
265 | scope_stack.pop()
266 | continue
267 | new_node = self.create_node(fragment)
268 | if new_node:
269 | parent_scope.children.append(new_node)
270 | if new_node.creates_scope:
271 | scope_stack.append(new_node)
272 | new_node.enter_scope()
273 | return root
274 |
275 | def create_node(self, fragment):
276 | node_class = None
277 | if fragment.type == TEXT_FRAGMENT:
278 | node_class = _Text
279 | elif fragment.type == VAR_FRAGMENT:
280 | node_class = _Variable
281 | elif fragment.type == OPEN_BLOCK_FRAGMENT:
282 | cmd = fragment.clean.split()[0]
283 | if cmd == 'each':
284 | node_class = _Each
285 | elif cmd == 'if':
286 | node_class = _If
287 | elif cmd == 'else':
288 | node_class = _Else
289 | elif cmd == 'call':
290 | node_class = _Call
291 | if node_class is None:
292 | raise TemplateSyntaxError(fragment)
293 | return node_class(fragment.clean)
294 |
295 |
296 | class Template(object):
297 | def __init__(self, contents):
298 | self.contents = contents
299 | self.root = Compiler(contents).compile()
300 |
301 | def render(self, **kwargs):
302 | return self.root.render(kwargs)
303 |
--------------------------------------------------------------------------------
/Report/generateReport.py:
--------------------------------------------------------------------------------
1 | # -* - coding: UTF-8 -* -
2 |
3 | import os
4 | from Report import reportWritor
5 | import time
6 | from ResMonitor.NetworkTraffic import networkTraffic
7 |
8 |
9 | report_dir = os.path.join(os.path.dirname(__file__), 'results')
10 | report_dir = "D:/eclipse/workspace/MobilePerformance/logs/task_0304113023"
11 |
12 |
13 | def formatStr1(d):
14 | "{'duration': 2, 'crashCount': '0', 'anrCount': '0', 'pkgName': '', 'deviceID': 'HC52SWME0349'}"
15 |
16 | s = "此次测试时长%d分钟，测试设备ID%s,其中crash数量%d个，ANR数量%d个。"%(d["duration"],d["deviceID"],int(d['crashCount']),int(d['anrCount']))
17 | return s
18 |
19 | def formatStr2(d):
20 | "{'count': 10, 'max': 2369ms, 'avg': 1929ms, 'min': 1802ms}"
21 | s = "此次测试共执行%d次，其中最大时间为 %d ms，最小时间为 %d ms,平均时间(取出最大值和最小值)为 %d ms"%(d['count'],int(d['max']),int(d['min']),int(d['avg']))
22 | return s
23 |
24 |
25 | def getAvgCpuAndMemory(log_dir):
26 | memory_log_dir = os.path.join(log_dir,'memory.log')
27 | #"C:\\Users\\zhaowei\\workspace\\MobilePerformance\\logs\\task_0906144920\\memory.log"
28 | f = open(memory_log_dir, "r")
29 | cpuDatas=[]
30 | memDatas=[]
31 | for line in f:
32 | if line.strip():
33 | ss = line.split()
34 | index = 2
35 | for i in range(len(ss)):
36 | if "%" in ss[i]:
37 | index = i
38 | break
39 | cpuDatas.append(int(ss[index][0:-1]))
40 | memDatas.append(int(ss[index+4][0:-1]))
41 | cpuDatas.sort()
42 | memDatas.sort()
43 | cpus = cpuDatas[1:-1]
44 | memorys = memDatas[1:-1]
45 | avgCpu = round(float(sum(cpus))/len(cpus),2)
46 | avgMem = round(float(sum(memorys))/len(memorys)/1024,2)
47 | return [avgCpu,avgMem]
48 |
49 |
50 | def generateReportEx(resultDict,report_dir):
51 | "生成报告"
52 | "resultList-测试结果数据"
53 |
54 | # resultDict = {'testItems': {'startTime': {'count': 3, 'max': 1877L, 'avg': 1839L, 'min': 1781L}}, 'endTime': '2016/03/04 14:42:27', 'startTime': '2016/03/04 14:42:11'}
55 | start_time = resultDict["startTime"]
56 | end_time = resultDict["endTime"]
57 | use_time = resultDict["useTime"]
58 | avgCpuAndMem = getAvgCpuAndMemory(report_dir)
59 | monkeyResult = None
60 | startTimeResult = None
61 |
62 | if resultDict["testItems"].has_key("monkeyTest"):
63 | monkeyResult = resultDict["testItems"]["monkeyTest"]
64 | if resultDict["testItems"].has_key("startTime"):
65 | startTimeResult = resultDict["testItems"]["startTime"]
66 |
67 | testItemStr = "测试内容包括："
68 | if len(resultDict["testItems"]) == 0:
69 | testItemStr += "手工操作。"
70 | else:
71 | testItemStr += "，".join(resultDict["testItems"].keys())
72 | testItemStr = testItemStr.replace("monkeyTest", "monkey测试")
73 | testItemStr = testItemStr.replace("startTime", "启动时间测试")
74 |
75 |
76 | report = reportWritor.Report(report_dir)
77 |
78 | #测试结果总结部分--begin
79 | report.write_line('')
80 | report.write_line('
Hi,all:
本次测试完成，测试开始时间：%s，结束时间：%s，共计：%s秒。%s。
'%(start_time,end_time,use_time,testItemStr))
81 | report.write_line('
')
89 | report.write_line('
Monkey测试结果:
%s
'%formatStr1(monkeyResult))
90 | report.write_line('
')
94 | report.write_line('
启动时间测试结果:
%s
'%formatStr2(startTimeResult))
95 | report.write_line('
')
101 | report.write_line('
CPU使用统计（%）：
')
102 | report.write_line('
本次测试CPU的平均值(取出最大值和最小值)为（%）：'+str(avgCpuAndMem[0])+'
')
103 | report.write_line('
')
104 | report.write_line('
')
108 | report.write_line('
内存使用统计（MB/s）：
')
109 | report.write_line('
本次测试内存的平均值(取出最大值和最小值)为（MB/s）：'+str(avgCpuAndMem[1])+'
')
110 | report.write_line('
')
111 | report.write_line('
')
115 | report.write_line('
流量使用统计（KB/s）：
')
116 | report.write_line('
本次测试的总流量为（KB）：'+str(round((networkTraffic.total_bytes/1024.0),2))+'KB
')
117 | networkTraffic.total_bytes = 0
118 | report.write_line('
')
119 | report.write_line('
')
123 | report.write_line('
电量使用统计（%）：
')
124 | report.write_line('
')
125 | report.write_line('