Merge branch '4.7' of scm.dev.nokia.troll.no:qt/qt-qml into 4.7

4 files changed, 592 insertions, 3 deletions

diff --git a/tests/auto/declarative/examples/tst_examples.cpp b/tests/auto/declarative/examples/tst_examples.cpp
index 16b0cbe..058fda1 100644
--- a/tests/auto/declarative/examples/tst_examples.cpp
+++ b/tests/auto/declarative/examples/tst_examples.cpp
@@ -89,6 +89,8 @@ tst_examples::tst_examples()
     excludedDirs << "examples/declarative/imageprovider";
     excludedDirs << "demos/declarative/minehunt";
 
+    excludedDirs << "doc/src/snippets/declarative/graphicswidgets";
+
 #ifdef QT_NO_WEBKIT
     excludedDirs << "examples/declarative/webview";
     excludedDirs << "demos/declarative/webbrowser";
diff --git a/tests/auto/declarative/qdeclarativedom/tst_qdeclarativedom.cpp b/tests/auto/declarative/qdeclarativedom/tst_qdeclarativedom.cpp
index a951827..6c19566 100644
--- a/tests/auto/declarative/qdeclarativedom/tst_qdeclarativedom.cpp
+++ b/tests/auto/declarative/qdeclarativedom/tst_qdeclarativedom.cpp
@@ -419,10 +419,8 @@ void tst_qdeclarativedom::loadSyntaxErrors()
 void tst_qdeclarativedom::loadRemoteErrors()
 {
     QByteArray qml = "import Qt 4.7\n"
+                     "import \"http://localhost/exampleQmlScript.js\" as Script\n"
                      "Item {\n"
-                     "    Script {\n"
-                     "        source: \"http://localhost/exampleQmlScript.js\""
-                     "    }\n"
                      "}";
     QDeclarativeDomDocument document;
     QVERIFY(false == document.load(&engine, qml));
diff --git a/tests/auto/declarative/qdeclarativepositioners/tst_qdeclarativepositioners.cpp b/tests/auto/declarative/qdeclarativepositioners/tst_qdeclarativepositioners.cpp
index b4ac0e1..7a23773 100644
--- a/tests/auto/declarative/qdeclarativepositioners/tst_qdeclarativepositioners.cpp
+++ b/tests/auto/declarative/qdeclarativepositioners/tst_qdeclarativepositioners.cpp
@@ -41,6 +41,7 @@
 #include <QtTest/QtTest>
 #include <private/qlistmodelinterface_p.h>
 #include <qdeclarativeview.h>
+#include <qdeclarativeengine.h>
 #include <private/qdeclarativerectangle_p.h>
 #include <private/qdeclarativepositioners_p.h>
 #include <private/qdeclarativetransition_p.h>
@@ -69,6 +70,7 @@ private slots:
     void test_repeater();
     void test_flow();
     void test_flow_resize();
+    void test_conflictinganchors();
 private:
     QDeclarativeView *createView(const QString &filename);
 };
@@ -100,6 +102,8 @@ void tst_QDeclarativePositioners::test_horizontal()
     QDeclarativeItem *row = canvas->rootObject()->findChild<QDeclarativeItem*>("row");
     QCOMPARE(row->width(), 110.0);
     QCOMPARE(row->height(), 50.0);
+
+    delete canvas;
 }
 
 void tst_QDeclarativePositioners::test_horizontal_spacing()
@@ -125,6 +129,8 @@ void tst_QDeclarativePositioners::test_horizontal_spacing()
     QDeclarativeItem *row = canvas->rootObject()->findChild<QDeclarativeItem*>("row");
     QCOMPARE(row->width(), 130.0);
     QCOMPARE(row->height(), 50.0);
+
+    delete canvas;
 }
 
 void tst_QDeclarativePositioners::test_horizontal_animated()
@@ -175,6 +181,8 @@ void tst_QDeclarativePositioners::test_horizontal_animated()
 
     QTRY_COMPARE(two->x(), 50.0);
     QTRY_COMPARE(three->x(), 100.0);
+
+    delete canvas;
 }
 
 void tst_QDeclarativePositioners::test_vertical()
