Merge branch 'master' of github.com:mbedmicro/mbed

Author: Bogdan Marinescu

workspace_tools/host_tests/echo.py

@@ -29,7 +29,7 @@ def test(self):
         TEST="longer serial test"
         check = True
         for i in range(1, 100):
-            self.mbed.serial.write(TEST + "\n")
+            self.mbed.serial_write(TEST + "\n")
             l = self.mbed.serial.readline().strip()
             if not l: continue
 

workspace_tools/host_tests/host_test.py

@@ -28,8 +28,7 @@
 from sys import stdout
 
 class Mbed:
-    """
-    Base class for a host driven test
+    """ Base class for a host driven test
     """
     def __init__(self):
         parser = OptionParser()
@@ -63,8 +62,17 @@ def __init__(self):
                           dest="forced_reset_type",
                           help="Forces different type of reset")
 
+        parser.add_option("-R", "--reset-timeout",
+                          dest="forced_reset_timeout",
+                          metavar="NUMBER",
+                          type="int",
+                          help="When forcing a reset using option -r you can set up after reset timeout in seconds")
+
         (self.options, _) = parser.parse_args()
 
+        self.DEFAULT_RESET_TOUT = 2
+        self.DEFAULT_TOUT = 10
+
         if self.options.port is None:
             raise Exception("The serial port of the target mbed have to be provided as command line arguments")
 
@@ -73,10 +81,12 @@ def __init__(self):
         self.extra_port = self.options.extra
         self.extra_serial = None
         self.serial = None
-        self.timeout = 10 if self.options.timeout is None else self.options.timeout
-        print 'Mbed: "%s" "%s"' % (self.port, self.disk)
+        self.timeout = self.DEFAULT_TOUT if self.options.timeout is None else self.options.timeout
+        print 'Host test instrumentation on port: "%s" with serial: "%s"' % (self.port, self.disk)
 
     def init_serial(self, baud=9600, extra_baud=9600):
+        """ Initialize serial port. Function will return error is port can't be opened or initialized
+        """
         result = True
         try:
             self.serial = Serial(self.port, timeout=1)
@@ -91,8 +101,18 @@ def init_serial(self, baud=9600, extra_baud=9600):
             self.flush()
         return result
 
+    def serial_timeout(self, timeout):
+        """ Wraps self.mbed.serial object timeout property
+        """
+        result = None
+        if self.serial:
+            self.serial.timeout = timeout
+            result = True
+        return result
+
     def serial_read(self, count=1):
-        """ Wraps self.mbed.serial object read method """
+        """ Wraps self.mbed.serial object read method
+        """
         result = None
         if self.serial:
             try:
@@ -102,23 +122,24 @@ def serial_read(self, count=1):
         return result
 
     def serial_write(self, write_buffer):
-        """ Wraps self.mbed.serial object write method """
-        result = -1
+        """ Wraps self.mbed.serial object write method
+        """
+        result = None
         if self.serial:
             try:
                 result = self.serial.write(write_buffer)
             except:
-               result = -1
+               result = None
         return result
 
     def safe_sendBreak(self, serial):
         """ Wraps serial.sendBreak() to avoid serial::serialposix.py exception on Linux
