tests/utils/widget_version.cpp

   1 /*
   2  * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  *    Licensed under the Apache License, Version 2.0 (the "License");
   5  *    you may not use this file except in compliance with the License.
   6  *    You may obtain a copy of the License at
   7  *
   8  *        http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  *    Unless required by applicable law or agreed to in writing, software
  11  *    distributed under the License is distributed on an "AS IS" BASIS,
  12  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  *    See the License for the specific language governing permissions and
  14  *    limitations under the License.
  15  */
  16 /*
  17  * @file    widget_version.cpp
  18  * @author  Przemyslaw Dobrowolski (p.dobrowolsk@samsung.com)
  19  * @version 1.0
  20  * @brief   Implementation file for test cases for engine internal tests
  21  */
  22 #include <sstream>
  23 #include <dpl/test/test_runner.h>
  24 #include <dpl/utils/widget_version.h>
  25
  26 RUNNER_TEST_GROUP_INIT(DPL_WIDGET_VERSION)
  27
  28 /*
  29 Name: WidgetVersion_M2_O0
  30 Description: tests correct parsing of version widget in format: [major].[minor]
  31 Expected: major and minor parts matches expected values
  32 */
  33 RUNNER_TEST(WidgetVersion_M2_O0)
  34 {
  35     DPL::String raw(L"1.2");
  36     WidgetVersion version(raw);
  37
  38     RUNNER_ASSERT(version.IsWac() == true);
  39     RUNNER_ASSERT(version.Major() == DPL::String(L"1"));
  40     RUNNER_ASSERT(version.Minor() == DPL::String(L"2"));
  41     RUNNER_ASSERT(version.Micro() == DPL::Optional<DPL::String>());
  42     RUNNER_ASSERT(version.Optional() == DPL::Optional<DPL::String>());
  43     RUNNER_ASSERT(version.Raw() == raw);
  44 }
  45
  46 /*
  47 Name: WidgetVersion_M2_O0_nonwac_1
  48 Description: tests if version is recognized as wac version number
  49 Expected: version should not be recognized as wac compatible
  50 */
  51 RUNNER_TEST(WidgetVersion_M2_O0_nonwac_1)
  52 {
  53     DPL::String raw(L"a1.2");
  54     WidgetVersion version(raw);
  55
  56     RUNNER_ASSERT(version.IsWac() == false);
  57     RUNNER_ASSERT(version.Raw() == raw);
  58 }
  59
  60 /*
  61 Name: WidgetVersion_M2_O0_nonwac_2
  62 Description: tests if version is recognized as wac version number
  63 Expected: version should not be recognized as wac compatible
  64 */
  65 RUNNER_TEST(WidgetVersion_M2_O0_nonwac_2)
  66 {
  67     DPL::String raw(L"1.2a");
  68     WidgetVersion version(raw);
  69
  70     RUNNER_ASSERT(version.IsWac() == false);
  71     RUNNER_ASSERT(version.Raw() == raw);
  72 }
  73
  74 /*
  75 Name: WidgetVersion_M2_O0_nonwac_3
  76 Description: tests if version is recognized as wac version number
  77 Expected: version should not be recognized as wac compatible
  78 */
  79 RUNNER_TEST(WidgetVersion_M2_O0_nonwac_3)
  80 {
  81     DPL::String raw(L"aaa1.2bbb");
  82     WidgetVersion version(raw);
  83
  84     RUNNER_ASSERT(version.IsWac() == false);
  85     RUNNER_ASSERT(version.Raw() == raw);
  86 }
  87
  88 /*
  89 Name: WidgetVersion_M2_O0_nonwac_4
  90 Description: tests if version is recognized as wac version number
  91 Expected: version should not be recognized as wac compatible
  92 */
  93 RUNNER_TEST(WidgetVersion_M2_O0_nonwac_4)
  94 {
  95     DPL::String raw(L"1a.a2");
  96     WidgetVersion version(raw);
  97
  98     RUNNER_ASSERT(version.IsWac() == false);
  99     RUNNER_ASSERT(version.Raw() == raw);
 100 }
 101
 102 /*
 103 Name: WidgetVersion_M2_O0_long
 104 Description: tests correct parsing of version widget in format: [major].[minor]
 105  for huge number
 106 Expected: major and minor parts matches expected values
 107 */
 108 RUNNER_TEST(WidgetVersion_M2_O0_long)
 109 {
 110     DPL::String raw(
 111         L"123456789012345678901234567890.98765432109876543210987654321");
 112     WidgetVersion version(raw);
 113
 114     RUNNER_ASSERT(version.IsWac() == true);
 115     RUNNER_ASSERT(version.Major() ==
 116                   DPL::String(L"123456789012345678901234567890"));
 117     RUNNER_ASSERT(version.Minor() ==
 118                   DPL::String(L"98765432109876543210987654321"));
 119     RUNNER_ASSERT(version.Micro() == DPL::Optional<DPL::String>());
 120     RUNNER_ASSERT(version.Optional() == DPL::Optional<DPL::String>());
 121     RUNNER_ASSERT(version.Raw() == raw);
 122 }
 123
 124 /*
 125 Name: WidgetVersion_M3_O0
 126 Description: tests correct wac version number
 127 Expected: major and minor and micro parts matches expected values.
 128  Version should be recognized as wac compatible
 129 */
 130 RUNNER_TEST(WidgetVersion_M3_O0)
 131 {
 132     DPL::String raw(L"1.2.3");
 133     WidgetVersion version(raw);
 134
 135     RUNNER_ASSERT(version.IsWac() == true);
 136     RUNNER_ASSERT(version.Major() == DPL::String(L"1"));
 137     RUNNER_ASSERT(version.Minor() == DPL::String(L"2"));
 138     RUNNER_ASSERT(version.Micro() == DPL::Optional<DPL::String>(L"3"));
 139     RUNNER_ASSERT(version.Optional() == DPL::Optional<DPL::String>());
 140     RUNNER_ASSERT(version.Raw() == raw);
 141 }
 142
 143 /*
 144 Name: WidgetVersion_M3_O0_nonwac_1
 145 Description: tests if version is recognized as wac version number
 146 Expected: version should not be recognized as wac compatible
 147 */
 148 RUNNER_TEST(WidgetVersion_M3_O0_nonwac_1)
 149 {
 150     DPL::String raw(L"a1a.2.3");
 151     WidgetVersion version(raw);
 152
 153     RUNNER_ASSERT(version.IsWac() == false);
 154     RUNNER_ASSERT(version.Raw() == raw);
 155 }
 156
 157 /*
 158 Name: WidgetVersion_M3_O0_nonwac_2
 159 Description: tests if version is recognized as wac version number
 160 Expected: version should not be recognized as wac compatible
 161 */
 162 RUNNER_TEST(WidgetVersion_M3_O0_nonwac_2)
 163 {
 164     DPL::String raw(L"1.b2.3");
 165     WidgetVersion version(raw);
 166
 167     RUNNER_ASSERT(version.IsWac() == false);
 168     RUNNER_ASSERT(version.Raw() == raw);
 169 }
 170
 171 /*
 172 Name: WidgetVersion_M3_O0_nonwac_3
 173 Description: tests if version is recognized as wac version number
 174 Expected: version should not be recognized as wac compatible
 175 */
 176 RUNNER_TEST(WidgetVersion_M3_O0_nonwac_3)
 177 {
 178     DPL::String raw(L"1.2.3c");
 179     WidgetVersion version(raw);
 180
 181     RUNNER_ASSERT(version.IsWac() == false);
 182     RUNNER_ASSERT(version.Raw() == raw);
 183 }
 184
 185 /*
 186 Name: WidgetVersion_M3_O1_1
 187 Description: tests correct wac version number with optional part
 188 Expected: major and minor and micro and optional parts matches expected values.
 189  Version should be recognized as wac compatible
 190 */
 191 RUNNER_TEST(WidgetVersion_M3_O1_1)
 192 {
 193     DPL::String raw(L"1.2.3 test111");
 194     WidgetVersion version(raw);
 195
 196     RUNNER_ASSERT(version.IsWac() == true);
 197     RUNNER_ASSERT(version.Major() == DPL::String(L"1"));
 198     RUNNER_ASSERT(version.Minor() == DPL::String(L"2"));
 199     RUNNER_ASSERT(version.Micro() == DPL::Optional<DPL::String>(L"3"));
 200     RUNNER_ASSERT(version.Optional() == DPL::Optional<DPL::String>(L"test111"));
 201     RUNNER_ASSERT(version.Raw() == raw);
 202 }
 203
 204 /*
 205 Name: WidgetVersion_M3_O1_1
 206 Description: tests correct wac version number with numeric optional part
 207 Expected: major and minor and micro and optional parts matches expected values.
 208  Version should be recognized as wac compatible
 209 */
 210 RUNNER_TEST(WidgetVersion_M3_O1_2)
 211 {
 212     DPL::String raw(L"1.2.3 111");
 213     WidgetVersion version(raw);
 214
 215     RUNNER_ASSERT(version.IsWac() == true);
 216     RUNNER_ASSERT(version.Major() == DPL::String(L"1"));
 217     RUNNER_ASSERT(version.Minor() == DPL::String(L"2"));
 218     RUNNER_ASSERT(version.Micro() == DPL::Optional<DPL::String>(L"3"));
 219     RUNNER_ASSERT(version.Optional() == DPL::Optional<DPL::String>(L"111"));
 220     RUNNER_ASSERT(version.Raw() == raw);
 221 }
 222
 223 /*
 224 Name: WidgetVersion_M3_O1_3
 225 Description: tests if version is recognized as wac version number
 226  when trailer spaces exists
 227 Expected: version should not be recognized as wac compatible
 228 */
 229 RUNNER_TEST(WidgetVersion_M3_O1_3)
 230 {
 231     DPL::String raw(L"1.2.3 ");
 232     WidgetVersion version(raw);
 233
 234     RUNNER_ASSERT(version.IsWac() == false);
 235     RUNNER_ASSERT(version.Raw() == raw);
 236 }
 237
 238 /*
 239 Name: WidgetVersion_M2_O1_1
 240 Description: tests if version is recognized as wac version number
 241  when optional part
 242 Expected: version should be recognized as wac compatible
 243 */
 244 RUNNER_TEST(WidgetVersion_M2_O1_1)
 245 {
 246     DPL::String raw(L"1.2 t");
 247     WidgetVersion version(raw);
 248
 249     RUNNER_ASSERT(version.IsWac() == true);
 250     RUNNER_ASSERT(version.Major() == DPL::String(L"1"));
 251     RUNNER_ASSERT(version.Minor() == DPL::String(L"2"));
 252     RUNNER_ASSERT(version.Micro() == DPL::Optional<DPL::String>());
 253     RUNNER_ASSERT(version.Optional() == DPL::Optional<DPL::String>(L"t"));
 254     RUNNER_ASSERT(version.Raw() == raw);
 255 }
 256
 257 /*
 258 Name: WidgetVersion_M2_O1_2
 259 Description: tests if version is recognized as wac version number
 260  with numeric optional part.
 261 Expected: major and minor and optional parts matches expected values.
 262  Version should be recognized as wac compatible.
 263 */
 264 RUNNER_TEST(WidgetVersion_M2_O1_2)
 265 {
 266     DPL::String raw(L"1.2 1234");
 267     WidgetVersion version(raw);
 268
 269     RUNNER_ASSERT(version.IsWac() == true);
 270     RUNNER_ASSERT(version.Major() == DPL::String(L"1"));
 271     RUNNER_ASSERT(version.Minor() == DPL::String(L"2"));
 272     RUNNER_ASSERT(version.Micro() == DPL::Optional<DPL::String>());
 273     RUNNER_ASSERT(version.Optional() == DPL::Optional<DPL::String>(L"1234"));
 274     RUNNER_ASSERT(version.Raw() == raw);
 275 }
 276
 277 /*
 278 Name: WidgetVersion_M4_O0_1
 279 Description: Tests if version is recognized as wac version number.
 280 Expected: major and minor and micro and optional parts matches expected values.
 281  Version should be recognized as wac compatible.
 282 */
 283 RUNNER_TEST(WidgetVersion_M4_O0_1)
 284 {
 285     DPL::String raw(L"1.1");
 286     DPL::String majorV(L"1");
 287     DPL::String minorV(L"1");
 288     DPL::Optional<DPL::String> microV = DPL::Optional<DPL::String>();
 289     DPL::Optional<DPL::String> optionalV = DPL::Optional<DPL::String>();
 290     WidgetVersion version(majorV, minorV, microV, optionalV);
 291
 292     RUNNER_ASSERT(version.IsWac() == true);
 293     RUNNER_ASSERT(version.Major() == majorV);
 294     RUNNER_ASSERT(version.Minor() == minorV);
 295     RUNNER_ASSERT(version.Micro() == microV);
 296     RUNNER_ASSERT(version.Optional() == optionalV);
 297     RUNNER_ASSERT(version.Raw() == raw);
 298 }
 299
 300 /*
 301 Name: WidgetVersion_M4_O0_nonwac_1
 302 Description: Tests if version is recognized as wac version number.
 303 Expected: Version should be recognized as non wac compatible.
 304 */
 305 RUNNER_TEST(WidgetVersion_M4_O0_nonwac_1)
 306 {
 307     DPL::String raw(L"a1.1");
 308     WidgetVersion version(L"a1", L"1", DPL::Optional<DPL::String>(), DPL::Optional<DPL::String>());
 309
 310     RUNNER_ASSERT(version.IsWac() == false);
 311     RUNNER_ASSERT(version.Raw() == raw);
 312 }
 313
 314 /*
 315 Name: WidgetVersion_M4_O0_nonwac_2
 316 Description: Tests if version is recognized as wac version number.
 317 Expected: Version should not be recognized as wac compatible.
 318 */
 319 RUNNER_TEST(WidgetVersion_M4_O0_nonwac_2)
 320 {
 321     DPL::String raw(L"1.1a");
 322     WidgetVersion version(L"1", L"1a", DPL::Optional<DPL::String>(), DPL::Optional<DPL::String>());
 323
 324     RUNNER_ASSERT(version.IsWac() == false);
 325     RUNNER_ASSERT(version.Raw() == raw);
 326 }
 327
 328 /*
 329 Name: WidgetVersion_M4_O1_1
 330 Description: Tests if version is recognized as wac version number.
 331 Expected: major, minor, micro and optional parts matches expected values.
 332  Version should be recognized as wac compatible.
 333 */
 334 RUNNER_TEST(WidgetVersion_M4_O1_1)
 335 {
 336     DPL::String raw(L"1.1.1");
 337     DPL::String majorV(L"1");
 338     DPL::String minorV(L"1");
 339     DPL::Optional<DPL::String> microV = DPL::Optional<DPL::String>(L"1");
 340     DPL::Optional<DPL::String> optionalV = DPL::Optional<DPL::String>();
 341     WidgetVersion version(majorV, minorV, microV, optionalV);
 342
 343     RUNNER_ASSERT(version.IsWac() == true);
 344     RUNNER_ASSERT(version.Major() == majorV);
 345     RUNNER_ASSERT(version.Minor() == minorV);
 346     RUNNER_ASSERT(version.Micro() == microV);
 347     RUNNER_ASSERT(version.Optional() == optionalV);
 348     RUNNER_ASSERT(version.Raw() == raw);
 349 }
 350
 351 /*
 352 Name: WidgetVersion_M4_O1_nonwac_1
 353 Description: Tests if version is recognized as wac version number.
 354 Expected: Version should not be recognized as wac compatible.
 355 */
 356 RUNNER_TEST(WidgetVersion_M4_O1_nonwac_1)
 357 {
 358     DPL::String majorV(L"1");
 359     DPL::String minorV(L"1");
 360     WidgetVersion version(L"1", L"1", DPL::Optional<DPL::String>(L"1a"), DPL::Optional<DPL::String>());
 361
 362     RUNNER_ASSERT(version.IsWac() == false);
 363     RUNNER_ASSERT(version.Raw() == L"1.1.1a");
 364 }
 365
 366 /*
 367 Name: WidgetVersion_M4_O1_nonwac_1
 368 Description: Tests if version is recognized as wac version number.
 369 Expected: Version should not be recognized as wac compatible.
 370 */
 371 RUNNER_TEST(WidgetVersion_M4_O1_nonwac_2)
 372 {
 373     WidgetVersion version(L"1", L"1", DPL::Optional<DPL::String>(L"a1"), DPL::Optional<DPL::String>());
 374
 375     RUNNER_ASSERT(version.IsWac() == false);
 376     RUNNER_ASSERT(version.Raw() == L"1.1.a1");
 377 }
 378
 379 /*
 380 Name: WidgetVersion_M4_O2_1
 381 Description: Tests if version is recognized as wac version number.
 382 Expected: major, minor, micro and optional parts matches expected values.
 383  Version should be recognized as wac compatible.
 384 */
 385 RUNNER_TEST(WidgetVersion_M4_O2_1)
 386 {
 387     DPL::String raw(L"1.1.1 a1");
 388     DPL::String majorV(L"1");
 389     DPL::String minorV(L"1");
 390     DPL::Optional<DPL::String> microV = DPL::Optional<DPL::String>(L"1");
 391     DPL::Optional<DPL::String> optionalV = DPL::Optional<DPL::String>(L"a1");
 392     WidgetVersion version(majorV, minorV, microV, optionalV);
 393
 394     RUNNER_ASSERT(version.IsWac() == true);
 395     RUNNER_ASSERT(version.Major() == majorV);
 396     RUNNER_ASSERT(version.Minor() == minorV);
 397     RUNNER_ASSERT(version.Micro() == microV);
 398     RUNNER_ASSERT(version.Optional() == optionalV);
 399     RUNNER_ASSERT(version.Raw() == raw);
 400 }
 401
 402 /*
 403 Name: WidgetVersion_M4_O2_1
 404 Description: Tests if version is recognized as wac version number.
 405 Expected: major, minor, micro and optional parts matches expected values.
 406  Version should be recognized as wac compatible.
 407 */
 408 RUNNER_TEST(WidgetVersion_M4_O2_nonwac_1)
 409 {
 410     WidgetVersion version(L"1", L"1", DPL::Optional<DPL::String>(L"a1"), DPL::Optional<DPL::String>(L"b1"));
 411
 412     RUNNER_ASSERT(version.IsWac() == false);
 413     RUNNER_ASSERT(version.Raw() == L"1.1.a1 b1");
 414 }
 415
 416 /*
 417 Name: WidgetVersion_Strange_0
 418 Description: tests if version is recognized as wac version number
 419 Expected: version should not be recognized as wac compatible
 420 */
 421 RUNNER_TEST(WidgetVersion_Strange_0)
 422 {
 423     DPL::String raw(L"1");
 424     WidgetVersion version(raw);
 425
 426     RUNNER_ASSERT(version.IsWac() == false);
 427     RUNNER_ASSERT(version.Raw() == raw);
 428 }
 429
 430 /*
 431 Name: WidgetVersion_Strange_1
 432 Description: tests if version is recognized as wac version number
 433 Expected: version should not be recognized as wac compatible
 434 */
 435 RUNNER_TEST(WidgetVersion_Strange_1)
 436 {
 437     DPL::String raw(L".1");
 438     WidgetVersion version(raw);
 439
 440     RUNNER_ASSERT(version.IsWac() == false);
 441     RUNNER_ASSERT(version.Raw() == raw);
 442 }
 443
 444 /*
 445 Name: WidgetVersion_Strange_2
 446 Description: tests if version is recognized as wac version number
 447 Expected: version should not be recognized as wac compatible
 448 */
 449 RUNNER_TEST(WidgetVersion_Strange_2)
 450 {
 451     DPL::String raw(L"..1");
 452     WidgetVersion version(raw);
 453
 454     RUNNER_ASSERT(version.IsWac() == false);
 455     RUNNER_ASSERT(version.Raw() == raw);
 456 }
 457
 458 /*
 459 Name: WidgetVersion_Strange_3
 460 Description: tests if version is recognized as wac version number
 461 Expected: version should not be recognized as wac compatible
 462 */
 463 RUNNER_TEST(WidgetVersion_Strange_3)
 464 {
 465     DPL::String raw(L"...1");
 466     WidgetVersion version(raw);
 467
 468     RUNNER_ASSERT(version.IsWac() == false);
 469     RUNNER_ASSERT(version.Raw() == raw);
 470 }
 471
 472 /*
 473 Name: WidgetVersion_Strange_4
 474 Description: tests if version is recognized as wac version number
 475 Expected: version should not be recognized as wac compatible
 476 */
 477 RUNNER_TEST(WidgetVersion_Strange_4)
 478 {
 479     DPL::String raw(L"qwerty");
 480     WidgetVersion version(raw);
 481
 482     RUNNER_ASSERT(version.IsWac() == false);
 483     RUNNER_ASSERT(version.Raw() == raw);
 484 }
 485
 486 /*
 487 Name: WidgetVersion_Strange_5
 488 Description: tests if version is recognized as wac version number
 489 Expected: version should not be recognized as wac compatible
 490 */
 491 RUNNER_TEST(WidgetVersion_Strange_5)
 492 {
 493     DPL::String raw(L"!@#$%^&*()_+   ^&%^*&%$^*&%*()&   JHKJLHKJLH   685685687");
 494     WidgetVersion version(raw);
 495
 496     RUNNER_ASSERT(version.IsWac() == false);
 497     RUNNER_ASSERT(version.Raw() == raw);
 498 }
 499
 500 /*
 501 Name: WidgetVersion_Strange_6
 502 Description: Tests if version is recognized as wac version number.
 503 Expected: Version should not be recognized as wac compatible.
 504 */
 505 RUNNER_TEST(WidgetVersion_Strange_6)
 506 {
 507     WidgetVersion version(L"1", L"", DPL::Optional<DPL::String>(), DPL::Optional<DPL::String>());
 508
 509     RUNNER_ASSERT(version.IsWac() == false);
 510     RUNNER_ASSERT(version.Raw() == L"1.");
 511 }
 512
 513 /*
 514 Name: WidgetVersion_Strange_7
 515 Description: Tests if version is recognized as wac version number.
 516 Expected: Version should not be recognized as wac compatible.
 517 */
 518 RUNNER_TEST(WidgetVersion_Strange_7)
 519 {
 520     WidgetVersion version(L"a", L"b", DPL::Optional<DPL::String>(), DPL::Optional<DPL::String>());
 521
 522     RUNNER_ASSERT(version.IsWac() == false);
 523     RUNNER_ASSERT(version.Raw() == L"a.b");
 524 }
 525
 526 /*
 527 Name: WidgetVersion_Strange_8
 528 Description: Tests if version is recognized as wac version number.
 529 Expected: Version should not be recognized as wac compatible.
 530 */
 531 RUNNER_TEST(WidgetVersion_Strange_8)
 532 {
 533     WidgetVersion version(L"", L"", DPL::Optional<DPL::String>(L"12"), DPL::Optional<DPL::String>(L"abcd123"));
 534
 535     RUNNER_ASSERT(version.IsWac() == false);
 536     RUNNER_ASSERT(version.Raw() == L"..12 abcd123");
 537 }
 538
 539 /*
 540 Name: WidgetVersion_Compare_0
 541 Description: Tests versions comparision by less than operator.
 542 Expected: Compare should work as expected.
 543 */
 544 RUNNER_TEST(WidgetVersion_Compare_0)
 545 {
 546     RUNNER_ASSERT(WidgetVersion(L"1.1") < WidgetVersion(L"1.2"));
 547     RUNNER_ASSERT(WidgetVersion(L"01.001") < WidgetVersion(L"0001.002"));
 548     RUNNER_ASSERT(WidgetVersion(L"01.001") < WidgetVersion(L"0001.0010"));
 549     RUNNER_ASSERT(WidgetVersion(L"01.001.01") < WidgetVersion(L"0001.001.012 abc"));
 550     RUNNER_ASSERT(WidgetVersion(L"087654321.0123456789") < WidgetVersion(L"0987654321.0123456789"));
 551 }
 552
 553 /*
 554 Name: WidgetVersion_Compare_1
 555 Description: Tests versions comparision by more than operator.
 556 Expected: Compare should work as expected.
 557 */
 558 RUNNER_TEST(WidgetVersion_Compare_1)
 559 {
 560     RUNNER_ASSERT(WidgetVersion(L"1.2") > WidgetVersion(L"1.1"));
 561     RUNNER_ASSERT(WidgetVersion(L"1.020") > WidgetVersion(L"0001.00002"));
 562     RUNNER_ASSERT(WidgetVersion(L"01.0020") > WidgetVersion(L"0001.001"));
 563     RUNNER_ASSERT(WidgetVersion(L"0001.0020.01") > WidgetVersion(L"01.0002.0 abcd"));
 564     RUNNER_ASSERT(WidgetVersion(
 565                       L"19647963733338932479072098437089778943732432.00000000000000004324324324324321")
 566                       > WidgetVersion(L"4324324324324324324321.000432"));
 567 }
 568
 569 /*
 570 Name: WidgetVersion_Compare_2
 571 Description: Tests versions comparision by less than or equal operator.
 572 Expected: Compare should work as expected.
 573 */
 574 RUNNER_TEST(WidgetVersion_Compare_2)
 575 {
 576     RUNNER_ASSERT(WidgetVersion(L"1.1") <= WidgetVersion(L"01.2"));
 577     RUNNER_ASSERT(WidgetVersion(L"0001.02") <= WidgetVersion(L"1.02"));
 578     RUNNER_ASSERT(WidgetVersion(L"001.002") <= WidgetVersion(L"0002.002"));
 579     RUNNER_ASSERT(WidgetVersion(L"2.00000000000000") <=
 580                   WidgetVersion(L"2.0 test"));
 581 }
 582
 583 /*
 584 Name: WidgetVersion_Compare_3
 585 Description: Tests versions comparision more than or equal operator.
 586 Expected: Compare should work as expected.
 587 */
 588 RUNNER_TEST(WidgetVersion_Compare_3)
 589 {
 590     RUNNER_ASSERT(WidgetVersion(L"1.2") >= WidgetVersion(L"1.1"));
 591     RUNNER_ASSERT(WidgetVersion(L"1.20") >= WidgetVersion(L"01.2"));
 592     RUNNER_ASSERT(WidgetVersion(L"001.20") >= WidgetVersion(L"01.0020"));
 593     RUNNER_ASSERT(WidgetVersion(L"001.20.11") >= WidgetVersion(L"01.0020.10 abc"));
 594     RUNNER_ASSERT(WidgetVersion(L"1.00000000000000") >=
 595                   WidgetVersion(L"1.0 test"));
 596 }
 597
 598 /*
 599 Name: WidgetVersion_Compare_4
 600 Description: Tests versions comparsion by equality operator.
 601 Expected: Versions should be equal.
 602 */
 603 RUNNER_TEST(WidgetVersion_Compare_4)
 604 {
 605     RUNNER_ASSERT(WidgetVersion(L"0.1") == WidgetVersion(L"00.1"));
 606     RUNNER_ASSERT(WidgetVersion(L"0002.0001") == WidgetVersion(L"02.01"));
 607     RUNNER_ASSERT(WidgetVersion(L"0001.02") == WidgetVersion(L"1.02"));
 608     RUNNER_ASSERT(WidgetVersion(L"2.0001.12") == WidgetVersion(L"002.01.12 abcd"));
 609     RUNNER_ASSERT(WidgetVersion(L"12345.1") == WidgetVersion(L"12345.1"));
 610     RUNNER_ASSERT(WidgetVersion(L"000123000.0 notatest") ==
 611                   WidgetVersion(L"00123000.0 testtesttest"));
 612 }
 613
 614 /*
 615 Name: WidgetVersion_Compare_5
 616 Description: Tests versions comparsion by inequality operator.
 617 Expected: Versions should not be equal.
 618 */
 619 RUNNER_TEST(WidgetVersion_Compare_5)
 620 {
 621     RUNNER_ASSERT(WidgetVersion(L"1.1") != WidgetVersion(L"1.11"));
 622     RUNNER_ASSERT(WidgetVersion(L"2.1.1") != WidgetVersion(L"2.1.11"));
 623     RUNNER_ASSERT(WidgetVersion(L"003.10.1") != WidgetVersion(L"3.10.11"));
 624     RUNNER_ASSERT(WidgetVersion(L"4.2.1 abc") != WidgetVersion(L"4.2.11 abc"));
 625 }
 626
 627 /*
 628 Name: WidgetVersion_Compare_6
 629 Description: Tests insertin WidgetVersion object into a stream (operator<<)
 630 Expected: Version should be successfully inserted into a stream.
 631 */
 632 RUNNER_TEST(WidgetVersion_Compare_6)
 633 {
 634     std::stringbuf buf;
 635     std::ostream stream(&buf);
 636     DPL::String raw(L"1.1");
 637
 638     stream << WidgetVersion(raw);
 639
 640     RUNNER_ASSERT(DPL::StringCompare(raw, DPL::FromASCIIString(buf.str())) == 0);
 641 }