/*
* 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);
}