-        Traceback (most recent call last):
-          File "make.py", line 189, in <module>
-            serial.sendBreak()
-          File "/usr/lib/python2.7/dist-packages/serial/serialposix.py", line 511, in sendBreak
-            termios.tcsendbreak(self.fd, int(duration/0.25))
-        error: (32, 'Broken pipe')
+            Traceback (most recent call last):
+              File "make.py", line 189, in <module>
+                serial.sendBreak()
+              File "/usr/lib/python2.7/dist-packages/serial/serialposix.py", line 511, in sendBreak
+                termios.tcsendbreak(self.fd, int(duration/0.25))
+            error: (32, 'Broken pipe')
         """
         result = True
         try:
@@ -132,24 +153,38 @@ def safe_sendBreak(self, serial):
                 result = False
         return result
 
-    def touch_file(self, path, name):
-        with os.open(path, 'a'):
+    def touch_file(self, path):
+        """ Touch file and set timestamp to items
+        """
+        with open(path, 'a'):
             os.utime(path, None)
 
+    def reset_timeout(self, timeout):
+        """ Timeout executed just after reset command is issued
+        """
+        for n in range(0, timeout):
+            sleep(1)
+
     def reset(self):
-        """ reboot.txt   - startup from standby state, reboots when in run mode.
+        """ Reset function. Supports 'standard' send break command via Mbed's CDC,
+            also handles other reset modes.
+            E.g. reset by touching file with specific file name:
+            reboot.txt   - startup from standby state, reboots when in run mode.
             shutdown.txt - shutdown from run mode
-            reset.txt    - reset fpga during run mode """
-        if self.options.forced_reset_type:
-            path = os.path.join([self.disk, self.options.forced_reset_type.lower()])
-            if self.options.forced_reset_type.endswith('.txt'):
-                self.touch_file(path)
+            reset.txt    - reset FPGA during run mode
+        """
+        if self.options.forced_reset_type and self.options.forced_reset_type.endswith('.txt'):
+            reset_file_path = os.path.join(self.disk, self.options.forced_reset_type.lower())
+            self.touch_file(reset_file_path)
         else:
             self.safe_sendBreak(self.serial)  # Instead of serial.sendBreak()
             # Give time to wait for the image loading
-        sleep(2)
+        reset_tout_s = self.options.forced_reset_timeout if self.options.forced_reset_timeout is not None else self.DEFAULT_RESET_TOUT
+        self.reset_timeout(reset_tout_s)
 
     def flush(self):
+        """ Flush serial ports
+        """
         self.serial.flushInput()
         self.serial.flushOutput()
         if self.extra_serial:
@@ -158,10 +193,15 @@ def flush(self):
 
 
 class Test:
+    """ Baseclass for host test's test runner
+    """
     def __init__(self):
         self.mbed = Mbed()
 
     def run(self):
+        """ Test runner for host test. This function will start executing
+            test and forward test result via serial port to test suite
+        """
         try:
             result = self.test()
             self.print_result("success" if result else "failure")
@@ -170,31 +210,40 @@ def run(self):
             self.print_result("error")
 
     def setup(self):
-        """ Setup and check if configuration for test is correct. E.g. if serial port can be opened """
+        """ Setup and check if configuration for test is correct. E.g. if serial port can be opened
+        """
         result = True
         if not self.mbed.serial:
             result = False
             self.print_result("ioerr_serial")
         return result
 
     def notify(self, message):
-        """ On screen notification function """
+        """ On screen notification function
+        """
         print message
         stdout.flush()
 
     def print_result(self, result):
-        """ Test result unified printing function """
+        """ Test result unified printing function
+        """
         self.notify("\n{%s}\n{end}" % result)
 
 
 class DefaultTest(Test):
+    """ Test class with serial port initialization
+    """
     def __init__(self):
         Test.__init__(self)
         serial_init_res = self.mbed.init_serial()
         self.mbed.reset()
 
 
 class Simple(DefaultTest):
+    """ Simple, basic host test's test runner waiting for serial port
+        output from MUT, no supervision over test running in MUT is executed.
+        Just waiting for result
+    """
     def run(self):
         try:
             while True:
@@ -207,5 +256,6 @@ def run(self):
         except KeyboardInterrupt, _:
             print "\n[CTRL+c] exit"
 
+
 if __name__ == '__main__':
     Simple().run()

workspace_tools/host_tests/rtc_auto.py

@@ -26,7 +26,9 @@ class RTCTest(DefaultTest):
 
     def run(self):
         test_result = True
-        c = self.mbed.serial.timeout = None
+        if self.mbed.serial_timeout(None) is None:
+            self.print_result("ioerr_serial")
+            return
         for i in range(0, 5):
             c = self.mbed.serial_read(38)   # 38 len("[1256729742] [2009-10-28 11:35:42 AM]\n"
             if c is None:

workspace_tools/host_tests/stdio_auto.py

@@ -31,7 +31,7 @@ def run(self):
         for i in range(1, 5):
             random_integer = random.randint(-10000, 10000)
             print "Generated number: " + str(random_integer)
-            self.mbed.serial.write(str(random_integer) + "\n")
+            self.mbed.serial_write(str(random_integer) + "\n")
             serial_stdio_msg = ""
 
             ip_msg_timeout = self.mbed.options.timeout

workspace_tools/host_tests/tcpecho_client_auto.py

@@ -33,7 +33,7 @@ def send_server_ip_port(self, ip_address, port_no):
         self.mbed.reset()
         print "Sending server IP Address to target..."
         connection_str = ip_address + ":" + str(port_no) + "\n"
-        self.mbed.serial.write(connection_str)
+        self.mbed.serial_write(connection_str)
 
 
 class TCPEchoClient_Handler(BaseRequestHandler):

workspace_tools/host_tests/udpecho_client_auto.py

@@ -32,7 +32,7 @@ def send_server_ip_port(self, ip_address, port_no):
         self.mbed.reset()
         print "Sending server IP Address to target..."
         connection_str = ip_address + ":" + str(port_no) + "\n"
-        self.mbed.serial.write(connection_str)
+        self.mbed.serial_write(connection_str)
 
 
 class UDPEchoClient_Handler(BaseRequestHandler):

workspace_tools/host_tests/wait_us_auto.py

@@ -23,7 +23,9 @@ class WaitusTest(DefaultTest):
     def run(self):
         test_result = True
         # First character to start test (to know after reset when test starts)
-        self.mbed.serial.timeout = None
+        if self.mbed.serial_timeout(None) is None:
+            self.print_result("ioerr_serial")
+            return
         c = self.mbed.serial_read(1)
         if c is None:
             self.print_result("ioerr_serial")

workspace_tools/singletest.py

@@ -91,7 +91,8 @@
 
 
 def get_version():
-    """ Returns test script version """
+    """ Returns test script version
+    """
     single_test_version_major = 1
     single_test_version_minor = 1
     return (single_test_version_major, single_test_version_minor)
@@ -168,6 +169,7 @@ def get_version():
     single_test = SingleTestRunner(_global_loops_count=opts.test_global_loops_value,
                                    _test_loops_list=opts.test_loops_list,
                                    _muts=MUTs,
+                                   _opts_log_file_name=opts.log_file_name,
                                    _test_spec=test_spec,
                                    _opts_goanna_for_mbed_sdk=opts.goanna_for_mbed_sdk,
                                    _opts_goanna_for_tests=opts.goanna_for_tests,
@@ -184,8 +186,9 @@ def get_version():
                                    _opts_suppress_summary=opts.suppress_summary,
                                    _opts_test_x_toolchain_summary=opts.test_x_toolchain_summary,
                                    _opts_copy_method=opts.copy_method,
-                                   _opts_mut_reset_type=opts.mut_reset_type
-                                   )
+                                   _opts_mut_reset_type=opts.mut_reset_type,
+                                   _opts_jobs=opts.jobs,
+                                   _opts_extend_test_timeout=opts.extend_test_timeout)
 
     # Runs test suite in CLI mode
     singletest_in_cli_mode(single_test)