diff --git a/tests/bench/qgsbench.cpp b/tests/bench/qgsbench.cpp
index 9d4606366ad..090b9ef80b6 100644
--- a/tests/bench/qgsbench.cpp
+++ b/tests/bench/qgsbench.cpp
@@ -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() ) );
diff --git a/tests/src/analysis/testqgsinterpolator.cpp b/tests/src/analysis/testqgsinterpolator.cpp
index a8c49fe29ae..a38e45cff87 100644
--- a/tests/src/analysis/testqgsinterpolator.cpp
+++ b/tests/src/analysis/testqgsinterpolator.cpp
@@ -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 ) );
diff --git a/tests/src/analysis/testqgsprocessing.cpp b/tests/src/analysis/testqgsprocessing.cpp
index cff5ad9fd0e..88d81d52717 100644
--- a/tests/src/analysis/testqgsprocessing.cpp
+++ b/tests/src/analysis/testqgsprocessing.cpp
@@ -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 );
diff --git a/tests/src/app/testqgisappclipboard.cpp b/tests/src/app/testqgisappclipboard.cpp
index ab71a075c33..464bca5cfe5 100644
--- a/tests/src/app/testqgisappclipboard.cpp
+++ b/tests/src/app/testqgisappclipboard.cpp
@@ -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" ) );
diff --git a/tests/src/app/testqgsmergeattributesdialog.cpp b/tests/src/app/testqgsmergeattributesdialog.cpp
index 1d89bf26c95..f1de2bfa8d6 100644
--- a/tests/src/app/testqgsmergeattributesdialog.cpp
+++ b/tests/src/app/testqgsmergeattributesdialog.cpp
@@ -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 }
                ) );
diff --git a/tests/src/core/testqgis.cpp b/tests/src/core/testqgis.cpp
index fe8852f1916..32fcd444fd0 100644
--- a/tests/src/core/testqgis.cpp
+++ b/tests/src/core/testqgis.cpp
@@ -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()
diff --git a/tests/src/core/testqgsarcgisrestutils.cpp b/tests/src/core/testqgsarcgisrestutils.cpp
index 0e803c999cc..7c7cc724d5b 100644
--- a/tests/src/core/testqgsarcgisrestutils.cpp
+++ b/tests/src/core/testqgsarcgisrestutils.cpp
@@ -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()
diff --git a/tests/src/core/testqgsauthmanager.cpp b/tests/src/core/testqgsauthmanager.cpp
index 2e570632774..80104ff8ce5 100644
--- a/tests/src/core/testqgsauthmanager.cpp
+++ b/tests/src/core/testqgsauthmanager.cpp
@@ -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() );
 }
 
diff --git a/tests/src/core/testqgsdxfexport.cpp b/tests/src/core/testqgsdxfexport.cpp
index a237cfaffac..70ae8f0a3b0 100644
--- a/tests/src/core/testqgsdxfexport.cpp
+++ b/tests/src/core/testqgsdxfexport.cpp
@@ -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" );
diff --git a/tests/src/core/testqgsexpression.cpp b/tests/src/core/testqgsexpression.cpp
index 8cc813b2c43..807293e467b 100644
--- a/tests/src/core/testqgsexpression.cpp
+++ b/tests/src/core/testqgsexpression.cpp
@@ -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 );
diff --git a/tests/src/core/testqgsexpressioncontext.cpp b/tests/src/core/testqgsexpressioncontext.cpp
index 51785e0b489..9191c319055 100644
--- a/tests/src/core/testqgsexpressioncontext.cpp
+++ b/tests/src/core/testqgsexpressioncontext.cpp
@@ -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 );
diff --git a/tests/src/core/testqgsfeature.cpp b/tests/src/core/testqgsfeature.cpp
index d9cc55f1e47..f7196540b0f 100644
--- a/tests/src/core/testqgsfeature.cpp
+++ b/tests/src/core/testqgsfeature.cpp
@@ -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 );
diff --git a/tests/src/core/testqgsfield.cpp b/tests/src/core/testqgsfield.cpp
index d596e7f3057..79b0f8a9ac1 100644
--- a/tests/src/core/testqgsfield.cpp
+++ b/tests/src/core/testqgsfield.cpp
@@ -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" )} );
diff --git a/tests/src/core/testqgsfields.cpp b/tests/src/core/testqgsfields.cpp
index 80baed7858d..208e33bfe55 100644
--- a/tests/src/core/testqgsfields.cpp
+++ b/tests/src/core/testqgsfields.cpp
@@ -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 );
 
