samples/propgrid/tests.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        samples/propgrid/tests.cpp
   3 // Purpose:     wxPropertyGrid tests
   4 // Author:      Jaakko Salli
   5 // Modified by:
   6 // Created:     2007-05-16
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Jaakko Salli
   9 // Licence:     wxWindows license
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 #include "wx/wxprec.h"
  13
  14 #ifdef __BORLANDC__
  15     #pragma hdrstop
  16 #endif
  17
  18 #ifndef WX_PRECOMP
  19     #include "wx/wx.h"
  20 #endif
  21
  22 #include <wx/propgrid/propgrid.h>
  23 #include <wx/propgrid/advprops.h>
  24 #include <wx/propgrid/manager.h>
  25
  26 #include "propgrid.h"
  27 #include "sampleprops.h"
  28
  29
  30 // -----------------------------------------------------------------------
  31 // wxTestCustomFlagsProperty
  32 // -----------------------------------------------------------------------
  33
  34 //
  35 // Test customizing wxColourProperty via subclassing
  36 //
  37 // * Includes custom colour entry.
  38 // * Includes extra custom entry.
  39 //
  40 class MyColourProperty : public wxColourProperty
  41 {
  42 public:
  43     MyColourProperty( const wxString& label = wxPG_LABEL,
  44                        const wxString& name = wxPG_LABEL,
  45                        const wxColour& value = *wxWHITE )
  46         : wxColourProperty(label, name, value)
  47     {
  48         wxPGChoices colours;
  49         colours.Add(wxT("White"));
  50         colours.Add(wxT("Black"));
  51         colours.Add(wxT("Red"));
  52         colours.Add(wxT("Green"));
  53         colours.Add(wxT("Blue"));
  54         colours.Add(wxT("Custom"));
  55         colours.Add(wxT("None"));
  56         m_choices = colours;
  57         SetIndex(0);
  58         wxVariant variant;
  59         variant << value;
  60         SetValue(variant);
  61     }
  62
  63     virtual ~MyColourProperty()
  64     {
  65     }
  66
  67     virtual wxColour GetColour( int index ) const
  68     {
  69         switch (index)
  70         {
  71             case 0: return *wxWHITE;
  72             case 1: return *wxBLACK;
  73             case 2: return *wxRED;
  74             case 3: return *wxGREEN;
  75             case 4: return *wxBLUE;
  76             case 5:
  77                 // Return current colour for the custom entry
  78                 wxColour col;
  79                 if ( GetIndex() == GetCustomColourIndex() )
  80                 {
  81                     if ( m_value.IsNull() )
  82                         return col;
  83                     col << m_value;
  84                     return col;
  85                 }
  86                 return *wxWHITE;
  87         };
  88         return wxColour();
  89     }
  90
  91     virtual wxString ColourToString( const wxColour& col, int index ) const
  92     {
  93         if ( index == (int)(m_choices.GetCount()-1) )
  94             return wxT("");
  95
  96         return wxColourProperty::ColourToString(col, index);
  97     }
  98
  99     virtual int GetCustomColourIndex() const
 100     {
 101         return m_choices.GetCount()-2;
 102     }
 103 };
 104
 105
 106 void FormMain::AddTestProperties( wxPropertyGridPage* pg )
 107 {
 108     pg->Append( new MyColourProperty(wxT("CustomColourProperty"), wxPG_LABEL, *wxGREEN) );
 109     pg->GetProperty(wxT("CustomColourProperty"))->SetFlag(wxPG_PROP_AUTO_UNSPECIFIED);
 110     pg->SetPropertyEditor( wxT("CustomColourProperty"), wxPGEditor_ComboBox );
 111
 112     pg->SetPropertyHelpString(wxT("CustomColourProperty"),
 113         wxT("This is a MyColourProperty from the sample app. ")
 114         wxT("It is built by subclassing wxColourProperty."));
 115 }
 116
 117 // -----------------------------------------------------------------------
 118
 119 void FormMain::OnDumpList( wxCommandEvent& WXUNUSED(event) )
 120 {
 121     wxVariant values = m_pPropGridManager->GetPropertyValues(wxT("list"), wxNullProperty, wxPG_INC_ATTRIBUTES);
 122     wxString text = wxT("This only tests that wxVariant related routines do not crash.");
 123     wxString t;
 124
 125     wxDialog* dlg = new wxDialog(this,-1,wxT("wxVariant Test"),
 126         wxDefaultPosition,wxDefaultSize,wxDEFAULT_DIALOG_STYLE|wxRESIZE_BORDER);
 127
 128     unsigned int i;
 129     for ( i = 0; i < (unsigned int)values.GetCount(); i++ )
 130     {
 131         wxVariant& v = values[i];
 132
 133         wxString strValue = v.GetString();
 134
 135 #if wxCHECK_VERSION(2,8,0)
 136         if ( v.GetName().EndsWith(wxT("@attr")) )
 137 #else
 138         if ( v.GetName().Right(5) == wxT("@attr") )
 139 #endif
 140         {
 141             text += wxString::Format(wxT("Attributes:\n"));
 142
 143             unsigned int n;
 144             for ( n = 0; n < (unsigned int)v.GetCount(); n++ )
 145             {
 146                 wxVariant& a = v[n];
 147
 148                 t.Printf(wxT("  atribute %i: name=\"%s\"  (type=\"%s\"  value=\"%s\")\n"),(int)n,
 149                     a.GetName().c_str(),a.GetType().c_str(),a.GetString().c_str());
 150                 text += t;
 151             }
 152         }
 153         else
 154         {
 155             t.Printf(wxT("%i: name=\"%s\"  type=\"%s\"  value=\"%s\"\n"),(int)i,
 156                 v.GetName().c_str(),v.GetType().c_str(),strValue.c_str());
 157             text += t;
 158         }
 159     }
 160
 161     // multi-line text editor dialog
 162     const int spacing = 8;
 163     wxBoxSizer* topsizer = new wxBoxSizer( wxVERTICAL );
 164     wxBoxSizer* rowsizer = new wxBoxSizer( wxHORIZONTAL );
 165     wxTextCtrl* ed = new wxTextCtrl(dlg,11,text,
 166         wxDefaultPosition,wxDefaultSize,wxTE_MULTILINE|wxTE_READONLY);
 167     rowsizer->Add( ed, 1, wxEXPAND|wxALL, spacing );
 168     topsizer->Add( rowsizer, 1, wxEXPAND, 0 );
 169     rowsizer = new wxBoxSizer( wxHORIZONTAL );
 170     const int butSzFlags =
 171         wxALIGN_CENTRE_HORIZONTAL|wxALIGN_CENTRE_VERTICAL|wxBOTTOM|wxLEFT|wxRIGHT;
 172     rowsizer->Add( new wxButton(dlg,wxID_OK,wxT("Ok")),
 173         0, butSzFlags, spacing );
 174     topsizer->Add( rowsizer, 0, wxALIGN_RIGHT|wxALIGN_CENTRE_VERTICAL, 0 );
 175
 176     dlg->SetSizer( topsizer );
 177     topsizer->SetSizeHints( dlg );
 178
 179     dlg->SetSize(400,300);
 180     dlg->Centre();
 181     dlg->ShowModal();
 182 }
 183
 184 // -----------------------------------------------------------------------
 185
 186 class TestRunner
 187 {
 188 public:
 189
 190     TestRunner( const wxString& name, wxPropertyGridManager* man, wxTextCtrl* ed, wxArrayString* errorMessages )
 191     {
 192         m_name = name;
 193         m_man = man;
 194         m_ed = ed;
 195         m_errorMessages = errorMessages;
 196 #ifdef __WXDEBUG__
 197         m_preWarnings = wxPGGlobalVars->m_warnings;
 198 #endif
 199
 200         if ( name != wxT("none") )
 201             Msg(name+wxT("\n"));
 202     }
 203
 204     ~TestRunner()
 205     {
 206 #ifdef __WXDEBUG__
 207         int warningsOccurred = wxPGGlobalVars->m_warnings - m_preWarnings;
 208         if ( warningsOccurred )
 209         {
 210             wxString s = wxString::Format(wxT("%i warnings occurred during test '%s'"), warningsOccurred, m_name.c_str());
 211             m_errorMessages->push_back(s);
 212             Msg(s);
 213         }
 214 #endif
 215     }
 216
 217     void Msg( const wxString& text )
 218     {
 219         if ( m_ed )
 220         {
 221             m_ed->AppendText(text);
 222             m_ed->AppendText(wxT("\n"));
 223         }
 224         wxLogDebug(text);
 225     }
 226
 227 protected:
 228     wxPropertyGridManager* m_man;
 229     wxTextCtrl* m_ed;
 230     wxArrayString* m_errorMessages;
 231     wxString m_name;
 232 #ifdef __WXDEBUG__
 233     int m_preWarnings;
 234 #endif
 235 };
 236
 237
 238 #define RT_START_TEST(TESTNAME) \
 239     TestRunner tr(wxT(#TESTNAME), pgman, ed, &errorMessages);
 240
 241 #define RT_MSG(S) \
 242     tr.Msg(S);
 243
 244 #define RT_FAILURE() \
 245     { \
 246         wxString s1 = wxString::Format(wxT("Test failure in tests.cpp, line %i."),__LINE__-1); \
 247         errorMessages.push_back(s1); \
 248         wxLogDebug(s1); \
 249         failures++; \
 250     }
 251
 252 #define RT_FAILURE_MSG(MSG) \
 253     { \
 254         wxString s1 = wxString::Format(wxT("Test failure in tests.cpp, line %i."),__LINE__-1); \
 255         errorMessages.push_back(s1); \
 256         wxLogDebug(s1); \
 257         wxString s2 = wxString::Format(wxT("Message: %s"),MSG); \
 258         errorMessages.push_back(s2); \
 259         wxLogDebug(s2); \
 260         failures++; \
 261     }
 262
 263 #define RT_VALIDATE_VIRTUAL_HEIGHT(PROPS, EXTRATEXT) \
 264     { \
 265         unsigned int h1_ = PROPS->GetVirtualHeight(); \
 266         unsigned int h2_ = PROPS->GetActualVirtualHeight(); \
 267         if ( h1_ != h2_ ) \
 268         { \
 269             wxString s_ = wxString::Format(wxT("VirtualHeight = %i, should be %i (%s)"), h1_, h2_, EXTRATEXT.c_str()); \
 270             RT_FAILURE_MSG(s_.c_str()); \
 271             _failed_ = true; \
 272         } \
 273         else \
 274         { \
 275             _failed_ = false; \
 276         } \
 277     }
 278
 279
 280 int gpiro_cmpfunc(const void* a, const void* b)
 281 {
 282     const wxPGProperty* p1 = (const wxPGProperty*) a;
 283     const wxPGProperty* p2 = (const wxPGProperty*) b;
 284     return (int) (((size_t)p1->GetClientData()) - ((size_t)p2->GetClientData()));
 285 }
 286
 287 wxArrayPGProperty GetPropertiesInRandomOrder( wxPropertyGridInterface* props, int iterationFlags = wxPG_ITERATE_ALL )
 288 {
 289     wxArrayPGProperty arr;
 290
 291     wxPropertyGridIterator it;
 292
 293     for ( it = props->GetIterator(iterationFlags);
 294           !it.AtEnd();
 295           it++ )
 296     {
 297         wxPGProperty* p = *it;
 298         size_t randomNumber = rand();
 299         p->SetClientData(reinterpret_cast<void*>(randomNumber));
 300         arr.push_back(p);
 301     }
 302
 303     wxPGProperty** firstEntry = &arr[0];
 304     qsort(firstEntry, arr.size(), sizeof(wxPGProperty*), gpiro_cmpfunc);
 305
 306     return arr;
 307 }
 308
 309 // Callback for testing property sorting
 310 int MyPropertySortFunction(wxPropertyGrid* WXUNUSED(propGrid),
 311                            wxPGProperty* p1,
 312                            wxPGProperty* p2)
 313 {
 314     // Reverse alphabetical order
 315     return p2->GetLabel().CmpNoCase( p1->GetBaseName() );
 316 }
 317
 318 bool FormMain::RunTests( bool fullTest, bool interactive )
 319 {
 320     wxString t;
 321
 322     wxPropertyGridManager* pgman = m_pPropGridManager;
 323     wxPropertyGrid* pg;
 324
 325     size_t i;
 326
 327     pgman->ClearSelection();
 328
 329     int failures = 0;
 330     bool _failed_ = false;
 331     wxArrayString errorMessages;
 332     wxDialog* dlg = NULL;
 333
 334     dlg = new wxDialog(this,-1,wxT("wxPropertyGrid Regression Tests"),
 335         wxDefaultPosition,wxDefaultSize,wxDEFAULT_DIALOG_STYLE|wxRESIZE_BORDER);
 336
 337     // multi-line text editor dialog
 338     const int spacing = 8;
 339     wxBoxSizer* topsizer = new wxBoxSizer( wxVERTICAL );
 340     wxBoxSizer* rowsizer = new wxBoxSizer( wxHORIZONTAL );
 341     wxTextCtrl* ed = new wxTextCtrl(dlg,11,wxEmptyString,
 342         wxDefaultPosition,wxDefaultSize,wxTE_MULTILINE|wxTE_READONLY);
 343     rowsizer->Add( ed, 1, wxEXPAND|wxALL, spacing );
 344     topsizer->Add( rowsizer, 1, wxEXPAND, 0 );
 345     rowsizer = new wxBoxSizer( wxHORIZONTAL );
 346     const int butSzFlags =
 347         wxALIGN_CENTRE_HORIZONTAL|wxALIGN_CENTRE_VERTICAL|wxBOTTOM|wxLEFT|wxRIGHT;
 348     rowsizer->Add( new wxButton(dlg,wxID_OK,wxT("Ok")),
 349         0, butSzFlags, spacing );
 350     topsizer->Add( rowsizer, 0, wxALIGN_RIGHT|wxALIGN_CENTRE_VERTICAL, 0 );
 351
 352     dlg->SetSizer( topsizer );
 353     topsizer->SetSizeHints( dlg );
 354
 355     dlg->SetSize(400,300);
 356     dlg->Move(wxSystemSettings::GetMetric(wxSYS_SCREEN_X)-dlg->GetSize().x,
 357               wxSystemSettings::GetMetric(wxSYS_SCREEN_Y)-dlg->GetSize().y);
 358     dlg->Show();
 359
 360     {
 361         //
 362         // Basic iterator tests
 363         RT_START_TEST(GetIterator)
 364
 365         wxPGVIterator it;
 366         int count;
 367
 368         count = 0;
 369         for ( it = pgman->GetVIterator(wxPG_ITERATE_PROPERTIES);
 370               !it.AtEnd();
 371               it.Next() )
 372         {
 373             wxPGProperty* p = it.GetProperty();
 374             if ( p->IsCategory() )
 375                 RT_FAILURE_MSG(wxString::Format(wxT("'%s' is a category (non-private child property expected)"),p->GetLabel().c_str()).c_str())
 376             else if ( p->GetParent()->HasFlag(wxPG_PROP_AGGREGATE) )
 377                 RT_FAILURE_MSG(wxString::Format(wxT("'%s' is a private child (non-private child property expected)"),p->GetLabel().c_str()).c_str())
 378             count++;
 379         }
 380
 381         RT_MSG(wxString::Format(wxT("GetVIterator(wxPG_ITERATE_PROPERTIES) -> %i entries"), count));
 382
 383         count = 0;
 384         for ( it = pgman->GetVIterator(wxPG_ITERATE_CATEGORIES);
 385               !it.AtEnd();
 386               it.Next() )
 387         {
 388             wxPGProperty* p = it.GetProperty();
 389             if ( !p->IsCategory() )
 390                 RT_FAILURE_MSG(wxString::Format(wxT("'%s' is not a category (only category was expected)"),p->GetLabel().c_str()).c_str())
 391             count++;
 392         }
 393
 394         RT_MSG(wxString::Format(wxT("GetVIterator(wxPG_ITERATE_CATEGORIES) -> %i entries"), count));
 395
 396         count = 0;
 397         for ( it = pgman->GetVIterator(wxPG_ITERATE_PROPERTIES|wxPG_ITERATE_CATEGORIES);
 398               !it.AtEnd();
 399               it.Next() )
 400         {
 401             wxPGProperty* p = it.GetProperty();
 402             if ( p->GetParent()->HasFlag(wxPG_PROP_AGGREGATE) )
 403                 RT_FAILURE_MSG(wxString::Format(wxT("'%s' is a private child (non-private child property or category expected)"),p->GetLabel().c_str()).c_str())
 404             count++;
 405         }
 406
 407         RT_MSG(wxString::Format(wxT("GetVIterator(wxPG_ITERATE_PROPERTIES|wxPG_ITERATE_CATEGORIES) -> %i entries"), count));
 408
 409         count = 0;
 410         for ( it = pgman->GetVIterator(wxPG_ITERATE_VISIBLE);
 411               !it.AtEnd();
 412               it.Next() )
 413         {
 414             wxPGProperty* p = it.GetProperty();
 415             if ( (p->GetParent() != p->GetParentState()->DoGetRoot() && !p->GetParent()->IsExpanded()) )
 416                 RT_FAILURE_MSG(wxString::Format(wxT("'%s' had collapsed parent (only visible properties expected)"),p->GetLabel().c_str()).c_str())
 417             else if ( p->HasFlag(wxPG_PROP_HIDDEN) )
 418                 RT_FAILURE_MSG(wxString::Format(wxT("'%s' was hidden (only visible properties expected)"),p->GetLabel().c_str()).c_str())
 419             count++;
 420         }
 421
 422         RT_MSG(wxString::Format(wxT("GetVIterator(wxPG_ITERATE_VISIBLE) -> %i entries"), count));
 423     }
 424
 425     if ( fullTest )
 426     {
 427         // Test that setting focus to properties does not crash things
 428         RT_START_TEST(SelectProperty)
 429
 430         wxPropertyGridIterator it;
 431         size_t ind;
 432
 433         for ( ind=0; ind<pgman->GetPageCount(); ind++ )
 434         {
 435             wxPropertyGridPage* page = pgman->GetPage(ind);
 436             pgman->SelectPage(page);
 437
 438             for ( it = page->GetIterator(wxPG_ITERATE_VISIBLE);
 439                   !it.AtEnd();
 440                   it++ )
 441             {
 442                 wxPGProperty* p = *it;
 443                 RT_MSG(p->GetLabel());
 444                 pgman->GetGrid()->SelectProperty(p, true);
 445                 ::wxMilliSleep(150);
 446                 Update();
 447             }
 448         }
 449     }
 450
 451     {
 452         //
 453         // Delete everything in reverse order
 454         RT_START_TEST(DeleteProperty)
 455
 456         wxPGVIterator it;
 457         wxArrayPGProperty array;
 458
 459         for ( it = pgman->GetVIterator(wxPG_ITERATE_ALL&~(wxPG_IT_CHILDREN(wxPG_PROP_AGGREGATE)));
 460               !it.AtEnd();
 461               it.Next() )
 462             array.push_back(it.GetProperty());
 463
 464         wxArrayPGProperty::reverse_iterator it2;
 465
 466         for ( it2 = array.rbegin(); it2 != array.rend(); it2++ )
 467         {
 468             wxPGProperty* p = (wxPGProperty*)*it2;
 469             RT_MSG(wxString::Format(wxT("Deleting '%s' ('%s')"),p->GetLabel().c_str(),p->GetName().c_str()));
 470             pgman->DeleteProperty(p);
 471         }
 472
 473         // Recreate grid
 474         CreateGrid( -1, -1 );
 475         pgman = m_pPropGridManager;
 476     }
 477
 478     {
 479         //
 480         // Test property default values
 481         RT_START_TEST(Default_Values)
 482
 483         wxPGVIterator it;
 484
 485         for ( it = pgman->GetVIterator(wxPG_ITERATE_PROPERTIES);
 486               !it.AtEnd();
 487               it.Next() )
 488         {
 489             wxPGProperty* p = it.GetProperty();
 490             pgman->SetPropertyValue(p, p->GetDefaultValue());
 491         }
 492
 493         // Recreate grid
 494         CreateGrid( -1, -1 );
 495         pgman = m_pPropGridManager;
 496     }
 497
 498     {
 499         RT_START_TEST(GetPropertyValues)
 500
 501         for ( i=0; i<3; i++ )
 502         {
 503             wxString text;
 504
 505             wxPropertyGridPage* page = pgman->GetPage(i);
 506
 507             wxVariant values = page->GetPropertyValues();
 508
 509             unsigned int i;
 510             for ( i = 0; i < (unsigned int)values.GetCount(); i++ )
 511             {
 512                 wxVariant& v = values[i];
 513
 514                 t.Printf(wxT("%i: name=\"%s\"  type=\"%s\"\n"),(int)i,
 515                     v.GetName().c_str(),v.GetType().c_str());
 516
 517                 text += t;
 518             }
 519             ed->AppendText(text);
 520         }
 521     }
 522
 523     {
 524         RT_START_TEST(SetPropertyValue_and_GetPropertyValue)
 525
 526         // In this section, mixed up usage of wxT("propname") and "propname"
 527         // in wxPropertyGridInterface functions is intentional.
 528         // Purpose is to test wxPGPropArgCls ctors.
 529
 530         //pg = (wxPropertyGrid*) NULL;
 531
 532         wxArrayString test_arrstr_1;
 533         test_arrstr_1.Add(wxT("Apple"));
 534         test_arrstr_1.Add(wxT("Orange"));
 535         test_arrstr_1.Add(wxT("Lemon"));
 536
 537         wxArrayString test_arrstr_2;
 538         test_arrstr_2.Add(wxT("Potato"));
 539         test_arrstr_2.Add(wxT("Cabbage"));
 540         test_arrstr_2.Add(wxT("Cucumber"));
 541
 542         wxArrayInt test_arrint_1;
 543         test_arrint_1.Add(1);
 544         test_arrint_1.Add(2);
 545         test_arrint_1.Add(3);
 546
 547         wxArrayInt test_arrint_2;
 548         test_arrint_2.Add(0);
 549         test_arrint_2.Add(1);
 550         test_arrint_2.Add(4);
 551
 552 #if wxUSE_DATETIME
 553         wxDateTime dt1 = wxDateTime::Now();
 554         dt1.SetYear(dt1.GetYear()-1);
 555
 556         wxDateTime dt2 = wxDateTime::Now();
 557         dt2.SetYear(dt2.GetYear()-10);
 558 #endif
 559
 560 #define FLAG_TEST_SET1 (wxCAPTION|wxCLOSE_BOX|wxSYSTEM_MENU|wxRESIZE_BORDER)
 561 #define FLAG_TEST_SET2 (wxSTAY_ON_TOP|wxCAPTION|wxICONIZE|wxSYSTEM_MENU)
 562
 563         pgman->SetPropertyValue(wxT("StringProperty"),wxT("Text1"));
 564         pgman->SetPropertyValue(wxT("IntProperty"),1024);
 565         pgman->SetPropertyValue(wxT("FloatProperty"),1024.0000000001);
 566         pgman->SetPropertyValue(wxT("BoolProperty"),FALSE);
 567         pgman->SetPropertyValue(wxT("EnumProperty"),120);
 568         pgman->SetPropertyValue(wxT("ArrayStringProperty"),test_arrstr_1);
 569         wxColour emptyCol;
 570         pgman->SetPropertyValue(wxT("ColourProperty"),emptyCol);
 571         pgman->SetPropertyValue(wxT("ColourProperty"),(wxObject*)wxBLACK);
 572         pgman->SetPropertyValue(wxT("Size"),WXVARIANT(wxSize(150,150)));
 573         pgman->SetPropertyValue(wxT("Position"),WXVARIANT(wxPoint(150,150)));
 574         pgman->SetPropertyValue(wxT("MultiChoiceProperty"),test_arrint_1);
 575 #if wxUSE_DATETIME
 576         pgman->SetPropertyValue(wxT("DateProperty"),dt1);
 577 #endif
 578
 579         pgman->SelectPage(2);
 580         pg = pgman->GetGrid();
 581
 582         if ( pg->GetPropertyValueAsString(wxT("StringProperty")) != wxT("Text1") )
 583             RT_FAILURE();
 584         if ( pg->GetPropertyValueAsInt(wxT("IntProperty")) != 1024 )
 585             RT_FAILURE();
 586         if ( pg->GetPropertyValueAsDouble(wxT("FloatProperty")) != 1024.0000000001 )
 587             RT_FAILURE();
 588         if ( pg->GetPropertyValueAsBool(wxT("BoolProperty")) != FALSE )
 589             RT_FAILURE();
 590         if ( pg->GetPropertyValueAsLong(wxT("EnumProperty")) != 120 )
 591             RT_FAILURE();
 592         if ( pg->GetPropertyValueAsArrayString(wxT("ArrayStringProperty")) != test_arrstr_1 )
 593             RT_FAILURE();
 594         wxColour col;
 595         col << pgman->GetPropertyValue(wxT("ColourProperty"));
 596         if ( col != *wxBLACK )
 597             RT_FAILURE();
 598         if ( wxSizeRefFromVariant(pg->GetPropertyValue(wxT("Size"))) != wxSize(150,150) )
 599             RT_FAILURE();
 600         if ( wxPointRefFromVariant(pg->GetPropertyValue(wxT("Position"))) != wxPoint(150,150) )
 601             RT_FAILURE();
 602         if ( !(pg->GetPropertyValueAsArrayInt(wxT("MultiChoiceProperty")) == test_arrint_1) )
 603             RT_FAILURE();
 604 #if wxUSE_DATETIME
 605         if ( !(pg->GetPropertyValueAsDateTime(wxT("DateProperty")) == dt1) )
 606             RT_FAILURE();
 607 #endif
 608
 609         pgman->SetPropertyValue(wxT("IntProperty"),wxLL(10000000000));
 610         if ( pg->GetPropertyValueAsLongLong(wxT("IntProperty")) != wxLL(10000000000) )
 611             RT_FAILURE();
 612
 613         pg->SetPropertyValue(wxT("StringProperty"),wxT("Text2"));
 614         pg->SetPropertyValue(wxT("IntProperty"),512);
 615         pg->SetPropertyValue(wxT("FloatProperty"),512.0);
 616         pg->SetPropertyValue(wxT("BoolProperty"),TRUE);
 617         pg->SetPropertyValue(wxT("EnumProperty"),80);
 618         pg->SetPropertyValue(wxT("ArrayStringProperty"),test_arrstr_2);
 619         pg->SetPropertyValue(wxT("ColourProperty"),(wxObject*)wxWHITE);
 620         pg->SetPropertyValue(wxT("Size"),WXVARIANT(wxSize(300,300)));
 621         pg->SetPropertyValue(wxT("Position"),WXVARIANT(wxPoint(300,300)));
 622         pg->SetPropertyValue(wxT("MultiChoiceProperty"),test_arrint_2);
 623 #if wxUSE_DATETIME
 624         pg->SetPropertyValue(wxT("DateProperty"),dt2);
 625 #endif
 626
 627         //pg = (wxPropertyGrid*) NULL;
 628
 629         pgman->SelectPage(0);
 630
 631         if ( pgman->GetPropertyValueAsString(wxT("StringProperty")) != wxT("Text2") )
 632             RT_FAILURE();
 633         if ( pgman->GetPropertyValueAsInt(wxT("IntProperty")) != 512 )
 634             RT_FAILURE();
 635         if ( pgman->GetPropertyValueAsDouble(wxT("FloatProperty")) != 512.0 )
 636             RT_FAILURE();
 637         if ( pgman->GetPropertyValueAsBool(wxT("BoolProperty")) != TRUE )
 638             RT_FAILURE();
 639         if ( pgman->GetPropertyValueAsLong(wxT("EnumProperty")) != 80 )
 640             RT_FAILURE();
 641         if ( pgman->GetPropertyValueAsArrayString(wxT("ArrayStringProperty")) != test_arrstr_2 )
 642             RT_FAILURE();
 643         col << pgman->GetPropertyValue(wxT("ColourProperty"));
 644         if ( col != *wxWHITE )
 645             RT_FAILURE();
 646         if ( wxSizeRefFromVariant(pgman->GetPropertyValue(wxT("Size"))) != wxSize(300,300) )
 647             RT_FAILURE();
 648         if ( wxPointRefFromVariant(pgman->GetPropertyValue(wxT("Position"))) != wxPoint(300,300) )
 649             RT_FAILURE();
 650         if ( !(pgman->GetPropertyValueAsArrayInt(wxT("MultiChoiceProperty")) == test_arrint_2) )
 651             RT_FAILURE();
 652 #if wxUSE_DATETIME
 653         if ( !(pgman->GetPropertyValueAsDateTime(wxT("DateProperty")) == dt2) )
 654             RT_FAILURE();
 655 #endif
 656
 657         pgman->SetPropertyValue(wxT("IntProperty"),wxLL(-80000000000));
 658         if ( pgman->GetPropertyValueAsLongLong(wxT("IntProperty")) != wxLL(-80000000000) )
 659             RT_FAILURE();
 660
 661         //
 662         // Flexible wx(U)LongLong << operator safety conformance tests
 663         wxPGProperty* prop;
 664         wxLongLong ll;
 665         wxULongLong ull;
 666
 667         prop = pgman->GetProperty(wxT("IntProperty"));
 668         prop->SetValue(128);
 669         ll << prop->GetValue();
 670         if ( ll != 128 )
 671             RT_FAILURE();
 672
 673         prop->SetValue(WXVARIANT(wxLL(68719476736)));
 674         ll << prop->GetValue();
 675         if ( ll.GetValue() != wxLL(68719476736) )
 676             RT_FAILURE();
 677
 678 #if wxUSE_LONGLONG_NATIVE
 679         wxLongLong_t ll_t;
 680         ll_t << prop->GetValue();
 681         if ( ll_t != wxLL(68719476736) )
 682             RT_FAILURE();
 683 #endif
 684
 685         prop->SetValue(256);
 686         ll << prop->GetValue();
 687         if ( ll != 256 )
 688             RT_FAILURE();
 689
 690         prop = pgman->GetProperty(wxT("UIntProperty"));
 691         prop->SetValue(128);
 692         ull << prop->GetValue();
 693         if ( ull != 128 )
 694             RT_FAILURE();
 695
 696         prop->SetValue(WXVARIANT(wxULL(68719476739)));
 697         ull << prop->GetValue();
 698         if ( ull.GetValue() != wxULL(68719476739) )
 699             RT_FAILURE();
 700
 701 #if wxUSE_LONGLONG_NATIVE
 702         wxULongLong_t ull_t;
 703         ull_t << prop->GetValue();
 704         if ( ull_t != wxLL(68719476739) )
 705             RT_FAILURE();
 706 #endif
 707
 708         prop->SetValue(256);
 709         ull << prop->GetValue();
 710         if ( ull != 256 )
 711             RT_FAILURE();
 712
 713         // Make sure children of composite parent get updated as well
 714         // Original string value: "Lamborghini Diablo SV; 5707; [300; 3.9; 8.6] 300000; Not Convertible"
 715
 716         //
 717         // This updates children as well
 718         wxString nvs = "Lamborghini Diablo XYZ; 5707; [100; 3.9; 8.6] 3000002; Convertible";
 719         pgman->SetPropertyValue("Car", nvs);
 720
 721         if ( pgman->GetPropertyValueAsString("Car.Model") != "Lamborghini Diablo XYZ" )
 722         {
 723             wxLogDebug("Did not match: Car.Model=%s", pgman->GetPropertyValueAsString("Car.Model").c_str());
 724             RT_FAILURE();
 725         }
 726
 727         if ( pgman->GetPropertyValueAsInt("Car.Speeds.Max. Speed (mph)") != 100 )
 728         {
 729             wxLogDebug("Did not match: Car.Speeds.Max. Speed (mph)=%s", pgman->GetPropertyValueAsString("Car.Speeds.Max. Speed (mph)").c_str());
 730             RT_FAILURE();
 731         }
 732
 733         if ( pgman->GetPropertyValueAsInt("Car.Price ($)") != 3000002 )
 734         {
 735             wxLogDebug("Did not match: Car.Price ($)=%s", pgman->GetPropertyValueAsString("Car.Price ($)").c_str());
 736             RT_FAILURE();
 737         }
 738
 739         if ( !pgman->GetPropertyValueAsBool("Car.Convertible") )
 740         {
 741             wxLogDebug("Did not match: Car.Convertible=%s", pgman->GetPropertyValueAsString("Car.Convertible").c_str());
 742             RT_FAILURE();
 743         }
 744     }
 745
 746     {
 747         RT_START_TEST(SetPropertyValueUnspecified)
 748
 749         // Null variant setter tests
 750         pgman->SetPropertyValueUnspecified(wxT("StringProperty"));
 751         pgman->SetPropertyValueUnspecified(wxT("IntProperty"));
 752         pgman->SetPropertyValueUnspecified(wxT("FloatProperty"));
 753         pgman->SetPropertyValueUnspecified(wxT("BoolProperty"));
 754         pgman->SetPropertyValueUnspecified(wxT("EnumProperty"));
 755         pgman->SetPropertyValueUnspecified(wxT("ArrayStringProperty"));
 756         pgman->SetPropertyValueUnspecified(wxT("ColourProperty"));
 757         pgman->SetPropertyValueUnspecified(wxT("Size"));
 758         pgman->SetPropertyValueUnspecified(wxT("Position"));
 759         pgman->SetPropertyValueUnspecified(wxT("MultiChoiceProperty"));
 760 #if wxUSE_DATETIME
 761         pgman->SetPropertyValueUnspecified(wxT("DateProperty"));
 762 #endif
 763     }
 764
 765     {
 766         RT_START_TEST(Attributes)
 767
 768         wxPGProperty* prop = pgman->GetProperty(wxT("StringProperty"));
 769         prop->SetAttribute(wxT("Dummy Attribute"), (long)15);
 770
 771         if ( prop->GetAttribute(wxT("Dummy Attribute")).GetLong() != 15 )
 772             RT_FAILURE();
 773
 774         prop->SetAttribute(wxT("Dummy Attribute"), wxVariant());
 775
 776         if ( !prop->GetAttribute(wxT("Dummy Attribute")).IsNull() )
 777             RT_FAILURE();
 778     }
 779
 780     {
 781         wxPropertyGridPage* page1;
 782         wxPropertyGridPage* page2;
 783         wxPropertyGridPage* page3;
 784         wxVariant pg1_values;
 785         wxVariant pg2_values;
 786         wxVariant pg3_values;
 787
 788         {
 789             RT_START_TEST(GetPropertyValues)
 790
 791             page1 = pgman->GetPage(0);
 792             pg1_values = page1->GetPropertyValues(wxT("Page1"),NULL,wxPG_KEEP_STRUCTURE);
 793             page2 = pgman->GetPage(1);
 794             pg2_values = page2->GetPropertyValues(wxT("Page2"),NULL,wxPG_KEEP_STRUCTURE);
 795             page3 = pgman->GetPage(2);
 796             pg3_values = page3->GetPropertyValues(wxT("Page3"),NULL,wxPG_KEEP_STRUCTURE);
 797         }
 798
 799         {
 800             RT_START_TEST(SetPropertyValues)
 801
 802             page1->SetPropertyValues(pg3_values);
 803             page2->SetPropertyValues(pg1_values);
 804             page3->SetPropertyValues(pg2_values);
 805         }
 806     }
 807
 808     if ( !(pgman->GetWindowStyleFlag()&wxPG_HIDE_CATEGORIES) )
 809     {
 810         RT_START_TEST(Collapse_and_GetFirstCategory_and_GetNextCategory)
 811
 812         for ( i=0; i<3; i++ )
 813         {
 814             wxPropertyGridPage* page = pgman->GetPage(i);
 815
 816             wxPropertyGridIterator it;
 817
 818             for ( it = page->GetIterator( wxPG_ITERATE_CATEGORIES );
 819                   !it.AtEnd();
 820                   it++ )
 821             {
 822                 wxPGProperty* p = *it;
 823
 824                 if ( !page->IsPropertyCategory(p) )
 825                     RT_FAILURE();
 826
 827                 page->Collapse( p );
 828
 829                 t.Printf(wxT("Collapsing: %s\n"),page->GetPropertyLabel(p).c_str());
 830                 ed->AppendText(t);
 831             }
 832         }
 833     }
 834
 835     {
 836         RT_START_TEST(Save_And_RestoreEditableState)
 837
 838         for ( i=0; i<3; i++ )
 839         {
 840             pgman->SelectPage(i);
 841
 842             wxString stringState = pgman->SaveEditableState();
 843             bool res = pgman->RestoreEditableState(stringState);
 844             if ( !res )
 845                 RT_FAILURE();
 846         }
 847     }
 848
 849     //if ( !(pgman->GetWindowStyleFlag()&wxPG_HIDE_CATEGORIES) )
 850     {
 851         RT_START_TEST(Expand_and_GetFirstCategory_and_GetNextCategory)
 852
 853         for ( i=0; i<3; i++ )
 854         {
 855             wxPropertyGridPage* page = pgman->GetPage(i);
 856
 857             wxPropertyGridIterator it;
 858
 859             for ( it = page->GetIterator( wxPG_ITERATE_CATEGORIES );
 860                   !it.AtEnd();
 861                   it++ )
 862             {
 863                 wxPGProperty* p = *it;
 864
 865                 if ( !page->IsPropertyCategory(p) )
 866                     RT_FAILURE();
 867
 868                 page->Expand( p );
 869
 870                 t.Printf(wxT("Expand: %s\n"),page->GetPropertyLabel(p).c_str());
 871                 ed->AppendText(t);
 872             }
 873         }
 874     }
 875
 876     {
 877         RT_START_TEST(Choice_Manipulation)
 878
 879         wxPGProperty* enumProp = pgman->GetProperty(wxT("EnumProperty"));
 880
 881         pgman->SelectPage(2);
 882         pgman->SelectProperty(enumProp);
 883         wxASSERT(pgman->GetGrid()->GetSelection() == enumProp);
 884
 885         const wxPGChoices& choices = enumProp->GetChoices();
 886         int ind = enumProp->InsertChoice(wxT("New Choice"), choices.GetCount()/2);
 887         enumProp->DeleteChoice(ind);
 888
 889         // Recreate the original grid
 890         CreateGrid( -1, -1 );
 891         pgman = m_pPropGridManager;
 892     }
 893
 894     //if ( !(pgman->GetWindowStyleFlag()&wxPG_HIDE_CATEGORIES) )
 895     {
 896         RT_START_TEST(RandomCollapse)
 897
 898         // Select the most error prone page as visible.
 899         pgman->SelectPage(1);
 900
 901         for ( i=0; i<3; i++ )
 902         {
 903             wxArrayPtrVoid arr;
 904
 905             wxPropertyGridPage* page = pgman->GetPage(i);
 906
 907             wxPropertyGridIterator it;
 908
 909             for ( it = page->GetIterator( wxPG_ITERATE_CATEGORIES );
 910                   !it.AtEnd();
 911                   it++ )
 912             {
 913                 arr.Add((void*)*it);
 914             }
 915
 916             if ( arr.GetCount() )
 917             {
 918                 size_t n;
 919
 920                 pgman->Collapse( (wxPGProperty*)arr.Item(0) );
 921
 922                 for ( n=arr.GetCount()-1; n>0; n-- )
 923                 {
 924                     pgman->Collapse( (wxPGProperty*)arr.Item(n) );
 925                 }
 926             }
 927
 928         }
 929     }
 930
 931     {
 932         RT_START_TEST(EnsureVisible)
 933         pgman->EnsureVisible(wxT("Cell Colour"));
 934     }
 935
 936     {
 937         RT_START_TEST(RemoveProperty)
 938
 939         wxPGProperty* p;
 940
 941         wxPGProperty* origParent =
 942             pgman->GetProperty(wxT("Window Styles"))->GetParent();
 943
 944         p = pgman->RemoveProperty(wxT("Window Styles"));
 945         pgman->Refresh();
 946         pgman->Update();
 947
 948         pgman->AppendIn(origParent, p);
 949         pgman->Refresh();
 950         pgman->Update();
 951     }
 952
 953     {
 954         RT_START_TEST(SortFunction)
 955
 956         wxPGProperty* p;
 957
 958         // Make sure indexes are as supposed
 959
 960         p = pgman->GetProperty(wxT("User Name"));
 961         if ( p->GetIndexInParent() != 3 )
 962             RT_FAILURE();
 963
 964         p = pgman->GetProperty(wxT("User Id"));
 965         if ( p->GetIndexInParent() != 2 )
 966             RT_FAILURE();
 967
 968         p = pgman->GetProperty(wxT("User Home"));
 969         if ( p->GetIndexInParent() != 1 )
 970             RT_FAILURE();
 971
 972         p = pgman->GetProperty(wxT("Operating System"));
 973         if ( p->GetIndexInParent() != 0 )
 974             RT_FAILURE();
 975
 976         pgman->GetGrid()->SetSortFunction(MyPropertySortFunction);
 977
 978         pgman->GetGrid()->SortChildren(wxT("Environment"));
 979
 980         // Make sure indexes have been reversed
 981         p = pgman->GetProperty(wxT("User Name"));
 982         if ( p->GetIndexInParent() != 0 )
 983             RT_FAILURE();
 984
 985         p = pgman->GetProperty(wxT("User Id"));
 986         if ( p->GetIndexInParent() != 1 )
 987             RT_FAILURE();
 988
 989         p = pgman->GetProperty(wxT("User Home"));
 990         if ( p->GetIndexInParent() != 2 )
 991             RT_FAILURE();
 992
 993         p = pgman->GetProperty(wxT("Operating System"));
 994         if ( p->GetIndexInParent() != 3 )
 995             RT_FAILURE();
 996     }
 997
 998     {
 999         RT_START_TEST(SetPropertyBackgroundColour)
1000         wxCommandEvent evt;
1001         evt.SetInt(1); // IsChecked() will return TRUE.
1002         evt.SetId(ID_COLOURSCHEME4);
1003         OnCatColours(evt);
1004         OnColourScheme(evt);
1005     }
1006
1007     {
1008         RT_START_TEST(Clear)
1009
1010         // Manager clear
1011         pgman->SelectProperty("Label");
1012         pgman->Clear();
1013
1014         if ( pgman->GetPageCount() )
1015             RT_FAILURE();
1016
1017         if ( pgman->GetGrid()->GetRoot()->GetChildCount() )
1018             RT_FAILURE();
1019
1020         // Recreate the original grid
1021         CreateGrid( -1, -1 );
1022         pgman = m_pPropGridManager;
1023
1024         // Grid clear
1025         pgman->SelectProperty("Label");
1026         pgman->GetGrid()->Clear();
1027
1028         if ( pgman->GetGrid()->GetRoot()->GetChildCount() )
1029             RT_FAILURE();
1030
1031         // Recreate the original grid
1032         CreateGrid( -1, -1 );
1033         pgman = m_pPropGridManager;
1034     }
1035
1036     /*
1037     {
1038         // TODO: This test fails.
1039         RT_START_TEST(SetSplitterPosition)
1040
1041         InitPanel();
1042
1043         const int trySplitterPos = 50;
1044
1045         int style = wxPG_AUTO_SORT;  // wxPG_SPLITTER_AUTO_CENTER;
1046         pgman = m_pPropGridManager =
1047             new wxPropertyGridManager(m_panel, wxID_ANY,
1048                                       wxDefaultPosition,
1049                                       wxDefaultSize,
1050                                       style );
1051
1052         PopulateGrid();
1053         pgman->SetSplitterPosition(trySplitterPos);
1054
1055         if ( pgman->GetGrid()->GetSplitterPosition() != trySplitterPos )
1056             RT_FAILURE_MSG(wxString::Format(wxT("Splitter position was %i (should have been %i)"),(int)pgman->GetGrid()->GetSplitterPosition(),trySplitterPos).c_str());
1057
1058         m_topSizer->Add( m_pPropGridManager, 1, wxEXPAND );
1059         FinalizePanel();
1060
1061         wxSize sz = GetSize();
1062         wxSize origSz = sz;
1063         sz.x += 5;
1064         sz.y += 5;
1065
1066         if ( pgman->GetGrid()->GetSplitterPosition() != trySplitterPos )
1067             RT_FAILURE_MSG(wxString::Format(wxT("Splitter position was %i (should have been %i)"),(int)pgman->GetGrid()->GetSplitterPosition(),trySplitterPos).c_str());
1068
1069         SetSize(origSz);
1070
1071         // Recreate the original grid
1072         CreateGrid( -1, -1 );
1073         pgman = m_pPropGridManager;
1074     }
1075     */
1076
1077     {
1078         RT_START_TEST(HideProperty)
1079
1080         wxPropertyGridPage* page = pgman->GetPage(0);
1081
1082         srand(0x1234);
1083
1084         wxArrayPGProperty arr1;
1085
1086         arr1 = GetPropertiesInRandomOrder(page);
1087
1088         if ( !_failed_ )
1089         {
1090             for ( i=0; i<arr1.size(); i++ )
1091             {
1092                 wxPGProperty* p = arr1[i];
1093                 page->HideProperty(p, true);
1094
1095                 wxString s = wxString::Format(wxT("HideProperty(%i, %s)"), i, p->GetLabel().c_str());
1096                 RT_VALIDATE_VIRTUAL_HEIGHT(page, s)
1097                 if ( _failed_ )
1098                     break;
1099             }
1100         }
1101
1102         if ( !_failed_ )
1103         {
1104             wxArrayPGProperty arr2 = GetPropertiesInRandomOrder(page);
1105
1106             for ( i=0; i<arr2.size(); i++ )
1107             {
1108                 wxPGProperty* p = arr2[i];
1109                 page->HideProperty(p, false);
1110
1111                 wxString s = wxString::Format(wxT("ShowProperty(%i, %s)"), i, p->GetLabel().c_str());
1112                 RT_VALIDATE_VIRTUAL_HEIGHT(page, s)
1113                 if ( _failed_ )
1114                     break;
1115             }
1116         }
1117
1118         //
1119         // Let's do some more, for better consistency
1120         arr1 = GetPropertiesInRandomOrder(page);
1121
1122         if ( !_failed_ )
1123         {
1124             for ( i=0; i<arr1.size(); i++ )
1125             {
1126                 wxPGProperty* p = arr1[i];
1127                 page->HideProperty(p, true);
1128
1129                 wxString s = wxString::Format(wxT("HideProperty(%i, %s)"), i, p->GetLabel().c_str());
1130                 RT_VALIDATE_VIRTUAL_HEIGHT(page, s)
1131                 if ( _failed_ )
1132                     break;
1133             }
1134         }
1135
1136         if ( !_failed_ )
1137         {
1138             wxArrayPGProperty arr2 = GetPropertiesInRandomOrder(page);
1139
1140             for ( i=0; i<arr2.size(); i++ )
1141             {
1142                 wxPGProperty* p = arr2[i];
1143                 page->HideProperty(p, false);
1144
1145                 wxString s = wxString::Format(wxT("ShowProperty(%i, %s)"), i, p->GetLabel().c_str());
1146                 RT_VALIDATE_VIRTUAL_HEIGHT(page, s)
1147                 if ( _failed_ )
1148                     break;
1149             }
1150         }
1151
1152         //
1153         // Ok, this time only hide half of them
1154         arr1 = GetPropertiesInRandomOrder(page);
1155         arr1.resize(arr1.size()/2);
1156
1157         if ( !_failed_ )
1158         {
1159             for ( i=0; i<arr1.size(); i++ )
1160             {
1161                 wxPGProperty* p = arr1[i];
1162                 page->HideProperty(p, true);
1163
1164                 wxString s = wxString::Format(wxT("HideProperty(%i, %s)"), i, p->GetLabel().c_str());
1165                 RT_VALIDATE_VIRTUAL_HEIGHT(page, s)
1166                 if ( _failed_ )
1167                     break;
1168             }
1169         }
1170
1171         if ( !_failed_ )
1172         {
1173             wxArrayPGProperty arr2 = GetPropertiesInRandomOrder(page);
1174
1175             for ( i=0; i<arr2.size(); i++ )
1176             {
1177                 wxPGProperty* p = arr2[i];
1178                 page->HideProperty(p, false);
1179
1180                 wxString s = wxString::Format(wxT("ShowProperty(%i, %s)"), i, p->GetLabel().c_str());
1181                 RT_VALIDATE_VIRTUAL_HEIGHT(page, s)
1182                 if ( _failed_ )
1183                     break;
1184             }
1185         }
1186
1187         // Recreate the original grid
1188         CreateGrid( -1, -1 );
1189         pgman = m_pPropGridManager;
1190     }
1191
1192     if ( fullTest )
1193     {
1194         RT_START_TEST(MultipleColumns)
1195
1196         // Test with multiple columns
1197         // FIXME: Does not display changes.
1198         for ( i=3; i<12; i+=2 )
1199         {
1200             RT_MSG(wxString::Format(wxT("%i columns"),i));
1201             CreateGrid( -1, -1 );
1202             pgman = m_pPropGridManager;
1203             pgman->SetColumnCount(i);
1204             Refresh();
1205             Update();
1206             wxMilliSleep(500);
1207         }
1208     }
1209
1210     if ( fullTest )
1211     {
1212         RT_START_TEST(WindowStyles)
1213
1214         // Recreate grid with all possible (single) flags
1215         wxASSERT(wxPG_AUTO_SORT == 0x000000010);
1216
1217         for ( i=4; i<16; i++ )
1218         {
1219             int flag = 1<<i;
1220             RT_MSG(wxString::Format(wxT("Style: 0x%X"),flag));
1221             CreateGrid( flag, -1 );
1222             pgman = m_pPropGridManager;
1223             Update();
1224             wxMilliSleep(500);
1225         }
1226
1227         wxASSERT(wxPG_EX_INIT_NOCAT == 0x00001000);
1228
1229         for ( i=12; i<24; i++ )
1230         {
1231             int flag = 1<<i;
1232             RT_MSG(wxString::Format(wxT("ExStyle: 0x%X"),flag));
1233             CreateGrid( -1, flag );
1234             pgman = m_pPropGridManager;
1235             Update();
1236             wxMilliSleep(500);
1237         }
1238
1239         // Recreate the original grid
1240         CreateGrid( -1, -1 );
1241         pgman = m_pPropGridManager;
1242     }
1243
1244     RT_START_TEST(none)
1245
1246     bool retVal;
1247
1248     if ( failures || errorMessages.size() )
1249     {
1250         retVal = false;
1251
1252         wxString s;
1253 #ifdef __WXDEBUG__
1254         if ( failures )
1255 #endif
1256             s = wxString::Format(wxT("%i tests failed!!!"), failures);
1257 #ifdef __WXDEBUG__
1258         else
1259             s = wxString::Format(wxT("All tests were succesfull, but there were %i warnings!"), wxPGGlobalVars->m_warnings);
1260 #endif
1261         RT_MSG(s)
1262         for ( i=0; i<errorMessages.size(); i++ )
1263             RT_MSG(errorMessages[i])
1264         wxMessageBox(s, wxT("Some Tests Failed"));
1265     }
1266     else
1267     {
1268         RT_MSG(wxT("All tests succesfull"))
1269         retVal = true;
1270
1271         if ( !interactive )
1272             dlg->Close();
1273     }
1274
1275     pgman->SelectPage(0);
1276
1277     // Test may screw up the toolbar, so we need to refresh it.
1278     wxToolBar* toolBar = pgman->GetToolBar();
1279     if ( toolBar )
1280         toolBar->Refresh();
1281
1282     return retVal;
1283 }
1284
1285 // -----------------------------------------------------------------------