samples/console/console.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        samples/console/console.cpp
   3 // Purpose:     a sample console (as opposed to GUI) progam using wxWindows
   4 // Author:      Vadim Zeitlin
   5 // Modified by:
   6 // Created:     04.10.99
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) 1999 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
   9 // Licence:     wxWindows license
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // ============================================================================
  13 // declarations
  14 // ============================================================================
  15
  16 // ----------------------------------------------------------------------------
  17 // headers
  18 // ----------------------------------------------------------------------------
  19
  20 #include <stdio.h>
  21
  22 #include <wx/string.h>
  23 #include <wx/file.h>
  24 #include <wx/app.h>
  25
  26 // ----------------------------------------------------------------------------
  27 // conditional compilation
  28 // ----------------------------------------------------------------------------
  29
  30 // what to test?
  31
  32 //#define TEST_ARRAYS
  33 //#define TEST_LOG
  34 //#define TEST_STRINGS
  35 //#define TEST_THREADS
  36 #define TEST_TIME
  37 //#define TEST_LONGLONG
  38
  39 // ============================================================================
  40 // implementation
  41 // ============================================================================
  42
  43 // ----------------------------------------------------------------------------
  44 // long long
  45 // ----------------------------------------------------------------------------
  46
  47 #ifdef TEST_LONGLONG
  48
  49 #include <wx/longlong.h>
  50 #include <wx/timer.h>
  51
  52 static void TestSpeed()
  53 {
  54     static const long max = 100000000;
  55     long n;
  56
  57     {
  58         wxStopWatch sw;
  59
  60         long l = 0;
  61         for ( n = 0; n < max; n++ )
  62         {
  63             l += n;
  64         }
  65
  66         printf("Summing longs took %ld milliseconds.\n", sw.Time());
  67     }
  68
  69     {
  70         wxStopWatch sw;
  71
  72         __int64 l = 0;
  73         for ( n = 0; n < max; n++ )
  74         {
  75             l += n;
  76         }
  77
  78         printf("Summing __int64s took %ld milliseconds.\n", sw.Time());
  79     }
  80
  81     {
  82         wxStopWatch sw;
  83
  84         wxLongLong l;
  85         for ( n = 0; n < max; n++ )
  86         {
  87             l += n;
  88         }
  89
  90         printf("Summing wxLongLongs took %ld milliseconds.\n", sw.Time());
  91     }
  92 }
  93
  94 static void TestDivision()
  95 {
  96     #define MAKE_LL(x1, x2, x3, x4) wxLongLong((x1 << 16) | x2, (x3 << 16) | x3)
  97
  98     // seed pseudo random generator
  99     //srand((unsigned)time(NULL));
 100
 101     size_t nTested = 0;
 102     for ( size_t n = 0; n < 10000; n++ )
 103     {
 104         // get a random wxLongLong (shifting by 12 the MSB ensures that the
 105         // multiplication will not overflow)
 106         wxLongLong ll = MAKE_LL((rand() >> 12), rand(), rand(), rand());
 107
 108         wxASSERT( (ll * 1000l)/1000l == ll );
 109
 110         nTested++;
 111     }
 112
 113     printf("\n*** Tested %u divisions/multiplications: ok\n", nTested);
 114
 115     #undef MAKE_LL
 116 }
 117
 118 #endif // TEST_LONGLONG
 119
 120 // ----------------------------------------------------------------------------
 121 // date time
 122 // ----------------------------------------------------------------------------
 123
 124 #ifdef TEST_TIME
 125
 126 #include <wx/datetime.h>
 127
 128 // this test miscellaneous static wxDateTime functions
 129 static void TestTimeStatic()
 130 {
 131     puts("\n*** wxDateTime static methods test ***");
 132
 133     // some info about the current date
 134     int year = wxDateTime::GetCurrentYear();
 135     printf("Current year %d is %sa leap one and has %d days.\n",
 136            year,
 137            wxDateTime::IsLeapYear(year) ? "" : "not ",
 138            wxDateTime::GetNumberOfDays(year));
 139
 140     wxDateTime::Month month = wxDateTime::GetCurrentMonth();
 141     printf("Current month is '%s' ('%s') and it has %d days\n",
 142            wxDateTime::GetMonthName(month, TRUE).c_str(),
 143            wxDateTime::GetMonthName(month).c_str(),
 144            wxDateTime::GetNumberOfDays(month));
 145
 146     // leap year logic
 147     static const size_t nYears = 5;
 148     static const size_t years[2][nYears] =
 149     {
 150         // first line: the years to test
 151         { 1990, 1976, 2000, 2030, 1984, },
 152
 153         // second line: TRUE if leap, FALSE otherwise
 154         { FALSE, TRUE, TRUE, FALSE, TRUE }
 155     };
 156
 157     for ( size_t n = 0; n < nYears; n++ )
 158     {
 159         int year = years[0][n];
 160         bool should = years[1][n] != 0;
 161
 162         printf("Year %d is %sa leap year (should be: %s)\n",
 163                year,
 164                wxDateTime::IsLeapYear(year) ? "" : "not ",
 165                should ? "yes" : "no");
 166
 167         wxASSERT( should == wxDateTime::IsLeapYear(year) );
 168     }
 169 }
 170
 171 // test constructing wxDateTime objects
 172 static void TestTimeSet()
 173 {
 174     puts("\n*** wxDateTime construction test ***");
 175
 176     printf("Current time:\t%s\n", wxDateTime::Now().Format().c_str());
 177     printf("Unix epoch:\t%s\n", wxDateTime((time_t)0).Format().c_str());
 178     printf("Today noon:\t%s\n", wxDateTime(12, 0).Format().c_str());
 179     printf("May 29, 1976:\t%s\n", wxDateTime(29, wxDateTime::May, 1976).Format().c_str());
 180 }
 181
 182 // test time zones stuff
 183 static void TestTimeZones()
 184 {
 185     puts("\n*** wxDateTime timezone test ***");
 186
 187     wxDateTime now = wxDateTime::Now();
 188
 189     printf("Current GMT time:\t%s\n", now.ToGMT().Format().c_str());
 190     printf("Unix epoch (GMT):\t%s\n", wxDateTime((time_t)0).MakeGMT().Format().c_str());
 191     printf("Current time in Paris:\t%s\n", now.ToTimezone(wxDateTime::CET).Format().c_str());
 192     printf("               Moscow:\t%s\n", now.ToTimezone(wxDateTime::MSK).Format().c_str());
 193     printf("             New York:\t%s\n", now.ToTimezone(wxDateTime::EST).Format().c_str());
 194 }
 195
 196 // test some minimal support for the dates outside the standard range
 197 static void TestTimeRange()
 198 {
 199     puts("\n*** wxDateTime out-of-standard-range dates test ***");
 200
 201     printf("Unix epoch:\t%s\n",
 202            wxDateTime(2440587.5).Format().c_str());
 203     printf("Feb 29, 0: \t%s\n",
 204             wxDateTime(29, wxDateTime::Feb, 0).Format().c_str());
 205     printf("JDN 0:     \t%s\n",
 206             wxDateTime(0.0).Format().c_str());
 207     printf("Jan 1, 1AD:\t%s\n",
 208             wxDateTime(1, wxDateTime::Jan, 1).Format().c_str());
 209     printf("May 29, 2099:\t%s\n",
 210             wxDateTime(29, wxDateTime::May, 2099).Format().c_str());
 211 }
 212
 213 // test conversions to JDN &c
 214 static void TestTimeJDN()
 215 {
 216     puts("\n*** wxDateTime to JDN test ***");
 217
 218     struct Date
 219     {
 220         wxDateTime::wxDateTime_t day;
 221         wxDateTime::Month month;
 222         int year;
 223         double jdn;
 224     };
 225
 226     static const Date testDates[] =
 227     {
 228         { 21, wxDateTime::Jan,  2222, 2532648.5 },
 229         { 29, wxDateTime::May,  1976, 2442927.5 },
 230         { 1,  wxDateTime::Jan,  1970, 2440587.5 },
 231         { 1,  wxDateTime::Jan,  1900, 2415020.5 },
 232         { 15, wxDateTime::Oct,  1582, 2299160.5 },
 233         { 4,  wxDateTime::Oct,  1582, 2299149.5 },
 234         { 1,  wxDateTime::Mar,     1, 1721484.5 },
 235         { 1,  wxDateTime::Jan,     1, 1721425.5 },
 236         { 31, wxDateTime::Dec,     0, 1721424.5 },
 237         { 1,  wxDateTime::Jan,     0, 1721059.5 },
 238         { 12, wxDateTime::Aug, -1234, 1270573.5 },
 239         { 12, wxDateTime::Aug, -4000,  260313.5 },
 240         { 24, wxDateTime::Nov, -4713,      -0.5 },
 241     };
 242
 243     for ( size_t n = 0; n < WXSIZEOF(testDates); n++ )
 244     {
 245         const Date& d = testDates[n];
 246         wxDateTime dt(d.day, d.month, d.year);
 247         double jdn = dt.GetJulianDayNumber();
 248
 249         printf("JDN of %s %02d, %4d%s is:\t%f",
 250                wxDateTime::GetMonthName(d.month).c_str(),
 251                d.day,
 252                wxDateTime::ConvertYearToBC(d.year),
 253                d.year > 0 ? "AD" : "BC",
 254                jdn);
 255         if ( jdn == d.jdn )
 256         {
 257             puts(" (ok)");
 258         }
 259         else
 260         {
 261             printf(" (ERROR: should be %f, delta = %f)\n",
 262                    d.jdn, jdn - d.jdn);
 263         }
 264     }
 265 }
 266
 267 #endif // TEST_TIME
 268
 269 // ----------------------------------------------------------------------------
 270 // threads
 271 // ----------------------------------------------------------------------------
 272
 273 #ifdef TEST_THREADS
 274
 275 #include <wx/thread.h>
 276
 277 static size_t gs_counter = (size_t)-1;
 278 static wxCriticalSection gs_critsect;
 279 static wxCondition gs_cond;
 280
 281 class MyJoinableThread : public wxThread
 282 {
 283 public:
 284     MyJoinableThread(size_t n) : wxThread(wxTHREAD_JOINABLE)
 285         { m_n = n; Create(); }
 286
 287     // thread execution starts here
 288     virtual ExitCode Entry();
 289
 290 private:
 291     size_t m_n;
 292 };
 293
 294 wxThread::ExitCode MyJoinableThread::Entry()
 295 {
 296     unsigned long res = 1;
 297     for ( size_t n = 1; n < m_n; n++ )
 298     {
 299         res *= n;
 300
 301         // it's a loooong calculation :-)
 302         Sleep(100);
 303     }
 304
 305     return (ExitCode)res;
 306 }
 307
 308 class MyDetachedThread : public wxThread
 309 {
 310 public:
 311     MyDetachedThread(size_t n, char ch)
 312     {
 313         m_n = n;
 314         m_ch = ch;
 315         m_cancelled = FALSE;
 316
 317         Create();
 318     }
 319
 320     // thread execution starts here
 321     virtual ExitCode Entry();
 322
 323     // and stops here
 324     virtual void OnExit();
 325
 326 private:
 327     size_t m_n; // number of characters to write
 328     char m_ch;  // character to write
 329
 330     bool m_cancelled;   // FALSE if we exit normally
 331 };
 332
 333 wxThread::ExitCode MyDetachedThread::Entry()
 334 {
 335     {
 336         wxCriticalSectionLocker lock(gs_critsect);
 337         if ( gs_counter == (size_t)-1 )
 338             gs_counter = 1;
 339         else
 340             gs_counter++;
 341     }
 342
 343     for ( size_t n = 0; n < m_n; n++ )
 344     {
 345         if ( TestDestroy() )
 346         {
 347             m_cancelled = TRUE;
 348
 349             break;
 350         }
 351
 352         putchar(m_ch);
 353         fflush(stdout);
 354
 355         wxThread::Sleep(100);
 356     }
 357
 358     return 0;
 359 }
 360
 361 void MyDetachedThread::OnExit()
 362 {
 363     wxLogTrace("thread", "Thread %ld is in OnExit", GetId());
 364
 365     wxCriticalSectionLocker lock(gs_critsect);
 366     if ( !--gs_counter && !m_cancelled )
 367         gs_cond.Signal();
 368 }
 369
 370 void TestDetachedThreads()
 371 {
 372     puts("\n*** Testing detached threads ***");
 373
 374     static const size_t nThreads = 3;
 375     MyDetachedThread *threads[nThreads];
 376     size_t n;
 377     for ( n = 0; n < nThreads; n++ )
 378     {
 379         threads[n] = new MyDetachedThread(10, 'A' + n);
 380     }
 381
 382     threads[0]->SetPriority(WXTHREAD_MIN_PRIORITY);
 383     threads[1]->SetPriority(WXTHREAD_MAX_PRIORITY);
 384
 385     for ( n = 0; n < nThreads; n++ )
 386     {
 387         threads[n]->Run();
 388     }
 389
 390     // wait until all threads terminate
 391     gs_cond.Wait();
 392
 393     puts("");
 394 }
 395
 396 void TestJoinableThreads()
 397 {
 398     puts("\n*** Testing a joinable thread (a loooong calculation...) ***");
 399
 400     // calc 10! in the background
 401     MyJoinableThread thread(10);
 402     thread.Run();
 403
 404     printf("\nThread terminated with exit code %lu.\n",
 405            (unsigned long)thread.Wait());
 406 }
 407
 408 void TestThreadSuspend()
 409 {
 410     puts("\n*** Testing thread suspend/resume functions ***");
 411
 412     MyDetachedThread *thread = new MyDetachedThread(15, 'X');
 413
 414     thread->Run();
 415
 416     // this is for this demo only, in a real life program we'd use another
 417     // condition variable which would be signaled from wxThread::Entry() to
 418     // tell us that the thread really started running - but here just wait a
 419     // bit and hope that it will be enough (the problem is, of course, that
 420     // the thread might still not run when we call Pause() which will result
 421     // in an error)
 422     wxThread::Sleep(300);
 423
 424     for ( size_t n = 0; n < 3; n++ )
 425     {
 426         thread->Pause();
 427
 428         puts("\nThread suspended");
 429         if ( n > 0 )
 430         {
 431             // don't sleep but resume immediately the first time
 432             wxThread::Sleep(300);
 433         }
 434         puts("Going to resume the thread");
 435
 436         thread->Resume();
 437     }
 438
 439     puts("Waiting until it terminates now");
 440
 441     // wait until the thread terminates
 442     gs_cond.Wait();
 443
 444     puts("");
 445 }
 446
 447 void TestThreadDelete()
 448 {
 449     // As above, using Sleep() is only for testing here - we must use some
 450     // synchronisation object instead to ensure that the thread is still
 451     // running when we delete it - deleting a detached thread which already
 452     // terminated will lead to a crash!
 453
 454     puts("\n*** Testing thread delete function ***");
 455
 456     MyDetachedThread *thread0 = new MyDetachedThread(30, 'W');
 457
 458     thread0->Delete();
 459
 460     puts("\nDeleted a thread which didn't start to run yet.");
 461
 462     MyDetachedThread *thread1 = new MyDetachedThread(30, 'Y');
 463
 464     thread1->Run();
 465
 466     wxThread::Sleep(300);
 467
 468     thread1->Delete();
 469
 470     puts("\nDeleted a running thread.");
 471
 472     MyDetachedThread *thread2 = new MyDetachedThread(30, 'Z');
 473
 474     thread2->Run();
 475
 476     wxThread::Sleep(300);
 477
 478     thread2->Pause();
 479
 480     thread2->Delete();
 481
 482     puts("\nDeleted a sleeping thread.");
 483
 484     MyJoinableThread thread3(20);
 485     thread3.Run();
 486
 487     thread3.Delete();
 488
 489     puts("\nDeleted a joinable thread.");
 490
 491     MyJoinableThread thread4(2);
 492     thread4.Run();
 493
 494     wxThread::Sleep(300);
 495
 496     thread4.Delete();
 497
 498     puts("\nDeleted a joinable thread which already terminated.");
 499
 500     puts("");
 501 }
 502
 503 #endif // TEST_THREADS
 504
 505 // ----------------------------------------------------------------------------
 506 // arrays
 507 // ----------------------------------------------------------------------------
 508
 509 #ifdef TEST_ARRAYS
 510
 511 void PrintArray(const char* name, const wxArrayString& array)
 512 {
 513     printf("Dump of the array '%s'\n", name);
 514
 515     size_t nCount = array.GetCount();
 516     for ( size_t n = 0; n < nCount; n++ )
 517     {
 518         printf("\t%s[%u] = '%s'\n", name, n, array[n].c_str());
 519     }
 520 }
 521
 522 #endif // TEST_ARRAYS
 523
 524 // ----------------------------------------------------------------------------
 525 // strings
 526 // ----------------------------------------------------------------------------
 527
 528 #ifdef TEST_STRINGS
 529
 530 #include "wx/timer.h"
 531
 532 void TestString()
 533 {
 534     wxStopWatch sw;
 535
 536     wxString a, b, c;
 537
 538     a.reserve (128);
 539     b.reserve (128);
 540     c.reserve (128);
 541
 542     for (int i = 0; i < 1000000; ++i)
 543     {
 544         a = "Hello";
 545         b = " world";
 546         c = "! How'ya doin'?";
 547         a += b;
 548         a += c;
 549         c = "Hello world! What's up?";
 550         if (c != a)
 551             c = "Doh!";
 552     }
 553
 554     printf ("TestString elapsed time: %ld\n", sw.Time());
 555 }
 556
 557 void TestPChar()
 558 {
 559     wxStopWatch sw;
 560
 561     char a [128];
 562     char b [128];
 563     char c [128];
 564
 565     for (int i = 0; i < 1000000; ++i)
 566     {
 567         strcpy (a, "Hello");
 568         strcpy (b, " world");
 569         strcpy (c, "! How'ya doin'?");
 570         strcat (a, b);
 571         strcat (a, c);
 572         strcpy (c, "Hello world! What's up?");
 573         if (strcmp (c, a) == 0)
 574             strcpy (c, "Doh!");
 575     }
 576
 577     printf ("TestPChar elapsed time: %ld\n", sw.Time());
 578 }
 579
 580 #endif // TEST_STRINGS
 581
 582 // ----------------------------------------------------------------------------
 583 // entry point
 584 // ----------------------------------------------------------------------------
 585
 586 int main(int argc, char **argv)
 587 {
 588     if ( !wxInitialize() )
 589     {
 590         fprintf(stderr, "Failed to initialize the wxWindows library, aborting.");
 591     }
 592
 593 #ifdef TEST_STRINGS
 594     TestPChar();
 595     TestString();
 596 #endif // TEST_STRINGS
 597
 598 #ifdef TEST_ARRAYS
 599     wxArrayString a1;
 600     a1.Add("tiger");
 601     a1.Add("cat");
 602     a1.Add("lion");
 603     a1.Add("dog");
 604     a1.Add("human");
 605     a1.Add("ape");
 606
 607     puts("*** Initially:");
 608
 609     PrintArray("a1", a1);
 610
 611     wxArrayString a2(a1);
 612     PrintArray("a2", a2);
 613
 614     wxSortedArrayString a3(a1);
 615     PrintArray("a3", a3);
 616
 617     puts("*** After deleting a string from a1");
 618     a1.Remove(2);
 619
 620     PrintArray("a1", a1);
 621     PrintArray("a2", a2);
 622     PrintArray("a3", a3);
 623
 624     puts("*** After reassigning a1 to a2 and a3");
 625     a3 = a2 = a1;
 626     PrintArray("a2", a2);
 627     PrintArray("a3", a3);
 628 #endif // TEST_ARRAYS
 629
 630 #ifdef TEST_LOG
 631     wxString s;
 632     for ( size_t n = 0; n < 8000; n++ )
 633     {
 634         s << (char)('A' + (n % 26));
 635     }
 636
 637     wxString msg;
 638     msg.Printf("A very very long message: '%s', the end!\n", s.c_str());
 639
 640     // this one shouldn't be truncated
 641     printf(msg);
 642
 643     // but this one will because log functions use fixed size buffer
 644     // (note that it doesn't need '\n' at the end neither - will be added
 645     //  by wxLog anyhow)
 646     wxLogMessage("A very very long message 2: '%s', the end!", s.c_str());
 647 #endif // TEST_LOG
 648
 649 #ifdef TEST_THREADS
 650     if ( argc > 1 && argv[1][0] == 't' )
 651         wxLog::AddTraceMask("thread");
 652
 653     if ( 1 )
 654         TestDetachedThreads();
 655     if ( 1 )
 656         TestJoinableThreads();
 657     if ( 1 )
 658         TestThreadSuspend();
 659     if ( 1 )
 660         TestThreadDelete();
 661
 662 #endif // TEST_THREADS
 663
 664 #ifdef TEST_LONGLONG
 665     if ( 0 )
 666         TestSpeed();
 667     if ( 1 )
 668         TestDivision();
 669 #endif // TEST_LONGLONG
 670
 671 #ifdef TEST_TIME
 672     TestTimeStatic();
 673     TestTimeSet();
 674     TestTimeZones();
 675     TestTimeRange();
 676     TestTimeJDN();
 677 #endif // TEST_TIME
 678
 679     wxUninitialize();
 680
 681     return 0;
 682 }