Release candidate for mbed-os-5.9.4

TESTS/mbed_hal/common_tickers/main.cpp

@@ -29,8 +29,10 @@
 #define TICKER_INT_VAL 500
 #define TICKER_DELTA 10
 
-#define LP_TICKER_OVERFLOW_DELTA 0 // this will allow to detect that ticker counter rollovers to 0
-#define US_TICKER_OVERFLOW_DELTA 50
+#define LP_TICKER_OVERFLOW_DELTA1   0   // this will allow to detect that ticker counter rollovers to 0
+#define LP_TICKER_OVERFLOW_DELTA2   0
+#define US_TICKER_OVERFLOW_DELTA1   50
+#define US_TICKER_OVERFLOW_DELTA2   60
 
 #define TICKER_100_TICKS 100
 
@@ -48,7 +50,18 @@ using namespace utest::v1;
 volatile int intFlag = 0;
 const ticker_interface_t* intf;
 ticker_irq_handler_type prev_irq_handler;
-unsigned int ticker_overflow_delta;
+/* Some targets might fail overflow test uncertainly due to getting trapped in busy
+ * intf->read() loop. In the loop, some ticker values wouldn't get caught in time
+ * because of:
+ * 1. Lower CPU clock
+ * 2. Compiled code with worse performance
+ * 3. Interrupt at that time
+ * 
+ * We fix it by checking small ticker value range rather than one exact ticker point
+ * in near overflow check.
+ */
+unsigned int ticker_overflow_delta1;
+unsigned int ticker_overflow_delta2;
 
 /* Auxiliary function to count ticker ticks elapsed during execution of N cycles of empty while loop.
  * Parameter <step> is used to disable compiler optimisation. */
@@ -293,12 +306,13 @@ void ticker_overflow_test(void)
     intFlag = 0;
 
     /* Wait for max count. */
