blob: 4c68b02ddf602c4b589a0488e96bdd356063c043 [file] [log] [blame]
Joe Onorato0578cbc2016-10-19 17:03:06 -07001/*
2 * Copyright (C) 2016 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#include "aapt.h"
18#include "adb.h"
19#include "make.h"
20#include "print.h"
21#include "util.h"
22
23#include <sstream>
24#include <string>
25#include <vector>
26
27#include <stdio.h>
28#include <stdlib.h>
29#include <string.h>
30#include <unistd.h>
31
32#include <google/protobuf/stubs/common.h>
33
34using namespace std;
35
36/**
37 * An entry from the command line for something that will be built, installed,
38 * and/or tested.
39 */
40struct Target {
41 bool build;
42 bool install;
43 bool test;
44 string pattern;
45 string name;
46 vector<string> actions;
47 Module module;
48
49 int testActionCount;
50
51 int testPassCount;
52 int testFailCount;
53 bool actionsWithNoTests;
54
55 Target(bool b, bool i, bool t, const string& p);
56};
57
58Target::Target(bool b, bool i, bool t, const string& p)
59 :build(b),
60 install(i),
61 test(t),
62 pattern(p),
63 testActionCount(0),
64 testPassCount(0),
65 testFailCount(0),
66 actionsWithNoTests(false)
67{
68}
69
70/**
71 * Command line options.
72 */
73struct Options {
74 // For help
75 bool runHelp;
76
77 // For tab completion
78 bool runTab;
79 string tabPattern;
80
81 // For build/install/test
Joe Onorato6592c3c2016-11-12 16:34:25 -080082 bool noRestart;
Joe Onorato0578cbc2016-10-19 17:03:06 -070083 bool reboot;
84 vector<Target*> targets;
85
86 Options();
87 ~Options();
88};
89
90Options::Options()
91 :runHelp(false),
92 runTab(false),
Joe Onorato6592c3c2016-11-12 16:34:25 -080093 noRestart(false),
Joe Onorato0578cbc2016-10-19 17:03:06 -070094 reboot(false),
95 targets()
96{
97}
98
99Options::~Options()
100{
101}
102
103struct InstallApk
104{
105 TrackedFile file;
106 bool alwaysInstall;
107 bool installed;
108
109 InstallApk();
110 InstallApk(const InstallApk& that);
111 InstallApk(const string& filename, bool always);
112 ~InstallApk() {};
113};
114
115InstallApk::InstallApk()
116{
117}
118
119InstallApk::InstallApk(const InstallApk& that)
120 :file(that.file),
121 alwaysInstall(that.alwaysInstall),
122 installed(that.installed)
123{
124}
125
126InstallApk::InstallApk(const string& filename, bool always)
127 :file(filename),
128 alwaysInstall(always),
129 installed(false)
130{
131}
132
133
134/**
135 * Record for an test that is going to be launched.
136 */
137struct TestAction {
138 TestAction();
139
140 // The package name from the apk
141 string packageName;
142
143 // The test runner class
144 string runner;
145
146 // The test class, or none if all tests should be run
147 string className;
148
149 // The original target that requested this action
150 Target* target;
151
152 // The number of tests that passed
153 int passCount;
154
155 // The number of tests that failed
156 int failCount;
157};
158
159TestAction::TestAction()
160 :passCount(0),
161 failCount(0)
162{
163}
164
165/**
166 * Record for an activity that is going to be launched.
167 */
168struct ActivityAction {
169 // The package name from the apk
170 string packageName;
171
172 // The test class, or none if all tests should be run
173 string className;
174};
175
176/**
177 * Callback class for the am instrument command.
178 */
179class TestResults: public InstrumentationCallbacks
180{
181public:
182 virtual void OnTestStatus(TestStatus& status);
183 virtual void OnSessionStatus(SessionStatus& status);
184
185 /**
186 * Set the TestAction that the tests are for.
187 * It will be updated with statistics as the tests run.
188 */
189 void SetCurrentAction(TestAction* action);
190
191private:
192 TestAction* m_currentAction;
193};
194
195void
196TestResults::OnTestStatus(TestStatus& status)
197{
198 bool found;
199// printf("OnTestStatus\n");
200// status.PrintDebugString();
201 int32_t resultCode = status.has_results() ? status.result_code() : 0;
202
203 if (!status.has_results()) {
204 return;
205 }
206 const ResultsBundle &results = status.results();
207
208 int32_t currentTestNum = get_bundle_int(results, &found, "current", NULL);
209 if (!found) {
210 currentTestNum = -1;
211 }
212
213 int32_t testCount = get_bundle_int(results, &found, "numtests", NULL);
214 if (!found) {
215 testCount = -1;
216 }
217
218 string className = get_bundle_string(results, &found, "class", NULL);
219 if (!found) {
220 return;
221 }
222
223 string testName = get_bundle_string(results, &found, "test", NULL);
224 if (!found) {
225 return;
226 }
227
228 if (resultCode == 0) {
229 // test passed
230 m_currentAction->passCount++;
231 m_currentAction->target->testPassCount++;
232 } else if (resultCode == 1) {
233 // test starting
234 ostringstream line;
235 line << "Running";
236 if (currentTestNum > 0) {
237 line << ": " << currentTestNum;
238 if (testCount > 0) {
239 line << " of " << testCount;
240 }
241 }
242 line << ": " << m_currentAction->target->name << ':' << className << "\\#" << testName;
243 print_one_line("%s", line.str().c_str());
244 } else if (resultCode == -2) {
245 // test failed
246 m_currentAction->failCount++;
247 m_currentAction->target->testFailCount++;
248 printf("%s\n%sFailed: %s:%s\\#%s%s\n", g_escapeClearLine, g_escapeRedBold,
249 m_currentAction->target->name.c_str(), className.c_str(),
250 testName.c_str(), g_escapeEndColor);
251
252 string stack = get_bundle_string(results, &found, "stack", NULL);
253 if (found) {
254 printf("%s\n", stack.c_str());
255 }
256 }
257}
258
259void
260TestResults::OnSessionStatus(SessionStatus& /*status*/)
261{
262 //status.PrintDebugString();
263}
264
265void
266TestResults::SetCurrentAction(TestAction* action)
267{
268 m_currentAction = action;
269}
270
271/**
272 * Prints the usage statement / help text.
273 */
274static void
275print_usage(FILE* out) {
276 fprintf(out, "usage: bit OPTIONS PATTERN\n");
277 fprintf(out, "\n");
278 fprintf(out, " Build, sync and test android code.\n");
279 fprintf(out, "\n");
280 fprintf(out, " The -b -i and -t options allow you to specify which phases\n");
281 fprintf(out, " you want to run. If none of those options are given, then\n");
282 fprintf(out, " all phases are run. If any of these options are provided\n");
283 fprintf(out, " then only the listed phases are run.\n");
284 fprintf(out, "\n");
285 fprintf(out, " OPTIONS\n");
286 fprintf(out, " -b Run a build\n");
287 fprintf(out, " -i Install the targets\n");
288 fprintf(out, " -t Run the tests\n");
289 fprintf(out, "\n");
Joe Onorato6592c3c2016-11-12 16:34:25 -0800290 fprintf(out, " -n Don't reboot or restart\n");
Joe Onorato0578cbc2016-10-19 17:03:06 -0700291 fprintf(out, " -r If the runtime needs to be restarted, do a full reboot\n");
292 fprintf(out, " instead\n");
293 fprintf(out, "\n");
294 fprintf(out, " PATTERN\n");
295 fprintf(out, " One or more targets to build, install and test. The target\n");
296 fprintf(out, " names are the names that appear in the LOCAL_MODULE or\n");
297 fprintf(out, " LOCAL_PACKAGE_NAME variables in Android.mk or Android.bp files.\n");
298 fprintf(out, "\n");
299 fprintf(out, " Building and installing\n");
300 fprintf(out, " -----------------------\n");
301 fprintf(out, " The modules specified will be built and then installed. If the\n");
302 fprintf(out, " files are on the system partition, they will be synced and the\n");
303 fprintf(out, " attached device rebooted. If they are APKs that aren't on the\n");
304 fprintf(out, " system partition they are installed with adb install.\n");
305 fprintf(out, "\n");
306 fprintf(out, " For example:\n");
307 fprintf(out, " bit framework\n");
308 fprintf(out, " Builds framework.jar, syncs the system partition and reboots.\n");
309 fprintf(out, "\n");
310 fprintf(out, " bit SystemUI\n");
311 fprintf(out, " Builds SystemUI.apk, syncs the system partition and reboots.\n");
312 fprintf(out, "\n");
313 fprintf(out, " bit CtsProtoTestCases\n");
314 fprintf(out, " Builds this CTS apk, adb installs it, but does not run any\n");
315 fprintf(out, " tests.\n");
316 fprintf(out, "\n");
317 fprintf(out, " Running Unit Tests\n");
318 fprintf(out, " ------------------\n");
319 fprintf(out, " To run a unit test, list the test class names and optionally the\n");
320 fprintf(out, " test method after the module.\n");
321 fprintf(out, "\n");
322 fprintf(out, " For example:\n");
323 fprintf(out, " bit CtsProtoTestCases:*\n");
324 fprintf(out, " Builds this CTS apk, adb installs it, and runs all the tests\n");
325 fprintf(out, " contained in that apk.\n");
326 fprintf(out, "\n");
327 fprintf(out, " bit framework CtsProtoTestCases:*\n");
328 fprintf(out, " Builds the framework and the apk, syncs and reboots, then\n");
329 fprintf(out, " adb installs CtsProtoTestCases.apk, and runs all tests \n");
330 fprintf(out, " contained in that apk.\n");
331 fprintf(out, "\n");
332 fprintf(out, " bit CtsProtoTestCases:.ProtoOutputStreamBoolTest\n");
333 fprintf(out, " bit CtsProtoTestCases:android.util.proto.cts.ProtoOutputStreamBoolTest\n");
334 fprintf(out, " Builds and installs CtsProtoTestCases.apk, and runs all the\n");
335 fprintf(out, " tests in the ProtoOutputStreamBoolTest class.\n");
336 fprintf(out, "\n");
337 fprintf(out, " bit CtsProtoTestCases:.ProtoOutputStreamBoolTest\\#testWrite\n");
338 fprintf(out, " Builds and installs CtsProtoTestCases.apk, and runs the testWrite\n");
339 fprintf(out, " test method on that class.\n");
340 fprintf(out, "\n");
341 fprintf(out, " bit CtsProtoTestCases:.ProtoOutputStreamBoolTest\\#testWrite,.ProtoOutputStreamBoolTest\\#testRepeated\n");
342 fprintf(out, " Builds and installs CtsProtoTestCases.apk, and runs the testWrite\n");
343 fprintf(out, " and testRepeated test methods on that class.\n");
344 fprintf(out, "\n");
Makoto Onuki164e7962017-07-06 16:20:11 -0700345 fprintf(out, " bit CtsProtoTestCases:android.util.proto.cts.\n");
346 fprintf(out, " Builds and installs CtsProtoTestCases.apk, and runs the tests in the java package\n");
347 fprintf(out, " \"android.util.proto.cts\".\n");
348 fprintf(out, "\n");
Joe Onorato0578cbc2016-10-19 17:03:06 -0700349 fprintf(out, " Launching an Activity\n");
350 fprintf(out, " ---------------------\n");
351 fprintf(out, " To launch an activity, specify the activity class name after\n");
352 fprintf(out, " the module name.\n");
353 fprintf(out, "\n");
354 fprintf(out, " For example:\n");
355 fprintf(out, " bit StatusBarTest:NotificationBuilderTest\n");
356 fprintf(out, " bit StatusBarTest:.NotificationBuilderTest\n");
357 fprintf(out, " bit StatusBarTest:com.android.statusbartest.NotificationBuilderTest\n");
358 fprintf(out, " Builds and installs StatusBarTest.apk, launches the\n");
359 fprintf(out, " com.android.statusbartest/.NotificationBuilderTest activity.\n");
360 fprintf(out, "\n");
361 fprintf(out, "\n");
362 fprintf(out, "usage: bit --tab ...\n");
363 fprintf(out, "\n");
364 fprintf(out, " Lists the targets in a format for tab completion. To get tab\n");
365 fprintf(out, " completion, add this to your bash environment:\n");
366 fprintf(out, "\n");
367 fprintf(out, " complete -C \"bit --tab\" bit\n");
368 fprintf(out, "\n");
369 fprintf(out, " Sourcing android's build/envsetup.sh will do this for you\n");
370 fprintf(out, " automatically.\n");
371 fprintf(out, "\n");
372 fprintf(out, "\n");
373 fprintf(out, "usage: bit --help\n");
374 fprintf(out, "usage: bit -h\n");
375 fprintf(out, "\n");
376 fprintf(out, " Print this help message\n");
377 fprintf(out, "\n");
378}
379
380
381/**
382 * Sets the appropriate flag* variables. If there is a problem with the
383 * commandline arguments, prints the help message and exits with an error.
384 */
385static void
386parse_args(Options* options, int argc, const char** argv)
387{
388 // Help
389 if (argc == 2 && (strcmp(argv[1], "-h") == 0 || strcmp(argv[1], "--help") == 0)) {
390 options->runHelp = true;
391 return;
392 }
393
394 // Tab
395 if (argc >= 4 && strcmp(argv[1], "--tab") == 0) {
396 options->runTab = true;
397 options->tabPattern = argv[3];
398 return;
399 }
400
401 // Normal usage
402 bool anyPhases = false;
403 bool gotPattern = false;
404 bool flagBuild = false;
405 bool flagInstall = false;
406 bool flagTest = false;
407 for (int i=1; i < argc; i++) {
408 string arg(argv[i]);
409 if (arg[0] == '-') {
410 for (size_t j=1; j<arg.size(); j++) {
411 switch (arg[j]) {
412 case '-':
413 break;
414 case 'b':
415 if (gotPattern) {
416 gotPattern = false;
417 flagInstall = false;
418 flagTest = false;
419 }
420 flagBuild = true;
421 anyPhases = true;
422 break;
423 case 'i':
424 if (gotPattern) {
425 gotPattern = false;
426 flagBuild = false;
427 flagTest = false;
428 }
429 flagInstall = true;
430 anyPhases = true;
431 break;
432 case 't':
433 if (gotPattern) {
434 gotPattern = false;
435 flagBuild = false;
436 flagInstall = false;
437 }
438 flagTest = true;
439 anyPhases = true;
440 break;
Joe Onorato6592c3c2016-11-12 16:34:25 -0800441 case 'n':
442 options->noRestart = true;
443 break;
Joe Onorato0578cbc2016-10-19 17:03:06 -0700444 case 'r':
445 options->reboot = true;
446 break;
447 default:
448 fprintf(stderr, "Unrecognized option '%c'\n", arg[j]);
449 print_usage(stderr);
450 exit(1);
451 break;
452 }
453 }
454 } else {
455 Target* target = new Target(flagBuild || !anyPhases, flagInstall || !anyPhases,
456 flagTest || !anyPhases, arg);
457 size_t colonPos = arg.find(':');
458 if (colonPos == 0) {
459 fprintf(stderr, "Test / activity supplied without a module to build: %s\n",
460 arg.c_str());
461 print_usage(stderr);
Yunlian Jiang2cfa8492016-12-06 16:08:39 -0800462 delete target;
Joe Onorato0578cbc2016-10-19 17:03:06 -0700463 exit(1);
464 } else if (colonPos == string::npos) {
465 target->name = arg;
466 } else {
467 target->name.assign(arg, 0, colonPos);
468 size_t beginPos = colonPos+1;
469 size_t commaPos;
470 while (true) {
471 commaPos = arg.find(',', beginPos);
472 if (commaPos == string::npos) {
473 if (beginPos != arg.size()) {
474 target->actions.push_back(string(arg, beginPos, commaPos));
475 }
476 break;
477 } else {
478 if (commaPos != beginPos) {
479 target->actions.push_back(string(arg, beginPos, commaPos-beginPos));
480 }
481 beginPos = commaPos+1;
482 }
483 }
484 }
485 options->targets.push_back(target);
486 gotPattern = true;
487 }
488 }
489 // If no pattern was supplied, give an error
490 if (options->targets.size() == 0) {
491 fprintf(stderr, "No PATTERN supplied.\n\n");
492 print_usage(stderr);
493 exit(1);
494 }
495}
496
497/**
498 * Get an environment variable.
499 * Exits with an error if it is unset or the empty string.
500 */
501static string
502get_required_env(const char* name, bool quiet)
503{
504 const char* value = getenv(name);
505 if (value == NULL || value[0] == '\0') {
506 if (!quiet) {
507 fprintf(stderr, "%s not set. Did you source build/envsetup.sh,"
508 " run lunch and do a build?\n", name);
509 }
510 exit(1);
511 }
512 return string(value);
513}
514
515/**
516 * Get the out directory.
517 *
518 * This duplicates the logic in build/make/core/envsetup.mk (which hasn't changed since 2011)
519 * so that we don't have to wait for get_build_var make invocation.
520 */
521string
522get_out_dir()
523{
524 const char* out_dir = getenv("OUT_DIR");
525 if (out_dir == NULL || out_dir[0] == '\0') {
526 const char* common_base = getenv("OUT_DIR_COMMON_BASE");
527 if (common_base == NULL || common_base[0] == '\0') {
528 // We don't prefix with buildTop because we cd there and it
529 // makes all the filenames long when being pretty printed.
530 return "out";
531 } else {
Joe Onorato8a5bb632016-10-21 14:31:42 -0700532 char pwd[PATH_MAX];
533 if (getcwd(pwd, PATH_MAX) == NULL) {
534 fprintf(stderr, "Your pwd is too long.\n");
535 exit(1);
536 }
Joe Onorato0578cbc2016-10-19 17:03:06 -0700537 const char* slash = strrchr(pwd, '/');
538 if (slash == NULL) {
539 slash = "";
540 }
541 string result(common_base);
542 result += slash;
Joe Onorato0578cbc2016-10-19 17:03:06 -0700543 return result;
544 }
545 }
546 return string(out_dir);
547}
548
549/**
550 * Check that a system property on the device matches the expected value.
551 * Exits with an error if they don't.
552 */
553static void
554check_device_property(const string& property, const string& expected)
555{
556 int err;
557 string deviceValue = get_system_property(property, &err);
558 check_error(err);
559 if (deviceValue != expected) {
560 print_error("There is a mismatch between the build you just did and the device you");
561 print_error("are trying to sync it to in the %s system property", property.c_str());
562 print_error(" build: %s", expected.c_str());
563 print_error(" device: %s", deviceValue.c_str());
564 exit(1);
565 }
566}
567
568/**
569 * Run the build, install, and test actions.
570 */
571void
Joe Onorato6592c3c2016-11-12 16:34:25 -0800572run_phases(vector<Target*> targets, const Options& options)
Joe Onorato0578cbc2016-10-19 17:03:06 -0700573{
574 int err = 0;
575
576 //
577 // Initialization
578 //
579
580 print_status("Initializing");
581
582 const string buildTop = get_required_env("ANDROID_BUILD_TOP", false);
583 const string buildProduct = get_required_env("TARGET_PRODUCT", false);
584 const string buildVariant = get_required_env("TARGET_BUILD_VARIANT", false);
585 const string buildType = get_required_env("TARGET_BUILD_TYPE", false);
586 const string buildDevice = get_build_var(buildTop, "TARGET_DEVICE", false);
587 const string buildId = get_build_var(buildTop, "BUILD_ID", false);
588 const string buildOut = get_out_dir();
589
590 // TODO: print_command("cd", buildTop.c_str());
591 chdir(buildTop.c_str());
592
593 // Get the modules for the targets
594 map<string,Module> modules;
595 read_modules(buildOut, buildDevice, &modules, false);
596 for (size_t i=0; i<targets.size(); i++) {
597 Target* target = targets[i];
598 map<string,Module>::iterator mod = modules.find(target->name);
599 if (mod != modules.end()) {
600 target->module = mod->second;
601 } else {
602 print_error("Error: Could not find module: %s", target->name.c_str());
603 err = 1;
604 }
605 }
606 if (err != 0) {
607 exit(1);
608 }
609
610 // Choose the goals
611 vector<string> goals;
612 for (size_t i=0; i<targets.size(); i++) {
613 Target* target = targets[i];
614 if (target->build) {
615 goals.push_back(target->name);
616 }
617 }
618
619 // Figure out whether we need to sync the system and which apks to install
620 string systemPath = buildOut + "/target/product/" + buildDevice + "/system/";
621 string dataPath = buildOut + "/target/product/" + buildDevice + "/data/";
622 bool syncSystem = false;
623 bool alwaysSyncSystem = false;
624 vector<InstallApk> installApks;
625 for (size_t i=0; i<targets.size(); i++) {
626 Target* target = targets[i];
627 if (target->install) {
628 for (size_t j=0; j<target->module.installed.size(); j++) {
629 const string& file = target->module.installed[j];
630 // System partition
631 if (starts_with(file, systemPath)) {
632 syncSystem = true;
633 if (!target->build) {
634 // If a system partition target didn't get built then
635 // it won't change we will always need to do adb sync
636 alwaysSyncSystem = true;
637 }
638 continue;
639 }
640 // Apk in the data partition
641 if (starts_with(file, dataPath) && ends_with(file, ".apk")) {
642 // Always install it if we didn't build it because otherwise
643 // it will never have changed.
644 installApks.push_back(InstallApk(file, !target->build));
645 continue;
646 }
647 }
648 }
649 }
650 map<string,FileInfo> systemFilesBefore;
651 if (syncSystem && !alwaysSyncSystem) {
652 get_directory_contents(systemPath, &systemFilesBefore);
653 }
654
655 //
656 // Build
657 //
658
659 // Run the build
660 if (goals.size() > 0) {
661 print_status("Building");
662 err = build_goals(goals);
663 check_error(err);
664 }
665
666 //
667 // Install
668 //
669
670 // Sync the system partition and reboot
671 bool skipSync = false;
672 if (syncSystem) {
673 print_status("Syncing /system");
674
675 if (!alwaysSyncSystem) {
676 // If nothing changed and we weren't forced to sync, skip the reboot for speed.
677 map<string,FileInfo> systemFilesAfter;
678 get_directory_contents(systemPath, &systemFilesAfter);
679 skipSync = !directory_contents_differ(systemFilesBefore, systemFilesAfter);
680 }
681 if (skipSync) {
682 printf("Skipping sync because no files changed.\n");
683 } else {
684 // Do some sanity checks
685 check_device_property("ro.build.product", buildProduct);
686 check_device_property("ro.build.type", buildVariant);
687 check_device_property("ro.build.id", buildId);
688
689 // Stop & Sync
Joe Onorato6592c3c2016-11-12 16:34:25 -0800690 if (!options.noRestart) {
691 err = run_adb("shell", "stop", NULL);
692 check_error(err);
693 }
Joe Onorato0578cbc2016-10-19 17:03:06 -0700694 err = run_adb("remount", NULL);
695 check_error(err);
696 err = run_adb("sync", "system", NULL);
697 check_error(err);
698
Joe Onorato6592c3c2016-11-12 16:34:25 -0800699 if (!options.noRestart) {
700 if (options.reboot) {
701 print_status("Rebooting");
Joe Onorato0578cbc2016-10-19 17:03:06 -0700702
Joe Onorato6592c3c2016-11-12 16:34:25 -0800703 err = run_adb("reboot", NULL);
704 check_error(err);
705 err = run_adb("wait-for-device", NULL);
706 check_error(err);
707 } else {
708 print_status("Restarting the runtime");
Joe Onorato0578cbc2016-10-19 17:03:06 -0700709
Joe Onorato6592c3c2016-11-12 16:34:25 -0800710 err = run_adb("shell", "setprop", "sys.boot_completed", "0", NULL);
711 check_error(err);
712 err = run_adb("shell", "start", NULL);
713 check_error(err);
Joe Onorato0578cbc2016-10-19 17:03:06 -0700714 }
Joe Onorato6592c3c2016-11-12 16:34:25 -0800715
716 while (true) {
717 string completed = get_system_property("sys.boot_completed", &err);
718 check_error(err);
719 if (completed == "1") {
720 break;
721 }
722 sleep(2);
723 }
724 sleep(1);
725 err = run_adb("shell", "wm", "dismiss-keyguard", NULL);
726 check_error(err);
Joe Onorato0578cbc2016-10-19 17:03:06 -0700727 }
Joe Onorato0578cbc2016-10-19 17:03:06 -0700728 }
729 }
730
731 // Install APKs
732 if (installApks.size() > 0) {
733 print_status("Installing APKs");
734 for (size_t i=0; i<installApks.size(); i++) {
735 InstallApk& apk = installApks[i];
736 if (!apk.file.fileInfo.exists || apk.file.HasChanged()) {
737 // It didn't exist before or it changed, so int needs install
738 err = run_adb("install", "-r", apk.file.filename.c_str(), NULL);
739 check_error(err);
740 apk.installed = true;
741 } else {
742 printf("APK didn't change. Skipping install of %s\n", apk.file.filename.c_str());
743 }
744 }
745 }
746
747 //
748 // Actions
749 //
750
751 // Inspect the apks, and figure out what is an activity and what needs a test runner
752 bool printedInspecting = false;
753 vector<TestAction> testActions;
754 vector<ActivityAction> activityActions;
755 for (size_t i=0; i<targets.size(); i++) {
756 Target* target = targets[i];
757 if (target->test) {
758 for (size_t j=0; j<target->module.installed.size(); j++) {
759 string filename = target->module.installed[j];
760
761 if (!ends_with(filename, ".apk")) {
762 continue;
763 }
764
765 if (!printedInspecting) {
766 printedInspecting = true;
767 print_status("Inspecting APKs");
768 }
769
770 Apk apk;
771 err = inspect_apk(&apk, filename);
772 check_error(err);
773
774 for (size_t k=0; k<target->actions.size(); k++) {
775 string actionString = target->actions[k];
776 if (actionString == "*") {
777 if (apk.runner.length() == 0) {
778 print_error("Error: Test requested for apk that doesn't"
779 " have an <instrumentation> tag: %s\n",
780 target->module.name.c_str());
781 exit(1);
782 }
783 TestAction action;
784 action.packageName = apk.package;
785 action.runner = apk.runner;
786 action.target = target;
787 testActions.push_back(action);
788 target->testActionCount++;
789 } else if (apk.HasActivity(actionString)) {
790 ActivityAction action;
791 action.packageName = apk.package;
792 action.className = full_class_name(apk.package, actionString);
793 activityActions.push_back(action);
794 } else {
795 if (apk.runner.length() == 0) {
796 print_error("Error: Test requested for apk that doesn't"
797 " have an <instrumentation> tag: %s\n",
798 target->module.name.c_str());
799 exit(1);
800 }
801 TestAction action;
802 action.packageName = apk.package;
803 action.runner = apk.runner;
804 action.className = full_class_name(apk.package, actionString);
805 action.target = target;
806 testActions.push_back(action);
807 target->testActionCount++;
808 }
809 }
810 }
811 }
812 }
813
814 // Run the instrumentation tests
815 TestResults testResults;
816 if (testActions.size() > 0) {
817 print_status("Running tests");
818 for (size_t i=0; i<testActions.size(); i++) {
819 TestAction& action = testActions[i];
820 testResults.SetCurrentAction(&action);
821 err = run_instrumentation_test(action.packageName, action.runner, action.className,
822 &testResults);
823 check_error(err);
824 if (action.passCount == 0 && action.failCount == 0) {
825 action.target->actionsWithNoTests = true;
826 }
827 int total = action.passCount + action.failCount;
828 printf("%sRan %d test%s for %s. ", g_escapeClearLine,
829 total, total > 1 ? "s" : "", action.target->name.c_str());
830 if (action.passCount == 0 && action.failCount == 0) {
831 printf("%s%d passed, %d failed%s\n", g_escapeYellowBold, action.passCount,
832 action.failCount, g_escapeEndColor);
833 } else if (action.failCount > 0) {
834 printf("%d passed, %s%d failed%s\n", action.passCount, g_escapeRedBold,
835 action.failCount, g_escapeEndColor);
836 } else {
837 printf("%s%d passed%s, %d failed\n", g_escapeGreenBold, action.passCount,
838 g_escapeEndColor, action.failCount);
839 }
840 }
841 }
842
843 // Launch the activity
844 if (activityActions.size() > 0) {
845 print_status("Starting activity");
846
847 if (activityActions.size() > 1) {
848 print_warning("Multiple activities specified. Will only start the first one:");
849 for (size_t i=0; i<activityActions.size(); i++) {
850 ActivityAction& action = activityActions[i];
851 print_warning(" %s",
852 pretty_component_name(action.packageName, action.className).c_str());
853 }
854 }
855
856 const ActivityAction& action = activityActions[0];
857 string componentName = action.packageName + "/" + action.className;
858 err = run_adb("shell", "am", "start", componentName.c_str(), NULL);
859 check_error(err);
860 }
861
862 //
863 // Print summary
864 //
865
866 printf("\n%s--------------------------------------------%s\n", g_escapeBold, g_escapeEndColor);
867
868 // Build
869 if (goals.size() > 0) {
870 printf("%sBuilt:%s\n", g_escapeBold, g_escapeEndColor);
871 for (size_t i=0; i<goals.size(); i++) {
872 printf(" %s\n", goals[i].c_str());
873 }
874 }
875
876 // Install
877 if (syncSystem) {
878 if (skipSync) {
879 printf("%sSkipped syncing /system partition%s\n", g_escapeBold, g_escapeEndColor);
880 } else {
881 printf("%sSynced /system partition%s\n", g_escapeBold, g_escapeEndColor);
882 }
883 }
884 if (installApks.size() > 0) {
885 bool printedTitle = false;
886 for (size_t i=0; i<installApks.size(); i++) {
887 const InstallApk& apk = installApks[i];
888 if (apk.installed) {
889 if (!printedTitle) {
890 printf("%sInstalled:%s\n", g_escapeBold, g_escapeEndColor);
891 printedTitle = true;
892 }
893 printf(" %s\n", apk.file.filename.c_str());
894 }
895 }
896 printedTitle = false;
897 for (size_t i=0; i<installApks.size(); i++) {
898 const InstallApk& apk = installApks[i];
899 if (!apk.installed) {
900 if (!printedTitle) {
901 printf("%sSkipped install:%s\n", g_escapeBold, g_escapeEndColor);
902 printedTitle = true;
903 }
904 printf(" %s\n", apk.file.filename.c_str());
905 }
906 }
907 }
908
909 // Tests
910 if (testActions.size() > 0) {
911 printf("%sRan tests:%s\n", g_escapeBold, g_escapeEndColor);
912 size_t maxNameLength = 0;
913 for (size_t i=0; i<targets.size(); i++) {
914 Target* target = targets[i];
915 if (target->test) {
916 size_t len = target->name.length();
917 if (len > maxNameLength) {
918 maxNameLength = len;
919 }
920 }
921 }
922 string padding(maxNameLength, ' ');
923 for (size_t i=0; i<targets.size(); i++) {
924 Target* target = targets[i];
925 if (target->testActionCount > 0) {
926 printf(" %s%s", target->name.c_str(), padding.c_str() + target->name.length());
927 if (target->actionsWithNoTests) {
928 printf(" %s%d passed, %d failed%s\n", g_escapeYellowBold,
929 target->testPassCount, target->testFailCount, g_escapeEndColor);
930 } else if (target->testFailCount > 0) {
931 printf(" %d passed, %s%d failed%s\n", target->testPassCount,
932 g_escapeRedBold, target->testFailCount, g_escapeEndColor);
933 } else {
934 printf(" %s%d passed%s, %d failed\n", g_escapeGreenBold,
935 target->testPassCount, g_escapeEndColor, target->testFailCount);
936 }
937 }
938 }
939 }
940 if (activityActions.size() > 1) {
941 printf("%sStarted Activity:%s\n", g_escapeBold, g_escapeEndColor);
942 const ActivityAction& action = activityActions[0];
943 printf(" %s\n", pretty_component_name(action.packageName, action.className).c_str());
944 }
945
946 printf("%s--------------------------------------------%s\n", g_escapeBold, g_escapeEndColor);
947}
948
949/**
950 * Implement tab completion of the target names from the all modules file.
951 */
952void
953run_tab_completion(const string& word)
954{
955 const string buildTop = get_required_env("ANDROID_BUILD_TOP", true);
956 const string buildProduct = get_required_env("TARGET_PRODUCT", false);
957 const string buildOut = get_out_dir();
958
959 chdir(buildTop.c_str());
960
961 string buildDevice = sniff_device_name(buildOut, buildProduct);
962
963 map<string,Module> modules;
964 read_modules(buildOut, buildDevice, &modules, true);
965
966 for (map<string,Module>::const_iterator it = modules.begin(); it != modules.end(); it++) {
967 if (starts_with(it->first, word)) {
968 printf("%s\n", it->first.c_str());
969 }
970 }
971}
972
973/**
974 * Main entry point.
975 */
976int
977main(int argc, const char** argv)
978{
979 GOOGLE_PROTOBUF_VERIFY_VERSION;
980 init_print();
981
982 Options options;
983 parse_args(&options, argc, argv);
984
985 if (options.runHelp) {
986 // Help
987 print_usage(stdout);
988 exit(0);
989 } else if (options.runTab) {
990 run_tab_completion(options.tabPattern);
991 exit(0);
992 } else {
993 // Normal run
Joe Onorato6592c3c2016-11-12 16:34:25 -0800994 run_phases(options.targets, options);
Joe Onorato0578cbc2016-10-19 17:03:06 -0700995 }
996
997 return 0;
998}
999