negative norwegian test2

.github/workflows/run-tests.yml

@@ -37,21 +37,6 @@ jobs:
     strategy:
       matrix:
         include:
-          - distro-version: '22.04'
-            qt-version: 5
-            run-tests: true
-            docker-tag-suffix: ''
-            with-qt6: OFF
-            with-qt5: ON
-            with-3d: ON
-            with-quick: ON
-            with-clazy: ON
-            with-grass7: OFF
-            with-grass8: OFF
-            with-compile-commands: ON
-            # LD_PRELOAD: /lib/x86_64-linux-gnu/libSegFault.so
-            experimental: false
-
           - distro-version: '38'
             qt-version: 6
             run-tests: true
@@ -290,23 +275,14 @@ jobs:
 
     strategy:
       matrix:
-        qt-version: [5, 6]
-        test-batch: [ALL_BUT_PROVIDERS, POSTGRES, HANA]
+        qt-version: [6]
+        test-batch: [ALL_BUT_PROVIDERS]
 
         include:
-          - qt-version: 5
-            distro-version: 22.04
-            docker-target: binary-only
-
           - qt-version: 6
             distro-version: 38
             docker-target: single
 
-          - qt-version: 5
-            distro-version: 22.04
-            test-batch: ORACLE
-            docker-target: binary-for-oracle
-
         exclude:
           - qt-version: 6
             test-batch: HANA

src/gui/qgsdoublevalidator.cpp

@@ -25,15 +25,18 @@
 
 #include "qgsdoublevalidator.h"
 
-const QString PERMISSIVE_DOUBLE = R"([+\-%3]?[\d]{0,1000}([\.%1][\d]{0,1000})?(e[+\-%3]?[\d]{0,%2})?)";
+const QString PERMISSIVE_DOUBLE = R"([+\-%3]?[\d]{0,1000}([\.%1][\d]{0,%2})?([eE%4][+\-%3]?[\d]{0,3})?)";
 
 QgsDoubleValidator::QgsDoubleValidator( QObject *parent )
   : QRegularExpressionValidator( parent )
   , mMinimum( std::numeric_limits<qreal>::lowest() )
   , mMaximum( std::numeric_limits<qreal>::max() )
 {
   // The regular expression accept double with point as decimal point but also the locale decimal point
-  const QRegularExpression reg( PERMISSIVE_DOUBLE.arg( locale().decimalPoint() ).arg( 1000 ).arg( locale().negativeSign() ) );
+  const QRegularExpression reg( PERMISSIVE_DOUBLE.arg( QLocale().decimalPoint() )
+                                .arg( QString::number( 1000 ) )
+                                .arg( QLocale().negativeSign() )
+                                .arg( QLocale().exponential() ) );
   setRegularExpression( reg );
 }
 
