From 4ba2513ca6fa42c37c45a573b4643b5e1d97db3b Mon Sep 17 00:00:00 2001
From: Aaron Kennedy <aaron.kennedy@nokia.com>
Date: Wed, 18 Nov 2009 13:25:03 +1000
Subject: tests

---
 src/declarative/util/qmllistaccessor.cpp           | 172 ++++------
 src/declarative/util/qmllistaccessor_p.h           |  12 +-
 .../qmllistaccessor/tst_qmllistaccessor.cpp        | 373 ++++++++++++++++++++-
 3 files changed, 443 insertions(+), 114 deletions(-)

diff --git a/src/declarative/util/qmllistaccessor.cpp b/src/declarative/util/qmllistaccessor.cpp
index 910f2a5..4adec81 100644
--- a/src/declarative/util/qmllistaccessor.cpp
+++ b/src/declarative/util/qmllistaccessor.cpp
@@ -77,8 +77,6 @@ void QmlListAccessor::setList(const QVariant &v, QmlEngine *engine)
         m_type = VariantList;
     } else if (d.canConvert(QVariant::Int)) {
         m_type = Integer;
-    } else if (d.type() != QVariant::UserType) {
-        m_type = Instance;
     } else if ((!enginePrivate && QmlMetaType::isObject(d.userType())) ||
                (enginePrivate && enginePrivate->isObject(d.userType()))) {
         QObject *data = 0;
@@ -89,18 +87,15 @@ void QmlListAccessor::setList(const QVariant &v, QmlEngine *engine)
                (enginePrivate && enginePrivate->isQmlList(d.userType()))) {
         m_type = QmlList;
     } else if (QmlMetaType::isList(d.userType())) {
-        m_type = QList;
+        m_type = QListPtr;
     } else {
-        m_type = Invalid;
-        d = QVariant();
+        m_type = Instance;
     }
 }
 
 int QmlListAccessor::count() const
 {
     switch(m_type) {
-    case Invalid:
-        return 0;
     case StringList:
         return qvariant_cast<QStringList>(d).count();
     case VariantList:
@@ -110,23 +105,25 @@ int QmlListAccessor::count() const
             QmlPrivate::ListInterface *li = *(QmlPrivate::ListInterface **)d.constData();
             return li->count();
         }
-    case QList:
-        return QmlMetaType::listCount(d);
+    case QListPtr:
+        {
+            QList<void *> *li = *(QList<void *> **)d.constData();
+            return li->count();
+        }
     case Instance:
         return 1;
     case Integer:
         return d.toInt();
+    default:
+    case Invalid:
+        return 0;
     }
-
-    return 0;
 }
 
 QVariant QmlListAccessor::at(int idx) const
 {
     Q_ASSERT(idx >= 0 && idx < count());
     switch(m_type) {
-    case Invalid:
-        return QVariant();
     case StringList:
         return QVariant::fromValue(qvariant_cast<QStringList>(d).at(idx));
     case VariantList:
@@ -138,142 +135,119 @@ QVariant QmlListAccessor::at(int idx) const
             li->at(idx, ptr);
             return QVariant::fromValue((QObject*)ptr[0]);
         }
-    case QList:
-        return QmlMetaType::listAt(d, idx);
+    case QListPtr:
+        {
+            QList<void *> *li = *(QList<void *> **)d.constData();
+            void *ptr = li->at(idx);
+            return QVariant::fromValue((QObject*)ptr);
+        }
     case Instance:
         return d;
     case Integer:
+        return QVariant(idx);
+    default:
+    case Invalid:
         return QVariant();
     }
-
-    return QVariant();
 }
 
-void QmlListAccessor::append(const QVariant &value)
+bool QmlListAccessor::append(const QVariant &value)
 {
     switch(m_type) {
-    case Invalid:
-        break;
-    case StringList:
-        {
-            const QString &str = value.toString();
-            qvariant_cast<QStringList>(d).append(str);
-            break;
-        }
-    case VariantList:
-        {
-            qvariant_cast<QVariantList>(d).append(value);
-            break;
-        }
     case QmlList:
         {
             QmlPrivate::ListInterface *li = *(QmlPrivate::ListInterface **)d.constData();
-            li->append(const_cast<void *>(value.constData()));  //XXX
-            break;
+            li->append(const_cast<void *>(value.constData()));  //XXX Typesafety
+            return true;
+        }
+    case QListPtr:
+        {
+            QList<void *> *li = *(QList<void *> **)d.constData();
+            li->append(*reinterpret_cast<void **>(const_cast<void *>(value.constData())));  //XXX Typesafety
+            return true;
         }
-    case QList:
-        QmlMetaType::append(d, value);
-        break;
+    case StringList:
+    case VariantList:
+    case Invalid:
     case Instance:
     case Integer:
-        //do nothing
-        break;
+    default:
+        return false;
     }
 }
 