-    while (intf->read() != (max_count - ticker_overflow_delta)) {
+    while (intf->read() >= (max_count - ticker_overflow_delta2) &&
+        intf->read() <= (max_count - ticker_overflow_delta1)) {
         /* Just wait. */
     }
 
     /* Now we are near/at the overflow point. Detect rollover. */
-    while (intf->read() > ticker_overflow_delta);
+    while (intf->read() > ticker_overflow_delta1);
 
     const uint32_t after_overflow = intf->read();
 
@@ -310,7 +324,7 @@ void ticker_overflow_test(void)
     const uint32_t next_after_overflow = intf->read();
 
     /* Check that after the overflow ticker continue count. */
-    TEST_ASSERT(after_overflow <= ticker_overflow_delta);
+    TEST_ASSERT(after_overflow <= ticker_overflow_delta1);
     TEST_ASSERT(next_after_overflow >= TICKER_100_TICKS);
     TEST_ASSERT_EQUAL(0, intFlag);
 
@@ -465,7 +479,8 @@ utest::v1::status_t us_ticker_setup(const Case *const source, const size_t index
 
     prev_irq_handler = set_us_ticker_irq_handler(ticker_event_handler_stub);
 
-    ticker_overflow_delta = US_TICKER_OVERFLOW_DELTA;
+    ticker_overflow_delta1 = US_TICKER_OVERFLOW_DELTA1;
+    ticker_overflow_delta2 = US_TICKER_OVERFLOW_DELTA2;
 
     return greentea_case_setup_handler(source, index_of_case);
 }
@@ -493,7 +508,8 @@ utest::v1::status_t lp_ticker_setup(const Case *const source, const size_t index
 
     prev_irq_handler = set_lp_ticker_irq_handler(ticker_event_handler_stub);
 
-    ticker_overflow_delta = LP_TICKER_OVERFLOW_DELTA;
+    ticker_overflow_delta1 = LP_TICKER_OVERFLOW_DELTA1;
+    ticker_overflow_delta2 = LP_TICKER_OVERFLOW_DELTA2;
 
     return greentea_case_setup_handler(source, index_of_case);
 }

TESTS/mbedmicro-rtos-mbed/basic/main.cpp

@@ -29,7 +29,11 @@
 
 using utest::v1::Case;
 
+#if defined(__CORTEX_M23) || defined(__CORTEX_M33)
+#define TEST_STACK_SIZE 512
+#else
 #define TEST_STACK_SIZE 256
+#endif
 #define ONE_MILLI_SEC 1000
 
 volatile uint32_t elapsed_time_ms = 0;

TESTS/mbedmicro-rtos-mbed/event_flags/main.cpp

@@ -30,7 +30,11 @@ using utest::v1::Case;
   #error [NOT_SUPPORTED] test not supported
 #endif
 
+#if defined(__CORTEX_M23) || defined(__CORTEX_M33)
+#define THREAD_STACK_SIZE   512
+#else
 #define THREAD_STACK_SIZE   320 /* 512B stack on GCC_ARM compiler cause out of memory on some 16kB RAM boards e.g. NUCLEO_F070RB */
+#endif
 
 #define MAX_FLAG_POS 30
 #define PROHIBITED_FLAG_POS 31

TESTS/mbedmicro-rtos-mbed/mail/main.cpp

@@ -29,7 +29,11 @@
 
 using namespace utest::v1;
 
+#if defined(__CORTEX_M23) || defined(__CORTEX_M33)
+#define THREAD_STACK_SIZE   512
+#else
 #define THREAD_STACK_SIZE   320 /* larger stack cause out of heap memory on some 16kB RAM boards in multi thread test*/
+#endif
 #define QUEUE_SIZE          16
 #define THREAD_1_ID         1
 #define THREAD_2_ID         2

TESTS/mbedmicro-rtos-mbed/malloc/main.cpp

@@ -37,6 +37,8 @@ volatile bool thread_should_continue = true;
 
 #if defined(__CORTEX_A9)
 #define THREAD_STACK_SIZE   512
+#elif defined(__CORTEX_M23) || defined(__CORTEX_M33)
+#define THREAD_STACK_SIZE   512
 #else
 #define THREAD_STACK_SIZE   256
 #endif

TESTS/mbedmicro-rtos-mbed/mutex/main.cpp

@@ -29,7 +29,11 @@
 
 using namespace utest::v1;
 
+#if defined(__CORTEX_M23) || defined(__CORTEX_M33)
+#define TEST_STACK_SIZE 768
+#else
 #define TEST_STACK_SIZE 512
+#endif
 
 #define TEST_LONG_DELAY 20
 #define TEST_DELAY 10

TESTS/mbedmicro-rtos-mbed/systimer/main.cpp

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#if !MBED_TICKLESS
+#ifndef MBED_TICKLESS
 #error [NOT_SUPPORTED] Tickless mode not supported for this target.
 #endif
 

TESTS/mbedmicro-rtos-mbed/threads/main.cpp

@@ -32,6 +32,8 @@
 #define THREAD_STACK_SIZE 512
 #if defined(__CORTEX_A9)
 #define PARALLEL_THREAD_STACK_SIZE 512
+#elif defined(__CORTEX_M23) || defined(__CORTEX_M33)
+#define PARALLEL_THREAD_STACK_SIZE 512
 #else
 #define PARALLEL_THREAD_STACK_SIZE 384
 #endif

TESTS/netsocket/tcp/main.cpp

@@ -32,6 +32,7 @@ using namespace utest::v1;
 namespace
 {
     NetworkInterface* net;
+    Timer tc_bucket; // Timer to limit a test cases run time
 }
 
 char tcp_global::rx_buffer[RX_BUFF_SIZE];
@@ -66,24 +67,32 @@ static void _ifdown() {
     printf("MBED: ifdown\n");
 }
 
-void tcpsocket_connect_to_echo_srv(TCPSocket& sock) {
+nsapi_error_t tcpsocket_connect_to_echo_srv(TCPSocket& sock) {
     SocketAddress tcp_addr;
 
     get_interface()->gethostbyname(MBED_CONF_APP_ECHO_SERVER_ADDR, &tcp_addr);
     tcp_addr.set_port(MBED_CONF_APP_ECHO_SERVER_PORT);
 
-    TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, sock.open(get_interface()));
-    TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, sock.connect(tcp_addr));
+    nsapi_error_t err = sock.open(get_interface());
+    if (err != NSAPI_ERROR_OK) {
+        return err;
+    }
+
+    return sock.connect(tcp_addr);
 }
 
-void tcpsocket_connect_to_discard_srv(TCPSocket& sock) {
+nsapi_error_t tcpsocket_connect_to_discard_srv(TCPSocket& sock) {
     SocketAddress tcp_addr;
 
     get_interface()->gethostbyname(MBED_CONF_APP_ECHO_SERVER_ADDR, &tcp_addr);
     tcp_addr.set_port(9);
 
-    TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, sock.open(get_interface()));
-    TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, sock.connect(tcp_addr));
+    nsapi_error_t err = sock.open(get_interface());
+    if (err != NSAPI_ERROR_OK) {
+        return err;
+    }
+
+    return sock.connect(tcp_addr);
 }
 
 void fill_tx_buffer_ascii(char *buff, size_t len)
@@ -93,16 +102,23 @@ void fill_tx_buffer_ascii(char *buff, size_t len)
     }
 }
 
+int split2half_rmng_tcp_test_time()
+{
+    return (tcp_global::TESTS_TIMEOUT-tc_bucket.read())/2;
+}
+
 // Test setup
 utest::v1::status_t greentea_setup(const size_t number_of_cases)
 {
-    GREENTEA_SETUP(480, "default_auto");
+    GREENTEA_SETUP(tcp_global::TESTS_TIMEOUT, "default_auto");
     _ifup();
+    tc_bucket.start();
     return greentea_test_setup_handler(number_of_cases);
 }
 
 void greentea_teardown(const size_t passed, const size_t failed, const failure_t failure)
 {
+    tc_bucket.stop();
     _ifdown();
     return greentea_test_teardown_handler(passed, failed, failure);
 }