@@ -51,7 +54,10 @@ QgsDoubleValidator::QgsDoubleValidator( double bottom, double top, QObject *pare
   , mMaximum( top )
 {
   // The regular expression accept double with point as decimal point but also the locale decimal point
-  const QRegularExpression reg( PERMISSIVE_DOUBLE.arg( locale().decimalPoint() ).arg( 1000 ).arg( locale().negativeSign() ) );
+  const QRegularExpression reg( PERMISSIVE_DOUBLE.arg( QLocale().decimalPoint() )
+                                .arg( QString::number( 1000 ) )
+                                .arg( QLocale().negativeSign() )
+                                .arg( QLocale().exponential() ) );
   setRegularExpression( reg );
 }
 
@@ -61,7 +67,10 @@ QgsDoubleValidator::QgsDoubleValidator( double bottom, double top, int decimal,
   , mMaximum( top )
 {
   // The regular expression accept double with point as decimal point but also the locale decimal point
-  const QRegularExpression reg( PERMISSIVE_DOUBLE.arg( locale().decimalPoint() ).arg( QString::number( decimal ) ).arg( locale().negativeSign() ) );
+  const QRegularExpression reg( PERMISSIVE_DOUBLE.arg( QLocale().decimalPoint() )
+                                .arg( QString::number( decimal ) )
+                                .arg( QLocale().negativeSign() )
+                                .arg( QLocale().exponential() ) );
   setRegularExpression( reg );
 }
 
@@ -71,13 +80,19 @@ QgsDoubleValidator::QgsDoubleValidator( int decimal, QObject *parent )
   , mMaximum( std::numeric_limits<qreal>::max() )
 {
   // The regular expression accept double with point as decimal point but also the locale decimal point
-  const QRegularExpression reg( PERMISSIVE_DOUBLE.arg( locale().decimalPoint() ).arg( QString::number( decimal ) ).arg( locale().negativeSign() ) );
+  const QRegularExpression reg( PERMISSIVE_DOUBLE.arg( QLocale().decimalPoint() )
+                                .arg( QString::number( decimal ) )
+                                .arg( QLocale().negativeSign() )
+                                .arg( QLocale().exponential() ) );
   setRegularExpression( reg );
 }
 
 void QgsDoubleValidator::setMaxDecimals( int maxDecimals )
 {
-  const QRegularExpression reg( PERMISSIVE_DOUBLE.arg( locale().decimalPoint() ).arg( QString::number( maxDecimals ) ).arg( locale().negativeSign() ) );
+  const QRegularExpression reg( PERMISSIVE_DOUBLE.arg( QLocale().decimalPoint() )
+                                .arg( QString::number( maxDecimals ) )
+                                .arg( QLocale().negativeSign() )
+                                .arg( QLocale().exponential() ) );
   setRegularExpression( reg );
 }
 
@@ -142,7 +157,7 @@ double QgsDoubleValidator::toDouble( const QString &input, bool *ok )
   // Still non ok? Try without locale's group separator
   if ( ! *ok && !( QLocale().numberOptions() & QLocale::NumberOption::OmitGroupSeparator ) )
   {
-    value = QLocale( ).toDouble( QString( input ).replace( QLocale().groupSeparator(), QString() ), ok );
+    value = QLocale().toDouble( QString( input ).replace( QLocale().groupSeparator(), QString() ), ok );
   }
   return value ;
 }

tests/src/gui/testqgsdoublevalidator.cpp

@@ -70,6 +70,17 @@ void TestQgsDoubleValidator::validate_data()
 
   QTest::newRow( "positive sign C decimal" ) << QString( "+4cd6" ) << int( QValidator::Acceptable ) << false;
 
+  QTest::newRow( "exponent <e> C negative" ) << QString( "44446ecn1" ) << int( QValidator::Acceptable ) << false;
+  QTest::newRow( "exponent <e> locale negative" ) << QString( "44446eln1" ) << int( QValidator::Acceptable ) << false;
+  QTest::newRow( "locale decimal exponent <E> positive" ) << QString( "444ld46E1" ) << int( QValidator::Acceptable ) << false;
+  QTest::newRow( "locale decimal exponent <E> positive sign" ) << QString( "444ld46E+1" ) << int( QValidator::Acceptable ) << false;
+  QTest::newRow( "locale exponent locale negative" ) << QString( "4446leln1" ) << int( QValidator::Acceptable ) << false;
+
+  QTest::newRow( "exponent <e> without digits" ) << QString( "4446e" ) << int( QValidator::Intermediate ) << false;
+  QTest::newRow( "exponent <e> with 4 digits" ) << QString( "44cd46e0001" ) << int( QValidator::Intermediate ) << false;
+
+  QTest::newRow( "locale decimal with many decimals exponent <e>" ) << QString( "0ld00000000000000000000000000000123e30" ) << int( QValidator::Acceptable ) << false;
+
   // QgsDoubleValidator doesn't expect group separator but it tolerates it,
   // so the result will be QValidator::Intermediate and not QValidator::Acceptable
   QTest::newRow( "locale group separator + locale decimal" ) << QString( "4lg444ld6" ) << int( QValidator::Intermediate ) << false;
@@ -99,6 +110,17 @@ void TestQgsDoubleValidator::toDouble_data()
 
   QTest::newRow( "positive sign C decimal" ) << QString( "+4cd6" ) << 4.6;
 
+  QTest::newRow( "exponent <e> C negative" ) << QString( "44446ecn1" ) << 4444.6;
+  QTest::newRow( "exponent <e> locale negative" ) << QString( "44446eln1" ) << 4444.6;
+  QTest::newRow( "locale decimal exponent <E> positive" ) << QString( "444ld46E1" ) << 4444.6;
+  QTest::newRow( "locale decimal exponent <E> positive sign" ) << QString( "444ld46E+1" ) << 4444.6;
+  QTest::newRow( "locale exponent locale negative" ) << QString( "44446leln1" ) << 4444.6;
+
+  QTest::newRow( "exponent <e> without digits" ) << QString( "4446e" ) << 0.0;
+  QTest::newRow( "exponent <e> with 4 digits" ) << QString( "44cd46e0001" ) << 444.6;
+
+  QTest::newRow( "locale decimal with many decimals and exponent <e>" ) << QString( "0ld00000000000000000000000000000123e30" ) << 1.23;
+
   // QgsDoubleValidator doesn't expect group separator but it tolerates it,
   // so the result will be QValidator::Intermediate and not QValidator::Acceptable
   QTest::newRow( "locale group separator + locale decimal" ) << QString( "4lg444ld6" ) << 4444.6;
@@ -116,35 +138,36 @@ void TestQgsDoubleValidator::toDouble_data()
 void TestQgsDoubleValidator::validate()
 {
   QLineEdit *lineEdit = new QLineEdit();
-  QgsDoubleValidator *validator = new QgsDoubleValidator( lineEdit );
 
   QFETCH( QString, actualState );
   QFETCH( int, expState );
   QFETCH( bool, negative );
   QString value;
   int expectedValue;
 
-  if ( negative )
-    validator->setRange( -10000, -4 );
-  else
-    validator->setRange( 4, 10000 );
-
-  lineEdit->setValidator( validator );
-
-  const QVector<QLocale>listLocale( {QLocale::English, QLocale::French, QLocale::German, QLocale::Italian, QLocale::NorwegianBokmal} );
+  const QVector<QLocale>listLocale( {QLocale::English, QLocale::French, QLocale::German, QLocale::Italian, QLocale::NorwegianBokmal, QLocale::Ukrainian} );
   QLocale loc;
   for ( int i = 0; i < listLocale.count(); ++i )
   {
     loc = listLocale.at( i );
     QLocale::setDefault( loc );
+
+    QgsDoubleValidator *validator = new QgsDoubleValidator( lineEdit );
+    if ( negative )
+      validator->setRange( -10000, -4 );
+    else
+      validator->setRange( 4, 10000 );
     validator->setLocale( loc );
+    lineEdit->setValidator( validator );
+
     value = actualState;
     value = value.replace( "ld", QLocale().decimalPoint() )
             .replace( "cd", QLocale( QLocale::C ).decimalPoint() )
             .replace( "lg", QLocale().groupSeparator() )
             .replace( "cg", QLocale( QLocale::C ).groupSeparator() )
             .replace( "ln", QLocale().negativeSign() )
-            .replace( "cn", QLocale( QLocale::C ).negativeSign() );
+            .replace( "cn", QLocale( QLocale::C ).negativeSign() )
+            .replace( "le", QLocale().exponential() );
     expectedValue = expState;
     // if the local group separator / decimal point is equal to the C one,
     // expected result will be different for double with test with mixed
@@ -159,19 +182,19 @@ void TestQgsDoubleValidator::validate()
     //                       and validator->validate(4cg444cd6) == 1 and not 0
     if ( ( QLocale( QLocale::C ).groupSeparator() == QLocale().groupSeparator() ||
            QLocale( QLocale::C ).decimalPoint() == QLocale().decimalPoint() )
-         && value != "string" && expectedValue == 0 )
+         && value != "string" && value != "4446e" && expectedValue == 0 )
       expectedValue = 1;
     // There is another corner case in the test where the group separator is equal
     // to the C decimal point and there is no decimal point,
     // in that case the value is valid, because the fall
     // back check is to test after removing all group separators
-    if ( QLocale( ).groupSeparator() == QLocale( QLocale::C ).decimalPoint()
-         && ! value.contains( QLocale( ).decimalPoint() )
-         && value != "string" && expectedValue == 0 )
+    if ( QLocale().groupSeparator() == QLocale( QLocale::C ).decimalPoint()
+         && ! value.contains( QLocale().decimalPoint() )
+         && value != "string" && value != "4446e" && expectedValue == 0 )
     {
       expectedValue = 1;
     }
-    // qDebug() << value << loc << int( validator->validate( value ) ) << expectedValue;
+    //qDebug() << value << loc << int( validator->validate( value ) ) << expectedValue;
     QCOMPARE( int( validator->validate( value ) ), expectedValue );
   }
 }
