File indexing completed on 2024-04-28 15:22:16

 /*
     This file is part of the KDE KFileMetaData project
     SPDX-FileCopyrightText: 2014 Vishesh Handa <me@vhanda.in>
 
     SPDX-License-Identifier: LGPL-2.1-or-later
 */
 
 #include "propertyinfotest.h"
 #include "propertyinfo.h"
 
 #include <QTest>
 
 using namespace KFileMetaData;
 
 //QTEST_GUILESS_MAIN(PropertyInfoTest)
 int main(int argc, char *argv[])
 {
     QCoreApplication app(argc, argv);
     PropertyInfoTest tc;
 
     auto arguments = app.arguments();
     if (arguments.contains(QStringLiteral("--localized"))) {
         arguments.removeAll(QStringLiteral("--localized"));
         tc.setLocalized(true);
     }
 
     return QTest::qExec(&tc, arguments);
 }
 
 void PropertyInfoTest::setLocalized(bool localized)
 {
     m_useLocalization = localized;
 }
 
 void PropertyInfoTest::init()
 {
     if (!m_useLocalization) {
         QLocale().setDefault(QLocale(QLocale::English, QLocale::UnitedStates));
     }
 }
 
 void PropertyInfoTest::testNameIdMapping()
 {
     const auto names = PropertyInfo::allNames();
 
     for (const auto& name : names) {
         const auto pi = PropertyInfo::fromName(name);
 
         QVERIFY(!pi.name().isEmpty());
         QVERIFY(!pi.displayName().isEmpty());
         QCOMPARE(name, pi.name());
 
         const auto pi2 = PropertyInfo::fromName(pi.name());
         QCOMPARE(pi.property(), pi2.property());
         QCOMPARE(pi, pi2);
         QCOMPARE(pi, PropertyInfo::fromName(pi.name().toLower()));
         QCOMPARE(pi, PropertyInfo::fromName(pi.name().toUpper()));
     }
 }
 
 void PropertyInfoTest::testFormatAsDisplayString() {
     QFETCH(KFileMetaData::PropertyInfo, propertyInfo);
     QFETCH(QVariant, value);
     QFETCH(QString, expected);
     QFETCH(bool, maybeLocalized);
 
     if (m_useLocalization && maybeLocalized) {
         qDebug() << "Expected:" << expected << ", formatted/localized:" << propertyInfo.formatAsDisplayString(value);
         if (expected != propertyInfo.formatAsDisplayString(value)) {
             QEXPECT_FAIL("", "Expected value not localized", Continue);
         }
     }
     QCOMPARE(propertyInfo.formatAsDisplayString(value), expected);
 }
 
 void PropertyInfoTest::testFormatAsDisplayString_data()
 {
     QTest::addColumn<KFileMetaData::PropertyInfo>("propertyInfo");
     QTest::addColumn<QVariant>("value");
     // expected values for an en_US locale
     QTest::addColumn<QString>("expected");
     QTest::addColumn<bool>("maybeLocalized");
 
     auto emptyProperty = PropertyInfo::fromName(QStringLiteral("no valid property name"));
     QTest::addRow("<invalid>")
         << emptyProperty << QVariant(QStringLiteral("empty")) << QStringLiteral("empty") << true;
 
     QStringList artistList = {QStringLiteral("Artist1"), QStringLiteral("Artist2"), QStringLiteral("Artist3")};
     QStringList authorList = {QStringLiteral("Author1")};
     QVariantList arrangerList = {QStringLiteral("Arranger1"), QStringLiteral("Arranger2")};
     QVariantList bitRateList = {128000, 130000};
     QVariantList titleList = {QStringLiteral("Title1"), QStringLiteral("Title2")};
 
     struct {
         KFileMetaData::Property::Property property;
         bool maybeLocalized;
         QVariant value;
         QString expected;
     } rows[] = {
         { Property::DiscNumber,             true,  2018,                    QStringLiteral("2018")},
         { Property::Title,                  false, QStringLiteral("Title"), QStringLiteral("Title")},
         { Property::Title,                  true,  titleList,               QStringLiteral("Title1 and Title2")},
         { Property::Artist,                 true,  artistList,              QStringLiteral("Artist1, Artist2, and Artist3")},
         { Property::Author,                 true,  authorList,              QStringLiteral("Author1")},
         { Property::Arranger,               true,  arrangerList,            QStringLiteral("Arranger1 and Arranger2")},
         { Property::Duration,               true,  1800,                    QStringLiteral("0:30:00")},
         { Property::SampleRate,             true,  44100,                   QStringLiteral("44.1 kHz")},
         { Property::BitRate,                true,  128000,                  QStringLiteral("128 kbit/s")},
         { Property::BitRate,                true,  1350000,                 QStringLiteral("1.35 Mbit/s")},
         { Property::BitRate,                true,  14700000,                QStringLiteral("14.7 Mbit/s")},
         { Property::BitRate,                true,  bitRateList,             QStringLiteral("128 kbit/s and 130 kbit/s")},
         { Property::ImageOrientation,       true,  5,                       QStringLiteral("Transposed")},
         { Property::PhotoFlash,             true,  0x00,                    QStringLiteral("No flash")},
         { Property::PhotoFlash,             true,  0x50,                    QStringLiteral("No, red-eye reduction")},
         { Property::PhotoGpsAltitude,       true,  1.1,                     QStringLiteral("1.1 m")},
         // make VisualStudio compiler happy: QChar(0x00B0) = "°"
         { Property::PhotoGpsLatitude,       true,  25,                      QStringLiteral("25") + QChar(0x00B0)},
         { Property::PhotoGpsLongitude,      true,  13.5,                    QStringLiteral("13.5") + QChar(0x00B0)},
         { Property::PhotoExposureTime,      true,  0.0015625,               QStringLiteral("1/640 s")},
         { Property::PhotoExposureTime,      true,  0.5,                     QStringLiteral("0.5 s")},
         { Property::PhotoExposureTime,      true,  0.15,                    QStringLiteral("0.15 s")},
         { Property::PhotoExposureBiasValue, true,  0.33333,                 QStringLiteral("1/3 EV")},
         { Property::PhotoExposureBiasValue, true,  0.66667,                 QStringLiteral("2/3 EV")},
         { Property::PhotoExposureBiasValue, true,  1,                       QStringLiteral("1 EV")},
         { Property::PhotoExposureBiasValue, true,  1.66667,                 QStringLiteral("1 2/3 EV")},
         { Property::PhotoExposureBiasValue, true,  0.1888,                  QStringLiteral("0.189 EV")},
         { Property::PhotoExposureBiasValue, true,  -0.33333,                QStringLiteral("-1/3 EV")},
         { Property::PhotoExposureBiasValue, true,  0,                       QStringLiteral("0 EV")},
         { Property::PhotoExposureBiasValue, true,  -1.5,                    QStringLiteral("-1 1/2 EV")},
         { Property::PhotoFNumber,           true,  4.0,                     QStringLiteral("f/4")},
         { Property::PhotoFNumber,           true,  2.8,                     QStringLiteral("f/2.8")},
         { Property::ReplayGainAlbumGain,    true,  -9.90,                   QStringLiteral("-9.9")},
         { Property::ReplayGainAlbumPeak,    true,  1.512,                   QStringLiteral("1.51")},
         { Property::ReplayGainAlbumGain,    true,  10.44,                   QStringLiteral("10.4")},
         { Property::ReplayGainAlbumPeak,    true,  1.306,                   QStringLiteral("1.31")},
         { Property::FrameRate,              true,  23,                      QStringLiteral("23 fps")},
         { Property::FrameRate,              true,  23.976,                  QStringLiteral("23.98 fps")},
         { Property::AspectRatio,            true,  1.77778,                 QStringLiteral("1.78:1")},
         { Property::PhotoFocalLength,       true,  2.0,                     QStringLiteral("2 mm")},
         { Property::PhotoFocalLength,       true,  2.4,                     QStringLiteral("2.4 mm")},
     };
 
     for (auto row : rows) {
         PropertyInfo info(row.property);
         QTest::addRow("%s", info.displayName().toUtf8().constData())
             << info << row.value << row.expected << row.maybeLocalized;
     }
 }
 
 void PropertyInfoTest::benchmarkPropertyInfo()
 {
     QFETCH(QString, propertyName);
     QFETCH(KFileMetaData::Property::Property, propertyId);
 
     QVERIFY(PropertyInfo::fromName(propertyName).property() == propertyId);
 
     auto property = PropertyInfo(propertyId);
 
     QBENCHMARK {
         // Instantiate a PropertyInfo from Id
         property = PropertyInfo(propertyId);
     }
 }
 
 void PropertyInfoTest::benchmarkPropertyInfoFromName()
 {
     QFETCH(QString, propertyName);
     auto property = PropertyInfo::fromName(propertyName);
 
     QBENCHMARK {
         // Instantiate a PropertyInfo from its name
         property = PropertyInfo::fromName(propertyName);
     }
 }
 
 void PropertyInfoTest::benchmarkPropertyInfoDisplayName()
 {
     QFETCH(KFileMetaData::Property::Property, propertyId);
 
     auto displayName = PropertyInfo(propertyId).displayName();
 
     QBENCHMARK {
         // Instantiate a PropertyInfo and get the displayName;
         auto property = PropertyInfo(propertyId);
         displayName = property.displayName();
     }
     QVERIFY(!displayName.isEmpty());
 }
 
 static void benchmarkTestData()
 {
     QTest::addColumn<QString>("propertyName");
     QTest::addColumn<KFileMetaData::Property::Property>("propertyId");
 
     QTest::addRow("album") << QStringLiteral("album") << KFileMetaData::Property::Album;
     QTest::addRow("width") << QStringLiteral("width") << KFileMetaData::Property::Width;
     QTest::addRow("originUrl") << QStringLiteral("originUrl") << KFileMetaData::Property::OriginUrl;
 }
 
 void PropertyInfoTest::benchmarkPropertyInfo_data()
 {
     benchmarkTestData();
 }
 
 void PropertyInfoTest::benchmarkPropertyInfoFromName_data()
 {
     benchmarkTestData();
 }
 
 void PropertyInfoTest::benchmarkPropertyInfoDisplayName_data()
 {
     benchmarkTestData();
 }
 
 #include "moc_propertyinfotest.cpp"