-void QmlListAccessor::insert(int index, const QVariant &value)
+bool QmlListAccessor::insert(int index, const QVariant &value)
 {
     switch(m_type) {
-    case Invalid:
-        break;
-    case StringList:
-        {
-            const QString &str = value.toString();
-            qvariant_cast<QStringList>(d).insert(index, str);
-            break;
-        }
-    case VariantList:
-        {
-            qvariant_cast<QVariantList>(d).insert(index, value);
-            break;
-        }
     case QmlList:
         {
             QmlPrivate::ListInterface *li = *(QmlPrivate::ListInterface **)d.constData();
-            li->insert(index, const_cast<void *>(value.constData()));   //XXX
-            break;
+            li->insert(index, const_cast<void *>(value.constData()));   //XXX Typesafety
+            return true;
+        }
+    case QListPtr:
+        {
+            QList<void *> *li = *(QList<void *>**)d.constData();
+            li->insert(index, *reinterpret_cast<void **>(const_cast<void *>(value.constData())));  //XXX Typesafety
+            return true;
         }
-    case QList:
-        //XXX needs implementation
-        qWarning() << "insert function not yet implemented for QLists";
-        break;
+    case StringList:
+    case VariantList:
+    case Invalid:
     case Instance:
-        //XXX do nothing?
-        if (index == 0)
-            setList(value);
-        break;
     case Integer:
-        break;
+    default:
+        return false;
     }
 }
 
-void QmlListAccessor::removeAt(int index)
+bool QmlListAccessor::removeAt(int index)
 {
     switch(m_type) {
-    case Invalid:
-        break;
-    case StringList:
-        qvariant_cast<QStringList>(d).removeAt(index);
-        break;
-    case VariantList:
-        qvariant_cast<QVariantList>(d).removeAt(index);
-        break;
     case QmlList:
         {
             QmlPrivate::ListInterface *li = *(QmlPrivate::ListInterface **)d.constData();
             li->removeAt(index);
-            break;
+            return true;
         }
-    case QList:
-        //XXX needs implementation
-        qWarning() << "removeAt function not yet implemented for QLists";
-        break;
+    case QListPtr:
+        {
+            QList<void *> *li = *(QList<void *>**)d.constData();
+            li->removeAt(index);
+            return true;
+        }
+    case StringList:
+    case VariantList:
+    case Invalid:
     case Instance:
-        //XXX do nothing?
-        if (index == 0)
-            setList(QVariant());
-        break;
     case Integer:
-        break;
+    default:
+        return false;
     }
 }
 
-void QmlListAccessor::clear()
+bool QmlListAccessor::clear()
 {
     switch(m_type) {
-    case Invalid:
-        break;
-    case StringList:
-        qvariant_cast<QStringList>(d).clear();
-        break;
-    case VariantList:
-        qvariant_cast<QVariantList>(d).clear();
-        break;
     case QmlList:
         {
             QmlPrivate::ListInterface *li = *(QmlPrivate::ListInterface **)d.constData();
             li->clear();
-            break;
+            return true;
+        }
+    case QListPtr:
+        {
+            QList<void *> *li = *(QList<void *>**)d.constData();
+            li->clear();
+            return true;
         }
-    case QList:
-        QmlMetaType::clear(d);
-        break;
+    case StringList:
+    case VariantList:
+    case Invalid:
     case Instance:
-        //XXX what should we do here?
-        setList(QVariant());
-        break;
     case Integer:
-        d = 0;
+    default:
+        return false;
     }
 }
 
