Add expect option to logger command

diff --git a/kernel/driver.cc b/kernel/driver.cc
index 9040408bc0dc58c71b282b7f666908be611c54e2..1802e8aacf80bd4481a4d2760d0bd13cb7736623 100644 (file)
--- a/kernel/driver.cc
+++ b/kernel/driver.cc
@@ -664,13 +664,15 @@ int main(int argc, char **argv)
        }
 #endif
 
+       log_check_expected();
+
        yosys_atexit();
 
        memhasher_off();
        if (call_abort)
                abort();
 
-       log_flush();
+       log_flush();    
 #if defined(_MSC_VER)
        _exit(0);
 #elif defined(_WIN32)

diff --git a/kernel/log.cc b/kernel/log.cc
index f5d6c488e0923db62e28c4b279f9232bc3e808b6..997c39c64885be374acf6e8c2ecaa9caf920e8e3 100644 (file)
--- a/kernel/log.cc
+++ b/kernel/log.cc
@@ -42,6 +42,7 @@ std::vector<FILE*> log_files;
 std::vector<std::ostream*> log_streams;
 std::map<std::string, std::set<std::string>> log_hdump;
 std::vector<std::regex> log_warn_regexes, log_nowarn_regexes, log_werror_regexes;
+std::vector<std::pair<std::regex,LogExpectedItem>> log_expect_log, log_expect_warning, log_expect_error;
 std::set<std::string> log_warnings, log_experimentals, log_experimentals_ignored;
 int log_warnings_count = 0;
 bool log_hdump_all = false;
@@ -68,6 +69,7 @@ int string_buf_index = -1;
 static struct timeval initial_tv = { 0, 0 };
 static bool next_print_log = false;
 static int log_newline_count = 0;
+static bool check_expected_logs = true;
 
 static void log_id_cache_clear()
 {
@@ -162,7 +164,7 @@ void logv(const char *format, va_list ap)
        {
                log_warn_regex_recusion_guard = true;
 
-               if (log_warn_regexes.empty())
+               if (log_warn_regexes.empty() && log_expect_log.empty())
                {
                        linebuffer.clear();
                }
@@ -174,6 +176,11 @@ void logv(const char *format, va_list ap)
                                for (auto &re : log_warn_regexes)
                                        if (std::regex_search(linebuffer, re))
                                                log_warning("Found log message matching -W regex:\n%s", str.c_str());
+
+                               for (auto &item : log_expect_log)
+                                       if (std::regex_search(linebuffer, item.first))
+                                               item.second.current_count++;
+
                                linebuffer.clear();
                        }
                }
