@ind-rcg/backend 246.1008.0

package/nativeSrc/common/Utils/StringFormat.cpp

@@ -0,0 +1,905 @@
+//
+//  StringFormat.cpp
+//  NGM
+//
+//  Created by RGS on 07/03/13.
+/*
+ * FILE_HEADER
+ */
+
+#include "StringFormat.h"
+
+#include <sstream>
+#include <fstream>
+
+#define TM_YEAR_BASE   1900
+
+#define DAYSPERLYEAR   366
+#define DAYSPERNYEAR   365
+#define DAYSPERWEEK    7
+
+#define LEAPYEAR(year) (!((year) % 4) && (((year) % 100) || !((year) % 400)))
+
+static char *_fmt(const char *format, const struct tm *t, char *pt, const char *ptlim);
+static char *_conv(const int n, const char *format, char *pt, const char *ptlim);
+static char *_add(const char *str, char *pt, const char *ptlim);
+///
+
+std::string to_string( double d )
+{
+  char buf[64];
+  safe_snprintf(buf, 64, "%f", d);
+  return (std::string(buf));
+}
+
+std::string to_string( size_t u )
+{
+  char buf[32];
+  safe_snprintf(buf, 32, "%lu", u);
+  return (std::string(buf));
+}
+
+std::string to_string( int i )
+{
+  char buf[32];
+  safe_snprintf(buf, 32, "%d", i);
+  return std::string(buf);
+}
+
+std::string to_string(INT64 ld )
+{
+  char buf[64];
+  safe_snprintf(buf, 64, "%lld", ld);
+  return std::string(buf);
+}
+
+std::string to_lower(const char *s) {
+  std::locale settings;
+  std::string cvt;
+  for(int i = 0; i < (int)safe_strlen(s); i++) { cvt += std::tolower(s[i], settings); }
+  return cvt;
+}
+
+std::string to_upper(const char *s) {
+  std::locale settings;
+  std::string cvt;
+  for(int i = 0; i < (int)safe_strlen(s); i++) { cvt += std::toupper(s[i], settings); }
+  return cvt;
+}
+
+bool to_boolean(const char *s) {
+  std::string cvt = to_lower(s);
+  return (("true" == cvt) || ("1" == cvt)) ? true : false;
+}
+
+std::string to_current_date() {
+   time_t t = time(0);   // get time now
+   struct tm * now = localtime( & t );
+   char buf[32];
+   safe_snprintf(buf, 32, "%04d-%02d-%02d",(now->tm_year + 1900), (now->tm_mon + 1), now->tm_mday);
+   return std::string(buf);
+}
+
+std::string to_current_date_time() {
+   time_t t = time(0);   // get time now
+   struct tm * now = localtime( & t );
+   char buf[32];
+   safe_snprintf(buf, 32, "%04d-%02d-%02d %02d:%02d:%02d",(now->tm_year + 1900), (now->tm_mon + 1), now->tm_mday, now->tm_hour, now->tm_min, now->tm_sec);
+   return std::string(buf);
+}
+
+std::string to_current_date_time_msecs() {
+#ifndef WIN32
+  timeval curTime;
+  gettimeofday(&curTime, NULL);
+  int msecs = curTime.tv_usec / 1000;
+
+  time_t t = time(0);
+  struct tm * now = localtime( & t );
+
+  char buf[32];
+  safe_snprintf(buf, 32, "%04d-%02d-%02d %02d:%02d:%02d.%03d",(now->tm_year + 1900), (now->tm_mon + 1), now->tm_mday, now->tm_hour, now->tm_min, now->tm_sec, msecs);
+#else
+   time_t t = time(0);   // get time now
+   struct tm * now = localtime( & t );
+   char buf[32];
+   safe_snprintf(buf, 32, "%04d-%02d-%02d %02d:%02d:%02d.%03d",(now->tm_year + 1900), (now->tm_mon + 1), now->tm_mday, now->tm_hour, now->tm_min, now->tm_sec,0);
+#endif
+  return std::string(buf);
+}
+
+//  Specific date time format implementation
+size_t formatted_date_time(char *s, size_t maxsize, const char *format, const struct tm *t) {
+    char *p;
+    
+    p = _fmt(((format == NULL) ? "%" : format), t, s, s + maxsize);
+    if (p == s + maxsize) return 0;
+    *p = '\0';
+    return p - s;
+}
+
+static char *_fmt(const char *format, const struct tm *t, char *pt, const char *ptlim) {
+    for ( ; *format; ++format) {
+            switch (*format) {
+                case '\0':
+                    --format;
+                    break;
+                    
+                case 'a': // a Lowercase Ante meridiem and Post meridiem - Ex: am or pm
+                    pt = _add((t->tm_hour >= 12) ? "pm" : "am", pt, ptlim);
+                    continue;
+                    
+                case 'A': // A Uppercase Ante meridiem and Post meridiem - Ex: AM or PM
+                    pt = _add((t->tm_hour >= 12) ? "PM" : "AM", pt, ptlim);
+                    continue;
+                    
+                case 'd': // Day of the month, 2 digits with leading zeros - Ex: 01 to 31
+                    pt = _conv(t->tm_mday, "%02d", pt, ptlim);
+                    continue;
+             
+                case 'H': // 24-hour format of an hour with leading zeros - Ex: 00 to 23
+                    pt = _conv(t->tm_hour, "%02d", pt, ptlim);
+                    continue;
+
+                case 'h': // 12-hour format of an hour with leading zeros - Ex: 01 to 12
+                    pt = _conv((t->tm_hour % 12) ? (t->tm_hour % 12) : 12, "%02d", pt, ptlim);
+                    continue;
+                  
+                case 'i': // Minutes, with leading zeros - Ex: 00 to 59
+                    pt = _conv(t->tm_min, "%02d", pt, ptlim);
+                    continue;
+
+                case 'j': // Day of the month without leading zeros - Ex: 1 to 31
+                    pt = _conv(t->tm_mday, "%2d", pt, ptlim);
+                    continue;
+                    
+                case 'G': // 24-hour format of an hour without leading zeros - Ex: 0 to 23
+                    pt = _conv(t->tm_hour, "%2d", pt, ptlim);
+                    continue;
+                    
+                case 'g': // 12-hour format of an hour without leading zeros - Ex: 1 to 12
+                    pt = _conv((t->tm_hour % 12) ? (t->tm_hour % 12) : 12, "%2d", pt, ptlim);
+                    continue;
+                    
+                case 'm': // Numeric representation of a month, with leading zeros
+                    pt = _conv(t->tm_mon + 1, "%02d", pt, ptlim);
+                    continue;
+                
+                case 'n': // Numeric representation of a month, without leading zeros - Ex: 1 to 12
+                    pt = _conv(t->tm_mon + 1, "%2d", pt, ptlim);
+                    continue;
+                   
+                case 'N': // ISO-8601 numeric representation of the day of the week 1 (for Monday) through 7 (for Sunday)
+                    pt = _conv((t->tm_wday == 0) ? 7 : t->tm_wday, "%d", pt, ptlim);
+                    continue;
+                    
+                case 's': // Seconds, with leading zeros - Ex: 00 to 59
+                    pt = _conv(t->tm_sec, "%02d", pt, ptlim);
+                    continue;
+
+                case 't': { // Number of days in the given month - Ex: 28 to 31
+                    int numberOfDays;
+                    int month = t->tm_mon + 1;
+                    int year = t->tm_year + TM_YEAR_BASE;
+                    if (month == 4 || month == 6 || month == 9 || month == 11)
+                        numberOfDays = 30;
+                    else if (month == 2) {
+                        if (LEAPYEAR(year)) numberOfDays = 29;
+                        else numberOfDays = 28;
+                    }  
+                    else  
+                        numberOfDays = 31;
+                    
+                    pt = _conv(numberOfDays, "%2d", pt, ptlim);
+                    continue;
+                }
+                case 'W': // ISO-8601 week number of year, weeks starting on Monday - Ex: 01 to 53
+                    pt = _conv((t->tm_yday + 7 - (t->tm_wday ? (t->tm_wday - 1) : 6)) / 7, "%02d", pt, ptlim);
+                    continue;
+                    
+                case 'y': // A two digit representation of a year - Ex: 99 or 03
+                    pt = _conv((t->tm_year + TM_YEAR_BASE) % 100, "%02d", pt, ptlim);
+                    continue;
+
+                case 'Y': // A full numeric representation of a year, 4 digits - Ex: 1999 or 2003
+                    pt = _conv(t->tm_year + TM_YEAR_BASE, "%04d", pt, ptlim);
+                    continue;
+                    
+                case 'z': // The day of the year (starting from 0)  0 to 364 (365 in leap years)
+                    pt = _conv(t->tm_yday + 1, "%03d", pt, ptlim);
+                    continue;
+                    
+                case '%':
+                default:
+                    break;
+            }
+        
+        if (pt == ptlim) break;
+        *pt++ = *format;
+    }
+    
+    return pt;
+}
+
+static char *_conv(const int n, const char *format, char *pt, const char *ptlim) {
+    char  buf[32];
+    
+    safe_snprintf(buf, 32, format, n);
+    return _add(buf, pt, ptlim);
+}
+
+static char *_add(const char *str, char *pt, const char *ptlim) {
+    while (pt < ptlim && (*pt = *str++) != '\0') ++pt;
+    return pt;
+}
+/////
+
+std::string StringFormat(const char *fmt, ...)
+{
+  int sz = SAFE_DEFAULT_BUFSIZE;
+  std::string str;
+  va_list ap;
+
+  if (NULL != fmt)
+  {
+    for (;;)
+    {
+      str.resize((size_t)sz);
+
+      va_start(ap, fmt);
+      int n = safe_vsnprintf((char *)str.c_str(), (size_t)sz, fmt, ap);
+      va_end(ap);
+
+      if (n < 0) break;
+
+      if (n < sz) { str.resize((size_t)n); break; }
+
+      sz = (sz == n) ? (n + 1) : (sz * 2);
+    }
+  }
+
+  return str;
+}
+
+
+std::string StringFormat(int sz, const char *fmt, ...)
+{
+  std::string str;
+  va_list ap;
+
+  if (NULL != fmt)
+  {
+    for (;;)
+    {
+      str.resize((size_t)sz);
+
+      va_start(ap, fmt);
+      int n = safe_vsnprintf((char *)str.c_str(), (size_t)sz, fmt, ap);
+      va_end(ap);
+
+      if (n < 0) break;
+
+      if (n < sz) { str.resize((size_t)n); break; }
+
+      sz = (sz == n) ? (n + 1) : (sz * 2);
+    }
+  }
+
+  return str;
+}
+
+// in place string replacement
+void StringReplace(std::string& subject, const std::string& search, const std::string& replace) {
+  if (search.empty()) return;
+  size_t pos = 0;
+  while( (pos = subject.find(search, pos)) != std::string::npos ) {
+    subject.replace(pos, search.length(), replace);
+    pos += replace.length();
+  }
+}
+
+void StringReplace(std::string& subject, const char *search, const char *replace) {
+  StringReplace(subject, std::string(search), std::string(replace) );
+}
+
+void StringEscapeResponseXML(std::string& subject)
+{
+    StringReplace(subject, std::string("\r\n" ), std::string("" ));
+    StringReplace(subject, std::string("  " ), std::string("" ));
+    StringReplace(subject, std::string("&" ), std::string("&amp;" ));
+    StringReplace(subject, std::string("'" ), std::string("&apos;"));
+    StringReplace(subject, std::string("\""), std::string("&quot;"));
+    StringReplace(subject, std::string(">" ), std::string("&gt;"  ));
+    StringReplace(subject, std::string("<" ), std::string("&lt;"  ));
+}
+
+void StringEscapeXML(std::string& subject)
+{
+  StringReplace(subject, std::string("&" ), std::string("&amp;" ));
+  StringReplace(subject, std::string("'" ), std::string("&apos;"));
+  StringReplace(subject, std::string("\""), std::string("&quot;"));
+  StringReplace(subject, std::string(">" ), std::string("&gt;"  ));
+  StringReplace(subject, std::string("<" ), std::string("&lt;"  ));
+}
+
+void StringDoubleEscapeXML(std::string& subject)
+{
+  StringReplace(subject, std::string("&" ), std::string("&amp;amp;" ));
+  StringReplace(subject, std::string("'" ), std::string("&amp;apos;"));
+  StringReplace(subject, std::string("\""), std::string("&amp;quot;"));
+  StringReplace(subject, std::string(">" ), std::string("&amp;gt;"  ));
+  StringReplace(subject, std::string("<" ), std::string("&amp;lt;"  ));
+}
+
+void StringEscapeJSON(std::string& subject)
+{
+  StringReplace(subject, std::string("\\"), std::string("\\\\")); //always replace these first!!!
+  StringReplace(subject, std::string("\""), std::string("\\\""));
+  StringReplace(subject, std::string("\t"), std::string("\\t"));
+  StringReplace(subject, std::string("\n"), std::string("\\n"));
+  StringReplace(subject, std::string("\r"), std::string("\\r"));
+  StringReplace(subject, std::string("/"),  std::string("\\/"));
+  StringReplace(subject, std::string("\b"), std::string("\\b"));
+  StringReplace(subject, std::string("\f"), std::string("\\f"));
+}
+
+std::vector<std::string> StringSplit(const std::string &s, char delim)
+{
+  std::vector<std::string> elems;
+  std::stringstream ss(s);
+  std::string item;
+
+  while (std::getline(ss, item, delim))
+  {
+    elems.push_back(item);
+  }
+
+  return elems;
+}
+
+std::vector<std::string> StringSplit(const char * s, char delim)
+{
+  std::string buf = s;
+
+  return StringSplit(buf, delim);
+}
+
+bool starts_with(const std::string& s1, const std::string& s2) {
+  return (s2.size() <= s1.size()) && s1.compare(0, s2.size(), s2) == 0;
+}
+
+bool ends_with(const std::string& s1, const std::string& s2) {
+  return (s2.size() <= s1.size()) && (s1.compare(s1.size() - s2.size(), s2.size(), s2) == 0);
+}
+
+bool contains(const std::string& s1, const std::string& s2) {
+  return std::string::npos != s1.find(s2);
+}
+
+void StringList::_buildJSONString(std::string & ret, const char *s, bool comma) {
+  ret += (comma) ? ", \"" : "\""; ret += s; ret += "\"";
+}
+
+void StringList::save(const char * file_name, const char * eol_mark) {
+  std::ofstream f(file_name); if (f.is_open()) { for (int i=0; i<(int)lst.size(); i++ ) { f << lst[i].c_str(); f << eol_mark; } f.close(); }
+}
+
+std::string StringList::toJSON() {
+  std::string ret = "["; for (int i=0; i<(int)lst.size(); i++) { _buildJSONString(ret, lst[i].c_str(), (0<i)); } ret += "]"; return ret;
+}
+
+const char *strreplace(char *s, char search, char replace )
+{
+  int l = (int)safe_strlen(s);
+
+  for ( int i=0; i<l; i++ ) {
+    if ( s[i] == search ) s[i] = replace;
+  }
+
+  return s;
+}
+
+const char *strrspn( const char *s )
+{
+  const char* p = strchr( s, '\0' );
+  while (p-- != s)
+    if (!strchr( " ", *p ))
+      break;
+  return p + 1;
+}
+
+char *trim_right( char *s )
+{
+  s[ strrspn( s ) - s ] = '\0';
+  return s;
+}
+
+char *trim_left( char *s )
+{
+  char* p = s + strspn( s, " " );
+  return (char *)safe_memcpy((void *)s, (const void *)p, safe_strlen( p ) + 1);
+}
+
+char *trim( char *s )
+{
+  return trim_left( trim_right( s ) );
+}
+
+void *safe_malloc(size_t size)
+{
+   return calloc(size, sizeof(char));
+}
+
+void safe_srand()
+{
+  return srand(time(NULL));
+}
+
+std::string safe_trim(const char *s)
+{
+  std::string result = "";
+
+  int len = safe_strlen(s);
+
+  if (len > 0)
+  {
+    char *sp = new char [len + 1];
+    safe_strcpy(sp,s);
+    trim(sp);
+    result = sp;
+    delete[] sp;
+  }
+
+  return result;
+}
+
+std::string safe_string(const char *s)
+{
+  std::string result = "";
+
+  int len = safe_strlen(s);
+
+  if (len > 0)
+  {
+    char *sp = new char [len + 1];
+    safe_strcpy(sp,s);
+    result = sp;
+    delete[] sp;
+  }
+
+  return result;
+}
+
+FILE *safe_fopen(const char *filename, const char *mode)
+{
+  std::string sFilename = safe_string(filename);
+  std::string sMode = safe_string(mode);
+
+  return fopen(sFilename.c_str(), sMode.c_str());
+}
+
+int safe_stat(const char *filename, struct stat *buf)
+{
+  struct stat dummy_buf;
+  std::string sFilename = safe_string(filename);
+
+  if (NULL == buf)
+  {
+    buf = &dummy_buf;
+  }
+
+  return stat(sFilename.c_str(), buf);
+}
+
+std::string ConvertWStringToString(const std::wstring& s)
+{
+	std::string temp(s.length(), ' ');
+  std::string::iterator str = temp.begin();
+
+  for (std::wstring::const_iterator itr = s.begin(); itr != s.end(); ++itr)
+  {
+    *str++ = (const char)*itr;
+  }
+
+  return temp;
+}
+
+std::string escapeJsonString(const std::string& inputStr) {
+  std::ostringstream oss;
+  for (std::string::const_iterator iter = inputStr.begin(); iter != inputStr.end(); iter++) {
+    switch (*iter) {
+      case '\\': oss << "\\\\"; break;
+      case '"': oss << "\\\""; break;
+      case '/': oss << "\\/"; break;
+      case '\b': oss << "\\b"; break;
+      case '\f': oss << "\\f"; break;
+      case '\n': oss << "\\n"; break;
+      case '\r': oss << "\\r"; break;
+      case '\t': oss << "\\t"; break;
+      default: oss << *iter; break;
+    }
+  }
+  return oss.str();
+}
+
+void * safe_memcpy(void *dst, const void *src, size_t count)
+{
+  if ((NULL == dst) || (NULL == src)) return NULL;
+  // CHECKMARX FALSE POSITIVE - Use_of_Obsolete_Functions
+  // Explanation ( looks like improper Null termination - which is not a finding any more)
+  // moving src to dst will keep NULL terminated in dst 
+  return memmove(dst, src, count);
+}
+
+const void * safe_memchr(const void * ptr, int ch, size_t count)
+{
+  if ((NULL == ptr) || (ch < 0) || (ch > 255)) return NULL;
+
+  return memchr(ptr, ch, count);
+}
+
+size_t safe_strlen(const char *str)
+{
+  if (NULL == str) return 0;
+
+  size_t len = safe_strnlen(str, SAFE_DEFAULT_STRLEN);
+  
+  return (SAFE_DEFAULT_STRLEN == len) ? 0 : len;
+}
+
+size_t safe_strnlen(const char *str, size_t count)
+{
+  if (NULL == str) return 0;
+
+  const char * end = (const char *)safe_memchr(str, '\0', count);
+
+  return (end == NULL) ? count : (end - str);
+}
+
+char * safe_strcat(char * dst, const char * src)
+{
+  if ((NULL == dst) || (NULL == src)) return NULL;
+
+  size_t len_dst = safe_strlen(dst);
+  size_t len_src = safe_strlen(src);
+
+  if ((0 == len_dst) && (*dst != 0x0)) return NULL;
+  if ((0 == len_src) && (*src != 0x0)) return NULL;
+
+  char * end_dst = dst + len_dst;
+
+  return (NULL == safe_memcpy(end_dst, src, len_src + 1)) ? NULL : dst;
+}
+
+char * safe_strcpy(char * dst, const char * src)
+{
+  if ((NULL == dst) || (NULL == src)) return NULL;
+
+  size_t len_src = safe_strlen(src);
+
+  if ((0 == len_src) && (*src != 0x0)) return NULL;
+
+  return (NULL == safe_memcpy(dst, src, len_src + 1)) ? NULL : dst;
+}
+
+char * safe_strncpy(char * dst, const char * src, size_t count)
+{
+  if ((NULL == dst) || (NULL == src)) return NULL;
+
+  if (0 == count) return dst;
+
+  size_t len_src = safe_strnlen(src, count);
+
+  if ((0 == len_src) && (*src != 0x0)) return NULL;
+
+  if (len_src > count) len_src = count;
+  
+  if (NULL == safe_memcpy(dst, src, len_src)) return NULL;
+
+  dst[len_src] = 0x0;
+  
+  return dst;
+}
+
+int safe_snprintf(char *str, size_t count, const char * fmt, ...)
+{
+  if ((NULL == str) || (NULL == fmt)) return -1;
+
+  if (0 == count) return 0;
+
+  va_list ap;
+  int n;
+
+  va_start(ap, fmt);
+  n = safe_vsnprintf(str, count, fmt, ap);
+  va_end(ap);
+
+  return n;
+}
+
+int safe_vsnprintf(char * str, size_t count, const char * fmt, va_list arg)
+{
+  if ((NULL == str) || (NULL == fmt)) return -1;
+
+  if (0 == count) return 0;
+
+  return vsnprintf(str, count, fmt, arg);
+}
+
+#ifdef SAFE_TEST
+void safe_test(const char *operating_system, const char *output_path_only_no_delimiter_no_filename, ...)
+{
+  if ((NULL == operating_system) || (NULL == output_path_only_no_delimiter_no_filename)) return;
+
+  std::string sOutputPath(output_path_only_no_delimiter_no_filename);
+
+  #ifdef WIN32
+  sOutputPath.append("\\safetest.log");
+#else
+  sOutputPath.append("/safetest.log");
+#endif
+
+  va_list ap;
+
+  time_t timer;
+  char buffer[32];
+  struct tm* tm_info;
+
+  FILE * fle = safe_fopen(sOutputPath.c_str(), "w");
+
+  if (NULL == fle) return;
+
+  #define SAFE_TEST_BUF_LEN 64
+  #define SAFE_TEST_ASCII_LEN 26
+  #define SAFE_TEST_DELIMITER_LEN 128
+  #define SAFE_TEST_BIGBUF_LEN 64000
+
+  char dst[SAFE_TEST_BUF_LEN];
+  char src[SAFE_TEST_BUF_LEN];
+  char str[SAFE_TEST_BUF_LEN];
+
+  char delimiter[SAFE_TEST_DELIMITER_LEN + 2];
+
+  char *pstr = (char *)safe_malloc(SAFE_TEST_BIGBUF_LEN);
+
+  const void *cvret = NULL;
+  void *vret = NULL;
+  char *cret = NULL;
+  int iret = -1;
+
+  for (int i = 0; i<SAFE_TEST_BUF_LEN; i++) { dst[i] = 0x0; src[i] = 0x0; str[i] = 0x0; }
+  for (int i = 0; i<SAFE_TEST_BIGBUF_LEN; i++) { pstr[i] = 'A' + (i % 26); }
+
+  for (int i = 0; i<SAFE_TEST_DELIMITER_LEN; i++) { delimiter[i] = '='; }
+
+  delimiter[SAFE_TEST_DELIMITER_LEN] = '\n';
+  delimiter[SAFE_TEST_DELIMITER_LEN + 1] = 0x0;
+
+  fprintf(fle, "Operating system: %s\n\n", operating_system);
+
+  time(&timer);
+  tm_info = localtime(&timer);
+  strftime(buffer, 26, "%Y-%m-%d %H:%M:%S", tm_info);
+  
+  fprintf(fle, "Begin tests at %s\n\n", buffer);
+
+//===========================================================================================
+  fputs(delimiter, fle);
+
+  fputs("Function: void * safe_memcpy(void *dst, const void *src, size_t count)\n\n", fle);
+
+  for (int i = 0; i<SAFE_TEST_BUF_LEN; i++) { dst[i] = 0x0; src[i] = 0x0; }
+  for (int i=0; i<SAFE_TEST_ASCII_LEN; i++) { dst[i] = '*'; src[i] = 'A' + i; }
+
+  fprintf(fle, "dst = %p [\"%s\"]\n", dst, dst);
+  fprintf(fle, "src = %p [\"%s\"]\n", src, src);
+
+  fputs("\n", fle);
+
+  vret = safe_memcpy(dst, NULL, 0);       fprintf(fle, "%p = safe_memcpy(dst, NULL, 0)\n", vret);
+  vret = safe_memcpy(NULL, src, 0);       fprintf(fle, "%p = safe_memcpy(NULL, src, 0)\n", vret);
+  vret = safe_memcpy(NULL, NULL, 0);      fprintf(fle, "%p = safe_memcpy(NULL, NULL, 0)\n", vret);
+  vret = safe_memcpy(dst, NULL, 10);      fprintf(fle, "%p = safe_memcpy(dst, NULL, 10)\n", vret);
+  vret = safe_memcpy(NULL, src, 10);      fprintf(fle, "%p = safe_memcpy(NULL, src, 10)\n", vret);
+  vret = safe_memcpy(NULL, NULL, 10);     fprintf(fle, "%p = safe_memcpy(NULL, NULL, 10)\n", vret);
+  vret = safe_memcpy(dst, src, 0);        fprintf(fle, "%p = safe_memcpy(dst, src, 0)  [\"%s\"]\n", vret, dst);
+  vret = safe_memcpy(dst, src, 10);       fprintf(fle, "%p = safe_memcpy(dst, src, 10) [\"%s\"]\n", vret, dst);
+  vret = safe_memcpy(src+1, src, 8);      fprintf(fle, "%p = safe_memcpy(src+1, src, 8) [\"%s\"]\n", vret, src);
+  vret = safe_memcpy(src, src+1, 5);      fprintf(fle, "%p = safe_memcpy(src, src+1, 5) [\"%s\"]\n", vret, src);
+
+  fputs("\n", fle);
+
+//===========================================================================================
+  fputs(delimiter, fle);
+
+  fputs("Function: const void * safe_memchr(const void * ptr, int ch, size_t count)\n\n", fle);
+
+  for (int i = 0; i<SAFE_TEST_BUF_LEN; i++) { str[i] = 0x0; }
+  for (int i = 0; i<SAFE_TEST_ASCII_LEN; i++) { str[i] = 'A' + i; }
+
+  fprintf(fle, "str = %p [\"%s\"]\n", str, str);
+
+  fputs("\n", fle);
+
+  cvret = safe_memchr(NULL, 0, 0);                   fprintf(fle, "%p = safe_memchr(NULL, 0, 0)\n", cvret);
+  cvret = safe_memchr(NULL, -1, 0);                  fprintf(fle, "%p = safe_memchr(NULL, -1, 0)\n", cvret);
+  cvret = safe_memchr(str, 0, 0);                    fprintf(fle, "%p = safe_memchr(str, 0, 0) [\"%s\"]\n", cvret, cvret != NULL ? cvret : "");
+  cvret = safe_memchr(str, 0, 10);                   fprintf(fle, "%p = safe_memchr(str, 0, 10) [\"%s\"]\n", cvret, cvret != NULL ? cvret : "");
+  cvret = safe_memchr(str, 0, SAFE_TEST_BUF_LEN);     fprintf(fle, "%p = safe_memchr(str, 0, %d) [\"%s\"]\n", cvret, SAFE_TEST_BUF_LEN, cvret != NULL ? cvret : "");
+  cvret = safe_memchr(str, 'D', 0);                  fprintf(fle, "%p = safe_memchr(str, 'D', 0) [\"%s\"]\n", cvret, cvret != NULL ? cvret : "");
+  cvret = safe_memchr(str, 'D', 10);                 fprintf(fle, "%p = safe_memchr(str, 'D', 10) [\"%s\"]\n", cvret, cvret != NULL ? cvret : "");
+  cvret = safe_memchr(str, 'D', SAFE_TEST_BUF_LEN);   fprintf(fle, "%p = safe_memchr(str, 'D', %d) [\"%s\"]\n", cvret, SAFE_TEST_BUF_LEN, cvret != NULL ? cvret : "");
+  cvret = safe_memchr(str, '#', 10);                 fprintf(fle, "%p = safe_memchr(str, '#', 10) [\"%s\"]\n", cvret, cvret != NULL ? cvret : "");
+  cvret = safe_memchr(str, '#', SAFE_TEST_BUF_LEN);   fprintf(fle, "%p = safe_memchr(str, '#', %d) [\"%s\"]\n", cvret, SAFE_TEST_BUF_LEN, cvret != NULL ? cvret : "");
+
+  fputs("\n", fle);
+
+//===========================================================================================
+  fputs(delimiter, fle);
+
+  fputs("Function: size_t safe_strlen(const char *str)\n\n", fle);
+
+  for (int i = 0; i<SAFE_TEST_BUF_LEN; i++) { str[i] = 0x0; }
+  for (int i = 0; i<SAFE_TEST_ASCII_LEN; i++) { str[i] = 'A' + i; }
+
+  fprintf(fle, "str = %p [\"%s\"]\n", str, str);
+  fprintf(fle, "pstr = %p [unterminated string[%d] of A..Z]\n", pstr, SAFE_TEST_BIGBUF_LEN);
+
+  fputs("\n", fle);
+
+  iret = safe_strlen(NULL);      fprintf(fle, "%d = safe_strlen(NULL)\n", iret);
+  iret = safe_strlen(str);       fprintf(fle, "%d = safe_strlen(str)\n", iret);
+
+  iret = safe_strlen(pstr);      fprintf(fle, "%d = safe_strlen(pstr)\n", iret);
+
+  fputs("\n", fle);
+
+//===========================================================================================
+  fputs(delimiter, fle);
+
+  fputs("Function: size_t safe_strnlen(const char *str, size_t count)\n\n", fle);
+
+  for (int i = 0; i<SAFE_TEST_ASCII_LEN; i++) { str[i] = 'A' + i; }
+
+  fprintf(fle, "str = %p [\"%s\"]\n", str, str);
+  fprintf(fle, "pstr = %p [unterminated string[%d] of A..Z]\n", pstr, SAFE_TEST_BIGBUF_LEN);
+
+  fputs("\n", fle);
+
+  iret = safe_strnlen(NULL,0);                           fprintf(fle, "%d = safe_strnlen(NULL,0)\n", iret);
+  iret = safe_strnlen(str, 0);                           fprintf(fle, "%d = safe_strnlen(str,0)\n", iret);
+  iret = safe_strnlen(str, 10);                          fprintf(fle, "%d = safe_strnlen(str,10)\n", iret);
+  iret = safe_strnlen(str, SAFE_TEST_BUF_LEN + 1);       fprintf(fle, "%d = safe_strnlen(str,%d)\n", iret, SAFE_TEST_BUF_LEN + 1);
+
+  iret = safe_strnlen(pstr, SAFE_DEFAULT_STRLEN);        fprintf(fle, "%d = safe_strnlen(pstr,%d)\n", iret, SAFE_DEFAULT_STRLEN);
+  iret = safe_strnlen(pstr, SAFE_TEST_BIGBUF_LEN);       fprintf(fle, "%d = safe_strnlen(pstr,%d)\n", iret, SAFE_TEST_BIGBUF_LEN);
+  iret = safe_strnlen(pstr, SAFE_TEST_BIGBUF_LEN * 2);   fprintf(fle, "%d = safe_strnlen(pstr,%d)\n", iret, SAFE_TEST_BIGBUF_LEN * 2);
+
+  fputs("\n", fle);
+
+//===========================================================================================
+  fputs(delimiter, fle);
+
+  fputs("Function: char * safe_strcat(char * dst, const char * src)\n\n", fle);
+
+  for (int i = 0; i<SAFE_TEST_BUF_LEN; i++)   { dst[i] = 0x0; src[i] = 0x0; }
+  for (int i = 0; i<SAFE_TEST_ASCII_LEN; i++) { dst[i] = '*'; src[i] = 'A' + i; }
+
+  fprintf(fle, "dst = %p [\"%s\"]\n", dst, dst);
+  fprintf(fle, "src = %p [\"%s\"]\n", src, src);
+
+  fputs("\n", fle);
+
+  cret = safe_strcat(dst, NULL);       fprintf(fle, "%p = safe_strcat(dst, NULL)\n", cret);
+  cret = safe_strcat(NULL, src);       fprintf(fle, "%p = safe_strcat(NULL, src)\n", cret);
+  cret = safe_strcat(NULL, NULL);      fprintf(fle, "%p = safe_strcat(NULL, NULL)\n", cret);
+  cret = safe_strcat(dst, src);        fprintf(fle, "%p = safe_strcat(dst, src)  [\"%s\"]\n", cret, dst);
+
+  fputs("\n", fle);
+
+//===========================================================================================
+  fputs(delimiter, fle);
+
+  fputs("Function: char * safe_strcpy(char * dst, const char * src)\n\n", fle);
+
+  for (int i = 0; i<SAFE_TEST_BUF_LEN; i++)   { dst[i] = 0x0; src[i] = 0x0; }
+  for (int i = 0; i<SAFE_TEST_ASCII_LEN; i++) { dst[i] = '*'; src[i] = 'A' + i; }
+  
+  fprintf(fle, "dst = %p [\"%s\"]\n", dst, dst);
+  fprintf(fle, "src = %p [\"%s\"]\n", src, src);
+
+  fputs("\n", fle);
+
+  cret = safe_strcpy(dst, NULL);       fprintf(fle, "%p = safe_strcpy(dst, NULL)\n", cret);
+  cret = safe_strcpy(NULL, src);       fprintf(fle, "%p = safe_strcpy(NULL, src)\n", cret);
+  cret = safe_strcpy(NULL, NULL);      fprintf(fle, "%p = safe_strcpy(NULL, NULL)\n", cret);
+  cret = safe_strcpy(dst, src);        fprintf(fle, "%p = safe_strcpy(dst, src)  [\"%s\"]\n", cret, dst);
+
+  fputs("\n", fle);
+
+//===========================================================================================
+  fputs(delimiter, fle);
+
+  fputs("Function: char * safe_strncpy(char * dst, const char * src, size_t count)\n\n", fle);
+
+  for (int i = 0; i<SAFE_TEST_BUF_LEN; i++) { dst[i] = 0x0; src[i] = 0x0; }
+  for (int i = 0; i<SAFE_TEST_ASCII_LEN; i++) { dst[i] = '*'; src[i] = 'A' + i; }
+
+  fprintf(fle, "dst = %p [\"%s\"]\n", dst, dst);
+  fprintf(fle, "src = %p [\"%s\"]\n", src, src);
+
+  fputs("\n", fle);
+
+  cret = safe_strncpy(dst, NULL, 0);       fprintf(fle, "%p = safe_strncpy(dst, NULL, 0)\n", cret);
+  cret = safe_strncpy(NULL, src, 0);       fprintf(fle, "%p = safe_strncpy(NULL, src, 0)\n", cret);
+  cret = safe_strncpy(NULL, NULL, 0);      fprintf(fle, "%p = safe_strncpy(NULL, NULL, 0)\n", cret);
+  cret = safe_strncpy(dst, NULL, 10);      fprintf(fle, "%p = safe_strncpy(dst, NULL, 10)\n", cret);
+  cret = safe_strncpy(NULL, src, 10);      fprintf(fle, "%p = safe_strncpy(NULL, src, 10)\n", cret);
+  cret = safe_strncpy(NULL, NULL, 10);     fprintf(fle, "%p = safe_strncpy(NULL, NULL, 10)\n", cret);
+  cret = safe_strncpy(dst, src, 0);        fprintf(fle, "%p = safe_strncpy(dst, src, 0)  [\"%s\"]\n", cret, dst);
+  cret = safe_strncpy(dst, src, 10);       fprintf(fle, "%p = safe_strncpy(dst, src, 10) [\"%s\"]\n", cret, dst);
+  cret = safe_strncpy(src+1, src, 8);      fprintf(fle, "%p = safe_strncpy(src+1, src, 8) [\"%s\"]\n", cret, src);
+  cret = safe_strncpy(src, src+1, 5);      fprintf(fle, "%p = safe_strncpy(src, src+1, 5) [\"%s\"]\n", cret, src);
+
+  fputs("\n", fle);
+
+//===========================================================================================
+  fputs(delimiter, fle);
+
+  fputs("Function: int safe_snprintf(char *str, size_t count, const char * fmt, ...)\n\n", fle);
+
+  for (int i = 0; i<SAFE_TEST_BUF_LEN; i++) { dst[i] = 0x0; src[i] = 0x0; }
+  for (int i = 0; i<SAFE_TEST_ASCII_LEN; i++) { dst[i] = '*'; src[i] = 'A' + i; }
+
+  fprintf(fle, "dst = %p [\"%s\"]\n", dst, dst);
+  fprintf(fle, "src = %p [\"%s\"]\n", src, src);
+
+  fputs("\n", fle);
+
+  iret = safe_snprintf(NULL, 0, NULL);        fprintf(fle, "%d = safe_snprintf(NULL, 0, NULL) [\"%s\"]\n", iret, iret != -1 ? dst : "");
+  iret = safe_snprintf(dst, 0, NULL);         fprintf(fle, "%d = safe_snprintf(dst, 0, NULL) [\"%s\"]\n", iret, iret != -1 ? dst : "");
+  iret = safe_snprintf(NULL, 0, "");          fprintf(fle, "%d = safe_snprintf(NULL, 0, "") [\"%s\"]\n", iret, iret != -1 ? dst : "");
+  iret = safe_snprintf(dst, 0, "");           fprintf(fle, "%d = safe_snprintf(dst, 0, "") [\"%s\"]\n", iret, iret != -1 ? dst : "");
+  iret = safe_snprintf(dst, 10, "");          fprintf(fle, "%d = safe_snprintf(dst, 10, "") [\"%s\"]\n", iret, iret != -1 ? dst : "");
+  iret = safe_snprintf(dst, 0, "%s", src);    fprintf(fle, "%d = safe_snprintf(dst, 0, \"%%s\", src) [\"%s\"]\n", iret, iret != -1 ? dst : "");
+  iret = safe_snprintf(dst, 10, "%s", src);   fprintf(fle, "%d = safe_snprintf(dst, 10, \"%%s\", src) [\"%s\"]\n", iret, iret != -1 ? dst : "");
+  iret = safe_snprintf(dst, SAFE_TEST_BUF_LEN - 1, "%s", src);   fprintf(fle, "%d = safe_snprintf(dst, %d, \"%%s\", src) [\"%s\"]\n", iret, SAFE_TEST_BUF_LEN - 1, iret != -1 ? dst : "");
+
+  fputs("\n", fle);
+
+//===========================================================================================
+  fputs(delimiter, fle);
+
+  fputs("Function: int safe_vsnprintf(char * str, size_t count, const char * fmt, va_list arg)\n\n", fle);
+
+  va_start(ap, output_path_only_no_delimiter_no_filename);
+
+  iret = safe_vsnprintf(NULL, 0, NULL, ap);    fprintf(fle, "%d = safe_vsnprintf(NULL, 0, NULL, empty va_list)\n", iret);
+  iret = safe_vsnprintf(dst, 0, NULL, ap);     fprintf(fle, "%d = safe_vsnprintf(dst, 0, NULL, empty va_list)\n", iret);
+  iret = safe_vsnprintf(NULL, 0, "", ap);      fprintf(fle, "%d = safe_vsnprintf(NULL, 0, \"\", empty va_list)\n", iret);
+  iret = safe_vsnprintf(dst, 0, "", ap);       fprintf(fle, "%d = safe_vsnprintf(dst, 0, \"\", empty va_list)\n", iret);
+  iret = safe_vsnprintf(dst, 10, "", ap);      fprintf(fle, "%d = safe_vsnprintf(dst, 10, \"\", empty va_list)\n", iret);
+
+  va_end(ap);
+
+  fputs("\n", fle);
+
+  fputs("Tests with a valid va_list are covered with safe_snprintf()\n", fle);
+  
+  fputs("\n", fle);
+
+//===========================================================================================
+  fputs(delimiter, fle);
+
+  time(&timer);
+  tm_info = localtime(&timer);
+  strftime(buffer, 26, "%Y-%m-%d %H:%M:%S", tm_info);
+
+  fprintf(fle, "End tests at %s", buffer);
+
+  free(pstr);
+
+  fflush(fle);
+  fclose(fle);
+}
+#endif