diff --git a/src/declarative/util/qmllistaccessor_p.h b/src/declarative/util/qmllistaccessor_p.h
index 2697606..3c67e3a 100644
--- a/src/declarative/util/qmllistaccessor_p.h
+++ b/src/declarative/util/qmllistaccessor_p.h
@@ -55,7 +55,7 @@ class Q_DECLARATIVE_EXPORT QmlListAccessor
 {
 public:
     QmlListAccessor();
-    virtual ~QmlListAccessor();
+    ~QmlListAccessor();
 
     QVariant list() const;
     void setList(const QVariant &, QmlEngine * = 0);
@@ -65,12 +65,12 @@ public:
     int count() const;
     QVariant at(int) const;
 
-    virtual void append(const QVariant &);
-    virtual void insert(int, const QVariant &);
-    virtual void removeAt(int);
-    virtual void clear();
+    bool append(const QVariant &);
+    bool insert(int, const QVariant &);
+    bool removeAt(int);
+    bool clear();
 
-    enum Type { Invalid, StringList, VariantList, QmlList, QList, Instance, Integer };
+    enum Type { Invalid, StringList, VariantList, QmlList, QListPtr, Instance, Integer };
     Type type() const { return m_type; }
 
 private:
diff --git a/tests/auto/declarative/qmllistaccessor/tst_qmllistaccessor.cpp b/tests/auto/declarative/qmllistaccessor/tst_qmllistaccessor.cpp
index 4c8219a..14de1df 100644
--- a/tests/auto/declarative/qmllistaccessor/tst_qmllistaccessor.cpp
+++ b/tests/auto/declarative/qmllistaccessor/tst_qmllistaccessor.cpp
@@ -50,29 +50,169 @@ public:
     tst_QmlListAccessor() {}
 
 private slots:
+    void invalid();
     void qmllist();
-    //void qlist();
+    void qlist();
     void qstringlist();
+    void qvariantlist();
+    void qobject();
+    void instance();
+    void integer();
 };
 
