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