0027357: Geom2dGcc_Circ2d2TanOn: check status of sub-algorithms to avoid exceptions

Additional checks for underlying algorithms have been added

test case

get rid of the warning

src/Geom2dGcc/Geom2dGcc_Circ2d2TanOn.cxx

@@ -87,18 +87,23 @@ Geom2dGcc_Circ2d2TanOn::
 			       GccEnt_QualifiedCirc(c2,Qualified2.Qualifier()),
 					CCon->Circ2d(),Tolerance);
 	    WellDone = CircAna.IsDone();
+            if (WellDone)
+            {
               NbrSol = CircAna.NbSolutions();
               for(Standard_Integer i=1; i<=NbrSol; i++) {
                 CircAna.WhichQualifier(i,qualifier1(i),qualifier2(i));
               }
               Results(CircAna);
             }
+	  }
 	  else {
 	    Handle(Geom2d_Line) LLon = Handle(Geom2d_Line)::DownCast(Con);
 	    GccAna_Circ2d2TanOn CircAna(Qc1,
 			       GccEnt_QualifiedCirc(c2,Qualified2.Qualifier()),
 					LLon->Lin2d(),Tolerance);
 	    WellDone = CircAna.IsDone();
+            if (WellDone)
+            {
               NbrSol = CircAna.NbSolutions();
               for(Standard_Integer i=1; i<=NbrSol; i++) {
                 CircAna.WhichQualifier(i,qualifier1(i),qualifier2(i));
@@ -106,6 +111,7 @@ Geom2dGcc_Circ2d2TanOn::
               Results(CircAna);
             }
 	  }
+	}
 	else {
 	  Handle(Geom2d_Line) LL2 = Handle(Geom2d_Line)::DownCast(CC2);
 	  gp_Lin2d l2(LL2->Lin2d());
@@ -115,18 +121,23 @@ Geom2dGcc_Circ2d2TanOn::
 			       GccEnt_QualifiedLin(l2,Qualified2.Qualifier()),
 					CCon->Circ2d(),Tolerance);
 	    WellDone = CircAna.IsDone();
+            if (WellDone)
+            {
               NbrSol = CircAna.NbSolutions();
               for(Standard_Integer i=1; i<=NbrSol; i++) {
                 CircAna.WhichQualifier(i,qualifier1(i),qualifier2(i));
               }
               Results(CircAna);
             }
+	  }
 	  else {
 	    Handle(Geom2d_Line) LLon = Handle(Geom2d_Line)::DownCast(Con);
 	    GccAna_Circ2d2TanOn CircAna(Qc1,
 			       GccEnt_QualifiedLin(l2,Qualified2.Qualifier()),
 					LLon->Lin2d(),Tolerance);
 	    WellDone = CircAna.IsDone();
+            if (WellDone)
+            {
               NbrSol = CircAna.NbSolutions();
               for(Standard_Integer i=1; i<=NbrSol; i++) {
                 CircAna.WhichQualifier(i,qualifier1(i),qualifier2(i));
@@ -135,6 +146,7 @@ Geom2dGcc_Circ2d2TanOn::
             }
 	  }
 	}
+      }
       else {
 	Handle(Geom2d_Line) LL1 = Handle(Geom2d_Line)::DownCast(CC1);
 	gp_Lin2d l1(LL1->Lin2d());
@@ -149,6 +161,8 @@ Geom2dGcc_Circ2d2TanOn::
 						       Qualified2.Qualifier()),
 					Ql1,CCon->Circ2d(),Tolerance);
 	    WellDone = CircAna.IsDone();