+void tst_QmlListAccessor::invalid()
+{
+    QmlListAccessor accessor;
+
+    QCOMPARE(accessor.list(), QVariant());
+    QVERIFY(!accessor.isValid());
+    QCOMPARE(accessor.type(), QmlListAccessor::Invalid);
+
+    QCOMPARE(accessor.count(), 0);
+    QCOMPARE(accessor.at(0), QVariant());
+    QCOMPARE(accessor.at(4), QVariant());
+    QVERIFY(!accessor.append(QVariant(10)));
+    QVERIFY(!accessor.insert(0, QVariant(10)));
+    QVERIFY(!accessor.removeAt(0));
+    QVERIFY(!accessor.clear());
+
+    accessor.setList(QVariant());
+
+    QCOMPARE(accessor.list(), QVariant());
+    QVERIFY(!accessor.isValid());
+    QCOMPARE(accessor.type(), QmlListAccessor::Invalid);
+
+    QCOMPARE(accessor.count(), 0);
+    QCOMPARE(accessor.at(0), QVariant());
+    QCOMPARE(accessor.at(4), QVariant());
+    QVERIFY(!accessor.append(QVariant(10)));
+    QVERIFY(!accessor.insert(0, QVariant(10)));
+    QVERIFY(!accessor.removeAt(0));
+    QVERIFY(!accessor.clear());
+}
+
 void tst_QmlListAccessor::qmllist()
 {
     QmlConcreteList<QObject*> list;
-    QObject *obj = new QObject;
+    QObject *obj = new QObject(this);
+    QObject *obj2 = new QObject(this);
+    QObject *obj3 = new QObject(this);
+
     list.append(obj);
     QVERIFY(list.count() == 1);
     QCOMPARE(list.at(0), obj);
 
     QmlListAccessor accessor;
     accessor.setList(qVariantFromValue((QmlList<QObject*>*)&list));
+    QCOMPARE(accessor.list(), qVariantFromValue((QmlList<QObject*>*)&list));
 
+    // type
+    QCOMPARE(accessor.type(), QmlListAccessor::QmlList);
+
+    // isValid
     QVERIFY(accessor.isValid());
-    QVERIFY(accessor.count() == 1);
 
-    QVariant v = accessor.at(0);
-    QCOMPARE(qvariant_cast<QObject*>(v), obj);
+    // count
+    QCOMPARE(accessor.count(), 1);
+
+    // at
+    QCOMPARE(qvariant_cast<QObject*>(accessor.at(0)), obj);
+
+    // append
+    accessor.append(qVariantFromValue(obj2));
+    QVERIFY(accessor.isValid());
+    QCOMPARE(accessor.count(), 2);
+    QCOMPARE(qvariant_cast<QObject*>(accessor.at(1)), obj2);
+    QCOMPARE(list.count(), 2);
+    QCOMPARE(list.at(0), obj);
+    QCOMPARE(list.at(1), obj2);
+
+    // insert
+    accessor.insert(1, qVariantFromValue(obj3));
+    QVERIFY(accessor.isValid());
+    QCOMPARE(accessor.count(), 3);
+    QCOMPARE(qvariant_cast<QObject*>(accessor.at(1)), obj3);
+    QCOMPARE(list.count(), 3);
+    QCOMPARE(list.at(0), obj);
+    QCOMPARE(list.at(1), obj3);
+    QCOMPARE(list.at(2), obj2);
+
+    // removeAt
+    accessor.removeAt(1);
+    QVERIFY(accessor.isValid());
+    QCOMPARE(accessor.count(), 2);
+    QCOMPARE(qvariant_cast<QObject*>(accessor.at(1)), obj2);
+    QCOMPARE(list.count(), 2);
+    QCOMPARE(list.at(0), obj);
+    QCOMPARE(list.at(1), obj2);
 
+    // clear
+    accessor.clear();
     QVERIFY(accessor.isValid());
+    QCOMPARE(accessor.count(), 0);
+    QCOMPARE(list.count(), 0);
+}
+
+void tst_QmlListAccessor::qlist()
+{
+    QList<QObject*> list;
+    QObject *obj = new QObject(this);
+    QObject *obj2 = new QObject(this);
+    QObject *obj3 = new QObject(this);
+
+    list.append(obj);
+    QVERIFY(list.count() == 1);
+    QCOMPARE(list.at(0), obj);
+
+    QmlListAccessor accessor;
+    accessor.setList(qVariantFromValue((QList<QObject*>*)&list));
+    QCOMPARE(accessor.list(), qVariantFromValue((QList<QObject*>*)&list));
+
+    // type
+    QCOMPARE(accessor.type(), QmlListAccessor::QListPtr);
+
+    // isValid
+    QVERIFY(accessor.isValid());
+
+    // count
+    QCOMPARE(accessor.count(), 1);
+
+    // at
+    QCOMPARE(qvariant_cast<QObject*>(accessor.at(0)), obj);
+
+    // append
+    accessor.append(qVariantFromValue(obj2));
+    QVERIFY(accessor.isValid());
+    QCOMPARE(accessor.count(), 2);
+    QCOMPARE(qvariant_cast<QObject*>(accessor.at(1)), obj2);
+    QCOMPARE(list.count(), 2);
+    QCOMPARE(list.at(0), obj);
+    QCOMPARE(list.at(1), obj2);
+
+    // insert
+    accessor.insert(1, qVariantFromValue(obj3));
+    QVERIFY(accessor.isValid());
+    QCOMPARE(accessor.count(), 3);
+    QCOMPARE(qvariant_cast<QObject*>(accessor.at(1)), obj3);
+    QCOMPARE(list.count(), 3);
+    QCOMPARE(list.at(0), obj);
+    QCOMPARE(list.at(1), obj3);
+    QCOMPARE(list.at(2), obj2);
+
+    // removeAt
+    accessor.removeAt(1);
+    QVERIFY(accessor.isValid());
+    QCOMPARE(accessor.count(), 2);
+    QCOMPARE(qvariant_cast<QObject*>(accessor.at(1)), obj2);
+    QCOMPARE(list.count(), 2);
+    QCOMPARE(list.at(0), obj);
+    QCOMPARE(list.at(1), obj2);
+
+    // clear
+    accessor.clear();
+    QVERIFY(accessor.isValid());
+    QCOMPARE(accessor.count(), 0);
+    QCOMPARE(list.count(), 0);
 }
 
 void tst_QmlListAccessor::qstringlist()
@@ -85,16 +225,231 @@ void tst_QmlListAccessor::qstringlist()
     QmlListAccessor accessor;
     accessor.setList(list);
 
