Bug fixes

Author: stellar-aria

include/cppspec.hpp

@@ -31,7 +31,7 @@
 #define before_each self.before_each
 #define after_all self.after_all
 #define after_each self.after_each
-#define let(name, body) auto(name) = self.let(body);
+#define let(name, body) auto(name) = self.let(body); self.register_let(&(name));
 
 #ifdef CPPSPEC_SEMIHOSTED
 #define CPPSPEC_MAIN(spec)                                                                              \

include/description.hpp

@@ -98,6 +98,7 @@ class Description : public Runnable {
 
   template <typename T>
   auto let(T body) -> Let<decltype(body())>;
+  void register_let(LetBase* let) noexcept;
   void reset_lets() noexcept;
 
   /********* Standard getters *********/
@@ -197,15 +198,13 @@ inline void Description::exec_after_eaches() {
  */
 template <typename T>
 auto Description::let(T block) -> Let<decltype(block())> {
-  // In reality, this gets inlined due to the fact that it's
-  // a templated function. Otherwise we wouldn't be able to
-  // add the address of the Let, return the Let by value,
-  // and still be able to do a valid deference of the Let
-  // pointer later on when we needed to reset the Let.
-
-  Let<decltype(block())> let(block);  // Create a Let
-  lets.push_front(&let);              // Add it to our list
-  return let;                         // Hand it object off
+  return Let<decltype(block())>(block);
+}
+
+// Register a let variable for reset between examples.
+// Must be called with the address of the variable that holds the returned Let.
+inline void Description::register_let(LetBase* let) noexcept {
+  lets.push_front(let);
 }
 
 // TODO: Should this be protected?

include/expectations/expectation.hpp

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <exception>
+#include <optional>
 #include <regex>
 #include <source_location>
 #include <string>
@@ -116,7 +117,9 @@ class Expectation {
   void to_match(std::string str, std::string msg = "");
   void to_partially_match(std::regex regex, std::string msg = "");
   void to_partially_match(std::string str, std::string msg = "");
-  void to_satisfy(std::function<bool(A)> /*test*/, std::string msg = "");
+  template <typename F>
+    requires std::invocable<F, A> && std::convertible_to<std::invoke_result_t<F, A>, bool>
+  void to_satisfy(F test, std::string msg = "");
   void to_start_with(std::string start, std::string msg = "");
 
   template <typename U>
@@ -355,8 +358,10 @@ void Expectation<A>::to_partially_match(std::regex regex, std::string msg) {
  * @return Whether the expectation succeeds or fails.
  */
 template <typename A>
-void Expectation<A>::to_satisfy(std::function<bool(A)> test, std::string msg) {
-  Matchers::Satisfy<A>(*this, test).set_message(std::move(msg)).run();
+template <typename F>
+  requires std::invocable<F, A> && std::convertible_to<std::invoke_result_t<F, A>, bool>
+void Expectation<A>::to_satisfy(F test, std::string msg) {
+  Matchers::Satisfy<A>(*this, std::function<bool(A)>(std::move(test))).set_message(std::move(msg)).run();
 }
 
 template <typename A>
@@ -377,8 +382,8 @@ void Expectation<A>::to_end_with(std::string ending, std::string msg) {
 
 template <typename A>
 template <typename U>
-void Expectation<A>::to_end_with(std::initializer_list<U> start_sequence, std::string msg) {
-  Matchers::StartWith<A, std::initializer_list<U>>(*this, start_sequence).set_message(std::move(msg)).run();
+void Expectation<A>::to_end_with(std::initializer_list<U> end_sequence, std::string msg) {
+  Matchers::EndWith<A, std::initializer_list<U>>(*this, end_sequence).set_message(std::move(msg)).run();
 }
 
 template <typename A>
@@ -438,7 +443,7 @@ template <Util::is_functional F>
 class ExpectationFunc : public Expectation<decltype(std::declval<F>()())> {
   using block_ret_t = decltype(std::declval<F>()());
   F block;
-  std::shared_ptr<block_ret_t> computed = nullptr;
+  std::optional<block_ret_t> computed = std::nullopt;
 
  public:
   ExpectationFunc(ExpectationFunc<F> const& copy, std::source_location location)
@@ -473,8 +478,8 @@ class ExpectationFunc : public Expectation<decltype(std::declval<F>()())> {
 
   /** @brief Get the target of the expectation. */
   block_ret_t& get_target() & override {
-    if (computed == nullptr) {
-      computed = std::make_shared<block_ret_t>(block());
+    if (!computed.has_value()) {
+      computed.emplace(block());
     }
     return *computed;
   }

include/result.hpp

@@ -1,7 +1,7 @@
 /** @file */
 #pragma once
 
-#include <ciso646>
+#include <version>
 #include <format>
 #include <source_location>
 #include <sstream>
@@ -25,17 +25,13 @@ class Result {
   [[nodiscard]] bool is_error() const noexcept { return status_ == Status::Error; }
 
   static Result reduce(const Result& lhs, const Result& rhs) noexcept {
-    if (lhs.is_failure()) {
-      return lhs;
-    } else if (rhs.is_failure()) {
-      return rhs;
-    } else if (lhs.is_success()) {
-      return lhs;
-    } else if (rhs.is_success()) {
-      return rhs;
-    } else {
-      return lhs;
-    }
+    if (lhs.is_failure()) return lhs;
+    if (rhs.is_failure()) return rhs;
+    if (lhs.is_error()) return lhs;
+    if (rhs.is_error()) return rhs;
+    if (lhs.is_success()) return lhs;
+    if (rhs.is_success()) return rhs;
+    return lhs;
   }
 
   /*--------- Location helper functions ------------*/
@@ -45,11 +41,9 @@ class Result {
   }
 
   [[nodiscard]] std::string get_type() const noexcept { return type; }
-  [[nodiscard]] std::string get_type() noexcept { return type; }
   void set_type(std::string type) noexcept { this->type = std::move(type); }
 
   /*--------- Message helper functions -------------*/
-  std::string get_message() noexcept { return message; }
   [[nodiscard]] std::string get_message() const noexcept { return message; }
   Result& set_message(std::string message) noexcept {
     this->message = std::move(message);

include/runnable.hpp

@@ -99,10 +99,9 @@ class Runnable {
   virtual void timed_run() {
     using namespace std::chrono;
     start_time_ = system_clock::now();
-    time_point start_time = high_resolution_clock::now();
+    auto start = steady_clock::now();
     run();
-    time_point end = high_resolution_clock::now();
-    runtime_ = end - start_time;
+    runtime_ = steady_clock::now() - start;
   }
 
   [[nodiscard]] std::chrono::duration<double> get_runtime() const { return runtime_; }