1  #include "pch.h"
  2  
  3  #include <common/version/helper.h>
  4  
  5  using namespace Microsoft::VisualStudio::CppUnitTestFramework;
  6  
  7  namespace Microsoft::VisualStudio::CppUnitTestFramework
  8  {
  9      template<>
 10      inline std::wstring ToString<VersionHelper>(const VersionHelper& v)
 11      {
 12          return v.toWstring();
 13      }
 14  }
 15  
 16  namespace UnitTestsVersionHelper
 17  {
 18      const size_t MAJOR_VERSION_0 = 0;
 19      const size_t MINOR_VERSION_12 = 12;
 20      const size_t REVISION_VERSION_0 = 0;
 21  
 22      TEST_CLASS (UnitTestsVersionHelper)
 23      {
 24      public:
 25          TEST_METHOD (integerConstructorShouldProperlyInitializationVersionNumbers)
 26          {
 27              VersionHelper sut(MAJOR_VERSION_0, MINOR_VERSION_12, REVISION_VERSION_0);
 28  
 29              Assert::AreEqual(MAJOR_VERSION_0, sut.major);
 30              Assert::AreEqual(MINOR_VERSION_12, sut.minor);
 31              Assert::AreEqual(REVISION_VERSION_0, sut.revision);
 32          }
 33          TEST_METHOD (integerConstructorShouldProperlyInitializationWithDifferentVersionNumbers)
 34          {
 35              const size_t testcaseMajor = 2;
 36              const size_t testcaseMinor = 25;
 37              const size_t testcaseRevision = 1;
 38              VersionHelper sut(testcaseMajor, testcaseMinor, testcaseRevision);
 39  
 40              Assert::AreEqual(testcaseMajor, sut.major);
 41              Assert::AreEqual(testcaseMinor, sut.minor);
 42              Assert::AreEqual(testcaseRevision, sut.revision);
 43          }
 44          TEST_METHOD (stringConstructorShouldProperlyInitializationVersionNumbers)
 45          {
 46              auto sut = VersionHelper::fromString("v0.12.3");
 47              Assert::IsTrue(sut.has_value());
 48              Assert::AreEqual(0ull, sut->major);
 49              Assert::AreEqual(12ull, sut->minor);
 50              Assert::AreEqual(3ull, sut->revision);
 51          }
 52          TEST_METHOD (stringConstructorShouldProperlyInitializationWithDifferentVersionNumbers)
 53          {
 54              auto sut = VersionHelper::fromString(L"v2.25.1");
 55              Assert::IsTrue(sut.has_value());
 56  
 57              Assert::AreEqual(2ull, sut->major);
 58              Assert::AreEqual(25ull, sut->minor);
 59              Assert::AreEqual(1ull, sut->revision);
 60          }
 61          TEST_METHOD (stringConstructorShouldProperlyInitializationVersionNumbersWithUppercaseV)
 62          {
 63              auto sut = VersionHelper::fromString(L"V2.25.1");
 64              Assert::IsTrue(sut.has_value());
 65  
 66              Assert::AreEqual(2ull, sut->major);
 67              Assert::AreEqual(25ull, sut->minor);
 68              Assert::AreEqual(1ull, sut->revision);
 69          }
 70          TEST_METHOD (emptyStringNotAccepted)
 71          {
 72              auto sut = VersionHelper::fromString("");
 73  
 74              Assert::IsFalse(sut.has_value());
 75          }
 76          TEST_METHOD (invalidStringNotAccepted1)
 77          {
 78              auto sut = VersionHelper::fromString(L"v2a.");
 79  
 80              Assert::IsFalse(sut.has_value());
 81          }
 82          TEST_METHOD (invalidStringNotAccepted2)
 83          {
 84              auto sut = VersionHelper::fromString(L"12abc2vv.0");
 85  
 86              Assert::IsFalse(sut.has_value());
 87          }
 88          TEST_METHOD (invalidStringNotAccepted3)
 89          {
 90              auto sut = VersionHelper::fromString("123");
 91  
 92              Assert::IsFalse(sut.has_value());
 93          }
 94          TEST_METHOD (invalidStringNotAccepted4)
 95          {
 96              auto sut = VersionHelper::fromString(L"v1v2v3");
 97  
 98              Assert::IsFalse(sut.has_value());
 99          }
100          TEST_METHOD (invalidStringNotAccepted5)
101          {
102              auto sut = VersionHelper::fromString("v.1.2.3v");
103  
104              Assert::IsFalse(sut.has_value());
105          }
106          TEST_METHOD (partialVersionStringNotAccepted1)
107          {
108              auto sut = VersionHelper::fromString(L"v1.");
109  
110              Assert::IsFalse(sut.has_value());
111          }
112          TEST_METHOD (partialVersionStringNotAccepted2)
113          {
114              auto sut = VersionHelper::fromString("v1.2");
115  
116              Assert::IsFalse(sut.has_value());
117          }
118          TEST_METHOD (partialVersionStringNotAccepted3)
119          {
120              auto sut = VersionHelper::fromString(L"v1.2.");
121  
122              Assert::IsFalse(sut.has_value());
123          }
124          TEST_METHOD (parsedWithoutLeadingV)
125          {
126              VersionHelper expected{ 12ull, 13ull, 111ull };
127              auto actual = VersionHelper::fromString(L"12.13.111");
128  
129              Assert::IsTrue(actual.has_value());
130              Assert::AreEqual(*actual, expected);
131          }
132          TEST_METHOD (whenMajorVersionIsGreaterComparisonOperatorShouldReturnProperValue)
133          {
134              VersionHelper lhs(MAJOR_VERSION_0 + 1, MINOR_VERSION_12, REVISION_VERSION_0);
135              VersionHelper rhs(MAJOR_VERSION_0, MINOR_VERSION_12, REVISION_VERSION_0);
136  
137              Assert::IsTrue(lhs > rhs);
138          }
139          TEST_METHOD (whenMajorVersionIsLesserComparisonOperatorShouldReturnProperValue)
140          {
141              VersionHelper lhs(MAJOR_VERSION_0, MINOR_VERSION_12, REVISION_VERSION_0);
142              VersionHelper rhs(MAJOR_VERSION_0 + 1, MINOR_VERSION_12, REVISION_VERSION_0);
143  
144              Assert::IsFalse(lhs > rhs);
145          }
146          TEST_METHOD (whenMajorVersionIsEqualComparisonOperatorShouldCompareMinorVersionValue)
147          {
148              VersionHelper lhs(MAJOR_VERSION_0, MINOR_VERSION_12, REVISION_VERSION_0);
149              VersionHelper rhs(MAJOR_VERSION_0, MINOR_VERSION_12 - 1, REVISION_VERSION_0);
150  
151              Assert::IsTrue(lhs > rhs);
152          }
153          TEST_METHOD (whenMajorVersionIsEqualComparisonOperatorShouldCompareMinorVersionValue2)
154          {
155              VersionHelper lhs(MAJOR_VERSION_0, MINOR_VERSION_12 - 1, REVISION_VERSION_0);
156              VersionHelper rhs(MAJOR_VERSION_0, MINOR_VERSION_12, REVISION_VERSION_0);
157  
158              Assert::IsFalse(lhs > rhs);
159          }
160  
161          TEST_METHOD (whenMajorAndMinorVersionIsEqualComparisonOperatorShouldCompareRevisionValue)
162          {
163              VersionHelper lhs(MAJOR_VERSION_0, MINOR_VERSION_12, REVISION_VERSION_0 + 1);
164              VersionHelper rhs(MAJOR_VERSION_0, MINOR_VERSION_12, REVISION_VERSION_0);
165  
166              Assert::IsTrue(lhs > rhs);
167          }
168          TEST_METHOD (whenMajorAndMinorVersionIsEqualComparisonOperatorShouldCompareRevisionValue2)
169          {
170              VersionHelper lhs(MAJOR_VERSION_0, MINOR_VERSION_12, REVISION_VERSION_0);
171              VersionHelper rhs(MAJOR_VERSION_0, MINOR_VERSION_12, REVISION_VERSION_0 + 1);
172  
173              Assert::IsFalse(lhs > rhs);
174          }
175          TEST_METHOD (whenMajorMinorAndRevisionIsEqualGreaterThanOperatorShouldReturnFalse)
176          {
177              VersionHelper lhs(MAJOR_VERSION_0, MINOR_VERSION_12, REVISION_VERSION_0);
178              VersionHelper rhs(MAJOR_VERSION_0, MINOR_VERSION_12, REVISION_VERSION_0);
179  
180              Assert::IsFalse(lhs > rhs);
181          }
182      };
183  }