def build(self, app, buildtype, buildoptions, maketarget): ''' Build the operating system. ''' app_name = app.get_name() if app_name == 'iotjs': build_options = ['IOTJS_ROOT_DIR=' + paths.IOTJS_PATH] build_options.append('IOTJS_BUILD_OPTION=' + ' '.join(buildoptions)) if buildtype == 'release': # Override the config file for release build. utils.copy_file( utils.join(paths.CONFIG_PATH, 'iotjs-tizenrt-release.config'), utils.join(paths.TIZENRT_OS_PATH, '.config')) tizenrt_patch = utils.join(paths.PATCHES_PATH, 'iotjs-tizenrt-%s.diff' % buildtype) utils.patch(paths.IOTJS_PATH, tizenrt_patch, False) utils.execute(paths.TIZENRT_OS_PATH, 'make', build_options) utils.patch(paths.IOTJS_PATH, tizenrt_patch, True) elif app_name == 'jerryscript': utils.execute(paths.TIZENRT_OS_PATH, 'make')
def run(self): ''' Main method to run IoT.js or JerryScript tests. ''' if self.env['info']['no_test']: return reporter.report_configuration(self.env) for testset, tests in read_testsets(self.env).items(): self.run_testset(testset, tests) if self.env['info']['coverage']: device = self.env['info']['device'] app_name = self.env['info']['app'] if device in ['artik053', 'artik530', 'rpi2' ] and app_name == 'iotjs': iotjs = self.env['modules']['iotjs'] commit_info = utils.last_commit_info(iotjs['src']) result_name = 'cov-%s-%s.json' % (commit_info['commit'], commit_info['date']) result_dir = utils.join(paths.RESULT_PATH, '%s/%s/' % (app_name, device)) result_path = utils.join(result_dir, result_name) self.coverage_info = utils.parse_coverage_info( self.env, result_path) reporter.report_coverage(self.coverage_info) reporter.report_final(self.results)
def __update_status_icon(self, app_name, device_type): ''' Update the status icon. ''' results_web_path = TEST_RESULTS_WEB_PATH[app_name] if not utils.exists(results_web_path): return utils.execute(results_web_path, 'git', ['pull', 'origin', 'gh-pages']) status = 'passing' for test in self.results: if test['result'] == 'fail': status = 'failing' break current_status_icon = utils.join(results_web_path, 'status', '%s.svg' % device_type) if not utils.exists(current_status_icon): return with open(current_status_icon) as file: if status in file.read(): return image = 'pass.svg' if status is 'passing' else 'fail.svg' copied_status_icon = utils.join(results_web_path, 'img', image) utils.copy_file(copied_status_icon, current_status_icon) utils.execute(results_web_path, 'git', ['add', current_status_icon]) utils.execute(results_web_path, 'git', ['commit', '-m', 'Update the status badge.']) utils.execute(results_web_path, 'git', ['push'])
def _build_iotjs(self, profile, extra_flags): ''' Build IoT.js for Tizen target. ''' iotjs = self.env['modules']['iotjs'] profiles = { 'minimal': 'profiles/minimal.profile', 'target': 'test/profiles/tizen.profile' } build_flags = [ '--clean', '--no-parallel-build', '--no-init-submodule', '--target-arch=noarch', '--target-os=tizen', '--target-board=rpi3', '--profile=%s' % profiles[profile], '--buildtype=%s' % self.env['info']['buildtype'] ] + extra_flags iotjs_build_options = ' '.join(build_flags) # Note: these values should be defined for GBS, because # it will compile the IoT.js itself. utils.define_environment('IOTJS_BUILD_OPTION', iotjs_build_options) args = ['--clean'] if self.env['info']['buildtype'] == 'debug': args.append('--debug') utils.execute(iotjs['src'], 'config/tizen/gbsbuild.sh', args) tizen_build_dir = utils.join(paths.GBS_IOTJS_PATH, 'build') iotjs_build_dir = utils.join(iotjs['src'], 'build') # Copy the GBS created binaries to the iotjs build folder. # Note: GBS compiles iotjs in the GBS folder. utils.copy(tizen_build_dir, iotjs_build_dir)
def _copy_build_files(self, target_module, builddir): ''' Copy the created binaries, libs, linker map to the build folder. ''' application = self.env['modules']['app'] linker_map = utils.join(builddir, 'linker.map') lib_folder = utils.join(builddir, 'libs') utils.copy(application['paths']['libdir'], lib_folder) utils.copy(target_module['paths']['linker-map'], linker_map) utils.copy(target_module['paths']['image'], builddir)
def __apply_stack_patches(self, device, revert=False): ''' Apply stack patch to measure the stack consumption of IoT.js ''' if device.get_type() == 'rpi2': iotjs_stack_patch = utils.join(paths.PATCHES_PATH, 'iotjs-stack.diff') utils.patch(paths.IOTJS_PATH, iotjs_stack_patch, revert) if device.get_type() == 'stm32f4dis': iotjs_stack_nuttx_patch = utils.join(paths.PATCHES_PATH, 'iotjs-stack-nuttx.diff') utils.patch(paths.IOTJS_PATH, iotjs_stack_nuttx_patch, revert)
def flash(self, app): ''' Send the application and the testsuite to the device with SFTP. ''' lpath_app = app.get_image() lpath_app_stack = app.get_image_stack() lpath_testsuite = utils.make_archive(app.get_test_dir(), 'tar') rpath_app = utils.join(self.remote_path, app.get_cmd()) rpath_app_stack = utils.join(self.remote_path, app.get_cmd_stack()) rpath_testsuite = utils.join(self.remote_path, 'test.tar') # Freya cross build. utils.copy_file(utils.join(paths.TOOLS_PATH, 'freya-cross-build.sh'), paths.FREYA_PATH) utils.execute(paths.FREYA_PATH, './freya-cross-build.sh') freya_dir = utils.join(paths.FREYA_PATH, 'valgrind_freya') lpath_freya = utils.make_archive(freya_dir, 'tar') rpath_freya = utils.join(self.remote_path, 'valgrind_freya.tar') lpath_resources = utils.make_archive(paths.RESOURCES_PATH, 'tar') rpath_resources = utils.join(self.remote_path, 'resources.tar') self.ssh.open() # Clean up in the remote folder. self.ssh.exec_command('rm -f ' + rpath_app) self.ssh.exec_command('rm -f ' + rpath_testsuite) self.ssh.exec_command('rm -f ' + rpath_freya) self.ssh.exec_command('rm -f ' + rpath_resources) self.ssh.exec_command('rm -rf ' + self.get_test_path()) # Send the application, the testsuite, the valgrind and the resource files. self.ssh.send_file(lpath_app, rpath_app) self.ssh.send_file(lpath_testsuite, rpath_testsuite) self.ssh.send_file(lpath_freya, rpath_freya) self.ssh.send_file(lpath_resources, rpath_resources) # Let the iotjs to be runnable and extract the tests and valgrind files. self.ssh.exec_command('chmod 770 ' + rpath_app) self.ssh.exec_command('mkdir ' + self.get_test_path()) self.ssh.exec_command('mkdir ' + utils.join(self.remote_path, 'valgrind_freya')) self.ssh.exec_command('tar -xmf ' + rpath_testsuite + ' -C ' + self.get_test_path()) self.ssh.exec_command('tar -xmf ' + rpath_freya + ' -C ' + utils.join(self.remote_path, 'valgrind_freya')) self.ssh.exec_command('tar -xmf ' + rpath_resources + ' -C ' + self.remote_path) # Note: stack measurement is only supported for iotjs. if app.get_name() == 'iotjs': self.ssh.exec_command('rm -f ' + rpath_app_stack) self.ssh.send_file(lpath_app_stack, rpath_app_stack) self.ssh.exec_command('chmod 770 ' + rpath_app_stack)
def get_romfs_file(self): ''' Return the path of the generated ROMFS image. ''' utils.generate_romfs(paths.IOTJS_PATH, paths.IOTJS_TEST_PATH) return utils.join(paths.IOTJS_PATH, 'nsh_romfsimg.h')
def save(self): ''' Save the current testresults into JSON format. ''' if self.env['info']['no_test']: return build_file = self.env['paths']['build-json'] build_info = utils.read_json_file(build_file) # Add the build information. test_info = { 'date': build_info['last-commit-date'], 'bin': build_info['bin'], 'submodules': build_info['submodules'] } # Specify a date named results file. result_dir = self.env['paths']['result'] filename = utils.join(result_dir, build_info['build-date']) if self.env['info']['coverage']: # Add the coverage information. test_info['coverage_info'] = self.coverage_info filename += '_coverage' else: # Add the test results. test_info['tests'] = self.results # Save the results into the date named file. utils.write_json_file(filename + '.json', test_info) # Publish the results if necessary. utils.upload_data_to_firebase(self.env, test_info)
def __apply_patches(self, app): ''' Apply patch file. ''' patch = utils.join(paths.PATCHES_PATH, 'tizenrt-%s.diff' % app.get_name()) utils.execute(paths.TIZENRT_PATH, 'git', ['reset', '--hard']) utils.execute(paths.TIZENRT_PATH, 'git', ['apply', patch])
def install_dependencies(self): ''' Install dependencies of the board. ''' if utils.exists(utils.join(paths.STLINK_BUILD_PATH, 'st-flash')): return utils.execute(paths.STLINK_PATH, 'make', ['release'])
def __configure(self, app): ''' Configuring TizenRT. ''' # FIXME: now it supports artik053 device only configure_name = utils.join('artik053', app.get_name()) utils.execute(paths.TIZENRT_TOOLS_PATH, './configure.sh', [configure_name])
def __apply_heap_patches(self, device, revert=False): ''' Apply memstat patches to measure the memory consumption of IoT.js ''' if device.get_type() in ['stm32f4dis', 'artik053']: iotjs_memstat_patch = utils.join(paths.PATCHES_PATH, 'iotjs-memstat.diff') utils.patch(paths.IOTJS_PATH, iotjs_memstat_patch, revert) libtuv_memstat_patch = utils.join(paths.PATCHES_PATH, 'libtuv-memstat.diff') utils.patch(paths.IOTJS_LIBTUV_PATH, libtuv_memstat_patch, revert) utils.execute(paths.IOTJS_LIBTUV_PATH, 'git', ['add', '-u']) jerry_memstat_patch = utils.join(paths.PATCHES_PATH, 'jerry-memstat.diff') utils.patch(paths.IOTJS_JERRY_PATH, jerry_memstat_patch, revert) utils.execute(paths.IOTJS_JERRY_PATH, 'git', ['add', '-u'])
def _build_freya(self): ''' Cross-compile Valgrind and its Freya tool. ''' build_dir = utils.join(self.env['paths']['build'], 'valgrind_freya') valgrind_files = [ 'vg-in-place', 'coregrind/valgrind', '.in_place/freya-arm-linux', '.in_place/vgpreload_core-arm-linux.so', '.in_place/vgpreload_freya-arm-linux.so' ] # Check if a Freya build already exists, if yes, skip the build. if utils.exist_files(build_dir, valgrind_files): return freya = self.env['modules']['freya'] utils.define_environment('LD', 'arm-linux-gnueabihf-ld') utils.define_environment('AR', 'arm-linux-gnueabihf-ar') utils.define_environment('CC', 'arm-linux-gnueabihf-gcc') utils.define_environment('CPP', 'arm-linux-gnueabihf-cpp') utils.define_environment('CXX', 'arm-linux-gnueabihf-g++') configure_options = ['--host=armv7-linux-gnueabihf'] utils.execute(freya['src'], './autogen.sh') utils.execute(freya['src'], './configure', configure_options) utils.execute(freya['src'], 'make', ['clean']) utils.execute(freya['src'], 'make', ['TOOLS=freya']) utils.unset_environment('LD') utils.unset_environment('AR') utils.unset_environment('CC') utils.unset_environment('CPP') utils.unset_environment('CXX') # Copy necessary files into the output directory. for valgrind_file in valgrind_files: src = utils.join(freya['src'], valgrind_file) dst = utils.join(build_dir, valgrind_file) utils.copy(src, dst)
def __copy_app_files(self, app): ''' Copy application files into the NuttX apps. ''' utils.copy_files(app.get_home_dir(), app.get_install_dir()) # Override the default romfs image file. utils.copy_file( app.get_romfs_file(), utils.join(paths.NUTTX_APPS_NSHLIB_PATH, 'nsh_romfsimg.h'))
def __configure(self, app): ''' Configuring NuttX. ''' utils.execute(paths.NUTTX_TOOLS_PATH, './configure.sh', ['stm32f4discovery/netnsh']) # Override the default config file with a prepared one. utils.copy_file(app.get_config_file(), utils.join(paths.NUTTX_PATH, '.config'))
def initialize(self): ''' Flash the device. ''' if self.env['info']['no_flash']: return target_app = self.env['modules']['app'] build_path = self.env['paths']['build'] test_src = target_app['paths']['tests'] test_dst = utils.join(build_path, 'tests') # 1. Copy all the necessary files. # Copy applicaiton RPM package file. rpm_package_path = self.env['paths']['tizen-rpm-package'] utils.copy(rpm_package_path, build_path) # Copy all the tests into the build folder. utils.copy(test_src, test_dst) utils.copy(paths.FREYA_TESTER, build_path) if not self.env['info']['no_memstat']: utils.copy(paths.FREYA_CONFIG, build_path) # Resolve the iotjs-dirname macro in the Freya configuration file. basename = utils.basename(paths.GBS_IOTJS_PATH) sed_flags = [ '-i', 's/%%{iotjs-dirname}/%s/g' % basename, 'iotjs-freya.config' ] utils.execute(build_path, 'sed', sed_flags) # 2. Deploy the build folder to the device. self.login() self.channel.exec_command('mount -o remount,rw /') shell_flags = 'ssh -p %s' % self.port rsync_flags = [ '--rsh', shell_flags, '--recursive', '--compress', '--delete' ] # Note: slash character is required after the path. # In this case `rsync` copies the whole folder, not # the subcontents to the destination. src = self.env['paths']['build'] + '/' dst = '%s@%s:%s' % (self.user, self.ip, self.workdir) utils.execute('.', 'rsync', rsync_flags + [src, dst]) # 3. Install rpm package template = 'rpm -ivh --force --nodeps %s/%s-1.0.0-0.armv7l.rpm' self.channel.exec_command(template % (self.workdir, self.app)) self.logout()
def read_testsets(self, device): ''' Read all the tests ''' # Read testsets testsets_file = utils.join(paths.IOTJS_TEST_PATH, 'testsets.json') testsets = {} with open(testsets_file, 'r') as testsets_p: testsets = json.load(testsets_p) # Read skip file skip_file = utils.join(paths.PROJECT_ROOT, 'API/testrunner/iotjs-skiplist.json') skip_list = self.get_skiplist(skip_file) skip_tests = skip_list[device.get_type()]['testfiles'] skip_testsets = skip_list[device.get_type()]['testsets'] os = device.get_os() os_name = os.get_name() # Update testset for testset in testsets: skip_testset = self.__in_dictlist('name', testset, skip_testsets) if skip_testset: for test in testsets[testset]: self.__add_test_to_skip(os_name, test, skip_testset['reason']) else: for skip_test in skip_tests: target_test = self.__in_dictlist('name', skip_test['name'], testsets[testset]) if target_test: self.__add_test_to_skip(os_name, target_test, skip_test['reason']) return testsets
def __copy_app_files(self, app): ''' Copy application files into the NuttX apps. ''' app_name = app.get_name() if app_name == 'jerryscript': # FIXME: now it supports artik053 device only app_config_dir = utils.join( paths.JERRY_TARGETS_PATH, '%s-%s' % (self.get_name(), 'artik053')) app_path = utils.join(app_config_dir, 'apps/jerryscript/') app_config_path = utils.join(app_config_dir, 'configs/jerryscript/') tizenrt_app_path = utils.join(paths.TIZENRT_APP_SYSTEM_PATH, app_name) utils.copy_files(app_path, tizenrt_app_path) rt_config_path = utils.join(paths.TIZENRT_CONFIGS_PATH, 'artik053', app_name) utils.copy_files(app_config_path, rt_config_path)
def _read_skiplist(self): ''' Read the local skiplists. ''' skiplists = { 'iotjs': 'iotjs-skiplist.json', 'jerryscript': 'jerryscript-skiplist.json' } skipfile = utils.join(paths.TESTRUNNER_PATH, skiplists[self.app]) skiplist = utils.read_json_file(skipfile) return skiplist[self.device_type]
def execute(self, app, args=[]): ''' Run commands for the given app on the board. ''' cmd = app.get_cmd() cmd_stack = app.get_cmd_stack() # Heap measurement command_template = 'python {root}/tester.py --cwd {cwd} --cmd {app} --testfile {file}' command = command_template.format(root=self.remote_path, cwd=self.get_test_path(), app=utils.join( self.remote_path, cmd), file=''.join(args)) stdout = self.ssh.exec_command(command) # Since the stdout is a JSON text, parse it. result = json.loads(stdout) # Make HTML friendly stdout. result['output'] = result['output'].rstrip('\n').replace('\n', '<br>') result['stack_peak'] = 'n/a' # Note: stack measurement is only supported for iotjs. if app.get_name() == 'iotjs': # Stack usage measurement command = command_template.format(root=self.remote_path, cwd=self.get_test_path(), app=utils.join( self.remote_path, cmd_stack), file=''.join(args)) stdout_stack = self.ssh.exec_command(command) result_stack = json.loads(stdout_stack) result['stack_peak'] = result_stack['stack'] return result
def __run_test_on_device(self, app, device, testset, test): ''' Execute the current test on the device. ''' testfile = utils.join(device.get_test_path(), testset, test['name']) if device.get_type() in ['stm32f4dis', 'artik053']: if app.get_name() is "jerryscript": return device.execute( app, [testfile, '--mem-stats', '--log-level 2']) elif app.get_name() is "iotjs": return device.execute(app, ['--memstat', testfile]) return device.execute(app, [testfile])
def initialize(self): ''' Flash the device. ''' if self.env['info']['no_flash']: return # 1. Copy all the necessary files. target_app = self.env['modules']['app'] build_path = self.env['paths']['build'] test_src = target_app['paths']['tests'] test_dst = utils.join(build_path, 'tests') # Copy all the tests into the build folder. utils.copy(test_src, test_dst) utils.copy(paths.FREYA_TESTER, build_path) if not self.env['info']['no_memstat']: # Copy Freya memory measurement files. utils.copy(paths.FREYA_CONFIG, build_path) # Resolve the iotjs-dirname macro in the Freya configuration file. basename = utils.basename(target_app['src']) sed_flags = [ '-i', 's/%%{iotjs-dirname}/%s/g' % basename, 'iotjs-freya.config' ] utils.execute(build_path, 'sed', sed_flags) # 2. Deploy the build folder to the device. shell_flags = 'ssh -p %s' % self.port rsync_flags = [ '--rsh', shell_flags, '--recursive', '--compress', '--delete' ] # Note: slash character is required after the path. # In this case `rsync` copies the whole folder, not # the subcontents to the destination. src = self.env['paths']['build'] + '/' dst = '%s@%s:%s' % (self.user, self.ip, self.workdir) utils.execute('.', 'rsync', rsync_flags + [src, dst])
def __save(self, app, device, is_publish): ''' Save the testresults. ''' os = device.get_os() device_type = device.get_type() # Create submodule information. submodules = { app.get_name(): utils.last_commit_info(app.get_home_dir()), os.get_name(): utils.last_commit_info(os.get_home_dir()) } if os.get_name() is 'nuttx': submodules['apps'] = utils.last_commit_info(paths.NUTTX_APPS_PATH) # Create the result. bin_sizes = {} if app.get_name() == 'iotjs': target_profile_mapfile = app.get_target_profile_mapfile() minimal_profile_mapfile = app.get_minimal_profile_mapfile() target_bin_sizes = utils.get_section_sizes_from_map( target_profile_mapfile) minimal_bin_sizes = utils.get_section_sizes_from_map( minimal_profile_mapfile) bin_sizes = { 'target_profile': target_bin_sizes, 'minimal_profile': minimal_bin_sizes } else: bin_sizes = utils.get_section_sizes(app.get_minimal_image()) result = { 'bin': bin_sizes, 'date': utils.get_standardized_date(), 'tests': self.results, 'submodules': submodules } device_dir = "stm32" if device_type == "stm32f4dis" else device_type # Save the results into a JSON file. result_dir = utils.join(paths.OUTPUT_PATH, app.get_name(), device_dir) if not utils.exists(result_dir): utils.mkdir(result_dir) result_file_name = result['date'] + '.json' result_file_name = result_file_name.replace(':', '.') result_file_path = utils.join(result_dir, result_file_name) utils.write_json_file(result_file_path, result) # Do not share the results if it not public. if not is_publish: return # Publish results to firebase user = utils.get_environment('FIREBASE_USER') pwd = utils.get_environment('FIREBASE_PWD') if not (pwd and user): return config = { "apiKey": "AIzaSyDMgyPr0V49Rdf5ODAU9nLY02ZGEUNoxiM", "authDomain": "remote-testrunner.firebaseapp.com", "databaseURL": "https://remote-testrunner.firebaseio.com", "storageBucket": "remote-testrunner.appspot.com", } firebase = pyrebase.initialize_app(config) auth = firebase.auth() db = firebase.database() user = auth.sign_in_with_email_and_password(user, pwd) with open(result_file_path) as result_file: result_data = json.load(result_file) db.child(app.get_name() + '/' + device_dir).push( result_data, user['idToken']) # Update the status icon after upload was successful. self.__update_status_icon(app.get_name(), device.get_type())
def get_image(self): ''' Return the path to the target application. ''' return utils.join(paths.TIZENRT_BIN_PATH, 'tinyara.bin')
def get_config_file(self): ''' Return the path to OS configuration file. ''' return utils.join(paths.CONFIG_PATH, 'iotjs.config')
def get_install_dir(self): ''' Return the path to where the application files should be copied. ''' return utils.join(paths.NUTTX_APPS_SYSTEM_PATH, 'iotjs')
def get_image_stack(self): ''' Return the path to the stack binary. ''' return utils.join(paths.IOTJS_BUILD_STACK_PATH, 'iotjs') % self.buildtype
def build(self, device): ''' Build IoT.js for the target device/OS and for Raspberry Pi 2. ''' # prebuild the OS os = device.get_os() os.prebuild(self) utils.rmtree(paths.IOTJS_MAP_DIR_PATH) utils.mkdir(paths.IOTJS_MAP_DIR_PATH) build_flags = [ '--clean', '--buildtype=%s' % self.buildtype, '--target-arch=arm', '--target-os=%s' % os.get_name(), ] # Step 1: Set the appropriate build flags for the targets. if device.get_type() == 'stm32f4dis': build_flags.append('--target-board=%s' % device.get_type()) build_flags.append('--jerry-heaplimit=56') build_flags.append('--no-parallel-build') build_flags.append('--nuttx-home=%s' % paths.NUTTX_PATH) profile = utils.join(paths.IOTJS_TEST_PROFILES_PATH, 'nuttx.profile') mapfile = utils.join(paths.NUTTX_PATH, "arch/arm/src/nuttx.map") elif device.get_type() == 'rpi2': build_flags.append('--target-board=%s' % device.get_type()) profile = utils.join(paths.IOTJS_TEST_PROFILES_PATH, 'rpi2-linux.profile') mapfile = utils.join(paths.IOTJS_BUILD_PATH % self.buildtype, "../iotjs.map") elif device.get_type() == 'artik053': profile = utils.join(paths.IOTJS_TEST_PROFILES_PATH, 'tizenrt.profile') mapfile = utils.join(paths.TIZENRT_BUILD_PATH, "output/bin/tinyara.map") else: console.fail('Non-minimal IoT.js build failed, unsupported ' 'device (%s)!' % device.get_type()) # Step 2: Create minimal profile build for the binary size measurement. build_flags.append('--profile=%s' % paths.IOTJS_MINIMAL_PROFILE_PATH) # Note: IoT.js is built by TizenRT in case of artik053. if device.get_type() in ['stm32f4dis', 'rpi2']: utils.execute(paths.IOTJS_PATH, 'tools/build.py', build_flags) os.build(self, self.buildtype, build_flags, 'all') utils.copy_file(mapfile, paths.IOTJS_MINIMAL_MAP_FILE_PATH) # Step 3: Create target specific profile build for the binary size measurement. os.prebuild(self) build_flags = build_flags[:-1] build_flags.append('--profile=%s' % profile) if device.get_type() in ['stm32f4dis', 'rpi2']: utils.execute(paths.IOTJS_PATH, 'tools/build.py', build_flags) os.build(self, self.buildtype, build_flags, 'all') utils.copy_file(mapfile, paths.IOTJS_TARGET_MAP_FILE_PATH) # Step 4: Create target specific profile with patches for the tests. self.__apply_heap_patches(device) if device.get_type() in ['stm32f4dis', 'artik053']: self.__apply_stack_patches(device) os.prebuild(self) build_flags_heap = list(build_flags) build_flags_heap.append('--jerry-memstat') if device.get_type() == 'rpi2': build_flags_heap.append('--compile-flag=-g') build_flags_heap.append('--jerry-compile-flag=-g') if device.get_type() in ['stm32f4dis', 'rpi2']: utils.execute(paths.IOTJS_PATH, 'tools/build.py', build_flags_heap) os.build(self, self.buildtype, build_flags_heap, 'all') # Revert all the memstat patches from the project. self.__apply_heap_patches(device, revert=True) # Build the application to stack consumption check if device.get_type() == 'rpi2': self.__apply_stack_patches(device) build_flags.append('--builddir=%s' % paths.IOTJS_BUILD_STACK_DIR) utils.execute(paths.IOTJS_PATH, 'tools/build.py', build_flags) self.__apply_stack_patches(device, revert=True)
def get_image(self): ''' Return the path to the image file. ''' return utils.join(paths.NUTTX_PATH, 'nuttx.bin')