sharpetronics/QGIS
1
0
Fork 0
mirror of https://github.com/qgis/QGIS.git synced 2025-10-06 00:07:29 -04:00
Code Issues Packages Projects Releases Wiki Activity

auto fix tests

Browse Source
This commit is contained in:
Julien Cabieces 2024-04-22 10:45:48 +02:00 committed by Nyall Dawson
parent 30e9886343
commit 46d656b09d
49 changed files with 590 additions and 590 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
tests/bench/qgsbench.cpp
View File

@ -299,7 +299,7 @@ QString QgsBench::serialize( const QMap<QString, QVariant> &map, int level )
QMap<QString, QVariant>::const_iterator i = map.constBegin();
while ( i != map.constEnd() )
{
switch ( static_cast< QMetaType::Type >( i.value().type() ) )
switch ( static_cast< QMetaType::Type >( i.value().userType() ) )
{
case QMetaType::Int:
list.append( space2 + '\"' + i.key() + "\": " + QString::number( i.value().toInt() ) );

4
tests/src/analysis/testqgsinterpolator.cpp
View File

@ -367,7 +367,7 @@ void TestQgsInterpolator::TIN_IDW_Interpolator_with_attribute()
QStringLiteral( "point" ),
QStringLiteral( "memory" ) );
QVERIFY( mLayerPoint->fields().field( "ZValue" ).type() == QVariant::Double );
QVERIFY( mLayerPoint->fields().field( "ZValue" ).type() == QMetaType::Type::Double );
const QString wkt1 = "Point (0 0)";
const QString wkt2 = "Point (2 0)";
@ -397,7 +397,7 @@ void TestQgsInterpolator::TIN_IDW_Interpolator_with_attribute()
QgsFeature f5;
f5.setFields( fields, true );
f5.setGeometry( QgsGeometry::fromWkt( wkt5 ) );
f5.setAttribute( "ZValue", QVariant( QVariant::Double ) ); //NULL value has to be ignore
f5.setAttribute( "ZValue", QgsVariantUtils::createVariant( QMetaType::Type::Double ) ); //NULL value has to be ignore
QgsFeature f6;
f6.setFields( fields, true );
f6.setGeometry( QgsGeometry::fromWkt( wkt6 ) );

12
tests/src/analysis/testqgsprocessing.cpp
View File

@ -2371,7 +2371,7 @@ void TestQgsProcessing::createFeatureSink()
// memory layer parameters
destination = QStringLiteral( "memory:mylayer" );
QgsFields fields;
fields.append( QgsField( QStringLiteral( "my_field" ), QVariant::String, QString(), 100 ) );
fields.append( QgsField( QStringLiteral( "my_field" ), QMetaType::Type::QString, QString(), 100 ) );
sink.reset( QgsProcessingUtils::createFeatureSink( destination, context, fields, Qgis::WkbType::PointZM, QgsCoordinateReferenceSystem::fromEpsgId( 3111 ), QVariantMap(), QStringList(), QStringList(), QgsFeatureSink::RegeneratePrimaryKey ) );
QVERIFY( sink.get() );
layer = qobject_cast< QgsVectorLayer *>( QgsProcessingUtils::mapLayerFromString( destination, context, false ) );
@ -2384,7 +2384,7 @@ void TestQgsProcessing::createFeatureSink()
QCOMPARE( layer->crs().authid(), QStringLiteral( "EPSG:3111" ) );
QCOMPARE( layer->fields().size(), 1 );
QCOMPARE( layer->fields().at( 0 ).name(), QStringLiteral( "my_field" ) );
QCOMPARE( layer->fields().at( 0 ).type(), QVariant::String );
QCOMPARE( layer->fields().at( 0 ).type(), QMetaType::Type::QString );
QCOMPARE( destination, layer->id() );
QCOMPARE( context.temporaryLayerStore()->mapLayer( layer->id() ), layer ); // layer should be in store
QCOMPARE( layer->featureCount(), 0L );
@ -2408,7 +2408,7 @@ void TestQgsProcessing::createFeatureSink()
QCOMPARE( layer->crs().authid(), QStringLiteral( "EPSG:3111" ) );
QCOMPARE( layer->fields().size(), 1 );
QCOMPARE( layer->fields().at( 0 ).name(), QStringLiteral( "my_field" ) );
QCOMPARE( layer->fields().at( 0 ).type(), QVariant::String );
QCOMPARE( layer->fields().at( 0 ).type(), QMetaType::Type::QString );
QCOMPARE( layer->featureCount(), 1L );
// no extension, should default to shp
@ -2428,7 +2428,7 @@ void TestQgsProcessing::createFeatureSink()
QCOMPARE( layer->fields().size(), 2 );
QCOMPARE( layer->fields().at( 0 ).name(), QStringLiteral( "fid" ) );
QCOMPARE( layer->fields().at( 1 ).name(), QStringLiteral( "my_field" ) );
QCOMPARE( layer->fields().at( 1 ).type(), QVariant::String );
QCOMPARE( layer->fields().at( 1 ).type(), QMetaType::Type::QString );
QCOMPARE( layer->featureCount(), 1L );
// append to existing OGR layer
QgsRemappingSinkDefinition remapDef;
@ -2438,7 +2438,7 @@ void TestQgsProcessing::createFeatureSink()
remapDef.setDestinationWkbType( Qgis::WkbType::Polygon );
remapDef.addMappedField( QStringLiteral( "my_field" ), QgsProperty::fromExpression( QStringLiteral( "field2 || @extra" ) ) );
QgsFields fields2;
fields2.append( QgsField( "field2", QVariant::String ) );
fields2.append( QgsField( "field2", QMetaType::Type::QString ) );
context.expressionContext().appendScope( new QgsExpressionContextScope() );
context.expressionContext().scope( 0 )->setVariable( QStringLiteral( "extra" ), 2 );
sink.reset( QgsProcessingUtils::createFeatureSink( destination, context, fields2, Qgis::WkbType::Point, QgsCoordinateReferenceSystem::fromEpsgId( 4326 ), QVariantMap(), QStringList(), QStringList(), QgsFeatureSink::SinkFlags(), &remapDef ) );
@ -2692,7 +2692,7 @@ void TestQgsProcessing::parameters()
// correctly setup feature
QgsFields fields;
fields.append( QgsField( "a_field", QVariant::String, QString(), 30 ) );
fields.append( QgsField( "a_field", QMetaType::Type::QString, QString(), 30 ) );
QgsFeature f( fields );
f.setAttribute( 0, QStringLiteral( "field value" ) );
context.expressionContext().setFeature( f );

22
tests/src/app/testqgisappclipboard.cpp
View File

@ -130,8 +130,8 @@ void TestQgisAppClipboard::copyToText()
//set clipboard to some QgsFeatures
QgsFields fields;
fields.append( QgsField( QStringLiteral( "int_field" ), QVariant::Int ) );
fields.append( QgsField( QStringLiteral( "string_field" ), QVariant::String ) );
fields.append( QgsField( QStringLiteral( "int_field" ), QMetaType::Type::Int ) );
fields.append( QgsField( QStringLiteral( "string_field" ), QMetaType::Type::QString ) );
QgsFeature feat( fields, 5 );
feat.setAttribute( QStringLiteral( "int_field" ), 9 );
feat.setAttribute( QStringLiteral( "string_field" ), "val" );
@ -443,7 +443,7 @@ void TestQgisAppClipboard::pasteWkt()
void TestQgisAppClipboard::pasteGeoJson()
{
QgsFields fields;
fields.append( QgsField( QStringLiteral( "name" ), QVariant::String ) );
fields.append( QgsField( QStringLiteral( "name" ), QMetaType::Type::QString ) );
mQgisApp->clipboard()->setText( QStringLiteral( "{\n\"type\": \"Feature\",\"geometry\": {\"type\": \"Point\",\"coordinates\": [125, 10]},\"properties\": {\"name\": \"Dinagat Islands\"}}" ) );
const QgsFeatureList features = mQgisApp->clipboard()->copyOf( fields );
@ -476,9 +476,9 @@ void TestQgisAppClipboard::retrieveFields()
fields = mQgisApp->clipboard()->fields();
QCOMPARE( fields.count(), 2 );
QCOMPARE( fields.at( 0 ).name(), QString( "name" ) );
QCOMPARE( fields.at( 0 ).type(), QVariant::String );
QCOMPARE( fields.at( 0 ).type(), QMetaType::Type::QString );
QCOMPARE( fields.at( 1 ).name(), QString( "height" ) );
QCOMPARE( fields.at( 1 ).type(), QVariant::Double );
QCOMPARE( fields.at( 1 ).type(), QMetaType::Type::Double );
}
void TestQgisAppClipboard::clipboardLogic()
@ -488,15 +488,15 @@ void TestQgisAppClipboard::clipboardLogic()
QgsFields fields = mQgisApp->clipboard()->fields();
QCOMPARE( fields.count(), 1 );
QCOMPARE( fields.at( 0 ).name(), QString( "name" ) );
QCOMPARE( fields.at( 0 ).type(), QVariant::String );
QCOMPARE( fields.at( 0 ).type(), QMetaType::Type::QString );
QgsFeatureList features = mQgisApp->clipboard()->copyOf( mQgisApp->clipboard()->fields() );
QCOMPARE( features.length(), 1 );
QCOMPARE( features.at( 0 ).attribute( "name" ).toString(), QString( "Dinagat Islands" ) );
//set clipboard to some QgsFeatures
fields = QgsFields();
fields.append( QgsField( QStringLiteral( "int_field" ), QVariant::Int ) );
fields.append( QgsField( QStringLiteral( "date_field" ), QVariant::Date ) );
fields.append( QgsField( QStringLiteral( "int_field" ), QMetaType::Type::Int ) );
fields.append( QgsField( QStringLiteral( "date_field" ), QMetaType::Type::QDate ) );
QgsFeature feat( fields, 5 );
feat.setAttribute( QStringLiteral( "int_field" ), 9 );
feat.setAttribute( QStringLiteral( "date_field" ), QVariant( QDate( 2010, 9, 5 ) ) );
@ -515,9 +515,9 @@ void TestQgisAppClipboard::clipboardLogic()
fields = mQgisApp->clipboard()->fields();
QCOMPARE( fields.count(), 2 );
QCOMPARE( fields.at( 0 ).name(), QString( "int_field" ) );
QCOMPARE( fields.at( 0 ).type(), QVariant::Int );
QCOMPARE( fields.at( 0 ).type(), QMetaType::Type::Int );
QCOMPARE( fields.at( 1 ).name(), QString( "date_field" ) );
QCOMPARE( fields.at( 1 ).type(), QVariant::Date );
QCOMPARE( fields.at( 1 ).type(), QMetaType::Type::QDate );
features = mQgisApp->clipboard()->copyOf( mQgisApp->clipboard()->fields() );
QCOMPARE( features.length(), 2 );
QCOMPARE( features.at( 0 ).id(), 5LL );
@ -532,7 +532,7 @@ void TestQgisAppClipboard::clipboardLogic()
fields = mQgisApp->clipboard()->fields();
QCOMPARE( fields.count(), 1 );
QCOMPARE( fields.at( 0 ).name(), QString( "name" ) );
QCOMPARE( fields.at( 0 ).type(), QVariant::String );
QCOMPARE( fields.at( 0 ).type(), QMetaType::Type::QString );
features = mQgisApp->clipboard()->copyOf( mQgisApp->clipboard()->fields() );
QCOMPARE( features.length(), 1 );
QCOMPARE( features.at( 0 ).attribute( "name" ).toString(), QString( "Dinagat Islands" ) );

4
tests/src/app/testqgsmergeattributesdialog.cpp
View File

@ -102,7 +102,7 @@ class TestQgsMergeattributesDialog : public QgsTest
QgsVectorLayer ml( "Polygon", "test", "memory" );
QVERIFY( ml.isValid() );
QgsField uniqueField( QStringLiteral( "unique" ), QVariant::Int );
QgsField uniqueField( QStringLiteral( "unique" ), QMetaType::Type::Int );
QgsFieldConstraints constraints;
constraints.setConstraint(
QgsFieldConstraints::ConstraintUnique
@ -111,7 +111,7 @@ class TestQgsMergeattributesDialog : public QgsTest
constraints
);
QgsField notUniqueField( QStringLiteral( "not_unique" ), QVariant::Int );
QgsField notUniqueField( QStringLiteral( "not_unique" ), QMetaType::Type::Int );
QVERIFY( ml.dataProvider()->addAttributes(
{ uniqueField, notUniqueField }
) );

28
tests/src/core/testqgis.cpp
View File

@ -269,10 +269,10 @@ void TestQgis::qVariantCompare_data()
QTest::newRow( "invalid to value" ) << QVariant() << QVariant( 2 ) << true << false;
QTest::newRow( "invalid to value 2" ) << QVariant( 2 ) << QVariant() << false << true;
QTest::newRow( "invalid to null" ) << QVariant() << QVariant( QVariant::String ) << true << false;
QTest::newRow( "invalid to null2 " ) << QVariant( QVariant::String ) << QVariant() << false << true;
QTest::newRow( "null to value" ) << QVariant( QVariant::String ) << QVariant( "a" ) << true << false;
QTest::newRow( "null to value 2" ) << QVariant( "a" ) << QVariant( QVariant::String ) << false << true;
QTest::newRow( "invalid to null" ) << QVariant() << QgsVariantUtils::createVariant( QMetaType::Type::QString ) << true << false;
QTest::newRow( "invalid to null2 " ) << QgsVariantUtils::createVariant( QMetaType::Type::QString ) << QVariant() << false << true;
QTest::newRow( "null to value" ) << QgsVariantUtils::createVariant( QMetaType::Type::QString ) << QVariant( "a" ) << true << false;
QTest::newRow( "null to value 2" ) << QVariant( "a" ) << QgsVariantUtils::createVariant( QMetaType::Type::QString ) << false << true;
QTest::newRow( "int" ) << QVariant( 1 ) << QVariant( 2 ) << true << false;
QTest::newRow( "int 2" ) << QVariant( 1 ) << QVariant( -2 ) << false << true;
@ -419,20 +419,20 @@ void TestQgis::testQgsVariantEqual()
// This is what we actually wanted to fix with qgsVariantEqual
// zero != NULL
QVERIFY( ! qgsVariantEqual( QVariant( 0 ), QVariant( QVariant::Int ) ) );
QVERIFY( ! qgsVariantEqual( QVariant( 0 ), QVariant( QVariant::Double ) ) );
QVERIFY( ! qgsVariantEqual( QVariant( 0.0f ), QVariant( QVariant::Int ) ) );
QVERIFY( ! qgsVariantEqual( QVariant( 0.0f ), QVariant( QVariant::Double ) ) );
QVERIFY( QVariant( 0 ) == QVariant( QVariant::Int ) );
QVERIFY( ! qgsVariantEqual( QVariant( 0 ), QgsVariantUtils::createVariant( QMetaType::Type::Int ) ) );
QVERIFY( ! qgsVariantEqual( QVariant( 0 ), QgsVariantUtils::createVariant( QMetaType::Type::Double ) ) );
QVERIFY( ! qgsVariantEqual( QVariant( 0.0f ), QgsVariantUtils::createVariant( QMetaType::Type::Int ) ) );
QVERIFY( ! qgsVariantEqual( QVariant( 0.0f ), QgsVariantUtils::createVariant( QMetaType::Type::Double ) ) );
QVERIFY( QVariant( 0 ) == QgsVariantUtils::createVariant( QMetaType::Type::Int ) );
// NULL identities
QVERIFY( qgsVariantEqual( QVariant( QVariant::Int ), QVariant( QVariant::Int ) ) );
QVERIFY( qgsVariantEqual( QVariant( QVariant::Double ), QVariant( QVariant::Double ) ) );
QVERIFY( qgsVariantEqual( QVariant( QVariant::Int ), QVariant( QVariant::Double ) ) );
QVERIFY( qgsVariantEqual( QVariant( QVariant::Int ), QVariant( QVariant::String ) ) );
QVERIFY( qgsVariantEqual( QgsVariantUtils::createVariant( QMetaType::Type::Int ), QgsVariantUtils::createVariant( QMetaType::Type::Int ) ) );
QVERIFY( qgsVariantEqual( QgsVariantUtils::createVariant( QMetaType::Type::Double ), QgsVariantUtils::createVariant( QMetaType::Type::Double ) ) );
QVERIFY( qgsVariantEqual( QgsVariantUtils::createVariant( QMetaType::Type::Int ), QgsVariantUtils::createVariant( QMetaType::Type::Double ) ) );
QVERIFY( qgsVariantEqual( QgsVariantUtils::createVariant( QMetaType::Type::Int ), QgsVariantUtils::createVariant( QMetaType::Type::QString ) ) );
// NULL should not be equal to invalid
QVERIFY( !qgsVariantEqual( QVariant(), QVariant( QVariant::Int ) ) );
QVERIFY( !qgsVariantEqual( QVariant(), QgsVariantUtils::createVariant( QMetaType::Type::Int ) ) );
}
void TestQgis::testQgsEnumMapList()

28
tests/src/core/testqgsarcgisrestutils.cpp
View File

@ -91,22 +91,22 @@ void TestQgsArcGisRestUtils::cleanupTestCase()
void TestQgsArcGisRestUtils::testMapEsriFieldType()
{
QCOMPARE( QgsArcGisRestUtils::convertFieldType( QStringLiteral( "esriFieldTypeInteger" ) ), QVariant::LongLong );
QCOMPARE( QgsArcGisRestUtils::convertFieldType( QStringLiteral( "esriFieldTypeSmallInteger" ) ), QVariant::Int );
QCOMPARE( QgsArcGisRestUtils::convertFieldType( QStringLiteral( "esriFieldTypeDouble" ) ), QVariant::Double );
QCOMPARE( QgsArcGisRestUtils::convertFieldType( QStringLiteral( "esriFieldTypeSingle" ) ), QVariant::Double );
QCOMPARE( QgsArcGisRestUtils::convertFieldType( QStringLiteral( "esriFieldTypeString" ) ), QVariant::String );
QCOMPARE( QgsArcGisRestUtils::convertFieldType( QStringLiteral( "esriFieldTypeDate" ) ), QVariant::DateTime );
QCOMPARE( QgsArcGisRestUtils::convertFieldType( QStringLiteral( "esriFieldTypeOID" ) ), QVariant::LongLong );
QCOMPARE( QgsArcGisRestUtils::convertFieldType( QStringLiteral( "esriFieldTypeBlob" ) ), QVariant::ByteArray );
QCOMPARE( QgsArcGisRestUtils::convertFieldType( QStringLiteral( "esriFieldTypeGlobalID" ) ), QVariant::String );
QCOMPARE( QgsArcGisRestUtils::convertFieldType( QStringLiteral( "esriFieldTypeRaster" ) ), QVariant::ByteArray );
QCOMPARE( QgsArcGisRestUtils::convertFieldType( QStringLiteral( "esriFieldTypeGUID" ) ), QVariant::String );
QCOMPARE( QgsArcGisRestUtils::convertFieldType( QStringLiteral( "esriFieldTypeXML" ) ), QVariant::String );
QCOMPARE( QgsArcGisRestUtils::convertFieldType( QStringLiteral( "esriFieldTypeInteger" ) ), QMetaType::Type::LongLong );
QCOMPARE( QgsArcGisRestUtils::convertFieldType( QStringLiteral( "esriFieldTypeSmallInteger" ) ), QMetaType::Type::Int );
QCOMPARE( QgsArcGisRestUtils::convertFieldType( QStringLiteral( "esriFieldTypeDouble" ) ), QMetaType::Type::Double );
QCOMPARE( QgsArcGisRestUtils::convertFieldType( QStringLiteral( "esriFieldTypeSingle" ) ), QMetaType::Type::Double );
QCOMPARE( QgsArcGisRestUtils::convertFieldType( QStringLiteral( "esriFieldTypeString" ) ), QMetaType::Type::QString );
QCOMPARE( QgsArcGisRestUtils::convertFieldType( QStringLiteral( "esriFieldTypeDate" ) ), QMetaType::Type::QDateTime );
QCOMPARE( QgsArcGisRestUtils::convertFieldType( QStringLiteral( "esriFieldTypeOID" ) ), QMetaType::Type::LongLong );
QCOMPARE( QgsArcGisRestUtils::convertFieldType( QStringLiteral( "esriFieldTypeBlob" ) ), QMetaType::Type::QByteArray );
QCOMPARE( QgsArcGisRestUtils::convertFieldType( QStringLiteral( "esriFieldTypeGlobalID" ) ), QMetaType::Type::QString );
QCOMPARE( QgsArcGisRestUtils::convertFieldType( QStringLiteral( "esriFieldTypeRaster" ) ), QMetaType::Type::QByteArray );
QCOMPARE( QgsArcGisRestUtils::convertFieldType( QStringLiteral( "esriFieldTypeGUID" ) ), QMetaType::Type::QString );
QCOMPARE( QgsArcGisRestUtils::convertFieldType( QStringLiteral( "esriFieldTypeXML" ) ), QMetaType::Type::QString );
// not valid fields
QCOMPARE( QgsArcGisRestUtils::convertFieldType( QStringLiteral( "esriFieldTypeGeometry" ) ), QVariant::Invalid );
QCOMPARE( QgsArcGisRestUtils::convertFieldType( QStringLiteral( "xxx" ) ), QVariant::Invalid );
QCOMPARE( QgsArcGisRestUtils::convertFieldType( QStringLiteral( "esriFieldTypeGeometry" ) ), QMetaType::Type::UnknownType );
QCOMPARE( QgsArcGisRestUtils::convertFieldType( QStringLiteral( "xxx" ) ), QMetaType::Type::UnknownType );
}
void TestQgsArcGisRestUtils::testParseSpatialReference()

6
tests/src/core/testqgsauthmanager.cpp
View File

@ -188,7 +188,7 @@ void TestQgsAuthManager::testMasterPassword()
QVERIFY( authm->setMasterPassword( true ) );
QCOMPARE( spy.count(), 1 );
spyargs = spy.takeFirst();
QVERIFY( spyargs.at( 0 ).type() == QVariant::Bool );
QVERIFY( spyargs.at( 0 ).userType() == QMetaType::Type::Bool );
QVERIFY( spyargs.at( 0 ).toBool() );
authm->clearMasterPassword();
@ -197,7 +197,7 @@ void TestQgsAuthManager::testMasterPassword()
QVERIFY( !authm->masterPasswordIsSet() );
QCOMPARE( spy.count(), 1 );
spyargs = spy.takeFirst();
QVERIFY( spyargs.at( 0 ).type() == QVariant::Bool );
QVERIFY( spyargs.at( 0 ).userType() == QMetaType::Type::Bool );
QVERIFY( !spyargs.at( 0 ).toBool() );
authm->clearMasterPassword();
@ -206,7 +206,7 @@ void TestQgsAuthManager::testMasterPassword()
QVERIFY( authm->masterPasswordIsSet() );
QCOMPARE( spy.count(), 1 );
spyargs = spy.takeFirst();
QVERIFY( spyargs.at( 0 ).type() == QVariant::Bool );
QVERIFY( spyargs.at( 0 ).userType() == QMetaType::Type::Bool );
QVERIFY( spyargs.at( 0 ).toBool() );
}

6
tests/src/core/testqgsdxfexport.cpp
View File

