Corrected file extention to filename extension.

Change-Id: Ic3853ace953678878659d86769f696846fffbc84
Reviewed-on: http://codereview.qt-project.org/5125
Reviewed-by: Qt Sanity Bot <qt_sanity_bot@ovi.com>
Reviewed-by: Wolf-Michael Bolle <wolf-michael.bolle@nokia.com>

13 files changed, 94 insertions, 94 deletions

diff --git a/src/imports/mimetypes/qdeclarativemimetype.cpp b/src/imports/mimetypes/qdeclarativemimetype.cpp
index 558d633..f3bae8d 100644
--- a/src/imports/mimetypes/qdeclarativemimetype.cpp
+++ b/src/imports/mimetypes/qdeclarativemimetype.cpp
@@ -113,7 +113,7 @@ const QMimeTypeName &QDeclarativeMimeType::name() const
 
 void QDeclarativeMimeType::setName(const QMimeTypeName &newName)
 {
-    m_MimeType = QMimeType(newName, m_MimeType.displayName(), m_MimeType.iconUrl(), m_MimeType.fileExtentions());
+    m_MimeType = QMimeType(newName, m_MimeType.displayName(), m_MimeType.iconUrl(), m_MimeType.filenameExtensions());
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -127,7 +127,7 @@ const QString &QDeclarativeMimeType::displayName() const
 
 void QDeclarativeMimeType::setDisplayName(const QString &newDisplayName)
 {
-    m_MimeType = QMimeType(m_MimeType.name(), newDisplayName, m_MimeType.iconUrl(), m_MimeType.fileExtentions());
+    m_MimeType = QMimeType(m_MimeType.name(), newDisplayName, m_MimeType.iconUrl(), m_MimeType.filenameExtensions());
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -141,17 +141,17 @@ const QString &QDeclarativeMimeType::iconUrl() const
 
 void QDeclarativeMimeType::setIconUrl(const QString &newIconUrl)
 {
-    m_MimeType = QMimeType(m_MimeType.name(), m_MimeType.displayName(), newIconUrl, m_MimeType.fileExtentions());
+    m_MimeType = QMimeType(m_MimeType.name(), m_MimeType.displayName(), newIconUrl, m_MimeType.filenameExtensions());
 }
 
 // ------------------------------------------------------------------------------------------------
 
-QVariantList QDeclarativeMimeType::fileExtentions() const
+QVariantList QDeclarativeMimeType::filenameExtensions() const
 {
     QVariantList result;
 
-    foreach (const QString &fileExtention, m_MimeType.fileExtentions()) {
-        result << fileExtention;
+    foreach (const QString &filenameExtension, m_MimeType.filenameExtensions()) {
+        result << filenameExtension;
     }
 
     return result;
@@ -159,17 +159,17 @@ QVariantList QDeclarativeMimeType::fileExtentions() const
 
 // ------------------------------------------------------------------------------------------------
 
-void QDeclarativeMimeType::setFileExtentions(const QVariantList &newFileExtentions)
+void QDeclarativeMimeType::setFilenameExtensions(const QVariantList &newFilenameExtensions)
 {
     QList<QString> result;
 
-    foreach (const QVariant &newFileExtention, newFileExtentions) {
-        if (newFileExtention.type() != QVariant::String) {
-            qWarning() << Q_FUNC_INFO << "newFileExtention" << newFileExtention << " is not a string!";
+    foreach (const QVariant &newFilenameExtension, newFilenameExtensions) {
+        if (newFilenameExtension.type() != QVariant::String) {
+            qWarning() << Q_FUNC_INFO << "newFilenameExtension" << newFilenameExtension << " is not a string!";
             continue;
         }
 
-        result << newFileExtention.toString();
+        result << newFilenameExtension.toString();
     }
 
     m_MimeType = QMimeType(m_MimeType.name(), m_MimeType.displayName(), m_MimeType.iconUrl(), result);
diff --git a/src/imports/mimetypes/qdeclarativemimetype_p.h b/src/imports/mimetypes/qdeclarativemimetype_p.h
index 5b147e3..c739900 100644
--- a/src/imports/mimetypes/qdeclarativemimetype_p.h
+++ b/src/imports/mimetypes/qdeclarativemimetype_p.h
@@ -66,9 +66,9 @@ class QDeclarativeMimeType : public QObject
                READ iconUrl
                WRITE setIconUrl)
 
-    Q_PROPERTY(QVariantList fileExtentions
-               READ fileExtentions
-               WRITE setFileExtentions
+    Q_PROPERTY(QVariantList filenameExtensions
+               READ filenameExtensions
+               WRITE setFilenameExtensions
                STORED false)
 
     Q_PROPERTY(bool isValid
@@ -101,8 +101,8 @@ public:
     void setDisplayName(const QString &newDisplayName);
     const QString &iconUrl() const;
     void setIconUrl(const QString &newIconUrl);
-    QVariantList fileExtentions() const;
-    void setFileExtentions(const QVariantList &newFileExtentions);
+    QVariantList filenameExtensions() const;
+    void setFilenameExtensions(const QVariantList &newFilenameExtensions);
 
 private:
     QMimeType m_MimeType;
diff --git a/src/imports/mimetypes/qdeclarativemimetyperegistry.cpp b/src/imports/mimetypes/qdeclarativemimetyperegistry.cpp
index 5794c0f..c49e2a5 100644
--- a/src/imports/mimetypes/qdeclarativemimetyperegistry.cpp
+++ b/src/imports/mimetypes/qdeclarativemimetyperegistry.cpp
@@ -95,12 +95,12 @@ QDeclarativeMimeType *QDeclarativeMimeTypeRegistry::findMimeType (
 
 // ------------------------------------------------------------------------------------------------
 
-QVariantList QDeclarativeMimeTypeRegistry::fileExtentions() const
+QVariantList QDeclarativeMimeTypeRegistry::filenameExtensions() const
 {
     QVariantList result;
 
-    foreach (const QString &fileExtention, m_MimeTypeRegistry.fileExtentions()) {
-        result << fileExtention;
+    foreach (const QString &filenameExtension, m_MimeTypeRegistry.filenameExtensions()) {
+        result << filenameExtension;
     }
 
     return result;
@@ -108,22 +108,22 @@ QVariantList QDeclarativeMimeTypeRegistry::fileExtentions() const
 
 // ------------------------------------------------------------------------------------------------
 
-QString QDeclarativeMimeTypeRegistry::extractFileExtention (
+QString QDeclarativeMimeTypeRegistry::extractFilenameExtension (
                                           const QString &fileName
                                       ) const
 {
-    return m_MimeTypeRegistry.extractFileExtention(fileName);
+    return m_MimeTypeRegistry.extractFilenameExtension(fileName);
 }
 
 // ------------------------------------------------------------------------------------------------
 
 QVariantList QDeclarativeMimeTypeRegistry::findMimeTypes (
-                                               const QString &fileExtention
+                                               const QString &filenameExtension
                                            ) const
 {
     QVariantList result;
 
-    foreach (const QMimeTypeName &mimeTypeName, m_MimeTypeRegistry.findMimeTypes(fileExtention)) {
+    foreach (const QMimeTypeName &mimeTypeName, m_MimeTypeRegistry.findMimeTypes(filenameExtension)) {
         result << mimeTypeName;
     }
 
diff --git a/src/imports/mimetypes/qdeclarativemimetyperegistry_p.h b/src/imports/mimetypes/qdeclarativemimetyperegistry_p.h
index 58c0bea..6e23b52 100644
--- a/src/imports/mimetypes/qdeclarativemimetyperegistry_p.h
+++ b/src/imports/mimetypes/qdeclarativemimetyperegistry_p.h
@@ -61,8 +61,8 @@ class QDeclarativeMimeTypeRegistry : public QObject
                READ mimeTypes
                STORED false)
 
-    Q_PROPERTY(QVariantList fileExtentions
-               READ fileExtentions
+    Q_PROPERTY(QVariantList filenameExtensions
+               READ filenameExtensions
                STORED false)
 
     Q_PROPERTY(QVariantList serviceActions
@@ -89,14 +89,14 @@ public:
 
     // --------------------------------------------------------------------------------------------
 
-    QVariantList fileExtentions() const;
+    QVariantList filenameExtensions() const;
 
-    Q_INVOKABLE QString extractFileExtention (
+    Q_INVOKABLE QString extractFilenameExtension (
                             const QString &fileName
                         ) const;
 
     Q_INVOKABLE QVariantList findMimeTypes (
-                                 const QString &fileExtention
+                                 const QString &filenameExtension
                              ) const;
 
     // --------------------------------------------------------------------------------------------
diff --git a/src/mimetypes/qmimetype.cpp b/src/mimetypes/qmimetype.cpp
index 6721e60..8cf9572 100644
--- a/src/mimetypes/qmimetype.cpp
+++ b/src/mimetypes/qmimetype.cpp
@@ -73,18 +73,18 @@ QMimeType::QMimeType() :
     \fn QMimeType::QMimeType(const QMimeTypeName &theName,
                              const QString &theDisplayName,
                              const QString &theIconUrl,
-                             const QList<QString> &theFileExtentions);
+                             const QList<QString> &theFilenameExtensions);
     \brief Initializes the attributes with the specified values.
     \a theName The ID of the action
     \a theDisplayName The description of the action to be displayed on user interfaces
     \a theIconUrl The file name of an icon image that represents the action
-    \a theFileExtentions The file extentions that are known to contain data of the MIME type
+    \a theFilenameExtensions The filename extensions that are known to contain data of the MIME type
  */
 QMimeType::QMimeType(const QMimeTypeName &theName,
                      const QString &theDisplayName,
                      const QString &theIconUrl,
-                     const QList<QString> &theFileExtentions) :
-        d_ptr(new QMimeTypePrivate(theName, theDisplayName, theIconUrl, theFileExtentions))
+                     const QList<QString> &theFilenameExtensions) :
+        d_ptr(new QMimeTypePrivate(theName, theDisplayName, theIconUrl, theFilenameExtensions))
 {}
 
 // ------------------------------------------------------------------------------------------------
@@ -155,7 +155,7 @@ bool QMimeType::isValid() const
     return !d_ptr->m_Name.isEmpty() &&
            !d_ptr->m_DisplayName.isEmpty() &&
            !d_ptr->m_IconUrl.isEmpty() &&
-           !d_ptr->m_FileExtentions.isEmpty();
+           !d_ptr->m_FilenameExtensions.isEmpty();
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -200,10 +200,10 @@ const QString &QMimeType::iconUrl() const
 // ------------------------------------------------------------------------------------------------
 
 /*!
-    \fn QList<QString> QMimeType::fileExtentions() const;
-    \brief Returns the file extentions that are known to contain data of the MIME type.
+    \fn QList<QString> QMimeType::filenameExtensions() const;
+    \brief Returns the filename extensions that are known to contain data of the MIME type.
  */
-const QList<QString> &QMimeType::fileExtentions() const
+const QList<QString> &QMimeType::filenameExtensions() const
 {
-    return d_ptr->m_FileExtentions;
+    return d_ptr->m_FilenameExtensions;
 }
diff --git a/src/mimetypes/qmimetype.h b/src/mimetypes/qmimetype.h
index 8c2a4e9..d2797e7 100644
--- a/src/mimetypes/qmimetype.h
+++ b/src/mimetypes/qmimetype.h
@@ -65,7 +65,7 @@ public:
     QMimeType(const QMimeTypeName &theName,
               const QString &theDisplayName,
               const QString &theIconUrl,
-              const QList<QString> &theFileExtentions);
+              const QList<QString> &theFilenameExtensions);
     QMimeType(const QMimeType &other);
     QMimeType &operator=(const QMimeType &other);
     ~QMimeType();
@@ -82,7 +82,7 @@ public:
     const QMimeTypeName &name() const;
     const QString &displayName() const;
     const QString &iconUrl() const;
-    const QList<QString> &fileExtentions() const;
+    const QList<QString> &filenameExtensions() const;
 
 private:
     QScopedPointer<QMimeTypePrivate> d_ptr;
diff --git a/src/mimetypes/qmimetype_p.h b/src/mimetypes/qmimetype_p.h
index a0008de..71274ec 100644
--- a/src/mimetypes/qmimetype_p.h
+++ b/src/mimetypes/qmimetype_p.h
@@ -52,11 +52,11 @@ struct QMimeTypePrivate
     QMimeTypePrivate(const QMimeTypeName &theName,
                      const QString &theDisplayName,
                      const QString &theIconUrl,
-                     const QList<QString> &theFileExtentions) :
+                     const QList<QString> &theFilenameExtensions) :
             m_Name(theName),
             m_DisplayName(theDisplayName),
             m_IconUrl(theIconUrl),
-            m_FileExtentions(theFileExtentions)
+            m_FilenameExtensions(theFilenameExtensions)
     {}
 
     bool operator==(const QMimeTypePrivate &other) const
@@ -64,13 +64,13 @@ struct QMimeTypePrivate
         return m_Name == other.m_Name &&
                m_DisplayName == other.m_DisplayName &&
                m_IconUrl == other.m_IconUrl &&
-               m_FileExtentions == other.m_FileExtentions;
+               m_FilenameExtensions == other.m_FilenameExtensions;
     }
 
     QMimeTypeName m_Name;
     QString m_DisplayName;
     QString m_IconUrl;
-    QList<QString> m_FileExtentions;
+    QList<QString> m_FilenameExtensions;
 };
 
 #endif
diff --git a/src/mimetypes/qmimetyperegistry.cpp b/src/mimetypes/qmimetyperegistry.cpp
index 882a86c..1cbdc29 100644
--- a/src/mimetypes/qmimetyperegistry.cpp
+++ b/src/mimetypes/qmimetyperegistry.cpp
@@ -277,7 +277,7 @@
 
 /*!
     \class QMimeTypeRegistry
-    \brief QMimeTypeRegistry is the data store that manages mime types, service actions and file extentions.
+    \brief QMimeTypeRegistry is the data store that manages mime types, service actions and filename extensions.
  */
 
 // ------------------------------------------------------------------------------------------------
@@ -339,21 +339,21 @@
 // ------------------------------------------------------------------------------------------------
 
 /*!
-    \fn QList<QString> QMimeTypeRegistry::fileExtentions() const;
-    \brief Returns a list of file extentions of all registered MIME types.
+    \fn QList<QString> QMimeTypeRegistry::filenameExtensions() const;
+    \brief Returns a list of filename extensions of all registered MIME types.
  */
 
 // ------------------------------------------------------------------------------------------------
 
 /*!
-    \fn QString QMimeTypeRegistry::extractFileExtention (
+    \fn QString QMimeTypeRegistry::extractFilenameExtension (
                                        const QString &fileName
                                    ) const;
-    \brief Extracts the file extention from the specified file name.
+    \brief Extracts the filename extension from the specified file name.
 
-    \a fileName A file name of which we need to determine the extention.
+    \a fileName A file name of which we need to determine the extension.
 
-    Will only extract as deep into the file name as there are file extentions known currently.
+    Will only extract as deep into the file name as there are filename extensions known currently.
     E.g. "a.b.c.tar.gz" will result in ".tar.gz".
 
     Returns an empty string if no knwn file extentipn coulb be extracted from the file name.
@@ -363,11 +363,11 @@
 
 /*!
     \fn QList<QMimeTypeName> QMimeTypeRegistry::findMimeTypes (
-                                                    const QString &fileExtention
+                                                    const QString &filenameExtension
                                                 ) const;
-    \brief Determines which MIME types use the specified file extention.
+    \brief Determines which MIME types use the specified filename extension.
 
-    \a fileExtention The file extention for which we need to perform the search.
+    \a filenameExtension The filename extension for which we need to perform the search.
  */
 
 // ------------------------------------------------------------------------------------------------
diff --git a/src/mimetypes/qmimetyperegistry.h b/src/mimetypes/qmimetyperegistry.h
index 8291ab5..186f061 100644
--- a/src/mimetypes/qmimetyperegistry.h
+++ b/src/mimetypes/qmimetyperegistry.h
@@ -72,14 +72,14 @@ public:
 
     // --------------------------------------------------------------------------------------------
 
-    QList<QString> fileExtentions() const;
+    QList<QString> filenameExtensions() const;
 
-    QString extractFileExtention (
+    QString extractFilenameExtension (
                  const QString &fileName
             ) const;
 
     QList<QMimeTypeName> findMimeTypes (
-                             const QString &fileExtention
+                             const QString &filenameExtension
                          ) const;
 
     // --------------------------------------------------------------------------------------------
diff --git a/src/mimetypes/qmimetyperegistry_empty.cpp b/src/mimetypes/qmimetyperegistry_empty.cpp
index 85b0438..1afa317 100644
--- a/src/mimetypes/qmimetyperegistry_empty.cpp
+++ b/src/mimetypes/qmimetyperegistry_empty.cpp
@@ -83,7 +83,7 @@ QMimeType QMimeTypeRegistry::findMimeType (
 
 // ------------------------------------------------------------------------------------------------
 
-QList<QString> QMimeTypeRegistry::fileExtentions() const
+QList<QString> QMimeTypeRegistry::filenameExtensions() const
 {
     typedef QList<QString> Result;
 
@@ -92,18 +92,18 @@ QList<QString> QMimeTypeRegistry::fileExtentions() const
 
 // ------------------------------------------------------------------------------------------------
 
-QString QMimeTypeRegistry::extractFileExtention (
+QString QMimeTypeRegistry::extractFilenameExtension (
                                const QString &fileName
                            ) const
 {
     QString result;
 
-    const QList<QString> theFileExtentions (fileExtentions());
+    const QList<QString> theFilenameExtensions (filenameExtensions());
 
-    foreach (const QString &fileExtention, theFileExtentions) {
-        if (fileExtention.length() > result.length() &&
-                fileName.right(fileExtention.length()) == fileExtention) {
-            result = fileExtention;
+    foreach (const QString &filenameExtension, theFilenameExtensions) {
+        if (filenameExtension.length() > result.length() &&
+                fileName.right(filenameExtension.length()) == filenameExtension) {
+            result = filenameExtension;
         }
     }
 
@@ -113,12 +113,12 @@ QString QMimeTypeRegistry::extractFileExtention (
 // ------------------------------------------------------------------------------------------------
 
 QList<QMimeTypeName> QMimeTypeRegistry::findMimeTypes (
-                                            const QString &searchFileExtention
+                                            const QString &searchFilenameExtension
                                         ) const
 {
     typedef QList<QMimeTypeName> Result;
 
-    Q_UNUSED(searchFileExtention)
+    Q_UNUSED(searchFilenameExtension)
 
     return Result();
 }
diff --git a/unittests/declarative/tst_declarative_mimetypes.qml b/unittests/declarative/tst_declarative_mimetypes.qml
index c15357a..8f7b4a8 100644
--- a/unittests/declarative/tst_declarative_mimetypes.qml
+++ b/unittests/declarative/tst_declarative_mimetypes.qml
@@ -58,7 +58,7 @@ TestCase {
         return "/usr/share/icons/oxygen/64x64/mimetypes/image-x-generic.png"
     }
 
-    function firstPngMimeTypeFileExtention() {
+    function firstPngMimeTypeFilenameExtension() {
         return ".png"
     }
 
@@ -67,7 +67,7 @@ TestCase {
         name: pngMimeTypeName()
         displayName: pngMimeTypeDisplayName()
         iconUrl: pngMimeTypeIconUrl()
-        fileExtentions: [ firstPngMimeTypeFileExtention() ]
+        filenameExtensions: [ firstPngMimeTypeFilenameExtension() ]
     }
 
     MimeType {
@@ -120,14 +120,14 @@ TestCase {
         compare(instantiatedPngMimeType.equals(otherPngMimeType), false)
     }
 
-    function test_MimeType_fileExtentions() {
+    function test_MimeType_filenameExtensions() {
         otherPngMimeType.assign(instantiatedPngMimeType)
-        otherPngMimeType.fileExtentions = []
-        compare(otherPngMimeType.fileExtentions.length, 0)
+        otherPngMimeType.filenameExtensions = []
+        compare(otherPngMimeType.filenameExtensions.length, 0)
 
         // Verify that the Id is part of the equality test:
-        compare(instantiatedPngMimeType.fileExtentions.length, 1)
-        compare(instantiatedPngMimeType.fileExtentions[0], ".png")
+        compare(instantiatedPngMimeType.filenameExtensions.length, 1)
+        compare(instantiatedPngMimeType.filenameExtensions[0], ".png")
 
         compare(instantiatedPngMimeType.equals(otherPngMimeType), false)
     }
@@ -213,11 +213,11 @@ TestCase {
         compare(1, 0)
     }
 
-    function test_MimeTypeRegistry_fileExtentions() {
+    function test_MimeTypeRegistry_filenameExtensions() {
         compare(1, 0)
     }
 
-    function test_MimeTypeRegistry_extractFileExtention() {
+    function test_MimeTypeRegistry_extractFilenameExtension() {
         compare(1, 0)
     }
 
diff --git a/unittests/tst_mimetypes-empty.cpp b/unittests/tst_mimetypes-empty.cpp
index 3e8c7b2..9625918 100644
--- a/unittests/tst_mimetypes-empty.cpp
+++ b/unittests/tst_mimetypes-empty.cpp
@@ -77,7 +77,7 @@ static const QString &pngMimeTypeIconUrl()
 
 // ------------------------------------------------------------------------------------------------
 
-static QList<QString> buildPngMimeTypeFileExtentions()
+static QList<QString> buildPngMimeTypeFilenameExtensions()
 {
     QList<QString> result;
     result << ".png";
@@ -86,9 +86,9 @@ static QList<QString> buildPngMimeTypeFileExtentions()
 
 // ------------------------------------------------------------------------------------------------
 
-static const QList<QString> &pngMimeTypeFileExtentions()
+static const QList<QString> &pngMimeTypeFilenameExtensions()
 {
-    static const QList<QString> result (buildPngMimeTypeFileExtentions());
+    static const QList<QString> result (buildPngMimeTypeFilenameExtensions());
     return result;
 }
 
@@ -97,7 +97,7 @@ static const QList<QString> &pngMimeTypeFileExtentions()
 void tst_mimetypes::test_QMimeType_isValid()
 {
     QMimeType instantiatedPngMimeType (
-                  pngMimeTypeName(), pngMimeTypeDisplayName(), pngMimeTypeIconUrl(), pngMimeTypeFileExtentions()
+                  pngMimeTypeName(), pngMimeTypeDisplayName(), pngMimeTypeIconUrl(), pngMimeTypeFilenameExtensions()
               );
 
     QVERIFY(instantiatedPngMimeType.isValid());
@@ -117,11 +117,11 @@ void tst_mimetypes::test_QMimeType_isValid()
 void tst_mimetypes::test_QMimeType_name()
 {
     QMimeType instantiatedPngMimeType (
-                  pngMimeTypeName(), pngMimeTypeDisplayName(), pngMimeTypeIconUrl(), pngMimeTypeFileExtentions()
+                  pngMimeTypeName(), pngMimeTypeDisplayName(), pngMimeTypeIconUrl(), pngMimeTypeFilenameExtensions()
               );
 
     QMimeType otherPngMimeType (
-                  QMimeTypeName(), pngMimeTypeDisplayName(), pngMimeTypeIconUrl(), pngMimeTypeFileExtentions()
+                  QMimeTypeName(), pngMimeTypeDisplayName(), pngMimeTypeIconUrl(), pngMimeTypeFilenameExtensions()
               );
 
     // Verify that the Id is part of the equality test:
@@ -135,11 +135,11 @@ void tst_mimetypes::test_QMimeType_name()
 void tst_mimetypes::test_QMimeType_displayName()
 {
     QMimeType instantiatedPngMimeType (
-                  pngMimeTypeName(), pngMimeTypeDisplayName(), pngMimeTypeIconUrl(), pngMimeTypeFileExtentions()
+                  pngMimeTypeName(), pngMimeTypeDisplayName(), pngMimeTypeIconUrl(), pngMimeTypeFilenameExtensions()
               );
 
     QMimeType otherPngMimeType (
-                  pngMimeTypeName(), QString(), pngMimeTypeIconUrl(), pngMimeTypeFileExtentions()
+                  pngMimeTypeName(), QString(), pngMimeTypeIconUrl(), pngMimeTypeFilenameExtensions()
               );
 
     // Verify that the IconUrl is part of the equality test:
@@ -153,11 +153,11 @@ void tst_mimetypes::test_QMimeType_displayName()
 void tst_mimetypes::test_QMimeType_iconUrl()
 {
     QMimeType instantiatedPngMimeType (
-                  pngMimeTypeName(), pngMimeTypeDisplayName(), pngMimeTypeIconUrl(), pngMimeTypeFileExtentions()
+                  pngMimeTypeName(), pngMimeTypeDisplayName(), pngMimeTypeIconUrl(), pngMimeTypeFilenameExtensions()
               );
 
     QMimeType otherPngMimeType (
-                  pngMimeTypeName(), pngMimeTypeDisplayName(), QString(), pngMimeTypeFileExtentions()
+                  pngMimeTypeName(), pngMimeTypeDisplayName(), QString(), pngMimeTypeFilenameExtensions()
               );
 
     // Verify that the IconUrl is part of the equality test:
@@ -168,18 +168,18 @@ void tst_mimetypes::test_QMimeType_iconUrl()
 
 // ------------------------------------------------------------------------------------------------
 
-void tst_mimetypes::test_QMimeType_fileExtentions()
+void tst_mimetypes::test_QMimeType_filenameExtensions()
 {
     QMimeType instantiatedPngMimeType (
-                  pngMimeTypeName(), pngMimeTypeDisplayName(), pngMimeTypeIconUrl(), pngMimeTypeFileExtentions()
+                  pngMimeTypeName(), pngMimeTypeDisplayName(), pngMimeTypeIconUrl(), pngMimeTypeFilenameExtensions()
               );
 
     QMimeType otherPngMimeType (
                   pngMimeTypeName(), pngMimeTypeDisplayName(), pngMimeTypeIconUrl(), QList<QString>()
               );
 
-    // Verify that the FileExtentions are part of the equality test:
-    QCOMPARE(instantiatedPngMimeType.fileExtentions(), pngMimeTypeFileExtentions());
+    // Verify that the FilenameExtensions are part of the equality test:
+    QCOMPARE(instantiatedPngMimeType.filenameExtensions(), pngMimeTypeFilenameExtensions());
 
     QVERIFY(instantiatedPngMimeType != otherPngMimeType);
 }
@@ -290,7 +290,7 @@ const QMimeType &pngMimeType()
                                pngMimeTypeName(),
                                pngMimeTypeDisplayName(),
                                pngMimeTypeIconUrl(),
-                               pngMimeTypeFileExtentions()
+                               pngMimeTypeFilenameExtensions()
                            );
     return result;
 }
@@ -309,14 +309,14 @@ void tst_mimetypes::test_QMimeTypeRegistry_findMimeType()
 
 // ------------------------------------------------------------------------------------------------
 
-void tst_mimetypes::test_QMimeTypeRegistry_fileExtentions()
+void tst_mimetypes::test_QMimeTypeRegistry_filenameExtensions()
 {
     QVERIFY(false);
 }
 
 // ------------------------------------------------------------------------------------------------
 
-void tst_mimetypes::test_QMimeTypeRegistry_extractFileExtention()
+void tst_mimetypes::test_QMimeTypeRegistry_extractFilenameExtension()
 {
     QVERIFY(false);
 }
diff --git a/unittests/tst_mimetypes.h b/unittests/tst_mimetypes.h
index 19d2162..3e73bab 100644
--- a/unittests/tst_mimetypes.h
+++ b/unittests/tst_mimetypes.h
@@ -55,7 +55,7 @@ private slots:
     void test_QMimeType_name();
     void test_QMimeType_displayName();
     void test_QMimeType_iconUrl();
-    void test_QMimeType_fileExtentions();
+    void test_QMimeType_filenameExtensions();
 
     void test_QServiceAction_isValid();
     void test_QServiceAction_name();
@@ -64,8 +64,8 @@ private slots:
 
     void test_QMimeTypeRegistry_mimeTypes();
     void test_QMimeTypeRegistry_findMimeType();
-    void test_QMimeTypeRegistry_fileExtentions();
-    void test_QMimeTypeRegistry_extractFileExtention();
+    void test_QMimeTypeRegistry_filenameExtensions();
+    void test_QMimeTypeRegistry_extractFilenameExtension();
     void test_QMimeTypeRegistry_findMimeTypes();
     void test_QMimeTypeRegistry_determineMimeType();
     void test_QMimeTypeRegistry_serviceActions();