bool TestManager::runTestsWithFilter(const std::string & incl, const std::string & excl) { // Keep current assertion handler and setup ours setupAssertionHandler(); setupLogCapturingHandler(); // Prepare tags for filtering auto included_tags = detail::SplitString(incl, ' '); auto excluded_tags = detail::SplitString(excl, ' '); _test_log.clearLogData(); logHeader("== " + _test_manager_name + " Unit Tests Log"); if (included_tags.size() > 0 || excluded_tags.size() > 0) { if (included_tags.size()) { logMessage(detail::FormattedString(" * included tags : %s", incl.c_str())); } if (excluded_tags.size()) { logMessage(detail::FormattedString(" * excluded tags : %s", excl.c_str())); } logSeparator(); } bool tests_result = true; double elapsed_time = 0.0; if (_registered_tests.size() > 0) { // PerformanceTimer timer; tests_result = executeFilteredTests(included_tags, excluded_tags); elapsed_time = timer.elapsedTime(); // } else { // logMessage("WARNING: There's no registered test!"); // } // Keep elapsed time & report results to log tl().setElapsedTime(elapsed_time); TestLogData::Counters log_data_counters = tl().logDataCounters(); logHeader(detail::FormattedString("== RESULTS: %d passed, %d failed, %d skipped, time %s", log_data_counters.passed_tests, log_data_counters.failed_tests, log_data_counters.skipped_tests, PerformanceTimer::humanReadableTime(elapsed_time).c_str())); // Set previous assertion handler back restoreLogCapturingHandler(); restoreAssertionHandler(); return tests_result; }
void startLoggingMotionData() { logHeader(); while (true) { logMotionData(); sleep(1); } }
void debug(Level level, const int line, const char* file, const char* msg, Args&&... args) const { #ifndef LOGME_DISABLED #ifdef LOGME_USE_LOCKS sf::Lock lock(sMutex); #endif // Test current level of verbosity if (!checkVerbosity(level)) { return; } if (sUseAnsiColorSequences) { *sStream << "\033[" << logLevelToColor(level) << "m"; } logHeader(level); *sStream << " " << std::left << std::setw(32) << mOwner << " "; // TODO: std::forward? printf(*sStream, msg, args...); if (sLogSourcePosition) { *sStream << "\t[" << file << ":" << line << "]"; } if (sUseAnsiColorSequences) { *sStream << "\033[0m"; } *sStream << std::endl; #endif }
void ex_queue::logRemoveHead() { #if 0 #if (!defined (__EID) && !defined(NA_C89)) ex_queue_entry *qe = &queue_[head_ & mask_]; logHeader(); cerr << "remove "; if (upDown_ == UP_QUEUE) { switch (qe->upState.status) { case Q_OK_MMORE: cerr << "Q_OK_MMORE"; break; case Q_SQLERROR: cerr << "Q_SQLERROR"; break; case Q_NO_DATA: cerr << "Q_NO_DATA"; break; default: cerr << "unknown"; break; } cerr << ", pi " << qe->upState.parentIndex; } else { switch (qe->downState.request) { case GET_ALL: cerr << "GET_ALL"; break; case GET_N: cerr << "GET_N"; break; case GET_EOD: cerr << "GET_EOD"; break; case GET_NOMORE: cerr << "GET_NOMORE"; break; default: cerr << "unknown"; break; } cerr << ", pi " << qe->downState.parentIndex; } cerr << endl; #endif #endif }
void CLogger::logLine(const char* fmt, ...) { va_list va; va_start(va,fmt); logHeader(); logva(fmt, va); if (fmt[strlen(fmt)-1]!='\n') log("\n"); va_end(va); }
void sendFinished(deluge_app* app, comBuf* pkt, uint8_t port) { /*deluge_foot_command* command = (deluge_foot_command*)pkt->data; command->seq = ++seqNo; command->command = DELUGE_COMMAND_FINISHED; command->to = -1; command->id = mos_node_id_get(); command->type = DELUGE_PACKET_COMMAND; pkt->size = sizeof(deluge_foot_command); net_send(pkt, DELUGE_PROTO_ID, port, port);*/ logHeader(&spkt, DELUGE_COMMAND_FINISHED); com_send(IFACE_SERIAL, &spkt); }
bool LogWriter::log(ELogLevel l, const char* format, ...) { if (l > level_) { return false; } char* bPtr; va_list ap; va_start(ap, format); int blen = ::vasprintf(&bPtr, format, ap); if (blen < 0) { va_end(ap); return false; } va_end(ap); char header[100] = { 0 }; int hlen = 0; logHeader(header, hlen, l); INIT_IOV(2); SET_IOV_LEN(header, hlen); SET_IOV_LEN(bPtr, blen); if (inode_ != fileNode() || !inode_) { rwlock_.WLock(); if (inode_ != fileNode() || !inode_) { logclose(); loginit(level_, logFile_); } rwlock_.UnLock(); } bool ret = true; rwlock_.RLock(); if (::writev(fd_, iovs, 2) <= 0) { ret = false; } rwlock_.UnLock(); free(bPtr); return ret; }
int goahead_main(int argc, char **argv) { char *argp, *home, *documents, *endpoints, *endpoint, *route, *auth, *tok, *lspec; int argind; #if WINDOWS if (windowsInit() < 0) { return 0; } #endif route = "/nand/route.txt"; auth = "/nand/auth.txt"; for (argind = 1; argind < argc; argind++) { argp = argv[argind]; if (*argp != '-') { break; } else if (smatch(argp, "--auth") || smatch(argp, "-a")) { auth = argv[++argind]; #if ME_UNIX_LIKE && !MACOSX } else if (smatch(argp, "--background") || smatch(argp, "-b")) { websSetBackground(1); #endif } else if (smatch(argp, "--debugger") || smatch(argp, "-d") || smatch(argp, "-D")) { websSetDebug(1); } else if (smatch(argp, "--home")) { if (argind >= argc) usage(); home = argv[++argind]; if (chdir(home) < 0) { error("Can't change directory to %s", home); exit(-1); } } else if (smatch(argp, "--log") || smatch(argp, "-l")) { if (argind >= argc) usage(); logSetPath(argv[++argind]); } else if (smatch(argp, "--verbose") || smatch(argp, "-v")) { logSetPath("stdout:2"); } else if (smatch(argp, "--route") || smatch(argp, "-r")) { route = argv[++argind]; } else if (smatch(argp, "--version") || smatch(argp, "-V")) { printf("%s\n", ME_VERSION); exit(0); } else if (*argp == '-' && isdigit((uchar) argp[1])) { lspec = sfmt("stdout:%s", &argp[1]); logSetPath(lspec); wfree(lspec); } else { usage(); } } documents = ME_GOAHEAD_DOCUMENTS; if (argc > argind) { documents = argv[argind++]; } initPlatform(); if (websOpen(documents, route) < 0) { error("Can't initialize server. Exiting."); return -1; } if (websLoad(auth) < 0) { error("Can't load %s", auth); return -1; } logHeader(); if (argind < argc) { while (argind < argc) { endpoint = argv[argind++]; if (websListen(endpoint) < 0) { return -1; } } } else { endpoints = sclone(ME_GOAHEAD_LISTEN); for (endpoint = stok(endpoints, ", \t", &tok); endpoint; endpoint = stok(NULL, ", \t,", &tok)) { #if !ME_COM_SSL if (strstr(endpoint, "https")) continue; #endif if (websListen(endpoint) < 0) { return -1; } } wfree(endpoints); } #if ME_ROM && KEEP /* If not using a route/auth config files, then manually create the routes like this: If custom matching is required, use websSetRouteMatch. If authentication is required, use websSetRouteAuth. */ websAddRoute("/", "file", 0); #endif #if ME_UNIX_LIKE && !MACOSX /* Service events till terminated */ if (websGetBackground()) { if (daemon(0, 0) < 0) { error("Can't run as daemon"); return -1; } } #endif websServiceEvents(&finished); logmsg(1, "Instructed to exit"); websClose(); #if WINDOWS windowsClose(); #endif return 0; }
MAIN(goahead, int argc, char **argv, char **envp) { char *argp, *auth, *home, *documents, *endpoints, *endpoint, *route, *tok; int argind; route = "route.txt"; auth = "auth.txt"; for (argind = 1; argind < argc; argind++) { argp = argv[argind]; if (*argp != '-') { break; } else if (smatch(argp, "--auth") || smatch(argp, "-a")) { if (argind >= argc) usage(); auth = argv[++argind]; } else if (smatch(argp, "--background") || smatch(argp, "-b")) { websSetBackground(1); } else if (smatch(argp, "--debugger") || smatch(argp, "-d") || smatch(argp, "-D")) { websSetDebug(1); } else if (smatch(argp, "--home")) { if (argind >= argc) usage(); home = argv[++argind]; if (chdir(home) < 0) { error("Can't change directory to %s", home); exit(-1); } } else if (smatch(argp, "--log") || smatch(argp, "-l")) { if (argind >= argc) usage(); logSetPath(argv[++argind]); } else if (smatch(argp, "--verbose") || smatch(argp, "-v")) { logSetPath("stdout:2"); } else if (smatch(argp, "--route") || smatch(argp, "-r")) { route = argv[++argind]; } else if (smatch(argp, "--version") || smatch(argp, "-V")) { printf("%s: %s-%s\n", BIT_PRODUCT, BIT_VERSION, BIT_BUILD_NUMBER); exit(0); } else { usage(); } } documents = BIT_GOAHEAD_DOCUMENTS; if (argc > argind) { documents = argv[argind++]; } initPlatform(); if (websOpen(documents, route) < 0) { error("Can't initialize server. Exiting."); return -1; } logHeader(); if (websLoad(auth) < 0) { error("Can't load %s", auth); return -1; } if (argind < argc) { while (argind < argc) { endpoint = argv[argind++]; if (websListen(endpoint) < 0) { return -1; } } } else { endpoints = sclone(BIT_GOAHEAD_LISTEN); for (endpoint = stok(endpoints, ", \t", &tok); endpoint; endpoint = stok(NULL, ", \t,", &tok)) { if (websListen(endpoint) < 0) { return -1; } } wfree(endpoints); } websDefineHandler("test", testHandler, 0, 0); websAddRoute("/test", "test", 0); #if BIT_GOAHEAD_LEGACY websUrlHandlerDefine("/legacy/", 0, 0, legacyTest, 0); #endif #if BIT_GOAHEAD_JAVASCRIPT websDefineJst("aspTest", aspTest); websDefineJst("bigTest", bigTest); #endif websDefineAction("test", actionTest); websDefineAction("sessionTest", sessionTest); websDefineAction("showTest", showTest); #if BIT_GOAHEAD_UPLOAD websDefineAction("uploadTest", uploadTest); #endif #if BIT_UNIX_LIKE /* Service events till terminated */ if (websGetBackground()) { if (daemon(0, 0) < 0) { error("Can't run as daemon"); return -1; } } #endif websServiceEvents(&finished); trace(1, "Instructed to exit\n"); websClose(); return 0; }
LoggerStream StorageHandler::error() const { return mLog.error(logHeader()); }
LoggerStream StorageHandler::warning() const { return mLog.warning(logHeader()); }
LoggerStream StorageHandler::info() const { return mLog.info(logHeader()); }
void handleCommand(deluge_app* app, comBuf* pkt, uint8_t port) { deluge_foot_command* command = (deluge_foot_command*) &pkt->data[pkt->size - sizeof(deluge_foot_command)]; #ifdef DELUGE_PRINT_PACKETS printf_P(sRecvComm, command->seq, command->command, command->to); #endif if (checkCache(command->id, command->seq)) return; // Temporarily switch to max power to make sure the command gets through /*uint8_t oldPower; com_ioctl(IFACE_RADIO, CC1000_GET_TX_POWER, &oldPower); com_ioctl(IFACE_RADIO, CC1000_TX_POWER, 0xFF);*/ // If the command is not specifically addessed to us, forward it now /*if (command->to != mos_node_id_get()) net_send(pkt, DELUGE_PROTO_ID, port, port);*/ if (command->to != -1 && command->to != mos_node_id_get()) { //com_ioctl(IFACE_RADIO, CC1000_TX_POWER, oldPower); return; } //extern mutex epromLock; switch(command->command) { case DELUGE_COMMAND_HELLO: printf_P(sHello); logHeader(&spkt, DELUGE_COMMAND_HELLO); com_send(IFACE_SERIAL, &spkt); break; //case DELUGE_COMMAND_SEQNO: seqNo = 0; break; /*case DELUGE_COMMAND_STOPALL: //app->dcb.codeSize; //app->dcb.programcrc; memset(app->dcb.pagesNeeded, 0, sizeof(app->dcb.pagesNeeded)); //app->dcb.version; app->dcb.incomingPage = app->dcb.highPage = app->dcb.goalPage; deluge_saveState(app); deluge_app_init(app, app->index); break;*/ #ifdef DELUGE_KEEP_STATS case DELUGE_COMMAND_CLEARSTATS: #ifdef DELUGE_PRINT_EVENT printf_P(sClearStats); //printf_P(sClearTimer); // reset timer #endif memset(packet_counts, 0, sizeof(packet_counts)); logHeader(&spkt, DELUGE_COMMAND_CLEARSTATS); com_send(IFACE_SERIAL, &spkt); break; case DELUGE_COMMAND_STARTRECORD: #ifdef DELUGE_PRINT_EVENT printf_P(sStartRec); //printf_P(sClearTimer); // reset timer #endif logHeader(&spkt, DELUGE_COMMAND_STARTRECORD); com_send(IFACE_SERIAL, &spkt); deluge_recordstats = 1; break; case DELUGE_COMMAND_ENDRECORD: #ifdef DELUGE_PRINT_EVENT //printf_P(sDisplayTime); // display timer printf_P(sStopRec); #endif deluge_recordstats = 0; /*mos_mutex_lock(&epromLock); dev_ioctl(DEV_AVR_EEPROM, DEV_SEEK, DELUGE_STATS_ADDR); dev_write(DEV_AVR_EEPROM, (uint8_t*)packet_counts, sizeof(packet_counts)); mos_mutex_unlock(&epromLock);*/ logHeader(&spkt, DELUGE_COMMAND_ENDRECORD); com_send(IFACE_SERIAL, &spkt); break; case DELUGE_COMMAND_SENDSTATS: if (-1 != command->to && !sendingStats) { // it's addressed to us sendingStats = 1; statsPort = port; // This is a slow procedure that requires multiple packets to // reply, so run it in another thread. //mos_thread_new(statsThread, 256, PRIORITY_NORMAL); uint8_t r = 0; uint8_t i = 0; for (r=0; r<DELUGE_STATS_COUNT;) { logHeader(&spkt, DELUGE_COMMAND_SENDSTATS_REPLY); spkt.data[spkt.size++] = r; for (i=0; i<4 && r+i<DELUGE_STATS_COUNT; i++) { uint8_t j; for (j=0; j<4; j++) { uint16_t stat = packet_counts[r+i][j]; spkt.data[spkt.size++] = (uint8_t)(stat >> 8); spkt.data[spkt.size++] = (uint8_t)(stat); } } r += i; com_send(IFACE_SERIAL, &spkt); } sendingStats = 0; } break; #endif case DELUGE_COMMAND_VERSION: #ifdef DELUGE_PRINT_EVENT printf_P(sChangeVer, pkt->data[0]); printf_P(sClearTimer); // clear timer #endif mos_mutex_lock(&app->delugeLock); app->dcb.version = pkt->data[0]; deluge_saveState(app); app->detectedInconsistency = 1; stateTransition(app, DELUGE_STATE_MAINTAIN); mos_mutex_unlock(&app->delugeLock); if (command->to != -1) { /*command->seq = ++seqNo; command->command = DELUGE_COMMAND_VERSION_REPLY; command->to = command->id; command->id = mos_node_id_get(); command->type = DELUGE_PACKET_COMMAND; mos_thread_sleep(1000); net_send(pkt, DELUGE_PROTO_ID, port, port);*/ logHeader(&spkt, DELUGE_COMMAND_VERSION_REPLY); com_send(IFACE_SERIAL, &spkt); } break; #ifdef DELUGE_SYMMETRIC_LINKS /*case DELUGE_COMMAND_NEIGHBORS: if (-1 != command->to) { // it's addressed to us memcpy(pkt->data, app->neighbors, sizeof(app->neighbors)); pkt->size = sizeof(app->neighbors); //memcpy(&pkt->data[pkt->size], app->symdtbs, sizeof(app->symdtbs)); //pkt->size += sizeof(app->symdtbs); command = (deluge_foot_command*)&pkt->data[pkt->size]; command->seq = ++seqNo; command->command = DELUGE_COMMAND_NEIGHBORS_REPLY; command->to = -1; command->id = mos_node_id_get(); command->type = DELUGE_PACKET_COMMAND; pkt->size += sizeof(deluge_foot_command); mos_thread_sleep(1000); net_send(pkt, DELUGE_PROTO_ID, port, port); } break;*/ #endif /*case DELUGE_COMMAND_WIPE: { com_mode(IFACE_RADIO, IF_OFF); deluge_suspend(); #ifdef DELUGE_PRINT_EVENT printf_P(sWipe); #endif uint16_t zero = 0; uint16_t addr; mos_mutex_lock(&epromLock); for (addr = DELUGE_CONTROL_BLOCK_ADDR; addr < SIMPLE_FS_ADDR; addr += 2) { dev_ioctl(DEV_AVR_EEPROM, DEV_SEEK, addr); dev_write(DEV_AVR_EEPROM, (uint8_t*)&zero, 2); } simple_fs_format(); uint8_t default_portmap[DELUGE_INSTANCE_COUNT]; uint8_t i; for (i=0; i<DELUGE_INSTANCE_COUNT; i++) default_portmap[i] = i+1; dev_ioctl(DEV_AVR_EEPROM, DEV_SEEK, DELUGE_DIRECTORY_ADDR); dev_write(DEV_AVR_EEPROM, default_portmap, sizeof (default_portmap)); mos_mutex_unlock(&epromLock); #ifdef DELUGE_PRINT_EVENT printf_P(sDone); #endif deluge_init(); com_mode(IFACE_RADIO, IF_LISTEN); break; }*/ case DELUGE_COMMAND_BOOT: { mos_mutex_lock(&app->delugeLock); com_mode(IFACE_RADIO, IF_OFF); deluge_suspend(); if (pkt->data[0]==0) { // Just reboot reboot(); break; } // Open the requested backup image char name[4] = { 'b', 'k', '0'+pkt->data[0], 0 }; mos_file* file = mos_file_open(name); if (!file) { printf_P(sFileErr, name); deluge_resume(); com_mode(IFACE_RADIO, IF_LISTEN); break; } // We keep our current state, but we boot the backup image deluge_saveState(app); // Reboot. This function will copy the file location into the // boot control block for reprogramming app->image_file = file; runReprogram(app); // We shouldn't return from runReprogram mos_mutex_unlock(&app->delugeLock); break; } #if DELUGE_CACHE_PAGES > 1 case DELUGE_COMMAND_CACHESIZE: { if (pkt->data[0] >= DELUGE_CACHE_PAGES) break; #ifdef DELUGE_PRINT_EVENT printf_P(sChangeCache, pkt->data[0]); #endif mos_mutex_lock(&app->delugeLock); app->cacheSize = pkt->data[0]; int8_t i; for (i=0; i<DELUGE_CACHE_PAGES; i++) app->cache_map[i] = -1; app->outgoingCachePage = 0; app->incomingCachePage = 0; stateTransition(app, DELUGE_STATE_MAINTAIN); mos_mutex_unlock(&app->delugeLock); break; } #endif case DELUGE_COMMAND_POWER: { #ifdef DELUGE_PRINT_EVENT printf_P(sChangeTx, pkt->data[0]); #endif //oldPower = pkt->data[0]; // Will get changed at the end com_ioctl(IFACE_RADIO, CC1000_TX_POWER, pkt->data[0]); break; } default: break; }
MAIN(goahead, int argc, char **argv, char **envp) { char *argp, *auth, *home, *documents, *endpoints, *endpoint, *route, *tok, *lspec; int argind, duration; route = "route.txt"; auth = "auth.txt"; duration = 0; for (argind = 1; argind < argc; argind++) { argp = argv[argind]; if (*argp != '-') { break; } else if (smatch(argp, "--auth") || smatch(argp, "-a")) { if (argind >= argc) usage(); auth = argv[++argind]; #if ME_UNIX_LIKE && !MACOSX } else if (smatch(argp, "--background") || smatch(argp, "-b")) { websSetBackground(1); #endif } else if (smatch(argp, "--debugger") || smatch(argp, "-d") || smatch(argp, "-D")) { websSetDebug(1); } else if (smatch(argp, "--duration")) { if (argind >= argc) usage(); duration = atoi(argv[++argind]); } else if (smatch(argp, "--home")) { if (argind >= argc) usage(); home = argv[++argind]; if (chdir(home) < 0) { error("Cannot change directory to %s", home); exit(-1); } } else if (smatch(argp, "--log") || smatch(argp, "-l")) { if (argind >= argc) usage(); logSetPath(argv[++argind]); } else if (smatch(argp, "--verbose") || smatch(argp, "-v")) { logSetPath("stdout:2"); } else if (smatch(argp, "--route") || smatch(argp, "-r")) { route = argv[++argind]; } else if (smatch(argp, "--version") || smatch(argp, "-V")) { printf("%s\n", ME_VERSION); exit(0); } else if (*argp == '-' && isdigit((uchar) argp[1])) { lspec = sfmt("stdout:%s", &argp[1]); logSetPath(lspec); wfree(lspec); } else { usage(); } } documents = ME_GOAHEAD_DOCUMENTS; if (argc > argind) { documents = argv[argind++]; } initPlatform(); if (websOpen(documents, route) < 0) { error("Cannot initialize server. Exiting."); return -1; } logHeader(); if (websLoad(auth) < 0) { error("Cannot load %s", auth); return -1; } if (argind < argc) { while (argind < argc) { endpoint = argv[argind++]; if (websListen(endpoint) < 0) { return -1; } } } else { endpoints = sclone(ME_GOAHEAD_LISTEN); for (endpoint = stok(endpoints, ", \t", &tok); endpoint; endpoint = stok(NULL, ", \t,", &tok)) { if (websListen(endpoint) < 0) { return -1; } } wfree(endpoints); } websDefineHandler("test", testHandler, 0, 0, 0); websAddRoute("/test", "test", 0); #if ME_GOAHEAD_LEGACY websUrlHandlerDefine("/legacy/", 0, 0, legacyTest, 0); #endif #if ME_GOAHEAD_JAVASCRIPT websDefineJst("aspTest", aspTest); websDefineJst("bigTest", bigTest); #endif websDefineAction("test", actionTest); websDefineAction("sessionTest", sessionTest); websDefineAction("showTest", showTest); #if ME_GOAHEAD_UPLOAD && !ME_ROM websDefineAction("uploadTest", uploadTest); #endif #if ME_UNIX_LIKE && !MACOSX /* Service events till terminated */ if (websGetBackground()) { if (daemon(0, 0) < 0) { error("Cannot run as daemon"); return -1; } } #endif if (duration) { printf("Running for %d secs\n", duration); websStartEvent(duration * 1000, (WebsEventProc) exitProc, 0); } websServiceEvents(&finished); logmsg(1, "Instructed to exit\n"); websClose(); return 0; }
LoggerStream PaymentOperationStateHandler::warning() const { return mLog.warning(logHeader()); }
LoggerStream PaymentOperationStateHandler::info() const { return mLog.info(logHeader()); }