Diff: features/FEATURE_COMMON_PAL/mbed-trace/test/Test.cpp

Revision:

0:f782d9c66c49

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/features/FEATURE_COMMON_PAL/mbed-trace/test/Test.cpp	Fri Feb 02 05:42:23 2018 +0000
@@ -0,0 +1,463 @@
+/*
+ * Copyright (c) 2014 ARM. All rights reserved.
+ */
+/**
+ * \file \test_libTrace\Test.c
+ *
+ * \brief Unit tests for mbed_trace
+ */
+#include <string.h>
+#include <stdlib.h>
+#include <stdint.h>
+
+#include "mbed-cpputest/CppUTest/TestHarness.h"
+#include "mbed-cpputest/CppUTest/SimpleString.h"
+#include "mbed-cpputest/CppUTest/CommandLineTestRunner.h"
+
+#define MBED_CONF_MBED_TRACE_ENABLE 1
+#define MBED_CONF_MBED_TRACE_FEA_IPV6 1
+
+#include "mbed-trace/mbed_trace.h"
+#include "ip6tos_stub.h"
+
+int main(int ac, char **av)
+{
+    return CommandLineTestRunner::RunAllTests(ac, av);
+}
+
+static int mutex_wait_count = 0;
+static int mutex_release_count = 0;
+static bool check_mutex_lock_status = true;
+void my_mutex_wait()
+{
+  mutex_wait_count++;
+}
+void my_mutex_release()
+{
+  mutex_release_count++;
+}
+
+char buf[1024];
+#include <stdio.h>
+void myprint(const char* str)
+{
+  if ( check_mutex_lock_status ) {
+      CHECK( (mutex_wait_count - mutex_release_count) > 0 );
+  }
+  strcpy(buf, str);
+}
+TEST_GROUP(trace)
+{
+  void setup()
+  {
+
+    mbed_trace_init();
+    mbed_trace_config_set(TRACE_MODE_PLAIN|TRACE_ACTIVE_LEVEL_ALL);
+    mbed_trace_print_function_set( myprint );
+    mbed_trace_mutex_wait_function_set( my_mutex_wait );
+    mbed_trace_mutex_release_function_set( my_mutex_release );
+  }
+  void teardown()
+  {
+    CHECK(mutex_wait_count == mutex_release_count); // Check the mutex count with every test
+    mbed_trace_free();
+  }
+};
+
+/* Unity test code starts */
+TEST(trace, MutexNotSet)
+{
+  mbed_trace_mutex_wait_function_set( 0 );
+  mbed_trace_mutex_release_function_set( 0 );
+  int mutex_call_count_at_entry = mutex_wait_count;
+  check_mutex_lock_status = false;
+
+  char expectedStr[] = "Hello hello!";
+  mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "Hello hello!");
+  STRCMP_EQUAL(expectedStr, buf);
+
+  CHECK( mutex_call_count_at_entry == mutex_wait_count );
+  CHECK( mutex_call_count_at_entry == mutex_release_count );
+
+  mbed_trace_mutex_wait_function_set( my_mutex_wait );
+  mbed_trace_mutex_release_function_set( my_mutex_release );
+  check_mutex_lock_status = true;
+}
+
+TEST(trace, Array)
+{
+  unsigned char longStr[200] = {0x66};
+  for(int i=0;i<200;i++) {longStr[i] = 0x66; }
+  mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "%s", mbed_trace_array(longStr, 200) );
+}
+
+TEST(trace, LongString)
+{
+  char longStr[1000] = {0x36};
+  for(int i=0;i<999;i++) {longStr[i] = 0x36; }
+  mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "%s", longStr );
+}
+
+TEST(trace, TooLong)
+{
+  #define TOO_LONG_SIZE 9400
+  #define TRACE_LINE_SIZE 1024
+  char longStr[TOO_LONG_SIZE] = {0};
+  for(int i=0;i<TOO_LONG_SIZE;i++) { longStr[i] = 0x36; }  
+  
+  mbed_trace_config_set(TRACE_ACTIVE_LEVEL_ALL);
+  mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "%s", longStr );
+  
+  char shouldStr[TRACE_LINE_SIZE] = "[DBG ][mygr]: ";
+  for(int i=14;i<TRACE_LINE_SIZE;i++) { shouldStr[i] = 0x36; }
+  shouldStr[TRACE_LINE_SIZE-1] = 0;
+  STRCMP_EQUAL(shouldStr, buf);
+}
+
+TEST(trace, BufferResize)
+{
+    uint8_t arr[20] = {0};
+    memset(arr, '0', 20);
+
+    mbed_trace_buffer_sizes(0, 10);
+    STRCMP_EQUAL("30:30:30*", mbed_trace_array(arr, 20));
+    mbed_trace_buffer_sizes(0, 15);
+    STRCMP_EQUAL("30:30:30:30*", mbed_trace_array(arr, 20));
+    mbed_trace_buffer_sizes(0, 15);
+    STRCMP_EQUAL("30:30:30:30", mbed_trace_array(arr, 4));
+
+    const char * expectedStr = "0123456789";
+    mbed_trace_buffer_sizes(11, 0);
+    mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "01234567890123456789");
+    STRCMP_EQUAL(expectedStr, buf);
+    expectedStr = "012345678901234";
+    mbed_trace_buffer_sizes(16, 0);
+    mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "01234567890123456789");
+    STRCMP_EQUAL(expectedStr, buf);
+    expectedStr = "012345678901234";
+    mbed_trace_buffer_sizes(16, 0);
+    mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "012345678901234");
+    STRCMP_EQUAL(expectedStr, buf);
+}
+
+TEST(trace, PreInitConfiguration)
+{
+    uint8_t arr[20] = {0};
+    memset(arr, '0', 20);
+
+    mbed_trace_free();
+    mbed_trace_config_set(TRACE_MODE_PLAIN|TRACE_ACTIVE_LEVEL_ALL);
+    mbed_trace_print_function_set( myprint );
+    mbed_trace_buffer_sizes(11, 10);
+    mbed_trace_mutex_wait_function_set( my_mutex_wait );
+    mbed_trace_mutex_release_function_set( my_mutex_release );
+    mbed_trace_init();
+
+    STRCMP_EQUAL("30:30:30*", mbed_trace_array(arr, 20));
+
+    const char * expectedStr = "0123456789";
+    mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "01234567890123456789");
+    STRCMP_EQUAL(expectedStr, buf);
+}
+
+#if YOTTA_CFG_MBED_TRACE_FEA_IPV6 == 1
+ip6tos_stub_def_t ip6tos_stub; // extern variable
+
+TEST(trace, ipv6)
+{
+    uint8_t prefix[] = { 0x14, 0x6e, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00 };
+    int prefix_len = 64;
+
+    char expected_str1[] = "146e:a00::/64";
+    ip6tos_stub.output_string = "146e:a00::/64";
+    char *str = mbed_trace_ipv6_prefix(prefix, prefix_len);
+    CHECK(memcmp(ip6tos_stub.input_array, prefix, 8) == 0);
+    STRCMP_EQUAL(expected_str1, str);
+    mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "flush buffers and locks");
+
+    char expected_str2[] = "::/0";
+    ip6tos_stub.output_string = "::/0";
+    str = mbed_trace_ipv6_prefix(NULL, 0);
+    STRCMP_EQUAL(expected_str2, str);
+    mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "flush buffers and locks");
+
+    char expected_str3[] = "<err>";
+    str = mbed_trace_ipv6_prefix(NULL, 1);
+    STRCMP_EQUAL(expected_str3, str);
+    mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "flush buffers and locks");
+
+    char expected_str4[] = "<err>";
+    str = mbed_trace_ipv6_prefix(prefix, 200);
+    STRCMP_EQUAL(expected_str4, str);
+    mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "flush buffers and locks");
+
+    char expected_str5[] = "";
+    ip6tos_stub.output_string = "0123456789012345678901234567890123456789";
+    str = mbed_trace_ipv6_prefix(prefix, 64); // Fill the tmp_data buffer
+    str = mbed_trace_ipv6_prefix(prefix, 64);
+    str = mbed_trace_ipv6_prefix(prefix, 64);
+    str = mbed_trace_ipv6_prefix(prefix, 64);
+    STRCMP_EQUAL(expected_str5, str);
+    mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "flush buffers and locks");
+}
+
+TEST(trace, active_level_all_ipv6)
+{
+  mbed_trace_config_set(TRACE_ACTIVE_LEVEL_ALL);
+  
+  uint8_t arr[] = { 0x20, 0x01, 0xd, 0xb8, 0,0,0,0,0,1,0,0,0,0,0,1 };
+  ip6tos_stub.output_string = "2001:db8::1:0:0:1";
+  mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "my addr: %s", mbed_trace_ipv6(arr));
+  CHECK(memcmp(ip6tos_stub.input_array, arr, 16) == 0);
+  STRCMP_EQUAL("[DBG ][mygr]: my addr: 2001:db8::1:0:0:1", buf);
+}
+#endif //YOTTA_CFG_MBED_TRACE_FEA_IPV6
+
+TEST(trace, config_change)
+{
+    mbed_trace_config_set(TRACE_MODE_COLOR|TRACE_ACTIVE_LEVEL_ALL);
+    CHECK(mbed_trace_config_get() == TRACE_MODE_COLOR|TRACE_ACTIVE_LEVEL_ALL);
+    mbed_trace_config_set(TRACE_MODE_PLAIN|TRACE_ACTIVE_LEVEL_NONE);
+    CHECK(mbed_trace_config_get() == TRACE_MODE_PLAIN|TRACE_ACTIVE_LEVEL_NONE);
+    mbed_trace_config_set(TRACE_MODE_PLAIN|TRACE_ACTIVE_LEVEL_ALL);
+    CHECK(mbed_trace_config_get() == TRACE_MODE_PLAIN|TRACE_ACTIVE_LEVEL_ALL);
+}
+
+TEST(trace, active_level_all_color)
+{
+  mbed_trace_config_set(TRACE_MODE_COLOR|TRACE_ACTIVE_LEVEL_ALL);
+  mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "hello");
+  STRCMP_EQUAL("\x1b[90m[DBG ][mygr]: hello\x1b[0m", buf);
+  mbed_tracef(TRACE_LEVEL_INFO, "mygr", "to one");
+  STRCMP_EQUAL("\x1b[39m[INFO][mygr]: to one\x1b[0m", buf);
+  mbed_tracef(TRACE_LEVEL_WARN, "mygr", "and all");
+  STRCMP_EQUAL("\x1b[33m[WARN][mygr]: and all\x1b[0m", buf);
+  mbed_tracef(TRACE_LEVEL_ERROR, "mygr", "even you");
+  STRCMP_EQUAL("\x1b[31m[ERR ][mygr]: even you\x1b[0m", buf);
+}
+
+TEST(trace, change_levels)
+{
+  mbed_trace_config_set(TRACE_ACTIVE_LEVEL_DEBUG);
+  mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "hep");
+  STRCMP_EQUAL("[DBG ][mygr]: hep", buf);
+  
+  mbed_trace_config_set(TRACE_ACTIVE_LEVEL_DEBUG|TRACE_MODE_PLAIN);
+  mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "hep");
+  STRCMP_EQUAL("hep", buf);
+  
+  mbed_trace_config_set(TRACE_ACTIVE_LEVEL_DEBUG|TRACE_MODE_COLOR);
+  mbed_tracef(TRACE_LEVEL_ERROR, "mygr", "hep");
+  STRCMP_EQUAL("\x1b[31m[ERR ][mygr]: hep\x1b[0m", buf);
+  
+}
+
+TEST(trace, active_level_debug)
+{
+  mbed_trace_config_set(TRACE_ACTIVE_LEVEL_DEBUG);
+  
+  mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "hep");
+  STRCMP_EQUAL("[DBG ][mygr]: hep", buf);
+  
+  mbed_tracef(TRACE_LEVEL_INFO, "mygr", "test");
+  STRCMP_EQUAL("[INFO][mygr]: test", buf);
+  
+  mbed_tracef(TRACE_LEVEL_WARN, "mygr", "hups");
+  STRCMP_EQUAL("[WARN][mygr]: hups", buf);
+  
+  mbed_tracef(TRACE_LEVEL_ERROR, "mygr", "o'ou");
+  STRCMP_EQUAL("[ERR ][mygr]: o'ou", buf);
+}
+
+TEST(trace, active_level_info)
+{
+  buf[0] = 0;
+  mbed_trace_config_set(TRACE_ACTIVE_LEVEL_INFO);
+  
+  mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "hep");
+  STRCMP_EQUAL("", mbed_trace_last());
+  
+  mbed_tracef(TRACE_LEVEL_INFO, "mygr", "test");
+  STRCMP_EQUAL("[INFO][mygr]: test", buf);
+  
+  mbed_tracef(TRACE_LEVEL_WARN, "mygr", "hups");
+  STRCMP_EQUAL("[WARN][mygr]: hups", buf);
+  
+  mbed_tracef(TRACE_LEVEL_ERROR, "mygr", "o'ou");
+  STRCMP_EQUAL("[ERR ][mygr]: o'ou", buf);
+}
+
+TEST(trace, active_level_warn)
+{
+  mbed_trace_config_set(TRACE_ACTIVE_LEVEL_WARN);
+  
+  mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "hep");
+  STRCMP_EQUAL("", mbed_trace_last());
+  
+  mbed_tracef(TRACE_LEVEL_INFO, "mygr", "test");
+  STRCMP_EQUAL("", mbed_trace_last());
+  
+  mbed_tracef(TRACE_LEVEL_WARN, "mygr", "hups");
+  STRCMP_EQUAL("[WARN][mygr]: hups", buf);
+  
+  mbed_tracef(TRACE_LEVEL_ERROR, "mygr", "o'ou");
+  STRCMP_EQUAL("[ERR ][mygr]: o'ou", buf);
+}
+
+TEST(trace, active_level_error)
+{
+  mbed_trace_config_set(TRACE_ACTIVE_LEVEL_ERROR);
+  
+  mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "hep");
+  STRCMP_EQUAL("", mbed_trace_last());
+  
+  mbed_tracef(TRACE_LEVEL_INFO, "mygr", "test");
+  STRCMP_EQUAL("", mbed_trace_last());
+  
+  mbed_tracef(TRACE_LEVEL_WARN, "mygr", "hups");
+  STRCMP_EQUAL("", mbed_trace_last());
+  
+  mbed_tracef(TRACE_LEVEL_ERROR, "mygr", "o'ou");
+  STRCMP_EQUAL("[ERR ][mygr]: o'ou", buf);
+}
+TEST(trace, active_level_none)
+{
+  mbed_trace_config_set(TRACE_ACTIVE_LEVEL_NONE);
+  
+  mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "hep");
+  STRCMP_EQUAL("", mbed_trace_last());
+  
+  mbed_tracef(TRACE_LEVEL_INFO, "mygr", "test");
+  STRCMP_EQUAL("", mbed_trace_last());
+  
+  mbed_tracef(TRACE_LEVEL_WARN, "mygr", "hups");
+  STRCMP_EQUAL("", mbed_trace_last());
+  
+  mbed_tracef(TRACE_LEVEL_ERROR, "mygr", "o'ou");
+  STRCMP_EQUAL("", mbed_trace_last());
+}
+
+TEST(trace, active_level_all_1)
+{
+  mbed_trace_config_set(TRACE_ACTIVE_LEVEL_ALL);
+  mbed_trace_exclude_filters_set((char*)"mygr");
+  
+  mbed_tracef(TRACE_LEVEL_DEBUG, "mygu", "hep");
+  STRCMP_EQUAL("[DBG ][mygu]: hep", buf);
+  
+  mbed_tracef(TRACE_LEVEL_INFO, "mygr", "test");
+  STRCMP_EQUAL("", mbed_trace_last());
+}
+TEST(trace, active_level_all_2)
+{
+  mbed_trace_config_set(TRACE_ACTIVE_LEVEL_ALL);
+  mbed_trace_exclude_filters_set((char*)"mygr,mygu");
+  
+  mbed_tracef(TRACE_LEVEL_DEBUG, "mygu", "hep");
+  STRCMP_EQUAL("", mbed_trace_last());
+  
+  mbed_tracef(TRACE_LEVEL_INFO, "mygr", "test");
+  STRCMP_EQUAL("", mbed_trace_last());
+}
+TEST(trace, active_level_all_3)
+{
+  mbed_trace_config_set(TRACE_ACTIVE_LEVEL_ALL);
+  mbed_trace_include_filters_set((char*)"mygr");
+  
+  mbed_tracef(TRACE_LEVEL_DEBUG, "mygu", "hep");
+  STRCMP_EQUAL("", mbed_trace_last());
+  
+  mbed_tracef(TRACE_LEVEL_INFO, "mygr", "test");
+  STRCMP_EQUAL("[INFO][mygr]: test", buf);
+}
+
+TEST(trace, active_level_all_array)
+{
+  mbed_trace_config_set(TRACE_ACTIVE_LEVEL_ALL);
+  
+  uint8_t arr[] = {0x01, 0x02, 0x03};
+  mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "my addr: %s", mbed_trace_array(arr, 3));
+  STRCMP_EQUAL("[DBG ][mygr]: my addr: 01:02:03", buf);
+}
+
+
+size_t time_length;
+char trace_prefix_str[] = "[<TIME>]";
+char* trace_prefix(size_t length){ 
+  time_length = length;
+  return trace_prefix_str; 
+}
+TEST(trace, prefix)
+{
+  mbed_trace_config_set(TRACE_ACTIVE_LEVEL_ALL);
+  mbed_trace_prefix_function_set( &trace_prefix );
+  mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "test %d %d", 1, 2);
+  STRCMP_EQUAL("[<TIME>][DBG ][mygr]: test 1 2", buf);
+  //TEST_ASSERT_EQUAL_INT(4, time_length);
+  
+  mbed_trace_config_set(TRACE_ACTIVE_LEVEL_ALL|TRACE_MODE_PLAIN);
+  mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "test");
+  STRCMP_EQUAL("test", buf);
+  
+  mbed_trace_config_set(TRACE_ACTIVE_LEVEL_ALL|TRACE_MODE_COLOR);
+  mbed_tracef(TRACE_LEVEL_ERROR, "mygr", "test");
+  STRCMP_EQUAL("\x1b[31m[<TIME>][ERR ][mygr]: test\x1b[0m", buf);
+}
+char trace_suffix_str[] = "[END]";
+char* trace_suffix()
+{
+  return trace_suffix_str;
+}
+TEST(trace, suffix)
+{
+  mbed_trace_config_set(TRACE_ACTIVE_LEVEL_ALL);
+  mbed_trace_prefix_function_set( &trace_prefix );
+  mbed_trace_suffix_function_set( &trace_suffix );
+  mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "test");
+  STRCMP_EQUAL("[<TIME>][DBG ][mygr]: test[END]", buf);
+}
+TEST(trace, formatting)
+{
+    mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "hello %d %d %.1f", 12, 13, 5.5);
+    STRCMP_EQUAL("hello 12 13 5.5", buf);
+    
+    mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "hello %d %d %d %d %d %d", 12, 13, 5, 6, 8, 9);
+    STRCMP_EQUAL("hello 12 13 5 6 8 9", buf);
+    
+    mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "HOH %d HAH %d %d %d %d %d", 12, 13, 5, 6, 8, 9);
+    STRCMP_EQUAL("HOH 12 HAH 13 5 6 8 9", buf);
+}
+TEST(trace, filters_control)
+{
+    mbed_trace_include_filters_set((char*)"hello");
+    STRCMP_EQUAL("hello", mbed_trace_include_filters_get());
+    
+    mbed_trace_include_filters_set(0);
+    STRCMP_EQUAL("", mbed_trace_include_filters_get());
+    
+    mbed_trace_exclude_filters_set((char*)"hello");
+    STRCMP_EQUAL("hello", mbed_trace_exclude_filters_get());
+    
+    mbed_trace_exclude_filters_set(0);
+    STRCMP_EQUAL("", mbed_trace_exclude_filters_get());
+}
+TEST(trace, no_printer)
+{
+    mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "hello");
+    STRCMP_EQUAL("hello", buf);
+    
+    mbed_trace_print_function_set(NULL);
+    mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "this shoudnt be printed because printer is missing");
+    STRCMP_EQUAL("hello", buf);
+}
+TEST(trace, uninitialized)
+{
+    mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "hello");
+    STRCMP_EQUAL("hello", buf);
+
+    mbed_trace_free();
+
+    mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "this shoudnt be printed because mtrace is not initialized");
+    STRCMP_EQUAL("hello", buf);
+}
+