@@ -201,6 +209,8 @@ void tst_QDeclarativePositioners::test_vertical()
     QVERIFY(column);
     QCOMPARE(column->height(), 80.0);
     QCOMPARE(column->width(), 50.0);
+
+    delete canvas;
 }
 
 void tst_QDeclarativePositioners::test_vertical_spacing()
@@ -226,6 +236,8 @@ void tst_QDeclarativePositioners::test_vertical_spacing()
     QDeclarativeItem *column = canvas->rootObject()->findChild<QDeclarativeItem*>("column");
     QCOMPARE(column->height(), 100.0);
     QCOMPARE(column->width(), 50.0);
+
+    delete canvas;
 }
 
 void tst_QDeclarativePositioners::test_vertical_animated()
@@ -273,6 +285,7 @@ void tst_QDeclarativePositioners::test_vertical_animated()
     QTRY_COMPARE(two->y(), 50.0);
     QTRY_COMPARE(three->y(), 100.0);
 
+    delete canvas;
 }
 
 void tst_QDeclarativePositioners::test_grid()
@@ -304,6 +317,8 @@ void tst_QDeclarativePositioners::test_grid()
     QDeclarativeItem *grid = canvas->rootObject()->findChild<QDeclarativeItem*>("grid");
     QCOMPARE(grid->width(), 120.0);
     QCOMPARE(grid->height(), 100.0);
+
+    delete canvas;
 }
 
 void tst_QDeclarativePositioners::test_grid_topToBottom()
@@ -335,6 +350,8 @@ void tst_QDeclarativePositioners::test_grid_topToBottom()
     QDeclarativeItem *grid = canvas->rootObject()->findChild<QDeclarativeItem*>("grid");
     QCOMPARE(grid->width(), 100.0);
     QCOMPARE(grid->height(), 120.0);
+
+    delete canvas;
 }
 
 void tst_QDeclarativePositioners::test_grid_spacing()
@@ -366,6 +383,8 @@ void tst_QDeclarativePositioners::test_grid_spacing()
     QDeclarativeItem *grid = canvas->rootObject()->findChild<QDeclarativeItem*>("grid");
     QCOMPARE(grid->width(), 128.0);
     QCOMPARE(grid->height(), 104.0);
+
+    delete canvas;
 }
 
 void tst_QDeclarativePositioners::test_grid_animated()
@@ -446,6 +465,7 @@ void tst_QDeclarativePositioners::test_grid_animated()
     QTRY_COMPARE(five->x(), 50.0);
     QTRY_COMPARE(five->y(), 50.0);
 
+    delete canvas;
 }
 
 void tst_QDeclarativePositioners::test_grid_zero_columns()
@@ -477,6 +497,8 @@ void tst_QDeclarativePositioners::test_grid_zero_columns()
     QDeclarativeItem *grid = canvas->rootObject()->findChild<QDeclarativeItem*>("grid");
     QCOMPARE(grid->width(), 170.0);
     QCOMPARE(grid->height(), 60.0);
+
+    delete canvas;
 }
 
 void tst_QDeclarativePositioners::test_propertychanges()
@@ -534,6 +556,8 @@ void tst_QDeclarativePositioners::test_propertychanges()
     grid->setRows(2);
     QCOMPARE(columnsSpy.count(),2);
     QCOMPARE(rowsSpy.count(),2);
+
+    delete canvas;
 }
 
 void tst_QDeclarativePositioners::test_repeater()
@@ -555,6 +579,8 @@ void tst_QDeclarativePositioners::test_repeater()
     QCOMPARE(two->y(), 0.0);
     QCOMPARE(three->x(), 100.0);
     QCOMPARE(three->y(), 0.0);
+
+    delete canvas;
 }
 
 void tst_QDeclarativePositioners::test_flow()
@@ -587,6 +613,8 @@ void tst_QDeclarativePositioners::test_flow()
     QVERIFY(flow);
     QCOMPARE(flow->width(), 90.0);
     QCOMPARE(flow->height(), 120.0);
+
+    delete canvas;
 }
 
 void tst_QDeclarativePositioners::test_flow_resize()
