Updates as listed in CHANGES.md

Author: tyler-gilbert

CHANGES.md

@@ -2,6 +2,9 @@
 
 ## New Features
 
+- Add `Signal::HandlerScope` to restore the default handler when the object goes out of scope
+- Add `Test::TimedScope` class to check for testing durations
+- Add enum class `chrono::Date::Month` for a list of months
 - Add class `Thread::Mq` to support posix mqueue
 - Add optional stack size parameter when constructing `Thread::Attributes`
 - If `Thread::Attributes` changes policy or priority, policy inherit is disabled

libraries/ChronoAPI/include/chrono/DateTime.hpp

@@ -92,10 +92,26 @@ class Date {
   int minute() const { return m_tm.tm_min; }
   int hour() const { return m_tm.tm_hour; }
 
+  enum class Month {
+    null,
+    january,
+    february,
+    march,
+    april,
+    may,
+    june,
+    july,
+    august,
+    september,
+    october,
+    november,
+    december
+  };
+
   int day() const { return m_tm.tm_mday; }
   int weekday() const { return m_tm.tm_wday; }
   int yearday() const { return m_tm.tm_yday; }
-  int month() const { return m_tm.tm_mon + 1; }
+  Month month() const { return Month(m_tm.tm_mon + 1); }
   int year() const { return m_tm.tm_year + 1900; }
 
   const struct tm &get_tm() const { return m_tm; }

libraries/TestAPI/include/test/Test.hpp

@@ -70,70 +70,18 @@ class Test : public api::ExecutionContext, public TestFlags {
     API_AF(Initialize, printer::Printer *, printer, nullptr);
   };
 
-  /*! \details Initializes the test report.
-   *
-   * This must be called before any tests are even
-   * constructed.
-   *
-   */
   static void initialize(const Initialize &options);
-
-  /*! \details Finalizes the test report.
-   *
-   * This should be called after the last test
-   * has been deconstructed.
-   *
-   */
   static void finalize();
 
-  /*! \details Parse command line options for running test types.
-   *
-   * This method searches for the following options and returns
-   * a value that has which tests to execute.
-   *
-   * - -execute_all
-   * - -api
-   * - -performance
-   * - -stress
-   * - -additional
-   *
-   * \code
-   * #include <test.hpp>
-   * #include <sys.hpp>
-   *
-   * int main(int argc, char * argv[]){
-   *   Cli cli(argc, argv);
-   *   u32 o_execute_flags = Test::parse_options(cli);
-   *
-   *   Test::initialize(cli.name(), cli.version());
-   *
-   *   if( o_execute_flags ){
-   *     Test test("do nothing");
-   *     test.execute(o_execute_flags);
-   *   }
-   *
-   *   Test::finalize();
-   *
-   *   return 0;
-   * }
-   *
-   * \endcode
-   *
-   */
   static ExecuteFlags parse_execution_flags(const sys::Cli &cli);
-  static u32
-  parse_test(const sys::Cli &cli, var::StringView name, u32 test_flag);
+  static u32 parse_test(const sys::Cli &cli, var::StringView name,
+                        u32 test_flag);
 
   Test(var::StringView name);
   ~Test();
 
   void execute(const sys::Cli &cli);
 
-  /*! \details Executes the tests specified by \a o_flags.
-   *
-   * @param o_flags Bitmask of the tests to execute (e.g., Test::EXECUTE_API)
-   *
-   */
   void execute(ExecuteFlags execute_flags = ExecuteFlags::all) {
     if (execute_flags & ExecuteFlags::api) {
       execute_api_case();
@@ -146,59 +94,17 @@ class Test : public api::ExecutionContext, public TestFlags {
     }
   }
 
-  /*! \details Executes the API test case. */
   void execute_api_case();
-  /*! \details Executes the performance test case. */
   void execute_performance_case();
-  /*! \details Executes the stress test case. */
   void execute_stress_case();
 
-  /*! \details Executes the class api test.
-   *
-   * This method should be overridden by the inheriting
-   * class.
-   *
-   */
   virtual bool execute_class_api_case();
-
-  /*! \details Executes the class performance test.
-   *
-   * This method should be overridden by the inheriting
-   * class.
-   *
-   */
   virtual bool execute_class_performance_case();
-
-  /*! \details Executes the class stress test.
-   *
-   * This method should be overridden by the inheriting
-   * class.
-   *
-   */
   virtual bool execute_class_stress_case();
 
-  /*! \details Returns the results of the test.
-   *
-   * If any single test case has a false result,
-   * the result of the test is false.  Otherwise,
-   * the result is true.
-   *
-   */
   bool result() const { return m_test_result; }
-
-  /*! \details Returns the current value of the case result.
-   *
-   * When a case is opened, the case result is set to true (passing).
-   *
-   * Calling set_case_failed() or print_case_failed() will set
-   * the case result value to false.
-   *
-   * case_result() is the default return value of close_case().
-   *
-   */
   bool case_result() const { return m_case_result; }
 
-  /*! \details Sets the current case result to failed. */
   void set_case_failed() {
     m_case_result = false;
     m_test_result = false;
@@ -210,9 +116,8 @@ class Test : public api::ExecutionContext, public TestFlags {
       return true;
     }
 
-    printer().key(
-      var::String().format("expect%d", line),
-      var::String().format("%s failed", function));
+    printer().key(var::String().format("expect%d", line),
+                  var::String().format("%s failed", function));
 
     if (is_error()) {
       printer().object("errorContext", api::ExecutionContext::error());
@@ -225,6 +130,42 @@ class Test : public api::ExecutionContext, public TestFlags {
 
   static bool final_result() { return m_final_result; }
 
+  class TimedScope {
+  public:
+    TimedScope(Test &test, const var::StringView name,
+               const chrono::MicroTime &minimum,
+               const chrono::MicroTime &maximum)
+        : m_test(test), m_name(name), m_start(test.case_timer().milliseconds()),
+          m_minimum(minimum.milliseconds()), m_maximum(maximum.milliseconds()) {
+      m_test.printer().open_object(name);
+      API_ASSERT(m_minimum < m_maximum);
+    }
+
+    ~TimedScope() {
+      const auto stop = m_test.case_timer().milliseconds();
+      const auto duration = stop - m_start;
+      m_test.printer()
+          .key("minimum (ms)", var::NumberString(m_minimum))
+          .key("maximum (ms)", var::NumberString(m_maximum))
+          .key("duration (ms)", var::NumberString(duration));
+      if (duration < m_minimum) {
+        m_test.printer().error("duration below minimum");
+        m_test.set_case_failed();
+      } else if( duration > m_maximum ){
+        m_test.printer().error("duration above maximum");
+        m_test.set_case_failed();
+      }
+      m_test.printer().close_object();
+    }
+
+  private:
+    Test &m_test;
+    var::StringView m_name;
+    u32 m_start;
+    u32 m_minimum;
+    u32 m_maximum;
+  };
+
 protected:
   const chrono::ClockTimer &case_timer() const { return m_case_timer; }
   chrono::ClockTimer &case_timer() { return m_case_timer; }

libraries/ThreadAPI/include/thread/Signal.hpp

@@ -248,6 +248,18 @@ class Signal : public SignalFlags {
   API_NO_DISCARD int sigvalue() const { return m_sigvalue.sival_int; }
   API_NO_DISCARD void *sigptr() const { return m_sigvalue.sival_ptr; }
 
+  class HandlerScope {
+  public:
+    HandlerScope(Signal & signal, const SignalHandler & handler) : m_signo(signal.number()){
+      signal.set_handler(handler);
+    }
+    ~HandlerScope(){
+      Signal(m_signo).set_handler(SignalHandler::default_());
+    }
+  private:
+    Number m_signo;
+  };
+
 private:
   int m_signo;
   union sigval m_sigvalue;

libraries/ThreadAPI/include/thread/Timer.hpp

@@ -5,45 +5,38 @@
 
 #include <signal.h>
 
-#include "chrono/ClockTime.hpp"
 #include "Signal.hpp"
+#include "chrono/ClockTime.hpp"
 
 namespace thread {
 
 class Timer : public api::ExecutionContext {
 public:
   using ClockId = chrono::ClockTime::ClockId;
-  Timer(Signal::Event& signal_event, ClockId clock_id = ClockId::realtime);
+  Timer(Signal::Event &signal_event, ClockId clock_id = ClockId::realtime);
   ~Timer();
 
-  Timer(const Timer & a) = delete;
-  Timer& operator=(const Timer &a) = delete;
+  Timer(const Timer &a) = delete;
+  Timer &operator=(const Timer &a) = delete;
 
-  Timer(Timer && a){
-    std::swap(m_timer, a.m_timer);
-  }
+  Timer(Timer &&a) { std::swap(m_timer, a.m_timer); }
 
-  Timer& operator=(Timer &&a){
+  Timer &operator=(Timer &&a) {
     std::swap(m_timer, a.m_timer);
     return *this;
   }
 
-  bool is_valid() const {
-    return m_timer != timer_t(-1);
-  }
+  bool is_valid() const { return m_timer != timer_t(-1); }
 
-  enum class Flags {
-    null = 0,
-    absolute_time = TIMER_ABSTIME
-  };
+  enum class Flags { null = 0, absolute_time = TIMER_ABSTIME };
 
   class SetTime {
     API_AC(SetTime, chrono::ClockTime, interval);
     API_AC(SetTime, chrono::ClockTime, value);
     API_AF(SetTime, Flags, flags, Flags::null);
   };
 
-  Timer & set_time(const SetTime & options);
+  Timer &set_time(const SetTime &options);
 
   class Info {
     API_RAC(Info, chrono::ClockTime, interval);
@@ -53,9 +46,21 @@ class Timer : public api::ExecutionContext {
 
   Info get_info() const;
 
+  class Alarm {
+  public:
+    enum class Type { seconds, useconds };
+
+  private:
+    API_AC(Alarm, chrono::ClockTime, value);
+    API_AC(Alarm, chrono::ClockTime, interval);
+    API_AF(Alarm, Type, type, Type::seconds);
+  };
+
+  static chrono::ClockTime alarm(const Alarm &options);
+  static void cancel_alarm() { alarm(Alarm()); }
+
 private:
   timer_t m_timer = timer_t(-1);
-
 };
 
 } // namespace thread

libraries/ThreadAPI/src/Timer.cpp

@@ -1,5 +1,9 @@
+#include <unistd.h>
+
 #include "thread/Timer.hpp"
 
+extern "C" useconds_t ualarm(useconds_t useconds, useconds_t interval);
+
 using namespace thread;
 
 Timer::Timer(Signal::Event &signal_event, ClockId clock_id) {
@@ -21,11 +25,11 @@ Timer &Timer::set_time(const SetTime &options) {
   struct itimerspec value = {.it_interval = *options.interval().timespec(),
                              .it_value = *options.value().timespec()};
 
-  API_SYSTEM_CALL("", timer_settime(m_timer, int(options.flags()), &value, nullptr));
+  API_SYSTEM_CALL(
+      "", timer_settime(m_timer, int(options.flags()), &value, nullptr));
   return *this;
 }
 
-
 Timer::Info Timer::get_info() const {
   API_RETURN_VALUE_IF_ERROR(Info());
 
@@ -37,3 +41,14 @@ Timer::Info Timer::get_info() const {
   return result;
 }
 
+chrono::ClockTime Timer::alarm(const Alarm &options) {
+  API_RETURN_VALUE_IF_ERROR(chrono::ClockTime());
+  if (options.type() == Alarm::Type::seconds) {
+    API_SYSTEM_CALL("", ::alarm(options.value().seconds()));
+    return chrono::ClockTime(return_value() * 1_seconds);
+  }
+
+  API_SYSTEM_CALL("", ::ualarm(options.value().nanoseconds() / 1000UL,
+                               options.interval().nanoseconds() / 1000UL));
+  return chrono::ClockTime(return_value() * 1_microseconds);
+}