1 /* 2 * Copyright (c) 2020-2021 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16 #include "gfx_utils/color.h" 17 18 #include <climits> 19 #include <gtest/gtest.h> 20 21 using namespace testing::ext; 22 namespace OHOS { 23 class ColorTest : public testing::Test { 24 public: SetUpTestCase(void)25 static void SetUpTestCase(void) {} TearDownTestCase(void)26 static void TearDownTestCase(void) {} 27 }; 28 29 /** 30 * @tc.name: ColorGetColorFromRGB_001 31 * @tc.desc: Verify GetColorFromRGB function, equal. 32 * @tc.type: FUNC 33 * @tc.require: AR000EEMQ9 34 */ 35 HWTEST_F(ColorTest, ColorGetColorFromRGB_001, TestSize.Level0) 36 { 37 ColorType color = Color::GetColorFromRGB(0, 0, 0); 38 39 EXPECT_EQ(color.red, 0); 40 EXPECT_EQ(color.green, 0); 41 EXPECT_EQ(color.blue, 0); 42 EXPECT_EQ(color.alpha, OPA_OPAQUE); 43 } 44 45 /** 46 * @tc.name: ColorGetColorFromRGBA_002 47 * @tc.desc: Verify GetColorFromRGBA function, equal. 48 * @tc.type: FUNC 49 * @tc.require: AR000EEMQ9 50 */ 51 HWTEST_F(ColorTest, ColorGetColorFromRGBA_002, TestSize.Level0) 52 { 53 ColorType color = Color::GetColorFromRGBA(0, 0, 0, OPA_TRANSPARENT); 54 55 EXPECT_EQ(color.red, 0); 56 EXPECT_EQ(color.green, 0); 57 EXPECT_EQ(color.blue, 0); 58 EXPECT_EQ(color.alpha, OPA_TRANSPARENT); 59 } 60 61 /** 62 * @tc.name: ColorColorTo32_001 63 * @tc.desc: Verify ColorTo32 function, equal. 64 * @tc.type: FUNC 65 * @tc.require: AR000EEMQ9 66 */ 67 HWTEST_F(ColorTest, ColorColorTo32_001, TestSize.Level0) 68 { 69 ColorType color; 70 color.red = 0; 71 color.green = 0; 72 color.blue = 0; 73 color.alpha = OPA_TRANSPARENT; 74 uint32_t color32 = 0; 75 76 EXPECT_EQ(Color::ColorTo32(color), color32); 77 } 78 79 /** 80 * @tc.name: ColorColorTo32_002 81 * @tc.desc: Verify ColorTo32 function, equal. 82 * @tc.type: FUNC 83 * @tc.require: AR000EEMQ9 84 */ 85 HWTEST_F(ColorTest, ColorColorTo32_002, TestSize.Level0) 86 { 87 Color16 color16; 88 color16.red = 0; 89 color16.green = 0; 90 color16.blue = 0; 91 92 EXPECT_EQ(Color::ColorTo32(color16, 0), 0); 93 } 94 95 /** 96 * @tc.name: ColorColorTo16_001 97 * @tc.desc: Verify ColorTo16 function, equal. 98 * @tc.type: FUNC 99 * @tc.require: AR000EEMQ9 100 */ 101 HWTEST_F(ColorTest, ColorColorTo16_001, TestSize.Level0) 102 { 103 Color32 color32; 104 color32.red = 0; 105 color32.green = 0; 106 color32.blue = 0; 107 108 EXPECT_EQ(Color::ColorTo16(color32), 0); 109 } 110 111 /** 112 * @tc.name: ColorWhite_001 113 * @tc.desc: Verify White function, equal. 114 * @tc.type: FUNC 115 * @tc.require: AR000EEMQ9 116 */ 117 HWTEST_F(ColorTest, ColorWhite_001, TestSize.Level0) 118 { 119 ColorType white = Color::White(); 120 121 EXPECT_EQ(white.red, 0xFF); 122 EXPECT_EQ(white.green, 0xFF); 123 EXPECT_EQ(white.blue, 0xFF); 124 } 125 126 /** 127 * @tc.name: ColorSilver_001 128 * @tc.desc: Verify Silver function, equal. 129 * @tc.type: FUNC 130 * @tc.require: AR000EEMQ9 131 */ 132 HWTEST_F(ColorTest, ColorSilver_001, TestSize.Level0) 133 { 134 ColorType silver = Color::Silver(); 135 136 EXPECT_EQ(silver.red, 0xC0); 137 EXPECT_EQ(silver.green, 0xC0); 138 EXPECT_EQ(silver.blue, 0xC0); 139 } 140 141 /** 142 * @tc.name: ColorGray_001 143 * @tc.desc: Verify Gray function, equal. 144 * @tc.type: FUNC 145 * @tc.require: AR000EEMQ9 146 */ 147 HWTEST_F(ColorTest, ColorGray_001, TestSize.Level0) 148 { 149 ColorType gray = Color::Gray(); 150 151 EXPECT_EQ(gray.red, 0x80); 152 EXPECT_EQ(gray.green, 0x80); 153 EXPECT_EQ(gray.blue, 0x80); 154 } 155 156 /** 157 * @tc.name: ColorBlack_001 158 * @tc.desc: Verify Black function, equal. 159 * @tc.type: FUNC 160 * @tc.require: AR000EEMQ9 161 */ 162 HWTEST_F(ColorTest, ColorBlack_001, TestSize.Level0) 163 { 164 ColorType black = Color::Black(); 165 166 EXPECT_EQ(black.red, 0x00); 167 EXPECT_EQ(black.green, 0x00); 168 EXPECT_EQ(black.blue, 0x00); 169 } 170 171 /** 172 * @tc.name: ColorRed_001 173 * @tc.desc: Verify Red function, equal. 174 * @tc.type: FUNC 175 * @tc.require: AR000EEMQ9 176 */ 177 HWTEST_F(ColorTest, ColorRed_001, TestSize.Level0) 178 { 179 ColorType red = Color::Red(); 180 181 EXPECT_EQ(red.red, 0xFF); 182 EXPECT_EQ(red.green, 0x00); 183 EXPECT_EQ(red.blue, 0x00); 184 } 185 186 /** 187 * @tc.name: ColorMaroon_001 188 * @tc.desc: Verify Maroon function, equal. 189 * @tc.type: FUNC 190 * @tc.require: AR000EEMQ9 191 */ 192 HWTEST_F(ColorTest, ColorMaroon_001, TestSize.Level0) 193 { 194 ColorType maroon = Color::Maroon(); 195 196 EXPECT_EQ(maroon.red, 0x80); 197 EXPECT_EQ(maroon.green, 0x00); 198 EXPECT_EQ(maroon.blue, 0x00); 199 } 200 201 /** 202 * @tc.name: ColorYellow_001 203 * @tc.desc: Verify Yellow function, equal. 204 * @tc.type: FUNC 205 * @tc.require: AR000EEMQ9 206 */ 207 HWTEST_F(ColorTest, ColorYellow_001, TestSize.Level0) 208 { 209 ColorType yellow = Color::Yellow(); 210 211 EXPECT_EQ(yellow.red, 0xFF); 212 EXPECT_EQ(yellow.green, 0xFF); 213 EXPECT_EQ(yellow.blue, 0x00); 214 } 215 216 /** 217 * @tc.name: ColorOlive_001 218 * @tc.desc: Verify Olive function, equal. 219 * @tc.type: FUNC 220 * @tc.require: AR000EEMQ9 221 */ 222 HWTEST_F(ColorTest, ColorOlive_001, TestSize.Level0) 223 { 224 ColorType olive = Color::Olive(); 225 226 EXPECT_EQ(olive.red, 0x80); 227 EXPECT_EQ(olive.green, 0x80); 228 EXPECT_EQ(olive.blue, 0x00); 229 } 230 231 /** 232 * @tc.name: ColorLime_001 233 * @tc.desc: Verify Lime function, equal. 234 * @tc.type: FUNC 235 * @tc.require: AR000EEMQ9 236 */ 237 HWTEST_F(ColorTest, ColorLime_001, TestSize.Level0) 238 { 239 ColorType lime = Color::Lime(); 240 241 EXPECT_EQ(lime.red, 0x00); 242 EXPECT_EQ(lime.green, 0xFF); 243 EXPECT_EQ(lime.blue, 0x00); 244 } 245 246 /** 247 * @tc.name: ColorGreen_001 248 * @tc.desc: Verify Green function, equal. 249 * @tc.type: FUNC 250 * @tc.require: AR000EEMQ9 251 */ 252 HWTEST_F(ColorTest, ColorGreen_001, TestSize.Level0) 253 { 254 ColorType green = Color::Green(); 255 256 EXPECT_EQ(green.red, 0x00); 257 EXPECT_EQ(green.green, 0xFF); 258 EXPECT_EQ(green.blue, 0x00); 259 } 260 261 /** 262 * @tc.name: ColorCyan_001 263 * @tc.desc: Verify Cyan function, equal. 264 * @tc.type: FUNC 265 * @tc.require: AR000EEMQ9 266 */ 267 HWTEST_F(ColorTest, ColorCyan_001, TestSize.Level0) 268 { 269 ColorType cyan = Color::Cyan(); 270 271 EXPECT_EQ(cyan.red, 0x00); 272 EXPECT_EQ(cyan.green, 0xFF); 273 EXPECT_EQ(cyan.blue, 0xFF); 274 } 275 276 /** 277 * @tc.name: ColorAqua_001 278 * @tc.desc: Verify Aqua function, equal. 279 * @tc.type: FUNC 280 * @tc.require: AR000EEMQ9 281 */ 282 HWTEST_F(ColorTest, ColorAqua_001, TestSize.Level0) 283 { 284 ColorType aqua = Color::Aqua(); 285 286 EXPECT_EQ(aqua.red, 0x00); 287 EXPECT_EQ(aqua.green, 0xFF); 288 EXPECT_EQ(aqua.blue, 0xFF); 289 } 290 291 /** 292 * @tc.name: ColorTeal_001 293 * @tc.desc: Verify Teal function, equal. 294 * @tc.type: FUNC 295 * @tc.require: AR000EEMQ9 296 */ 297 HWTEST_F(ColorTest, ColorTeal_001, TestSize.Level0) 298 { 299 ColorType teal = Color::Teal(); 300 301 EXPECT_EQ(teal.red, 0x00); 302 EXPECT_EQ(teal.green, 0x80); 303 EXPECT_EQ(teal.blue, 0x80); 304 } 305 306 /** 307 * @tc.name: ColorBlue_001 308 * @tc.desc: Verify Blue function, equal. 309 * @tc.type: FUNC 310 * @tc.require: AR000EEMQ9 311 */ 312 HWTEST_F(ColorTest, ColorBlue_001, TestSize.Level0) 313 { 314 ColorType blue = Color::Blue(); 315 316 EXPECT_EQ(blue.red, 0x00); 317 EXPECT_EQ(blue.green, 0x00); 318 EXPECT_EQ(blue.blue, 0xFF); 319 } 320 321 /** 322 * @tc.name: ColorNavy_001 323 * @tc.desc: Verify Navy function, equal. 324 * @tc.type: FUNC 325 * @tc.require: AR000EEMQ9 326 */ 327 HWTEST_F(ColorTest, ColorNavy_001, TestSize.Level0) 328 { 329 ColorType navy = Color::Navy(); 330 331 EXPECT_EQ(navy.red, 0x00); 332 EXPECT_EQ(navy.green, 0x00); 333 EXPECT_EQ(navy.blue, 0x80); 334 } 335 336 /** 337 * @tc.name: ColorMagenta_001 338 * @tc.desc: Verify Magenta function, equal. 339 * @tc.type: FUNC 340 * @tc.require: AR000EEMQ9 341 */ 342 HWTEST_F(ColorTest, ColorMagenta_001, TestSize.Level0) 343 { 344 ColorType magenta = Color::Magenta(); 345 346 EXPECT_EQ(magenta.red, 0xFF); 347 EXPECT_EQ(magenta.green, 0x00); 348 EXPECT_EQ(magenta.blue, 0xFF); 349 } 350 351 /** 352 * @tc.name: ColorPurple_001 353 * @tc.desc: Verify Purple function, equal. 354 * @tc.type: FUNC 355 * @tc.require: AR000EEMQ9 356 */ 357 HWTEST_F(ColorTest, ColorPurple_001, TestSize.Level0) 358 { 359 ColorType purple = Color::Purple(); 360 361 EXPECT_EQ(purple.red, 0x80); 362 EXPECT_EQ(purple.green, 0x00); 363 EXPECT_EQ(purple.blue, 0x80); 364 } 365 366 /** 367 * @tc.name: ColorOrange_001 368 * @tc.desc: Verify Orange function, equal. 369 * @tc.type: FUNC 370 * @tc.require: AR000EEMQ9 371 */ 372 HWTEST_F(ColorTest, ColorOrange_001, TestSize.Level0) 373 { 374 ColorType orange = Color::Orange(); 375 376 EXPECT_EQ(orange.red, 0xFF); 377 EXPECT_EQ(orange.green, 0xA5); 378 EXPECT_EQ(orange.blue, 0x00); 379 } 380 } // namespace OHOS