+    // type
+    QCOMPARE(accessor.type(), QmlListAccessor::StringList);
+
+    // isValid
+    QVERIFY(accessor.isValid());
+
+    // count
+    QVERIFY(accessor.count() == 2);
+
+    // at
+    QCOMPARE(qvariant_cast<QString>(accessor.at(0)), QLatin1String("Item1"));
+    QCOMPARE(qvariant_cast<QString>(accessor.at(1)), QLatin1String("Item2"));
+
+    // append
+    QVERIFY(!accessor.append(QVariant("Item3")));
+    QVERIFY(accessor.isValid());
+    QVERIFY(accessor.count() == 2);
+    QCOMPARE(qvariant_cast<QString>(accessor.at(0)), QLatin1String("Item1"));
+    QCOMPARE(qvariant_cast<QString>(accessor.at(1)), QLatin1String("Item2"));
+
+    // insert
+    QVERIFY(!accessor.insert(1, QVariant("MiddleItem")));
+    QVERIFY(accessor.isValid());
+    QVERIFY(accessor.count() == 2);
+    QCOMPARE(qvariant_cast<QString>(accessor.at(0)), QLatin1String("Item1"));
+    QCOMPARE(qvariant_cast<QString>(accessor.at(1)), QLatin1String("Item2"));
+
+    // removeAt
+    QVERIFY(!accessor.removeAt(1));
+    QVERIFY(accessor.isValid());
+    QVERIFY(accessor.count() == 2);
+    QCOMPARE(qvariant_cast<QString>(accessor.at(0)), QLatin1String("Item1"));
+    QCOMPARE(qvariant_cast<QString>(accessor.at(1)), QLatin1String("Item2"));
+
+    // clear
+    QVERIFY(!accessor.clear());
+    QVERIFY(accessor.isValid());
+    QVERIFY(accessor.count() == 2);
+    QCOMPARE(qvariant_cast<QString>(accessor.at(0)), QLatin1String("Item1"));
+    QCOMPARE(qvariant_cast<QString>(accessor.at(1)), QLatin1String("Item2"));
+}
+
+void tst_QmlListAccessor::qvariantlist()
+{
+    QVariantList list;
+    list.append(QLatin1String("Item1"));
+    list.append(QLatin1String("Item2"));
+    QVERIFY(list.count() == 2);
+
+    QmlListAccessor accessor;
+    accessor.setList(list);
+
+    // type
+    QCOMPARE(accessor.type(), QmlListAccessor::VariantList);
+
+    // isValid
+    QVERIFY(accessor.isValid());
+
+    // count
+    QVERIFY(accessor.count() == 2);
+
+    // at
+    QCOMPARE(qvariant_cast<QString>(accessor.at(0)), QLatin1String("Item1"));
+    QCOMPARE(qvariant_cast<QString>(accessor.at(1)), QLatin1String("Item2"));
+
+    // append
+    QVERIFY(!accessor.append(QVariant("Item3")));
     QVERIFY(accessor.isValid());
     QVERIFY(accessor.count() == 2);
+    QCOMPARE(qvariant_cast<QString>(accessor.at(0)), QLatin1String("Item1"));
+    QCOMPARE(qvariant_cast<QString>(accessor.at(1)), QLatin1String("Item2"));
+
+    // insert
+    QVERIFY(!accessor.insert(1, QVariant("MiddleItem")));
+    QVERIFY(accessor.isValid());
+    QVERIFY(accessor.count() == 2);
+    QCOMPARE(qvariant_cast<QString>(accessor.at(0)), QLatin1String("Item1"));
+    QCOMPARE(qvariant_cast<QString>(accessor.at(1)), QLatin1String("Item2"));
+
+    // removeAt
+    QVERIFY(!accessor.removeAt(1));
+    QVERIFY(accessor.isValid());
+    QVERIFY(accessor.count() == 2);
+    QCOMPARE(qvariant_cast<QString>(accessor.at(0)), QLatin1String("Item1"));
+    QCOMPARE(qvariant_cast<QString>(accessor.at(1)), QLatin1String("Item2"));
+
+    // clear
+    QVERIFY(!accessor.clear());
+    QVERIFY(accessor.isValid());
+    QVERIFY(accessor.count() == 2);
+    QCOMPARE(qvariant_cast<QString>(accessor.at(0)), QLatin1String("Item1"));
+    QCOMPARE(qvariant_cast<QString>(accessor.at(1)), QLatin1String("Item2"));
+}
+
+void tst_QmlListAccessor::qobject()
+{
+    QObject *obj = new QObject(this);
+
+    QmlListAccessor accessor;
+    accessor.setList(qVariantFromValue(obj));
 
-    QVariant v = accessor.at(0);
-    QCOMPARE(qvariant_cast<QString>(v), QLatin1String("Item1"));
+    // type
+    QCOMPARE(accessor.type(), QmlListAccessor::Instance);
 
-    v = accessor.at(1);
-    QCOMPARE(qvariant_cast<QString>(v), QLatin1String("Item2"));
+    // isValid
+    QVERIFY(accessor.isValid());
+
+    // count
+    QVERIFY(accessor.count() == 1);
+
+    // at
+    QCOMPARE(accessor.at(0), qVariantFromValue(obj));
+
+    // append
+    QVERIFY(!accessor.append(qVariantFromValue((QObject *)0)));
+    QVERIFY(accessor.isValid());
+    QVERIFY(accessor.count() == 1);
+    QCOMPARE(accessor.at(0), qVariantFromValue(obj));
+
+    // insert
+    QVERIFY(!accessor.insert(0, qVariantFromValue((QObject *)0)));
+    QVERIFY(accessor.isValid());
+    QVERIFY(accessor.count() == 1);
+    QCOMPARE(accessor.at(0), qVariantFromValue(obj));
+
+    // removeAt
+    QVERIFY(!accessor.removeAt(0));
+    QVERIFY(accessor.isValid());
+    QVERIFY(accessor.count() == 1);
+    QCOMPARE(accessor.at(0), qVariantFromValue(obj));
+
+    // clear
+    QVERIFY(!accessor.clear());
+    QVERIFY(accessor.isValid());
+    QVERIFY(accessor.count() == 1);
+    QCOMPARE(accessor.at(0), qVariantFromValue(obj));
 }
 
