src/QANCollection/QANCollection_Test.cxx

   1 // Created on: 2004-03-05
   2 // Created by: Mikhail KUZMITCHEV
   3 // Copyright (c) 2004-2014 OPEN CASCADE SAS
   4 //
   5 // This file is part of Open CASCADE Technology software library.
   6 //
   7 // This library is free software; you can redistribute it and/or modify it under
   8 // the terms of the GNU Lesser General Public License version 2.1 as published
   9 // by the Free Software Foundation, with special exception defined in the file
  10 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
  11 // distribution for complete text of the license and disclaimer of any warranty.
  12 //
  13 // Alternatively, this file may be used under the terms of Open CASCADE
  14 // commercial license or contractual agreement.
  15
  16 #include <QANCollection.hxx>
  17 #include <QANCollection_Common.hxx>
  18
  19 #include <Draw.hxx>
  20 #include <Draw_Interpretor.hxx>
  21
  22 #include <gp_Pnt.hxx>
  23
  24 #include <Precision.hxx>
  25
  26 #include <NCollection_Vector.hxx>
  27
  28 #define ItemType gp_Pnt
  29 #define Key1Type Standard_Real
  30 #define Key2Type Standard_Integer
  31
  32 #include <NCollection_DefineArray1.hxx>
  33 #include <NCollection_DefineHArray1.hxx>
  34 ////////////////////////////////DEFINE_ARRAY1(QANCollection_Array1,QANCollection_BaseCol,ItemType)
  35 ////////////////////////////////DEFINE_HARRAY1(QANCollection_HArray1,QANCollection_Array1)
  36 DEFINE_ARRAY1(QANCollection_Array1Func,QANCollection_BaseColFunc,ItemType)
  37 DEFINE_HARRAY1(QANCollection_HArray1Func,QANCollection_Array1Func)
  38
  39 #include <NCollection_DefineArray2.hxx>
  40 #include <NCollection_DefineHArray2.hxx>
  41 ////////////////////////////////DEFINE_ARRAY2(QANCollection_Array2,QANCollection_BaseCol,ItemType)
  42 ////////////////////////////////DEFINE_HARRAY2(QANCollection_HArray2,QANCollection_Array2)
  43 DEFINE_ARRAY2(QANCollection_Array2Func,QANCollection_BaseColFunc,ItemType)
  44 DEFINE_HARRAY2(QANCollection_HArray2Func,QANCollection_Array2Func)
  45
  46 #include <NCollection_DefineMap.hxx>
  47 #include <NCollection_DefineDataMap.hxx>
  48 #include <NCollection_DefineDoubleMap.hxx>
  49 #include <NCollection_DefineIndexedMap.hxx>
  50 #include <NCollection_DefineIndexedDataMap.hxx>
  51 ////////////////////////////////DEFINE_MAP(QANCollection_Map,QANCollection_Key1BaseCol,Key1Type)
  52 ////////////////////////////////DEFINE_DATAMAP(QANCollection_DataMap,QANCollection_BaseCol,Key1Type,ItemType)
  53 ////////////////////////////////DEFINE_DOUBLEMAP(QANCollection_DoubleMap,QANCollection_Key2BaseCol,Key1Type,Key2Type)
  54 ////////////////////////////////DEFINE_INDEXEDMAP(QANCollection_IndexedMap,QANCollection_Key1BaseCol,Key1Type)
  55 ////////////////////////////////DEFINE_INDEXEDDATAMAP(QANCollection_IDMap,QANCollection_BaseCol,Key1Type,ItemType)
  56 DEFINE_MAP(QANCollection_MapFunc,QANCollection_Key1BaseColFunc,Key1Type)
  57 DEFINE_DATAMAP(QANCollection_DataMapFunc,QANCollection_BaseColFunc,Key1Type,ItemType)
  58 DEFINE_DOUBLEMAP(QANCollection_DoubleMapFunc,QANCollection_Key2BaseColFunc,Key1Type,Key2Type)
  59 DEFINE_INDEXEDMAP(QANCollection_IndexedMapFunc,QANCollection_Key1BaseColFunc,Key1Type)
  60 DEFINE_INDEXEDDATAMAP(QANCollection_IDMapFunc,QANCollection_BaseColFunc,Key1Type,ItemType)
  61
  62 #include <NCollection_DefineList.hxx>
  63 ////////////////////////////////DEFINE_LIST(QANCollection_List,QANCollection_BaseCol,ItemType)
  64 DEFINE_LIST(QANCollection_ListFunc,QANCollection_BaseColFunc,ItemType)
  65
  66 #include <NCollection_DefineSequence.hxx>
  67 #include <NCollection_DefineHSequence.hxx>
  68 ////////////////////////////////DEFINE_SEQUENCE(QANCollection_Sequence,QANCollection_BaseCol,ItemType)
  69 ////////////////////////////////DEFINE_HSEQUENCE(QANCollection_HSequence,QANCollection_Sequence)
  70 DEFINE_SEQUENCE(QANCollection_SequenceFunc,QANCollection_BaseColFunc,ItemType)
  71 DEFINE_HSEQUENCE(QANCollection_HSequenceFunc,QANCollection_SequenceFunc)
  72
  73 // HashCode and IsEquel must be defined for key types of maps
  74 Standard_Integer HashCode(const gp_Pnt thePnt, int theUpper)
  75 {
  76   return HashCode(thePnt.X(),theUpper);
  77 }
  78
  79 Standard_Boolean IsEqual(const gp_Pnt& theP1, const gp_Pnt& theP2)
  80 {
  81   return theP1.IsEqual(theP2,gp::Resolution());
  82 }
  83
  84 ////////////////////////////////void printCollection (QANCollection_Key1BaseCol& aColl,
  85 template <class Coll>
  86 void printCollection (Coll& aColl, const char * str)
  87 {
  88   printf ("%s:\n",str);
  89   Standard_Integer iSize = aColl.Size();
  90   ////////////////////////////////QANCollection_Key1BaseCol::Iterator& anIter = aColl.CreateIterator();
  91   typename Coll::Iterator anIter (aColl);
  92   if (!anIter.More())
  93   {
  94     if (iSize==0)
  95       printf ("   <Empty collection>\n");
  96     else
  97       printf ("Error   : empty collection has size==%d",iSize);
  98   }
  99   else
 100   {
 101     printf ("   Size==%d\n",iSize);
 102     for (; anIter.More(); anIter.Next())
 103       PrintItem(anIter.Value());
 104   }
 105 }
 106
 107 ////////////////////////////////void AssignCollection (QANCollection_BaseCol& aCollSrc,
 108 ////////////////////////////////                       QANCollection_BaseCol& aCollDst)
 109 template <class Coll>
 110 void AssignCollection (Coll& aCollSrc, Coll& aCollDst)
 111 {
 112   printCollection (aCollSrc,"Source collection");
 113   aCollDst.Assign(aCollSrc);
 114   printCollection (aCollDst,"Target collection");
 115 }
 116
 117 // ===================== Test methods of Array1 type ==========================
 118 ////////////////////////////////void TestArray1  (QANCollection_Array1&     theA1)
 119 static void TestArray1  (QANCollection_Array1Func&     theA1)
 120 {
 121   // Bounds
 122   Standard_Integer iLow=theA1.Lower();
 123   Standard_Integer iUpp=theA1.Upper();
 124   Standard_Integer i;
 125
 126   printf ("Info: testing Array1(%d,%d), %s\n",
 127           iLow, iUpp, (theA1.IsDeletable()?"deletable":"frozen"));
 128   // C-array constructor, Length, Init
 129   ItemType anItem;
 130   Random(anItem);
 131   theA1.Init (anItem);
 132   ItemType * rBlock = new ItemType[theA1.Length()];
 133   ////////////////////////////////QANCollection_Array1 aCArr(*rBlock, iLow-100, iUpp-100);
 134   QANCollection_Array1Func aCArr(*rBlock, iLow-100, iUpp-100);
 135   printf ("      created the same sized preallocated array (%d,%d), %s\n",
 136         aCArr.Lower(),aCArr.Upper(),(aCArr.IsDeletable()?"deletable":"frozen"));
 137   // *Value, operator()
 138   for (i=iLow+1; i<iUpp; i++)
 139   {
 140     Random (aCArr.ChangeValue (i-101));
 141     aCArr.SetValue (i-100, ItemType(aCArr.Value(i-101)));
 142     aCArr(i-99) = aCArr(i-100) = aCArr(i-101);
 143   }
 144   // Handle, copy constructor (including operator=)
 145   ////////////////////////////////Handle(QANCollection_HArray1) aHa = new QANCollection_HArray1(aCArr);
 146   Handle(QANCollection_HArray1Func) aHa = new QANCollection_HArray1Func(aCArr);
 147   // Assign
 148   AssignCollection (aHa->ChangeArray1(), theA1);
 149 }
 150
 151 // ===================== Test methods of Array2 type ==========================
 152 ////////////////////////////////void TestArray2  (QANCollection_Array2&     theA2)
 153 static void TestArray2  (QANCollection_Array2Func&     theA2)
 154 {
 155   // Bounds
 156   Standard_Integer iLR=theA2.LowerRow(), iLC=theA2.LowerCol();
 157   Standard_Integer iUR=theA2.UpperRow(), iUC=theA2.UpperCol();
 158   Standard_Integer i,j;
 159
 160   printf ("Info: testing Array2 (%d,%d)(%d,%d), %s\n",
 161           iLR, iUR, iLC, iUC, (theA2.IsDeletable()?"deletable":"frozen"));
 162   // C-array constructor, Length, Init, RowLength, ColLength
 163   ItemType anItem;
 164   Random(anItem);
 165   theA2.Init (anItem);
 166   ItemType * rBlock = new ItemType[theA2.Length()];
 167   ////////////////////////////////QANCollection_Array2 aCArr(*rBlock, iLR-100, iUR-100, iLC, iUC);
 168   QANCollection_Array2Func aCArr(*rBlock, iLR-100, iUR-100, iLC, iUC);
 169   printf ("      created the same sized preallocated array (%d*%d), %s\n",
 170           aCArr.RowLength(), aCArr.ColLength(),
 171           (aCArr.IsDeletable()?"deletable":"frozen"));
 172   // *Value, operator()
 173   for (i=iLR+1; i<iUR; i++)
 174   {
 175     for (j=iLC; j<=iUC; j++)
 176     {
 177       Random (aCArr.ChangeValue (i-101, j));
 178       aCArr.SetValue (i-100, j,
 179                       ItemType(aCArr.Value(i-101,j)));
 180       aCArr(i-99,j) = aCArr(i-100,j) = aCArr(i-101,j);
 181     }
 182   }
 183   // Handle, copy constructor (including operator=)
 184   ////////////////////////////////Handle(QANCollection_HArray2) aHa = new QANCollection_HArray2(aCArr);
 185   Handle(QANCollection_HArray2Func) aHa = new QANCollection_HArray2Func(aCArr);
 186   // Assign
 187   AssignCollection (aHa->ChangeArray2(), theA2);
 188 }
 189
 190 // ===================== Test methods of List type ==========================
 191 ////////////////////////////////void TestList (QANCollection_List&     theL)
 192 static void TestList (QANCollection_ListFunc&     theL)
 193 {
 194   // Extent
 195   Standard_Integer iExt=theL.Extent();
 196   Standard_Integer i;
 197
 198   printf ("Info: testing List(%d)\n", iExt);
 199   // Append(2), Prepend(2), InsertBefore(2), InsertAfter(2),
 200   // Remove, RemoveFirst, First, Last
 201   ItemType anItem;
 202   ////////////////////////////////QANCollection_List aL, aL1;
 203   QANCollection_ListFunc aL, aL1;
 204   for (i=0; i<4; i++)
 205   {
 206     Random (anItem);
 207     aL.Append (anItem); // #1
 208     aL.Append (aL1);    // #2
 209     Random (anItem);
 210     aL1.Prepend (anItem); // #3
 211     aL1.Prepend (aL);     // #4
 212     ////////////////////////////////QANCollection_List::Iterator anI(theL);
 213     QANCollection_ListFunc::Iterator anI(theL);
 214     if (anI.More())
 215     {
 216       Random (anItem);
 217       theL.InsertBefore (anItem, anI); // #5
 218       theL.InsertBefore (aL1, anI);    // #6
 219       Random (anItem);
 220       theL.InsertAfter (anItem, anI); // #7
 221       theL.InsertAfter (aL, anI);     // #8
 222       theL.Remove (anI);  // #9
 223       if (theL.Extent() > 0)
 224         theL.RemoveFirst(); // #10
 225     }
 226     else
 227     {
 228       theL.Prepend (anItem);
 229       PrintItem(theL.First());
 230       PrintItem(theL.Last());
 231     }
 232   }
 233   // Copy constructor + operator=
 234   ////////////////////////////////aL = QANCollection_List(theL);
 235   aL = QANCollection_ListFunc(theL);
 236
 237   // Assign
 238   AssignCollection (theL, aL);
 239
 240   // Clear
 241   aL.Clear();
 242 }
 243
 244 // ===================== Test methods of Sequence type ========================
 245 ////////////////////////////////void TestSequence (QANCollection_Sequence& theS)
 246 static void TestSequence (QANCollection_SequenceFunc& theS)
 247 {
 248   Standard_Integer i;
 249
 250   printf ("Info: testing Sequence\n");
 251   // Append(2)
 252   ItemType anItem;
 253   ////////////////////////////////QANCollection_Sequence aS, aS1;
 254   QANCollection_SequenceFunc aS, aS1;
 255   // Append(2), Prepend(2), InsertBefore(2), InsertAfter(2),
 256   // Remove, RemoveFirst, First, Last
 257   for (i=0; i<4; i++)
 258   {
 259     Random (anItem);
 260     aS.Append (anItem); // #1
 261     aS.Append (aS1);    // #2
 262     Random (anItem);
 263     aS1.Prepend (anItem); // #3
 264     aS1.Prepend (aS);     // #4
 265     if (theS.Length() > 0)
 266     {
 267       Random (anItem);
 268       theS.InsertBefore (1, anItem); // #5
 269       theS.InsertBefore (2, aS1);    // #6
 270       Random (anItem);
 271       theS.InsertAfter (1, anItem); // #7
 272       theS.InsertAfter (2, aS);     // #8
 273       theS.Remove (1);  // #9
 274       if (theS.Length() > 0)
 275         theS.Remove(1); // #10
 276     }
 277     else
 278     {
 279       theS.Prepend (anItem);
 280       PrintItem(theS.First());
 281       PrintItem(theS.Last());
 282     }
 283   }
 284
 285   // ()
 286   PrintItem(theS(1));
 287
 288   // Handle, Split
 289   ////////////////////////////////Handle(QANCollection_HSequence) aHS = new QANCollection_HSequence(aS1);
 290   Handle(QANCollection_HSequenceFunc) aHS = new QANCollection_HSequenceFunc(aS1);
 291   theS.Split (3, aHS->ChangeSequence());
 292
 293   // Assign
 294   AssignCollection (theS, aS);
 295
 296   // Clear
 297   aS.Clear();
 298 }
 299
 300 // ===================== Test methods of Map type =============================
 301 ////////////////////////////////void TestMap  (QANCollection_Map& theM)
 302 static void TestMap  (QANCollection_MapFunc& theM)
 303 {
 304   // Extent
 305   Standard_Integer iExt=theM.Extent();
 306   Standard_Integer i;
 307
 308   printf ("Info: testing Map(l=%d)\n", iExt);
 309   theM.Statistics(cout);
 310   // Resize
 311   theM.ReSize(8);
 312   theM.Statistics(cout);
 313   cout.flush();
 314   // Constructor
 315   ////////////////////////////////QANCollection_Map aM;
 316   QANCollection_MapFunc aM;
 317   // Add
 318   Key1Type aKey;
 319   for (i=0; i<8; i++)
 320   {
 321     Random (aKey);
 322     aM.Add (aKey);
 323   }
 324   // Contains, Remove
 325   if (!aM.Contains(aKey))
 326   {
 327     printf("Error   : map says that it does not contain its key ");
 328     PrintItem(aKey);
 329   }
 330   else
 331   {
 332     aM.Remove(aKey);
 333     printf("      successfully removed item, l=%d\n", aM.Size());
 334   }
 335   // Copy constructor (including operator=)
 336   ////////////////////////////////QANCollection_Map aM2 = QANCollection_Map(aM);
 337   QANCollection_MapFunc aM2 = QANCollection_MapFunc(aM);
 338   // Assign
 339   AssignCollection (aM2,theM);
 340
 341   // Clear
 342   aM.Clear();
 343 }
 344
 345 // ===================== Test methods of DataMap type =========================
 346 ////////////////////////////////void TestDataMap  (QANCollection_DataMap& theM)
 347 static void TestDataMap  (QANCollection_DataMapFunc& theM)
 348 {
 349   // Extent
 350   Standard_Integer iExt=theM.Extent();
 351   Standard_Integer i;
 352
 353   printf ("Info: testing DataMap(l=%d)\n", iExt);
 354   theM.Statistics(cout);
 355   // Resize
 356   theM.ReSize(8);
 357   theM.Statistics(cout);
 358   cout.flush();
 359   // Constructor
 360   ////////////////////////////////QANCollection_DataMap aM;
 361   QANCollection_DataMapFunc aM;
 362   // Bind, Find, ChangeFind, ()
 363   Key1Type aKey;
 364   ItemType anItem;
 365   for (i=0; i<8; i++)
 366   {
 367     Random (aKey);
 368     Random (anItem);
 369     aM.Bind (aKey, anItem);
 370     PrintItem(aM.Find(aKey));
 371     Random(aM(aKey));
 372   }
 373   // IsBound, UnBind
 374   if (!aM.IsBound(aKey))
 375   {
 376     printf("Error   : map says that it does not contain its key ");
 377     PrintItem(aKey);
 378   }
 379   else
 380   {
 381     aM.UnBind(aKey);
 382     printf("      successfully unbound the key, l=%d\n", aM.Size());
 383   }
 384   // Copy constructor (including operator=)
 385   ////////////////////////////////theM = QANCollection_DataMap(aM);
 386   theM = QANCollection_DataMapFunc(aM);
 387   // Assign - prohibited
 388   // AssignCollection (aM2,theM);
 389   printCollection (theM, "DataMap:");
 390
 391   // Clear
 392   aM.Clear();
 393 }
 394
 395
 396 // ===================== Test methods of DoubleMap type =======================
 397 ////////////////////////////////void TestDoubleMap  (QANCollection_DoubleMap& theM)
 398 static void TestDoubleMap  (QANCollection_DoubleMapFunc& theM)
 399 {
 400   // Extent
 401   Standard_Integer iExt=theM.Extent();
 402   Standard_Integer i;
 403
 404   printf ("Info: testing DoubleMap(l=%d)\n", iExt);
 405   theM.Statistics(cout);
 406   // Resize
 407   theM.ReSize(8);
 408   theM.Statistics(cout);
 409   cout.flush();
 410   // Constructor
 411   ////////////////////////////////QANCollection_DoubleMap aM;
 412   QANCollection_DoubleMapFunc aM;
 413   // Bind, Find?,
 414   Key1Type aKey1;
 415   Key2Type aKey2;
 416   for (i=0; i<8; i++)
 417   {
 418     Random (aKey1);
 419     Random (aKey2);
 420     aM.Bind (aKey1, aKey2);
 421     PrintItem(aM.Find1(aKey1));
 422     if (!aM.IsBound1(aKey1))
 423     {
 424       printf("Error   : map says that it does not contain its key ");
 425       PrintItem(aKey1);
 426     }
 427     PrintItem(aM.Find2(aKey2));
 428     if (!aM.IsBound2(aKey2))
 429     {
 430       printf("Error   : map says that it does not contain its key ");
 431       PrintItem(aKey2);
 432     }
 433   }
 434   // AreBound, UnBind
 435   if (!aM.AreBound(aKey1,aKey2))
 436   {
 437     printf("Error   : map says that it does not contain its keys ");
 438     PrintItem(aKey1);
 439     PrintItem(aKey2);
 440   }
 441   else
 442   {
 443     if (aM.UnBind2(aKey2))
 444       printf("      successfully unbound the key, l=%d\n", aM.Size());
 445     if (aM.UnBind1(aKey1))
 446       printf("Error   : unbound both keys?!\n");
 447   }
 448   // Copy constructor (including operator=)
 449   ////////////////////////////////theM = QANCollection_DoubleMap(aM);
 450   theM = QANCollection_DoubleMapFunc(aM);
 451   // Assign - prohibited
 452   // AssignCollection (aM2,theM);
 453   printCollection (theM, "DoubleMap:");
 454
 455   // Clear
 456   aM.Clear();
 457 }
 458
 459 // ===================== Test methods of IndexedMap type ======================
 460 ////////////////////////////////void TestIndexedMap  (QANCollection_IndexedMap& theM)
 461 static void TestIndexedMap  (QANCollection_IndexedMapFunc& theM)
 462 {
 463   // Extent
 464   Standard_Integer iExt=theM.Extent();
 465   Standard_Integer i;
 466
 467   printf ("Info: testing IndexedMap(l=%d)\n", iExt);
 468   theM.Statistics(cout);
 469   // Resize
 470   theM.ReSize(8);
 471   theM.Statistics(cout);
 472   cout.flush();
 473   // Constructor
 474   ////////////////////////////////QANCollection_IndexedMap aM;
 475   QANCollection_IndexedMapFunc aM;
 476   // Add, FindKey, FindIndex
 477   Key1Type aKey;
 478   for (i=0; i<8; i++)
 479   {
 480     Random (aKey);
 481     aM.Add (aKey);
 482     Standard_Integer iIndex=aM.FindIndex(aKey);
 483     printf ("     added a key, i=%d, k=",iIndex);
 484     PrintItem(aM(iIndex));
 485   }
 486   // Contains, Remove
 487   if (!aM.Contains(aM.FindKey(aM.FindIndex(aKey))))
 488   {
 489     printf("Error   : map says that it does not contain its key ");
 490     PrintItem(aKey);
 491   }
 492   else
 493   {
 494     aM.RemoveLast();
 495     printf("      successfully removed item, l=%d\n", aM.Size());
 496   }
 497   // Substitute
 498   Random(aKey);
 499   aM.Substitute(1,aKey);
 500   if (!aM.Contains (aKey) || aM.FindIndex (aKey) != 1)
 501   {
 502     printf("Error   : map does not contain valid key after substitute");
 503   }
 504   // Invoke substitute with the same key
 505   aM.Substitute(1,aKey);
 506   if (!aM.Contains (aKey) || aM.FindIndex (aKey) != 1)
 507   {
 508     printf("Error   : map does not contain valid key after substitute");
 509   }
 510   // Copy constructor (including operator=)
 511   ////////////////////////////////QANCollection_IndexedMap aM2 = QANCollection_IndexedMap(aM);
 512   QANCollection_IndexedMapFunc aM2 = QANCollection_IndexedMapFunc(aM);
 513   // Assign
 514   AssignCollection (aM2,theM);
 515
 516   // Clear
 517   aM.Clear();
 518 }
 519
 520 // ===================== Test methods of IndexedDataMap type ==================
 521 ////////////////////////////////void TestIndexedDataMap  (QANCollection_IDMap& theM)
 522 static void TestIndexedDataMap  (QANCollection_IDMapFunc& theM)
 523 {
 524   // Extent
 525   Standard_Integer iExt=theM.Extent();
 526   Standard_Integer i;
 527
 528   printf ("Info: testing IndexedDataMap(l=%d)\n", iExt);
 529   theM.Statistics(cout);
 530   // Resize
 531   theM.ReSize(8);
 532   theM.Statistics(cout);
 533   cout.flush();
 534   // Constructor
 535   ////////////////////////////////QANCollection_IDMap aM;
 536   QANCollection_IDMapFunc aM;
 537   // Add, FindKey, FindIndex, FindFromIndex, Change..., ()
 538   Key1Type aKey;
 539   ItemType anItem;
 540   for (i=0; i<8; i++)
 541   {
 542     Random (aKey);
 543     Random (anItem);
 544     aM.Add (aKey, anItem);
 545     Standard_Integer iIndex=aM.FindIndex(aKey);
 546     printf ("     added a key, i=%d, k=",iIndex);
 547     PrintItem(aM.FindKey(iIndex));
 548     PrintItem(aM(iIndex));
 549     Random(aM.ChangeFromIndex(iIndex));
 550   }
 551   // Contains, Remove, FindFromKey
 552   if (!aM.Contains(aM.FindKey(aM.FindIndex(aKey))))
 553   {
 554     printf("Error   : map says that it does not contain its key ");
 555     PrintItem(aKey);
 556   }
 557   else
 558   {
 559     anItem = aM.FindFromKey(aKey);
 560     aM.RemoveLast();
 561     printf("      successfully removed item, l=%d\n", aM.Size());
 562   }
 563   // Substitute with different keys
 564   Random(aKey);
 565   aM.Substitute (1, aKey, anItem);
 566   if (!aM.Contains (aKey) || aM.FindIndex (aKey) != 1 || !aM.FindFromKey (aKey).IsEqual (anItem, Precision::Confusion()))
 567   {
 568     printf("Error   : map does not contain valid key and item after substitute");
 569   }
 570   // Substitute with equal keys
 571   Random(anItem);
 572   aM.Substitute (1, aKey, anItem);
 573   if (!aM.Contains (aKey) || aM.FindIndex (aKey) != 1 || !aM.FindFromKey (aKey).IsEqual (anItem, Precision::Confusion()))
 574   {
 575     printf("Error   : map does not contain valid key and item after substitute");
 576   }
 577   // Copy constructor (including operator=)
 578   ////////////////////////////////theM = QANCollection_IDMap(aM);
 579   theM = QANCollection_IDMapFunc(aM);
 580   // Assign - prohibited
 581   // AssignCollection (aM2,theM);
 582   printCollection (theM, "DoubleMap:");
 583
 584   // Clear
 585   aM.Clear();
 586 }
 587
 588 //=======================================================================
 589 //function : CheckArguments1
 590 //purpose  :
 591 //=======================================================================
 592 Standard_Integer CheckArguments1(Draw_Interpretor& di, Standard_Integer argc, const char ** argv, Standard_Integer& Lower, Standard_Integer& Upper)
 593 {
 594   if ( argc != 3) {
 595     di << "Usage : " << argv[0] << " Lower Upper\n";
 596     return 1;
 597   }
 598   Lower = Draw::Atoi(argv[1]);
 599   Upper = Draw::Atoi(argv[2]);
 600   if ( Lower > Upper ) {
 601     di << "Lower > Upper\n";
 602     return 1;
 603   }
 604   return 0;
 605 }
 606
 607 //=======================================================================
 608 //function : CheckArguments2
 609 //purpose  :
 610 //=======================================================================
 611 Standard_Integer CheckArguments2(Draw_Interpretor& di, Standard_Integer argc, const char ** argv, Standard_Integer& LowerRow, Standard_Integer& UpperRow, Standard_Integer& LowerCol, Standard_Integer& UpperCol)
 612 {
 613   if ( argc != 5) {
 614     di << "Usage : " << argv[0] << " LowerRow UpperRow LowerCol UpperCol\n";
 615     return 1;
 616   }
 617   LowerRow = Draw::Atoi(argv[1]);
 618   UpperRow = Draw::Atoi(argv[2]);
 619   LowerCol = Draw::Atoi(argv[3]);
 620   UpperCol = Draw::Atoi(argv[4]);
 621   if ( LowerRow > UpperRow ) {
 622     di << "LowerRow > UpperRow\n";
 623     return 1;
 624   }
 625   if ( LowerCol > UpperCol ) {
 626     di << "LowerCol UpperCol> \n";
 627     return 1;
 628   }
 629   return 0;
 630 }
 631
 632
 633 //=======================================================================
 634 //function : QANColTestArray1
 635 //purpose  :
 636 //=======================================================================
 637 static Standard_Integer QANColTestArray1(Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
 638 {
 639   Standard_Integer Lower, Upper;
 640   if ( CheckArguments1(di, argc, argv, Lower, Upper) ) {
 641     return 1;
 642   }
 643   QANCollection_Array1Func anArr1(Lower, Upper);
 644   TestArray1(anArr1);
 645   return 0;
 646 }
 647
 648 //=======================================================================
 649 //function : QANColTestArray2
 650 //purpose  :
 651 //=======================================================================
 652 static Standard_Integer QANColTestArray2(Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
 653 {
 654   Standard_Integer LowerRow, UpperRow, LowerCol, UpperCol;
 655   if ( CheckArguments2(di, argc, argv, LowerRow, UpperRow, LowerCol, UpperCol) ) {
 656     return 1;
 657   }
 658   QANCollection_Array2Func anArr2(LowerRow, UpperRow, LowerCol, UpperCol);
 659   TestArray2(anArr2);
 660   return 0;
 661 }
 662
 663 //=======================================================================
 664 //function : QANColTestMap
 665 //purpose  :
 666 //=======================================================================
 667 static Standard_Integer QANColTestMap(Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
 668 {
 669   if ( argc != 1) {
 670     di << "Usage : " << argv[0] << "\n";
 671     return 1;
 672   }
 673   QANCollection_MapFunc aMap;
 674   TestMap(aMap);
 675   return 0;
 676 }
 677
 678 //=======================================================================
 679 //function : QANColTestDataMap
 680 //purpose  :
 681 //=======================================================================
 682 static Standard_Integer QANColTestDataMap(Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
 683 {
 684   if ( argc != 1) {
 685     di << "Usage : " << argv[0] << "\n";
 686     return 1;
 687   }
 688   QANCollection_DataMapFunc aDataMap;
 689   TestDataMap(aDataMap);
 690   return 0;
 691 }
 692
 693 //=======================================================================
 694 //function : QANColTestDoubleMap
 695 //purpose  :
 696 //=======================================================================
 697 static Standard_Integer QANColTestDoubleMap(Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
 698 {
 699   if ( argc != 1) {
 700     di << "Usage : " << argv[0] << "\n";
 701     return 1;
 702   }
 703   QANCollection_DoubleMapFunc aDoubleMap;
 704   TestDoubleMap(aDoubleMap);
 705   return 0;
 706 }
 707
 708 //=======================================================================
 709 //function : QANColTestIndexedMap
 710 //purpose  :
 711 //=======================================================================
 712 static Standard_Integer QANColTestIndexedMap(Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
 713 {
 714   if ( argc != 1) {
 715     di << "Usage : " << argv[0] << "\n";
 716     return 1;
 717   }
 718   QANCollection_IndexedMapFunc aIndexedMap;
 719   TestIndexedMap(aIndexedMap);
 720   return 0;
 721 }
 722
 723 //=======================================================================
 724 //function : QANColTestIndexedDataMap
 725 //purpose  :
 726 //=======================================================================
 727 static Standard_Integer QANColTestIndexedDataMap(Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
 728 {
 729   if ( argc != 1) {
 730     di << "Usage : " << argv[0] << "\n";
 731     return 1;
 732   }
 733   QANCollection_IDMapFunc aIDMap;
 734   TestIndexedDataMap(aIDMap);
 735   return 0;
 736 }
 737
 738 //=======================================================================
 739 //function : QANColTestList
 740 //purpose  :
 741 //=======================================================================
 742 static Standard_Integer QANColTestList(Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
 743 {
 744   if ( argc != 1) {
 745     di << "Usage : " << argv[0] << "\n";
 746     return 1;
 747   }
 748   QANCollection_ListFunc aList;
 749   TestList(aList);
 750   return 0;
 751 }
 752
 753 //=======================================================================
 754 //function : QANColTestVector
 755 //purpose  :
 756 //=======================================================================
 757 static Standard_Integer QANColTestVector (Draw_Interpretor&, Standard_Integer, const char**)
 758 {
 759   // test method Append and copying of empty vector
 760   NCollection_Vector<int> aVec;
 761   NCollection_Vector<int> aVec2 (aVec);
 762   NCollection_Vector<int> aVec3;
 763   aVec3 = aVec;
 764
 765   aVec.Append(5);
 766   if (aVec(0) != 5)
 767     std::cout << "Error: wrong value in original vector!" << endl;
 768   aVec2.Append(5);
 769   if (aVec2(0) != 5)
 770     std::cout << "Error: wrong value in copy-constructed vector!" << endl;
 771   aVec3.Append(5);
 772   if (aVec3(0) != 5)
 773     std::cout << "Error: wrong value in copied vector!" << endl;
 774   std::cout << "Test OK" << endl;
 775
 776   return 0;
 777 }
 778
 779 //=======================================================================
 780 //function : QANColTestSequence
 781 //purpose  :
 782 //=======================================================================
 783 static Standard_Integer QANColTestSequence(Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
 784 {
 785   if ( argc != 1) {
 786     di << "Usage : " << argv[0] << "\n";
 787     return 1;
 788   }
 789   QANCollection_SequenceFunc aSeq;
 790   TestSequence(aSeq);
 791   return 0;
 792 }
 793
 794 void QANCollection::CommandsTest(Draw_Interpretor& theCommands) {
 795   const char *group = "QANCollection";
 796
 797   // from agvCollTest/src/CollectionEXE/FuncTestEXE.cxx
 798   theCommands.Add("QANColTestArray1",         "QANColTestArray1",         __FILE__, QANColTestArray1,         group);
 799   theCommands.Add("QANColTestArray2",         "QANColTestArray2",         __FILE__, QANColTestArray2,         group);
 800   theCommands.Add("QANColTestMap",            "QANColTestMap",            __FILE__, QANColTestMap,            group);
 801   theCommands.Add("QANColTestDataMap",        "QANColTestDataMap",        __FILE__, QANColTestDataMap,        group);
 802   theCommands.Add("QANColTestDoubleMap",      "QANColTestDoubleMap",      __FILE__, QANColTestDoubleMap,      group);
 803   theCommands.Add("QANColTestIndexedMap",     "QANColTestIndexedMap",     __FILE__, QANColTestIndexedMap,     group);
 804   theCommands.Add("QANColTestIndexedDataMap", "QANColTestIndexedDataMap", __FILE__, QANColTestIndexedDataMap, group);
 805   theCommands.Add("QANColTestList",           "QANColTestList",           __FILE__, QANColTestList,           group);
 806   theCommands.Add("QANColTestSequence",       "QANColTestSequence",       __FILE__, QANColTestSequence,       group);
 807   theCommands.Add("QANColTestVector",         "QANColTestVector",         __FILE__, QANColTestVector,         group);
 808 }