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