QStringList Statistics::ranking(QString key){
QMultiMap<quint64, QString> *map = this->_rankings.value(key);
QStringList rankedList;
QList<quint64> keys = map->keys();
for(int i = keys.length()-1; i >= 0;--i){
rankedList.append(map->value(keys.at(i)));
}
return rankedList;
}
void AutoTestUnitTests::testCodeParserGTest()
{
if (qgetenv("GOOGLETEST_DIR").isEmpty())
QSKIP("This test needs googletest - set GOOGLETEST_DIR (point to googletest repository)");
QFETCH(QString, projectFilePath);
CppTools::Tests::ProjectOpenerAndCloser projectManager;
CppTools::ProjectInfo projectInfo = projectManager.open(projectFilePath, true);
QVERIFY(projectInfo.isValid());
QSignalSpy parserSpy(m_model->parser(), SIGNAL(parsingFinished()));
QSignalSpy modelUpdateSpy(m_model, SIGNAL(sweepingDone()));
QVERIFY(parserSpy.wait(20000));
QVERIFY(modelUpdateSpy.wait());
QCOMPARE(m_model->gtestNamesCount(), 7);
QMultiMap<QString, int> expectedNamesAndSets;
expectedNamesAndSets.insert(QStringLiteral("FactorialTest"), 3);
expectedNamesAndSets.insert(QStringLiteral("FactorialTest_Iterative"), 2);
expectedNamesAndSets.insert(QStringLiteral("Sum"), 2);
expectedNamesAndSets.insert(QStringLiteral("QueueTest"), 2);
expectedNamesAndSets.insert(QStringLiteral("DummyTest"), 1); // used as parameterized test
expectedNamesAndSets.insert(QStringLiteral("DummyTest"), 1); // used as 'normal' test
expectedNamesAndSets.insert(QStringLiteral("NamespaceTest"), 1);
QMultiMap<QString, int> foundNamesAndSets = m_model->gtestNamesAndSets();
QCOMPARE(expectedNamesAndSets.size(), foundNamesAndSets.size());
foreach (const QString &name, expectedNamesAndSets.keys())
QCOMPARE(expectedNamesAndSets.values(name), foundNamesAndSets.values(name));
// check also that no Qt related tests have been found
QCOMPARE(m_model->autoTestsCount(), 0);
QCOMPARE(m_model->namedQuickTestsCount(), 0);
QCOMPARE(m_model->unnamedQuickTestsCount(), 0);
QCOMPARE(m_model->dataTagsCount(), 0);
}
void AutoTestUnitTests::testCodeParserGTest()
{
if (qgetenv("GOOGLETEST_DIR").isEmpty())
QSKIP("This test needs googletest - set GOOGLETEST_DIR (point to googletest repository)");
NavigationWidget *navigation = NavigationWidget::instance();
navigation->activateSubWidget(Constants::AUTOTEST_ID);
CppTools::Tests::ProjectOpenerAndCloser projectManager;
CppTools::ProjectInfo projectInfo = projectManager.open(
QString(m_tmpDir->path() + QLatin1String("/simple_gt/simple_gt.pro")), true);
QVERIFY(projectInfo.isValid());
QSignalSpy parserSpy(m_model->parser(), SIGNAL(parsingFinished()));
QVERIFY(parserSpy.wait(20000));
QCOMPARE(m_model->gtestNamesCount(), 6);
QMultiMap<QString, int> expectedNamesAndSets;
expectedNamesAndSets.insert(QStringLiteral("FactorialTest"), 3);
expectedNamesAndSets.insert(QStringLiteral("FactorialTest_Iterative"), 2);
expectedNamesAndSets.insert(QStringLiteral("Sum"), 2);
expectedNamesAndSets.insert(QStringLiteral("QueueTest"), 2);
expectedNamesAndSets.insert(QStringLiteral("DummyTest"), 1); // used as parameterized test
expectedNamesAndSets.insert(QStringLiteral("DummyTest"), 1); // used as 'normal' test
QMultiMap<QString, int> foundNamesAndSets = m_model->gtestNamesAndSets();
QCOMPARE(expectedNamesAndSets.size(), foundNamesAndSets.size());
foreach (const QString &name, expectedNamesAndSets.keys())
QCOMPARE(expectedNamesAndSets.values(name), foundNamesAndSets.values(name));
// check also that no Qt related tests have been found
QCOMPARE(m_model->autoTestsCount(), 0);
QCOMPARE(m_model->namedQuickTestsCount(), 0);
QCOMPARE(m_model->unnamedQuickTestsCount(), 0);
QCOMPARE(m_model->dataTagsCount(), 0);
}
const QMultiMap<QString, GBFeatureKey>& GBFeatureUtils::getKeyGroups() {
QMutexLocker locker(&getKeyGroups_mutex);
static QMultiMap<QString, GBFeatureKey> groups;
if (groups.isEmpty()) {
QString genes = QObject::tr("Genes");
groups.insert(genes, GBFeatureKey_CDS);
groups.insert(genes, GBFeatureKey_exon);
groups.insert(genes, GBFeatureKey_gene);
groups.insert(genes, GBFeatureKey_intron);
groups.insert(genes, GBFeatureKey_mRNA);
groups.insert(genes, GBFeatureKey_polyA_site);
groups.insert(genes, GBFeatureKey_precursor_RNA);
groups.insert(genes, GBFeatureKey_prim_transcript);
groups.insert(genes, GBFeatureKey_promoter);
groups.insert(genes, GBFeatureKey_3_clip);
groups.insert(genes, GBFeatureKey_3_UTR);
groups.insert(genes, GBFeatureKey_5_clip);
groups.insert(genes, GBFeatureKey_5_UTR);
QString signls = QObject::tr("Signals");
groups.insert(signls, GBFeatureKey_attenuator);
groups.insert(signls, GBFeatureKey_CAAT_signal);
groups.insert(signls, GBFeatureKey_GC_signal);
groups.insert(signls, GBFeatureKey_enhancer);
groups.insert(signls, GBFeatureKey_mat_peptide);
groups.insert(signls, GBFeatureKey_misc_signal);
groups.insert(signls, GBFeatureKey_oriT);
groups.insert(signls, GBFeatureKey_rep_origin);
groups.insert(signls, GBFeatureKey_polyA_site);
groups.insert(signls, GBFeatureKey_polyA_signal);
groups.insert(signls, GBFeatureKey_promoter);
groups.insert(signls, GBFeatureKey_RBS);
groups.insert(signls, GBFeatureKey_sig_peptide);
groups.insert(signls, GBFeatureKey_terminator);
groups.insert(signls, GBFeatureKey_transit_peptide);
groups.insert(signls, GBFeatureKey_TATA_signal);
groups.insert(signls, GBFeatureKey__35_signal);
groups.insert(signls, GBFeatureKey__10_signal);
groups.insert(signls, GBFeatureKey_regulatory);
QString binding = QObject::tr("Binding");
groups.insert(binding, GBFeatureKey_misc_binding);
groups.insert(binding, GBFeatureKey_primer_bind);
groups.insert(binding, GBFeatureKey_protein_bind);
groups.insert(binding, GBFeatureKey_bond);
QString variation = QObject::tr("Variation");
groups.insert(variation, GBFeatureKey_conflict);
groups.insert(variation, GBFeatureKey_misc_difference);
groups.insert(variation, GBFeatureKey_modified_base);
groups.insert(variation, GBFeatureKey_old_sequence);
groups.insert(variation, GBFeatureKey_STS);
groups.insert(variation, GBFeatureKey_unsure);
groups.insert(variation, GBFeatureKey_variation);
QString repeats = QObject::tr("Repeats");
groups.insert(repeats, GBFeatureKey_LTR);
groups.insert(repeats, GBFeatureKey_repeat_region);
groups.insert(repeats, GBFeatureKey_repeat_unit);
groups.insert(repeats, GBFeatureKey_satellite);
groups.insert(repeats, GBFeatureKey_transposon); //TODO: recheck grouping
QString rna = QObject::tr("RNA");
groups.insert(rna, GBFeatureKey_ncRNA);
groups.insert(rna, GBFeatureKey_misc_RNA);
groups.insert(rna, GBFeatureKey_mRNA);
groups.insert(rna, GBFeatureKey_rRNA);
groups.insert(rna, GBFeatureKey_scRNA);
groups.insert(rna, GBFeatureKey_snRNA);
groups.insert(rna, GBFeatureKey_tRNA);
groups.insert(rna, GBFeatureKey_tmRNA);
QString misc = QObject::tr("Misc");
groups.insert(misc, GBFeatureKey_assembly_gap);
groups.insert(misc, GBFeatureKey_centromere);
groups.insert(misc, GBFeatureKey_D_loop);
groups.insert(misc, GBFeatureKey_gap);
groups.insert(misc, GBFeatureKey_iDNA);
groups.insert(misc, GBFeatureKey_misc_binding);
groups.insert(misc, GBFeatureKey_misc_feature);
groups.insert(misc, GBFeatureKey_misc_recomb);
groups.insert(misc, GBFeatureKey_misc_structure);
groups.insert(misc, GBFeatureKey_mobile_element);
groups.insert(misc, GBFeatureKey_operon);
groups.insert(misc, GBFeatureKey_primer); //TODO: recheck grouping
groups.insert(misc, GBFeatureKey_source);
groups.insert(misc, GBFeatureKey_stem_loop);
groups.insert(misc, GBFeatureKey_telomere);
groups.insert(misc, GBFeatureKey_Protein);
groups.insert(misc, GBFeatureKey_Region);
groups.insert(misc, GBFeatureKey_Site);
QString spans = QObject::tr("Spans");
groups.insert(spans, GBFeatureKey_C_region);
groups.insert(spans, GBFeatureKey_D_segment);
groups.insert(spans, GBFeatureKey_J_region);
groups.insert(spans, GBFeatureKey_J_segment);
groups.insert(spans, GBFeatureKey_N_region);
groups.insert(spans, GBFeatureKey_S_region);
groups.insert(spans, GBFeatureKey_V_region);
groups.insert(spans, GBFeatureKey_V_segment);
#ifdef _DEBUG
//check that no feature lost
QVector<bool> featureInGroup(GBFeatureKey_NUM_KEYS, false);
foreach(const QString& groupName, groups.keys()) {
QList<GBFeatureKey> values = groups.values(groupName);
foreach (GBFeatureKey k, values) {
featureInGroup[k] = true;
}
}
for (int i=0; i<GBFeatureKey_NUM_KEYS; i++) {
GBFeatureKey fk = GBFeatureKey(i);
assert(featureInGroup[fk]);
}
#endif
}
QList<QgsOgrDbLayerInfo *> QgsOgrLayerItem::subLayers( const QString &path, const QString &driver )
{
QList<QgsOgrDbLayerInfo *> children;
// Vector layers
const QgsVectorLayer::LayerOptions layerOptions { QgsProject::instance()->transformContext() };
QgsVectorLayer layer( path, QStringLiteral( "ogr_tmp" ), QStringLiteral( "ogr" ), layerOptions );
if ( ! layer.isValid( ) )
{
QgsDebugMsgLevel( QStringLiteral( "Layer is not a valid %1 Vector layer %2" ).arg( path ), 3 );
}
else
{
// Collect mixed-geom layers
QMultiMap<int, QStringList> subLayersMap;
QgsOgrProvider *ogrProvider = qobject_cast<QgsOgrProvider *>( layer.dataProvider() );
const QStringList subLayersList( ogrProvider->subLayersWithoutFeatureCount( ) );
QMap< QString, int > mapLayerNameToCount;
bool uniqueNames = true;
int prevIdx = -1;
for ( const QString &descriptor : subLayersList )
{
QStringList pieces = descriptor.split( QgsDataProvider::SUBLAYER_SEPARATOR );
int idx = pieces[0].toInt();
subLayersMap.insert( idx, pieces );
if ( pieces.count() >= 4 && idx != prevIdx )
{
QString layerName = pieces[1];
int count = ++mapLayerNameToCount[layerName];
if ( count > 1 || layerName.isEmpty() )
uniqueNames = false;
}
prevIdx = idx;
}
prevIdx = -1;
const auto subLayerKeys = subLayersMap.keys( );
for ( const int &idx : subLayerKeys )
{
if ( idx == prevIdx )
{
continue;
}
prevIdx = idx;
QList<QStringList> values = subLayersMap.values( idx );
for ( int i = 0; i < values.size(); ++i )
{
QStringList pieces = values.at( i );
QString layerId = pieces[0];
QString name = pieces[1];
// QString featuresCount = pieces[2]; // Not used
QString geometryType = pieces[3];
QString geometryColumn = pieces[4];
QgsLayerItem::LayerType layerType;
layerType = QgsOgrLayerItem::layerTypeFromDb( geometryType );
// example URI for mixed-geoms geoms: '/path/gdal_sample_v1.2_no_extensions.gpkg|layerid=7|geometrytype=Point'
// example URI for mixed-geoms attr table: '/path/gdal_sample_v1.2_no_extensions.gpkg|layername=MyLayer|layerid=7'
// example URI for single geoms: '/path/gdal_sample_v1.2_no_extensions.gpkg|layerid=6'
QString uri;
if ( layerType != QgsLayerItem::LayerType::NoType )
{
if ( geometryType.contains( QStringLiteral( "Collection" ), Qt::CaseInsensitive ) )
{
QgsDebugMsgLevel( QStringLiteral( "Layer %1 is a geometry collection: skipping %2" ).arg( name, path ), 3 );
}
else
{
if ( uniqueNames )
uri = QStringLiteral( "%1|layername=%2" ).arg( path, name );
else
uri = QStringLiteral( "%1|layerid=%2" ).arg( path, layerId );
if ( values.size() > 1 )
{
uri += QStringLiteral( "|geometrytype=" ) + geometryType;
}
QgsDebugMsgLevel( QStringLiteral( "Adding %1 Vector item %2 %3 %4" ).arg( driver, name, uri, geometryType ), 3 );
children.append( new QgsOgrDbLayerInfo( path, uri, name, geometryColumn, geometryType, layerType ) );
}
}
else
{
QgsDebugMsgLevel( QStringLiteral( "Layer type is not a supported %1 Vector layer %2" ).arg( driver, path ), 3 );
uri = QStringLiteral( "%1|layerid=%2|layername=%3" ).arg( path, layerId, name );
children.append( new QgsOgrDbLayerInfo( path, uri, name, geometryColumn, geometryType, QgsLayerItem::LayerType::TableLayer ) );
}
QgsDebugMsgLevel( QStringLiteral( "Adding %1 Vector item %2 %3 %4" ).arg( driver, name, uri, geometryType ), 3 );
}
}
}
// Raster layers
QgsRasterLayer::LayerOptions options;
options.loadDefaultStyle = false;
QgsRasterLayer rlayer( path, QStringLiteral( "gdal_tmp" ), QStringLiteral( "gdal" ), options );
if ( !rlayer.dataProvider()->subLayers( ).empty() )
{
const QStringList layers( rlayer.dataProvider()->subLayers( ) );
for ( const QString &uri : layers )
{
// Split on ':' since this is what comes out from the provider
QStringList pieces = uri.split( ':' );
QString name = pieces.value( pieces.length() - 1 );
QgsDebugMsgLevel( QStringLiteral( "Adding GeoPackage Raster item %1 %2 %3" ).arg( name, uri ), 3 );
children.append( new QgsOgrDbLayerInfo( path, uri, name, QString(), QStringLiteral( "Raster" ), QgsLayerItem::LayerType::Raster ) );
}
}
else if ( rlayer.isValid( ) )
{
// Get the identifier
GDALAllRegister();
// do not print errors, but write to debug
CPLPushErrorHandler( CPLQuietErrorHandler );
CPLErrorReset();
gdal::dataset_unique_ptr hDS( GDALOpen( path.toUtf8().constData(), GA_ReadOnly ) );
CPLPopErrorHandler();
if ( ! hDS )
{
QgsDebugMsg( QStringLiteral( "GDALOpen error # %1 : %2 " ).arg( CPLGetLastErrorNo() ).arg( CPLGetLastErrorMsg() ) );
}
else
{
QString uri( QStringLiteral( "%1:%2" ).arg( driver, path ) );
QString name = GDALGetMetadataItem( hDS.get(), "IDENTIFIER", nullptr );
hDS.reset();
// Fallback: will not be able to delete the table
if ( name.isEmpty() )
{
name = QFileInfo( path ).fileName();
}
else
{
uri += QStringLiteral( ":%1" ).arg( name );
}
QgsDebugMsgLevel( QStringLiteral( "Adding %1 Raster item %2 %3" ).arg( driver, name, path ), 3 );
children.append( new QgsOgrDbLayerInfo( path, uri, name, QString(), QStringLiteral( "Raster" ), QgsLayerItem::LayerType::Raster ) );
}
}
return children;
}
void QgsMapRendererParallelJob::renderLayerStatic( LayerRenderJob& job )
{
if ( job.context.renderingStopped() )
return;
if ( job.cached )
return;
#ifdef QGISDEBUG
static QSet<QString> running;
static QMultiMap<int, QString> elapsed;
QSettings settings;
bool log = settings.value( "/Map/logCanvasRefreshEvent", false ).toBool();
QTime t;
t.start();
QgsDebugMsg( QString( "job %1 start" ).arg( reinterpret_cast< ulong >( &job ), 0, 16 ) );
if ( log )
{
QgsMessageLog::logMessage( tr( "Layer %1 job started" ).arg( job.layerId ), tr( "Rendering" ) );
Q_ASSERT( !running.contains( job.layerId ) );
running << job.layerId;
}
#endif
try
{
job.renderer->render();
}
catch ( QgsException & e )
{
QgsDebugMsg( "Caught unhandled QgsException: " + e.what() );
}
catch ( std::exception & e )
{
QgsDebugMsg( "Caught unhandled std::exception: " + QString::fromAscii( e.what() ) );
}
catch ( ... )
{
QgsDebugMsg( "Caught unhandled unknown exception" );
}
#ifdef QGISDEBUG
int tt = t.elapsed();
QgsDebugMsg( QString( "job %1 end [%2 ms]" ).arg( reinterpret_cast< ulong >( &job ), 0, 16 ).arg( tt ) );
if ( log )
{
running.remove( job.layerId );
elapsed.insert( tt, job.layerId );
QgsMessageLog::logMessage( tr( "Layer %1 job ended (%2 ms; still running:%3)" ).arg( job.layerId ).arg( tt ).arg( QStringList( running.values() ).join( ", " ) ), tr( "Rendering" ) );
if ( running.isEmpty() )
{
QList<int> tt( elapsed.keys() );
qSort( tt.begin(), tt.end(), qGreater<int>() );
Q_FOREACH ( int t, tt )
{
QgsMessageLog::logMessage( tr( "%1 ms: %2" ).arg( t ).arg( QStringList( elapsed.values( t ) ).join( ", " ) ), tr( "Rendering" ) );
}
QgsMessageLog::logMessage( "---", tr( "Rendering" ) );
elapsed.clear();
}
void tst_QWebPluginDatabase::preferredPlugin()
{
QMultiMap<QString, QWebPluginInfo> pluginsMap;
QWebPluginDatabase* database = QWebSettings::pluginDatabase();
QList<QWebPluginInfo> plugins = database->plugins();
for (int i = 0; i < plugins.count(); ++i) {
QWebPluginInfo plugin = plugins.at(i);
QList<MimeType> mimeTypes = plugin.mimeTypes();
for (int j = 0; j < mimeTypes.count(); ++j) {
QString mimeType = mimeTypes.at(j).name;
pluginsMap.insert(mimeType, plugin);
}
}
QMultiMap<QString, QWebPluginInfo>::iterator it = pluginsMap.begin();
while (it != pluginsMap.end()) {
QString mimeType = it.key();
if (pluginsMap.count(mimeType) > 1) {
QList<QWebPluginInfo> pluginsForMimeType = pluginsMap.values(mimeType);
QWebPluginInfo plugin = database->pluginForMimeType(mimeType);
QVERIFY(plugin.supportsMimeType(mimeType));
pluginsForMimeType.removeAll(plugin);
for (int i = 0; i < pluginsForMimeType.count(); ++i) {
QWebPluginInfo anotherPlugin = pluginsForMimeType.at(i);
QVERIFY(plugin.supportsMimeType(mimeType));
QVERIFY(plugin != anotherPlugin);
QCOMPARE(database->pluginForMimeType(mimeType), plugin);
database->setPreferredPluginForMimeType(mimeType, anotherPlugin);
QCOMPARE(database->pluginForMimeType(mimeType), anotherPlugin);
anotherPlugin.setEnabled(false);
QCOMPARE(database->pluginForMimeType(mimeType), plugin);
anotherPlugin.setEnabled(true);
QCOMPARE(database->pluginForMimeType(mimeType), anotherPlugin);
database->setSearchPaths(database->searchPaths());
QCOMPARE(database->pluginForMimeType(mimeType), anotherPlugin);
database->setPreferredPluginForMimeType(mimeType, QWebPluginInfo());
QCOMPARE(database->pluginForMimeType(mimeType), plugin);
}
} else {
QWebPluginInfo plugin = database->pluginForMimeType(mimeType);
QCOMPARE(pluginsMap.value(mimeType), plugin);
database->setPreferredPluginForMimeType(mimeType, plugin);
QCOMPARE(database->pluginForMimeType(mimeType), plugin);
plugin.setEnabled(false);
QCOMPARE(database->pluginForMimeType(mimeType), QWebPluginInfo());
plugin.setEnabled(true);
database->setPreferredPluginForMimeType(mimeType, QWebPluginInfo());
QCOMPARE(database->pluginForMimeType(mimeType), plugin);
}
++it;
}
if (pluginsMap.keys().count() >= 2) {
QStringList mimeTypes = pluginsMap.uniqueKeys();
QString mimeType1 = mimeTypes.at(0);
QString mimeType2 = mimeTypes.at(1);
QWebPluginInfo plugin1 = database->pluginForMimeType(mimeType1);
QWebPluginInfo plugin2 = database->pluginForMimeType(mimeType2);
int i = 2;
while (plugin2.supportsMimeType(mimeType1)
&& !mimeType2.isEmpty()
&& i < mimeTypes.count()) {
mimeType2 = mimeTypes.at(i);
plugin2 = database->pluginForMimeType(mimeType2);
++i;
}
plugin1 = database->pluginForMimeType(mimeType1);
QVERIFY(plugin1.supportsMimeType(mimeType1));
QVERIFY(!plugin1.isNull());
plugin2 = database->pluginForMimeType(mimeType2);
QVERIFY(plugin2.supportsMimeType(mimeType2));
QVERIFY(!plugin2.isNull());
database->setPreferredPluginForMimeType(mimeType2, plugin1);
QVERIFY(!plugin1.supportsMimeType(mimeType2));
QCOMPARE(database->pluginForMimeType(mimeType2), plugin2);
database->setPreferredPluginForMimeType(mimeType1, plugin1);
QVERIFY(!plugin2.supportsMimeType(mimeType1));
QCOMPARE(database->pluginForMimeType(mimeType2), plugin2);
}
}