diff --git a/app/attributes/fieldvalidator.cpp b/app/attributes/fieldvalidator.cpp index b5d2922a5..a29533c7a 100644 --- a/app/attributes/fieldvalidator.cpp +++ b/app/attributes/fieldvalidator.cpp @@ -12,12 +12,26 @@ #include "featurelayerpair.h" #include "mixedattributevalue.h" -#include "qgsfield.h" -#include "qgsvectorlayerutils.h" +#include +#include #include #include +QString FieldValidator::numberInvalid() { return tr( "Value must be a number" ); }; +QString FieldValidator::numberUpperBoundReached() { return tr( "Value must be lower than %1" ); }; +QString FieldValidator::numberLowerBoundReached() { return tr( "Value must be higher than %1" ); }; +QString FieldValidator::numberExceedingVariableLimits() { return tr( "Value is too large" );}; +QString FieldValidator::numberMustBeInt() { return tr( "Field can not contain decimal places" );}; +QString FieldValidator::textTooLong() { return tr( "Can not be longer than %1 characters" );}; +QString FieldValidator::softNotNullFailed() { return tr( "Field should not be empty" );}; +QString FieldValidator::hardNotNullFailed() { return tr( "Field must not be empty" );}; +QString FieldValidator::softUniqueFailed() { return tr( "Value should be unique" );}; +QString FieldValidator::hardUniqueFailed() { return tr( "Value must be unique" );}; +QString FieldValidator::softExpressionFailed() { return tr( "Unmet QGIS expression constraint" );}; +QString FieldValidator::hardExpressionFailed() { return tr( "Unmet QGIS expression constraint" );}; +QString FieldValidator::genericValidationFailed() { return tr( "Not a valid value" );}; + FieldValidator::FieldValidator( QObject *parent ) : QObject( parent ) { @@ -42,7 +56,7 @@ FieldValidator::ValidationStatus FieldValidator::validate( const FeatureLayerPai if ( value.userType() == qMetaTypeId() ) return Valid; - bool isNumeric = item.editorWidgetType() == QStringLiteral( "Range" ) || field.isNumeric(); + const bool isNumeric = item.editorWidgetType() == QStringLiteral( "Range" ) || field.isNumeric(); if ( isNumeric ) { state = validateNumericField( item, value, validationMessage ); @@ -62,7 +76,7 @@ FieldValidator::ValidationStatus FieldValidator::validate( const FeatureLayerPai // Continue to check hard and soft QGIS constraints QStringList errors; - bool hardConstraintSatisfied = QgsVectorLayerUtils::validateAttribute( pair.layer(), pair.feature(), item.fieldIndex(), errors, QgsFieldConstraints::ConstraintStrengthHard ); + const bool hardConstraintSatisfied = QgsVectorLayerUtils::validateAttribute( pair.layer(), pair.feature(), item.fieldIndex(), errors, QgsFieldConstraints::ConstraintStrengthHard ); if ( !hardConstraintSatisfied ) { validationMessage = constructConstraintValidationMessage( item, errors ); @@ -71,7 +85,7 @@ FieldValidator::ValidationStatus FieldValidator::validate( const FeatureLayerPai errors.clear(); - bool softConstraintSatisfied = QgsVectorLayerUtils::validateAttribute( pair.layer(), pair.feature(), item.fieldIndex(), errors, QgsFieldConstraints::ConstraintStrengthSoft ); + const bool softConstraintSatisfied = QgsVectorLayerUtils::validateAttribute( pair.layer(), pair.feature(), item.fieldIndex(), errors, QgsFieldConstraints::ConstraintStrengthSoft ); if ( !softConstraintSatisfied ) { validationMessage = constructConstraintValidationMessage( item, errors ); @@ -88,18 +102,18 @@ FieldValidator::ValidationStatus FieldValidator::validateTextField( const FormIt // Check if the text is not too long for the field if ( field.length() > 0 ) { - const int vLength = value.toString().length(); + const int vLength = static_cast( value.toString().length() ); if ( vLength > field.length() ) { - validationMessage = ValidationTexts::textTooLong.arg( field.length() ); + validationMessage = textTooLong().arg( field.length() ); return Error; } } if ( !field.convertCompatible( value ) ) { - validationMessage = ValidationTexts::genericValidationFailed; + validationMessage = genericValidationFailed(); return Error; } @@ -117,7 +131,7 @@ FieldValidator::ValidationStatus FieldValidator::validateNumericField( const For // in Qt 6 isNull() does not return true for true if the variant contained an object // of a builtin type with an isNull() method that returned true for that object. - // So isNull() for QVariant( QString() ) will return false and we need to handle this + // So isNull() for QVariant( QString() ) will return false, and we need to handle this // separately. if ( value.userType() == QVariant::String && value.toString().isEmpty() ) { @@ -126,17 +140,17 @@ FieldValidator::ValidationStatus FieldValidator::validateNumericField( const For QString errorMessage; - bool containsDecimals = value.toString().contains( QLocale().decimalPoint() ) || value.toString().contains( "." ); + const bool containsDecimals = value.toString().contains( QLocale().decimalPoint() ) || value.toString().contains( "." ); if ( !field.convertCompatible( value, &errorMessage ) ) { if ( errorMessage.contains( QStringLiteral( "too large" ) ) ) { - validationMessage = ValidationTexts::numberExceedingVariableLimits; + validationMessage = numberExceedingVariableLimits(); } else { - validationMessage = ValidationTexts::numberInvalid; + validationMessage = numberInvalid(); } return Error; @@ -147,28 +161,28 @@ FieldValidator::ValidationStatus FieldValidator::validateNumericField( const For * however, the value would not be saved and would get replaced by zero, * so we need to handle it here and set invalid state for such input. */ - validationMessage = ValidationTexts::numberMustBeInt; + validationMessage = numberMustBeInt(); return Error; } - bool isRangeEditable = item.editorWidgetType() == QStringLiteral( "Range" ) && - item.editorWidgetConfig().value( QStringLiteral( "Style" ) ) == QStringLiteral( "SpinBox" ); + const bool isRangeEditable = item.editorWidgetType() == QStringLiteral( "Range" ) && + item.editorWidgetConfig().value( QStringLiteral( "Style" ) ) == QStringLiteral( "SpinBox" ); // Check min/max range if ( isRangeEditable ) { - double min = item.editorWidgetConfig().value( "Min" ).toDouble(); - double max = item.editorWidgetConfig().value( "Max" ).toDouble(); - double val = value.toDouble(); + const double min = item.editorWidgetConfig().value( "Min" ).toDouble(); + const double max = item.editorWidgetConfig().value( "Max" ).toDouble(); + const double val = value.toDouble(); if ( val < min ) { - validationMessage = ValidationTexts::numberLowerBoundReached.arg( min ); + validationMessage = numberLowerBoundReached().arg( min ); return Error; } else if ( val > max ) { - validationMessage = ValidationTexts::numberUpperBoundReached.arg( max ); + validationMessage = numberUpperBoundReached().arg( max ); return Error; } } @@ -182,7 +196,7 @@ FieldValidator::ValidationStatus FieldValidator::validateGenericField( const For if ( !field.convertCompatible( value ) ) { - validationMessage = ValidationTexts::genericValidationFailed; + validationMessage = genericValidationFailed(); return Error; } @@ -197,50 +211,50 @@ QString FieldValidator::constructConstraintValidationMessage( const FormItem &it */ const QgsField field = item.field(); - QgsFieldConstraints fldCons = field.constraints(); + const QgsFieldConstraints &fldCons = field.constraints(); QStringList validationMessages; - bool hasNotNullConstraint = fldCons.constraints() & QgsFieldConstraints::ConstraintNotNull; - bool notNullViolated = unmetConstraints.contains( QStringLiteral( "value is NULL" ) ); + const bool hasNotNullConstraint = fldCons.constraints() & QgsFieldConstraints::ConstraintNotNull; + const bool notNullViolated = unmetConstraints.contains( QStringLiteral( "value is NULL" ) ); if ( hasNotNullConstraint && notNullViolated ) { - QgsFieldConstraints::ConstraintStrength strength = fldCons.constraintStrength( QgsFieldConstraints::ConstraintNotNull ); + const QgsFieldConstraints::ConstraintStrength strength = fldCons.constraintStrength( QgsFieldConstraints::ConstraintNotNull ); if ( strength == QgsFieldConstraints::ConstraintStrengthHard ) { - validationMessages << ValidationTexts::hardNotNullFailed; + validationMessages << hardNotNullFailed(); } else if ( strength == QgsFieldConstraints::ConstraintStrengthSoft ) { - validationMessages << ValidationTexts::softNotNullFailed; + validationMessages << softNotNullFailed(); } } - bool hasUniqueConstraint = fldCons.constraints() & QgsFieldConstraints::ConstraintUnique; - bool uniqueViolated = unmetConstraints.contains( QStringLiteral( "value is not unique" ) ); + const bool hasUniqueConstraint = fldCons.constraints() & QgsFieldConstraints::ConstraintUnique; + const bool uniqueViolated = unmetConstraints.contains( QStringLiteral( "value is not unique" ) ); if ( hasUniqueConstraint && uniqueViolated ) { - QgsFieldConstraints::ConstraintStrength strength = fldCons.constraintStrength( QgsFieldConstraints::ConstraintUnique ); + const QgsFieldConstraints::ConstraintStrength strength = fldCons.constraintStrength( QgsFieldConstraints::ConstraintUnique ); if ( strength == QgsFieldConstraints::ConstraintStrengthHard ) { - validationMessages << ValidationTexts::hardUniqueFailed; + validationMessages << hardUniqueFailed(); } else if ( strength == QgsFieldConstraints::ConstraintStrengthSoft ) { - validationMessages << ValidationTexts::softUniqueFailed; + validationMessages << softUniqueFailed(); } } - bool hasExpressionConstrain = fldCons.constraints() & QgsFieldConstraints::ConstraintExpression; - bool expressionViolated = unmetConstraints.filter( QRegularExpression( "(parser error|evaluation error|check failed)" ) ).size() > 0; + const bool hasExpressionConstrain = fldCons.constraints() & QgsFieldConstraints::ConstraintExpression; + const bool expressionViolated = !unmetConstraints.filter( QRegularExpression( "(parser error|evaluation error|check failed)" ) ).empty(); if ( hasExpressionConstrain && expressionViolated ) { - QgsFieldConstraints::ConstraintStrength strength = fldCons.constraintStrength( QgsFieldConstraints::ConstraintExpression ); - bool containsDescription = !fldCons.constraintDescription().isEmpty(); + const QgsFieldConstraints::ConstraintStrength strength = fldCons.constraintStrength( QgsFieldConstraints::ConstraintExpression ); + const bool containsDescription = !fldCons.constraintDescription().isEmpty(); if ( containsDescription ) { @@ -250,19 +264,19 @@ QString FieldValidator::constructConstraintValidationMessage( const FormItem &it { if ( strength == QgsFieldConstraints::ConstraintStrengthHard ) { - validationMessages << ValidationTexts::hardExpressionFailed; + validationMessages << hardExpressionFailed(); } else if ( strength == QgsFieldConstraints::ConstraintStrengthSoft ) { - validationMessages << ValidationTexts::softExpressionFailed; + validationMessages << softExpressionFailed(); } } } - if ( validationMessages.size() ) + if ( !validationMessages.empty() ) { return validationMessages.join( QStringLiteral( "\n" ) ); // each message on new line } - return QString(); + return {}; } diff --git a/app/attributes/fieldvalidator.h b/app/attributes/fieldvalidator.h index 3ffba922c..f376b7c58 100644 --- a/app/attributes/fieldvalidator.h +++ b/app/attributes/fieldvalidator.h @@ -10,7 +10,6 @@ #ifndef FIELDVALIDATOR_H #define FIELDVALIDATOR_H -#include #include #include @@ -49,28 +48,23 @@ class FieldValidator : public QObject private: static QString constructConstraintValidationMessage( const FormItem &item, const QStringList &unmetConstraints ); -}; - -namespace ValidationTexts -{ - - const QString numberInvalid = QObject::tr( "Value must be a number" ); - const QString numberUpperBoundReached = QObject::tr( "Value must be lower than %1" ); - const QString numberLowerBoundReached = QObject::tr( "Value must be higher than %1" ); - const QString numberExceedingVariableLimits = QObject::tr( "Value is too large" ); - const QString numberMustBeInt = QObject::tr( "Field can not contain decimal places" ); - const QString textTooLong = QObject::tr( "Can not be longer than %1 characters" ); - - const QString softNotNullFailed = QObject::tr( "Field should not be empty" ); - const QString hardNotNullFailed = QObject::tr( "Field must not be empty" ); - const QString softUniqueFailed = QObject::tr( "Value should be unique" ); - const QString hardUniqueFailed = QObject::tr( "Value must be unique" ); - const QString softExpressionFailed = QObject::tr( "Unmet QGIS expression constraint" ); - const QString hardExpressionFailed = QObject::tr( "Unmet QGIS expression constraint" ); - - const QString genericValidationFailed = QObject::tr( "Not a valid value" ); - -} + static QString numberInvalid(); + static QString numberUpperBoundReached(); + static QString numberLowerBoundReached(); + static QString numberExceedingVariableLimits(); + static QString numberMustBeInt(); + static QString textTooLong(); + static QString softNotNullFailed(); + static QString hardNotNullFailed(); + static QString softUniqueFailed(); + static QString hardUniqueFailed(); + static QString softExpressionFailed(); + static QString hardExpressionFailed(); + static QString genericValidationFailed(); + + friend class TestAttributeController; + friend class TestFormEditors; +}; #endif // FIELDVALIDATOR_H diff --git a/app/test/testattributecontroller.cpp b/app/test/testattributecontroller.cpp index 4b0106fe2..9843a9af3 100644 --- a/app/test/testattributecontroller.cpp +++ b/app/test/testattributecontroller.cpp @@ -358,32 +358,30 @@ void TestAttributeController::testValidationMessages() FieldValidator::ValidationStatus expectedValidationStatus; }; - namespace V = ValidationTexts; - QList testunits { // Attribute - Name Not NULL - SOFT - { items.at( 1 ), QVariant(), V::softNotNullFailed, FieldValidator::Warning }, + { items.at( 1 ), QVariant(), FieldValidator::softNotNullFailed(), FieldValidator::Warning }, { items.at( 1 ), QStringLiteral( "A" ), "", FieldValidator::Valid }, - { items.at( 1 ), QVariant( QString() ), V::softNotNullFailed, FieldValidator::Warning }, + { items.at( 1 ), QVariant( QString() ), FieldValidator::softNotNullFailed(), FieldValidator::Warning }, { items.at( 1 ), "abcsd fsdkajf nsa ", "", FieldValidator::Valid }, // Attribute - Size Not NULL - HARD <0; 10000> - { items.at( 2 ), QVariant(), V::hardNotNullFailed, FieldValidator::Error }, + { items.at( 2 ), QVariant(), FieldValidator::hardNotNullFailed(), FieldValidator::Error }, { items.at( 2 ), "1", "", FieldValidator::Valid }, - { items.at( 2 ), "1a", V::numberInvalid, FieldValidator::Error }, - { items.at( 2 ), "10001", V::numberUpperBoundReached.arg( 10000 ), FieldValidator::Error }, - { items.at( 2 ), "-1", V::numberLowerBoundReached.arg( 0 ), FieldValidator::Error }, + { items.at( 2 ), "1a", FieldValidator::numberInvalid(), FieldValidator::Error }, + { items.at( 2 ), "10001", FieldValidator::numberUpperBoundReached().arg( 10000 ), FieldValidator::Error }, + { items.at( 2 ), "-1", FieldValidator::numberLowerBoundReached().arg( 0 ), FieldValidator::Error }, { items.at( 2 ), "150", "", FieldValidator::Valid }, // Attribute - SectorId Unique - SOFT <-100; 1000> { items.at( 3 ), "1", "", FieldValidator::Valid }, { items.at( 3 ), "-100", "", FieldValidator::Valid }, - { items.at( 3 ), "13", V::softUniqueFailed, FieldValidator::Warning }, // there should already be feature with such value + { items.at( 3 ), "13", FieldValidator::softUniqueFailed(), FieldValidator::Warning }, // there should already be feature with such value { items.at( 3 ), "14", "", FieldValidator::Valid }, - { items.at( 3 ), "14sad", V::numberInvalid, FieldValidator::Error }, - { items.at( 3 ), "-", V::numberInvalid, FieldValidator::Error }, - { items.at( 3 ), ".", V::numberInvalid, FieldValidator::Error }, + { items.at( 3 ), "14sad", FieldValidator::numberInvalid(), FieldValidator::Error }, + { items.at( 3 ), "-", FieldValidator::numberInvalid(), FieldValidator::Error }, + { items.at( 3 ), ".", FieldValidator::numberInvalid(), FieldValidator::Error }, { items.at( 3 ), "14", "", FieldValidator::Valid }, // Attribute - Occupied Expression, must be TRUE - HARD, expression descriptionn: 'Must be true' @@ -391,16 +389,16 @@ void TestAttributeController::testValidationMessages() { items.at( 4 ), true, "", FieldValidator::Valid }, // Attribure - DateTime(datetime) Not NULL - HARD, format: yyyy-MM-dd HH:mm:ss (default) - { items.at( 5 ), QVariant(), V::hardNotNullFailed, FieldValidator::Error }, + { items.at( 5 ), QVariant(), FieldValidator::hardNotNullFailed(), FieldValidator::Error }, { items.at( 5 ), QVariant( QDateTime::fromString( "2020-03-10 10:40:30", "yyyy-MM-dd HH:mm:ss" ) ), "", FieldValidator::Valid }, // Attribure - LastEdit(date) Not NULL - HARD, format: dd-MM-yyyy (custom) - { items.at( 6 ), QVariant(), V::hardNotNullFailed, FieldValidator::Error }, + { items.at( 6 ), QVariant(), FieldValidator::hardNotNullFailed(), FieldValidator::Error }, { items.at( 6 ), QVariant( QDateTime::fromString( "29-10-1998", "dd-MM-yyyy" ) ), "", FieldValidator::Valid }, // Attribute - Hash Unique - HARD { items.at( 7 ), QVariant(), "", FieldValidator::Valid }, - { items.at( 7 ), "1", V::hardUniqueFailed, FieldValidator::Error }, + { items.at( 7 ), "1", FieldValidator::hardUniqueFailed(), FieldValidator::Error }, { items.at( 7 ), QVariant(), "", FieldValidator::Valid }, { items.at( 7 ), "2", "", FieldValidator::Valid }, @@ -409,7 +407,7 @@ void TestAttributeController::testValidationMessages() { items.at( 8 ), "f", "", FieldValidator::Valid }, { items.at( 8 ), "fi", "", FieldValidator::Valid }, { items.at( 8 ), "five ", "", FieldValidator::Valid }, - { items.at( 8 ), "five chars limit", V::textTooLong.arg( 5 ), FieldValidator::Error }, + { items.at( 8 ), "five chars limit", FieldValidator::textTooLong().arg( 5 ), FieldValidator::Error }, { items.at( 8 ), "five ", "", FieldValidator::Valid } }; @@ -609,13 +607,11 @@ void TestAttributeController::testRawValue() FieldValidator::ValidationStatus expectedValidationStatus; }; - namespace V = ValidationTexts; - QList testunits { { items.at( 1 ), QVariant( 1 ), QVariant( "1" ), QVariant( "1" ), "", FieldValidator::Valid }, { items.at( 1 ), QVariant( "1" ), QVariant( "1" ), QVariant( "1" ), "", FieldValidator::Valid }, - { items.at( 4 ), QVariant( "a" ), QVariant(), QVariant( "a" ), V::numberInvalid, FieldValidator::Error }, + { items.at( 4 ), QVariant( "a" ), QVariant(), QVariant( "a" ), FieldValidator::numberInvalid(), FieldValidator::Error }, { items.at( 4 ), QVariant( "1" ), QVariant( 1 ), QVariant( "1" ), "", FieldValidator::Valid }, { items.at( 4 ), QVariant( 1 ), QVariant( 1 ), QVariant( 1 ), "", FieldValidator::Valid }, }; diff --git a/app/test/testformeditors.cpp b/app/test/testformeditors.cpp index feb974139..d2d5f2be5 100644 --- a/app/test/testformeditors.cpp +++ b/app/test/testformeditors.cpp @@ -97,21 +97,19 @@ void TestFormEditors::testNumericFields() FieldValidator::ValidationStatus expectedValidationStatus; }; - namespace V = ValidationTexts; - QList combinations = { // field "Heading", Int, range <100; 1000>, range editable { QVariant( QString() ), headingFieldId, "", FieldValidator::Valid }, - { "1", headingFieldId, V::numberLowerBoundReached.arg( 100 ), FieldValidator::Error }, - { "-1", headingFieldId, V::numberLowerBoundReached.arg( 100 ), FieldValidator::Error }, - { "10", headingFieldId, V::numberLowerBoundReached.arg( 100 ), FieldValidator::Error }, - { "-10", headingFieldId, V::numberLowerBoundReached.arg( 100 ), FieldValidator::Error }, - { "-100", headingFieldId, V::numberLowerBoundReached.arg( 100 ), FieldValidator::Error }, + { "1", headingFieldId, FieldValidator::numberLowerBoundReached().arg( 100 ), FieldValidator::Error }, + { "-1", headingFieldId, FieldValidator::numberLowerBoundReached().arg( 100 ), FieldValidator::Error }, + { "10", headingFieldId, FieldValidator::numberLowerBoundReached().arg( 100 ), FieldValidator::Error }, + { "-10", headingFieldId, FieldValidator::numberLowerBoundReached().arg( 100 ), FieldValidator::Error }, + { "-100", headingFieldId, FieldValidator::numberLowerBoundReached().arg( 100 ), FieldValidator::Error }, { "100", headingFieldId, "", FieldValidator::Valid }, - { "100h", headingFieldId, V::numberInvalid, FieldValidator::Error }, + { "100h", headingFieldId, FieldValidator::numberInvalid(), FieldValidator::Error }, { "100", headingFieldId, "", FieldValidator::Valid }, - { "1001", headingFieldId, V::numberUpperBoundReached.arg( 1000 ), FieldValidator::Error }, + { "1001", headingFieldId, FieldValidator::numberUpperBoundReached().arg( 1000 ), FieldValidator::Error }, { "1000", headingFieldId, "", FieldValidator::Valid }, // field "Importance", Real, range <-100.00; 100.00>, step:0.01, precision: 2, range editable @@ -119,22 +117,22 @@ void TestFormEditors::testNumericFields() { "0", importanceFieldId, "", FieldValidator::Valid }, { "-1.00", importanceFieldId, "", FieldValidator::Valid }, { "100.00", importanceFieldId, "", FieldValidator::Valid }, - { "100.002", importanceFieldId, V::numberUpperBoundReached.arg( 100.00 ), FieldValidator::Error }, - { "100.002fdsa", importanceFieldId, V::numberInvalid, FieldValidator::Error }, - { "100.,.,.,", importanceFieldId, V::numberInvalid, FieldValidator::Error }, - { "1 000", importanceFieldId, V::numberInvalid, FieldValidator::Error }, + { "100.002", importanceFieldId, FieldValidator::numberUpperBoundReached().arg( 100.00 ), FieldValidator::Error }, + { "100.002fdsa", importanceFieldId, FieldValidator::numberInvalid(), FieldValidator::Error }, + { "100.,.,.,", importanceFieldId, FieldValidator::numberInvalid(), FieldValidator::Error }, + { "1 000", importanceFieldId, FieldValidator::numberInvalid(), FieldValidator::Error }, { "10", importanceFieldId, "", FieldValidator::Valid }, // field "Pilots", Int, range <-1000; -100>, range editable { QVariant( QString() ), pilotsFieldId, "", FieldValidator::Valid }, { "-100", pilotsFieldId, "", FieldValidator::Valid }, { "-1000", pilotsFieldId, "", FieldValidator::Valid }, - { "0", pilotsFieldId, V::numberUpperBoundReached.arg( -100 ), FieldValidator::Error }, - { "150", pilotsFieldId, V::numberUpperBoundReached.arg( -100 ), FieldValidator::Error }, - { "-1001", pilotsFieldId, V::numberLowerBoundReached.arg( -1000 ), FieldValidator::Error }, - { "-51216354321435", pilotsFieldId, V::numberExceedingVariableLimits, FieldValidator::Error }, - { "--100", pilotsFieldId, V::numberInvalid, FieldValidator::Error }, - { "--100fsda", pilotsFieldId, V::numberInvalid, FieldValidator::Error }, + { "0", pilotsFieldId, FieldValidator::numberUpperBoundReached().arg( -100 ), FieldValidator::Error }, + { "150", pilotsFieldId, FieldValidator::numberUpperBoundReached().arg( -100 ), FieldValidator::Error }, + { "-1001", pilotsFieldId, FieldValidator::numberLowerBoundReached().arg( -1000 ), FieldValidator::Error }, + { "-51216354321435", pilotsFieldId, FieldValidator::numberExceedingVariableLimits(), FieldValidator::Error }, + { "--100", pilotsFieldId, FieldValidator::numberInvalid(), FieldValidator::Error }, + { "--100fsda", pilotsFieldId, FieldValidator::numberInvalid(), FieldValidator::Error }, { "-100", pilotsFieldId, "", FieldValidator::Valid }, // field "Cabin Crew", Int, no limit, range editable @@ -143,9 +141,9 @@ void TestFormEditors::testNumericFields() { "-1000", cabinCrewFieldId, "", FieldValidator::Valid }, { "-2147483647", cabinCrewFieldId, "", FieldValidator::Valid }, // int limit from QGIS { "2147483647", cabinCrewFieldId, "", FieldValidator::Valid }, // int limit from QGIS - { "214748364799", cabinCrewFieldId, V::numberExceedingVariableLimits, FieldValidator::Error }, - { "-214748364799", cabinCrewFieldId, V::numberExceedingVariableLimits, FieldValidator::Error }, - { "-214748-", cabinCrewFieldId, V::numberInvalid, FieldValidator::Error }, + { "214748364799", cabinCrewFieldId, FieldValidator::numberExceedingVariableLimits(), FieldValidator::Error }, + { "-214748364799", cabinCrewFieldId, FieldValidator::numberExceedingVariableLimits(), FieldValidator::Error }, + { "-214748-", cabinCrewFieldId, FieldValidator::numberInvalid(), FieldValidator::Error }, // field "Staff", Int, no limit, range slider { QVariant( QString() ), staffFieldId, "", FieldValidator::Valid },