@ -124,7 +124,7 @@ void TestQgsDxfExport::init()
mPointLayerNoSymbols = new QgsVectorLayer( filename, QStringLiteral( "points" ), QStringLiteral( "ogr" ) );
QVERIFY( mPointLayerNoSymbols->isValid() );
mPointLayerNoSymbols->setRenderer( new QgsNullSymbolRenderer() );
mPointLayerNoSymbols->addExpressionField( QStringLiteral( "'A text with spaces'" ), QgsField( QStringLiteral( "Spacestest" ), QVariant::String ) );
mPointLayerNoSymbols->addExpressionField( QStringLiteral( "'A text with spaces'" ), QgsField( QStringLiteral( "Spacestest" ), QMetaType::Type::QString ) );
QgsProject::instance()->addMapLayer( mPointLayerNoSymbols );
//Point layer with geometry generator symbolizer
@ -554,7 +554,7 @@ void TestQgsDxfExport::testMtext_data()
QgsVectorLayer *pointLayerNoSymbols = new QgsVectorLayer( filename, QStringLiteral( "points" ), QStringLiteral( "ogr" ) );
QVERIFY( pointLayerNoSymbols->isValid() );
pointLayerNoSymbols->setRenderer( new QgsNullSymbolRenderer() );
pointLayerNoSymbols->addExpressionField( QStringLiteral( "'A text with spaces'" ), QgsField( QStringLiteral( "Spacestest" ), QVariant::String ) );
pointLayerNoSymbols->addExpressionField( QStringLiteral( "'A text with spaces'" ), QgsField( QStringLiteral( "Spacestest" ), QMetaType::Type::QString ) );
QTest::newRow( "MText No Symbology" )
<< pointLayerNoSymbols
@ -599,7 +599,7 @@ void TestQgsDxfExport::testMTextEscapeSpaces()
void TestQgsDxfExport::testMTextEscapeLineBreaks()
{
const int field = mPointLayerNoSymbols->addExpressionField( QStringLiteral( "'A text with ' || char(13) || char(10) || 'line break'" ), QgsField( QStringLiteral( "linebreaktest" ), QVariant::String ) );
const int field = mPointLayerNoSymbols->addExpressionField( QStringLiteral( "'A text with ' || char(13) || char(10) || 'line break'" ), QgsField( QStringLiteral( "linebreaktest" ), QMetaType::Type::QString ) );
QgsPalLayerSettings settings;
settings.fieldName = QStringLiteral( "linebreaktest" );

174
tests/src/core/testqgsexpression.cpp
View File

@ -197,19 +197,19 @@ class TestQgsExpression: public QObject
af1.setAttribute( QStringLiteral( "col1" ), 4 );
af1.setAttribute( QStringLiteral( "col2" ), "test" );
af1.setAttribute( QStringLiteral( "col3" ), 2 );
af1.setAttribute( QStringLiteral( "col4" ), QVariant( QVariant::String ) );
af1.setAttribute( QStringLiteral( "col4" ), QgsVariantUtils::createVariant( QMetaType::Type::QString ) );
QgsFeature af2( mAggregatesLayer->dataProvider()->fields(), 2 );
af2.setGeometry( QgsGeometry::fromPointXY( QgsPointXY( 1, 0 ) ) );
af2.setAttribute( QStringLiteral( "col1" ), 1 );
af2.setAttribute( QStringLiteral( "col2" ), QVariant( QVariant::String ) );
af2.setAttribute( QStringLiteral( "col2" ), QgsVariantUtils::createVariant( QMetaType::Type::QString ) );
af2.setAttribute( QStringLiteral( "col3" ), 1 );
af2.setAttribute( QStringLiteral( "col4" ), QVariant( QVariant::String ) );
af2.setAttribute( QStringLiteral( "col4" ), QgsVariantUtils::createVariant( QMetaType::Type::QString ) );
QgsFeature af3( mAggregatesLayer->dataProvider()->fields(), 3 );
af3.setGeometry( QgsGeometry::fromPointXY( QgsPointXY( 2, 0 ) ) );
af3.setAttribute( QStringLiteral( "col1" ), 3 );
af3.setAttribute( QStringLiteral( "col2" ), "test333" );
af3.setAttribute( QStringLiteral( "col3" ), 2 );
af3.setAttribute( QStringLiteral( "col4" ), QVariant( QVariant::String ) );
af3.setAttribute( QStringLiteral( "col4" ), QgsVariantUtils::createVariant( QMetaType::Type::QString ) );
QgsFeature af4( mAggregatesLayer->dataProvider()->fields(), 4 );
af4.setGeometry( QgsGeometry::fromPointXY( QgsPointXY( 3, 0 ) ) );
af4.setAttribute( QStringLiteral( "col1" ), 2 );
@ -219,7 +219,7 @@ class TestQgsExpression: public QObject
QgsFeature af5( mAggregatesLayer->dataProvider()->fields(), 5 );
af5.setGeometry( QgsGeometry() );
af5.setAttribute( QStringLiteral( "col1" ), 5 );
af5.setAttribute( QStringLiteral( "col2" ), QVariant( QVariant::String ) );
af5.setAttribute( QStringLiteral( "col2" ), QgsVariantUtils::createVariant( QMetaType::Type::QString ) );
af5.setAttribute( QStringLiteral( "col3" ), 3 );
af5.setAttribute( QStringLiteral( "col4" ), "test" );
QgsFeature af6( mAggregatesLayer->dataProvider()->fields(), 6 );
@ -248,7 +248,7 @@ class TestQgsExpression: public QObject
cf1.setAttribute( QStringLiteral( "col3" ), 2 );
QgsFeature cf2( mChildLayer->dataProvider()->fields(), 2 );
cf2.setAttribute( QStringLiteral( "parent" ), 4 );
cf2.setAttribute( QStringLiteral( "col2" ), QVariant( QVariant::String ) );
cf2.setAttribute( QStringLiteral( "col2" ), QgsVariantUtils::createVariant( QMetaType::Type::QString ) );
cf2.setAttribute( QStringLiteral( "col3" ), 1 );
QgsFeature cf3( mChildLayer->dataProvider()->fields(), 3 );
cf3.setAttribute( QStringLiteral( "parent" ), 4 );
@ -260,7 +260,7 @@ class TestQgsExpression: public QObject
cf4.setAttribute( QStringLiteral( "col3" ), 2 );
QgsFeature cf5( mChildLayer->dataProvider()->fields(), 5 );
cf5.setAttribute( QStringLiteral( "parent" ), 3 );
cf5.setAttribute( QStringLiteral( "col2" ), QVariant( QVariant::String ) );
cf5.setAttribute( QStringLiteral( "col2" ), QgsVariantUtils::createVariant( QMetaType::Type::QString ) );
cf5.setAttribute( QStringLiteral( "col3" ), 7 );
mChildLayer->dataProvider()->addFeatures( QgsFeatureList() << cf1 << cf2 << cf3 << cf4 << cf5 );
QgsProject::instance()->addMapLayer( mChildLayer );
@ -491,7 +491,7 @@ class TestQgsExpression: public QObject
QVariant res = exp.evaluate();
if ( exp.hasEvalError() )
qDebug() << exp.evalErrorString();
if ( res.type() != result.type() )
if ( res.userType() != result.userType() )
{
qDebug() << "got " << res.typeName() << " instead of " << result.typeName();
}
@ -551,7 +551,7 @@ class TestQgsExpression: public QObject
QVariant res = exp.evaluate();
if ( exp.hasEvalError() )
qDebug() << exp.evalErrorString();
if ( res.type() != result.type() )
if ( res.userType() != result.userType() )
{
qDebug() << "got " << res.typeName() << " instead of " << result.typeName();
}
@ -980,15 +980,15 @@ class TestQgsExpression: public QObject
QTest::newRow( "max(3.5,-2.1,1)" ) << "max(3.5,-2.1,1)" << false << QVariant( 3.5 );
QTest::newRow( "max with null value" ) << "max(1,3.5,null)" << false << QVariant( 3.5 );
QTest::newRow( "max with null value first" ) << "max(null,-3.5,2)" << false << QVariant( 2. );
QTest::newRow( "max with no params" ) << "max()" << false << QVariant( QVariant::Double );
QTest::newRow( "max with only null value" ) << "max(null)" << false << QVariant( QVariant::Double );
QTest::newRow( "max with no params" ) << "max()" << false << QgsVariantUtils::createVariant( QMetaType::Type::Double );
QTest::newRow( "max with only null value" ) << "max(null)" << false << QgsVariantUtils::createVariant( QMetaType::Type::Double );
QTest::newRow( "min(-1.5)" ) << "min(-1.5)" << false << QVariant( -1.5 );
QTest::newRow( "min(-16.6,3.5,-2.1)" ) << "min(-16.6,3.5,-2.1)" << false << QVariant( -16.6 );
QTest::newRow( "min(5,3.5,-2.1)" ) << "min(5,3.5,-2.1)" << false << QVariant( -2.1 );
QTest::newRow( "min with null value" ) << "min(5,null,-2.1)" << false << QVariant( -2.1 );
QTest::newRow( "min with null value first" ) << "min(null,3.2,6.5)" << false << QVariant( 3.2 );
QTest::newRow( "min with no params" ) << "min()" << false << QVariant( QVariant::Double );
QTest::newRow( "min with only null value" ) << "min(null)" << false << QVariant( QVariant::Double );
QTest::newRow( "min with no params" ) << "min()" << false << QgsVariantUtils::createVariant( QMetaType::Type::Double );
QTest::newRow( "min with only null value" ) << "min(null)" << false << QgsVariantUtils::createVariant( QMetaType::Type::Double );
QTest::newRow( "clamp(-2,1,5)" ) << "clamp(-2,1,5)" << false << QVariant( 1.0 );
QTest::newRow( "clamp(min:=-2,value:=1,max:=5)" ) << "clamp(min:=-2,value:=1,max:=5)" << false << QVariant( 1.0 );
QTest::newRow( "clamp(-2,-10,5)" ) << "clamp(-2,-10,5)" << false << QVariant( -2.0 );
@ -1863,7 +1863,7 @@ class TestQgsExpression: public QObject
QTest::newRow( "epoch invalid date" ) << "epoch('invalid')" << true << QVariant();
// datetime_from_epoch will always return a local datetime, so here we create some circular magic to create a local datetime during test (so test can be ran in every timezone...)
QTest::newRow( "datetime_from_epoch" ) << "datetime_from_epoch(epoch(to_datetime('2017-01-01T00:00:01')))" << false << QVariant( QDateTime( QDate( 2017, 1, 1 ), QTime( 0, 0, 1 ), Qt::LocalTime ) );
QTest::newRow( "datetime_from_epoch_null" ) << "datetime_from_epoch(NULL)" << false << QVariant( QVariant::Invalid );
QTest::newRow( "datetime_from_epoch_null" ) << "datetime_from_epoch(NULL)" << false << QgsVariantUtils::createVariant( QMetaType::Type::UnknownType );
QTest::newRow( "date from format" ) << "to_date('June 29, 2019','MMMM d, yyyy')" << false << QVariant( QDate( 2019, 6, 29 ) );
QTest::newRow( "date from format and language" ) << "to_date('29 juin, 2019','d MMMM, yyyy','fr')" << false << QVariant( QDate( 2019, 6, 29 ) );
QTest::newRow( "date from format, wrong string" ) << "to_date('wrong.string.here','yyyy.MM.dd')" << true << QVariant();
@ -2242,9 +2242,9 @@ class TestQgsExpression: public QObject
QVariant result = exp.evaluate();
if ( exp.hasEvalError() )
qDebug() << exp.evalErrorString();
if ( result.type() != expected.type() )
if ( result.userType() != expected.userType() )
{
qDebug() << "got type " << result.typeName() << "(" << result.type() << ") instead of " << expected.typeName() << "(" << expected.type() << ")";
qDebug() << "got type " << result.typeName() << "(" << static_cast<QMetaType::Type>( result.userType() ) << ") instead of " << expected.typeName() << "(" << static_cast<QMetaType::Type>( expected.userType() ) << ")";
}
//qDebug() << res.type() << " " << result.type();
//qDebug() << "type " << res.typeName();
@ -2254,47 +2254,47 @@ class TestQgsExpression: public QObject
QVERIFY( exp.prepare( &context ) );
QVariant::Type resultType = result.type();
QVariant::Type expectedType = expected.type();
QMetaType::Type resultType = static_cast<QMetaType::Type>( result.userType() );
QMetaType::Type expectedType = static_cast<QMetaType::Type>( expected.userType() );
if ( resultType == QVariant::Int )
resultType = QVariant::LongLong;
if ( expectedType == QVariant::Int )
expectedType = QVariant::LongLong;
if ( resultType == QMetaType::Type::Int )
resultType = QMetaType::Type::LongLong;
if ( expectedType == QMetaType::Type::Int )
expectedType = QMetaType::Type::LongLong;
QCOMPARE( resultType, expectedType );
switch ( resultType )
{
case QVariant::Invalid:
case QMetaType::Type::UnknownType:
break; // nothing more to check
case QVariant::LongLong:
case QMetaType::Type::LongLong:
QCOMPARE( result.toLongLong(), expected.toLongLong() );
break;
case QVariant::Double:
case QMetaType::Type::Double:
QCOMPARE( result.toDouble(), expected.toDouble() );
break;
case QVariant::Bool:
case QMetaType::Type::Bool:
QCOMPARE( result.toBool(), expected.toBool() );
break;
case QVariant::String:
case QMetaType::Type::QString:
QCOMPARE( result.toString(), expected.toString() );
break;
case QVariant::Date:
case QMetaType::Type::QDate:
QCOMPARE( result.toDate(), expected.toDate() );
break;
case QVariant::DateTime:
case QMetaType::Type::QDateTime:
QCOMPARE( result.toDateTime(), expected.toDateTime() );
break;
case QVariant::Time:
case QMetaType::Type::QTime:
QCOMPARE( result.toTime(), expected.toTime() );
break;
case QVariant::List:
case QMetaType::Type::QVariantList:
QCOMPARE( result.toList(), expected.toList() );
break;
case QVariant::ByteArray:
case QMetaType::Type::QByteArray:
QCOMPARE( result.toByteArray(), expected.toByteArray() );
break;
case QVariant::UserType:
case QMetaType::Type::User:
{
if ( result.userType() == qMetaTypeId<QgsInterval>() )
{
@ -2334,8 +2334,8 @@ class TestQgsExpression: public QObject
QgsFields fields;
fields.append( QgsField( QStringLiteral( "x1" ) ) );
fields.append( QgsField( QStringLiteral( "x2" ) ) );
fields.append( QgsField( QStringLiteral( "foo" ), QVariant::Int ) );
fields.append( QgsField( QStringLiteral( "sin" ), QVariant::Int ) );
fields.append( QgsField( QStringLiteral( "foo" ), QMetaType::Type::Int ) );
fields.append( QgsField( QStringLiteral( "sin" ), QMetaType::Type::Int ) );
QgsFeature f;
f.initAttributes( 4 );
@ -2350,7 +2350,7 @@ class TestQgsExpression: public QObject
QCOMPARE( prepareRes, true );
QCOMPARE( exp.hasEvalError(), false );
QVariant res = exp.evaluate( &context );
QCOMPARE( res.type(), QVariant::LongLong );
QCOMPARE( static_cast<QMetaType::Type>( res.userType() ), QMetaType::Type::LongLong );
QCOMPARE( res.toInt(), 21 );
// bad exp
@ -2359,7 +2359,7 @@ class TestQgsExpression: public QObject
QCOMPARE( prepareRes2, false );
QCOMPARE( exp2.hasEvalError(), true );
QVariant res2 = exp2.evaluate( &context );
QCOMPARE( res2.type(), QVariant::Invalid );
QCOMPARE( static_cast<QMetaType::Type>( res2.userType() ), QMetaType::Type::UnknownType );
// Has field called sin and function
QgsExpression exp3( QStringLiteral( "sin" ) );
@ -2367,7 +2367,7 @@ class TestQgsExpression: public QObject
QCOMPARE( prepareRes, true );
QCOMPARE( exp3.hasEvalError(), false );
res = exp3.evaluate( &context );
QCOMPARE( res.type(), QVariant::Int );
QCOMPARE( static_cast<QMetaType::Type>( res.userType() ), QMetaType::Type::Int );
QCOMPARE( res.toInt(), 10 );
QgsExpression exp4( QStringLiteral( "sin(3.14)" ) );
@ -2454,7 +2454,7 @@ class TestQgsExpression: public QObject
QgsFeature f( 100 );
QgsFields fields;
fields.append( QgsField( QStringLiteral( "col1" ) ) );
fields.append( QgsField( QStringLiteral( "second_column" ), QVariant::Int ) );
fields.append( QgsField( QStringLiteral( "second_column" ), QMetaType::Type::Int ) );
f.setFields( fields, true );
f.setAttribute( QStringLiteral( "col1" ), QStringLiteral( "test value" ) );
f.setAttribute( QStringLiteral( "second_column" ), 5 );
@ -2487,7 +2487,7 @@ class TestQgsExpression: public QObject
QgsFeature f( 100 );
QgsFields fields;
fields.append( QgsField( QStringLiteral( "col1" ) ) );
fields.append( QgsField( QStringLiteral( "second_column" ), QVariant::Int ) );
fields.append( QgsField( QStringLiteral( "second_column" ), QMetaType::Type::Int ) );
f.setFields( fields, true );
f.setAttribute( QStringLiteral( "col1" ), QStringLiteral( "test value" ) );
f.setAttribute( QStringLiteral( "second_column" ), 5 );
@ -2670,7 +2670,7 @@ class TestQgsExpression: public QObject
QTest::newRow( "geometry collect" ) << "geom_to_wkt(aggregate('aggregate_layer','collect',$geometry))" << false << QVariant( QStringLiteral( "MultiPoint ((0 0),(1 0),(2 0),(3 0),(5 0),(6 0))" ) );
QVariantList array;
array << "test" << QVariant( QVariant::String ) << "test333" << "test4" << QVariant( QVariant::String ) << "test4" << "test7";
array << "test" << QgsVariantUtils::createVariant( QMetaType::Type::QString ) << "test333" << "test4" << QgsVariantUtils::createVariant( QMetaType::Type::QString ) << "test4" << "test7";
QTest::newRow( "array aggregate" ) << "aggregate('aggregate_layer','array_agg',\"col2\")" << false << QVariant( array );
QTest::newRow( "sub expression" ) << "aggregate('test','sum',\"col1\" * 2)" << false << QVariant( 65 * 2 );
@ -2894,10 +2894,10 @@ class TestQgsExpression: public QObject
QTest::newRow( "two_selected" ) << "num_selected()" << ( QgsFeatureIds() << 1 << 2 ) << firstFeature << mMemoryLayer << QVariant( 2 );
QTest::newRow( "is_selected" ) << "is_selected()" << ( QgsFeatureIds() << 1 << 2 ) << firstFeature << mMemoryLayer << QVariant( true );
QTest::newRow( "not_selected" ) << "is_selected()" << ( QgsFeatureIds() << 4 << 2 ) << firstFeature << mMemoryLayer << QVariant( false );
QTest::newRow( "no layer num_selected" ) << "num_selected()" << ( QgsFeatureIds() << 4 << 2 ) << QgsFeature() << noLayer << QVariant( QVariant::LongLong );
QTest::newRow( "no layer is_selected" ) << "is_selected()" << ( QgsFeatureIds() << 4 << 2 ) << QgsFeature() << noLayer << QVariant( QVariant::Bool );
QTest::newRow( "no layer num_selected" ) << "num_selected()" << ( QgsFeatureIds() << 4 << 2 ) << QgsFeature() << noLayer << QVariant( QVariant::LongLong );
QTest::newRow( "is_selected with params" ) << "is_selected('test', get_feature('test', 'col1', 10))" << ( QgsFeatureIds() << 4 << 2 ) << QgsFeature() << noLayer << QVariant( QVariant::Bool );
QTest::newRow( "no layer num_selected" ) << "num_selected()" << ( QgsFeatureIds() << 4 << 2 ) << QgsFeature() << noLayer << QgsVariantUtils::createVariant( QMetaType::Type::LongLong );
QTest::newRow( "no layer is_selected" ) << "is_selected()" << ( QgsFeatureIds() << 4 << 2 ) << QgsFeature() << noLayer << QgsVariantUtils::createVariant( QMetaType::Type::Bool );
QTest::newRow( "no layer num_selected" ) << "num_selected()" << ( QgsFeatureIds() << 4 << 2 ) << QgsFeature() << noLayer << QgsVariantUtils::createVariant( QMetaType::Type::LongLong );
QTest::newRow( "is_selected with params" ) << "is_selected('test', get_feature('test', 'col1', 10))" << ( QgsFeatureIds() << 4 << 2 ) << QgsFeature() << noLayer << QgsVariantUtils::createVariant( QMetaType::Type::Bool );
QTest::newRow( "num_selected with params" ) << "num_selected('test')" << ( QgsFeatureIds() << 4 << 2 ) << QgsFeature() << noLayer << QVariant( 2 );
}
@ -3082,7 +3082,7 @@ class TestQgsExpression: public QObject
// Invalid expression since max<min
QgsExpression exp3( QStringLiteral( "rand(10,1)" ) );
QVariant v3 = exp3.evaluate();
QCOMPARE( v3.type(), QVariant::Invalid );
QCOMPARE( static_cast<QMetaType::Type>( v3.userType() ), QMetaType::Type::UnknownType );
// Supports multiple type of seeds
QgsExpression exp4( QStringLiteral( "rand(1,10,123)" ) );
@ -3129,7 +3129,7 @@ class TestQgsExpression: public QObject
// Invalid expression since max<min
QgsExpression exp3( QStringLiteral( "randf(9.3333,1.784)" ) );
QVariant v3 = exp3.evaluate();
QCOMPARE( v3.type(), QVariant::Invalid );
QCOMPARE( static_cast<QMetaType::Type>( v3.userType() ), QMetaType::Type::UnknownType );
// Supports multiple type of seeds
QgsExpression exp4( QStringLiteral( "randf(1.5,9.5,123)" ) );
@ -4087,7 +4087,7 @@ class TestQgsExpression: public QObject
QgsFeature f( 100 );
QgsFields fields;
fields.append( QgsField( QStringLiteral( "col1" ) ) );
fields.append( QgsField( QStringLiteral( "second_column" ), QVariant::Int ) );
fields.append( QgsField( QStringLiteral( "second_column" ), QMetaType::Type::Int ) );
f.setFields( fields, true );
f.setAttribute( QStringLiteral( "col1" ), QStringLiteral( "test value" ) );
f.setAttribute( QStringLiteral( "second_column" ), 5 );
@ -4134,7 +4134,7 @@ class TestQgsExpression: public QObject
QgsFeature f( 100 );
QgsFields fields;
fields.append( QgsField( QStringLiteral( "col1" ) ) );
fields.append( QgsField( QStringLiteral( "strings" ), QVariant::StringList, QStringLiteral( "string[]" ), 0, 0, QString(), QVariant::String ) );
fields.append( QgsField( QStringLiteral( "strings" ), QMetaType::Type::QStringList, QStringLiteral( "string[]" ), 0, 0, QString(), QMetaType::Type::QString ) );
f.setFields( fields, true );
f.setAttribute( QStringLiteral( "col1" ), QStringLiteral( "test value" ) );
QStringList array;
@ -4253,7 +4253,7 @@ class TestQgsExpression: public QObject
QgsFeature f( 100 );
QgsFields fields;
fields.append( QgsField( QStringLiteral( "col1" ) ) );
fields.append( QgsField( QStringLiteral( "ints" ), QVariant::List, QStringLiteral( "int[]" ), 0, 0, QString(), QVariant::Int ) );
fields.append( QgsField( QStringLiteral( "ints" ), QMetaType::Type::QVariantList, QStringLiteral( "int[]" ), 0, 0, QString(), QMetaType::Type::Int ) );
f.setFields( fields, true );
f.setAttribute( QStringLiteral( "col1" ), QStringLiteral( "test value" ) );
QVariantList array;
@ -4393,7 +4393,7 @@ class TestQgsExpression: public QObject
QgsFeature f( 100 );
QgsFields fields;
fields.append( QgsField( QStringLiteral( "col1" ) ) );
fields.append( QgsField( QStringLiteral( "map" ), QVariant::Map, QStringLiteral( "map" ), 0, 0, QString(), QVariant::String ) );
fields.append( QgsField( QStringLiteral( "map" ), QMetaType::Type::QVariantMap, QStringLiteral( "map" ), 0, 0, QString(), QMetaType::Type::QString ) );
f.setFields( fields, true );
f.setAttribute( QStringLiteral( "col1" ), QStringLiteral( "test value" ) );
QVariantMap map;
@ -4503,13 +4503,13 @@ class TestQgsExpression: public QObject
QCOMPARE( QgsExpression::quotedValue( QVariant( "a string" ) ), QString( "'a string'" ) );
QCOMPARE( QgsExpression::quotedValue( QVariant( "a\nstring" ) ), QString( "'a\\nstring'" ) );
QCOMPARE( QgsExpression::quotedValue( QVariant( 5 ) ), QString( "5" ) );
QCOMPARE( QgsExpression::quotedValue( QVariant( 5 ), QVariant::String ), QString( "'5'" ) );
QCOMPARE( QgsExpression::quotedValue( QVariant( 5 ), QMetaType::Type::QString ), QString( "'5'" ) );
QCOMPARE( QgsExpression::quotedValue( QVariant( 5LL ) ), QString( "5" ) );
QCOMPARE( QgsExpression::quotedValue( QVariant( 5.5 ) ), QString( "5.5" ) );
QCOMPARE( QgsExpression::quotedValue( QVariant( true ) ), QString( "TRUE" ) );
QCOMPARE( QgsExpression::quotedValue( QVariant( true ), QVariant::String ), QString( "'true'" ) );
QCOMPARE( QgsExpression::quotedValue( QVariant( true ), QMetaType::Type::QString ), QString( "'true'" ) );
QCOMPARE( QgsExpression::quotedValue( QVariant() ), QString( "NULL" ) );
QCOMPARE( QgsExpression::quotedValue( QVariant(), QVariant::String ), QString( "NULL" ) );
QCOMPARE( QgsExpression::quotedValue( QVariant(), QMetaType::Type::QString ), QString( "NULL" ) );
QVariantList array = QVariantList() << QVariant( 1 ) << QVariant( "a" ) << QVariant();
QCOMPARE( QgsExpression::quotedValue( array ), QString( "array( 1, 'a', NULL )" ) );
QCOMPARE( QgsExpression::quotedValue( QStringList( { QStringLiteral( "abc" ), QStringLiteral( "def" )} ) ), QString( "array( 'abc', 'def' )" ) );
@ -4547,8 +4547,8 @@ class TestQgsExpression: public QObject
void test_expressionToLayerFieldIndex()
{
std::unique_ptr layer = std::make_unique< QgsVectorLayer >( QStringLiteral( "Point" ), QStringLiteral( "test" ), QStringLiteral( "memory" ) );
layer->dataProvider()->addAttributes( { QgsField( QStringLiteral( "field1" ), QVariant::String ),
QgsField( QStringLiteral( "another FIELD" ), QVariant::String )
layer->dataProvider()->addAttributes( { QgsField( QStringLiteral( "field1" ), QMetaType::Type::QString ),
QgsField( QStringLiteral( "another FIELD" ), QMetaType::Type::QString )
} );
layer->updateFields();
@ -4574,8 +4574,8 @@ class TestQgsExpression: public QObject
void test_quoteFieldExpression()
{
std::unique_ptr layer = std::make_unique< QgsVectorLayer >( QStringLiteral( "Point" ), QStringLiteral( "test" ), QStringLiteral( "memory" ) );
layer->dataProvider()->addAttributes( { QgsField( QStringLiteral( "field1" ), QVariant::String ),
QgsField( QStringLiteral( "another FIELD" ), QVariant::String )
layer->dataProvider()->addAttributes( { QgsField( QStringLiteral( "field1" ), QMetaType::Type::QString ),
QgsField( QStringLiteral( "another FIELD" ), QMetaType::Type::QString )
} );
layer->updateFields();
@ -4681,13 +4681,13 @@ class TestQgsExpression: public QObject
//should take precedence over feature's field collection
QgsFields fields;
fields.append( QgsField( QStringLiteral( "f1" ), QVariant::String ) );
fields.append( QgsField( QStringLiteral( "f1" ), QMetaType::Type::QString ) );
QgsFeature f( 1 );
f.setFields( fields );
//also add a joined field - this will not be available in feature's field collection
fields.append( QgsField( QStringLiteral( "j1" ), QVariant::String ), Qgis::FieldOrigin::Join, 1 );
fields.append( QgsField( QStringLiteral( "j1" ), QMetaType::Type::QString ), Qgis::FieldOrigin::Join, 1 );
f.setAttributes( QgsAttributes() << QVariant( "f1" ) << QVariant( "j1" ) );
f.setValid( true );
@ -4706,7 +4706,7 @@ class TestQgsExpression: public QObject
// final test - check that feature's field collection is also used when corresponding field NOT found
// in explicitly passed field collection
fields.append( QgsField( QStringLiteral( "f2" ), QVariant::String ) );
fields.append( QgsField( QStringLiteral( "f2" ), QMetaType::Type::QString ) );
f.setFields( fields );
f.setAttributes( QgsAttributes() << QVariant( "f1" ) << QVariant( "j1" ) << QVariant( "f2" ) );
context.setFeature( f );
@ -5142,11 +5142,11 @@ class TestQgsExpression: public QObject
void test_formatPreviewStringWithLocale()
{
const QVariant t_int( 12345 );
QVariant t_uint( QVariant::UInt );
QVariant t_uint = QgsVariantUtils::createVariant( QMetaType::Type::UInt );
t_uint = 12345;
QVariant t_long( QVariant::LongLong );
QVariant t_long = QgsVariantUtils::createVariant( QMetaType::Type::LongLong );
t_long = 12345;
QVariant t_ulong( QVariant::ULongLong );
QVariant t_ulong = QgsVariantUtils::createVariant( QMetaType::Type::ULongLong );
t_ulong = 12345;
const QVariant t_float( 12345.001F );
const QVariant t_double( 12345.001 );
@ -5331,12 +5331,12 @@ class TestQgsExpression: public QObject
QgsExpressionContext context;
QgsFields fields;
fields.append( QgsField( "string_field", QVariant::String ) );
fields.append( QgsField( "non_null_int", QVariant::Int ) );
fields.append( QgsField( "null_int", QVariant::Int ) );
fields.append( QgsField( "string_field", QMetaType::Type::QString ) );
fields.append( QgsField( "non_null_int", QMetaType::Type::Int ) );
fields.append( QgsField( "null_int", QMetaType::Type::Int ) );
QgsFeature feature( fields );
feature.setAttributes( QgsAttributes( { QVariant( QStringLiteral( "string value" ) ), QVariant( 5 ), QVariant( QVariant::Int ) } ) );
feature.setAttributes( QgsAttributes( { QVariant( QStringLiteral( "string value" ) ), QVariant( 5 ), QgsVariantUtils::createVariant( QMetaType::Type::Int ) } ) );
context.setFeature( feature );
context.setFields( fields );
@ -5350,22 +5350,22 @@ class TestQgsExpression: public QObject
// https://github.com/qgis/QGIS/issues/36112
QgsFields fields;
fields.append( QgsField( QStringLiteral( "foo" ), QVariant::Int ) );
fields.append( QgsField( QStringLiteral( "foo" ), QMetaType::Type::Int ) );
QgsFeature f;
f.initAttributes( 1 );
f.setAttribute( 0, QVariant( QVariant::Int ) );
f.setAttribute( 0, QgsVariantUtils::createVariant( QMetaType::Type::Int ) );
QgsExpressionContext context = QgsExpressionContextUtils::createFeatureBasedContext( f, fields );
QgsExpression exp( QStringLiteral( "concat('test', foo)" ) );
QVariant res = exp.evaluate( &context );
QCOMPARE( res.type(), QVariant::String );
QCOMPARE( static_cast<QMetaType::Type>( res.userType() ), QMetaType::Type::QString );
QCOMPARE( res.toString(), QStringLiteral( "test" ) );
f.setAttribute( 0, QVariant() );
context = QgsExpressionContextUtils::createFeatureBasedContext( f, fields );
res = exp.evaluate( &context );
QCOMPARE( res.type(), QVariant::String );
QCOMPARE( static_cast<QMetaType::Type>( res.userType() ), QMetaType::Type::QString );
QCOMPARE( res.toString(), QStringLiteral( "test" ) );
}
@ -5448,8 +5448,8 @@ class TestQgsExpression: public QObject
void testPrecomputedNodesWithIntrospectionFunctions()
{
QgsFields fields;
fields.append( QgsField( QStringLiteral( "first_field" ), QVariant::Int ) );
fields.append( QgsField( QStringLiteral( "second_field" ), QVariant::Int ) );
fields.append( QgsField( QStringLiteral( "first_field" ), QMetaType::Type::Int ) );
fields.append( QgsField( QStringLiteral( "second_field" ), QMetaType::Type::Int ) );
QgsExpression exp( QStringLiteral( "attribute(@static_feature, concat('second','_',@field_name_part_var)) + x(geometry( @static_feature ))" ) );
// initially this expression requires all attributes -- we can't determine the referenced columns in advance
@ -5491,7 +5491,7 @@ class TestQgsExpression: public QObject
QCOMPARE( exp2.referencedVariables(), QSet<QString>() << QStringLiteral( "field_name_part_var" ) << QStringLiteral( "static_feature" ) );
QgsFields fields2;
fields2.append( QgsField( QStringLiteral( "another_field" ), QVariant::Int ) );
fields2.append( QgsField( QStringLiteral( "another_field" ), QMetaType::Type::Int ) );
context.setFields( fields2 );
QVERIFY( exp2.prepare( & context ) );
@ -5508,8 +5508,8 @@ class TestQgsExpression: public QObject
void testPrecomputedNodesWithBinaryOperators()
{
QgsFields fields;
fields.append( QgsField( QStringLiteral( "first_field" ), QVariant::Int ) );
fields.append( QgsField( QStringLiteral( "second_field" ), QVariant::Int ) );
fields.append( QgsField( QStringLiteral( "first_field" ), QMetaType::Type::Int ) );
fields.append( QgsField( QStringLiteral( "second_field" ), QMetaType::Type::Int ) );
// OR operations:
@ -5567,9 +5567,9 @@ class TestQgsExpression: public QObject
void testPrecomputedNodesReplacedWithEffectiveNodes()
{
QgsFields fields;
fields.append( QgsField( QStringLiteral( "first_field" ), QVariant::Int ) );
fields.append( QgsField( QStringLiteral( "second_field" ), QVariant::Int ) );
fields.append( QgsField( QStringLiteral( "third_field" ), QVariant::Int ) );
fields.append( QgsField( QStringLiteral( "first_field" ), QMetaType::Type::Int ) );
fields.append( QgsField( QStringLiteral( "second_field" ), QMetaType::Type::Int ) );
fields.append( QgsField( QStringLiteral( "third_field" ), QMetaType::Type::Int ) );
QgsFeature f( fields );
f.setAttributes( QgsAttributes() << 11 << 20 << 300 );
@ -5674,9 +5674,9 @@ class TestQgsExpression: public QObject
void testNodeSetCachedStaticValue()
{
QgsFields fields;
fields.append( QgsField( QStringLiteral( "first_field" ), QVariant::Int ) );
fields.append( QgsField( QStringLiteral( "second_field" ), QVariant::Int ) );
fields.append( QgsField( QStringLiteral( "third_field" ), QVariant::Int ) );
fields.append( QgsField( QStringLiteral( "first_field" ), QMetaType::Type::Int ) );
fields.append( QgsField( QStringLiteral( "second_field" ), QMetaType::Type::Int ) );
fields.append( QgsField( QStringLiteral( "third_field" ), QMetaType::Type::Int ) );
QgsFeature f( fields );
f.setAttributes( QgsAttributes() << 11 << 20 << 300 );
@ -5698,11 +5698,11 @@ class TestQgsExpression: public QObject
void testExpressionUtilsToLocalizedString()
{
const QVariant t_int( 12346 );
QVariant t_uint( QVariant::UInt );
QVariant t_uint = QgsVariantUtils::createVariant( QMetaType::Type::UInt );
t_uint = 12346;
QVariant t_long( QVariant::LongLong );
QVariant t_long = QgsVariantUtils::createVariant( QMetaType::Type::LongLong );
t_long = 12346;
QVariant t_ulong( QVariant::ULongLong );
QVariant t_ulong = QgsVariantUtils::createVariant( QMetaType::Type::ULongLong );
t_ulong = 12346;
const QVariant t_double( 123456.801 );
@ -5752,7 +5752,7 @@ class TestQgsExpression: public QObject
// non-static arguments are not allowed
QgsFields fields;
fields.append( QgsField( QStringLiteral( "first_field" ), QVariant::Int ) );
fields.append( QgsField( QStringLiteral( "first_field" ), QMetaType::Type::Int ) );
QgsFeature f( fields );
f.setAttributes( QgsAttributes() << 11 );

2
tests/src/core/testqgsexpressioncontext.cpp
View File

@ -875,7 +875,7 @@ void TestQgsExpressionContext::featureBasedContext()
QgsFields fields;
fields.append( QgsField( QStringLiteral( "x1" ) ) );
fields.append( QgsField( QStringLiteral( "x2" ) ) );
fields.append( QgsField( QStringLiteral( "foo" ), QVariant::Int ) );
fields.append( QgsField( QStringLiteral( "foo" ), QMetaType::Type::Int ) );
QgsFeature f;
f.initAttributes( 3 );

2
tests/src/core/testqgsfeature.cpp
View File

@ -110,7 +110,7 @@ void TestQgsFeature::attributesTest()
QVERIFY( attr1 != attr4 );
//null value
const QVariant nullDouble( QVariant::Double );
const QVariant nullDouble( QMetaType::Type::Double );
QgsAttributes attr5;
attr5 << QVariant( 5 ) << nullDouble << QVariant( "val" );
QVERIFY( attr1 != attr5 );

242
tests/src/core/testqgsfield.cpp
View File

@ -84,7 +84,7 @@ void TestQgsField::create()
{
std::unique_ptr<QgsField> field( new QgsField( QStringLiteral( "name" ), QVariant::Double, QStringLiteral( "double" ), 5, 2, QStringLiteral( "comment" ) ) );
QCOMPARE( field->name(), QString( "name" ) );
QCOMPARE( field->type(), QVariant::Double );
QCOMPARE( field->type(), QMetaType::Type::Double );
QCOMPARE( field->typeName(), QString( "double" ) );
QCOMPARE( field->length(), 5 );
QCOMPARE( field->precision(), 2 );
@ -95,7 +95,7 @@ void TestQgsField::create()
void TestQgsField::copy()
{
QgsField original( QStringLiteral( "original" ), QVariant::Double, QStringLiteral( "double" ), 5, 2, QStringLiteral( "comment" ) );
QgsField original( QStringLiteral( "original" ), QMetaType::Type::Double, QStringLiteral( "double" ), 5, 2, QStringLiteral( "comment" ) );
QgsFieldConstraints constraints;
constraints.setConstraint( QgsFieldConstraints::ConstraintNotNull, QgsFieldConstraints::ConstraintOriginProvider );
constraints.setConstraintExpression( QStringLiteral( "constraint expression" ), QStringLiteral( "description" ) );
@ -123,7 +123,7 @@ void TestQgsField::copy()
void TestQgsField::assignment()
{
QgsField original( QStringLiteral( "original" ), QVariant::Double, QStringLiteral( "double" ), 5, 2, QStringLiteral( "comment" ) );
QgsField original( QStringLiteral( "original" ), QMetaType::Type::Double, QStringLiteral( "double" ), 5, 2, QStringLiteral( "comment" ) );
QgsFieldConstraints constraints;
constraints.setConstraint( QgsFieldConstraints::ConstraintNotNull, QgsFieldConstraints::ConstraintOriginProvider );
constraints.setConstraintExpression( QStringLiteral( "constraint expression" ), QStringLiteral( "description" ) );
@ -147,8 +147,8 @@ void TestQgsField::gettersSetters()
QgsField field;
field.setName( QStringLiteral( "name" ) );
QCOMPARE( field.name(), QString( "name" ) );
field.setType( QVariant::Int );
QCOMPARE( field.type(), QVariant::Int );
field.setType( QMetaType::Type::Int );
QCOMPARE( field.type(), QMetaType::Type::Int );
field.setTypeName( QStringLiteral( "typeName" ) );
QCOMPARE( field.typeName(), QString( "typeName" ) );
field.setLength( 5 );
@ -226,50 +226,50 @@ void TestQgsField::gettersSetters()
void TestQgsField::isNumeric()
{
QgsField field;
field.setType( QVariant::Int );
field.setType( QMetaType::Type::Int );
QVERIFY( field.isNumeric() );
field.setType( QVariant::UInt );
field.setType( QMetaType::Type::UInt );
QVERIFY( field.isNumeric() );
field.setType( QVariant::Double );
field.setType( QMetaType::Type::Double );
QVERIFY( field.isNumeric() );
field.setType( QVariant::LongLong );
field.setType( QMetaType::Type::LongLong );
QVERIFY( field.isNumeric() );
field.setType( QVariant::ULongLong );
field.setType( QMetaType::Type::ULongLong );
QVERIFY( field.isNumeric() );
field.setType( QVariant::String );
field.setType( QMetaType::Type::QString );
QVERIFY( !field.isNumeric() );
field.setType( QVariant::DateTime );
field.setType( QMetaType::Type::QDateTime );
QVERIFY( !field.isNumeric() );
field.setType( QVariant::Bool );
field.setType( QMetaType::Type::Bool );
QVERIFY( !field.isNumeric() );
field.setType( QVariant::Invalid );
field.setType( QMetaType::Type::UnknownType );
QVERIFY( !field.isNumeric() );
}
void TestQgsField::isDateTime()
{
QgsField field;
field.setType( QVariant::Int );
field.setType( QMetaType::Type::Int );
QVERIFY( !field.isDateOrTime() );
field.setType( QVariant::UInt );
field.setType( QMetaType::Type::UInt );
QVERIFY( !field.isDateOrTime() );
field.setType( QVariant::Double );
field.setType( QMetaType::Type::Double );
QVERIFY( !field.isDateOrTime() );
field.setType( QVariant::LongLong );
field.setType( QMetaType::Type::LongLong );
QVERIFY( !field.isDateOrTime() );
field.setType( QVariant::ULongLong );
field.setType( QMetaType::Type::ULongLong );
QVERIFY( !field.isDateOrTime() );
field.setType( QVariant::String );
field.setType( QMetaType::Type::QString );
QVERIFY( !field.isDateOrTime() );
field.setType( QVariant::DateTime );
field.setType( QMetaType::Type::QDateTime );
QVERIFY( field.isDateOrTime() );
field.setType( QVariant::Time );
field.setType( QMetaType::Type::QTime );
QVERIFY( field.isDateOrTime() );
field.setType( QVariant::Date );
field.setType( QMetaType::Type::QDate );
QVERIFY( field.isDateOrTime() );
field.setType( QVariant::Bool );
field.setType( QMetaType::Type::Bool );
QVERIFY( !field.isDateOrTime() );
field.setType( QVariant::Invalid );
field.setType( QMetaType::Type::UnknownType );
QVERIFY( !field.isDateOrTime() );
}
@ -277,7 +277,7 @@ void TestQgsField::equality()
{
QgsField field1;
field1.setName( QStringLiteral( "name" ) );
field1.setType( QVariant::Int );
field1.setType( QMetaType::Type::Int );
field1.setLength( 5 );
field1.setPrecision( 2 );
field1.setTypeName( QStringLiteral( "typename1" ) ); //typename is NOT required for equality
@ -287,7 +287,7 @@ void TestQgsField::equality()
field1.setConstraints( constraints );
QgsField field2;
field2.setName( QStringLiteral( "name" ) );
field2.setType( QVariant::Int );
field2.setType( QMetaType::Type::Int );
field2.setLength( 5 );
field2.setPrecision( 2 );
field2.setTypeName( QStringLiteral( "typename2" ) ); //typename is NOT required for equality
@ -303,10 +303,10 @@ void TestQgsField::equality()
QVERIFY( !( field1 == field2 ) );
QVERIFY( field1 != field2 );
field2.setName( QStringLiteral( "name" ) );
field2.setType( QVariant::Double );
field2.setType( QMetaType::Type::Double );
QVERIFY( !( field1 == field2 ) );
QVERIFY( field1 != field2 );
field2.setType( QVariant::Int );
field2.setType( QMetaType::Type::Int );
field2.setLength( 9 );
QVERIFY( !( field1 == field2 ) );
QVERIFY( field1 != field2 );
@ -412,7 +412,7 @@ void TestQgsField::equality()
void TestQgsField::asVariant()
{
QgsField original( QStringLiteral( "original" ), QVariant::Double, QStringLiteral( "double" ), 5, 2, QStringLiteral( "comment" ) );
QgsField original( QStringLiteral( "original" ), QMetaType::Type::Double, QStringLiteral( "double" ), 5, 2, QStringLiteral( "comment" ) );
QgsFieldConstraints constraints;
constraints.setConstraint( QgsFieldConstraints::ConstraintNotNull );
original.setConstraints( constraints );
@ -427,7 +427,7 @@ void TestQgsField::asVariant()
void TestQgsField::displayString()
{
const QgsField stringField( QStringLiteral( "string" ), QVariant::String, QStringLiteral( "string" ) );
const QgsField stringField( QStringLiteral( "string" ), QMetaType::Type::QString, QStringLiteral( "string" ) );
//test string value
const QString test( QStringLiteral( "test string" ) );
@ -435,37 +435,37 @@ void TestQgsField::displayString()
//test NULL
QgsApplication::setNullRepresentation( QStringLiteral( "TEST NULL" ) );
const QVariant nullString = QVariant( QVariant::String );
const QVariant nullString = QgsVariantUtils::createVariant( QMetaType::Type::QString );
QCOMPARE( stringField.displayString( nullString ), QString( "TEST NULL" ) );
//test int value in string type
const QgsField intField( QStringLiteral( "int" ), QVariant::String, QStringLiteral( "int" ) );
const QgsField intField( QStringLiteral( "int" ), QMetaType::Type::QString, QStringLiteral( "int" ) );
QCOMPARE( intField.displayString( 5 ), QString( "5" ) );
QCOMPARE( intField.displayString( 599999898999LL ), QString( "599999898999" ) );
//test int value in int type
const QgsField intField2( QStringLiteral( "int" ), QVariant::Int, QStringLiteral( "int" ) );
const QgsField intField2( QStringLiteral( "int" ), QMetaType::Type::Int, QStringLiteral( "int" ) );
QCOMPARE( intField2.displayString( 5 ), QString( "5" ) );
QCOMPARE( intField2.displayString( 599999898999LL ), QString( "599,999,898,999" ) );
//test long type
const QgsField longField( QStringLiteral( "long" ), QVariant::LongLong, QStringLiteral( "longlong" ) );
const QgsField longField( QStringLiteral( "long" ), QMetaType::Type::LongLong, QStringLiteral( "longlong" ) );
QCOMPARE( longField.displayString( 5 ), QString( "5" ) );
QCOMPARE( longField.displayString( 599999898999LL ), QString( "599,999,898,999" ) );
//test NULL int
const QVariant nullInt = QVariant( QVariant::Int );
const QVariant nullInt = QgsVariantUtils::createVariant( QMetaType::Type::Int );
QCOMPARE( intField.displayString( nullInt ), QString( "TEST NULL" ) );
//test double value
const QgsField doubleField( QStringLiteral( "double" ), QVariant::Double, QStringLiteral( "double" ), 10, 3 );
const QgsField doubleField( QStringLiteral( "double" ), QMetaType::Type::Double, QStringLiteral( "double" ), 10, 3 );
QCOMPARE( doubleField.displayString( 5.005005 ), QString( "5.005" ) );
QCOMPARE( doubleField.displayString( 4.5e-09 ).toLower(), QString( "4.5e-09" ) );
QCOMPARE( doubleField.displayString( 1e-04 ), QString( "0.0001" ) );
QCOMPARE( doubleField.displayString( -5.005005 ), QString( "-5.005" ) );
QCOMPARE( doubleField.displayString( -4.5e-09 ).toLower(), QString( "-4.5e-09" ) );
QCOMPARE( doubleField.displayString( -1e-04 ), QString( "-0.0001" ) );
const QgsField doubleFieldNoPrec( QStringLiteral( "double" ), QVariant::Double, QStringLiteral( "double" ), 10 );
const QgsField doubleFieldNoPrec( QStringLiteral( "double" ), QMetaType::Type::Double, QStringLiteral( "double" ), 10 );
QCOMPARE( doubleFieldNoPrec.displayString( 5.005005 ), QString( "5.005005" ) );
QCOMPARE( doubleFieldNoPrec.displayString( 5.005005005 ), QString( "5.005005005" ) );
QCOMPARE( doubleFieldNoPrec.displayString( 4.5e-09 ).toLower(), QString( "4.5e-09" ) );
@ -499,7 +499,7 @@ void TestQgsField::displayString()
QCOMPARE( doubleFieldNoPrec.displayString( ( "(1+2)" ) ), QString( "(1+2)" ) );
//test NULL double
const QVariant nullDouble = QVariant( QVariant::Double );
const QVariant nullDouble = QgsVariantUtils::createVariant( QMetaType::Type::Double );
QCOMPARE( doubleField.displayString( nullDouble ), QString( "TEST NULL" ) );
//test double value with German locale
@ -567,92 +567,92 @@ void TestQgsField::displayString()
QCOMPARE( longField.displayString( 599999898999LL ), QString( "599999898999" ) );
// binary field
const QgsField binaryField( QStringLiteral( "binary" ), QVariant::ByteArray, QStringLiteral( "Binary" ) );
const QgsField binaryField( QStringLiteral( "binary" ), QMetaType::Type::QByteArray, QStringLiteral( "Binary" ) );
const QString testBAString( QStringLiteral( "test string" ) );
const QByteArray testBA( testBAString.toLocal8Bit() );
QCOMPARE( binaryField.displayString( testBA ), QStringLiteral( "BLOB" ) );
// array field
const QgsField stringArrayField( QStringLiteral( "stringArray" ), QVariant::StringList, QStringLiteral( "StringArray" ) );
const QgsField stringArrayField( QStringLiteral( "stringArray" ), QMetaType::Type::QStringList, QStringLiteral( "StringArray" ) );
QCOMPARE( stringArrayField.displayString( QStringList() << "A" << "B" << "C" ), QStringLiteral( "A, B, C" ) );
const QgsField intArrayField( QStringLiteral( "intArray" ), QVariant::List, QStringLiteral( "IntArray" ) );
const QgsField intArrayField( QStringLiteral( "intArray" ), QMetaType::Type::QVariantList, QStringLiteral( "IntArray" ) );
QCOMPARE( intArrayField.displayString( QVariantList() << 1 << 2 << 3 ), QStringLiteral( "1, 2, 3" ) );
}
void TestQgsField::convertCompatible()
{
//test string field
const QgsField stringField( QStringLiteral( "string" ), QVariant::String, QStringLiteral( "string" ) );
const QgsField stringField( QStringLiteral( "string" ), QMetaType::Type::QString, QStringLiteral( "string" ) );
QVariant stringVar( "test string" );
QVERIFY( stringField.convertCompatible( stringVar ) );
QCOMPARE( stringVar.toString(), QString( "test string" ) );
QVariant nullString = QVariant( QVariant::String );
QVariant nullString = QgsVariantUtils::createVariant( QMetaType::Type::QString );
QVERIFY( stringField.convertCompatible( nullString ) );
QCOMPARE( nullString.type(), QVariant::String );
QCOMPARE( static_cast<QMetaType::Type>( nullString.userType() ), QMetaType::Type::QString );
QVERIFY( nullString.isNull() );
QVariant intVar( 5 );
QVERIFY( stringField.convertCompatible( intVar ) );
QCOMPARE( intVar.type(), QVariant::String );
QCOMPARE( static_cast<QMetaType::Type>( intVar.userType() ), QMetaType::Type::QString );
QCOMPARE( intVar, QVariant( "5" ) );
QVariant nullInt = QVariant( QVariant::Int );
QVariant nullInt = QgsVariantUtils::createVariant( QMetaType::Type::Int );
QVERIFY( stringField.convertCompatible( nullInt ) );
QCOMPARE( nullInt.type(), QVariant::String );
QCOMPARE( static_cast<QMetaType::Type>( nullInt.userType() ), QMetaType::Type::QString );
QVERIFY( nullInt.isNull() );
QVariant doubleVar( 1.25 );
QVERIFY( stringField.convertCompatible( doubleVar ) );
QCOMPARE( doubleVar.type(), QVariant::String );
QCOMPARE( static_cast<QMetaType::Type>( doubleVar.userType() ), QMetaType::Type::QString );
QCOMPARE( doubleVar, QVariant( "1.25" ) );
QVariant nullDouble = QVariant( QVariant::Double );
QVariant nullDouble = QgsVariantUtils::createVariant( QMetaType::Type::Double );
QVERIFY( stringField.convertCompatible( nullDouble ) );
QCOMPARE( nullDouble.type(), QVariant::String );
QCOMPARE( static_cast<QMetaType::Type>( nullDouble.userType() ), QMetaType::Type::QString );
QVERIFY( nullDouble.isNull() );
//test double
const QgsField doubleField( QStringLiteral( "double" ), QVariant::Double, QStringLiteral( "double" ) );
const QgsField doubleField( QStringLiteral( "double" ), QMetaType::Type::Double, QStringLiteral( "double" ) );
stringVar = QVariant( "test string" );
QString error;
QVERIFY( !doubleField.convertCompatible( stringVar, &error ) );
QCOMPARE( stringVar.type(), QVariant::Double );
QCOMPARE( static_cast<QMetaType::Type>( stringVar.userType() ), QMetaType::Type::Double );
QCOMPARE( error, QStringLiteral( "Could not convert value \"test string\" to target type \"double\"" ) );
stringVar = QVariant( "test string" );
QVERIFY( !doubleField.convertCompatible( stringVar ) );
QVERIFY( stringVar.isNull() );
nullString = QVariant( QVariant::String );
nullString = QgsVariantUtils::createVariant( QMetaType::Type::QString );
QVERIFY( doubleField.convertCompatible( nullString, &error ) );
QVERIFY( error.isEmpty() );
QCOMPARE( nullString.type(), QVariant::Double );
QCOMPARE( static_cast<QMetaType::Type>( nullString.userType() ), QMetaType::Type::Double );
QVERIFY( nullString.isNull() );
intVar = QVariant( 5 );
QVERIFY( doubleField.convertCompatible( intVar ) );
QCOMPARE( intVar.type(), QVariant::Double );
QCOMPARE( static_cast<QMetaType::Type>( intVar.userType() ), QMetaType::Type::Double );
QCOMPARE( intVar, QVariant( 5.0 ) );
nullInt = QVariant( QVariant::Int );
nullInt = QgsVariantUtils::createVariant( QMetaType::Type::Int );
QVERIFY( doubleField.convertCompatible( nullInt ) );
QCOMPARE( nullInt.type(), QVariant::Double );
QCOMPARE( static_cast<QMetaType::Type>( nullInt.userType() ), QMetaType::Type::Double );
QVERIFY( nullInt.isNull() );
doubleVar = QVariant( 1.25 );
QVERIFY( doubleField.convertCompatible( doubleVar ) );
QCOMPARE( doubleVar.type(), QVariant::Double );
QCOMPARE( static_cast<QMetaType::Type>( doubleVar.userType() ), QMetaType::Type::Double );
QCOMPARE( doubleVar, QVariant( 1.25 ) );
nullDouble = QVariant( QVariant::Double );
nullDouble = QgsVariantUtils::createVariant( QMetaType::Type::Double );
QVERIFY( doubleField.convertCompatible( nullDouble ) );
QCOMPARE( nullDouble.type(), QVariant::Double );
QCOMPARE( static_cast<QMetaType::Type>( nullDouble.userType() ), QMetaType::Type::Double );
QVERIFY( nullDouble.isNull() );
//test special rules
//conversion of double to int
QgsField intField( QStringLiteral( "int" ), QVariant::Int, QStringLiteral( "int" ) );
QgsField intField( QStringLiteral( "int" ), QMetaType::Type::Int, QStringLiteral( "int" ) );
//small double, should be rounded
QVariant smallDouble( 45.7 );
QVERIFY( intField.convertCompatible( smallDouble ) );
QCOMPARE( smallDouble.type(), QVariant::Int );
QCOMPARE( static_cast<QMetaType::Type>( smallDouble.userType() ), QMetaType::Type::Int );
QCOMPARE( smallDouble, QVariant( 46 ) );
QVariant negativeSmallDouble( -9345.754534525235235 );
QVERIFY( intField.convertCompatible( negativeSmallDouble ) );
QCOMPARE( negativeSmallDouble.type(), QVariant::Int );
QCOMPARE( static_cast<QMetaType::Type>( negativeSmallDouble.userType() ), QMetaType::Type::Int );
QCOMPARE( negativeSmallDouble, QVariant( -9346 ) );
//large double, cannot be converted
QVariant largeDouble( 9999999999.99 );
@ -660,7 +660,7 @@ void TestQgsField::convertCompatible()
QCOMPARE( error, QStringLiteral( "Value \"10000000000\" is too large for integer field" ) );
largeDouble = QVariant( 9999999999.99 );
QVERIFY( !intField.convertCompatible( largeDouble ) );
QCOMPARE( largeDouble.type(), QVariant::Int );
QCOMPARE( static_cast<QMetaType::Type>( largeDouble.userType() ), QMetaType::Type::Int );
QVERIFY( largeDouble.isNull() );
//conversion of string double value to int
@ -669,16 +669,16 @@ void TestQgsField::convertCompatible()
QCOMPARE( error, QStringLiteral( "Value \"notanumber\" is not a number" ) );
notNumberString = QVariant( "notanumber" );
QVERIFY( !intField.convertCompatible( notNumberString ) );
QCOMPARE( notNumberString.type(), QVariant::Int );
QCOMPARE( static_cast<QMetaType::Type>( notNumberString.userType() ), QMetaType::Type::Int );
QVERIFY( notNumberString.isNull() );
//small double, should be rounded
QVariant smallDoubleString( "45.7" );
QVERIFY( intField.convertCompatible( smallDoubleString ) );
QCOMPARE( smallDoubleString.type(), QVariant::Int );
QCOMPARE( static_cast<QMetaType::Type>( smallDoubleString.userType() ), QMetaType::Type::Int );
QCOMPARE( smallDoubleString, QVariant( 46 ) );
QVariant negativeSmallDoubleString( "-9345.754534525235235" );
QVERIFY( intField.convertCompatible( negativeSmallDoubleString ) );
QCOMPARE( negativeSmallDoubleString.type(), QVariant::Int );
QCOMPARE( static_cast<QMetaType::Type>( negativeSmallDoubleString.userType() ), QMetaType::Type::Int );
QCOMPARE( negativeSmallDoubleString, QVariant( -9346 ) );
//large double, cannot be converted
QVariant largeDoubleString( "9999999999.99" );
@ -686,96 +686,96 @@ void TestQgsField::convertCompatible()
QCOMPARE( error, QStringLiteral( "Value \"1e+10\" is too large for integer field" ) );
largeDoubleString = QVariant( "9999999999.99" );
QVERIFY( !intField.convertCompatible( largeDoubleString ) );
QCOMPARE( largeDoubleString.type(), QVariant::Int );
QCOMPARE( static_cast<QMetaType::Type>( largeDoubleString.userType() ), QMetaType::Type::Int );
QVERIFY( largeDoubleString.isNull() );
//conversion of longlong to int
QVariant longlong( 99999999999999999LL );
QVERIFY( !intField.convertCompatible( longlong, &error ) );
QCOMPARE( error, QStringLiteral( "Value \"99999999999999999\" is too large for integer field" ) );
QCOMPARE( longlong.type(), QVariant::Int );
QCOMPARE( static_cast<QMetaType::Type>( longlong.userType() ), QMetaType::Type::Int );
QVERIFY( longlong.isNull() );
QVariant smallLonglong( 99LL );
QVERIFY( intField.convertCompatible( smallLonglong ) );
QCOMPARE( smallLonglong.type(), QVariant::Int );
QCOMPARE( static_cast<QMetaType::Type>( smallLonglong.userType() ), QMetaType::Type::Int );
QCOMPARE( smallLonglong, QVariant( 99 ) );
// negative longlong to int
QVariant negativeLonglong( -99999999999999999LL );
QVERIFY( !intField.convertCompatible( negativeLonglong, &error ) );
QCOMPARE( error, QStringLiteral( "Value \"-99999999999999999\" is too large for integer field" ) );
QCOMPARE( negativeLonglong.type(), QVariant::Int );
QCOMPARE( static_cast<QMetaType::Type>( negativeLonglong.userType() ), QMetaType::Type::Int );
QVERIFY( negativeLonglong.isNull() );
// small negative longlong to int
QVariant smallNegativeLonglong( -99LL );
QVERIFY( intField.convertCompatible( smallNegativeLonglong ) );
QCOMPARE( smallNegativeLonglong.type(), QVariant::Int );
QCOMPARE( static_cast<QMetaType::Type>( smallNegativeLonglong.userType() ), QMetaType::Type::Int );
QCOMPARE( smallNegativeLonglong, QVariant( -99 ) );
//string representation of an int
QVariant stringInt( "123456" );
QVERIFY( intField.convertCompatible( stringInt ) );
QCOMPARE( stringInt.type(), QVariant::Int );
QCOMPARE( static_cast<QMetaType::Type>( stringInt.userType() ), QMetaType::Type::Int );
QCOMPARE( stringInt, QVariant( 123456 ) );
// now with group separator for english locale
stringInt = QVariant( "123,456" );
QVERIFY( intField.convertCompatible( stringInt ) );
QCOMPARE( stringInt.type(), QVariant::Int );
QCOMPARE( static_cast<QMetaType::Type>( stringInt.userType() ), QMetaType::Type::Int );
QCOMPARE( stringInt, QVariant( "123456" ) );
//conversion of longlong to longlong field
const QgsField longlongField( QStringLiteral( "long" ), QVariant::LongLong, QStringLiteral( "longlong" ) );
const QgsField longlongField( QStringLiteral( "long" ), QMetaType::Type::LongLong, QStringLiteral( "longlong" ) );
longlong = QVariant( 99999999999999999LL );
QVERIFY( longlongField.convertCompatible( longlong ) );
QCOMPARE( longlong.type(), QVariant::LongLong );
QCOMPARE( static_cast<QMetaType::Type>( longlong.userType() ), QMetaType::Type::LongLong );
QCOMPARE( longlong, QVariant( 99999999999999999LL ) );
//string representation of a longlong
QVariant stringLong( "99999999999999999" );
QVERIFY( longlongField.convertCompatible( stringLong ) );
QCOMPARE( stringLong.type(), QVariant::LongLong );
QCOMPARE( static_cast<QMetaType::Type>( stringLong.userType() ), QMetaType::Type::LongLong );
QCOMPARE( stringLong, QVariant( 99999999999999999LL ) );
// now with group separator for english locale
stringLong = QVariant( "99,999,999,999,999,999" );
QVERIFY( longlongField.convertCompatible( stringLong ) );
QCOMPARE( stringLong.type(), QVariant::LongLong );
QCOMPARE( static_cast<QMetaType::Type>( stringLong.userType() ), QMetaType::Type::LongLong );
QCOMPARE( stringLong, QVariant( 99999999999999999LL ) );
//conversion of string double value to longlong
notNumberString = QVariant( "notanumber" );
QVERIFY( !longlongField.convertCompatible( notNumberString, &error ) );
QCOMPARE( error, QStringLiteral( "Value \"notanumber\" is not a number" ) );
QCOMPARE( notNumberString.type(), QVariant::LongLong );
QCOMPARE( static_cast<QMetaType::Type>( notNumberString.userType() ), QMetaType::Type::LongLong );
QVERIFY( notNumberString.isNull() );
//small double, should be rounded
smallDoubleString = QVariant( "45.7" );
QVERIFY( longlongField.convertCompatible( smallDoubleString ) );
QCOMPARE( smallDoubleString.type(), QVariant::LongLong );
QCOMPARE( static_cast<QMetaType::Type>( smallDoubleString.userType() ), QMetaType::Type::LongLong );
QCOMPARE( smallDoubleString, QVariant( 46 ) );
negativeSmallDoubleString = QVariant( "-9345.754534525235235" );
QVERIFY( longlongField.convertCompatible( negativeSmallDoubleString ) );
QCOMPARE( negativeSmallDoubleString.type(), QVariant::LongLong );
QCOMPARE( static_cast<QMetaType::Type>( negativeSmallDoubleString.userType() ), QMetaType::Type::LongLong );
QCOMPARE( negativeSmallDoubleString, QVariant( -9346 ) );
//large double, can be converted
largeDoubleString = QVariant( "9999999999.99" );
QVERIFY( longlongField.convertCompatible( largeDoubleString ) );
QCOMPARE( largeDoubleString.type(), QVariant::LongLong );
QCOMPARE( static_cast<QMetaType::Type>( largeDoubleString.userType() ), QMetaType::Type::LongLong );
QCOMPARE( largeDoubleString, QVariant( 10000000000LL ) );
//extra large double, cannot be converted
largeDoubleString = QVariant( "999999999999999999999.99" );
QVERIFY( !longlongField.convertCompatible( largeDoubleString, &error ) );
QCOMPARE( error, QStringLiteral( "Value \"1e+21\" is too large for long long field" ) );
QCOMPARE( largeDoubleString.type(), QVariant::LongLong );
QCOMPARE( static_cast<QMetaType::Type>( largeDoubleString.userType() ), QMetaType::Type::LongLong );
QVERIFY( largeDoubleString.isNull() );
//string representation of a double
QVariant stringDouble( "123456.012345" );
QVERIFY( doubleField.convertCompatible( stringDouble ) );
QCOMPARE( stringDouble.type(), QVariant::Double );
QCOMPARE( static_cast<QMetaType::Type>( stringDouble.userType() ), QMetaType::Type::Double );
QCOMPARE( stringDouble, QVariant( 123456.012345 ) );
// now with group separator for english locale
stringDouble = QVariant( "1,223,456.012345" );
QVERIFY( doubleField.convertCompatible( stringDouble ) );
QCOMPARE( stringDouble.type(), QVariant::Double );
QCOMPARE( static_cast<QMetaType::Type>( stringDouble.userType() ), QMetaType::Type::Double );
QCOMPARE( stringDouble, QVariant( 1223456.012345 ) );
// This should not convert
stringDouble = QVariant( "1.223.456,012345" );
@ -783,28 +783,28 @@ void TestQgsField::convertCompatible()
QCOMPARE( error, QStringLiteral( "Could not convert value \"1.223.456,012345\" to target type \"double\"" ) );
//double with precision
const QgsField doubleWithPrecField( QStringLiteral( "double" ), QVariant::Double, QStringLiteral( "double" ), 10, 3 );
const QgsField doubleWithPrecField( QStringLiteral( "double" ), QMetaType::Type::Double, QStringLiteral( "double" ), 10, 3 );
doubleVar = QVariant( 10.12345678 );
//note - this returns true!
QVERIFY( doubleWithPrecField.convertCompatible( doubleVar ) );
QCOMPARE( doubleVar.type(), QVariant::Double );
QCOMPARE( static_cast<QMetaType::Type>( doubleVar.userType() ), QMetaType::Type::Double );
QCOMPARE( doubleVar.toDouble(), 10.123 );
//truncating string length
const QgsField stringWithLen( QStringLiteral( "string" ), QVariant::String, QStringLiteral( "string" ), 3 );
const QgsField stringWithLen( QStringLiteral( "string" ), QMetaType::Type::QString, QStringLiteral( "string" ), 3 );
stringVar = QVariant( "longstring" );
QVERIFY( !stringWithLen.convertCompatible( stringVar, &error ) );
QCOMPARE( error, QStringLiteral( "String of length 10 exceeds maximum field length (3)" ) );
QCOMPARE( stringVar.type(), QVariant::String );
QCOMPARE( static_cast<QMetaType::Type>( stringVar.userType() ), QMetaType::Type::QString );
QCOMPARE( stringVar.toString(), QString( "lon" ) );
// Referenced geometries
const QgsField stringGeomRef( QStringLiteral( "string" ), QVariant::String, QStringLiteral( "string" ) );
const QgsField stringGeomRef( QStringLiteral( "string" ), QMetaType::Type::QString, QStringLiteral( "string" ) );
QgsGeometry geom { QgsGeometry::fromWkt( "POINT( 1 1 )" ) };
QgsReferencedGeometry geomRef { geom, QgsCoordinateReferenceSystem() };
QVariant geomVar = QVariant::fromValue( geomRef );
QVERIFY( stringGeomRef.convertCompatible( geomVar, &error ) );
QCOMPARE( geomVar.type(), QVariant::String );
QCOMPARE( static_cast<QMetaType::Type>( geomVar.userType() ), QMetaType::Type::QString );
QCOMPARE( geomVar.toString().toUpper(), QString( "POINT (1 1)" ) );
/////////////////////////////////////////////////////////
@ -814,98 +814,98 @@ void TestQgsField::convertCompatible()
QLocale::setDefault( QLocale::German );
QVariant doubleCommaVar( "1,2345" );
QVERIFY( doubleField.convertCompatible( doubleCommaVar ) );
QCOMPARE( doubleCommaVar.type(), QVariant::Double );
QCOMPARE( static_cast<QMetaType::Type>( doubleCommaVar.userType() ), QMetaType::Type::Double );
QCOMPARE( doubleCommaVar.toString(), QString( "1.2345" ) );
//string representation of an int
stringInt = QVariant( "123456" );
QVERIFY( intField.convertCompatible( stringInt ) );
QCOMPARE( stringInt.type(), QVariant::Int );
QCOMPARE( static_cast<QMetaType::Type>( stringInt.userType() ), QMetaType::Type::Int );
QCOMPARE( stringInt, QVariant( 123456 ) );
// now with group separator for german locale
stringInt = QVariant( "123.456" );
QVERIFY( intField.convertCompatible( stringInt ) );
QCOMPARE( stringInt.type(), QVariant::Int );
QCOMPARE( static_cast<QMetaType::Type>( stringInt.userType() ), QMetaType::Type::Int );
QCOMPARE( stringInt, QVariant( "123456" ) );
//string representation of a longlong
stringLong = QVariant( "99999999999999999" );
QVERIFY( longlongField.convertCompatible( stringLong ) );
QCOMPARE( stringLong.type(), QVariant::LongLong );
QCOMPARE( static_cast<QMetaType::Type>( stringLong.userType() ), QMetaType::Type::LongLong );
QCOMPARE( stringLong, QVariant( 99999999999999999LL ) );
// now with group separator for german locale
stringLong = QVariant( "99.999.999.999.999.999" );
QVERIFY( longlongField.convertCompatible( stringLong ) );
QCOMPARE( stringLong.type(), QVariant::LongLong );
QCOMPARE( static_cast<QMetaType::Type>( stringLong.userType() ), QMetaType::Type::LongLong );
QCOMPARE( stringLong, QVariant( 99999999999999999LL ) );
//string representation of a double
stringDouble = QVariant( "123456,012345" );
QVERIFY( doubleField.convertCompatible( stringDouble ) );
QCOMPARE( stringDouble.type(), QVariant::Double );
QCOMPARE( static_cast<QMetaType::Type>( stringDouble.userType() ), QMetaType::Type::Double );
QCOMPARE( stringDouble, QVariant( 123456.012345 ) );
// For doubles we also want to accept dot as a decimal point
stringDouble = QVariant( "123456.012345" );
QVERIFY( doubleField.convertCompatible( stringDouble ) );
QCOMPARE( stringDouble.type(), QVariant::Double );
QCOMPARE( static_cast<QMetaType::Type>( stringDouble.userType() ), QMetaType::Type::Double );
QCOMPARE( stringDouble, QVariant( 123456.012345 ) );
// now with group separator for german locale
stringDouble = QVariant( "1.223.456,012345" );
QVERIFY( doubleField.convertCompatible( stringDouble ) );
QCOMPARE( stringDouble.type(), QVariant::Double );
QCOMPARE( static_cast<QMetaType::Type>( stringDouble.userType() ), QMetaType::Type::Double );
QCOMPARE( stringDouble, QVariant( 1223456.012345 ) );
// Be are good citizens and we also accept english locale
stringDouble = QVariant( "1,223,456.012345" );
QVERIFY( doubleField.convertCompatible( stringDouble ) );
QCOMPARE( stringDouble.type(), QVariant::Double );
QCOMPARE( static_cast<QMetaType::Type>( stringDouble.userType() ), QMetaType::Type::Double );
QCOMPARE( stringDouble, QVariant( 1223456.012345 ) );
// Test that wrongly formatted decimal separator are also accepted
QLocale::setDefault( QLocale::German );
stringDouble = QVariant( "12.23.456,012345" );
QVERIFY( doubleField.convertCompatible( stringDouble ) );
QCOMPARE( stringDouble.type(), QVariant::Double );
QCOMPARE( static_cast<QMetaType::Type>( stringDouble.userType() ), QMetaType::Type::Double );
QCOMPARE( stringDouble, QVariant( 1223456.012345 ) );
// Test 0 on int fields
intField = QgsField( QStringLiteral( "int" ), QVariant::Int, QStringLiteral( "Integer" ), 10 );
intField = QgsField( QStringLiteral( "int" ), QMetaType::Type::Int, QStringLiteral( "Integer" ), 10 );
QVariant vZero = 0;
QVERIFY( intField.convertCompatible( vZero ) );
// Test string-based json field conversion
{
const QgsField jsonField( QStringLiteral( "json" ), QVariant::String, QStringLiteral( "json" ) );
const QgsField jsonField( QStringLiteral( "json" ), QMetaType::Type::QString, QStringLiteral( "json" ) );
QVariant jsonValue = QVariant::fromValue( QVariantList() << 1 << 5 << 8 );
QVERIFY( jsonField.convertCompatible( jsonValue ) );
QCOMPARE( jsonValue.type(), QVariant::String );
QCOMPARE( static_cast<QMetaType::Type>( jsonValue.userType() ), QMetaType::Type::QString );
QCOMPARE( jsonValue, QString( "[1,5,8]" ) );
QVariantMap variantMap;
variantMap.insert( QStringLiteral( "a" ), 1 );
variantMap.insert( QStringLiteral( "c" ), 3 );
jsonValue = QVariant::fromValue( variantMap );
QVERIFY( jsonField.convertCompatible( jsonValue ) );
QCOMPARE( jsonValue.type(), QVariant::String );
QCOMPARE( static_cast<QMetaType::Type>( jsonValue.userType() ), QMetaType::Type::QString );
QCOMPARE( jsonValue, QString( "{\"a\":1,\"c\":3}" ) );
}
// Test map-based json field (i.e. OGR geopackage JSON fields) conversion
{
const QgsField jsonField( QStringLiteral( "json" ), QVariant::Map, QStringLiteral( "json" ) );
const QgsField jsonField( QStringLiteral( "json" ), QMetaType::Type::QVariantMap, QStringLiteral( "json" ) );
QVariant jsonValue = QVariant::fromValue( QVariantList() << 1 << 5 << 8 );
QVERIFY( jsonField.convertCompatible( jsonValue ) );
QCOMPARE( jsonValue.type(), QVariant::List );
QCOMPARE( static_cast<QMetaType::Type>( jsonValue.userType() ), QMetaType::Type::QVariantList );
QCOMPARE( jsonValue, QVariantList() << 1 << 5 << 8 );
QVariantMap variantMap;
variantMap.insert( QStringLiteral( "a" ), 1 );
variantMap.insert( QStringLiteral( "c" ), 3 );
jsonValue = QVariant::fromValue( variantMap );
QVERIFY( jsonField.convertCompatible( jsonValue ) );
QCOMPARE( jsonValue.type(), QVariant::Map );
QCOMPARE( static_cast<QMetaType::Type>( jsonValue.userType() ), QMetaType::Type::QVariantMap );
QCOMPARE( jsonValue, variantMap );
}
// geometry field conversion
const QgsField geometryField( QStringLiteral( "geometry" ), QVariant::UserType, QStringLiteral( "geometry" ) );
const QgsField geometryField( QStringLiteral( "geometry" ), QMetaType::Type::User, QStringLiteral( "geometry" ) );
QVariant geometryValue;
QVERIFY( geometryField.convertCompatible( geometryValue ) );
QVERIFY( geometryValue.isNull() );
@ -926,7 +926,7 @@ void TestQgsField::dataStream()
{
QgsField original;
original.setName( QStringLiteral( "name" ) );
original.setType( QVariant::Int );
original.setType( QMetaType::Type::Int );
original.setLength( 5 );
original.setPrecision( 2 );
original.setTypeName( QStringLiteral( "typename1" ) );
@ -1000,15 +1000,15 @@ void TestQgsField::displayType()
void TestQgsField::friendlyTypeString()
{
QgsField field;
field.setType( QVariant::String );
field.setType( QMetaType::Type::QString );
QCOMPARE( field.friendlyTypeString(), QStringLiteral( "Text (string)" ) );
field.setType( QVariant::Double );
field.setType( QMetaType::Type::Double );
field.setLength( 20 );
QCOMPARE( field.friendlyTypeString(), QStringLiteral( "Decimal (double)" ) );
field.setType( QVariant::List );
field.setSubType( QVariant::String );
field.setType( QMetaType::Type::QVariantList );
field.setSubType( QMetaType::Type::QString );
QCOMPARE( field.friendlyTypeString(), QStringLiteral( "List" ) );
field.setType( QVariant::UserType );
field.setType( QMetaType::Type::User );
field.setTypeName( QStringLiteral( "geometry" ) );
QCOMPARE( field.friendlyTypeString(), QStringLiteral( "Geometry" ) );
}
@ -1036,10 +1036,10 @@ void TestQgsField::editorWidgetSetup()
void TestQgsField::collection()
{
QgsField field( QStringLiteral( "collection" ), QVariant::List, QStringLiteral( "_int32" ), 0, 0, QString(), QVariant::Int );
QCOMPARE( field.subType(), QVariant::Int );
field.setSubType( QVariant::Double );
QCOMPARE( field.subType(), QVariant::Double );
QgsField field( QStringLiteral( "collection" ), QMetaType::Type::QVariantList, QStringLiteral( "_int32" ), 0, 0, QString(), QMetaType::Type::Int );
QCOMPARE( field.subType(), QMetaType::Type::Int );
field.setSubType( QMetaType::Type::Double );
QCOMPARE( field.subType(), QMetaType::Type::Double );
QVariant str( "hello" );
QVERIFY( !field.convertCompatible( str ) );
@ -1052,7 +1052,7 @@ void TestQgsField::collection()
QVERIFY( field.convertCompatible( doubleList ) );
QCOMPARE( doubleList.toList(), QVariantList( {1.1, 2.2, 3.3 } ) );
QgsField stringListField( QStringLiteral( "collection" ), QVariant::StringList );
QgsField stringListField( QStringLiteral( "collection" ), QMetaType::Type::QStringList );
str = QVariant( "hello" );
QVERIFY( stringListField.convertCompatible( str ) );
QCOMPARE( str, QStringList{ QStringLiteral( "hello" )} );

6
tests/src/core/testqgsfields.cpp
View File

@ -443,7 +443,7 @@ void TestQgsFields::dataStream()
{
QgsField original1;
original1.setName( QStringLiteral( "name" ) );
original1.setType( QVariant::Int );
original1.setType( QMetaType::Type::Int );
original1.setLength( 5 );
original1.setPrecision( 2 );
original1.setTypeName( QStringLiteral( "typename1" ) );
@ -451,7 +451,7 @@ void TestQgsFields::dataStream()
QgsField original2;
original2.setName( QStringLiteral( "next name" ) );
original2.setType( QVariant::Double );
original2.setType( QMetaType::Type::Double );
original2.setLength( 15 );
original2.setPrecision( 3 );
original2.setTypeName( QStringLiteral( "double" ) );
@ -480,7 +480,7 @@ void TestQgsFields::field()
{
QgsField original;
original.setName( QStringLiteral( "name" ) );
original.setType( QVariant::Int );
original.setType( QMetaType::Type::Int );
original.setLength( 5 );
original.setPrecision( 2 );

16
tests/src/core/testqgsgeopdfexport.cpp
View File

@ -83,8 +83,8 @@ void TestQgsGeoPdfExport::testCollectingFeatures()
QCOMPARE( geoPdfExporter.mVectorComponents.count(), 0 );
QgsFields fields;
fields.append( QgsField( QStringLiteral( "a1" ), QVariant::Int ) );
fields.append( QgsField( QStringLiteral( "a2" ), QVariant::Int ) );
fields.append( QgsField( QStringLiteral( "a1" ), QMetaType::Type::Int ) );
fields.append( QgsField( QStringLiteral( "a2" ), QMetaType::Type::Int ) );
QgsFeature f( fields );
f.setAttributes( QgsAttributes() << 1 << 2 );
@ -161,8 +161,8 @@ void TestQgsGeoPdfExport::testComposition()
QCOMPARE( geoPdfExporter.mVectorComponents.count(), 0 );
QgsFields fields;
fields.append( QgsField( QStringLiteral( "a1" ), QVariant::Int ) );
fields.append( QgsField( QStringLiteral( "a2" ), QVariant::Int ) );
fields.append( QgsField( QStringLiteral( "a1" ), QMetaType::Type::Int ) );
fields.append( QgsField( QStringLiteral( "a2" ), QMetaType::Type::Int ) );
QgsFeature f( fields );
f.setAttributes( QgsAttributes() << 1 << 2 );
@ -400,8 +400,8 @@ void TestQgsGeoPdfExport::testGroups()
QCOMPARE( geoPdfExporter.mVectorComponents.count(), 0 );
QgsFields fields;
fields.append( QgsField( QStringLiteral( "a1" ), QVariant::Int ) );
fields.append( QgsField( QStringLiteral( "a2" ), QVariant::Int ) );
fields.append( QgsField( QStringLiteral( "a1" ), QMetaType::Type::Int ) );
fields.append( QgsField( QStringLiteral( "a2" ), QMetaType::Type::Int ) );
QgsFeature f( fields );
f.setAttributes( QgsAttributes() << 1 << 2 );
@ -481,8 +481,8 @@ void TestQgsGeoPdfExport::testCustomGroups()
TestGeoPdfExporter geoPdfExporter;
QgsFields fields;
fields.append( QgsField( QStringLiteral( "a1" ), QVariant::Int ) );
fields.append( QgsField( QStringLiteral( "a2" ), QVariant::Int ) );
fields.append( QgsField( QStringLiteral( "a1" ), QMetaType::Type::Int ) );
fields.append( QgsField( QStringLiteral( "a2" ), QMetaType::Type::Int ) );
QgsFeature f( fields );
f.setAttributes( QgsAttributes() << 1 << 2 );

48
tests/src/core/testqgsgml.cpp
View File

@ -115,8 +115,8 @@ const QString data1( "<myns:FeatureCollection "
void TestQgsGML::testFromURL()
{
QgsFields fields;
fields.append( QgsField( QStringLiteral( "intfield" ), QVariant::Int, QStringLiteral( "int" ) ) );
fields.append( QgsField( QStringLiteral( "nillablefield" ), QVariant::Int, QStringLiteral( "nillablefield" ) ) );
fields.append( QgsField( QStringLiteral( "intfield" ), QMetaType::Type::Int, QStringLiteral( "int" ) ) );
fields.append( QgsField( QStringLiteral( "nillablefield" ), QMetaType::Type::Int, QStringLiteral( "nillablefield" ) ) );
QgsGml gmlParser( QStringLiteral( "mytypename" ), QStringLiteral( "mygeom" ), fields );
Qgis::WkbType wkbType;
QTemporaryFile tmpFile;
@ -137,8 +137,8 @@ void TestQgsGML::testFromURL()
void TestQgsGML::testFromByteArray()
{
QgsFields fields;
fields.append( QgsField( QStringLiteral( "intfield" ), QVariant::Int, QStringLiteral( "int" ) ) );
fields.append( QgsField( QStringLiteral( "nillablefield" ), QVariant::Int, QStringLiteral( "nillablefield" ) ) );
fields.append( QgsField( QStringLiteral( "intfield" ), QMetaType::Type::Int, QStringLiteral( "int" ) ) );
fields.append( QgsField( QStringLiteral( "nillablefield" ), QMetaType::Type::Int, QStringLiteral( "nillablefield" ) ) );
QgsGml gmlParser( QStringLiteral( "mytypename" ), QStringLiteral( "mygeom" ), fields );
Qgis::WkbType wkbType;
QCOMPARE( gmlParser.getFeatures( data1.toLatin1(), &wkbType ), 0 );
@ -157,12 +157,12 @@ void TestQgsGML::testFromByteArray()
void TestQgsGML::testStreamingParser()
{
QgsFields fields;
fields.append( QgsField( QStringLiteral( "intfield" ), QVariant::Int, QStringLiteral( "int" ) ) );
fields.append( QgsField( QStringLiteral( "nillablefield" ), QVariant::Int, QStringLiteral( "nillablefield" ) ) );
fields.append( QgsField( QStringLiteral( "longfield" ), QVariant::LongLong, QStringLiteral( "longlong" ) ) );
fields.append( QgsField( QStringLiteral( "doublefield" ), QVariant::Double, QStringLiteral( "double" ) ) );
fields.append( QgsField( QStringLiteral( "strfield" ), QVariant::String, QStringLiteral( "string" ) ) );
fields.append( QgsField( QStringLiteral( "datetimefield" ), QVariant::DateTime, QStringLiteral( "datetime" ) ) );
fields.append( QgsField( QStringLiteral( "intfield" ), QMetaType::Type::Int, QStringLiteral( "int" ) ) );
fields.append( QgsField( QStringLiteral( "nillablefield" ), QMetaType::Type::Int, QStringLiteral( "nillablefield" ) ) );
fields.append( QgsField( QStringLiteral( "longfield" ), QMetaType::Type::LongLong, QStringLiteral( "longlong" ) ) );
fields.append( QgsField( QStringLiteral( "doublefield" ), QMetaType::Type::Double, QStringLiteral( "double" ) ) );
fields.append( QgsField( QStringLiteral( "strfield" ), QMetaType::Type::QString, QStringLiteral( "string" ) ) );
fields.append( QgsField( QStringLiteral( "datetimefield" ), QMetaType::Type::QDateTime, QStringLiteral( "datetime" ) ) );
QgsGmlStreamingParser gmlParser( QStringLiteral( "mytypename" ), QStringLiteral( "mygeom" ), fields );
QCOMPARE( gmlParser.processData( data1.mid( 0, data1.size() / 2 ).toLatin1(), false ), true );
QCOMPARE( gmlParser.getAndStealReadyFeatures().size(), 0 );
@ -991,8 +991,8 @@ void TestQgsGML::testException()
void TestQgsGML::testTuple()
{
QgsFields fields;
fields.append( QgsField( QStringLiteral( "my_first_attr" ), QVariant::Int, QStringLiteral( "int" ) ) );
fields.append( QgsField( QStringLiteral( "my_second_attr" ), QVariant::Int, QStringLiteral( "int" ) ) );
fields.append( QgsField( QStringLiteral( "my_first_attr" ), QMetaType::Type::Int, QStringLiteral( "int" ) ) );
fields.append( QgsField( QStringLiteral( "my_second_attr" ), QMetaType::Type::Int, QStringLiteral( "int" ) ) );
QList<QgsGmlStreamingParser::LayerProperties> layerProperties;
QgsGmlStreamingParser::LayerProperties prop;
prop.mName = QStringLiteral( "ns:firstlayer" );
@ -1046,7 +1046,7 @@ void TestQgsGML::testTuple()
void TestQgsGML::testRenamedFields()
{
QgsFields fields;
fields.append( QgsField( QStringLiteral( "my_first_attr" ), QVariant::Int, QStringLiteral( "int" ) ) );
fields.append( QgsField( QStringLiteral( "my_first_attr" ), QMetaType::Type::Int, QStringLiteral( "int" ) ) );
QList<QgsGmlStreamingParser::LayerProperties> layerProperties;
QgsGmlStreamingParser::LayerProperties prop;
prop.mName = QStringLiteral( "ns:mylayer" );
@ -1319,7 +1319,7 @@ void TestQgsGML::testUnknownEncoding()
"</myns:FeatureCollection>" ).arg( xmlHeader ) );
QgsFields fields;
fields.append( QgsField( QStringLiteral( "strfield" ), QVariant::String, QStringLiteral( "string" ) ) );
fields.append( QgsField( QStringLiteral( "strfield" ), QMetaType::Type::QString, QStringLiteral( "string" ) ) );
{
QgsGml gmlParser( QStringLiteral( "mytypename" ), QStringLiteral( "mygeom" ), fields );
@ -1370,7 +1370,7 @@ void TestQgsGML::testUnhandledEncoding()
"</myns:FeatureCollection>" );
QgsFields fields;
fields.append( QgsField( QStringLiteral( "strfield" ), QVariant::String, QStringLiteral( "string" ) ) );
fields.append( QgsField( QStringLiteral( "strfield" ), QMetaType::Type::QString, QStringLiteral( "string" ) ) );
QgsGml gmlParser( QStringLiteral( "mytypename" ), QStringLiteral( "mygeom" ), fields );
QCOMPARE( gmlParser.getFeatures( data.toUtf8(), &wkbType ), 0 );
@ -1419,15 +1419,15 @@ void TestQgsGML::testXPath()
"</myns:FeatureCollection>" );
QgsFields fields;
fields.append( QgsField( QStringLiteral( "fid" ), QVariant::String, QStringLiteral( "fid" ) ) );
fields.append( QgsField( QStringLiteral( "my_attr" ), QVariant::String, QStringLiteral( "string" ) ) );
fields.append( QgsField( QStringLiteral( "strfield" ), QVariant::String, QStringLiteral( "string" ) ) );
fields.append( QgsField( QStringLiteral( "nested_strfield2" ), QVariant::String, QStringLiteral( "string" ) ) );
fields.append( QgsField( QStringLiteral( "nested_strfield2_attr" ), QVariant::String, QStringLiteral( "string" ) ) );
fields.append( QgsField( QStringLiteral( "nested_strfield3" ), QVariant::String, QStringLiteral( "string" ) ) );
fields.append( QgsField( QStringLiteral( "complex" ), QVariant::String, QStringLiteral( "string" ) ) );
fields.append( QgsField( QStringLiteral( "complex2" ), QVariant::String, QStringLiteral( "string" ) ) );
fields.append( QgsField( QStringLiteral( "complex_repeated" ), QVariant::String, QStringLiteral( "string" ) ) );
fields.append( QgsField( QStringLiteral( "fid" ), QMetaType::Type::QString, QStringLiteral( "fid" ) ) );
fields.append( QgsField( QStringLiteral( "my_attr" ), QMetaType::Type::QString, QStringLiteral( "string" ) ) );
fields.append( QgsField( QStringLiteral( "strfield" ), QMetaType::Type::QString, QStringLiteral( "string" ) ) );
fields.append( QgsField( QStringLiteral( "nested_strfield2" ), QMetaType::Type::QString, QStringLiteral( "string" ) ) );
fields.append( QgsField( QStringLiteral( "nested_strfield2_attr" ), QMetaType::Type::QString, QStringLiteral( "string" ) ) );
fields.append( QgsField( QStringLiteral( "nested_strfield3" ), QMetaType::Type::QString, QStringLiteral( "string" ) ) );
fields.append( QgsField( QStringLiteral( "complex" ), QMetaType::Type::QString, QStringLiteral( "string" ) ) );
fields.append( QgsField( QStringLiteral( "complex2" ), QMetaType::Type::QString, QStringLiteral( "string" ) ) );
fields.append( QgsField( QStringLiteral( "complex_repeated" ), QMetaType::Type::QString, QStringLiteral( "string" ) ) );
QgsGmlStreamingParser gmlParser( QStringLiteral( "mytypename" ), QStringLiteral( "mygeom" ), fields );

50
tests/src/core/testqgsjsonutils.cpp
View File

@ -60,7 +60,7 @@ void TestQgsJsonUtils::testStringList()
{
const QString json = QgsJsonUtils::encodeValue( list );
QCOMPARE( json, QString( "[]" ) );
const QVariant back = QgsJsonUtils::parseArray( json, QVariant::String );
const QVariant back = QgsJsonUtils::parseArray( json, QMetaType::Type::QString );
QCOMPARE( back.toStringList(), list );
}
@ -68,16 +68,16 @@ void TestQgsJsonUtils::testStringList()
list << QStringLiteral( "one" ) << QStringLiteral( "<',\"\\>" ) << QStringLiteral( "two" );
const QString json = QgsJsonUtils::encodeValue( list );
QCOMPARE( json, QString( "[\"one\",\"<',\\\"\\\\>\",\"two\"]" ) );
const QVariant back = QgsJsonUtils::parseArray( json, QVariant::String );
const QVariant back = QgsJsonUtils::parseArray( json, QMetaType::Type::QString );
QCOMPARE( back.toStringList(), list );
}
}
void TestQgsJsonUtils::testJsonArray()
{
QCOMPARE( QgsJsonUtils::parseArray( R"([1,2,3])", QVariant::Int ), QVariantList() << 1 << 2 << 3 );
QCOMPARE( QgsJsonUtils::parseArray( R"([1,2,3])", QMetaType::Type::Int ), QVariantList() << 1 << 2 << 3 );
QCOMPARE( QgsJsonUtils::parseArray( R"([1,2,3])" ), QVariantList() << 1 << 2 << 3 );
QCOMPARE( QgsJsonUtils::parseArray( R"([1,2,3])", QVariant::Double ), QVariantList() << 1.0 << 2.0 << 3.0 );
QCOMPARE( QgsJsonUtils::parseArray( R"([1,2,3])", QMetaType::Type::Double ), QVariantList() << 1.0 << 2.0 << 3.0 );
QCOMPARE( QgsJsonUtils::parseArray( R"([1.0,2.0,3.0])" ), QVariantList() << 1.0 << 2.0 << 3.0 );
QCOMPARE( QgsJsonUtils::parseArray( R"([1.234567,2.00003e+4,-3.01234e-02])" ), QVariantList() << 1.234567 << 2.00003e+4 << -3.01234e-2 );
// Strings
@ -89,21 +89,21 @@ void TestQgsJsonUtils::testJsonArray()
// Mixed types
QCOMPARE( QgsJsonUtils::parseArray( R"([1,"a",2.0])" ), QVariantList() << 1 << "a" << 2.0 );
// discarded ...
QCOMPARE( QgsJsonUtils::parseArray( R"([1,"a",2.0])", QVariant::Int ), QVariantList() << 1 << 2.0 );
QCOMPARE( QgsJsonUtils::parseArray( R"([1,"a",2.0])", QMetaType::Type::Int ), QVariantList() << 1 << 2.0 );
// Try invalid JSON
QCOMPARE( QgsJsonUtils::parseArray( R"(not valid json here)" ), QVariantList() );
QCOMPARE( QgsJsonUtils::parseArray( R"(not valid json here)", QVariant::Int ), QVariantList() );
QCOMPARE( QgsJsonUtils::parseArray( R"(not valid json here)", QMetaType::Type::Int ), QVariantList() );
// Empty
QCOMPARE( QgsJsonUtils::parseArray( R"([])", QVariant::Int ), QVariantList() );
QCOMPARE( QgsJsonUtils::parseArray( "", QVariant::Int ), QVariantList() );
QCOMPARE( QgsJsonUtils::parseArray( R"([])", QMetaType::Type::Int ), QVariantList() );
QCOMPARE( QgsJsonUtils::parseArray( "", QMetaType::Type::Int ), QVariantList() );
// Booleans
QCOMPARE( QgsJsonUtils::parseArray( "[true,false]", QVariant::Bool ), QVariantList() << true << false );
QCOMPARE( QgsJsonUtils::parseArray( "[true,false]", QMetaType::Type::Bool ), QVariantList() << true << false );
// Nulls
for ( const QVariant &value : QgsJsonUtils::parseArray( R"([null, null])" ) )
{
QVERIFY( value.isNull() );
QVERIFY( value.isValid() );
QCOMPARE( value, QVariant( QVariant::Type::Int ) );
QCOMPARE( value, QgsVariantUtils::createVariant( QMetaType::Type::Int ) );
}
for ( const QVariant &value : QgsJsonUtils::parseArray( R"([null, null])", QVariant::Type::Double ) )
{
@ -117,7 +117,7 @@ void TestQgsJsonUtils::testJsonToVariant()
{
const json value = json::parse( "{\"_bool\":true,\"_double\":1234.45,\"_int\":123,\"_list\":[1,2,3.4,null],\"_null\":null,\"_object\":{\"int\":123}}" );
const QVariant variant = QgsJsonUtils::jsonToVariant( value );
QCOMPARE( variant.type(), QVariant::Map );
QCOMPARE( static_cast<QMetaType::Type>( variant.userType() ), QMetaType::Type::QVariantMap );
QCOMPARE( variant.toMap().value( QStringLiteral( "_bool" ) ), true );
QCOMPARE( variant.toMap().value( QStringLiteral( "_double" ) ), 1234.45 );
QCOMPARE( variant.toMap().value( QStringLiteral( "_int" ) ), 123 );
@ -171,14 +171,14 @@ void TestQgsJsonUtils::testIntList()
list << 1 << -2;
const QString json = QgsJsonUtils::encodeValue( list );
QCOMPARE( json, QString( "[1,-2]" ) );
const QVariantList back = QgsJsonUtils::parseArray( json, QVariant::Int );
const QVariantList back = QgsJsonUtils::parseArray( json, QMetaType::Type::Int );
QCOMPARE( back, list );
QCOMPARE( back.at( 0 ).type(), QVariant::Int );
QCOMPARE( static_cast<QMetaType::Type>( back.at( 0 ).userType() ), QMetaType::Type::Int );
}
{
// check invalid entries are ignored
const QVariantList back = QgsJsonUtils::parseArray( QStringLiteral( "[1,\"a\",-2]" ), QVariant::Int );
const QVariantList back = QgsJsonUtils::parseArray( QStringLiteral( "[1,\"a\",-2]" ), QMetaType::Type::Int );
QCOMPARE( back, list );
}
}
@ -190,9 +190,9 @@ void TestQgsJsonUtils::testDoubleList()
list << 1.0 << -2.2456;
const QString json = QgsJsonUtils::encodeValue( list );
QCOMPARE( json, QString( "[1,-2.2456]" ) );
const QVariantList back = QgsJsonUtils::parseArray( json, QVariant::Double );
const QVariantList back = QgsJsonUtils::parseArray( json, QMetaType::Type::Double );
QCOMPARE( back, list );
QCOMPARE( back.at( 0 ).type(), QVariant::Double );
QCOMPARE( static_cast<QMetaType::Type>( back.at( 0 ).userType() ), QMetaType::Type::Double );
}
void TestQgsJsonUtils::testExportAttributesJson_data()
@ -344,8 +344,8 @@ void TestQgsJsonUtils::testParseNumbers()
QFETCH( QString, number );
QFETCH( int, type );
qDebug() << number << QgsJsonUtils::parseJson( number ) << QgsJsonUtils::parseJson( number ).type() << type;
QCOMPARE( QgsJsonUtils::parseJson( number ).type(), type );
qDebug() << number << QgsJsonUtils::parseJson( number ) << static_cast<QMetaType::Type>( QgsJsonUtils::parseJson( number ).userType() ) << type;
QCOMPARE( static_cast<QMetaType::Type>( QgsJsonUtils::parseJson( number ).userType() ), type );
}
void TestQgsJsonUtils::testParseNumbers_data()
@ -353,13 +353,13 @@ void TestQgsJsonUtils::testParseNumbers_data()
QTest::addColumn<QString>( "number" );
QTest::addColumn<int>( "type" );
QTest::newRow( "zero" ) << "0" << static_cast<int>( QVariant::Type::Int );
QTest::newRow( "int max" ) << QString::number( std::numeric_limits<int>::max() ) << static_cast<int>( QVariant::Type::Int );
QTest::newRow( "int min" ) << QString::number( std::numeric_limits<int>::lowest() ) << static_cast<int>( QVariant::Type::Int );
QTest::newRow( "uint max" ) << QString::number( std::numeric_limits<uint>::max() ) << static_cast<int>( QVariant::Type::LongLong );
QTest::newRow( "ulong max" ) << QString::number( std::numeric_limits<qulonglong>::max() ) << static_cast<int>( QVariant::Type::ULongLong );
QTest::newRow( "longlong max" ) << QString::number( std::numeric_limits<qlonglong>::max() ) << static_cast<int>( QVariant::Type::LongLong );
QTest::newRow( "longlong min" ) << QString::number( std::numeric_limits<qlonglong>::lowest() ) << static_cast<int>( QVariant::Type::LongLong );
QTest::newRow( "zero" ) << "0" << static_cast<int>( QMetaType::Type::Int );
QTest::newRow( "int max" ) << QString::number( std::numeric_limits<int>::max() ) << static_cast<int>( QMetaType::Type::Int );
QTest::newRow( "int min" ) << QString::number( std::numeric_limits<int>::lowest() ) << static_cast<int>( QMetaType::Type::Int );
QTest::newRow( "uint max" ) << QString::number( std::numeric_limits<uint>::max() ) << static_cast<int>( QMetaType::Type::LongLong );
QTest::newRow( "ulong max" ) << QString::number( std::numeric_limits<qulonglong>::max() ) << static_cast<int>( QMetaType::Type::ULongLong );
QTest::newRow( "longlong max" ) << QString::number( std::numeric_limits<qlonglong>::max() ) << static_cast<int>( QMetaType::Type::LongLong );
QTest::newRow( "longlong min" ) << QString::number( std::numeric_limits<qlonglong>::lowest() ) << static_cast<int>( QMetaType::Type::LongLong );
}

2
tests/src/core/testqgslayouttable.cpp
View File

@ -1137,7 +1137,7 @@ void TestQgsLayoutTable::testIntegerNullCell()
QgsFeature f2( layer->dataProvider()->fields(), 2 );
f2.setAttribute( QStringLiteral( "intf" ), 2 );
QgsFeature f3( layer->dataProvider()->fields(), 3 );
f3.setAttribute( QStringLiteral( "intf" ), QVariant( QVariant::Int ) );
f3.setAttribute( QStringLiteral( "intf" ), QgsVariantUtils::createVariant( QMetaType::Type::Int ) );
layer->dataProvider()->addFeatures( QgsFeatureList() << f1 << f2 << f3 );
table->setVectorLayer( layer.get() );

6
tests/src/core/testqgslegendrenderer.cpp
View File

@ -255,7 +255,7 @@ void TestQgsLegendRenderer::init()
{
QgsVectorDataProvider *pr = mVL3->dataProvider();
QList<QgsField> attrs;
attrs << QgsField( QStringLiteral( "test_attr" ), QVariant::Int );
attrs << QgsField( QStringLiteral( "test_attr" ), QMetaType::Type::Int );
pr->addAttributes( attrs );
QgsFields fields;
@ -975,7 +975,7 @@ void TestQgsLegendRenderer::testFilterByMapSameSymbol()
{
QgsVectorDataProvider *pr = vl4->dataProvider();
QList<QgsField> attrs;
attrs << QgsField( QStringLiteral( "test_attr" ), QVariant::Int );
attrs << QgsField( QStringLiteral( "test_attr" ), QMetaType::Type::Int );
pr->addAttributes( attrs );
QgsFields fields;
@ -1491,7 +1491,7 @@ void TestQgsLegendRenderer::testDataDefinedSizeCollapsed()
{
QgsVectorDataProvider *pr = vlDataDefinedSize->dataProvider();
QList<QgsField> attrs;
attrs << QgsField( QStringLiteral( "test_attr" ), QVariant::Int );
attrs << QgsField( QStringLiteral( "test_attr" ), QMetaType::Type::Int );
pr->addAttributes( attrs );
QgsFields fields;

2
tests/src/core/testqgsmaprendererjob.cpp
View File

@ -128,7 +128,7 @@ void TestQgsMapRendererJob::initTestCase()
//create some objects that will be used in all tests...
mEncoding = QStringLiteral( "UTF-8" );
QgsField myField1( QStringLiteral( "Value" ), QVariant::Int, QStringLiteral( "int" ), 10, 0, QStringLiteral( "Value on lon" ) );
QgsField myField1( QStringLiteral( "Value" ), QMetaType::Type::Int, QStringLiteral( "int" ), 10, 0, QStringLiteral( "Value on lon" ) );
mFields.append( myField1 );
mCRS = QgsCoordinateReferenceSystem( geoWkt() );
//

2
tests/src/core/testqgsogcutils.cpp
View File

@ -547,7 +547,7 @@ void TestQgsOgcUtils::testExpressionFromOgcFilterWithLongLong()
QgsVectorLayer layer( "Point?crs=epsg:4326", "temp", "memory" );
const QgsField longlongField( QStringLiteral( "id" ), QVariant::LongLong );
const QgsField longlongField( QStringLiteral( "id" ), QMetaType::Type::LongLong );
QList<QgsField> fields;
fields.append( longlongField );

134
tests/src/core/testqgsogrutils.cpp
View File

@ -303,12 +303,12 @@ void TestQgsOgrUtils::getOgrFeatureAttribute()
oFeat = OGR_L_GetNextFeature( ogrLayer );
QVERIFY( oFeat );
fields.append( QgsField( QStringLiteral( "int_field" ), QVariant::Int ) );
fields.append( QgsField( QStringLiteral( "dbl_field" ), QVariant::Double ) );
fields.append( QgsField( QStringLiteral( "date_field" ), QVariant::Date ) );
fields.append( QgsField( QStringLiteral( "time_field" ), QVariant::Time ) );
fields.append( QgsField( QStringLiteral( "datetime_field" ), QVariant::DateTime ) );
fields.append( QgsField( QStringLiteral( "string_field" ), QVariant::String ) );
fields.append( QgsField( QStringLiteral( "int_field" ), QMetaType::Type::Int ) );
fields.append( QgsField( QStringLiteral( "dbl_field" ), QMetaType::Type::Double ) );
fields.append( QgsField( QStringLiteral( "date_field" ), QMetaType::Type::QDate ) );
fields.append( QgsField( QStringLiteral( "time_field" ), QMetaType::Type::QTime ) );
fields.append( QgsField( QStringLiteral( "datetime_field" ), QMetaType::Type::QDateTime ) );
fields.append( QgsField( QStringLiteral( "string_field" ), QMetaType::Type::QString ) );
// attribute index out of range
val = QgsOgrUtils::getOgrFeatureAttribute( oFeat, fields, -1, QTextCodec::codecForName( "System" ), &ok );
@ -370,12 +370,12 @@ void TestQgsOgrUtils::readOgrFeatureAttributes()
oFeat = OGR_L_GetNextFeature( ogrLayer );
QVERIFY( oFeat );
fields.append( QgsField( QStringLiteral( "int_field" ), QVariant::Int ) );
fields.append( QgsField( QStringLiteral( "dbl_field" ), QVariant::Double ) );
fields.append( QgsField( QStringLiteral( "date_field" ), QVariant::Date ) );
fields.append( QgsField( QStringLiteral( "time_field" ), QVariant::Time ) );
fields.append( QgsField( QStringLiteral( "datetime_field" ), QVariant::DateTime ) );
fields.append( QgsField( QStringLiteral( "string_field" ), QVariant::String ) );
fields.append( QgsField( QStringLiteral( "int_field" ), QMetaType::Type::Int ) );
fields.append( QgsField( QStringLiteral( "dbl_field" ), QMetaType::Type::Double ) );
fields.append( QgsField( QStringLiteral( "date_field" ), QMetaType::Type::QDate ) );
fields.append( QgsField( QStringLiteral( "time_field" ), QMetaType::Type::QTime ) );
fields.append( QgsField( QStringLiteral( "datetime_field" ), QMetaType::Type::QDateTime ) );
fields.append( QgsField( QStringLiteral( "string_field" ), QMetaType::Type::QString ) );
QVERIFY( QgsOgrUtils::readOgrFeatureAttributes( oFeat, fields, f, QTextCodec::codecForName( "System" ) ) );
QCOMPARE( f.attribute( "int_field" ), QVariant( 5 ) );
@ -407,12 +407,12 @@ void TestQgsOgrUtils::readOgrFeature()
oFeat = OGR_L_GetNextFeature( ogrLayer );
QVERIFY( oFeat );
fields.append( QgsField( QStringLiteral( "int_field" ), QVariant::Int ) );
fields.append( QgsField( QStringLiteral( "dbl_field" ), QVariant::Double ) );
fields.append( QgsField( QStringLiteral( "date_field" ), QVariant::Date ) );
fields.append( QgsField( QStringLiteral( "time_field" ), QVariant::Time ) );
fields.append( QgsField( QStringLiteral( "datetime_field" ), QVariant::DateTime ) );
fields.append( QgsField( QStringLiteral( "string_field" ), QVariant::String ) );
fields.append( QgsField( QStringLiteral( "int_field" ), QMetaType::Type::Int ) );
fields.append( QgsField( QStringLiteral( "dbl_field" ), QMetaType::Type::Double ) );
fields.append( QgsField( QStringLiteral( "date_field" ), QMetaType::Type::QDate ) );
fields.append( QgsField( QStringLiteral( "time_field" ), QMetaType::Type::QTime ) );
fields.append( QgsField( QStringLiteral( "datetime_field" ), QMetaType::Type::QDateTime ) );
fields.append( QgsField( QStringLiteral( "string_field" ), QMetaType::Type::QString ) );
f = QgsOgrUtils::readOgrFeature( oFeat, fields, QTextCodec::codecForName( "System" ) );
QVERIFY( f.isValid() );
@ -450,17 +450,17 @@ void TestQgsOgrUtils::readOgrFields()
f = QgsOgrUtils::readOgrFields( oFeat, QTextCodec::codecForName( "System" ) );
QCOMPARE( f.count(), 6 );
QCOMPARE( f.at( 0 ).name(), QString( "int_field" ) );
QCOMPARE( f.at( 0 ).type(), QVariant::Int );
QCOMPARE( f.at( 0 ).type(), QMetaType::Type::Int );
QCOMPARE( f.at( 1 ).name(), QString( "dbl_field" ) );
QCOMPARE( f.at( 1 ).type(), QVariant::Double );
QCOMPARE( f.at( 1 ).type(), QMetaType::Type::Double );
QCOMPARE( f.at( 2 ).name(), QString( "date_field" ) );
QCOMPARE( f.at( 2 ).type(), QVariant::Date );
QCOMPARE( f.at( 2 ).type(), QMetaType::Type::QDate );
QCOMPARE( f.at( 3 ).name(), QString( "time_field" ) );
QCOMPARE( f.at( 3 ).type(), QVariant::Time );
QCOMPARE( f.at( 3 ).type(), QMetaType::Type::QTime );
QCOMPARE( f.at( 4 ).name(), QString( "datetime_field" ) );
QCOMPARE( f.at( 4 ).type(), QVariant::DateTime );
QCOMPARE( f.at( 4 ).type(), QMetaType::Type::QDateTime );
QCOMPARE( f.at( 5 ).name(), QString( "string_field" ) );
QCOMPARE( f.at( 5 ).type(), QVariant::String );
QCOMPARE( f.at( 5 ).type(), QMetaType::Type::QString );
OGR_F_Destroy( oFeat );
OGR_DS_Destroy( hDS );
@ -469,7 +469,7 @@ void TestQgsOgrUtils::readOgrFields()
void TestQgsOgrUtils::stringToFeatureList()
{
QgsFields fields;
fields.append( QgsField( QStringLiteral( "name" ), QVariant::String ) );
fields.append( QgsField( QStringLiteral( "name" ), QMetaType::Type::QString ) );
//empty string
QgsFeatureList features = QgsOgrUtils::stringToFeatureList( QString(), fields, QTextCodec::codecForName( "System" ) );
@ -522,17 +522,17 @@ void TestQgsOgrUtils::stringToFields()
fields = QgsOgrUtils::stringToFields( QStringLiteral( "{\n\"type\": \"Feature\",\"geometry\": {\"type\": \"Point\",\"coordinates\": [125, 10]},\"properties\": {\"name\": \"Dinagat Islands\",\"height\":5.5}}" ), QTextCodec::codecForName( "System" ) );
QCOMPARE( fields.count(), 2 );
QCOMPARE( fields.at( 0 ).name(), QString( "name" ) );
QCOMPARE( fields.at( 0 ).type(), QVariant::String );
QCOMPARE( fields.at( 0 ).type(), QMetaType::Type::QString );
QCOMPARE( fields.at( 1 ).name(), QString( "height" ) );
QCOMPARE( fields.at( 1 ).type(), QVariant::Double );
QCOMPARE( fields.at( 1 ).type(), QMetaType::Type::Double );
// geojson string with 2 features
fields = QgsOgrUtils::stringToFields( QStringLiteral( "{ \"type\": \"FeatureCollection\",\"features\":[{\n\"type\": \"Feature\",\"geometry\": {\"type\": \"Point\",\"coordinates\": [125, 10]},\"properties\": {\"name\": \"Dinagat Islands\",\"height\":5.5}}, {\n\"type\": \"Feature\",\"geometry\": {\"type\": \"Point\",\"coordinates\": [110, 20]},\"properties\": {\"name\": \"Henry Gale Island\",\"height\":6.5}}]}" ), QTextCodec::codecForName( "System" ) );
QCOMPARE( fields.count(), 2 );
QCOMPARE( fields.at( 0 ).name(), QString( "name" ) );
QCOMPARE( fields.at( 0 ).type(), QVariant::String );
QCOMPARE( fields.at( 0 ).type(), QMetaType::Type::QString );
QCOMPARE( fields.at( 1 ).name(), QString( "height" ) );
QCOMPARE( fields.at( 1 ).type(), QVariant::Double );
QCOMPARE( fields.at( 1 ).type(), QMetaType::Type::Double );
}
void TestQgsOgrUtils::textCodec()
@ -928,29 +928,29 @@ void TestQgsOgrUtils::testOgrFieldTypeToQVariantType_data()
QTest::addColumn<int>( "expectedType" );
QTest::addColumn<int>( "expectedSubType" );
QTest::newRow( "OFTInteger" ) << static_cast< int >( OFTInteger ) << static_cast< int >( OFSTNone ) << static_cast< int >( QVariant::Int ) << static_cast< int >( QVariant::Invalid );
QTest::newRow( "OFTIntegerList" ) << static_cast< int >( OFTIntegerList ) << static_cast< int >( OFSTNone ) << static_cast< int >( QVariant::List ) << static_cast< int >( QVariant::Int );
QTest::newRow( "OFTInteger" ) << static_cast< int >( OFTInteger ) << static_cast< int >( OFSTNone ) << static_cast< int >( QMetaType::Type::Int ) << static_cast< int >( QMetaType::Type::UnknownType );
QTest::newRow( "OFTIntegerList" ) << static_cast< int >( OFTIntegerList ) << static_cast< int >( OFSTNone ) << static_cast< int >( QMetaType::Type::QVariantList ) << static_cast< int >( QMetaType::Type::Int );
QTest::newRow( "OFSTBoolean" ) << static_cast< int >( OFTInteger ) << static_cast< int >( OFSTBoolean ) << static_cast< int >( QVariant::Bool ) << static_cast< int >( QVariant::Invalid );
QTest::newRow( "OFSTBoolean" ) << static_cast< int >( OFTInteger ) << static_cast< int >( OFSTBoolean ) << static_cast< int >( QMetaType::Type::Bool ) << static_cast< int >( QMetaType::Type::UnknownType );
QTest::newRow( "OFTReal" ) << static_cast< int >( OFTReal ) << static_cast< int >( OFSTNone ) << static_cast< int >( QVariant::Double ) << static_cast< int >( QVariant::Invalid );
QTest::newRow( "OFTRealList" ) << static_cast< int >( OFTRealList ) << static_cast< int >( OFSTNone ) << static_cast< int >( QVariant::List ) << static_cast< int >( QVariant::Double );
QTest::newRow( "OFTReal" ) << static_cast< int >( OFTReal ) << static_cast< int >( OFSTNone ) << static_cast< int >( QMetaType::Type::Double ) << static_cast< int >( QMetaType::Type::UnknownType );
QTest::newRow( "OFTRealList" ) << static_cast< int >( OFTRealList ) << static_cast< int >( OFSTNone ) << static_cast< int >( QMetaType::Type::QVariantList ) << static_cast< int >( QMetaType::Type::Double );
QTest::newRow( "OFTString" ) << static_cast< int >( OFTString ) << static_cast< int >( OFSTNone ) << static_cast< int >( QVariant::String ) << static_cast< int >( QVariant::Invalid );
QTest::newRow( "OFTStringList" ) << static_cast< int >( OFTStringList ) << static_cast< int >( OFSTNone ) << static_cast< int >( QVariant::StringList ) << static_cast< int >( QVariant::String );
QTest::newRow( "OFTWideString" ) << static_cast< int >( OFTWideString ) << static_cast< int >( OFSTNone ) << static_cast< int >( QVariant::String ) << static_cast< int >( QVariant::Invalid );
QTest::newRow( "OFTWideStringList" ) << static_cast< int >( OFTWideStringList ) << static_cast< int >( OFSTNone ) << static_cast< int >( QVariant::StringList ) << static_cast< int >( QVariant::String );
QTest::newRow( "OFTString" ) << static_cast< int >( OFTString ) << static_cast< int >( OFSTNone ) << static_cast< int >( QMetaType::Type::QString ) << static_cast< int >( QMetaType::Type::UnknownType );
QTest::newRow( "OFTStringList" ) << static_cast< int >( OFTStringList ) << static_cast< int >( OFSTNone ) << static_cast< int >( QMetaType::Type::QStringList ) << static_cast< int >( QMetaType::Type::QString );
QTest::newRow( "OFTWideString" ) << static_cast< int >( OFTWideString ) << static_cast< int >( OFSTNone ) << static_cast< int >( QMetaType::Type::QString ) << static_cast< int >( QMetaType::Type::UnknownType );
QTest::newRow( "OFTWideStringList" ) << static_cast< int >( OFTWideStringList ) << static_cast< int >( OFSTNone ) << static_cast< int >( QMetaType::Type::QStringList ) << static_cast< int >( QMetaType::Type::QString );
QTest::newRow( "OFTString OFSTJSON" ) << static_cast< int >( OFTString ) << static_cast< int >( OFSTJSON ) << static_cast< int >( QVariant::Map ) << static_cast< int >( QVariant::String );
QTest::newRow( "OFTWideString OFSTJSON" ) << static_cast< int >( OFTWideString ) << static_cast< int >( OFSTJSON ) << static_cast< int >( QVariant::Map ) << static_cast< int >( QVariant::String );
QTest::newRow( "OFTString OFSTJSON" ) << static_cast< int >( OFTString ) << static_cast< int >( OFSTJSON ) << static_cast< int >( QMetaType::Type::QVariantMap ) << static_cast< int >( QMetaType::Type::QString );
QTest::newRow( "OFTWideString OFSTJSON" ) << static_cast< int >( OFTWideString ) << static_cast< int >( OFSTJSON ) << static_cast< int >( QMetaType::Type::QVariantMap ) << static_cast< int >( QMetaType::Type::QString );
QTest::newRow( "OFTInteger64" ) << static_cast< int >( OFTInteger64 ) << static_cast< int >( OFSTNone ) << static_cast< int >( QVariant::LongLong ) << static_cast< int >( QVariant::Invalid );
QTest::newRow( "OFTInteger64List" ) << static_cast< int >( OFTInteger64List ) << static_cast< int >( OFSTNone ) << static_cast< int >( QVariant::List ) << static_cast< int >( QVariant::LongLong );
QTest::newRow( "OFTInteger64" ) << static_cast< int >( OFTInteger64 ) << static_cast< int >( OFSTNone ) << static_cast< int >( QMetaType::Type::LongLong ) << static_cast< int >( QMetaType::Type::UnknownType );
QTest::newRow( "OFTInteger64List" ) << static_cast< int >( OFTInteger64List ) << static_cast< int >( OFSTNone ) << static_cast< int >( QMetaType::Type::QVariantList ) << static_cast< int >( QMetaType::Type::LongLong );
QTest::newRow( "OFTBinary" ) << static_cast< int >( OFTBinary ) << static_cast< int >( OFSTNone ) << static_cast< int >( QVariant::ByteArray ) << static_cast< int >( QVariant::Invalid );
QTest::newRow( "OFTDate" ) << static_cast< int >( OFTDate ) << static_cast< int >( OFSTNone ) << static_cast< int >( QVariant::Date ) << static_cast< int >( QVariant::Invalid );
QTest::newRow( "OFTTime" ) << static_cast< int >( OFTTime ) << static_cast< int >( OFSTNone ) << static_cast< int >( QVariant::Time ) << static_cast< int >( QVariant::Invalid );
QTest::newRow( "OFTDateTime" ) << static_cast< int >( OFTDateTime ) << static_cast< int >( OFSTNone ) << static_cast< int >( QVariant::DateTime ) << static_cast< int >( QVariant::Invalid );
QTest::newRow( "OFTBinary" ) << static_cast< int >( OFTBinary ) << static_cast< int >( OFSTNone ) << static_cast< int >( QMetaType::Type::QByteArray ) << static_cast< int >( QMetaType::Type::UnknownType );
QTest::newRow( "OFTDate" ) << static_cast< int >( OFTDate ) << static_cast< int >( OFSTNone ) << static_cast< int >( QMetaType::Type::QDate ) << static_cast< int >( QMetaType::Type::UnknownType );
QTest::newRow( "OFTTime" ) << static_cast< int >( OFTTime ) << static_cast< int >( OFSTNone ) << static_cast< int >( QMetaType::Type::QTime ) << static_cast< int >( QMetaType::Type::UnknownType );
QTest::newRow( "OFTDateTime" ) << static_cast< int >( OFTDateTime ) << static_cast< int >( OFSTNone ) << static_cast< int >( QMetaType::Type::QDateTime ) << static_cast< int >( QMetaType::Type::UnknownType );
}
void TestQgsOgrUtils::testOgrFieldTypeToQVariantType()
@ -960,8 +960,8 @@ void TestQgsOgrUtils::testOgrFieldTypeToQVariantType()
QFETCH( int, expectedType );
QFETCH( int, expectedSubType );
QVariant::Type variantType;
QVariant::Type variantSubType;
QMetaType::Type variantType;
QMetaType::Type variantSubType;
QgsOgrUtils::ogrFieldTypeToQVariantType( static_cast<OGRFieldType>( ogrType ),
static_cast<OGRFieldSubType>( ogrSubType ),
variantType, variantSubType );
@ -975,17 +975,17 @@ void TestQgsOgrUtils::testVariantTypeToOgrFieldType_data()
QTest::addColumn<int>( "expectedType" );
QTest::addColumn<int>( "expectedSubType" );
QTest::newRow( "Bool" ) << static_cast< int >( QVariant::Type::Bool ) << static_cast< int >( OFTInteger ) << static_cast< int >( OFSTBoolean );
QTest::newRow( "Int" ) << static_cast< int >( QVariant::Type::Int ) << static_cast< int >( OFTInteger ) << static_cast< int >( OFSTNone );
QTest::newRow( "LongLong" ) << static_cast< int >( QVariant::Type::LongLong ) << static_cast< int >( OFTInteger64 ) << static_cast< int >( OFSTNone );
QTest::newRow( "Double" ) << static_cast< int >( QVariant::Type::Double ) << static_cast< int >( OFTReal ) << static_cast< int >( OFSTNone );
QTest::newRow( "Char" ) << static_cast< int >( QVariant::Type::Char ) << static_cast< int >( OFTString ) << static_cast< int >( OFSTNone );
QTest::newRow( "String" ) << static_cast< int >( QVariant::Type::String ) << static_cast< int >( OFTString ) << static_cast< int >( OFSTNone );
QTest::newRow( "StringList" ) << static_cast< int >( QVariant::Type::StringList ) << static_cast< int >( OFTStringList ) << static_cast< int >( OFSTNone );
QTest::newRow( "ByteArray" ) << static_cast< int >( QVariant::Type::ByteArray ) << static_cast< int >( OFTBinary ) << static_cast< int >( OFSTNone );
QTest::newRow( "Date" ) << static_cast< int >( QVariant::Type::Date ) << static_cast< int >( OFTDate ) << static_cast< int >( OFSTNone );
QTest::newRow( "Time" ) << static_cast< int >( QVariant::Type::Time ) << static_cast< int >( OFTTime ) << static_cast< int >( OFSTNone );
QTest::newRow( "DateTime" ) << static_cast< int >( QVariant::Type::DateTime ) << static_cast< int >( OFTDateTime ) << static_cast< int >( OFSTNone );
QTest::newRow( "Bool" ) << static_cast< int >( QMetaType::Type::Bool ) << static_cast< int >( OFTInteger ) << static_cast< int >( OFSTBoolean );
QTest::newRow( "Int" ) << static_cast< int >( QMetaType::Type::Int ) << static_cast< int >( OFTInteger ) << static_cast< int >( OFSTNone );
QTest::newRow( "LongLong" ) << static_cast< int >( QMetaType::Type::LongLong ) << static_cast< int >( OFTInteger64 ) << static_cast< int >( OFSTNone );
QTest::newRow( "Double" ) << static_cast< int >( QMetaType::Type::Double ) << static_cast< int >( OFTReal ) << static_cast< int >( OFSTNone );
QTest::newRow( "Char" ) << static_cast< int >( QMetaType::Type::QChar ) << static_cast< int >( OFTString ) << static_cast< int >( OFSTNone );
QTest::newRow( "String" ) << static_cast< int >( QMetaType::Type::QString ) << static_cast< int >( OFTString ) << static_cast< int >( OFSTNone );
QTest::newRow( "StringList" ) << static_cast< int >( QMetaType::Type::QStringList ) << static_cast< int >( OFTStringList ) << static_cast< int >( OFSTNone );
QTest::newRow( "ByteArray" ) << static_cast< int >( QMetaType::Type::QByteArray ) << static_cast< int >( OFTBinary ) << static_cast< int >( OFSTNone );
QTest::newRow( "Date" ) << static_cast< int >( QMetaType::Type::QDate ) << static_cast< int >( OFTDate ) << static_cast< int >( OFSTNone );
QTest::newRow( "Time" ) << static_cast< int >( QMetaType::Type::QTime ) << static_cast< int >( OFTTime ) << static_cast< int >( OFSTNone );
QTest::newRow( "DateTime" ) << static_cast< int >( QMetaType::Type::QDateTime ) << static_cast< int >( OFTDateTime ) << static_cast< int >( OFSTNone );
}
void TestQgsOgrUtils::testVariantTypeToOgrFieldType()
@ -996,7 +996,7 @@ void TestQgsOgrUtils::testVariantTypeToOgrFieldType()
OGRFieldType type;
OGRFieldSubType subType;
QgsOgrUtils::variantTypeToOgrFieldType( static_cast<QVariant::Type>( variantType ),
QgsOgrUtils::variantTypeToOgrFieldType( static_cast<QMetaType::Type>( variantType ),
type, subType );
QCOMPARE( static_cast< int >( type ), expectedType );
QCOMPARE( static_cast< int >( subType ), expectedSubType );
@ -1133,7 +1133,7 @@ void TestQgsOgrUtils::testConvertFieldDomain()
QVERIFY( codedFieldDomain );
QCOMPARE( codedFieldDomain->name(), QStringLiteral( "name" ) );
QCOMPARE( codedFieldDomain->description(), QStringLiteral( "desc" ) );
QCOMPARE( codedFieldDomain->fieldType(), QVariant::Int );
QCOMPARE( codedFieldDomain->fieldType(), QMetaType::Type::Int );
QCOMPARE( codedFieldDomain->values().size(), 2 );
QCOMPARE( codedFieldDomain->values().at( 0 ).code(), QVariant( 1 ) );
QCOMPARE( codedFieldDomain->values().at( 0 ).value(), QStringLiteral( "val1" ) );
@ -1173,7 +1173,7 @@ void TestQgsOgrUtils::testConvertFieldDomain()
QVERIFY( rangeDomain );
QCOMPARE( rangeDomain->name(), QStringLiteral( "name" ) );
QCOMPARE( rangeDomain->description(), QStringLiteral( "desc" ) );
QCOMPARE( rangeDomain->fieldType(), QVariant::Int );
QCOMPARE( rangeDomain->fieldType(), QMetaType::Type::Int );
QCOMPARE( rangeDomain->minimum(), QVariant( 5 ) );
QCOMPARE( rangeDomain->maximum(), QVariant( 15 ) );
QVERIFY( rangeDomain->minimumIsInclusive() );
@ -1192,14 +1192,14 @@ void TestQgsOgrUtils::testConvertFieldDomain()
QVERIFY( globDomain );
QCOMPARE( globDomain->name(), QStringLiteral( "name" ) );
QCOMPARE( globDomain->description(), QStringLiteral( "desc" ) );
QCOMPARE( globDomain->fieldType(), QVariant::String );
QCOMPARE( globDomain->fieldType(), QMetaType::Type::QString );
OGR_FldDomain_Destroy( domain );
}
void TestQgsOgrUtils::testConvertToFieldDomain()
{
// test converting QgsFieldDomain to OGR field domain
QgsGlobFieldDomain globDomain( QStringLiteral( "name" ), QStringLiteral( "desc" ), QVariant::String, QStringLiteral( "*a*" ) );
QgsGlobFieldDomain globDomain( QStringLiteral( "name" ), QStringLiteral( "desc" ), QMetaType::Type::QString, QStringLiteral( "*a*" ) );
OGRFieldDomainH domain = QgsOgrUtils::convertFieldDomain( &globDomain );
std::unique_ptr< QgsFieldDomain > res = QgsOgrUtils::convertFieldDomain( domain );
@ -1228,7 +1228,7 @@ void TestQgsOgrUtils::testConvertToFieldDomain()
// range
QgsRangeFieldDomain rangeDomain( QStringLiteral( "name" ), QStringLiteral( "desc" ), QVariant::Int,
QgsRangeFieldDomain rangeDomain( QStringLiteral( "name" ), QStringLiteral( "desc" ), QMetaType::Type::Int,
1, true, 5, false );
domain = QgsOgrUtils::convertFieldDomain( &rangeDomain );
res = QgsOgrUtils::convertFieldDomain( domain );
@ -1240,7 +1240,7 @@ void TestQgsOgrUtils::testConvertToFieldDomain()
QCOMPARE( dynamic_cast< QgsRangeFieldDomain * >( res.get() )->maximum(), QVariant( 5 ) );
QVERIFY( !dynamic_cast< QgsRangeFieldDomain * >( res.get() )->maximumIsInclusive() );
rangeDomain.setFieldType( QVariant::Double );
rangeDomain.setFieldType( QMetaType::Type::Double );
rangeDomain.setMinimum( 5.5 );
rangeDomain.setMaximum( 12.1 );
rangeDomain.setMinimumIsInclusive( false );
@ -1254,7 +1254,7 @@ void TestQgsOgrUtils::testConvertToFieldDomain()
QVERIFY( dynamic_cast< QgsRangeFieldDomain * >( res.get() )->maximumIsInclusive() );
// coded
QgsCodedFieldDomain codedDomain( QStringLiteral( "name" ), QStringLiteral( "desc" ), QVariant::String,
QgsCodedFieldDomain codedDomain( QStringLiteral( "name" ), QStringLiteral( "desc" ), QMetaType::Type::QString,
{
QgsCodedValue( "aa", "aaaa" ),
QgsCodedValue( "bb", "bbbb" ),

18
tests/src/core/testqgspointcloudattribute.cpp
View File

@ -98,12 +98,12 @@ void TestQgsPointCloudAttribute::testAttributeDisplayType()
void TestQgsPointCloudAttribute::testVariantType()
{
QCOMPARE( QgsPointCloudAttribute( QStringLiteral( "x" ), QgsPointCloudAttribute::DataType::Char ).variantType(), QVariant::Int );
QCOMPARE( QgsPointCloudAttribute( QStringLiteral( "x" ), QgsPointCloudAttribute::DataType::Short ).variantType(), QVariant::Int );
QCOMPARE( QgsPointCloudAttribute( QStringLiteral( "x" ), QgsPointCloudAttribute::DataType::UShort ).variantType(), QVariant::Int );
QCOMPARE( QgsPointCloudAttribute( QStringLiteral( "x" ), QgsPointCloudAttribute::DataType::Int32 ).variantType(), QVariant::Int );
QCOMPARE( QgsPointCloudAttribute( QStringLiteral( "x" ), QgsPointCloudAttribute::DataType::Float ).variantType(), QVariant::Double );
QCOMPARE( QgsPointCloudAttribute( QStringLiteral( "x" ), QgsPointCloudAttribute::DataType::Double ).variantType(), QVariant::Double );
QCOMPARE( QgsPointCloudAttribute( QStringLiteral( "x" ), QgsPointCloudAttribute::DataType::Char ).variantType(), QMetaType::Type::Int );
QCOMPARE( QgsPointCloudAttribute( QStringLiteral( "x" ), QgsPointCloudAttribute::DataType::Short ).variantType(), QMetaType::Type::Int );
QCOMPARE( QgsPointCloudAttribute( QStringLiteral( "x" ), QgsPointCloudAttribute::DataType::UShort ).variantType(), QMetaType::Type::Int );
QCOMPARE( QgsPointCloudAttribute( QStringLiteral( "x" ), QgsPointCloudAttribute::DataType::Int32 ).variantType(), QMetaType::Type::Int );
QCOMPARE( QgsPointCloudAttribute( QStringLiteral( "x" ), QgsPointCloudAttribute::DataType::Float ).variantType(), QMetaType::Type::Double );
QCOMPARE( QgsPointCloudAttribute( QStringLiteral( "x" ), QgsPointCloudAttribute::DataType::Double ).variantType(), QMetaType::Type::Double );
}
void TestQgsPointCloudAttribute::testIsNumeric()
@ -281,11 +281,11 @@ void TestQgsPointCloudAttribute::testToFields()
QCOMPARE( fields.size(), 3 );
QCOMPARE( fields.at( 0 ).name(), QStringLiteral( "at1" ) );
QCOMPARE( fields.at( 0 ).type(), QVariant::Double );
QCOMPARE( fields.at( 0 ).type(), QMetaType::Type::Double );
QCOMPARE( fields.at( 1 ).name(), QStringLiteral( "at2" ) );
QCOMPARE( fields.at( 1 ).type(), QVariant::Int );
QCOMPARE( fields.at( 1 ).type(), QMetaType::Type::Int );
QCOMPARE( fields.at( 2 ).name(), QStringLiteral( "at3" ) );
QCOMPARE( fields.at( 2 ).type(), QVariant::Double );
QCOMPARE( fields.at( 2 ).type(), QMetaType::Type::Double );
}
QGSTEST_MAIN( TestQgsPointCloudAttribute )

2
tests/src/core/testqgsprojectstorage.cpp
View File

@ -174,7 +174,7 @@ void TestQgsProjectStorage::testMemoryStorage()
const int fldCnt0 = layer1->fields().count();
QgsAuxiliaryLayer *layerAux = prj1.auxiliaryStorage()->createAuxiliaryLayer( layer1->fields().at( 0 ), layer1 );
layer1->setAuxiliaryLayer( layerAux );
layerAux->addAttribute( QgsField( "fld_aux", QVariant::Int ) );
layerAux->addAttribute( QgsField( "fld_aux", QMetaType::Type::Int ) );
layerAux->commitChanges();
QCOMPARE( fldCnt0, 6 );
QCOMPARE( layer1->fields().count(), 7 );

48
tests/src/core/testqgsproperty.cpp
View File

@ -163,7 +163,7 @@ void TestQgsProperty::conversions()
collection.property( 0 ).setStaticValue( "i am not a color" ); //badly encoded color, should return default color
QCOMPARE( c1.valueAsColor( context, QColor( 200, 210, 220 ) ), QColor( 200, 210, 220 ) );
QCOMPARE( collection.valueAsColor( 0, context, QColor( 200, 210, 220 ) ), QColor( 200, 210, 220 ) );
collection.property( 0 ).setStaticValue( QVariant( QVariant::String ) ); //null value
collection.property( 0 ).setStaticValue( QgsVariantUtils::createVariant( QMetaType::Type::QString ) ); //null value
QCOMPARE( c1.valueAsColor( context, QColor( 200, 210, 220 ), &ok ), QColor( 200, 210, 220 ) );
QVERIFY( !ok );
QCOMPARE( collection.valueAsColor( 0, context, QColor( 200, 210, 220 ), &ok ), QColor( 200, 210, 220 ) );
@ -188,8 +188,8 @@ void TestQgsProperty::conversions()
collection.property( 1 ).setStaticValue( "i am not a double" ); //not a double, should return default value
QCOMPARE( d1.valueAsDouble( context, -1.2 ), -1.2 );
QCOMPARE( collection.valueAsDouble( 1, context, -1.2 ), -1.2 );
d1.setStaticValue( QVariant( QVariant::Double ) ); //null value
collection.property( 1 ).setStaticValue( QVariant( QVariant::Double ) ); //null value
d1.setStaticValue( QgsVariantUtils::createVariant( QMetaType::Type::Double ) ); //null value
collection.property( 1 ).setStaticValue( QgsVariantUtils::createVariant( QMetaType::Type::Double ) ); //null value
QCOMPARE( d1.valueAsDouble( context, -1.2, &ok ), -1.2 );
QVERIFY( !ok );
QCOMPARE( collection.valueAsDouble( 1, context, -1.2, &ok ), -1.2 );
@ -223,8 +223,8 @@ void TestQgsProperty::conversions()
collection.property( 2 ).setStaticValue( "i am not a int" ); //not a int, should return default value
QCOMPARE( i1.valueAsInt( context, -11 ), -11 );
QCOMPARE( collection.valueAsInt( 2, context, -11 ), -11 );
i1.setStaticValue( QVariant( QVariant::Int ) ); // null value
collection.property( 2 ).setStaticValue( QVariant( QVariant::Int ) ); // null value
i1.setStaticValue( QgsVariantUtils::createVariant( QMetaType::Type::Int ) ); // null value
collection.property( 2 ).setStaticValue( QgsVariantUtils::createVariant( QMetaType::Type::Int ) ); // null value
QCOMPARE( i1.valueAsInt( context, -11, &ok ), -11 );
QVERIFY( !ok );
QCOMPARE( collection.valueAsInt( 2, context, -11, &ok ), -11 );
@ -277,8 +277,8 @@ void TestQgsProperty::conversions()
QCOMPARE( b1.valueAsBool( context, true ), false );
QCOMPARE( collection.valueAsBool( 3, context, false ), false );
QCOMPARE( collection.valueAsBool( 3, context, true ), false );
b1.setStaticValue( QVariant( QVariant::Bool ) ); // null value
collection.property( 3 ).setStaticValue( QVariant( QVariant::Bool ) );
b1.setStaticValue( QgsVariantUtils::createVariant( QMetaType::Type::Bool ) ); // null value
collection.property( 3 ).setStaticValue( QgsVariantUtils::createVariant( QMetaType::Type::Bool ) );
QCOMPARE( b1.valueAsBool( context, false ), false );
QCOMPARE( b1.valueAsBool( context, true ), true );
QCOMPARE( collection.valueAsBool( 3, context, false, &ok ), false );
@ -299,8 +299,8 @@ void TestQgsProperty::conversions()
QVERIFY( ok );
QCOMPARE( collection.valueAsString( 4, context, "y", &ok ), QStringLiteral( "s" ) );
QVERIFY( ok );
s1.setStaticValue( QVariant( QVariant::String ) );
collection.property( 4 ).setStaticValue( QVariant( QVariant::String ) );
s1.setStaticValue( QgsVariantUtils::createVariant( QMetaType::Type::QString ) );
collection.property( 4 ).setStaticValue( QgsVariantUtils::createVariant( QMetaType::Type::QString ) );
QCOMPARE( s1.valueAsString( context, "n", &ok ), QStringLiteral( "n" ) );
QVERIFY( !ok );
QCOMPARE( collection.valueAsString( 4, context, "y", &ok ), QStringLiteral( "y" ) );
@ -329,8 +329,8 @@ void TestQgsProperty::conversions()
collection.property( 5 ).setStaticValue( "i am not a datetime" ); //not a double, should return default value
QCOMPARE( d1.valueAsDateTime( context, dt ), dt );
QCOMPARE( collection.valueAsDateTime( 5, context, dt ), dt );
d1.setStaticValue( QVariant( QVariant::DateTime ) ); // null value
collection.property( 5 ).setStaticValue( QVariant( QVariant::DateTime ) ); // null value
d1.setStaticValue( QgsVariantUtils::createVariant( QMetaType::Type::QDateTime ) ); // null value
collection.property( 5 ).setStaticValue( QgsVariantUtils::createVariant( QMetaType::Type::QDateTime ) ); // null value
QCOMPARE( d1.valueAsDateTime( context, dt, &ok ), dt );
QVERIFY( !ok );
QCOMPARE( collection.valueAsDateTime( 5, context, dt, &ok ), dt );
@ -439,8 +439,8 @@ void TestQgsProperty::fieldBasedProperty()
//make a feature
QgsFeature ft;
QgsFields fields;
fields.append( QgsField( QStringLiteral( "field1" ), QVariant::Int ) );
fields.append( QgsField( QStringLiteral( "field2" ), QVariant::Int ) );
fields.append( QgsField( QStringLiteral( "field1" ), QMetaType::Type::Int ) );
fields.append( QgsField( QStringLiteral( "field2" ), QMetaType::Type::Int ) );
ft.setFields( fields );
QgsAttributes attr;
attr << QVariant( 5 ) << QVariant( 7 );
@ -538,8 +538,8 @@ void TestQgsProperty::expressionBasedProperty()
//make a feature
QgsFeature ft;
QgsFields fields;
fields.append( QgsField( QStringLiteral( "field1" ), QVariant::Int ) );
fields.append( QgsField( QStringLiteral( "field2" ), QVariant::Int ) );
fields.append( QgsField( QStringLiteral( "field1" ), QMetaType::Type::Int ) );
fields.append( QgsField( QStringLiteral( "field2" ), QMetaType::Type::Int ) );
ft.setFields( fields );
QgsAttributes attr;
attr << QVariant( 5 ) << QVariant( 7 );
@ -719,7 +719,7 @@ void TestQgsProperty::isStaticValueInContext()
// should still be non-static, even with valid fields
QgsFields fields;
fields.append( QgsField( QStringLiteral( "xxx" ), QVariant::Int ) );
fields.append( QgsField( QStringLiteral( "xxx" ), QMetaType::Type::Int ) );
context.setFields( fields );
v = 5;
QVERIFY( !p.isStaticValueInContext( context, v ) );
@ -769,7 +769,7 @@ void TestQgsProperty::propertyTransformer()
QVERIFY( dynamic_cast< const TestTransformer * >( p1.transformer() ) );
QCOMPARE( static_cast< const TestTransformer * >( p1.transformer() )->minValue(), 10.0 );
QCOMPARE( static_cast< const TestTransformer * >( p1.transformer() )->maxValue(), 20.0 );
p1.setStaticValue( QVariant( QVariant::Double ) );
p1.setStaticValue( QgsVariantUtils::createVariant( QMetaType::Type::Double ) );
QCOMPARE( p1.value( context, -99 ).toDouble(), -1.0 );
p1.setStaticValue( 11.0 );
QCOMPARE( p1.value( context, -99 ).toDouble(), 22.0 );
@ -843,7 +843,7 @@ void TestQgsProperty::genericNumericTransformer()
QCOMPARE( t1.transform( context, 10 ).toInt(), 100 );
QCOMPARE( t1.transform( context, 20 ).toInt(), 200 );
//null value
QCOMPARE( t1.transform( context, QVariant( QVariant::Double ) ).toInt(), -10 );
QCOMPARE( t1.transform( context, QgsVariantUtils::createVariant( QMetaType::Type::Double ) ).toInt(), -10 );
//non numeric value
QCOMPARE( t1.transform( context, QVariant( "ffff" ) ), QVariant( "ffff" ) );
@ -1044,7 +1044,7 @@ void TestQgsProperty::sizeScaleTransformer()
QCOMPARE( scale.transform( context, 10 ).toInt(), 100 );
QCOMPARE( scale.transform( context, 20 ).toInt(), 200 );
//null value
QCOMPARE( scale.transform( context, QVariant( QVariant::Double ) ).toInt(), -10 );
QCOMPARE( scale.transform( context, QgsVariantUtils::createVariant( QMetaType::Type::Double ) ).toInt(), -10 );
//non numeric value
QCOMPARE( scale.transform( context, QVariant( "ffff" ) ), QVariant( "ffff" ) );
@ -1273,7 +1273,7 @@ void TestQgsProperty::colorRampTransformer()
QCOMPARE( scale.transform( context, 10 ).value<QColor>(), QColor( 0, 0, 0 ) );
QCOMPARE( scale.transform( context, 20 ).value<QColor>(), QColor( 255, 255, 255 ) );
//null value
QCOMPARE( scale.transform( context, QVariant( QVariant::Double ) ).value<QColor>(), QColor( 100, 150, 200 ) );
QCOMPARE( scale.transform( context, QgsVariantUtils::createVariant( QMetaType::Type::Double ) ).value<QColor>(), QColor( 100, 150, 200 ) );
//non numeric value
QCOMPARE( scale.transform( context, QVariant( "ffff" ) ), QVariant( "ffff" ) );
@ -1460,8 +1460,8 @@ void TestQgsProperty::propertyCollection()
//make a feature
QgsFeature ft;
QgsFields fields;
fields.append( QgsField( QStringLiteral( "field1" ), QVariant::Int ) );
fields.append( QgsField( QStringLiteral( "field2" ), QVariant::Int ) );
fields.append( QgsField( QStringLiteral( "field1" ), QMetaType::Type::Int ) );
fields.append( QgsField( QStringLiteral( "field2" ), QMetaType::Type::Int ) );
ft.setFields( fields );
QgsAttributes attr;
attr << QVariant( 5 ) << QVariant( 7 );
@ -1662,8 +1662,8 @@ void TestQgsProperty::collectionStack()
//make a feature
QgsFeature ft;
QgsFields fields;
fields.append( QgsField( QStringLiteral( "field1" ), QVariant::Int ) );
fields.append( QgsField( QStringLiteral( "field2" ), QVariant::Int ) );
fields.append( QgsField( QStringLiteral( "field1" ), QMetaType::Type::Int ) );
fields.append( QgsField( QStringLiteral( "field2" ), QMetaType::Type::Int ) );
ft.setFields( fields );
QgsAttributes attr;
attr << QVariant( 5 ) << QVariant( 7 );

28
tests/src/core/testqgsrulebasedrenderer.cpp
View File

@ -200,7 +200,7 @@ class TestQgsRuleBasedRenderer: public QgsTest
const QString shpFile = TEST_DATA_DIR + QStringLiteral( "/rectangles.shp" );
std::unique_ptr< QgsVectorLayer > layer = std::make_unique< QgsVectorLayer >( shpFile, QStringLiteral( "rectangles" ), QStringLiteral( "ogr" ) );
QVERIFY( layer->isValid() );
QgsField vfield = QgsField( QStringLiteral( "fa_cy-fie+ld" ), QVariant::Int );
QgsField vfield = QgsField( QStringLiteral( "fa_cy-fie+ld" ), QMetaType::Type::Int );
layer->addExpressionField( QStringLiteral( "\"id\"" ), vfield );
// Create rulebased style
@ -238,7 +238,7 @@ class TestQgsRuleBasedRenderer: public QgsTest
const QString shpFile = TEST_DATA_DIR + QStringLiteral( "/rectangles.shp" );
std::unique_ptr< QgsVectorLayer > layer = std::make_unique< QgsVectorLayer >( shpFile, QStringLiteral( "rectangles" ), QStringLiteral( "ogr" ) );
QVERIFY( layer->isValid() );
QgsField vfield = QgsField( QStringLiteral( "fa_cy-fie+ld" ), QVariant::Int );
QgsField vfield = QgsField( QStringLiteral( "fa_cy-fie+ld" ), QMetaType::Type::Int );
layer->addExpressionField( QStringLiteral( "\"id\"" ), vfield );
// Create rulebased style
@ -278,7 +278,7 @@ class TestQgsRuleBasedRenderer: public QgsTest
const QString shpFile = TEST_DATA_DIR + QStringLiteral( "/rectangles.shp" );
std::unique_ptr< QgsVectorLayer > layer = std::make_unique< QgsVectorLayer >( shpFile, QStringLiteral( "rectangles" ), QStringLiteral( "ogr" ) );
QVERIFY( layer->isValid() );
QgsField vfield = QgsField( QStringLiteral( "fa_cy-fie+ld" ), QVariant::Int );
QgsField vfield = QgsField( QStringLiteral( "fa_cy-fie+ld" ), QMetaType::Type::Int );
layer->addExpressionField( QStringLiteral( "\"id\"" ), vfield );
// Create rulebased style
@ -336,7 +336,7 @@ class TestQgsRuleBasedRenderer: public QgsTest
const QString shpFile = TEST_DATA_DIR + QStringLiteral( "/rectangles.shp" );
std::unique_ptr< QgsVectorLayer > layer = std::make_unique< QgsVectorLayer >( shpFile, QStringLiteral( "rectangles" ), QStringLiteral( "ogr" ) );
QVERIFY( layer->isValid() );
QgsField vfield = QgsField( QStringLiteral( "fa_cy-fie+ld" ), QVariant::Int );
QgsField vfield = QgsField( QStringLiteral( "fa_cy-fie+ld" ), QMetaType::Type::Int );
layer->addExpressionField( QStringLiteral( "\"id\"" ), vfield );
// Create rulebased style
@ -391,7 +391,7 @@ class TestQgsRuleBasedRenderer: public QgsTest
const QString shpFile = TEST_DATA_DIR + QStringLiteral( "/rectangles.shp" );
std::unique_ptr< QgsVectorLayer > layer = std::make_unique< QgsVectorLayer >( shpFile, QStringLiteral( "rectangles" ), QStringLiteral( "ogr" ) );
QVERIFY( layer->isValid() );
QgsField vfield = QgsField( QStringLiteral( "fa_cy-fie+ld" ), QVariant::Int );
QgsField vfield = QgsField( QStringLiteral( "fa_cy-fie+ld" ), QMetaType::Type::Int );
layer->addExpressionField( QStringLiteral( "\"id\"" ), vfield );
// Create rulebased style
@ -436,7 +436,7 @@ class TestQgsRuleBasedRenderer: public QgsTest
const QString shpFile = TEST_DATA_DIR + QStringLiteral( "/rectangles.shp" );
std::unique_ptr< QgsVectorLayer > layer = std::make_unique< QgsVectorLayer >( shpFile, QStringLiteral( "rectangles" ), QStringLiteral( "ogr" ) );
QVERIFY( layer->isValid() );
QgsField vfield = QgsField( QStringLiteral( "fa_cy-fie+ld" ), QVariant::Int );
QgsField vfield = QgsField( QStringLiteral( "fa_cy-fie+ld" ), QMetaType::Type::Int );
layer->addExpressionField( QStringLiteral( "\"id\"" ), vfield );
// Create rulebased style
@ -486,7 +486,7 @@ class TestQgsRuleBasedRenderer: public QgsTest
const QString shpFile = TEST_DATA_DIR + QStringLiteral( "/rectangles.shp" );
std::unique_ptr< QgsVectorLayer > layer = std::make_unique< QgsVectorLayer >( shpFile, QStringLiteral( "rectangles" ), QStringLiteral( "ogr" ) );
QVERIFY( layer->isValid() );
QgsField vfield = QgsField( QStringLiteral( "fa_cy-fie+ld" ), QVariant::Int );
QgsField vfield = QgsField( QStringLiteral( "fa_cy-fie+ld" ), QMetaType::Type::Int );
layer->addExpressionField( QStringLiteral( "\"id\"" ), vfield );
// Create rulebased style
@ -622,7 +622,7 @@ class TestQgsRuleBasedRenderer: public QgsTest
const QString shpFile = TEST_DATA_DIR + QStringLiteral( "/rectangles.shp" );
std::unique_ptr< QgsVectorLayer > layer = std::make_unique< QgsVectorLayer >( shpFile, QStringLiteral( "rectangles" ), QStringLiteral( "ogr" ) );
QVERIFY( layer->isValid() );
QgsField vfield = QgsField( QStringLiteral( "fa_cy-fie+ld" ), QVariant::Int );
QgsField vfield = QgsField( QStringLiteral( "fa_cy-fie+ld" ), QMetaType::Type::Int );
layer->addExpressionField( QStringLiteral( "\"id\"" ), vfield );
// Create rulebased style
@ -678,7 +678,7 @@ class TestQgsRuleBasedRenderer: public QgsTest
const QString shpFile = TEST_DATA_DIR + QStringLiteral( "/rectangles.shp" );
std::unique_ptr< QgsVectorLayer > layer = std::make_unique< QgsVectorLayer >( shpFile, QStringLiteral( "rectangles" ), QStringLiteral( "ogr" ) );
QVERIFY( layer->isValid() );
QgsField vfield = QgsField( QStringLiteral( "fa_cy-fie+ld" ), QVariant::Int );
QgsField vfield = QgsField( QStringLiteral( "fa_cy-fie+ld" ), QMetaType::Type::Int );
layer->addExpressionField( QStringLiteral( "\"id\"" ), vfield );
// Create rulebased style
@ -742,7 +742,7 @@ class TestQgsRuleBasedRenderer: public QgsTest
const QString shpFile = TEST_DATA_DIR + QStringLiteral( "/rectangles.shp" );
std::unique_ptr< QgsVectorLayer > layer = std::make_unique< QgsVectorLayer >( shpFile, QStringLiteral( "rectangles" ), QStringLiteral( "ogr" ) );
QVERIFY( layer->isValid() );
QgsField vfield = QgsField( QStringLiteral( "fa_cy-fie+ld" ), QVariant::Int );
QgsField vfield = QgsField( QStringLiteral( "fa_cy-fie+ld" ), QMetaType::Type::Int );
layer->addExpressionField( QStringLiteral( "\"id\"" ), vfield );
// Create rulebased style
@ -797,7 +797,7 @@ class TestQgsRuleBasedRenderer: public QgsTest
const QString shpFile = TEST_DATA_DIR + QStringLiteral( "/rectangles.shp" );
std::unique_ptr< QgsVectorLayer > layer = std::make_unique< QgsVectorLayer >( shpFile, QStringLiteral( "rectangles" ), QStringLiteral( "ogr" ) );
QVERIFY( layer->isValid() );
QgsField vfield = QgsField( QStringLiteral( "fa_cy-fie+ld" ), QVariant::Int );
QgsField vfield = QgsField( QStringLiteral( "fa_cy-fie+ld" ), QMetaType::Type::Int );
layer->addExpressionField( QStringLiteral( "\"id\"" ), vfield );
// Create rulebased style
@ -956,7 +956,7 @@ class TestQgsRuleBasedRenderer: public QgsTest
const QString shpFile = TEST_DATA_DIR + QStringLiteral( "/rectangles.shp" );
std::unique_ptr< QgsVectorLayer > layer = std::make_unique< QgsVectorLayer >( shpFile, QStringLiteral( "rectangles" ), QStringLiteral( "ogr" ) );
QVERIFY( layer->isValid() );
QgsField vfield = QgsField( QStringLiteral( "fa_cy-fie+ld" ), QVariant::Int );
QgsField vfield = QgsField( QStringLiteral( "fa_cy-fie+ld" ), QMetaType::Type::Int );
layer->addExpressionField( QStringLiteral( "\"id\"" ), vfield );
// Create rulebased style
@ -1201,8 +1201,8 @@ class TestQgsRuleBasedRenderer: public QgsTest
elseRule->appendChild( threeRule );
QgsFields fields;
fields.append( QgsField( QStringLiteral( "Importance" ), QVariant::Int ) );
fields.append( QgsField( QStringLiteral( "Pilots" ), QVariant::Int ) );
fields.append( QgsField( QStringLiteral( "Importance" ), QMetaType::Type::Int ) );
fields.append( QgsField( QStringLiteral( "Pilots" ), QMetaType::Type::Int ) );
QgsFeature feature( fields );
QgsExpressionContext expContext;

2
tests/src/core/testqgsstatisticalsummary.cpp
View File

@ -297,7 +297,7 @@ void TestQgsStatisticSummary::countMissing()
s.addVariant( 6 );
s.addVariant( QVariant() );
s.addVariant( 7 );
s.addVariant( QVariant( QVariant::Double ) );
s.addVariant( QgsVariantUtils::createVariant( QMetaType::Type::Double ) );
s.addVariant( 9 );
s.addVariant( "Asdasdsad" );
s.finalize();

6
tests/src/core/testqgsvectordataprovider.cpp
View File

@ -123,9 +123,9 @@ static void checkFid4( QgsFeature &f, bool hasGeometry, bool hasAttrs, int onlyO
}
else
{
QCOMPARE( attrs[0].type(), QVariant::Invalid );
QCOMPARE( attrs[1].type(), QVariant::Invalid );
QCOMPARE( attrs[2].type(), QVariant::Invalid );
QCOMPARE( static_cast<QMetaType::Type>( attrs[0].userType() ), QMetaType::Type::UnknownType );
QCOMPARE( static_cast<QMetaType::Type>( attrs[1].userType() ), QMetaType::Type::UnknownType );
QCOMPARE( static_cast<QMetaType::Type>( attrs[2].userType() ), QMetaType::Type::UnknownType );
}
if ( hasGeometry )

20
tests/src/core/testqgsvectorfilewriter.cpp
View File

@ -141,7 +141,7 @@ void TestQgsVectorFileWriter::initTestCase()
//create some objects that will be used in all tests...
mEncoding = QStringLiteral( "UTF-8" );
const QgsField myField1( QStringLiteral( "Field1" ), QVariant::String, QStringLiteral( "String" ), 10, 0, QStringLiteral( "Field 1 comment" ) );
const QgsField myField1( QStringLiteral( "Field1" ), QMetaType::Type::QString, QStringLiteral( "String" ), 10, 0, QStringLiteral( "Field 1 comment" ) );
mFields.append( myField1 );
mCRS = QgsCoordinateReferenceSystem( geoWkt() );
mPoint1 = QgsPointXY( 10.0, 10.0 );
@ -426,7 +426,7 @@ void TestQgsVectorFileWriter::regression1141()
//create some objects that will be used in all tests...
const QString encoding = QStringLiteral( "UTF-8" );
const QgsField myField( QStringLiteral( "ąęćń" ), QVariant::Int, QStringLiteral( "int" ), 10, 0, QStringLiteral( "Value on lon" ) );
const QgsField myField( QStringLiteral( "ąęćń" ), QVarQMetaType::Type::InttringLiteral( "int" ), 10, 0, QStringLiteral( "Value on lon" ) );
QgsFields fields;
fields.append( myField );
QgsCoordinateReferenceSystem crs;
@ -546,10 +546,10 @@ void TestQgsVectorFileWriter::testExportArrayToGpkg()
tmpFile.open();
const QString fileName( tmpFile.fileName( ) );
QgsVectorLayer vl( "Point?field=arrayfield:integerlist&field=arrayfield2:stringlist", "test", "memory" );
QCOMPARE( vl.fields().at( 0 ).type(), QVariant::List );
QCOMPARE( vl.fields().at( 0 ).subType(), QVariant::Int );
QCOMPARE( vl.fields().at( 1 ).type(), QVariant::StringList );
QCOMPARE( vl.fields().at( 1 ).subType(), QVariant::String );
QCOMPARE( vl.fields().at( 0 ).type(), QMetaType::Type::QVariantList );
QCOMPARE( vl.fields().at( 0 ).subType(), QMetaType::Type::Int );
QCOMPARE( vl.fields().at( 1 ).type(), QMetaType::Type::QStringList );
QCOMPARE( vl.fields().at( 1 ).subType(), QMetaType::Type::QString );
QgsFeature f { vl.fields() };
f.setAttribute( 0, QVariantList() << 1 << 2 << 3 );
f.setAttribute( 1, QStringList() << "a" << "b" << "c" );
@ -571,11 +571,11 @@ void TestQgsVectorFileWriter::testExportArrayToGpkg()
const QgsVectorLayer vl2( QStringLiteral( "%1|layername=test" ).arg( fileName ), "src_test", "ogr" );
QVERIFY( vl2.isValid() );
QCOMPARE( vl2.featureCount(), 1L );
QCOMPARE( vl2.fields().at( 1 ).type(), QVariant::Map );
QCOMPARE( vl2.fields().at( 1 ).subType(), QVariant::String );
QCOMPARE( vl2.fields().at( 1 ).type(), QMetaType::Type::QVariantMap );
QCOMPARE( vl2.fields().at( 1 ).subType(), QMetaType::Type::QString );
QCOMPARE( vl2.fields().at( 1 ).typeName(), QStringLiteral( "JSON" ) );
QCOMPARE( vl2.fields().at( 2 ).type(), QVariant::Map );
QCOMPARE( vl2.fields().at( 2 ).subType(), QVariant::String );
QCOMPARE( vl2.fields().at( 2 ).type(), QMetaType::Type::QVariantMap );
QCOMPARE( vl2.fields().at( 2 ).subType(), QMetaType::Type::QString );
QCOMPARE( vl2.fields().at( 2 ).typeName(), QStringLiteral( "JSON" ) );
QCOMPARE( vl2.getFeature( 1 ).attribute( 1 ).toList(), QVariantList() << 1 << 2 << 3 );
QCOMPARE( vl2.getFeature( 1 ).attribute( 2 ).toStringList(), QStringList() << "a" << "b" << "c" );

4
tests/src/core/testqgsvectorlayer.cpp
View File

@ -460,7 +460,7 @@ void TestQgsVectorLayer::testFieldExpression()
QgsVectorLayer layer1( QStringLiteral( "Point?field=name:string" ), QStringLiteral( "layer1" ), QStringLiteral( "memory" ) );
QVERIFY( layer1.isValid() );
layer1.addExpressionField( QStringLiteral( "'abc'" ), QgsField( QStringLiteral( "virtual_field" ), QVariant::String ) );
layer1.addExpressionField( QStringLiteral( "'abc'" ), QgsField( QStringLiteral( "virtual_field" ), QMetaType::Type::QString ) );
QCOMPARE( layer1.expressionField( layer1.fields().lookupField( QStringLiteral( "virtual_field" ) ) ), QStringLiteral( "'abc'" ) );
QCOMPARE( layer1.expressionField( layer1.fields().lookupField( QStringLiteral( "name" ) ) ), QString() );
@ -474,7 +474,7 @@ void TestQgsVectorLayer::testFieldAggregateExpression()
QgsVectorLayer layer( testPolysFile, QStringLiteral( "layer1" ), QStringLiteral( "ogr" ) );
QVERIFY( layer.isValid() );
layer.addExpressionField( QStringLiteral( "sum($area)" ), QgsField( QStringLiteral( "virtual_field" ), QVariant::String ) );
layer.addExpressionField( QStringLiteral( "sum($area)" ), QgsField( QStringLiteral( "virtual_field" ), QMetaType::Type::QString ) );
const int vfIndex = layer.fields().count() - 1;
QCOMPARE( layer.fields().at( 0 ).name(), QStringLiteral( "fid" ) );

2
tests/src/core/testqgsvectorlayercache.cpp
View File

@ -164,7 +164,7 @@ void TestVectorLayerCache::testCacheAttrActions()
// Add an attribute, make sure it is returned also if a cached feature is requested
mPointsLayer->startEditing();
const QVariant::Type attrType = QVariant::Int;
const QMetaType::Type attrType = QMetaType::Type::Int;
mPointsLayer->addAttribute( QgsField( QStringLiteral( "newAttr" ), attrType, QStringLiteral( "Int" ), 5, 0 ) );
mPointsLayer->commitChanges();

2
tests/src/core/testqgsvectorlayerjoinbuffer.cpp
View File

@ -314,7 +314,7 @@ void TestVectorLayerJoinBuffer::testJoinTransitive()
QCOMPARE( fA1.attribute( "B_C_value_c" ).toInt(), 101 );
// test that layer A gets updated when layer C changes its fields
vlC->addExpressionField( QStringLiteral( "123" ), QgsField( QStringLiteral( "dummy" ), QVariant::Int ) );
vlC->addExpressionField( QStringLiteral( "123" ), QgsField( QStringLiteral( "dummy" ), QMetaType::Type::Int ) );
QVERIFY( vlA->fields().count() == 4 ); // id_a, B_value_b, B_C_value_c, B_C_dummy
vlC->removeExpressionField( 0 );

8
tests/src/core/testqgsvectortilewriter.cpp
View File

@ -125,7 +125,7 @@ void TestQgsVectorTileWriter::test_basic()
QCOMPARE( fieldNamesLines, QStringList() << "Name" << "Value" );
QgsFields fieldsPolys;
fieldsPolys.append( QgsField( "Name", QVariant::String ) );
fieldsPolys.append( QgsField( "Name", QMetaType::Type::QString ) );
QMap<QString, QgsFields> perLayerFields;
perLayerFields["polys"] = fieldsPolys;
perLayerFields["lines"] = QgsFields();
@ -194,7 +194,7 @@ void TestQgsVectorTileWriter::test_mbtiles()
QCOMPARE( fieldNamesLines, QStringList() << "Name" << "Value" );
QgsFields fieldsPolys;
fieldsPolys.append( QgsField( "Name", QVariant::String ) );
fieldsPolys.append( QgsField( "Name", QMetaType::Type::QString ) );
QMap<QString, QgsFields> perLayerFields;
perLayerFields["polys"] = fieldsPolys;
perLayerFields["lines"] = QgsFields();
@ -373,7 +373,7 @@ void TestQgsVectorTileWriter::test_z0TileMatrix3857()
QCOMPARE( fieldNamesLines, QStringList() << "Name" << "Value" );
QgsFields fieldsPolys;
fieldsPolys.append( QgsField( "Name", QVariant::String ) );
fieldsPolys.append( QgsField( "Name", QMetaType::Type::QString ) );
QMap<QString, QgsFields> perLayerFields;
perLayerFields["polys"] = fieldsPolys;
perLayerFields["lines"] = QgsFields();
@ -459,7 +459,7 @@ void TestQgsVectorTileWriter::test_z0TileMatrix2154()
QCOMPARE( fieldNamesLines, QStringList() << "Name" << "Value" );
QgsFields fieldsPolys;
fieldsPolys.append( QgsField( "Name", QVariant::String ) );
fieldsPolys.append( QgsField( "Name", QMetaType::Type::QString ) );
QMap<QString, QgsFields> perLayerFields;
perLayerFields["polys"] = fieldsPolys;
perLayerFields["lines"] = QgsFields();

2
tests/src/geometry_checker/testqgsgeometrychecks.cpp
View File

@ -1403,7 +1403,7 @@ QList<QgsGeometryCheckError *> TestQgsGeometryChecks::searchCheckErrors( const Q
}
if ( !value.isNull() )
{
if ( value.type() == QVariant::Double )
if ( value.userType() == QMetaType::Type::Double )
{
if ( !qgsDoubleNear( value.toDouble(), error->value().toDouble(), tol ) )
{

52
tests/src/gui/testprocessinggui.cpp
View File

@ -3320,14 +3320,14 @@ void TestProcessingGui::testFieldWrapper()
// filtering fields
QgsFields f;
f.append( QgsField( QStringLiteral( "string" ), QVariant::String ) );
f.append( QgsField( QStringLiteral( "double" ), QVariant::Double ) );
f.append( QgsField( QStringLiteral( "int" ), QVariant::Int ) );
f.append( QgsField( QStringLiteral( "date" ), QVariant::Date ) );
f.append( QgsField( QStringLiteral( "time" ), QVariant::Time ) );
f.append( QgsField( QStringLiteral( "datetime" ), QVariant::DateTime ) );
f.append( QgsField( QStringLiteral( "binary" ), QVariant::ByteArray ) );
f.append( QgsField( QStringLiteral( "boolean" ), QVariant::Bool ) );
f.append( QgsField( QStringLiteral( "string" ), QMetaType::Type::QString ) );
f.append( QgsField( QStringLiteral( "double" ), QMetaType::Type::Double ) );
f.append( QgsField( QStringLiteral( "int" ), QMetaType::Type::Int ) );
f.append( QgsField( QStringLiteral( "date" ), QMetaType::Type::QDate ) );
f.append( QgsField( QStringLiteral( "time" ), QMetaType::Type::QTime ) );
f.append( QgsField( QStringLiteral( "datetime" ), QMetaType::Type::QDateTime ) );
f.append( QgsField( QStringLiteral( "binary" ), QMetaType::Type::QByteArray ) );
f.append( QgsField( QStringLiteral( "boolean" ), QMetaType::Type::Bool ) );
QgsFields f2 = wrapper3.filterFields( f );
QCOMPARE( f2, f );
@ -8340,12 +8340,12 @@ void TestProcessingGui::testFieldMapWidget()
QVariantMap map;
map.insert( QStringLiteral( "name" ), QStringLiteral( "n" ) );
map.insert( QStringLiteral( "type" ), static_cast< int >( QVariant::Double ) );
map.insert( QStringLiteral( "type" ), static_cast< int >( QMetaType::Type::Double ) );
map.insert( QStringLiteral( "length" ), 8 );
map.insert( QStringLiteral( "precision" ), 5 );
QVariantMap map2;
map2.insert( QStringLiteral( "name" ), QStringLiteral( "n2" ) );
map2.insert( QStringLiteral( "type" ), static_cast< int >( QVariant::String ) );
map2.insert( QStringLiteral( "type" ), static_cast< int >( QMetaType::Type::QString ) );
map2.insert( QStringLiteral( "expression" ), QStringLiteral( "'abc' || \"def\"" ) );
map2.insert( QStringLiteral( "alias" ), QStringLiteral( "my alias" ) );
map2.insert( QStringLiteral( "comment" ), QStringLiteral( "my comment" ) );
@ -8356,12 +8356,12 @@ void TestProcessingGui::testFieldMapWidget()
QCOMPARE( widget.value().toList().size(), 2 );
QCOMPARE( widget.value().toList().at( 0 ).toMap().value( QStringLiteral( "name" ) ).toString(), QStringLiteral( "n" ) );
QCOMPARE( widget.value().toList().at( 0 ).toMap().value( QStringLiteral( "type" ) ).toInt(), static_cast< int >( QVariant::Double ) );
QCOMPARE( widget.value().toList().at( 0 ).toMap().value( QStringLiteral( "type" ) ).toInt(), static_cast< int >( QMetaType::Type::Double ) );
QCOMPARE( widget.value().toList().at( 0 ).toMap().value( QStringLiteral( "length" ) ).toInt(), 8 );
QCOMPARE( widget.value().toList().at( 0 ).toMap().value( QStringLiteral( "precision" ) ).toInt(), 5 );
QCOMPARE( widget.value().toList().at( 0 ).toMap().value( QStringLiteral( "expression" ) ).toString(), QString() );
QCOMPARE( widget.value().toList().at( 1 ).toMap().value( QStringLiteral( "name" ) ).toString(), QStringLiteral( "n2" ) );
QCOMPARE( widget.value().toList().at( 1 ).toMap().value( QStringLiteral( "type" ) ).toInt(), static_cast< int >( QVariant::String ) );
QCOMPARE( widget.value().toList().at( 1 ).toMap().value( QStringLiteral( "type" ) ).toInt(), static_cast< int >( QMetaType::Type::QString ) );
QCOMPARE( widget.value().toList().at( 1 ).toMap().value( QStringLiteral( "expression" ) ).toString(), QStringLiteral( "'abc' || \"def\"" ) );
QCOMPARE( widget.value().toList().at( 1 ).toMap().value( QStringLiteral( "alias" ) ).toString(), QStringLiteral( "my alias" ) );
QCOMPARE( widget.value().toList().at( 1 ).toMap().value( QStringLiteral( "comment" ) ).toString(), QStringLiteral( "my comment" ) );
@ -8383,12 +8383,12 @@ void TestProcessingGui::testFieldMapWrapper()
QVariantMap map;
map.insert( QStringLiteral( "name" ), QStringLiteral( "n" ) );
map.insert( QStringLiteral( "type" ), static_cast< int >( QVariant::Double ) );
map.insert( QStringLiteral( "type" ), static_cast< int >( QMetaType::Type::Double ) );
map.insert( QStringLiteral( "length" ), 8 );
map.insert( QStringLiteral( "precision" ), 5 );
QVariantMap map2;
map2.insert( QStringLiteral( "name" ), QStringLiteral( "n2" ) );
map2.insert( QStringLiteral( "type" ), static_cast< int >( QVariant::String ) );
map2.insert( QStringLiteral( "type" ), static_cast< int >( QMetaType::Type::QString ) );
map2.insert( QStringLiteral( "expression" ), QStringLiteral( "'abc' || \"def\"" ) );
map2.insert( QStringLiteral( "alias" ), QStringLiteral( "my alias" ) );
map2.insert( QStringLiteral( "comment" ), QStringLiteral( "my comment" ) );
@ -8397,12 +8397,12 @@ void TestProcessingGui::testFieldMapWrapper()
wrapper.setWidgetValue( QVariantList() << map << map2, context );
QCOMPARE( spy.count(), 1 );
QCOMPARE( wrapper.widgetValue().toList().at( 0 ).toMap().value( QStringLiteral( "name" ) ).toString(), QStringLiteral( "n" ) );
QCOMPARE( wrapper.widgetValue().toList().at( 0 ).toMap().value( QStringLiteral( "type" ) ).toInt(), static_cast< int >( QVariant::Double ) );
QCOMPARE( wrapper.widgetValue().toList().at( 0 ).toMap().value( QStringLiteral( "type" ) ).toInt(), static_cast< int >( QMetaType::Type::Double ) );
QCOMPARE( wrapper.widgetValue().toList().at( 0 ).toMap().value( QStringLiteral( "length" ) ).toInt(), 8 );
QCOMPARE( wrapper.widgetValue().toList().at( 0 ).toMap().value( QStringLiteral( "precision" ) ).toInt(), 5 );
QCOMPARE( wrapper.widgetValue().toList().at( 0 ).toMap().value( QStringLiteral( "expression" ) ).toString(), QString() );
QCOMPARE( wrapper.widgetValue().toList().at( 1 ).toMap().value( QStringLiteral( "name" ) ).toString(), QStringLiteral( "n2" ) );
QCOMPARE( wrapper.widgetValue().toList().at( 1 ).toMap().value( QStringLiteral( "type" ) ).toInt(), static_cast< int >( QVariant::String ) );
QCOMPARE( wrapper.widgetValue().toList().at( 1 ).toMap().value( QStringLiteral( "type" ) ).toInt(), static_cast< int >( QMetaType::Type::QString ) );
QCOMPARE( wrapper.widgetValue().toList().at( 1 ).toMap().value( QStringLiteral( "expression" ) ).toString(), QStringLiteral( "'abc' || \"def\"" ) );
QCOMPARE( wrapper.widgetValue().toList().at( 1 ).toMap().value( QStringLiteral( "alias" ) ).toString(), QStringLiteral( "my alias" ) );
QCOMPARE( wrapper.widgetValue().toList().at( 1 ).toMap().value( QStringLiteral( "comment" ) ).toString(), QStringLiteral( "my comment" ) );
@ -8540,12 +8540,12 @@ void TestProcessingGui::testAggregateWidget()
QVariantMap map;
map.insert( QStringLiteral( "name" ), QStringLiteral( "n" ) );
map.insert( QStringLiteral( "type" ), static_cast< int >( QVariant::Double ) );
map.insert( QStringLiteral( "type" ), static_cast< int >( QMetaType::Type::Double ) );
map.insert( QStringLiteral( "length" ), 8 );
map.insert( QStringLiteral( "precision" ), 5 );
QVariantMap map2;
map2.insert( QStringLiteral( "name" ), QStringLiteral( "n2" ) );
map2.insert( QStringLiteral( "type" ), static_cast< int >( QVariant::String ) );
map2.insert( QStringLiteral( "type" ), static_cast< int >( QMetaType::Type::QString ) );
map2.insert( QStringLiteral( "input" ), QStringLiteral( "'abc' || \"def\"" ) );
map2.insert( QStringLiteral( "aggregate" ), QStringLiteral( "concatenate" ) );
map2.insert( QStringLiteral( "delimiter" ), QStringLiteral( "|" ) );
@ -8556,14 +8556,14 @@ void TestProcessingGui::testAggregateWidget()
QCOMPARE( widget.value().toList().size(), 2 );
QCOMPARE( widget.value().toList().at( 0 ).toMap().value( QStringLiteral( "name" ) ).toString(), QStringLiteral( "n" ) );
QCOMPARE( widget.value().toList().at( 0 ).toMap().value( QStringLiteral( "type" ) ).toInt(), static_cast< int >( QVariant::Double ) );
QCOMPARE( widget.value().toList().at( 0 ).toMap().value( QStringLiteral( "type" ) ).toInt(), static_cast< int >( QMetaType::Type::Double ) );
QCOMPARE( widget.value().toList().at( 0 ).toMap().value( QStringLiteral( "length" ) ).toInt(), 8 );
QCOMPARE( widget.value().toList().at( 0 ).toMap().value( QStringLiteral( "precision" ) ).toInt(), 5 );
QCOMPARE( widget.value().toList().at( 0 ).toMap().value( QStringLiteral( "input" ) ).toString(), QString() );
QCOMPARE( widget.value().toList().at( 0 ).toMap().value( QStringLiteral( "aggregate" ) ).toString(), QString() );
QCOMPARE( widget.value().toList().at( 0 ).toMap().value( QStringLiteral( "delimiter" ) ).toString(), QString() );
QCOMPARE( widget.value().toList().at( 1 ).toMap().value( QStringLiteral( "name" ) ).toString(), QStringLiteral( "n2" ) );
QCOMPARE( widget.value().toList().at( 1 ).toMap().value( QStringLiteral( "type" ) ).toInt(), static_cast< int >( QVariant::String ) );
QCOMPARE( widget.value().toList().at( 1 ).toMap().value( QStringLiteral( "type" ) ).toInt(), static_cast< int >( QMetaType::Type::QString ) );
QCOMPARE( widget.value().toList().at( 1 ).toMap().value( QStringLiteral( "input" ) ).toString(), QStringLiteral( "'abc' || \"def\"" ) );
QCOMPARE( widget.value().toList().at( 1 ).toMap().value( QStringLiteral( "aggregate" ) ).toString(), QStringLiteral( "concatenate" ) );
QCOMPARE( widget.value().toList().at( 1 ).toMap().value( QStringLiteral( "delimiter" ) ).toString(), QStringLiteral( "|" ) );
@ -8585,12 +8585,12 @@ void TestProcessingGui::testAggregateWrapper()
QVariantMap map;
map.insert( QStringLiteral( "name" ), QStringLiteral( "n" ) );
map.insert( QStringLiteral( "type" ), static_cast< int >( QVariant::Double ) );
map.insert( QStringLiteral( "type" ), static_cast< int >( QMetaType::Type::Double ) );
map.insert( QStringLiteral( "length" ), 8 );
map.insert( QStringLiteral( "precision" ), 5 );
QVariantMap map2;
map2.insert( QStringLiteral( "name" ), QStringLiteral( "n2" ) );
map2.insert( QStringLiteral( "type" ), static_cast< int >( QVariant::String ) );
map2.insert( QStringLiteral( "type" ), static_cast< int >( QMetaType::Type::QString ) );
map2.insert( QStringLiteral( "input" ), QStringLiteral( "'abc' || \"def\"" ) );
map2.insert( QStringLiteral( "aggregate" ), QStringLiteral( "concatenate" ) );
map2.insert( QStringLiteral( "delimiter" ), QStringLiteral( "|" ) );
@ -8599,14 +8599,14 @@ void TestProcessingGui::testAggregateWrapper()
wrapper.setWidgetValue( QVariantList() << map << map2, context );
QCOMPARE( spy.count(), 1 );
QCOMPARE( wrapper.widgetValue().toList().at( 0 ).toMap().value( QStringLiteral( "name" ) ).toString(), QStringLiteral( "n" ) );
QCOMPARE( wrapper.widgetValue().toList().at( 0 ).toMap().value( QStringLiteral( "type" ) ).toInt(), static_cast< int >( QVariant::Double ) );
QCOMPARE( wrapper.widgetValue().toList().at( 0 ).toMap().value( QStringLiteral( "type" ) ).toInt(), static_cast< int >( QMetaType::Type::Double ) );
QCOMPARE( wrapper.widgetValue().toList().at( 0 ).toMap().value( QStringLiteral( "length" ) ).toInt(), 8 );
QCOMPARE( wrapper.widgetValue().toList().at( 0 ).toMap().value( QStringLiteral( "precision" ) ).toInt(), 5 );
QCOMPARE( wrapper.widgetValue().toList().at( 0 ).toMap().value( QStringLiteral( "input" ) ).toString(), QString() );
QCOMPARE( wrapper.widgetValue().toList().at( 0 ).toMap().value( QStringLiteral( "aggregate" ) ).toString(), QString() );
QCOMPARE( wrapper.widgetValue().toList().at( 0 ).toMap().value( QStringLiteral( "delimiter" ) ).toString(), QString() );
QCOMPARE( wrapper.widgetValue().toList().at( 1 ).toMap().value( QStringLiteral( "name" ) ).toString(), QStringLiteral( "n2" ) );
QCOMPARE( wrapper.widgetValue().toList().at( 1 ).toMap().value( QStringLiteral( "type" ) ).toInt(), static_cast< int >( QVariant::String ) );
QCOMPARE( wrapper.widgetValue().toList().at( 1 ).toMap().value( QStringLiteral( "type" ) ).toInt(), static_cast< int >( QMetaType::Type::QString ) );
QCOMPARE( wrapper.widgetValue().toList().at( 1 ).toMap().value( QStringLiteral( "input" ) ).toString(), QStringLiteral( "'abc' || \"def\"" ) );
QCOMPARE( wrapper.widgetValue().toList().at( 1 ).toMap().value( QStringLiteral( "aggregate" ) ).toString(), QStringLiteral( "concatenate" ) );
QCOMPARE( wrapper.widgetValue().toList().at( 1 ).toMap().value( QStringLiteral( "delimiter" ) ).toString(), QStringLiteral( "|" ) );
@ -10155,7 +10155,7 @@ void TestProcessingGui::testMeshDatasetWrapperLayerInProject()
QCOMPARE( timeSpy.count(), 3 );
QVariant groupsValue = groupsWrapper.widgetValue();
QVERIFY( groupsValue.type() == QVariant::List );
QVERIFY( groupsValue.userType() == QMetaType::Type::QVariantList );
QVariantList groupsList = groupsValue.toList();
QCOMPARE( groupsList.count(), 1 );
QCOMPARE( groupsList.at( 0 ).toInt(), 1 );
@ -10185,7 +10185,7 @@ void TestProcessingGui::testMeshDatasetWrapperLayerInProject()
QCOMPARE( timeSpy.count(), 4 ); //radioButtonDatasetGroupTimeStep already checked
QVariant timeValue = timeWrapper.widgetValue();
QVERIFY( timeValue.type() == QVariant::Map );
QVERIFY( timeValue.userType() == QMetaType::Type::QVariantMap );
QVariantMap timeValueMap = timeValue.toMap();
QCOMPARE( timeValueMap[QStringLiteral( "type" )].toString(), QStringLiteral( "dataset-time-step" ) );
pythonString = timeDefinition.valueAsPythonString( timeWrapper.widgetValue(), context );

8
tests/src/gui/testqgsattributeform.cpp
View File

@ -396,11 +396,11 @@ void TestQgsAttributeForm::testDynamicForm()
ww = qobject_cast<QgsEditorWidgetWrapper *>( form.mWidgets[1] );
QCOMPARE( ww->field().name(), QString( "layerB_col0" ) );
QCOMPARE( ww->value(), QVariant( QVariant::Int ) );
QCOMPARE( ww->value(), QgsVariantUtils::createVariant( QMetaType::Type::Int ) );
ww = qobject_cast<QgsEditorWidgetWrapper *>( form.mWidgets[2] );
QCOMPARE( ww->field().name(), QString( "layerC_col0" ) );
QCOMPARE( ww->value(), QVariant( QVariant::Int ) );
QCOMPARE( ww->value(), QgsVariantUtils::createVariant( QMetaType::Type::Int ) );
// change layerA join id field to join with layerB
form.changeAttribute( QStringLiteral( "id_a" ), QVariant( 30 ) );
@ -415,7 +415,7 @@ void TestQgsAttributeForm::testDynamicForm()
ww = qobject_cast<QgsEditorWidgetWrapper *>( form.mWidgets[2] );
QCOMPARE( ww->field().name(), QString( "layerC_col0" ) );
QCOMPARE( ww->value(), QVariant( QVariant::Int ) );
QCOMPARE( ww->value(), QgsVariantUtils::createVariant( QMetaType::Type::Int ) );
// change layerA join id field to join with layerC
form.changeAttribute( QStringLiteral( "id_a" ), QVariant( 32 ) );
@ -426,7 +426,7 @@ void TestQgsAttributeForm::testDynamicForm()
ww = qobject_cast<QgsEditorWidgetWrapper *>( form.mWidgets[1] );
QCOMPARE( ww->field().name(), QString( "layerB_col0" ) );
QCOMPARE( ww->value(), QVariant( QVariant::Int ) );
QCOMPARE( ww->value(), QgsVariantUtils::createVariant( QMetaType::Type::Int ) );
ww = qobject_cast<QgsEditorWidgetWrapper *>( form.mWidgets[2] );
QCOMPARE( ww->field().name(), QString( "layerC_col0" ) );

20
tests/src/gui/testqgsdatetimeedit.cpp
View File

@ -63,13 +63,13 @@ void TestQgsDateTimeEdit::init()
// add fields
QList<QgsField> fields;
fields.append( QgsField( "date1", QVariant::Date ) );
fields.append( QgsField( "date2", QVariant::Date ) );
fields.append( QgsField( "date3", QVariant::Date ) );
fields.append( QgsField( "time", QVariant::Time ) );
fields.append( QgsField( "datetime1", QVariant::DateTime ) );
fields.append( QgsField( "datetime2", QVariant::DateTime ) );
fields.append( QgsField( "text", QVariant::String ) );
fields.append( QgsField( "date1", QMetaType::Type::QDate ) );
fields.append( QgsField( "date2", QMetaType::Type::QDate ) );
fields.append( QgsField( "date3", QMetaType::Type::QDate ) );
fields.append( QgsField( "time", QMetaType::Type::QTime ) );
fields.append( QgsField( "datetime1", QMetaType::Type::QDateTime ) );
fields.append( QgsField( "datetime2", QMetaType::Type::QDateTime ) );
fields.append( QgsField( "text", QMetaType::Type::QString ) );
vl->dataProvider()->addAttributes( fields );
vl->updateFields();
QVERIFY( vl.get() );
@ -187,19 +187,19 @@ void TestQgsDateTimeEdit::focus()
QgsDateTimeEdit *dateedit1 = qobject_cast<QgsDateTimeEdit *>( widget1->createWidget( &w ) );
QVERIFY( dateedit1 );
widget1->initWidget( dateedit1 );
widget1->setValue( QVariant::Date );
widget1->setValue( QMetaType::Type::QDate );
widget2->setConfig( cfg );
QgsDateTimeEdit *dateedit2 = qobject_cast<QgsDateTimeEdit *>( widget2->createWidget( &w ) );
QVERIFY( dateedit2 );
widget2->initWidget( dateedit2 );
widget2->setValue( QVariant::Date );
widget2->setValue( QMetaType::Type::QDate );
widget3->setConfig( cfg );
QgsDateTimeEdit *dateedit3 = qobject_cast<QgsDateTimeEdit *>( widget3->createWidget( &w ) );
QVERIFY( dateedit3 );
widget3->initWidget( dateedit3 );
widget3->setValue( QVariant::Date );
widget3->setValue( QMetaType::Type::QDate );
QVERIFY( widget1->value().isNull() );
QVERIFY( widget2->value().isNull() );

4
tests/src/gui/testqgsexternalresourcewidgetwrapper.cpp
View File

@ -271,12 +271,12 @@ void TestQgsExternalResourceWidgetWrapper::testSetNullValues()
ww.updateValues( QVariant() );
QCOMPARE( ww.mLineEdit->text(), QgsApplication::nullRepresentation() );
QCOMPARE( ww.mQgsWidget->documentPath(), QVariant( QVariant::String ) );
QCOMPARE( ww.mQgsWidget->documentPath(), QgsVariantUtils::createVariant( QMetaType::Type::QString ) );
QCOMPARE( spy.count(), 2 );
ww.updateValues( QgsApplication::nullRepresentation() );
QCOMPARE( ww.mLineEdit->text(), QgsApplication::nullRepresentation() );
QCOMPARE( ww.mQgsWidget->documentPath(), QVariant( QVariant::String ) );
QCOMPARE( ww.mQgsWidget->documentPath(), QgsVariantUtils::createVariant( QMetaType::Type::QString ) );
QCOMPARE( spy.count(), 2 );
delete widget;

2
tests/src/gui/testqgsexternalstoragefilewidget.cpp
View File

@ -640,7 +640,7 @@ void TestQgsExternalStorageFileWidget::testStoringChangeFeature()
w.show();
QgsFields fields;
fields.append( QgsField( QStringLiteral( "myfield" ), QVariant::String ) );
fields.append( QgsField( QStringLiteral( "myfield" ), QMetaType::Type::QString ) );
QgsFeature f1( fields );
f1.setAttribute( QStringLiteral( "myfield" ), QStringLiteral( "val1" ) );

6
tests/src/gui/testqgsfeaturelistcombobox.cpp
View File

@ -174,14 +174,14 @@ void TestQgsFeatureListComboBox::testMultipleForeignKeys()
cb->setIdentifierValuesToNull();
QCOMPARE( cb->identifierValues().count(), 3 );
QCOMPARE( cb->identifierValues(), QVariantList() << QVariant( QVariant::Int ) << QVariant( QVariant::Int ) << QVariant( QVariant::Int ) );
QCOMPARE( cb->identifierValues(), QVariantList() << QgsVariantUtils::createVariant( QMetaType::Type::Int ) << QgsVariantUtils::createVariant( QMetaType::Type::Int ) << QgsVariantUtils::createVariant( QMetaType::Type::Int ) );
cb->setIdentifierValues( QVariantList() << "silver" << 888 << "fish" );
QCOMPARE( cb->identifierValues(), QVariantList() << "silver" << 888 << "fish" );
cb->setIdentifierValuesToNull();
QCOMPARE( cb->identifierValues().count(), 3 );
QCOMPARE( cb->identifierValues(), QVariantList() << QVariant( QVariant::Int ) << QVariant( QVariant::Int ) << QVariant( QVariant::Int ) );
QCOMPARE( cb->identifierValues(), QVariantList() << QgsVariantUtils::createVariant( QMetaType::Type::Int ) << QgsVariantUtils::createVariant( QMetaType::Type::Int ) << QgsVariantUtils::createVariant( QMetaType::Type::Int ) );
cb->setIdentifierFields( QStringList() << "material" << "raccord" );
cb->setDisplayExpression( "\"material\" || ' ' || \"raccord\"" );
@ -193,7 +193,7 @@ void TestQgsFeatureListComboBox::testMultipleForeignKeys()
cb->setIdentifierValuesToNull();
QCOMPARE( cb->identifierValues().count(), 2 );
QCOMPARE( cb->identifierValues(), QVariantList() << QVariant( QVariant::Int ) << QVariant( QVariant::Int ) );
QCOMPARE( cb->identifierValues(), QVariantList() << QgsVariantUtils::createVariant( QMetaType::Type::Int ) << QgsVariantUtils::createVariant( QMetaType::Type::Int ) );
}
void TestQgsFeatureListComboBox::testAllowNull()

2
tests/src/gui/testqgsfieldexpressionwidget.cpp
View File

@ -138,7 +138,7 @@ void TestQgsFieldExpressionWidget::testRemoveJoin()
void TestQgsFieldExpressionWidget::asExpression()
{
QgsVectorLayer *layer = new QgsVectorLayer( QStringLiteral( "point?field=fld:int&field=fld2:int&field=fld3:int" ), QStringLiteral( "x" ), QStringLiteral( "memory" ) );
layer->dataProvider()->addAttributes( QList< QgsField >() << QgsField( QStringLiteral( "a space" ), QVariant::String ) );
layer->dataProvider()->addAttributes( QList< QgsField >() << QgsField( QStringLiteral( "a space" ), QMetaType::Type::QString ) );
layer->updateFields();
QgsProject::instance()->addMapLayer( layer );

4
tests/src/gui/testqgskeyvaluewidget.cpp
View File

@ -55,7 +55,7 @@ class TestQgsKeyValueWidget : public QObject
wrapper->setValues( initial, QVariantList() );
const QVariant value = wrapper->value();
QCOMPARE( int( value.type() ), int( QVariant::Map ) );
QCOMPARE( int( static_cast<QMetaType::Type>( value.userType() ) ), int( QMetaType::Type::QVariantMap ) );
QCOMPARE( value.toMap(), initial );
QCOMPARE( spy.count(), 0 );
@ -66,7 +66,7 @@ class TestQgsKeyValueWidget : public QObject
QVariantMap expected = initial;
expected[QStringLiteral( "1" )] = "hello";
const QVariant eventValue = spy.at( 0 ).at( 0 ).value<QVariant>();
QCOMPARE( int( eventValue.type() ), int( QVariant::Map ) );
QCOMPARE( int( static_cast<QMetaType::Type>( eventValue.userType() ) ), int( QMetaType::Type::QVariantMap ) );
QCOMPARE( eventValue.toMap(), expected );
QCOMPARE( wrapper->value().toMap(), expected );
QCOMPARE( spy.count(), 1 );

8
tests/src/gui/testqgslistwidget.cpp
View File

@ -81,7 +81,7 @@ class TestQgsListWidget : public QObject
wrapper->setValues( initial, QVariantList() );
const QVariant value = wrapper->value();
QCOMPARE( int( value.type() ), int( QVariant::StringList ) );
QCOMPARE( int( static_cast<QMetaType::Type>( value.userType() ) ), int( QMetaType::Type::QStringList ) );
QCOMPARE( value.toStringList(), initial );
QCOMPARE( spy.count(), 0 );
@ -93,7 +93,7 @@ class TestQgsListWidget : public QObject
QStringList expected = initial;
expected[0] = QStringLiteral( "hello" );
const QVariant eventValue = spy.at( 0 ).at( 0 ).value<QVariant>();
QCOMPARE( int( eventValue.type() ), int( QVariant::StringList ) );
QCOMPARE( int( static_cast<QMetaType::Type>( eventValue.userType() ) ), int( QMetaType::Type::QStringList ) );
QCOMPARE( eventValue.toStringList(), expected );
QCOMPARE( wrapper->value().toStringList(), expected );
QCOMPARE( spy.count(), 1 );
@ -116,7 +116,7 @@ class TestQgsListWidget : public QObject
wrapper->setValues( initial, QVariantList() );
const QVariant value = wrapper->value();
QCOMPARE( int( value.type() ), int( QVariant::List ) );
QCOMPARE( int( static_cast<QMetaType::Type>( value.userType() ) ), int( QMetaType::Type::QVariantList ) );
QCOMPARE( value.toList(), initial );
QCOMPARE( spy.count(), 0 );
@ -128,7 +128,7 @@ class TestQgsListWidget : public QObject
expected[0] = 3;
QCOMPARE( spy.count(), 1 );
QVariant eventValue = spy.at( 0 ).at( 0 ).value<QVariant>();
QCOMPARE( int( eventValue.type() ), int( QVariant::List ) );
QCOMPARE( int( static_cast<QMetaType::Type>( eventValue.userType() ) ), int( QMetaType::Type::QVariantList ) );
QCOMPARE( eventValue.toList(), expected );
QCOMPARE( wrapper->value().toList(), expected );
QVERIFY( widget->valid() );

24
tests/src/gui/testqgsrangewidgetwrapper.cpp
View File

@ -89,17 +89,17 @@ void TestQgsRangeWidgetWrapper::init()
// add fields
QList<QgsField> fields;
fields.append( QgsField( "id", QVariant::Int ) );
fields.append( QgsField( "id", QMetaType::Type::Int ) );
// precision = 9
QgsField dfield( "number", QVariant::Double );
QgsField dfield( "number", QMetaType::Type::Double );
dfield.setPrecision( 9 );
fields.append( dfield );
// default precision = 0
const QgsField dfield2( "number_def", QVariant::Double );
const QgsField dfield2( "number_def", QMetaType::Type::Double );
fields.append( dfield2 );
// simple int
fields.append( QgsField( "simplenumber", QVariant::Int ) );
fields.append( QgsField( "longlong", QVariant::LongLong ) );
fields.append( QgsField( "simplenumber", QMetaType::Type::Int ) );
fields.append( QgsField( "longlong", QMetaType::Type::LongLong ) );
vl->dataProvider()->addAttributes( fields );
vl->updateFields();
QVERIFY( vl.get() );
@ -304,11 +304,11 @@ void TestQgsRangeWidgetWrapper::test_nulls()
// Out of range
widget1->setFeature( vl->getFeature( 3 ) );
QCOMPARE( editor1->value( ), editor1->minimum() );
QCOMPARE( widget1->value( ), QVariant( QVariant::Double ) );
QCOMPARE( widget1->value( ), QgsVariantUtils::createVariant( QMetaType::Type::Double ) );
widget1->setFeature( QgsFeature( vl->fields() ) );
// Null
QCOMPARE( editor1->value( ), editor1->minimum() );
QCOMPARE( widget1->value( ), QVariant( QVariant::Double ) );
QCOMPARE( widget1->value( ), QgsVariantUtils::createVariant( QMetaType::Type::Double ) );
QCOMPARE( editor1->mLineEdit->text(), SPECIAL_TEXT_WHEN_EMPTY );
editor1->mLineEdit->setText( QString( "151%1" ).arg( SPECIAL_TEXT_WHEN_EMPTY ) );
QCOMPARE( widget1->value( ).toInt(), 151 );
@ -323,11 +323,11 @@ void TestQgsRangeWidgetWrapper::test_nulls()
// Out of range
widget0->setFeature( vl->getFeature( 3 ) );
QCOMPARE( editor0->value( ), editor0->minimum() );
QCOMPARE( widget0->value( ), QVariant( QVariant::Int ) );
QCOMPARE( widget0->value( ), QgsVariantUtils::createVariant( QMetaType::Type::Int ) );
widget0->setFeature( QgsFeature( vl->fields() ) );
// Null
QCOMPARE( editor0->value( ), editor0->minimum() );
QCOMPARE( widget0->value( ), QVariant( QVariant::Int ) );
QCOMPARE( widget0->value( ), QgsVariantUtils::createVariant( QMetaType::Type::Int ) );
QCOMPARE( editor0->mLineEdit->text(), SPECIAL_TEXT_WHEN_EMPTY );
editor0->mLineEdit->setText( QString( "150%1" ).arg( SPECIAL_TEXT_WHEN_EMPTY ) );
@ -385,21 +385,21 @@ void TestQgsRangeWidgetWrapper::test_focus()
QgsDoubleSpinBox *editor1 = qobject_cast<QgsDoubleSpinBox *>( widget1->createWidget( w ) );
QVERIFY( editor1 );
widget1->initWidget( editor1 );
widget1->setValue( QVariant( QVariant::Double ) );
widget1->setValue( QgsVariantUtils::createVariant( QMetaType::Type::Double ) );
//QgsDoubleSpinBox
widget2->setConfig( cfg );
QgsDoubleSpinBox *editor2 = qobject_cast<QgsDoubleSpinBox *>( widget2->createWidget( w ) );
QVERIFY( editor2 );
widget2->initWidget( editor2 );
widget2->setValue( QVariant( QVariant::Double ) );
widget2->setValue( QgsVariantUtils::createVariant( QMetaType::Type::Double ) );
//QgsSpinBox
widget3->setConfig( cfg );
QgsSpinBox *editor3 = qobject_cast<QgsSpinBox *>( widget3->createWidget( w ) );
QVERIFY( editor3 );
widget3->initWidget( editor3 );
widget3->setValue( QVariant( QVariant::Int ) );
widget3->setValue( QgsVariantUtils::createVariant( QMetaType::Type::Int ) );
QVERIFY( widget1->value().isNull() );
QVERIFY( widget2->value().isNull() );

2
tests/src/gui/testqgsrelationreferencewidget.cpp
View File

@ -488,7 +488,7 @@ void TestQgsRelationReferenceWidget::testChainFilterDeleteForeignKey()
QCOMPARE( cbs[2]->currentText(), QString( "sleeve" ) );
// set a null foreign key
w.setForeignKeys( QVariantList() << QVariant( QVariant::Int ) );
w.setForeignKeys( QVariantList() << QgsVariantUtils::createVariant( QMetaType::Type::Int ) );
QCOMPARE( cbs[0]->currentText(), QString( "material" ) );
QCOMPARE( cbs[0]->isEnabled(), true );
QCOMPARE( cbs[1]->currentText(), QString( "diameter" ) );

8
tests/src/gui/testqgsvaluerelationwidgetwrapper.cpp
View File

@ -1371,7 +1371,7 @@ void TestQgsValueRelationWidgetWrapper::testWithJsonInSpatialite()
// FEATURE 4
w_favoriteauthors.setFeature( vl_json->getFeature( 4 ) );
// Because allowNull is false we have a NULL variant here
QCOMPARE( w_favoriteauthors.value(), QVariant( QVariant::Type::List ) );
QCOMPARE( w_favoriteauthors.value(), QgsVariantUtils::createVariant( QMetaType::Type::QVariantList ) );
cfg_favoriteauthors[ QStringLiteral( "AllowNull" ) ] = true;
w_favoriteauthors.setConfig( cfg_favoriteauthors );
//check if first feature checked correctly (empty list)
@ -1389,7 +1389,7 @@ void TestQgsValueRelationWidgetWrapper::testWithJsonInSpatialite()
// FEATURE 5
w_favoriteauthors.setFeature( vl_json->getFeature( 5 ) );
// Because allowNull is false we have a NULL variant here
QCOMPARE( w_favoriteauthors.value(), QVariant( QVariant::Type::List ) );
QCOMPARE( w_favoriteauthors.value(), QgsVariantUtils::createVariant( QMetaType::Type::QVariantList ) );
cfg_favoriteauthors[ QStringLiteral( "AllowNull" ) ] = true;
w_favoriteauthors.setConfig( cfg_favoriteauthors );
@ -1540,7 +1540,7 @@ void TestQgsValueRelationWidgetWrapper::testWithJsonInSpatialiteTextFk()
w_favoriteauthors.setFeature( vl_json->getFeature( 4 ) );
// Because allowNull is false we have a NULL variant here
QCOMPARE( w_favoriteauthors.value(), QVariant( QVariant::Type::List ) );
QCOMPARE( w_favoriteauthors.value(), QgsVariantUtils::createVariant( QMetaType::Type::QVariantList ) );
cfg_favoriteauthors[ QStringLiteral( "AllowNull" ) ] = true;
w_favoriteauthors.setConfig( cfg_favoriteauthors );
@ -1561,7 +1561,7 @@ void TestQgsValueRelationWidgetWrapper::testWithJsonInSpatialiteTextFk()
w_favoriteauthors.setFeature( vl_json->getFeature( 5 ) );
// Because allowNull is false we have a NULL variant here
QCOMPARE( w_favoriteauthors.value(), QVariant( QVariant::Type::List ) );
QCOMPARE( w_favoriteauthors.value(), QgsVariantUtils::createVariant( QMetaType::Type::QVariantList ) );
cfg_favoriteauthors[ QStringLiteral( "AllowNull" ) ] = true;
w_favoriteauthors.setConfig( cfg_favoriteauthors );

4
tests/src/providers/testqgspostgresconn.cpp
View File

@ -112,12 +112,12 @@ class TestQgsPostgresConn: public QObject
QgsFields fields;
QgsField f;
f.setName( "ts" );
f.setType( QVariant::DateTime );
f.setType( QMetaType::Type::QDateTime );
f.setTypeName( "timestamp" );
fields.append( f );
QgsField f2;
f2.setName( "pk" );
f2.setType( QVariant::LongLong );
f2.setType( QMetaType::Type::LongLong );
f2.setTypeName( "serial8" );
fields.append( f2 );

80
tests/src/providers/testqgspostgresprovider.cpp
View File

@ -82,8 +82,8 @@ class TestQgsPostgresProvider: public QObject
void TestQgsPostgresProvider::decodeHstore()
{
const QVariant decoded = QgsPostgresProvider::convertValue( QVariant::Map, QVariant::String, QStringLiteral( "\"1\"=>\"2\", \"a\"=>\"b, \\\"c'\", \"backslash\"=>\"\\\\\"" ), QStringLiteral( "hstore" ), nullptr );
QCOMPARE( decoded.type(), QVariant::Map );
const QVariant decoded = QgsPostgresProvider::convertValue( QMetaType::Type::QVariantMap, QMetaType::Type::QString, QStringLiteral( "\"1\"=>\"2\", \"a\"=>\"b, \\\"c'\", \"backslash\"=>\"\\\\\"" ), QStringLiteral( "hstore" ), nullptr );
QCOMPARE( static_cast<QMetaType::Type>( decoded.userType() ), QMetaType::Type::QVariantMap );
QVariantMap expected;
expected[QStringLiteral( "1" )] = "2";
@ -95,8 +95,8 @@ void TestQgsPostgresProvider::decodeHstore()
void TestQgsPostgresProvider::decodeHstoreNoQuote()
{
const QVariant decoded = QgsPostgresProvider::convertValue( QVariant::Map, QVariant::String, QStringLiteral( "1=>2, a=>b c" ), QStringLiteral( "hstore" ), nullptr );
QCOMPARE( decoded.type(), QVariant::Map );
const QVariant decoded = QgsPostgresProvider::convertValue( QMetaType::Type::QVariantMap, QMetaType::Type::QString, QStringLiteral( "1=>2, a=>b c" ), QStringLiteral( "hstore" ), nullptr );
QCOMPARE( static_cast<QMetaType::Type>( decoded.userType() ), QMetaType::Type::QVariantMap );
QVariantMap expected;
expected[QStringLiteral( "1" )] = "2";
@ -107,8 +107,8 @@ void TestQgsPostgresProvider::decodeHstoreNoQuote()
void TestQgsPostgresProvider::decodeArray2StringList()
{
const QVariant decoded = QgsPostgresProvider::convertValue( QVariant::StringList, QVariant::String, QStringLiteral( "{\"1\",\"2\", \"a\\\\1\" , \"\\\\\",\"b, \\\"c'\"}" ), QStringLiteral( "hstore" ), nullptr );
QCOMPARE( decoded.type(), QVariant::StringList );
const QVariant decoded = QgsPostgresProvider::convertValue( QMetaType::Type::QStringList, QMetaType::Type::QString, QStringLiteral( "{\"1\",\"2\", \"a\\\\1\" , \"\\\\\",\"b, \\\"c'\"}" ), QStringLiteral( "hstore" ), nullptr );
QCOMPARE( static_cast<QMetaType::Type>( decoded.userType() ), QMetaType::Type::QStringList );
QStringList expected;
expected << QStringLiteral( "1" ) << QStringLiteral( "2" ) << QStringLiteral( "a\\1" ) << QStringLiteral( "\\" ) << QStringLiteral( "b, \"c'" );
@ -118,8 +118,8 @@ void TestQgsPostgresProvider::decodeArray2StringList()
void TestQgsPostgresProvider::decodeArray2StringListNoQuote()
{
const QVariant decoded = QgsPostgresProvider::convertValue( QVariant::StringList, QVariant::String, QStringLiteral( "{1,2, a ,b, c}" ), QStringLiteral( "hstore" ), nullptr );
QCOMPARE( decoded.type(), QVariant::StringList );
const QVariant decoded = QgsPostgresProvider::convertValue( QMetaType::Type::QStringList, QMetaType::Type::QString, QStringLiteral( "{1,2, a ,b, c}" ), QStringLiteral( "hstore" ), nullptr );
QCOMPARE( static_cast<QMetaType::Type>( decoded.userType() ), QMetaType::Type::QStringList );
QStringList expected;
expected << QStringLiteral( "1" ) << QStringLiteral( "2" ) << QStringLiteral( "a" ) << QStringLiteral( "b" ) << QStringLiteral( "c" );
@ -129,8 +129,8 @@ void TestQgsPostgresProvider::decodeArray2StringListNoQuote()
void TestQgsPostgresProvider::decodeArray2IntList()
{
const QVariant decoded = QgsPostgresProvider::convertValue( QVariant::StringList, QVariant::String, QStringLiteral( "{1, 2, 3,-5,10}" ), QStringLiteral( "hstore" ), nullptr );
QCOMPARE( decoded.type(), QVariant::StringList );
const QVariant decoded = QgsPostgresProvider::convertValue( QMetaType::Type::QStringList, QMetaType::Type::QString, QStringLiteral( "{1, 2, 3,-5,10}" ), QStringLiteral( "hstore" ), nullptr );
QCOMPARE( static_cast<QMetaType::Type>( decoded.userType() ), QMetaType::Type::QStringList );
QVariantList expected;
expected << QVariant( 1 ) << QVariant( 2 ) << QVariant( 3 ) << QVariant( -5 ) << QVariant( 10 );
@ -140,8 +140,8 @@ void TestQgsPostgresProvider::decodeArray2IntList()
void TestQgsPostgresProvider::decode2DimensionArray()
{
const QVariant decoded = QgsPostgresProvider::convertValue( QVariant::StringList, QVariant::String, QStringLiteral( "{{foo,\"escape bracket \\}\"},{\"escape bracket and backslash \\\\\\}\",\"hello bar\"}}" ), QStringLiteral( "_text" ), nullptr );
QCOMPARE( decoded.type(), QVariant::StringList );
const QVariant decoded = QgsPostgresProvider::convertValue( QMetaType::Type::QStringList, QMetaType::Type::QString, QStringLiteral( "{{foo,\"escape bracket \\}\"},{\"escape bracket and backslash \\\\\\}\",\"hello bar\"}}" ), QStringLiteral( "_text" ), nullptr );
QCOMPARE( static_cast<QMetaType::Type>( decoded.userType() ), QMetaType::Type::QStringList );
QVariantList expected;
expected << QVariant( "{foo,\"escape bracket \\}\"}" ) << QVariant( "{\"escape bracket and backslash \\\\\\}\",\"hello bar\"}" );
@ -151,8 +151,8 @@ void TestQgsPostgresProvider::decode2DimensionArray()
void TestQgsPostgresProvider::decode3DimensionArray()
{
const QVariant decoded = QgsPostgresProvider::convertValue( QVariant::StringList, QVariant::String, QStringLiteral( "{{{0,1},{1,2}},{{3,4},{5,6}}}" ), QStringLiteral( "_integer" ), nullptr );
QCOMPARE( decoded.type(), QVariant::StringList );
const QVariant decoded = QgsPostgresProvider::convertValue( QMetaType::Type::QStringList, QMetaType::Type::QString, QStringLiteral( "{{{0,1},{1,2}},{{3,4},{5,6}}}" ), QStringLiteral( "_integer" ), nullptr );
QCOMPARE( static_cast<QMetaType::Type>( decoded.userType() ), QMetaType::Type::QStringList );
QVariantList expected;
expected << QVariant( "{{0,1},{1,2}}" ) << QVariant( "{{3,4},{5,6}}" );
@ -162,8 +162,8 @@ void TestQgsPostgresProvider::decode3DimensionArray()
void TestQgsPostgresProvider::decodeJsonList()
{
const QVariant decoded = QgsPostgresProvider::convertValue( QVariant::Map, QVariant::String, QStringLiteral( "[1,2,3]" ), QStringLiteral( "json" ), nullptr );
QCOMPARE( decoded.type(), QVariant::List );
const QVariant decoded = QgsPostgresProvider::convertValue( QMetaType::Type::QVariantMap, QMetaType::Type::QString, QStringLiteral( "[1,2,3]" ), QStringLiteral( "json" ), nullptr );
QCOMPARE( static_cast<QMetaType::Type>( decoded.userType() ), QMetaType::Type::QVariantList );
QVariantList expected;
expected.append( 1 );
@ -175,8 +175,8 @@ void TestQgsPostgresProvider::decodeJsonList()
void TestQgsPostgresProvider::decodeJsonbList()
{
const QVariant decoded = QgsPostgresProvider::convertValue( QVariant::Map, QVariant::String, QStringLiteral( "[1,2,3]" ), QStringLiteral( "jsonb" ), nullptr );
QCOMPARE( decoded.type(), QVariant::List );
const QVariant decoded = QgsPostgresProvider::convertValue( QMetaType::Type::QVariantMap, QMetaType::Type::QString, QStringLiteral( "[1,2,3]" ), QStringLiteral( "jsonb" ), nullptr );
QCOMPARE( static_cast<QMetaType::Type>( decoded.userType() ), QMetaType::Type::QVariantList );
QVariantList expected;
expected.append( 1 );
@ -188,8 +188,8 @@ void TestQgsPostgresProvider::decodeJsonbList()
void TestQgsPostgresProvider::decodeJsonMap()
{
const QVariant decoded = QgsPostgresProvider::convertValue( QVariant::Map, QVariant::String, QStringLiteral( "{\"a\":1,\"b\":2}" ), QStringLiteral( "json" ), nullptr );
QCOMPARE( decoded.type(), QVariant::Map );
const QVariant decoded = QgsPostgresProvider::convertValue( QMetaType::Type::QVariantMap, QMetaType::Type::QString, QStringLiteral( "{\"a\":1,\"b\":2}" ), QStringLiteral( "json" ), nullptr );
QCOMPARE( static_cast<QMetaType::Type>( decoded.userType() ), QMetaType::Type::QVariantMap );
QVariantMap expected;
expected[QStringLiteral( "a" )] = "1";
@ -200,8 +200,8 @@ void TestQgsPostgresProvider::decodeJsonMap()
void TestQgsPostgresProvider::decodeJsonbMap()
{
const QVariant decoded = QgsPostgresProvider::convertValue( QVariant::Map, QVariant::String, QStringLiteral( "{\"a\":1,\"b\":2}" ), QStringLiteral( "jsonb" ), nullptr );
QCOMPARE( decoded.type(), QVariant::Map );
const QVariant decoded = QgsPostgresProvider::convertValue( QMetaType::Type::QVariantMap, QMetaType::Type::QString, QStringLiteral( "{\"a\":1,\"b\":2}" ), QStringLiteral( "jsonb" ), nullptr );
QCOMPARE( static_cast<QMetaType::Type>( decoded.userType() ), QMetaType::Type::QVariantMap );
QVariantMap expected;
expected[QStringLiteral( "a" )] = "1";
@ -215,20 +215,20 @@ void TestQgsPostgresProvider::testDecodeDateTimes()
QVariant decoded;
decoded = QgsPostgresProvider::convertValue( QVariant::DateTime, QVariant::Invalid, QStringLiteral( "2020-06-08 18:30:35.496438+02" ), QStringLiteral( "timestamptz" ), nullptr );
QCOMPARE( decoded.type(), QVariant::DateTime );
decoded = QgsPostgresProvider::convertValue( QMetaType::Type::QDateTime, QMetaType::Type::UnknownType, QStringLiteral( "2020-06-08 18:30:35.496438+02" ), QStringLiteral( "timestamptz" ), nullptr );
QCOMPARE( static_cast<QMetaType::Type>( decoded.userType() ), QMetaType::Type::QDateTime );
decoded = QgsPostgresProvider::convertValue( QVariant::Time, QVariant::Invalid, QStringLiteral( "18:29:27.569401+02" ), QStringLiteral( "timetz" ), nullptr );
QCOMPARE( decoded.type(), QVariant::Time );
decoded = QgsPostgresProvider::convertValue( QMetaType::Type::QTime, QMetaType::Type::UnknownType, QStringLiteral( "18:29:27.569401+02" ), QStringLiteral( "timetz" ), nullptr );
QCOMPARE( static_cast<QMetaType::Type>( decoded.userType() ), QMetaType::Type::QTime );
decoded = QgsPostgresProvider::convertValue( QVariant::Date, QVariant::Invalid, QStringLiteral( "2020-06-08" ), QStringLiteral( "date" ), nullptr );
QCOMPARE( decoded.type(), QVariant::Date );
decoded = QgsPostgresProvider::convertValue( QMetaType::Type::QDate, QMetaType::Type::UnknownType, QStringLiteral( "2020-06-08" ), QStringLiteral( "date" ), nullptr );
QCOMPARE( static_cast<QMetaType::Type>( decoded.userType() ), QMetaType::Type::QDate );
decoded = QgsPostgresProvider::convertValue( QVariant::DateTime, QVariant::Invalid, QStringLiteral( "2020-06-08 18:30:35.496438" ), QStringLiteral( "timestamp" ), nullptr );
QCOMPARE( decoded.type(), QVariant::DateTime );
decoded = QgsPostgresProvider::convertValue( QMetaType::Type::QDateTime, QMetaType::Type::UnknownType, QStringLiteral( "2020-06-08 18:30:35.496438" ), QStringLiteral( "timestamp" ), nullptr );
QCOMPARE( static_cast<QMetaType::Type>( decoded.userType() ), QMetaType::Type::QDateTime );
decoded = QgsPostgresProvider::convertValue( QVariant::Time, QVariant::Invalid, QStringLiteral( "18:29:27.569401" ), QStringLiteral( "time" ), nullptr );
QCOMPARE( decoded.type(), QVariant::Time );
decoded = QgsPostgresProvider::convertValue( QMetaType::Type::QTime, QMetaType::Type::UnknownType, QStringLiteral( "18:29:27.569401" ), QStringLiteral( "time" ), nullptr );
QCOMPARE( static_cast<QMetaType::Type>( decoded.userType() ), QMetaType::Type::QTime );
}
@ -244,7 +244,7 @@ void TestQgsPostgresProvider::testQuotedValueBigInt()
// 4 byte integer
f0.setName( "fld_integer" );
f0.setType( QVariant::Int );
f0.setType( QMetaType::Type::Int );
f0.setTypeName( "int4" );
fields.append( f0 );
@ -258,7 +258,7 @@ void TestQgsPostgresProvider::testQuotedValueBigInt()
// 8 byte integer
f1.setName( "fld_bigint" );
f1.setType( QVariant::LongLong );
f1.setType( QMetaType::Type::LongLong );
f1.setTypeName( "int8" );
fields.clear();
@ -276,7 +276,7 @@ void TestQgsPostgresProvider::testQuotedValueBigInt()
// double
f2.setName( "fld_double" );
f2.setType( QVariant::Double );
f2.setType( QMetaType::Type::Double );
f2.setTypeName( "float8" );
fields.clear();
@ -294,7 +294,7 @@ void TestQgsPostgresProvider::testQuotedValueBigInt()
// text
f3.setName( "fld_text" );
f3.setType( QVariant::String );
f3.setType( QMetaType::Type::QString );
f3.setTypeName( "text" );
fields.clear();
@ -377,7 +377,7 @@ void TestQgsPostgresProvider::testWhereClauseFids()
// 4 byte integer -> IN clause
f0.setName( "fld" );
f0.setType( QVariant::Int );
f0.setType( QMetaType::Type::Int );
f0.setTypeName( "int4" );
// for positive integers, fid == the value, there is no map.
@ -392,7 +392,7 @@ void TestQgsPostgresProvider::testWhereClauseFids()
// 8 byte integer -> IN clause
f1.setName( "fld" );
f1.setType( QVariant::LongLong );
f1.setType( QMetaType::Type::LongLong );
f1.setTypeName( "int8" );
fields.clear();
@ -410,7 +410,7 @@ void TestQgsPostgresProvider::testWhereClauseFids()
// double -> OR clause
f2.setName( "fld" );
f2.setType( QVariant::Double );
f2.setType( QMetaType::Type::Double );
f2.setTypeName( "float8" );
fields.clear();
@ -428,7 +428,7 @@ void TestQgsPostgresProvider::testWhereClauseFids()
// text -> IN clause
f3.setName( "fld" );
f3.setType( QVariant::String );
f3.setType( QMetaType::Type::QString );
f3.setTypeName( "text" );
fields.clear();

16
tests/src/server/testqgsserverquerystringparameter.cpp
View File

@ -94,10 +94,10 @@ void TestQgsServerQueryStringParameter::testArguments()
// Test string (default)
request.setUrl( QStringLiteral( "http://www.qgis.org/api/?parameter1=123" ) );
QCOMPARE( p.value( ctx ).toString(), QString( "123" ) );
QCOMPARE( p.value( ctx ).type(), QVariant::String );
QCOMPARE( static_cast<QMetaType::Type>( p.value( ctx ).userType() ), QMetaType::Type::QString );
request.setUrl( QStringLiteral( "http://www.qgis.org/api/?parameter1=a%20string" ) );
QCOMPARE( p.value( ctx ).toString(), QString( "a string" ) );
QCOMPARE( p.value( ctx ).type(), QVariant::String );
QCOMPARE( static_cast<QMetaType::Type>( p.value( ctx ).userType() ), QMetaType::Type::QString );
request.setUrl( QStringLiteral( "http://www.qgis.org/api/" ) );
QCOMPARE( p.value( ctx ).toString(), QString() );
@ -110,7 +110,7 @@ void TestQgsServerQueryStringParameter::testArguments()
p.mType = QgsServerQueryStringParameter::Type::Integer;
request.setUrl( QStringLiteral( "http://www.qgis.org/api/?parameter1=123" ) );
QCOMPARE( p.value( ctx ).toInt(), 123 );
QCOMPARE( p.value( ctx ).type(), QVariant::LongLong );
QCOMPARE( static_cast<QMetaType::Type>( p.value( ctx ).userType() ), QMetaType::Type::LongLong );
request.setUrl( QStringLiteral( "http://www.qgis.org/api/?parameter1=a%20string" ) );
QVERIFY_EXCEPTION_THROWN( p.value( ctx ), QgsServerApiBadRequestException );
@ -118,10 +118,10 @@ void TestQgsServerQueryStringParameter::testArguments()
p.mType = QgsServerQueryStringParameter::Type::Double;
request.setUrl( QStringLiteral( "http://www.qgis.org/api/?parameter1=123" ) );
QCOMPARE( p.value( ctx ).toDouble(), 123.0 );
QCOMPARE( p.value( ctx ).type(), QVariant::Double );
QCOMPARE( static_cast<QMetaType::Type>( p.value( ctx ).userType() ), QMetaType::Type::Double );
request.setUrl( QStringLiteral( "http://www.qgis.org/api/?parameter1=123.456" ) );
QCOMPARE( p.value( ctx ).toDouble(), 123.456 );
QCOMPARE( p.value( ctx ).type(), QVariant::Double );
QCOMPARE( static_cast<QMetaType::Type>( p.value( ctx ).userType() ), QMetaType::Type::Double );
request.setUrl( QStringLiteral( "http://www.qgis.org/api/?parameter1=a%20string" ) );
QVERIFY_EXCEPTION_THROWN( p.value( ctx ), QgsServerApiBadRequestException );
QCOMPARE( QString::fromStdString( p.data()["schema"]["type"] ), QString( "number" ) );
@ -130,10 +130,10 @@ void TestQgsServerQueryStringParameter::testArguments()
p.mType = QgsServerQueryStringParameter::Type::List;
request.setUrl( QStringLiteral( "http://www.qgis.org/api/?parameter1=123,a%20value" ) );
QCOMPARE( p.value( ctx ).toStringList(), QStringList() << QStringLiteral( "123" ) << QStringLiteral( "a value" ) );
QCOMPARE( p.value( ctx ).type(), QVariant::StringList );
QCOMPARE( static_cast<QMetaType::Type>( p.value( ctx ).userType() ), QMetaType::Type::QStringList );
request.setUrl( QStringLiteral( "http://www.qgis.org/api/?parameter1=a%20value" ) );
QCOMPARE( p.value( ctx ).toStringList(), QStringList() << QStringLiteral( "a value" ) );
QCOMPARE( p.value( ctx ).type(), QVariant::StringList );
QCOMPARE( static_cast<QMetaType::Type>( p.value( ctx ).userType() ), QMetaType::Type::QStringList );
}
@ -159,7 +159,7 @@ void TestQgsServerQueryStringParameter::testCustomValidators()
request.setUrl( QStringLiteral( "http://www.qgis.org/api/?parameter1=501" ) );
QCOMPARE( p.value( ctx ).toInt(), 502 );
QCOMPARE( p.value( ctx ).type(), QVariant::LongLong );
QCOMPARE( static_cast<QMetaType::Type>( p.value( ctx ).userType() ), QMetaType::Type::LongLong );
}