//-----------------------------------------------------------------------------
int ctkVTKErrorLogMessageHandlerWithThreadsTest1(int argc, char * argv [])
{
QCoreApplication app(argc, argv);
Q_UNUSED(app);
ctkErrorLogModel model;
ctkModelTester modelTester;
modelTester.setVerbose(false);
try
{
modelTester.setModel(&model);
// --------------------------------------------------------------------------
// Monitor Stream messages
model.registerMsgHandler(new ctkVTKErrorLogMessageHandler);
model.setMsgHandlerEnabled(ctkVTKErrorLogMessageHandler::HandlerName, true);
int threadCount = 15;
int maxIteration = 5;
int messagesPerIteration = 3;
startLogMessageThreads<LogVTKMessageThread>(threadCount, maxIteration);
// Give enough time for the threads to send their messages
QTimer::singleShot(1500, qApp, SLOT(quit()));
app.exec();
int expectedMessageCount = threadCount * maxIteration * messagesPerIteration;
QString errorMsg = checkRowCount(__LINE__, model.rowCount(), /* expected = */ expectedMessageCount);
if (!errorMsg.isEmpty())
{
model.disableAllMsgHandler();
printErrorMessage(errorMsg);
printTextMessages(model);
return EXIT_FAILURE;
}
}
catch (const char* error)
{
model.disableAllMsgHandler();
std::cerr << error << std::endl;
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
//-----------------------------------------------------------------------------
int ctkErrorLogModelTest1(int argc, char * argv [])
{
QCoreApplication app(argc, argv);
Q_UNUSED(app);
ctkErrorLogModel model;
ctkModelTester modelTester;
modelTester.setVerbose(false);
QString errorMsg;
QStringList enabledMessageHandlers = model.msgHandlerEnabled();
int currentEnabledMessageHandlersCount = enabledMessageHandlers.count();
errorMsg = checkInteger(__LINE__, "EnabledMessageHandlersCount", currentEnabledMessageHandlersCount, 0);
if (!errorMsg.isEmpty())
{
model.disableAllMsgHandler();
printErrorMessage(errorMsg);
return EXIT_FAILURE;
}
try
{
modelTester.setModel(&model);
// --------------------------------------------------------------------------
// Monitor Qt messages
{
model.registerMsgHandler(new ctkErrorLogQtMessageHandler);
model.setMsgHandlerEnabled(ctkErrorLogQtMessageHandler::HandlerName, true);
errorMsg = checkRowCount(__LINE__, model.rowCount(), /* expected = */ 0);
if (!errorMsg.isEmpty())
{
model.disableAllMsgHandler();
printErrorMessage(errorMsg);
return EXIT_FAILURE;
}
QString qtMessage0("This is a qDebug message");
qDebug().nospace() << qPrintable(qtMessage0);
QString qtMessage1("This is a qWarning message");
qWarning().nospace() << qPrintable(qtMessage1);
QString qtMessage2("This is a qCritical message");
qCritical().nospace() << qPrintable(qtMessage2);
QStringList expectedQtMessages;
expectedQtMessages << qtMessage0 << qtMessage1 << qtMessage2;
errorMsg = checkRowCount(__LINE__, model.rowCount(), /* expected = */ expectedQtMessages.count());
if (!errorMsg.isEmpty())
{
model.disableAllMsgHandler();
printErrorMessage(errorMsg);
printTextMessages(model);
return EXIT_FAILURE;
}
errorMsg = checkTextMessages(__LINE__, model, expectedQtMessages);
if (!errorMsg.isEmpty())
{
model.disableAllMsgHandler();
printErrorMessage(errorMsg);
return EXIT_FAILURE;
}
// Check if msgHandlerEnabled() works as expected
enabledMessageHandlers = model.msgHandlerEnabled();
currentEnabledMessageHandlersCount = enabledMessageHandlers.count();
errorMsg = checkInteger(__LINE__, "EnabledMessageHandlersCount", currentEnabledMessageHandlersCount, 1);
if (!errorMsg.isEmpty())
{
model.disableAllMsgHandler();
printErrorMessage(errorMsg);
return EXIT_FAILURE;
}
// Clear
model.clear();
// Disable Qt messages monitoring
model.setMsgHandlerEnabled(ctkErrorLogQtMessageHandler::HandlerName, false);
qDebug() << "This qDebug message should appear in the console";
qWarning() << "This qWarning message should appear in the console";
qCritical() << "This qCritical message should appear in the console";
errorMsg = checkRowCount(__LINE__, model.rowCount(), /* expected = */ 0);
if (!errorMsg.isEmpty())
{
model.disableAllMsgHandler();
printErrorMessage(errorMsg);
printTextMessages(model);
return EXIT_FAILURE;
}
}
// --------------------------------------------------------------------------
// Monitor Stream messages
{
model.registerMsgHandler(new ctkErrorLogStreamMessageHandler);
model.setMsgHandlerEnabled(ctkErrorLogStreamMessageHandler::HandlerName, true);
// Make sure Qt message handler is still disabled
if (model.msgHandlerEnabled(ctkErrorLogQtMessageHandler::HandlerName))
{
model.disableAllMsgHandler();
errorMsg = QLatin1String("Line %1 - Qt message handler should be disabled");
printErrorMessage(errorMsg.arg(__LINE__));
return EXIT_FAILURE;
}
errorMsg = checkRowCount(__LINE__, model.rowCount(), /* expected = */ 0);
if (!errorMsg.isEmpty())
{
model.disableAllMsgHandler();
printErrorMessage(errorMsg);
printTextMessages(model);
return EXIT_FAILURE;
}
QString streamMessage0("This is a Cout message");
std::cout << qPrintable(streamMessage0) << std::endl;
QString streamMessage1("This is a Cerr message");
std::cerr << qPrintable(streamMessage1) << std::endl;
QStringList expectedStreamMessages;
expectedStreamMessages << streamMessage0 << streamMessage1;
errorMsg = checkRowCount(__LINE__, model.rowCount(), /* expected = */ expectedStreamMessages.count());
if (!errorMsg.isEmpty())
{
model.disableAllMsgHandler();
printErrorMessage(errorMsg);
printTextMessages(model);
return EXIT_FAILURE;
}
errorMsg = checkTextMessages(__LINE__, model, expectedStreamMessages);
if (!errorMsg.isEmpty())
{
model.disableAllMsgHandler();
printErrorMessage(errorMsg);
return EXIT_FAILURE;
}
// Clear
model.clear();
// Disable Stream messages monitoring
model.setMsgHandlerEnabled(ctkErrorLogStreamMessageHandler::HandlerName, false);
std::cout << "This std::cout message should appear in the console" << std::endl;
std::cerr << "This std::cerr message should appear in the console" << std::endl;
errorMsg = checkRowCount(__LINE__, model.rowCount(), /* expected = */ 0);
if (!errorMsg.isEmpty())
{
model.disableAllMsgHandler();
printErrorMessage(errorMsg);
printTextMessages(model);
return EXIT_FAILURE;
}
}
// --------------------------------------------------------------------------
// Monitor FD messages
{
model.registerMsgHandler(new ctkErrorLogFDMessageHandler);
model.setMsgHandlerEnabled(ctkErrorLogFDMessageHandler::HandlerName, true);
errorMsg = checkRowCount(__LINE__, model.rowCount(), /* expected = */ 0);
if (!errorMsg.isEmpty())
{
model.disableAllMsgHandler();
printErrorMessage(errorMsg);
printTextMessages(model);
return EXIT_FAILURE;
}
QString fdMessage0("This is a stdout");
fprintf(stdout, "%s", qPrintable(fdMessage0));
QString fdMessage0b(" message");
fprintf(stdout, "%s\n", qPrintable(fdMessage0b));
fdMessage0.append(fdMessage0b);
fflush(stdout);
// QString fdMessage1("This is a 2nd stdout message");
// fprintf(stdout, "%s\n", qPrintable(fdMessage1));
// fflush(stdout);
QString fdMessage2("This is a stderr");
fprintf(stderr, "%s", qPrintable(fdMessage2));
QString fdMessage2b(" message");
fprintf(stderr, "%s\n", qPrintable(fdMessage2b));
fdMessage2.append(fdMessage2b);
fflush(stderr);
// QString fdMessage3("This is a 2nd stderr message");
// fprintf(stderr, "%s\n", qPrintable(fdMessage3));
// fflush(stderr);
QStringList expectedFDMessages;
expectedFDMessages << fdMessage0 /*<< fdMessage1*/ << fdMessage2 /*<< fdMessage3*/;
// Give enough time to the QFileSystemWatcher used internally by ctkErrorLogFDMessageHandler
// to consider the updated files.
QTimer timer;
timer.setSingleShot(true);
timer.start(1000);
while(timer.isActive())
{
QCoreApplication::processEvents();
}
errorMsg = checkRowCount(__LINE__, model.rowCount(), /* expected = */ expectedFDMessages.count());
if (!errorMsg.isEmpty())
{
model.disableAllMsgHandler();
printErrorMessage(errorMsg);
printTextMessages(model);
return EXIT_FAILURE;
}
errorMsg = checkTextMessages(__LINE__, model, expectedFDMessages);
if (!errorMsg.isEmpty())
{
model.disableAllMsgHandler();
printErrorMessage(errorMsg);
return EXIT_FAILURE;
}
// Clear
model.clear();
// Disable FD messages monitoring
model.setMsgHandlerEnabled(ctkErrorLogFDMessageHandler::HandlerName, false);
fprintf(stdout, "%s", "This stdout message should appear in the console\n");
fprintf(stderr, "%s", "This stderr message should appear in the console\n");
fflush(stderr);
errorMsg = checkRowCount(__LINE__, model.rowCount(), /* expected = */ 0);
if (!errorMsg.isEmpty())
{
model.disableAllMsgHandler();
printErrorMessage(errorMsg);
printTextMessages(model);
return EXIT_FAILURE;
}
}
}
catch (const char* error)
{
model.disableAllMsgHandler();
std::cerr << error << std::endl;
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
//-----------------------------------------------------------------------------
int ctkErrorLogModelTerminalOutputTest1(int argc, char * argv [])
{
QCoreApplication app(argc, argv);
Q_UNUSED(app);
QString fdMessage0("This is stdout message");
QString fdMessage1("This is stderr message");
QString qtMessage0("This is a qDebug message");
QString qtMessage1("This is a qWarning message");
QString qtMessage2("This is a qCritical message");
QString stdMessage0("This is a std::cerr message");
QString stdMessage1("This is a std::cout message");
QStringList expectedMessages;
expectedMessages << fdMessage0 << fdMessage1
<< qtMessage0 << qtMessage1 << qtMessage2
<< stdMessage0 << stdMessage1;
// Since the order of the messages outputed on the terminal is not deterministic,
// let's just make sure that all messages have been displayed on the terminal
// independently of their order.
if (!checkTerminalOutput(expectedMessages))
{
return EXIT_FAILURE;
}
QString errorMsg;
ctkErrorLogModel model;
ctkErrorLogModel::TerminalOutputs currentTerminalOutputEnabled = model.terminalOutputs();
errorMsg = checkBoolean(__LINE__, "TerminalOutputEnabled",
currentTerminalOutputEnabled, ctkErrorLogModel::None);
if (!errorMsg.isEmpty())
{
model.disableAllMsgHandler();
printErrorMessage(errorMsg);
printTextMessages(model);
return EXIT_FAILURE;
}
model.setTerminalOutputs(ctkErrorLogModel::All);
currentTerminalOutputEnabled = model.terminalOutputs();
errorMsg = checkBoolean(__LINE__, "TerminalOutputEnabled",
currentTerminalOutputEnabled, ctkErrorLogModel::All);
if (!errorMsg.isEmpty())
{
model.disableAllMsgHandler();
printErrorMessage(errorMsg);
printTextMessages(model);
return EXIT_FAILURE;
}
ctkModelTester modelTester;
modelTester.setVerbose(false);
try
{
modelTester.setModel(&model);
// Monitor Qt messages
model.registerMsgHandler(new ctkErrorLogQtMessageHandler);
model.setMsgHandlerEnabled(ctkErrorLogQtMessageHandler::HandlerName, true);
// Monitor Stream messages
model.registerMsgHandler(new ctkErrorLogStreamMessageHandler);
model.setMsgHandlerEnabled(ctkErrorLogStreamMessageHandler::HandlerName, true);
// Monitor FD messages
model.registerMsgHandler(new ctkErrorLogFDMessageHandler);
model.setMsgHandlerEnabled(ctkErrorLogFDMessageHandler::HandlerName, true);
fprintf(stdout, "%s\n", qPrintable(fdMessage0));
fflush(stdout);
qDebug().nospace() << qPrintable(qtMessage0);
std::cerr << qPrintable(stdMessage0) << std::endl;
qWarning().nospace() << qPrintable(qtMessage1);
fprintf(stderr, "%s\n", qPrintable(fdMessage1));
fflush(stderr);
std::cout << qPrintable(stdMessage1) << std::endl;
qCritical().nospace() << qPrintable(qtMessage2);
// Give enough time to the ErrorLogModel to consider the queued messages.
processEvents(1000);
errorMsg = checkRowCount(__LINE__, model.rowCount(), /* expected = */ expectedMessages.count());
if (!errorMsg.isEmpty())
{
model.disableAllMsgHandler();
printErrorMessage(errorMsg);
printTextMessages(model);
return EXIT_FAILURE;
}
errorMsg = checkTextMessages(__LINE__, model, expectedMessages);
if (!errorMsg.isEmpty())
{
model.disableAllMsgHandler();
printErrorMessage(errorMsg);
printTextMessages(model);
return EXIT_FAILURE;
}
}
catch (const char* error)
{
model.disableAllMsgHandler();
std::cerr << error << std::endl;
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
//-----------------------------------------------------------------------------
int ctkErrorLogWidgetTest1(int argc, char * argv [])
{
QApplication app(argc, argv);
QMainWindow mainWindow;
mainWindow.show();
QString errorMsg;
ctkErrorLogModel model;
ctkErrorLogWidget widget;
// --------------------------------------------------------------------------
// Monitor application StatusBar messages
{
model.registerMsgHandler(new ctkErrorLogStatusMessageHandler(&mainWindow));
model.setMsgHandlerEnabled(ctkErrorLogStatusMessageHandler::HandlerName, true);
QString expectedStatusText1 = QLatin1String("This is a status message");
mainWindow.statusBar()->showMessage(expectedStatusText1);
// Give enough time to the ErrorLogModel to consider the queued messages.
processEvents(1000);
QStringList expectedStatusMessages;
expectedStatusMessages << expectedStatusText1;
errorMsg = checkRowCount(__LINE__, model.rowCount(), /* expected = */ expectedStatusMessages.count());
if (!errorMsg.isEmpty())
{
model.disableAllMsgHandler();
printErrorMessage(errorMsg);
printTextMessages(model);
return EXIT_FAILURE;
}
errorMsg = checkTextMessages(__LINE__, model, expectedStatusMessages);
if (!errorMsg.isEmpty())
{
model.disableAllMsgHandler();
printErrorMessage(errorMsg);
printTextMessages(model);
return EXIT_FAILURE;
}
// Clear
model.clear();
// Disable Qt messages monitoring
model.setMsgHandlerEnabled(ctkErrorLogStatusMessageHandler::HandlerName, false);
mainWindow.statusBar()->showMessage(
QLatin1String("This is status message shouldn't appear in ErrorLogModel"));
errorMsg = checkRowCount(__LINE__, model.rowCount(), /* expected = */ 0);
if (!errorMsg.isEmpty())
{
model.disableAllMsgHandler();
printErrorMessage(errorMsg);
printTextMessages(model);
return EXIT_FAILURE;
}
}
// --------------------------------------------------------------------------
// Monitor Stream messages
{
model.registerMsgHandler(new ctkErrorLogStreamMessageHandler);
model.setMsgHandlerEnabled(ctkErrorLogStreamMessageHandler::HandlerName, true);
std::cout << "This is a Cout message" << std::endl;
std::cerr << "This is a Cerr message" << std::endl;
}
// --------------------------------------------------------------------------
// Monitor Qt messages
{
model.registerMsgHandler(new ctkErrorLogQtMessageHandler);
model.setMsgHandlerEnabled(ctkErrorLogQtMessageHandler::HandlerName, true);
qDebug() << "This is a Qt Debug message";
qWarning() << "This is a Qt Warning message";
qCritical() << "This is a Qt Critical message";
}
QTime start = QTime::currentTime();
for (int i = 0; i < 500; ++i)
{
qDebug() << "This is a Qt Debug message - id:0 - group:" << i;
std::cout << "This is a Cout message - id:1 - group:" << i << std::endl;
qWarning() << "This is a Qt Warning message - id:2 - group:" << i;
std::cerr << "This is a Cerr message - id:3 - group:" << i << std::endl;
qCritical() << "This is a Qt Critical message - id:4 - group:" << i;
qDebug() << "This is a Qt Debug message - id:5 - group:" << i;
std::cout << "This is a Cout message - id:6 - group:" << i << std::endl;
qWarning() << "This is a Qt Warning message - id:7 - group:" << i;
std::cerr << "This is a Cerr message - id:8 - group:" << i << std::endl;
qCritical() << "This is a Qt Critical message - id:9 - group:" << i;
}
fprintf(stdout, "Msg handling time: %d\n", start.msecsTo(QTime::currentTime()));
fflush(stdout);
model.setLogEntryGrouping(true);
start = QTime::currentTime();
for (int i = 0; i < 1000; ++i)
{
std::cout << "This is a Cout message - id:1 - group:" << i << std::endl;
std::cout << "This is a Cout message - id:2 - group:" << i << std::endl;
std::cout << "This is a Cout message - id:3 - group:" << i << std::endl;
std::cout << "This is a Cout message - id:4 - group:" << i << std::endl;
}
fprintf(stdout, "Msg handling time: %d\n", start.msecsTo(QTime::currentTime()));
fflush(stdout);
widget.setErrorLogModel(&model);
widget.setErrorLogModel(0);
widget.setErrorLogModel(&model);
widget.setErrorLogModel(&model);
widget.show();
if (argc < 2 || QString(argv[1]) != "-I" )
{
QTimer::singleShot(1000, &app, SLOT(quit()));
}
return app.exec();
}
