bool PuppetCreator::build(const QString &qmlPuppetProjectFilePath) const
{
PuppetBuildProgressDialog progressDialog;
m_compileLog.clear();
QTemporaryDir buildDirectory;
bool buildSucceeded = false;
if (qtIsSupported()) {
if (buildDirectory.isValid()) {
QStringList qmakeArguments;
qmakeArguments.append(QStringLiteral("-r"));
qmakeArguments.append(QStringLiteral("-after"));
qmakeArguments.append(QStringLiteral("DESTDIR=") + qmlpuppetDirectory(UserSpacePuppet));
#ifndef QT_DEBUG
qmakeArguments.append(QStringLiteral("CONFIG+=release"));
#endif
qmakeArguments.append(qmlPuppetProjectFilePath);
buildSucceeded = startBuildProcess(buildDirectory.path(), qmakeCommand(), qmakeArguments);
if (buildSucceeded) {
progressDialog.show();
buildSucceeded = startBuildProcess(buildDirectory.path(), buildCommand(), QStringList(), &progressDialog);
progressDialog.hide();
}
} else {
buildSucceeded = true;
}
}
m_useOnlyFallbackPuppet = !buildSucceeded; // fall back to creator puppet and don't compile again
return buildSucceeded;
}
terrama2::core::DataSetSeries terrama2::core::DataAccessorDcpToa5::getSeries(const std::string& uri,
const terrama2::core::Filter& filter,
terrama2::core::DataSetPtr dataSet) const
{
std::string mask = getMask(dataSet);
std::string folder = getFolder(dataSet);
QTemporaryDir tempBaseDir;
if(!tempBaseDir.isValid())
{
QString errMsg = QObject::tr("Can't create temporary folder.");
TERRAMA2_LOG_ERROR() << errMsg;
throw DataAccessException() << ErrorDescription(errMsg);
}
QDir tempDir(tempBaseDir.path());
tempDir.mkdir(QString::fromStdString(folder));
tempDir.cd(QString::fromStdString(folder));
QUrl url((uri+"/"+folder+"/"+mask).c_str());
QFileInfo originalInfo(url.path());
QFile file(url.path());
QFile tempFile(tempDir.path()+"/"+originalInfo.fileName());
if(!file.open(QIODevice::ReadOnly))
{
QString errMsg = QObject::tr("Can't open file: dataset %1.").arg(dataSet->id);
TERRAMA2_LOG_ERROR() << errMsg;
throw DataAccessException() << ErrorDescription(errMsg);
}
if(!tempFile.open(QIODevice::ReadWrite))
{
QString errMsg = QObject::tr("Can't open temporary file: dataset %1.").arg(dataSet->id);
TERRAMA2_LOG_ERROR() << errMsg;
throw DataAccessException() << ErrorDescription(errMsg);
}
file.readLine();//ignore first line
tempFile.write(file.readLine()); //headers line
//ignore third and fourth lines
file.readLine();
file.readLine();
//read all file
tempFile.write(file.readAll()); //headers line
//update file path
std::string tempUri = "file://"+tempBaseDir.path().toStdString();
file.close();
tempFile.close();
auto dataSeries = terrama2::core::DataAccessorFile::getSeries(tempUri, filter, dataSet);
return dataSeries;
}
void tst_qmldiskcache::cppRegisteredSingletonDependency()
{
qmlClearTypeRegistrations();
QScopedPointer<QQmlEngine> engine(new QQmlEngine);
QTemporaryDir tempDir;
QVERIFY(tempDir.isValid());
const auto writeTempFile = [&tempDir](const QString &fileName, const char *contents) {
QFile f(tempDir.path() + '/' + fileName);
const bool ok = f.open(QIODevice::WriteOnly | QIODevice::Truncate);
Q_ASSERT(ok);
f.write(contents);
return f.fileName();
};
writeTempFile("MySingleton.qml", "import QtQml 2.0\npragma Singleton\nQtObject { property int value: 42 }");
qmlRegisterSingletonType(QUrl::fromLocalFile(tempDir.path() + QLatin1String("/MySingleton.qml")), "CppRegisteredSingletonDependency", 1, 0, "Singly");
const QString testFilePath = writeTempFile("main.qml", "import QtQml 2.0\nimport CppRegisteredSingletonDependency 1.0\nQtObject {\n"
" function getValue() { return Singly.value; }\n"
"}");
{
CleanlyLoadingComponent component(engine.data(), QUrl::fromLocalFile(testFilePath));
QScopedPointer<QObject> obj(component.create());
QVERIFY(!obj.isNull());
QVariant value;
QVERIFY(QMetaObject::invokeMethod(obj.data(), "getValue", Q_RETURN_ARG(QVariant, value)));
QCOMPARE(value.toInt(), 42);
}
const QString testFileCachePath = testFilePath + QLatin1Char('c');
QVERIFY(QFile::exists(testFileCachePath));
QDateTime initialCacheTimeStamp = QFileInfo(testFileCachePath).lastModified();
engine.reset(new QQmlEngine);
waitForFileSystem();
writeTempFile("MySingleton.qml", "import QtQml 2.0\npragma Singleton\nQtObject { property int value: 100 }");
waitForFileSystem();
{
CleanlyLoadingComponent component(engine.data(), QUrl::fromLocalFile(testFilePath));
QScopedPointer<QObject> obj(component.create());
QVERIFY(!obj.isNull());
{
QVERIFY(QFile::exists(testFileCachePath));
QDateTime newCacheTimeStamp = QFileInfo(testFileCachePath).lastModified();
QVERIFY2(newCacheTimeStamp > initialCacheTimeStamp, qPrintable(newCacheTimeStamp.toString()));
}
QVariant value;
QVERIFY(QMetaObject::invokeMethod(obj.data(), "getValue", Q_RETURN_ARG(QVariant, value)));
QCOMPARE(value.toInt(), 100);
}
}
void CreateFileTest::createFileTest()
{
QTemporaryDir dir;
QVERIFY(dir.isValid());
const auto filePath = QDir::cleanPath(dir.path() + "/subA/subB/file.txt");
QVERIFY(!QFile::exists(filePath));
QVERIFY(createFile(filePath));
QVERIFY(QFile::exists(filePath));
}
void CreateFileTest::createFileInDirectoryTest()
{
QTemporaryDir dir;
QVERIFY(dir.isValid());
QString fileName = "file.txt";
const auto dirPath = QDir::cleanPath( dir.path() + "/subC" );
const auto filePath = QDir::cleanPath( dirPath + "/" + fileName );
QVERIFY(!QFile::exists(filePath));
QVERIFY(createFileInDirectory(dirPath, fileName));
QVERIFY(QFile::exists(filePath));
}
void tst_qmldiskcache::singletonDependency()
{
QScopedPointer<QQmlEngine> engine(new QQmlEngine);
QTemporaryDir tempDir;
QVERIFY(tempDir.isValid());
const auto writeTempFile = [&tempDir](const QString &fileName, const char *contents) {
QFile f(tempDir.path() + '/' + fileName);
const bool ok = f.open(QIODevice::WriteOnly | QIODevice::Truncate);
Q_ASSERT(ok);
f.write(contents);
return f.fileName();
};
writeTempFile("MySingleton.qml", "import QtQml 2.0\npragma Singleton\nQtObject { property int value: 42 }");
writeTempFile("qmldir", "singleton MySingleton 1.0 MySingleton.qml");
const QString testFilePath = writeTempFile("main.qml", "import QtQml 2.0\nimport \".\"\nQtObject {\n"
" property int value: MySingleton.value\n"
"}");
{
CleanlyLoadingComponent component(engine.data(), QUrl::fromLocalFile(testFilePath));
QScopedPointer<QObject> obj(component.create());
QVERIFY(!obj.isNull());
QCOMPARE(obj->property("value").toInt(), 42);
}
const QString testFileCachePath = testFilePath + QLatin1Char('c');
QVERIFY(QFile::exists(testFileCachePath));
QDateTime initialCacheTimeStamp = QFileInfo(testFileCachePath).lastModified();
engine.reset(new QQmlEngine);
waitForFileSystem();
writeTempFile("MySingleton.qml", "import QtQml 2.0\npragma Singleton\nQtObject { property int value: 100 }");
waitForFileSystem();
{
CleanlyLoadingComponent component(engine.data(), QUrl::fromLocalFile(testFilePath));
QScopedPointer<QObject> obj(component.create());
QVERIFY(!obj.isNull());
QCOMPARE(obj->property("value").toInt(), 100);
}
{
QVERIFY(QFile::exists(testFileCachePath));
QDateTime newCacheTimeStamp = QFileInfo(testFileCachePath).lastModified();
QVERIFY2(newCacheTimeStamp > initialCacheTimeStamp, qPrintable(newCacheTimeStamp.toString()));
}
}
void KIOPasteTest::testPasteJob()
{
QFETCH(QList<QUrl>, urls);
QFETCH(bool, data);
QFETCH(bool, cut);
QFETCH(QString, expectedFileName);
QMimeData mimeData;
bool isDir = false;
bool isFile = false;
if (!urls.isEmpty()) {
mimeData.setUrls(urls);
QFileInfo fileInfo(urls.first().toLocalFile());
isDir = fileInfo.isDir();
isFile = fileInfo.isFile();
}
if (data) {
mimeData.setText(QStringLiteral("Hello world"));
}
KIO::setClipboardDataCut(&mimeData, cut);
QTemporaryDir destTempDir;
QVERIFY(destTempDir.isValid());
const QString destDir = destTempDir.path();
KIO::Job *job = KIO::paste(&mimeData, QUrl::fromLocalFile(destDir), KIO::HideProgressInfo);
QSignalSpy spy(job, SIGNAL(itemCreated(QUrl)));
QVERIFY(spy.isValid());
job->setUiDelegate(0);
const bool expectedSuccess = !expectedFileName.isEmpty();
QCOMPARE(job->exec(), expectedSuccess);
if (expectedSuccess) {
const QString destFile = destDir + '/' + expectedFileName;
QVERIFY2(QFile::exists(destFile), qPrintable(expectedFileName));
if (isDir) {
QVERIFY(QFileInfo(destFile).isDir());
} else {
QVERIFY(QFileInfo(destFile).isFile());
QFile file(destFile);
QVERIFY(file.open(QIODevice::ReadOnly));
QCOMPARE(QString(file.readAll()), QString("Hello world"));
}
if (cut) {
QVERIFY(!QFile::exists(urls.first().toLocalFile()));
} else {
QVERIFY(QFile::exists(urls.first().toLocalFile()));
}
QCOMPARE(spy.count(), isFile || cut ? 1 : 2);
QCOMPARE(spy.at(0).at(0).value<QUrl>().toLocalFile(), destFile);
}
}
void tst_qmldiskcache::fileSelectors()
{
QQmlEngine engine;
QTemporaryDir tempDir;
QVERIFY(tempDir.isValid());
const QString testFilePath = tempDir.path() + "/test.qml";
{
QFile f(testFilePath);
QVERIFY2(f.open(QIODevice::WriteOnly), qPrintable(f.errorString()));
f.write(QByteArrayLiteral("import QtQml 2.0\nQtObject { property int value: 42 }"));
}
const QString selector = QStringLiteral("testSelector");
const QString selectorPath = tempDir.path() + "/+" + selector;
const QString selectedTestFilePath = selectorPath + "/test.qml";
{
QVERIFY(QDir::root().mkpath(selectorPath));
QFile f(selectorPath + "/test.qml");
QVERIFY2(f.open(QIODevice::WriteOnly), qPrintable(f.errorString()));
f.write(QByteArrayLiteral("import QtQml 2.0\nQtObject { property int value: 100 }"));
}
{
QQmlComponent component(&engine, testFilePath);
QScopedPointer<QObject> obj(component.create());
QVERIFY(!obj.isNull());
QCOMPARE(obj->property("value").toInt(), 42);
QFile cacheFile(testFilePath + "c");
QVERIFY2(cacheFile.exists(), qPrintable(cacheFile.fileName()));
}
QQmlFileSelector qmlSelector(&engine);
qmlSelector.setExtraSelectors(QStringList() << selector);
engine.clearComponentCache();
{
QQmlComponent component(&engine, testFilePath);
QScopedPointer<QObject> obj(component.create());
QVERIFY(!obj.isNull());
QCOMPARE(obj->property("value").toInt(), 100);
QFile cacheFile(selectedTestFilePath + "c");
QVERIFY2(cacheFile.exists(), qPrintable(cacheFile.fileName()));
}
}
QDir Project_sV::getDirectoryName()
{
QDir dirName;
#if QT_VERSION >= QT_VERSION_CHECK(5, 0, 0)
//QTemporaryDir tempDir("slowmovideo");
QTemporaryDir tempDir;; // use default
if (tempDir.isValid())
dirName = QDir(tempDir.path());
else
#endif
dirName = QDir::temp();
return dirName;
}
void EpubExportZip::addByteArray(const QString& path, QByteArray& content, CompressionLevel level)
{
// TODO: find a way to use in memory files... if not possible, maybe patch the zip library
// Qresources or named pipes might be the way to go (ale/20140430)
QTemporaryDir dir;
if (dir.isValid()) {
// dir.path() returns the unique directory path
QFileInfo fileinfo(path);
QString filename = QDir(dir.path()).filePath(fileinfo.fileName());
// qDebug() << "filename" << filename;
QFile file(filename);
if (file.open(QFile::WriteOnly)) {
file.write(content);
file.close();
addFile(filename, fileinfo.path(), level);
} else {
qDebug() << "could not open temporary file" << file.fileName();
}
}
}
void ArchiveTest::testExtraction()
{
QFETCH(QString, archivePath);
Archive *archive = Archive::create(archivePath, this);
QVERIFY(archive);
if (!archive->isValid()) {
QSKIP("Could not find a plugin to handle the archive. Skipping test.", SkipSingle);
}
QTemporaryDir destDir;
if (!destDir.isValid()) {
QSKIP("Could not create a temporary directory for extraction. Skipping test.", SkipSingle);
}
QFETCH(QVariantList, entriesToExtract);
QFETCH(ExtractionOptions, extractionOptions);
auto extractionJob = archive->copyFiles(entriesToExtract, destDir.path(), extractionOptions);
QEventLoop eventLoop(this);
connect(extractionJob, &KJob::result, &eventLoop, &QEventLoop::quit);
extractionJob->start();
eventLoop.exec(); // krazy:exclude=crashy
QFETCH(int, expectedExtractedEntriesCount);
int extractedEntriesCount = 0;
QDirIterator dirIt(destDir.path(), QDir::AllEntries | QDir::NoDotAndDotDot, QDirIterator::Subdirectories);
while (dirIt.hasNext()) {
extractedEntriesCount++;
dirIt.next();
}
QCOMPARE(extractedEntriesCount, expectedExtractedEntriesCount);
archive->deleteLater();
}
exportVideoRenderTarget::exportVideoRenderTarget(RenderTask_sV *parentRenderTask) :
AbstractRenderTarget_sV(parentRenderTask)
{
#if _NO_INSIDE_TMPDIR_
//TODO: should use projectdir to create render dir
#if QT_VERSION >= QT_VERSION_CHECK(5, 0, 0)
//QTemporaryDir tempDir("slowmovideo");
QTemporaryDir tempDir;; // use default
if (tempDir.isValid())
m_targetDir = QDir(tempDir.path());
else
#endif
m_targetDir = QDir::temp();
#else
m_targetDir = parentRenderTask->getRenderDirectory();
#endif
qDebug() << " target dir " << m_targetDir;
m_filenamePattern = "rendered-%1.png";
use_qt = 1;
first = 0;
}
void DocumentTest::testImageLocalDirectory() {
Tellico::Config::setImageLocation(Tellico::Config::ImagesInLocalDir);
// the default collection will use a temporary directory as a local image dir
QVERIFY(!Tellico::ImageFactory::localDir().isEmpty());
QString tempDirName;
QTemporaryDir tempDir;
QVERIFY(tempDir.isValid());
tempDir.setAutoRemove(true);
tempDirName = tempDir.path();
QString fileName = tempDirName + "/with-image.tc";
QString imageDirName = tempDirName + "/with-image_files/";
// copy a collection file that includes an image into the temporary directory
QVERIFY(QFile::copy(QFINDTESTDATA("data/with-image.tc"), fileName));
Tellico::Data::Document* doc = Tellico::Data::Document::self();
QVERIFY(doc->openDocument(QUrl::fromLocalFile(fileName)));
QCOMPARE(Tellico::ImageFactory::localDir(), imageDirName);
Tellico::Data::CollPtr coll = doc->collection();
QVERIFY(coll);
QCOMPARE(coll->type(), Tellico::Data::Collection::Book);
QCOMPARE(coll->title(), QLatin1String("My Books"));
QCOMPARE(coll->entries().size(), 1);
Tellico::Data::EntryPtr e = coll->entries().at(0);
QVERIFY(e);
QCOMPARE(e->field(QLatin1String("cover")), QLatin1String("17b54b2a742c6d342a75f122d615a793.jpeg"));
// save the document, so the images get copied out of the .tc file into the local image directory
QVERIFY(doc->saveDocument(QUrl::fromLocalFile(fileName)));
// verify that backup file gets created
QVERIFY(QFile::exists(fileName + '~'));
// check that the local image directory is created with the image file inside
QDir imageDir(imageDirName);
QVERIFY(imageDir.exists());
QVERIFY(imageDir.exists(e->field(QLatin1String("cover"))));
// clear the internal image cache
Tellico::ImageFactory::clean(true);
// verify that the images are copied from the old directory when saving to a new file
QString fileName2 = tempDirName + "/with-image2.tc";
QString imageDirName2 = tempDirName + "/with-image2_files/";
QVERIFY(doc->saveDocument(QUrl::fromLocalFile(fileName2)));
QVERIFY(QFile::exists(fileName2));
QDir imageDir2(imageDirName2);
QVERIFY(imageDir2.exists());
QVERIFY(imageDir2.exists(e->field(QLatin1String("cover"))));
/*************************************************************************/
/* now also verify image directory when file name has multiple periods */
/* see https://bugs.kde.org/show_bug.cgi?id=348088 */
/* also have to check backwards compatibility with prior behavior */
/*************************************************************************/
QString fileName3 = tempDirName + "/with-image.1.tc";
QString imageDirName3 = tempDirName + "/with-image.1_files/";
// copy the collection file, which no longer contains the images inside
QVERIFY(QFile::copy(fileName, fileName3));
QVERIFY(doc->openDocument(QUrl::fromLocalFile(fileName3)));
QCOMPARE(Tellico::ImageFactory::localDir(), imageDirName3);
QDir imageDir3(imageDirName3);
// verify that the images can be loaded from the image directory that does NOT have multiple periods
// since that was the behavior prior to the bug being fixed
coll = doc->collection();
e = coll->entries().at(0);
// image should not be in the next image dir yet since we haven't saved
QVERIFY(!imageDir3.exists(e->field(QLatin1String("cover"))));
QVERIFY(!Tellico::ImageFactory::imageById(e->field("cover")).isNull());
// now remove the first image from the first image directory, save the document, and verify that
// the proper image exists and is written
QVERIFY(imageDir.remove(e->field("cover")));
QVERIFY(!imageDir.exists(e->field(QLatin1String("cover"))));
QVERIFY(doc->saveDocument(QUrl::fromLocalFile(fileName3)));
// now the file should exist in the proper location
QVERIFY(imageDir3.exists(e->field(QLatin1String("cover"))));
// clear the cache
Tellico::ImageFactory::clean(true);
QVERIFY(!Tellico::ImageFactory::imageById(e->field("cover")).isNull());
// sanity check, the directory should not exists after QTemporaryDir destruction
tempDir.remove();
QVERIFY(!QDir(tempDirName).exists());
}
void TestQgsProject::testPathResolverSvg()
{
QString dataDir( TEST_DATA_DIR ); //defined in CmakeLists.txt
QString layerPath = dataDir + "/points.shp";
QVERIFY( QgsSymbolLayerUtils::svgSymbolNameToPath( QString(), QgsPathResolver() ).isEmpty() );
QVERIFY( QgsSymbolLayerUtils::svgSymbolPathToName( QString(), QgsPathResolver() ).isEmpty() );
// build a project with 3 layers, each having a simple renderer with SVG marker
// - existing SVG file in project dir
// - existing SVG file in QGIS dir
// - non-exsiting SVG file
QTemporaryDir dir;
QVERIFY( dir.isValid() );
// on mac the returned path was not canonical and the resolver failed to convert paths properly
QString dirPath = QFileInfo( dir.path() ).canonicalFilePath();
QString projectFilename = dirPath + "/project.qgs";
QString ourSvgPath = dirPath + "/valid.svg";
QString invalidSvgPath = dirPath + "/invalid.svg";
QFile svgFile( ourSvgPath );
QVERIFY( svgFile.open( QIODevice::WriteOnly ) );
svgFile.write( "<svg/>" ); // not a proper SVG, but good enough for this case
svgFile.close();
QVERIFY( QFileInfo::exists( ourSvgPath ) ); // should exist now
QString librarySvgPath = QgsSymbolLayerUtils::svgSymbolNameToPath( QStringLiteral( "transport/transport_airport.svg" ), QgsPathResolver() );
QCOMPARE( QgsSymbolLayerUtils::svgSymbolPathToName( librarySvgPath, QgsPathResolver() ), QStringLiteral( "transport/transport_airport.svg" ) );
QgsVectorLayer *layer1 = new QgsVectorLayer( layerPath, QStringLiteral( "points 1" ), QStringLiteral( "ogr" ) );
_useRendererWithSvgSymbol( layer1, ourSvgPath );
QgsVectorLayer *layer2 = new QgsVectorLayer( layerPath, QStringLiteral( "points 2" ), QStringLiteral( "ogr" ) );
_useRendererWithSvgSymbol( layer2, invalidSvgPath );
QgsVectorLayer *layer3 = new QgsVectorLayer( layerPath, QStringLiteral( "points 3" ), QStringLiteral( "ogr" ) );
_useRendererWithSvgSymbol( layer3, librarySvgPath );
QVERIFY( layer1->isValid() );
QgsProject project;
project.addMapLayers( QList<QgsMapLayer *>() << layer1 << layer2 << layer3 );
project.write( projectFilename );
// make sure the path resolver works with relative paths (enabled by default)
QCOMPARE( project.pathResolver().readPath( "./a.txt" ), dirPath + "/a.txt" );
QCOMPARE( project.pathResolver().writePath( dirPath + "/a.txt" ), QString( "./a.txt" ) );
// check that the saved paths are relative
// key = layer name, value = svg path
QHash<QString, QString> projectFileSvgPaths = _parseSvgPathsForLayers( projectFilename );
QCOMPARE( projectFileSvgPaths.count(), 3 );
QCOMPARE( projectFileSvgPaths["points 1"], QString( "./valid.svg" ) ); // relative path to project
QCOMPARE( projectFileSvgPaths["points 2"], invalidSvgPath ); // full path to non-existent file (not sure why - but that's how it works now)
QCOMPARE( projectFileSvgPaths["points 3"], QString( "transport/transport_airport.svg" ) ); // relative path to library
// load project again, check that the paths are absolute
QgsProject projectLoaded;
projectLoaded.read( projectFilename );
QString svg1 = _getLayerSvgMarkerPath( projectLoaded, QStringLiteral( "points 1" ) );
QString svg2 = _getLayerSvgMarkerPath( projectLoaded, QStringLiteral( "points 2" ) );
QString svg3 = _getLayerSvgMarkerPath( projectLoaded, QStringLiteral( "points 3" ) );
QCOMPARE( svg1, ourSvgPath );
QCOMPARE( svg2, invalidSvgPath );
QCOMPARE( svg3, librarySvgPath );
//
// now let's use these layers in embedded in another project...
//
QList<QDomNode> brokenNodes;
QgsProject projectMaster;
QVERIFY( projectMaster.createEmbeddedLayer( layer1->id(), projectFilename, brokenNodes ) );
QVERIFY( projectMaster.createEmbeddedLayer( layer2->id(), projectFilename, brokenNodes ) );
QVERIFY( projectMaster.createEmbeddedLayer( layer3->id(), projectFilename, brokenNodes ) );
QString svg1x = _getLayerSvgMarkerPath( projectMaster, QStringLiteral( "points 1" ) );
QString svg2x = _getLayerSvgMarkerPath( projectLoaded, QStringLiteral( "points 2" ) );
QString svg3x = _getLayerSvgMarkerPath( projectLoaded, QStringLiteral( "points 3" ) );
QCOMPARE( svg1x, ourSvgPath );
QCOMPARE( svg2x, invalidSvgPath );
QCOMPARE( svg3x, librarySvgPath );
}
void tst_qmldiskcache::stableOrderOfDependentCompositeTypes()
{
QQmlEngine engine;
QTemporaryDir tempDir;
QVERIFY(tempDir.isValid());
{
const QString depFilePath = tempDir.path() + "/FirstDependentType.qml";
QFile f(depFilePath);
QVERIFY2(f.open(QIODevice::WriteOnly), qPrintable(f.errorString()));
f.write(QByteArrayLiteral("import QtQml 2.0\nQtObject { property int value: 42 }"));
}
{
const QString depFilePath = tempDir.path() + "/SecondDependentType.qml";
QFile f(depFilePath);
QVERIFY2(f.open(QIODevice::WriteOnly), qPrintable(f.errorString()));
f.write(QByteArrayLiteral("import QtQml 2.0\nQtObject { property int value: 100 }"));
}
const QString testFilePath = tempDir.path() + "/main.qml";
{
QFile f(testFilePath);
QVERIFY2(f.open(QIODevice::WriteOnly), qPrintable(f.errorString()));
f.write(QByteArrayLiteral("import QtQml 2.0\nQtObject {\n"
" property QtObject dep1: FirstDependentType{}\n"
" property QtObject dep2: SecondDependentType{}\n"
" property int value: dep1.value + dep2.value\n"
"}"));
}
QByteArray firstDependentTypeClassName;
QByteArray secondDependentTypeClassName;
{
CleanlyLoadingComponent component(&engine, QUrl::fromLocalFile(testFilePath));
QScopedPointer<QObject> obj(component.create());
QVERIFY(!obj.isNull());
QCOMPARE(obj->property("value").toInt(), 142);
firstDependentTypeClassName = qvariant_cast<QObject *>(obj->property("dep1"))->metaObject()->className();
secondDependentTypeClassName = qvariant_cast<QObject *>(obj->property("dep2"))->metaObject()->className();
}
QVERIFY(firstDependentTypeClassName != secondDependentTypeClassName);
QVERIFY2(firstDependentTypeClassName.contains("QMLTYPE"), firstDependentTypeClassName.constData());
QVERIFY2(secondDependentTypeClassName.contains("QMLTYPE"), secondDependentTypeClassName.constData());
const QString testFileCachePath = testFilePath + QLatin1Char('c');
QVERIFY(QFile::exists(testFileCachePath));
QDateTime initialCacheTimeStamp = QFileInfo(testFileCachePath).lastModified();
engine.clearComponentCache();
waitForFileSystem();
// Creating the test component a second time should load it from the cache (same time stamp),
// despite the class names of the dependent composite types differing.
{
CleanlyLoadingComponent component(&engine, QUrl::fromLocalFile(testFilePath));
QScopedPointer<QObject> obj(component.create());
QVERIFY(!obj.isNull());
QCOMPARE(obj->property("value").toInt(), 142);
QVERIFY(qvariant_cast<QObject *>(obj->property("dep1"))->metaObject()->className() != firstDependentTypeClassName);
QVERIFY(qvariant_cast<QObject *>(obj->property("dep2"))->metaObject()->className() != secondDependentTypeClassName);
}
{
QVERIFY(QFile::exists(testFileCachePath));
QDateTime newCacheTimeStamp = QFileInfo(testFileCachePath).lastModified();
QCOMPARE(newCacheTimeStamp, initialCacheTimeStamp);
}
// Now change the first dependent QML type and see if we correctly re-generate the
// caches.
engine.clearComponentCache();
waitForFileSystem();
{
const QString depFilePath = tempDir.path() + "/FirstDependentType.qml";
QFile f(depFilePath);
QVERIFY2(f.open(QIODevice::WriteOnly), qPrintable(f.errorString()));
f.write(QByteArrayLiteral("import QtQml 2.0\nQtObject { property int value: 40 }"));
}
{
CleanlyLoadingComponent component(&engine, QUrl::fromLocalFile(testFilePath));
QScopedPointer<QObject> obj(component.create());
QVERIFY(!obj.isNull());
QCOMPARE(obj->property("value").toInt(), 140);
}
{
QVERIFY(QFile::exists(testFileCachePath));
QDateTime newCacheTimeStamp = QFileInfo(testFileCachePath).lastModified();
QVERIFY2(newCacheTimeStamp > initialCacheTimeStamp, qPrintable(newCacheTimeStamp.toString()));
}
}