add googletest to the project (#8)

* add googletest to the project

* add clean functionality

* add tests for leading zeroes

* enable <==> operator

* add more fields for testing

* add comment

* add more tests

* check if non-digit components exist

Author: anonrig

.gitignore

@@ -1,2 +1,4 @@
 build
 cmake-build-debug
+tests/Testing
+Testing

CMakeLists.txt

@@ -10,6 +10,15 @@ endif()
 
 include(GNUInstallDirs)
 
+include(FetchContent)
+FetchContent_Declare(
+  googletest
+  URL https://github.com/google/googletest/archive/03597a01ee50ed33e9dfd640b249b4be3799d395.zip
+)
+# For Windows: Prevent overriding the parent project's compiler/linker settings
+set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
+FetchContent_MakeAvailable(googletest)
+
 add_subdirectory(src)
 enable_testing()
 add_subdirectory(tests)

README.md

@@ -8,6 +8,6 @@ Usage:
 ```
 cmake -B build
 cmake --build build
-ctest --test-dir build
+ctest --test-dir build --output-on-failure
 ./build/benchmarks/benchmark 
-```
+```

include/version_weaver.h

@@ -11,12 +11,9 @@ namespace version_weaver {
 static constexpr size_t MAX_VERSION_LENGTH = 256;
 
 bool validate(std::string_view version);
-bool gt(std::string_view version1, std::string_view version2);
-bool lt(std::string_view version1, std::string_view version2);
 bool satisfies(std::string_view version, std::string_view range);
 std::string coerce(std::string_view version);
 std::string minimum(std::string_view range);
-std::string clean(std::string_view range);
 
 // A normal version number MUST take the form X.Y.Z where X, Y, and Z are
 // non-negative integers, and MUST NOT contain leading zeroes.
@@ -58,6 +55,11 @@ enum ParseError {
   INVALID_INPUT,
 };
 
+// This will return a cleaned and trimmed semver version.
+// If the provided version is not valid a null will be returned.
+// This does not work for ranges.
+std::expected<Version, ParseError> clean(std::string_view range);
+
 std::expected<Version, ParseError> parse(std::string_view version);
 }  // namespace version_weaver
 
@@ -73,10 +75,15 @@ inline bool operator==(const version_weaver::Version& first,
   if (first.minor != second.minor) return first.minor == second.minor;
   return first.patch == second.patch;
 }
-/*
-inline auto operator<=>(const version_weaver::Version& first, const
-version_weaver::Version& second) { if (first.major != second.major) return
-first.major <=> second.major; if (first.minor != second.minor) return
-first.minor <=> second.minor; return first.patch <=> second.patch;
-}*/
+inline auto operator<=>(const version_weaver::Version& first,
+                        const version_weaver::Version& second) {
+  if (first.major != second.major) {
+    return first.major <=> second.major;
+  }
+  if (first.minor != second.minor) {
+    return first.minor <=> second.minor;
+  }
+  return first.patch <=> second.patch;
+}
+
 #endif  // VERSION_WEAVER_H

src/version_weaver.cpp

@@ -2,18 +2,14 @@
 #include <algorithm>
 #include <cctype>
 namespace version_weaver {
-bool validate(std::string_view version) { return bool(parse(version)); }
-
-bool gt(std::string_view version1, std::string_view version2) { return true; }
-bool lt(std::string_view version1, std::string_view version2) { return true; }
+bool validate(std::string_view version) { return parse(version).has_value(); }
 bool satisfies(std::string_view version, std::string_view range) {
   return true;
 }
 std::string coerce(std::string_view version) { return ""; }
 std::string minimum(std::string_view range) { return ""; }
-std::string clean(std::string_view range) { return ""; }
 
-inline void trim_whitespace(std::string_view* input) noexcept {
+constexpr inline void trim_whitespace(std::string_view* input) noexcept {
   while (!input->empty() && std::isspace(input->front())) {
     input->remove_prefix(1);
   }
@@ -22,6 +18,29 @@ inline void trim_whitespace(std::string_view* input) noexcept {
   }
 }
 
+constexpr inline bool contains_only_digits(std::string_view input) noexcept {
+  // Optimization opportunity: Replace this with a hash table lookup.
+  return input.find_first_not_of("0123456789") == std::string_view::npos;
+}
+
+std::expected<Version, ParseError> clean(std::string_view input) {
+  std::string_view range = input;
+  trim_whitespace(&range);
+  if (range.empty()) return std::unexpected(ParseError::INVALID_INPUT);
+
+  // Trim any leading value expect = and v.
+  while (!range.empty() && (range.front() == '=' || range.front() == 'v')) {
+    range.remove_prefix(1);
+  }
+
+  // If range starts with a non-digit character, it is invalid.
+  if (!range.empty() && !std::isdigit(range.front())) {
+    return std::unexpected(ParseError::INVALID_INPUT);
+  }
+
+  return parse(range);
+}
+
 std::expected<Version, ParseError> parse(std::string_view input) {
   if (input.size() > MAX_VERSION_LENGTH) {
     return std::unexpected(ParseError::VERSION_LARGER_THAN_MAX_LENGTH);
@@ -42,6 +61,9 @@ std::expected<Version, ParseError> parse(std::string_view input) {
     // Version components can not have leading zeroes.
     return std::unexpected(ParseError::INVALID_INPUT);
   }
+  if (!contains_only_digits(major)) {
+    return std::unexpected(ParseError::INVALID_INPUT);
+  }
   version.major = major;
   input_copy = input_copy.substr(dot_iterator + 1);
   dot_iterator = input_copy.find('.');
@@ -55,6 +77,9 @@ std::expected<Version, ParseError> parse(std::string_view input) {
     // Version components can not have leading zeroes.
     return std::unexpected(ParseError::INVALID_INPUT);
   }
+  if (!contains_only_digits(minor)) {
+    return std::unexpected(ParseError::INVALID_INPUT);
+  }
   version.minor = minor;
   input_copy = input_copy.substr(dot_iterator + 1);
   dot_iterator = input_copy.find_first_of("-+");
@@ -64,6 +89,9 @@ std::expected<Version, ParseError> parse(std::string_view input) {
   if (patch.empty() || (patch.front() == '0' && patch.size() > 1)) {
     return std::unexpected(ParseError::INVALID_INPUT);
   }
+  if (!contains_only_digits(patch)) {
+    return std::unexpected(ParseError::INVALID_INPUT);
+  }
   version.patch = patch;
   if (dot_iterator == std::string_view::npos) {
     return version;

tests/CMakeLists.txt

@@ -1,4 +1,10 @@
+include(GoogleTest)
 include(CTest)
 add_executable(basictests basictests.cpp)
+target_link_libraries(
+  basictests
+  GTest::gtest_main
+)
 target_link_libraries(basictests version_weaver)
-add_test(basictests_test basictests)
+add_test(basictests_test basictests)
+gtest_discover_tests(basictests)

tests/basictests.cpp

@@ -1,49 +1,86 @@
 #include "version_weaver.h"
-#include <cstdlib>
-#include <vector>
 #include <format>
+#include <vector>
+
+#include <gtest/gtest.h>
+
+using TestData =
+    std::pair<std::string, std::expected<version_weaver::Version,
+                                         version_weaver::ParseError>>;
+std::vector<TestData> parse_values = {
+    {"1.0.0", version_weaver::Version{"1", "0", "0"}},
+    {"1.0.0-alpha", version_weaver::Version{"1", "0", "0", "alpha"}},
+    {"1.0.0-alpha.1", version_weaver::Version{"1", "0", "0", "alpha.1"}},
+    {"1.0.0-0.3.7", version_weaver::Version{"1", "0", "0", "0.3.7"}},
+    {"1.0.0-x.7.z.92", version_weaver::Version{"1", "0", "0", "x.7.z.92"}},
+    {"1.0.0-x-y-z.--", version_weaver::Version{"1", "0", "0", "x-y-z.--"}},
+    {"1.0.0-alpha+001", version_weaver::Version{"1", "0", "0", "alpha", "001"}},
+    {"1.0.0+20130313144700",
+     version_weaver::Version{"1", "0", "0", std::nullopt, "20130313144700"}},
+    {"1.0.0-beta+exp.sha.5114f85",
+     version_weaver::Version{"1", "0", "0", "beta", "exp.sha.5114f85"}},
+    {"1.0.0+21AF26D3----117B344092BD",
+     version_weaver::Version{"1", "0", "0", std::nullopt,
+                             "21AF26D3----117B344092BD"}},
 
-std::vector<std::pair<std::string, std::expected<version_weaver::Version,
-                                                 version_weaver::ParseError>>>
-    test_values = {
-        {"1.0.0", version_weaver::Version{"1", "0", "0"}},
-        {"1.0.0-alpha", version_weaver::Version{"1", "0", "0", "alpha"}},
-        {"1.0.0-alpha.1", version_weaver::Version{"1", "0", "0", "alpha.1"}},
-        {"1.0.0-0.3.7", version_weaver::Version{"1", "0", "0", "0.3.7"}},
-        {"1.0.0-x.7.z.92", version_weaver::Version{"1", "0", "0", "x.7.z.92"}},
-        {"1.0.0-x-y-z.--", version_weaver::Version{"1", "0", "0", "x-y-z.--"}},
-        {"1.0.0-alpha+001",
-         version_weaver::Version{"1", "0", "0", "alpha", "001"}},
-        {"1.0.0+20130313144700",
-         version_weaver::Version{"1", "0", "0", "", "20130313144700"}},
-        {"1.0.0-beta+exp.sha.5114f85",
-         version_weaver::Version{"1", "0", "0", "beta", "exp.sha.5114f85"}},
-        {"1.0.0+21AF26D3----117B344092BD",
-         version_weaver::Version{"1", "0", "0", "",
-                                 "21AF26D3----117B344092BD"}},
 };
 
-bool test_parse() {
-  for (const auto& [input, expected] : test_values) {
-    auto result = version_weaver::parse(input);
-    if (bool(result) != bool(expected)) {
-      std::printf("Expected %d, got %d\n", bool(expected), bool(result));
-      return false;
-    }
-    if (bool(result)) {
-      if (result.value() != expected.value()) {
-        std::printf("Expected \n");
-        return false;
-      }
+TEST(basictests, parse) {
+  for (const auto& [input, expected] : parse_values) {
+    auto parse_result = version_weaver::parse(input);
+    ASSERT_EQ(parse_result.has_value(), expected.has_value());
+    if (parse_result.has_value()) {
+      ASSERT_EQ(parse_result->major, expected->major);
+      ASSERT_EQ(parse_result->minor, expected->minor);
+      ASSERT_EQ(parse_result->patch, expected->patch);
+      ASSERT_EQ(parse_result->pre_release, expected->pre_release);
+      ASSERT_EQ(parse_result->build, expected->build);
+    } else {
+      ASSERT_EQ(parse_result.error(), expected.error());
     }
   }
-  return true;
+
+  SUCCEED();
 }
-int main() {
-  if (!test_parse()) {
-    std::printf("Test failed\n");
-    return EXIT_FAILURE;
+
+// A normal version number MUST take the form X.Y.Z
+// where X, Y, and Z are non-negative integers, and
+// MUST NOT contain leading zeroes.
+TEST(basictests, leading_zeroes) {
+  ASSERT_FALSE(version_weaver::parse("0.0.0").has_value());
+  ASSERT_FALSE(version_weaver::parse("01.0.0").has_value());
+  ASSERT_FALSE(version_weaver::parse("1.01.0").has_value());
+  ASSERT_FALSE(version_weaver::parse("1.0.01").has_value());
+}
+
+std::vector<TestData> clean_values = {
+    {"1.2.3", version_weaver::Version{"1", "2", "3"}},
+    {" 1.2.3 ", version_weaver::Version{"1", "2", "3"}},
+    {" 1.2.3-4 ", version_weaver::Version{"1", "2", "3", "4"}},
+    {" 1.2.3-pre ", version_weaver::Version{"1", "2", "3", "pre"}},
+    {"  =v1.2.3   ", version_weaver::Version{"1", "2", "3"}},
+    {"v1.2.3", version_weaver::Version{"1", "2", "3"}},
+    {" v1.2.3 ", version_weaver::Version{"1", "2", "3"}},
+    {"\t1.2.3", version_weaver::Version{"1", "2", "3"}},
+    {">1.2.3", std::unexpected(version_weaver::ParseError::INVALID_INPUT)},
+    {"~1.2.3", std::unexpected(version_weaver::ParseError::INVALID_INPUT)},
+    {"<=1.2.3", std::unexpected(version_weaver::ParseError::INVALID_INPUT)},
+    {"1.2.x", std::unexpected(version_weaver::ParseError::INVALID_INPUT)},
+};
+
+TEST(basictests, clean) {
+  for (const auto& [input, expected] : clean_values) {
+    auto cleaned_result = version_weaver::clean(input);
+    std::printf("input: %s\n", input.c_str());
+    ASSERT_EQ(cleaned_result.has_value(), expected.has_value());
+    if (cleaned_result.has_value()) {
+      ASSERT_EQ(cleaned_result->major, expected->major);
+      ASSERT_EQ(cleaned_result->minor, expected->minor);
+      ASSERT_EQ(cleaned_result->patch, expected->patch);
+      ASSERT_EQ(cleaned_result->pre_release, expected->pre_release);
+      ASSERT_EQ(cleaned_result->build, expected->build);
+    } else {
+      ASSERT_EQ(cleaned_result.error(), expected.error());
+    }
   }
-  std::printf("Tests succeeded!\n");
-  return EXIT_SUCCESS;
-}
+}