+            if (WellDone)
+            {
               NbrSol = CircAna.NbSolutions();
               for(Standard_Integer i=1; i<=NbrSol; i++) {
                 CircAna.WhichQualifier(i,qualifier1(i),qualifier2(i));
@@ -156,12 +170,15 @@ Geom2dGcc_Circ2d2TanOn::
               Results(CircAna);
               Invert = Standard_True;
             }
+	  }
 	  else {
 	    Handle(Geom2d_Line) LLon = Handle(Geom2d_Line)::DownCast(Con);
 	    GccAna_Circ2d2TanOn CircAna(GccEnt_QualifiedCirc(c2,
 						       Qualified2.Qualifier()),
 					Ql1,LLon->Lin2d(),Tolerance);
 	    WellDone = CircAna.IsDone();
+            if (WellDone)
+            {
               NbrSol = CircAna.NbSolutions();
               for(Standard_Integer i=1; i<=NbrSol; i++) {
                 CircAna.WhichQualifier(i,qualifier1(i),qualifier2(i));
@@ -170,6 +187,7 @@ Geom2dGcc_Circ2d2TanOn::
               Invert = Standard_True;
             }
 	  }
+	}
 	else {
 	  Handle(Geom2d_Line) LL2 = Handle(Geom2d_Line)::DownCast(CC2);
 	  gp_Lin2d l2(LL2->Lin2d());
@@ -179,18 +197,23 @@ Geom2dGcc_Circ2d2TanOn::
 			       GccEnt_QualifiedLin(l2,Qualified2.Qualifier()),
 					CCon->Circ2d(),Tolerance);
 	    WellDone = CircAna.IsDone();
+            if (WellDone)
+            {
               NbrSol = CircAna.NbSolutions();
               for(Standard_Integer i=1; i<=NbrSol; i++) {
                 CircAna.WhichQualifier(i,qualifier1(i),qualifier2(i));
               }
               Results(CircAna);
             }
+	  }
 	  else {
 	    Handle(Geom2d_Line) LLon = Handle(Geom2d_Line)::DownCast(Con);
 	    GccAna_Circ2d2TanOn CircAna(Ql1,
 			       GccEnt_QualifiedLin(l2,Qualified2.Qualifier()),
 					LLon->Lin2d(),Tolerance);
 	    WellDone = CircAna.IsDone();
+            if (WellDone)
+            {
               NbrSol = CircAna.NbSolutions();
               for(Standard_Integer i=1; i<=NbrSol; i++) {
                 CircAna.WhichQualifier(i,qualifier1(i),qualifier2(i));
@@ -200,6 +223,7 @@ Geom2dGcc_Circ2d2TanOn::
 	  }
 	}
       }
+    }
 
 //=============================================================================
 //                            Appel a GccGeo.                                 +
@@ -218,12 +242,15 @@ Geom2dGcc_Circ2d2TanOn::
 	    GccEnt_QualifiedCirc(c2,Qualified2.Qualifier());
 	  Geom2dGcc_Circ2d2TanOnGeo CircGeo(Qc1,Qc2,OnCurve,Tolerance);
 	  WellDone = CircGeo.IsDone();
+          if (WellDone)
+          {
             NbrSol = CircGeo.NbSolutions();
             for(Standard_Integer i=1; i<=NbrSol; i++) {
               CircGeo.WhichQualifier(i,qualifier1(i),qualifier2(i));
             }
             Results(CircGeo);
           }