diff --git a/tests/src/core/testqgsgeopdfexport.cpp b/tests/src/core/testqgsgeopdfexport.cpp
index d70ae13005c..4aecb990b75 100644
--- a/tests/src/core/testqgsgeopdfexport.cpp
+++ b/tests/src/core/testqgsgeopdfexport.cpp
@@ -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 );
diff --git a/tests/src/core/testqgsgml.cpp b/tests/src/core/testqgsgml.cpp
index 9b95a3beda9..e823824e137 100644
--- a/tests/src/core/testqgsgml.cpp
+++ b/tests/src/core/testqgsgml.cpp
@@ -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 );
 
diff --git a/tests/src/core/testqgsjsonutils.cpp b/tests/src/core/testqgsjsonutils.cpp
index 4c36ba775be..00f023e907b 100644
--- a/tests/src/core/testqgsjsonutils.cpp
+++ b/tests/src/core/testqgsjsonutils.cpp
@@ -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 );
 }
 
 
diff --git a/tests/src/core/testqgslayouttable.cpp b/tests/src/core/testqgslayouttable.cpp
index 0a8a514e6b7..c6dc6bac2b8 100644
--- a/tests/src/core/testqgslayouttable.cpp
+++ b/tests/src/core/testqgslayouttable.cpp
@@ -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() );
diff --git a/tests/src/core/testqgslegendrenderer.cpp b/tests/src/core/testqgslegendrenderer.cpp
index 788de1810fb..953a1ab91af 100644
--- a/tests/src/core/testqgslegendrenderer.cpp
+++ b/tests/src/core/testqgslegendrenderer.cpp
@@ -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;
diff --git a/tests/src/core/testqgsmaprendererjob.cpp b/tests/src/core/testqgsmaprendererjob.cpp
index 66f637435bb..7c646fae454 100644
--- a/tests/src/core/testqgsmaprendererjob.cpp
+++ b/tests/src/core/testqgsmaprendererjob.cpp
@@ -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() );
   //
diff --git a/tests/src/core/testqgsogcutils.cpp b/tests/src/core/testqgsogcutils.cpp
index 2bfcf26b8ca..4dec2fee4ab 100644
--- a/tests/src/core/testqgsogcutils.cpp
+++ b/tests/src/core/testqgsogcutils.cpp
@@ -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 );
diff --git a/tests/src/core/testqgsogrutils.cpp b/tests/src/core/testqgsogrutils.cpp
index 0a28627d222..93d9429d9e7 100644
--- a/tests/src/core/testqgsogrutils.cpp
+++ b/tests/src/core/testqgsogrutils.cpp
@@ -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" ),
diff --git a/tests/src/core/testqgspointcloudattribute.cpp b/tests/src/core/testqgspointcloudattribute.cpp
index b4a41c99685..244292930cc 100644
--- a/tests/src/core/testqgspointcloudattribute.cpp
+++ b/tests/src/core/testqgspointcloudattribute.cpp
@@ -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 )
diff --git a/tests/src/core/testqgsprojectstorage.cpp b/tests/src/core/testqgsprojectstorage.cpp
index 24f51510ae6..d8e186b4adb 100644
--- a/tests/src/core/testqgsprojectstorage.cpp
+++ b/tests/src/core/testqgsprojectstorage.cpp
@@ -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 );
diff --git a/tests/src/core/testqgsproperty.cpp b/tests/src/core/testqgsproperty.cpp
index 6e4530d9c4d..afa379d8c01 100644
--- a/tests/src/core/testqgsproperty.cpp
+++ b/tests/src/core/testqgsproperty.cpp
@@ -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 );
diff --git a/tests/src/core/testqgsrulebasedrenderer.cpp b/tests/src/core/testqgsrulebasedrenderer.cpp
index 780acba03ff..3e35d356f76 100644
--- a/tests/src/core/testqgsrulebasedrenderer.cpp
+++ b/tests/src/core/testqgsrulebasedrenderer.cpp
@@ -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;
diff --git a/tests/src/core/testqgsstatisticalsummary.cpp b/tests/src/core/testqgsstatisticalsummary.cpp
index ac5cdcb4248..a21eac7adcb 100644
--- a/tests/src/core/testqgsstatisticalsummary.cpp
+++ b/tests/src/core/testqgsstatisticalsummary.cpp
@@ -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();
diff --git a/tests/src/core/testqgsvectordataprovider.cpp b/tests/src/core/testqgsvectordataprovider.cpp
index 15845e97c9a..4da1faece61 100644
--- a/tests/src/core/testqgsvectordataprovider.cpp
+++ b/tests/src/core/testqgsvectordataprovider.cpp
@@ -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 )
diff --git a/tests/src/core/testqgsvectorfilewriter.cpp b/tests/src/core/testqgsvectorfilewriter.cpp
index 89172769cc7..0f8838208bf 100644
--- a/tests/src/core/testqgsvectorfilewriter.cpp
+++ b/tests/src/core/testqgsvectorfilewriter.cpp
@@ -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" );
diff --git a/tests/src/core/testqgsvectorlayer.cpp b/tests/src/core/testqgsvectorlayer.cpp
index 5d290ad6dfa..1a3b9c1ecfd 100644
--- a/tests/src/core/testqgsvectorlayer.cpp
+++ b/tests/src/core/testqgsvectorlayer.cpp
@@ -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" ) );
diff --git a/tests/src/core/testqgsvectorlayercache.cpp b/tests/src/core/testqgsvectorlayercache.cpp
index 4e9a054b481..14f889146db 100644
--- a/tests/src/core/testqgsvectorlayercache.cpp
+++ b/tests/src/core/testqgsvectorlayercache.cpp
@@ -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();
 
