unittests/tests/FormatTest.cpp

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