+	}
 	else {
 	  Handle(Geom2d_Line) LL2 = Handle(Geom2d_Line)::DownCast(CC2);
 	  gp_Lin2d l2(LL2->Lin2d());
@@ -231,6 +258,8 @@ Geom2dGcc_Circ2d2TanOn::
 	    GccEnt_QualifiedLin(l2,Qualified2.Qualifier());
 	  Geom2dGcc_Circ2d2TanOnGeo CircGeo(Qc1,Ql2,OnCurve,Tolerance);
 	  WellDone = CircGeo.IsDone();
+          if (WellDone)
+          {
             NbrSol = CircGeo.NbSolutions();
             for(Standard_Integer i=1; i<=NbrSol; i++) {
               CircGeo.WhichQualifier(i,qualifier1(i),qualifier2(i));
@@ -238,6 +267,7 @@ Geom2dGcc_Circ2d2TanOn::
             Results(CircGeo);
           }
 	}
+      }
       else {
 	Handle(Geom2d_Line) LL1 = Handle(Geom2d_Line)::DownCast(CC1);
 	gp_Lin2d l1(LL1->Lin2d());
@@ -250,6 +280,8 @@ Geom2dGcc_Circ2d2TanOn::
 	    GccEnt_QualifiedCirc(c2,Qualified2.Qualifier());
 	  Geom2dGcc_Circ2d2TanOnGeo CircGeo(Qc2,Ql1,OnCurve,Tolerance);
 	  WellDone = CircGeo.IsDone();
+          if (WellDone)
+          {
             NbrSol = CircGeo.NbSolutions();
             for(Standard_Integer i=1; i<=NbrSol; i++) {
               CircGeo.WhichQualifier(i,qualifier1(i),qualifier2(i));
@@ -257,6 +289,7 @@ Geom2dGcc_Circ2d2TanOn::
             Results(CircGeo);
             Invert = Standard_True;
           }
+	}
 	else {
 	  Handle(Geom2d_Line) LL2 = Handle(Geom2d_Line)::DownCast(CC2);
 	  gp_Lin2d l2(LL2->Lin2d());
@@ -264,6 +297,8 @@ Geom2dGcc_Circ2d2TanOn::
 	    GccEnt_QualifiedLin(l2,Qualified2.Qualifier());
 	  Geom2dGcc_Circ2d2TanOnGeo CircGeo(Ql1,Ql2,OnCurve,Tolerance);
 	  WellDone = CircGeo.IsDone();
+          if (WellDone)
+          {
             NbrSol = CircGeo.NbSolutions();
             for(Standard_Integer i=1; i<=NbrSol; i++) {
               CircGeo.WhichQualifier(i,qualifier1(i),qualifier2(i));
@@ -273,6 +308,7 @@ Geom2dGcc_Circ2d2TanOn::
 	}
       }
     }
+  }
   else {
     Geom2dGcc_QCurve Qc1(C1,Qualified1.Qualifier());
     Geom2dGcc_QCurve Qc2(C2,Qualified2.Qualifier());
@@ -282,6 +318,8 @@ Geom2dGcc_Circ2d2TanOn::
 	Geom2dGcc_Circ2d2TanOnIter Circ(Qc1,Qc2,CCon->Circ2d(),
 				   Param1,Param2,ParamOn,Tolerance);
 	WellDone = Circ.IsDone();
+        if (WellDone)
+        {
           NbrSol = 1;
           cirsol(1)   = Circ.ThisSolution();
           if (Circ.IsTheSame1()) { TheSame1(1) = 1; }
@@ -291,11 +329,14 @@ Geom2dGcc_Circ2d2TanOn::
           Circ.Tangency1(par1sol(1),pararg1(1),pnttg1sol(1));
           Circ.Tangency2(par2sol(1),pararg2(1),pnttg2sol(1));
         }
+      }
       else {
 	Handle(Geom2d_Line) LLon = Handle(Geom2d_Line)::DownCast(Con);
 	Geom2dGcc_Circ2d2TanOnIter Circ(Qc1,Qc2,LLon->Lin2d(),
 				       Param1,Param2,ParamOn,Tolerance);
 	WellDone = Circ.IsDone();
+        if (WellDone)
+        {
           NbrSol = 1;
           cirsol(1)   = Circ.ThisSolution();
           if (Circ.IsTheSame1()) { TheSame1(1) = 1; }
@@ -307,9 +348,12 @@ Geom2dGcc_Circ2d2TanOn::
           Circ.Tangency2(par2sol(1),pararg2(1),pnttg2sol(1));
         }
       }
+    }
     Geom2dGcc_Circ2d2TanOnIter Circ(Qc1,Qc2,OnCurve,
 				   Param1,Param2,ParamOn,Tolerance);
     WellDone = Circ.IsDone();
+    if (WellDone)
+    {
       NbrSol = 1;
       cirsol(1)   = Circ.ThisSolution();
       if (Circ.IsTheSame1()) { TheSame1(1) = 1; }
@@ -321,6 +365,7 @@ Geom2dGcc_Circ2d2TanOn::
       Circ.Tangency2(par2sol(1),pararg2(1),pnttg2sol(1));
     }
   }
