Merge pull request #354 from physycom/test

Add some tests

Author: Grufoony

src/dsf/dsf.hpp

@@ -6,7 +6,7 @@
 
 static constexpr uint8_t DSF_VERSION_MAJOR = 3;
 static constexpr uint8_t DSF_VERSION_MINOR = 14;
-static constexpr uint8_t DSF_VERSION_PATCH = 0;
+static constexpr uint8_t DSF_VERSION_PATCH = 1;
 
 static auto const DSF_VERSION =
     std::format("{}.{}.{}", DSF_VERSION_MAJOR, DSF_VERSION_MINOR, DSF_VERSION_PATCH);

src/dsf/headers/Geometry.hpp

@@ -18,7 +18,6 @@ namespace dsf {
       double m_y;
 
     public:
-      Point() = default;
       /// @brief Construct a Point with given x and y coordinates.
       /// @param x The x coordinate
       /// @param y The y coordinate
@@ -65,7 +64,7 @@ struct std::formatter<dsf::geometry::Point> {
   constexpr auto parse(format_parse_context& ctx) { return ctx.begin(); }
 
   template <typename FormatContext>
-  auto format(dsf::geometry::Point const& point, FormatContext&& ctx) {
+  auto format(dsf::geometry::Point const& point, FormatContext& ctx) const {
     return std::format_to(ctx.out(), "POINT ({}, {})", point.x(), point.y());
   }
 };
@@ -75,7 +74,7 @@ struct fmt::formatter<dsf::geometry::Point> {
   constexpr auto parse(fmt::format_parse_context& ctx) { return ctx.begin(); }
 
   template <typename FormatContext>
-  auto format(dsf::geometry::Point const& point, FormatContext& ctx) const {
+  auto format(dsf::geometry::Point const& point, FormatContext&& ctx) const {
     return fmt::format_to(ctx.out(), "POINT ({}, {})", point.x(), point.y());
   }
 };
@@ -85,7 +84,7 @@ struct std::formatter<dsf::geometry::PolyLine> {
   constexpr auto parse(format_parse_context& ctx) { return ctx.begin(); }
 
   template <typename FormatContext>
-  auto format(dsf::geometry::PolyLine const& polyline, FormatContext&& ctx) {
+  auto format(dsf::geometry::PolyLine const& polyline, FormatContext&& ctx) const {
     auto out = std::format_to(ctx.out(), "LINESTRING (");
     for (std::size_t i = 0; i < polyline.size(); ++i) {
       if (i > 0) {

src/dsf/headers/Intersection.hpp

@@ -115,20 +115,20 @@ struct std::formatter<dsf::Intersection> {
   constexpr auto parse(format_parse_context& ctx) { return ctx.begin(); }
 
   template <typename FormatContext>
-  auto format(dsf::Intersection const& intersection, FormatContext&& ctx) {
-    return std::format_to(
+  auto format(dsf::Intersection const& intersection, FormatContext&& ctx) const {
+    auto out = std::format_to(
         ctx.out(),
         "Intersection(id: {}, name: {}, capacity: {}, transportCapacity: {}, "
-        "nAgents: {}, coords: {})",
+        "nAgents: {}, coords: ",
         intersection.id(),
         intersection.name(),
         intersection.capacity(),
         intersection.transportCapacity(),
         intersection.nAgents());
     if (intersection.geometry().has_value()) {
-      return std::format_to(ctx.out(), "{})", *intersection.geometry());
+      return std::format_to(out, "{})", *intersection.geometry());
     } else {
-      return std::format_to(ctx.out(), "N/A)");
+      return std::format_to(out, "N/A)");
     }
   }
 };

src/dsf/sources/Geometry.cpp

@@ -15,7 +15,12 @@ namespace dsf {
         }
         std::string coordStr = strPoint.substr(start + 1, end - start - 1);
         std::istringstream coordStream(coordStr);
-        coordStream >> m_x >> m_y;
+        double x, y;
+        if (!(coordStream >> x >> y)) {
+          throw std::invalid_argument("Malformed WKT POINT coordinates: " + strPoint);
+        }
+        m_x = x;
+        m_y = y;
       } else {
         throw std::invalid_argument("Unsupported format: " + format);
       }
@@ -37,7 +42,15 @@ namespace dsf {
         while (std::getline(coordsStream, pointStr, ',')) {
           std::istringstream pointStream(pointStr);
           double x, y;
-          pointStream >> x >> y;
+          std::string extra;
+          if (!(pointStream >> x >> y)) {
+            throw std::invalid_argument("Malformed WKT LINESTRING point: " + pointStr);
+          }
+          // Should not be any extra tokens after two numbers
+          if (pointStream >> extra) {
+            throw std::invalid_argument("Too many values in WKT LINESTRING point: " +
+                                        pointStr);
+          }
           this->push_back(Point{x, y});
         }
       } else {

src/dsf/sources/Intersection.cpp

@@ -7,7 +7,7 @@
 namespace dsf {
   void Intersection::setCapacity(Size capacity) {
     if (capacity < m_agents.size()) {
-      throw std::logic_error(std::format(
+      throw std::runtime_error(std::format(
           "Intersection capacity ({}) is smaller than the current queue size ({}).",
           capacity,
           m_agents.size()));
@@ -16,7 +16,9 @@ namespace dsf {
   }
 
   void Intersection::addAgent(double angle, std::unique_ptr<Agent> pAgent) {
-    assert(!isFull());
+    if (isFull()) {
+      throw std::runtime_error(std::format("{} is full.", *this));
+    }
     auto iAngle{static_cast<int16_t>(angle * 100)};
     m_agents.emplace(iAngle, std::move(pAgent));
     ++m_agentCounter;

test/Test_geometry.cpp

@@ -0,0 +1,68 @@
+#include "../src/dsf/headers/Geometry.hpp"
+#include "doctest.h"
+#include <string>
+
+using namespace dsf::geometry;
+
+TEST_CASE("Point constructors and equality") {
+  SUBCASE("Double constructor") {
+    Point p(1.5, -2.3);
+    CHECK_EQ(p.x(), 1.5);
+    CHECK_EQ(p.y(), -2.3);
+  }
+  SUBCASE("String constructor WKT") {
+    Point p("POINT(3.2 4.5)");
+    CHECK_EQ(p.x(), 3.2);
+    CHECK_EQ(p.y(), 4.5);
+  }
+  SUBCASE("Equality operator") {
+    Point p1(1.0, 2.0);
+    Point p2(1.0, 2.0);
+    Point p3(1.0, 2.0000001);
+    CHECK(p1 == p2);
+    CHECK_FALSE(p1 == p3);
+  }
+}
+
+TEST_CASE("PolyLine constructors and parsing") {
+  SUBCASE("Default constructor") {
+    PolyLine pl;
+    CHECK(pl.empty());
+  }
+  SUBCASE("Empty WKT LINESTRING") {
+    auto emptyPoly = PolyLine("LINESTRING()");
+    CHECK(emptyPoly.empty());
+  }
+  SUBCASE("Initializer list constructor") {
+    PolyLine pl{Point(1, 2), Point(3, 4)};
+    CHECK_EQ(pl.size(), 2);
+    CHECK_EQ(pl[0].x(), 1);
+    CHECK_EQ(pl[0].y(), 2);
+    CHECK_EQ(pl[1].x(), 3);
+    CHECK_EQ(pl[1].y(), 4);
+  }
+  SUBCASE("WKT LINESTRING constructor") {
+    PolyLine pl("LINESTRING(1 2, 3 4, 5 6)");
+    CHECK_EQ(pl.size(), 3);
+    CHECK_EQ(pl[0].x(), 1);
+    CHECK_EQ(pl[0].y(), 2);
+    CHECK_EQ(pl[1].x(), 3);
+    CHECK_EQ(pl[1].y(), 4);
+    CHECK_EQ(pl[2].x(), 5);
+    CHECK_EQ(pl[2].y(), 6);
+  }
+  SUBCASE("WKT LINESTRING with extra spaces") {
+    PolyLine pl("LINESTRING( 1 2 , 3 4 , 5 6 )");
+    CHECK_EQ(pl.size(), 3);
+    CHECK_EQ(pl[0].x(), 1);
+    CHECK_EQ(pl[0].y(), 2);
+    CHECK_EQ(pl[1].x(), 3);
+    CHECK_EQ(pl[1].y(), 4);
+    CHECK_EQ(pl[2].x(), 5);
+    CHECK_EQ(pl[2].y(), 6);
+  }
+  SUBCASE("Invalid WKT format throws") {
+    CHECK_THROWS_AS(PolyLine("LINESTRING(1,2,3,4)"), std::invalid_argument);
+    CHECK_THROWS_AS(PolyLine("LINESTRING(1 2 3 4)"), std::invalid_argument);
+  }
+}

test/Test_itinerary.cpp

@@ -8,16 +8,89 @@ using Itinerary = dsf::Itinerary;
 
 TEST_CASE("Itinerary") {
   SUBCASE("Constructors") {
-    GIVEN("Some parameters") {
-      dsf::Id itineraryId{0};
-      dsf::Id destinationId{2};
-      WHEN("The Itinerary is constructed") {
-        Itinerary itinerary{itineraryId, destinationId};
-        THEN("The source and destination are set correctly") {
-          CHECK_EQ(itinerary.id(), itineraryId);
-          CHECK_EQ(itinerary.destination(), destinationId);
-        }
-      }
+    dsf::Id itineraryId{0};
+    dsf::Id destinationId{2};
+    Itinerary itinerary{itineraryId, destinationId};
+    CHECK_EQ(itinerary.id(), itineraryId);
+    CHECK_EQ(itinerary.destination(), destinationId);
+  }
+
+  SUBCASE("Set and get path") {
+    Itinerary itinerary{1, 42};
+    std::unordered_map<dsf::Id, std::vector<dsf::Id>> path = {
+        {1, {2, 3}}, {2, {4}}, {3, {5, 6, 7}}};
+    itinerary.setPath(path);
+    auto const& result = itinerary.path();
+    CHECK_EQ(result.size(), path.size());
+    for (const auto& [k, v] : path) {
+      CHECK(result.count(k) == 1);
+      CHECK(result.at(k) == v);
+    }
+  }
+
+  SUBCASE("Save and load itinerary") {
+    Itinerary itinerary{7, 99};
+    std::unordered_map<dsf::Id, std::vector<dsf::Id>> path = {
+        {7, {8, 9}}, {8, {10}}, {9, {11, 12}}};
+    itinerary.setPath(path);
+    const std::string filename = "test_itinerary.bin";
+    itinerary.save(filename);
+
+    Itinerary loaded{7, 0};  // destination will be overwritten by load
+    loaded.load(filename);
+    CHECK_EQ(loaded.destination(), 99);
+    auto const& loadedPath = loaded.path();
+    CHECK_EQ(loadedPath.size(), path.size());
+    for (const auto& [k, v] : path) {
+      CHECK(loadedPath.count(k) == 1);
+      CHECK(loadedPath.at(k) == v);
+    }
+    // Clean up
+    std::remove(filename.c_str());
+  }
+
+  SUBCASE("Load from non-existent file throws") {
+    Itinerary itinerary{1, 2};
+    CHECK_THROWS_AS(itinerary.load("nonexistent_file.bin"), std::runtime_error);
+  }
+
+  SUBCASE("Empty path") {
+    Itinerary itinerary{123, 456};
+    itinerary.setPath({});
+    CHECK(itinerary.path().empty());
+    const std::string filename = "test_empty_path.bin";
+    itinerary.save(filename);
+    Itinerary loaded{123, 0};
+    loaded.load(filename);
+    CHECK(loaded.path().empty());
+    std::remove(filename.c_str());
+  }
+
+  SUBCASE("Large path") {
+    Itinerary itinerary{100, 200};
+    std::unordered_map<dsf::Id, std::vector<dsf::Id>> path;
+    for (dsf::Id i = 0; i < 100; ++i) {
+      std::vector<dsf::Id> v;
+      for (dsf::Id j = 0; j < 10; ++j)
+        v.push_back(i * 10 + j);
+      path[i] = v;
+    }
+    itinerary.setPath(path);
+    CHECK_EQ(itinerary.path().size(), 100);
+    for (dsf::Id i = 0; i < 100; ++i) {
+      CHECK(itinerary.path().count(i) == 1);
+      CHECK(itinerary.path().at(i).size() == 10);
+    }
+    const std::string filename = "test_large_path.bin";
+    itinerary.save(filename);
+    Itinerary loaded{100, 0};
+    loaded.load(filename);
+    CHECK_EQ(loaded.path().size(), 100);
+    for (dsf::Id i = 0; i < 100; ++i) {
+      CHECK(loaded.path().count(i) == 1);
+      CHECK(loaded.path().at(i).size() == 10);
+      CHECK(loaded.path().at(i) == path[i]);
     }
+    std::remove(filename.c_str());
   }
 }