@@ -244,6 +251,10 @@ static void logv_warning_with_prefix(const char *prefix,
                        if (std::regex_search(message, re))
                                log_error("%s",  message.c_str());
 
+               for (auto &item : log_expect_warning)
+                       if (std::regex_search(message, item.first))
+                               item.second.current_count++;
+
                if (log_warnings.count(message))
                {
                        log("%s%s", prefix, message.c_str());
@@ -328,6 +339,12 @@ static void logv_error_with_prefix(const char *prefix,
        if (log_error_atexit)
                log_error_atexit();
 
+       for (auto &item : log_expect_error)
+               if (std::regex_search(log_last_error, item.first))
+                       item.second.current_count++;
+
+       if (check_expected_logs)
+               log_check_expected();
 #ifdef EMSCRIPTEN
        log_files = backup_log_files;
        throw 0;
@@ -636,6 +653,46 @@ void log_wire(RTLIL::Wire *wire, std::string indent)
        log("%s", buf.str().c_str());
 }
 
+void log_check_expected()
+{
+       check_expected_logs = false;
+
+       for (auto &item : log_expect_warning) {
+               if (item.second.current_count != item.second.expected_count) {
+                       log_error("Expected warning pattern '%s' not found !\n", item.second.pattern.c_str());
+               }
+               if (item.second.current_count != item.second.expected_count) {
+                       log_error("Expected warning pattern '%s' found %d time(s), instead of %d time(s) !\n", 
+                               item.second.pattern.c_str(), item.second.current_count, item.second.expected_count);
+               }
+       }
+
+       for (auto &item : log_expect_log) {
+               if (item.second.current_count == 0) {
+                       log_error("Expected log pattern '%s' not found !\n", item.second.pattern.c_str());
+               }
+               if (item.second.current_count != item.second.expected_count) {
+                       log_error("Expected log pattern '%s' found %d time(s), instead of %d time(s) !\n",
+                               item.second.pattern.c_str(), item.second.current_count, item.second.expected_count);
+               }
+       }
+
+       for (auto &item : log_expect_error)
+               if (item.second.current_count == item.second.expected_count) {
+                       log("Expected error pattern '%s' found !!!\n", item.second.pattern.c_str());
+                       #ifdef EMSCRIPTEN
+                               log_files = backup_log_files;
+                               throw 0;
+                       #elif defined(_MSC_VER)
+                               _exit(0);
+                       #else
+                               _Exit(0);
+                       #endif                  
+               } else {
+                       log_error("Expected error pattern '%s' not found !\n", item.second.pattern.c_str());
+               }
+}
+
 // ---------------------------------------------------
 // This is the magic behind the code coverage counters
 // ---------------------------------------------------

diff --git a/kernel/log.h b/kernel/log.h
index 9db8efaa5eaa4cad2742e7cfa7cde7133b2d41c6..0f912fccb14c81fd784c8aaf0a02d71eb5a22de8 100644 (file)
--- a/kernel/log.h
+++ b/kernel/log.h
@@ -135,6 +135,23 @@ void log_backtrace(const char *prefix, int levels);
 void log_reset_stack();
 void log_flush();
 
+struct LogExpectedItem
+{
+       LogExpectedItem(std::string pattern, int expected) :
+               expected_count(expected),
+               current_count(0),
+               pattern(pattern)
+       {
+       }
+
+       int expected_count;
+       int current_count;
+       std::string pattern;
+};
+
+extern std::vector<std::pair<std::regex,LogExpectedItem>> log_expect_log, log_expect_warning, log_expect_error;
+void log_check_expected();
+
 const char *log_signal(const RTLIL::SigSpec &sig, bool autoint = true);
 const char *log_const(const RTLIL::Const &value, bool autoint = true);
 const char *log_id(RTLIL::IdString id);

diff --git a/passes/cmds/logger.cc b/passes/cmds/logger.cc
index 3feef7dc53f677cd520413581f010331116d7acd..30768980e95b4228f0b607a7197d37ba186e7279 100644 (file)
--- a/passes/cmds/logger.cc
+++ b/passes/cmds/logger.cc
@@ -57,6 +57,9 @@ struct LoggerPass : public Pass {
                log("    -experimental <feature>\n");
                log("        do not print warnings for the specified experimental feature\n");
                log("\n");
+               log("    -expect <type> <regex> <expected_count>\n");
+               log("        expect log,warning or error to appear. In case of error return code is 0.\n");
+               log("\n");
        }
 
        void execute(std::vector<std::string> args, RTLIL::Design * design) YS_OVERRIDE
@@ -125,13 +128,44 @@ struct LoggerPass : public Pass {
                                log("Disabled debug log messages.");
                                continue;
                        }
-                       break;
                        if (args[argidx] == "-experimental" && argidx+1 < args.size()) {
                                std::string value = args[++argidx];
                                log("Added '%s' experimental ignore list.", value.c_str());
                                log_experimentals_ignored.insert(value);
                                continue;
                        }
+                       if (args[argidx] == "-expect" && argidx+3 < args.size()) {
+                               std::string type = args[++argidx];
+                               if (type!="error" && type!="warning" && type!="log")
+                                       log_cmd_error("Expect command require type to be 'log', 'warning' or 'error' !\n");
+                               if (type=="error" && log_expect_error.size()>0)
+                                       log_cmd_error("Only single error message can be expected !\n");
+                               std::string pattern = args[++argidx];
+                               if (pattern.front() == '\"' && pattern.back() == '\"') pattern = pattern.substr(1, pattern.size() - 2);                                 
+                               int count = atoi(args[++argidx].c_str());
+                               if (count<=0)
+                                       log_cmd_error("Number of expected messages must be higher then 0 !\n");
+                               if (type=="error" && count!=1)
+                                       log_cmd_error("Expected error message occurrences must be 1 !\n");
+                               log("Added regex '%s' for warnings to expected %s list.\n", pattern.c_str(), type.c_str());
+                               if (type=="error")
+                                       log_expect_error.push_back(std::make_pair(std::regex(pattern,
+                                               std::regex_constants::nosubs |
+                                               std::regex_constants::optimize |
+                                               std::regex_constants::egrep), LogExpectedItem(pattern, count)));
+                               else if (type=="warning")
+                                       log_expect_warning.push_back(std::make_pair(std::regex(pattern,
+                                               std::regex_constants::nosubs |
+                                               std::regex_constants::optimize |
+                                               std::regex_constants::egrep), LogExpectedItem(pattern, count)));
+                               else
+                                       log_expect_log.push_back(std::make_pair(std::regex(pattern,
+                                               std::regex_constants::nosubs |
+                                               std::regex_constants::optimize |
+                                               std::regex_constants::egrep), LogExpectedItem(pattern, count)));
+
+                               continue;
+                       }
                        break;
                }
                extra_args(args, argidx, design, false);