/* * Assert that logs but does not break execution flow on failures (i.e. for test cases). */ int SDLTest_AssertCheck(int assertCondition, const char *assertDescription, ...) { va_list list; char logMessage[SDLTEST_MAX_LOGMESSAGE_LENGTH]; /* Print assert description into a buffer */ SDL_memset(logMessage, 0, SDLTEST_MAX_LOGMESSAGE_LENGTH); va_start(list, assertDescription); SDL_vsnprintf(logMessage, SDLTEST_MAX_LOGMESSAGE_LENGTH - 1, assertDescription, list); va_end(list); /* Log pass or fail message */ if (assertCondition == ASSERT_FAIL) { SDLTest_AssertsFailed++; SDLTest_LogError(SDLTest_AssertCheckFormat, logMessage, "Failed"); } else { SDLTest_AssertsPassed++; SDLTest_Log(SDLTest_AssertCheckFormat, logMessage, "Passed"); } return assertCondition; }
void AssertEquals(int expected, int actual, char *message, ...) { va_list args; char buf[256]; va_start( args, message ); memset(buf, 0, sizeof(buf)); SDL_vsnprintf( buf, sizeof(buf), message, args ); va_end( args ); if(expected != actual) { AssertWithValues("AssertEquals", 0, buf, actual, expected, time(0)); _testReturnValue = TEST_RESULT_FAILURE; _testAssertsFailed++; _BailOut(); } else { AssertWithValues("AssertEquals", 1, buf, actual, expected, time(0)); _testAssertsPassed++; } }
void SDL_LogMessageV(int category, SDL_LogPriority priority, const char *fmt, va_list ap) { char *message; /* Nothing to do if we don't have an output function */ if (!SDL_log_function) { return; } /* Make sure we don't exceed array bounds */ if ((int)priority < 0 || priority >= SDL_NUM_LOG_PRIORITIES) { return; } /* See if we want to do anything with this message */ if (priority < SDL_LogGetPriority(category)) { return; } message = SDL_stack_alloc(char, SDL_MAX_LOG_MESSAGE); if (!message) { return; } SDL_vsnprintf(message, SDL_MAX_LOG_MESSAGE, fmt, ap); SDL_log_function(SDL_log_userdata, category, priority, message); SDL_stack_free(message); }
void SDLCALL SDLNet_SetError(const char *fmt, ...) { va_list argp; va_start(argp, fmt); SDL_vsnprintf(errorbuf, sizeof(errorbuf), fmt, argp); va_end(argp); #ifndef WITHOUT_SDL SDL_SetError("%s", errorbuf); #endif }
void AssertPass(char *message, ...) { va_list args; char buf[256]; va_start( args, message ); SDL_vsnprintf( buf, sizeof(buf), message, args ); va_end( args ); Assert("AssertPass", 1, buf, time(0)); _testAssertsPassed++; }
/* * Prints given message with a timestamp in the TEST category and the ERROR priority. */ void SDLTest_LogError(SDL_PRINTF_FORMAT_STRING const char *fmt, ...) { va_list list; char logMessage[SDLTEST_MAX_LOGMESSAGE_LENGTH]; /* Print log message into a buffer */ SDL_memset(logMessage, 0, SDLTEST_MAX_LOGMESSAGE_LENGTH); va_start(list, fmt); SDL_vsnprintf(logMessage, SDLTEST_MAX_LOGMESSAGE_LENGTH - 1, fmt, list); va_end(list); /* Log with timestamp and newline */ SDL_LogMessage(SDL_LOG_CATEGORY_TEST, SDL_LOG_PRIORITY_ERROR, "%s: %s", SDLTest_TimestampToString(time(0)), logMessage); }
/* * Assert that logs and break execution flow on failures (i.e. for harness errors). */ void SDLTest_Assert(int assertCondition, const char *assertDescription, ...) { va_list list; char logMessage[SDLTEST_MAX_LOGMESSAGE_LENGTH]; /* Print assert description into a buffer */ SDL_memset(logMessage, 0, SDLTEST_MAX_LOGMESSAGE_LENGTH); va_start(list, assertDescription); SDL_vsnprintf(logMessage, SDLTEST_MAX_LOGMESSAGE_LENGTH - 1, assertDescription, list); va_end(list); /* Log, then assert and break on failure */ SDL_assert((SDLTest_AssertCheck(assertCondition, logMessage))); }
/* * Prints given message with a timestamp in the TEST category and INFO priority. */ void SDLTest_Log(char *fmt, ...) { va_list list; char logMessage[SDLTEST_MAX_LOGMESSAGE_LENGTH]; // Print log message into a buffer memset(logMessage, 0, SDLTEST_MAX_LOGMESSAGE_LENGTH); va_start(list, fmt); SDL_vsnprintf(logMessage, SDLTEST_MAX_LOGMESSAGE_LENGTH - 1, fmt, list); va_end(list); // Log with timestamp and newline SDL_LogMessage(SDL_LOG_CATEGORY_TEST, SDL_LOG_PRIORITY_INFO, "%s: %s\n", SDLTest_TimestampToString(time(0)), logMessage); }
/* * Explicitly passing Assert that logs (i.e. for test cases). */ void SDLTest_AssertPass(const char *assertDescription, ...) { va_list list; char logMessage[SDLTEST_MAX_LOGMESSAGE_LENGTH]; /* Print assert description into a buffer */ SDL_memset(logMessage, 0, SDLTEST_MAX_LOGMESSAGE_LENGTH); va_start(list, assertDescription); SDL_vsnprintf(logMessage, SDLTEST_MAX_LOGMESSAGE_LENGTH - 1, assertDescription, list); va_end(list); /* Log pass message */ SDLTest_AssertsPassed++; SDLTest_Log(SDLTest_AssertCheckFormat, logMessage, "Pass"); }
static void debug_print(const char *fmt, ...) { #ifdef __WIN32__ /* Format into a buffer for OutputDebugStringA(). */ char buf[1024]; char *startptr; char *ptr; LPTSTR tstr; int len; va_list ap; va_start(ap, fmt); len = (int) SDL_vsnprintf(buf, sizeof (buf), fmt, ap); va_end(ap); /* Visual C's vsnprintf() may not null-terminate the buffer. */ if ((len >= sizeof (buf)) || (len < 0)) { buf[sizeof (buf) - 1] = '\0'; } /* Write it, sorting out the Unix newlines... */ startptr = buf; for (ptr = startptr; *ptr; ptr++) { if (*ptr == '\n') { *ptr = '\0'; tstr = WIN_UTF8ToString(startptr); OutputDebugString(tstr); SDL_free(tstr); OutputDebugString(TEXT("\r\n")); startptr = ptr+1; } } /* catch that last piece if it didn't have a newline... */ if (startptr != ptr) { tstr = WIN_UTF8ToString(startptr); OutputDebugString(tstr); SDL_free(tstr); } #else /* Unix has it easy. Just dump it to stderr. */ va_list ap; va_start(ap, fmt); vfprintf(stderr, fmt, ap); va_end(ap); fflush(stderr); #endif }
void AssertFail(char *message, ...) { va_list args; char buf[256]; va_start( args, message ); SDL_vsnprintf( buf, sizeof(buf), message, args ); va_end( args ); Assert("AssertFail", 0, buf, time(0)); _testReturnValue = TEST_RESULT_FAILURE; _testAssertsFailed++; _BailOut(); }
static void print_string(char **text, size_t *maxlen, const char *fmt, ...) { int len; va_list ap; va_start(ap, fmt); len = SDL_vsnprintf(*text, *maxlen, fmt, ap); if (len > 0) { *text += len; if ((size_t)len < *maxlen) { *maxlen -= len; } else { *maxlen = 0; } } va_end(ap); }
void SDL_LogMessageV(int category, SDL_LogPriority priority, const char *fmt, va_list ap) { char *message; size_t len; /* Nothing to do if we don't have an output function */ if (!SDL_log_function) { return; } /* Make sure we don't exceed array bounds */ if ((int)priority < 0 || priority >= SDL_NUM_LOG_PRIORITIES) { return; } /* See if we want to do anything with this message */ if (priority < SDL_LogGetPriority(category)) { return; } /* !!! FIXME: why not just "char message[SDL_MAX_LOG_MESSAGE];" ? */ message = SDL_stack_alloc(char, SDL_MAX_LOG_MESSAGE); if (!message) { return; } SDL_vsnprintf(message, SDL_MAX_LOG_MESSAGE, fmt, ap); /* Chop off final endline. */ len = SDL_strlen(message); if ((len > 0) && (message[len-1] == '\n')) { message[--len] = '\0'; if ((len > 0) && (message[len-1] == '\r')) { /* catch "\r\n", too. */ message[--len] = '\0'; } } SDL_log_function(SDL_log_userdata, category, priority, message); SDL_stack_free(message); }
void Log::vsnprint(LogLevel logLevel, LogCategory category, const char* msg, va_list args) { char buf[1024]; const char *categoryStr = LogTypes[static_cast<int>(category)]; SDL_vsnprintf(buf, sizeof(buf), msg, args); buf[sizeof(buf) - 1] = '\0'; switch (logLevel) { case LogLevel::LEVEL_INFO: SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION, ANSI_COLOR_GREEN "(%s): %s" ANSI_COLOR_RESET "\n", categoryStr, buf); for (ConsolesConstIter i = _consoles.begin(); i != _consoles.end(); ++i) { (*i)->logInfo(buf); } break; case LogLevel::LEVEL_WARN: SDL_LogWarn(SDL_LOG_CATEGORY_APPLICATION, ANSI_COLOR_YELLOW "(%s): %s" ANSI_COLOR_RESET "\n", categoryStr, buf); for (ConsolesConstIter i = _consoles.begin(); i != _consoles.end(); ++i) { (*i)->logInfo(buf); } break; case LogLevel::LEVEL_ERROR: SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, ANSI_COLOR_RED "(%s): %s" ANSI_COLOR_RESET "\n", categoryStr, buf); for (ConsolesConstIter i = _consoles.begin(); i != _consoles.end(); ++i) { (*i)->logError(buf); } break; case LogLevel::LEVEL_DEBUG: SDL_LogDebug(SDL_LOG_CATEGORY_APPLICATION, ANSI_COLOR_BLUE "(%s): %s" ANSI_COLOR_RESET "\n", categoryStr, buf); for (ConsolesConstIter i = _consoles.begin(); i != _consoles.end(); ++i) { (*i)->logDebug(buf); } break; case LogLevel::LEVEL_TRACE: SDL_LogVerbose(SDL_LOG_CATEGORY_APPLICATION, ANSI_COLOR_CYAN "(%s): %s" ANSI_COLOR_RESET "\n", categoryStr, buf); for (ConsolesConstIter i = _consoles.begin(); i != _consoles.end(); ++i) { (*i)->logTrace(buf); } break; default: break; } }
void AssertTrue(int condition, char *message, ...) { va_list args; char buf[256]; va_start( args, message ); SDL_vsnprintf( buf, sizeof(buf), message, args ); va_end( args ); if (!condition) { Assert("AssertTrue", 0, buf, time(0)); _testReturnValue = TEST_RESULT_FAILURE; _testAssertsFailed++; _BailOut(); } else { Assert("AssertTrue", 1, buf, time(0)); _testAssertsPassed++; } }
void XMLLog(time_t eventTime, char *fmt, ...) { // create the log message va_list args; char logMessage[1024]; memset(logMessage, 0, sizeof(logMessage)); va_start( args, fmt ); SDL_vsnprintf( logMessage, sizeof(logMessage), fmt, args ); va_end( args ); char *output = XMLOpenElement(logElementName); XMLOutputter(indentLevel++, YES, output); // log message output = XMLOpenElement(messageElementName); XMLOutputter(indentLevel++, NO, output); // fix this here! output = XMLAddContent(logMessage); XMLOutputter(indentLevel, NO, output); output = XMLCloseElement(messageElementName); XMLOutputter(--indentLevel, YES, output); // log eventTime output = XMLOpenElement(timeElementName); XMLOutputter(indentLevel++, NO, output); output = XMLAddContent(TimestampToString(eventTime)); XMLOutputter(indentLevel, NO, output); output = XMLCloseElement(timeElementName); XMLOutputter(--indentLevel, YES, output); output = XMLCloseElement(logElementName); XMLOutputter(--indentLevel, YES, output); }
static int cmsg(int type, int verbosity_level, char *fmt, ...) { #ifdef GREGS_DEBUG va_list ap; int flag_newline = 1; if ((type==CMSG_TEXT || type==CMSG_INFO || type==CMSG_WARNING) && ctl.verbosity<verbosity_level-1) return 0; if (*fmt == '~') { flag_newline = 0; fmt++; } va_start(ap, fmt); if (!ctl.opened) { vfprintf(stderr, fmt, ap); if (flag_newline) fprintf(stderr, "\n"); } else { vfprintf(stderr, fmt, ap); if (flag_newline) fprintf(stderr, "\n"); } va_end(ap); if (!flag_newline) fflush(stderr); return 0; #else va_list ap; if ((type==CMSG_TEXT || type==CMSG_INFO || type==CMSG_WARNING) && ctl.verbosity<verbosity_level) return 0; va_start(ap, fmt); SDL_vsnprintf(timidity_error, TIMIDITY_ERROR_SIZE, fmt, ap); va_end(ap); return 0; #endif }
void kexSystem::Log(const char *fmt, ...) { #define MAX_LOGMESSAGE_LENGTH 3584 va_list list; time_t copy; static char buffer[64]; struct tm *local; char logMessage[MAX_LOGMESSAGE_LENGTH]; SDL_memset(logMessage, 0, MAX_LOGMESSAGE_LENGTH); va_start(list, fmt); SDL_vsnprintf(logMessage, MAX_LOGMESSAGE_LENGTH - 1, fmt, list); va_end(list); #ifdef _WIN32 Sys_Printf(logMessage); #endif SDL_memset(buffer, 0, sizeof(buffer)); copy = time(0); local = localtime(©); strftime(buffer, sizeof(buffer), "%X", local); printf("%s: %s", buffer, logMessage); }