+}
 
 Geom2dGcc_Circ2d2TanOn::
    Geom2dGcc_Circ2d2TanOn (const Geom2dGcc_QualifiedCurve&    Qualified1 , 
@@ -366,16 +411,21 @@ Geom2dGcc_Circ2d2TanOn::
 	  Handle(Geom2d_Circle) CCon = Handle(Geom2d_Circle)::DownCast(Con);
 	  GccAna_Circ2d2TanOn CircAna(Qc1,pnt,CCon->Circ2d(),Tolerance);
 	  WellDone = CircAna.IsDone();
+          if (WellDone)
+          {
             NbrSol = CircAna.NbSolutions();
             for(Standard_Integer i=1; i<=NbrSol; i++) {
               CircAna.WhichQualifier(i,qualifier1(i),qualifier2(i));
             }
             Results(CircAna);
           }
+	}
 	else if (Type3 == GeomAbs_Line) {
 	  Handle(Geom2d_Line) CCon = Handle(Geom2d_Line)::DownCast(Con);
 	  GccAna_Circ2d2TanOn CircAna(Qc1,pnt,CCon->Lin2d(),Tolerance);
 	  WellDone = CircAna.IsDone();
+          if (WellDone)
+          {
             NbrSol = CircAna.NbSolutions();
             for(Standard_Integer i=1; i<=NbrSol; i++) {
               CircAna.WhichQualifier(i,qualifier1(i),qualifier2(i));
@@ -383,6 +433,7 @@ Geom2dGcc_Circ2d2TanOn::
             Results(CircAna);
           }
 	}
+      }
       else {
 	Handle(Geom2d_Line) LLL1 = Handle(Geom2d_Line)::DownCast(CC1);
 	gp_Lin2d l1(LLL1->Lin2d());
@@ -391,16 +442,21 @@ Geom2dGcc_Circ2d2TanOn::
 	  Handle(Geom2d_Circle) CCon = Handle(Geom2d_Circle)::DownCast(Con);
 	  GccAna_Circ2d2TanOn CircAna(Ql1,pnt,CCon->Circ2d(),Tolerance);
 	  WellDone = CircAna.IsDone();
+          if (WellDone)
+          {
             NbrSol = CircAna.NbSolutions();
             for(Standard_Integer i=1; i<=NbrSol; i++) {
               CircAna.WhichQualifier(i,qualifier1(i),qualifier2(i));
             }
             Results(CircAna);
           }
+	}
 	else if (Type3 == GeomAbs_Line) {
 	  Handle(Geom2d_Line) LLon = Handle(Geom2d_Line)::DownCast(Con);
 	  GccAna_Circ2d2TanOn CircAna(Ql1,pnt,LLon->Lin2d(),Tolerance);
 	  WellDone = CircAna.IsDone();
+          if (WellDone)
+          {
             NbrSol = CircAna.NbSolutions();
             for(Standard_Integer i=1; i<=NbrSol; i++) {
               CircAna.WhichQualifier(i,qualifier1(i),qualifier2(i));
@@ -409,6 +465,7 @@ Geom2dGcc_Circ2d2TanOn::
           }
 	}
       }
+    }
 //=============================================================================
 //                            Appel a GccGeo.                                 +
 //=============================================================================
@@ -420,18 +477,23 @@ Geom2dGcc_Circ2d2TanOn::
 	GccEnt_QualifiedCirc Qc1(c1,Qualified1.Qualifier());
 	Geom2dGcc_Circ2d2TanOnGeo CircGeo(Qc1,Point->Pnt2d(),OnCurve,Tolerance);
 	WellDone = CircGeo.IsDone();
+        if (WellDone)
+        {
           NbrSol = CircGeo.NbSolutions();
           for(Standard_Integer i=1; i<=NbrSol; i++) {
             CircGeo.WhichQualifier(i,qualifier1(i),qualifier2(i));
           }
           Results(CircGeo);
         }
+      }
       else {
 	Handle(Geom2d_Line) LLL1 = Handle(Geom2d_Line)::DownCast(CC1);
 	gp_Lin2d l1(LLL1->Lin2d());
 	GccEnt_QualifiedLin Ql1(l1,Qualified1.Qualifier());
 	Geom2dGcc_Circ2d2TanOnGeo CircGeo(Ql1,Point->Pnt2d(),OnCurve,Tolerance);
 	WellDone = CircGeo.IsDone();
+        if (WellDone)
+        {
           NbrSol = CircGeo.NbSolutions();
           for(Standard_Integer i=1; i<=NbrSol; i++) {
             CircGeo.WhichQualifier(i,qualifier1(i),qualifier2(i));
@@ -440,6 +502,7 @@ Geom2dGcc_Circ2d2TanOn::
         }
       }
     }