TESTS/netsocket/tcp/tcp_tests.h

@@ -21,11 +21,17 @@
 NetworkInterface* get_interface();
 void drop_bad_packets(TCPSocket& sock, int orig_timeout);
 void fill_tx_buffer_ascii(char *buff, size_t len);
-void tcpsocket_connect_to_echo_srv(TCPSocket& sock);
-void tcpsocket_connect_to_discard_srv(TCPSocket& sock);
+nsapi_error_t tcpsocket_connect_to_echo_srv(TCPSocket& sock);
+nsapi_error_t tcpsocket_connect_to_discard_srv(TCPSocket& sock);
+
+/**
+ * Single testcase might take only half of the remaining execution time
+ */
+int split2half_rmng_tcp_test_time(); // [s]
 
 namespace tcp_global
 {
+static const int TESTS_TIMEOUT = 480;
 static const int TCP_OS_STACK_SIZE = 1024;
 
 static const int RX_BUFF_SIZE = 1220;

TESTS/netsocket/tcp/tcpsocket_echotest.cpp

@@ -37,6 +37,9 @@ namespace
                                         1100,1200};
     TCPSocket sock;
     Semaphore tx_sem(0, 1);
+
+    Timer tc_exec_time;
+    int time_allotted;
 }
 
 static void _sigio_handler(osThreadId id) {
@@ -45,7 +48,10 @@ static void _sigio_handler(osThreadId id) {
 
 void TCPSOCKET_ECHOTEST()
 {
-    tcpsocket_connect_to_echo_srv(sock);
+    if (tcpsocket_connect_to_echo_srv(sock) != NSAPI_ERROR_OK) {
+        TEST_FAIL();
+        return;
+    }
 
     int recvd;
     int sent;
@@ -57,6 +63,8 @@ void TCPSOCKET_ECHOTEST()
         if (sent < 0) {
             printf("[Round#%02d] network error %d\n", x, sent);
             TEST_FAIL();
+            TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, sock.close());
+            return;
         }
 
         int bytes2recv = sent;
@@ -65,6 +73,8 @@ void TCPSOCKET_ECHOTEST()
                 if (recvd < 0) {
                 printf("[Round#%02d] network error %d\n", x, recvd);
                 TEST_FAIL();
+                TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, sock.close());
+                return;
             }
             bytes2recv -= recvd;
         }
@@ -80,10 +90,15 @@ void tcpsocket_echotest_nonblock_receiver(void *receive_bytes)
     while (bytes2recv) {
         recvd = sock.recv(&(tcp_global::rx_buffer[*(int*)receive_bytes-bytes2recv]), bytes2recv);
         if (recvd == NSAPI_ERROR_WOULD_BLOCK) {
+            if (tc_exec_time.read() >= time_allotted) {
+                TEST_FAIL();
+                break;
+            }
             wait(1);
             continue;
         } else if (recvd < 0) {
             TEST_FAIL();
+            break;
         }
         bytes2recv -= recvd;
     }
@@ -99,6 +114,9 @@ void tcpsocket_echotest_nonblock_receiver(void *receive_bytes)
 
 void TCPSOCKET_ECHOTEST_NONBLOCK()
 {
+    tc_exec_time.start();
+    time_allotted = split2half_rmng_tcp_test_time(); // [s]
+
     tcpsocket_connect_to_echo_srv(sock);
     sock.set_blocking(false);
     sock.sigio(callback(_sigio_handler, Thread::gettid()));
@@ -124,19 +142,30 @@ void TCPSOCKET_ECHOTEST_NONBLOCK()
         while (bytes2send > 0) {
             sent = sock.send(&(tcp_global::tx_buffer[pkt_s-bytes2send]), bytes2send);
             if (sent == NSAPI_ERROR_WOULD_BLOCK) {
-                TEST_ASSERT_NOT_EQUAL(osEventTimeout, osSignalWait(SIGNAL_SIGIO, SIGIO_TIMEOUT).status);
+                if (tc_exec_time.read() >= time_allotted ||
+                   osSignalWait(SIGNAL_SIGIO, SIGIO_TIMEOUT).status == osEventTimeout) {
+                    thread->terminate();
+                    delete thread;
+                    TEST_FAIL();
+                    goto END;
+                }
                 continue;
             } else if (sent <= 0) {
                 printf("[Sender#%02d] network error %d\n", s_idx, sent);
+                thread->terminate();
+                delete thread;
                 TEST_FAIL();
+                goto END;
             }
             bytes2send -= sent;
         }
         printf("[Sender#%02d] bytes sent: %d\n", s_idx, pkt_s);
-        tx_sem.wait();
+        tx_sem.wait(split2half_rmng_tcp_test_time());
         thread->join();
         delete thread;
     }
+END:
+    tc_exec_time.stop();
     free(stack_mem);
     TEST_ASSERT_EQUAL(NSAPI_ERROR_OK, sock.close());
 }