diff --git a/tests/src/core/testqgsvectorlayerjoinbuffer.cpp b/tests/src/core/testqgsvectorlayerjoinbuffer.cpp
index c342ddb33f0..4bad15a8a59 100644
--- a/tests/src/core/testqgsvectorlayerjoinbuffer.cpp
+++ b/tests/src/core/testqgsvectorlayerjoinbuffer.cpp
@@ -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 );
 
diff --git a/tests/src/core/testqgsvectortilewriter.cpp b/tests/src/core/testqgsvectortilewriter.cpp
index f6f8dba613b..54a9115f9ef 100644
--- a/tests/src/core/testqgsvectortilewriter.cpp
+++ b/tests/src/core/testqgsvectortilewriter.cpp
@@ -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();
diff --git a/tests/src/geometry_checker/testqgsgeometrychecks.cpp b/tests/src/geometry_checker/testqgsgeometrychecks.cpp
index 3ac984bc408..713bc18463a 100644
--- a/tests/src/geometry_checker/testqgsgeometrychecks.cpp
+++ b/tests/src/geometry_checker/testqgsgeometrychecks.cpp
@@ -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 ) )
         {
diff --git a/tests/src/gui/testprocessinggui.cpp b/tests/src/gui/testprocessinggui.cpp
index 5f65ea40751..8be1fdfceca 100644
--- a/tests/src/gui/testprocessinggui.cpp
+++ b/tests/src/gui/testprocessinggui.cpp
@@ -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 );
diff --git a/tests/src/gui/testqgsattributeform.cpp b/tests/src/gui/testqgsattributeform.cpp
index e830b8046ef..805b27ab30a 100644
--- a/tests/src/gui/testqgsattributeform.cpp
+++ b/tests/src/gui/testqgsattributeform.cpp
@@ -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" ) );
diff --git a/tests/src/gui/testqgsdatetimeedit.cpp b/tests/src/gui/testqgsdatetimeedit.cpp
index 2f064913cde..d0ed46abbe7 100644
--- a/tests/src/gui/testqgsdatetimeedit.cpp
+++ b/tests/src/gui/testqgsdatetimeedit.cpp
@@ -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() );
diff --git a/tests/src/gui/testqgsexternalresourcewidgetwrapper.cpp b/tests/src/gui/testqgsexternalresourcewidgetwrapper.cpp
index 0ba65d767e5..da77f862bee 100644
--- a/tests/src/gui/testqgsexternalresourcewidgetwrapper.cpp
+++ b/tests/src/gui/testqgsexternalresourcewidgetwrapper.cpp
@@ -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;
diff --git a/tests/src/gui/testqgsexternalstoragefilewidget.cpp b/tests/src/gui/testqgsexternalstoragefilewidget.cpp
index 6ab5456a4a6..8df49b31c75 100644
--- a/tests/src/gui/testqgsexternalstoragefilewidget.cpp
+++ b/tests/src/gui/testqgsexternalstoragefilewidget.cpp
@@ -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" ) );
diff --git a/tests/src/gui/testqgsfeaturelistcombobox.cpp b/tests/src/gui/testqgsfeaturelistcombobox.cpp
index dd0e6a2ce4c..bb89a5438f9 100644
--- a/tests/src/gui/testqgsfeaturelistcombobox.cpp
+++ b/tests/src/gui/testqgsfeaturelistcombobox.cpp
@@ -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()
diff --git a/tests/src/gui/testqgsfieldexpressionwidget.cpp b/tests/src/gui/testqgsfieldexpressionwidget.cpp
index da604d555a2..c9639dcd241 100644
--- a/tests/src/gui/testqgsfieldexpressionwidget.cpp
+++ b/tests/src/gui/testqgsfieldexpressionwidget.cpp
@@ -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 );
 
