std::int32_t CmdRegisterNym::run(
std::string server,
std::string mynym,
std::string publish,
std::string primary)
{
if (!checkServer("server", server)) { return -1; }
if (!checkNym("mynym", mynym)) { return -1; }
bool shouldPublish{false};
if ("" != publish && !checkBoolean("publish", publish)) {
return -1;
} else {
shouldPublish = publish == "true";
}
if (!checkNym("mynym", mynym)) { return -1; }
bool isPrimary{false};
if ("" != primary && !checkBoolean("primary", primary)) {
return -1;
} else {
isPrimary = primary == "true";
}
if (!shouldPublish && isPrimary) {
otOut << "Can't make the server primary if it isn't published.";
return -1;
}
auto& sync = Opentxs::Client().Sync();
OTIdentifier taskID = sync.RegisterNym(
Identifier::Factory(mynym),
Identifier::Factory(server),
shouldPublish,
isPrimary);
ThreadStatus status = sync.Status(taskID);
while (status == ThreadStatus::RUNNING) {
Log::Sleep(std::chrono::milliseconds(100));
status = sync.Status(taskID);
}
switch (status) {
case ThreadStatus::FINISHED_SUCCESS: {
otOut << "Nym registered successfully " << std::endl;
} break;
case ThreadStatus::FINISHED_FAILED: {
otOut << "Nym not registered " << std::endl;
[[fallthrough]];
}
case ThreadStatus::ERROR:
case ThreadStatus::SHUTDOWN:
default: {
return -1;
}
}
return 0;
}
int NUnaryOp::check() {
int isValid = 1;
this->type = resolveType();
/* Do we have a unary boolean expression? (i.e. NOT) */
if(op == LNOT) {
return checkBoolean();
}
/* Valid if the type is a number and the children are valid. */
isValid &= Node::check();
/* Is the type invalid? */
if(type == INVALIDTYPE) {
printErrorHeader("unary operator");
error_type_mismatch(op, children[0]->getType(), TNUMBER);
isValid = 0;
}
return isValid;
}
void SemanticsVisitor::visit(WhileLoopingNode& wn) {
visitChildren(wn);
checkBoolean(wn.getCondition());
}
void SemanticsVisitor::visit(ForLoopingNode& fn) {
currentSymbolTable().openScope();
visitChildren(fn); // FIXME should I use TopDeclVisitor here ???
checkBoolean(fn.getCondition());
currentSymbolTable().closeScope();
}
void SemanticsVisitor::visit(IfTestingNode& ifn) {
visitChildren(ifn);
checkBoolean(ifn.getCondition());
}
//-----------------------------------------------------------------------------
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 ctkErrorLogModelFileLoggingTest1(int argc, char * argv [])
{
QCoreApplication app(argc, argv);
Q_UNUSED(app);
ctkErrorLogModel model;
// fileLoggingEnabled
if (!checkBoolean(__LINE__, "FileLoggingEnabled", model.fileLoggingEnabled(), false).isEmpty())
{
return EXIT_FAILURE;
}
model.setFileLoggingEnabled(true);
if (!checkBoolean(__LINE__, "FileLoggingEnabled", model.fileLoggingEnabled(), true).isEmpty())
{
return EXIT_FAILURE;
}
// Create log file
QTemporaryFile logFile(QDir::tempPath() + "/ctkErrorLogModelFileLoggingTest1.XXXXXX");
logFile.setAutoRemove(false);
logFile.open();
logFile.close();
QString logFilePath = logFile.fileName();
// filePath
if (!checkString(__LINE__, "FilePath", model.filePath(), "").isEmpty())
{
return EXIT_FAILURE;
}
model.setFilePath(logFilePath);
if (!checkString(__LINE__, "FilePath", model.filePath(), logFilePath).isEmpty())
{
return EXIT_FAILURE;
}
// 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);
// Qt messages
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);
// Stream messages
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;
// FD messages
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);
// XXX FD messages from stderr and stdout are not always reported in the same order
//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);
// Give enough time to the ErrorLogModel to consider the queued messages.
processEvents(1000);
model.disableAllMsgHandler();
QList<QStringList> expectedLogEntries;
expectedLogEntries << (QStringList() << "DEBUG" << "Qt" << qtMessage0);
expectedLogEntries << (QStringList() << "WARNING" << "Qt" << qtMessage1);
expectedLogEntries << (QStringList() << "CRITICAL" << "Qt" << qtMessage2);
expectedLogEntries << (QStringList() << "INFO" << "Stream" << streamMessage0);
expectedLogEntries << (QStringList() << "CRITICAL" << "Stream" << streamMessage1);
expectedLogEntries << (QStringList() << "INFO" << "FD" << fdMessage0);
//expectedLogEntries << (QStringList() << "INFO" << "FD" << fdMessage1);
expectedLogEntries << (QStringList() << "CRITICAL" << "FD" << fdMessage2);
//expectedLogEntries << (QStringList() << "CRITICAL" << "FD" << fdMessage3);
QStringList currentLogEntries = readFile(logFilePath);
QString expectedLogEntryPatternTemplate("^\\[%1\\]\\[%2\\] [0-9\\.\\s\\:]+ \\[\\] \\(unknown\\:0\\) \\- %3$");
for(int entryIndex = 0; entryIndex < expectedLogEntries.size(); ++entryIndex)
{
QStringList entry = expectedLogEntries.at(entryIndex);
QRegExp regexp(expectedLogEntryPatternTemplate.arg(entry.at(0)).arg(entry.at(1)).arg(entry.at(2)));
if (!regexp.exactMatch(currentLogEntries.at(entryIndex)))
{
printErrorMessage(
QString("Line %1 - Log entry %2 does NOT math expected regular expression.\n\tLogEntry: %3\n\tRegExp: %4").
arg(__LINE__).arg(entryIndex).arg(currentLogEntries.at(entryIndex)).arg(regexp.pattern()));
return EXIT_FAILURE;
}
}
return EXIT_SUCCESS;
}
