From 76506c5ffdc614ddaccccc7ba9b3a9c6150dd2f8 Mon Sep 17 00:00:00 2001 From: Marko Zivanovic Date: Thu, 8 Oct 2015 00:40:45 +0200 Subject: [PATCH] Initial version of semver 2.0.0 parser. --- .gitignore | 28 +++ CMakeLists.txt | 39 +++++ LICENSE | 22 +++ include/version.h | 71 ++++++++ src/CMakeLists.txt | 7 + src/version.cpp | 158 +++++++++++++++++ test/CMakeLists.txt | 23 +++ test/semver200_comparator_tests.cpp | 127 ++++++++++++++ test/semver200_parser_tests.cpp | 257 ++++++++++++++++++++++++++++ test/semver200_validator_tests.cpp | 31 ++++ 10 files changed, 763 insertions(+) create mode 100644 .gitignore create mode 100644 CMakeLists.txt create mode 100644 LICENSE create mode 100644 include/version.h create mode 100644 src/CMakeLists.txt create mode 100644 src/version.cpp create mode 100644 test/CMakeLists.txt create mode 100644 test/semver200_comparator_tests.cpp create mode 100644 test/semver200_parser_tests.cpp create mode 100644 test/semver200_validator_tests.cpp diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..b8bd026 --- /dev/null +++ b/.gitignore @@ -0,0 +1,28 @@ +# Compiled Object files +*.slo +*.lo +*.o +*.obj + +# Precompiled Headers +*.gch +*.pch + +# Compiled Dynamic libraries +*.so +*.dylib +*.dll + +# Fortran module files +*.mod + +# Compiled Static libraries +*.lai +*.la +*.a +*.lib + +# Executables +*.exe +*.out +*.app diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644 index 0000000..f9c6ece --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,39 @@ +cmake_minimum_required(VERSION 3.0) +project(semver) +set(VERSION_MAJOR "0") +set(VERSION_MINOR "1") +set(VERSION_PATCH "0") +set(VERSION_RELEASE "alpha") +set(VERSION_BUILD "") + +# Build full version string, including optional components +string(COMPARE NOTEQUAL VERSION_RELEASE "" HAVE_RELEASE) +string(COMPARE NOTEQUAL VERSION_BUILD "" HAVE_BUILD) +set(VERSION_FULL "${VERSION_MAJOR}.${VERSION_MINOR}.${VERSION_PATCH}") +if(HAVE_RELEASE) + set(VERSION_FULL "${VERSION_FULL}-${VERSION_RELEASE}") +endif() +if(HAVE_BUILD) + set(VERSION_FULL "${VERSION_FULL}-${VERSION_BUILD}") +endif() + +if(UNIX) + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Werror -Wextra -pedantic") + add_definitions(-std=c++14) +endif() + +if(WIN32) + add_definitions(-DWINVER=0x0601) + add_definitions(-D_WIN32_WINNT=0x0601) +endif() + +if(MSVC) + add_definitions(-D_SCL_SECURE_NO_WARNINGS) +endif() + +add_subdirectory(src) +add_subdirectory(test) + +enable_testing() +add_test(NAME semver200_parser_tests COMMAND semver200_parser_tests) +add_test(NAME semver200_comparator_tests COMMAND semver200_comparator_tests) diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..5323465 --- /dev/null +++ b/LICENSE @@ -0,0 +1,22 @@ +The MIT License (MIT) + +Copyright (c) 2015 Marko Živanović + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. + diff --git a/include/version.h b/include/version.h new file mode 100644 index 0000000..3068a9e --- /dev/null +++ b/include/version.h @@ -0,0 +1,71 @@ +/* +The MIT License (MIT) + +Copyright (c) 2015 Marko Zivanovic + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +#pragma once + +#include +#include + +namespace version { + + struct Version_data { + int major; + int minor; + int patch; + std::string release; + std::string build; + }; + + struct Semver200_parser { + Version_data parse(const std::string&); + }; + + struct Semver200_comparator { + int compare(const Version_data&, const Version_data&); + }; + + template + class Basic_version { + public: + Basic_version(const std::string&, Parser, Comparator); + + bool operator>(const Basic_version&); + bool operator>=(const Basic_version&); + bool operator<(const Basic_version&); + bool operator<=(const Basic_version&); + bool operator==(const Basic_version&); + bool operator!=(const Basic_version&); + + private: + Parser parser_; + Comparator comparator_; + const Version_data ver_; + }; + + class Semver200 : public Basic_version {}; + + class Parse_error : public std::runtime_error { + using std::runtime_error::runtime_error; + }; +} diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt new file mode 100644 index 0000000..9c4f51d --- /dev/null +++ b/src/CMakeLists.txt @@ -0,0 +1,7 @@ +include_directories( + ../include +) + +add_library(semver + version.cpp +) diff --git a/src/version.cpp b/src/version.cpp new file mode 100644 index 0000000..eefe506 --- /dev/null +++ b/src/version.cpp @@ -0,0 +1,158 @@ +/* +The MIT License (MIT) + +Copyright (c) 2015 Marko Zivanovic + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +#include +#include +#include "version.h" + +using namespace std; + +namespace { + enum class Parser_phase { + major, minor, patch, release, build + }; + + using Phase_transition_hook = function; + using Transition = tuple; + using Validator = function; + + inline Transition mkx(const char c, Parser_phase p, Phase_transition_hook px) { + return make_tuple(c, p, px); + } + + inline void process_char(const char c, Parser_phase& phase, const vector transitions, + string& target, Validator validate) { + for (const auto& t : transitions) { + if (c == get<0>(t)) { + phase = get<1>(t); + if (get<2>(t)) get<2>(t)(target); + return; + } + } + validate(target, c); + target.push_back(c); + } + + auto normal_version_validator = [](const string& tgt, const char c) { + if (c < '0' || c > '9') throw version::Parse_error("invalid character encountered: " + string(1, c)); + if (tgt.compare(0, 1, "0") == 0) throw version::Parse_error("leading 0 not allowed"); + }; + + auto release_version_validator = [](const string& tgt, const char c) { + if ((c < '0' || c > '9') && (c < 'A' || c > 'Z') && (c < 'a' || c > 'z') && c != '.' && c != '-') + throw version::Parse_error("invalid character encountered: " + string(1, c)); + }; + + void validate_release_identifier(const string& id) { + if (id.find_first_not_of("0123456789") == string::npos + && id.compare(0, 1, "0") == 0) { + throw version::Parse_error("leading 0 not allowed"); + } + } + + void validate_release_identifiers(const string& release) { + string id; + for (const auto& c : release) { + if (c == '.') { + validate_release_identifier(id); + id.clear(); + } else { + id.push_back(c); + } + } + validate_release_identifier(id); + } +} + +namespace version { + + Version_data Semver200_parser::parse(const string& s) { + string major; + string minor; + string patch; + string release; + string build; + + auto process_release_component = [&](const string& t) { + if (t.empty()) throw Parse_error("version identifier cannot be empty"); + if (t.compare(t.length() - 1, 1, ".") == 0) throw Parse_error("version identifier cannot be empty"); + release.push_back('.');}; + + auto process_build_component = [&](const string& t) { + if (t.empty()) throw Parse_error("version identifier cannot be empty"); + if (t.compare(t.length() - 1, 1, ".") == 0) throw Parse_error("version identifier cannot be empty"); + build.push_back('.');}; + + auto major_xs = { + mkx('.', Parser_phase::minor, {}) + }; + auto minor_xs = { + mkx('.', Parser_phase::patch, {}) + }; + auto patch_xs = { + mkx('-', Parser_phase::release, {}), + mkx('+', Parser_phase::build, {}) + }; + auto release_xs = { + mkx('.', Parser_phase::release, process_release_component), + mkx('+', Parser_phase::build, {}) + }; + auto build_xs = { + mkx('.', Parser_phase::build, process_build_component) + }; + Parser_phase phase = Parser_phase::major; + for (const auto& c : s) { + switch (phase) { + case Parser_phase::major: + process_char(c, phase, major_xs, major, normal_version_validator); + break; + case Parser_phase::minor: + process_char(c, phase, minor_xs, minor, normal_version_validator); + break; + case Parser_phase::patch: + process_char(c, phase, patch_xs, patch, normal_version_validator); + break; + case Parser_phase::release: + process_char(c, phase, release_xs, release, release_version_validator); + break; + case Parser_phase::build: + process_char(c, phase, build_xs, build, release_version_validator); + break; + } + } + + validate_release_identifiers(release); + + try { + return Version_data{ stoi(major), stoi(minor), stoi(patch), release, build }; + } catch (invalid_argument& ex) { + throw Parse_error(ex.what()); + } + } + + int Semver200_comparator::compare(const Version_data& l, const Version_data& r) { + throw 1; + } + +} diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt new file mode 100644 index 0000000..afe37cc --- /dev/null +++ b/test/CMakeLists.txt @@ -0,0 +1,23 @@ +set(Boost_USE_STATIC_LIBS ON) +set(Boost_USE_MULTITHREADED ON) + +find_package(Boost COMPONENTS unit_test_framework) +#find_package(Threads) + +include_directories(../include) + +include_directories( + ${Boost_INCLUDE_DIRS} +) + +add_executable(semver200_parser_tests semver200_parser_tests.cpp) +target_link_libraries(semver200_parser_tests + ${Boost_UNIT_TEST_FRAMEWORK_LIBRARY} + semver +) + +add_executable(semver200_comparator_tests semver200_comparator_tests.cpp) +target_link_libraries(semver200_comparator_tests + ${Boost_UNIT_TEST_FRAMEWORK_LIBRARY} + semver +) diff --git a/test/semver200_comparator_tests.cpp b/test/semver200_comparator_tests.cpp new file mode 100644 index 0000000..fc59078 --- /dev/null +++ b/test/semver200_comparator_tests.cpp @@ -0,0 +1,127 @@ +/* +The MIT License (MIT) + +Copyright (c) 2015 Marko Zivanovic + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +#define BOOST_TEST_MODULE semver200_comparator_tests + +#include +#include "version.h" + +using namespace version; + +int compare(const std::string& l, const std::string& r) { + Semver200_comparator c; + Semver200_parser p; + auto lv = p.parse(l); + auto rv = p.parse(r); + return c.compare(lv, rv); +} + +BOOST_AUTO_TEST_CASE(compare_normal_eq) { + BOOST_CHECK(compare("0.0.0", "0.0.0") == 0); +} + +BOOST_AUTO_TEST_CASE(compare_normal_major_gt_1) { + BOOST_CHECK(compare("1.0.0", "0.0.0") == 1); +} + +BOOST_AUTO_TEST_CASE(compare_normal_major_gt_2) { + BOOST_CHECK(compare("1.0.0", "0.0.5") == 1); +} + +BOOST_AUTO_TEST_CASE(compare_normal_major_gt_3) { + BOOST_CHECK(compare("1.0.0", "0.17.0") == 1); +} + +BOOST_AUTO_TEST_CASE(compare_normal_minor_gt_1) { + BOOST_CHECK(compare("1.1.0", "1.0.0") == 1); +} + +BOOST_AUTO_TEST_CASE(compare_normal_minor_gt_2) { + BOOST_CHECK(compare("1.1.0", "1.0.32") == 1); +} + +BOOST_AUTO_TEST_CASE(compare_normal_patch_gt) { + BOOST_CHECK(compare("1.1.3", "1.1.0") == 1); +} + +BOOST_AUTO_TEST_CASE(compare_normal_major_lt_1) { + BOOST_CHECK(compare("1.0.0", "2.0.0") == -1); +} + +BOOST_AUTO_TEST_CASE(compare_normal_major_lt_2) { + BOOST_CHECK(compare("1.0.1", "2.0.0") == -1); +} + +BOOST_AUTO_TEST_CASE(compare_normal_major_lt_3) { + BOOST_CHECK(compare("1.3.0", "2.0.0") == -1); +} + +BOOST_AUTO_TEST_CASE(compare_normal_minor_lt_1) { + BOOST_CHECK(compare("1.1.0", "1.2.0") == -1); +} + +BOOST_AUTO_TEST_CASE(compare_normal_minor_lt_2) { + BOOST_CHECK(compare("1.1.3", "1.2.0") == -1); +} + +BOOST_AUTO_TEST_CASE(compare_normal_patch_lt) { + BOOST_CHECK(compare("1.1.3", "1.1.5") == -1); +} + +BOOST_AUTO_TEST_CASE(compare_prerel_single_eq) { + BOOST_CHECK(compare("1.1.3-prerel", "1.1.3-prerel") == 1); +} + +BOOST_AUTO_TEST_CASE(compare_prerel_multiple_eq) { + BOOST_CHECK(compare("1.1.3-prerel.1.2.3", "1.1.3-prerel.1.2.3") == 1); +} + +BOOST_AUTO_TEST_CASE(compare_prerel_multiple_num_eq) { + BOOST_CHECK(compare("1.1.3-prerel.123", "1.1.3-prerel.123") == 1); +} + +BOOST_AUTO_TEST_CASE(compare_prerel_multiple_num_gt) { + BOOST_CHECK(compare("1.1.3-prerel.123", "1.1.3-prerel.120") == 1); +} + +BOOST_AUTO_TEST_CASE(compare_prerel_multiple_num_lt) { + BOOST_CHECK(compare("1.1.3-prerel.123", "1.1.3-prerel.125") == -1); +} + +BOOST_AUTO_TEST_CASE(compare_prerel_single_alpha_gt) { + BOOST_CHECK(compare("1.1.3-alpha", "1.1.3-beta") == 1); +} + +BOOST_AUTO_TEST_CASE(compare_prerel_single_alpha_lt) { + BOOST_CHECK(compare("1.1.3-beta", "1.1.3-gamma") == -1); +} + +BOOST_AUTO_TEST_CASE(compare_prerel_single_alpha_gt_2) { + BOOST_CHECK(compare("1.1.3-alpha5", "1.1.3-alpha4") == 1); +} + +BOOST_AUTO_TEST_CASE(compare_prerel_single_alpha_lt_2) { + BOOST_CHECK(compare("1.1.3-beta3", "1.1.3-beta5") == -1); +} + diff --git a/test/semver200_parser_tests.cpp b/test/semver200_parser_tests.cpp new file mode 100644 index 0000000..e8df487 --- /dev/null +++ b/test/semver200_parser_tests.cpp @@ -0,0 +1,257 @@ +/* +The MIT License (MIT) + +Copyright (c) 2015 Marko Zivanovic + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +#define BOOST_TEST_MODULE semver200_parser_tests + +#include +#include "version.h" + +using namespace version; + +Version_data parse(const std::string& s) { + Semver200_parser p; + return p.parse(s); +} + +BOOST_AUTO_TEST_CASE(parse_normal) { + auto r = parse("1.0.0"); + BOOST_CHECK_EQUAL(r.major, 1); + BOOST_CHECK_EQUAL(r.minor, 0); + BOOST_CHECK_EQUAL(r.patch, 0); + BOOST_CHECK_EQUAL(r.release, ""); + BOOST_CHECK_EQUAL(r.build, ""); +} + +BOOST_AUTO_TEST_CASE(parse_normal_bad_format_1) { + BOOST_CHECK_THROW(parse("bad.version"), Parse_error); +} + +BOOST_AUTO_TEST_CASE(parse_normal_bad_format_2) { + BOOST_CHECK_THROW(parse("1.2.3.4"), Parse_error); +} + +BOOST_AUTO_TEST_CASE(parse_prerel_single) { + auto r = parse("1.0.0-prerelease"); + BOOST_CHECK_EQUAL(r.major, 1); + BOOST_CHECK_EQUAL(r.minor, 0); + BOOST_CHECK_EQUAL(r.patch, 0); + BOOST_CHECK_EQUAL(r.release, "prerelease"); + BOOST_CHECK_EQUAL(r.build, ""); +} + +BOOST_AUTO_TEST_CASE(parse_prerel_ok_multiple_1) { + auto r = parse("1.0.0-prerelease.rel-1"); + BOOST_CHECK_EQUAL(r.major, 1); + BOOST_CHECK_EQUAL(r.minor, 0); + BOOST_CHECK_EQUAL(r.patch, 0); + BOOST_CHECK_EQUAL(r.release, "prerelease.rel-1"); + BOOST_CHECK_EQUAL(r.build, ""); +} + +BOOST_AUTO_TEST_CASE(parse_prerel_ok_multiple_2) { + auto r = parse("1.0.0-prerelease.rel-1.b.c.f"); + BOOST_CHECK_EQUAL(r.major, 1); + BOOST_CHECK_EQUAL(r.minor, 0); + BOOST_CHECK_EQUAL(r.patch, 0); + BOOST_CHECK_EQUAL(r.release, "prerelease.rel-1.b.c.f"); + BOOST_CHECK_EQUAL(r.build, ""); +} + +BOOST_AUTO_TEST_CASE(parse_normal_build_single) { + auto r = parse("1.0.0+test"); + BOOST_CHECK_EQUAL(r.major, 1); + BOOST_CHECK_EQUAL(r.minor, 0); + BOOST_CHECK_EQUAL(r.patch, 0); + BOOST_CHECK_EQUAL(r.release, ""); + BOOST_CHECK_EQUAL(r.build, "test"); +} + +BOOST_AUTO_TEST_CASE(parse_normal_build_multiple) { + auto r = parse("1.0.0+test.123.4.5"); + BOOST_CHECK_EQUAL(r.major, 1); + BOOST_CHECK_EQUAL(r.minor, 0); + BOOST_CHECK_EQUAL(r.patch, 0); + BOOST_CHECK_EQUAL(r.release, ""); + BOOST_CHECK_EQUAL(r.build, "test.123.4.5"); +} + +BOOST_AUTO_TEST_CASE(parse_normal_prerel_single_build_single) { + auto r = parse("1.0.0-prerel+test"); + BOOST_CHECK_EQUAL(r.major, 1); + BOOST_CHECK_EQUAL(r.minor, 0); + BOOST_CHECK_EQUAL(r.patch, 0); + BOOST_CHECK_EQUAL(r.release, "prerel"); + BOOST_CHECK_EQUAL(r.build, "test"); +} + +BOOST_AUTO_TEST_CASE(parse_normal_prerel_single_build_multiple) { + auto r = parse("1.0.0-prerel+test.1.2.3"); + BOOST_CHECK_EQUAL(r.major, 1); + BOOST_CHECK_EQUAL(r.minor, 0); + BOOST_CHECK_EQUAL(r.patch, 0); + BOOST_CHECK_EQUAL(r.release, "prerel"); + BOOST_CHECK_EQUAL(r.build, "test.1.2.3"); +} + +BOOST_AUTO_TEST_CASE(parse_normal_prerel_multiple_build_single) { + auto r = parse("1.0.0-prerel.1.2.3+test"); + BOOST_CHECK_EQUAL(r.major, 1); + BOOST_CHECK_EQUAL(r.minor, 0); + BOOST_CHECK_EQUAL(r.patch, 0); + BOOST_CHECK_EQUAL(r.release, "prerel.1.2.3"); + BOOST_CHECK_EQUAL(r.build, "test"); +} + +BOOST_AUTO_TEST_CASE(parse_normal_prerel_multiple_build_multiple) { + auto r = parse("1.0.0-prerel.1.2.3+test.1.2.3"); + BOOST_CHECK_EQUAL(r.major, 1); + BOOST_CHECK_EQUAL(r.minor, 0); + BOOST_CHECK_EQUAL(r.patch, 0); + BOOST_CHECK_EQUAL(r.release, "prerel.1.2.3"); + BOOST_CHECK_EQUAL(r.build, "test.1.2.3"); +} + +BOOST_AUTO_TEST_CASE(parse_normal_all_empty) { + BOOST_CHECK_THROW(parse(".."), Parse_error); +} + +BOOST_AUTO_TEST_CASE(parse_normal_major_empty) { + BOOST_CHECK_THROW(parse(".0.0"), Parse_error); +} + +BOOST_AUTO_TEST_CASE(parse_normal_minor_empty) { + BOOST_CHECK_THROW(parse("1..0"), Parse_error); +} + +BOOST_AUTO_TEST_CASE(parse_normal_patch_empty) { + BOOST_CHECK_THROW(parse("1.1."), Parse_error); +} + +BOOST_AUTO_TEST_CASE(parse_normal_major_with_letters) { + BOOST_CHECK_THROW(parse("1a.0.0"), Parse_error); +} + +BOOST_AUTO_TEST_CASE(parse_normal_minor_with_letters) { + BOOST_CHECK_THROW(parse("1.0a.0"), Parse_error); +} + +BOOST_AUTO_TEST_CASE(parse_normal_patch_with_letters) { + BOOST_CHECK_THROW(parse("1.0.0a"), Parse_error); +} + +BOOST_AUTO_TEST_CASE(parse_normal_major_leading_0) { + BOOST_CHECK_THROW(parse("01.0.0"), Parse_error); +} + +BOOST_AUTO_TEST_CASE(parse_normal_minor_leading_0) { + BOOST_CHECK_THROW(parse("1.00.0"), Parse_error); +} + +BOOST_AUTO_TEST_CASE(parse_normal_patch_leading_0) { + BOOST_CHECK_THROW(parse("1.0.00"), Parse_error); +} + +BOOST_AUTO_TEST_CASE(parse_normal_major_negative) { + BOOST_CHECK_THROW(parse("-1.0.0"), Parse_error); +} + +BOOST_AUTO_TEST_CASE(parse_normal_minor_negative) { + BOOST_CHECK_THROW(parse("1.-1.0"), Parse_error); +} + +BOOST_AUTO_TEST_CASE(parse_normal_patch_negative) { + BOOST_CHECK_THROW(parse("1.0.-1"), Parse_error); +} + +BOOST_AUTO_TEST_CASE(parse_prerel_multiple) { + BOOST_CHECK_NO_THROW(parse("1.0.0-pre-rel.123.test.deadbeef.31415")); +} + +BOOST_AUTO_TEST_CASE(parse_prerel_invalid_chars) { + BOOST_CHECK_THROW(parse("1.0.0-prerelease#1"), Parse_error); +} + +BOOST_AUTO_TEST_CASE(parse_prerel_empty_id) { + BOOST_CHECK_THROW(parse("1.0.0-prerel..test"), Parse_error); +} + +BOOST_AUTO_TEST_CASE(parse_prerel_num_with_leading_0) { + BOOST_CHECK_THROW(parse("1.0.0-prerel.01"), Parse_error); +} + +BOOST_AUTO_TEST_CASE(parse_build_single_id) { + BOOST_CHECK_NO_THROW(parse("1.0.0+build")); +} + +BOOST_AUTO_TEST_CASE(parse_build_multiple_id) { + BOOST_CHECK_NO_THROW(parse("1.0.0+build.123.test.deadbeef.31415")); +} + +BOOST_AUTO_TEST_CASE(parse_build_invalid_chars) { + BOOST_CHECK_THROW(parse("1.0.0+build#1"), Parse_error); +} + +BOOST_AUTO_TEST_CASE(parse_build_empty_id) { + BOOST_CHECK_THROW(parse("1.0.0+build..test"), Parse_error); +} + +BOOST_AUTO_TEST_CASE(parse_prerel_single_build_single) { + BOOST_CHECK_NO_THROW(parse("1.0.0-prerelease+build")); +} + +BOOST_AUTO_TEST_CASE(parse_prerel_multiple_build_single) { + BOOST_CHECK_NO_THROW(parse("1.0.0-pre-rel.123.test.deadbeef.31415+build")); +} + +BOOST_AUTO_TEST_CASE(parse_prerel_invalid_chars_build_single) { + BOOST_CHECK_THROW(parse("1.0.0-prerelease#1+build"), Parse_error); +} + +BOOST_AUTO_TEST_CASE(parse_prerel_empty_id_build_single) { + BOOST_CHECK_THROW(parse("1.0.0-prerel..test+build"), Parse_error); +} + +BOOST_AUTO_TEST_CASE(parse_prerel_num_with_leading_0_build_single) { + BOOST_CHECK_THROW(parse("1.0.0-prerel.01+build"), Parse_error); +} + +BOOST_AUTO_TEST_CASE(parse_prerel_single_build_multiple) { + BOOST_CHECK_NO_THROW(parse("1.0.0-prerelease+build.1.2.3")); +} + +BOOST_AUTO_TEST_CASE(parse_prerel_multiple_build_multiple) { + BOOST_CHECK_NO_THROW(parse("1.0.0-pre-rel.123.test.deadbeef.31415+build.1.2.3")); +} + +BOOST_AUTO_TEST_CASE(parse_prerel_invalid_chars_build_multiple) { + BOOST_CHECK_THROW(parse("1.0.0-prerelease#1+build.1.2.3"), Parse_error); +} + +BOOST_AUTO_TEST_CASE(parse_prerel_empty_id_build_multiple) { + BOOST_CHECK_THROW(parse("1.0.0-prerel..test+build.1.2.3"), Parse_error); +} + +BOOST_AUTO_TEST_CASE(parse_prerel_num_with_leading_0_build_multiple) { + BOOST_CHECK_THROW(parse("1.0.0-prerel.01+build.1.2.3"), Parse_error); +} diff --git a/test/semver200_validator_tests.cpp b/test/semver200_validator_tests.cpp new file mode 100644 index 0000000..54fb6b6 --- /dev/null +++ b/test/semver200_validator_tests.cpp @@ -0,0 +1,31 @@ +/* +The MIT License (MIT) + +Copyright (c) 2015 Marko Zivanovic + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +*/ + +#define BOOST_TEST_MODULE semver200_validator_tests + +#include +#include "version.h" + +using namespace version; +