Test.cpp

00001 /*
00002  * Copyright (c) 2014 ARM. All rights reserved.
00003  */
00004 /**
00005  * \file \test_libTrace\Test.c
00006  *
00007  * \brief Unit tests for mbed_trace
00008  */
00009 #include <string.h>
00010 #include <stdlib.h>
00011 #include <stdint.h>
00012 
00013 #include "mbed-cpputest/CppUTest/TestHarness.h"
00014 #include "mbed-cpputest/CppUTest/SimpleString.h"
00015 #include "mbed-cpputest/CppUTest/CommandLineTestRunner.h"
00016 
00017 #define MBED_CONF_MBED_TRACE_ENABLE 1
00018 #define MBED_CONF_MBED_TRACE_FEA_IPV6 1
00019 
00020 #include "mbed-trace/mbed_trace.h"
00021 #include "ip6tos_stub.h"
00022 
00023 int main(int ac, char **av)
00024 {
00025     return CommandLineTestRunner::RunAllTests(ac, av);
00026 }
00027 
00028 static int mutex_wait_count = 0;
00029 static int mutex_release_count = 0;
00030 static bool check_mutex_lock_status = true;
00031 void my_mutex_wait()
00032 {
00033   mutex_wait_count++;
00034 }
00035 void my_mutex_release()
00036 {
00037   mutex_release_count++;
00038 }
00039 
00040 char buf[1024];
00041 #include <stdio.h>
00042 void myprint(const char* str)
00043 {
00044   if ( check_mutex_lock_status ) {
00045       CHECK( (mutex_wait_count - mutex_release_count) > 0 );
00046   }
00047   strcpy(buf, str);
00048 }
00049 TEST_GROUP(trace)
00050 {
00051   void setup()
00052   {
00053 
00054     mbed_trace_init();
00055     mbed_trace_config_set(TRACE_MODE_PLAIN|TRACE_ACTIVE_LEVEL_ALL);
00056     mbed_trace_print_function_set( myprint );
00057     mbed_trace_mutex_wait_function_set( my_mutex_wait );
00058     mbed_trace_mutex_release_function_set( my_mutex_release );
00059   }
00060   void teardown()
00061   {
00062     CHECK(mutex_wait_count == mutex_release_count); // Check the mutex count with every test
00063     mbed_trace_free();
00064   }
00065 };
00066 
00067 /* Unity test code starts */
00068 TEST(trace, MutexNotSet)
00069 {
00070   mbed_trace_mutex_wait_function_set( 0 );
00071   mbed_trace_mutex_release_function_set( 0 );
00072   int mutex_call_count_at_entry = mutex_wait_count;
00073   check_mutex_lock_status = false;
00074 
00075   char expectedStr[] = "Hello hello!";
00076   mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "Hello hello!");
00077   STRCMP_EQUAL(expectedStr, buf);
00078 
00079   CHECK( mutex_call_count_at_entry == mutex_wait_count );
00080   CHECK( mutex_call_count_at_entry == mutex_release_count );
00081 
00082   mbed_trace_mutex_wait_function_set( my_mutex_wait );
00083   mbed_trace_mutex_release_function_set( my_mutex_release );
00084   check_mutex_lock_status = true;
00085 }
00086 
00087 TEST(trace, Array)
00088 {
00089   unsigned char longStr[200] = {0x66};
00090   for(int i=0;i<200;i++) {longStr[i] = 0x66; }
00091   mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "%s", mbed_trace_array(longStr, 200) );
00092 }
00093 
00094 TEST(trace, LongString)
00095 {
00096   char longStr[1000] = {0x36};
00097   for(int i=0;i<999;i++) {longStr[i] = 0x36; }
00098   mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "%s", longStr );
00099 }
00100 
00101 TEST(trace, TooLong)
00102 {
00103   #define TOO_LONG_SIZE 9400
00104   #define TRACE_LINE_SIZE 1024
00105   char longStr[TOO_LONG_SIZE] = {0};
00106   for(int i=0;i<TOO_LONG_SIZE;i++) { longStr[i] = 0x36; }  
00107   
00108   mbed_trace_config_set(TRACE_ACTIVE_LEVEL_ALL);
00109   mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "%s", longStr );
00110   
00111   char shouldStr[TRACE_LINE_SIZE] = "[DBG ][mygr]: ";
00112   for(int i=14;i<TRACE_LINE_SIZE;i++) { shouldStr[i] = 0x36; }
00113   shouldStr[TRACE_LINE_SIZE-1] = 0;
00114   STRCMP_EQUAL(shouldStr, buf);
00115 }
00116 
00117 TEST(trace, BufferResize)
00118 {
00119     uint8_t arr[20] = {0};
00120     memset(arr, '0', 20);
00121 
00122     mbed_trace_buffer_sizes(0, 10);
00123     STRCMP_EQUAL("30:30:30*", mbed_trace_array(arr, 20));
00124     mbed_trace_buffer_sizes(0, 15);
00125     STRCMP_EQUAL("30:30:30:30*", mbed_trace_array(arr, 20));
00126     mbed_trace_buffer_sizes(0, 15);
00127     STRCMP_EQUAL("30:30:30:30", mbed_trace_array(arr, 4));
00128 
00129     const char * expectedStr = "0123456789";
00130     mbed_trace_buffer_sizes(11, 0);
00131     mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "01234567890123456789");
00132     STRCMP_EQUAL(expectedStr, buf);
00133     expectedStr = "012345678901234";
00134     mbed_trace_buffer_sizes(16, 0);
00135     mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "01234567890123456789");
00136     STRCMP_EQUAL(expectedStr, buf);
00137     expectedStr = "012345678901234";
00138     mbed_trace_buffer_sizes(16, 0);
00139     mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "012345678901234");
00140     STRCMP_EQUAL(expectedStr, buf);
00141 }
00142 
00143 TEST(trace, PreInitConfiguration)
00144 {
00145     uint8_t arr[20] = {0};
00146     memset(arr, '0', 20);
00147 
00148     mbed_trace_free();
00149     mbed_trace_config_set(TRACE_MODE_PLAIN|TRACE_ACTIVE_LEVEL_ALL);
00150     mbed_trace_print_function_set( myprint );
00151     mbed_trace_buffer_sizes(11, 10);
00152     mbed_trace_mutex_wait_function_set( my_mutex_wait );
00153     mbed_trace_mutex_release_function_set( my_mutex_release );
00154     mbed_trace_init();
00155 
00156     STRCMP_EQUAL("30:30:30*", mbed_trace_array(arr, 20));
00157 
00158     const char * expectedStr = "0123456789";
00159     mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "01234567890123456789");
00160     STRCMP_EQUAL(expectedStr, buf);
00161 }
00162 
00163 #if YOTTA_CFG_MBED_TRACE_FEA_IPV6 == 1
00164 ip6tos_stub_def_t ip6tos_stub; // extern variable
00165 
00166 TEST(trace, ipv6)
00167 {
00168     uint8_t prefix[] = { 0x14, 0x6e, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00 };
00169     int prefix_len = 64;
00170 
00171     char expected_str1[] = "146e:a00::/64";
00172     ip6tos_stub.output_string = "146e:a00::/64";
00173     char *str = mbed_trace_ipv6_prefix(prefix, prefix_len);
00174     CHECK(memcmp(ip6tos_stub.input_array, prefix, 8) == 0);
00175     STRCMP_EQUAL(expected_str1, str);
00176     mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "flush buffers and locks");
00177 
00178     char expected_str2[] = "::/0";
00179     ip6tos_stub.output_string = "::/0";
00180     str = mbed_trace_ipv6_prefix(NULL, 0);
00181     STRCMP_EQUAL(expected_str2, str);
00182     mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "flush buffers and locks");
00183 
00184     char expected_str3[] = "<err>";
00185     str = mbed_trace_ipv6_prefix(NULL, 1);
00186     STRCMP_EQUAL(expected_str3, str);
00187     mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "flush buffers and locks");
00188 
00189     char expected_str4[] = "<err>";
00190     str = mbed_trace_ipv6_prefix(prefix, 200);
00191     STRCMP_EQUAL(expected_str4, str);
00192     mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "flush buffers and locks");
00193 
00194     char expected_str5[] = "";
00195     ip6tos_stub.output_string = "0123456789012345678901234567890123456789";
00196     str = mbed_trace_ipv6_prefix(prefix, 64); // Fill the tmp_data buffer
00197     str = mbed_trace_ipv6_prefix(prefix, 64);
00198     str = mbed_trace_ipv6_prefix(prefix, 64);
00199     str = mbed_trace_ipv6_prefix(prefix, 64);
00200     STRCMP_EQUAL(expected_str5, str);
00201     mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "flush buffers and locks");
00202 }
00203 
00204 TEST(trace, active_level_all_ipv6)
00205 {
00206   mbed_trace_config_set(TRACE_ACTIVE_LEVEL_ALL);
00207   
00208   uint8_t arr[] = { 0x20, 0x01, 0xd, 0xb8, 0,0,0,0,0,1,0,0,0,0,0,1 };
00209   ip6tos_stub.output_string = "2001:db8::1:0:0:1";
00210   mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "my addr: %s", mbed_trace_ipv6(arr));
00211   CHECK(memcmp(ip6tos_stub.input_array, arr, 16) == 0);
00212   STRCMP_EQUAL("[DBG ][mygr]: my addr: 2001:db8::1:0:0:1", buf);
00213 }
00214 #endif //YOTTA_CFG_MBED_TRACE_FEA_IPV6
00215 
00216 TEST(trace, config_change)
00217 {
00218     mbed_trace_config_set(TRACE_MODE_COLOR|TRACE_ACTIVE_LEVEL_ALL);
00219     CHECK(mbed_trace_config_get() == TRACE_MODE_COLOR|TRACE_ACTIVE_LEVEL_ALL);
00220     mbed_trace_config_set(TRACE_MODE_PLAIN|TRACE_ACTIVE_LEVEL_NONE);
00221     CHECK(mbed_trace_config_get() == TRACE_MODE_PLAIN|TRACE_ACTIVE_LEVEL_NONE);
00222     mbed_trace_config_set(TRACE_MODE_PLAIN|TRACE_ACTIVE_LEVEL_ALL);
00223     CHECK(mbed_trace_config_get() == TRACE_MODE_PLAIN|TRACE_ACTIVE_LEVEL_ALL);
00224 }
00225 
00226 TEST(trace, active_level_all_color)
00227 {
00228   mbed_trace_config_set(TRACE_MODE_COLOR|TRACE_ACTIVE_LEVEL_ALL);
00229   mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "hello");
00230   STRCMP_EQUAL("\x1b[90m[DBG ][mygr]: hello\x1b[0m", buf);
00231   mbed_tracef(TRACE_LEVEL_INFO, "mygr", "to one");
00232   STRCMP_EQUAL("\x1b[39m[INFO][mygr]: to one\x1b[0m", buf);
00233   mbed_tracef(TRACE_LEVEL_WARN, "mygr", "and all");
00234   STRCMP_EQUAL("\x1b[33m[WARN][mygr]: and all\x1b[0m", buf);
00235   mbed_tracef(TRACE_LEVEL_ERROR, "mygr", "even you");
00236   STRCMP_EQUAL("\x1b[31m[ERR ][mygr]: even you\x1b[0m", buf);
00237 }
00238 
00239 TEST(trace, change_levels)
00240 {
00241   mbed_trace_config_set(TRACE_ACTIVE_LEVEL_DEBUG);
00242   mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "hep");
00243   STRCMP_EQUAL("[DBG ][mygr]: hep", buf);
00244   
00245   mbed_trace_config_set(TRACE_ACTIVE_LEVEL_DEBUG|TRACE_MODE_PLAIN);
00246   mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "hep");
00247   STRCMP_EQUAL("hep", buf);
00248   
00249   mbed_trace_config_set(TRACE_ACTIVE_LEVEL_DEBUG|TRACE_MODE_COLOR);
00250   mbed_tracef(TRACE_LEVEL_ERROR, "mygr", "hep");
00251   STRCMP_EQUAL("\x1b[31m[ERR ][mygr]: hep\x1b[0m", buf);
00252   
00253 }
00254 
00255 TEST(trace, active_level_debug)
00256 {
00257   mbed_trace_config_set(TRACE_ACTIVE_LEVEL_DEBUG);
00258   
00259   mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "hep");
00260   STRCMP_EQUAL("[DBG ][mygr]: hep", buf);
00261   
00262   mbed_tracef(TRACE_LEVEL_INFO, "mygr", "test");
00263   STRCMP_EQUAL("[INFO][mygr]: test", buf);
00264   
00265   mbed_tracef(TRACE_LEVEL_WARN, "mygr", "hups");
00266   STRCMP_EQUAL("[WARN][mygr]: hups", buf);
00267   
00268   mbed_tracef(TRACE_LEVEL_ERROR, "mygr", "o'ou");
00269   STRCMP_EQUAL("[ERR ][mygr]: o'ou", buf);
00270 }
00271 
00272 TEST(trace, active_level_info)
00273 {
00274   buf[0] = 0;
00275   mbed_trace_config_set(TRACE_ACTIVE_LEVEL_INFO);
00276   
00277   mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "hep");
00278   STRCMP_EQUAL("", mbed_trace_last());
00279   
00280   mbed_tracef(TRACE_LEVEL_INFO, "mygr", "test");
00281   STRCMP_EQUAL("[INFO][mygr]: test", buf);
00282   
00283   mbed_tracef(TRACE_LEVEL_WARN, "mygr", "hups");
00284   STRCMP_EQUAL("[WARN][mygr]: hups", buf);
00285   
00286   mbed_tracef(TRACE_LEVEL_ERROR, "mygr", "o'ou");
00287   STRCMP_EQUAL("[ERR ][mygr]: o'ou", buf);
00288 }
00289 
00290 TEST(trace, active_level_warn)
00291 {
00292   mbed_trace_config_set(TRACE_ACTIVE_LEVEL_WARN);
00293   
00294   mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "hep");
00295   STRCMP_EQUAL("", mbed_trace_last());
00296   
00297   mbed_tracef(TRACE_LEVEL_INFO, "mygr", "test");
00298   STRCMP_EQUAL("", mbed_trace_last());
00299   
00300   mbed_tracef(TRACE_LEVEL_WARN, "mygr", "hups");
00301   STRCMP_EQUAL("[WARN][mygr]: hups", buf);
00302   
00303   mbed_tracef(TRACE_LEVEL_ERROR, "mygr", "o'ou");
00304   STRCMP_EQUAL("[ERR ][mygr]: o'ou", buf);
00305 }
00306 
00307 TEST(trace, active_level_error)
00308 {
00309   mbed_trace_config_set(TRACE_ACTIVE_LEVEL_ERROR);
00310   
00311   mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "hep");
00312   STRCMP_EQUAL("", mbed_trace_last());
00313   
00314   mbed_tracef(TRACE_LEVEL_INFO, "mygr", "test");
00315   STRCMP_EQUAL("", mbed_trace_last());
00316   
00317   mbed_tracef(TRACE_LEVEL_WARN, "mygr", "hups");
00318   STRCMP_EQUAL("", mbed_trace_last());
00319   
00320   mbed_tracef(TRACE_LEVEL_ERROR, "mygr", "o'ou");
00321   STRCMP_EQUAL("[ERR ][mygr]: o'ou", buf);
00322 }
00323 TEST(trace, active_level_none)
00324 {
00325   mbed_trace_config_set(TRACE_ACTIVE_LEVEL_NONE);
00326   
00327   mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "hep");
00328   STRCMP_EQUAL("", mbed_trace_last());
00329   
00330   mbed_tracef(TRACE_LEVEL_INFO, "mygr", "test");
00331   STRCMP_EQUAL("", mbed_trace_last());
00332   
00333   mbed_tracef(TRACE_LEVEL_WARN, "mygr", "hups");
00334   STRCMP_EQUAL("", mbed_trace_last());
00335   
00336   mbed_tracef(TRACE_LEVEL_ERROR, "mygr", "o'ou");
00337   STRCMP_EQUAL("", mbed_trace_last());
00338 }
00339 
00340 TEST(trace, active_level_all_1)
00341 {
00342   mbed_trace_config_set(TRACE_ACTIVE_LEVEL_ALL);
00343   mbed_trace_exclude_filters_set((char*)"mygr");
00344   
00345   mbed_tracef(TRACE_LEVEL_DEBUG, "mygu", "hep");
00346   STRCMP_EQUAL("[DBG ][mygu]: hep", buf);
00347   
00348   mbed_tracef(TRACE_LEVEL_INFO, "mygr", "test");
00349   STRCMP_EQUAL("", mbed_trace_last());
00350 }
00351 TEST(trace, active_level_all_2)
00352 {
00353   mbed_trace_config_set(TRACE_ACTIVE_LEVEL_ALL);
00354   mbed_trace_exclude_filters_set((char*)"mygr,mygu");
00355   
00356   mbed_tracef(TRACE_LEVEL_DEBUG, "mygu", "hep");
00357   STRCMP_EQUAL("", mbed_trace_last());
00358   
00359   mbed_tracef(TRACE_LEVEL_INFO, "mygr", "test");
00360   STRCMP_EQUAL("", mbed_trace_last());
00361 }
00362 TEST(trace, active_level_all_3)
00363 {
00364   mbed_trace_config_set(TRACE_ACTIVE_LEVEL_ALL);
00365   mbed_trace_include_filters_set((char*)"mygr");
00366   
00367   mbed_tracef(TRACE_LEVEL_DEBUG, "mygu", "hep");
00368   STRCMP_EQUAL("", mbed_trace_last());
00369   
00370   mbed_tracef(TRACE_LEVEL_INFO, "mygr", "test");
00371   STRCMP_EQUAL("[INFO][mygr]: test", buf);
00372 }
00373 
00374 TEST(trace, active_level_all_array)
00375 {
00376   mbed_trace_config_set(TRACE_ACTIVE_LEVEL_ALL);
00377   
00378   uint8_t arr[] = {0x01, 0x02, 0x03};
00379   mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "my addr: %s", mbed_trace_array(arr, 3));
00380   STRCMP_EQUAL("[DBG ][mygr]: my addr: 01:02:03", buf);
00381 }
00382 
00383 
00384 size_t time_length;
00385 char trace_prefix_str[] = "[<TIME>]";
00386 char* trace_prefix(size_t length){ 
00387   time_length = length;
00388   return trace_prefix_str; 
00389 }
00390 TEST(trace, prefix)
00391 {
00392   mbed_trace_config_set(TRACE_ACTIVE_LEVEL_ALL);
00393   mbed_trace_prefix_function_set( &trace_prefix );
00394   mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "test %d %d", 1, 2);
00395   STRCMP_EQUAL("[<TIME>][DBG ][mygr]: test 1 2", buf);
00396   //TEST_ASSERT_EQUAL_INT(4, time_length);
00397   
00398   mbed_trace_config_set(TRACE_ACTIVE_LEVEL_ALL|TRACE_MODE_PLAIN);
00399   mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "test");
00400   STRCMP_EQUAL("test", buf);
00401   
00402   mbed_trace_config_set(TRACE_ACTIVE_LEVEL_ALL|TRACE_MODE_COLOR);
00403   mbed_tracef(TRACE_LEVEL_ERROR, "mygr", "test");
00404   STRCMP_EQUAL("\x1b[31m[<TIME>][ERR ][mygr]: test\x1b[0m", buf);
00405 }
00406 char trace_suffix_str[] = "[END]";
00407 char* trace_suffix()
00408 {
00409   return trace_suffix_str;
00410 }
00411 TEST(trace, suffix)
00412 {
00413   mbed_trace_config_set(TRACE_ACTIVE_LEVEL_ALL);
00414   mbed_trace_prefix_function_set( &trace_prefix );
00415   mbed_trace_suffix_function_set( &trace_suffix );
00416   mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "test");
00417   STRCMP_EQUAL("[<TIME>][DBG ][mygr]: test[END]", buf);
00418 }
00419 TEST(trace, formatting)
00420 {
00421     mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "hello %d %d %.1f", 12, 13, 5.5);
00422     STRCMP_EQUAL("hello 12 13 5.5", buf);
00423     
00424     mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "hello %d %d %d %d %d %d", 12, 13, 5, 6, 8, 9);
00425     STRCMP_EQUAL("hello 12 13 5 6 8 9", buf);
00426     
00427     mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "HOH %d HAH %d %d %d %d %d", 12, 13, 5, 6, 8, 9);
00428     STRCMP_EQUAL("HOH 12 HAH 13 5 6 8 9", buf);
00429 }
00430 TEST(trace, filters_control)
00431 {
00432     mbed_trace_include_filters_set((char*)"hello");
00433     STRCMP_EQUAL("hello", mbed_trace_include_filters_get());
00434     
00435     mbed_trace_include_filters_set(0);
00436     STRCMP_EQUAL("", mbed_trace_include_filters_get());
00437     
00438     mbed_trace_exclude_filters_set((char*)"hello");
00439     STRCMP_EQUAL("hello", mbed_trace_exclude_filters_get());
00440     
00441     mbed_trace_exclude_filters_set(0);
00442     STRCMP_EQUAL("", mbed_trace_exclude_filters_get());
00443 }
00444 TEST(trace, no_printer)
00445 {
00446     mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "hello");
00447     STRCMP_EQUAL("hello", buf);
00448     
00449     mbed_trace_print_function_set(NULL);
00450     mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "this shoudnt be printed because printer is missing");
00451     STRCMP_EQUAL("hello", buf);
00452 }
00453 TEST(trace, uninitialized)
00454 {
00455     mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "hello");
00456     STRCMP_EQUAL("hello", buf);
00457 
00458     mbed_trace_free();
00459 
00460     mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "this shoudnt be printed because mtrace is not initialized");
00461     STRCMP_EQUAL("hello", buf);
00462 }
00463