+void tst_QmlListAccessor::instance()
+{
+    QRect r;
+
+    QmlListAccessor accessor;
+    accessor.setList(r);
+
+    // type
+    QCOMPARE(accessor.type(), QmlListAccessor::Instance);
+
+    // isValid
+    QVERIFY(accessor.isValid());
+
+    // count
+    QVERIFY(accessor.count() == 1);
+
+    // at
+    QCOMPARE(accessor.at(0), qVariantFromValue(r));
+
+    // append
+    QVERIFY(!accessor.append(qVariantFromValue(r)));
+    QVERIFY(accessor.isValid());
+    QVERIFY(accessor.count() == 1);
+    QCOMPARE(accessor.at(0), qVariantFromValue(r));
+
+    // insert
+    QVERIFY(!accessor.insert(0, qVariantFromValue(r)));
+    QVERIFY(accessor.isValid());
+    QVERIFY(accessor.count() == 1);
+    QCOMPARE(accessor.at(0), qVariantFromValue(r));
+
+    // removeAt
+    QVERIFY(!accessor.removeAt(0));
+    QVERIFY(accessor.isValid());
+    QVERIFY(accessor.count() == 1);
+    QCOMPARE(accessor.at(0), qVariantFromValue(r));
+
+    // clear
+    QVERIFY(!accessor.clear());
+    QVERIFY(accessor.isValid());
+    QVERIFY(accessor.count() == 1);
+    QCOMPARE(accessor.at(0), qVariantFromValue(r));
+}
+
+void tst_QmlListAccessor::integer()
+{
+    int r = 13;
+
+    QmlListAccessor accessor;
+    accessor.setList(r);
+
+    // type
+    QCOMPARE(accessor.type(), QmlListAccessor::Integer);
+
+    // isValid
+    QVERIFY(accessor.isValid());
+
+    // count
+    QVERIFY(accessor.count() == 13);
+
+    // at
+    QCOMPARE(accessor.at(4), qVariantFromValue(4));
+
+    // append
+    QVERIFY(!accessor.append(qVariantFromValue(r)));
+    QVERIFY(accessor.isValid());
+    QVERIFY(accessor.count() == 13);
+    QCOMPARE(accessor.at(4), qVariantFromValue(4));
+
+    // insert
+    QVERIFY(!accessor.insert(0, qVariantFromValue(r)));
+    QVERIFY(accessor.isValid());
+    QVERIFY(accessor.count() == 13);
+    QCOMPARE(accessor.at(4), qVariantFromValue(4));
+
+    // removeAt
+    QVERIFY(!accessor.removeAt(0));
+    QVERIFY(accessor.isValid());
+    QVERIFY(accessor.count() == 13);
+    QCOMPARE(accessor.at(4), qVariantFromValue(4));
+
+    // clear
+    QVERIFY(!accessor.clear());
+    QVERIFY(accessor.isValid());
+    QVERIFY(accessor.count() == 13);
+    QCOMPARE(accessor.at(4), qVariantFromValue(4));
+}
 
 QTEST_MAIN(tst_QmlListAccessor)
 
-- 
cgit v0.12