diff --git a/tests/src/gui/testqgskeyvaluewidget.cpp b/tests/src/gui/testqgskeyvaluewidget.cpp
index e7e1a4a53f3..5d7c2f036ee 100644
--- a/tests/src/gui/testqgskeyvaluewidget.cpp
+++ b/tests/src/gui/testqgskeyvaluewidget.cpp
@@ -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 );
diff --git a/tests/src/gui/testqgslistwidget.cpp b/tests/src/gui/testqgslistwidget.cpp
index dcdd32e33ce..8c1f0ae1caf 100644
--- a/tests/src/gui/testqgslistwidget.cpp
+++ b/tests/src/gui/testqgslistwidget.cpp
@@ -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() );
diff --git a/tests/src/gui/testqgsrangewidgetwrapper.cpp b/tests/src/gui/testqgsrangewidgetwrapper.cpp
index fd0ea37e7ab..7f2e677ab76 100644
--- a/tests/src/gui/testqgsrangewidgetwrapper.cpp
+++ b/tests/src/gui/testqgsrangewidgetwrapper.cpp
@@ -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() );
diff --git a/tests/src/gui/testqgsrelationreferencewidget.cpp b/tests/src/gui/testqgsrelationreferencewidget.cpp
index 7e34ed64918..0bb816792c9 100644
--- a/tests/src/gui/testqgsrelationreferencewidget.cpp
+++ b/tests/src/gui/testqgsrelationreferencewidget.cpp
@@ -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" ) );
diff --git a/tests/src/gui/testqgsvaluerelationwidgetwrapper.cpp b/tests/src/gui/testqgsvaluerelationwidgetwrapper.cpp
index c4a16968cc8..27da5a85391 100644
--- a/tests/src/gui/testqgsvaluerelationwidgetwrapper.cpp
+++ b/tests/src/gui/testqgsvaluerelationwidgetwrapper.cpp
@@ -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 );
 
diff --git a/tests/src/providers/testqgspostgresconn.cpp b/tests/src/providers/testqgspostgresconn.cpp
index d10496b5f9b..c02c687c8e2 100644
--- a/tests/src/providers/testqgspostgresconn.cpp
+++ b/tests/src/providers/testqgspostgresconn.cpp
@@ -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 );
 
diff --git a/tests/src/providers/testqgspostgresprovider.cpp b/tests/src/providers/testqgspostgresprovider.cpp
index 6420d494423..2ed06d71d2d 100644
--- a/tests/src/providers/testqgspostgresprovider.cpp
+++ b/tests/src/providers/testqgspostgresprovider.cpp
@@ -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();
diff --git a/tests/src/server/testqgsserverquerystringparameter.cpp b/tests/src/server/testqgsserverquerystringparameter.cpp
index 6abbc2e160c..78aad721648 100644
--- a/tests/src/server/testqgsserverquerystringparameter.cpp
+++ b/tests/src/server/testqgsserverquerystringparameter.cpp
@@ -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 );
 
 }