1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
|
/*
* Copyright (C) 2012 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.compatibilitytest;
import android.app.ActivityManager;
import android.app.ActivityManager.ProcessErrorStateInfo;
import android.content.Context;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.os.Bundle;
import android.test.InstrumentationTestCase;
import android.util.Log;
import junit.framework.Assert;
import java.util.Collection;
/**
* Application Compatibility Test that launches an application and detects crashes.
*/
public class AppCompatibility extends InstrumentationTestCase {
private static final String TAG = "AppCompability";
private static final String PACKAGE_TO_LAUNCH = "package_to_launch";
private static final String APP_LAUNCH_TIMEOUT_MSECS = "app_launch_timeout_ms";
private static final String WORKSPACE_LAUNCH_TIMEOUT_MSECS = "workspace_launch_timeout_ms";
private int mAppLaunchTimeout = 7000;
private int mWorkspaceLaunchTimeout = 2000;
private Context mContext;
private ActivityManager mActivityManager;
private PackageManager mPackageManager;
private AppCompatibilityRunner mRunner;
private Bundle mArgs;
@Override
public void setUp() throws Exception{
super.setUp();
mRunner = (AppCompatibilityRunner) getInstrumentation();
assertNotNull("Could not fetch InstrumentationTestRunner.",mRunner);
mContext = mRunner.getTargetContext();
Assert.assertNotNull("Could not get the Context", mContext);
mActivityManager = (ActivityManager)
mContext.getSystemService(Context.ACTIVITY_SERVICE);
Assert.assertNotNull("Could not get Activity Manager", mActivityManager);
mPackageManager = mContext.getPackageManager();
Assert.assertNotNull("Missing Package Manager", mPackageManager);
mArgs = mRunner.getBundle();
// Parse optional inputs.
String appLaunchTimeoutMsecs = mArgs.getString(APP_LAUNCH_TIMEOUT_MSECS);
if (appLaunchTimeoutMsecs != null) {
mAppLaunchTimeout = Integer.parseInt(appLaunchTimeoutMsecs);
}
String workspaceLaunchTimeoutMsecs = mArgs.getString(WORKSPACE_LAUNCH_TIMEOUT_MSECS);
if (workspaceLaunchTimeoutMsecs != null) {
mWorkspaceLaunchTimeout = Integer.parseInt(workspaceLaunchTimeoutMsecs);
}
}
@Override
protected void tearDown() throws Exception {
super.tearDown();
}
/**
* Actual test case that launches the package and throws an exception on the first error.
* @throws Exception
*/
public void testAppStability() throws Exception {
String packageName = mArgs.getString(PACKAGE_TO_LAUNCH);
if (packageName != null) {
Log.d(TAG, "Launching app " + packageName);
Collection<ProcessErrorStateInfo> err = launchActivity(packageName);
// Make sure there are no errors when launching the application, otherwise raise an
// exception with the first error encountered.
assertNull(getFirstError(err), err);
} else {
Log.d(TAG, "Missing argument, use " + PACKAGE_TO_LAUNCH +
" to specify the package to launch");
}
}
/**
* Gets the first error in collection and return the long message for it.
* @param in {@link Collection} of {@link ProcessErrorStateInfo} to parse.
* @return {@link String} the long message of the error.
*/
private String getFirstError(Collection<ProcessErrorStateInfo> in) {
if (in == null) {
return null;
}
ProcessErrorStateInfo err = in.iterator().next();
if (err != null) {
return err.stackTrace;
}
return null;
}
/**
* Launches and activity and queries for errors.
* @param packageName {@link String} the package name of the application to launch.
* @return {@link Collection} of {@link ProcessErrorStateInfo} detected during the app launch.
*/
private Collection<ProcessErrorStateInfo> launchActivity(String packageName) {
Intent homeIntent = new Intent(Intent.ACTION_MAIN);
homeIntent.addCategory(Intent.CATEGORY_HOME);
homeIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
Intent intent = mPackageManager.getLaunchIntentForPackage(packageName);
// We check for any Crash or ANR dialogs that are already up, and we ignore them. This is
// so that we don't report crashes that were caused by prior apps (which those particular
// tests should have caught and reported already). Otherwise, test failures would cascade
// from the initial broken app to many/all of the tests following that app's launch.
final Collection<ProcessErrorStateInfo> preErr = mActivityManager.getProcessesInErrorState();
// Launch Activity
mContext.startActivity(intent);
try {
Thread.sleep(mAppLaunchTimeout);
} catch (InterruptedException e) {
// ignore
}
// Send the "home" intent and wait 2 seconds for us to get there
mContext.startActivity(homeIntent);
try {
Thread.sleep(mWorkspaceLaunchTimeout);
} catch (InterruptedException e) {
// ignore
}
// See if there are any errors. We wait until down here to give ANRs as much time as
// possible to occur.
final Collection<ProcessErrorStateInfo> postErr =
mActivityManager.getProcessesInErrorState();
// Take the difference between the error processes we see now, and the ones that were
// present when we started
if (preErr != null && postErr != null) {
postErr.removeAll(preErr);
}
return postErr;
}
}
|
