Merge 09ce65b93f4b8f43343ad1e9d512849b255e6487 into ac9051e2b66008a4918ff9100745a27b0840400e

src/app/maptools/qgsmaptoolshapecircle2points.cpp

@@ -63,6 +63,9 @@ bool QgsMapToolShapeCircle2Points::cadCanvasReleaseEvent( QgsMapMouseEvent *e, Q
   }
   else if ( e->button() == Qt::RightButton )
   {
+    if ( mCircle.isEmpty() )
+      return false;
+
     mPoints.append( mParentTool->mapPoint( *e ) );
     addCircleToParentTool();
     return true;

src/app/maptools/qgsmaptoolshapecircle2tangentspoint.cpp

@@ -100,6 +100,9 @@ bool QgsMapToolShapeCircle2TangentsPoint::cadCanvasReleaseEvent( QgsMapMouseEven
   }
   else if ( e->button() == Qt::RightButton )
   {
+    if ( mPoints.size() < 4 || mCircle.isEmpty() )
+      return false;
+
     addCircleToParentTool();
     return true;
   }

src/app/maptools/qgsmaptoolshapecircle3points.cpp

@@ -65,6 +65,9 @@ bool QgsMapToolShapeCircle3Points::cadCanvasReleaseEvent( QgsMapMouseEvent *e, Q
   }
   else if ( e->button() == Qt::RightButton )
   {
+    if ( mCircle.isEmpty() )
+      return false;
+
     mPoints.append( mParentTool->mapPoint( *e ) );
     addCircleToParentTool();
     return true;

src/app/maptools/qgsmaptoolshapecircle3tangents.cpp

@@ -92,6 +92,9 @@ bool QgsMapToolShapeCircle3Tangents::cadCanvasReleaseEvent( QgsMapMouseEvent *e,
   }
   else if ( e->button() == Qt::RightButton )
   {
+    if ( mCircle.isEmpty() )
+      return false;
+
     if ( match.isValid() && ( mPoints.size() == 4 ) )
     {
       match.edgePoints( p1, p2 );

src/app/maptools/qgsmaptoolshapecirclecenterpoint.cpp

@@ -68,6 +68,9 @@ bool QgsMapToolShapeCircleCenterPoint::cadCanvasReleaseEvent( QgsMapMouseEvent *
   }
   else if ( e->button() == Qt::RightButton )
   {
+    if ( mCircle.isEmpty() )
+      return false;
+
     mPoints.append( point );
     addCircleToParentTool();
     return true;

src/app/maptools/qgsmaptoolshapecircularstringradius.cpp

@@ -106,6 +106,9 @@ bool QgsMapToolShapeCircularStringRadius::cadCanvasReleaseEvent( QgsMapMouseEven
   }
   else if ( e->button() == Qt::RightButton )
   {
+    if ( mPoints.size() < 3 )
+      return false;
+
     if ( !( mPoints.size() % 2 ) )
       mPoints.removeLast();
     addCurveToParentTool();

src/app/maptools/qgsmaptoolshapeellipsecenter2points.cpp

@@ -68,6 +68,9 @@ bool QgsMapToolShapeEllipseCenter2Points::cadCanvasReleaseEvent( QgsMapMouseEven
   }
   else if ( e->button() == Qt::RightButton )
   {
+    if ( mEllipse.isEmpty() )
+      return false;
+
     addEllipseToParentTool();
     return true;
   }

src/app/maptools/qgsmaptoolshapeellipsecenterpoint.cpp

@@ -68,6 +68,9 @@ bool QgsMapToolShapeEllipseCenterPoint::cadCanvasReleaseEvent( QgsMapMouseEvent
   }
   else if ( e->button() == Qt::RightButton )
   {
+    if ( mEllipse.isEmpty() )
+      return false;
+
     addEllipseToParentTool();
     return true;
   }

src/app/maptools/qgsmaptoolshapeellipseextent.cpp

@@ -74,6 +74,9 @@ bool QgsMapToolShapeEllipseExtent::cadCanvasReleaseEvent( QgsMapMouseEvent *e, Q
   }
   else if ( e->button() == Qt::RightButton )
   {
+    if ( mEllipse.isEmpty() )
+      return false;
+
     addEllipseToParentTool();
     return true;
   }

src/app/maptools/qgsmaptoolshapeellipsefoci.cpp

@@ -74,6 +74,9 @@ bool QgsMapToolShapeEllipseFoci::cadCanvasReleaseEvent( QgsMapMouseEvent *e, Qgs
   }
   else if ( e->button() == Qt::RightButton )
   {
+    if ( mEllipse.isEmpty() )
+      return false;
+
     addEllipseToParentTool();
     return true;
   }

src/app/maptools/qgsmaptoolshaperectangle3points.cpp

@@ -115,6 +115,9 @@ bool QgsMapToolShapeRectangle3Points::cadCanvasReleaseEvent( QgsMapMouseEvent *e
   }
   else if ( e->button() == Qt::RightButton )
   {
+    if ( !mRectangle.isValid() )
+      return false;
+
     addRectangleToParentTool();
     return true;
   }

src/app/maptools/qgsmaptoolshaperectanglecenter.cpp

@@ -70,6 +70,9 @@ bool QgsMapToolShapeRectangleCenter::cadCanvasReleaseEvent( QgsMapMouseEvent *e,
   }
   else if ( e->button() == Qt::RightButton )
   {
+    if ( !mRectangle.isValid() )
+      return false;
+
     mPoints.append( point );
     addRectangleToParentTool();
     return true;

src/app/maptools/qgsmaptoolshaperectangleextent.cpp

@@ -68,6 +68,9 @@ bool QgsMapToolShapeRectangleExtent::cadCanvasReleaseEvent( QgsMapMouseEvent *e,
   }
   else if ( e->button() == Qt::RightButton )
   {
+    if ( !mRectangle.isValid() )
+      return false;
+
     mPoints.append( point );
     addRectangleToParentTool();
     return true;

src/app/maptools/qgsmaptoolshaperegularpolygon2points.cpp

@@ -78,6 +78,9 @@ bool QgsMapToolShapeRegularPolygon2Points::cadCanvasReleaseEvent( QgsMapMouseEve
   }
   else if ( e->button() == Qt::RightButton )
   {
+    if ( mRegularPolygon.isEmpty() )
+      return false;
+
     mPoints.append( point );
     addRegularPolygonToParentTool();
     return true;

src/app/maptools/qgsmaptoolshaperegularpolygoncentercorner.cpp

@@ -75,6 +75,9 @@ bool QgsMapToolShapeRegularPolygonCenterCorner::cadCanvasReleaseEvent( QgsMapMou
   }
   else if ( e->button() == Qt::RightButton )
   {
+    if ( mRegularPolygon.isEmpty() )
+      return false;
+
     mPoints.append( point );
     addRegularPolygonToParentTool();
     return true;

src/app/maptools/qgsmaptoolshaperegularpolygoncenterpoint.cpp

@@ -77,6 +77,9 @@ bool QgsMapToolShapeRegularPolygonCenterPoint::cadCanvasReleaseEvent( QgsMapMous
   }
   else if ( e->button() == Qt::RightButton )
   {
+    if ( mRegularPolygon.isEmpty() )
+      return false;
+
     mPoints.append( point );
     addRegularPolygonToParentTool();
     return true;

tests/src/app/testqgsmaptoolcircle.cpp

@@ -30,6 +30,8 @@
 #include "qgsmaptoolshapecircle2points.h"
 #include "qgsmaptoolshapecircle3points.h"
 #include "qgsmaptoolshapecirclecenterpoint.h"
+#include "qgsmaptoolshapecircle3tangents.h"
+#include "qgsmaptoolshapecircle2tangentspoint.h"
 
 
 class TestQgsMapToolCircle : public QObject
@@ -45,6 +47,11 @@ class TestQgsMapToolCircle : public QObject
 
     void testCircle_data();
     void testCircle();
+    void testDrawCircleFrom2PointsNotEnoughPoints();
+    void testDrawCircleFrom3PointsNotEnoughPoints();
+    void testDrawCircleFromCenterPointNotEnoughPoints();
+    void testDrawCircleFrom3TangentsNotEnoughPoints();
+    void testDrawCircleFrom2TangentsNotEnoughPoints();
 
   private:
     void resetMapTool( QgsMapToolShapeMetadata *metadata );
@@ -334,7 +341,6 @@ QgsFeatureId TestQgsMapToolCircle::drawCircleFromCenterPointWithDeletedVertex()
   return utils.newFeatureId();
 }
 
-
 void TestQgsMapToolCircle::testCircle_data()
 {
   QTest::addColumn<QString>( "wktGeometry" );
@@ -392,6 +398,107 @@ void TestQgsMapToolCircle::testCircle()
   QCOMPARE( wktGeometry, wktExpected );
 }
 
+void TestQgsMapToolCircle::testDrawCircleFrom2PointsNotEnoughPoints()
+{
+  QgsVectorLayer *layer = mVectorLayerMap["XY"].get();
+  mCanvas->setCurrentLayer( layer );
+  layer->startEditing();
+  const long long count = layer->featureCount();
+
+  QgsMapToolShapeCircle2PointsMetadata md;
+  resetMapTool( &md );
+
+  TestQgsMapToolAdvancedDigitizingUtils utils( mMapTool );
+  utils.mouseClick( 0, 0, Qt::RightButton );
+  QCOMPARE( layer->featureCount(), count );
+
+  utils.keyClick( Qt::Key_Escape );
+
+  utils.mouseClick( 0, 0, Qt::LeftButton );
+  utils.mouseClick( 0, 0, Qt::RightButton );
+  QCOMPARE( layer->featureCount(), count );
+
+  layer->rollBack();
+}
+
+void TestQgsMapToolCircle::testDrawCircleFrom3PointsNotEnoughPoints()
+{
+  QgsVectorLayer *layer = mVectorLayerMap["XY"].get();
+  mCanvas->setCurrentLayer( layer );
+  layer->startEditing();
+  const long long count = layer->featureCount();
+
+  QgsMapToolShapeCircle3PointsMetadata md;
+  resetMapTool( &md );
+
+  TestQgsMapToolAdvancedDigitizingUtils utils( mMapTool );
+  utils.mouseClick( 0, 0, Qt::RightButton );
+  QCOMPARE( layer->featureCount(), count );
+
+  utils.keyClick( Qt::Key_Escape );
+
+  utils.mouseClick( 0, 0, Qt::LeftButton );
+  utils.mouseMove( 1, 1 );
+  utils.mouseClick( 1, 1, Qt::RightButton );
+
+  QCOMPARE( layer->featureCount(), count );
+  layer->rollBack();
+}
+
+void TestQgsMapToolCircle::testDrawCircleFromCenterPointNotEnoughPoints()
+{
+  QgsVectorLayer *layer = mVectorLayerMap["XY"].get();
+  mCanvas->setCurrentLayer( layer );
+  layer->startEditing();
+  const long long count = layer->featureCount();
+
+  QgsMapToolShapeCircleCenterPointMetadata md;
+  resetMapTool( &md );
+  TestQgsMapToolAdvancedDigitizingUtils utils( mMapTool );
+  utils.mouseClick( 0, 0, Qt::RightButton );
+  QCOMPARE( layer->featureCount(), count );
+
+  utils.keyClick( Qt::Key_Escape );
+
+  utils.mouseClick( 0, 0, Qt::LeftButton );
+  utils.mouseClick( 0, 0, Qt::RightButton );
+  QCOMPARE( layer->featureCount(), count );
+  layer->rollBack();
+}
+
+void TestQgsMapToolCircle::testDrawCircleFrom3TangentsNotEnoughPoints()
+{
+  QgsVectorLayer *layer = mVectorLayerMap["XY"].get();
+  mCanvas->setCurrentLayer( layer );
+  layer->startEditing();
+  const long long count = layer->featureCount();
+
+  QgsMapToolShapeCircle3TangentsMetadata md;
+  resetMapTool( &md );
+
+  TestQgsMapToolAdvancedDigitizingUtils utils( mMapTool );
+  utils.mouseClick( 0, 2, Qt::RightButton );
+
+  QCOMPARE( layer->featureCount(), count );
+  layer->rollBack();
+}
+
+void TestQgsMapToolCircle::testDrawCircleFrom2TangentsNotEnoughPoints()
+{
+  QgsVectorLayer *layer = mVectorLayerMap["XY"].get();
+  mCanvas->setCurrentLayer( layer );
+  layer->startEditing();
+  const long long count = layer->featureCount();
+
+  QgsMapToolShapeCircle2TangentsPointMetadata md;
+  resetMapTool( &md );
+
+  TestQgsMapToolAdvancedDigitizingUtils utils( mMapTool );
+  utils.mouseClick( 0, 2, Qt::RightButton );
+
+  QCOMPARE( layer->featureCount(), count );
+  layer->rollBack();
+}
 
 QGSTEST_MAIN( TestQgsMapToolCircle )
 #include "testqgsmaptoolcircle.moc"

tests/src/app/testqgsmaptoolcircularstring.cpp

@@ -41,6 +41,7 @@ class TestQgsMapToolCircularString : public QObject
     void testAddCircularStringCurvePoint();
     void testAddCircularStringRadius();
     void testAddCircularStringRadiusWithDeletedVertex();
+    void testAddCircularStringRadiusNotEnoughPoints();
     void testAddCircularStringAfterClassicDigitizing();
 
   private:
@@ -175,6 +176,34 @@ void TestQgsMapToolCircularString::testAddCircularStringRadiusWithDeletedVertex(
   QgsSettingsRegistryCore::settingsDigitizingDefaultZValue->setValue( 0 );
 }
 
+void TestQgsMapToolCircularString::testAddCircularStringRadiusNotEnoughPoints()
+{
+  const long long count = mLayer->featureCount();
+  mLayer->startEditing();
+
+  QgsMapToolShapeCircularStringRadiusMetadata md;
+  resetMapTool( &md );
+
+  TestQgsMapToolAdvancedDigitizingUtils utils( mMapTool );
+  utils.mouseClick( 0, 0, Qt::RightButton );
+  QCOMPARE( mLayer->featureCount(), count );
+
+  utils.keyClick( Qt::Key_Escape );
+  utils.mouseClick( 1, 1, Qt::LeftButton );
+  utils.mouseMove( 2, 2 );
+  utils.mouseClick( 2, 2, Qt::RightButton );
+  QCOMPARE( mLayer->featureCount(), count );
+
+  utils.keyClick( Qt::Key_Escape );
+  utils.mouseClick( 1, 1, Qt::LeftButton );
+  utils.mouseClick( 2, 2, Qt::LeftButton );
+  utils.mouseMove( 1, 2 );
+  utils.mouseClick( 1, 2, Qt::RightButton );
+  QCOMPARE( mLayer->featureCount(), count );
+
+  mLayer->rollBack();
+}
+
 void TestQgsMapToolCircularString::testAddCircularStringAfterClassicDigitizing()
 {
   QgsSettingsRegistryCore::settingsDigitizingDefaultZValue->setValue( 333 );

tests/src/app/testqgsmaptoolellipse.cpp

@@ -46,6 +46,11 @@ class TestQgsMapToolEllipse : public QObject
     void testEllipse_data();
     void testEllipse();
 
+    void testEllipseFromCenterAndPointNotEnoughPoints();
+    void testEllipseFromCenterAnd2PointsNotEnoughPoints();
+    void testEllipseFromExtentNotEnoughPoints();
+    void testEllipseFromFociNotEnoughPoints();
+
   private:
     QgisApp *mQgisApp = nullptr;
     QgsMapToolCapture *mMapTool = nullptr;
@@ -450,6 +455,115 @@ void TestQgsMapToolEllipse::testEllipse()
   QCOMPARE( wktGeometry, wktExpected );
 }
 
+void TestQgsMapToolEllipse::testEllipseFromCenterAndPointNotEnoughPoints()
+{
+  QgsVectorLayer *layer = mVectorLayerMap["XY"].get();
+  mCanvas->setCurrentLayer( layer );
+  layer->startEditing();
+  const long long count = layer->featureCount();
+
+  QgsMapToolShapeEllipseCenterPointMetadata md;
+  resetMapTool( &md );
+
+  TestQgsMapToolAdvancedDigitizingUtils utils( mMapTool );
+  utils.mouseClick( 0, 0, Qt::RightButton );
+  QCOMPARE( layer->featureCount(), count );
+
+  utils.keyClick( Qt::Key_Escape );
+
+  utils.mouseClick( 0, 0, Qt::LeftButton );
+  utils.mouseClick( 0, 0, Qt::RightButton );
+  QCOMPARE( layer->featureCount(), count );
+
+  layer->rollBack();
+}
+
+void TestQgsMapToolEllipse::testEllipseFromCenterAnd2PointsNotEnoughPoints()
+{
+  QgsVectorLayer *layer = mVectorLayerMap["XY"].get();
+  mCanvas->setCurrentLayer( layer );
+  layer->startEditing();
+  const long long count = layer->featureCount();
+
+  QgsMapToolShapeEllipseCenter2PointsMetadata md;
+  resetMapTool( &md );
+
+  TestQgsMapToolAdvancedDigitizingUtils utils( mMapTool );
+  utils.mouseClick( 0, 0, Qt::RightButton );
+  QCOMPARE( layer->featureCount(), count );
+
+  utils.keyClick( Qt::Key_Escape );
+
+  utils.mouseClick( 0, 0, Qt::LeftButton );
+  utils.mouseMove( 1, 1 );
+  utils.mouseClick( 1, 1, Qt::RightButton );
+  QCOMPARE( layer->featureCount(), count );
+
+  utils.keyClick( Qt::Key_Escape );
+
+  utils.mouseClick( 0, 0, Qt::LeftButton );
+  utils.mouseMove( 1, 1 );
+  utils.mouseClick( 1, 1, Qt::LeftButton );
+  utils.mouseClick( 1, 1, Qt::RightButton );
+  QCOMPARE( layer->featureCount(), count );
+
+  layer->rollBack();
+}
+
+void TestQgsMapToolEllipse::testEllipseFromExtentNotEnoughPoints()
+{
+  QgsVectorLayer *layer = mVectorLayerMap["XY"].get();
+  mCanvas->setCurrentLayer( layer );
+  layer->startEditing();
+  const long long count = layer->featureCount();
+
+  QgsMapToolShapeEllipseExtentMetadata md;
+  resetMapTool( &md );
+
+  TestQgsMapToolAdvancedDigitizingUtils utils( mMapTool );
+  utils.mouseClick( 0, 0, Qt::RightButton );
+  QCOMPARE( layer->featureCount(), count );
+
+  utils.keyClick( Qt::Key_Escape );
+
+  utils.mouseClick( 0, 0, Qt::LeftButton );
+  utils.mouseClick( 0, 0, Qt::RightButton );
+  QCOMPARE( layer->featureCount(), count );
+
+  layer->rollBack();
+}
+
+void TestQgsMapToolEllipse::testEllipseFromFociNotEnoughPoints()
+{
+  QgsVectorLayer *layer = mVectorLayerMap["XY"].get();
+  mCanvas->setCurrentLayer( layer );
+  layer->startEditing();
+  const long long count = layer->featureCount();
+
+  QgsMapToolShapeEllipseFociMetadata md;
+  resetMapTool( &md );
+
+  TestQgsMapToolAdvancedDigitizingUtils utils( mMapTool );
+  utils.mouseClick( 0, 0, Qt::RightButton );
+  QCOMPARE( layer->featureCount(), count );
+
+  utils.keyClick( Qt::Key_Escape );
+
+  utils.mouseClick( 0, 0, Qt::LeftButton );
+  utils.mouseClick( 0, 0, Qt::RightButton );
+  QCOMPARE( layer->featureCount(), count );
+
+  utils.keyClick( Qt::Key_Escape );
+
+  utils.mouseClick( 0, 0, Qt::LeftButton );
+  utils.mouseMove( 1, 1 );
+  utils.mouseClick( 1, 1, Qt::LeftButton );
+  utils.mouseClick( 1, 1, Qt::RightButton );
+  QCOMPARE( layer->featureCount(), count );
+
+  layer->rollBack();
+}
+
 
 QGSTEST_MAIN( TestQgsMapToolEllipse )
 #include "testqgsmaptoolellipse.moc"

tests/src/app/testqgsmaptoolrectangle.cpp

@@ -43,12 +43,16 @@ class TestQgsMapToolRectangle : public QObject
 
     void testRectangleFromCenter();
     void testRectangleFromCenterWithDeletedVertex();
+    void testRectangleFromCenterNotEnoughPoints();
     void testRectangleFromExtent();
     void testRectangleFromExtentWithDeletedVertex();
+    void testRectangleFromExtentNotEnoughPoints();
     void testRectangleFrom3PointsDistance();
     void testRectangleFrom3PointsDistanceWithDeletedVertex();
+    void testRectangleFrom3PointsDistanceNotEnoughPoints();
     void testRectangleFrom3PointsProjected();
     void testRectangleFrom3PointsProjectedWithDeletedVertex();
+    void testRectangleFrom3PointsProjectedNotEnoughPoints();
 
   private:
     void resetMapTool( QgsMapToolShapeMetadata *metadata );
@@ -157,6 +161,27 @@ void TestQgsMapToolRectangle::testRectangleFromCenterWithDeletedVertex()
   QgsSettingsRegistryCore::settingsDigitizingDefaultZValue->setValue( 0 );
 }
 
+void TestQgsMapToolRectangle::testRectangleFromCenterNotEnoughPoints()
+{
+  const long long count = mLayer->featureCount();
+  mLayer->startEditing();
+
+  QgsMapToolShapeRectangleCenterMetadata md;
+  resetMapTool( &md );
+
+  TestQgsMapToolAdvancedDigitizingUtils utils( mMapTool );
+  utils.mouseClick( 0, 0, Qt::RightButton );
+  QCOMPARE( mLayer->featureCount(), count );
+
+  utils.keyClick( Qt::Key_Escape );
+
+  utils.mouseClick( 0, 0, Qt::LeftButton );
+  utils.mouseClick( 0, 0, Qt::RightButton );
+  QCOMPARE( mLayer->featureCount(), count );
+
+  mLayer->rollBack();
+}
+
 void TestQgsMapToolRectangle::testRectangleFromExtent()
 {
   QgsSettingsRegistryCore::settingsDigitizingDefaultZValue->setValue( 222 );
@@ -210,6 +235,27 @@ void TestQgsMapToolRectangle::testRectangleFromExtentWithDeletedVertex()
   QgsSettingsRegistryCore::settingsDigitizingDefaultZValue->setValue( 0 );
 }
 
+void TestQgsMapToolRectangle::testRectangleFromExtentNotEnoughPoints()
+{
+  const long long count = mLayer->featureCount();
+  mLayer->startEditing();
+
+  QgsMapToolShapeRectangleExtentMetadata md;
+  resetMapTool( &md );
+
+  TestQgsMapToolAdvancedDigitizingUtils utils( mMapTool );
+  utils.mouseClick( 0, 0, Qt::RightButton );
+  QCOMPARE( mLayer->featureCount(), count );
+
+  utils.keyClick( Qt::Key_Escape );
+
+  utils.mouseClick( 0, 0, Qt::LeftButton );
+  utils.mouseClick( 0, 0, Qt::RightButton );
+  QCOMPARE( mLayer->featureCount(), count );
+
+  mLayer->rollBack();
+}
+
 
 void TestQgsMapToolRectangle::testRectangleFrom3PointsDistance()
 {
@@ -268,6 +314,35 @@ void TestQgsMapToolRectangle::testRectangleFrom3PointsDistanceWithDeletedVertex(
   QgsSettingsRegistryCore::settingsDigitizingDefaultZValue->setValue( 0 );
 }
 
+void TestQgsMapToolRectangle::testRectangleFrom3PointsDistanceNotEnoughPoints()
+{
+  const long long count = mLayer->featureCount();
+  mLayer->startEditing();
+
+  QgsMapToolShapeRectangle3PointsMetadata md( QgsMapToolShapeRectangle3PointsMetadata::CreateMode::Distance );
+  resetMapTool( &md );
+
+  TestQgsMapToolAdvancedDigitizingUtils utils( mMapTool );
+  utils.mouseClick( 0, 0, Qt::RightButton );
+  QCOMPARE( mLayer->featureCount(), count );
+
+  utils.keyClick( Qt::Key_Escape );
+
+  utils.mouseClick( 0, 0, Qt::LeftButton );
+  utils.mouseMove( 1, 1 );
+  utils.mouseClick( 1, 1, Qt::RightButton );
+  QCOMPARE( mLayer->featureCount(), count );
+
+  utils.keyClick( Qt::Key_Escape );
+
+  utils.mouseClick( 0, 0, Qt::LeftButton );
+  utils.mouseClick( 1, 1, Qt::LeftButton );
+  utils.mouseClick( 1, 1, Qt::RightButton );
+  QCOMPARE( mLayer->featureCount(), count );
+
+  mLayer->rollBack();
+}
+
 void TestQgsMapToolRectangle::testRectangleFrom3PointsProjected()
 {
   QgsSettingsRegistryCore::settingsDigitizingDefaultZValue->setValue( 111 );
@@ -324,5 +399,34 @@ void TestQgsMapToolRectangle::testRectangleFrom3PointsProjectedWithDeletedVertex
   mLayer->rollBack();
   QgsSettingsRegistryCore::settingsDigitizingDefaultZValue->setValue( 0 );
 }
+
+void TestQgsMapToolRectangle::testRectangleFrom3PointsProjectedNotEnoughPoints()
+{
+  const long long count = mLayer->featureCount();
+  mLayer->startEditing();
+
+  QgsMapToolShapeRectangle3PointsMetadata md( QgsMapToolShapeRectangle3PointsMetadata::CreateMode::Projected );
+  resetMapTool( &md );
+
+  TestQgsMapToolAdvancedDigitizingUtils utils( mMapTool );
+  utils.mouseClick( 0, 0, Qt::RightButton );
+  QCOMPARE( mLayer->featureCount(), count );
+
+  utils.keyClick( Qt::Key_Escape );
+
+  utils.mouseClick( 0, 0, Qt::LeftButton );
+  utils.mouseMove( 1, 1 );
+  utils.mouseClick( 1, 1, Qt::RightButton );
+  QCOMPARE( mLayer->featureCount(), count );
+
+  utils.keyClick( Qt::Key_Escape );
+
+  utils.mouseClick( 0, 0, Qt::LeftButton );
+  utils.mouseClick( 1, 1, Qt::LeftButton );
+  utils.mouseClick( 1, 1, Qt::RightButton );
+  QCOMPARE( mLayer->featureCount(), count );
+
+  mLayer->rollBack();
+}
 QGSTEST_MAIN( TestQgsMapToolRectangle )
 #include "testqgsmaptoolrectangle.moc"

tests/src/app/testqgsmaptoolregularpolygon.cpp

@@ -43,10 +43,13 @@ class TestQgsMapToolRegularPolygon : public QObject
 
     void testRegularPolygonFrom2Points();
     void testRegularPolygonFrom2PointsWithDeletedVertex();
+    void testRegularPolygonFrom2PointsNotEnoughPoints();
     void testRegularPolygonFromCenterAndPoint();
     void testRegularPolygonFromCenterAndPointWithDeletedVertex();
-    void testRegularPolygonFromCenterAndCroner();
+    void testRegularPolygonFromCenterAndPointNotEnoughPoints();
-    void testRegularPolygonFromCenterAndCronerWithDeletedVertex();
+    void testRegularPolygonFromCenterAndCorner();
+    void testRegularPolygonFromCenterAndCornerWithDeletedVertex();
+    void testRegularPolygonFromCenterAndCornerNotEnoughPoints();
 
   private:
     void resetMapTool( QgsMapToolShapeMetadata *metadata );
@@ -150,6 +153,27 @@ void TestQgsMapToolRegularPolygon::testRegularPolygonFrom2PointsWithDeletedVerte
   QgsSettingsRegistryCore::settingsDigitizingDefaultZValue->setValue( 0 );
 }
 
+void TestQgsMapToolRegularPolygon::testRegularPolygonFrom2PointsNotEnoughPoints()
+{
+  const long long count = mLayer->featureCount();
+  mLayer->startEditing();
+
+  QgsMapToolShapeRegularPolygon2PointsMetadata md;
+  resetMapTool( &md );
+
+  TestQgsMapToolAdvancedDigitizingUtils utils( mMapTool );
+  utils.mouseClick( 0, 0, Qt::RightButton );
+  QCOMPARE( mLayer->featureCount(), count );
+
+  utils.keyClick( Qt::Key_Escape );
+
+  utils.mouseClick( 0, 0, Qt::LeftButton );
+  utils.mouseClick( 0, 0, Qt::RightButton );
+  QCOMPARE( mLayer->featureCount(), count );
+
+  mLayer->rollBack();
+}
+
 
 void TestQgsMapToolRegularPolygon::testRegularPolygonFromCenterAndPoint()
 {
@@ -200,8 +224,29 @@ void TestQgsMapToolRegularPolygon::testRegularPolygonFromCenterAndPointWithDelet
   QgsSettingsRegistryCore::settingsDigitizingDefaultZValue->setValue( 0 );
 }
 
+void TestQgsMapToolRegularPolygon::testRegularPolygonFromCenterAndPointNotEnoughPoints()
+{
+  const long long count = mLayer->featureCount();
+  mLayer->startEditing();
 
-void TestQgsMapToolRegularPolygon::testRegularPolygonFromCenterAndCroner()
+  QgsMapToolShapeRegularPolygonCenterPointMetadata md;
+  resetMapTool( &md );
+
+  TestQgsMapToolAdvancedDigitizingUtils utils( mMapTool );
+  utils.mouseClick( 0, 0, Qt::RightButton );
+  QCOMPARE( mLayer->featureCount(), count );
+
+  utils.keyClick( Qt::Key_Escape );
+
+  utils.mouseClick( 0, 0, Qt::LeftButton );
+  utils.mouseClick( 0, 0, Qt::RightButton );
+  QCOMPARE( mLayer->featureCount(), count );
+
+  mLayer->rollBack();
+}
+
+
+void TestQgsMapToolRegularPolygon::testRegularPolygonFromCenterAndCorner()
 {
   QgsSettingsRegistryCore::settingsDigitizingDefaultZValue->setValue( 111 );
   mLayer->startEditing();
@@ -224,7 +269,8 @@ void TestQgsMapToolRegularPolygon::testRegularPolygonFromCenterAndCroner()
   mLayer->rollBack();
   QgsSettingsRegistryCore::settingsDigitizingDefaultZValue->setValue( 0 );
 }
-void TestQgsMapToolRegularPolygon::testRegularPolygonFromCenterAndCronerWithDeletedVertex()
+
+void TestQgsMapToolRegularPolygon::testRegularPolygonFromCenterAndCornerWithDeletedVertex()
 {
   QgsSettingsRegistryCore::settingsDigitizingDefaultZValue->setValue( 111 );
   mLayer->startEditing();
@@ -250,6 +296,27 @@ void TestQgsMapToolRegularPolygon::testRegularPolygonFromCenterAndCronerWithDele
   QgsSettingsRegistryCore::settingsDigitizingDefaultZValue->setValue( 0 );
 }
 
+void TestQgsMapToolRegularPolygon::testRegularPolygonFromCenterAndCornerNotEnoughPoints()
+{
+  const long long count = mLayer->featureCount();
+  mLayer->startEditing();
+
+  QgsMapToolShapeRegularPolygonCenterCornerMetadata md;
+  resetMapTool( &md );
+
+  TestQgsMapToolAdvancedDigitizingUtils utils( mMapTool );
+  utils.mouseClick( 0, 0, Qt::RightButton );
+  QCOMPARE( mLayer->featureCount(), count );
+
+  utils.keyClick( Qt::Key_Escape );
+
+  utils.mouseClick( 0, 0, Qt::LeftButton );
+  utils.mouseClick( 0, 0, Qt::RightButton );
+  QCOMPARE( mLayer->featureCount(), count );
+
+  mLayer->rollBack();
+}
+
 
 QGSTEST_MAIN( TestQgsMapToolRegularPolygon )
 #include "testqgsmaptoolregularpolygon.moc"