Merge pull request #3290 from ARMmbed/release-candidate

Release candidate for mbed-os-5.2.3

Author: adbridge

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/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");
+}
+

cmsis/core_caFunc.h

@@ -811,6 +811,23 @@ __asm(
 __STATIC_INLINE void __v7_inv_dcache_all(void) {
     __v7_all_cache(0);
 }
+/** \brief  Clean the whole D$
+
+    DCCSW. Clean by Set/Way
+ */
+
+__STATIC_INLINE void __v7_clean_dcache_all(void) {
+    __v7_all_cache(1);
+}
+
+/** \brief  Clean and invalidate the whole D$
+
+    DCCISW. Clean and Invalidate by Set/Way
+ */
+
+__STATIC_INLINE void __v7_clean_inv_dcache_all(void) {
+    __v7_all_cache(2);
+}
 /** \brief  Clean and Invalidate D$ by MVA
 
     DCCIMVAC. Data cache clean and invalidate by MVA to PoC

events/equeue/equeue_mbed.cpp

@@ -38,8 +38,10 @@ static void equeue_tick_update() {
 }
 
 static void equeue_tick_init() {
-    MBED_ASSERT(sizeof(equeue_timer) >= sizeof(Timer));
-    MBED_ASSERT(sizeof(equeue_ticker) >= sizeof(Ticker));
+    MBED_STATIC_ASSERT(sizeof(equeue_timer) >= sizeof(Timer),
+            "The equeue_timer buffer must fit the class Timer");
+    MBED_STATIC_ASSERT(sizeof(equeue_ticker) >= sizeof(Ticker),
+            "The equeue_ticker buffer must fit the class Ticker");
     new (equeue_timer) Timer;
     new (equeue_ticker) Ticker;
 
@@ -78,7 +80,8 @@ void equeue_mutex_unlock(equeue_mutex_t *m) {
 #ifdef MBED_CONF_RTOS_PRESENT
 
 int equeue_sema_create(equeue_sema_t *s) {
-    MBED_ASSERT(sizeof(equeue_sema_t) >= sizeof(Semaphore));
+    MBED_STATIC_ASSERT(sizeof(equeue_sema_t) >= sizeof(Semaphore),
+            "The equeue_sema_t must fit the class Semaphore");
     new (s) Semaphore(0);
     return 0;
 }

features/FEATURE_LWIP/TESTS/mbedmicro-net/gethostbyname/main.cpp

@@ -0,0 +1,104 @@
+#include "mbed.h"
+#include "greentea-client/test_env.h"
+#include "unity.h"
+#include "utest.h"
+#include "EthernetInterface.h"
+
+using namespace utest::v1;
+
+
+// Hostname for testing against
+// Must have A and AAAA records
+#ifndef MBED_DNS_TEST_HOST
+#define MBED_DNS_TEST_HOST "connector.mbed.com"
+#endif
+
+// Address info from stack
+const char *ip_literal;
+nsapi_version_t ip_pref;
+const char *ip_pref_repr;
+
+// Network setup
+EthernetInterface net;
+void net_bringup() {
+    int err = net.connect();
+    TEST_ASSERT_EQUAL(0, err);
+    printf("MBED: Connected to network\n");
+    printf("MBED: IP Address: %s\n", net.get_ip_address());
+
+    ip_literal = net.get_ip_address();
+    ip_pref = SocketAddress(ip_literal).get_ip_version();
+    ip_pref_repr = (ip_pref == NSAPI_IPv4) ? "ipv4" :
+                   (ip_pref == NSAPI_IPv6) ? "ipv6" : "unspec";
+}
+
+
+// DNS tests
+void test_dns_query() {
+    SocketAddress addr;
+    int err = net.gethostbyname(MBED_DNS_TEST_HOST, &addr);
+    printf("DNS: query \"%s\" => \"%s\"\n",
+            MBED_DNS_TEST_HOST, addr.get_ip_address());
+
+    TEST_ASSERT_EQUAL(0, err);
+    TEST_ASSERT((bool)addr);
+    TEST_ASSERT(strlen(addr.get_ip_address()) > 1);
+}
+
+void test_dns_query_pref() {
+    SocketAddress addr;
+    int err = net.gethostbyname(MBED_DNS_TEST_HOST, &addr, ip_pref);
+    printf("DNS: query %s \"%s\" => \"%s\"\n",
+            ip_pref_repr, MBED_DNS_TEST_HOST, addr.get_ip_address());
+
+    TEST_ASSERT_EQUAL(0, err);
+    TEST_ASSERT((bool)addr);
+    TEST_ASSERT(strlen(addr.get_ip_address()) > 1);
+    TEST_ASSERT_EQUAL(ip_pref, addr.get_ip_version());
+}
+
+void test_dns_literal() {
+    SocketAddress addr;
+    int err = net.gethostbyname(ip_literal, &addr);
+    printf("DNS: literal \"%s\" => \"%s\"\n",
+            ip_literal, addr.get_ip_address());
+
+    TEST_ASSERT_EQUAL(0, err);
+    TEST_ASSERT((bool)addr);
+    TEST_ASSERT(strlen(addr.get_ip_address()) > 1);
+    TEST_ASSERT(strcmp(ip_literal, addr.get_ip_address()) == 0);
+}
+
+void test_dns_literal_pref() {
+    SocketAddress addr;
+    int err = net.gethostbyname(ip_literal, &addr, ip_pref);
+    printf("DNS: literal %s \"%s\" => \"%s\"\n",
+            ip_pref_repr, ip_literal, addr.get_ip_address());
+
+    TEST_ASSERT_EQUAL(0, err);
+    TEST_ASSERT((bool)addr);
+    TEST_ASSERT(strlen(addr.get_ip_address()) > 1);
+    TEST_ASSERT_EQUAL(ip_pref, addr.get_ip_version());
+    TEST_ASSERT(strcmp(ip_literal, addr.get_ip_address()) == 0);
+}
+
+
+// Test setup
+utest::v1::status_t test_setup(const size_t number_of_cases) {
+    GREENTEA_SETUP(20, "default_auto");
+    net_bringup();
+    return verbose_test_setup_handler(number_of_cases);
+}
+
+Case cases[] = {
+    Case("Testing DNS query",               test_dns_query),
+    Case("Testing DNS preference query",    test_dns_query_pref),
+    Case("Testing DNS literal",             test_dns_literal),
+    Case("Testing DNS preference literal",  test_dns_literal_pref),
+};
+
+Specification specification(test_setup, cases);
+
+int main() {
+    return !Harness::run(specification);
+}