0026619: Tolerances of operands are modified using bop
[occt.git] / src / QABugs / QABugs_19.cxx
1 // Created on: 2002-05-21
2 // Created by: QA Admin
3 // Copyright (c) 2002-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 <QABugs.hxx>
17
18 #include <Draw_Interpretor.hxx>
19 #include <DBRep.hxx>
20 #include <DrawTrSurf.hxx>
21 #include <ViewerTest.hxx>
22 #include <V3d_View.hxx>
23 #include <TopoDS_Shape.hxx>
24 #include <AIS_InteractiveContext.hxx>
25 #include <AIS_LocalContext.hxx>
26 #include <AIS_TexturedShape.hxx>
27 #include <Image_PixMap.hxx>
28 #include <Image_Color.hxx>
29
30 #include <gp_Pnt2d.hxx>
31 #include <gp_Ax1.hxx>
32 #include <GCE2d_MakeSegment.hxx>
33 #include <Geom2d_TrimmedCurve.hxx>
34 #include <DrawTrSurf.hxx>
35
36 #include <Precision.hxx>
37
38 #include <cstdio>
39 #include <cmath>
40 #include <iostream>
41 #include <OSD_Timer.hxx>
42 #include <OSD_Parallel.hxx>
43 #include <OSD_PerfMeter.hxx>
44 #include <BRepPrimAPI_MakeBox.hxx>
45 #include <BRepPrimAPI_MakeSphere.hxx>
46 #include <BRepAlgo_Cut.hxx>
47 #include <NCollection_Map.hxx>
48 #include <NCollection_Handle.hxx>
49 #include <NCollection_IncAllocator.hxx>
50 #include <TCollection_HAsciiString.hxx>
51 #include <GeomFill_Trihedron.hxx>
52 #include <BRepOffsetAPI_MakePipe.hxx>
53 #include <TopExp_Explorer.hxx>
54
55 #include <SelectMgr_Filter.hxx>
56
57 #include <Standard_Version.hxx>
58
59 #define QCOMPARE(val1, val2) \
60   di << "Checking " #val1 " == " #val2 << \
61         ((val1) == (val2) ? ": OK\n" : ": Error\n")
62
63 static Standard_Integer OCC230 (Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
64 {
65   if ( argc != 4) {
66     di << "ERROR OCC230: Usage : " << argv[0] << " TrimmedCurve Pnt2d Pnt2d\n";
67     return 1;
68   }
69
70   gp_Pnt2d P1, P2;
71   if ( !DrawTrSurf::GetPoint2d(argv[2],P1)) {
72     di << "ERROR OCC230: " << argv[2] << " is not Pnt2d\n";
73     return 1;
74   }
75   if ( !DrawTrSurf::GetPoint2d(argv[3],P2)) {
76     di << "ERROR OCC230: " << argv[3] << " is not Pnt2d\n";
77     return 1;
78   }
79
80   GCE2d_MakeSegment MakeSegment(P1,P2);
81   Handle(Geom2d_TrimmedCurve) TrimmedCurve = MakeSegment.Value();
82   DrawTrSurf::Set(argv[1], TrimmedCurve);
83   return 0;
84 }
85
86 static Standard_Integer OCC23361 (Draw_Interpretor& di, Standard_Integer /*argc*/, const char ** /*argv*/)
87 {
88   gp_Pnt p(0, 0, 2);
89   
90   gp_Trsf t1, t2;
91   t1.SetRotation(gp_Ax1(p, gp_Dir(0, 1, 0)), -0.49328285294022267);
92   t2.SetRotation(gp_Ax1(p, gp_Dir(0, 0, 1)), 0.87538474718473880);
93
94   gp_Trsf tComp = t2 * t1;
95
96   gp_Pnt p1(10, 3, 4);
97   gp_Pnt p2 = p1.Transformed(tComp);
98   gp_Pnt p3 = p1.Transformed(t1);
99   p3.Transform(t2);
100
101   // points must be equal
102   if ( ! p2.IsEqual(p3, Precision::Confusion()) )
103     di << "ERROR OCC23361: equivalent transformations does not produce equal points\n";
104   else 
105     di << "OCC23361: OK\n";
106
107   return 0;
108 }
109
110 static Standard_Integer OCC23237 (Draw_Interpretor& di, Standard_Integer /*argc*/, const char** /*argv*/)
111 {
112   OSD_PerfMeter aPM("TestMeter",0);
113   OSD_Timer aTM;
114   
115   // run some operation in cycle for about 2 seconds to have good values of times to compare
116   int count = 0;
117   printf("OSD_PerfMeter test.\nRunning Boolean operation on solids in loop.\n");
118   for (; aTM.ElapsedTime() < 2.; count++)
119   {
120     aPM.Start();
121     aTM.Start();
122
123     // do some operation that will take considerable time compared with time of starting / stopping timers
124     BRepPrimAPI_MakeBox aBox (10., 10., 10.);
125     BRepPrimAPI_MakeSphere aSphere (10.);
126     BRepAlgo_Cut aCutter (aBox.Shape(), aSphere.Shape());
127
128     aTM.Stop();
129     aPM.Stop();
130   }
131  
132   int aNbEnters = 0;
133   Standard_Real aPerfMeter_CPUtime = 0., aTimer_CPUTime = 0., aS;
134   Standard_Integer aM, aH;
135   aTM.Show(aS, aM, aH, aTimer_CPUTime);
136
137   perf_get_meter("TestMeter", &aNbEnters, &aPerfMeter_CPUtime);
138   perf_init_meter("TestMeter");
139
140   Standard_Real aTimeDiff = (fabs(aTimer_CPUTime - aPerfMeter_CPUtime) / aTimer_CPUTime);
141
142   printf("\nMeasurement results (%d cycles):\n", count);
143   printf("\nOSD_PerfMeter CPU time: %lf\nOSD_Timer CPU time: %lf\n",
144     aPerfMeter_CPUtime, aTimer_CPUTime);
145   printf("Time delta is: %.3lf %%\n", aTimeDiff * 100);
146
147   if (aTimeDiff > 0.2)
148     di << "OCC23237: Error: too much difference between CPU and elapsed times";
149   else if (aNbEnters != count)
150     di << "OCC23237: Error: counter reported by PerfMeter (" << aNbEnters << ") does not correspond to actual number of cycles";
151   else
152     di << "OCC23237: OK";
153
154   return 0;
155 }
156
157 class IncrementerDecrementer
158 {
159 public:
160     IncrementerDecrementer (Standard_Integer* theVal, Standard_Boolean thePositive) : myVal (theVal), myPositive (thePositive)
161     {}
162     void operator() (const size_t) const
163     {
164       if ( myPositive )
165         Standard_Atomic_Increment(myVal);
166       else
167         Standard_Atomic_Decrement(myVal);
168     }
169 private:
170     Standard_Integer*   myVal;
171     Standard_Boolean    myPositive;
172 };
173
174 static Standard_Integer OCC22980 (Draw_Interpretor& di, Standard_Integer /*argc*/, const char ** /*argv*/)
175 {
176   int aSum = 0;
177
178   //check returned value
179   QCOMPARE (Standard_Atomic_Decrement (&aSum), -1);
180   QCOMPARE (Standard_Atomic_Increment (&aSum), 0);
181   QCOMPARE (Standard_Atomic_Increment (&aSum), 1);
182   QCOMPARE (Standard_Atomic_Increment (&aSum), 2);
183 //  QCOMPARE (Standard_Atomic_DecrementTest (&aSum), 0);
184 //  QCOMPARE (Standard_Atomic_DecrementTest (&aSum), 1);
185
186   //check atomicity 
187   aSum = 0;
188   const int N = 1 << 24; //big enough to ensure concurrency
189
190   //increment
191   OSD_Parallel::For(0, N, IncrementerDecrementer (&aSum, true));
192   QCOMPARE (aSum, N);
193
194   //decrement
195   OSD_Parallel::For(0, N, IncrementerDecrementer (&aSum, false));
196   QCOMPARE (aSum, 0);
197
198   return 0;
199 }
200
201 #include <TDocStd_Application.hxx>
202 #include <XCAFApp_Application.hxx>
203 #include <TDocStd_Document.hxx>
204 #include <XCAFDoc_ShapeTool.hxx>
205 #include <XCAFDoc_DocumentTool.hxx>
206 #include <TDF_Label.hxx>
207 #include <TDataStd_Name.hxx>
208
209 static Standard_Integer OCC23595 (Draw_Interpretor& di, Standard_Integer /*argc*/, const char** /*argv*/)
210 {
211   Handle(TDocStd_Application) anApp = XCAFApp_Application::GetApplication();
212   Handle(TDocStd_Document) aDoc;
213   anApp->NewDocument ("XmlXCAF", aDoc);
214   QCOMPARE (!aDoc.IsNull(), Standard_True);
215
216   Handle(XCAFDoc_ShapeTool) aShTool = XCAFDoc_DocumentTool::ShapeTool (aDoc->Main());
217
218   //check default value
219   Standard_Boolean aValue = XCAFDoc_ShapeTool::AutoNaming();
220   QCOMPARE (aValue, Standard_True);
221
222   //true
223   XCAFDoc_ShapeTool::SetAutoNaming (Standard_True);
224   TopoDS_Shape aShape = BRepPrimAPI_MakeBox (100., 200., 300.).Shape();
225   TDF_Label aLabel = aShTool->AddShape (aShape);
226   Handle(TDataStd_Name) anAttr;
227   QCOMPARE (aLabel.FindAttribute (TDataStd_Name::GetID(), anAttr), Standard_True);
228
229   //false
230   XCAFDoc_ShapeTool::SetAutoNaming (Standard_False);
231   aShape = BRepPrimAPI_MakeBox (300., 200., 100.).Shape();
232   aLabel = aShTool->AddShape (aShape);
233   QCOMPARE (!aLabel.FindAttribute (TDataStd_Name::GetID(), anAttr), Standard_True);
234
235   //restore
236   XCAFDoc_ShapeTool::SetAutoNaming (aValue);
237
238   return 0;
239 }
240
241 #include <ExprIntrp_GenExp.hxx>
242 Standard_Integer OCC22611 (Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
243 {
244
245   if (argc != 3) {
246     di << "Usage : " << argv[0] << " string nb\n";
247     return 1;
248   }
249
250   TCollection_AsciiString aToken = argv[1];
251   Standard_Integer aNb = atoi(argv[2]);
252
253   Handle(ExprIntrp_GenExp) aGen = ExprIntrp_GenExp::Create();
254   for (Standard_Integer i=0; i < aNb; i++)
255   {
256     aGen->Process(aToken);
257     Handle(Expr_GeneralExpression) aExpr = aGen->Expression();
258   }
259
260   return 0;
261 }
262
263 Standard_Integer OCC22595 (Draw_Interpretor& di, Standard_Integer /*argc*/, const char ** /*argv*/)
264 {
265   gp_Mat M0;
266   di << "M0 = "
267   << " {" << M0(1,1) << "} {" << M0(1,2) << "} {" << M0(1,3) <<"}"
268   << " {" << M0(2,1) << "} {" << M0(2,2) << "} {" << M0(2,3) <<"}"
269   << " {" << M0(1,1) << "} {" << M0(1,2) << "} {" << M0(1,3) <<"}";
270   return 0;
271 }
272
273 #include <TopoDS_Face.hxx>
274 #include <TopoDS_Face.hxx>
275 #include <TopoDS.hxx>
276 #include <BRepBuilderAPI_Transform.hxx>
277 #include <BRepExtrema_DistShapeShape.hxx>
278 #include <BRepTools.hxx>
279
280 static Standard_Boolean OCC23774Test(const TopoDS_Face& grossPlateFace, const TopoDS_Shape& originalWire, Draw_Interpretor& di)
281 {
282   BRepExtrema_DistShapeShape distShapeShape(grossPlateFace,originalWire,Extrema_ExtFlag_MIN);
283   if(!distShapeShape.IsDone()) {
284     di <<"Distance ShapeShape is Not Done\n";
285     return Standard_False;
286   }
287
288   if(distShapeShape.Value() > 0.01) {
289     di << "Wrong Dist = " <<distShapeShape.Value() << "\n";
290     return Standard_False;
291   } else
292     di << "Dist0 = " <<distShapeShape.Value() <<"\n";
293
294   //////////////////////////////////////////////////////////////////////////
295   /// First Flip Y
296   const gp_Pnt2d axis1P1(1474.8199035519228,1249.9995745636970);
297   const gp_Pnt2d axis1P2(1474.8199035519228,1250.9995745636970);
298
299   gp_Vec2d mirrorVector1(axis1P1,axis1P2);
300
301   gp_Trsf2d mirror1;
302   mirror1.SetMirror(gp_Ax2d(axis1P1,mirrorVector1));
303
304   BRepBuilderAPI_Transform transformer1(mirror1);
305   transformer1.Perform(originalWire);
306   if(!transformer1.IsDone()) {
307     di << "Not Done1 \n";
308     return Standard_False;
309   }
310   TopoDS_Shape step1ModifiedShape = transformer1.ModifiedShape(originalWire);
311   
312   BRepExtrema_DistShapeShape distShapeShape1(grossPlateFace,step1ModifiedShape,Extrema_ExtFlag_MIN);
313   if(!distShapeShape1.IsDone())
314     return Standard_False;
315   if(distShapeShape1.Value() > 0.01) {
316     di << "Dist = " <<distShapeShape1.Value() <<"\n";
317     return Standard_False;
318   } else
319     di << "Dist1 = " <<distShapeShape1.Value() <<"\n";
320
321   //////////////////////////////////////////////////////////////////////////
322   /// Second flip Y
323   transformer1.Perform(step1ModifiedShape);
324   if(!transformer1.IsDone()) {
325     di << "Not Done1 \n";
326     return Standard_False;
327   }
328   TopoDS_Shape step2ModifiedShape = transformer1.ModifiedShape(step1ModifiedShape);
329
330   //This is identity matrix for values but for type is gp_Rotation ?!
331   gp_Trsf2d mirror11 = mirror1;
332   mirror11.PreMultiply(mirror1);
333
334   BRepExtrema_DistShapeShape distShapeShape2(grossPlateFace,step2ModifiedShape);//,Extrema_ExtFlag_MIN);
335   if(!distShapeShape2.IsDone())
336     return Standard_False;
337
338   //This last test case give error (the value is 1008.8822038689706)
339   if(distShapeShape2.Value() > 0.01) {
340     di  << "Wrong Dist2 = " <<distShapeShape2.Value() <<"\n";
341     Standard_Integer N = distShapeShape2.NbSolution();
342     di << "Nb = " <<N <<"\n";
343     for (Standard_Integer i=1;i <= N;i++)
344         di <<"Sol(" <<i<<") = " <<distShapeShape2.PointOnShape1(i).Distance(distShapeShape2.PointOnShape2(i)) <<"\n";
345     return Standard_False;
346   }
347   di << "Distance2 = " <<distShapeShape2.Value() <<"\n";
348  
349   return Standard_True;
350 }
351 static Standard_Integer OCC23774(Draw_Interpretor& di, Standard_Integer n, const char** a)
352
353
354   if (n != 3) {
355         di <<"OCC23774: invalid number of input parameters\n";
356         return 1;
357   }
358
359   const char *ns1 = (a[1]), *ns2 = (a[2]);
360   TopoDS_Shape S1(DBRep::Get(ns1)), S2(DBRep::Get(ns2));
361   if (S1.IsNull() || S2.IsNull()) {
362         di <<"OCC23774: Null input shapes\n";
363         return 1;
364   }
365   const TopoDS_Face& aFace  = TopoDS::Face(S1);
366   if(!OCC23774Test(aFace, S2, di))
367         di << "Something is wrong\n";
368
369  return 0;
370 }
371
372 #include <GeomConvert_ApproxSurface.hxx>
373 #include <Geom_BSplineSurface.hxx>
374 #include <Draw.hxx>
375 #include <OSD_Thread.hxx>
376
377 struct GeomConvertTest_Data
378 {
379   Standard_Integer nbupoles;
380   Handle(Geom_Surface) surf;
381 };
382
383 static Standard_Address GeomConvertTest (Standard_Address data)
384 {
385   GeomConvertTest_Data* info = (GeomConvertTest_Data*)data;
386
387   GeomConvert_ApproxSurface aGAS (info->surf, 1e-4, GeomAbs_C1, GeomAbs_C1, 9, 9, 100, 1);
388   if (!aGAS.IsDone()) {
389     cout << "Error: ApproxSurface is not done!" << endl;
390     return 0;
391   }
392   const Handle(Geom_BSplineSurface)& aBSurf = aGAS.Surface();
393   if (aBSurf.IsNull()) {
394     cout << "Error: BSplineSurface is not created!" << endl;
395     return 0;
396   }
397   cout << "Number of UPoles:" << aBSurf->NbUPoles();
398   if (aBSurf->NbUPoles() == info->nbupoles)
399   {
400     cout << ": OK" << endl;
401     return data; // any non-null pointer
402   }
403   else
404   {
405     cout << ": Error, must be " << info->nbupoles << endl;
406     return 0;
407   }
408 }
409
410 static Standard_Integer OCC23952sweep (Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
411 {
412   if (argc != 3) {
413     cout << "Error: invalid number of arguments" << endl;
414     return 1;
415   }
416
417   struct GeomConvertTest_Data aStorage;
418   aStorage.nbupoles = Draw::Atoi(argv[1]); 
419   aStorage.surf = DrawTrSurf::GetSurface(argv[2]);
420   if (aStorage.surf.IsNull())
421   {
422     cout << "Error: " << argv[2] << " is not a DRAW surface!" << endl;
423     return 0;
424   }
425
426   // start conversion in several threads
427   const int NBTHREADS = 100;
428   OSD_Thread aThread[NBTHREADS];
429   for (int i=0; i < NBTHREADS; i++)
430   { 
431     aThread[i].SetFunction (GeomConvertTest);
432     if (!aThread[i].Run(&aStorage))
433       di << "Error: Cannot start thread << " << i << "\n";
434   }
435
436   // check results
437   for (int i=0; i < NBTHREADS; i++)
438   { 
439     Standard_Address aResult = 0;
440     if (!aThread[i].Wait(aResult))
441       di << "Error: Failed waiting for thread << " << i << "\n";
442     if (!aResult) 
443       di << "Error: wrong number of poles in thread " << i << "!\n";
444   }
445
446   return 0;
447 }
448
449 #include <GeomInt_IntSS.hxx>
450
451 struct GeomIntSSTest_Data
452 {
453   Standard_Integer nbsol;
454   Handle(Geom_Surface) surf1, surf2;
455 };
456
457 static Standard_Address GeomIntSSTest (Standard_Address data)
458 {
459   GeomIntSSTest_Data* info = (GeomIntSSTest_Data*)data;
460   GeomInt_IntSS anInter;
461   anInter.Perform (info->surf1, info->surf2, Precision::Confusion(), Standard_True);
462   if (!anInter.IsDone()) {
463     cout << "An intersection is not done!" << endl;
464     return 0;
465   }
466
467   cout << "Number of Lines:" << anInter.NbLines();
468   if (anInter.NbLines() == info->nbsol)
469   {
470     cout << ": OK" << endl;
471     return data; // any non-null pointer
472   }
473   else
474   {
475     cout << ": Error, must be " << info->nbsol << endl;
476     return 0;
477   }
478 }
479
480 static Standard_Integer OCC23952intersect (Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
481 {
482   if (argc != 4) {
483     cout << "Error: invalid number of arguments" << endl;
484     return 1;
485   }
486
487   struct GeomIntSSTest_Data aStorage;
488   aStorage.nbsol = Draw::Atoi(argv[1]); 
489   aStorage.surf1 = DrawTrSurf::GetSurface(argv[2]);
490   aStorage.surf2 = DrawTrSurf::GetSurface(argv[3]);
491   if (aStorage.surf1.IsNull() || aStorage.surf2.IsNull())
492   {
493     cout << "Error: Either " << argv[2] << " or " << argv[3] << " is not a DRAW surface!" << endl;
494     return 0;
495   }
496
497   // start conversion in several threads
498   const int NBTHREADS = 100;
499   OSD_Thread aThread[NBTHREADS];
500   for (int i=0; i < NBTHREADS; i++)
501   { 
502     aThread[i].SetFunction (GeomIntSSTest);
503     if (!aThread[i].Run(&aStorage))
504       di << "Error: Cannot start thread << " << i << "\n";
505   }
506
507   // check results
508   for (int i=0; i < NBTHREADS; i++)
509   { 
510     Standard_Address aResult = 0;
511     if (!aThread[i].Wait(aResult))
512       di << "Error: Failed waiting for thread << " << i << "\n";
513     if (!aResult) 
514       di << "Error: wrong number of intersections in thread " << i << "!\n"; 
515   }
516
517   return 0;
518 }
519
520 #include <Geom_SurfaceOfRevolution.hxx> 
521 static Standard_Integer OCC23683 (Draw_Interpretor& di, Standard_Integer argc,const char ** argv)
522 {
523   if (argc < 2) {
524     di<<"Usage: " << argv[0] << " invalid number of arguments\n";
525     return 1;
526   }
527
528   Standard_Integer ucontinuity = 1;
529   Standard_Integer vcontinuity = 1;
530   Standard_Boolean iscnu = false;
531   Standard_Boolean iscnv = false;
532   
533   Handle(Geom_Surface) aSurf = DrawTrSurf::GetSurface(argv[1]);
534
535   QCOMPARE (aSurf->IsCNu (ucontinuity), iscnu);
536   QCOMPARE (aSurf->IsCNv (vcontinuity), iscnv);
537
538   return 0;
539 }
540
541 #include <gp_Ax1.hxx>
542 #include <gp_Ax22d.hxx>
543 #include <Geom_Plane.hxx>
544 #include <Geom2d_Circle.hxx>
545 #include <Geom2d_TrimmedCurve.hxx>
546 #include <BRepBuilderAPI_MakeEdge.hxx>
547 #include <BRepPrimAPI_MakeRevol.hxx>
548 #include <Geom2d_OffsetCurve.hxx>
549
550 static int test_offset(Draw_Interpretor& di, Standard_Integer argc, const char** argv)
551 {
552   // Check the command arguments
553   if ( argc != 1 )
554   {
555     di << "Error: " << argv[0] << " - invalid number of arguments\n";
556     di << "Usage: type help " << argv[0] << "\n";
557     return 1; // TCL_ERROR
558   }
559
560   gp_Ax1 RotoAx( gp::Origin(), gp::DZ() );
561   gp_Ax22d Ax2( gp::Origin2d(), gp::DY2d(), gp::DX2d() );
562   Handle(Geom_Surface) Plane = new Geom_Plane( gp::YOZ() );
563
564   di << "<<<< Preparing sample surface of revolution based on trimmed curve >>>>\n";
565   di << "-----------------------------------------------------------------------\n";
566
567   Handle(Geom2d_Circle) C2d1 = new Geom2d_Circle(Ax2, 1.0);
568   Handle(Geom2d_TrimmedCurve) C2d1Trimmed = new Geom2d_TrimmedCurve(C2d1, 0.0, M_PI/2.0);
569   TopoDS_Edge E1 = BRepBuilderAPI_MakeEdge(C2d1Trimmed, Plane);
570
571   DBRep::Set("e1", E1);
572
573   BRepPrimAPI_MakeRevol aRevolBuilder1(E1, RotoAx);
574   TopoDS_Face F1 = TopoDS::Face( aRevolBuilder1.Shape() );
575
576   DBRep::Set("f1", F1);
577
578   di << "Result: f1\n";
579
580   di << "<<<< Preparing sample surface of revolution based on offset curve  >>>>\n";
581   di << "-----------------------------------------------------------------------\n";
582
583   Handle(Geom2d_OffsetCurve) C2d2Offset = new Geom2d_OffsetCurve(C2d1Trimmed, -0.5);
584   TopoDS_Edge E2 = BRepBuilderAPI_MakeEdge(C2d2Offset, Plane);
585
586   DBRep::Set("e2", E2);
587
588   BRepPrimAPI_MakeRevol aRevolBuilder2(E2, RotoAx);
589   TopoDS_Face F2 = TopoDS::Face( aRevolBuilder2.Shape() );
590
591   DBRep::Set("f2", F2);
592
593   di << "Result: f2\n";
594
595   return 0;
596 }
597
598 #include <Geom_Curve.hxx>
599 #include <Geom_Surface.hxx>
600 #include <Precision.hxx>
601 #include <ShapeConstruct_ProjectCurveOnSurface.hxx>
602 //=======================================================================
603 //function : OCC24008
604 //purpose  : 
605 //=======================================================================
606 static Standard_Integer OCC24008 (Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
607 {
608   if (argc != 3) {
609     di << "Usage: " << argv[0] << " invalid number of arguments\n";
610     return 1;
611   }
612   Handle(Geom_Curve) aCurve = DrawTrSurf::GetCurve(argv[1]);
613   Handle(Geom_Surface) aSurf = DrawTrSurf::GetSurface(argv[2]);
614   if (aCurve.IsNull()) {
615     di << "Curve was not read\n";
616         return 1;
617   }
618   if (aSurf.IsNull()) {
619         di << "Surface was not read\n";
620         return 1;
621   }
622   ShapeConstruct_ProjectCurveOnSurface aProj;
623   aProj.Init (aSurf, Precision::Confusion());
624   try {
625     Handle(Geom2d_Curve) aPCurve;
626     aProj.Perform (aCurve, aCurve->FirstParameter(), aCurve->LastParameter(), aPCurve);
627     if (aPCurve.IsNull()) {
628           di << "PCurve was not created\n";
629           return 1;
630     }
631   } catch (...) {
632     di << "Exception was caught\n";
633   }
634   return 0;
635 }
636
637 #include <GeomAdaptor_Surface.hxx>
638 #include <Draw.hxx>
639 //=======================================================================
640 //function : OCC23945
641 //purpose  : 
642 //=======================================================================
643
644 static Standard_Integer OCC23945 (Draw_Interpretor& /*di*/,Standard_Integer n, const char** a)
645 {
646   if (n < 5) return 1;
647
648   Handle(Geom_Surface) aS = DrawTrSurf::GetSurface(a[1]);
649   if (aS.IsNull()) return 1;
650
651   GeomAdaptor_Surface GS(aS);
652
653   Standard_Real U = Draw::Atof(a[2]);
654   Standard_Real V = Draw::Atof(a[3]);
655
656   Standard_Boolean DrawPoint = ( n%3 == 2);
657   if ( DrawPoint) n--;
658
659   gp_Pnt P;
660   if (n >= 13) {
661     gp_Vec DU,DV;
662     if (n >= 22) {
663       gp_Vec D2U,D2V,D2UV;
664       GS.D2(U,V,P,DU,DV,D2U,D2V,D2UV);
665       Draw::Set(a[13],D2U.X());
666       Draw::Set(a[14],D2U.Y());
667       Draw::Set(a[15],D2U.Z());
668       Draw::Set(a[16],D2V.X());
669       Draw::Set(a[17],D2V.Y());
670       Draw::Set(a[18],D2V.Z());
671       Draw::Set(a[19],D2UV.X());
672       Draw::Set(a[20],D2UV.Y());
673       Draw::Set(a[21],D2UV.Z());
674     }
675     else
676       GS.D1(U,V,P,DU,DV);
677
678     Draw::Set(a[7],DU.X());
679     Draw::Set(a[8],DU.Y());
680     Draw::Set(a[9],DU.Z());
681     Draw::Set(a[10],DV.X());
682     Draw::Set(a[11],DV.Y());
683     Draw::Set(a[12],DV.Z());
684   }
685   else 
686     GS.D0(U,V,P);
687
688   if ( n > 6) {
689     Draw::Set(a[4],P.X());
690     Draw::Set(a[5],P.Y());
691     Draw::Set(a[6],P.Z());
692   }
693   if ( DrawPoint) {
694     DrawTrSurf::Set(a[n],P);
695   }
696
697   return 0;
698 }
699
700 //=======================================================================
701 //function : OCC11758
702 //purpose  : 
703 //=======================================================================
704 static Standard_Integer OCC11758 (Draw_Interpretor& di, Standard_Integer n, const char**)
705 {
706   if (n != 1) return 1;
707
708   const char* theStr = "0123456789";
709   Standard_Integer i, j;
710   for ( i = 0; i < 5; ++i ) {
711     // TCollection_AsciiString(const Standard_CString astring)
712     TCollection_AsciiString a(theStr+i);
713     // IsEqual (const Standard_CString other)const
714     //assert( a == theStr+i );
715     QCOMPARE ( a , theStr+i );
716
717     //TCollection_AsciiString(const Standard_CString astring,const Standard_Integer aLen )
718     TCollection_AsciiString b(theStr+i, 3);
719     //assert( b.Length() == 3 );
720     //assert( strncmp( b.ToCString(), theStr+i, 3 ) == 0 );
721     //assert( strlen( b.ToCString() ) == 3 );
722     QCOMPARE ( b.Length() , 3 );
723     QCOMPARE ( strncmp( b.ToCString() , theStr+i, 3 ) , 0 );
724     QCOMPARE ( b.Length() , 3 );
725
726     //TCollection_AsciiString(const Standard_Integer aValue)
727     TCollection_AsciiString c(i);
728     //assert( c.IsIntegerValue() );
729     //assert( c.IntegerValue() == i );
730     QCOMPARE ( c.IsIntegerValue() , Standard_True );
731     QCOMPARE ( c.IntegerValue() , i );
732
733     //TCollection_AsciiString(const Standard_Real aValue)
734     TCollection_AsciiString d( 0.1*i );
735     //assert( d.IsRealValue() );
736     //assert( TCollection_AsciiString(3.3) == "3.3");
737     QCOMPARE ( d.IsRealValue() , Standard_True );
738     QCOMPARE ( TCollection_AsciiString(3.3) , "3.3" );
739
740     //TCollection_AsciiString(const TCollection_AsciiString& astring)
741     TCollection_AsciiString e(d);
742     //assert( e == d );
743     //assert( e.Length() == d.Length() );
744     //assert( strcmp( e.ToCString(), d.ToCString() ) == 0 );
745     QCOMPARE ( e ,d  );
746     QCOMPARE ( e.Length() , d.Length() );
747     QCOMPARE ( strcmp( e.ToCString(), d.ToCString() ) , 0 );
748
749     // TCollection_AsciiString(const TCollection_AsciiString& astring ,
750     //                         const Standard_Character other )
751     TCollection_AsciiString f(e,'\a');
752     //assert( f.Length() == e.Length() + 1 );
753     //assert( strncmp( f.ToCString(), e.ToCString(), e.Length() ) == 0 );
754     //assert( f.Value( f.Length() ) == '\a');
755     QCOMPARE ( f.Length() , e.Length() + 1 );
756     QCOMPARE ( strncmp( f.ToCString(), e.ToCString(), e.Length() ) , 0 );
757     QCOMPARE ( f.Value( f.Length() ) , '\a' );
758
759     // TCollection_AsciiString(const TCollection_AsciiString& astring ,
760     //                         const Standard_CString other )
761     TCollection_AsciiString g(f, theStr);
762     //assert( g.Length() == f.Length() + strlen( theStr ));
763     //assert( strncmp( g.ToCString(), f.ToCString(), f.Length() ) == 0 );
764     //assert( g.Search( theStr ) == f.Length() + 1 );
765     QCOMPARE ( g.Length() , f.Length() + (Standard_Integer)strlen( theStr ) );
766     QCOMPARE ( strncmp( g.ToCString(), f.ToCString(), f.Length() ) , 0 );
767     QCOMPARE ( g.Search( theStr ) , f.Length() + 1 );
768
769     // TCollection_AsciiString(const TCollection_AsciiString& astring ,
770     //                         const TCollection_AsciiString& other )
771     TCollection_AsciiString h(d,a);
772     //assert( h.Length() == d.Length() + a.Length() );
773     //assert( strncmp( h.ToCString(), d.ToCString(), d.Length() ) == 0 );
774     //assert( strncmp( h.ToCString() + d.Length(), a.ToCString(), a.Length() ) == 0 );
775     QCOMPARE ( h.Length() , d.Length() + a.Length() );
776     QCOMPARE ( strncmp( h.ToCString(), d.ToCString(), d.Length() ) , 0 );
777     QCOMPARE ( strncmp( h.ToCString() + d.Length(), a.ToCString(), a.Length() ) , 0 );
778
779     // AssignCat(const Standard_CString other)
780     c.AssignCat( a.ToCString() );
781     //assert( c.Length() == 1 + a.Length() );
782     //assert( c.Search( a ) == 2 );
783     QCOMPARE ( c.Length() , 1 + a.Length() );
784     QCOMPARE ( c.Search( a ) , 2 );
785
786     // AssignCat(const TCollection_AsciiString& other)
787     Standard_Integer dl = d.Length();
788     d.AssignCat( a );
789     //assert( d.Length() == dl + a.Length() );
790     //assert( d.Search( a ) == dl + 1 );
791     QCOMPARE ( d.Length() , dl + a.Length() );
792     QCOMPARE ( d.Search( a ) , dl + 1 );
793
794     // Capitalize()
795     TCollection_AsciiString capitalize("aBC");
796     capitalize.Capitalize();
797     //assert( capitalize == "Abc" );
798     QCOMPARE ( capitalize , "Abc" );
799
800     // Copy(const Standard_CString fromwhere)
801     d = theStr+i;
802     //assert( d == theStr+i );
803     QCOMPARE ( d , theStr+i );
804
805     // Copy(const TCollection_AsciiString& fromwhere)
806     d = h;
807     // IsEqual (const TCollection_AsciiString& other)const
808     //assert( d == h );
809     QCOMPARE ( d , h );
810
811     // Insert(const Standard_Integer where, const Standard_CString what)
812     dl = d.Length();
813     d.Insert( 2, theStr );
814     //assert( d.Length() == dl + strlen( theStr ));
815     //assert( strncmp( d.ToCString() + 1, theStr, strlen( theStr )) == 0 );
816     QCOMPARE ( d.Length() , dl + (Standard_Integer)strlen( theStr ) );
817     QCOMPARE ( strncmp( d.ToCString() + 1, theStr, strlen( theStr )) , 0 );
818
819     //Insert(const Standard_Integer where,const Standard_Character what)
820     d = theStr;
821     d.Insert( i+1, 'i' );
822     //assert( d.Length() == strlen( theStr ) + 1 );
823     //assert( d.Value( i+1 ) == 'i');
824     //assert( strcmp( d.ToCString() + i + 1, theStr+i ) == 0 );
825     QCOMPARE ( d.Length() , (Standard_Integer)strlen( theStr ) + 1 );
826     QCOMPARE ( d.Value( i+1 ) , 'i' );
827     QCOMPARE ( strcmp( d.ToCString() + i + 1, theStr+i ) , 0 );
828
829     //Insert(const Standard_Integer where,const TCollection_AsciiString& what)
830     d = theStr;
831     d.Insert( i+1, TCollection_AsciiString( "i" ));
832     //assert( d.Length() == strlen( theStr ) + 1 );
833     //assert( d.Value( i+1 ) == 'i');
834     //assert( strcmp( d.ToCString() + i + 1, theStr+i ) == 0 );
835     QCOMPARE ( d.Length() , (Standard_Integer)strlen( theStr ) + 1 );
836     QCOMPARE ( d.Value( i+1 ) , 'i' );
837     QCOMPARE ( strcmp( d.ToCString() + i + 1, theStr+i ) , 0 );
838
839     // IsDifferent (const Standard_CString other)const
840     //assert( d.IsDifferent( theStr ));
841     //assert( d.IsDifferent( "theStr" ));
842     //assert( d.IsDifferent( "" ));
843     //assert( !d.IsDifferent( d.ToCString() ));
844     QCOMPARE ( d.IsDifferent( theStr ) , Standard_True );
845     QCOMPARE ( d.IsDifferent( "theStr" ) , Standard_True );
846     QCOMPARE ( d.IsDifferent( "" ) , Standard_True );
847     QCOMPARE ( !d.IsDifferent( d.ToCString() ) , Standard_True );
848
849     // IsDifferent (const TCollection_AsciiString& other)const
850     //assert( d.IsDifferent( TCollection_AsciiString() ));
851     //assert( d.IsDifferent( a ));
852     //assert( d.IsDifferent( h ));
853     //assert( !d.IsDifferent( d ));
854     QCOMPARE ( d.IsDifferent( TCollection_AsciiString() ) , Standard_True );
855     QCOMPARE ( d.IsDifferent( a ) , Standard_True );
856     QCOMPARE ( d.IsDifferent( h ) , Standard_True );
857     QCOMPARE ( !d.IsDifferent( d ) , Standard_True );
858
859     // IsLess (const Standard_CString other)const
860     //assert( TCollection_AsciiString ("0"). IsLess("1"));
861     //assert( TCollection_AsciiString ("0"). IsLess("00"));
862     //assert( TCollection_AsciiString ("").  IsLess("0"));
863     //assert( !TCollection_AsciiString("1"). IsLess("0"));
864     //assert( !TCollection_AsciiString("00").IsLess("0"));
865     //assert( !TCollection_AsciiString("0"). IsLess(""));
866     //assert( TCollection_AsciiString (theStr+i).IsLess(theStr+i+1));
867     QCOMPARE ( TCollection_AsciiString ("0"). IsLess("1") , Standard_True );
868     QCOMPARE ( TCollection_AsciiString ("0"). IsLess("00") , Standard_True );
869     QCOMPARE ( TCollection_AsciiString ("").  IsLess("0") , Standard_True );
870     QCOMPARE ( !TCollection_AsciiString("1"). IsLess("0"), Standard_True );
871     QCOMPARE ( !TCollection_AsciiString("00").IsLess("0") , Standard_True );
872     QCOMPARE ( !TCollection_AsciiString("0"). IsLess("") , Standard_True );
873     QCOMPARE ( TCollection_AsciiString (theStr+i).IsLess(theStr+i+1) , Standard_True );
874
875     // IsLess (const TCollection_AsciiString& other)const
876     //assert( TCollection_AsciiString ("0"). IsLess(TCollection_AsciiString("1" )));
877     //assert( TCollection_AsciiString ("0"). IsLess(TCollection_AsciiString("00")));
878     //assert( TCollection_AsciiString ("").  IsLess(TCollection_AsciiString("0" )));
879     //assert( !TCollection_AsciiString("1"). IsLess(TCollection_AsciiString("0" )));
880     //assert( !TCollection_AsciiString("00").IsLess(TCollection_AsciiString("0" )));
881     //assert( !TCollection_AsciiString("0"). IsLess(TCollection_AsciiString(""  )));
882     //assert( TCollection_AsciiString (theStr+i).IsLess(TCollection_AsciiString(theStr+i+1)));
883     QCOMPARE ( TCollection_AsciiString ("0"). IsLess(TCollection_AsciiString("1" )) , Standard_True );
884     QCOMPARE ( TCollection_AsciiString ("0"). IsLess(TCollection_AsciiString("00")) , Standard_True );
885     QCOMPARE ( TCollection_AsciiString ("").  IsLess(TCollection_AsciiString("0" )) , Standard_True );
886     QCOMPARE ( !TCollection_AsciiString("1"). IsLess(TCollection_AsciiString("0" )) , Standard_True );
887     QCOMPARE ( !TCollection_AsciiString("00").IsLess(TCollection_AsciiString("0" )) , Standard_True );
888     QCOMPARE ( !TCollection_AsciiString("0"). IsLess(TCollection_AsciiString(""  )) , Standard_True );
889     QCOMPARE ( TCollection_AsciiString (theStr+i).IsLess(TCollection_AsciiString(theStr+i+1)) , Standard_True );
890
891     // IsGreater (const Standard_CString other)const
892     //assert( !TCollection_AsciiString("0"). IsGreater("1"));
893     //assert( !TCollection_AsciiString("0"). IsGreater("00"));
894     //assert( !TCollection_AsciiString("").  IsGreater("0"));
895     //assert( TCollection_AsciiString ("1"). IsGreater("0"));
896     //assert( TCollection_AsciiString ("00").IsGreater("0"));
897     //assert( TCollection_AsciiString ("0"). IsGreater(""));
898     //assert( TCollection_AsciiString (theStr+i+1).IsGreater(theStr+i));
899     QCOMPARE ( !TCollection_AsciiString("0"). IsGreater("1") , Standard_True );
900     QCOMPARE ( !TCollection_AsciiString("0"). IsGreater("00") , Standard_True );
901     QCOMPARE ( !TCollection_AsciiString("").  IsGreater("0") , Standard_True );
902     QCOMPARE ( TCollection_AsciiString ("1"). IsGreater("0") , Standard_True );
903     QCOMPARE ( TCollection_AsciiString ("00").IsGreater("0") , Standard_True );
904     QCOMPARE ( TCollection_AsciiString ("0"). IsGreater("") , Standard_True );
905     QCOMPARE ( TCollection_AsciiString (theStr+i+1).IsGreater(theStr+i) , Standard_True );
906
907     // IsGreater (const TCollection_AsciiString& other)const
908     //assert( !TCollection_AsciiString("0"). IsGreater(TCollection_AsciiString("1" )));
909     //assert( !TCollection_AsciiString("0"). IsGreater(TCollection_AsciiString("00")));
910     //assert( !TCollection_AsciiString("").  IsGreater(TCollection_AsciiString("0" )));
911     //assert( TCollection_AsciiString ("1"). IsGreater(TCollection_AsciiString("0" )));
912     //assert( TCollection_AsciiString ("00").IsGreater(TCollection_AsciiString("0" )));
913     //assert( TCollection_AsciiString ("0"). IsGreater(TCollection_AsciiString(""  )));
914     //assert( TCollection_AsciiString (theStr+i+1).IsGreater(TCollection_AsciiString(theStr+i)));
915     QCOMPARE ( !TCollection_AsciiString("0"). IsGreater(TCollection_AsciiString("1" )) , Standard_True );
916     QCOMPARE ( !TCollection_AsciiString("0"). IsGreater(TCollection_AsciiString("00")) , Standard_True );
917     QCOMPARE ( !TCollection_AsciiString("").  IsGreater(TCollection_AsciiString("0" )) , Standard_True );
918     QCOMPARE ( TCollection_AsciiString ("1"). IsGreater(TCollection_AsciiString("0" )) , Standard_True );
919     QCOMPARE ( TCollection_AsciiString ("00").IsGreater(TCollection_AsciiString("0" )) , Standard_True );
920     QCOMPARE ( TCollection_AsciiString ("0"). IsGreater(TCollection_AsciiString(""  )) , Standard_True );
921     QCOMPARE ( TCollection_AsciiString (theStr+i+1).IsGreater(TCollection_AsciiString(theStr+i)) , Standard_True );
922
923     // void Read(Standard_IStream& astream)
924     std::istringstream is( theStr );
925     e.Read( is );
926     //assert( e == theStr );
927     QCOMPARE ( e , theStr );
928
929     // Standard_Integer SearchFromEnd (const Standard_CString what)const
930     //assert( e.SearchFromEnd( theStr + i ) == i + 1 );
931     QCOMPARE ( e.SearchFromEnd( theStr + i ) , i + 1 );
932
933     // SetValue(const Standard_Integer where, const Standard_CString what)
934     e.SetValue( i+1, "what");
935     //assert( e.Search( "what" ) == i+1 );
936     //assert( e.Length() == strlen( theStr ));
937     QCOMPARE ( e.Search( "what" ) , i+1 );
938     QCOMPARE ( e.Length() , (Standard_Integer)strlen( theStr ) );
939
940     // TCollection_AsciiString Split (const Standard_Integer where)
941     e = theStr;
942     d = e.Split( i+1 );
943     //assert( d.Length() + e.Length() == strlen( theStr ));
944     QCOMPARE ( d.Length() + e.Length() , (Standard_Integer)strlen( theStr ) );
945
946     // TCollection_AsciiString SubString (const Standard_Integer FromIndex,
947     //                                    const Standard_Integer ToIndex) const
948     e = theStr;
949     d = e.SubString( (unsigned int)i+1, (unsigned int)i+3 );
950     //assert( d.Length() == 3 );
951     //assert( d.Value(1) == theStr[ i ]);
952     QCOMPARE ( d.Length() , 3 );
953     QCOMPARE ( d.Value(1) , theStr[ i ] );
954
955     // TCollection_AsciiString Token (const Standard_CString separators,
956     //                                const Standard_Integer whichone) const
957     e = " ";
958     for ( j = 0; j < i; ++j ) {
959       e += TCollection_AsciiString( theStr[j] ) + " ";
960       //assert( e.Token(" ", j+1 ) == TCollection_AsciiString( theStr+j, 1 ));
961       QCOMPARE ( e.Token(" ", j+1 ) , TCollection_AsciiString( theStr+j, 1 ) );
962     }
963   }
964   for ( i = 0; i < 5; ++i )
965   {
966     // TCollection_ExtendedString (const Standard_CString astring, 
967     //                             const Standard_Boolean isMultiByte) 
968     const TCollection_ExtendedString a( theStr+i );
969     //assert( TCollection_AsciiString( a ) == theStr+i );
970     QCOMPARE ( TCollection_AsciiString( a ) , theStr+i );
971
972     //TCollection_ExtendedString (const Standard_ExtString astring)
973     const TCollection_ExtendedString b( a.ToExtString() );
974     //assert( a == b );
975     QCOMPARE ( a , b );
976
977     // TCollection_ExtendedString (const Standard_Integer      length,
978     //                             const Standard_ExtCharacter filler )
979     const TCollection_ExtendedString c( i, 1 );
980     //assert( c.Length() == i );
981     QCOMPARE ( c.Length() , i );
982     if ( c.Length() > 0 ) {
983       //assert( c.Value( i ) == 1 );
984       QCOMPARE ( c.Value( i ) , 1 );
985     }
986
987     // TCollection_ExtendedString (const Standard_Integer aValue)
988     TCollection_ExtendedString d( i );
989     const TCollection_AsciiString da( d );
990     //assert( da.IsIntegerValue() );
991     //assert( da.IntegerValue() == i );
992     QCOMPARE ( da.IsIntegerValue() , Standard_True );
993     QCOMPARE (  da.IntegerValue(), i );
994
995     // TCollection_ExtendedString (const Standard_Real aValue)
996     const TCollection_ExtendedString e( 0.1 * i );
997     const TCollection_AsciiString ea( e );
998     //assert( ea.IsRealValue() );
999     //assert( Abs( ea.RealValue() - 0.1 * i ) < 1e-10 );
1000     QCOMPARE ( ea.IsRealValue() , Standard_True );
1001     QCOMPARE ( Abs( ea.RealValue() - 0.1 * i ) < 1e-10 , Standard_True );
1002
1003     // TCollection_ExtendedString (const TCollection_ExtendedString& astring)
1004     const TCollection_ExtendedString f(e);
1005     //assert( f.Length() == e.Length());
1006     //assert( f == e );
1007     QCOMPARE ( f.Length() , e.Length() );
1008     QCOMPARE ( f , e );
1009
1010     // TCollection_ExtendedString (const TCollection_AsciiString& astring)
1011     const TCollection_ExtendedString g( ea );
1012     //assert( g.Length() == ea.Length() );
1013     //assert( TCollection_AsciiString( g ) == ea );
1014     QCOMPARE ( g.Length() , ea.Length() );
1015     QCOMPARE ( TCollection_AsciiString( g ) , ea );
1016
1017     // AssignCat (const TCollection_ExtendedString& other)
1018     const TCollection_ExtendedString sep(",");
1019     d.AssignCat( sep );
1020     d.AssignCat( g );
1021     //assert( d.Length() == 2 + g.Length() );
1022     //assert( d.Token( sep.ToExtString(), 1 ) == TCollection_ExtendedString( i ));
1023     //assert( d.Token( sep.ToExtString(), 2 ) == g );
1024     QCOMPARE ( d.Length() , 2 + g.Length() );
1025     QCOMPARE ( d.Token( sep.ToExtString(), 1 ) , TCollection_ExtendedString( i ) );
1026     QCOMPARE ( d.Token( sep.ToExtString(), 2 ) , g );
1027
1028     // TCollection_ExtendedString Cat (const TCollection_ExtendedString& other) const
1029     const TCollection_ExtendedString cat = a.Cat( sep );
1030     //assert( cat.Length() == a.Length() + sep.Length() );
1031     //assert( cat.Search( a ) == 1 );
1032     //assert( cat.Search( sep ) == a.Length() + 1 );
1033     QCOMPARE ( cat.Length() , a.Length() + sep.Length() );
1034     QCOMPARE ( cat.Search( a ) , 1 );
1035     QCOMPARE ( cat.Search( sep ) , a.Length() + 1 );
1036
1037     // Copy (const TCollection_ExtendedString& fromwhere)
1038     d = cat;
1039     //assert( d.Length() == cat.Length() );
1040     //assert( d == cat );
1041     QCOMPARE ( d.Length() , cat.Length() );
1042     QCOMPARE ( d , cat );
1043
1044     // IsEqual (const Standard_ExtString other) const
1045     //assert( d.IsEqual( d.ToExtString() ));
1046     QCOMPARE ( d.IsEqual( d.ToExtString() ) , Standard_True );
1047
1048     // IsDifferent (const Standard_ExtString other ) const
1049     //assert( d.IsDifferent( a.ToExtString() ));
1050     QCOMPARE ( d.IsDifferent( a.ToExtString() ) , Standard_True );
1051
1052     // IsDifferent (const TCollection_ExtendedString& other) const
1053     //assert( d.IsDifferent( a ));
1054     QCOMPARE ( d.IsDifferent( a ) , Standard_True );
1055
1056     // IsLess (const Standard_ExtString other) const
1057     const TCollection_ExtendedString l0("0"), l1("1"), l00("00"), l, ls(theStr+i), ls1(theStr+i+1);
1058     //assert( l0. IsLess( l1.ToExtString() ));
1059     //assert( l0. IsLess( l00.ToExtString() ));
1060     //assert( l.  IsLess( l0.ToExtString() ));
1061     //assert( ! l1. IsLess( l0.ToExtString() ));
1062     //assert( ! l00.IsLess( l0.ToExtString() ));
1063     //assert( ! l0. IsLess( l.ToExtString() ));
1064     //assert( ls.IsLess( ls1.ToExtString() ));
1065     QCOMPARE ( l0. IsLess( l1.ToExtString() ) , Standard_True );
1066     QCOMPARE ( l0. IsLess( l00.ToExtString() ) , Standard_True );
1067     QCOMPARE ( l.  IsLess( l0.ToExtString() ) , Standard_True );
1068     QCOMPARE ( ! l1. IsLess( l0.ToExtString() ) , Standard_True );
1069     QCOMPARE ( ! l00.IsLess( l0.ToExtString() ) , Standard_True );
1070     QCOMPARE ( ! l0. IsLess( l.ToExtString() ) , Standard_True );
1071     QCOMPARE ( ls.IsLess( ls1.ToExtString() ) , Standard_True );
1072
1073     // IsLess (const TCollection_ExtendedString& other) const
1074     //assert( l0. IsLess( l1 ));
1075     //assert( l0. IsLess( l00 ));
1076     //assert( l.  IsLess( l0 ));
1077     //assert( ! l1. IsLess( l0 ));
1078     //assert( ! l00.IsLess( l0 ));
1079     //assert( ! l0. IsLess( l ));
1080     //assert( ls.IsLess( ls1 ));
1081     QCOMPARE ( l0. IsLess( l1 ) , Standard_True );
1082     QCOMPARE ( l0. IsLess( l00 ) , Standard_True );
1083     QCOMPARE ( l.  IsLess( l0 ) , Standard_True );
1084     QCOMPARE ( ! l1. IsLess( l0 ) , Standard_True );
1085     QCOMPARE ( ! l00.IsLess( l0 ) , Standard_True );
1086     QCOMPARE ( ! l0. IsLess( l ) , Standard_True );
1087     QCOMPARE ( ls.IsLess( ls1 ) , Standard_True );
1088
1089     // IsGreater (const Standard_ExtString other) const
1090     //assert( ! l0.IsGreater( l1.ToExtString() ));
1091     //assert( ! l0.IsGreater( l00.ToExtString() ));
1092     //assert( ! l. IsGreater( l0.ToExtString() ));
1093     //assert(  l1. IsGreater( l0.ToExtString() ));
1094     //assert(  l00.IsGreater( l0.ToExtString() ));
1095     //assert(  l0. IsGreater( l.ToExtString() ));
1096     //assert(  ls1.IsGreater( ls.ToExtString() ));
1097     QCOMPARE ( ! l0.IsGreater( l1.ToExtString() ) , Standard_True );
1098     QCOMPARE ( ! l0.IsGreater( l00.ToExtString() ) , Standard_True );
1099     QCOMPARE ( ! l. IsGreater( l0.ToExtString() ) , Standard_True );
1100     QCOMPARE ( l1. IsGreater( l0.ToExtString() ) , Standard_True );
1101     QCOMPARE ( l00.IsGreater( l0.ToExtString() ) , Standard_True );
1102     QCOMPARE ( l0. IsGreater( l.ToExtString() ) , Standard_True );
1103     QCOMPARE ( ls1.IsGreater( ls.ToExtString() ) ,Standard_True  );
1104
1105     // IsGreater (const TCollection_ExtendedString& other) const
1106     //assert( ! l0.IsGreater( l1));
1107     //assert( ! l0.IsGreater( l00));
1108     //assert( ! l. IsGreater( l0));
1109     //assert(  l1. IsGreater( l0));
1110     //assert(  l00.IsGreater( l0));
1111     //assert(  l0. IsGreater( l));
1112     //assert(  ls1.IsGreater( ls));
1113     QCOMPARE ( ! l0.IsGreater( l1) , Standard_True );
1114     QCOMPARE ( ! l0.IsGreater( l00) , Standard_True );
1115     QCOMPARE ( ! l. IsGreater( l0) , Standard_True );
1116     QCOMPARE ( l1. IsGreater( l0) , Standard_True );
1117     QCOMPARE ( l00.IsGreater( l0) , Standard_True );
1118     QCOMPARE ( l0. IsGreater( l) , Standard_True );
1119     QCOMPARE ( ls1.IsGreater( ls) , Standard_True );
1120
1121     // ==========================
1122     //TCollection_HAsciiString::
1123     // ==========================
1124
1125     // IsDifferent(const Handle(TCollection_HAsciiString)& S)
1126     Handle(TCollection_HAsciiString) ha1 = new TCollection_HAsciiString( theStr+i );
1127     Handle(TCollection_HAsciiString) ha2 = new TCollection_HAsciiString( theStr+i+1 );
1128     //assert( ha1->IsDifferent( ha2 ));
1129     //assert( !ha1->IsDifferent( ha1 ));
1130     QCOMPARE ( ha1->IsDifferent( ha2 ) , Standard_True );
1131     QCOMPARE ( !ha1->IsDifferent( ha1 ) , Standard_True );
1132
1133     // IsSameString (const Handle(TCollection_HAsciiString)& S)
1134     //assert( !ha1->IsSameString( ha2 ));
1135     //assert( ha1->IsSameString( ha1 ));
1136     QCOMPARE ( !ha1->IsSameString( ha2 ) , Standard_True );
1137     QCOMPARE ( ha1->IsSameString( ha1 ) , Standard_True );
1138
1139     // IsSameState (const Handle(TCollection_HAsciiString)& other) const
1140     //assert( !ha1->IsSameState( ha2 ));
1141     //assert( ha1->IsSameState( ha1 ));
1142     QCOMPARE ( !ha1->IsSameState( ha2 ) , Standard_True );
1143     QCOMPARE ( ha1->IsSameState( ha1 ) , Standard_True );
1144
1145     // IsSameString (const Handle(TCollection_HAsciiString)& S ,
1146     //               const Standard_Boolean CaseSensitive) const
1147     //assert( !ha1->IsSameString( ha2, true ));
1148     //assert( ha1->IsSameString( ha1, true ));
1149     //assert( !ha1->IsSameString( ha2, false ));
1150     //assert( ha1->IsSameString( ha1, false ));
1151     QCOMPARE ( !ha1->IsSameString( ha2, Standard_True ) , Standard_True );
1152     QCOMPARE ( ha1->IsSameString( ha1, Standard_True ) , Standard_True );
1153     QCOMPARE ( !ha1->IsSameString( ha2, Standard_False ) , Standard_True );
1154     QCOMPARE ( ha1->IsSameString( ha1, Standard_False ) , Standard_True );
1155
1156     ha1->SetValue( 1, "AbC0000000");
1157     ha2->SetValue( 1, "aBc0000000");
1158     //assert( !ha1->IsSameString( ha2, true ));
1159     //assert( ha1->IsSameString( ha2, false ));
1160     QCOMPARE ( !ha1->IsSameString( ha2, Standard_True ) , Standard_True );
1161     QCOMPARE (  ha1->IsSameString( ha2, Standard_False ), Standard_True );
1162   }
1163   return 0;
1164 }
1165
1166 #include <Geom_CylindricalSurface.hxx>
1167 #include <IntTools_FaceFace.hxx>
1168 #include <IntTools_Curve.hxx>
1169 #include <IntTools_PntOn2Faces.hxx>
1170
1171 static Standard_Integer OCC24005 (Draw_Interpretor& theDI, Standard_Integer theNArg, const char** theArgv) 
1172 {
1173   if(theNArg < 2)
1174   {
1175     theDI << "Wrong a number of arguments!\n";
1176     return 1;
1177   }
1178
1179   Handle(Geom_Plane) plane(new Geom_Plane(
1180                                   gp_Ax3( gp_Pnt(-72.948737453424499, 754.30437716359393, 259.52151854671678),
1181                                   gp_Dir(6.2471473085930200e-007, -0.99999999999980493, 0.00000000000000000),
1182                                   gp_Dir(0.99999999999980493, 6.2471473085930200e-007, 0.00000000000000000))));
1183   Handle(Geom_CylindricalSurface) cylinder(
1184                   new Geom_CylindricalSurface(
1185                                   gp_Ax3(gp_Pnt(-6.4812490053250649, 753.39408794522092, 279.16400974257465),
1186                                   gp_Dir(1.0000000000000000, 0.0, 0.00000000000000000),
1187                                   gp_Dir(0.0, 1.0000000000000000, 0.00000000000000000)),
1188                                                                                           19.712534607908712));
1189
1190   DrawTrSurf::Set("pln", plane);
1191   theDI << "pln\n";
1192   DrawTrSurf::Set("cyl", cylinder);
1193   theDI << "cyl\n";
1194
1195   BRep_Builder builder;
1196   TopoDS_Face face1, face2;
1197   builder.MakeFace(face1, plane, Precision::Confusion());
1198   builder.MakeFace(face2, cylinder, Precision::Confusion());
1199   IntTools_FaceFace anInters;
1200   anInters.SetParameters(false, true, true, Precision::Confusion());
1201   anInters.Perform(face1, face2);
1202
1203   if (!anInters.IsDone())
1204   {
1205     theDI<<"No intersections found!\n";
1206
1207     return 1;
1208   }
1209
1210   //Handle(Geom_Curve) aResult;
1211   //gp_Pnt             aPoint;
1212
1213   const IntTools_SequenceOfCurves& aCvsX=anInters.Lines();
1214   const IntTools_SequenceOfPntOn2Faces& aPntsX=anInters.Points();
1215
1216   char buf[1024];  
1217   Standard_Integer aNbCurves, aNbPoints;
1218
1219   aNbCurves=aCvsX.Length();
1220   aNbPoints=aPntsX.Length();
1221
1222   if (aNbCurves >= 2)
1223   {
1224     for (Standard_Integer i=1; i<=aNbCurves; ++i)
1225     {
1226       Sprintf(buf, "%s_%d",theArgv[1],i);
1227       theDI << buf << " ";
1228       
1229       const IntTools_Curve& aIC = aCvsX(i);
1230       const Handle(Geom_Curve)& aC3D= aIC.Curve();
1231       DrawTrSurf::Set(buf,aC3D);
1232     }
1233   }
1234   else if (aNbCurves == 1)
1235   {
1236     const IntTools_Curve& aIC = aCvsX(1);
1237     const Handle(Geom_Curve)& aC3D= aIC.Curve();
1238     Sprintf(buf, "%s",theArgv[1]);
1239     theDI << buf << " ";
1240     DrawTrSurf::Set(buf,aC3D);
1241   }
1242
1243   for (Standard_Integer i = 1; i<=aNbPoints; ++i)
1244   {
1245     const IntTools_PntOn2Faces& aPi=aPntsX(i);
1246     const gp_Pnt& aP=aPi.P1().Pnt();
1247     
1248     Sprintf(buf,"%s_p_%d",theArgv[1],i);
1249     theDI << buf << " ";
1250     DrawTrSurf::Set(buf, aP);
1251   }
1252
1253   return 0;
1254 }
1255
1256 #include <BRepAlgo_NormalProjection.hxx>
1257 static Standard_Integer OCC24012 (Draw_Interpretor& di, Standard_Integer argc, const char ** argv) 
1258 {
1259         if (argc != 3) {
1260                 di << "Usage : " << argv[0] << " should be 2 arguments (face and edge)";
1261                 return 1;
1262         }
1263         
1264         Handle(AIS_InteractiveContext) myAISContext = ViewerTest::GetAISContext();
1265         if(myAISContext.IsNull()) {
1266                 di << "use 'vinit' command before " << argv[0] << "\n";
1267                 return 1;
1268         }
1269
1270         TopoDS_Face m_Face1 = TopoDS::Face(DBRep::Get(argv[1]));
1271         TopoDS_Edge m_Edge = TopoDS::Edge(DBRep::Get(argv[2]));
1272         
1273         BRepAlgo_NormalProjection anormpro(m_Face1);
1274     anormpro.Add(m_Edge);
1275     anormpro.SetDefaultParams();
1276
1277     //anormpro.Compute3d();
1278     //anormpro.SetLimit();
1279
1280     anormpro.Build();
1281
1282     if (anormpro.IsDone())
1283     {
1284         TopoDS_Shape rshape = anormpro.Projection();
1285                 Handle(AIS_InteractiveObject) myShape = new AIS_Shape (rshape);
1286                 myAISContext->SetColor(myShape, Quantity_Color(Quantity_NOC_YELLOW));
1287                 myAISContext->Display(myShape, Standard_True);
1288     }
1289
1290         return 0;
1291 }
1292
1293 #include <BRepFeat_SplitShape.hxx>
1294 #include <ShapeAnalysis_ShapeContents.hxx>
1295 #include <BRepAlgo.hxx>
1296 static Standard_Integer OCC24086 (Draw_Interpretor& di, Standard_Integer argc, const char ** argv) 
1297 {
1298         if (argc != 3) {
1299                 di << "Usage : " << argv[0] << " should be 2 arguments (face and wire)";
1300                 return 1;
1301         }
1302         
1303         Handle(AIS_InteractiveContext) myAISContext = ViewerTest::GetAISContext();
1304         if(myAISContext.IsNull()) {
1305                 di << "use 'vinit' command before " << argv[0] << "\n";
1306                 return 1;
1307         }
1308         
1309         TopoDS_Shape result;
1310         TopoDS_Face face = TopoDS::Face(DBRep::Get(argv[1]));
1311         TopoDS_Wire wire = TopoDS::Wire(DBRep::Get(argv[2]));
1312     
1313         BRepFeat_SplitShape asplit(face);
1314         asplit.Add(wire, face);
1315         asplit.Build();
1316     result = asplit.Shape();
1317     ShapeAnalysis_ShapeContents ana;
1318     ana.Perform(result);
1319     ana.NbFaces();
1320
1321         if (!(BRepAlgo::IsValid(result))) {
1322                 di << "Result was checked and it is INVALID\n";
1323         } else {
1324                 di << "Result was checked and it is VALID\n";
1325         }
1326         
1327         Handle(AIS_InteractiveObject) myShape = new AIS_Shape (result);
1328         myAISContext->Display(myShape, Standard_True);
1329
1330         return 0;
1331 }
1332
1333 #include <Geom_Circle.hxx>
1334 #include <GeomAdaptor_Curve.hxx>
1335 #include <Extrema_ExtPC.hxx>
1336 #include <gp_Cylinder.hxx>
1337 #include <ElSLib.hxx>
1338 static Standard_Integer OCC24945 (Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
1339 {
1340   if (argc != 1) {
1341     di << "Usage: " << argv[0] << " invalid number of arguments\n";
1342     return 1;
1343   }
1344
1345   gp_Pnt aP3D( -1725.97, 843.257, -4.22741e-013 );
1346   gp_Ax2 aAxis( gp_Pnt( 0, 843.257, 0 ), gp_Dir( 0, -1, 0 ), gp::DX() );
1347   Handle(Geom_Circle) aCircle = new Geom_Circle( aAxis, 1725.9708621929999 );
1348   GeomAdaptor_Curve aC3D( aCircle );
1349
1350   Extrema_ExtPC aExtPC( aP3D, aC3D );
1351   //Standard_Real aParam = (aExtPC.Point(1)).Parameter();
1352   gp_Pnt aProj = (aExtPC.Point(1)).Value();
1353   di << "Projected point: X = " << aProj.X() << "; Y = " << aProj.Y() << "; Z = " << aProj.Z() << "\n";
1354
1355   // Result of deviation
1356   gp_Ax2 aCylAxis( gp_Pnt( 0, 2103.87, 0 ), -gp::DY(), -gp::DX() );
1357   gp_Cylinder aCylinder( aCylAxis, 1890. );
1358
1359   Standard_Real aU = 0., aV = 0.;
1360   ElSLib::Parameters( aCylinder, aProj, aU, aV );
1361   di << "Parameters on cylinder: U = " << aU << "; V = " << aV << "\n";
1362   
1363   return 0;
1364 }
1365
1366 #include <Extrema_FuncExtPS.hxx>
1367 #include <math_FunctionSetRoot.hxx>
1368 #include <math_Vector.hxx>
1369 #include <BRepBuilderAPI_MakeVertex.hxx>
1370 static Standard_Integer OCC24137 (Draw_Interpretor& theDI, Standard_Integer theNArg, const char** theArgv) 
1371 {
1372   Standard_Integer anArgIter = 1;
1373   if (theNArg < 5)
1374     {
1375       theDI <<"Usage: " << theArgv[0] << " face vertex U V [N]\n";
1376       return 1;
1377     }
1378
1379   // get target shape
1380   Standard_CString aFaceName = theArgv[anArgIter++];
1381   Standard_CString aVertName = theArgv[anArgIter++];
1382   const TopoDS_Shape aShapeF = DBRep::Get (aFaceName);
1383   const TopoDS_Shape aShapeV = DBRep::Get (aVertName);
1384   const Standard_Real aUFrom = Atof (theArgv[anArgIter++]);
1385   const Standard_Real aVFrom = Atof (theArgv[anArgIter++]);
1386   const Standard_Integer aNbIts = (anArgIter < theNArg) ? atol (theArgv[anArgIter++]) : 100;
1387   if (aShapeF.IsNull() || aShapeF.ShapeType() != TopAbs_FACE)
1388     {
1389       std::cout << "Error: " << aFaceName << " shape is null / not a face" << std::endl;
1390       return 1;
1391     }
1392   if (aShapeV.IsNull() || aShapeV.ShapeType() != TopAbs_VERTEX)
1393     {
1394       std::cout << "Error: " << aVertName << " shape is null / not a vertex" << std::endl;
1395       return 1;
1396     }
1397   const TopoDS_Face   aFace = TopoDS::Face   (aShapeF);
1398   const TopoDS_Vertex aVert = TopoDS::Vertex (aShapeV);
1399   GeomAdaptor_Surface aSurf (BRep_Tool::Surface (aFace));
1400
1401   gp_Pnt aPnt = BRep_Tool::Pnt (aVert), aRes;
1402
1403   Extrema_FuncExtPS    anExtFunc;
1404   math_FunctionSetRoot aRoot (anExtFunc, aNbIts);
1405
1406   math_Vector aTolUV (1, 2), aUVinf  (1, 2), aUVsup  (1, 2), aFromUV (1, 2);
1407   aTolUV (1) =  Precision::Confusion(); aTolUV (2) =  Precision::Confusion();
1408   aUVinf (1) = -Precision::Infinite();  aUVinf (2) = -Precision::Infinite();
1409   aUVsup (1) =  Precision::Infinite();  aUVsup (2) =  Precision::Infinite();
1410   aFromUV(1) =  aUFrom; aFromUV(2) = aVFrom;
1411
1412   anExtFunc.Initialize (aSurf);
1413   anExtFunc.SetPoint (aPnt);
1414   aRoot.SetTolerance (aTolUV);
1415   aRoot.Perform (anExtFunc, aFromUV, aUVinf, aUVsup);
1416   if (!aRoot.IsDone())
1417     {
1418       std::cerr << "No results!\n";
1419       return 1;
1420     }
1421
1422   theDI << aRoot.Root()(1) << " " << aRoot.Root()(2) << "\n";
1423   
1424   aSurf.D0 (aRoot.Root()(1), aRoot.Root()(2), aRes);
1425   DBRep::Set ("result", BRepBuilderAPI_MakeVertex (aRes));
1426   return 0;
1427 }
1428
1429 //! Check boolean operations on NCollection_Map
1430 static Standard_Integer OCC24271 (Draw_Interpretor& di,
1431                                   Standard_Integer  /*theArgNb*/,
1432                                   const char**      /*theArgVec*/)
1433 {
1434   // input data
1435   const Standard_Integer aLeftLower  = 1;
1436   const Standard_Integer aLeftUpper  = 10;
1437   const Standard_Integer aRightLower = 5;
1438   const Standard_Integer aRightUpper = 15;
1439
1440   // define arguments
1441   NCollection_Map<Standard_Integer> aMapLeft;
1442   for (Standard_Integer aKeyIter = aLeftLower; aKeyIter <= aLeftUpper; ++aKeyIter)
1443   {
1444     aMapLeft.Add (aKeyIter);
1445   }
1446
1447   NCollection_Map<Standard_Integer> aMapRight;
1448   for (Standard_Integer aKeyIter = aRightLower; aKeyIter <= aRightUpper; ++aKeyIter)
1449   {
1450     aMapRight.Add (aKeyIter);
1451   }
1452
1453   QCOMPARE (aMapLeft .Contains (aMapRight), Standard_False);
1454   QCOMPARE (aMapRight.Contains (aMapLeft),  Standard_False);
1455
1456   // validate Union operation
1457   NCollection_Map<Standard_Integer> aMapUnion;
1458   aMapUnion.Union (aMapLeft, aMapRight);
1459   QCOMPARE (aMapUnion.Extent(), aRightUpper - aLeftLower + 1);
1460   for (Standard_Integer aKeyIter = aLeftLower; aKeyIter <= aRightUpper; ++aKeyIter)
1461   {
1462     QCOMPARE (aMapUnion.Contains (aKeyIter), Standard_True);
1463   }
1464
1465   // validate Intersection operation
1466   NCollection_Map<Standard_Integer> aMapSect;
1467   aMapSect.Intersection (aMapLeft, aMapRight);
1468   QCOMPARE (aMapSect.Extent(), aLeftUpper - aRightLower + 1);
1469   for (Standard_Integer aKeyIter = aRightLower; aKeyIter <= aLeftUpper; ++aKeyIter)
1470   {
1471     QCOMPARE (aMapSect.Contains (aKeyIter), Standard_True);
1472   }
1473   QCOMPARE (aMapLeft .Contains (aMapSect), Standard_True);
1474   QCOMPARE (aMapRight.Contains (aMapSect), Standard_True);
1475
1476   // validate Substruction operation
1477   NCollection_Map<Standard_Integer> aMapSubsLR;
1478   aMapSubsLR.Subtraction (aMapLeft, aMapRight);
1479   QCOMPARE (aMapSubsLR.Extent(), aRightLower - aLeftLower);
1480   for (Standard_Integer aKeyIter = aLeftLower; aKeyIter < aRightLower; ++aKeyIter)
1481   {
1482     QCOMPARE (aMapSubsLR.Contains (aKeyIter), Standard_True);
1483   }
1484
1485   NCollection_Map<Standard_Integer> aMapSubsRL;
1486   aMapSubsRL.Subtraction (aMapRight, aMapLeft);
1487   QCOMPARE (aMapSubsRL.Extent(), aRightUpper - aLeftUpper);
1488   for (Standard_Integer aKeyIter = aLeftUpper + 1; aKeyIter < aRightUpper; ++aKeyIter)
1489   {
1490     QCOMPARE (aMapSubsRL.Contains (aKeyIter), Standard_True);
1491   }
1492
1493   // validate Difference operation
1494   NCollection_Map<Standard_Integer> aMapDiff;
1495   aMapDiff.Difference (aMapLeft, aMapRight);
1496   QCOMPARE (aMapDiff.Extent(), aRightLower - aLeftLower + aRightUpper - aLeftUpper);
1497   for (Standard_Integer aKeyIter = aLeftLower; aKeyIter < aRightLower; ++aKeyIter)
1498   {
1499     QCOMPARE (aMapDiff.Contains (aKeyIter), Standard_True);
1500   }
1501   for (Standard_Integer aKeyIter = aLeftUpper + 1; aKeyIter < aRightUpper; ++aKeyIter)
1502   {
1503     QCOMPARE (aMapDiff.Contains (aKeyIter), Standard_True);
1504   }
1505
1506   // validate Exchange operation
1507   NCollection_Map<Standard_Integer> aMapSwap;
1508   aMapSwap.Exchange (aMapSect);
1509   for (Standard_Integer aKeyIter = aRightLower; aKeyIter <= aLeftUpper; ++aKeyIter)
1510   {
1511     QCOMPARE (aMapSwap.Contains (aKeyIter), Standard_True);
1512   }
1513   QCOMPARE (aMapSect.IsEmpty(), Standard_True);
1514   aMapSwap.Add (34);
1515   aMapSect.Add (43);
1516
1517   NCollection_Map<Standard_Integer> aMapCopy (aMapSwap);
1518   QCOMPARE (aMapCopy.IsEqual (aMapSwap), Standard_True);
1519   aMapCopy.Remove (34);
1520   aMapCopy.Add    (43);
1521   QCOMPARE (aMapCopy.IsEqual (aMapSwap), Standard_False);
1522
1523   return 0;
1524 }
1525
1526 #define QVERIFY(val1) \
1527   di << "Checking " #val1 " == Standard_True" << \
1528         ((val1) == Standard_True ? ": OK\n" : ": Error\n")
1529
1530 #include <GeomInt_IntSS.hxx>
1531 #include <Geom_ConicalSurface.hxx>
1532 #include <Standard_ErrorHandler.hxx>
1533 //=======================================================================
1534 //function : OCC23972
1535 //purpose  : 
1536 //=======================================================================
1537 static void DoGeomIntSSTest (const Handle(Geom_Surface)& theSurf1,
1538                              const Handle(Geom_Surface)& theSurf2,
1539                              const Standard_Integer theNbSol,
1540                              Draw_Interpretor& di)
1541 {
1542   try {
1543     OCC_CATCH_SIGNALS
1544          GeomInt_IntSS anInter;
1545          anInter.Perform (theSurf1, theSurf2, Precision::Confusion(), Standard_True);
1546          QVERIFY (anInter.IsDone());
1547          QCOMPARE (anInter.NbLines(), theNbSol);
1548   } catch (...) {
1549     QVERIFY (Standard_False);
1550   }
1551 }
1552
1553 namespace {
1554   static Handle(Geom_ConicalSurface) CreateCone (const gp_Pnt& theLoc,
1555                                                  const gp_Dir& theDir,
1556                                                  const gp_Dir& theXDir,
1557                                                  const Standard_Real theRad,
1558                                                  const Standard_Real theSin,
1559                                                  const Standard_Real theCos)
1560   {
1561     const Standard_Real anA = atan (theSin / theCos);
1562     gp_Ax3 anAxis (theLoc, theDir, theXDir);
1563     Handle(Geom_ConicalSurface) aSurf = new Geom_ConicalSurface (anAxis, anA, theRad);
1564     return aSurf;
1565   }
1566 }
1567
1568 static Standard_Integer OCC23972 (Draw_Interpretor& di,Standard_Integer n, const char**)
1569 {
1570   if (n != 1) return 1;
1571
1572   //process specific cones, cannot read them from files because due to rounding the original error
1573   //in math_FunctionRoots gets hidden
1574   Handle(Geom_Surface) aS1 = CreateCone (
1575                                          gp_Pnt (123.694345356663, 789.9, 68.15),
1576                                          gp_Dir (-1, 3.48029791472957e-016, -8.41302743359754e-017),
1577                                          gp_Dir (-3.48029791472957e-016, -1, -3.17572289932207e-016),
1578                                          3.28206830417112,
1579                                          0.780868809443031,
1580                                          0.624695047554424);
1581   Handle(Geom_Surface) aS2 = CreateCone (
1582                                          gp_Pnt (123.694345356663, 784.9, 68.15),
1583                                          gp_Dir (-1, -2.5209507537117e-016, -1.49772808948866e-016),
1584                                          gp_Dir (1.49772808948866e-016, 3.17572289932207e-016, -1),
1585                                          3.28206830417112,
1586                                          0.780868809443031,
1587                                          0.624695047554424);
1588   
1589   DoGeomIntSSTest (aS1, aS2, 2, di);
1590
1591   return 0;
1592 }
1593
1594 #include <ShapeFix_EdgeProjAux.hxx>
1595 static Standard_Integer OCC24370 (Draw_Interpretor& di, Standard_Integer argc,const char ** argv)
1596 {
1597   if (argc < 5) {
1598     di<<"Usage: " << argv[0] << " invalid number of arguments\n";
1599     return 1;
1600   }
1601
1602   TopoDS_Shape aSh = DBRep::Get(argv[1]);
1603   if (aSh.IsNull()) {
1604     di << argv[0] << " Error: Null input edge\n";
1605     return 1;
1606   }
1607   const TopoDS_Edge& anEdge = TopoDS::Edge (aSh);
1608
1609   Handle(Geom2d_Curve) aC = DrawTrSurf::GetCurve2d(argv[2]);
1610   if (aC.IsNull()) {
1611     di << argv[0] << " Error: Null input curve\n";
1612     return 1;
1613   }
1614
1615   Handle(Geom_Surface) aS = DrawTrSurf::GetSurface(argv[3]);
1616   if (aS.IsNull()) {
1617     di << argv[0] << " Error: Null input surface\n";
1618     return 1;
1619   }
1620
1621   Standard_Real prec = Draw::Atof(argv[4]);
1622   
1623   //prepare data
1624   TopoDS_Face aFace;
1625   BRep_Builder aB;
1626   aB.MakeFace (aFace, aS, Precision::Confusion());
1627   aB.UpdateEdge (anEdge, aC, aFace, Precision::Confusion());
1628   aB.Range (anEdge, aFace, aC->FirstParameter(), aC->LastParameter());
1629
1630   //call algorithm
1631   ShapeFix_EdgeProjAux aProj (aFace, anEdge);
1632   aProj.Compute (prec);
1633   
1634   Standard_Boolean isfirstdone = aProj.IsFirstDone();
1635   Standard_Boolean islastdone = aProj.IsLastDone();
1636
1637   Standard_Real first = 0.;
1638   Standard_Real last = 0.;
1639   Standard_Integer isfirstdoneInteger = 0;
1640   Standard_Integer islastdoneInteger = 0;
1641
1642
1643   if (isfirstdone) {
1644     first = aProj.FirstParam();
1645     isfirstdoneInteger = 1;
1646   }
1647  
1648   if (islastdone) {
1649     last= aProj.LastParam();
1650     islastdoneInteger = 1;
1651   }
1652
1653   di << isfirstdoneInteger << " "<< islastdoneInteger << " "<< first << " "<< last << " \n";
1654
1655   return 0;
1656 }
1657
1658 template<typename T, typename HT>
1659 static void DoIsNull(Draw_Interpretor& di)
1660 {
1661   HT aHandle;
1662   //    QVERIFY (aHandle.IsNull());
1663   QCOMPARE (aHandle.IsNull(), Standard_True);
1664   const T* p = aHandle.get();
1665 #if OCC_VERSION_HEX > 0x060700
1666   //QVERIFY (!p);
1667   //QVERIFY (p == 0);
1668   QCOMPARE (!p, Standard_True);
1669   QCOMPARE (p == 0, Standard_True);
1670 #endif
1671
1672   aHandle = new T;
1673   //QVERIFY (!aHandle.IsNull());
1674   QCOMPARE (!aHandle.IsNull(), Standard_True);
1675   p = aHandle.get();
1676   //QVERIFY (p);
1677   //QVERIFY (p != 0);
1678   QCOMPARE (p != NULL, Standard_True);
1679   QCOMPARE (p != 0, Standard_True);
1680 }
1681
1682 //=======================================================================
1683 //function : OCC24533
1684 //purpose  : 
1685 //=======================================================================
1686 static Standard_Integer OCC24533 (Draw_Interpretor& di, Standard_Integer n, const char**)
1687 {
1688   if (n != 1) return 1;
1689
1690   DoIsNull<Standard_Transient, Handle(Standard_Transient)>(di);
1691
1692   return 0;
1693 }
1694
1695 // Dummy class to test interface for compilation issues
1696 class QABugs_HandleClass : public Standard_Transient
1697 {
1698 public:
1699   Standard_Integer HandleProc (Draw_Interpretor& , Standard_Integer  , const char** theArgVec)
1700   {
1701     std::cerr << "QABugs_HandleClass[" << this << "] " << theArgVec[0] << "\n";
1702     return 0;
1703   }
1704   DEFINE_STANDARD_RTTI_INLINE(QABugs_HandleClass,Standard_Transient) // Type definition
1705 };
1706 DEFINE_STANDARD_HANDLE    (QABugs_HandleClass, Standard_Transient)
1707
1708
1709 // Dummy class to test interface for compilation issues
1710 struct QABugs_NHandleClass
1711 {
1712   Standard_Integer NHandleProc (Draw_Interpretor& , Standard_Integer  , const char** theArgVec)
1713   {
1714     std::cerr << "QABugs_NHandleClass[" << this << "] " << theArgVec[0] << "\n";
1715     return 0;
1716   }
1717 };
1718
1719 #include <XCAFDoc_ColorTool.hxx>
1720 #include <STEPControl_StepModelType.hxx>
1721 #include <STEPCAFControl_Writer.hxx>
1722 static Standard_Integer OCC23951 (Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
1723 {
1724   if (argc != 2) {
1725     di << "Usage: " << argv[0] << " invalid number of arguments\n";
1726     return 1;
1727   }
1728   Handle(TDocStd_Document) aDoc = new TDocStd_Document("dummy");;
1729   TopoDS_Shape s1 = BRepPrimAPI_MakeBox(1,1,1).Shape();
1730   TDF_Label lab1 = XCAFDoc_DocumentTool::ShapeTool (aDoc->Main ())->NewShape();
1731   XCAFDoc_DocumentTool::ShapeTool (aDoc->Main ())->SetShape(lab1, s1);
1732   TDataStd_Name::Set(lab1, "Box1");
1733         
1734   Quantity_Color yellow(1,1,0, Quantity_TOC_RGB);
1735   XCAFDoc_DocumentTool::ColorTool (aDoc->Main())->SetColor(lab1, yellow, XCAFDoc_ColorGen);
1736   XCAFDoc_DocumentTool::ColorTool(aDoc->Main())->SetVisibility(lab1, 0);
1737
1738   STEPControl_StepModelType mode = STEPControl_AsIs;
1739   STEPCAFControl_Writer writer;
1740   if ( ! writer.Transfer (aDoc, mode ) )
1741   {
1742     di << "The document cannot be translated or gives no result"  <<  "\n";
1743     return 1;
1744   }
1745
1746   writer.Write(argv[1]);
1747   return 0;
1748 }
1749
1750
1751 //=======================================================================
1752 //function : OCC23950
1753 //purpose  :
1754 //=======================================================================
1755 static Standard_Integer OCC23950 (Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
1756 {
1757   if (argc != 2) {
1758     di << "Usage : " << argv[0] << " step_file\n";
1759     return 1;
1760   }
1761
1762   Handle(TDocStd_Document) aDoc = new TDocStd_Document ("dummy");
1763   TopoDS_Shape s6 = BRepBuilderAPI_MakeVertex (gp_Pnt (75, 0, 0));
1764   gp_Trsf t0;
1765   TopLoc_Location location0 (t0);
1766
1767   TDF_Label lab1 = XCAFDoc_DocumentTool::ShapeTool (aDoc->Main ())->NewShape ();
1768   XCAFDoc_DocumentTool::ShapeTool (aDoc->Main ())->SetShape (lab1, s6);
1769   TDataStd_Name::Set(lab1, "Point1");
1770
1771   TDF_Label labelA0 = XCAFDoc_DocumentTool::ShapeTool (aDoc->Main ())->NewShape ();
1772   TDataStd_Name::Set(labelA0, "ASSEMBLY");
1773
1774   TDF_Label component01 = XCAFDoc_DocumentTool::ShapeTool (aDoc->Main ())->AddComponent (labelA0, lab1, location0);
1775
1776   Quantity_Color yellow(1,1,0, Quantity_TOC_RGB);
1777   XCAFDoc_DocumentTool::ColorTool (labelA0)->SetColor (component01, yellow, XCAFDoc_ColorGen);
1778   XCAFDoc_DocumentTool::ColorTool (labelA0)->SetVisibility (component01, 0);
1779
1780   STEPControl_StepModelType mode = STEPControl_AsIs;
1781   STEPCAFControl_Writer writer;
1782   if (! writer.Transfer (aDoc, mode))
1783   {
1784     di << "The document cannot be translated or gives no result\n";
1785     return 1;
1786   }
1787
1788   writer.Write (argv[1]);
1789   return 0;
1790 }
1791
1792 //=======================================================================
1793 //function : OCC24622
1794 //purpose  : The command tests sourcing Image_PixMap to AIS_TexturedShape
1795 //=======================================================================
1796 static Standard_Integer OCC24622 (Draw_Interpretor& /*theDi*/, Standard_Integer theArgNb, const char** theArgVec)
1797 {
1798   if (theArgNb != 2)
1799   {
1800     std::cout << "Usage : " << theArgVec[0] << " texture={1D|2D}";
1801     return 1;
1802   }
1803
1804   const Handle(AIS_InteractiveContext)& anAISContext = ViewerTest::GetAISContext();
1805   if (anAISContext.IsNull())
1806   {
1807     std::cout << "Please initialize view with \"vinit\".\n";
1808     return 1;
1809   }
1810
1811   Handle(Image_PixMap) anImage = new Image_PixMap();
1812
1813   static const Image_ColorRGB aBitmap[8] =
1814   {
1815     {{255,   0, 0}}, {{0,  148, 255}}, {{ 0, 148, 255}}, {{255,  94, 0}},
1816     {{255, 121, 0}}, {{76, 255,   0}}, {{76, 255,   0}}, {{255, 202, 0}}
1817   };
1818
1819   TCollection_AsciiString aTextureTypeArg (theArgVec[1]);
1820   aTextureTypeArg.UpperCase();
1821   if (aTextureTypeArg == "1D")
1822   {
1823     anImage->InitWrapper (Image_PixMap::ImgRGB, (Standard_Byte*)aBitmap, 8, 1);
1824   }
1825   else if (aTextureTypeArg == "2D")
1826   {
1827     anImage->InitTrash (Image_PixMap::ImgRGB, 8, 8);
1828     for (Standard_Integer aRow = 0; aRow < 8; ++aRow)
1829     {
1830       for (Standard_Integer aCol = 0; aCol < 8; ++aCol)
1831       {
1832         anImage->ChangeValue<Image_ColorRGB> (aRow, aCol) = aBitmap[aRow];
1833       }
1834     }
1835   }
1836   else
1837   {
1838     std::cout << "Please specify type of texture to test {1D|2D}.\n";
1839     return 1;
1840   }
1841
1842   TopoDS_Shape aBlankShape = BRepPrimAPI_MakeBox (10.0, 10.0, 10.0).Shape();
1843
1844   Handle(AIS_TexturedShape) aTexturedShape = new AIS_TexturedShape (aBlankShape);
1845   aTexturedShape->SetTexturePixMap (anImage);
1846   anAISContext->Display (aTexturedShape, 3, 0);
1847
1848   return 0;
1849 }
1850
1851 //=======================================================================
1852 //function : OCC24667
1853 //purpose  : 
1854 //=======================================================================
1855 static Standard_Integer OCC24667 (Draw_Interpretor& di, Standard_Integer n, const char** a)
1856 {
1857   if (n == 1)
1858   {
1859     di << "OCC24667 result Wire_spine Profile [Mode [Approx]]\n";
1860     di << "Mode = 0 - CorrectedFrenet,\n";
1861     di << "     = 1 - Frenet,\n";
1862     di << "     = 2 - DiscreteTrihedron\n";
1863     di << "Approx - force C1-approximation if result is C0\n";
1864     return 0;
1865   }
1866
1867   if (n > 1 && n < 4) return 1;
1868
1869   TopoDS_Shape Spine = DBRep::Get(a[2],TopAbs_WIRE);
1870   if ( Spine.IsNull()) return 1;
1871
1872   TopoDS_Shape Profile = DBRep::Get(a[3]);
1873   if ( Profile.IsNull()) return 1;
1874
1875   GeomFill_Trihedron Mode = GeomFill_IsCorrectedFrenet;
1876   if (n >= 5)
1877   {
1878     Standard_Integer iMode = atoi(a[4]);
1879     if (iMode == 1)
1880       Mode = GeomFill_IsFrenet;
1881     else if (iMode == 2)
1882       Mode = GeomFill_IsDiscreteTrihedron;
1883   }
1884
1885   Standard_Boolean ForceApproxC1 = Standard_False;
1886   if (n >= 6)
1887     ForceApproxC1 = Standard_True;
1888
1889   BRepOffsetAPI_MakePipe aPipe(TopoDS::Wire(Spine),
1890                                           Profile,
1891                                           Mode,
1892                                           ForceApproxC1);
1893
1894   TopoDS_Shape S = aPipe.Shape();
1895   TopoDS_Shape aSF = aPipe.FirstShape();
1896   TopoDS_Shape aSL = aPipe.LastShape();
1897
1898   DBRep::Set(a[1],S);
1899
1900   TCollection_AsciiString aStrF(a[1], "_f");
1901   TCollection_AsciiString aStrL(a[1], "_l");
1902
1903   DBRep::Set(aStrF.ToCString(), aSF);
1904   DBRep::Set(aStrL.ToCString(), aSL);
1905
1906   return 0;
1907 }
1908
1909 #include <BRepPrimAPI_MakeCylinder.hxx>
1910 #include <BRepBuilderAPI_Copy.hxx>
1911 #include <BRepTools_NurbsConvertModification.hxx>
1912 static TopoDS_Shape CreateTestShape (int& theShapeNb)
1913 {
1914   TopoDS_Compound aComp;
1915   BRep_Builder aBuilder;
1916   aBuilder.MakeCompound (aComp);
1917   //NURBS modifier is used to increase footprint of each shape
1918   Handle(BRepTools_NurbsConvertModification) aNurbsModif = new BRepTools_NurbsConvertModification;
1919   TopoDS_Shape aRefShape = BRepPrimAPI_MakeCylinder (50., 100.).Solid();
1920   BRepTools_Modifier aModifier (aRefShape, aNurbsModif);
1921   if (aModifier.IsDone()) {
1922     aRefShape = aModifier.ModifiedShape (aRefShape);
1923   }
1924   int aSiblingNb = 0;
1925   for (; theShapeNb > 0; --theShapeNb) {
1926     TopoDS_Shape aShape;
1927     if (++aSiblingNb <= 100) { //number of siblings is limited to avoid long lists
1928                 aShape = BRepBuilderAPI_Copy (aRefShape, Standard_True /*CopyGeom*/).Shape();
1929     } else {
1930       aShape = CreateTestShape (theShapeNb);
1931     }
1932     aBuilder.Add (aComp, aShape);
1933   }
1934   return aComp;
1935 }
1936
1937 #include <AppStd_Application.hxx>
1938 #include <TDataStd_Integer.hxx>
1939 #include <TNaming_Builder.hxx>
1940 static Standard_Integer OCC24931 (Draw_Interpretor& di, Standard_Integer argc, const char** argv)
1941 {
1942   if (argc != 2) {
1943     di << "Usage: " << argv[0] << " invalid number of arguments\n";
1944     return 1;
1945   }
1946   TCollection_ExtendedString aFileName (argv[1]);
1947   PCDM_StoreStatus aSStatus  = PCDM_SS_Failure;
1948
1949   Handle(TDocStd_Application) anApp = new AppStd_Application;
1950   {
1951     Handle(TDocStd_Document) aDoc;
1952     anApp->NewDocument ("XmlOcaf", aDoc);
1953     TDF_Label aLab = aDoc->Main();
1954     TDataStd_Integer::Set (aLab, 0);
1955     int n = 10000; //must be big enough
1956     TopoDS_Shape aShape = CreateTestShape (n);
1957     TNaming_Builder aBuilder (aLab);
1958     aBuilder.Generated (aShape);
1959
1960     aSStatus = anApp->SaveAs (aDoc, aFileName);
1961     anApp->Close (aDoc);
1962   }
1963   QCOMPARE (aSStatus, PCDM_SS_OK);
1964   return 0;
1965 }
1966
1967 #include <AppStdL_Application.hxx>
1968 #include <TDocStd_Application.hxx>
1969 #include <TDataStd_Integer.hxx>
1970 #include <TDF_AttributeIterator.hxx>
1971 //=======================================================================
1972 //function : OCC24755
1973 //purpose  : 
1974 //=======================================================================
1975 static Standard_Integer OCC24755 (Draw_Interpretor& di, Standard_Integer n, const char** a)
1976 {
1977   if (n != 1)
1978   {
1979     std::cout << "Usage : " << a[0] << "\n";
1980     return 1;
1981   }
1982
1983   Handle(TDocStd_Application) anApp = new AppStdL_Application;
1984   Handle(TDocStd_Document) aDoc;
1985   anApp->NewDocument ("BinOcaf", aDoc);
1986   TDF_Label aLab = aDoc->Main();
1987   TDataStd_Integer::Set (aLab, 0);
1988   TDataStd_Name::Set (aLab, "test");
1989
1990   TDF_AttributeIterator i (aLab);
1991   Handle(TDF_Attribute) anAttr = i.Value();
1992   QCOMPARE (anAttr->IsKind (STANDARD_TYPE (TDataStd_Integer)), Standard_True);
1993   i.Next();
1994   anAttr = i.Value();
1995   QCOMPARE (anAttr->IsKind (STANDARD_TYPE (TDataStd_Name)), Standard_True);
1996
1997   return 0;
1998 }
1999
2000 struct MyStubObject
2001 {
2002   MyStubObject() : ptr(0L) {}
2003   MyStubObject(void* thePtr) : ptr(thePtr) {}
2004   char overhead[40];
2005   void* ptr;
2006 };
2007
2008 //=======================================================================
2009 //function : OCC24834
2010 //purpose  : 
2011 //=======================================================================
2012 static Standard_Integer OCC24834 (Draw_Interpretor& di, Standard_Integer n, const char** a)
2013 {
2014   if (n != 1)
2015   {
2016     std::cout << "Usage : " << a[0] << "\n";
2017     return 1;
2018   }
2019
2020   int i = sizeof (char*);  
2021   if (i > 4) {
2022     std::cout << "64-bit architecture is not supported.\n";
2023     return 0;
2024   }
2025
2026   NCollection_List<MyStubObject> aList;
2027   const Standard_Integer aSmallBlockSize = 40;
2028   const Standard_Integer aLargeBlockSize = 1500000;
2029
2030   // quick populate memory with large blocks
2031   try
2032   {
2033     for (;;)
2034     {
2035       aList.Append(MyStubObject(Standard::Allocate(aLargeBlockSize)));
2036     }
2037   }
2038   catch (Standard_Failure)
2039   {
2040     di << "caught out of memory for large blocks: OK\n";
2041   }
2042   catch (...)
2043   {
2044     di << "skept out of memory for large blocks: Error\n";
2045   }
2046
2047   // allocate small blocks
2048   try
2049   {
2050     for (;;)
2051     {
2052       aList.Append(MyStubObject(Standard::Allocate(aSmallBlockSize)));
2053     }
2054   }
2055   catch (Standard_Failure)
2056   {
2057     di << "caught out of memory for small blocks: OK\n";
2058   }
2059   catch (...)
2060   {
2061     di << "skept out of memory for small blocks: Error\n";
2062   }
2063
2064   // release all allocated blocks
2065   for (NCollection_List<MyStubObject>::Iterator it(aList); it.More(); it.Next())
2066   {
2067     Standard::Free(it.Value().ptr);
2068   }
2069   return 0;
2070 }
2071
2072
2073 #include <Geom2dAPI_InterCurveCurve.hxx>
2074 #include <IntRes2d_IntersectionPoint.hxx>
2075 //=======================================================================
2076 //function : OCC24889
2077 //purpose  : 
2078 //=======================================================================
2079 static Standard_Integer OCC24889 (Draw_Interpretor& theDI,
2080                                   Standard_Integer /*theNArg*/,
2081                                   const char** /*theArgs*/)
2082 {
2083  // Curves
2084   Handle( Geom2d_Circle ) aCircle1 = new Geom2d_Circle(
2085     gp_Ax22d( gp_Pnt2d( 25, -25 ), gp_Dir2d( 1, 0 ), gp_Dir2d( -0, 1 ) ), 155 );
2086
2087   Handle( Geom2d_Circle ) aCircle2 = new Geom2d_Circle(
2088     gp_Ax22d( gp_Pnt2d( 25, 25 ), gp_Dir2d( 1, 0 ), gp_Dir2d( -0, 1 ) ), 155 );
2089
2090   Handle( Geom2d_TrimmedCurve ) aTrim[2] = {
2091     new Geom2d_TrimmedCurve( aCircle1, 1.57079632679490, 2.97959469729228 ),
2092     new Geom2d_TrimmedCurve( aCircle2, 3.30359060633978, 4.71238898038469 )
2093   };
2094
2095   DrawTrSurf::Set("c_1", aTrim[0]);
2096   DrawTrSurf::Set("c_2", aTrim[1]);
2097
2098   // Intersection
2099   const Standard_Real aTol = Precision::Confusion();
2100   Geom2dAPI_InterCurveCurve aIntTool( aTrim[0], aTrim[1], aTol );
2101
2102   const IntRes2d_IntersectionPoint& aIntPnt =
2103     aIntTool.Intersector().Point( 1 );
2104
2105   gp_Pnt2d aIntRes = aIntTool.Point( 1 );
2106   Standard_Real aPar[2] = {
2107     aIntPnt.ParamOnFirst(),
2108     aIntPnt.ParamOnSecond()
2109   };
2110
2111   //theDI.precision( 5 );
2112   theDI << "Int point: X = " << aIntRes.X() << "; Y = " << aIntRes.Y() << "\n";
2113   for (int i = 0; i < 2; ++i)
2114   {
2115     theDI << "Curve " << i << ": FirstParam = " << aTrim[i]->FirstParameter() <<
2116       "; LastParam = " << aTrim[i]->LastParameter() <<
2117       "; IntParameter = " << aPar[i] << "\n";
2118   }
2119
2120   return 0;
2121 }
2122
2123 #include <math_GlobOptMin.hxx>
2124 #include <math_MultipleVarFunctionWithHessian.hxx>
2125 //=======================================================================
2126 //function : OCC25004
2127 //purpose  : Check extremaCC on Branin function.
2128 //=======================================================================
2129 // Function is:
2130 // f(u,v) = a*(v - b*u^2 + c*u-r)^2+s(1-t)*cos(u)+s
2131 // Standard borders are:
2132 // -5 <= u <= 10
2133 //  0 <= v <= 15
2134 class BraninFunction : public math_MultipleVarFunctionWithHessian
2135 {
2136 public:
2137   BraninFunction()
2138   {
2139     a = 1.0;
2140     b = 5.1 / (4.0 * M_PI * M_PI);
2141     c = 5.0 / M_PI;
2142     r = 6.0;
2143     s = 10.0;
2144     t = 1.0 / (8.0 *  M_PI);
2145   }
2146   virtual Standard_Integer NbVariables() const
2147   {
2148     return 2;
2149   }
2150   virtual Standard_Boolean Value(const math_Vector& X,Standard_Real& F)
2151   {
2152     Standard_Real u = X(1);
2153     Standard_Real v = X(2);
2154
2155     Standard_Real aSqPt = (v - b * u * u + c * u - r); // Square Part of function.
2156     Standard_Real aLnPt = s * (1 - t) * cos(u); // Linear part of funcrtion.
2157     F = a * aSqPt * aSqPt + aLnPt + s;
2158     return Standard_True;
2159   }
2160   virtual Standard_Boolean Gradient(const math_Vector& X,math_Vector& G)
2161   {
2162     Standard_Real u = X(1);
2163     Standard_Real v = X(2);
2164
2165     Standard_Real aSqPt = (v - b * u * u + c * u - r); // Square Part of function.
2166     G(1) = 2 * a * aSqPt * (c - 2 * b * u) - s * (1 - t) * sin(u);
2167     G(2) = 2 * a * aSqPt;
2168
2169     return Standard_True;
2170   }
2171   virtual Standard_Boolean Values(const math_Vector& X,Standard_Real& F,math_Vector& G)
2172   {
2173     Value(X,F);
2174     Gradient(X,G);
2175
2176     return Standard_True;
2177   }
2178   virtual Standard_Boolean Values(const math_Vector& X,Standard_Real& F,math_Vector& G,math_Matrix& H)
2179   {
2180     Value(X,F);
2181     Gradient(X,G);
2182
2183     Standard_Real u = X(1);
2184     Standard_Real v = X(2);
2185
2186     Standard_Real aSqPt = (v - b * u * u + c * u - r); // Square Part of function.
2187     Standard_Real aTmpPt = c - 2 * b *u; // Tmp part.
2188     H(1,1) = 2 * a * aTmpPt * aTmpPt - 4 * a * b * aSqPt - s * (1 - t) * cos(u);
2189     H(1,2) = 2 * a * aTmpPt;
2190     H(2,1) = H(1,2);
2191     H(2,2) = 2 * a;
2192
2193     return Standard_True;
2194   }
2195
2196 private:
2197   // Standard parameters.
2198   Standard_Real a, b, c, r, s, t;
2199 };
2200
2201 static Standard_Integer OCC25004 (Draw_Interpretor& theDI,
2202                                   Standard_Integer /*theNArg*/,
2203                                   const char** /*theArgs*/)
2204 {
2205   BraninFunction aFunc;
2206
2207   math_Vector aLower(1,2), aUpper(1,2);
2208   aLower(1) = -5;
2209   aLower(2) =  0;
2210   aUpper(1) = 10;
2211   aUpper(2) = 15;
2212
2213   Standard_Integer aGridOrder = 16;
2214   math_Vector aFuncValues(1, aGridOrder * aGridOrder);
2215
2216   Standard_Real aLipConst = 0;
2217   math_Vector aCurrPnt1(1, 2), aCurrPnt2(1, 2);
2218
2219   // Get Lipshitz constant estimation on regular grid.
2220   Standard_Integer i, j, idx = 1;
2221   for(i = 1; i <= aGridOrder; i++)
2222   {
2223     for(j = 1; j <= aGridOrder; j++)
2224     {
2225       aCurrPnt1(1) = aLower(1) + (aUpper(1) - aLower(1)) * (i - 1) / (aGridOrder - 1.0);
2226       aCurrPnt1(2) = aLower(2) + (aUpper(2) - aLower(2)) * (j - 1) / (aGridOrder - 1.0);
2227
2228       aFunc.Value(aCurrPnt1, aFuncValues(idx));
2229       idx++;
2230     }
2231   }
2232
2233   Standard_Integer k, l;
2234   Standard_Integer idx1, idx2;
2235   for(i = 1; i <= aGridOrder; i++)
2236   for(j = 1; j <= aGridOrder; j++)
2237   for(k = 1; k <= aGridOrder; k++)
2238   for(l = 1; l <= aGridOrder; l++)
2239     {
2240       if (i == k && j == l) 
2241         continue;
2242
2243       aCurrPnt1(1) = aLower(1) + (aUpper(1) - aLower(1)) * (i - 1) / (aGridOrder - 1.0);
2244       aCurrPnt1(2) = aLower(2) + (aUpper(2) - aLower(2)) * (j - 1) / (aGridOrder - 1.0);
2245       idx1 = (i - 1) * aGridOrder + j;
2246
2247       aCurrPnt2(1) = aLower(1) + (aUpper(1) - aLower(1)) * (k - 1) / (aGridOrder - 1.0);
2248       aCurrPnt2(2) = aLower(2) + (aUpper(2) - aLower(2)) * (l - 1) / (aGridOrder - 1.0);
2249       idx2 = (k - 1) * aGridOrder + l;
2250
2251       aCurrPnt1.Add(-aCurrPnt2);
2252       Standard_Real dist = aCurrPnt1.Norm();
2253
2254       Standard_Real C = Abs(aFuncValues(idx1) - aFuncValues(idx2)) / dist;
2255       if (C > aLipConst)
2256         aLipConst = C;
2257     }
2258
2259   math_GlobOptMin aFinder(&aFunc, aLower, aUpper, aLipConst);
2260   aFinder.Perform();
2261   //(-pi , 12.275), (pi , 2.275), (9.42478, 2.475)
2262
2263   Standard_Real anExtValue = aFinder.GetF();
2264   theDI << "F = " << anExtValue << "\n";
2265
2266   Standard_Integer aNbExt = aFinder.NbExtrema();
2267   theDI << "NbExtrema = " << aNbExt << "\n";
2268
2269   return 0;
2270 }
2271
2272 #include <OSD_Environment.hxx>
2273 #include <Plugin.hxx>
2274 #include <Plugin_Macro.hxx>
2275 #include <Resource_Manager.hxx>
2276
2277 #define THE_QATEST_DOC_FORMAT       "My Proprietary Format"
2278
2279 #define QA_CHECK(theDesc, theExpr, theValue) \
2280 {\
2281   const bool isTrue = !!(theExpr); \
2282   std::cout << theDesc << (isTrue ? " TRUE  " : " FALSE ") << (isTrue == theValue ? " is OK\n" : " is FAIL\n"); \
2283 }
2284
2285 class Test_TDocStd_Application : public TDocStd_Application
2286 {
2287 public:
2288
2289   static void initGlobalPluginMap (const TCollection_AsciiString& thePlugin,
2290                                    const TCollection_AsciiString& theSaver,
2291                                    const TCollection_AsciiString& theLoader)
2292   {
2293     const Handle(Resource_Manager)& aManager = Plugin::AdditionalPluginMap();
2294     aManager->SetResource ((theSaver  + ".Location").ToCString(), thePlugin.ToCString());
2295     aManager->SetResource ((theLoader + ".Location").ToCString(), thePlugin.ToCString());
2296   }
2297
2298   Test_TDocStd_Application (const TCollection_AsciiString& thePlugin,
2299                             const TCollection_AsciiString& theSaver,
2300                             const TCollection_AsciiString& theLoader)
2301   {
2302     initGlobalPluginMap (thePlugin, theSaver, theLoader);
2303
2304     // explicitly initialize resource manager
2305     myResources = new Resource_Manager ("");
2306     myResources->SetResource ("xml.FileFormat", THE_QATEST_DOC_FORMAT);
2307     myResources->SetResource (THE_QATEST_DOC_FORMAT ".Description",     "Test XML Document");
2308     myResources->SetResource (THE_QATEST_DOC_FORMAT ".FileExtension",   "xml");
2309     myResources->SetResource (THE_QATEST_DOC_FORMAT ".StoragePlugin",   theSaver.ToCString());
2310     myResources->SetResource (THE_QATEST_DOC_FORMAT ".RetrievalPlugin", theLoader.ToCString());
2311   }
2312
2313   virtual Standard_CString ResourcesName() { return ""; }
2314   virtual void Formats (TColStd_SequenceOfExtendedString& theFormats) { theFormats.Clear(); }
2315 };
2316
2317 //=======================================================================
2318 //function : OCC24925
2319 //purpose  :
2320 //=======================================================================
2321 static Standard_Integer OCC24925 (Draw_Interpretor& theDI,
2322                                   Standard_Integer  theArgNb,
2323                                   const char**      theArgVec)
2324 {
2325   if (theArgNb != 2
2326    && theArgNb != 5)
2327   {
2328     std::cout << "Error: wrong syntax! See usage:\n";
2329     theDI.PrintHelp (theArgVec[0]);
2330     return 1;
2331   }
2332
2333   Standard_Integer anArgIter = 1;
2334   TCollection_ExtendedString aFileName = theArgVec[anArgIter++];
2335   TCollection_AsciiString    aPlugin   = "TKXml";
2336   TCollection_AsciiString    aSaver    = "03a56820-8269-11d5-aab2-0050044b1af1"; // XmlStorageDriver   in XmlDrivers.cxx
2337   TCollection_AsciiString    aLoader   = "03a56822-8269-11d5-aab2-0050044b1af1"; // XmlRetrievalDriver in XmlDrivers.cxx
2338   if (anArgIter < theArgNb)
2339   {
2340     aPlugin = theArgVec[anArgIter++];
2341     aSaver  = theArgVec[anArgIter++];
2342     aLoader = theArgVec[anArgIter++];
2343   }
2344
2345   PCDM_StoreStatus  aSStatus = PCDM_SS_Failure;
2346   PCDM_ReaderStatus aRStatus = PCDM_RS_OpenError;
2347
2348   Handle(TDocStd_Application) anApp = new Test_TDocStd_Application (aPlugin, aSaver, aLoader);
2349   {
2350     Handle(TDocStd_Document) aDoc;
2351     anApp->NewDocument (THE_QATEST_DOC_FORMAT, aDoc);
2352     TDF_Label aLab = aDoc->Main();
2353     TDataStd_Integer::Set (aLab, 0);
2354     TDataStd_Name::Set (aLab, "QABugs_19.cxx");
2355
2356     aSStatus = anApp->SaveAs (aDoc, aFileName);
2357     anApp->Close (aDoc);
2358   }
2359   QA_CHECK ("SaveAs()", aSStatus == PCDM_SS_OK, true);
2360
2361   {
2362     Handle(TDocStd_Document) aDoc;
2363     aRStatus = anApp->Open (aFileName, aDoc);
2364     anApp->Close (aDoc);
2365   }
2366   QA_CHECK ("Open()  ", aRStatus == PCDM_RS_OK, true);
2367   return 0;
2368 }
2369
2370 //=======================================================================
2371 //function : OCC25043
2372 //purpose  :
2373 //=======================================================================
2374 #include <BRepAlgoAPI_Check.hxx>
2375 static Standard_Integer OCC25043 (Draw_Interpretor& theDI,
2376                                   Standard_Integer  theArgNb,
2377                                   const char**      theArgVec)
2378 {
2379   if (theArgNb != 2) {
2380     theDI << "Usage: " << theArgVec[0] << " shape\n";
2381     return 1;
2382   }
2383   
2384   TopoDS_Shape aShape = DBRep::Get(theArgVec[1]);
2385   if (aShape.IsNull()) 
2386   {
2387     theDI << theArgVec[1] << " shape is NULL\n";
2388     return 1;
2389   }
2390   
2391   BRepAlgoAPI_Check  anAlgoApiCheck(aShape, Standard_True, Standard_True);
2392
2393   if (!anAlgoApiCheck.IsValid())
2394   {
2395     BOPAlgo_ListIteratorOfListOfCheckResult anCheckIter(anAlgoApiCheck.Result());
2396     for (; anCheckIter.More(); anCheckIter.Next())
2397     {
2398       const BOPAlgo_CheckResult& aCurCheckRes = anCheckIter.Value();
2399       const BOPCol_ListOfShape& aCurFaultyShapes = aCurCheckRes.GetFaultyShapes1();
2400       BOPCol_ListIteratorOfListOfShape aFaultyIter(aCurFaultyShapes);
2401       for (; aFaultyIter.More(); aFaultyIter.Next())
2402       {
2403         const TopoDS_Shape& aFaultyShape = aFaultyIter.Value();
2404         
2405         Standard_Boolean anIsFaultyShapeFound = Standard_False;
2406         TopExp_Explorer anExp(aShape, aFaultyShape.ShapeType());
2407         for (; anExp.More() && !anIsFaultyShapeFound; anExp.Next())
2408         {
2409           if (anExp.Current().IsEqual(aFaultyShape))
2410             anIsFaultyShapeFound = Standard_True;
2411         }
2412         
2413         if (!anIsFaultyShapeFound)
2414         {
2415           theDI << "Error. Faulty Shape is NOT found in source shape.\n";
2416           return 0;
2417         }
2418         else 
2419         {
2420           theDI << "Info. Faulty shape is found in source shape\n";
2421         }
2422       }
2423     }
2424   }
2425   else 
2426   {
2427     theDI << "Problems are not detected. Test is not performed.";
2428   }
2429
2430   return 0;
2431 }
2432
2433 //=======================================================================
2434 //function : OCC24606
2435 //purpose  :
2436 //=======================================================================
2437 static Standard_Integer OCC24606 (Draw_Interpretor& theDI,
2438                                   Standard_Integer  theArgNb,
2439                                   const char**      theArgVec)
2440 {
2441   if (theArgNb > 1)
2442   {
2443     std::cerr << "Error: incorrect number of arguments.\n";
2444     theDI << "Usage : " << theArgVec[0] << "\n";
2445     return 1;
2446   }
2447
2448   Handle(V3d_View) aView = ViewerTest::CurrentView();
2449   if (aView.IsNull())
2450   {
2451     std::cerr << "Errro: no active view, please call 'vinit'.\n";
2452     return 1;
2453   }
2454
2455   aView->DepthFitAll();
2456   aView->FitAll();
2457
2458   return 0;
2459 }
2460
2461 //=======================================================================
2462 //function : OCC23010
2463 //purpose  :
2464 //=======================================================================
2465 #include <STEPCAFControl_Reader.hxx>
2466
2467 class mOcafApplication : public TDocStd_Application
2468 {
2469   void Formats(TColStd_SequenceOfExtendedString& Formats)
2470   {
2471     Formats.Append(TCollection_ExtendedString("mOcafApplication"));
2472   }
2473   Standard_CString ResourcesName()
2474   {
2475     return Standard_CString("Resources");
2476   }
2477 };
2478
2479 static Standard_Integer OCC23010 (Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
2480 {
2481   if (argc != 2) {
2482     di << "Usage: " << argv[0] << " invalid number of arguments\n";
2483     return 1;
2484   }
2485   std::string fileName=argv[1];
2486   mOcafApplication *mCasApp = new mOcafApplication();
2487   Handle(TDocStd_Document) doc;
2488   mCasApp->NewDocument("BinXCAF", doc);
2489   STEPCAFControl_Reader stepReader;
2490   IFSelect_ReturnStatus status = stepReader.ReadFile (fileName.c_str());
2491   if (status != IFSelect_RetDone)
2492     return false;
2493   stepReader.SetColorMode(Standard_True);
2494   stepReader.SetLayerMode(Standard_True);
2495   stepReader.SetNameMode(Standard_True);
2496   stepReader.Transfer(doc); // ERROR HERE!!!
2497   delete mCasApp;
2498   return 0;
2499 }
2500
2501 //=======================================================================
2502 //function : OCC25202
2503 //purpose  :
2504 //=======================================================================
2505 #include <ShapeBuild_ReShape.hxx>
2506 static Standard_Integer OCC25202 ( Draw_Interpretor& theDI,
2507                                    Standard_Integer theArgN,
2508                                    const char** theArgVal)
2509 {
2510   //  0      1    2     3     4     5     6 
2511   //reshape res shape numF1 face1 numF2 face2
2512   if(theArgN < 7)
2513     {
2514       theDI << "Use: reshape res shape numF1 face1 numF2 face2\n";
2515       return 1;
2516     }
2517
2518   TopoDS_Shape aShape = DBRep::Get(theArgVal[2]);
2519   const Standard_Integer  aNumOfRE1 = Draw::Atoi(theArgVal[3]),
2520                           aNumOfRE2 = Draw::Atoi(theArgVal[5]);
2521   TopoDS_Face aShapeForRepl1 = TopoDS::Face(DBRep::Get(theArgVal[4])),
2522               aShapeForRepl2 = TopoDS::Face(DBRep::Get(theArgVal[6]));
2523
2524   if(aShape.IsNull())
2525   {
2526     theDI << theArgVal[2] << " is null shape\n";
2527     return 1;
2528   }
2529
2530   if(aShapeForRepl1.IsNull())
2531   {
2532     theDI << theArgVal[4] << " is not a replaced type\n";
2533     return 1;
2534   }
2535
2536   if(aShapeForRepl2.IsNull())
2537   {
2538     theDI << theArgVal[6] << " is not a replaced type\n";
2539     return 1;
2540   }
2541
2542
2543   TopoDS_Shape aReplacedShape;
2544   ShapeBuild_ReShape aReshape;
2545
2546   //////////////////// explode (begin)
2547   TopTools_MapOfShape M;
2548   M.Add(aShape);
2549   Standard_Integer aNbShapes = 0;
2550   for (TopExp_Explorer ex(aShape,TopAbs_FACE); ex.More(); ex.Next())
2551     {
2552       const TopoDS_Shape& Sx = ex.Current();
2553       Standard_Boolean added = M.Add(Sx);
2554       if (added)
2555         {
2556           aNbShapes++;
2557           if(aNbShapes == aNumOfRE1)
2558             {
2559               aReplacedShape = Sx;
2560
2561               aReshape.Replace(aReplacedShape, aShapeForRepl1);
2562             }
2563
2564           if(aNbShapes == aNumOfRE2)
2565             {
2566               aReplacedShape = Sx;
2567
2568               aReshape.Replace(aReplacedShape, aShapeForRepl2);
2569             }
2570         }
2571     }
2572   //////////////////// explode (end)
2573
2574   if(aReplacedShape.IsNull())
2575     {
2576       theDI << "There is not any shape for replacing.\n";
2577     }
2578
2579   DBRep::Set (theArgVal[1],aReshape.Apply (aShape,TopAbs_WIRE,2));
2580
2581   return 0;
2582 }
2583
2584 #include <ShapeFix_Wireframe.hxx>
2585 //=======================================================================
2586 //function : OCC7570
2587 //purpose  : 
2588 //=======================================================================
2589 static Standard_Integer OCC7570 (Draw_Interpretor& di, Standard_Integer n, const char** a)
2590 {
2591   if (n != 2) {
2592     di<<"Usage: "<<a[0]<<" invalid number of arguments\n";
2593     return 1;
2594   }
2595   TopoDS_Shape in_shape (DBRep::Get (a[1]));
2596   ShapeFix_Wireframe fix_tool (in_shape);
2597   fix_tool.ModeDropSmallEdges () = Standard_True;
2598   fix_tool.SetPrecision (1.e+6);
2599   fix_tool.SetLimitAngle (0.01);
2600   fix_tool.FixSmallEdges ();
2601   TopoDS_Shape new_shape = fix_tool.Shape ();
2602   return 0;
2603 }
2604
2605 #include <AIS_TypeFilter.hxx>
2606 //=======================================================================
2607 //function : OCC25340
2608 //purpose  : 
2609 //=======================================================================
2610 static Standard_Integer OCC25340 (Draw_Interpretor& /*theDI*/,
2611                                  Standard_Integer  /*theArgNb*/,
2612                                  const char** /*theArgVec*/)
2613 {
2614   Handle(AIS_InteractiveContext) aCtx = ViewerTest::GetAISContext();
2615   if (aCtx.IsNull())
2616   {
2617     std::cerr << "Error: No opened viewer!\n";
2618     return 1;
2619   }
2620   Handle(AIS_TypeFilter) aFilter = new AIS_TypeFilter (AIS_KOI_Shape);
2621   aCtx->AddFilter (aFilter);
2622   return 0;
2623 }
2624
2625 //=======================================================================
2626 //function : OCC24826
2627 //purpose  :
2628 //=======================================================================
2629 class ParallelTest_Saxpy
2630 {
2631 public:
2632   typedef NCollection_Array1<Standard_Real> Vector;
2633
2634   //! Constructor
2635   ParallelTest_Saxpy(const Vector& theX, Vector& theY, Standard_Real theScalar)
2636   : myX(theX),
2637     myY(theY),
2638     myScalar(theScalar)
2639   {
2640   }
2641
2642   //! Dummy calculation
2643   void operator() (const Standard_Integer theIndex) const
2644   {
2645     myY(theIndex) = myScalar * myX(theIndex) + myY(theIndex);
2646   }
2647
2648 private:
2649   ParallelTest_Saxpy( const ParallelTest_Saxpy& );
2650   ParallelTest_Saxpy& operator =( ParallelTest_Saxpy& );
2651
2652 private:
2653   const Vector&       myX;
2654   Vector&             myY;
2655   const Standard_Real myScalar;
2656 };
2657
2658 //---------------------------------------------------------------------
2659 static Standard_Integer OCC24826(Draw_Interpretor& theDI,
2660                                  Standard_Integer  trheArgc,
2661                                  const char**      theArgv)
2662 {
2663   if ( trheArgc != 2 )
2664   {
2665     theDI << "Usage: "
2666           << theArgv[0]
2667           << " vec_length\n";
2668     return 1;
2669   }
2670
2671   // Generate data;
2672   Standard_Integer aLength = Draw::Atoi(theArgv[1]);
2673
2674   NCollection_Array1<Standard_Real> aX (0, aLength - 1);
2675   NCollection_Array1<Standard_Real> anY(0, aLength - 1);
2676
2677   for ( Standard_Integer i = 0; i < aLength; ++i )
2678   {
2679     aX(i) = anY(i) = (Standard_Real) i;
2680   }
2681
2682   OSD_Timer aTimer;
2683
2684   aTimer.Start();
2685
2686   //! Serial proccesing
2687   for ( Standard_Integer i = 0; i < aLength; ++i )
2688   {
2689     anY(i) = 1e-6 * aX(i) + anY(i);
2690   }
2691
2692   aTimer.Stop();
2693   cout << "Processing time (sequential mode):\n";
2694   aTimer.Show();
2695
2696   const ParallelTest_Saxpy aFunctor(aX, anY, 1e-6);
2697
2698   aTimer.Reset();
2699   aTimer.Start();
2700
2701   // Parallel processing
2702   OSD_Parallel::For(0, aLength, aFunctor);
2703
2704   aTimer.Stop();
2705   cout << "Processing time (parallel mode):\n";
2706   aTimer.Show();
2707
2708   return 0;
2709 }
2710
2711 /*****************************************************************************/
2712
2713 #include <GeomAPI_IntSS.hxx>
2714 //=======================================================================
2715 //function : OCC25100
2716 //purpose  :
2717 //=======================================================================
2718 static Standard_Integer OCC25100 (Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
2719 {
2720   if (argc < 2)
2721   {
2722     di << "the method requires a shape name\n";
2723     return 1;
2724   }
2725
2726   TopoDS_Shape S = DBRep::Get(argv[1]);
2727   if ( S.IsNull() )
2728   {
2729     di << "Shape is empty\n";
2730     return 1;
2731   }
2732   
2733   TopExp_Explorer aFaceExp(S, TopAbs_FACE);
2734   const Handle(Geom_Surface)& aSurf = BRep_Tool::Surface(TopoDS::Face(aFaceExp.Current()));
2735
2736   GeomAPI_IntSS anIntersector(aSurf, aSurf, Precision::Confusion());
2737
2738   if (!anIntersector.IsDone())
2739   {
2740     di << "Error. Intersection is not done\n";
2741     return 1;
2742   }
2743
2744   di << "Test complete\n";
2745
2746   return 0;
2747 }
2748
2749 //=======================================================================
2750 //function : OCC25348
2751 //purpose  : 
2752 //=======================================================================
2753 static Standard_Integer OCC25348 (Draw_Interpretor& theDI,
2754                                  Standard_Integer  /*theArgNb*/,
2755                                  const char** /*theArgVec*/)
2756 {
2757   Handle(NCollection_IncAllocator) anAlloc1;
2758   NCollection_List<int> aList1(anAlloc1);
2759   for (int i=0; i < 10; i++)
2760   {
2761     Handle(NCollection_IncAllocator) anAlloc2;
2762     NCollection_List<int> aList2(anAlloc2);
2763     aList2.Append(i);
2764     aList1.Assign(aList2);
2765   }
2766   theDI << "Test complete\n";
2767   return 0;
2768 }
2769
2770 #include <IntCurvesFace_ShapeIntersector.hxx>
2771 #include <BRepBndLib.hxx>
2772 //=======================================================================
2773 //function : OCC25413
2774 //purpose  : 
2775 //=======================================================================
2776 static Standard_Integer OCC25413 (Draw_Interpretor& di, Standard_Integer narg , const char** a)
2777 {
2778   if (narg != 2) {
2779     di << "Usage: " << a[0] << " invalid number of arguments\n";
2780     return 1;
2781   }
2782   TopoDS_Shape aShape = DBRep::Get (a[1]);
2783
2784   IntCurvesFace_ShapeIntersector Inter;
2785   Inter.Load(aShape, Precision::Confusion());
2786
2787   Bnd_Box aBndBox;
2788   BRepBndLib::Add(aShape, aBndBox);
2789
2790   gp_Dir aDir(0., 1., 0.);
2791   const int N = 250;
2792   Standard_Real xMin = aBndBox.CornerMin().X();
2793   Standard_Real zMin = aBndBox.CornerMin().Z();
2794   Standard_Real xMax = aBndBox.CornerMax().X();
2795   Standard_Real zMax = aBndBox.CornerMax().Z();
2796   Standard_Real xStep = (xMax - xMin) / N;
2797   Standard_Real zStep = (zMax - zMin) / N;
2798
2799   for (Standard_Real x = xMin; x <= xMax; x += xStep)
2800     for (Standard_Real z = zMin; z <= zMax; z += zStep)
2801     {
2802       gp_Pnt aPoint(x, 0.0, z);
2803       gp_Lin aLine(aPoint, aDir);
2804       Inter.PerformNearest(aLine, -100., 100.);
2805     }
2806   return 0;
2807 }
2808
2809
2810 #include <BOPAlgo_PaveFiller.hxx>
2811 //
2812 #include <BRepAlgoAPI_BooleanOperation.hxx>
2813 #include <BRepAlgoAPI_Common.hxx>
2814 #include <BRepAlgoAPI_Fuse.hxx>
2815 #include <BRepAlgoAPI_Cut.hxx>
2816 #include <BRepAlgoAPI_Section.hxx>
2817 //
2818 #include <BOPTools.hxx>
2819 //
2820 #include <BOPCol_MapOfShape.hxx>
2821 #include <BOPCol_ListOfShape.hxx>
2822 //=======================================================================
2823 //function : OCC25446
2824 //purpose  :
2825 //=======================================================================
2826 static Standard_Integer OCC25446 (Draw_Interpretor& theDI, 
2827                                   Standard_Integer argc, 
2828                                   const char ** argv)
2829 {
2830   if (argc != 5) {
2831     theDI << "Usage: OCC25446 res b1 b2 op\n";
2832     return 1;
2833   }
2834   //
2835   TopoDS_Shape aS1 = DBRep::Get(argv[2]);
2836   if (aS1.IsNull()) {
2837     theDI << argv[2] << " shape is NULL\n";
2838     return 1;
2839   }
2840   //
2841   TopoDS_Shape aS2 = DBRep::Get(argv[3]);
2842   if (aS2.IsNull()) {
2843     theDI << argv[3] << " shape is NULL\n";
2844     return 1;
2845   }
2846   //
2847   Standard_Integer iOp;
2848   BOPAlgo_Operation aOp;
2849   //
2850   iOp = Draw::Atoi(argv[4]);
2851   if (iOp < 0 || iOp > 4) {
2852     theDI << "Invalid operation type\n";
2853     return 1;
2854   }
2855   aOp = (BOPAlgo_Operation)iOp;
2856   //
2857   Standard_Integer iErr;
2858   BOPCol_ListOfShape aLS;
2859   BOPAlgo_PaveFiller aPF;
2860   //
2861   aLS.Append(aS1);
2862   aLS.Append(aS2);
2863   aPF.SetArguments(aLS);
2864   //
2865   aPF.Perform();
2866   iErr = aPF.ErrorStatus();
2867   if (iErr) {
2868     theDI << "Intersection failed with error status: " << iErr << "\n";
2869     return 1;
2870   }
2871   //
2872   BRepAlgoAPI_BooleanOperation* pBuilder = NULL;
2873   // 
2874   switch (aOp) {
2875   case BOPAlgo_COMMON:
2876     pBuilder = new BRepAlgoAPI_Common(aS1, aS2, aPF);
2877     break;
2878   case BOPAlgo_FUSE:
2879     pBuilder = new BRepAlgoAPI_Fuse(aS1, aS2, aPF);
2880     break;
2881   case BOPAlgo_CUT:
2882     pBuilder = new BRepAlgoAPI_Cut (aS1, aS2, aPF);
2883     break;
2884   case BOPAlgo_CUT21:
2885     pBuilder = new BRepAlgoAPI_Cut(aS1, aS2, aPF, Standard_False);
2886     break;
2887   case BOPAlgo_SECTION:
2888     pBuilder = new BRepAlgoAPI_Section(aS1, aS2, aPF);
2889     break;
2890   default:
2891     break;
2892   }
2893   //
2894   iErr = pBuilder->ErrorStatus();
2895   if (!pBuilder->IsDone()) {
2896     theDI << "BOP failed with error status: " << iErr << "\n";
2897     return 1;
2898   }
2899   //
2900   const TopoDS_Shape& aRes = pBuilder->Shape();
2901   DBRep::Set(argv[1], aRes);
2902   //
2903   BOPCol_MapOfShape aMapArgs, aMapShape;
2904   BOPCol_MapIteratorOfMapOfShape aIt;
2905   Standard_Boolean bIsDeletedHist, bIsDeletedMap;
2906   TopAbs_ShapeEnum aType;
2907   //
2908   BOPTools::MapShapes(aS1, aMapArgs);
2909   BOPTools::MapShapes(aS2, aMapArgs);
2910   BOPTools::MapShapes(aRes, aMapShape);
2911   //
2912   aIt.Initialize(aMapArgs);
2913   for (; aIt.More(); aIt.Next()) {
2914     const TopoDS_Shape& aS = aIt.Value();
2915     aType = aS.ShapeType();
2916     if (!(aType==TopAbs_EDGE || aType==TopAbs_FACE || 
2917           aType==TopAbs_VERTEX || aType==TopAbs_SOLID)) {
2918       continue;
2919     }
2920     //
2921     bIsDeletedHist = pBuilder->IsDeleted(aS);
2922     bIsDeletedMap = !aMapShape.Contains(aS) &&
2923       (pBuilder->Modified(aS).Extent() == 0);
2924     //
2925     if (bIsDeletedHist != bIsDeletedMap) {
2926       theDI << "Error. Wrong value of IsDeleted flag.\n";
2927       return 1;
2928     }
2929   }
2930   //
2931   theDI << "Test complete\n";
2932   return 0;
2933 }
2934
2935 //====================================================
2936 // Auxiliary functor class for the command OCC25545;
2937 // it gets access to a vertex with the given index and
2938 // checks that X coordinate of the point is equal to index;
2939 // if it is not so then a data race is reported.
2940 //====================================================
2941 struct OCC25545_Functor
2942 {
2943   OCC25545_Functor(const std::vector<TopoDS_Shape>& theShapeVec)
2944     : myShapeVec(&theShapeVec),
2945       myIsRaceDetected(0)
2946   {}
2947
2948   void operator()(size_t i) const
2949   {
2950     if (!myIsRaceDetected) {
2951       const TopoDS_Vertex& aV = TopoDS::Vertex (myShapeVec->at(i));
2952       gp_Pnt aP = BRep_Tool::Pnt (aV);
2953       if (aP.X () != static_cast<double> (i)) {
2954         Standard_Atomic_Increment(&myIsRaceDetected);
2955       }
2956     }
2957   }
2958
2959   const std::vector<TopoDS_Shape>* myShapeVec;
2960   mutable volatile int myIsRaceDetected;
2961 };
2962
2963 //=======================================================================
2964 //function : OCC25545
2965 //purpose  : Tests data race when concurrently accessing TopLoc_Location::Transformation()
2966 //=======================================================================
2967 #ifdef HAVE_TBB
2968 static Standard_Integer OCC25545 (Draw_Interpretor& di, 
2969                                   Standard_Integer, 
2970                                   const char **)
2971 {
2972   // Place vertices in a vector, giving the i-th vertex the
2973   // transformation that translates it on the vector (i,0,0) from the origin.
2974   size_t n = 1000;
2975   std::vector<TopoDS_Shape> aShapeVec (n);
2976   std::vector<TopLoc_Location> aLocVec (n);
2977   TopoDS_Shape aShape = BRepBuilderAPI_MakeVertex (gp::Origin ());
2978   aShapeVec[0] = aShape;
2979   for (size_t i = 1; i < n; ++i) {
2980     gp_Trsf aT;
2981     aT.SetTranslation (gp_Vec (1, 0, 0));
2982     aLocVec[i] = aLocVec[i - 1] * aT;
2983     aShapeVec[i] = aShape.Moved (aLocVec[i]);
2984   }
2985
2986   // Evaluator function will access vertices geometry
2987   // concurrently
2988   OCC25545_Functor aFunc(aShapeVec);
2989
2990   //concurrently process
2991   tbb::parallel_for (size_t (0), n, aFunc, tbb::simple_partitioner ());
2992   QVERIFY (!aFunc.myIsRaceDetected);
2993   return 0;
2994 }
2995 #else
2996 static Standard_Integer OCC25545 (Draw_Interpretor&, 
2997                                   Standard_Integer, 
2998                                   const char **argv)
2999 {
3000   cout << "Test skipped: command " << argv[0] << " requires TBB library" << endl;
3001   return 0;
3002 }
3003 #endif
3004
3005 //=======================================================================
3006 //function : OCC25547
3007 //purpose  :
3008 //=======================================================================
3009 #include <BRepMesh_GeomTool.hxx>
3010 #include <BRepAdaptor_Curve.hxx>
3011 #include <Geom_TrimmedCurve.hxx>
3012 #include <BRepBuilderAPI_MakeFace.hxx>
3013 #include <BRepAdaptor_HSurface.hxx>
3014 #include <BRepAdaptor_Surface.hxx>
3015 static Standard_Integer OCC25547(
3016   Draw_Interpretor& theDI, 
3017   Standard_Integer  /*argc*/, 
3018   const char **     /*argv*/)
3019 {
3020   // The general aim of this test is to prevent linkage errors due to missed
3021   // Standard_EXPORT attribute for static methods.
3022
3023   // However, start checking the main functionality at first.
3024   const Standard_Real aFirstP = 0., aLastP = M_PI;
3025   Handle(Geom_Circle) aCircle = new Geom_Circle(gp_Ax2(gp::Origin(), gp::DZ()), 10);
3026   Handle(Geom_TrimmedCurve) aHalf = new Geom_TrimmedCurve(aCircle, aFirstP, aLastP);
3027   TopoDS_Edge aEdge = BRepBuilderAPI_MakeEdge(aHalf);
3028   BRepAdaptor_Curve aAdaptor(aEdge);
3029   BRepMesh_GeomTool aGeomTool(aAdaptor, aFirstP, aLastP, 0.1, 0.5);
3030
3031   if (aGeomTool.NbPoints() == 0)
3032   {
3033     theDI << "Error. BRepMesh_GeomTool failed to discretize an arc.\n";
3034     return 1;
3035   }
3036
3037   // Test static methods.
3038   TopoDS_Face aFace = BRepBuilderAPI_MakeFace(gp_Pln(gp::Origin(), gp::DZ()));
3039   BRepAdaptor_Surface aSurf(aFace);
3040   Handle(BRepAdaptor_HSurface) aHSurf = new BRepAdaptor_HSurface(aSurf);
3041
3042   gp_Pnt aPnt;
3043   gp_Dir aNormal;
3044   if (!BRepMesh_GeomTool::Normal(aHSurf, 10., 10., aPnt, aNormal))
3045   {
3046     theDI << "Error. BRepMesh_GeomTool failed to take a normal of surface.\n";
3047     return 1;
3048   }
3049
3050   gp_XY aRefPnts[4] = {
3051     gp_XY(-10., -10.), gp_XY(10., 10.), 
3052     gp_XY(-10., 10.), gp_XY(10., -10.)
3053   };
3054
3055   gp_Pnt2d aIntPnt;
3056   Standard_Real aParams[2];
3057   BRepMesh_GeomTool::IntFlag aIntFlag = BRepMesh_GeomTool::IntLinLin(
3058     aRefPnts[0], aRefPnts[1], aRefPnts[2], aRefPnts[3], 
3059     aIntPnt.ChangeCoord(), aParams);
3060
3061   Standard_Real aDiff = aIntPnt.Distance(gp::Origin2d());
3062   if (aIntFlag != BRepMesh_GeomTool::Cross || aDiff > Precision::PConfusion())
3063   {
3064     theDI << "Error. BRepMesh_GeomTool failed to intersect two lines.\n";
3065     return 1;
3066   }
3067
3068   aIntFlag = BRepMesh_GeomTool::IntSegSeg(
3069     aRefPnts[0], aRefPnts[1], aRefPnts[2], aRefPnts[3], 
3070     Standard_False, Standard_False, aIntPnt);
3071
3072   aDiff = aIntPnt.Distance(gp::Origin2d());
3073   if (aIntFlag != BRepMesh_GeomTool::Cross || aDiff > Precision::PConfusion())
3074   {
3075     theDI << "Error. BRepMesh_GeomTool failed to intersect two segments.\n";
3076     return 1;
3077   }
3078
3079
3080   theDI << "Test complete\n";
3081   return 0;
3082 }
3083
3084 static Standard_Integer OCC26139 (Draw_Interpretor& theDI,
3085                                   Standard_Integer  argc,
3086                                   const char **     argv)
3087 {
3088
3089   Handle(AIS_InteractiveContext) aCtx = ViewerTest::GetAISContext();
3090   if (aCtx.IsNull())
3091   {
3092     theDI << "Use 'vinit' command before " << argv[0] << "\n";
3093     return 1;
3094   }
3095
3096   Standard_Integer aBoxGridSize = 100;
3097   Standard_Integer aCompGridSize = 3;
3098   Standard_Real aBoxSize = 5.0;
3099
3100   if (argc > 1)
3101   {
3102     for (Standard_Integer anArgIdx = 1; anArgIdx < argc; ++anArgIdx)
3103     {
3104       TCollection_AsciiString anArg (argv[anArgIdx]);
3105       anArg.LowerCase();
3106       if (anArg == "-boxgrid")
3107       {
3108         aBoxGridSize = Draw::Atoi (argv[++anArgIdx]);
3109       }
3110       else if (anArg == "-compgrid")
3111       {
3112         aCompGridSize = Draw::Atoi (argv[++anArgIdx]);
3113       }
3114       else if (anArg == "-boxsize")
3115       {
3116         aBoxSize = Draw::Atof (argv[++anArgIdx]);
3117       }
3118     }
3119   }
3120
3121   NCollection_List<Handle(AIS_Shape)> aCompounds;
3122   for (Standard_Integer aCompGridX = 0; aCompGridX < aCompGridSize; ++aCompGridX)
3123   {
3124     for (Standard_Integer aCompGridY = 0; aCompGridY < aCompGridSize; ++aCompGridY)
3125     {
3126       BRep_Builder aBuilder;
3127       TopoDS_Compound aComp;
3128       aBuilder.MakeCompound (aComp);
3129       for (Standard_Integer aBoxGridX = 0; aBoxGridX < aBoxGridSize; ++aBoxGridX)
3130       {
3131         for (Standard_Integer aBoxGridY = 0; aBoxGridY < aBoxGridSize; ++aBoxGridY)
3132         {
3133           BRepPrimAPI_MakeBox aBox (gp_Pnt (aBoxGridX * aBoxSize, aBoxGridY * aBoxSize, 0.0),
3134                                     aBoxSize, aBoxSize, aBoxSize);
3135           aBuilder.Add (aComp, aBox.Shape());
3136         }
3137       }
3138       gp_Trsf aTrsf;
3139       aTrsf.SetTranslation (gp_Vec (aBoxGridSize * aBoxSize * aCompGridX,
3140                                     aBoxGridSize * aBoxSize * aCompGridY,
3141                                     0.0));
3142       TopLoc_Location aLoc (aTrsf);
3143       aComp.Located (aLoc);
3144       aCompounds.Append (new AIS_Shape (aComp));
3145     }
3146   }
3147
3148   OSD_Timer aTimer;
3149   for (NCollection_List<Handle(AIS_Shape)>::Iterator aCompIter (aCompounds); aCompIter.More(); aCompIter.Next())
3150   {
3151     aTimer.Start();
3152     aCtx->Display (aCompIter.Value(), Standard_False);
3153     aTimer.Stop();
3154     theDI << "Display time: " << aTimer.ElapsedTime() << "\n";
3155     aTimer.Reset();
3156   }
3157
3158   aTimer.Reset();
3159   aTimer.Start();
3160   for (NCollection_List<Handle(AIS_Shape)>::Iterator aCompIter (aCompounds); aCompIter.More(); aCompIter.Next())
3161   {
3162     aCtx->Remove (aCompIter.Value(), Standard_False);
3163   }
3164   aTimer.Stop();
3165   theDI << "Remove time: " << aTimer.ElapsedTime() << "\n";
3166
3167   return 0;
3168 }
3169
3170 #include <TColStd_DataMapIteratorOfDataMapOfIntegerInteger.hxx>
3171 #include <TColStd_DataMapOfIntegerInteger.hxx>
3172 #include <OSD.hxx>
3173 #include <ShapeFix_Wire.hxx>
3174 #include <ShapeExtend_Status.hxx>
3175 #ifdef _WIN32
3176 #define EXCEPTION ...
3177 #else
3178 #define EXCEPTION Standard_Failure
3179 #endif
3180
3181 static ShapeExtend_Status getStatusGap(const Handle(ShapeFix_Wire)&   theFix,
3182                                        const Standard_Boolean theIs3d)
3183 {
3184         for (Standard_Integer i=ShapeExtend_OK; i<=ShapeExtend_FAIL; i++)
3185         {
3186                 Standard_Boolean isFound;
3187                 if (theIs3d)
3188                         isFound = theFix->StatusGaps3d( (ShapeExtend_Status) i );
3189                 else
3190                         isFound = theFix->StatusGaps2d( (ShapeExtend_Status) i );
3191                 if (isFound) return ShapeExtend_Status(i);
3192         }
3193         return ShapeExtend_OK;
3194 }
3195
3196 //===================
3197 //function : OCC24881
3198 //purpose  : 
3199 //===================
3200 static Standard_Integer OCC24881 (Draw_Interpretor& di, Standard_Integer narg , const char** a)
3201 {
3202   if (narg < 2) {
3203     di<<"Usage: "<<a[0]<<" invalid number of arguments\n";
3204     return 1;
3205   }
3206 //    cout <<"FileName1: " << argv[1] <<endl;
3207
3208   TopoDS_Shape aShape = DBRep::Get (a[1]);
3209
3210     OSD::SetSignal();
3211     Handle(ShapeFix_Wire) aWireFix = new ShapeFix_Wire;
3212
3213     // map FixStatus - NbSuchStatuses
3214     TColStd_DataMapOfIntegerInteger aStatusNbDMap;
3215     Standard_Integer nbFixed=0, nbOk=0;
3216
3217 //Begin: STEP 7
3218     ShapeExtend_Status aStatus=ShapeExtend_OK;
3219     try {
3220         TopExp_Explorer aFaceExplorer(aShape, TopAbs_FACE);
3221         for (; aFaceExplorer.More(); aFaceExplorer.Next())
3222         {
3223                 TopoDS_Shape aFace = aFaceExplorer.Current();
3224                 // loop on wires
3225                 TopoDS_Iterator aWireItr(aFace);
3226                 for (; aWireItr.More(); aWireItr.Next() )
3227                 {
3228                         Standard_Boolean wasOk = Standard_False;
3229                         TopoDS_Wire aSrcWire = TopoDS::Wire(aWireItr.Value());
3230
3231                         aWireFix->Load (aSrcWire);
3232                         aWireFix->SetFace (TopoDS::Face(aFace));
3233                         aWireFix->FixReorder(); //correct order is a prerequisite
3234                         // fix 3d
3235                         if (!aWireFix->FixGaps3d())
3236                         {
3237                                 // not fixed, why?
3238                                 aStatus = getStatusGap(aWireFix, Standard_True);
3239                                 if (aStatus == ShapeExtend_OK)
3240                                         wasOk = Standard_True;
3241                                 else
3242                                 {
3243                                         // keep 3d fail status
3244                                         if (aStatusNbDMap.IsBound (aStatus))
3245                                                 aStatusNbDMap(aStatus)++;
3246                                         else
3247                                                 aStatusNbDMap.Bind(aStatus,1);
3248                                         continue;
3249                                 }
3250                         }
3251
3252                         // fix 2d
3253                         if (aWireFix->FixGaps2d())
3254                                 nbFixed++;
3255                         else
3256                         {
3257                                 aStatus = getStatusGap(aWireFix, Standard_False);
3258                                 if (aStatus == ShapeExtend_OK)
3259                                 {
3260                                         if (wasOk)
3261                                         {
3262                                                 nbOk++;
3263                                                 continue;
3264                                         }
3265                                         else
3266                                                 nbFixed++;
3267                                 }
3268                                 else
3269                                 {
3270                                         // keep 2d fail status
3271                                         Standard_Integer aStatus2d = aStatus + ShapeExtend_FAIL;
3272                                         if (aStatusNbDMap.IsBound (aStatus2d))
3273                                                 aStatusNbDMap(aStatus2d)++;
3274                                         else
3275                                                 aStatusNbDMap.Bind(aStatus2d,1);
3276                                         continue;
3277                                 }
3278                         }
3279                 }
3280         }
3281 //End: STEP 7
3282      } catch (EXCEPTION) {
3283        di << "Exception is raised = " <<aStatus << "\n";
3284        return 1;
3285
3286      }
3287 // report what is done
3288
3289         if (nbFixed)
3290         {
3291                 di <<"Fix_FillGaps_Fixed: nbFixed = "<<nbFixed <<"\n";
3292
3293         }    
3294         if (nbOk)
3295         {
3296                 di << "Fix_FillGaps_NothingToDo\n";
3297
3298         }
3299         TColStd_DataMapIteratorOfDataMapOfIntegerInteger aStatusItr(aStatusNbDMap);
3300         for (; aStatusItr.More(); aStatusItr.Next()) 
3301         {
3302                 switch ((ShapeExtend_Status) aStatusItr.Key()) 
3303                 {
3304                         // treat 3d status
3305                         case ShapeExtend_FAIL1:
3306                         di <<"Fix_FillGaps_3dNoCurveFail, nb failed = ";
3307                         break;
3308                         case ShapeExtend_FAIL2:
3309                         di <<"Fix_FillGaps_3dSomeGapsFail, nb failed = ";
3310                         break;
3311                         default:
3312                         // treat 2d status
3313                         switch ((ShapeExtend_Status) (aStatusItr.Key() - ShapeExtend_FAIL)) 
3314                         {
3315                                 case ShapeExtend_FAIL1:
3316                                 di <<"Fix_FillGaps_2dNoPCurveFail, nb failed = ";
3317                                 break;
3318                                 case ShapeExtend_FAIL2:
3319                                 di <<"Fix_FillGaps_2dSomeGapsFail, nb failed = ";
3320                                 break;
3321                                 default:
3322                                 break;
3323                         }
3324                 }
3325                 di <<aStatusItr.Value()<< "\n";
3326         }
3327         di << ("__________________________________") <<"\n";
3328
3329   return 0;
3330 }
3331
3332 //=======================================================================
3333 //function : OCC26172
3334 //purpose  :
3335 //=======================================================================
3336 static Standard_Integer OCC26172 (Draw_Interpretor& theDI, Standard_Integer theArgNb, const char** theArgVec)
3337 {
3338   if (theArgNb != 1)
3339   {
3340     std::cerr << "Error: wrong number of arguments! See usage:\n";
3341     theDI.PrintHelp (theArgVec[0]);
3342     return 1;
3343   }
3344
3345   Handle(AIS_InteractiveContext) anAISContext = ViewerTest::GetAISContext();
3346   if(anAISContext.IsNull())
3347   {
3348     std::cerr << "Error: no active view. Please call vinit.\n";
3349     return 1;
3350   }
3351
3352   gp_Pnt aStart (100, 100, 100);
3353   gp_Pnt anEnd (300, 400, 600);
3354   BRepBuilderAPI_MakeEdge anEdgeBuilder (aStart, anEnd);
3355   TopoDS_Edge anEdge = anEdgeBuilder.Edge();
3356   Handle(AIS_Shape) aTestAISShape = new AIS_Shape (anEdge);
3357   anAISContext->Display (aTestAISShape);
3358
3359   // 2. activate it in selection modes
3360   TColStd_SequenceOfInteger aModes;
3361   aModes.Append (AIS_Shape::SelectionMode ((TopAbs_ShapeEnum) TopAbs_VERTEX));
3362   aModes.Append (AIS_Shape::SelectionMode ((TopAbs_ShapeEnum) TopAbs_EDGE));
3363
3364   anAISContext->OpenLocalContext();
3365   anAISContext->Deactivate (aTestAISShape);
3366   anAISContext->Load (aTestAISShape, -1, true);
3367   for (Standard_Integer anIt = 1; anIt <= aModes.Length(); ++anIt)
3368   {
3369     anAISContext->Activate (aTestAISShape, aModes (anIt));
3370   }
3371
3372   // select entities in vertex selection mode
3373   Handle(SelectMgr_Selection) aSelection = aTestAISShape->Selection (aModes (1));
3374   for (aSelection->Init(); aSelection->More(); aSelection->Next())
3375   {
3376     Handle(SelectBasics_SensitiveEntity) anEntity = aSelection->Sensitive()->BaseSensitive();
3377     if (anEntity.IsNull())
3378     {
3379       continue;
3380     }
3381
3382     Handle(SelectMgr_EntityOwner) anOwner =
3383       Handle(SelectMgr_EntityOwner)::DownCast (anEntity->OwnerId());
3384
3385     if (anOwner.IsNull())
3386     {
3387       continue;
3388     }
3389
3390     anAISContext->LocalContext()->AddOrRemoveSelected (anOwner);
3391   }
3392
3393   // select entities in edge selection mode
3394   aSelection = aTestAISShape->Selection (aModes (2));
3395   for (aSelection->Init(); aSelection->More(); aSelection->Next())
3396   {
3397     Handle(SelectBasics_SensitiveEntity) anEntity = aSelection->Sensitive()->BaseSensitive();
3398     if (anEntity.IsNull())
3399     {
3400       continue;
3401     }
3402
3403     Handle(SelectMgr_EntityOwner) anOwner =
3404       Handle(SelectMgr_EntityOwner)::DownCast (anEntity->OwnerId());
3405
3406     if (anOwner.IsNull())
3407     {
3408       continue;
3409     }
3410
3411     anAISContext->LocalContext()->AddOrRemoveSelected (anOwner);
3412   }
3413
3414   // deactivate vertex mode and check clearing of outdated selection
3415   anAISContext->Deactivate (aTestAISShape, aModes (1));
3416   anAISContext->LocalContext()->ClearOutdatedSelection (aTestAISShape, true);
3417
3418   return 0;
3419 }
3420
3421 //=======================================================================
3422 //function : OCC26284
3423 //purpose  :
3424 //=======================================================================
3425 static Standard_Integer OCC26284 (Draw_Interpretor& theDI, Standard_Integer theArgNb, const char** theArgVec)
3426 {
3427   if (theArgNb != 1)
3428   {
3429     std::cerr << "Error: wrong number of arguments! See usage:\n";
3430     theDI.PrintHelp (theArgVec[0]);
3431     return 1;
3432   }
3433
3434   Handle(AIS_InteractiveContext) anAISContext = ViewerTest::GetAISContext();
3435   if (anAISContext.IsNull())
3436   {
3437     std::cerr << "Error: no active view. Please call vinit.\n";
3438     return 1;
3439   }
3440
3441   BRepPrimAPI_MakeSphere aSphereBuilder (gp_Pnt (0.0, 0.0, 0.0), 1.0);
3442   Handle(AIS_Shape) aSphere = new AIS_Shape (aSphereBuilder.Shape());
3443   anAISContext->Display (aSphere);
3444   for (Standard_Integer aChildIdx = 0; aChildIdx < 5; ++aChildIdx)
3445   {
3446     BRepPrimAPI_MakeSphere aBuilder (gp_Pnt (1.0 + aChildIdx, 1.0 + aChildIdx, 1.0 + aChildIdx), 1.0);
3447     Handle(AIS_Shape) aChild = new AIS_Shape (aBuilder.Shape());
3448     aSphere->AddChild (aChild);
3449     anAISContext->Display (aChild);
3450   }
3451
3452   anAISContext->RecomputeSelectionOnly (aSphere);
3453
3454   return 0;
3455 }
3456
3457 #include <IntTools_Context.hxx>
3458 #include <GeomAPI_ProjectPointOnSurf.hxx>
3459
3460 //=======================================================================
3461 //function : xprojponf
3462 //purpose  : 
3463 //=======================================================================
3464 Standard_Integer xprojponf (Draw_Interpretor& di, 
3465                             Standard_Integer n, 
3466                             const char** a)
3467 {
3468   if (n!=3) {
3469     di<<" use xprojponf p f \n";
3470     return 0;
3471   }
3472   // 
3473   gp_Pnt aP, aPS;
3474   TopoDS_Shape aS;
3475   TopoDS_Face aF;
3476   Handle(IntTools_Context) aCtx;
3477   //
3478   DrawTrSurf::GetPoint(a[1], aP);
3479   aS=DBRep::Get(a[2]);
3480   //
3481   if (aS.IsNull()) {
3482     di<<" null shape is not allowed\n";
3483     return 0;
3484   }
3485   //
3486   if (aS.ShapeType()!=TopAbs_FACE) {
3487     di << a[2] << " not a face\n";
3488     return 0;
3489   }
3490   //
3491   aCtx=new IntTools_Context;
3492   //
3493   aF=TopoDS::Face(aS);
3494   GeomAPI_ProjectPointOnSurf& aPPS=aCtx->ProjPS(aF);
3495   //
3496   aPPS.Perform(aP);
3497   if (!aPPS.IsDone()) {
3498     di<<" projection failed\n";
3499     return 0;
3500   }
3501   //
3502   aPS=aPPS.NearestPoint();
3503   di<< " point px " << aPS.X() << " " << aPS.Y() << " " <<  aPS.Z() << "\n";
3504   //
3505   return 0;
3506 }
3507
3508 //=======================================================================
3509 //function : OCC25547
3510 //purpose  :
3511 //=======================================================================
3512 #include <BRepMesh_CircleTool.hxx>
3513 #include <SelectMgr_EntityOwner.hxx>
3514
3515 static Standard_Boolean inspect_point(const gp_XY&        thePoint,
3516                                       const gp_XY&        theCenter,
3517                                       const Standard_Real theRadius)
3518 {
3519   static Standard_Real aPrecision   = Precision::PConfusion();
3520   static Standard_Real aSqPrecision = aPrecision * aPrecision;
3521   const gp_XY aDistVec = thePoint - theCenter;
3522   if (aDistVec.SquareModulus() - (theRadius * theRadius) < aSqPrecision)
3523     return Standard_True;
3524   else
3525     return Standard_False;
3526 }
3527
3528 static Standard_Integer OCC24923(
3529   Draw_Interpretor& theDI, 
3530   Standard_Integer  argc, 
3531   const char **     argv)
3532 {
3533   srand(static_cast<unsigned int>(time(NULL)));
3534
3535   const Standard_Real    aMaxDeviation = (argc > 1) ? Draw::Atof(argv[1]) : 0.01;
3536   const Standard_Integer aPointsNb     = 10000000;
3537   const Standard_Real    aMinAngle     = 5 * M_PI / 180.;
3538   static Standard_Real   aSqPrecision  = Precision::PConfusion() * Precision::PConfusion();
3539
3540   Standard_Integer aFailedNb = 0;
3541   for (Standard_Integer i = 0; i < aPointsNb; ++i)
3542   {
3543     gp_XY p[3];
3544     for (Standard_Integer j = 0; j < 3; ++j)
3545       p[j].SetCoord(((Standard_Real)rand())/RAND_MAX, ((Standard_Real)rand())/RAND_MAX);
3546
3547     // Check that points do not compose degenerated triangle.
3548     gp_XY aVec1 = p[1] - p[0];
3549     gp_XY aVec2 = p[2] - p[0];
3550     if (aVec1.SquareModulus() > aSqPrecision && 
3551         aVec2.SquareModulus() > aSqPrecision &&
3552         (aVec1 ^ aVec2) > aMinAngle)
3553     {
3554       gp_XY aCenter;
3555       Standard_Real aRadius;
3556       if (BRepMesh_CircleTool::MakeCircle(p[0], p[1], p[2], aCenter, aRadius))
3557       {
3558         if (!inspect_point(p[0], aCenter, aRadius) || 
3559             !inspect_point(p[1], aCenter, aRadius) || 
3560             !inspect_point(p[2], aCenter, aRadius))
3561         {
3562          /* theDI << "Missed: " <<
3563             "p1=(" << p1.X() << ", " << p1.Y() << "), " <<
3564             "p2=(" << p2.X() << ", " << p2.Y() << "), " <<
3565             "p3=(" << p3.X() << ", " << p3.Y() << "), " <<
3566             "c=(" << aCenter.X() << ", " << aCenter.Y() << "), " <<
3567             "r=" << aRadius << "\n";*/
3568             
3569           ++aFailedNb;
3570         }
3571
3572         continue;
3573       }
3574     }
3575
3576     // Ensure that aPointsNb suitable for tests are generated
3577     --i;
3578   }
3579
3580   const Standard_Real aDeviation = 
3581     1. - (Standard_Real)(aPointsNb - aFailedNb) / (Standard_Real)aPointsNb;
3582
3583   theDI << "Number of failed cases: " << aFailedNb << " (Total " << aPointsNb << ")\n";
3584   if (aDeviation > aMaxDeviation)
3585   {
3586     theDI << "Failed. Number of incorrect results is too huge: " << 
3587       aDeviation * 100 << "% (Max " << aMaxDeviation * 100 << "%)\n";
3588     return 1;
3589   }
3590
3591   theDI << "Deviation of incorrect results is: " <<
3592     aDeviation * 100 << "% (Max " << aMaxDeviation * 100 << "%)\n";
3593   theDI << "Test completed\n";
3594   return 0;
3595 }
3596
3597 #include <TColGeom_Array1OfBSplineCurve.hxx>
3598 #include <TColStd_Array1OfReal.hxx>
3599 #include <TColGeom_HArray1OfBSplineCurve.hxx>
3600 #include <GeomConvert.hxx>
3601
3602 //=======================================================================
3603 //function : OCC26446
3604 //purpose  : 
3605 //=======================================================================
3606 Standard_Integer OCC26446 (Draw_Interpretor& di, 
3607                            Standard_Integer n, 
3608                            const char** a)
3609 {
3610   if (n != 4) {
3611     di << "Usage: OCC26446 r c1 c2\n";
3612     return 1;
3613   }
3614
3615   Handle(Geom_BSplineCurve) aCurve1 =
3616     Handle(Geom_BSplineCurve)::DownCast(DrawTrSurf::GetCurve(a[2]));
3617   Handle(Geom_BSplineCurve) aCurve2 = 
3618     Handle(Geom_BSplineCurve)::DownCast(DrawTrSurf::GetCurve(a[3]));
3619
3620   if (aCurve1.IsNull()) {
3621     di << a[2] << " is not a BSpline curve\n";
3622         return 1;
3623   }
3624
3625   if (aCurve2.IsNull()) {
3626     di << a[3] << " is not a BSpline curve\n";
3627         return 1;
3628   }
3629
3630   TColGeom_Array1OfBSplineCurve          aCurves     (0, 1);
3631   TColStd_Array1OfReal                   aTolerances (0, 0);
3632   Standard_Real                          aTolConf    = 1.e-3;
3633   Standard_Real                          aTolClosure = Precision::Confusion();
3634   Handle(TColGeom_HArray1OfBSplineCurve) aConcatCurves;
3635   Handle(TColStd_HArray1OfInteger)       anIndices;
3636
3637   aCurves.SetValue(0, aCurve1);
3638   aCurves.SetValue(1, aCurve2);
3639   aTolerances.SetValue(0, aTolConf);
3640
3641   GeomConvert::ConcatC1(aCurves,
3642                         aTolerances,
3643                         anIndices,
3644                         aConcatCurves,
3645                         Standard_False,
3646                         aTolClosure);
3647
3648   Handle(Geom_BSplineCurve) aResult =
3649     aConcatCurves->Value(aConcatCurves->Lower());
3650
3651   DrawTrSurf::Set(a[1], aResult);
3652   return 0;
3653 }
3654
3655 static Standard_Integer OCC26448 (Draw_Interpretor& theDI, Standard_Integer, const char **)
3656 {
3657   TColStd_SequenceOfReal aSeq1, aSeq2;
3658   aSeq1.Append(11.);
3659   aSeq1.Prepend (aSeq2);
3660   theDI << "TCollection: 11 -> " << aSeq1.First() << "\n";
3661
3662   NCollection_Sequence<Standard_Real> nSeq1, nSeq2;
3663   nSeq1.Append(11.);
3664   nSeq1.Prepend (nSeq2);
3665   theDI << "NCollection: 11 -> " << nSeq1.First() << "\n";
3666
3667   theDI << "OK";
3668   return 0;
3669 }
3670
3671 //=======================================================================
3672 //function : OCC26407
3673 //purpose  :
3674 //=======================================================================
3675 #include <BRepBuilderAPI_MakeWire.hxx>
3676 #include <BRepBuilderAPI_MakeEdge.hxx>
3677 #include <BRepMesh_IncrementalMesh.hxx>
3678 #include <TCollection_AsciiString.hxx>
3679 static Standard_Integer OCC26407 (Draw_Interpretor& theDI, Standard_Integer theArgNb, const char** theArgVec)
3680 {
3681   if (theArgNb != 2)
3682   {
3683     std::cerr << "Error: wrong number of arguments! See usage:\n";
3684     theDI.PrintHelp (theArgVec[0]);
3685     return 1;
3686   }
3687
3688   // Construct vertices.
3689   std::vector<TopoDS_Vertex> wire_vertices;
3690   wire_vertices.push_back(BRepBuilderAPI_MakeVertex(gp_Pnt(587.90000000000009094947, 40.6758179230516248026106, 88.5)));
3691   wire_vertices.push_back(BRepBuilderAPI_MakeVertex(gp_Pnt(807.824182076948432040808, 260.599999999999965893949, 88.5)));
3692   wire_vertices.push_back(BRepBuilderAPI_MakeVertex(gp_Pnt(644.174182076948454778176, 424.249999999999943156581, 88.5000000000000142108547)));
3693   wire_vertices.push_back(BRepBuilderAPI_MakeVertex(gp_Pnt(629.978025792618950617907, 424.25, 88.5)));
3694   wire_vertices.push_back(BRepBuilderAPI_MakeVertex(gp_Pnt(793.628025792618700506864, 260.599999999999852207111, 88.5)));
3695   wire_vertices.push_back(BRepBuilderAPI_MakeVertex(gp_Pnt(587.900000000000204636308, 54.8719742073813492311274, 88.5)));
3696   wire_vertices.push_back(BRepBuilderAPI_MakeVertex(gp_Pnt(218.521974207381418864315, 424.250000000000056843419, 88.5)));
3697   wire_vertices.push_back(BRepBuilderAPI_MakeVertex(gp_Pnt(204.325817923051886282337, 424.249999999999943156581, 88.5)));
3698