+  }                                   
   else {
     Geom2dGcc_QCurve Qc1(C1,Qualified1.Qualifier());
     if ((Type3 == GeomAbs_Circle || Type3 == GeomAbs_Line)) {
@@ -448,6 +511,8 @@ Geom2dGcc_Circ2d2TanOn::
 	Geom2dGcc_Circ2d2TanOnIter Circ(Qc1,Point->Pnt2d(),CCon->Circ2d(),
 				   Param1,ParamOn,Tolerance);
 	WellDone = Circ.IsDone();
+        if (WellDone)
+        {
           NbrSol = 1;
           cirsol(1)   = Circ.ThisSolution();
           if (Circ.IsTheSame1()) { TheSame1(1) = 1; }
@@ -456,11 +521,14 @@ Geom2dGcc_Circ2d2TanOn::
           Circ.Tangency1(par1sol(1),pararg1(1),pnttg1sol(1));
           Circ.Tangency2(par2sol(1),pararg2(1),pnttg2sol(1));
         }
+      }
       else {
 	Handle(Geom2d_Line) LLon = Handle(Geom2d_Line)::DownCast(Con);
 	Geom2dGcc_Circ2d2TanOnIter Circ(Qc1,Point->Pnt2d(),LLon->Lin2d(),
 				       Param1,ParamOn,Tolerance);
 	WellDone = Circ.IsDone();
+        if (WellDone)
+        {
           NbrSol = 1;
           cirsol(1)   = Circ.ThisSolution();
           if (Circ.IsTheSame1()) { TheSame1(1) = 1; }
@@ -470,10 +538,13 @@ Geom2dGcc_Circ2d2TanOn::
           Circ.Tangency2(par2sol(1),pararg2(1),pnttg2sol(1));
         }
       }
+    }
     else {
       Geom2dGcc_Circ2d2TanOnIter Circ(Qc1,Point->Pnt2d(),OnCurve,
 				 Param1,ParamOn,Tolerance);
       WellDone = Circ.IsDone();
+      if (WellDone)
+      {
         NbrSol = 1;
         cirsol(1)   = Circ.ThisSolution();
         if (Circ.IsTheSame1()) { TheSame1(1) = 1; }
@@ -486,6 +557,7 @@ Geom2dGcc_Circ2d2TanOn::
       }
     }
   }
+}
 
 Geom2dGcc_Circ2d2TanOn::
    Geom2dGcc_Circ2d2TanOn (const Handle(Geom2d_Point)&        Point1     , 
@@ -523,16 +595,21 @@ Geom2dGcc_Circ2d2TanOn::
       Handle(Geom2d_Circle) CCon = Handle(Geom2d_Circle)::DownCast(Con);
       GccAna_Circ2d2TanOn CircAna(pnt1,pnt2,CCon->Circ2d(),Tolerance);
       WellDone = CircAna.IsDone();
+      if (WellDone)
+      {
         NbrSol = CircAna.NbSolutions();
         for(Standard_Integer i=1; i<=NbrSol; i++) {
           CircAna.WhichQualifier(i,qualifier1(i),qualifier2(i));
         }
         Results(CircAna);
       }
+    }
     else {
       Handle(Geom2d_Line) LLon = Handle(Geom2d_Line)::DownCast(Con);
       GccAna_Circ2d2TanOn CircAna(pnt1,pnt2,LLon->Lin2d(),Tolerance);
       WellDone = CircAna.IsDone();
+      if (WellDone)
+      {
         NbrSol = CircAna.NbSolutions();
         for(Standard_Integer i=1; i<=NbrSol; i++) {
           CircAna.WhichQualifier(i,qualifier1(i),qualifier2(i));
@@ -540,6 +617,7 @@ Geom2dGcc_Circ2d2TanOn::
         Results(CircAna);
       }
     }
+  }
 
 //=============================================================================
 //                            Appel a GccGeo.                                 +
@@ -549,6 +627,8 @@ Geom2dGcc_Circ2d2TanOn::
     Geom2dGcc_Circ2d2TanOnGeo CircGeo(Point1->Pnt2d(),Point2->Pnt2d(),
 				     OnCurve,Tolerance);
     WellDone = CircGeo.IsDone();
+    if (WellDone)
+    {
       NbrSol = CircGeo.NbSolutions();
       for(Standard_Integer i=1; i<=NbrSol; i++) {
         CircGeo.WhichQualifier(i,qualifier1(i),qualifier2(i));
@@ -556,6 +636,7 @@ Geom2dGcc_Circ2d2TanOn::
       Results(CircGeo);
     }
   }
