Release Mbed Crypto 0.1.0a
diff --git a/tests/scripts/mbedtls_test.py b/tests/scripts/mbedtls_test.py
new file mode 100755
index 0000000..cdd7524
--- /dev/null
+++ b/tests/scripts/mbedtls_test.py
@@ -0,0 +1,342 @@
+# Greentea host test script for on-target tests.
+#
+# Copyright (C) 2018, ARM Limited, All Rights Reserved
+# SPDX-License-Identifier: Apache-2.0
+#
+# 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.
+#
+# This file is part of Mbed Crypto (https://tls.mbed.org)
+
+
+"""
+Greentea host test script for on-target tests.
+
+Host test script for testing Mbed Crypto test suites on target. Implements
+BaseHostTest to handle key,value pairs (events) coming from Mbed Crypto
+tests. Reads data file corresponding to the executing binary and dispatches
+test cases.
+"""
+
+
+import re
+import os
+import binascii
+from mbed_host_tests import BaseHostTest, event_callback
+
+
+class TestDataParser(object):
+ """
+ parser for mbedcrypto test data files.
+ """
+
+ def __init__(self):
+ """
+ Constructor
+ """
+ self.tests = []
+
+ def parse(self, data_file):
+ """
+ Data file parser.
+
+ :param data_file: Data file path
+ """
+ with open(data_file, 'r') as f:
+ self.__parse(f)
+
+ @staticmethod
+ def __escaped_split(str, ch):
+ """
+ Splits str on ch except when escaped.
+
+ :param str: String to split
+ :param ch: Split character
+ :return: List of splits
+ """
+ if len(ch) > 1:
+ raise ValueError('Expected split character. Found string!')
+ out = []
+ part = ''
+ escape = False
+ for i in range(len(str)):
+ if not escape and str[i] == ch:
+ out.append(part)
+ part = ''
+ else:
+ part += str[i]
+ escape = not escape and str[i] == '\\'
+ if len(part):
+ out.append(part)
+ return out
+
+ def __parse(self, file):
+ """
+ Parses data file using supplied file object.
+
+ :param file: Data file object
+ :return:
+ """
+ for line in file:
+ line = line.strip()
+ if len(line) == 0:
+ continue
+ # Read test name
+ name = line
+
+ # Check dependencies
+ deps = []
+ line = file.next().strip()
+ m = re.search('depends_on\:(.*)', line)
+ if m:
+ deps = [int(x) for x in m.group(1).split(':')]
+ line = file.next().strip()
+
+ # Read test vectors
+ line = line.replace('\\n', '\n')
+ parts = self.__escaped_split(line, ':')
+ function = int(parts[0])
+ x = parts[1:]
+ l = len(x)
+ assert l % 2 == 0, "Number of test arguments should be even: %s" % line
+ args = [(x[i * 2], x[(i * 2) + 1]) for i in range(len(x)/2)]
+ self.tests.append((name, function, deps, args))
+
+ def get_test_data(self):
+ """
+ Returns test data.
+ """
+ return self.tests
+
+
+class MbedCryptoTest(BaseHostTest):
+ """
+ Event handler for mbedcrypto unit tests. This script is loaded at run time
+ by htrun while executing mbedcrypto unit tests.
+ """
+ # From suites/helpers.function
+ DEPENDENCY_SUPPORTED = 0
+ KEY_VALUE_MAPPING_FOUND = DEPENDENCY_SUPPORTED
+ DISPATCH_TEST_SUCCESS = DEPENDENCY_SUPPORTED
+
+ KEY_VALUE_MAPPING_NOT_FOUND = -1
+ DEPENDENCY_NOT_SUPPORTED = -2
+ DISPATCH_TEST_FN_NOT_FOUND = -3
+ DISPATCH_INVALID_TEST_DATA = -4
+ DISPATCH_UNSUPPORTED_SUITE = -5
+
+ def __init__(self):
+ """
+ Constructor initialises test index to 0.
+ """
+ super(MbedCryptoTest, self).__init__()
+ self.tests = []
+ self.test_index = -1
+ self.dep_index = 0
+ self.error_str = dict()
+ self.error_str[self.DEPENDENCY_SUPPORTED] = 'DEPENDENCY_SUPPORTED'
+ self.error_str[self.KEY_VALUE_MAPPING_NOT_FOUND] = 'KEY_VALUE_MAPPING_NOT_FOUND'
+ self.error_str[self.DEPENDENCY_NOT_SUPPORTED] = 'DEPENDENCY_NOT_SUPPORTED'
+ self.error_str[self.DISPATCH_TEST_FN_NOT_FOUND] = 'DISPATCH_TEST_FN_NOT_FOUND'
+ self.error_str[self.DISPATCH_INVALID_TEST_DATA] = 'DISPATCH_INVALID_TEST_DATA'
+ self.error_str[self.DISPATCH_UNSUPPORTED_SUITE] = 'DISPATCH_UNSUPPORTED_SUITE'
+
+ def setup(self):
+ """
+ Setup hook implementation. Reads test suite data file and parses out tests.
+ """
+ binary_path = self.get_config_item('image_path')
+ script_dir = os.path.split(os.path.abspath(__file__))[0]
+ suite_name = os.path.splitext(os.path.basename(binary_path))[0]
+ data_file = ".".join((suite_name, 'data'))
+ data_file = os.path.join(script_dir, '..', 'mbedcrypto', suite_name, data_file)
+ if os.path.exists(data_file):
+ self.log("Running tests from %s" % data_file)
+ parser = TestDataParser()
+ parser.parse(data_file)
+ self.tests = parser.get_test_data()
+ self.print_test_info()
+ else:
+ self.log("Data file not found: %s" % data_file)
+ self.notify_complete(False)
+
+ def print_test_info(self):
+ """
+ Prints test summary read by Greentea to detect test cases.
+ """
+ self.log('{{__testcase_count;%d}}' % len(self.tests))
+ for name, _, _, _ in self.tests:
+ self.log('{{__testcase_name;%s}}' % name)
+
+ @staticmethod
+ def align_32bit(b):
+ """
+ 4 byte aligns input byte array.
+
+ :return:
+ """
+ b += bytearray((4 - (len(b))) % 4)
+
+ @staticmethod
+ def hex_str_bytes(hex_str):
+ """
+ Converts Hex string representation to byte array
+
+ :param hex_str: Hex in string format.
+ :return: Output Byte array
+ """
+ assert hex_str[0] == '"' and hex_str[len(hex_str) - 1] == '"', \
+ "HEX test parameter missing '\"': %s" % hex_str
+ hex_str = hex_str.strip('"')
+ assert len(hex_str) % 2 == 0, "HEX parameter len should be mod of 2: %s" % hex_str
+
+ b = binascii.unhexlify(hex_str)
+ return b
+
+ @staticmethod
+ def int32_to_bigendian_bytes(i):
+ """
+ Coverts i to bytearray in big endian format.
+
+ :param i: Input integer
+ :return: Output bytes array in big endian or network order
+ """
+ b = bytearray([((i >> x) & 0xff) for x in [24, 16, 8, 0]])
+ return b
+
+ def test_vector_to_bytes(self, function_id, deps, parameters):
+ """
+ Converts test vector into a byte array that can be sent to the target.
+
+ :param function_id: Test Function Identifier
+ :param deps: Dependency list
+ :param parameters: Test function input parameters
+ :return: Byte array and its length
+ """
+ b = bytearray([len(deps)])
+ if len(deps):
+ b += bytearray(deps)
+ b += bytearray([function_id, len(parameters)])
+ for typ, param in parameters:
+ if typ == 'int' or typ == 'exp':
+ i = int(param)
+ b += 'I' if typ == 'int' else 'E'
+ self.align_32bit(b)
+ b += self.int32_to_bigendian_bytes(i)
+ elif typ == 'char*':
+ param = param.strip('"')
+ i = len(param) + 1 # + 1 for null termination
+ b += 'S'
+ self.align_32bit(b)
+ b += self.int32_to_bigendian_bytes(i)
+ b += bytearray(list(param))
+ b += '\0' # Null terminate
+ elif typ == 'hex':
+ hb = self.hex_str_bytes(param)
+ b += 'H'
+ self.align_32bit(b)
+ i = len(hb)
+ b += self.int32_to_bigendian_bytes(i)
+ b += hb
+ length = self.int32_to_bigendian_bytes(len(b))
+ return b, length
+
+ def run_next_test(self):
+ """
+ Send next test function to the target.
+
+ """
+ self.test_index += 1
+ self.dep_index = 0
+ if self.test_index < len(self.tests):
+ name, function_id, deps, args = self.tests[self.test_index]
+ self.run_test(name, function_id, deps, args)
+ else:
+ self.notify_complete(True)
+
+ def run_test(self, name, function_id, deps, args):
+ """
+ Runs the test.
+
+ :param name: Test name
+ :param function_id: function identifier
+ :param deps: Dependencies list
+ :param args: test parameters
+ :return:
+ """
+ self.log("Running: %s" % name)
+
+ bytes, length = self.test_vector_to_bytes(function_id, deps, args)
+ self.send_kv(length, bytes)
+
+ @staticmethod
+ def get_result(value):
+ """
+ Converts result from string type to integer
+ :param value: Result code in string
+ :return: Integer result code
+ """
+ try:
+ return int(value)
+ except ValueError:
+ ValueError("Result should return error number. Instead received %s" % value)
+ return 0
+
+ @event_callback('GO')
+ def on_go(self, key, value, timestamp):
+ """
+ Called on key "GO". Kicks off test execution.
+
+ :param key: Event key
+ :param value: Value. ignored
+ :param timestamp: Timestamp ignored.
+ :return:
+ """
+ self.run_next_test()
+
+ @event_callback("R")
+ def on_result(self, key, value, timestamp):
+ """
+ Handle result. Prints test start, finish prints required by Greentea to detect test execution.
+
+ :param key: Event key
+ :param value: Value. ignored
+ :param timestamp: Timestamp ignored.
+ :return:
+ """
+ int_val = self.get_result(value)
+ name, function, deps, args = self.tests[self.test_index]
+ self.log('{{__testcase_start;%s}}' % name)
+ self.log('{{__testcase_finish;%s;%d;%d}}' % (name, int_val == 0,
+ int_val != 0))
+ self.run_next_test()
+
+ @event_callback("F")
+ def on_failure(self, key, value, timestamp):
+ """
+ Handles test execution failure. That means dependency not supported or
+ Test function not supported. Hence marking test as skipped.
+
+ :param key: Event key
+ :param value: Value. ignored
+ :param timestamp: Timestamp ignored.
+ :return:
+ """
+ int_val = self.get_result(value)
+ name, function, deps, args = self.tests[self.test_index]
+ if int_val in self.error_str:
+ err = self.error_str[int_val]
+ else:
+ err = 'Unknown error'
+ # For skip status, do not write {{__testcase_finish;...}}
+ self.log("Error: %s" % err)
+ self.run_next_test()