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, Null0Array)
00095 {
00096   static const unsigned char array[2] = { 0x23, 0x45 };
00097   mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "%s", mbed_trace_array(array, 2));
00098   STRCMP_EQUAL("23:45", buf);
00099   mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "%s", mbed_trace_array(array, 0));
00100   STRCMP_EQUAL("", buf);
00101   mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "%s", mbed_trace_array(NULL, 0));
00102   STRCMP_EQUAL("", buf);
00103   mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "%s", mbed_trace_array(NULL, 2));
00104   STRCMP_EQUAL("<null>", buf);
00105 }
00106 
00107 TEST(trace, LongString)
00108 {
00109   char longStr[1000] = {0x36};
00110   for(int i=0;i<999;i++) {longStr[i] = 0x36; }
00111   mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "%s", longStr );
00112 }
00113 
00114 TEST(trace, TooLong)
00115 {
00116   #define TOO_LONG_SIZE 9400
00117   #define TRACE_LINE_SIZE 1024
00118   char longStr[TOO_LONG_SIZE] = {0};
00119   for(int i=0;i<TOO_LONG_SIZE;i++) { longStr[i] = 0x36; }  
00120   
00121   mbed_trace_config_set(TRACE_ACTIVE_LEVEL_ALL);
00122   mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "%s", longStr );
00123   
00124   char shouldStr[TRACE_LINE_SIZE] = "[DBG ][mygr]: ";
00125   for(int i=14;i<TRACE_LINE_SIZE;i++) { shouldStr[i] = 0x36; }
00126   shouldStr[TRACE_LINE_SIZE-1] = 0;
00127   STRCMP_EQUAL(shouldStr, buf);
00128 }
00129 
00130 TEST(trace, BufferResize)
00131 {
00132     uint8_t arr[20] = {0};
00133     memset(arr, '0', 20);
00134 
00135     mbed_trace_buffer_sizes(0, 10);
00136     STRCMP_EQUAL("30:30:30*", mbed_trace_array(arr, 20));
00137     mbed_trace_buffer_sizes(0, 15);
00138     STRCMP_EQUAL("30:30:30:30*", mbed_trace_array(arr, 20));
00139     mbed_trace_buffer_sizes(0, 15);
00140     STRCMP_EQUAL("30:30:30:30", mbed_trace_array(arr, 4));
00141 
00142     const char * expectedStr = "0123456789";
00143     mbed_trace_buffer_sizes(11, 0);
00144     mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "01234567890123456789");
00145     STRCMP_EQUAL(expectedStr, buf);
00146     expectedStr = "012345678901234";
00147     mbed_trace_buffer_sizes(16, 0);
00148     mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "01234567890123456789");
00149     STRCMP_EQUAL(expectedStr, buf);
00150     expectedStr = "012345678901234";
00151     mbed_trace_buffer_sizes(16, 0);
00152     mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "012345678901234");
00153     STRCMP_EQUAL(expectedStr, buf);
00154 }
00155 
00156 TEST(trace, PreInitConfiguration)
00157 {
00158     uint8_t arr[20] = {0};
00159     memset(arr, '0', 20);
00160 
00161     mbed_trace_free();
00162     mbed_trace_config_set(TRACE_MODE_PLAIN|TRACE_ACTIVE_LEVEL_ALL);
00163     mbed_trace_print_function_set( myprint );
00164     mbed_trace_buffer_sizes(11, 10);
00165     mbed_trace_mutex_wait_function_set( my_mutex_wait );
00166     mbed_trace_mutex_release_function_set( my_mutex_release );
00167     mbed_trace_init();
00168 
00169     STRCMP_EQUAL("30:30:30*", mbed_trace_array(arr, 20));
00170 
00171     const char * expectedStr = "0123456789";
00172     mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "01234567890123456789");
00173     STRCMP_EQUAL(expectedStr, buf);
00174 }
00175 
00176 #if YOTTA_CFG_MBED_TRACE_FEA_IPV6 == 1
00177 ip6tos_stub_def_t ip6tos_stub; // extern variable
00178 
00179 TEST(trace, ipv6)
00180 {
00181     uint8_t prefix[] = { 0x14, 0x6e, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00 };
00182     int prefix_len = 64;
00183 
00184     char expected_str1[] = "146e:a00::/64";
00185     ip6tos_stub.output_string = "146e:a00::/64";
00186     char *str = mbed_trace_ipv6_prefix(prefix, prefix_len);
00187     CHECK(memcmp(ip6tos_stub.input_array, prefix, 8) == 0);
00188     STRCMP_EQUAL(expected_str1, str);
00189     mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "flush buffers and locks");
00190 
00191     char expected_str2[] = "::/0";
00192     ip6tos_stub.output_string = "::/0";
00193     str = mbed_trace_ipv6_prefix(NULL, 0);
00194     STRCMP_EQUAL(expected_str2, str);
00195     mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "flush buffers and locks");
00196 
00197     char expected_str3[] = "<err>";
00198     str = mbed_trace_ipv6_prefix(NULL, 1);
00199     STRCMP_EQUAL(expected_str3, str);
00200     mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "flush buffers and locks");
00201 
00202     char expected_str4[] = "<err>";
00203     str = mbed_trace_ipv6_prefix(prefix, 200);
00204     STRCMP_EQUAL(expected_str4, str);
00205     mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "flush buffers and locks");
00206 
00207     char expected_str5[] = "";
00208     ip6tos_stub.output_string = "0123456789012345678901234567890123456789";
00209     str = mbed_trace_ipv6_prefix(prefix, 64); // Fill the tmp_data buffer
00210     str = mbed_trace_ipv6_prefix(prefix, 64);
00211     str = mbed_trace_ipv6_prefix(prefix, 64);
00212     str = mbed_trace_ipv6_prefix(prefix, 64);
00213     STRCMP_EQUAL(expected_str5, str);
00214     mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "flush buffers and locks");
00215 }
00216 
00217 TEST(trace, active_level_all_ipv6)
00218 {
00219   mbed_trace_config_set(TRACE_ACTIVE_LEVEL_ALL);
00220   
00221   uint8_t arr[] = { 0x20, 0x01, 0xd, 0xb8, 0,0,0,0,0,1,0,0,0,0,0,1 };
00222   ip6tos_stub.output_string = "2001:db8::1:0:0:1";
00223   mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "my addr: %s", mbed_trace_ipv6(arr));
00224   CHECK(memcmp(ip6tos_stub.input_array, arr, 16) == 0);
00225   STRCMP_EQUAL("[DBG ][mygr]: my addr: 2001:db8::1:0:0:1", buf);
00226 }
00227 #endif //YOTTA_CFG_MBED_TRACE_FEA_IPV6
00228 
00229 TEST(trace, config_change)
00230 {
00231     mbed_trace_config_set(TRACE_MODE_COLOR|TRACE_ACTIVE_LEVEL_ALL);
00232     CHECK(mbed_trace_config_get() == TRACE_MODE_COLOR|TRACE_ACTIVE_LEVEL_ALL);
00233     mbed_trace_config_set(TRACE_MODE_PLAIN|TRACE_ACTIVE_LEVEL_NONE);
00234     CHECK(mbed_trace_config_get() == TRACE_MODE_PLAIN|TRACE_ACTIVE_LEVEL_NONE);
00235     mbed_trace_config_set(TRACE_MODE_PLAIN|TRACE_ACTIVE_LEVEL_ALL);
00236     CHECK(mbed_trace_config_get() == TRACE_MODE_PLAIN|TRACE_ACTIVE_LEVEL_ALL);
00237 }
00238 
00239 TEST(trace, active_level_all_color)
00240 {
00241   mbed_trace_config_set(TRACE_MODE_COLOR|TRACE_ACTIVE_LEVEL_ALL);
00242   mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "hello");
00243   STRCMP_EQUAL("\x1b[90m[DBG ][mygr]: hello\x1b[0m", buf);
00244   mbed_tracef(TRACE_LEVEL_INFO, "mygr", "to one");
00245   STRCMP_EQUAL("\x1b[39m[INFO][mygr]: to one\x1b[0m", buf);
00246   mbed_tracef(TRACE_LEVEL_WARN, "mygr", "and all");
00247   STRCMP_EQUAL("\x1b[33m[WARN][mygr]: and all\x1b[0m", buf);
00248   mbed_tracef(TRACE_LEVEL_ERROR, "mygr", "even you");
00249   STRCMP_EQUAL("\x1b[31m[ERR ][mygr]: even you\x1b[0m", buf);
00250 }
00251 
00252 TEST(trace, change_levels)
00253 {
00254   mbed_trace_config_set(TRACE_ACTIVE_LEVEL_DEBUG);
00255   mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "hep");
00256   STRCMP_EQUAL("[DBG ][mygr]: hep", buf);
00257   
00258   mbed_trace_config_set(TRACE_ACTIVE_LEVEL_DEBUG|TRACE_MODE_PLAIN);
00259   mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "hep");
00260   STRCMP_EQUAL("hep", buf);
00261   
00262   mbed_trace_config_set(TRACE_ACTIVE_LEVEL_DEBUG|TRACE_MODE_COLOR);
00263   mbed_tracef(TRACE_LEVEL_ERROR, "mygr", "hep");
00264   STRCMP_EQUAL("\x1b[31m[ERR ][mygr]: hep\x1b[0m", buf);
00265   
00266 }
00267 
00268 TEST(trace, active_level_debug)
00269 {
00270   mbed_trace_config_set(TRACE_ACTIVE_LEVEL_DEBUG);
00271   
00272   mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "hep");
00273   STRCMP_EQUAL("[DBG ][mygr]: hep", buf);
00274   
00275   mbed_tracef(TRACE_LEVEL_INFO, "mygr", "test");
00276   STRCMP_EQUAL("[INFO][mygr]: test", buf);
00277   
00278   mbed_tracef(TRACE_LEVEL_WARN, "mygr", "hups");
00279   STRCMP_EQUAL("[WARN][mygr]: hups", buf);
00280   
00281   mbed_tracef(TRACE_LEVEL_ERROR, "mygr", "o'ou");
00282   STRCMP_EQUAL("[ERR ][mygr]: o'ou", buf);
00283 }
00284 
00285 TEST(trace, active_level_info)
00286 {
00287   buf[0] = 0;
00288   mbed_trace_config_set(TRACE_ACTIVE_LEVEL_INFO);
00289   
00290   mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "hep");
00291   STRCMP_EQUAL("", mbed_trace_last());
00292   
00293   mbed_tracef(TRACE_LEVEL_INFO, "mygr", "test");
00294   STRCMP_EQUAL("[INFO][mygr]: test", buf);
00295   
00296   mbed_tracef(TRACE_LEVEL_WARN, "mygr", "hups");
00297   STRCMP_EQUAL("[WARN][mygr]: hups", buf);
00298   
00299   mbed_tracef(TRACE_LEVEL_ERROR, "mygr", "o'ou");
00300   STRCMP_EQUAL("[ERR ][mygr]: o'ou", buf);
00301 }
00302 
00303 TEST(trace, active_level_warn)
00304 {
00305   mbed_trace_config_set(TRACE_ACTIVE_LEVEL_WARN);
00306   
00307   mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "hep");
00308   STRCMP_EQUAL("", mbed_trace_last());
00309   
00310   mbed_tracef(TRACE_LEVEL_INFO, "mygr", "test");
00311   STRCMP_EQUAL("", mbed_trace_last());
00312   
00313   mbed_tracef(TRACE_LEVEL_WARN, "mygr", "hups");
00314   STRCMP_EQUAL("[WARN][mygr]: hups", buf);
00315   
00316   mbed_tracef(TRACE_LEVEL_ERROR, "mygr", "o'ou");
00317   STRCMP_EQUAL("[ERR ][mygr]: o'ou", buf);
00318 }
00319 
00320 TEST(trace, active_level_error)
00321 {
00322   mbed_trace_config_set(TRACE_ACTIVE_LEVEL_ERROR);
00323   
00324   mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "hep");
00325   STRCMP_EQUAL("", mbed_trace_last());
00326   
00327   mbed_tracef(TRACE_LEVEL_INFO, "mygr", "test");
00328   STRCMP_EQUAL("", mbed_trace_last());
00329   
00330   mbed_tracef(TRACE_LEVEL_WARN, "mygr", "hups");
00331   STRCMP_EQUAL("", mbed_trace_last());
00332   
00333   mbed_tracef(TRACE_LEVEL_ERROR, "mygr", "o'ou");
00334   STRCMP_EQUAL("[ERR ][mygr]: o'ou", buf);
00335 }
00336 TEST(trace, active_level_none)
00337 {
00338   mbed_trace_config_set(TRACE_ACTIVE_LEVEL_NONE);
00339   
00340   mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "hep");
00341   STRCMP_EQUAL("", mbed_trace_last());
00342   
00343   mbed_tracef(TRACE_LEVEL_INFO, "mygr", "test");
00344   STRCMP_EQUAL("", mbed_trace_last());
00345   
00346   mbed_tracef(TRACE_LEVEL_WARN, "mygr", "hups");
00347   STRCMP_EQUAL("", mbed_trace_last());
00348   
00349   mbed_tracef(TRACE_LEVEL_ERROR, "mygr", "o'ou");
00350   STRCMP_EQUAL("", mbed_trace_last());
00351 }
00352 
00353 TEST(trace, active_level_all_1)
00354 {
00355   mbed_trace_config_set(TRACE_ACTIVE_LEVEL_ALL);
00356   mbed_trace_exclude_filters_set((char*)"mygr");
00357   
00358   mbed_tracef(TRACE_LEVEL_DEBUG, "mygu", "hep");
00359   STRCMP_EQUAL("[DBG ][mygu]: hep", buf);
00360   
00361   mbed_tracef(TRACE_LEVEL_INFO, "mygr", "test");
00362   STRCMP_EQUAL("", mbed_trace_last());
00363 }
00364 TEST(trace, active_level_all_2)
00365 {
00366   mbed_trace_config_set(TRACE_ACTIVE_LEVEL_ALL);
00367   mbed_trace_exclude_filters_set((char*)"mygr,mygu");
00368   
00369   mbed_tracef(TRACE_LEVEL_DEBUG, "mygu", "hep");
00370   STRCMP_EQUAL("", mbed_trace_last());
00371   
00372   mbed_tracef(TRACE_LEVEL_INFO, "mygr", "test");
00373   STRCMP_EQUAL("", mbed_trace_last());
00374 }
00375 TEST(trace, active_level_all_3)
00376 {
00377   mbed_trace_config_set(TRACE_ACTIVE_LEVEL_ALL);
00378   mbed_trace_include_filters_set((char*)"mygr");
00379   
00380   mbed_tracef(TRACE_LEVEL_DEBUG, "mygu", "hep");
00381   STRCMP_EQUAL("", mbed_trace_last());
00382   
00383   mbed_tracef(TRACE_LEVEL_INFO, "mygr", "test");
00384   STRCMP_EQUAL("[INFO][mygr]: test", buf);
00385 }
00386 
00387 TEST(trace, active_level_all_array)
00388 {
00389   mbed_trace_config_set(TRACE_ACTIVE_LEVEL_ALL);
00390   
00391   uint8_t arr[] = {0x01, 0x02, 0x03};
00392   mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "my addr: %s", mbed_trace_array(arr, 3));
00393   STRCMP_EQUAL("[DBG ][mygr]: my addr: 01:02:03", buf);
00394 }
00395 
00396 
00397 size_t time_length;
00398 char trace_prefix_str[] = "[<TIME>]";
00399 char* trace_prefix(size_t length){ 
00400   time_length = length;
00401   return trace_prefix_str; 
00402 }
00403 TEST(trace, prefix)
00404 {
00405   mbed_trace_config_set(TRACE_ACTIVE_LEVEL_ALL);
00406   mbed_trace_prefix_function_set( &trace_prefix );
00407   mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "test %d %d", 1, 2);
00408   STRCMP_EQUAL("[<TIME>][DBG ][mygr]: test 1 2", buf);
00409   //TEST_ASSERT_EQUAL_INT(4, time_length);
00410   
00411   mbed_trace_config_set(TRACE_ACTIVE_LEVEL_ALL|TRACE_MODE_PLAIN);
00412   mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "test");
00413   STRCMP_EQUAL("test", buf);
00414   
00415   mbed_trace_config_set(TRACE_ACTIVE_LEVEL_ALL|TRACE_MODE_COLOR);
00416   mbed_tracef(TRACE_LEVEL_ERROR, "mygr", "test");
00417   STRCMP_EQUAL("\x1b[31m[<TIME>][ERR ][mygr]: test\x1b[0m", buf);
00418 }
00419 char trace_suffix_str[] = "[END]";
00420 char* trace_suffix()
00421 {
00422   return trace_suffix_str;
00423 }
00424 TEST(trace, suffix)
00425 {
00426   mbed_trace_config_set(TRACE_ACTIVE_LEVEL_ALL);
00427   mbed_trace_prefix_function_set( &trace_prefix );
00428   mbed_trace_suffix_function_set( &trace_suffix );
00429   mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "test");
00430   STRCMP_EQUAL("[<TIME>][DBG ][mygr]: test[END]", buf);
00431 }
00432 TEST(trace, formatting)
00433 {
00434     mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "hello %d %d %.1f", 12, 13, 5.5);
00435     STRCMP_EQUAL("hello 12 13 5.5", buf);
00436     
00437     mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "hello %d %d %d %d %d %d", 12, 13, 5, 6, 8, 9);
00438     STRCMP_EQUAL("hello 12 13 5 6 8 9", buf);
00439     
00440     mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "HOH %d HAH %d %d %d %d %d", 12, 13, 5, 6, 8, 9);
00441     STRCMP_EQUAL("HOH 12 HAH 13 5 6 8 9", buf);
00442 }
00443 TEST(trace, filters_control)
00444 {
00445     mbed_trace_include_filters_set((char*)"hello");
00446     STRCMP_EQUAL("hello", mbed_trace_include_filters_get());
00447     
00448     mbed_trace_include_filters_set(0);
00449     STRCMP_EQUAL("", mbed_trace_include_filters_get());
00450     
00451     mbed_trace_exclude_filters_set((char*)"hello");
00452     STRCMP_EQUAL("hello", mbed_trace_exclude_filters_get());
00453     
00454     mbed_trace_exclude_filters_set(0);
00455     STRCMP_EQUAL("", mbed_trace_exclude_filters_get());
00456 }
00457 TEST(trace, no_printer)
00458 {
00459     mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "hello");
00460     STRCMP_EQUAL("hello", buf);
00461     
00462     mbed_trace_print_function_set(NULL);
00463     mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "this shoudnt be printed because printer is missing");
00464     STRCMP_EQUAL("hello", buf);
00465 }
00466 TEST(trace, uninitialized)
00467 {
00468     mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "hello");
00469     STRCMP_EQUAL("hello", buf);
00470 
00471     mbed_trace_free();
00472 
00473     mbed_tracef(TRACE_LEVEL_DEBUG, "mygr", "this shoudnt be printed because mtrace is not initialized");
00474     STRCMP_EQUAL("hello", buf);
00475 }
00476