+}
 
 void Geom2dGcc_Circ2d2TanOn::Results(const GccAna_Circ2d2TanOn& Circ)
 {

src/QABugs/QABugs_20.cxx

@@ -1975,6 +1975,57 @@ static Standard_Integer OCC26747_3(Draw_Interpretor& theDI,
   return 0;
 }
 
+#include "Geom2d_BezierCurve.hxx"
+#include "Geom2dGcc_QualifiedCurve.hxx"
+#include "Geom2dAdaptor_Curve.hxx"
+#include "Geom2dAPI_ProjectPointOnCurve.hxx"
+#include "Geom2dGcc_Circ2d2TanOn.hxx"
+//=======================================================================
+//function : OCC27357
+//purpose :
+//=======================================================================
+static Standard_Integer OCC27357(Draw_Interpretor& theDI,
+                                 Standard_Integer,
+                                 const char **)
+{
+  TColgp_Array1OfPnt2d aPoles(1,3);
+  aPoles.SetValue(1, gp_Pnt2d(0.,0.));
+  aPoles.SetValue(2, gp_Pnt2d(0.,1.));
+  aPoles.SetValue(3, gp_Pnt2d(6.,0.));
+
+  Handle(Geom2d_BezierCurve) aCurve1 = new Geom2d_BezierCurve(aPoles);
+  aPoles.SetValue(2, gp_Pnt2d(0.,1.5));
+  Handle(Geom2d_BezierCurve) aCurve2 = new Geom2d_BezierCurve(aPoles);
+  NCollection_List<Standard_Integer> aDuumyList;
+  int nP = 100;
+  for(int i = 0 ; i < nP ; i++){
+    Standard_Real u = i / (nP-1.);
+    gp_Pnt2d aP1;
+    gp_Vec2d aTangent;
+    aCurve1->D1(u,aP1,aTangent);
+    gp_Vec2d aNormal(-aTangent.Y(),aTangent.X());
+    Handle(Geom2d_Line) normalLine=new Geom2d_Line(aP1, gp_Dir2d(aNormal));
+    Geom2dGcc_QualifiedCurve qualifiedC1(Geom2dAdaptor_Curve(aCurve1),GccEnt_unqualified);
+    Geom2dGcc_QualifiedCurve qualifiedC2(Geom2dAdaptor_Curve(aCurve2),GccEnt_unqualified);
+
+    try
+    {
+      Geom2dAPI_ProjectPointOnCurve projPc1(aP1, aCurve1);
+      double g1 = projPc1.LowerDistanceParameter();
+      Geom2dAPI_ProjectPointOnCurve projPc3(aP1, normalLine);
+      double g3 = projPc3.LowerDistanceParameter();
+      Geom2dGcc_Circ2d2TanOn aCircleBuilder(qualifiedC1,qualifiedC2,
+        Geom2dAdaptor_Curve(normalLine),1e-9,g1,g1,g3);
+      aDuumyList.Append(aCircleBuilder.NbSolutions());
+    }
+    catch(Standard_Failure)
+    {
+      theDI << "Exception was caught\n";
+    }
+  }
+  return 0;
+}
+
 void QABugs::Commands_20(Draw_Interpretor& theCommands) {
   const char *group = "QABugs";
 
@@ -1990,6 +2041,6 @@ void QABugs::Commands_20(Draw_Interpretor& theCommands) {
   theCommands.Add ("OCC26747_1", "OCC26747_1 result", __FILE__, OCC26747_1, group);
   theCommands.Add ("OCC26747_2", "OCC26747_2 result", __FILE__, OCC26747_2, group);
   theCommands.Add ("OCC26747_3", "OCC26747_3 result", __FILE__, OCC26747_3, group);
-
+  theCommands.Add ("OCC27357", "OCC27357", __FILE__, OCC27357, group);
   return;
 }

tests/bugs/modalg_6/bug27357

@@ -0,0 +1,16 @@
+puts "========"
+puts "OCC27357"
+puts "========"
+puts ""
+#################################################################
+# Geom2dGcc_Circ2d2TanOn: check status of sub-algorithms to avoid exceptions
+#################################################################
+
+pload QAcommands
+
+set info [OCC27357]
+if { [regexp "Exception" $info] != 0 } {
+    puts "Error : Exception was caught"
+} else {
+    puts "OK"
+}