@@ -183,7 +206,7 @@ void TestQgsDoubleValidator::toDouble()
   QString value;
   double expectedValue;
 
-  const QVector<QLocale>listLocale( {QLocale::English, QLocale::French, QLocale::German, QLocale::Italian, QLocale::NorwegianBokmal} );
+  const QVector<QLocale>listLocale( {QLocale::English, QLocale::French, QLocale::German, QLocale::Italian, QLocale::NorwegianBokmal, QLocale::Ukrainian} );
   QLocale loc;
   for ( int i = 0; i < listLocale.count(); ++i )
   {
@@ -195,7 +218,8 @@ void TestQgsDoubleValidator::toDouble()
             .replace( "lg", QLocale().groupSeparator() )
             .replace( "cg", QLocale( QLocale::C ).groupSeparator() )
             .replace( "ln", QLocale().negativeSign() )
-            .replace( "cn", QLocale( QLocale::C ).negativeSign() );
+            .replace( "cn", QLocale( QLocale::C ).negativeSign() )
+            .replace( "le", QLocale().exponential() );
     expectedValue = expValue;
     // if the local group separator / decimal point is equal to the C one,
     // expected result will be different for double with test with mixed
@@ -210,15 +234,15 @@ void TestQgsDoubleValidator::toDouble()
     //                       and QgsDoubleValidator::toDouble(4cg444cd6) == 4444.6 and not 0.0
     if ( ( QLocale( QLocale::C ).groupSeparator() == QLocale().groupSeparator() ||
            QLocale( QLocale::C ).decimalPoint() == QLocale().decimalPoint() )
-         && value != "string" && expectedValue == 0.0 )
+         && value != "string" && value != "4446e" && expectedValue == 0.0 )
       expectedValue = 4444.6;
     // There is another corner case in the test where the group separator is equal
     // to the C decimal point and there is no decimal point,
     // in that case the value is valid, because the fall
     // back check is to test after removing all group separators
-    if ( QLocale( ).groupSeparator() == QLocale( QLocale::C ).decimalPoint()
-         && ! value.contains( QLocale( ).decimalPoint() )
-         && value != "string" && expectedValue == 0 )
+    if ( QLocale().groupSeparator() == QLocale( QLocale::C ).decimalPoint()
+         && ! value.contains( QLocale().decimalPoint() )
+         && value != "string" && value != "4446e" && expectedValue == 0 )
     {
       expectedValue = 44446;
     }