@@ -618,6 +646,78 @@ void tst_QDeclarativePositioners::test_flow_resize()
     QCOMPARE(four->y(), 50.0);
     QCOMPARE(five->x(), 50.0);
     QCOMPARE(five->y(), 50.0);
+
+    delete canvas;
+}
+
+QString warningMessage;
+
+void interceptWarnings(QtMsgType type, const char *msg)
+{
+    Q_UNUSED( type );
+    warningMessage = msg;
+}
+
+void tst_QDeclarativePositioners::test_conflictinganchors()
+{
+    qInstallMsgHandler(interceptWarnings);
+    QDeclarativeEngine engine;
+    QDeclarativeComponent component(&engine);
+
+    component.setData("import Qt 4.7\nColumn { Item {} }", QUrl::fromLocalFile(""));
+    QDeclarativeItem *item = qobject_cast<QDeclarativeItem*>(component.create());
+    QVERIFY(item);
+    QVERIFY(warningMessage.isEmpty());
+
+    component.setData("import Qt 4.7\nRow { Item {} }", QUrl::fromLocalFile(""));
+    item = qobject_cast<QDeclarativeItem*>(component.create());
+    QVERIFY(item);
+    QVERIFY(warningMessage.isEmpty());
+
+    component.setData("import Qt 4.7\nGrid { Item {} }", QUrl::fromLocalFile(""));
+    item = qobject_cast<QDeclarativeItem*>(component.create());
+    QVERIFY(item);
+    QVERIFY(warningMessage.isEmpty());
+
+    component.setData("import Qt 4.7\nFlow { Item {} }", QUrl::fromLocalFile(""));
+    item = qobject_cast<QDeclarativeItem*>(component.create());
+    QVERIFY(item);
+    QVERIFY(warningMessage.isEmpty());
+
+    component.setData("import Qt 4.7\nColumn { Item { anchors.top: parent.top } }", QUrl::fromLocalFile(""));
+    item = qobject_cast<QDeclarativeItem*>(component.create());
+    QVERIFY(item);
+    QCOMPARE(warningMessage, QString("file::2:1: QML Column: Cannot specify top, bottom or verticalCenter anchors for items inside Column"));
+    warningMessage.clear();
+
+    component.setData("import Qt 4.7\nColumn { Item { anchors.left: parent.left } }", QUrl::fromLocalFile(""));
+    item = qobject_cast<QDeclarativeItem*>(component.create());
+    QVERIFY(item);
+    QVERIFY(warningMessage.isEmpty());
+    warningMessage.clear();
+
+    component.setData("import Qt 4.7\nRow { Item { anchors.left: parent.left } }", QUrl::fromLocalFile(""));
+    item = qobject_cast<QDeclarativeItem*>(component.create());
+    QVERIFY(item);
+    QCOMPARE(warningMessage, QString("file::2:1: QML Row: Cannot specify left, right or horizontalCenter anchors for items inside Row"));
+    warningMessage.clear();
+
+    component.setData("import Qt 4.7\nRow { Item { anchors.top: parent.top } }", QUrl::fromLocalFile(""));
+    item = qobject_cast<QDeclarativeItem*>(component.create());
+    QVERIFY(item);
+    QVERIFY(warningMessage.isEmpty());
+    warningMessage.clear();
+
+    component.setData("import Qt 4.7\nGrid { Item { anchors.horizontalCenter: parent.horizontalCenter } }", QUrl::fromLocalFile(""));
+    item = qobject_cast<QDeclarativeItem*>(component.create());
+    QVERIFY(item);
+    QCOMPARE(warningMessage, QString("file::2:1: QML Grid: Cannot specify anchors for items inside Grid"));
+    warningMessage.clear();
+
+    component.setData("import Qt 4.7\nFlow { Item { anchors.verticalCenter: parent.verticalCenter } }", QUrl::fromLocalFile(""));
+    item = qobject_cast<QDeclarativeItem*>(component.create());
+    QVERIFY(item);
+    QCOMPARE(warningMessage, QString("file::2:1: QML Flow: Cannot specify anchors for items inside Flow"));
 }
 
 QDeclarativeView *tst_QDeclarativePositioners::createView(const QString &filename)
