unittests/tests/FormatTest.cpp

   1 #include <muleunit/test.h>
   2 #include <common/Format.h>
   3 #include <limits>
   4
   5 #include <Types.h>
   6
   7 using namespace muleunit;
   8
   9 // Note: These tests have been written in accordance with the
  10 //       capabilities of printf found in printf(3).
  11
  12 #define ELEMENTS(x) (sizeof(x)/sizeof(x[0]))
  13 #define MIN(x) std::numeric_limits<x>::min()
  14 #define MAX(x) std::numeric_limits<x>::max()
  15
  16
  17 DECLARE(Format)
  18         // Less is valid for the string type, so we need a cut
  19         // down test for that.
  20         void testFormat(const wxString& str, const wxChar* value) {
  21                 for (int p = -1; p < 5; ++p) {
  22                         wxString format;
  23
  24                         format += wxT("%");
  25
  26                         if (p == -1) {
  27                                 format += wxT(".");
  28                         } else {
  29                                 format += wxString::Format(wxT(".%d"), p);
  30                         }
  31
  32                         format += str;
  33
  34                         wxString reference = wxString::Format(format, value);
  35                         wxString actual = CFormat(format) % value;
  36
  37                         ASSERT_EQUALS_M(reference, actual, format + wxT(": '") + reference + wxT("' != '") + actual + wxT("'"));
  38                 }
  39         }
  40 END_DECLARE;
  41
  42
  43 TEST(Format, ConstructorAndGetString)
  44 {
  45         {
  46                 // Null should be valid
  47                 CFormat fmt1(NULL);
  48                 ASSERT_TRUE(fmt1.IsReady());
  49                 ASSERT_EQUALS(wxT(""), fmt1.GetString());
  50         }
  51
  52         {
  53                 // Empty string should be valid
  54                 CFormat fmt2(wxT(""));
  55                 ASSERT_TRUE(fmt2.IsReady());
  56                 ASSERT_EQUALS(wxT(""), fmt2.GetString());
  57         }
  58
  59         {
  60                 // Simple string with no format fields
  61                 CFormat fmt3(wxT("a b c"));
  62                 ASSERT_TRUE(fmt3.IsReady());
  63                 ASSERT_EQUALS(wxT("a b c"), fmt3.GetString());
  64         }
  65
  66         {
  67                 // Simple string with one format field
  68                 CFormat fmt4(wxT("a %i c"));
  69                 ASSERT_FALSE(fmt4.IsReady());
  70 #ifdef __WXDEBUG__
  71                 ASSERT_RAISES(CAssertFailureException, fmt4.GetString());
  72 #endif
  73
  74                 CAssertOff null;
  75                 ASSERT_EQUALS(wxT("a %i c"), fmt4.GetString());
  76         }
  77 }
  78
  79
  80 TEST(Format, SetStringAndGetString)
  81 {
  82         CFormat format(NULL);
  83         ASSERT_TRUE(format.IsReady());
  84         ASSERT_EQUALS(wxT(""), format.GetString());
  85
  86         // Empty string should be valid
  87         format = CFormat(wxT(""));
  88         ASSERT_TRUE(format.IsReady());
  89         ASSERT_EQUALS(wxT(""), format.GetString());
  90
  91         // Simple string with no format fields
  92         format = CFormat(wxT("a b c"));
  93         ASSERT_TRUE(format.IsReady());
  94         ASSERT_EQUALS(wxT("a b c"), format.GetString());
  95
  96         // Simple string with one format field
  97         format = CFormat(wxT("a %i c"));
  98         ASSERT_FALSE(format.IsReady());
  99 #ifdef __WXDEBUG__
 100         ASSERT_RAISES(CAssertFailureException, format.GetString());
 101 #endif
 102
 103         CAssertOff null;
 104         ASSERT_EQUALS(wxT("a %i c"), format.GetString());
 105 }
 106
 107
 108
 109 //! Implementation for the Standard type test
 110 #define STANDARD_TEST(cformat, wxformat, value) \
 111         { \
 112                 wxString reference      = wxString::Format(wxString(wxT("%")) + wxformat, value); \
 113                 wxString actual         = CFormat(wxString(wxT("%")) + cformat) % value; \
 114                 ASSERT_EQUALS_M(reference, actual, wxString(wxT("%")) << wxformat \
 115                                 << wxT(" vs. %") << cformat << wxT(": '") + reference + wxT("' != '") + actual + wxT("'")); \
 116         }
 117
 118
 119
 120 //! Test the two boundaries and a middle value of the specificed format
 121 #define STANDARD_TYPE_TESTS(cformat, wxformat, type) \
 122         STANDARD_TEST(cformat, wxformat, MIN(type)); \
 123         STANDARD_TEST(cformat, wxformat, (type)(MAX(type) / 2)); \
 124         STANDARD_TEST(cformat, wxformat, MAX(type)); \
 125
 126 // In wx >= 2.9 wxChar represents a Unicode code point, thus its maximum value
 127 // is 1114111 (0x10ffff).
 128 TEST(Format, InjectwxChar)
 129 {
 130         STANDARD_TEST(wxT("c"), wxT("c"), MIN(wxChar));
 131         STANDARD_TEST(wxT("c"), wxT("c"), (wxChar)(std::min<wxChar>(MAX(wxChar), 0x10ffff) / 2));
 132         STANDARD_TEST(wxT("c"), wxT("c"), (std::min<wxChar>(MAX(wxChar), 0x10ffff)));
 133 }
 134
 135
 136 //! All length specifiers are supported and should yield the same result
 137 const wxChar* int_lengths[] =
 138 {
 139         wxT("h"),
 140         wxT(""),
 141         wxT("l"),
 142         wxT("ll"),
 143         NULL
 144 };
 145
 146 //! All signed types are supported, and should yield the same result
 147 const wxChar* sint_types[] =
 148 {
 149         wxT("d"),
 150         wxT("i"),
 151         NULL
 152 };
 153
 154
 155 //! All unsigned types are supported, and should yield the same result
 156 const wxChar* uint_types[] =
 157 {
 158         wxT("u"),
 159         wxT("o"),
 160         wxT("x"),
 161         wxT("X"),
 162         NULL
 163 };
 164
 165
 166 TEST(Format, InjectInteger)
 167 {
 168         const wxChar** sint_entry = sint_types;
 169
 170         while (*sint_entry) {
 171                 const wxChar** len_entry = int_lengths;
 172
 173                 while (*len_entry) {
 174                         wxString entry = wxString() << *len_entry << *sint_entry;
 175
 176                         STANDARD_TYPE_TESTS(entry, wxString() << wxT("h") << *sint_entry,       signed short);
 177                         STANDARD_TYPE_TESTS(entry, wxString() << wxT("") << *sint_entry,        signed int);
 178                         STANDARD_TYPE_TESTS(entry, wxString() << wxT("l") << *sint_entry,       signed long);
 179                         STANDARD_TYPE_TESTS(entry, wxString() << wxLongLongFmtSpec << *sint_entry,      signed long long);
 180
 181                         ++len_entry;
 182                 }
 183
 184                 ++sint_entry;
 185         }
 186
 187
 188         const wxChar** uint_entry = uint_types;
 189         while (*uint_entry) {
 190                 const wxChar** len_entry = int_lengths;
 191
 192                 while (*len_entry) {
 193                         wxString entry = wxString() << *len_entry << *uint_entry;
 194
 195                         STANDARD_TYPE_TESTS(entry, wxString() << wxT("h") << *uint_entry,       unsigned short);
 196                         STANDARD_TYPE_TESTS(entry, wxString() << wxT("") << *uint_entry,        unsigned int);
 197                         STANDARD_TYPE_TESTS(entry, wxString() << wxT("l") << *uint_entry,       unsigned long);
 198                         STANDARD_TYPE_TESTS(entry, wxString() << wxLongLongFmtSpec << *uint_entry,      unsigned long long);
 199
 200                         ++len_entry;
 201                 }
 202
 203                 ++uint_entry;
 204         }
 205 }
 206
 207
 208 TEST(Format, InjectFloatAndDouble)
 209 {
 210         STANDARD_TYPE_TESTS(wxT("e"), wxT("e"), float);
 211         STANDARD_TYPE_TESTS(wxT("E"), wxT("E"), float);
 212         STANDARD_TYPE_TESTS(wxT("f"), wxT("f"), float);
 213         STANDARD_TYPE_TESTS(wxT("F"), wxT("F"), float);
 214         STANDARD_TYPE_TESTS(wxT("g"), wxT("g"), float);
 215         STANDARD_TYPE_TESTS(wxT("G"), wxT("G"), float);
 216
 217         STANDARD_TYPE_TESTS(wxT("e"), wxT("e"), double);
 218         STANDARD_TYPE_TESTS(wxT("E"), wxT("E"), double);
 219         STANDARD_TYPE_TESTS(wxT("f"), wxT("f"), double);
 220         STANDARD_TYPE_TESTS(wxT("F"), wxT("F"), double);
 221         STANDARD_TYPE_TESTS(wxT("g"), wxT("g"), double);
 222         STANDARD_TYPE_TESTS(wxT("G"), wxT("G"), double);
 223 }
 224
 225
 226 TEST(Format, InjectString)
 227 {
 228         testFormat(wxT("s"), wxT(""));
 229         testFormat(wxT("s"), wxT("abc"));
 230 }
 231
 232
 233 TEST(Format, InjectNULLString)
 234 {
 235         for (int p = -1; p < 5; ++p) {
 236                 wxString format = wxT("%");
 237
 238                 if (p == -1) {
 239                         format += wxT(".");
 240                 } else {
 241                         format += wxString::Format(wxT(".%d"), p);
 242                 }
 243
 244                 format += wxT("s");
 245
 246                 wxString actual = CFormat(format) % (const wxChar*)NULL;
 247
 248                 ASSERT_TRUE_M(actual.IsEmpty(), wxT("Expected empty string, got '") + actual + wxT("'"));
 249         }
 250 }
 251
 252
 253 TEST(Format, MultipleFields)
 254 {
 255         {
 256                 CFormat fmt1(wxT("%d _ %u _ %i"));
 257                 fmt1 % -1 % 2u % -4;
 258                 ASSERT_TRUE(fmt1.IsReady());
 259                 ASSERT_EQUALS(wxT("-1 _ 2 _ -4"), fmt1.GetString());
 260         }
 261
 262         {
 263                 CFormat fmt2(wxT("%d _ %u _ %i"));
 264                 ASSERT_FALSE(fmt2.IsReady());
 265                 fmt2 % -1;
 266                 ASSERT_FALSE(fmt2.IsReady());
 267                 fmt2 %  2u;
 268                 ASSERT_FALSE(fmt2.IsReady());
 269                 fmt2 % -4;
 270                 ASSERT_TRUE(fmt2.IsReady());
 271                 ASSERT_EQUALS(wxT("-1 _ 2 _ -4"), fmt2.GetString());
 272         }
 273
 274         {
 275                 // Test grouped fields
 276                 CFormat fmt3(wxT("%d%u%i"));
 277                 fmt3 % -1 % 2u % -4;
 278                 ASSERT_EQUALS(wxT("-12-4"), fmt3.GetString());
 279         }
 280 }
 281
 282
 283 TEST(Format, EscapedPercentageSign)
 284 {
 285         {
 286                 CFormat fmt1(wxT("%%"));
 287                 ASSERT_EQUALS(wxT("%"), fmt1.GetString());
 288         }
 289
 290         {
 291                 CFormat fmt2(wxT("-- %% --"));
 292                 ASSERT_EQUALS(wxT("-- % --"), fmt2.GetString());
 293         }
 294
 295         {
 296                 CFormat fmt3(wxT("%d _ %% _ %i"));
 297                 fmt3 % 1 % 2;
 298                 ASSERT_TRUE(fmt3.IsReady());
 299                 ASSERT_EQUALS(wxT("1 _ % _ 2"), fmt3.GetString());
 300         }
 301
 302         {
 303                 CFormat fmt4(wxT("%% _ %% _ %%"));
 304                 ASSERT_EQUALS(wxT("% _ % _ %"), fmt4.GetString());
 305         }
 306 }
 307
 308
 309 ///////////////////////////////////////////////////////////
 310 // The following checks for invalid operations
 311
 312 TEST(Format, MalformedFields)
 313 {
 314 #ifdef __WXDEBUG__
 315         {
 316                 // Incomplete format string
 317                 ASSERT_RAISES(CAssertFailureException, CFormat(wxT("%")));
 318                 ASSERT_RAISES(CAssertFailureException, CFormat(wxT(" -- %")));
 319
 320                 // Non-existing type
 321                 ASSERT_RAISES(CAssertFailureException, CFormat(wxT("%q")) % 1);
 322                 ASSERT_RAISES(CAssertFailureException, CFormat(wxT(" -- %q")) % 1.0f );
 323                 ASSERT_RAISES(CAssertFailureException, CFormat(wxT(" -- %q -- ")) % wxT("1"));
 324
 325                 // Invalid string length
 326                 ASSERT_RAISES(CAssertFailureException, CFormat(wxT("%.qs")) % wxT(""));
 327                 ASSERT_RAISES(CAssertFailureException, CFormat(wxT("%.-10s")) % wxT(""));
 328         }
 329 #endif
 330
 331         {
 332                 CAssertOff null;
 333
 334                 ASSERT_EQUALS(wxT("%"), CFormat(wxT("%")));
 335                 ASSERT_EQUALS(wxT(" -- %"), CFormat(wxT(" -- %")));
 336
 337                 // Non-existing type
 338                 ASSERT_EQUALS(wxT("%q"), CFormat(wxT("%q")) % 1);
 339                 ASSERT_EQUALS(wxT(" -- %q"), CFormat(wxT(" -- %q")) % 1.0f );
 340                 ASSERT_EQUALS(wxT(" -- %q -- "), CFormat(wxT(" -- %q -- ")) % wxT("1"));
 341
 342                 // Invalid string length
 343                 ASSERT_EQUALS(wxT("%.qs"), CFormat(wxT("%.qs")) % wxT(""));
 344                 ASSERT_EQUALS(wxT("%.-10s"), CFormat(wxT("%.-10s")) % wxT(""));
 345
 346                 // Wrong and right arguments
 347                 ASSERT_EQUALS(wxT("%s -- 17"), CFormat(wxT("%s -- %i")) % 1 % 17);
 348         }
 349 }
 350
 351
 352 TEST(Format, NotReady)
 353 {
 354         CFormat fmt(wxT("-- %s - %d"));
 355         ASSERT_FALSE(fmt.IsReady());
 356 #ifdef __WXDEBUG__
 357         ASSERT_RAISES(CAssertFailureException, fmt.GetString());
 358 #endif
 359
 360         {
 361                 CAssertOff null;
 362                 ASSERT_EQUALS(wxT("-- %s - %d"), fmt);
 363         }
 364
 365         fmt % wxT("foo");
 366
 367         ASSERT_FALSE(fmt.IsReady());
 368 #ifdef __WXDEBUG__
 369         ASSERT_RAISES(CAssertFailureException, fmt.GetString());
 370 #endif
 371
 372         {
 373                 CAssertOff null;
 374                 ASSERT_EQUALS(wxT("-- foo - %d"), fmt);
 375         }
 376
 377         fmt % 42;
 378
 379         ASSERT_TRUE(fmt.IsReady());
 380         ASSERT_EQUALS(wxT("-- foo - 42"), fmt.GetString());
 381 }
 382
 383
 384 TEST(Format, WrongTypes)
 385 {
 386 #ifdef __WXDEBUG__
 387         {
 388                 // Entirely wrong types:
 389                 ASSERT_RAISES(CAssertFailureException, CFormat(wxT("%s")) % 1);
 390                 ASSERT_RAISES(CAssertFailureException, CFormat(wxT("%s")) % 1.0f);
 391                 ASSERT_RAISES(CAssertFailureException, CFormat(wxT("%s")) % wxT('1'));
 392
 393                 ASSERT_RAISES(CAssertFailureException, CFormat(wxT("%f")) % 1);
 394                 ASSERT_RAISES(CAssertFailureException, CFormat(wxT("%f")) % wxT('1'));
 395                 ASSERT_RAISES(CAssertFailureException, CFormat(wxT("%f")) % wxT("1"));
 396
 397                 ASSERT_RAISES(CAssertFailureException, CFormat(wxT("%d")) % 1.0f);
 398                 ASSERT_RAISES(CAssertFailureException, CFormat(wxT("%d")) % wxT("1"));
 399         }
 400 #endif
 401
 402         {
 403                 CAssertOff null;
 404
 405                 ASSERT_EQUALS(wxT("-- %s -- 42 --"), CFormat(wxT("-- %s -- %u --")) % 1 % 42);
 406                 ASSERT_EQUALS(wxT("-- %f -- 42 --"), CFormat(wxT("-- %f -- %u --")) % 1 % 42);
 407                 ASSERT_EQUALS(wxT("-- %d -- 42 --"), CFormat(wxT("-- %d -- %u --")) % 1.0f % 42);
 408         }
 409 }
 410
 411
 412 TEST(Format, NotSupported)
 413 {
 414 #ifdef __WXDEBUG__
 415         {
 416                 ASSERT_RAISES(CAssertFailureException, CFormat(wxT("%*d")) % 1);
 417                 ASSERT_RAISES(CAssertFailureException, CFormat(wxT("%*s")) % wxT(""));
 418                 ASSERT_RAISES(CAssertFailureException, CFormat(wxT("%p")) % wxT(""));
 419                 ASSERT_RAISES(CAssertFailureException, CFormat(wxT("%n")) % wxT(""));
 420         }
 421 #endif
 422
 423         {
 424                 CAssertOff null;
 425
 426                 ASSERT_EQUALS(wxT("%*d"), CFormat(wxT("%*d")) % 1);
 427                 ASSERT_EQUALS(wxT("%*s"), CFormat(wxT("%*s")) % wxT(""));
 428                 ASSERT_EQUALS(wxT("%p"), CFormat(wxT("%p")) % wxT(""));
 429                 ASSERT_EQUALS(wxT("%n"), CFormat(wxT("%n")) % wxT(""));
 430         }
 431 }
 432
 433
 434 TEST(Format, Overfeeding)
 435 {
 436         CFormat fmt(wxT("%d - %d"));
 437         ASSERT_FALSE(fmt.IsReady());
 438         fmt % 1 % 2;
 439         ASSERT_TRUE(fmt.IsReady());
 440         ASSERT_EQUALS(wxT("1 - 2"), fmt.GetString());
 441
 442 #ifdef __WXDEBUG__
 443         ASSERT_RAISES(CAssertFailureException, fmt % 1);
 444 #endif
 445         ASSERT_TRUE(fmt.IsReady());
 446         ASSERT_EQUALS(wxT("1 - 2"), fmt.GetString());
 447
 448 #ifdef __WXDEBUG__
 449         ASSERT_RAISES(CAssertFailureException, fmt % 1.0f);
 450 #endif
 451         ASSERT_TRUE(fmt.IsReady());
 452         ASSERT_EQUALS(wxT("1 - 2"), fmt.GetString());
 453
 454 #ifdef __WXDEBUG__
 455         ASSERT_RAISES(CAssertFailureException, fmt % wxT("1"));
 456 #endif
 457         ASSERT_TRUE(fmt.IsReady());
 458         ASSERT_EQUALS(wxT("1 - 2"), fmt.GetString());
 459 }
 460
 461
 462 TEST(Format, 64bValues)
 463 {
 464         {
 465                 CFormat fmt(wxT("%lli - %lli"));
 466                 fmt % MIN(sint64) % MAX(sint64);
 467                 ASSERT_EQUALS(wxT("-9223372036854775808 - 9223372036854775807"), fmt.GetString());
 468         }
 469
 470         {
 471                 CFormat fmt(wxT("%llu - %llu"));
 472                 fmt % MIN(uint64) % MAX(uint64);
 473                 ASSERT_EQUALS(wxT("0 - 18446744073709551615"), fmt.GetString());
 474         }
 475 }
 476
 477
 478 class CTestPrintable : public CPrintable
 479 {
 480 public:
 481         CTestPrintable(int value)
 482                 : m_value(value)
 483         {
 484         }
 485
 486         virtual wxString GetPrintableString() const
 487         {
 488                 return wxString::Format(wxT("%i"), m_value);
 489         }
 490
 491 private:
 492         int m_value;
 493 };
 494
 495 TEST(Format, Printable)
 496 {
 497         {
 498                 CFormat fmt(wxT("%s"));
 499                 fmt % CTestPrintable(10);
 500                 ASSERT_EQUALS(wxT("10"), fmt.GetString());
 501         }
 502
 503         {
 504                 CFormat fmt(wxT("%s"));
 505                 fmt % CTestPrintable(-10);
 506                 ASSERT_EQUALS(wxT("-10"), fmt.GetString());
 507         }
 508 }