1  #include "pch.h"
  2  #include "TestHelpers.h"
  3  #include <color.h>
  4  
  5  using namespace Microsoft::VisualStudio::CppUnitTestFramework;
  6  
  7  namespace UnitTestsCommonUtils
  8  {
  9      TEST_CLASS(ColorUtilsTests)
 10      {
 11      public:
 12          // checkValidRGB tests
 13          TEST_METHOD(CheckValidRGB_ValidBlack_ReturnsTrue)
 14          {
 15              uint8_t r, g, b;
 16              bool result = checkValidRGB(L"#000000", &r, &g, &b);
 17              Assert::IsTrue(result);
 18              Assert::AreEqual(static_cast<uint8_t>(0), r);
 19              Assert::AreEqual(static_cast<uint8_t>(0), g);
 20              Assert::AreEqual(static_cast<uint8_t>(0), b);
 21          }
 22  
 23          TEST_METHOD(CheckValidRGB_ValidWhite_ReturnsTrue)
 24          {
 25              uint8_t r, g, b;
 26              bool result = checkValidRGB(L"#FFFFFF", &r, &g, &b);
 27              Assert::IsTrue(result);
 28              Assert::AreEqual(static_cast<uint8_t>(255), r);
 29              Assert::AreEqual(static_cast<uint8_t>(255), g);
 30              Assert::AreEqual(static_cast<uint8_t>(255), b);
 31          }
 32  
 33          TEST_METHOD(CheckValidRGB_ValidRed_ReturnsTrue)
 34          {
 35              uint8_t r, g, b;
 36              bool result = checkValidRGB(L"#FF0000", &r, &g, &b);
 37              Assert::IsTrue(result);
 38              Assert::AreEqual(static_cast<uint8_t>(255), r);
 39              Assert::AreEqual(static_cast<uint8_t>(0), g);
 40              Assert::AreEqual(static_cast<uint8_t>(0), b);
 41          }
 42  
 43          TEST_METHOD(CheckValidRGB_ValidGreen_ReturnsTrue)
 44          {
 45              uint8_t r, g, b;
 46              bool result = checkValidRGB(L"#00FF00", &r, &g, &b);
 47              Assert::IsTrue(result);
 48              Assert::AreEqual(static_cast<uint8_t>(0), r);
 49              Assert::AreEqual(static_cast<uint8_t>(255), g);
 50              Assert::AreEqual(static_cast<uint8_t>(0), b);
 51          }
 52  
 53          TEST_METHOD(CheckValidRGB_ValidBlue_ReturnsTrue)
 54          {
 55              uint8_t r, g, b;
 56              bool result = checkValidRGB(L"#0000FF", &r, &g, &b);
 57              Assert::IsTrue(result);
 58              Assert::AreEqual(static_cast<uint8_t>(0), r);
 59              Assert::AreEqual(static_cast<uint8_t>(0), g);
 60              Assert::AreEqual(static_cast<uint8_t>(255), b);
 61          }
 62  
 63          TEST_METHOD(CheckValidRGB_ValidMixed_ReturnsTrue)
 64          {
 65              uint8_t r, g, b;
 66              bool result = checkValidRGB(L"#AB12CD", &r, &g, &b);
 67              Assert::IsTrue(result);
 68              Assert::AreEqual(static_cast<uint8_t>(0xAB), r);
 69              Assert::AreEqual(static_cast<uint8_t>(0x12), g);
 70              Assert::AreEqual(static_cast<uint8_t>(0xCD), b);
 71          }
 72  
 73          TEST_METHOD(CheckValidRGB_MissingHash_ReturnsFalse)
 74          {
 75              uint8_t r, g, b;
 76              bool result = checkValidRGB(L"FFFFFF", &r, &g, &b);
 77              Assert::IsFalse(result);
 78          }
 79  
 80          TEST_METHOD(CheckValidRGB_TooShort_ReturnsFalse)
 81          {
 82              uint8_t r, g, b;
 83              bool result = checkValidRGB(L"#FFF", &r, &g, &b);
 84              Assert::IsFalse(result);
 85          }
 86  
 87          TEST_METHOD(CheckValidRGB_TooLong_ReturnsFalse)
 88          {
 89              uint8_t r, g, b;
 90              bool result = checkValidRGB(L"#FFFFFFFF", &r, &g, &b);
 91              Assert::IsFalse(result);
 92          }
 93  
 94          TEST_METHOD(CheckValidRGB_InvalidChars_ReturnsFalse)
 95          {
 96              uint8_t r, g, b;
 97              bool result = checkValidRGB(L"#GGHHII", &r, &g, &b);
 98              Assert::IsFalse(result);
 99          }
100  
101          TEST_METHOD(CheckValidRGB_LowercaseInvalid_ReturnsFalse)
102          {
103              uint8_t r, g, b;
104              bool result = checkValidRGB(L"#ffffff", &r, &g, &b);
105              Assert::IsFalse(result);
106          }
107  
108          TEST_METHOD(CheckValidRGB_EmptyString_ReturnsFalse)
109          {
110              uint8_t r, g, b;
111              bool result = checkValidRGB(L"", &r, &g, &b);
112              Assert::IsFalse(result);
113          }
114  
115          TEST_METHOD(CheckValidRGB_OnlyHash_ReturnsFalse)
116          {
117              uint8_t r, g, b;
118              bool result = checkValidRGB(L"#", &r, &g, &b);
119              Assert::IsFalse(result);
120          }
121  
122          // checkValidARGB tests
123          TEST_METHOD(CheckValidARGB_ValidBlackOpaque_ReturnsTrue)
124          {
125              uint8_t a, r, g, b;
126              bool result = checkValidARGB(L"#FF000000", &a, &r, &g, &b);
127              Assert::IsTrue(result);
128              Assert::AreEqual(static_cast<uint8_t>(255), a);
129              Assert::AreEqual(static_cast<uint8_t>(0), r);
130              Assert::AreEqual(static_cast<uint8_t>(0), g);
131              Assert::AreEqual(static_cast<uint8_t>(0), b);
132          }
133  
134          TEST_METHOD(CheckValidARGB_ValidWhiteOpaque_ReturnsTrue)
135          {
136              uint8_t a, r, g, b;
137              bool result = checkValidARGB(L"#FFFFFFFF", &a, &r, &g, &b);
138              Assert::IsTrue(result);
139              Assert::AreEqual(static_cast<uint8_t>(255), a);
140              Assert::AreEqual(static_cast<uint8_t>(255), r);
141              Assert::AreEqual(static_cast<uint8_t>(255), g);
142              Assert::AreEqual(static_cast<uint8_t>(255), b);
143          }
144  
145          TEST_METHOD(CheckValidARGB_ValidTransparent_ReturnsTrue)
146          {
147              uint8_t a, r, g, b;
148              bool result = checkValidARGB(L"#00FFFFFF", &a, &r, &g, &b);
149              Assert::IsTrue(result);
150              Assert::AreEqual(static_cast<uint8_t>(0), a);
151              Assert::AreEqual(static_cast<uint8_t>(255), r);
152              Assert::AreEqual(static_cast<uint8_t>(255), g);
153              Assert::AreEqual(static_cast<uint8_t>(255), b);
154          }
155  
156          TEST_METHOD(CheckValidARGB_ValidSemiTransparent_ReturnsTrue)
157          {
158              uint8_t a, r, g, b;
159              bool result = checkValidARGB(L"#80FF0000", &a, &r, &g, &b);
160              Assert::IsTrue(result);
161              Assert::AreEqual(static_cast<uint8_t>(0x80), a);
162              Assert::AreEqual(static_cast<uint8_t>(255), r);
163              Assert::AreEqual(static_cast<uint8_t>(0), g);
164              Assert::AreEqual(static_cast<uint8_t>(0), b);
165          }
166  
167          TEST_METHOD(CheckValidARGB_ValidMixed_ReturnsTrue)
168          {
169              uint8_t a, r, g, b;
170              bool result = checkValidARGB(L"#12345678", &a, &r, &g, &b);
171              Assert::IsTrue(result);
172              Assert::AreEqual(static_cast<uint8_t>(0x12), a);
173              Assert::AreEqual(static_cast<uint8_t>(0x34), r);
174              Assert::AreEqual(static_cast<uint8_t>(0x56), g);
175              Assert::AreEqual(static_cast<uint8_t>(0x78), b);
176          }
177  
178          TEST_METHOD(CheckValidARGB_MissingHash_ReturnsFalse)
179          {
180              uint8_t a, r, g, b;
181              bool result = checkValidARGB(L"FFFFFFFF", &a, &r, &g, &b);
182              Assert::IsFalse(result);
183          }
184  
185          TEST_METHOD(CheckValidARGB_TooShort_ReturnsFalse)
186          {
187              uint8_t a, r, g, b;
188              bool result = checkValidARGB(L"#FFFFFF", &a, &r, &g, &b);
189              Assert::IsFalse(result);
190          }
191  
192          TEST_METHOD(CheckValidARGB_TooLong_ReturnsFalse)
193          {
194              uint8_t a, r, g, b;
195              bool result = checkValidARGB(L"#FFFFFFFFFF", &a, &r, &g, &b);
196              Assert::IsFalse(result);
197          }
198  
199          TEST_METHOD(CheckValidARGB_InvalidChars_ReturnsFalse)
200          {
201              uint8_t a, r, g, b;
202              bool result = checkValidARGB(L"#GGHHIIJJ", &a, &r, &g, &b);
203              Assert::IsFalse(result);
204          }
205  
206          TEST_METHOD(CheckValidARGB_LowercaseInvalid_ReturnsFalse)
207          {
208              uint8_t a, r, g, b;
209              bool result = checkValidARGB(L"#ffffffff", &a, &r, &g, &b);
210              Assert::IsFalse(result);
211          }
212  
213          TEST_METHOD(CheckValidARGB_EmptyString_ReturnsFalse)
214          {
215              uint8_t a, r, g, b;
216              bool result = checkValidARGB(L"", &a, &r, &g, &b);
217              Assert::IsFalse(result);
218          }
219      };
220  }