diff --git a/tests/auto/qlist/tst_qlist.cpp b/tests/auto/qlist/tst_qlist.cpp
index e2944cc..ba8aefa 100644
--- a/tests/auto/qlist/tst_qlist.cpp
+++ b/tests/auto/qlist/tst_qlist.cpp
@@ -62,6 +62,33 @@ private slots:
     void append() const;
     void prepend() const;
     void mid() const;
+    void at() const;
+    void first() const;
+    void last() const;
+    void begin() const;
+    void end() const;
+    void contains() const;
+    void count() const;
+    void empty() const;
+    void endsWith() const;
+    void lastIndexOf() const;
+    void move() const;
+    void removeAll() const;
+    void removeAt() const;
+    void removeOne() const;
+    void replace() const;
+    void startsWith() const;
+    void swap() const;
+    void takeAt() const;
+    void takeFirst() const;
+    void takeLast() const;
+    void toSet() const;
+    void toStdList() const;
+    void toVector() const;
+    void value() const;
+
+    void testSTLIterators() const;
+    void testOperators() const;
 };
 
 void tst_QList::length() const
@@ -173,5 +200,467 @@ void tst_QList::mid() const
              QList<QString>() << "bak" << "buck" << "hello");
 }
 
+void tst_QList::at() const
+{
+    // test at() and make sure it functions correctly with some simple list manipulation.
+    QList<QString> list;
+
+    // create a list
+    list << "foo" << "bar" << "baz";
+    QVERIFY(list.size() == 3);
+    QCOMPARE(list.at(0), QLatin1String("foo"));
+    QCOMPARE(list.at(1), QLatin1String("bar"));
+    QCOMPARE(list.at(2), QLatin1String("baz"));
+
+    // append an item
+    list << "hello";
+    QVERIFY(list.size() == 4);
+    QCOMPARE(list.at(0), QLatin1String("foo"));
+    QCOMPARE(list.at(1), QLatin1String("bar"));
+    QCOMPARE(list.at(2), QLatin1String("baz"));
+    QCOMPARE(list.at(3), QLatin1String("hello"));
+
+    // remove an item
+    list.removeAt(1);
+    QVERIFY(list.size() == 3);
+    QCOMPARE(list.at(0), QLatin1String("foo"));
+    QCOMPARE(list.at(1), QLatin1String("baz"));
+    QCOMPARE(list.at(2), QLatin1String("hello"));
+}
+
+void tst_QList::first() const
+{
+    QList<QString> list;
+    list << "foo" << "bar";
+
+    QCOMPARE(list.first(), QLatin1String("foo"));
+
+    // remove an item, make sure it still works
+    list.pop_front();
+    QVERIFY(list.size() == 1);
+    QCOMPARE(list.first(), QLatin1String("bar"));
+}
+
+void tst_QList::last() const
+{
+    QList<QString> list;
+    list << "foo" << "bar";
+
+    QCOMPARE(list.last(), QLatin1String("bar"));
+
+    // remove an item, make sure it still works
+    list.pop_back();
+    QVERIFY(list.size() == 1);
+    QCOMPARE(list.last(), QLatin1String("foo"));
+}
+
+void tst_QList::begin() const
+{
+    QList<QString> list;
+    list << "foo" << "bar";
+
+    QCOMPARE(*list.begin(), QLatin1String("foo"));
+
+    // remove an item, make sure it still works
+    list.pop_front();
+    QVERIFY(list.size() == 1);
+    QCOMPARE(*list.begin(), QLatin1String("bar"));
+}
+
+void tst_QList::end() const
+{
+    QList<QString> list;
+    list << "foo" << "bar";
+
+    QCOMPARE(*--list.end(), QLatin1String("bar"));
+
+    // remove an item, make sure it still works
+    list.pop_back();
+    QVERIFY(list.size() == 1);
+    QCOMPARE(*--list.end(), QLatin1String("foo"));
+}
+
+void tst_QList::contains() const
+{
+    QList<QString> list;
+    list << "foo" << "bar" << "baz";
+
+    QVERIFY(list.contains(QLatin1String("foo")) == true);
+    QVERIFY(list.contains(QLatin1String("pirates")) != true);
+
+    // add it and make sure it matches
+    list.append(QLatin1String("ninjas"));
+    QVERIFY(list.contains(QLatin1String("ninjas")) == true);
+}
+
+void tst_QList::count() const
+{
+    QList<QString> list;
+
+    // starts empty
+    QVERIFY(list.count() == 0);
+
+    // goes up
+    list.append(QLatin1String("foo"));
+    QVERIFY(list.count() == 1);
+
+    // and up
+    list.append(QLatin1String("bar"));
+    QVERIFY(list.count() == 2);
+
+    // and down
+    list.pop_back();
+    QVERIFY(list.count() == 1);
+
+    // and empty. :)
+    list.pop_back();
+    QVERIFY(list.count() == 0);
+}
+
+void tst_QList::empty() const
+{
+    QList<QString> list;
+
+    // make sure it starts empty
+    QVERIFY(list.empty());
+
+    // and doesn't stay empty
+    list.append(QLatin1String("foo"));
+    QVERIFY(!list.empty());
+
+    // and goes back to being empty
+    list.pop_back();
+    QVERIFY(list.empty());
+}
+
+void tst_QList::endsWith() const
+{
+    QList<QString> list;
+    list << "foo" << "bar" << "baz";
+
+    // test it returns correctly in both cases
+    QVERIFY(list.endsWith(QLatin1String("baz")));
+    QVERIFY(!list.endsWith(QLatin1String("bar")));
+
+    // remove an item and make sure the end item changes
+    list.pop_back();
+    QVERIFY(list.endsWith(QLatin1String("bar")));
+}
+
+void tst_QList::lastIndexOf() const
+{
+    QList<QString> list;
+    list << "foo" << "bar" << "baz";
+
+    // one instance of the target item
+    QVERIFY(list.lastIndexOf(QLatin1String("baz")) == 2);
+
+    // shouldn't find this
+    QVERIFY(list.lastIndexOf(QLatin1String("shouldntfindme")) == -1);
+
+    // multiple instances
+    list.append("baz");
+    list.append("baz");
+    QVERIFY(list.lastIndexOf(QLatin1String("baz")) == 4);
+
+    // search from the middle to find the last one
+    QVERIFY(list.lastIndexOf(QLatin1String("baz"), 3) == 3);
+
+    // try find none
+    QVERIFY(list.lastIndexOf(QLatin1String("baz"), 1) == -1);
+}
+
+void tst_QList::move() const
+{
+    QList<QString> list;
+    list << "foo" << "bar" << "baz";
+
+    // move an item
+    list.move(0, list.count() - 1);
+    QCOMPARE(list, QList<QString>() << "bar" << "baz" << "foo");
+
+    // move it back
+    list.move(list.count() - 1, 0);
+    QCOMPARE(list, QList<QString>() << "foo" << "bar" << "baz");
+
+    // move an item in the middle
+    list.move(1, 0);
+    QCOMPARE(list, QList<QString>() << "bar" << "foo" << "baz");
+}
+
+void tst_QList::removeAll() const
+{
+    QList<QString> list;
+    list << "foo" << "bar" << "baz";
+
+    // remove one instance
+    list.removeAll(QLatin1String("bar"));
+    QCOMPARE(list, QList<QString>() << "foo" << "baz");
+
+    // many instances
+    list << "foo" << "bar" << "baz";
+    list << "foo" << "bar" << "baz";
+    list << "foo" << "bar" << "baz";
+    list.removeAll(QLatin1String("bar"));
+    QCOMPARE(list, QList<QString>() << "foo" << "baz" << "foo" << "baz" << "foo" << "baz" << "foo" << "baz");
+
+    // try remove something that doesn't exist
+    list.removeAll(QLatin1String("you won't remove anything I hope"));
+    QCOMPARE(list, QList<QString>() << "foo" << "baz" << "foo" << "baz" << "foo" << "baz" << "foo" << "baz");
+}
+
+void tst_QList::removeAt() const
+{
+    QList<QString> list;
+    list << "foo" << "bar" << "baz";
+
+    // middle
+    list.removeAt(1);
+    QCOMPARE(list, QList<QString>() << "foo" << "baz");
+
+    // start
+    list.removeAt(0);
+    QCOMPARE(list, QList<QString>() << "baz");
+
+    // final
+    list.removeAt(0);
+    QCOMPARE(list, QList<QString>());
+}
+
+void tst_QList::removeOne() const
+{
+    QList<QString> list;
+    list << "foo" << "bar" << "baz";
+
+    // middle
+    list.removeOne(QLatin1String("bar"));
+    QCOMPARE(list, QList<QString>() << "foo" << "baz");
+
+    // start
+    list.removeOne(QLatin1String("foo"));
+    QCOMPARE(list, QList<QString>() << "baz");
+
+    // last
+    list.removeOne(QLatin1String("baz"));
+    QCOMPARE(list, QList<QString>());
+
+    // make sure it really only removes one :)
+    list << "foo" << "foo";
+    list.removeOne("foo");
+    QCOMPARE(list, QList<QString>() << "foo");
+
+    // try remove something that doesn't exist
+    list.removeOne(QLatin1String("you won't remove anything I hope"));
+    QCOMPARE(list, QList<QString>() << "foo");
+}
+
+void tst_QList::replace() const
+{
+    QList<QString> list;
+    list << "foo" << "bar" << "baz";
+
+    // start
+    list.replace(0, "moo");
+    QCOMPARE(list, QList<QString>() << "moo" << "bar" << "baz");
+
+    // middle
+    list.replace(1, "cow");
+    QCOMPARE(list, QList<QString>() << "moo" << "cow" << "baz");
+
+    // end
+    list.replace(2, "milk");
+    QCOMPARE(list, QList<QString>() << "moo" << "cow" << "milk");
+}
+
+void tst_QList::startsWith() const
+{
+    QList<QString> list;
+    list << "foo" << "bar" << "baz";
+
+    // make sure it starts ok
+    QVERIFY(list.startsWith(QLatin1String("foo")));
+
+    // remove an item
+    list.removeFirst();
+    QVERIFY(list.startsWith(QLatin1String("bar")));
+}
+
+void tst_QList::swap() const
+{
+    QList<QString> list;
+    list << "foo" << "bar" << "baz";
+
+    // swap
+    list.swap(0, 2);
+    QCOMPARE(list, QList<QString>() << "baz" << "bar" << "foo");
+
+    // swap again
+    list.swap(1, 2);
+    QCOMPARE(list, QList<QString>() << "baz" << "foo" << "bar");
+}
+
+void tst_QList::takeAt() const
+{
+    QList<QString> list;
+    list << "foo" << "bar" << "baz";
+
+    QCOMPARE(list.takeAt(0), QLatin1String("foo"));
+    QVERIFY(list.size() == 2);
+    QCOMPARE(list.takeAt(1), QLatin1String("baz"));
+    QVERIFY(list.size() == 1);
+    QCOMPARE(list.takeAt(0), QLatin1String("bar"));
+    QVERIFY(list.size() == 0);
+}
+
+void tst_QList::takeFirst() const
+{
+    QList<QString> list;
+    list << "foo" << "bar" << "baz";
+
+    QCOMPARE(list.takeFirst(), QLatin1String("foo"));
+    QVERIFY(list.size() == 2);
+    QCOMPARE(list.takeFirst(), QLatin1String("bar"));
+    QVERIFY(list.size() == 1);
+    QCOMPARE(list.takeFirst(), QLatin1String("baz"));
+    QVERIFY(list.size() == 0);
+}
+
+void tst_QList::takeLast() const
+{
+    QList<QString> list;
+    list << "foo" << "bar" << "baz";
+
+    QCOMPARE(list.takeLast(), QLatin1String("baz"));
+    QCOMPARE(list.takeLast(), QLatin1String("bar"));
+    QCOMPARE(list.takeLast(), QLatin1String("foo"));
+}
+
+void tst_QList::toSet() const
+{
+    QList<QString> list;
+    list << "foo" << "bar" << "baz";
+
+    // no duplicates
+    QCOMPARE(list.toSet(), QSet<QString>() << "foo" << "bar" << "baz");
+    QCOMPARE(list, QList<QString>() << "foo" << "bar" << "baz");
+
+    // duplicates (is this more of a QSet test?)
+    list << "foo" << "bar" << "baz";
+    QCOMPARE(list.toSet(), QSet<QString>() << "foo" << "bar" << "baz");
+    QCOMPARE(list, QList<QString>() << "foo" << "bar" << "baz" << "foo" << "bar" << "baz");
+}
+
+void tst_QList::toStdList() const
+{
+    QList<QString> list;
+    list << "foo" << "bar" << "baz";
+
+    // yuck.
+    std::list<QString> slist;
+    slist.push_back(QLatin1String("foo"));
+    slist.push_back(QLatin1String("bar"));
+    slist.push_back(QLatin1String("baz"));
+
+    QCOMPARE(list.toStdList(), slist);
+    QCOMPARE(list, QList<QString>() << "foo" << "bar" << "baz");
+}
+
+void tst_QList::toVector() const
+{
+    QList<QString> list;
+    list << "foo" << "bar" << "baz";
+
+    QCOMPARE(list.toVector(), QVector<QString>() << "foo" << "bar" << "baz");
+}
+
+void tst_QList::value() const
+{
+    QList<QString> list;
+    list << "foo" << "bar" << "baz";
+
+    // test real values
+    QCOMPARE(list.value(0), QLatin1String("foo"));
+    QCOMPARE(list.value(2), QLatin1String("baz"));
+
+    // test empty default
+    QCOMPARE(list.value(3), QString());
+    QCOMPARE(list.value(-1), QString());
+
+    // test defaults
+    QLatin1String defaultstr("default");
+    QCOMPARE(list.value(-1, defaultstr), defaultstr);
+    QCOMPARE(list.value(3, defaultstr), defaultstr);
+}
+
+void tst_QList::testOperators() const
+{
+    QList<QString> list;
+    list << "foo" << "bar" << "baz";
+
+    QList<QString> listtwo;
+    listtwo << "foo" << "bar" << "baz";
+
+    // test equal
+    QVERIFY(list == listtwo);
+
+    // not equal
+    listtwo.append("not equal");
+    QVERIFY(list != listtwo);
+
+    // +=
+    list += listtwo;
+    QVERIFY(list.size() == 7);
+    QVERIFY(listtwo.size() == 4);
+    QCOMPARE(list, QList<QString>() << "foo" << "bar" << "baz" << "foo" << "bar" << "baz" << "not equal");
+
+    // =
+    list = listtwo;
+    QCOMPARE(list, listtwo);
+    QCOMPARE(list, QList<QString>() << "foo" << "bar" << "baz" << "not equal");
+
+    // []
+    QCOMPARE(list[0], QLatin1String("foo"));
+    QCOMPARE(list[list.size() - 1], QLatin1String("not equal"));
+}
+
+void tst_QList::testSTLIterators() const
+{
+    QList<QString> list;
+
+    // create a list
+    list << "foo" << "bar" << "baz";
+    QList<QString>::iterator it = list.begin();
+    QCOMPARE(*it, QLatin1String("foo")); it++;
+    QCOMPARE(*it, QLatin1String("bar")); it++;
+    QCOMPARE(*it, QLatin1String("baz")); it++;
+    QCOMPARE(it, list.end()); it--;
+
+    // walk backwards
+    QCOMPARE(*it, QLatin1String("baz")); it--;
+    QCOMPARE(*it, QLatin1String("bar")); it--;
+    QCOMPARE(*it, QLatin1String("foo"));
+
+    // test erase
+    it = list.erase(it);
+    QVERIFY(list.size() == 2);
+    QCOMPARE(*it, QLatin1String("bar"));
+
+    // test multiple erase
+    it = list.erase(it, it + 2);
+    QVERIFY(list.size() == 0);
+    QCOMPARE(it, list.end());
+
+    // insert again
+    it = list.insert(it, QLatin1String("foo"));
+    QVERIFY(list.size() == 1);
+    QCOMPARE(*it, QLatin1String("foo"));
+
+    // insert again
+    it = list.insert(it, QLatin1String("bar"));
+    QVERIFY(list.size() == 2);
+    QCOMPARE(*it++, QLatin1String("bar"));
+    QCOMPARE(*it, QLatin1String("foo"));
+}
+
 QTEST_APPLESS_MAIN(tst_QList)
 #include "tst_qlist.moc"