timeout. tests

Author: anderspkd

include/scl/net/channel.h

@@ -60,10 +60,7 @@ class Channel {
    * @param timeout the timeout.
    * @return the received packet.
    */
-  virtual Task<std::optional<Packet>> recv(Time::Duration timeout) {
-    (void)timeout;
-    co_return {};
-  }
+  virtual Task<std::optional<Packet>> recv(Time::Duration timeout) = 0;
 
   /**
    * @brief Check if there is something to receive on this channel.

include/scl/net/loopback.h

@@ -19,6 +19,7 @@
 
 #include <deque>
 #include <memory>
+#include <stdexcept>
 
 #include "scl/coro/task.h"
 #include "scl/net/channel.h"
@@ -112,6 +113,10 @@ class LoopbackChannel final : public Channel {
     co_return packet;
   }
 
+  Task<std::optional<Packet>> recv(Time::Duration /* ignored */) override {
+    co_return co_await recv();
+  }
+
   /**
    * @brief Check if there are data available for receiving.
    */

include/scl/net/tcp/channel.h

@@ -80,6 +80,8 @@ class TcpChannel final : public Channel {
    */
   Task<Packet> recv() override;
 
+  Task<std::optional<Packet>> recv(Time::Duration timeout) override;
+
   /**
    * @brief Check if this channel has data ready for recovering.
    * @return true if there's data to receive and false otherwise.

include/scl/simulation/simulator.h

@@ -87,7 +87,7 @@ class Simulator final {
    * @brief Run the simulation.
    */
   template <ProtocolBuilder BUILDER>
-  void run(BUILDER& builder, NetworkDescription network_desc) {
+  void run(BUILDER builder, NetworkDescription network_desc) {
     auto protocol = builder();
     if (protocol.size() != network_desc.size()) {
       throw std::logic_error("protocols do not match network definition");
@@ -101,7 +101,7 @@ class Simulator final {
   template <typename HOOK>
     requires(std::convertible_to<HOOK, SimulationHook::HookType>)
   void addHook(EventType trigger, HOOK hook) {
-    m_hooks.emplace_back(trigger, hook);
+    m_hooks.emplace_back(SimulationHook{.trigger = trigger, .hook = hook});
   }
 
   /**
@@ -110,7 +110,7 @@ class Simulator final {
   template <typename HOOK>
     requires(std::convertible_to<HOOK, SimulationHook::HookType>)
   void addHook(HOOK hook) {
-    m_hooks.emplace_back({}, hook);
+    m_hooks.emplace_back(SimulationHook{.trigger = {}, .hook = hook});
   }
 
  private:

include/scl/simulation/transport.h

@@ -27,6 +27,9 @@
 
 namespace scl::details {
 
+/**
+ * @brief Handles the movement of packets between parties in a simulation.
+ */
 class Transport {
  public:
   Transport(SimulatorContext& sim_ctx) : m_sim_ctx(sim_ctx) {}
@@ -35,6 +38,7 @@ class Transport {
   void send(Time::Duration ts, ChannelId id, Packet&& pkt);
 
   bool ready(ChannelId id) const;
+  bool ready(ChannelId id, Time::Duration limit) const;
 
   std::pair<Packet, Time::Duration> recv(Time::Duration ts, ChannelId id);
 

src/scl/argparser.cc

@@ -15,33 +15,35 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
+#include <vector>
+
 #include "scl/argparser.h"
 
-#include <vector>
+using namespace scl;
 
 template <>
-bool scl::ProgramOptions::get<bool>(std::string_view name) const {
+bool ProgramOptions::get<bool>(std::string_view name) const {
   const auto v = m_args.at(name);
   return v == "1" || v == "true";
 }
 
 template <>
-int scl::ProgramOptions::get<int>(std::string_view name) const {
+int ProgramOptions::get<int>(std::string_view name) const {
   return std::stoi(m_args.at(name).data());
 }
 
 template <>
-std::size_t scl::ProgramOptions::get<std::size_t>(std::string_view name) const {
+std::size_t ProgramOptions::get<std::size_t>(std::string_view name) const {
   return std::stoul(m_args.at(name).data());
 }
 
-bool scl::ProgramOptions::Parser::isArg(std::string_view name) const {
+bool ProgramOptions::Parser::isArg(std::string_view name) const {
   return std::any_of(m_args.begin(), m_args.end(), [&](auto a) {
     return a.name == name;
   });
 }
 
-bool scl::ProgramOptions::Parser::isFlag(std::string_view name) const {
+bool ProgramOptions::Parser::isFlag(std::string_view name) const {
   return std::any_of(m_flags.begin(), m_flags.end(), [&](auto f) {
     return f.name == name;
   });
@@ -73,9 +75,9 @@ bool hasDuplicates(const std::vector<ARG_OR_FLAG>& opts) {
 
 }  // namespace
 
-using ParseRet = std::variant<scl::ProgramOptions, std::string_view>;
+using ParseRet = std::variant<ProgramOptions, std::string_view>;
 
-ParseRet scl::ProgramOptions::Parser::parseArguments(int argc, char** argv) {
+ParseRet ProgramOptions::Parser::parseArguments(int argc, char** argv) {
   if (hasDuplicates(m_args)) {
     return "duplicate argument definition";
   }
@@ -135,9 +137,8 @@ ParseRet scl::ProgramOptions::Parser::parseArguments(int argc, char** argv) {
   return error_msg;
 }
 
-void scl::ProgramOptions::Parser::argListShort(
-    std::ostream& stream,
-    std::string_view program_name) const {
+void ProgramOptions::Parser::argListShort(std::ostream& stream,
+                                          std::string_view program_name) const {
   stream << "Usage: " << program_name << " ";
   forEachRequired(m_args, [&stream](const auto arg) {
     stream << "-" << arg.name << " " << arg.type_hint << " ";
@@ -155,7 +156,7 @@ std::string getPadding(std::size_t lead) {
   return std::string(psz, ' ');
 }
 
-void writeArg(std::ostream& stream, const scl::ProgramArg& arg) {
+void writeArg(std::ostream& stream, const ProgramArg& arg) {
   stream << " -" << arg.name << " '" << arg.type_hint << "'";
   if (!arg.description.empty()) {
     const auto pad_str = getPadding(arg.name.size() + arg.type_hint.size() + 5);
@@ -167,7 +168,7 @@ void writeArg(std::ostream& stream, const scl::ProgramArg& arg) {
   stream << std::endl;
 }
 
-void writeFlag(std::ostream& stream, const scl::ProgramFlag& flag) {
+void writeFlag(std::ostream& stream, const ProgramFlag& flag) {
   stream << " -" << flag.name;
   if (!flag.description.empty()) {
     const auto pad_str = getPadding(flag.name.size() + 2);
@@ -188,7 +189,7 @@ bool hasOptional(IT begin, IT end) {
 
 }  // namespace
 
-void scl::ProgramOptions::Parser::argListLong(std::ostream& stream) const {
+void ProgramOptions::Parser::argListLong(std::ostream& stream) const {
   if (!m_description.empty()) {
     stream << std::endl << m_description << std::endl;
   }
@@ -218,7 +219,7 @@ void scl::ProgramOptions::Parser::argListLong(std::ostream& stream) const {
   }
 }
 
-void scl::ProgramOptions::Parser::printHelp(std::string_view error_msg) {
+void ProgramOptions::Parser::printHelp(std::string_view error_msg) {
   bool error = !error_msg.empty();
 
   if (error) {

src/scl/coro/runtime.cc

@@ -21,14 +21,15 @@
 
 #include "scl/coro/task.h"
 
-void scl::details::removeHandle(Runtime* runtime,
-                                std::coroutine_handle<> handle) {
+using namespace scl;
+
+void details::removeHandle(Runtime* runtime, std::coroutine_handle<> handle) {
   if (runtime != nullptr) {
     runtime->deschedule(handle);
   }
 }
 
-std::coroutine_handle<> scl::DefaultRuntime::next() {
+std::coroutine_handle<> DefaultRuntime::next() {
   auto b = m_tq.begin();
   const auto e = m_tq.end();
   while (b != e) {
@@ -42,7 +43,7 @@ std::coroutine_handle<> scl::DefaultRuntime::next() {
   return std::noop_coroutine();
 }
 
-void scl::DefaultRuntime::deschedule(std::coroutine_handle<> coroutine) {
+void DefaultRuntime::deschedule(std::coroutine_handle<> coroutine) {
   m_tq.remove_if([&coroutine](const Pair& pair) {
     return std::get<0>(pair) == coroutine;
   });

src/scl/hex.cc

@@ -20,8 +20,10 @@
 #include <cstdint>
 #include <iomanip>
 
+using namespace scl;
+
 template <>
-std::string scl::details::toHexString(const __uint128_t& v) {
+std::string details::toHexString(const __uint128_t& v) {
   auto top = static_cast<std::uint64_t>(v >> 64);
   auto bot = static_cast<std::uint64_t>(v);
 

src/scl/math/ff_ops_gmp.cc

@@ -17,7 +17,9 @@
 
 #include "./ff_ops_gmp.h"
 
-std::size_t scl::details::findFirstNonZero(const std::string& s) {
+using namespace scl;
+
+std::size_t details::findFirstNonZero(const std::string& s) {
   int n = 0;
   for (const auto c : s) {
     if (c != '0') {

src/scl/math/mersenne127.cc

@@ -24,33 +24,33 @@
 #include "scl/hex.h"
 #include "scl/math/ff_ops.h"
 
+using namespace scl;
+
 using u64 = std::uint64_t;
 using u128 = __uint128_t;
 
 // The prime p = 2^127 - 1.
 static const u128 p = (((u128)0x7FFFFFFFFFFFFFFF) << 64) | 0xFFFFFFFFFFFFFFFF;
 
-using Mersenne127 = scl::Mersenne127;
-
 template <>
-void scl::details::convertTo<Mersenne127>(u128& out, const int value) {
+void details::convertTo<Mersenne127>(u128& out, const int value) {
   out = value < 0 ? value + p : value;
 }
 
 template <>
-void scl::details::convertTo<Mersenne127>(u128& out, const std::string& src) {
+void details::convertTo<Mersenne127>(u128& out, const std::string& src) {
   out = fromHexString<u128>(src);
   out = out % p;
 }
 
 template <>
-void scl::details::add<Mersenne127>(u128& out, const u128& op) {
+void details::add<Mersenne127>(u128& out, const u128& op) {
   modAdd(out, op, p);
 }
 
 template <>
-void scl::details::subtract<Mersenne127>(u128& out, const u128& op) {
-  details::modSub(out, op, p);
+void details::subtract<Mersenne127>(u128& out, const u128& op) {
+  modSub(out, op, p);
 }
 
 namespace {
@@ -83,7 +83,7 @@ u256 multiplyFull(const u128 x, const u128 y) {
 }  // namespace
 
 template <>
-void scl::details::multiply<Mersenne127>(u128& out, const u128& op) {
+void details::multiply<Mersenne127>(u128& out, const u128& op) {
   u256 z = multiplyFull(out, op);
   out = z.high << 1;
   u128 b = z.low;
@@ -95,33 +95,32 @@ void scl::details::multiply<Mersenne127>(u128& out, const u128& op) {
 }
 
 template <>
-void scl::details::negate<Mersenne127>(u128& out) {
+void details::negate<Mersenne127>(u128& out) {
   modNeg(out, p);
 }
 
 template <>
-void scl::details::invert<Mersenne127>(u128& out) {
+void details::invert<Mersenne127>(u128& out) {
   modInv<u128, __int128_t>(out, out, p);
 }
 
 template <>
-bool scl::details::equal<Mersenne127>(const u128& in1, const u128& in2) {
+bool details::equal<Mersenne127>(const u128& in1, const u128& in2) {
   return in1 == in2;
 }
 
 template <>
-void scl::details::fromBytes<Mersenne127>(u128& dest,
-                                          const unsigned char* src) {
+void details::fromBytes<Mersenne127>(u128& dest, const unsigned char* src) {
   dest = *(const u128*)src;
   dest = dest % p;
 }
 
 template <>
-void scl::details::toBytes<Mersenne127>(unsigned char* dest, const u128& src) {
+void details::toBytes<Mersenne127>(unsigned char* dest, const u128& src) {
   std::memcpy(dest, &src, sizeof(u128));
 }
 
 template <>
-std::string scl::details::toString<Mersenne127>(const u128& in) {
+std::string details::toString<Mersenne127>(const u128& in) {
   return toHexString(in);
 }