3 # Copyright (c) 2013, 2014 Intel Corporation. All rights reserved.
4 # Use of this source code is governed by a BSD-style license that can be
5 # found in the LICENSE file.
15 from customize import ReplaceSpaceWithUnderscore
18 def Clean(name, app_version):
19 if os.path.exists(name):
21 if options.mode == 'shared':
22 if os.path.isfile(name + '_' + app_version + '.apk'):
23 os.remove(name + '_' + app_version + '.apk')
25 if os.path.isfile(name + '_' + app_version + '_x86.apk'):
26 os.remove(name + '_' + app_version + '_x86.apk')
27 if os.path.isfile(name + '_' + app_version + '_arm.apk'):
28 os.remove(name + '_' + app_version + '_arm.apk')
31 def CompareSizeForCompressor(mode, original, ext, name, fun):
34 mode_list = ['all', 'js', 'css']
36 www_dir = os.path.join(name, 'assets', 'www')
37 if os.path.exists(www_dir):
38 size = GetFileSize(original)
39 compressed_file = os.path.join(www_dir, ext, 'test.' + ext)
40 compressed_size = GetFileSize(compressed_file)
43 fun(compressed_size < size)
45 fun(size == compressed_size)
47 print('Error: %s is not exist.' % www_dir)
50 def GetFileSize(file_path):
52 if os.path.exists(file_path):
53 size = os.path.getsize(file_path)
57 def RunCommand(command):
58 """Runs the command list, return the output."""
59 proc = subprocess.Popen(command, stdout=subprocess.PIPE,
60 stderr=subprocess.STDOUT, shell=False)
61 return proc.communicate()[0]
64 def GetResultWithOption(mode=None, manifest=None, name=None, package=None):
66 if manifest is not None:
67 manifest = '--manifest=' + manifest
69 app_url = '--app-url=http://www.intel.com'
71 name = '--name=' + name
72 if package is not None:
73 package = '--package=' + package
75 cmd = ['python', 'make_apk.py',
76 '--app-version=1.0.0',
82 return RunCommand(cmd)
85 class TestMakeApk(unittest.TestCase):
88 cls._original_dir = os.getcwd()
90 target_dir = os.path.expanduser(options.tool_path)
91 elif options.build_dir and options.target:
92 target_dir = os.path.join(options.build_dir,
95 if os.path.exists(target_dir):
96 # Prepare the test data.
97 test_src_dir = os.path.join(os.path.dirname(os.path.realpath(__file__)),
99 test_des_dir = os.path.join(target_dir, 'test_data')
100 if not os.path.exists(test_des_dir):
101 shutil.copytree(test_src_dir, test_des_dir)
104 unittest.SkipTest('xwalk_app_template folder doesn\'t exist. '
105 'Skipping all tests in make_apk_test.py')
107 if options.mode == 'shared':
108 cls._mode = '--mode=shared'
109 elif options.mode == 'embedded':
110 cls._mode = '--mode=embedded'
111 cls.fakeNativeLibrary()
114 def tearDownClass(cls):
115 # Clean the test data.
116 if options.tool_path:
117 test_data_dir = os.path.join(os.path.expanduser(options.tool_path),
119 elif options.build_dir and options.target:
120 test_data_dir = os.path.join(options.build_dir,
122 'xwalk_app_template',
124 if os.path.exists(test_data_dir):
125 shutil.rmtree(test_data_dir)
126 cls.restoreNativeLibrary()
127 os.chdir(cls._original_dir)
130 def fakeNativeLibrary():
131 # To reduce the time consumption of make_apk test for embedded mode,
132 # replace the original native library with an empty library.
133 # Because it doesn't affect the result of test.
134 if options.mode == 'embedded':
135 native_library_dir = os.path.join('xwalk_core_library', 'libs')
136 native_library_temp_dir = 'temp'
137 shutil.copytree(native_library_dir, native_library_temp_dir)
138 for root, _, files in os.walk(native_library_dir):
139 if 'libxwalkcore.so' in files:
140 native_library_path = os.path.join(root, 'libxwalkcore.so')
141 # Remove the original library
142 os.remove(native_library_path)
143 # Create an empty library file
144 open(native_library_path, 'a').close()
147 def restoreNativeLibrary():
148 # Restore the original native library for embedded mode.
149 if options.mode == 'embedded':
150 native_library_dir = os.path.join('xwalk_core_library', 'libs')
151 native_library_temp_dir = 'temp'
152 if os.path.isdir(native_library_dir):
153 shutil.rmtree(native_library_dir)
154 shutil.move(native_library_temp_dir, native_library_dir)
158 x86_native_lib_path = os.path.join('xwalk_core_library', 'libs',
159 'x86', 'libxwalkcore.so')
160 arm_native_lib_path = os.path.join('xwalk_core_library', 'libs',
161 'armeabi-v7a', 'libxwalkcore.so')
163 if os.path.isfile(x86_native_lib_path):
164 arch_list.append('x86')
165 if os.path.isfile(arm_native_lib_path):
166 arch_list.append('arm')
169 def checkApks(self, apk_name, app_version):
170 # Check whether some files are contained in the given APK.
171 if self._mode.find('shared') != -1:
172 apk_path = '%s_%s.apk' % (apk_name, app_version)
173 self.checkApk(apk_path, '')
174 elif self._mode.find('embedded') != -1:
175 x86_apk_path = '%s_%s_x86.apk' % (apk_name, app_version)
176 if os.path.exists(x86_apk_path):
177 self.checkApk(x86_apk_path, 'x86')
178 arm_apk_path = '%s_%s_arm.apk' % (apk_name, app_version)
179 if os.path.exists(arm_apk_path):
180 self.checkApk(arm_apk_path, 'arm')
182 def checkApk(self, apk_path, arch):
183 # Check whether some files are contained in the given apk
184 # for specified arch.
185 cmd = ['jar', 'tvf', apk_path]
186 out = RunCommand(cmd)
187 common_files = ['AndroidManifest.xml', 'classes.dex']
188 for res_file in common_files:
189 self.assertTrue(out.find(res_file) != -1)
190 if self._mode.find('embedded') != -1:
191 embedded_related_files = ['icudtl.dat',
193 'device_capabilities_api.js',
194 'launch_screen_api.js',
195 'presentation_api.js']
196 for res_file in embedded_related_files:
197 self.assertTrue(out.find(res_file) != -1)
199 self.assertTrue(out.find('x86/libxwalkcore.so') != -1)
201 self.assertTrue(out.find('armeabi-v7a/libxwalkcore.so') != -1)
204 cmd = ['python', 'make_apk.py', '--app-version=1.0.0',
205 '--app-url=http://www.intel.com',
206 '--package=org.xwalk.example', self._mode]
207 out = RunCommand(cmd)
208 Clean('Example', '1.0.0')
209 self.assertIn('An APK name is required', out)
211 cmd = ['python', 'make_apk.py', '--name=Test_Example',
212 '--app-version=1.0.0', '--app-url=http://www.intel.com',
213 '--package=org.xwalk.example', self._mode]
214 out = RunCommand(cmd)
215 self.assertNotIn('An APK name is required', out)
216 Clean('Test_Example', '1.0.0')
218 invalid_chars = '\/:.*?"<>|-'
219 for c in invalid_chars:
220 invalid_name = '--name=Example' + c
221 cmd = ['python', 'make_apk.py', invalid_name,
222 '--app-version=1.0.0', '--package=org.xwalk.example',
223 '--app-url=http://www.intel.com', self._mode]
224 out = RunCommand(cmd)
225 self.assertTrue(out.find('invalid characters') != -1)
227 def testToolVersion(self):
228 cmd = ['python', 'make_apk.py', '--version']
229 out = RunCommand(cmd)
230 self.assertTrue(out.find('Crosswalk app packaging tool version') != -1)
232 def testAppDescriptionAndVersion(self):
233 cmd = ['python', 'make_apk.py', '--name=Example',
234 '--package=org.xwalk.example', '--app-version=1.0.0',
235 '--description=a sample application',
236 '--app-url=http://www.intel.com', self._mode]
238 self.addCleanup(Clean, 'Example', '1.0.0')
239 manifest = 'Example/AndroidManifest.xml'
240 with open(manifest, 'r') as content_file:
241 content = content_file.read()
242 self.assertTrue(os.path.exists(manifest))
243 self.assertTrue(content.find('description') != -1)
244 self.assertTrue(content.find('versionName') != -1)
245 self.checkApks('Example', '1.0.0')
247 def testAppVersionCode(self):
248 cmd = ['python', 'make_apk.py', '--name=Example',
249 '--package=org.xwalk.example', '--app-version=1.0.0',
250 '--description=a sample application',
251 '--app-versionCode=3',
252 '--app-url=http://www.intel.com', self._mode]
254 self.addCleanup(Clean, 'Example', '1.0.0')
255 manifest = 'Example/AndroidManifest.xml'
256 with open(manifest, 'r') as content_file:
257 content = content_file.read()
258 self.assertTrue(os.path.exists(manifest))
259 self.assertTrue(content.find('versionCode="3"') != -1)
260 self.checkApks('Example', '1.0.0')
262 def testAppVersionCodeBase(self):
263 # Arch option only works for embedded mode,
264 # so only test it for embedded mode.
265 if self._mode.find('embedded') == -1:
267 if 'x86' in self.archs():
269 versionCode = 'versionCode="60000003"'
272 versionCode = 'versionCode="20000003"'
273 cmd = ['python', 'make_apk.py', '--name=Example',
274 '--package=org.xwalk.example', '--app-version=1.0.0',
275 '--description=a sample application',
276 '--app-versionCodeBase=3',
278 '--app-url=http://www.intel.com', self._mode]
280 self.addCleanup(Clean, 'Example', '1.0.0')
281 manifest = 'Example/AndroidManifest.xml'
282 with open(manifest, 'r') as content_file:
283 content = content_file.read()
284 self.assertTrue(os.path.exists(manifest))
285 self.assertTrue(content.find(versionCode) != -1)
286 self.checkApks('Example', '1.0.0')
288 def testAppBigVersionCodeBase(self):
289 # Arch option only works for embedded mode,
290 # so only test it for embedded mode.
291 if self._mode.find('embedded') == -1:
293 if 'x86' in self.archs():
297 cmd = ['python', 'make_apk.py', '--name=Example',
298 '--package=org.xwalk.example', '--app-version=1.0.0',
299 '--description=a sample application',
300 '--app-versionCodeBase=30000000',
302 '--app-url=http://www.intel.com', self._mode]
304 self.addCleanup(Clean, 'Example', '1.0.0')
305 manifest = 'Example/AndroidManifest.xml'
306 self.assertFalse(os.path.exists(manifest))
308 def testPermissions(self):
309 cmd = ['python', 'make_apk.py', '--name=Example', '--app-version=1.0.0',
310 '--package=org.xwalk.example', '--permissions=geolocation',
311 '--app-url=http://www.intel.com', self._mode]
313 self.addCleanup(Clean, 'Example', '1.0.0')
314 manifest = 'Example/AndroidManifest.xml'
315 with open(manifest, 'r') as content_file:
316 content = content_file.read()
317 self.assertTrue(os.path.exists(manifest))
318 self.assertTrue(content.find('ACCESS_FINE_LOCATION') != -1)
319 self.checkApks('Example', '1.0.0')
321 def testPermissionsWithError(self):
322 cmd = ['python', 'make_apk.py', '--name=Example', '--app-version=1.0.0',
323 '--package=org.xwalk.example', '--permissions=UndefinedPermission',
324 '--app-url=http://www.intel.com', self._mode]
325 out = RunCommand(cmd)
326 self.assertTrue(out.find('related API is not supported.') != -1)
327 cmd = ['python', 'make_apk.py', '--name=Example', '--app-version=1.0.0',
328 '--package=org.xwalk.example',
329 '--permissions=Contacts.Geolocation.Messaging',
330 '--app-url=http://www.intel.com', self._mode]
331 out = RunCommand(cmd)
332 self.assertTrue(out.find('related API is not supported.') != -1)
334 def testPackage(self):
335 cmd = ['python', 'make_apk.py', '--name=Example', '--app-version=1.0.0',
336 '--app-url=http://www.intel.com', self._mode]
337 out = RunCommand(cmd)
338 self.assertIn('A package name is required', out)
340 cmd = ['python', 'make_apk.py', '--name=Example', '--app-version=1.0.0',
341 '--package=org.xwalk.example',
342 '--app-url=http://www.intel.com', self._mode]
343 out = RunCommand(cmd)
344 self.assertNotIn('A package name is required', out)
345 Clean('Example', '1.0.0')
347 def testPackageWithInvalidCharacter(self):
348 package_name_error = 'package name should be started with letters'
350 cmd = ['python', 'make_apk.py', '--name=Example', '--app-version=1.0.0',
351 '--package=org.xwalk._example',
352 '--app-url=http://www.intel.com', self._mode]
353 out = RunCommand(cmd)
354 self.assertIn(package_name_error, out)
356 cmd = ['python', 'make_apk.py', '--name=Example', '--app-version=1.0.0',
357 '--package=org.xwalk.123example',
358 '--app-url=http://www.intel.com', self._mode]
359 out = RunCommand(cmd)
360 self.assertIn(package_name_error, out)
362 cmd = ['python', 'make_apk.py', '--name=Example', '--app-version=1.0.0',
363 '--package=org.xwalk.example_',
364 '--app-url=http://www.intel.com', self._mode]
365 out = RunCommand(cmd)
366 self.assertNotIn(package_name_error, out)
367 Clean('Example', '1.0.0')
370 cmd = ['python', 'make_apk.py', '--name=Example', '--app-version=1.0.0',
371 '--package=org.xwalk.example', '--app-url=http://www.intel.com',
373 out = RunCommand(cmd)
374 self.assertNotIn('You must pass either "--app-url" or',
376 self.assertNotIn('You must specify both "--app-local-path" and',
378 self.addCleanup(Clean, 'Example', '1.0.0')
379 self.checkApks('Example', '1.0.0')
380 Clean('Example', '1.0.0')
382 test_entry_root = 'test_data/entry'
383 cmd = ['python', 'make_apk.py', '--name=Example', '--app-version=1.0.0',
384 '--package=org.xwalk.example', '--app-root=%s' % test_entry_root,
385 '--app-local-path=index.html', self._mode]
386 out = RunCommand(cmd)
387 self.assertNotIn('You must pass either "--app-url" or',
389 self.assertNotIn('You must specify both "--app-local-path" and',
391 self.checkApks('Example', '1.0.0')
393 def testEntryWithErrors(self):
394 cmd = ['python', 'make_apk.py', '--name=Example', '--app-version=1.0.0',
395 '--package=org.xwalk.example', self._mode]
396 out = RunCommand(cmd)
397 self.addCleanup(Clean, 'Example', '1.0.0')
398 self.assertIn('You must pass either "--app-url" or',
401 self.assertFalse(os.path.exists('Example.apk'))
402 Clean('Example', '1.0.0')
404 cmd = ['python', 'make_apk.py', '--name=Example', '--app-version=1.0.0',
405 '--package=org.xwalk.example', '--app-url=http://www.intel.com',
406 '--app-root=.', self._mode]
407 out = RunCommand(cmd)
408 self.assertIn('You must pass either "--app-url" or',
410 self.assertFalse(os.path.exists('Example.apk'))
411 Clean('Example', '1.0.0')
413 cmd = ['python', 'make_apk.py', '--name=Example', '--app-version=1.0.0',
414 '--package=org.xwalk.example', '--app-root=./', self._mode]
415 out = RunCommand(cmd)
416 self.assertIn('You must specify both "--app-local-path" and',
418 self.assertFalse(os.path.exists('Example.apk'))
419 Clean('Example', '1.0.0')
421 cmd = ['python', 'make_apk.py', '--name=Example', '--app-version=1.0.0',
422 '--package=org.xwalk.example', '--app-local-path=index.html',
424 out = RunCommand(cmd)
425 self.assertIn('You must specify both "--app-local-path" and',
427 self.assertFalse(os.path.exists('Example.apk'))
428 Clean('Example', '1.0.0')
430 manifest_path = os.path.join('test_data', 'manifest',
431 'manifest_app_launch_local_path.json')
432 cmd = ['python', 'make_apk.py', '--package=org.xwalk.example',
433 '--manifest=%s' % manifest_path, self._mode]
434 out = RunCommand(cmd)
436 out.find('Please make sure that the local path file') != -1)
437 self.assertFalse(os.path.exists('Example.apk'))
439 def testIconByOption(self):
440 icon = os.path.join('test_data', 'manifest', 'icons', 'icon_96.png')
441 cmd = ['python', 'make_apk.py', '--name=Example', '--app-version=1.0.0',
442 '--package=org.xwalk.example', '--app-url=http://www.intel.com',
443 '--icon=%s' % icon, self._mode]
445 self.addCleanup(Clean, 'Example', '1.0.0')
446 manifest = 'Example/AndroidManifest.xml'
447 with open(manifest, 'r') as content_file:
448 content = content_file.read()
449 self.assertTrue(content.find('drawable/icon_96') != -1)
450 self.checkApks('Example', '1.0.0')
452 def testIconByManifest(self):
453 manifest_path = os.path.join('test_data', 'manifest', 'manifest_icon.json')
454 cmd = ['python', 'make_apk.py', '--name=Example', '--app-version=1.0.0',
455 '--package=org.xwalk.example', '--app-url=http://www.intel.com',
456 '--manifest=%s' % manifest_path, self._mode]
458 self.addCleanup(Clean, 'Example', '1.0.0')
459 manifest = 'Example/AndroidManifest.xml'
460 with open(manifest, 'r') as content_file:
461 content = content_file.read()
462 self.assertTrue(content.find('drawable/icon') != -1)
463 self.checkApks('Example', '1.0.0')
465 def testFullscreen(self):
466 cmd = ['python', 'make_apk.py', '--name=Example', '--app-version=1.0.0',
467 '--package=org.xwalk.example', '--app-url=http://www.intel.com',
470 self.addCleanup(Clean, 'Example', '1.0.0')
471 theme = 'Example/res/values-v14/theme.xml'
472 with open(theme, 'r') as content_file:
473 content = content_file.read()
474 self.assertTrue(os.path.exists(theme))
477 '<item name="android:windowFullscreen">true</item>') != -1)
478 self.checkApks('Example', '1.0.0')
480 def testEnableRemoteDebugging(self):
481 cmd = ['python', 'make_apk.py', '--name=Example', '--app-version=1.0.0',
482 '--package=org.xwalk.example', '--app-url=http://www.intel.com',
483 '--enable-remote-debugging', self._mode]
485 self.addCleanup(Clean, 'Example', '1.0.0')
486 activity = 'Example/src/org/xwalk/example/ExampleActivity.java'
487 with open(activity, 'r') as content_file:
488 content = content_file.read()
489 self.assertTrue(os.path.exists(activity))
490 self.assertTrue(content.find('setRemoteDebugging') != -1)
491 self.checkApks('Example', '1.0.0')
492 Clean('Example', '1.0.0')
493 manifest_path = os.path.join('test_data', 'manifest', 'manifest.json')
494 cmd = ['python', 'make_apk.py', '--enable-remote-debugging',
495 '--package=org.xwalk.example',
496 '--manifest=%s' % manifest_path, self._mode]
498 activity = 'Example/src/org/xwalk/example/ExampleActivity.java'
499 with open(activity, 'r') as content_file:
500 content = content_file.read()
501 self.assertTrue(os.path.exists(activity))
502 self.assertTrue(content.find('setRemoteDebugging') != -1)
503 self.checkApks('Example', '1.0.0')
505 def testKeystore(self):
506 keystore_path = os.path.join('test_data', 'keystore',
507 'xwalk-test.keystore')
508 cmd = ['python', 'make_apk.py', '--name=Example', '--app-version=1.0.0',
509 '--package=org.xwalk.example', '--app-url=http://www.intel.com',
510 '--keystore-path=%s' % keystore_path, '--keystore-alias=xwalk-test',
511 '--keystore-passcode=xwalk-test',
512 '--keystore-alias-passcode=xwalk-test', self._mode]
514 self.addCleanup(Clean, 'Example', '1.0.0')
515 self.assertTrue(os.path.exists('Example'))
516 apk_list = ['Example.apk', 'Example_x86.apk', 'Example_arm.apk']
518 if os.path.isfile(apk):
519 cmd = ['jarsigner', '-verify', '-keystore',
520 keystore_path, '-verbose', apk]
521 out = RunCommand(cmd)
522 self.assertTrue(out.find('smk') != -1)
523 self.checkApks('Example', '1.0.0')
525 def testManifest(self):
526 manifest_path = os.path.join('test_data', 'manifest', 'manifest.json')
527 cmd = ['python', 'make_apk.py', '--package=org.xwalk.example',
528 '--manifest=%s' % manifest_path, self._mode]
530 self.addCleanup(Clean, 'Example', '1.0.0')
531 manifest = 'Example/AndroidManifest.xml'
532 with open(manifest, 'r') as content_file:
533 content = content_file.read()
534 self.assertTrue(os.path.exists(manifest))
535 self.assertTrue(content.find('android.permission.READ_CONTACTS') != -1)
536 self.assertTrue(content.find('android.permission.WRITE_CONTACTS') != -1)
538 content.find('android.permission.ACCESS_FINE_LOCATION') != -1)
539 self.assertTrue(content.find('android.permission.READ_SMS') != -1)
540 self.assertTrue(content.find('android.permission.RECEIVE_SMS') != -1)
541 self.assertTrue(content.find('android.permission.SEND_SMS') != -1)
542 self.assertTrue(content.find('android.permission.WRITE_SMS') != -1)
543 self.assertTrue(content.find('landscape') != -1)
544 theme = 'Example/res/values-v14/theme.xml'
545 with open(theme, 'r') as content_file:
546 content = content_file.read()
547 self.assertTrue(os.path.exists(theme))
550 '<item name="android:windowFullscreen">true</item>') != -1)
551 self.assertTrue(os.path.exists('Example'))
552 self.checkApks('Example', '1.0.0')
554 def testManifestWithSpecificValue(self):
555 manifest_path = os.path.join('test_data', 'manifest',
556 'manifest_app_launch_local_path.json')
557 cmd = ['python', 'make_apk.py', '--package=org.xwalk.example',
558 '--manifest=%s' % manifest_path, self._mode]
559 out = RunCommand(cmd)
560 self.addCleanup(Clean, 'Example', '1.0.0')
561 self.assertTrue(out.find('no app launch path') == -1)
562 self.checkApks('Example', '1.0.0')
564 def testManifestWithDeprecatedField(self):
565 manifest_path = os.path.join('test_data', 'manifest', 'deprecated',
566 'manifest_app_local_path.json')
567 cmd = ['python', 'make_apk.py', '--package=org.xwalk.example',
568 '--manifest=%s' % manifest_path, self._mode]
569 out = RunCommand(cmd)
570 self.addCleanup(Clean, 'Example', '1.0.0')
571 self.assertIn('WARNING: app.launch.local_path is deprecated for Crosswalk',
573 Clean('Example', '1.0.0')
575 manifest_path = os.path.join('test_data', 'manifest', 'deprecated',
576 'manifest_launch_path.json')
577 cmd = ['python', 'make_apk.py', '--package=org.xwalk.example',
578 '--manifest=%s' % manifest_path, self._mode]
579 out = RunCommand(cmd)
580 self.assertIn('WARNING: launch_path is deprecated for Crosswalk', out)
581 Clean('Example', '1.0.0')
583 manifest_path = os.path.join('test_data', 'manifest', 'deprecated',
584 'manifest_permissions.json')
585 cmd = ['python', 'make_apk.py', '--package=org.xwalk.example',
586 '--manifest=%s' % manifest_path, self._mode]
587 out = RunCommand(cmd)
588 self.assertIn('WARNING: permissions is deprecated for Crosswalk', out)
589 Clean('Example', '1.0.0')
591 manifest_path = os.path.join('test_data', 'manifest',
592 'manifest_deprecated_icon.json')
593 cmd = ['python', 'make_apk.py', '--package=org.xwalk.example',
594 '--manifest=%s' % manifest_path, self._mode]
595 out = RunCommand(cmd)
596 self.assertIn('WARNING: icons defined as dictionary form is deprecated',
598 Clean('Example', '1.0.0')
600 manifest_path = os.path.join('test_data', 'manifest', 'deprecated',
601 'manifest_description.json')
602 cmd = ['python', 'make_apk.py', '--package=org.xwalk.example',
603 '--manifest=%s' % manifest_path, self._mode]
604 out = RunCommand(cmd)
605 self.assertIn('WARNING: description is deprecated for Crosswalk', out)
606 Clean('Example', '1.0.0')
608 manifest_path = os.path.join('test_data', 'manifest', 'deprecated',
609 'manifest_deprecated_version.json')
610 cmd = ['python', 'make_apk.py', '--package=org.xwalk.example',
611 '--manifest=%s' % manifest_path, self._mode]
612 out = RunCommand(cmd)
613 self.assertIn('WARNING: version is deprecated for Crosswalk', out)
615 def testManifestWithError(self):
616 manifest_path = os.path.join('test_data', 'manifest',
617 'manifest_no_app_launch_path.json')
618 cmd = ['python', 'make_apk.py', '--package=org.xwalk.example',
619 '--manifest=%s' % manifest_path, '--verbose', self._mode]
620 out = RunCommand(cmd)
621 self.assertTrue(out.find('no app launch path') != -1)
622 manifest_path = os.path.join('test_data', 'manifest',
623 'manifest_no_name.json')
624 cmd = ['python', 'make_apk.py', '--package=org.xwalk.example',
625 '--manifest=%s' % manifest_path, '--verbose', self._mode]
626 out = RunCommand(cmd)
627 self.assertTrue(out.find('no \'name\' field') != -1)
628 manifest_path = os.path.join('test_data', 'manifest',
629 'manifest_permissions_format_error.json')
630 cmd = ['python', 'make_apk.py', '--package=org.xwalk.example',
631 '--manifest=%s' % manifest_path, '--verbose', self._mode]
632 out = RunCommand(cmd)
633 self.assertTrue(out.find('\'Permissions\' field error') != -1)
634 manifest_path = os.path.join('test_data', 'manifest',
635 'manifest_permissions_field_error.json')
636 cmd = ['python', 'make_apk.py', '--package=org.xwalk.example',
637 '--manifest=%s' % manifest_path, '--verbose', self._mode]
638 out = RunCommand(cmd)
639 self.assertTrue(out.find('\'Permissions\' field error') != -1)
640 manifest_path = os.path.join('test_data', 'manifest',
641 'manifest_not_supported_permission.json')
642 cmd = ['python', 'make_apk.py', '--package=org.xwalk.example',
643 '--manifest=%s' % manifest_path, '--verbose', self._mode]
644 out = RunCommand(cmd)
646 out.find('\'Telephony\' related API is not supported') != -1)
648 def testExtensionsWithOneExtension(self):
649 # Test with an existed extension.
650 extension_path = 'test_data/extensions/myextension'
651 cmd = ['python', 'make_apk.py', '--name=Example', '--app-version=1.0.0',
652 '--package=org.xwalk.example', '--app-url=http://www.intel.com',
653 '--extensions=%s' % extension_path, self._mode]
655 self.addCleanup(Clean, 'Example', '1.0.0')
656 self.assertTrue(os.path.exists('Example'))
657 extensions_config_json = 'Example/assets/extensions-config.json'
658 self.assertTrue(os.path.exists(extensions_config_json))
659 with open(extensions_config_json, 'r') as content_file:
660 content = content_file.read()
662 content.find('xwalk-extensions/myextension/myextension.js'))
663 self.assertTrue(content.find('com.example.extension.MyExtension'))
664 extension_js = 'Example/assets/xwalk-extensions/myextension/myextension.js'
665 self.assertTrue(os.path.exists(extension_js))
666 extension_jar = 'Example/xwalk-extensions/myextension/myextension.jar'
667 self.assertTrue(os.path.exists(extension_jar))
668 self.checkApks('Example', '1.0.0')
670 def testExtensionsWithNonExtension(self):
671 # Test with a non-existed extension.
672 extension_path = 'test_data/extensions/myextension'
673 cmd = ['python', 'make_apk.py', '--name=Example', '--app-version=1.0.0',
674 '--package=org.xwalk.example', '--app-url=http://www.intel.com',
675 '--extensions=%s1' % extension_path, self._mode, '--verbose']
676 out = RunCommand(cmd)
677 error_msg = 'Error: can\'t find the extension directory'
678 self.assertTrue(out.find(error_msg) != -1)
679 self.assertTrue(out.find('Exiting with error code: 9') != -1)
681 def testExtensionWithPermissions(self):
682 test_entry_root = 'test_data/entry'
683 # Add redundant separators for test.
684 extension_path = 'test_data//extensions/contactextension/'
685 cmd = ['python', 'make_apk.py', '--name=Example', '--app-version=1.0.0',
686 '--package=org.xwalk.example', '--app-root=%s' % test_entry_root,
687 '--app-local-path=contactextension.html',
688 '--extensions=%s' % extension_path, self._mode]
690 self.addCleanup(Clean, 'Example', '1.0.0')
691 self.assertTrue(os.path.exists('Example'))
692 manifest = 'Example/AndroidManifest.xml'
693 with open(manifest, 'r') as content_file:
694 content = content_file.read()
695 self.assertTrue(os.path.exists(manifest))
696 self.assertTrue(content.find('android.permission.WRITE_CONTACTS') != -1)
697 self.assertTrue(content.find('android.permission.READ_CONTACTS') != -1)
698 self.checkApks('Example', '1.0.0')
701 xpk_file = os.path.join('test_data', 'xpk', 'example.xpk')
702 cmd = ['python', 'make_apk.py', '--package=org.xwalk.example',
703 '--xpk=%s' % xpk_file, self._mode]
705 self.addCleanup(Clean, 'Example', '1.0.0')
706 self.assertTrue(os.path.exists('Example'))
707 self.checkApks('Example', '1.0.0')
709 def testXPKWithError(self):
710 xpk_file = os.path.join('test_data', 'xpk', 'error.xpk')
711 cmd = ['python', 'make_apk.py', '--package=org.xwalk.example',
712 '--xpk=%s' % xpk_file, self._mode]
713 out = RunCommand(cmd)
714 error_msg = 'XPK doesn\'t contain manifest file'
715 self.assertTrue(out.find(error_msg) != -1)
716 self.assertFalse(os.path.exists('Example'))
718 def testOrientation(self):
719 cmd = ['python', 'make_apk.py', '--name=Example', '--app-version=1.0.0',
720 '--package=org.xwalk.example', '--app-url=http://www.intel.com',
721 '--orientation=landscape', self._mode]
723 self.addCleanup(Clean, 'Example', '1.0.0')
724 manifest = 'Example/AndroidManifest.xml'
725 with open(manifest, 'r') as content_file:
726 content = content_file.read()
727 self.assertTrue(os.path.exists(manifest))
728 self.assertTrue(content.find('landscape') != -1)
729 self.assertTrue(os.path.exists('Example'))
730 self.checkApks('Example', '1.0.0')
733 # Arch option only works for embedded mode,
734 # so only test it for embedded mode.
735 if self._mode.find('embedded') != -1:
736 cmd = ['python', 'make_apk.py', '--name=Example', '--app-version=1.0.0',
737 '--package=org.xwalk.example', '--app-url=http://www.intel.com',
738 '--arch=x86', self._mode]
740 self.addCleanup(Clean, 'Example', '1.0.0')
741 if 'x86' in self.archs():
742 self.assertTrue(os.path.isfile('Example_1.0.0_x86.apk'))
743 self.checkApk('Example_1.0.0_x86.apk', 'x86')
745 self.assertFalse(os.path.isfile('Example_1.0.0_x86.apk'))
746 self.assertFalse(os.path.isfile('Example_1.0.0_arm.apk'))
747 Clean('Example', '1.0.0')
748 cmd = ['python', 'make_apk.py', '--name=Example', '--app-version=1.0.0',
749 '--package=org.xwalk.example', '--app-url=http://www.intel.com',
750 '--arch=arm', self._mode]
752 if 'arm' in self.archs():
753 self.assertTrue(os.path.isfile('Example_1.0.0_arm.apk'))
754 self.checkApk('Example_1.0.0_arm.apk', 'arm')
756 self.assertFalse(os.path.isfile('Example_1.0.0._arm.apk'))
757 self.assertFalse(os.path.isfile('Example_1.0.0_x86.apk'))
758 Clean('Example', '1.0.0')
759 cmd = ['python', 'make_apk.py', '--name=Example', '--app-version=1.0.0',
760 '--package=org.xwalk.example', '--app-url=http://www.intel.com',
763 if 'arm' in self.archs():
764 self.assertTrue(os.path.isfile('Example_1.0.0_arm.apk'))
765 self.checkApk('Example_1.0.0_arm.apk', 'arm')
767 self.assertFalse(os.path.isfile('Example_1.0.0._arm.apk'))
768 if 'x86' in self.archs():
769 self.assertTrue(os.path.isfile('Example_1.0.0_x86.apk'))
770 self.checkApk('Example_1.0.0_x86.apk', 'x86')
772 self.assertFalse(os.path.isfile('Example_1.0.0._x86.apk'))
773 Clean('Example', '1.0.0')
774 cmd = ['python', 'make_apk.py', '--name=Example', '--app-version=1.0.0',
775 '--package=org.xwalk.example', '--app-url=http://www.intel.com',
776 '--arch=undefined', self._mode]
777 out = RunCommand(cmd)
778 error_msg = 'invalid choice: \'undefined\''
779 self.assertTrue(out.find(error_msg) != -1)
781 def testVerbose(self):
782 cmd = ['python', 'make_apk.py', '--name=Example', '--app-version=1.0.0',
783 '--package=org.xwalk.example', '--app-url=http://www.intel.com',
784 '--verbose', self._mode]
785 result = RunCommand(cmd)
786 self.addCleanup(Clean, 'Example', '1.0.0')
787 self.assertTrue(result.find('aapt') != -1)
788 self.assertTrue(result.find('crunch') != -1)
789 self.assertTrue(result.find('apkbuilder') != -1)
790 self.assertTrue(os.path.exists('Example'))
791 self.checkApks('Example', '1.0.0')
793 def executeCommandAndVerifyResult(self, exec_file):
794 # Test all of supported options with empty 'mode' option.
795 icon_path = './template/res/drawable-xhdpi/crosswalk.png'
796 extension_path = 'test_data/extensions/myextension'
799 if exec_file.find("make_apk.py") != -1:
801 icon = '--icon=%s' % icon_path
802 cmd = ['python', '%s' % exec_file,
803 '--app-version=1.0.0',
804 '--app-url=http://www.intel.com',
806 '--description=a sample application',
807 '--enable-remote-debugging',
808 '--extensions=%s' % extension_path,
813 '--orientation=landscape',
814 '--package=org.xwalk.example',
815 '--permissions=geolocation']
817 self.addCleanup(Clean, 'Example', '1.0.0')
818 activity = 'Example/src/org/xwalk/example/ExampleActivity.java'
819 with open(activity, 'r') as content_file:
820 content = content_file.read()
821 self.assertTrue(os.path.exists(activity))
822 # Test remote debugging option.
823 self.assertTrue(content.find('setRemoteDebugging') != -1)
824 # Test keep screen on option
825 self.assertTrue(content.find('FLAG_KEEP_SCREEN_ON') != -1)
827 manifest = 'Example/AndroidManifest.xml'
828 with open(manifest, 'r') as content_file:
829 content = content_file.read()
830 self.assertTrue(os.path.exists(manifest))
831 # Test permission option.
832 self.assertTrue(content.find('ACCESS_FINE_LOCATION') != -1)
833 # Test description option.
834 self.assertTrue(content.find('description') != -1)
835 # Test app version option.
836 self.assertTrue(content.find('versionName') != -1)
837 # Test orientation option.
838 self.assertTrue(content.find('landscape') != -1)
839 # Test fullscreen option
840 theme = 'Example/res/values-v14/theme.xml'
841 with open(theme, 'r') as content_file:
842 content = content_file.read()
843 self.assertTrue(os.path.exists(theme))
846 '<item name="android:windowFullscreen">true</item>') != -1)
847 # Test extensions option.
848 extensions_config_json = 'Example/assets/extensions-config.json'
849 self.assertTrue(os.path.exists(extensions_config_json))
850 with open(extensions_config_json, 'r') as content_file:
851 content = content_file.read()
852 js_file_name = 'xwalk-extensions/myextension/myextension.js'
853 self.assertTrue(content.find(js_file_name))
854 self.assertTrue(content.find('com.example.extension.MyExtension'))
855 extension_js = 'Example/assets/xwalk-extensions/myextension/myextension.js'
856 self.assertTrue(os.path.exists(extension_js))
857 extension_jar = 'Example/xwalk-extensions/myextension/myextension.jar'
858 self.assertTrue(os.path.exists(extension_jar))
860 def testEmptyMode(self):
861 self.executeCommandAndVerifyResult('make_apk.py')
863 def testCustomizeFile(self):
864 cmd = ['python', 'make_apk.py',
865 '--app-url=http://www.intel.com',
866 '--app-version=1.0.0',
868 '--package=org.xwalk.example',
871 manifest = 'Example/AndroidManifest.xml'
872 if not os.path.exists(manifest):
873 print 'The \'%s\' was not generated, please check it.' % manifest
876 self.executeCommandAndVerifyResult('customize.py')
878 def testLaunchScreen(self):
879 # Prepare launch screen resources.
880 launch_screen_path = os.path.join('test_data', 'launchScreen')
881 orientations = ['default', 'portrait', 'landscape']
882 dimensions = ['0_75', '1', '1_5', '2']
883 img_types = ['img', 'bg']
884 for orientation in orientations:
885 for dimension in dimensions:
886 for img_type in img_types:
887 name = orientation + '_' + img_type + '_' + dimension
888 path_tmp = os.path.join(launch_screen_path, name)
889 _file = open(path_tmp,'w+')
893 manifest_path = os.path.join('test_data', 'launchScreen',
894 'manifest_deprecated_launch_screen.json')
895 cmd = ['python', 'make_apk.py', '--package=org.xwalk.example',
896 '--manifest=%s' % manifest_path, self._mode]
897 out = RunCommand(cmd)
899 out.find('WARNING: launch_screen is deprecated for Crosswalk') != -1)
900 Clean('Example', '1.0.0')
901 manifest_path = os.path.join('test_data', 'launchScreen', 'manifest.json')
902 cmd = ['python', 'make_apk.py', '--package=org.xwalk.example',
903 '--manifest=%s' % manifest_path, self._mode]
906 theme_path = os.path.join('Example', 'res', 'values-v14', 'theme.xml')
907 self.assertTrue(os.path.exists(theme_path))
908 with open(theme_path, 'r') as content_file:
909 content = content_file.read()
910 self.assertTrue(content.find('@drawable/launchscreen_bg') != -1)
911 # Check launchscreen_bg.xml
912 launch_screen_bg_path = os.path.join(
913 "Example", 'res', 'drawable', 'launchscreen_bg.xml')
914 self.assertTrue(os.path.exists(launch_screen_bg_path))
915 with open(launch_screen_bg_path, 'r') as content_file:
916 content = content_file.read()
917 self.assertTrue(content.find('@drawable/launchscreen_bg_img') != -1)
918 # Check resource images
919 for orientation in orientations:
920 for dimension in dimensions:
921 drawable = 'drawable'
922 if orientation == 'portrait':
923 drawable = drawable + '-port'
924 elif orientation == 'landscape':
925 drawable = drawable + '-land'
926 if dimension == '0_75':
927 drawable = drawable + '-ldpi'
928 elif dimension == '1':
929 drawable = drawable + '-mdpi'
930 elif dimension == '1_5':
931 drawable = drawable + '-hdpi'
932 elif dimension == '2':
933 drawable = drawable + '-xhdpi'
934 # Check background image
935 bg_drawable = os.path.join(
936 "Example", 'res', drawable, 'launchscreen_bg_img')
937 self.assertTrue(os.path.exists(bg_drawable))
938 with open(bg_drawable, 'r') as content_file:
939 content = content_file.read()
940 name = orientation + '_' + 'bg' + '_' + dimension
941 self.assertTrue(content == name)
942 # Check foreground image
943 fg_drawable = os.path.join(
944 "Example", 'res', drawable, 'launchscreen_img')
945 self.assertTrue(os.path.exists(fg_drawable))
946 with open(fg_drawable, 'r') as content_file:
947 content = content_file.read()
948 name = orientation + '_' + 'img' + '_' + dimension
949 self.assertTrue(content == name)
950 self.checkApks('Example', '1.0.0')
951 Clean('Example', '1.0.0')
953 def testTargetDir(self):
954 test_option = ['./', '../', '~/']
955 for option in test_option:
956 cmd = ['python', 'make_apk.py', '--name=Example', '--app-version=1.0.0',
957 '--package=org.xwalk.example', '--app-url=http://www.intel.com',
958 '--target-dir=%s' % option, self._mode]
960 self.addCleanup(Clean, os.path.expanduser('%sExample' % option), '1.0.0')
961 if self._mode.find('shared') != -1:
962 apk_path = os.path.expanduser('%sExample_1.0.0.apk' % option)
963 self.assertTrue(os.path.exists(apk_path))
964 self.checkApk(apk_path, '')
965 elif self._mode.find('embedded') != -1:
966 for arch in self.archs():
967 apk_path = os.path.expanduser('%sExample_1.0.0_%s.apk'
969 self.assertTrue(os.path.exists(apk_path))
970 self.checkApk(apk_path, arch)
972 def testCompressor(self):
973 app_root = os.path.join('test_data', 'compressor')
974 css_folder = os.path.join('test_data', 'compressor', 'css')
975 css_file = os.path.join(css_folder, 'test.css')
976 js_folder = os.path.join('test_data', 'compressor', 'js')
977 js_file = os.path.join(js_folder, 'test.js')
978 fun = self.assertTrue
981 cmd = ['python', 'customize.py',
983 '--package=org.xwalk.example',
985 '--app-root=%s' % app_root]
987 CompareSizeForCompressor('all', css_file, 'css', name, fun)
988 CompareSizeForCompressor('all', js_file, 'js', name, fun)
990 cmd = ['python', 'customize.py',
992 '--package=org.xwalk.example',
993 '--app-root=%s' % app_root,
996 CompareSizeForCompressor('all', css_file, 'css', name, fun)
997 CompareSizeForCompressor('all', js_file, 'js', name, fun)
999 cmd = ['python', 'customize.py',
1001 '--package=org.xwalk.example',
1003 '--app-root=%s' % app_root]
1005 CompareSizeForCompressor('js', js_file, 'js', name, fun)
1007 cmd = ['python', 'customize.py',
1009 '--package=org.xwalk.example',
1011 '--app-root=%s' % app_root]
1013 CompareSizeForCompressor('css', css_file, 'css', name, fun)
1015 cmd = ['python', 'customize.py',
1017 '--package=org.xwalk.example',
1018 '--app-root=%s' % app_root]
1020 CompareSizeForCompressor(None, css_file, 'css', name, fun)
1021 CompareSizeForCompressor(None, js_file, 'js', name, fun)
1023 cmd = ['python', 'customize.py',
1025 '--package=org.xwalk.example',
1026 '--app-root=%s' % app_root,
1027 '--compressor=other']
1029 CompareSizeForCompressor(None, css_file, 'css', name, fun)
1030 CompareSizeForCompressor(None, js_file, 'js', name, fun)
1032 Clean(name, '1.0.0')
1034 def testInvalidCharacter(self):
1036 start_with_letters = ' should be started with letters'
1037 app_name_error = 'app name' + start_with_letters
1038 package_name_error = 'package name' + start_with_letters
1039 parse_error = 'parser error in manifest.json file'
1040 directory = os.path.join('test_data', 'manifest', 'invalidchars')
1042 manifest_path = os.path.join(directory, 'manifest_with_space_name.json')
1043 result = GetResultWithOption(self._mode, manifest_path)
1044 self.assertTrue(result.find(app_name_error) != -1)
1046 manifest_path = os.path.join(directory, 'manifest_with_chinese_name.json')
1047 result = GetResultWithOption(self._mode, manifest_path)
1048 self.assertTrue(result.find(app_name_error) != -1)
1050 manifest_path = os.path.join(directory, 'manifest_parse_error.json')
1051 result = GetResultWithOption(self._mode, manifest_path)
1052 self.assertTrue(result.find(parse_error) != -1)
1054 manifest_path = os.path.join(directory, 'manifest_with_invalid_name.json')
1055 result = GetResultWithOption(self._mode, manifest_path)
1056 self.assertTrue(result.find(app_name_error) != -1)
1058 manifest_path = os.path.join(directory, 'manifest_contain_space_name.json')
1059 result = GetResultWithOption(self._mode, manifest_path)
1060 self.assertTrue(result.find(app_name_error) == -1)
1062 package = 'org.xwalk.example'
1064 result = GetResultWithOption(self._mode, name=name, package=package)
1065 self.assertTrue(result.find(app_name_error) != -1)
1068 result = GetResultWithOption(self._mode, name=name, package=package)
1069 self.assertTrue(result.find(app_name_error) != -1)
1072 result = GetResultWithOption(self._mode, name=name, package=package)
1073 self.assertTrue(result.find(app_name_error) == -1)
1074 Clean(name, version)
1077 def VerifyResultForAppNameWithSpace(self, manifest=None, name=None,
1080 GetResultWithOption(manifest=manifest, name=name, package=package)
1083 replaced_name = ReplaceSpaceWithUnderscore(name)
1084 manifest = replaced_name + '/AndroidManifest.xml'
1085 with open(manifest, 'r') as content_file:
1086 content = content_file.read()
1087 self.assertTrue(os.path.exists(manifest))
1088 self.assertTrue(name in content)
1089 Clean(replaced_name, version)
1092 def testAppNameWithSpace(self):
1094 package = 'org.xwalk.app_name'
1096 self.VerifyResultForAppNameWithSpace(name=name, package=package)
1099 self.VerifyResultForAppNameWithSpace(name=name, package=package)
1101 directory = os.path.join('test_data', 'manifest', 'invalidchars')
1102 manifest_path = os.path.join(directory, 'manifest_contain_space_name.json')
1103 self.VerifyResultForAppNameWithSpace(manifest=manifest_path,
1107 def SuiteWithModeOption():
1108 # Gather all the tests for the specified mode option.
1109 test_suite = unittest.TestSuite()
1110 test_suite.addTest(TestMakeApk('testAppBigVersionCodeBase'))
1111 test_suite.addTest(TestMakeApk('testAppVersionCode'))
1112 test_suite.addTest(TestMakeApk('testAppVersionCodeBase'))
1113 test_suite.addTest(TestMakeApk('testAppDescriptionAndVersion'))
1114 test_suite.addTest(TestMakeApk('testArch'))
1115 test_suite.addTest(TestMakeApk('testEnableRemoteDebugging'))
1116 test_suite.addTest(TestMakeApk('testEntry'))
1117 test_suite.addTest(TestMakeApk('testEntryWithErrors'))
1118 test_suite.addTest(TestMakeApk('testExtensionsWithOneExtension'))
1119 test_suite.addTest(TestMakeApk('testExtensionsWithNonExtension'))
1120 test_suite.addTest(TestMakeApk('testExtensionWithPermissions'))
1121 test_suite.addTest(TestMakeApk('testFullscreen'))
1122 test_suite.addTest(TestMakeApk('testIconByOption'))
1123 test_suite.addTest(TestMakeApk('testIconByManifest'))
1124 test_suite.addTest(TestMakeApk('testInvalidCharacter'))
1125 test_suite.addTest(TestMakeApk('testKeystore'))
1126 test_suite.addTest(TestMakeApk('testManifest'))
1127 test_suite.addTest(TestMakeApk('testManifestWithDeprecatedField'))
1128 test_suite.addTest(TestMakeApk('testManifestWithError'))
1129 test_suite.addTest(TestMakeApk('testName'))
1130 test_suite.addTest(TestMakeApk('testOrientation'))
1131 test_suite.addTest(TestMakeApk('testPackage'))
1132 test_suite.addTest(TestMakeApk('testPackageWithInvalidCharacter'))
1133 test_suite.addTest(TestMakeApk('testPermissions'))
1134 test_suite.addTest(TestMakeApk('testPermissionsWithError'))
1135 test_suite.addTest(TestMakeApk('testXPK'))
1136 test_suite.addTest(TestMakeApk('testXPKWithError'))
1137 test_suite.addTest(TestMakeApk('testTargetDir'))
1138 test_suite.addTest(TestMakeApk('testLaunchScreen'))
1142 def SuiteWithEmptyModeOption():
1143 # Gather all the tests for empty mode option.
1144 test_suite = unittest.TestSuite()
1145 test_suite.addTest(TestMakeApk('testAppNameWithSpace'))
1146 test_suite.addTest(TestMakeApk('testCompressor'))
1147 test_suite.addTest(TestMakeApk('testCustomizeFile'))
1148 test_suite.addTest(TestMakeApk('testEmptyMode'))
1149 test_suite.addTest(TestMakeApk('testToolVersion'))
1150 test_suite.addTest(TestMakeApk('testVerbose'))
1154 def TestSuiteRun(test_runner, suite):
1155 results = test_runner.run(suite)
1156 return results.wasSuccessful()
1159 if __name__ == '__main__':
1160 parser = optparse.OptionParser()
1161 info = ('The build directory for xwalk.'
1162 'Such as: --build-dir=src/out')
1163 parser.add_option('--build-dir', help=info)
1164 info = ('The build target for xwalk.'
1165 'Such as: --target=Release')
1166 parser.add_option('--target', help=info)
1167 info = ('The path of package tool.')
1168 parser.add_option('--tool-path', help=info)
1169 info = ('The packaging mode for xwalk. Such as: --mode=embedded.'
1170 'Please refer the detail to the option of make_apk.py.')
1171 parser.add_option('--mode', help=info)
1172 options, dummy = parser.parse_args()
1173 if len(sys.argv) == 1:
1178 mode_suite = SuiteWithModeOption()
1179 empty_mode_suite = SuiteWithEmptyModeOption()
1180 runner = unittest.TextTestRunner(verbosity=2)
1181 if options.build_dir or options.target:
1182 warnings.warn(('"--build-dir" and "--target" will be deprecated soon, '
1183 'please leverage "--tool-path" instead.'),
1187 test_result = TestSuiteRun(runner, mode_suite)
1189 # Run tests in both embedded and shared mode
1190 # when the mode option isn't specified.
1191 options.mode = 'embedded'
1192 print 'Run tests in embedded mode.'
1193 test_result = TestSuiteRun(runner, mode_suite)
1194 options.mode = 'shared'
1195 print 'Run tests in shared mode.'
1196 test_result = TestSuiteRun(runner, mode_suite) and test_result
1198 print 'Run test without \'--mode\' option.'
1199 test_result = TestSuiteRun(runner, empty_mode_suite) and test_result