section id attribute.
- """
- return "target_test_%s_%s_%s_%s"% (toolchain.lower(), target.lower(), test_id.lower(), loop_no)
-
- def get_result_div_sections(self, test, test_no):
- """ Generates separate
sections which contains test results output.
- """
-
- RESULT_COLORS = {'OK': 'LimeGreen',
- 'FAIL': 'Orange',
- 'ERROR': 'LightCoral',
- 'OTHER': 'LightGray',
- }
-
- tooltip_name = self.get_tooltip_name(test['toolchain_name'], test['target_name'], test['id'], test_no)
- background_color = RESULT_COLORS[test['result'] if test['result'] in RESULT_COLORS else 'OTHER']
- result_div_style = "background-color: %s"% background_color
-
- result = """
-
%s
-
- %s
-
- %s in %.2f sec
-
-
- %s
-
-
-
- """% (result_div_style,
- tooltip_name,
- tooltip_name,
- test['result'],
- tooltip_name,
- test['target_name_unique'],
- test['description'],
- test['elapsed_time'],
- test['output'].replace('\n', '
'))
- return result
-
- def get_result_tree(self, test_results):
- """ If test was run in a loop (we got few results from the same test)
- we will show it in a column to see all results.
- This function produces HTML table with corresponding results.
- """
- result = ''
- for i, test_result in enumerate(test_results):
- result += '
'
- test_ids = sorted(test_result.keys())
- for test_no in test_ids:
- test = test_result[test_no]
- result += """
- | %s |
-
"""% self.get_result_div_sections(test, "%d_%d" % (test_no, i))
- result += '
'
- return result
-
- def get_all_unique_test_ids(self, test_result_ext):
- """ Gets all unique test ids from all ran tests.
- We need this to create complete list of all test ran.
- """
- result = []
- targets = test_result_ext.keys()
- for target in targets:
- toolchains = test_result_ext[target].keys()
- for toolchain in toolchains:
- tests = test_result_ext[target][toolchain].keys()
- result.extend(tests)
- return sorted(list(set(result)))
-
- #
- # Exporters functions
- #
-
- def exporter_html(self, test_result_ext, test_suite_properties=None):
- """ Export test results in proprietary HTML format.
- """
- result = """
-
-
mbed SDK test suite test result report
- %s
- %s
-
-
- """% (self.CSS_STYLE, self.JAVASCRIPT)
-
- unique_test_ids = self.get_all_unique_test_ids(test_result_ext)
- targets = sorted(test_result_ext.keys())
- result += '
'
- for target in targets:
- toolchains = sorted(test_result_ext[target].keys())
- for toolchain in toolchains:
- result += ' | '
- result += ' | '
-
- tests = sorted(test_result_ext[target][toolchain].keys())
- for test in unique_test_ids:
- result += """%s | """% test
- result += """
-
- | %s |
- %s |
- """% (toolchain, target)
-
- for test in unique_test_ids:
- test_result = self.get_result_tree(test_result_ext[target][toolchain][test]) if test in tests else ''
- result += '%s | '% (test_result)
-
- result += '
'
- result += '
'
- result += ''
- return result
-
- def exporter_junit_ioper(self, test_result_ext, test_suite_properties=None):
- from junit_xml import TestSuite, TestCase
- test_suites = []
- test_cases = []
-
- for platform in sorted(test_result_ext.keys()):
- # {platform : ['Platform', 'Result', 'Scope', 'Description'])
- test_cases = []
- for tr_result in test_result_ext[platform]:
- result, name, scope, description = tr_result
-
- classname = 'test.ioper.%s.%s.%s' % (platform, name, scope)
- elapsed_sec = 0
- _stdout = description
- _stderr = ''
- # Test case
- tc = TestCase(name, classname, elapsed_sec, _stdout, _stderr)
- # Test case extra failure / error info
- if result == 'FAIL':
- tc.add_failure_info(description, _stdout)
- elif result == 'ERROR':
- tc.add_error_info(description, _stdout)
- elif result == 'SKIP' or result == 'NOT_SUPPORTED':
- tc.add_skipped_info(description, _stdout)
-
- test_cases.append(tc)
- ts = TestSuite("test.suite.ioper.%s" % (platform), test_cases)
- test_suites.append(ts)
- return TestSuite.to_xml_string(test_suites)
-
- def exporter_junit(self, test_result_ext, test_suite_properties=None):
- """ Export test results in JUnit XML compliant format
- """
- from junit_xml import TestSuite, TestCase
- test_suites = []
- test_cases = []
-
- targets = sorted(test_result_ext.keys())
- for target in targets:
- toolchains = sorted(test_result_ext[target].keys())
- for toolchain in toolchains:
- test_cases = []
- tests = sorted(test_result_ext[target][toolchain].keys())
- for test in tests:
- test_results = test_result_ext[target][toolchain][test]
- for test_res in test_results:
- test_ids = sorted(test_res.keys())
- for test_no in test_ids:
- test_result = test_res[test_no]
- name = test_result['description']
- classname = '%s.%s.%s.%s'% (self.package, target, toolchain, test_result['id'])
- elapsed_sec = test_result['elapsed_time']
- _stdout = test_result['output']
-
- if 'target_name_unique' in test_result:
- _stderr = test_result['target_name_unique']
- else:
- _stderr = test_result['target_name']
-
- # Test case
- tc = TestCase(name, classname, elapsed_sec, _stdout, _stderr)
-
- # Test case extra failure / error info
- message = test_result['result']
- if test_result['result'] == 'FAIL':
- tc.add_failure_info(message, _stdout)
- elif test_result['result'] == 'SKIP' or test_result["result"] == 'NOT_SUPPORTED':
- tc.add_skipped_info(message, _stdout)
- elif test_result['result'] != 'OK':
- tc.add_error_info(message, _stdout)
-
- test_cases.append(tc)
-
- ts = TestSuite("test.suite.%s.%s"% (target, toolchain), test_cases, properties=test_suite_properties[target][toolchain])
- test_suites.append(ts)
- return TestSuite.to_xml_string(test_suites)
-
- def exporter_print_helper(self, array, print_log=False):
- for item in array:
- print " * %s::%s::%s" % (item["target_name"], item["toolchain_name"], item["id"])
- if print_log:
- log_lines = item["output"].split("\n")
- for log_line in log_lines:
- print " %s" % log_line
-
- def exporter_print(self, test_result_ext, print_log_for_failures=False):
- """ Export test results in print format.
- """
- failures = []
- skips = []
- successes = []
-
- unique_test_ids = self.get_all_unique_test_ids(test_result_ext)
- targets = sorted(test_result_ext.keys())
-
- for target in targets:
- toolchains = sorted(test_result_ext[target].keys())
- for toolchain in toolchains:
- tests = sorted(test_result_ext[target][toolchain].keys())
- for test in tests:
- test_runs = test_result_ext[target][toolchain][test]
- for test_runner in test_runs:
- #test_run = test_result_ext[target][toolchain][test][test_run_number][0]
- test_run = test_runner[0]
-
- if test_run["result"] == "FAIL":
- failures.append(test_run)
- elif test_run["result"] == "SKIP" or test_run["result"] == "NOT_SUPPORTED":
- skips.append(test_run)
- elif test_run["result"] == "OK":
- successes.append(test_run)
- else:
- raise Exception("Unhandled result type: %s" % (test_run["result"]))
-
- if successes:
- print "\n\nBuild successes:"
- self.exporter_print_helper(successes)
-
- if skips:
- print "\n\nBuild skips:"
- self.exporter_print_helper(skips)
-
- if failures:
- print "\n\nBuild failures:"
- self.exporter_print_helper(failures, print_log=print_log_for_failures)
- return False
- else:
- return True
diff --git a/tools/test_mysql.py b/tools/test_mysql.py
deleted file mode 100644
index 4f00ab6dd9..0000000000
--- a/tools/test_mysql.py
+++ /dev/null
@@ -1,271 +0,0 @@
-"""
-mbed SDK
-Copyright (c) 2011-2014 ARM Limited
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
- http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-
-Author: Przemyslaw Wirkus
-"""
-
-import re
-import MySQLdb as mdb
-
-# Imports from TEST API
-from tools.test_db import BaseDBAccess
-
-
-class MySQLDBAccess(BaseDBAccess):
- """ Wrapper for MySQL DB access for common test suite interface
- """
- def __init__(self):
- BaseDBAccess.__init__(self)
- self.DB_TYPE = 'mysql'
-
- def detect_database(self, verbose=False):
- """ detect database and return VERION data structure or string (verbose=True)
- """
- query = 'SHOW VARIABLES LIKE "%version%"'
- rows = self.select_all(query)
- if verbose:
- result = []
- for row in rows:
- result.append("\t%s: %s"% (row['Variable_name'], row['Value']))
- result = "\n".join(result)
- else:
- result = rows
- return result
-
- def parse_db_connection_string(self, str):
- """ Parsing SQL DB connection string. String should contain:
- - DB Name, user name, password, URL (DB host), name
- Function should return tuple with parsed (host, user, passwd, db) or None if error
- E.g. connection string: 'mysql://username:password@127.0.0.1/db_name'
- """
- result = BaseDBAccess().parse_db_connection_string(str)
- if result is not None:
- (db_type, username, password, host, db_name) = result
- if db_type != 'mysql':
- result = None
- return result
-
- def is_connected(self):
- """ Returns True if we are connected to database
- """
- return self.db_object is not None
-
- def connect(self, host, user, passwd, db):
- """ Connects to DB and returns DB object
- """
- try:
- self.db_object = mdb.connect(host=host, user=user, passwd=passwd, db=db)
- # Let's remember connection credentials
- self.db_type = self.DB_TYPE
- self.host = host
- self.user = user
- self.passwd = passwd
- self.db = db
- except mdb.Error, e:
- print "Error %d: %s"% (e.args[0], e.args[1])
- self.db_object = None
- self.db_type = None
- self.host = None
- self.user = None
- self.passwd = None
- self.db = None
-
- def connect_url(self, db_url):
- """ Connects to database using db_url (database url parsing),
- store host, username, password, db_name
- """
- result = self.parse_db_connection_string(db_url)
- if result is not None:
- (db_type, username, password, host, db_name) = result
- if db_type == self.DB_TYPE:
- self.connect(host, username, password, db_name)
-
- def reconnect(self):
- """ Reconnects to DB and returns DB object using stored host name,
- database name and credentials (user name and password)
- """
- self.connect(self.host, self.user, self.passwd, self.db)
-
- def disconnect(self):
- """ Close DB connection
- """
- if self.db_object:
- self.db_object.close()
- self.db_object = None
- self.db_type = None
-
- def escape_string(self, str):
- """ Escapes string so it can be put in SQL query between quotes
- """
- con = self.db_object
- result = con.escape_string(str)
- return result if result else ''
-
- def select_all(self, query):
- """ Execute SELECT query and get all results
- """
- con = self.db_object
- cur = con.cursor(mdb.cursors.DictCursor)
- cur.execute(query)
- rows = cur.fetchall()
- return rows
-
- def insert(self, query, commit=True):
- """ Execute INSERT query, define if you want to commit
- """
- con = self.db_object
- cur = con.cursor()
- cur.execute(query)
- if commit:
- con.commit()
- return cur.lastrowid
-
- def get_next_build_id(self, name, desc='', location='', type=None, status=None):
- """ Insert new build_id (DB unique build like ID number to send all test results)
- """
- if status is None:
- status = self.BUILD_ID_STATUS_STARTED
-
- if type is None:
- type = self.BUILD_ID_TYPE_TEST
-
- query = """INSERT INTO `%s` (%s_name, %s_desc, %s_location, %s_type_fk, %s_status_fk)
- VALUES ('%s', '%s', '%s', %d, %d)"""% (self.TABLE_BUILD_ID,
- self.TABLE_BUILD_ID,
- self.TABLE_BUILD_ID,
- self.TABLE_BUILD_ID,
- self.TABLE_BUILD_ID,
- self.TABLE_BUILD_ID,
- self.escape_string(name),
- self.escape_string(desc),
- self.escape_string(location),
- type,
- status)
- index = self.insert(query) # Provide inserted record PK
- return index
-
- def get_table_entry_pk(self, table, column, value, update_db=True):
- """ Checks for entries in tables with two columns (_pk, )
- If update_db is True updates table entry if value in specified column doesn't exist
- """
- # TODO: table buffering
- result = None
- table_pk = '%s_pk'% table
- query = """SELECT `%s`
- FROM `%s`
- WHERE `%s`='%s'"""% (table_pk,
- table,
- column,
- self.escape_string(value))
- rows = self.select_all(query)
- if len(rows) == 1:
- result = rows[0][table_pk]
- elif len(rows) == 0 and update_db:
- # Update DB with new value
- result = self.update_table_entry(table, column, value)
- return result
-
- def update_table_entry(self, table, column, value):
- """ Updates table entry if value in specified column doesn't exist
- Locks table to perform atomic read + update
- """
- result = None
- con = self.db_object
- cur = con.cursor()
- cur.execute("LOCK TABLES `%s` WRITE"% table)
- table_pk = '%s_pk'% table
- query = """SELECT `%s`
- FROM `%s`
- WHERE `%s`='%s'"""% (table_pk,
- table,
- column,
- self.escape_string(value))
- cur.execute(query)
- rows = cur.fetchall()
- if len(rows) == 0:
- query = """INSERT INTO `%s` (%s)
- VALUES ('%s')"""% (table,
- column,
- self.escape_string(value))
- cur.execute(query)
- result = cur.lastrowid
- con.commit()
- cur.execute("UNLOCK TABLES")
- return result
-
- def update_build_id_info(self, build_id, **kw):
- """ Update additional data inside build_id table
- Examples:
- db.update_build_id_info(build_id, _status_fk=self.BUILD_ID_STATUS_COMPLETED, _shuffle_seed=0.0123456789):
- """
- if len(kw):
- con = self.db_object
- cur = con.cursor()
- # Prepare UPDATE query
- # ["`mtest_build_id_pk`=[value-1]", "`mtest_build_id_name`=[value-2]", "`mtest_build_id_desc`=[value-3]"]
- set_list = []
- for col_sufix in kw:
- assign_str = "`%s%s`='%s'"% (self.TABLE_BUILD_ID, col_sufix, self.escape_string(str(kw[col_sufix])))
- set_list.append(assign_str)
- set_str = ', '.join(set_list)
- query = """UPDATE `%s`
- SET %s
- WHERE `mtest_build_id_pk`=%d"""% (self.TABLE_BUILD_ID,
- set_str,
- build_id)
- cur.execute(query)
- con.commit()
-
- def insert_test_entry(self, build_id, target, toolchain, test_type, test_id, test_result, test_output, test_time, test_timeout, test_loop, test_extra=''):
- """ Inserts test result entry to database. All checks regarding existing
- toolchain names in DB are performed.
- If some data is missing DB will be updated
- """
- # Get all table FK and if entry is new try to insert new value
- target_fk = self.get_table_entry_pk(self.TABLE_TARGET, self.TABLE_TARGET + '_name', target)
- toolchain_fk = self.get_table_entry_pk(self.TABLE_TOOLCHAIN, self.TABLE_TOOLCHAIN + '_name', toolchain)
- test_type_fk = self.get_table_entry_pk(self.TABLE_TEST_TYPE, self.TABLE_TEST_TYPE + '_name', test_type)
- test_id_fk = self.get_table_entry_pk(self.TABLE_TEST_ID, self.TABLE_TEST_ID + '_name', test_id)
- test_result_fk = self.get_table_entry_pk(self.TABLE_TEST_RESULT, self.TABLE_TEST_RESULT + '_name', test_result)
-
- con = self.db_object
- cur = con.cursor()
-
- query = """ INSERT INTO `%s` (`mtest_build_id_fk`,
- `mtest_target_fk`,
- `mtest_toolchain_fk`,
- `mtest_test_type_fk`,
- `mtest_test_id_fk`,
- `mtest_test_result_fk`,
- `mtest_test_output`,
- `mtest_test_time`,
- `mtest_test_timeout`,
- `mtest_test_loop_no`,
- `mtest_test_result_extra`)
- VALUES (%d, %d, %d, %d, %d, %d, '%s', %.2f, %.2f, %d, '%s')"""% (self.TABLE_TEST_ENTRY,
- build_id,
- target_fk,
- toolchain_fk,
- test_type_fk,
- test_id_fk,
- test_result_fk,
- self.escape_string(test_output),
- test_time,
- test_timeout,
- test_loop,
- self.escape_string(test_extra))
- cur.execute(query)
- con.commit()
diff --git a/tools/test_webapi.py b/tools/test_webapi.py
deleted file mode 100644
index ffed0e4624..0000000000
--- a/tools/test_webapi.py
+++ /dev/null
@@ -1,242 +0,0 @@
-"""
-mbed SDK
-Copyright (c) 2011-2014 ARM Limited
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
- http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-
-Author: Przemyslaw Wirkus
-"""
-
-import sys
-import json
-import optparse
-from flask import Flask
-from os.path import join, abspath, dirname
-
-# Be sure that the tools directory is in the search path
-ROOT = abspath(join(dirname(__file__), ".."))
-sys.path.insert(0, ROOT)
-
-# Imports related to mbed build api
-from tools.utils import construct_enum
-from tools.build_api import mcu_toolchain_matrix
-
-# Imports from TEST API
-from test_api import SingleTestRunner
-from test_api import SingleTestExecutor
-from test_api import get_json_data_from_file
-from test_api import print_muts_configuration_from_json
-from test_api import print_test_configuration_from_json
-from test_api import get_avail_tests_summary_table
-from test_api import get_default_test_options_parser
-
-
-class SingleTestRunnerWebService(SingleTestRunner):
- def __init__(self):
- super(SingleTestRunnerWebService, self).__init__()
-
- # With this lock we should control access to certain resources inside this class
- self.resource_lock = thread.allocate_lock()
-
- self.RestRequest = construct_enum(REST_MUTS='muts',
- REST_TEST_SPEC='test_spec',
- REST_TEST_RESULTS='test_results')
-
- def get_rest_result_template(self, result, command, success_code):
- """ Returns common part of every web service request
- """
- result = {"result" : result,
- "command" : command,
- "success_code": success_code} # 0 - OK, >0 - Error number
- return result
-
- # REST API handlers for Flask framework
- def rest_api_status(self):
- """ Returns current test execution status. E.g. running / finished etc.
- """
- with self.resource_lock:
- pass
-
- def rest_api_config(self):
- """ Returns configuration passed to SingleTest executor
- """
- with self.resource_lock:
- pass
-
- def rest_api_log(self):
- """ Returns current test log """
- with self.resource_lock:
- pass
-
- def rest_api_request_handler(self, request_type):
- """ Returns various data structures. Both static and mutable during test
- """
- result = {}
- success_code = 0
- with self.resource_lock:
- if request_type == self.RestRequest.REST_MUTS:
- result = self.muts # Returns MUTs
- elif request_type == self.RestRequest.REST_TEST_SPEC:
- result = self.test_spec # Returns Test Specification
- elif request_type == self.RestRequest.REST_TEST_RESULTS:
- pass # Returns test results
- else:
- success_code = -1
- return json.dumps(self.get_rest_result_template(result, 'request/' + request_type, success_code), indent=4)
-
-
-def singletest_in_webservice_mode():
- # TODO Implement this web service functionality
- pass
-
-
-def get_default_test_webservice_options_parser():
- """ Get test script web service options used by CLI, webservices etc.
- """
- parser = get_default_test_options_parser()
-
- # Things related to web services offered by test suite scripts
- parser.add_option('', '--rest-api',
- dest='rest_api_enabled',
- default=False,
- action="store_true",
- help='Enables REST API.')
-
- parser.add_option('', '--rest-api-port',
- dest='rest_api_port_no',
- help='Sets port for REST API interface')
-
- return parser
-
-'''
-if __name__ == '__main__':
- # Command line options
- parser = get_default_test_options_parser()
-
- parser.description = """This script allows you to run mbed defined test cases for particular MCU(s) and corresponding toolchain(s)."""
- parser.epilog = """Example: singletest.py -i test_spec.json -M muts_all.json"""
-
- (opts, args) = parser.parse_args()
-
- # Print summary / information about automation test status
- if opts.test_automation_report:
- print get_avail_tests_summary_table()
- exit(0)
-
- # Print summary / information about automation test status
- if opts.test_case_report:
- test_case_report_cols = ['id', 'automated', 'description', 'peripherals', 'host_test', 'duration', 'source_dir']
- print get_avail_tests_summary_table(cols=test_case_report_cols, result_summary=False, join_delim='\n')
- exit(0)
-
- # Only prints matrix of supported toolchains
- if opts.supported_toolchains:
- print mcu_toolchain_matrix(platform_filter=opts.general_filter_regex)
- exit(0)
-
- # Open file with test specification
- # test_spec_filename tells script which targets and their toolchain(s)
- # should be covered by the test scenario
- test_spec = get_json_data_from_file(opts.test_spec_filename) if opts.test_spec_filename else None
- if test_spec is None:
- if not opts.test_spec_filename:
- parser.print_help()
- exit(-1)
-
- # Get extra MUTs if applicable
- MUTs = get_json_data_from_file(opts.muts_spec_filename) if opts.muts_spec_filename else None
-
- if MUTs is None:
- if not opts.muts_spec_filename:
- parser.print_help()
- exit(-1)
-
- # Only prints read MUTs configuration
- if MUTs and opts.verbose_test_configuration_only:
- print "MUTs configuration in %s:"% opts.muts_spec_filename
- print print_muts_configuration_from_json(MUTs)
- print
- print "Test specification in %s:"% opts.test_spec_filename
- print print_test_configuration_from_json(test_spec)
- exit(0)
-
- # Verbose test specification and MUTs configuration
- if MUTs and opts.verbose:
- print print_muts_configuration_from_json(MUTs)
- if test_spec and opts.verbose:
- print print_test_configuration_from_json(test_spec)
-
- if opts.only_build_tests:
- # We are skipping testing phase, and suppress summary
- opts.suppress_summary = True
-
- single_test = SingleTestRunner(_global_loops_count=opts.test_global_loops_value,
- _test_loops_list=opts.test_loops_list,
- _muts=MUTs,
- _test_spec=test_spec,
- _opts_goanna_for_mbed_sdk=opts.goanna_for_mbed_sdk,
- _opts_goanna_for_tests=opts.goanna_for_tests,
- _opts_shuffle_test_order=opts.shuffle_test_order,
- _opts_shuffle_test_seed=opts.shuffle_test_seed,
- _opts_test_by_names=opts.test_by_names,
- _opts_test_only_peripheral=opts.test_only_peripheral,
- _opts_test_only_common=opts.test_only_common,
- _opts_verbose_skipped_tests=opts.verbose_skipped_tests,
- _opts_verbose_test_result_only=opts.verbose_test_result_only,
- _opts_verbose=opts.verbose,
- _opts_firmware_global_name=opts.firmware_global_name,
- _opts_only_build_tests=opts.only_build_tests,
- _opts_suppress_summary=opts.suppress_summary,
- _opts_test_x_toolchain_summary=opts.test_x_toolchain_summary,
- _opts_copy_method=opts.copy_method
- )
-
- try:
- st_exec_thread = SingleTestExecutor(single_test)
- except KeyboardInterrupt, e:
- print "\n[CTRL+c] exit"
- st_exec_thread.start()
-
- if opts.rest_api_enabled:
- # Enable REST API
-
- app = Flask(__name__)
-
- @app.route('/')
- def hello_world():
- return 'Hello World!'
-
- @app.route('/status')
- def rest_api_status():
- return single_test.rest_api_status() # TODO
-
- @app.route('/config')
- def rest_api_config():
- return single_test.rest_api_config() # TODO
-
- @app.route('/log')
- def rest_api_log():
- return single_test.rest_api_log() # TODO
-
- @app.route('/request/') # 'muts', 'test_spec', 'test_results'
- def rest_api_request_handler(request_type):
- result = single_test.rest_api_request_handler(request_type) # TODO
- return result
-
- rest_api_port = int(opts.rest_api_port_no) if opts.rest_api_port_no else 5555
- app.debug = False
- app.run(port=rest_api_port) # Blocking Flask REST API web service
- else:
- st_exec_thread.join()
-
-'''
diff --git a/tools/tests.py b/tools/tests.py
deleted file mode 100644
index fab1bbf8fd..0000000000
--- a/tools/tests.py
+++ /dev/null
@@ -1,1208 +0,0 @@
-"""
-mbed SDK
-Copyright (c) 2011-2013 ARM Limited
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
- http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-"""
-from tools.paths import *
-from tools.data.support import *
-
-TEST_CMSIS_LIB = join(TEST_DIR, "cmsis", "lib")
-TEST_MBED_LIB = join(TEST_DIR, "mbed", "env")
-
-PERIPHERALS = join(TEST_DIR, "peripherals")
-BENCHMARKS_DIR = join(TEST_DIR, "benchmarks")
-
-SD = join(TEST_DIR, "sd")
-TMP102 = join(PERIPHERALS, 'TMP102')
-AT30TSE75X = join(PERIPHERALS, 'AT30TSE75X')
-
-"""
-Wiring:
- * Ground:
- * LPC1*: p1
- * KL25Z: GND
-
- * Vout
- * LPC1*: p40
- * KL25Z: P3V3
-
- * TMP102 (I2C):
- * LPC1*: (SDA=p28 , SCL=p27)
- * KL25Z: (SDA=PTC9, SCL=PTC8)
- * MAXWSNENV: (SDA=TP6, SCL=TP5)
-
- * digital_loop (Digital(In|Out|InOut), InterruptIn):
- * Arduino headers: (D0 <-> D7)
- * LPC1549: (D2 <-> D7)
- * LPC1*: (p5 <-> p25 )
- * KL25Z: (PTA5<-> PTC6)
- * NUCLEO_F103RB: (PC_6 <-> PB_8)
- * MAXWSNENV: (TP3 <-> TP4)
- * MAX32600MBED: (P1_0 <-> P4_7)
- * VK_RZ_A1H: (P3_2 <-> P5_6)
-
- * port_loop (Port(In|Out|InOut)):
- * Arduino headers: (D0 <-> D7), (D1 <-> D6)
- * LPC1*: (p5 <-> p25), (p6 <-> p26)
- * KL25Z: (PTA5 <-> PTC6), (PTA4 <-> PTC5)
- * NUCLEO_F103RB: (PC_6 <-> PB_8), (PC_5 <-> PB_9)
- * MAXWSNENV: (TP1 <-> TP3), (TP2 <-> TP4)
- * MAX32600MBED: (P1_0 <-> P4_7), (P1_1 <-> P4_6)
- * VK_RZ_A1H: (P3_2 <-> P5_6), (P3_7 <-> P5_1)
-
- * analog_loop (AnalogIn, AnalogOut):
- * Arduino headers: (A0 <-> A5)
- * LPC1549: (A0 <-> D12)
- * LPC1*: (p17 <-> p18 )
- * KL25Z: (PTE30 <-> PTC2)
-
- * analog_pot (AnalogIn):
- * Arduino headers: (A0, A1)
- * VK_RZ_A1H: (AN0, AN1)
-
- * SD (SPI):
- * LPC1*: (mosi=p11 , miso=p12 , sclk=p13 , cs=p14 )
- * KL25Z: (mosi=PTD2, miso=PTD3, sclk=PTD1, cs=PTD0)
-
- * MMA7660 (I2C):
- * LPC1*: (SDA=p28 , SCL=p27)
-
- * i2c_loop:
- * LPC1768: (p28 <-> p9), (p27 <-> p10)
-
- * i2c_eeprom:
- * LPC1*: (SDA=p28 , SCL=p27)
- * KL25Z: (SDA=PTE0, SCL=PTE1)
- * VK_RZ_A1H:(SDA=P1_1, SCL=P1_0)
-
- * can_transceiver:
- * LPC1768: (RX=p9, TX=p10)
- * LPC1549: (RX=D9, TX=D8)
- * LPC4088: (RX=p9, TX=p10)
- * VK_RZ_A1H:(RX=P5_9, TX=P5_10)
- * NUCLEO_F091RC: (RX=PA_11, TX=PA_12)
- * NUCLEO_F072RB: (RX=PA_11, TX=PA_12)
- * NUCLEO_F042K6: (RX=PA_11, TX=PA_12)
- * NUCLEO_F334R8: (RX=PA_11, TX=PA_12)
- * NUCLEO_F303RE: (RX=PA_11, TX=PA_12)
- * NUCLEO_F303K8: (RX=PA_11, TX=PA_12)
- * NUCLEO_F302R8: (RX=PA_11, TX=PA_12)
- * NUCLEO_F446RE: (RX=PA_11, TX=PA_12)
- * DISCO_F469NI: (RX=PB_8, TX=PB_9)
- * DISCO_F4269ZI: (RX=PA_11, TX=PA_12)
- * NUCLEO_F103RB: (RX=PA_11, TX=PA_12)
- * NUCLEO_F746ZG: (RX=PA_11, TX=PA_12)
- * DISCO_F746NG: (RX=PB_8, TX=PB_9)
- * DISCO_L476VG: (RX=PA_11, TX=PA_12)
- * NUCLEO_L476RG: (RX=PA_11, TX=PA_12)
-
-"""
-TESTS = [
- # Automated MBED tests
- {
- "id": "MBED_A1", "description": "Basic",
- "source_dir": join(TEST_DIR, "mbed", "basic"),
- "dependencies": [MBED_LIBRARIES, TEST_MBED_LIB],
- "automated": True,
- },
- {
- "id": "MBED_A2", "description": "Semihost file system",
- "source_dir": join(TEST_DIR, "mbed", "file"),
- "dependencies": [MBED_LIBRARIES, TEST_MBED_LIB],
- "automated": True,
- "mcu": ["LPC1768", "LPC2368", "LPC11U24"]
- },
- {
- "id": "MBED_A3", "description": "C++ STL",
- "source_dir": join(TEST_DIR, "mbed", "stl"),
- "dependencies": [MBED_LIBRARIES, TEST_MBED_LIB],
- "automated": False,
- },
- {
- "id": "MBED_A4", "description": "I2C TMP102",
- "source_dir": join(TEST_DIR, "mbed", "i2c_TMP102"),
- "dependencies": [MBED_LIBRARIES, TEST_MBED_LIB, TMP102],
- "automated": True,
- "peripherals": ["TMP102"]
- },
- {
- "id": "MBED_AT30TSE75X", "description": "I2C Temperature Sensor / EEPROM",
- "source_dir": join(TEST_DIR, "mbed", "i2c_at30tse75x"),
- "dependencies": [MBED_LIBRARIES, TEST_MBED_LIB, AT30TSE75X],
- "automated": False,
- "peripherals": ["AT30TSE75X"]
- },
- {
- "id": "MBED_A5", "description": "DigitalIn DigitalOut",
- "source_dir": join(TEST_DIR, "mbed", "digitalin_digitalout"),
- "dependencies": [MBED_LIBRARIES, TEST_MBED_LIB],
- "automated": True,
- "peripherals": ["digital_loop"]
- },
- {
- "id": "MBED_A6", "description": "DigitalInOut",
- "source_dir": join(TEST_DIR, "mbed", "digitalinout"),
- "dependencies": [MBED_LIBRARIES, TEST_MBED_LIB],
- "automated": True,
- "peripherals": ["digital_loop"]
- },
- {
- "id": "MBED_A7", "description": "InterruptIn",
- "source_dir": join(TEST_DIR, "mbed", "interruptin"),
- "dependencies": [MBED_LIBRARIES, TEST_MBED_LIB],
- "duration": 15,
- "automated": True,
- "peripherals": ["digital_loop"]
- },
- {
- "id": "MBED_A8", "description": "Analog",
- "source_dir": join(TEST_DIR, "mbed", "analog"),
- "dependencies": [MBED_LIBRARIES, TEST_MBED_LIB],
- "automated": True,
- "peripherals": ["analog_loop"],
- "mcu": ["LPC1768", "LPC2368", "LPC2460", "KL25Z", "K64F", "K22F", "LPC4088", "LPC1549",
- "NUCLEO_F072RB", "NUCLEO_F091RC", "NUCLEO_F302R8", "NUCLEO_F303K8", "NUCLEO_F303RE",
- "NUCLEO_F334R8", "NUCLEO_L053R8", "NUCLEO_L073RZ", "NUCLEO_L152RE",
- "NUCLEO_F410RB", "NUCLEO_F411RE", "NUCLEO_F446RE", "DISCO_F407VG", "DISCO_F746NG", "NUCLEO_F746ZG",
- "ARCH_MAX", "MAX32600MBED", "MOTE_L152RC", "B96B_F446VE"]
- },
- {
- "id": "MBED_A9", "description": "Serial Echo at 115200",
- "source_dir": join(TEST_DIR, "mbed", "echo"),
- "dependencies": [MBED_LIBRARIES, TEST_MBED_LIB],
- "automated": True,
- #"host_test": "echo"
- },
- {
- "id": "MBED_A10", "description": "PortOut PortIn",
- "source_dir": join(TEST_DIR, "mbed", "portout_portin"),
- "dependencies": [MBED_LIBRARIES, TEST_MBED_LIB],
- "peripherals": ["port_loop"],
- "supported": DEFAULT_SUPPORT,
- "automated": True,
- },
- {
- "id": "MBED_A11", "description": "PortInOut",
- "source_dir": join(TEST_DIR, "mbed", "portinout"),
- "dependencies": [MBED_LIBRARIES, TEST_MBED_LIB],
- "peripherals": ["port_loop"],
- "supported": DEFAULT_SUPPORT,
- "automated": True,
- },
- {
- "id": "MBED_A12", "description": "SD File System",
- "source_dir": join(TEST_DIR, "mbed", "sd"),
- "dependencies": [MBED_LIBRARIES, TEST_MBED_LIB, FS_LIBRARY],
- "automated": True,
- "duration": 15,
- "peripherals": ["SD"]
- },
- {
- "id": "MBED_A13", "description": "I2C MMA7660 accelerometer",
- "source_dir": join(TEST_DIR, "mbed", "i2c_MMA7660"),
- "dependencies": [MBED_LIBRARIES, TEST_MBED_LIB, join(PERIPHERALS, 'MMA7660')],
- "automated": True,
- "peripherals": ["MMA7660"]
- },
- {
- "id": "MBED_A14", "description": "I2C Master",
- "source_dir": join(TEST_DIR, "mbed", "i2c_master"),
- "dependencies": [MBED_LIBRARIES, TEST_MBED_LIB,],
- },
- {
- "id": "MBED_A15", "description": "I2C Slave",
- "source_dir": join(TEST_DIR, "mbed", "i2c_slave"),
- "dependencies": [MBED_LIBRARIES, TEST_MBED_LIB,],
- },
- {
- "id": "MBED_A16", "description": "SPI Master",
- "source_dir": join(TEST_DIR, "mbed", "spi_master"),
- "dependencies": [MBED_LIBRARIES, TEST_MBED_LIB,],
- },
- {
- "id": "MBED_A17", "description": "SPI Slave",
- "source_dir": join(TEST_DIR, "mbed", "spi_slave"),
- "dependencies": [MBED_LIBRARIES, TEST_MBED_LIB,],
- },
- {
- "id": "MBED_A18", "description": "Interrupt vector relocation",
- "source_dir": join(TEST_DIR, "mbed", "vtor_reloc"),
- "dependencies": [MBED_LIBRARIES, TEST_MBED_LIB,],
- "mcu": ["LPC1768"],
- "automated": True,
- },
- {
- "id": "MBED_A19", "description": "I2C EEPROM read/write test",
- "source_dir": join(TEST_DIR, "mbed", "i2c_eeprom"),
- "dependencies": [MBED_LIBRARIES, TEST_MBED_LIB],
- "peripherals": ["24LC256"],
- "automated": True,
- "duration": 15,
- },
- {
- "id": "MBED_A20", "description": "I2C master/slave test",
- "source_dir": join(TEST_DIR, "mbed", "i2c_master_slave"),
- "dependencies": [MBED_LIBRARIES, TEST_MBED_LIB,],
- "mcu": ["LPC1768", "RZ_A1H"],
- "peripherals": ["i2c_loop"]
- },
- {
- "id": "MBED_A21", "description": "Call function before main (mbed_main)",
- "source_dir": join(TEST_DIR, "mbed", "call_before_main"),
- "dependencies": [MBED_LIBRARIES, TEST_MBED_LIB],
- "automated": True,
- },
- {
- "id": "MBED_A22", "description": "SPIFI for LPC4088 (test 1)",
- "source_dir": join(TEST_DIR, "mbed", "spifi1"),
- "dependencies": [MBED_LIBRARIES, TEST_MBED_LIB],
- "automated": True,
- "duration": 30,
- "mcu": ["LPC4088","LPC4088_DM"]
- },
- {
- "id": "MBED_A23", "description": "SPIFI for LPC4088 (test 2)",
- "source_dir": join(TEST_DIR, "mbed", "spifi2"),
- "dependencies": [MBED_LIBRARIES, TEST_MBED_LIB],
- "automated": True,
- "duration": 30,
- "mcu": ["LPC4088","LPC4088_DM"]
- },
- {
- "id": "MBED_A24", "description": "Serial echo with RTS/CTS flow control",
- "source_dir": join(TEST_DIR, "mbed", "echo_flow_control"),
- "dependencies": [MBED_LIBRARIES],
- "automated": "True",
- "host_test": "echo_flow_control",
- "mcu": ["LPC1768"],
- "peripherals": ["extra_serial"]
- },
- {
- "id": "MBED_A25", "description": "I2C EEPROM line read/write test",
- "source_dir": join(TEST_DIR, "mbed", "i2c_eeprom_line"),
- "dependencies": [MBED_LIBRARIES, TEST_MBED_LIB],
- "peripherals": ["24LC256"],
- "automated": True,
- "duration": 10,
- },
- {
- "id": "MBED_A26", "description": "AnalogIn potentiometer test",
- "source_dir": join(TEST_DIR, "mbed", "analog_pot"),
- "dependencies": [MBED_LIBRARIES, TEST_MBED_LIB],
- "peripherals": ["analog_pot"],
- "automated": True,
- "duration": 10,
- },
- {
- "id": "MBED_A27", "description": "CAN loopback test",
- "source_dir": join(TEST_DIR, "mbed", "can_loopback"),
- "dependencies": [MBED_LIBRARIES, TEST_MBED_LIB],
- "automated": True,
- "duration": 20,
- "peripherals": ["can_transceiver"],
- "mcu": ["LPC1549", "LPC1768","B96B_F446VE", "VK_RZ_A1H",
- "NUCLEO_F091RC", "NUCLEO_F072RB", "NUCLEO_F042K6", "NUCLEO_F334R8",
- "NUCLEO_F303RE", "NUCLEO_F303K8", "NUCLEO_F302R8", "NUCLEO_F446RE",
- "DISCO_F469NI", "DISCO_F429ZI", "NUCLEO_F103RB", "NUCLEO_F746ZG",
- "DISCO_F746NG", "DISCO_L476VG", "NUCLEO_L476RG"]
- },
- {
- "id": "MBED_BLINKY", "description": "Blinky",
- "source_dir": join(TEST_DIR, "mbed", "blinky"),
- "dependencies": [MBED_LIBRARIES, TEST_MBED_LIB],
- "automated": False,
- },
- {
- "id": "MBED_BUS", "description": "Blinky BUS",
- "source_dir": join(TEST_DIR, "mbed", "bus"),
- "dependencies": [MBED_LIBRARIES, TEST_MBED_LIB],
- "automated": False,
- "duration": 15,
- },
-
- {
- "id": "MBED_BUSOUT", "description": "BusOut",
- "source_dir": join(TEST_DIR, "mbed", "bus_out"),
- "dependencies": [MBED_LIBRARIES, TEST_MBED_LIB],
- "automated": True,
- "duration": 15,
- },
-
- # Size benchmarks
- {
- "id": "BENCHMARK_1", "description": "Size (c environment)",
- "source_dir": join(BENCHMARKS_DIR, "cenv"),
- "dependencies": [MBED_LIBRARIES]
- },
- {
- "id": "BENCHMARK_2", "description": "Size (float math)",
- "source_dir": join(BENCHMARKS_DIR, "float_math"),
- "dependencies": [MBED_LIBRARIES]
- },
- {
- "id": "BENCHMARK_3", "description": "Size (printf)",
- "source_dir": join(BENCHMARKS_DIR, "printf"),
- "dependencies": [MBED_LIBRARIES]
- },
- {
- "id": "BENCHMARK_4", "description": "Size (mbed libs)",
- "source_dir": join(BENCHMARKS_DIR, "mbed"),
- "dependencies": [MBED_LIBRARIES]
- },
- {
- "id": "BENCHMARK_5", "description": "Size (all)",
- "source_dir": join(BENCHMARKS_DIR, "all"),
- "dependencies": [MBED_LIBRARIES]
- },
-
- # performance related tests
- {
- "id": "PERF_1", "description": "SD Stdio R/W Speed",
- "source_dir": join(TEST_DIR, "mbed", "sd_perf_stdio"),
- "dependencies": [MBED_LIBRARIES, TEST_MBED_LIB, FS_LIBRARY],
- "automated": True,
- "duration": 15,
- "peripherals": ["SD"]
- },
- {
- "id": "PERF_2", "description": "SD FileHandle R/W Speed",
- "source_dir": join(TEST_DIR, "mbed", "sd_perf_fhandle"),
- "dependencies": [MBED_LIBRARIES, TEST_MBED_LIB, FS_LIBRARY],
- "automated": True,
- "duration": 15,
- "peripherals": ["SD"]
- },
- {
- "id": "PERF_3", "description": "SD FatFS R/W Speed",
- "source_dir": join(TEST_DIR, "mbed", "sd_perf_fatfs"),
- "dependencies": [MBED_LIBRARIES, TEST_MBED_LIB, FS_LIBRARY],
- "automated": True,
- "duration": 15,
- "peripherals": ["SD"]
- },
-
-
- # Not automated MBED tests
- {
- "id": "MBED_1", "description": "I2C SRF08",
- "source_dir": join(TEST_DIR, "mbed", "i2c_SRF08"),
- "dependencies": [MBED_LIBRARIES, TEST_MBED_LIB, join(PERIPHERALS, 'SRF08')],
- "peripherals": ["SRF08"]
- },
- {
- "id": "MBED_2", "description": "stdio",
- "source_dir": join(TEST_DIR, "mbed", "stdio"),
- "dependencies": [MBED_LIBRARIES, TEST_MBED_LIB],
- "duration": 20,
- "automated": True,
- #"host_test": "stdio_auto"
- },
- {
- "id": "MBED_3", "description": "PortOut",
- "source_dir": join(TEST_DIR, "mbed", "portout"),
- "dependencies": [MBED_LIBRARIES],
- },
- {
- "id": "MBED_4", "description": "Sleep",
- "source_dir": join(TEST_DIR, "mbed", "sleep"),
- "dependencies": [MBED_LIBRARIES, TEST_MBED_LIB],
- "duration": 30,
- "mcu": ["LPC1768", "LPC11U24", "LPC4088","LPC4088_DM","NRF51822", "LPC11U68"]
- },
- {
- "id": "MBED_5", "description": "PWM",
- "source_dir": join(TEST_DIR, "mbed", "pwm"),
- "dependencies": [MBED_LIBRARIES, TEST_MBED_LIB]
- },
- {
- "id": "MBED_6", "description": "SW Reset",
- "source_dir": join(TEST_DIR, "mbed", "reset"),
- "dependencies": [MBED_LIBRARIES],
- "duration": 15
- },
- {
- "id": "MBED_7", "description": "stdio benchmark",
- "source_dir": join(TEST_DIR, "mbed", "stdio_benchmark"),
- "dependencies": [MBED_LIBRARIES],
- "duration": 40
- },
- {
- "id": "MBED_8", "description": "SPI",
- "source_dir": join(TEST_DIR, "mbed", "spi"),
- "dependencies": [MBED_LIBRARIES],
- },
- {
- "id": "MBED_9", "description": "Sleep Timeout",
- "source_dir": join(TEST_DIR, "mbed", "sleep_timeout"),
- "dependencies": [MBED_LIBRARIES],
- },
- {
- "id": "MBED_10", "description": "Hello World",
- "source_dir": join(TEST_DIR, "mbed", "hello"),
- "dependencies": [MBED_LIBRARIES, TEST_MBED_LIB],
- "automated": True,
- #"host_test": "hello_auto",
- },
- {
- "id": "MBED_11", "description": "Ticker Int",
- "source_dir": join(TEST_DIR, "mbed", "ticker"),
- "dependencies": [MBED_LIBRARIES, TEST_MBED_LIB],
- "automated": True,
- #"host_test": "wait_us_auto",
- "duration": 20,
- },
- {
- "id": "MBED_12", "description": "C++",
- "source_dir": join(TEST_DIR, "mbed", "cpp"),
- "dependencies": [MBED_LIBRARIES, TEST_MBED_LIB],
- "automated": True
- },
- {
- "id": "MBED_13", "description": "Heap & Stack",
- "source_dir": join(TEST_DIR, "mbed", "heap_and_stack"),
- "dependencies": [MBED_LIBRARIES, TEST_MBED_LIB],
- },
- {
- "id": "MBED_14", "description": "Serial Interrupt",
- "source_dir": join(TEST_DIR, "mbed", "serial_interrupt"),
- "dependencies": [MBED_LIBRARIES, TEST_MBED_LIB],
- },
- {
- "id": "MBED_15", "description": "RPC",
- "source_dir": join(TEST_DIR, "mbed", "rpc"),
- "dependencies": [MBED_LIBRARIES, join(LIB_DIR, "rpc"), TEST_MBED_LIB],
- "automated": False,
- "mcu": ["LPC1768"]
- },
- {
- "id": "MBED_16", "description": "RTC",
- "source_dir": join(TEST_DIR, "mbed", "rtc"),
- "dependencies": [MBED_LIBRARIES, TEST_MBED_LIB],
- "automated": True,
- "exclude_mcu": ["NRF51822", "NRF51822_BOOT", "NRF51822_OTA", "NRF51822_Y5_MBUG",
- "NRF51_DK", "NRF51_DK_BOOT", "NRF51_DK_OTA",
- "NRF51_MICROBIT", "NRF51_MICROBIT_B", "NRF51_MICROBIT_BOOT",
- "NRF51_MICROBIT_B_BOOT", "NRF51_MICROBIT_B_OTA", "NRF51_MICROBIT_OTA",
- "HRM1017", "HRM1017_BOOT", "HRM1701_OTA",
- "TY51822R3", "TY51822R3_BOOT", "TY51822R3_OTA",
- "NRF15_DONGLE", "NRF15_DONGLE_BOOT", "NRF15_DONGLE_OTA",
- "ARCH_BLE", "ARCH_BLE_BOOT", "ARCH_BLE_OTA",
- "ARCH_LINK", "ARCH_LINK_BOOT", "ARCH_LINK_OTA",
- "RBLAB_BLENANO", "RBLAB_BLENANO_BOOT", "RBLAB_BLENANO_OTA",
- "RBLAB_NRF51822", "RBLAB_NRF51822_BOOT", "RBLAB_NRF51822_OTA",
- "SEEED_TINY_BLE", "SEEED_TINY_BLE_BOOT", "SEEED_TINY_BLE_OTA",
- "WALLBOT_BLE", "WALLBOT_BLE_BOOT", "WALLBOT_BLE_OTA",
- "DELTA_DFCM_NNN40", "DELTA_DFCM_NNN40_BOOT", "DELTA_DFCM_NNN40_OTA",
- "LPC1114"],
- #"host_test": "rtc_auto",
- "duration": 15
- },
- {
- "id": "MBED_17", "description": "Serial Interrupt 2",
- "source_dir": join(TEST_DIR, "mbed", "serial_interrupt_2"),
- "dependencies": [MBED_LIBRARIES],
- },
- {
- "id": "MBED_18", "description": "Local FS Directory",
- "source_dir": join(TEST_DIR, "mbed", "dir"),
- "dependencies": [MBED_LIBRARIES],
- },
- {
- "id": "MBED_19", "description": "SD FS Directory",
- "source_dir": join(TEST_DIR, "mbed", "dir_sd"),
- "dependencies": [MBED_LIBRARIES, FS_LIBRARY],
- "peripherals": ["SD"]
- },
- {
- "id": "MBED_20", "description": "InterruptIn 2",
- "source_dir": join(TEST_DIR, "mbed", "interruptin_2"),
- "dependencies": [MBED_LIBRARIES],
- },
- {
- "id": "MBED_21", "description": "freopen Stream",
- "source_dir": join(TEST_DIR, "mbed", "freopen"),
- "dependencies": [MBED_LIBRARIES],
- },
- {
- "id": "MBED_22", "description": "Semihost",
- "source_dir": join(TEST_DIR, "mbed", "semihost"),
- "dependencies": [MBED_LIBRARIES, TEST_MBED_LIB],
- "automated": True,
- "mcu": ["LPC1768", "LPC2368", "LPC11U24"]
- },
- {
- "id": "MBED_23", "description": "Ticker Int us",
- "source_dir": join(TEST_DIR, "mbed", "ticker_2"),
- "dependencies": [MBED_LIBRARIES, TEST_MBED_LIB],
- "duration": 15,
- "automated": True,
- #"host_test": "wait_us_auto"
- },
- {
- "id": "MBED_24", "description": "Timeout Int us",
- "source_dir": join(TEST_DIR, "mbed", "timeout"),
- "dependencies": [MBED_LIBRARIES, TEST_MBED_LIB],
- "duration": 15,
- "automated": True,
- #"host_test": "wait_us_auto"
- },
- {
- "id": "MBED_25", "description": "Time us",
- "source_dir": join(TEST_DIR, "mbed", "time_us"),
- "dependencies": [MBED_LIBRARIES, TEST_MBED_LIB],
- "duration": 15,
- "automated": True,
- #"host_test": "wait_us_auto"
- },
- {
- "id": "MBED_26", "description": "Integer constant division",
- "source_dir": join(TEST_DIR, "mbed", "div"),
- "dependencies": [MBED_LIBRARIES, TEST_MBED_LIB],
- "automated": True,
- },
- {
- "id": "MBED_27", "description": "SPI ADXL345",
- "source_dir": join(TEST_DIR, "mbed", "spi_ADXL345"),
- "dependencies": [MBED_LIBRARIES, TEST_MBED_LIB, join(PERIPHERALS, 'ADXL345')],
- "peripherals": ["ADXL345"]
- },
- {
- "id": "MBED_28", "description": "Interrupt chaining (InterruptManager)",
- "source_dir": join(TEST_DIR, "mbed", "interrupt_chaining"),
- "dependencies": [MBED_LIBRARIES, TEST_MBED_LIB],
- },
- {
- "id": "MBED_29", "description": "CAN network test",
- "source_dir": join(TEST_DIR, "mbed", "can"),
- "dependencies": [MBED_LIBRARIES],
- "mcu": ["LPC1768", "LPC4088", "LPC1549", "RZ_A1H", "B96B_F446VE", "NUCLEO_F091RC",
- "NUCLEO_F072RB", "NUCLEO_F042K6", "NUCLEO_F334R8", "NUCLEO_F303RE",
- "NUCLEO_F303K8", "NUCLEO_F302R8", "NUCLEO_F446RE", "DISCO_F469NI",
- "DISCO_F429ZI", "NUCLEO_F103RB", "NUCLEO_F746ZG", "DISCO_F746NG",
- "NUCLEO_L476RG"]
- },
- {
- "id": "MBED_30", "description": "CAN network test using interrupts",
- "source_dir": join(TEST_DIR, "mbed", "can_interrupt"),
- "dependencies": [MBED_LIBRARIES],
- "mcu": ["LPC1768", "LPC4088", "LPC1549", "RZ_A1H", "B96B_F446VE", "NUCLEO_F091RC",
- "NUCLEO_F072RB", "NUCLEO_F042K6", "NUCLEO_F334R8", "NUCLEO_F303RE",
- "NUCLEO_F303K8", "NUCLEO_F302R8", "NUCLEO_F446RE", "DISCO_F469NI",
- "DISCO_F429ZI", "NUCLEO_F103RB", "NUCLEO_F746ZG", "DISCO_F746NG",
- "NUCLEO_L476RG"]
- },
- {
- "id": "MBED_31", "description": "PWM LED test",
- "source_dir": join(TEST_DIR, "mbed", "pwm_led"),
- "dependencies": [MBED_LIBRARIES],
- },
- {
- "id": "MBED_32", "description": "Pin toggling",
- "source_dir": join(TEST_DIR, "mbed", "pin_toggling"),
- "dependencies": [MBED_LIBRARIES],
- },
- {
- "id": "MBED_33", "description": "C string operations",
- "source_dir": join(TEST_DIR, "mbed", "cstring"),
- "dependencies": [MBED_LIBRARIES, TEST_MBED_LIB],
- "duration": 10,
- "automated": False,
- },
- {
- "id": "MBED_34", "description": "Ticker Two callbacks",
- "source_dir": join(TEST_DIR, "mbed", "ticker_3"),
- "dependencies": [MBED_LIBRARIES, TEST_MBED_LIB],
- "duration": 15,
- "automated": True,
- #"host_test": "wait_us_auto"
- },
- {
- "id": "MBED_35", "description": "SPI C12832 display",
- "source_dir": join(TEST_DIR, "mbed", "spi_C12832"),
- "dependencies": [MBED_LIBRARIES, TEST_MBED_LIB, join(PERIPHERALS, 'C12832')],
- "peripherals": ["C12832"],
- "automated": True,
- "duration": 10,
- },
- {
- "id": "MBED_36", "description": "WFI correct behavior",
- "source_dir": join(TEST_DIR, "mbed", "wfi"),
- "dependencies": [MBED_LIBRARIES, TEST_MBED_LIB],
- "automated": False
- },
- {
- "id": "MBED_37", "description": "Serial NC RX",
- "source_dir": join(TEST_DIR, "mbed", "serial_nc_rx"),
- "dependencies": [MBED_LIBRARIES, TEST_MBED_LIB],
- "automated": True
- },
- {
- "id": "MBED_38", "description": "Serial NC TX",
- "source_dir": join(TEST_DIR, "mbed", "serial_nc_tx"),
- "dependencies": [MBED_LIBRARIES, TEST_MBED_LIB],
- "automated": True
- },
-
- # CMSIS RTOS tests
- {
- "id": "CMSIS_RTOS_1", "description": "Basic",
- "source_dir": join(TEST_DIR, "rtos", "cmsis", "basic"),
- "dependencies": [MBED_LIBRARIES, RTOS_LIBRARIES],
- },
- {
- "id": "CMSIS_RTOS_2", "description": "Mutex",
- "source_dir": join(TEST_DIR, "rtos", "cmsis", "mutex"),
- "dependencies": [MBED_LIBRARIES, RTOS_LIBRARIES],
- "duration": 20
- },
- {
- "id": "CMSIS_RTOS_3", "description": "Semaphore",
- "source_dir": join(TEST_DIR, "rtos", "cmsis", "semaphore"),
- "dependencies": [MBED_LIBRARIES, RTOS_LIBRARIES],
- "duration": 20
- },
- {
- "id": "CMSIS_RTOS_4", "description": "Signals",
- "source_dir": join(TEST_DIR, "rtos", "cmsis", "signals"),
- "dependencies": [MBED_LIBRARIES, RTOS_LIBRARIES],
- },
- {
- "id": "CMSIS_RTOS_5", "description": "Queue",
- "source_dir": join(TEST_DIR, "rtos", "cmsis", "queue"),
- "dependencies": [MBED_LIBRARIES, RTOS_LIBRARIES],
- "duration": 20
- },
- {
- "id": "CMSIS_RTOS_6", "description": "Mail",
- "source_dir": join(TEST_DIR, "rtos", "cmsis", "mail"),
- "dependencies": [MBED_LIBRARIES, RTOS_LIBRARIES],
- "duration": 20
- },
- {
- "id": "CMSIS_RTOS_7", "description": "Timer",
- "source_dir": join(TEST_DIR, "rtos", "cmsis", "timer"),
- "dependencies": [MBED_LIBRARIES, RTOS_LIBRARIES],
- },
- {
- "id": "CMSIS_RTOS_8", "description": "ISR",
- "source_dir": join(TEST_DIR, "rtos", "cmsis", "isr"),
- "dependencies": [MBED_LIBRARIES, RTOS_LIBRARIES],
- },
-
- # mbed RTOS tests
- {
- "id": "RTOS_1", "description": "Basic thread",
- "source_dir": join(TEST_DIR, "rtos", "mbed", "basic"),
- "dependencies": [MBED_LIBRARIES, RTOS_LIBRARIES, TEST_MBED_LIB],
- "duration": 15,
- "automated": True,
- #"host_test": "wait_us_auto",
- "mcu": ["LPC1768", "LPC1549", "LPC11U24", "LPC812", "LPC2460", "LPC824", "SSCI824",
- "KL25Z", "KL05Z", "K64F", "KL46Z",
- "RZ_A1H", "VK_RZ_A1H", "DISCO_F407VG", "DISCO_F429ZI", "NUCLEO_F411RE", "DISCO_F469NI", "NUCLEO_F410RB",
- "NUCLEO_F401RE", "NUCLEO_F334R8", "DISCO_F334C8", "NUCLEO_F302R8", "NUCLEO_F030R8", "NUCLEO_F070RB",
- "NUCLEO_L031K6", "NUCLEO_L053R8", "DISCO_L053C8", "NUCLEO_L073RZ", "NUCLEO_F072RB", "NUCLEO_F091RC", "DISCO_L476VG", "NUCLEO_L476RG",
- "DISCO_F401VC", "NUCLEO_F303RE", "NUCLEO_F303K8", "MAXWSNENV", "MAX32600MBED", "NUCLEO_L152RE", "NUCLEO_F446RE", "NUCLEO_F103RB", "DISCO_F746NG", "NUCLEO_F746ZG", "MOTE_L152RC", "B96B_F446VE",
- "EFM32HG_STK3400", "EFM32PG_STK3401", "EFM32LG_STK3600", "EFM32GG_STK3700", "EFM32WG_STK3800",
- "NRF51822", "NRF51_DK", "NRF51_MICROBIT", "SEEED_TINY_BLE"],
- },
- {
- "id": "RTOS_2", "description": "Mutex resource lock",
- "source_dir": join(TEST_DIR, "rtos", "mbed", "mutex"),
- "dependencies": [MBED_LIBRARIES, RTOS_LIBRARIES, TEST_MBED_LIB],
- "duration": 20,
- "automated": True,
- "mcu": ["LPC1768", "LPC1549", "LPC11U24", "LPC812", "LPC2460", "LPC824", "SSCI824",
- "KL25Z", "KL05Z", "K64F", "KL46Z",
- "RZ_A1H", "VK_RZ_A1H", "DISCO_F407VG", "DISCO_F429ZI", "NUCLEO_F411RE", "DISCO_F469NI", "NUCLEO_F410RB",
- "NUCLEO_F401RE", "NUCLEO_F334R8", "DISCO_F334C8", "NUCLEO_F302R8", "NUCLEO_F030R8", "NUCLEO_F070RB",
- "NUCLEO_L031K6", "NUCLEO_L053R8", "DISCO_L053C8", "NUCLEO_L073RZ", "NUCLEO_F072RB", "NUCLEO_F091RC", "DISCO_L476VG", "NUCLEO_L476RG",
- "DISCO_F401VC", "NUCLEO_F303RE", "NUCLEO_F303K8", "MAXWSNENV", "MAX32600MBED", "NUCLEO_L152RE", "NUCLEO_F446RE", "NUCLEO_F103RB", "DISCO_F746NG",
- "NUCLEO_F746ZG", "MOTE_L152RC", "B96B_F446VE",
- "EFM32HG_STK3400", "EFM32PG_STK3401", "EFM32LG_STK3600", "EFM32GG_STK3700", "EFM32WG_STK3800",
- "NRF51822", "NRF51_DK", "NRF51_MICROBIT", "SEEED_TINY_BLE"],
- },
- {
- "id": "RTOS_3", "description": "Semaphore resource lock",
- "source_dir": join(TEST_DIR, "rtos", "mbed", "semaphore"),
- "dependencies": [MBED_LIBRARIES, RTOS_LIBRARIES, TEST_MBED_LIB],
- "duration": 20,
- "automated": True,
- "mcu": ["LPC1768", "LPC1549", "LPC11U24", "LPC812", "LPC2460", "LPC824", "SSCI824",
- "KL25Z", "KL05Z", "K64F", "KL46Z",
- "RZ_A1H", "VK_RZ_A1H", "DISCO_F407VG", "DISCO_F429ZI", "NUCLEO_F411RE", "DISCO_F469NI", "NUCLEO_F410RB",
- "NUCLEO_F401RE", "NUCLEO_F334R8", "DISCO_F334C8", "NUCLEO_F302R8", "NUCLEO_F030R8", "NUCLEO_F070RB",
- "NUCLEO_L031K6", "NUCLEO_L053R8", "DISCO_L053C8", "NUCLEO_L073RZ", "NUCLEO_F072RB", "NUCLEO_F091RC", "DISCO_L476VG", "NUCLEO_L476RG",
- "DISCO_F401VC", "NUCLEO_F303RE", "NUCLEO_F303K8", "MAXWSNENV", "MAX32600MBED", "NUCLEO_L152RE", "NUCLEO_F446RE", "NUCLEO_F103RB", "DISCO_F746NG",
- "NUCLEO_F746ZG", "MOTE_L152RC", "B96B_F446VE",
- "EFM32HG_STK3400", "EFM32PG_STK3401", "EFM32LG_STK3600", "EFM32GG_STK3700", "EFM32WG_STK3800",
- "NRF51822", "NRF51_DK", "NRF51_MICROBIT", "SEEED_TINY_BLE"],
- },
- {
- "id": "RTOS_4", "description": "Signals messaging",
- "source_dir": join(TEST_DIR, "rtos", "mbed", "signals"),
- "dependencies": [MBED_LIBRARIES, RTOS_LIBRARIES, TEST_MBED_LIB],
- "automated": True,
- "mcu": ["LPC1768", "LPC1549", "LPC11U24", "LPC812", "LPC2460", "LPC824", "SSCI824",
- "KL25Z", "KL05Z", "K64F", "KL46Z",
- "RZ_A1H", "VK_RZ_A1H", "DISCO_F407VG", "DISCO_F429ZI", "NUCLEO_F411RE", "DISCO_F469NI", "NUCLEO_F410RB",
- "NUCLEO_F401RE", "NUCLEO_F334R8", "DISCO_F334C8", "NUCLEO_F302R8", "NUCLEO_F030R8", "NUCLEO_F070RB",
- "NUCLEO_L031K6", "NUCLEO_L053R8", "DISCO_L053C8", "NUCLEO_L073RZ", "NUCLEO_F072RB", "NUCLEO_F091RC", "DISCO_L476VG", "NUCLEO_L476RG",
- "DISCO_F401VC", "NUCLEO_F303RE", "NUCLEO_F303K8", "MAXWSNENV", "MAX32600MBED", "NUCLEO_L152RE", "NUCLEO_F446RE", "NUCLEO_F103RB", "DISCO_F746NG",
- "NUCLEO_F746ZG", "MOTE_L152RC", "B96B_F446VE",
- "EFM32HG_STK3400", "EFM32PG_STK3401", "EFM32LG_STK3600", "EFM32GG_STK3700", "EFM32WG_STK3800",
- "NRF51822", "NRF51_DK", "NRF51_MICROBIT", "SEEED_TINY_BLE"],
- },
- {
- "id": "RTOS_5", "description": "Queue messaging",
- "source_dir": join(TEST_DIR, "rtos", "mbed", "queue"),
- "dependencies": [MBED_LIBRARIES, RTOS_LIBRARIES, TEST_MBED_LIB],
- "automated": True,
- "mcu": ["LPC1768", "LPC1549", "LPC11U24", "LPC812", "LPC2460", "LPC824", "SSCI824",
- "KL25Z", "KL05Z", "K64F", "KL46Z",
- "RZ_A1H", "VK_RZ_A1H", "DISCO_F407VG", "DISCO_F429ZI", "NUCLEO_F411RE", "DISCO_F469NI", "NUCLEO_F410RB",
- "NUCLEO_F401RE", "NUCLEO_F334R8", "DISCO_F334C8", "NUCLEO_F302R8", "NUCLEO_F030R8", "NUCLEO_F070RB",
- "NUCLEO_L031K6", "NUCLEO_L053R8", "DISCO_L053C8", "NUCLEO_L073RZ", "NUCLEO_F072RB", "NUCLEO_F091RC", "DISCO_L476VG", "NUCLEO_L476RG",
- "DISCO_F401VC", "NUCLEO_F303RE", "NUCLEO_F303K8", "MAXWSNENV", "MAX32600MBED", "NUCLEO_L152RE",
- "NUCLEO_F446RE", "NUCLEO_F103RB", "DISCO_F746NG", "NUCLEO_F746ZG", "MOTE_L152RC", "B96B_F446VE",
- "EFM32HG_STK3400", "EFM32PG_STK3401", "EFM32LG_STK3600", "EFM32GG_STK3700", "EFM32WG_STK3800",
- "NRF51822", "NRF51_DK", "NRF51_MICROBIT", "SEEED_TINY_BLE"],
- },
- {
- "id": "RTOS_6", "description": "Mail messaging",
- "source_dir": join(TEST_DIR, "rtos", "mbed", "mail"),
- "dependencies": [MBED_LIBRARIES, RTOS_LIBRARIES, TEST_MBED_LIB],
- "automated": True,
- "mcu": ["LPC1768", "LPC1549", "LPC11U24", "LPC812", "LPC2460", "LPC824", "SSCI824",
- "KL25Z", "KL05Z", "K64F", "KL46Z",
- "RZ_A1H", "VK_RZ_A1H", "DISCO_F407VG", "DISCO_F429ZI", "NUCLEO_F411RE", "DISCO_F469NI", "NUCLEO_F410RB",
- "NUCLEO_F401RE", "NUCLEO_F334R8", "DISCO_F334C8", "NUCLEO_F302R8", "NUCLEO_F030R8", "NUCLEO_F070RB",
- "NUCLEO_L031K6", "NUCLEO_L053R8", "DISCO_L053C8", "NUCLEO_L073RZ", "NUCLEO_F072RB", "NUCLEO_F091RC", "DISCO_L476VG", "NUCLEO_L476RG",
- "DISCO_F401VC", "NUCLEO_F303RE", "NUCLEO_F303K8", "MAXWSNENV", "MAX32600MBED", "NUCLEO_L152RE",
- "NUCLEO_F446RE", "NUCLEO_F103RB", "DISCO_F746NG", "NUCLEO_F746ZG", "MOTE_L152RC", "B96B_F446VE",
- "EFM32HG_STK3400", "EFM32PG_STK3401", "EFM32LG_STK3600", "EFM32GG_STK3700", "EFM32WG_STK3800",
- "NRF51822", "NRF51_DK", "NRF51_MICROBIT", "SEEED_TINY_BLE"],
- },
- {
- "id": "RTOS_7", "description": "Timer",
- "source_dir": join(TEST_DIR, "rtos", "mbed", "timer"),
- "dependencies": [MBED_LIBRARIES, RTOS_LIBRARIES, TEST_MBED_LIB],
- "duration": 15,
- "automated": True,
- #"host_test": "wait_us_auto",
- "mcu": ["LPC1768", "LPC1549", "LPC11U24", "LPC812", "LPC2460", "LPC824", "SSCI824",
- "KL25Z", "KL05Z", "K64F", "KL46Z",
- "RZ_A1H", "VK_RZ_A1H", "DISCO_F407VG", "DISCO_F429ZI", "NUCLEO_F411RE", "DISCO_F469NI", "NUCLEO_F410RB",
- "NUCLEO_F401RE", "NUCLEO_F334R8", "DISCO_F334C8", "NUCLEO_F302R8", "NUCLEO_F030R8", "NUCLEO_F070RB",
- "NUCLEO_L031K6", "NUCLEO_L053R8", "DISCO_L053C8", "NUCLEO_L073RZ", "NUCLEO_F072RB", "NUCLEO_F091RC", "DISCO_L476VG", "NUCLEO_L476RG",
- "DISCO_F401VC", "NUCLEO_F303RE", "NUCLEO_F303K8", "MAXWSNENV", "MAX32600MBED", "NUCLEO_L152RE",
- "NUCLEO_F446RE", "NUCLEO_F103RB", "DISCO_F746NG", "NUCLEO_F746ZG", "MOTE_L152RC", "B96B_F446VE",
- "EFM32HG_STK3400", "EFM32PG_STK3401", "EFM32LG_STK3600", "EFM32GG_STK3700", "EFM32WG_STK3800",
- "NRF51822", "NRF51_DK", "NRF51_MICROBIT", "SEEED_TINY_BLE"],
- },
- {
- "id": "RTOS_8", "description": "ISR (Queue)",
- "source_dir": join(TEST_DIR, "rtos", "mbed", "isr"),
- "dependencies": [MBED_LIBRARIES, RTOS_LIBRARIES, TEST_MBED_LIB],
- "automated": True,
- "mcu": ["LPC1768", "LPC1549", "LPC11U24", "LPC812", "LPC2460", "LPC824", "SSCI824",
- "KL25Z", "KL05Z", "K64F", "KL46Z",
- "RZ_A1H", "VK_RZ_A1H", "DISCO_F407VG", "DISCO_F429ZI", "NUCLEO_F411RE", "DISCO_F469NI", "NUCLEO_F410RB",
- "NUCLEO_F401RE", "NUCLEO_F334R8", "DISCO_F334C8", "NUCLEO_F302R8", "NUCLEO_F030R8", "NUCLEO_F070RB",
- "NUCLEO_L031K6", "NUCLEO_L053R8", "DISCO_L053C8", "NUCLEO_L073RZ", "NUCLEO_F072RB", "NUCLEO_F091RC", "DISCO_L476VG", "NUCLEO_L476RG",
- "DISCO_F401VC", "NUCLEO_F303RE", "NUCLEO_F303K8", "MAXWSNENV", "MAX32600MBED", "NUCLEO_L152RE",
- "NUCLEO_F446RE", "NUCLEO_F103RB", "DISCO_F746NG", "NUCLEO_F746ZG", "MOTE_L152RC", "B96B_F446VE",
- "EFM32HG_STK3400", "EFM32PG_STK3401", "EFM32LG_STK3600", "EFM32GG_STK3700", "EFM32WG_STK3800",
- "NRF51822", "NRF51_DK", "NRF51_MICROBIT", "SEEED_TINY_BLE"],
- },
- {
- "id": "RTOS_9", "description": "SD File write-read",
- "source_dir": join(TEST_DIR, "rtos", "mbed", "file"),
- "dependencies": [MBED_LIBRARIES, RTOS_LIBRARIES, TEST_MBED_LIB, FS_LIBRARY],
- "automated": True,
- "peripherals": ["SD"],
- "mcu": ["LPC1768", "LPC11U24", "LPC812", "KL25Z",
- "KL05Z", "K64F", "KL46Z", "RZ_A1H",
- "DISCO_F407VG", "DISCO_F429ZI", "NUCLEO_F411RE", "NUCLEO_F401RE", "NUCLEO_F410RB", "DISCO_F469NI"],
- },
-
- # Networking Tests
- {
- "id": "NET_1", "description": "TCP client hello world",
- "source_dir": join(TEST_DIR, "net", "helloworld", "tcpclient"),
- "dependencies": [MBED_LIBRARIES, RTOS_LIBRARIES, ETH_LIBRARY, TEST_MBED_LIB],
- "duration": 15,
- "automated": True,
- "peripherals": ["ethernet"],
- },
- {
- "id": "NET_2", "description": "NIST Internet Time Service",
- "source_dir": join(TEST_DIR, "net", "helloworld", "udpclient"),
- "dependencies": [MBED_LIBRARIES, RTOS_LIBRARIES, ETH_LIBRARY, TEST_MBED_LIB],
- "duration": 15,
- "automated": True,
- "peripherals": ["ethernet"],
- },
- {
- "id": "NET_3", "description": "TCP echo server",
- "source_dir": join(TEST_DIR, "net", "echo", "tcp_server"),
- "dependencies": [MBED_LIBRARIES, RTOS_LIBRARIES, ETH_LIBRARY, TEST_MBED_LIB],
- "automated": True,
- #"host_test" : "tcpecho_server_auto",
- "peripherals": ["ethernet"],
- },
- {
- "id": "NET_4", "description": "TCP echo client",
- "source_dir": join(TEST_DIR, "net", "echo", "tcp_client"),
- "dependencies": [MBED_LIBRARIES, RTOS_LIBRARIES, ETH_LIBRARY, TEST_MBED_LIB],
- "automated": True,
- #"host_test": "tcpecho_client_auto",
- "peripherals": ["ethernet"]
- },
- {
- "id": "NET_5", "description": "UDP echo server",
- "source_dir": join(TEST_DIR, "net", "echo", "udp_server"),
- "dependencies": [MBED_LIBRARIES, RTOS_LIBRARIES, ETH_LIBRARY, TEST_MBED_LIB],
- "automated": True,
- #"host_test" : "udpecho_server_auto",
- "peripherals": ["ethernet"]
- },
- {
- "id": "NET_6", "description": "UDP echo client",
- "source_dir": join(TEST_DIR, "net", "echo", "udp_client"),
- "dependencies": [MBED_LIBRARIES, RTOS_LIBRARIES, ETH_LIBRARY, TEST_MBED_LIB],
- "automated": True,
- #"host_test" : "udpecho_client_auto",
- "peripherals": ["ethernet"],
- },
- {
- "id": "NET_7", "description": "HTTP client hello world",
- "source_dir": join(TEST_DIR, "net", "protocols", "HTTPClient_HelloWorld"),
- "dependencies": [MBED_LIBRARIES, RTOS_LIBRARIES, ETH_LIBRARY, TEST_MBED_LIB],
- "automated": True,
- "duration": 15,
- "peripherals": ["ethernet"],
- },
- {
- "id": "NET_8", "description": "NTP client",
- "source_dir": join(TEST_DIR, "net", "protocols", "NTPClient_HelloWorld"),
- "dependencies": [MBED_LIBRARIES, RTOS_LIBRARIES, ETH_LIBRARY, TEST_MBED_LIB],
- "automated": True,
- "peripherals": ["ethernet"],
- },
- {
- "id": "NET_9", "description": "Multicast Send",
- "source_dir": join(TEST_DIR, "net", "helloworld", "multicast_send"),
- "dependencies": [MBED_LIBRARIES, RTOS_LIBRARIES, ETH_LIBRARY],
- "peripherals": ["ethernet"],
- },
- {
- "id": "NET_10", "description": "Multicast Receive",
- "source_dir": join(TEST_DIR, "net", "helloworld", "multicast_receive"),
- "dependencies": [MBED_LIBRARIES, RTOS_LIBRARIES, ETH_LIBRARY],
- "peripherals": ["ethernet"],
- },
- {
- "id": "NET_11", "description": "Broadcast Send",
- "source_dir": join(TEST_DIR, "net", "helloworld", "broadcast_send"),
- "dependencies": [MBED_LIBRARIES, RTOS_LIBRARIES, ETH_LIBRARY],
- "peripherals": ["ethernet"],
- },
- {
- "id": "NET_12", "description": "Broadcast Receive",
- "source_dir": join(TEST_DIR, "net", "helloworld", "broadcast_receive"),
- "dependencies": [MBED_LIBRARIES, RTOS_LIBRARIES, ETH_LIBRARY],
- "peripherals": ["ethernet"],
- },
- {
- "id": "NET_13", "description": "TCP client echo loop",
- "source_dir": join(TEST_DIR, "net", "echo", "tcp_client_loop"),
- "dependencies": [MBED_LIBRARIES, RTOS_LIBRARIES, ETH_LIBRARY, TEST_MBED_LIB],
- "automated": True,
- "duration": 15,
- #"host_test": "tcpecho_client_auto",
- "peripherals": ["ethernet"],
- },
- {
- "id": "NET_14", "description": "UDP PHY/Data link layer",
- "source_dir": join(TEST_DIR, "net", "echo", "udp_link_layer"),
- "dependencies": [MBED_LIBRARIES, RTOS_LIBRARIES, ETH_LIBRARY],
- "automated": False,
- "duration": 20,
- "host_test": "udp_link_layer_auto",
- "peripherals": ["ethernet"],
- },
-
- # u-blox tests
- {
- "id": "UB_1", "description": "u-blox USB modem: HTTP client",
- "source_dir": [join(TEST_DIR, "net", "cellular", "http", "ubloxusb"), join(TEST_DIR, "net", "cellular", "http", "common")],
- "dependencies": [MBED_LIBRARIES, RTOS_LIBRARIES, USB_HOST_LIBRARIES, UBLOX_LIBRARY],
- "supported": CORTEX_ARM_SUPPORT,
- },
- {
- "id": "UB_2", "description": "u-blox USB modem: SMS test",
- "source_dir": [join(TEST_DIR, "net", "cellular", "sms", "ubloxusb"), join(TEST_DIR, "net", "cellular", "sms", "common")],
- "dependencies": [MBED_LIBRARIES, RTOS_LIBRARIES, USB_HOST_LIBRARIES, UBLOX_LIBRARY],
- "supported": CORTEX_ARM_SUPPORT,
- },
-
- # USB Tests
- {
- "id": "USB_1", "description": "Mouse",
- "source_dir": join(TEST_DIR, "usb", "device", "basic"),
- "dependencies": [MBED_LIBRARIES, USB_LIBRARIES],
- },
- {
- "id": "USB_2", "description": "Keyboard",
- "source_dir": join(TEST_DIR, "usb", "device", "keyboard"),
- "dependencies": [MBED_LIBRARIES, USB_LIBRARIES],
- },
- {
- "id": "USB_3", "description": "Mouse_Keyboard",
- "source_dir": join(TEST_DIR, "usb", "device", "keyboard"),
- "dependencies": [MBED_LIBRARIES, USB_LIBRARIES],
- },
- {
- "id": "USB_4", "description": "Serial Port",
- "source_dir": join(TEST_DIR, "usb", "device", "serial"),
- "dependencies": [MBED_LIBRARIES, USB_LIBRARIES],
- "supported": CORTEX_ARM_SUPPORT,
- },
- {
- "id": "USB_5", "description": "Generic HID",
- "source_dir": join(TEST_DIR, "usb", "device", "raw_hid"),
- "dependencies": [MBED_LIBRARIES, USB_LIBRARIES],
- },
- {
- "id": "USB_6", "description": "MIDI",
- "source_dir": join(TEST_DIR, "usb", "device", "midi"),
- "dependencies": [MBED_LIBRARIES, USB_LIBRARIES],
- },
- {
- "id": "USB_7", "description": "AUDIO",
- "source_dir": join(TEST_DIR, "usb", "device", "audio"),
- "dependencies": [MBED_LIBRARIES, USB_LIBRARIES],
- },
-
- # CMSIS DSP
- {
- "id": "CMSIS_DSP_1", "description": "FIR",
- "source_dir": join(TEST_DIR, "dsp", "cmsis", "fir_f32"),
- "dependencies": [MBED_LIBRARIES, DSP_LIBRARIES],
- },
-
- # mbed DSP
- {
- "id": "DSP_1", "description": "FIR",
- "source_dir": join(TEST_DIR, "dsp", "mbed", "fir_f32"),
- "dependencies": [MBED_LIBRARIES, DSP_LIBRARIES],
- },
-
- # KL25Z
- {
- "id": "KL25Z_1", "description": "LPTMR",
- "source_dir": join(TEST_DIR, "KL25Z", "lptmr"),
- "dependencies": [MBED_LIBRARIES],
- "supported": CORTEX_ARM_SUPPORT,
- "mcu": ["KL25Z"],
- },
- {
- "id": "KL25Z_2", "description": "PIT",
- "source_dir": join(TEST_DIR, "KL25Z", "pit"),
- "dependencies": [MBED_LIBRARIES],
- "supported": CORTEX_ARM_SUPPORT,
- "mcu": ["KL25Z"],
- },
- {
- "id": "KL25Z_3", "description": "TSI Touch Sensor",
- "source_dir": join(TEST_DIR, "mbed", "tsi"),
- "dependencies": [MBED_LIBRARIES, TEST_MBED_LIB, join(PERIPHERALS, 'TSI')],
- "mcu": ["KL25Z"],
- },
- {
- "id": "KL25Z_4", "description": "RTC",
- "source_dir": join(TEST_DIR, "KL25Z", "rtc"),
- "dependencies": [MBED_LIBRARIES],
- "mcu": ["KL25Z"],
- },
- {
- "id": "KL25Z_5", "description": "MMA8451Q accelerometer",
- "source_dir": join(TEST_DIR, "mbed", "i2c_MMA8451Q"),
- "dependencies": [MBED_LIBRARIES, TEST_MBED_LIB, join(PERIPHERALS, 'MMA8451Q')],
- "mcu": ["KL25Z", "KL05Z", "KL46Z", "K20D50M"],
- "automated": True,
- "duration": 15,
- },
-
- # Examples
- {
- "id": "EXAMPLE_1", "description": "/dev/null",
- "source_dir": join(TEST_DIR, "mbed", "dev_null"),
- "dependencies": [MBED_LIBRARIES, TEST_MBED_LIB],
- "automated": True,
- #"host_test" : "dev_null_auto",
- },
- {
- "id": "EXAMPLE_2", "description": "FS + RTOS",
- "source_dir": join(TEST_DIR, "mbed", "fs"),
- "dependencies": [MBED_LIBRARIES, RTOS_LIBRARIES, TEST_MBED_LIB, FS_LIBRARY],
- },
-
- # CPPUTEST Library provides Unit testing Framework
- #
- # To write TESTs and TEST_GROUPs please add CPPUTEST_LIBRARY to 'dependencies'
- #
- # This will also include:
- # 1. test runner - main function with call to CommandLineTestRunner::RunAllTests(ac, av)
- # 2. Serial console object to print test result on serial port console
- #
-
- # Unit testing with cpputest library
- {
- "id": "UT_1", "description": "Basic",
- "source_dir": join(TEST_DIR, "utest", "basic"),
- "dependencies": [MBED_LIBRARIES, TEST_MBED_LIB, CPPUTEST_LIBRARY],
- "automated": False,
- },
- {
- "id": "UT_2", "description": "Semihost file system",
- "source_dir": join(TEST_DIR, "utest", "semihost_fs"),
- "dependencies": [MBED_LIBRARIES, TEST_MBED_LIB, CPPUTEST_LIBRARY],
- "automated": False,
- "mcu": ["LPC1768", "LPC2368", "LPC11U24"]
- },
- {
- "id": "UT_3", "description": "General tests",
- "source_dir": join(TEST_DIR, "utest", "general"),
- "dependencies": [MBED_LIBRARIES, TEST_MBED_LIB, CPPUTEST_LIBRARY],
- "automated": False,
- },
- {
- "id": "UT_BUSIO", "description": "BusIn BusOut",
- "source_dir": join(TEST_DIR, "utest", "bus"),
- "dependencies": [MBED_LIBRARIES, TEST_MBED_LIB, CPPUTEST_LIBRARY],
- "automated": False,
- },
- {
- "id": "UT_I2C_EEPROM_ASYNCH", "description": "I2C Asynch eeprom",
- "source_dir": join(TEST_DIR, "utest", "i2c_eeprom_asynch"),
- "dependencies": [MBED_LIBRARIES, TEST_MBED_LIB, CPPUTEST_LIBRARY],
- "automated": False,
- },
- {
- "id": "UT_SERIAL_ASYNCH", "description": "Asynch serial test (req 2 serial peripherals)",
- "source_dir": join(TEST_DIR, "utest", "serial_asynch"),
- "dependencies": [MBED_LIBRARIES, TEST_MBED_LIB, CPPUTEST_LIBRARY],
- "automated": False,
- },
- {
- "id": "UT_SPI_ASYNCH", "description": "Asynch spi test",
- "source_dir": join(TEST_DIR, "utest", "spi_asynch"),
- "dependencies": [MBED_LIBRARIES, TEST_MBED_LIB, CPPUTEST_LIBRARY],
- "automated": False,
- },
- {
- "id": "UT_LP_TICKER", "description": "Low power ticker test",
- "source_dir": join(TEST_DIR, "utest", "lp_ticker"),
- "dependencies": [MBED_LIBRARIES, TEST_MBED_LIB, CPPUTEST_LIBRARY],
- "automated": False,
- },
-
- # Tests used for target information purposes
- {
- "id": "DTCT_1", "description": "Simple detect test",
- "source_dir": join(TEST_DIR, "mbed", "detect"),
- "dependencies": [MBED_LIBRARIES, TEST_MBED_LIB],
- "automated": True,
- #"host_test" : "detect_auto",
- },
-
-]
-
-# Group tests with the same goals into categories
-GROUPS = {
- "core": ["MBED_A1", "MBED_A2", "MBED_A3", "MBED_A18"],
- "digital_io": ["MBED_A5", "MBED_A6", "MBED_A7", "MBED_A10", "MBED_A11"],
- "analog_io": ["MBED_A8"],
- "i2c": ["MBED_A19", "MBED_A20"],
- "spi": ["MBED_A12"],
-}
-GROUPS["rtos"] = [test["id"] for test in TESTS if test["id"].startswith("RTOS_")]
-GROUPS["net"] = [test["id"] for test in TESTS if test["id"].startswith("NET_")]
-GROUPS["automated"] = [test["id"] for test in TESTS if test.get("automated", False)]
-# Look for 'TEST_GROUPS' in mbed_settings.py and update the GROUPS dictionary
-# with the information in test_groups if found
-try:
- from mbed_settings import TEST_GROUPS
-except:
- TEST_GROUPS = {}
-GROUPS.update(TEST_GROUPS)
-
-class Test:
- DEFAULTS = {
- #'mcu': None,
- 'description': None,
- 'dependencies': None,
- 'duration': 10,
- 'host_test': 'host_test',
- 'automated': False,
- 'peripherals': None,
- #'supported': None,
- 'source_dir': None,
- 'extra_files': None
- }
- def __init__(self, n):
- self.n = n
- self.__dict__.update(Test.DEFAULTS)
- self.__dict__.update(TESTS[n])
-
- def is_supported(self, target, toolchain):
- if hasattr(self, 'mcu') and not target in self.mcu:
- return False
- if hasattr(self, 'exclude_mcu') and target in self.exclude_mcu:
- return False
- if not hasattr(self, 'supported'):
- return True
- return (target in self.supported) and (toolchain in self.supported[target])
-
- def get_description(self):
- if self.description:
- return self.description
- else:
- return self.id
-
- def __cmp__(self, other):
- return cmp(self.n, other.n)
-
- def __str__(self):
- return "[%3d] %s: %s" % (self.n, self.id, self.get_description())
-
- def __getitem__(self, key):
- if key == "id": return self.id
- elif key == "mcu": return self.mcu
- elif key == "exclude_mcu": return self.exclude_mcu
- elif key == "dependencies": return self.dependencies
- elif key == "description": return self.description
- elif key == "duration": return self.duration
- elif key == "host_test": return self.host_test
- elif key == "automated": return self.automated
- elif key == "peripherals": return self.peripherals
- elif key == "supported": return self.supported
- elif key == "source_dir": return self.source_dir
- elif key == "extra_files": return self.extra_files
- else:
- return None
-
-TEST_MAP = dict([(test['id'], Test(i)) for i, test in enumerate(TESTS)])
diff --git a/tools/toolchains/__init__.py b/tools/toolchains/__init__.py
deleted file mode 100644
index 765257fc36..0000000000
--- a/tools/toolchains/__init__.py
+++ /dev/null
@@ -1,872 +0,0 @@
-"""
-mbed SDK
-Copyright (c) 2011-2013 ARM Limited
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
- http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-"""
-
-import re
-import sys
-from os import stat, walk, getcwd, sep
-from copy import copy
-from time import time, sleep
-from types import ListType
-from shutil import copyfile
-from os.path import join, splitext, exists, relpath, dirname, basename, split, abspath
-from inspect import getmro
-
-from multiprocessing import Pool, cpu_count
-from tools.utils import run_cmd, mkdir, rel_path, ToolException, NotSupportedException, split_path
-from tools.settings import BUILD_OPTIONS, MBED_ORG_USER
-import tools.hooks as hooks
-from tools.memap import MemapParser
-from hashlib import md5
-import fnmatch
-
-
-#Disables multiprocessing if set to higher number than the host machine CPUs
-CPU_COUNT_MIN = 1
-
-def compile_worker(job):
- results = []
- for command in job['commands']:
- _, _stderr, _rc = run_cmd(command, job['work_dir'])
- results.append({
- 'code': _rc,
- 'output': _stderr,
- 'command': command
- })
-
- return {
- 'source': job['source'],
- 'object': job['object'],
- 'commands': job['commands'],
- 'results': results
- }
-
-
-class Resources:
- def __init__(self, base_path=None):
- self.base_path = base_path
-
- self.inc_dirs = []
- self.headers = []
-
- self.s_sources = []
- self.c_sources = []
- self.cpp_sources = []
-
- self.lib_dirs = set([])
- self.objects = []
- self.libraries = []
-
- # mbed special files
- self.lib_builds = []
- self.lib_refs = []
-
- self.repo_dirs = []
- self.repo_files = []
-
- self.linker_script = None
-
- # Other files
- self.hex_files = []
- self.bin_files = []
- self.json_files = []
-
- def __add__(self, resources):
- if resources is None:
- return self
- else:
- return self.add(resources)
-
- def __radd__(self, resources):
- if resources is None:
- return self
- else:
- return self.add(resources)
-
- def add(self, resources):
- self.inc_dirs += resources.inc_dirs
- self.headers += resources.headers
-
- self.s_sources += resources.s_sources
- self.c_sources += resources.c_sources
- self.cpp_sources += resources.cpp_sources
-
- self.lib_dirs |= resources.lib_dirs
- self.objects += resources.objects
- self.libraries += resources.libraries
-
- self.lib_builds += resources.lib_builds
- self.lib_refs += resources.lib_refs
-
- self.repo_dirs += resources.repo_dirs
- self.repo_files += resources.repo_files
-
- if resources.linker_script is not None:
- self.linker_script = resources.linker_script
-
- self.hex_files += resources.hex_files
- self.bin_files += resources.bin_files
- self.json_files += resources.json_files
-
- return self
-
- def relative_to(self, base, dot=False):
- for field in ['inc_dirs', 'headers', 's_sources', 'c_sources',
- 'cpp_sources', 'lib_dirs', 'objects', 'libraries',
- 'lib_builds', 'lib_refs', 'repo_dirs', 'repo_files',
- 'hex_files', 'bin_files', 'json_files']:
- v = [rel_path(f, base, dot) for f in getattr(self, field)]
- setattr(self, field, v)
- if self.linker_script is not None:
- self.linker_script = rel_path(self.linker_script, base, dot)
-
- def win_to_unix(self):
- for field in ['inc_dirs', 'headers', 's_sources', 'c_sources',
- 'cpp_sources', 'lib_dirs', 'objects', 'libraries',
- 'lib_builds', 'lib_refs', 'repo_dirs', 'repo_files',
- 'hex_files', 'bin_files', 'json_files']:
- v = [f.replace('\\', '/') for f in getattr(self, field)]
- setattr(self, field, v)
- if self.linker_script is not None:
- self.linker_script = self.linker_script.replace('\\', '/')
-
- def __str__(self):
- s = []
-
- for (label, resources) in (
- ('Include Directories', self.inc_dirs),
- ('Headers', self.headers),
-
- ('Assembly sources', self.s_sources),
- ('C sources', self.c_sources),
- ('C++ sources', self.cpp_sources),
-
- ('Library directories', self.lib_dirs),
- ('Objects', self.objects),
- ('Libraries', self.libraries),
-
- ('Hex files', self.hex_files),
- ('Bin files', self.bin_files),
- ):
- if resources:
- s.append('%s:\n ' % label + '\n '.join(resources))
-
- if self.linker_script:
- s.append('Linker Script: ' + self.linker_script)
-
- return '\n'.join(s)
-
-# Support legacy build conventions: the original mbed build system did not have
-# standard labels for the "TARGET_" and "TOOLCHAIN_" specific directories, but
-# had the knowledge of a list of these directories to be ignored.
-LEGACY_IGNORE_DIRS = set([
- 'LPC11U24', 'LPC1768', 'LPC2368', 'LPC4088', 'LPC812', 'KL25Z',
- 'ARM', 'GCC_ARM', 'GCC_CR', 'IAR', 'uARM'
-])
-LEGACY_TOOLCHAIN_NAMES = {
- 'ARM_STD':'ARM', 'ARM_MICRO': 'uARM',
- 'GCC_ARM': 'GCC_ARM', 'GCC_CR': 'GCC_CR',
- 'IAR': 'IAR',
-}
-
-
-class mbedToolchain:
- VERBOSE = True
- ignorepatterns = []
-
- CORTEX_SYMBOLS = {
- "Cortex-M0" : ["__CORTEX_M0", "ARM_MATH_CM0", "__CMSIS_RTOS", "__MBED_CMSIS_RTOS_CM"],
- "Cortex-M0+": ["__CORTEX_M0PLUS", "ARM_MATH_CM0PLUS", "__CMSIS_RTOS", "__MBED_CMSIS_RTOS_CM"],
- "Cortex-M1" : ["__CORTEX_M3", "ARM_MATH_CM1"],
- "Cortex-M3" : ["__CORTEX_M3", "ARM_MATH_CM3", "__CMSIS_RTOS", "__MBED_CMSIS_RTOS_CM"],
- "Cortex-M4" : ["__CORTEX_M4", "ARM_MATH_CM4", "__CMSIS_RTOS", "__MBED_CMSIS_RTOS_CM"],
- "Cortex-M4F" : ["__CORTEX_M4", "ARM_MATH_CM4", "__FPU_PRESENT=1", "__CMSIS_RTOS", "__MBED_CMSIS_RTOS_CM"],
- "Cortex-M7" : ["__CORTEX_M7", "ARM_MATH_CM7", "__CMSIS_RTOS", "__MBED_CMSIS_RTOS_CM"],
- "Cortex-M7F" : ["__CORTEX_M7", "ARM_MATH_CM7", "__FPU_PRESENT=1", "__CMSIS_RTOS", "__MBED_CMSIS_RTOS_CM"],
- "Cortex-A9" : ["__CORTEX_A9", "ARM_MATH_CA9", "__FPU_PRESENT", "__CMSIS_RTOS", "__EVAL", "__MBED_CMSIS_RTOS_CA9"],
- }
-
- GOANNA_FORMAT = "[Goanna] warning [%FILENAME%:%LINENO%] - [%CHECKNAME%(%SEVERITY%)] %MESSAGE%"
- GOANNA_DIAGNOSTIC_PATTERN = re.compile(r'"\[Goanna\] (?Pwarning) \[(?P[^:]+):(?P\d+)\] \- (?P.*)"')
-
- def __init__(self, target, options=None, notify=None, macros=None, silent=False, extra_verbose=False):
- self.target = target
- self.name = self.__class__.__name__
- self.hook = hooks.Hook(target, self)
- self.silent = silent
- self.output = ""
-
- self.legacy_ignore_dirs = LEGACY_IGNORE_DIRS - set([target.name, LEGACY_TOOLCHAIN_NAMES[self.name]])
-
- if notify:
- self.notify_fun = notify
- elif extra_verbose:
- self.notify_fun = self.print_notify_verbose
- else:
- self.notify_fun = self.print_notify
-
- self.options = options if options is not None else []
-
- self.macros = macros or []
- self.options.extend(BUILD_OPTIONS)
- if self.options:
- self.info("Build Options: %s" % (', '.join(self.options)))
-
- self.obj_path = join("TARGET_"+target.name, "TOOLCHAIN_"+self.name)
-
- self.symbols = None
- self.labels = None
- self.has_config = False
-
- self.build_all = False
- self.build_dir = None
- self.timestamp = time()
- self.jobs = 1
-
- self.CHROOT = None
-
- self.mp_pool = None
-
- if 'UVISOR' in self.target.features and 'UVISOR_SUPPORTED' in self.target.extra_labels:
- self.target.core = re.sub(r"F$", '', self.target.core)
-
- def get_output(self):
- return self.output
-
- def print_notify(self, event, silent=False):
- """ Default command line notification
- """
- msg = None
-
- if not self.VERBOSE and event['type'] == 'tool_error':
- msg = event['message']
-
- elif event['type'] in ['info', 'debug']:
- msg = event['message']
-
- elif event['type'] == 'cc':
- event['severity'] = event['severity'].title()
- event['file'] = basename(event['file'])
- msg = '[%(severity)s] %(file)s@%(line)s: %(message)s' % event
-
- elif event['type'] == 'progress':
- if not silent:
- msg = '%s: %s' % (event['action'].title(), basename(event['file']))
-
- if msg:
- print msg
- self.output += msg + "\n"
-
- def print_notify_verbose(self, event, silent=False):
- """ Default command line notification with more verbose mode
- """
- if event['type'] in ['info', 'debug']:
- self.print_notify(event) # standard handle
-
- elif event['type'] == 'cc':
- event['severity'] = event['severity'].title()
- event['file'] = basename(event['file'])
- event['mcu_name'] = "None"
- event['toolchain'] = "None"
- event['target_name'] = event['target_name'].upper() if event['target_name'] else "Unknown"
- event['toolchain_name'] = event['toolchain_name'].upper() if event['toolchain_name'] else "Unknown"
- msg = '[%(severity)s] %(target_name)s::%(toolchain_name)s::%(file)s@%(line)s: %(message)s' % event
- print msg
- self.output += msg + "\n"
-
- elif event['type'] == 'progress':
- self.print_notify(event) # standard handle
-
- def notify(self, event):
- """ Little closure for notify functions
- """
- return self.notify_fun(event, self.silent)
-
- def __exit__(self):
- if self.mp_pool is not None:
- self.mp_pool.terminate()
-
- def goanna_parse_line(self, line):
- if "analyze" in self.options:
- return self.GOANNA_DIAGNOSTIC_PATTERN.match(line)
- else:
- return None
-
- def get_symbols(self):
- if self.symbols is None:
- # Target and Toolchain symbols
- labels = self.get_labels()
- self.symbols = ["TARGET_%s" % t for t in labels['TARGET']]
- self.symbols.extend(["FEATURE_%s" % t for t in labels['FEATURE']])
- self.symbols.extend(["TOOLCHAIN_%s" % t for t in labels['TOOLCHAIN']])
-
- # Config support
- if self.has_config:
- self.symbols.append('HAVE_MBED_CONFIG_H')
-
- # Cortex CPU symbols
- if self.target.core in mbedToolchain.CORTEX_SYMBOLS:
- self.symbols.extend(mbedToolchain.CORTEX_SYMBOLS[self.target.core])
-
- # Symbols defined by the on-line build.system
- self.symbols.extend(['MBED_BUILD_TIMESTAMP=%s' % self.timestamp, 'TARGET_LIKE_MBED', '__MBED__=1'])
- if MBED_ORG_USER:
- self.symbols.append('MBED_USERNAME=' + MBED_ORG_USER)
-
- # Add target's symbols
- self.symbols += self.target.macros
- # Add target's hardware
- self.symbols += ["DEVICE_" + data + "=1" for data in self.target.device_has]
- # Add target's features
- self.symbols += ["FEATURE_" + data + "=1" for data in self.target.features]
- # Add extra symbols passed via 'macros' parameter
- self.symbols += self.macros
-
- # Form factor variables
- if hasattr(self.target, 'supported_form_factors'):
- self.symbols.extend(["TARGET_FF_%s" % t for t in self.target.supported_form_factors])
-
- return list(set(self.symbols)) # Return only unique symbols
-
- # Extend the internal list of macros
- def add_macros(self, new_macros):
- self.macros.extend(new_macros)
-
- def get_labels(self):
- if self.labels is None:
- toolchain_labels = [c.__name__ for c in getmro(self.__class__)]
- toolchain_labels.remove('mbedToolchain')
- self.labels = {
- 'TARGET': self.target.get_labels() + ["DEBUG" if "debug-info" in self.options else "RELEASE"],
- 'FEATURE': self.target.features,
- 'TOOLCHAIN': toolchain_labels
- }
- return self.labels
-
- def need_update(self, target, dependencies):
- if self.build_all:
- return True
-
- if not exists(target):
- return True
-
- target_mod_time = stat(target).st_mtime
-
- for d in dependencies:
-
- # Some objects are not provided with full path and here we do not have
- # information about the library paths. Safe option: assume an update
- if not d or not exists(d):
- return True
-
- if stat(d).st_mtime >= target_mod_time:
- return True
-
- return False
-
- def is_ignored(self, file_path):
- for pattern in self.ignorepatterns:
- if fnmatch.fnmatch(file_path, pattern):
- return True
- return False
-
- def scan_resources(self, path, exclude_paths=None):
- labels = self.get_labels()
- resources = Resources(path)
- self.has_config = False
-
- """ os.walk(top[, topdown=True[, onerror=None[, followlinks=False]]])
- When topdown is True, the caller can modify the dirnames list in-place
- (perhaps using del or slice assignment), and walk() will only recurse into
- the subdirectories whose names remain in dirnames; this can be used to prune
- the search, impose a specific order of visiting, or even to inform walk()
- about directories the caller creates or renames before it resumes walk()
- again. Modifying dirnames when topdown is False is ineffective, because in
- bottom-up mode the directories in dirnames are generated before dirpath
- itself is generated.
- """
- for root, dirs, files in walk(path, followlinks=True):
- # Remove ignored directories
- # Check if folder contains .mbedignore
- if ".mbedignore" in files :
- with open (join(root,".mbedignore"), "r") as f:
- lines=f.readlines()
- lines = [l.strip() for l in lines] # Strip whitespaces
- lines = [l for l in lines if l != ""] # Strip empty lines
- lines = [l for l in lines if not re.match("^#",l)] # Strip comment lines
- # Append root path to glob patterns
- # and append patterns to ignorepatterns
- self.ignorepatterns.extend([join(root,line.strip()) for line in lines])
-
- for d in copy(dirs):
- dir_path = join(root, d)
- if d == '.hg':
- resources.repo_dirs.append(dir_path)
- resources.repo_files.extend(self.scan_repository(dir_path))
-
- if ((d.startswith('.') or d in self.legacy_ignore_dirs) or
- (d.startswith('TARGET_') and d[7:] not in labels['TARGET']) or
- (d.startswith('FEATURE_') and d[8:] not in labels['FEATURE']) or
- (d.startswith('TOOLCHAIN_') and d[10:] not in labels['TOOLCHAIN']) or
- (d == 'TESTS')):
- dirs.remove(d)
-
-
- # Remove dirs that already match the ignorepatterns
- # to avoid travelling into them and to prevent them
- # on appearing in include path.
- if self.is_ignored(join(dir_path,"")):
- dirs.remove(d)
-
- if exclude_paths:
- for exclude_path in exclude_paths:
- rel_path = relpath(dir_path, exclude_path)
- if not (rel_path.startswith('..')):
- dirs.remove(d)
- break
-
- # Add root to include paths
- resources.inc_dirs.append(root)
-
- for file in files:
- file_path = join(root, file)
-
- if self.is_ignored(file_path):
- continue
-
- _, ext = splitext(file)
- ext = ext.lower()
-
- if ext == '.s':
- resources.s_sources.append(file_path)
-
- elif ext == '.c':
- resources.c_sources.append(file_path)
-
- elif ext == '.cpp':
- resources.cpp_sources.append(file_path)
-
- elif ext == '.h' or ext == '.hpp':
- if basename(file_path) == "mbed_config.h":
- self.has_config = True
- resources.headers.append(file_path)
-
- elif ext == '.o':
- resources.objects.append(file_path)
-
- elif ext == self.LIBRARY_EXT:
- resources.libraries.append(file_path)
- resources.lib_dirs.add(root)
-
- elif ext == self.LINKER_EXT:
- if resources.linker_script is not None:
- self.info("Warning: Multiple linker scripts detected: %s -> %s" % (resources.linker_script, file_path))
- resources.linker_script = file_path
-
- elif ext == '.lib':
- resources.lib_refs.append(file_path)
-
- elif ext == '.bld':
- resources.lib_builds.append(file_path)
-
- elif file == '.hgignore':
- resources.repo_files.append(file_path)
-
- elif ext == '.hex':
- resources.hex_files.append(file_path)
-
- elif ext == '.bin':
- resources.bin_files.append(file_path)
-
- elif ext == '.json':
- resources.json_files.append(file_path)
-
- return resources
-
- def scan_repository(self, path):
- resources = []
-
- for root, dirs, files in walk(path):
- # Remove ignored directories
- for d in copy(dirs):
- if d == '.' or d == '..':
- dirs.remove(d)
-
- for file in files:
- file_path = join(root, file)
- resources.append(file_path)
-
- return resources
-
- def copy_files(self, files_paths, trg_path, rel_path=None):
-
- # Handle a single file
- if type(files_paths) != ListType: files_paths = [files_paths]
-
- for source in files_paths:
- if source is None:
- files_paths.remove(source)
-
- for source in files_paths:
- if rel_path is not None:
- relative_path = relpath(source, rel_path)
- else:
- _, relative_path = split(source)
-
- target = join(trg_path, relative_path)
-
- if (target != source) and (self.need_update(target, [source])):
- self.progress("copy", relative_path)
- mkdir(dirname(target))
- copyfile(source, target)
-
- def relative_object_path(self, build_path, base_dir, source):
- source_dir, name, _ = split_path(source)
-
- obj_dir = join(build_path, relpath(source_dir, base_dir))
- mkdir(obj_dir)
- return join(obj_dir, name + '.o')
-
- def get_inc_file(self, includes):
- include_file = join(self.build_dir, ".includes_%s.txt" % self.inc_md5)
- if not exists(include_file):
- with open(include_file, "wb") as f:
- cmd_list = []
- for c in includes:
- if c:
- cmd_list.append(('-I%s' % c).replace("\\", "/"))
- string = " ".join(cmd_list)
- f.write(string)
- return include_file
-
- def compile_sources(self, resources, build_path, inc_dirs=None):
- # Web IDE progress bar for project build
- files_to_compile = resources.s_sources + resources.c_sources + resources.cpp_sources
- self.to_be_compiled = len(files_to_compile)
- self.compiled = 0
-
- inc_paths = resources.inc_dirs
- if inc_dirs is not None:
- inc_paths.extend(inc_dirs)
- # De-duplicate include paths
- inc_paths = set(inc_paths)
- # Sort include paths for consistency
- inc_paths = sorted(set(inc_paths))
- # Unique id of all include paths
- self.inc_md5 = md5(' '.join(inc_paths)).hexdigest()
- # Where to store response files
- self.build_dir = build_path
-
- objects = []
- queue = []
- prev_dir = None
-
- # The dependency checking for C/C++ is delegated to the compiler
- base_path = resources.base_path
- # Sort compile queue for consistency
- files_to_compile.sort()
- work_dir = getcwd()
-
- for source in files_to_compile:
- _, name, _ = split_path(source)
- object = self.relative_object_path(build_path, base_path, source)
-
- # Queue mode (multiprocessing)
- commands = self.compile_command(source, object, inc_paths)
- if commands is not None:
- queue.append({
- 'source': source,
- 'object': object,
- 'commands': commands,
- 'work_dir': work_dir,
- 'chroot': self.CHROOT
- })
- else:
- objects.append(object)
-
- # Use queues/multiprocessing if cpu count is higher than setting
- jobs = self.jobs if self.jobs else cpu_count()
- if jobs > CPU_COUNT_MIN and len(queue) > jobs:
- return self.compile_queue(queue, objects)
- else:
- return self.compile_seq(queue, objects)
-
- def compile_seq(self, queue, objects):
- for item in queue:
- result = compile_worker(item)
-
- self.compiled += 1
- self.progress("compile", item['source'], build_update=True)
- for res in result['results']:
- self.debug("Command: %s" % ' '.join(res['command']))
- self.compile_output([
- res['code'],
- res['output'],
- res['command']
- ])
- objects.append(result['object'])
- return objects
-
- def compile_queue(self, queue, objects):
- jobs_count = int(self.jobs if self.jobs else cpu_count())
- p = Pool(processes=jobs_count)
-
- results = []
- for i in range(len(queue)):
- results.append(p.apply_async(compile_worker, [queue[i]]))
-
- itr = 0
- while True:
- itr += 1
- if itr > 180000:
- p.terminate()
- p.join()
- raise ToolException("Compile did not finish in 5 minutes")
-
- pending = 0
- for r in results:
- if r._ready is True:
- try:
- result = r.get()
- results.remove(r)
-
- self.compiled += 1
- self.progress("compile", result['source'], build_update=True)
- for res in result['results']:
- self.debug("Command: %s" % ' '.join(res['command']))
- self.compile_output([
- res['code'],
- res['output'],
- res['command']
- ])
- objects.append(result['object'])
- except ToolException, err:
- p.terminate()
- p.join()
- raise ToolException(err)
- else:
- pending += 1
- if pending > jobs_count:
- break
-
-
- if len(results) == 0:
- break
-
- sleep(0.01)
-
- results = None
- p.terminate()
- p.join()
-
- return objects
-
- def compile_command(self, source, object, includes):
- # Check dependencies
- _, ext = splitext(source)
- ext = ext.lower()
-
- if ext == '.c' or ext == '.cpp':
- base, _ = splitext(object)
- dep_path = base + '.d'
- deps = self.parse_dependencies(dep_path) if (exists(dep_path)) else []
- if len(deps) == 0 or self.need_update(object, deps):
- if ext == '.c':
- return self.compile_c(source, object, includes)
- else:
- return self.compile_cpp(source, object, includes)
- elif ext == '.s':
- deps = [source]
- if self.need_update(object, deps):
- return self.assemble(source, object, includes)
- else:
- return False
-
- return None
-
- def is_not_supported_error(self, output):
- return "#error directive: [NOT_SUPPORTED]" in output
-
- def compile_output(self, output=[]):
- _rc = output[0]
- _stderr = output[1]
- command = output[2]
-
- # Parse output for Warnings and Errors
- self.parse_output(_stderr)
- self.debug("Return: %s"% _rc)
- for error_line in _stderr.splitlines():
- self.debug("Output: %s"% error_line)
-
-
- # Check return code
- if _rc != 0:
- for line in _stderr.splitlines():
- self.tool_error(line)
-
- if self.is_not_supported_error(_stderr):
- raise NotSupportedException(_stderr)
- else:
- raise ToolException(_stderr)
-
- def build_library(self, objects, dir, name):
- needed_update = False
- lib = self.STD_LIB_NAME % name
- fout = join(dir, lib)
- if self.need_update(fout, objects):
- self.info("Library: %s" % lib)
- self.archive(objects, fout)
- needed_update = True
-
- return needed_update
-
- def link_program(self, r, tmp_path, name):
- needed_update = False
- ext = 'bin'
- if hasattr(self.target, 'OUTPUT_EXT'):
- ext = self.target.OUTPUT_EXT
-
- if hasattr(self.target, 'OUTPUT_NAMING'):
- self.var("binary_naming", self.target.OUTPUT_NAMING)
- if self.target.OUTPUT_NAMING == "8.3":
- name = name[0:8]
- ext = ext[0:3]
-
- # Create destination directory
- head, tail = split(name)
- new_path = join(tmp_path, head)
- mkdir(new_path)
-
- filename = name+'.'+ext
- elf = join(tmp_path, name + '.elf')
- bin = join(tmp_path, filename)
- map = join(tmp_path, name + '.map')
-
- if self.need_update(elf, r.objects + r.libraries + [r.linker_script]):
- needed_update = True
- self.progress("link", name)
- self.link(elf, r.objects, r.libraries, r.lib_dirs, r.linker_script)
-
- if self.need_update(bin, [elf]):
- needed_update = True
- self.progress("elf2bin", name)
-
- self.binary(r, elf, bin)
-
- self.mem_stats(map)
-
- self.var("compile_succeded", True)
- self.var("binary", filename)
-
- return bin, needed_update
-
- def default_cmd(self, command):
- self.debug("Command: %s"% ' '.join(command))
- _stdout, _stderr, _rc = run_cmd(command)
-
- self.debug("Return: %s"% _rc)
-
- for output_line in _stdout.splitlines():
- self.debug("Output: %s"% output_line)
- for error_line in _stderr.splitlines():
- self.debug("Errors: %s"% error_line)
-
- if _rc != 0:
- for line in _stderr.splitlines():
- self.tool_error(line)
- raise ToolException(_stderr)
-
- ### NOTIFICATIONS ###
- def info(self, message):
- self.notify({'type': 'info', 'message': message})
-
- def debug(self, message):
- if self.VERBOSE:
- if type(message) is ListType:
- message = ' '.join(message)
- message = "[DEBUG] " + message
- self.notify({'type': 'debug', 'message': message})
-
- def cc_info(self, severity, file, line, message, target_name=None, toolchain_name=None):
- self.notify({'type': 'cc',
- 'severity': severity,
- 'file': file,
- 'line': line,
- 'message': message,
- 'target_name': target_name,
- 'toolchain_name': toolchain_name})
-
- def progress(self, action, file, build_update=False):
- msg = {'type': 'progress', 'action': action, 'file': file}
- if build_update:
- msg['percent'] = 100. * float(self.compiled) / float(self.to_be_compiled)
- self.notify(msg)
-
- def tool_error(self, message):
- self.notify({'type': 'tool_error', 'message': message})
-
- def var(self, key, value):
- self.notify({'type': 'var', 'key': key, 'val': value})
-
- def mem_stats(self, map):
- # Creates parser object
- toolchain = self.__class__.__name__
-
- # Create memap object
- memap = MemapParser()
-
- # Parse and decode a map file
- if memap.parse(abspath(map), toolchain) is False:
- self.info("Unknown toolchain for memory statistics %s" % toolchain)
- return
-
- # Write output to stdout in text (pretty table) format
- memap.generate_output('table')
-
- # Write output to file in JSON format
- map_out = splitext(map)[0] + "_map.json"
- memap.generate_output('json', map_out)
-
- # Write output to file in CSV format for the CI
- map_csv = splitext(map)[0] + "_map.csv"
- memap.generate_output('csv-ci', map_csv)
-
-
-from tools.settings import ARM_BIN
-from tools.settings import GCC_ARM_PATH, GCC_CR_PATH
-from tools.settings import IAR_PATH
-
-TOOLCHAIN_BIN_PATH = {
- 'ARM': ARM_BIN,
- 'uARM': ARM_BIN,
- 'GCC_ARM': GCC_ARM_PATH,
- 'GCC_CR': GCC_CR_PATH,
- 'IAR': IAR_PATH
-}
-
-from tools.toolchains.arm import ARM_STD, ARM_MICRO
-from tools.toolchains.gcc import GCC_ARM, GCC_CR
-from tools.toolchains.iar import IAR
-
-TOOLCHAIN_CLASSES = {
- 'ARM': ARM_STD,
- 'uARM': ARM_MICRO,
- 'GCC_ARM': GCC_ARM,
- 'GCC_CR': GCC_CR,
- 'IAR': IAR
-}
-
-TOOLCHAINS = set(TOOLCHAIN_CLASSES.keys())
diff --git a/tools/toolchains/arm.py b/tools/toolchains/arm.py
deleted file mode 100644
index 11b6564dfa..0000000000
--- a/tools/toolchains/arm.py
+++ /dev/null
@@ -1,269 +0,0 @@
-"""
-mbed SDK
-Copyright (c) 2011-2013 ARM Limited
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
- http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-"""
-import re
-from os.path import join, dirname, splitext, basename, exists
-
-from tools.toolchains import mbedToolchain
-from tools.settings import ARM_BIN, ARM_INC, ARM_LIB, MY_ARM_CLIB, ARM_CPPLIB, GOANNA_PATH
-from tools.hooks import hook_tool
-from tools.utils import mkdir
-import copy
-
-class ARM(mbedToolchain):
- LINKER_EXT = '.sct'
- LIBRARY_EXT = '.ar'
-
- STD_LIB_NAME = "%s.ar"
- DIAGNOSTIC_PATTERN = re.compile('"(?P[^"]+)", line (?P\d+)( \(column (?P\d+)\)|): (?PWarning|Error): (?P.+)')
- DEP_PATTERN = re.compile('\S+:\s(?P.+)\n')
-
-
- DEFAULT_FLAGS = {
- 'common': ["-c", "--gnu",
- "-Otime", "--split_sections", "--apcs=interwork",
- "--brief_diagnostics", "--restrict", "--multibyte_chars", "-I", "\""+ARM_INC+"\""],
- 'asm': [],
- 'c': ["--md", "--no_depend_system_headers", "--c99", "-D__ASSERT_MSG"],
- 'cxx': ["--cpp", "--no_rtti"],
- 'ld': [],
- }
-
- def __init__(self, target, options=None, notify=None, macros=None, silent=False, extra_verbose=False):
- mbedToolchain.__init__(self, target, options, notify, macros, silent, extra_verbose=extra_verbose)
-
- if target.core == "Cortex-M0+":
- cpu = "Cortex-M0"
- elif target.core == "Cortex-M4F":
- cpu = "Cortex-M4.fp"
- elif target.core == "Cortex-M7F":
- cpu = "Cortex-M7.fp.sp"
- else:
- cpu = target.core
-
- main_cc = join(ARM_BIN, "armcc")
-
- self.flags = copy.deepcopy(self.DEFAULT_FLAGS)
- self.flags['common'] += ["--cpu=%s" % cpu]
- if "save-asm" in self.options:
- self.flags['common'].extend(["--asm", "--interleave"])
-
- if "debug-info" in self.options:
- self.flags['common'].append("-g")
- self.flags['c'].append("-O0")
- else:
- self.flags['c'].append("-O3")
-
- self.asm = [main_cc] + self.flags['common'] + self.flags['asm']
- if not "analyze" in self.options:
- self.cc = [main_cc] + self.flags['common'] + self.flags['c']
- self.cppc = [main_cc] + self.flags['common'] + self.flags['c'] + self.flags['cxx']
- else:
- self.cc = [join(GOANNA_PATH, "goannacc"), "--with-cc=" + main_cc.replace('\\', '/'), "--dialect=armcc", '--output-format="%s"' % self.GOANNA_FORMAT] + self.flags['common'] + self.flags['c']
- self.cppc= [join(GOANNA_PATH, "goannac++"), "--with-cxx=" + main_cc.replace('\\', '/'), "--dialect=armcc", '--output-format="%s"' % self.GOANNA_FORMAT] + self.flags['common'] + self.flags['c'] + self.flags['cxx']
-
- self.ld = [join(ARM_BIN, "armlink")]
- self.sys_libs = []
-
- self.ar = join(ARM_BIN, "armar")
- self.elf2bin = join(ARM_BIN, "fromelf")
-
- def parse_dependencies(self, dep_path):
- dependencies = []
- for line in open(dep_path).readlines():
- match = ARM.DEP_PATTERN.match(line)
- if match is not None:
- dependencies.append(match.group('file'))
- return dependencies
-
- def parse_output(self, output):
- for line in output.splitlines():
- match = ARM.DIAGNOSTIC_PATTERN.match(line)
- if match is not None:
- self.cc_info(
- match.group('severity').lower(),
- match.group('file'),
- match.group('line'),
- match.group('message'),
- target_name=self.target.name,
- toolchain_name=self.name
- )
- match = self.goanna_parse_line(line)
- if match is not None:
- self.cc_info(
- match.group('severity').lower(),
- match.group('file'),
- match.group('line'),
- match.group('message')
- )
-
- def get_dep_option(self, object):
- base, _ = splitext(object)
- dep_path = base + '.d'
- return ["--depend", dep_path]
-
- def get_compile_options(self, defines, includes):
- return ['-D%s' % d for d in defines] + ['--via', self.get_inc_file(includes)]
-
- @hook_tool
- def assemble(self, source, object, includes):
- # Preprocess first, then assemble
- dir = join(dirname(object), '.temp')
- mkdir(dir)
- tempfile = join(dir, basename(object) + '.E.s')
-
- # Build preprocess assemble command
- cmd_pre = self.asm + self.get_compile_options(self.get_symbols(), includes) + ["-E", "-o", tempfile, source]
-
- # Build main assemble command
- cmd = self.asm + ["-o", object, tempfile]
-
- # Call cmdline hook
- cmd_pre = self.hook.get_cmdline_assembler(cmd_pre)
- cmd = self.hook.get_cmdline_assembler(cmd)
-
- # Return command array, don't execute
- return [cmd_pre, cmd]
-
- @hook_tool
- def compile(self, cc, source, object, includes):
- # Build compile command
- cmd = cc + self.get_compile_options(self.get_symbols(), includes)
-
- cmd.extend(self.get_dep_option(object))
-
- cmd.extend(["-o", object, source])
-
- # Call cmdline hook
- cmd = self.hook.get_cmdline_compiler(cmd)
-
- return [cmd]
-
- def compile_c(self, source, object, includes):
- return self.compile(self.cc, source, object, includes)
-
- def compile_cpp(self, source, object, includes):
- return self.compile(self.cppc, source, object, includes)
-
- @hook_tool
- def link(self, output, objects, libraries, lib_dirs, mem_map):
- map_file = splitext(output)[0] + ".map"
- if len(lib_dirs):
- args = ["-o", output, "--userlibpath", ",".join(lib_dirs), "--info=totals", "--map", "--list=%s" % map_file]
- else:
- args = ["-o", output, "--info=totals", "--map", "--list=%s" % map_file]
-
- if mem_map:
- args.extend(["--scatter", mem_map])
-
- # Build linker command
- cmd = self.ld + args + objects + libraries + self.sys_libs
-
- # Call cmdline hook
- cmd = self.hook.get_cmdline_linker(cmd)
-
- # Split link command to linker executable + response file
- link_files = join(dirname(output), ".link_files.txt")
- with open(link_files, "wb") as f:
- cmd_linker = cmd[0]
- cmd_list = []
- for c in cmd[1:]:
- if c:
- cmd_list.append(('"%s"' % c) if not c.startswith('-') else c)
- string = " ".join(cmd_list).replace("\\", "/")
- f.write(string)
-
- # Exec command
- self.default_cmd([cmd_linker, '--via', link_files])
-
- @hook_tool
- def archive(self, objects, lib_path):
- archive_files = join(dirname(lib_path), ".archive_files.txt")
- with open(archive_files, "wb") as f:
- o_list = []
- for o in objects:
- o_list.append('"%s"' % o)
- string = " ".join(o_list).replace("\\", "/")
- f.write(string)
-
- # Exec command
- self.default_cmd([self.ar, '-r', lib_path, '--via', archive_files])
-
- @hook_tool
- def binary(self, resources, elf, bin):
- # Build binary command
- cmd = [self.elf2bin, '--bin', '-o', bin, elf]
-
- # Call cmdline hook
- cmd = self.hook.get_cmdline_binary(cmd)
-
- # Exec command
- self.default_cmd(cmd)
-
-
-class ARM_STD(ARM):
- def __init__(self, target, options=None, notify=None, macros=None, silent=False, extra_verbose=False):
- ARM.__init__(self, target, options, notify, macros, silent, extra_verbose=extra_verbose)
-
- # Extend flags
- self.flags['ld'].extend(["--libpath", ARM_LIB])
-
- # Run-time values
- self.ld.extend(["--libpath", ARM_LIB])
-
-
-class ARM_MICRO(ARM):
- PATCHED_LIBRARY = False
-
- def __init__(self, target, options=None, notify=None, macros=None, silent=False, extra_verbose=False):
- ARM.__init__(self, target, options, notify, macros, silent, extra_verbose=extra_verbose)
-
- # Extend flags
- self.flags['common'].extend(["-D__MICROLIB"])
- self.flags['c'].extend(["--library_type=microlib"])
- self.flags['ld'].extend(["--library_type=microlib"])
-
- # Run-time values
- self.asm += ["-D__MICROLIB"]
- self.cc += ["-D__MICROLIB", "--library_type=microlib"]
- self.cppc += ["-D__MICROLIB", "--library_type=microlib"]
- self.ld += ["--library_type=microlib"]
-
- # Only allow a single thread
- self.cc += ["-DMBED_RTOS_SINGLE_THREAD"]
- self.cppc += ["-DMBED_RTOS_SINGLE_THREAD"]
-
- # We had to patch microlib to add C++ support
- # In later releases this patch should have entered mainline
- if ARM_MICRO.PATCHED_LIBRARY:
- # Run-time values
- self.flags['ld'].extend(["--noscanlib"])
- # Run-time values
- self.ld += ["--noscanlib"]
-
- # System Libraries
- self.sys_libs.extend([join(MY_ARM_CLIB, lib+".l") for lib in ["mc_p", "mf_p", "m_ps"]])
-
- if target.core == "Cortex-M3":
- self.sys_libs.extend([join(ARM_CPPLIB, lib+".l") for lib in ["cpp_ws", "cpprt_w"]])
-
- elif target.core in ["Cortex-M0", "Cortex-M0+"]:
- self.sys_libs.extend([join(ARM_CPPLIB, lib+".l") for lib in ["cpp_ps", "cpprt_p"]])
- else:
- # Run-time values
- self.flags['ld'].extend(["--libpath", ARM_LIB])
- # Run-time values
- self.ld.extend(["--libpath", ARM_LIB])
diff --git a/tools/toolchains/gcc.py b/tools/toolchains/gcc.py
deleted file mode 100644
index aa71e1360e..0000000000
--- a/tools/toolchains/gcc.py
+++ /dev/null
@@ -1,293 +0,0 @@
-"""
-mbed SDK
-Copyright (c) 2011-2013 ARM Limited
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
- http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-"""
-import re
-from os.path import join, basename, splitext, dirname, exists
-
-from tools.toolchains import mbedToolchain
-from tools.settings import GCC_ARM_PATH, GCC_CR_PATH
-from tools.settings import GOANNA_PATH
-from tools.hooks import hook_tool
-
-class GCC(mbedToolchain):
- LINKER_EXT = '.ld'
- LIBRARY_EXT = '.a'
-
- STD_LIB_NAME = "lib%s.a"
- DIAGNOSTIC_PATTERN = re.compile('((?P[^:]+):(?P\d+):)(\d+:)? (?Pwarning|error): (?P.+)')
-
- def __init__(self, target, options=None, notify=None, macros=None, silent=False, tool_path="", extra_verbose=False):
- mbedToolchain.__init__(self, target, options, notify, macros, silent, extra_verbose=extra_verbose)
-
- if target.core == "Cortex-M0+":
- cpu = "cortex-m0plus"
- elif target.core == "Cortex-M4F":
- cpu = "cortex-m4"
- elif target.core == "Cortex-M7F":
- cpu = "cortex-m7"
- else:
- cpu = target.core.lower()
-
- self.cpu = ["-mcpu=%s" % cpu]
- if target.core.startswith("Cortex"):
- self.cpu.append("-mthumb")
-
- if target.core == "Cortex-M4F":
- self.cpu.append("-mfpu=fpv4-sp-d16")
- self.cpu.append("-mfloat-abi=softfp")
- elif target.core == "Cortex-M7F":
- self.cpu.append("-mfpu=fpv5-d16")
- self.cpu.append("-mfloat-abi=softfp")
-
- if target.core == "Cortex-A9":
- self.cpu.append("-mthumb-interwork")
- self.cpu.append("-marm")
- self.cpu.append("-march=armv7-a")
- self.cpu.append("-mfpu=vfpv3")
- self.cpu.append("-mfloat-abi=hard")
- self.cpu.append("-mno-unaligned-access")
-
-
- # Note: We are using "-O2" instead of "-Os" to avoid this known GCC bug:
- # http://gcc.gnu.org/bugzilla/show_bug.cgi?id=46762
- common_flags = ["-c", "-Wall", "-Wextra",
- "-Wno-unused-parameter", "-Wno-missing-field-initializers",
- "-fmessage-length=0", "-fno-exceptions", "-fno-builtin",
- "-ffunction-sections", "-fdata-sections",
- "-fno-delete-null-pointer-checks", "-fomit-frame-pointer"
- ] + self.cpu
-
- if "save-asm" in self.options:
- common_flags.append("-save-temps")
-
- if "debug-info" in self.options:
- common_flags.append("-g")
- common_flags.append("-O0")
- else:
- common_flags.append("-O2")
-
- main_cc = join(tool_path, "arm-none-eabi-gcc")
- main_cppc = join(tool_path, "arm-none-eabi-g++")
- self.asm = [main_cc, "-x", "assembler-with-cpp"] + common_flags
- if not "analyze" in self.options:
- self.cc = [main_cc, "-std=gnu99"] + common_flags
- self.cppc =[main_cppc, "-std=gnu++98", "-fno-rtti"] + common_flags
- else:
- self.cc = [join(GOANNA_PATH, "goannacc"), "--with-cc=" + main_cc.replace('\\', '/'), "-std=gnu99", "--dialect=gnu", '--output-format="%s"' % self.GOANNA_FORMAT] + common_flags
- self.cppc= [join(GOANNA_PATH, "goannac++"), "--with-cxx=" + main_cppc.replace('\\', '/'), "-std=gnu++98", "-fno-rtti", "--dialect=gnu", '--output-format="%s"' % self.GOANNA_FORMAT] + common_flags
-
- self.ld = [join(tool_path, "arm-none-eabi-gcc"), "-Wl,--gc-sections", "-Wl,--wrap,main", "-Wl,--wrap,_malloc_r", "-Wl,--wrap,_free_r", "-Wl,--wrap,_realloc_r"] + self.cpu
- self.sys_libs = ["stdc++", "supc++", "m", "c", "gcc"]
-
- self.ar = join(tool_path, "arm-none-eabi-ar")
- self.elf2bin = join(tool_path, "arm-none-eabi-objcopy")
-
- def parse_dependencies(self, dep_path):
- dependencies = []
- buff = open(dep_path).readlines()
- buff[0] = re.sub('^(.*?)\: ', '', buff[0])
- for line in buff:
- file = line.replace('\\\n', '').strip()
- if file:
- # GCC might list more than one dependency on a single line, in this case
- # the dependencies are separated by a space. However, a space might also
- # indicate an actual space character in a dependency path, but in this case
- # the space character is prefixed by a backslash.
- # Temporary replace all '\ ' with a special char that is not used (\a in this
- # case) to keep them from being interpreted by 'split' (they will be converted
- # back later to a space char)
- file = file.replace('\\ ', '\a')
- if file.find(" ") == -1:
- dependencies.append(file.replace('\a', ' '))
- else:
- dependencies = dependencies + [f.replace('\a', ' ') for f in file.split(" ")]
- return dependencies
-
- def is_not_supported_error(self, output):
- return "error: #error [NOT_SUPPORTED]" in output
-
- def parse_output(self, output):
- # The warning/error notification is multiline
- WHERE, WHAT = 0, 1
- state, file, message = WHERE, None, None
- for line in output.splitlines():
- match = self.goanna_parse_line(line)
- if match is not None:
- self.cc_info(
- match.group('severity').lower(),
- match.group('file'),
- match.group('line'),
- match.group('message'),
- target_name=self.target.name,
- toolchain_name=self.name
- )
- continue
-
-
- match = GCC.DIAGNOSTIC_PATTERN.match(line)
- if match is not None:
- self.cc_info(
- match.group('severity').lower(),
- match.group('file'),
- match.group('line'),
- match.group('message'),
- target_name=self.target.name,
- toolchain_name=self.name
- )
-
- def get_dep_option(self, object):
- base, _ = splitext(object)
- dep_path = base + '.d'
- return ["-MD", "-MF", dep_path]
-
- def get_compile_options(self, defines, includes):
- return ['-D%s' % d for d in defines] + ['@%s' % self.get_inc_file(includes)]
-
- @hook_tool
- def assemble(self, source, object, includes):
- # Build assemble command
- cmd = self.asm + self.get_compile_options(self.get_symbols(), includes) + ["-o", object, source]
-
- # Call cmdline hook
- cmd = self.hook.get_cmdline_assembler(cmd)
-
- # Return command array, don't execute
- return [cmd]
-
- @hook_tool
- def compile(self, cc, source, object, includes):
- # Build compile command
- cmd = cc + self.get_compile_options(self.get_symbols(), includes)
-
- cmd.extend(self.get_dep_option(object))
-
- cmd.extend(["-o", object, source])
-
- # Call cmdline hook
- cmd = self.hook.get_cmdline_compiler(cmd)
-
- return [cmd]
-
- def compile_c(self, source, object, includes):
- return self.compile(self.cc, source, object, includes)
-
- def compile_cpp(self, source, object, includes):
- return self.compile(self.cppc, source, object, includes)
-
- @hook_tool
- def link(self, output, objects, libraries, lib_dirs, mem_map):
- libs = []
- for l in libraries:
- name, _ = splitext(basename(l))
- libs.append("-l%s" % name[3:])
- libs.extend(["-l%s" % l for l in self.sys_libs])
-
- # Build linker command
- map_file = splitext(output)[0] + ".map"
- cmd = self.ld + ["-o", output, "-Wl,-Map=%s" % map_file] + objects + ["-Wl,--start-group"] + libs + ["-Wl,--end-group"]
- if mem_map:
- cmd.extend(['-T', mem_map])
-
- for L in lib_dirs:
- cmd.extend(['-L', L])
- cmd.extend(libs)
-
- # Call cmdline hook
- cmd = self.hook.get_cmdline_linker(cmd)
-
- # Split link command to linker executable + response file
- link_files = join(dirname(output), ".link_files.txt")
- with open(link_files, "wb") as f:
- cmd_linker = cmd[0]
- cmd_list = []
- for c in cmd[1:]:
- if c:
- cmd_list.append(('"%s"' % c) if not c.startswith('-') else c)
- string = " ".join(cmd_list).replace("\\", "/")
- f.write(string)
-
- # Exec command
- self.default_cmd([cmd_linker, "@%s" % link_files])
-
- @hook_tool
- def archive(self, objects, lib_path):
- archive_files = join(dirname(lib_path), ".archive_files.txt")
- with open(archive_files, "wb") as f:
- o_list = []
- for o in objects:
- o_list.append('"%s"' % o)
- string = " ".join(o_list).replace("\\", "/")
- f.write(string)
-
- # Exec command
- self.default_cmd([self.ar, 'rcs', lib_path, "@%s" % archive_files])
-
- @hook_tool
- def binary(self, resources, elf, bin):
- # Build binary command
- cmd = [self.elf2bin, "-O", "binary", elf, bin]
-
- # Call cmdline hook
- cmd = self.hook.get_cmdline_binary(cmd)
-
- # Exec command
- self.default_cmd(cmd)
-
-
-class GCC_ARM(GCC):
- def __init__(self, target, options=None, notify=None, macros=None, silent=False, extra_verbose=False):
- GCC.__init__(self, target, options, notify, macros, silent, GCC_ARM_PATH, extra_verbose=extra_verbose)
-
- # Use latest gcc nanolib
- if "big-build" in self.options:
- use_nano = False
- elif "small-build" in self.options:
- use_nano = True
- elif target.default_build == "standard":
- use_nano = False
- elif target.default_build == "small":
- use_nano = True
- else:
- use_nano = False
-
- if use_nano:
- self.ld.append("--specs=nano.specs")
- self.cc += ["-DMBED_RTOS_SINGLE_THREAD"]
- self.cppc += ["-DMBED_RTOS_SINGLE_THREAD"]
-
- if target.name in ["LPC1768", "LPC4088", "LPC4088_DM", "LPC4330", "UBLOX_C027", "LPC2368"]:
- self.ld.extend(["-u _printf_float", "-u _scanf_float"])
- elif target.name in ["RZ_A1H", "VK_RZ_A1H", "ARCH_MAX", "DISCO_F407VG", "DISCO_F429ZI", "DISCO_F469NI", "NUCLEO_F401RE", "NUCLEO_F410RB", "NUCLEO_F411RE", "NUCLEO_F446RE", "ELMO_F411RE", "MTS_MDOT_F411RE", "MTS_DRAGONFLY_F411RE", "DISCO_F746NG"]:
- self.ld.extend(["-u_printf_float", "-u_scanf_float"])
-
- self.sys_libs.append("nosys")
-
-
-class GCC_CR(GCC):
- def __init__(self, target, options=None, notify=None, macros=None, silent=False, extra_verbose=False):
- GCC.__init__(self, target, options, notify, macros, silent, GCC_CR_PATH, extra_verbose=extra_verbose)
-
- additional_compiler_flags = [
- "-D__NEWLIB__", "-D__CODE_RED", "-D__USE_CMSIS", "-DCPP_USE_HEAP",
- ]
- self.cc += additional_compiler_flags
- self.cppc += additional_compiler_flags
-
- # Use latest gcc nanolib
- self.ld.append("--specs=nano.specs")
- if target.name in ["LPC1768", "LPC4088", "LPC4088_DM", "LPC4330", "UBLOX_C027", "LPC2368"]:
- self.ld.extend(["-u _printf_float", "-u _scanf_float"])
- self.ld += ["-nostdlib"]
diff --git a/tools/toolchains/iar.py b/tools/toolchains/iar.py
deleted file mode 100644
index c3aa4a098a..0000000000
--- a/tools/toolchains/iar.py
+++ /dev/null
@@ -1,198 +0,0 @@
-"""
-mbed SDK
-Copyright (c) 2011-2013 ARM Limited
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
- http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-"""
-import re
-from os import remove
-from os.path import join, exists, dirname, splitext, exists
-
-from tools.toolchains import mbedToolchain
-from tools.settings import IAR_PATH
-from tools.settings import GOANNA_PATH
-from tools.hooks import hook_tool
-
-class IAR(mbedToolchain):
- LIBRARY_EXT = '.a'
- LINKER_EXT = '.icf'
- STD_LIB_NAME = "%s.a"
-
- DIAGNOSTIC_PATTERN = re.compile('"(?P[^"]+)",(?P[\d]+)\s+(?PWarning|Error)(?P.+)')
-
- def __init__(self, target, options=None, notify=None, macros=None, silent=False, extra_verbose=False):
- mbedToolchain.__init__(self, target, options, notify, macros, silent, extra_verbose=extra_verbose)
- if target.core == "Cortex-M7F":
- cpuchoice = "Cortex-M7"
- else:
- cpuchoice = target.core
- c_flags = [
- "--cpu=%s" % cpuchoice, "--thumb",
- "--dlib_config", join(IAR_PATH, "inc", "c", "DLib_Config_Full.h"),
- "-e", # Enable IAR language extension
- "--no_wrap_diagnostics",
- # Pa050: No need to be notified about "non-native end of line sequence"
- # Pa084: Pointless integer comparison -> checks for the values of an enum, but we use values outside of the enum to notify errors (ie: NC).
- # Pa093: Implicit conversion from float to integer (ie: wait_ms(85.4) -> wait_ms(85))
- # Pa082: Operation involving two values from two registers (ie: (float)(*obj->MR)/(float)(LPC_PWM1->MR0))
- "--diag_suppress=Pa050,Pa084,Pa093,Pa082",
- ]
-
- if target.core == "Cortex-M7F":
- c_flags.append("--fpu=VFPv5_sp")
-
-
- if "debug-info" in self.options:
- c_flags.append("-r")
- c_flags.append("-On")
- else:
- c_flags.append("-Oh")
-
- IAR_BIN = join(IAR_PATH, "bin")
- main_cc = join(IAR_BIN, "iccarm")
-
- if target.core == "Cortex-M7F":
- self.asm = [join(IAR_BIN, "iasmarm")] + ["--cpu", cpuchoice] + ["--fpu", "VFPv5_sp"]
- else:
- self.asm = [join(IAR_BIN, "iasmarm")] + ["--cpu", cpuchoice]
- if not "analyze" in self.options:
- self.cc = [main_cc, "--vla"] + c_flags
- self.cppc = [main_cc, "--c++", "--no_rtti", "--no_exceptions"] + c_flags
- else:
- self.cc = [join(GOANNA_PATH, "goannacc"), '--with-cc="%s"' % main_cc.replace('\\', '/'), "--dialect=iar-arm", '--output-format="%s"' % self.GOANNA_FORMAT, "--vla"] + c_flags
- self.cppc = [join(GOANNA_PATH, "goannac++"), '--with-cxx="%s"' % main_cc.replace('\\', '/'), "--dialect=iar-arm", '--output-format="%s"' % self.GOANNA_FORMAT] + ["--c++", "--no_rtti", "--no_exceptions"] + c_flags
- self.ld = join(IAR_BIN, "ilinkarm")
- self.ar = join(IAR_BIN, "iarchive")
- self.elf2bin = join(IAR_BIN, "ielftool")
-
- def parse_dependencies(self, dep_path):
- return [path.strip() for path in open(dep_path).readlines()
- if (path and not path.isspace())]
-
- def parse_output(self, output):
- for line in output.splitlines():
- match = IAR.DIAGNOSTIC_PATTERN.match(line)
- if match is not None:
- self.cc_info(
- match.group('severity').lower(),
- match.group('file'),
- match.group('line'),
- match.group('message'),
- target_name=self.target.name,
- toolchain_name=self.name
- )
- match = self.goanna_parse_line(line)
- if match is not None:
- self.cc_info(
- match.group('severity').lower(),
- match.group('file'),
- match.group('line'),
- match.group('message')
- )
-
- def get_dep_option(self, object):
- base, _ = splitext(object)
- dep_path = base + '.d'
- return ["--dependencies", dep_path]
-
- def cc_extra(self, object):
- base, _ = splitext(object)
- return ["-l", base + '.s.txt']
-
- def get_compile_options(self, defines, includes):
- return ['-D%s' % d for d in defines] + ['-f', self.get_inc_file(includes)]
-
- @hook_tool
- def assemble(self, source, object, includes):
- # Build assemble command
- cmd = self.asm + self.get_compile_options(self.get_symbols(), includes) + ["-o", object, source]
-
- # Call cmdline hook
- cmd = self.hook.get_cmdline_assembler(cmd)
-
- # Return command array, don't execute
- return [cmd]
-
- @hook_tool
- def compile(self, cc, source, object, includes):
- # Build compile command
- cmd = cc + self.get_compile_options(self.get_symbols(), includes)
-
- cmd.extend(self.get_dep_option(object))
-
- cmd.extend(self.cc_extra(object))
-
- cmd.extend(["-o", object, source])
-
- # Call cmdline hook
- cmd = self.hook.get_cmdline_compiler(cmd)
-
- return [cmd]
-
- def compile_c(self, source, object, includes):
- return self.compile(self.cc, source, object, includes)
-
- def compile_cpp(self, source, object, includes):
- return self.compile(self.cppc, source, object, includes)
-
- @hook_tool
- def link(self, output, objects, libraries, lib_dirs, mem_map):
- # Build linker command
- map_file = splitext(output)[0] + ".map"
- cmd = [self.ld, "-o", output, "--skip_dynamic_initialization", "--map=%s" % map_file] + objects + libraries
-
- if mem_map:
- cmd.extend(["--config", mem_map])
-
- # Call cmdline hook
- cmd = self.hook.get_cmdline_linker(cmd)
-
- # Split link command to linker executable + response file
- link_files = join(dirname(output), ".link_files.txt")
- with open(link_files, "wb") as f:
- cmd_linker = cmd[0]
- cmd_list = []
- for c in cmd[1:]:
- if c:
- cmd_list.append(('"%s"' % c) if not c.startswith('-') else c)
- string = " ".join(cmd_list).replace("\\", "/")
- f.write(string)
-
- # Exec command
- self.default_cmd([cmd_linker, '-f', link_files])
-
- @hook_tool
- def archive(self, objects, lib_path):
- archive_files = join(dirname(lib_path), ".archive_files.txt")
- with open(archive_files, "wb") as f:
- o_list = []
- for o in objects:
- o_list.append('"%s"' % o)
- string = " ".join(o_list).replace("\\", "/")
- f.write(string)
-
- if exists(lib_path):
- remove(lib_path)
-
- self.default_cmd([self.ar, lib_path, '-f', archive_files])
-
- @hook_tool
- def binary(self, resources, elf, bin):
- # Build binary command
- cmd = [self.elf2bin, "--bin", elf, bin]
-
- # Call cmdline hook
- cmd = self.hook.get_cmdline_binary(cmd)
-
- # Exec command
- self.default_cmd(cmd)
diff --git a/tools/upload_results.py b/tools/upload_results.py
deleted file mode 100644
index f07efb11ac..0000000000
--- a/tools/upload_results.py
+++ /dev/null
@@ -1,373 +0,0 @@
-"""
-mbed SDK
-Copyright (c) 2011-2013 ARM Limited
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
- http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-"""
-import sys
-import argparse
-import xml.etree.ElementTree as ET
-import requests
-import urlparse
-
-def create_headers(args):
- return { 'X-Api-Key': args.api_key }
-
-def finish_command(command, response):
- print(command, response.status_code, response.reason)
- print(response.text)
-
- if response.status_code < 400:
- sys.exit(0)
- else:
- sys.exit(2)
-
-def create_build(args):
- build = {}
- build['buildType'] = args.build_type
- build['number'] = args.build_number
- build['source'] = args.build_source
- build['status'] = 'running'
-
- r = requests.post(urlparse.urljoin(args.url, "api/builds"), headers=create_headers(args), json=build)
-
- if r.status_code < 400:
- if args.property_file_format:
- print("MBED_BUILD_ID=" + r.text)
- else:
- print(r.text)
-
- sys.exit(0)
- else:
- sys.exit(2)
-
-def finish_build(args):
- data = {}
- data['status'] = 'completed'
-
- r = requests.put(urlparse.urljoin(args.url, "api/builds/" + args.build_id), headers=create_headers(args), json=data)
- finish_command('finish-build', r)
-
-def promote_build(args):
- data = {}
- data['buildType'] = 'Release'
-
- r = requests.put(urlparse.urljoin(args.url, "api/builds/" + args.build_id), headers=create_headers(args), json=data)
- finish_command('promote-build', r)
-
-def abort_build(args):
- data = {}
- data['status'] = 'aborted'
-
- r = requests.put(urlparse.urljoin(args.url, "api/builds/" + args.build_id), headers=create_headers(args), json=data)
- finish_command('abort-build', r)
-
-def add_project_runs(args):
- '''
- -------------------------------------
- Notes on 'project_run_data' structure:
- --------------------------------------
- 'projectRuns' - Tree structure used to keep track of what projects have
- been logged in different report files. The tree is organized as follows:
-
- 'projectRuns': { - Root element of tree
-
- 'hostOs': { - Host OS on which project was built/tested
- - ex. windows, linux, or mac
-
- 'platform': { - Platform for which project was built/tested
- (Corresponds to platform names in targets.py)
- - ex. K64F, LPC1768, NRF51822, etc.
-
- 'toolchain': { - Toolchain with which project was built/tested
- (Corresponds to TOOLCHAIN_CLASSES names in toolchains/__init__.py)
- - ex. ARM, uARM, GCC_ARM, etc.
-
- 'project': { - Project that was build/tested
- (Corresponds to test id in tests.py or library id in libraries.py)
- - For tests, ex. MBED_A1, MBED_11, DTCT_1 etc.
- - For libraries, ex. MBED, RTX, RTOS, etc.
-
- },
- ...
- },
- ...
- },
- ...
- }
- }
-
- 'platforms_set' - Set of all the platform names mentioned in the given report files
-
- 'toolchains_set' - Set of all the toolchain names mentioned in the given report files
-
- 'names_set' - Set of all the project names mentioned in the given report files
-
- 'hostOses_set' - Set of all the host names given (only given by the command line arguments)
- '''
-
- project_run_data = {}
- project_run_data['projectRuns'] = {}
- project_run_data['platforms_set'] = set()
- project_run_data['vendors_set'] = set()
- project_run_data['toolchains_set'] = set()
- project_run_data['names_set'] = set()
- project_run_data['hostOses_set'] = set()
- project_run_data['hostOses_set'].add(args.host_os)
-
- if args.build_report:
- add_report(project_run_data, args.build_report, True, args.build_id, args.host_os)
-
- if args.test_report:
- add_report(project_run_data, args.test_report, False, args.build_id, args.host_os)
-
- ts_data = format_project_run_data(project_run_data, args.limit)
- total_result = True
-
- total_parts = len(ts_data)
- print "Uploading project runs in %d parts" % total_parts
-
- for index, data in enumerate(ts_data):
- r = requests.post(urlparse.urljoin(args.url, "api/projectRuns"), headers=create_headers(args), json=data)
- print("add-project-runs part %d/%d" % (index + 1, total_parts), r.status_code, r.reason)
- print(r.text)
-
- if r.status_code >= 400:
- total_result = False
-
- if total_result:
- print "'add-project-runs' completed successfully"
- sys.exit(0)
- else:
- print "'add-project-runs' failed"
- sys.exit(2)
-
-def prep_ts_data():
- ts_data = {}
- ts_data['projectRuns'] = []
- ts_data['platforms'] = set()
- ts_data['vendors'] = set()
- ts_data['toolchains'] = set()
- ts_data['names'] = set()
- ts_data['hostOses'] = set()
- return ts_data
-
-def finish_ts_data(ts_data, project_run_data):
- ts_data['platforms'] = list(ts_data['platforms'])
- ts_data['vendors'] = list(ts_data['vendors'])
- ts_data['toolchains'] = list(ts_data['toolchains'])
- ts_data['names'] = list(ts_data['names'])
- ts_data['hostOses'] = list(ts_data['hostOses'])
-
- # Add all vendors to every projectRun submission
- # TODO Either add "vendor" to the "project_run_data"
- # or remove "vendor" entirely from the viewer
- ts_data['vendors'] = list(project_run_data['vendors_set'])
-
-def format_project_run_data(project_run_data, limit):
- all_ts_data = []
- current_limit_count = 0
-
- ts_data = prep_ts_data()
- ts_data['projectRuns'] = []
-
- for hostOs_name, hostOs in project_run_data['projectRuns'].iteritems():
- for platform_name, platform in hostOs.iteritems():
- for toolchain_name, toolchain in platform.iteritems():
- for project_name, project in toolchain.iteritems():
- if current_limit_count >= limit:
- finish_ts_data(ts_data, project_run_data)
- all_ts_data.append(ts_data)
- ts_data = prep_ts_data()
- current_limit_count = 0
-
- ts_data['projectRuns'].append(project)
- ts_data['platforms'].add(platform_name)
- ts_data['toolchains'].add(toolchain_name)
- ts_data['names'].add(project_name)
- ts_data['hostOses'].add(hostOs_name)
- current_limit_count += 1
-
- if current_limit_count > 0:
- finish_ts_data(ts_data, project_run_data)
- all_ts_data.append(ts_data)
-
- return all_ts_data
-
-def find_project_run(projectRuns, project):
- keys = ['hostOs', 'platform', 'toolchain', 'project']
-
- elem = projectRuns
-
- for key in keys:
- if not project[key] in elem:
- return None
-
- elem = elem[project[key]]
-
- return elem
-
-def add_project_run(projectRuns, project):
- keys = ['hostOs', 'platform', 'toolchain']
-
- elem = projectRuns
-
- for key in keys:
- if not project[key] in elem:
- elem[project[key]] = {}
-
- elem = elem[project[key]]
-
- elem[project['project']] = project
-
-def update_project_run_results(project_to_update, project, is_build):
- if is_build:
- project_to_update['buildPass'] = project['buildPass']
- project_to_update['buildResult'] = project['buildResult']
- project_to_update['buildOutput'] = project['buildOutput']
- else:
- project_to_update['testPass'] = project['testPass']
- project_to_update['testResult'] = project['testResult']
- project_to_update['testOutput'] = project['testOutput']
-
-def update_project_run(projectRuns, project, is_build):
- found_project = find_project_run(projectRuns, project)
- if found_project:
- update_project_run_results(found_project, project, is_build)
- else:
- add_project_run(projectRuns, project)
-
-def add_report(project_run_data, report_file, is_build, build_id, host_os):
- tree = None
-
- try:
- tree = ET.parse(report_file)
- except:
- print(sys.exc_info()[0])
- print('Invalid path to report: %s', report_file)
- sys.exit(1)
-
- test_suites = tree.getroot()
-
- for test_suite in test_suites:
- platform = ""
- toolchain = ""
- vendor = ""
- for properties in test_suite.findall('properties'):
- for property in properties.findall('property'):
- if property.attrib['name'] == 'target':
- platform = property.attrib['value']
- project_run_data['platforms_set'].add(platform)
- elif property.attrib['name'] == 'toolchain':
- toolchain = property.attrib['value']
- project_run_data['toolchains_set'].add(toolchain)
- elif property.attrib['name'] == 'vendor':
- vendor = property.attrib['value']
- project_run_data['vendors_set'].add(vendor)
-
- for test_case in test_suite.findall('testcase'):
- projectRun = {}
- projectRun['build'] = build_id
- projectRun['hostOs'] = host_os
- projectRun['platform'] = platform
- projectRun['toolchain'] = toolchain
- projectRun['project'] = test_case.attrib['classname'].split('.')[-1]
- projectRun['vendor'] = vendor
-
- project_run_data['names_set'].add(projectRun['project'])
-
- should_skip = False
- skips = test_case.findall('skipped')
-
- if skips:
- should_skip = skips[0].attrib['message'] == 'SKIP'
-
- if not should_skip:
- system_outs = test_case.findall('system-out')
-
- output = ""
- if system_outs:
- output = system_outs[0].text
-
- if is_build:
- projectRun['buildOutput'] = output
- else:
- projectRun['testOutput'] = output
-
- errors = test_case.findall('error')
- failures = test_case.findall('failure')
- projectRunPass = None
- result = None
-
- if errors:
- projectRunPass = False
- result = errors[0].attrib['message']
- elif failures:
- projectRunPass = False
- result = failures[0].attrib['message']
- elif skips:
- projectRunPass = True
- result = skips[0].attrib['message']
- else:
- projectRunPass = True
- result = 'OK'
-
- if is_build:
- projectRun['buildPass'] = projectRunPass
- projectRun['buildResult'] = result
- else:
- projectRun['testPass'] = projectRunPass
- projectRun['testResult'] = result
-
- update_project_run(project_run_data['projectRuns'], projectRun, is_build)
-
-def main(arguments):
- # Register and parse command line arguments
- parser = argparse.ArgumentParser()
- parser.add_argument('-u', '--url', required=True, help='url to ci site')
- parser.add_argument('-k', '--api-key', required=True, help='api-key for posting data')
-
- subparsers = parser.add_subparsers(help='subcommand help')
-
- create_build_parser = subparsers.add_parser('create-build', help='create a new build')
- create_build_parser.add_argument('-b', '--build-number', required=True, help='build number')
- create_build_parser.add_argument('-T', '--build-type', choices=['Nightly', 'Limited', 'Pull_Request', 'Release_Candidate'], required=True, help='type of build')
- create_build_parser.add_argument('-s', '--build-source', required=True, help='url to source of build')
- create_build_parser.add_argument('-p', '--property-file-format', action='store_true', help='print result in the property file format')
- create_build_parser.set_defaults(func=create_build)
-
- finish_build_parser = subparsers.add_parser('finish-build', help='finish a running build')
- finish_build_parser.add_argument('-b', '--build-id', required=True, help='build id')
- finish_build_parser.set_defaults(func=finish_build)
-
- finish_build_parser = subparsers.add_parser('promote-build', help='promote a build to a release')
- finish_build_parser.add_argument('-b', '--build-id', required=True, help='build id')
- finish_build_parser.set_defaults(func=promote_build)
-
- abort_build_parser = subparsers.add_parser('abort-build', help='abort a running build')
- abort_build_parser.add_argument('-b', '--build-id', required=True, help='build id')
- abort_build_parser.set_defaults(func=abort_build)
-
- add_project_runs_parser = subparsers.add_parser('add-project-runs', help='add project runs to a build')
- add_project_runs_parser.add_argument('-b', '--build-id', required=True, help='build id')
- add_project_runs_parser.add_argument('-r', '--build-report', required=False, help='path to junit xml build report')
- add_project_runs_parser.add_argument('-t', '--test-report', required=False, help='path to junit xml test report')
- add_project_runs_parser.add_argument('-o', '--host-os', required=True, help='host os on which test was run')
- add_project_runs_parser.add_argument('-l', '--limit', required=False, type=int, default=1000, help='Limit the number of project runs sent at a time to avoid HTTP errors (default is 1000)')
- add_project_runs_parser.set_defaults(func=add_project_runs)
-
- args = parser.parse_args(arguments)
- args.func(args)
-
-if __name__ == '__main__':
- main(sys.argv[1:])
diff --git a/tools/utils.py b/tools/utils.py
deleted file mode 100644
index 861366cf9e..0000000000
--- a/tools/utils.py
+++ /dev/null
@@ -1,197 +0,0 @@
-"""
-mbed SDK
-Copyright (c) 2011-2013 ARM Limited
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
- http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-"""
-import sys
-import inspect
-import os
-from os import listdir, remove, makedirs
-from shutil import copyfile
-from os.path import isdir, join, exists, split, relpath, splitext
-from subprocess import Popen, PIPE, STDOUT, call
-import json
-from collections import OrderedDict
-
-def cmd(l, check=True, verbose=False, shell=False, cwd=None):
- text = l if shell else ' '.join(l)
- if verbose:
- print text
- rc = call(l, shell=shell, cwd=cwd)
- if check and rc != 0:
- raise Exception('ERROR %d: "%s"' % (rc, text))
-
-
-def run_cmd(command, wd=None, redirect=False):
- assert is_cmd_valid(command[0])
- try:
- p = Popen(command, stdout=PIPE, stderr=STDOUT if redirect else PIPE, cwd=wd)
- _stdout, _stderr = p.communicate()
- except:
- print "[OS ERROR] Command: "+(' '.join(command))
- raise
- return _stdout, _stderr, p.returncode
-
-
-def run_cmd_ext(command):
- assert is_cmd_valid(command[0])
- p = Popen(command, stdout=PIPE, stderr=PIPE)
- _stdout, _stderr = p.communicate()
- return _stdout, _stderr, p.returncode
-
-
-def is_cmd_valid(cmd):
- caller = get_caller_name()
- abspath = find_cmd_abspath(cmd)
- if not abspath:
- error("%s: Command '%s' can't be found" % (caller, cmd))
- if not is_exec(abspath):
- error("%s: Command '%s' resolves to file '%s' which is not executable" % (caller, cmd, abspath))
- return True
-
-
-def is_exec(path):
- return os.access(path, os.X_OK) or os.access(path+'.exe', os.X_OK)
-
-
-def find_cmd_abspath(cmd):
- """ Returns the absolute path to a command.
- None is returned if no absolute path was found.
- """
- if exists(cmd) or exists(cmd + '.exe'):
- return os.path.abspath(cmd)
- if not 'PATH' in os.environ:
- raise Exception("Can't find command path for current platform ('%s')" % sys.platform)
- PATH=os.environ['PATH']
- for path in PATH.split(os.pathsep):
- abspath = '%s/%s' % (path, cmd)
- if exists(abspath) or exists(abspath + '.exe'):
- return abspath
-
-
-def mkdir(path):
- if not exists(path):
- makedirs(path)
-
-
-def copy_file(src, dst):
- """ Implement the behaviour of "shutil.copy(src, dst)" without copying the
- permissions (this was causing errors with directories mounted with samba)
- """
- if isdir(dst):
- _, file = split(src)
- dst = join(dst, file)
- copyfile(src, dst)
-
-
-def delete_dir_files(dir):
- if not exists(dir):
- return
-
- for f in listdir(dir):
- file = join(dir, f)
- if not isdir(file):
- remove(file)
-
-
-def get_caller_name(steps=2):
- """
- When called inside a function, it returns the name
- of the caller of that function.
- """
- return inspect.stack()[steps][3]
-
-
-def error(msg):
- print("ERROR: %s" % msg)
- sys.exit(1)
-
-
-def rel_path(path, base, dot=False):
- p = relpath(path, base)
- if dot and not p.startswith('.'):
- p = './' + p
- return p
-
-
-class ToolException(Exception):
- pass
-
-class NotSupportedException(Exception):
- pass
-
-def split_path(path):
- base, file = split(path)
- name, ext = splitext(file)
- return base, name, ext
-
-
-def args_error(parser, message):
- print "\n\n%s\n\n" % message
- parser.print_help()
- sys.exit()
-
-
-def construct_enum(**enums):
- """ Create your own pseudo-enums """
- return type('Enum', (), enums)
-
-
-def check_required_modules(required_modules, verbose=True):
- """ Function checks for Python modules which should be "importable" (installed)
- before test suite can be used.
- @return returns True if all modules are installed already
- """
- import imp
- not_installed_modules = []
- for module_name in required_modules:
- try:
- imp.find_module(module_name)
- except ImportError as e:
- # We also test against a rare case: module is an egg file
- try:
- __import__(module_name)
- except ImportError as e:
- not_installed_modules.append(module_name)
- if verbose:
- print "Error: %s" % e
-
- if verbose:
- if not_installed_modules:
- print "Warning: Module(s) %s not installed. Please install required module(s) before using this script."% (', '.join(not_installed_modules))
-
- if not_installed_modules:
- return False
- else:
- return True
-
-# Utility function: traverse a dictionary and change all the strings in the dictionary to
-# ASCII from Unicode. Useful when reading ASCII JSON data, because the JSON decoder always
-# returns Unicode string.
-# Based on http://stackoverflow.com/a/13105359
-def dict_to_ascii(input):
- if isinstance(input, dict):
- return OrderedDict([(dict_to_ascii(key), dict_to_ascii(value)) for key, value in input.iteritems()])
- elif isinstance(input, list):
- return [dict_to_ascii(element) for element in input]
- elif isinstance(input, unicode):
- return input.encode('ascii')
- else:
- return input
-
-# Read a JSON file and return its Python representation, transforming all the strings from Unicode
-# to ASCII. The order of keys in the JSON file is preserved.
-def json_file_to_dict(fname):
- with open(fname, "rt") as f:
- return dict_to_ascii(json.load(f, object_pairs_hook=OrderedDict))