Mbed os 5.2

.travis.yml

@@ -7,6 +7,7 @@ script:
   - python tools/test/pylint.py
   - py.test tools/test/toolchains/api.py
   - python tools/test/memap/memap_test.py
+  - python tools/project.py -S
   - python tools/build_travis.py
 before_install:
   - sudo add-apt-repository -y ppa:terry.guo/gcc-arm-embedded
@@ -16,9 +17,7 @@ before_install:
   - arm-none-eabi-gcc --version
   - python --version
 install:
-  - sudo pip install colorama
-  - sudo pip install prettytable
-  - sudo pip install jinja2
+  - sudo pip install -r requirements.txt
   - sudo pip install pytest
   - sudo pip install pylint
   - sudo pip install hypothesis

README.md

@@ -6,15 +6,15 @@ mbed OS accelerates the process of creating a connected product by providing a p
 
 ## Current release
 
-Our current release series is mbed OS 5.1:
+Our current release series is mbed OS 5.2:
 
-- [Release Note](https://docs.mbed.com/docs/mbed-os-release-notes/en/latest/5_1/release/)
+- [Release Note](https://docs.mbed.com/docs/mbed-os-release-notes/en/latest/5_2/release_note/)
 
 ## Getting Started for Developers
 
 We have a getting started guide for developers using mbed OS in applications:
 
-- [Getting Started](https://docs.mbed.com/docs/mbed-os-handbook/en/5.1/)
+- [Getting Started](https://docs.mbed.com/docs/mbed-os-handbook/en/5.2/)
 
 ## Getting Started for Contributors
 

TESTS/mbed_drivers/lp_timeout/main.cpp

@@ -43,8 +43,18 @@ void lp_timeout_1s_deepsleep(void)
 {
     complete = false;
 
-    /* 
-     * We use here lp_ticker_read() instead of us_ticker_read() for start and 
+    /*
+     * Since deepsleep() may shut down the UART peripheral, we wait for 10ms
+     * to allow for hardware serial buffers to completely flush.
+
+     * This should be replaced with a better function that checks if the
+     * hardware buffers are empty. However, such an API does not exist now,
+     * so we'll use the wait_ms() function for now.
+     */
+    wait_ms(10);
+
+    /*
+     * We use here lp_ticker_read() instead of us_ticker_read() for start and
      * end because the microseconds timer might be disable during deepsleep.
      */
     timestamp_t start = lp_ticker_read();
@@ -108,7 +118,7 @@ void lp_timeout_500us(void)
 
 }
 
-status_t greentea_failure_handler(const Case *const source, const failure_t reason) {
+utest::v1::status_t greentea_failure_handler(const Case *const source, const failure_t reason) {
     greentea_case_failure_abort_handler(source, reason);
     return STATUS_CONTINUE;
 }
@@ -124,7 +134,7 @@ Case cases[] = {
 #endif /* DEVICE_SLEEP */
 };
 
-status_t greentea_test_setup(const size_t number_of_cases) {
+utest::v1::status_t greentea_test_setup(const size_t number_of_cases) {
     GREENTEA_SETUP(20, "default_auto");
     return greentea_test_setup_handler(number_of_cases);
 }

TESTS/mbed_functional/callback/main.cpp

@@ -233,6 +233,11 @@ template <typename T>
 T const_volatile_void_func5(const volatile void *t, T a0, T a1, T a2, T a3, T a4)
     { return static_cast<const volatile Thing<T>*>(t)->t | a0 | a1 | a2 | a3 | a4; }
 
+// Inheriting class
+template <typename T>
+class Thing2 : public Thing<T> {
+};
+
 
 // function call and result verification
 template <typename T>
@@ -315,15 +320,18 @@ struct Verifier {
 template <typename T>
 void test_dispatch0() {
     Thing<T> thing;
+    Thing2<T> thing2;
     Verifier<T>::verify0(static_func0<T>);
     Verifier<T>::verify0(&thing, &Thing<T>::member_func0);
     Verifier<T>::verify0((const Thing<T>*)&thing, &Thing<T>::const_member_func0);
     Verifier<T>::verify0((volatile Thing<T>*)&thing, &Thing<T>::volatile_member_func0);
     Verifier<T>::verify0((const volatile Thing<T>*)&thing, &Thing<T>::const_volatile_member_func0);
+    Verifier<T>::verify0(&thing2, &Thing2<T>::member_func0);
     Verifier<T>::verify0(&bound_func0<T>, &thing);
     Verifier<T>::verify0(&const_bound_func0<T>, (const Thing<T>*)&thing);
     Verifier<T>::verify0(&volatile_bound_func0<T>, (volatile Thing<T>*)&thing);
     Verifier<T>::verify0(&const_volatile_bound_func0<T>, (const volatile Thing<T>*)&thing);
+    Verifier<T>::verify0(&bound_func0<T>, &thing2);
     Verifier<T>::verify0(&void_func0<T>, &thing);
     Verifier<T>::verify0(&const_void_func0<T>, (const Thing<T>*)&thing);
     Verifier<T>::verify0(&volatile_void_func0<T>, (volatile Thing<T>*)&thing);
@@ -342,15 +350,18 @@ void test_dispatch0() {
 template <typename T>
 void test_dispatch1() {
     Thing<T> thing;
+    Thing2<T> thing2;
     Verifier<T>::verify1(static_func1<T>);
     Verifier<T>::verify1(&thing, &Thing<T>::member_func1);
     Verifier<T>::verify1((const Thing<T>*)&thing, &Thing<T>::const_member_func1);
     Verifier<T>::verify1((volatile Thing<T>*)&thing, &Thing<T>::volatile_member_func1);
     Verifier<T>::verify1((const volatile Thing<T>*)&thing, &Thing<T>::const_volatile_member_func1);
+    Verifier<T>::verify1(&thing2, &Thing2<T>::member_func1);
     Verifier<T>::verify1(&bound_func1<T>, &thing);
     Verifier<T>::verify1(&const_bound_func1<T>, (const Thing<T>*)&thing);
     Verifier<T>::verify1(&volatile_bound_func1<T>, (volatile Thing<T>*)&thing);
     Verifier<T>::verify1(&const_volatile_bound_func1<T>, (const volatile Thing<T>*)&thing);
+    Verifier<T>::verify1(&bound_func1<T>, &thing2);
     Verifier<T>::verify1(&void_func1<T>, &thing);
     Verifier<T>::verify1(&const_void_func1<T>, (const Thing<T>*)&thing);
     Verifier<T>::verify1(&volatile_void_func1<T>, (volatile Thing<T>*)&thing);
@@ -369,15 +380,18 @@ void test_dispatch1() {
 template <typename T>
 void test_dispatch2() {
     Thing<T> thing;
+    Thing2<T> thing2;
     Verifier<T>::verify2(static_func2<T>);
     Verifier<T>::verify2(&thing, &Thing<T>::member_func2);
     Verifier<T>::verify2((const Thing<T>*)&thing, &Thing<T>::const_member_func2);
     Verifier<T>::verify2((volatile Thing<T>*)&thing, &Thing<T>::volatile_member_func2);
     Verifier<T>::verify2((const volatile Thing<T>*)&thing, &Thing<T>::const_volatile_member_func2);
+    Verifier<T>::verify2(&thing2, &Thing2<T>::member_func2);
     Verifier<T>::verify2(&bound_func2<T>, &thing);
     Verifier<T>::verify2(&const_bound_func2<T>, (const Thing<T>*)&thing);
     Verifier<T>::verify2(&volatile_bound_func2<T>, (volatile Thing<T>*)&thing);
     Verifier<T>::verify2(&const_volatile_bound_func2<T>, (const volatile Thing<T>*)&thing);
+    Verifier<T>::verify2(&bound_func2<T>, &thing2);
     Verifier<T>::verify2(&void_func2<T>, &thing);
     Verifier<T>::verify2(&const_void_func2<T>, (const Thing<T>*)&thing);
     Verifier<T>::verify2(&volatile_void_func2<T>, (volatile Thing<T>*)&thing);
@@ -396,15 +410,18 @@ void test_dispatch2() {
 template <typename T>
 void test_dispatch3() {
     Thing<T> thing;
+    Thing2<T> thing2;
     Verifier<T>::verify3(static_func3<T>);
     Verifier<T>::verify3(&thing, &Thing<T>::member_func3);
     Verifier<T>::verify3((const Thing<T>*)&thing, &Thing<T>::const_member_func3);
     Verifier<T>::verify3((volatile Thing<T>*)&thing, &Thing<T>::volatile_member_func3);
     Verifier<T>::verify3((const volatile Thing<T>*)&thing, &Thing<T>::const_volatile_member_func3);
+    Verifier<T>::verify3(&thing2, &Thing2<T>::member_func3);
     Verifier<T>::verify3(&bound_func3<T>, &thing);
     Verifier<T>::verify3(&const_bound_func3<T>, (const Thing<T>*)&thing);
     Verifier<T>::verify3(&volatile_bound_func3<T>, (volatile Thing<T>*)&thing);
     Verifier<T>::verify3(&const_volatile_bound_func3<T>, (const volatile Thing<T>*)&thing);
+    Verifier<T>::verify3(&bound_func3<T>, &thing2);
     Verifier<T>::verify3(&void_func3<T>, &thing);
     Verifier<T>::verify3(&const_void_func3<T>, (const Thing<T>*)&thing);
     Verifier<T>::verify3(&volatile_void_func3<T>, (volatile Thing<T>*)&thing);
@@ -423,15 +440,18 @@ void test_dispatch3() {
 template <typename T>
 void test_dispatch4() {
     Thing<T> thing;
+    Thing2<T> thing2;
     Verifier<T>::verify4(static_func4<T>);
     Verifier<T>::verify4(&thing, &Thing<T>::member_func4);
     Verifier<T>::verify4((const Thing<T>*)&thing, &Thing<T>::const_member_func4);
     Verifier<T>::verify4((volatile Thing<T>*)&thing, &Thing<T>::volatile_member_func4);
     Verifier<T>::verify4((const volatile Thing<T>*)&thing, &Thing<T>::const_volatile_member_func4);
+    Verifier<T>::verify4(&thing2, &Thing2<T>::member_func4);
     Verifier<T>::verify4(&bound_func4<T>, &thing);
     Verifier<T>::verify4(&const_bound_func4<T>, (const Thing<T>*)&thing);
     Verifier<T>::verify4(&volatile_bound_func4<T>, (volatile Thing<T>*)&thing);
     Verifier<T>::verify4(&const_volatile_bound_func4<T>, (const volatile Thing<T>*)&thing);
+    Verifier<T>::verify4(&bound_func4<T>, &thing2);
     Verifier<T>::verify4(&void_func4<T>, &thing);
     Verifier<T>::verify4(&const_void_func4<T>, (const Thing<T>*)&thing);
     Verifier<T>::verify4(&volatile_void_func4<T>, (volatile Thing<T>*)&thing);
@@ -450,15 +470,18 @@ void test_dispatch4() {
 template <typename T>
 void test_dispatch5() {
     Thing<T> thing;
+    Thing2<T> thing2;
     Verifier<T>::verify5(static_func5<T>);
     Verifier<T>::verify5(&thing, &Thing<T>::member_func5);
     Verifier<T>::verify5((const Thing<T>*)&thing, &Thing<T>::const_member_func5);
     Verifier<T>::verify5((volatile Thing<T>*)&thing, &Thing<T>::volatile_member_func5);
     Verifier<T>::verify5((const volatile Thing<T>*)&thing, &Thing<T>::const_volatile_member_func5);
+    Verifier<T>::verify5(&thing2, &Thing2<T>::member_func5);
     Verifier<T>::verify5(&bound_func5<T>, &thing);
     Verifier<T>::verify5(&const_bound_func5<T>, (const Thing<T>*)&thing);
     Verifier<T>::verify5(&volatile_bound_func5<T>, (volatile Thing<T>*)&thing);
     Verifier<T>::verify5(&const_volatile_bound_func5<T>, (const volatile Thing<T>*)&thing);
+    Verifier<T>::verify5(&bound_func5<T>, &thing2);
     Verifier<T>::verify5(&void_func5<T>, &thing);
     Verifier<T>::verify5(&const_void_func5<T>, (const Thing<T>*)&thing);
     Verifier<T>::verify5(&volatile_void_func5<T>, (volatile Thing<T>*)&thing);

TESTS/mbed_hal/lp_ticker/main.cpp

@@ -65,12 +65,22 @@ void lp_ticker_1s_deepsleep()
     complete = false;
     uint32_t delay_ts;
 
+    /*
+     * Since deepsleep() may shut down the UART peripheral, we wait for 10ms
+     * to allow for hardware serial buffers to completely flush.
+
+     * This should be replaced with a better function that checks if the
+     * hardware buffers are empty. However, such an API does not exist now,
+     * so we'll use the wait_ms() function for now.
+     */
+    wait_ms(10);
+
     ticker_set_handler(lp_ticker_data, cb_done);
     ticker_remove_event(lp_ticker_data, &delay_event);
     delay_ts = lp_ticker_read() + 1000000;
 
-    /* 
-     * We use here lp_ticker_read() instead of us_ticker_read() for start and 
+    /*
+     * We use here lp_ticker_read() instead of us_ticker_read() for start and
      * end because the microseconds timer might be disable during deepsleep.
      */
     timestamp_t start = lp_ticker_read();
@@ -123,7 +133,7 @@ void lp_ticker_5s(void)
     lp_ticker_delay_us(5000000, LONG_TIMEOUT);
 }
 
-status_t greentea_failure_handler(const Case *const source, const failure_t reason) {
+utest::v1::status_t greentea_failure_handler(const Case *const source, const failure_t reason) {
     greentea_case_failure_abort_handler(source, reason);
     return STATUS_CONTINUE;
 }
@@ -139,7 +149,7 @@ Case cases[] = {
 #endif /* DEVICE_SLEEP */
 };
 
-status_t greentea_test_setup(const size_t number_of_cases) {
+utest::v1::status_t greentea_test_setup(const size_t number_of_cases) {
     GREENTEA_SETUP(20, "default_auto");
     lp_ticker_data->interface->init();
     return greentea_test_setup_handler(number_of_cases);

TESTS/mbedmicro-mbed/cpp/main.cpp

@@ -9,8 +9,10 @@ class Test {
     const int pattern;
 
 public:
-    Test(const char* _name) : name(_name), pattern(PATTERN_CHECK_VALUE)  {
-        print("init");
+    Test(const char* _name, bool print_message=true) : name(_name), pattern(PATTERN_CHECK_VALUE)  {
+        if (print_message) {
+            print("init");
+        }
     }
 
     void print(const char *message) {
@@ -39,7 +41,7 @@ class Test {
 };
 
 /* Check C++ startup initialisation */
-Test s("Static");
+Test s("Static", false);
 
 /* EXPECTED OUTPUT:
 *******************
@@ -59,6 +61,7 @@ int main (void) {
     bool result = true;
     for (;;)
     {
+        s.print("init");
         // Global stack object simple test
         s.stack_test();
         if (s.check_init() == false)

TESTS/mbedmicro-mbed/static_assert/main.cpp

@@ -0,0 +1,26 @@
+#include <stdio.h>
+#include <stdint.h>
+
+#include "toolchain.h"
+#include "greentea-client/test_env.h"
+#include "unity.h"
+#include "utest.h"
+
+using namespace utest::v1;
+
+void no_test() {}
+
+utest::v1::status_t test_setup(const size_t number_of_cases) {
+    GREENTEA_SETUP(5, "default_auto");
+    return verbose_test_setup_handler(number_of_cases);
+}
+
+Case cases[] = {
+    Case("Compilation test", no_test),
+};
+
+Specification specification(test_setup, cases);
+
+int main() {
+    return !Harness::run(specification);
+}

TESTS/mbedmicro-mbed/static_assert/test_c.c

@@ -0,0 +1,39 @@
+#include "mbed_assert.h"
+#define THE_ANSWER 42
+
+// Tests for static asserts in different contexts
+// multiple asserts are used to garuntee no conflicts occur in generated labels
+
+// Test for static asserts in global context
+MBED_STATIC_ASSERT(sizeof(int) >= sizeof(char),
+        "An int must be larger than char");
+MBED_STATIC_ASSERT(2 + 2 == 4,
+        "Hopefully the universe is mathematically consistent");
+MBED_STATIC_ASSERT(THE_ANSWER == 42,
+        "Said Deep Thought, with infinite majesty and calm");
+
+struct test {
+    int dummy;
+
+    // Test for static asserts in struct context
+    MBED_STRUCT_STATIC_ASSERT(sizeof(int) >= sizeof(char),
+            "An int must be larger than char");
+    MBED_STRUCT_STATIC_ASSERT(2 + 2 == 4,
+            "Hopefully the universe is mathematically consistent");
+    MBED_STRUCT_STATIC_ASSERT(THE_ANSWER == 42,
+            "Said Deep Thought, with infinite majesty and calm");
+};
+
+MBED_STATIC_ASSERT(sizeof(struct test) == sizeof(int),
+        "Static assertions should not change the size of a struct");
+
+void doit_c(void) {
+    // Test for static asserts in function context
+    MBED_STATIC_ASSERT(sizeof(int) >= sizeof(char),
+            "An int must be larger than char");
+    MBED_STATIC_ASSERT(2 + 2 == 4,
+            "Hopefully the universe is mathematically consistent");
+    MBED_STATIC_ASSERT(THE_ANSWER == 42,
+            "Said Deep Thought, with infinite majesty and calm");
+}
+

TESTS/mbedmicro-mbed/static_assert/test_cpp.cpp

@@ -0,0 +1,46 @@
+#include "mbed_assert.h"
+#define THE_ANSWER 42
+
+// Tests for static asserts in different contexts
+// multiple asserts are used to garuntee no conflicts occur in generated labels
+
+// Test for static asserts in global context
+MBED_STATIC_ASSERT(sizeof(int) >= sizeof(char),
+        "An int must be larger than char");
+MBED_STATIC_ASSERT(2 + 2 == 4,
+        "Hopefully the universe is mathematically consistent");
+MBED_STATIC_ASSERT(THE_ANSWER == 42,
+        "Said Deep Thought, with infinite majesty and calm");
+
+struct test {
+    int dummy;
+
+    // Test for static asserts in struct context
+    MBED_STRUCT_STATIC_ASSERT(sizeof(int) >= sizeof(char),
+            "An int must be larger than char");
+    MBED_STRUCT_STATIC_ASSERT(2 + 2 == 4,
+            "Hopefully the universe is mathematically consistent");
+    MBED_STRUCT_STATIC_ASSERT(THE_ANSWER == 42,
+            "Said Deep Thought, with infinite majesty and calm");
+
+    MBED_STATIC_ASSERT(sizeof(int) >= sizeof(char),
+            "An int must be larger than char");
+    MBED_STATIC_ASSERT(2 + 2 == 4,
+            "Hopefully the universe is mathematically consistent");
+    MBED_STATIC_ASSERT(THE_ANSWER == 42,
+            "Said Deep Thought, with infinite majesty and calm");
+};
+
+MBED_STATIC_ASSERT(sizeof(struct test) == sizeof(int),
+        "Static assertions should not change the size of a struct");
+
+void doit_c(void) {
+    // Test for static asserts in function context
+    MBED_STATIC_ASSERT(sizeof(int) >= sizeof(char),
+            "An int must be larger than char");
+    MBED_STATIC_ASSERT(2 + 2 == 4,
+            "Hopefully the universe is mathematically consistent");
+    MBED_STATIC_ASSERT(THE_ANSWER == 42,
+            "Said Deep Thought, with infinite majesty and calm");
+}
+

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

@@ -25,6 +25,8 @@
     #define STACK_SIZE 512
 #elif defined(TARGET_XDOT_L151CC)
     #define STACK_SIZE 1024
+#elif defined(TARGET_HI2110)
+    #define STACK_SIZE 512
 #else
     #define STACK_SIZE DEFAULT_STACK_SIZE
 #endif