Merge lp:~mhr3/dee-qt/changeset-support into lp:dee-qt

[Michal Hruby]

Takes advantage of added changeset API in dee 1.2.7 to map more naturally to Qt's way of dealing with changes to models.

Takes advantage of added changeset API in dee 1.2.7 to map more naturally to Qt's way of dealing with changes to models.

Also added support for generating coverage and added a bunch of tests to bump the coverage number to >95% (from ~50%).

Requires lp:~mhr3/dee/add-changesets

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:88
http://jenkins.qa.ubuntu.com/job/dee-qt-ci/10/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/dee-qt-saucy-amd64-ci/8/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/dee-qt-saucy-armhf-ci/6/console

Click here to trigger a rebuild:
http://s-jenkins:8080/job/dee-qt-ci/10/rebuild

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:88
http://jenkins.qa.ubuntu.com/job/dee-qt-ci/11/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/dee-qt-saucy-amd64-ci/9
    FAILURE: http://jenkins.qa.ubuntu.com/job/dee-qt-saucy-armhf-ci/7/console

Click here to trigger a rebuild:
http://s-jenkins:8080/job/dee-qt-ci/11/rebuild

review: Needs Fixing (continuous-integration)

[Paweł Stołowski (stolowski)]

357 + if (model->d->m_changesetInProgress) {

Shouldn't this say "if (!model->d->m_changesetInProgress) {"?

review: Needs Information

[Paweł Stołowski (stolowski)]

221 + // have the "extra" row from the addition, so we need to hide it
Can you enhance this comment a bit - how is "hiding" actually achieved here?

230 + m_count += m_changesetRowEnd - m_changesetRowStart + 1;
241 + m_count -= m_changesetRowEnd - m_changesetRowStart + 1;

Why "+1"

review: Needs Information

[lp:~mhr3/dee-qt/changeset-support]

89. By Michal Hruby on 2013-09-19

Explain things better, split up the flushing into separate method

[Michal Hruby (mhr3)]

> 357 + if (model->d->m_changesetInProgress) {
>
> Shouldn't this say "if (!model->d->m_changesetInProgress) {"?

No, this is callback for row-changed, in case of transaction we need to flush everything we received so far.

[Michal Hruby (mhr3)]

> 221 + // have the "extra" row from the addition, so we need to hide
> it
> Can you enhance this comment a bit - how is "hiding" actually achieved here?

Updated the comments, hopefully it's more clear now.

> 230 + m_count += m_changesetRowEnd - m_changesetRowStart + 1;
> 241 + m_count -= m_changesetRowEnd - m_changesetRowStart + 1;
>
> Why "+1"

Because a single insert is beginInsertRows(0, 0) => ie rowStart = 0, rowEnd = 0; count += 0 - 0 + 1;
For insertion of two rows: beginInsertRows(0, 1) => rowStart = 0, rowEnd = 1; count += 1 - 0 + 1;

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:89
http://jenkins.qa.ubuntu.com/job/dee-qt-ci/12/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/dee-qt-saucy-amd64-ci/10
    SUCCESS: http://jenkins.qa.ubuntu.com/job/dee-qt-saucy-armhf-ci/8

Click here to trigger a rebuild:
http://s-jenkins:8080/job/dee-qt-ci/12/rebuild

review: Approve (continuous-integration)

[Paweł Stołowski (stolowski)]

398 + // there's an extra row in the backend, skip it by incrementing
399 + row++;
400 + }
401 + } else {
402 + if (d->m_rowBeingRemoved >= 0 && row >= d->m_rowBeingRemoved) {
403 + // we need to skip the about-to-be-removed row
404 + row++;

Why are we skipping only one row? The changeset may span multiple rows, shouldn't this be taken into account?

review: Needs Information

[Michal Hruby (mhr3)]

When processing a transaction/changeset the row-* signals from Dee are used as synchronization points and since the Qt model signals are emitted during the transaction, there's really always just one row that needs to be skipped.

The primary thing here is that the skipping only happens when inside the row-* callback.

Consider how the transaction looks like in pseudocode:

// starting inside dee
var rows = dbus_signal.get_rows_iter();
while (rows.has_next())
{
  row = rows.next();
  var row_signal = this.submit_change(row, out iter);
  this.emit(row_signal, iter, () =>
  {
    // inside the signal emission we get into the DeeListModel plugin code
    if (consecutive_changes(iter)) processChange(...);
    else flushChangesAndProcessChange(() =>
    {
      beginRowsInserted(begin, end);
      // now qt will emit rowsInserted() or rowsRemoved()
      endRowsInserted(begin, end, () =>
      {
        // view code that will read the model
        for (int i = begin; i < end; i++)
          model.data(i, someRole); // at this point we need to skip the row that's currently being added (current iter, always just one)
      });
    });
  });
}

Of course the situation is different when the entire transaction is consecutive:
// starting inside dee
var rows = dbus_signal.get_rows_iter();
while (rows.has_next())
{
  row = rows.next();
  var row_signal = this.submit_change(row, out iter);
  this.emit(row_signal, iter, () => { processChange(...); }
}

this.emit(changeset_finished, () =>
{
  // inside the signal emission we get into the DeeListModel plugin code
  flushChanges(() =>
  {
    beginRowsInserted(begin, end);
    // now qt will emit rowsInserted() or rowsRemoved()
    endRowsInserted(begin, end, () =>
    {
      // view code that will read the model
      for (int i = begin; i < end; i++)
        model.data(i, someRole); // no need to skip anything, models are in sync
    });
  });
});

[Paweł Stołowski (stolowski)]

Nice stuff! Thanks for explanations!

review: Approve

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2013-07-25 14:23:11 +0000
+++ CMakeLists.txt	2013-09-19 17:47:15 +0000
@@ -2,7 +2,7 @@
 cmake_minimum_required(VERSION 2.8.6)
 
 set(SONAME 3)
-set(VERSION 3.2)
+set(VERSION 3.3)
 set(SOVERSION 3.0.0)
 
 # Instruct CMake to run moc automatically when needed.
@@ -10,6 +10,11 @@
 
 # Dependencies
 include(FindPkgConfig)
+
+set(CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake" "${CMAKE_MODULE_PATH}")
+
+include(Coverage)
+
 if (WITHQT5)
   message("Building Qt5 version")
 
@@ -39,7 +44,7 @@
 
 set(QT_DEE_PKGCONFIG_FILE lib${DEE_QT_LIBNAME}.pc)
 
-pkg_check_modules(DEE REQUIRED dee-1.0)
+pkg_check_modules(DEE REQUIRED dee-1.0>=1.2.7)
 
 # Build flags
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fvisibility=hidden -Wall -Wundef -std=c++0x")

=== added directory 'cmake'
=== added file 'cmake/COPYING-CMAKE-SCRIPTS'
--- cmake/COPYING-CMAKE-SCRIPTS	1970-01-01 00:00:00 +0000
+++ cmake/COPYING-CMAKE-SCRIPTS	2013-09-19 17:47:15 +0000
@@ -0,0 +1,22 @@
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+1. Redistributions of source code must retain the copyright
+   notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+3. The name of the author may not be used to endorse or promote products 
+   derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

=== added file 'cmake/Coverage.cmake'
--- cmake/Coverage.cmake	1970-01-01 00:00:00 +0000
+++ cmake/Coverage.cmake	2013-09-19 17:47:15 +0000
@@ -0,0 +1,37 @@
+if (CMAKE_BUILD_TYPE MATCHES coverage)
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} --coverage")
+  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} --coverage")
+  set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} --coverage")
+  set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} --coverage")
+
+  find_program(GCOVR_EXECUTABLE gcovr HINTS ${GCOVR_ROOT} "${GCOVR_ROOT}/bin")
+  if (NOT GCOVR_EXECUTABLE)
+    message(STATUS "Gcovr binary was not found, can not generate XML coverage info.")
+  else ()
+    message(STATUS "Gcovr found, can generate XML coverage info.")
+    add_custom_target (coverage-xml
+      WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
+      COMMAND "${GCOVR_EXECUTABLE}" --exclude="test.*" --exclude="obj.*" -x -r "${CMAKE_SOURCE_DIR}" 
+      --object-directory=${CMAKE_BINARY_DIR} -o coverage.xml)
+  endif()
+
+  find_program(LCOV_EXECUTABLE lcov HINTS ${LCOV_ROOT} "${GCOVR_ROOT}/bin")
+  find_program(GENHTML_EXECUTABLE genhtml HINTS ${GENHTML_ROOT})
+  if (NOT LCOV_EXECUTABLE)
+    message(STATUS "Lcov binary was not found, can not generate HTML coverage info.")
+  else ()
+    if(NOT GENHTML_EXECUTABLE)
+      message(STATUS "Genthml binary not found, can not generate HTML coverage info.")
+    else()
+      message(STATUS "Lcov and genhtml found, can generate HTML coverage info.")
+      add_custom_target (coverage-html
+        WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
+        COMMAND "${LCOV_EXECUTABLE}" --capture --output-file "${CMAKE_BINARY_DIR}/coverage.info" --no-checksum --directory "${CMAKE_BINARY_DIR}"
+        COMMAND "${LCOV_EXECUTABLE}" --remove "${CMAKE_BINARY_DIR}/coverage.info" '/usr/*' --output-file "${CMAKE_BINARY_DIR}/coverage.info" 
+        COMMAND "${LCOV_EXECUTABLE}" --remove "${CMAKE_BINARY_DIR}/coverage.info" '${CMAKE_BINARY_DIR}/moc_*' --output-file "${CMAKE_BINARY_DIR}/coverage.info" 
+        COMMAND "${LCOV_EXECUTABLE}" --remove "${CMAKE_BINARY_DIR}/coverage.info" '${CMAKE_SOURCE_DIR}/tests/*' --output-file "${CMAKE_BINARY_DIR}/coverage.info" 
+        COMMAND "${GENHTML_EXECUTABLE}" --prefix "${CMAKE_BINARY_DIR}" --output-directory coveragereport --title "Code Coverage" --legend --show-details coverage.info
+        )
+    endif()
+  endif()
+endif()

=== modified file 'debian/changelog'
--- debian/changelog	2013-08-21 16:18:56 +0000
+++ debian/changelog	2013-09-19 17:47:15 +0000
@@ -1,3 +1,9 @@
+dee-qt (3.3-0ubuntu1) UNRELEASED; urgency=low
+
+  * Take advantage of new changeset API in dee
+
+ -- Michal Hruby <[e-mail]>  Tue, 10 Sep 2013 16:56:00 +0100
+
 dee-qt (3.2+13.10.20130821.1-0ubuntu1) saucy; urgency=low
 
   [ Albert Astals ]

=== modified file 'deelistmodel.cpp'
--- deelistmodel.cpp	2013-08-21 11:03:07 +0000
+++ deelistmodel.cpp	2013-09-19 17:47:15 +0000
@@ -28,6 +28,19 @@
 
 class DeeListModelPrivate {
 public:
+    enum ProcessingState
+    {
+        START,
+        ADDITIONS,
+        REMOVALS
+    };
+
+    enum ChangeType
+    {
+        ADDITION,
+        REMOVAL
+    };
+
     DeeListModelPrivate(DeeListModel* parent);
     ~DeeListModelPrivate();
 
@@ -37,22 +50,43 @@
     void createRoles();
     bool synchronized() const;
 
+    void processChange(ChangeType changeType, int changePos);
+    void flushChanges();
+
     /* GObject signal handlers for m_deeModel */
     static void onSynchronizedChanged(GObject* emitter, GParamSpec *pspec, DeeListModel* model);
     static void onRowAdded(GObject* emitter, DeeModelIter* iter, DeeListModel* model);
     static void onRowRemoved(GObject* emitter, DeeModelIter* iter, DeeListModel* model);
     static void onRowChanged(GObject* emitter, DeeModelIter* iter, DeeListModel* model);
 
+    static void onStartChangeset(DeeListModel* model);
+    static void onFinishChangeset(DeeListModel* model);
+
     DeeListModel* m_parent;
     DeeModel* m_deeModel;
     QString m_name;
     int m_count;
     bool m_listeningSynchronized;
     QHash<int, QByteArray> m_roleNames;
+    int m_rowBeingAdded;
     int m_rowBeingRemoved;
+    ProcessingState m_changesetState;
+    bool m_changesetInProgress;
+    int m_changesetRowStart;
+    int m_changesetRowEnd;
 };
 
-DeeListModelPrivate::DeeListModelPrivate(DeeListModel* parent) : m_parent(parent), m_deeModel(NULL), m_count(0), m_listeningSynchronized(false), m_rowBeingRemoved(-1)
+DeeListModelPrivate::DeeListModelPrivate(DeeListModel* parent)
+    : m_parent(parent)
+    , m_deeModel(NULL)
+    , m_count(0)
+    , m_listeningSynchronized(false)
+    , m_rowBeingAdded(-1)
+    , m_rowBeingRemoved(-1)
+    , m_changesetState(ProcessingState::START)
+    , m_changesetInProgress(false)
+    , m_changesetRowStart(-1)
+    , m_changesetRowEnd(-1)
 {
 }
 
@@ -72,7 +106,10 @@
         }
         g_object_disconnect(m_deeModel, "any_signal", G_CALLBACK(onRowAdded), m_parent,
                                         "any_signal", G_CALLBACK(onRowRemoved), m_parent,
-                                        "any_signal", G_CALLBACK(onRowChanged), m_parent, NULL);
+                                        "any_signal", G_CALLBACK(onRowChanged), m_parent,
+                                        "any_signal", G_CALLBACK(onStartChangeset), m_parent,
+                                        "any_signal", G_CALLBACK(onFinishChangeset), m_parent,
+                                        NULL);
 
         g_object_unref(m_deeModel);
         m_deeModel = NULL;
@@ -104,6 +141,8 @@
     g_signal_connect(m_deeModel, "row-added", G_CALLBACK(onRowAdded), m_parent);
     g_signal_connect(m_deeModel, "row-removed", G_CALLBACK(onRowRemoved), m_parent);
     g_signal_connect(m_deeModel, "row-changed", G_CALLBACK(onRowChanged), m_parent);
+    g_signal_connect_swapped(m_deeModel, "changeset-started", G_CALLBACK(onStartChangeset), m_parent);
+    g_signal_connect_swapped(m_deeModel, "changeset-finished", G_CALLBACK(onFinishChangeset), m_parent);
     if (synchronized())
     {
         createRoles();
@@ -134,6 +173,90 @@
 }
 
 void
+DeeListModelPrivate::flushChanges()
+{
+    bool countChanged = false;
+    // The problem we're facing here is that the signals emitted by DeeListModel are not completely
+    // in sync with the backend DeeModel - Qt will likely call our data() method right after calling
+    // end{Insert|Remove}Rows() and the backend model might still have extra rows, because we're
+    // inside onRowRemoved/onRowAdded callback
+    // See the data() method for more details
+    if (m_changesetState == ProcessingState::ADDITIONS) {
+        /* Force emission of QAbstractItemModel::rowsInserted by calling
+           beginInsertRows and endInsertRows. Necessary because according to the
+           documentation:
+           "It can only be emitted by the QAbstractItemModel implementation, and
+            cannot be explicitly emitted in subclass code."
+        */
+        m_parent->beginInsertRows(QModelIndex(), m_changesetRowStart, m_changesetRowEnd);
+        m_count += m_changesetRowEnd - m_changesetRowStart + 1;
+        countChanged = true;
+        m_parent->endInsertRows();
+    } else if (m_changesetState == ProcessingState::REMOVALS) {
+        /* Force emission of QAbstractItemModel::rowsRemoved by calling
+           beginRemoveRows and endRemoveRows. Necessary because according to the
+           documentation:
+           "It can only be emitted by the QAbstractItemModel implementation, and
+            cannot be explicitly emitted in subclass code."
+        */
+        m_parent->beginRemoveRows(QModelIndex(), m_changesetRowStart, m_changesetRowEnd);
+        m_count -= m_changesetRowEnd - m_changesetRowStart + 1;
+        countChanged = true;
+        m_parent->endRemoveRows();
+    }
+
+    if (countChanged) Q_EMIT m_parent->countChanged();
+
+    m_changesetState = ProcessingState::START;
+    m_changesetRowStart = -1;
+    m_changesetRowEnd = -1;
+}
+
+void
+DeeListModelPrivate::processChange(ChangeType changeType, int changePos)
+{
+    /* flush if changeType doesn't match current processing state */
+    if (m_changesetState != ProcessingState::START &&
+            ((changeType == ChangeType::ADDITION && m_changesetState != ProcessingState::ADDITIONS) ||
+            (changeType == ChangeType::REMOVAL && m_changesetState != ProcessingState::REMOVALS))) {
+        flushChanges();
+    }
+
+    /* flush also if current changeType isn't consecutive:
+     * - consecutive additions are if changePos == m_changesetRowEnd + 1
+     * - consecutive removals are if changePos == m_changesetRowStart
+     */
+    if ((m_changesetState == ProcessingState::ADDITIONS && changePos != m_changesetRowEnd + 1) ||
+            (m_changesetState == ProcessingState::REMOVALS && changePos != m_changesetRowStart)) {
+        flushChanges();
+    }
+
+    switch (m_changesetState) {
+        case ProcessingState::START:
+            switch (changeType) {
+                case ChangeType::ADDITION:
+                    m_changesetState = ProcessingState::ADDITIONS;
+                    m_changesetRowStart = changePos;
+                    m_changesetRowEnd = changePos;
+                    break;
+                case ChangeType::REMOVAL:
+                    m_changesetState = ProcessingState::REMOVALS;
+                    m_changesetRowStart = changePos;
+                    m_changesetRowEnd = changePos;
+                    break;
+                default: break;
+            }
+            break;
+        case ProcessingState::ADDITIONS:
+            m_changesetRowEnd = changePos;
+            break;
+        case ProcessingState::REMOVALS:
+            m_changesetRowEnd++;
+            break;
+    }
+}
+
+void
 DeeListModelPrivate::createRoles()
 {
     if (m_deeModel == NULL) {
@@ -182,16 +305,14 @@
     }
 
     gint position = dee_model_get_position(model->d->m_deeModel, iter);
-    /* Force emission of QAbstractItemModel::rowsInserted by calling
-       beginInsertRows and endInsertRows. Necessary because according to the
-       documentation:
-       "It can only be emitted by the QAbstractItemModel implementation, and
-        cannot be explicitly emitted in subclass code."
-    */
-    model->beginInsertRows(QModelIndex(), position, position);
-    model->d->m_count++;
-    model->endInsertRows();
-    Q_EMIT model->countChanged();
+
+    /* if we're inside transaction, we'll consider this row hidden */
+    model->d->m_rowBeingAdded = position;
+    model->d->processChange(ChangeType::ADDITION, position);
+    if (!model->d->m_changesetInProgress) {
+        model->d->flushChanges();
+    }
+    model->d->m_rowBeingAdded = -1;
 }
 
 void
@@ -204,22 +325,17 @@
     }
 
     /* Note that at this point the row is still present and valid in the DeeModel.
-       Therefore the value returned by dee_model_get_n_columns() might not be
+       Therefore the value returned by dee_model_get_n_rows() might not be
        what one would expect.
        See Dee's dee_sequence_model_remove() method.
     */
     gint position = dee_model_get_position(model->d->m_deeModel, iter);
-    /* Force emission of QAbstractItemModel::rowsRemoved by calling
-       beginRemoveRows and endRemoveRows. Necessary because according to the
-       documentation:
-       "It can only be emitted by the QAbstractItemModel implementation, and
-        cannot be explicitly emitted in subclass code."
-    */
-    model->beginRemoveRows(QModelIndex(), position, position);
+
     model->d->m_rowBeingRemoved = position;
-    model->d->m_count--;
-    model->endRemoveRows();
-    Q_EMIT model->countChanged();
+    model->d->processChange(ChangeType::REMOVAL, position);
+    if (!model->d->m_changesetInProgress) {
+        model->d->flushChanges();
+    }
     model->d->m_rowBeingRemoved = -1;
 }
 
@@ -232,11 +348,30 @@
         return;
     }
 
+    /* If we're inside a transaction we need to flush the currently queued
+     * changes and emit the dataChanged signal after that */
+    if (model->d->m_changesetInProgress) {
+        model->d->flushChanges();
+    }
+
     gint position = dee_model_get_position(model->d->m_deeModel, iter);
     QModelIndex index = model->index(position);
     Q_EMIT model->dataChanged(index, index);
 }
 
+void
+DeeListModelPrivate::onStartChangeset(DeeListModel* model)
+{
+    model->d->m_changesetInProgress = true;
+}
+
+void
+DeeListModelPrivate::onFinishChangeset(DeeListModel* model)
+{
+    model->d->flushChanges();
+    model->d->m_changesetInProgress = false;
+}
+
 
 
 DeeListModel::DeeListModel(QObject *parent) :
@@ -320,8 +455,22 @@
     DeeModelIter* iter;
 
     int row = index.row();
-    if (d->m_rowBeingRemoved >= 0 && row >= d->m_rowBeingRemoved) {
-        row++;
+    // we're inside the row-{added|removed} callback and the backend model still has the removed row
+    // (in case of row-removed) or already has the added row (in case of row-added), there are two cases:
+    // 1) inside a transaction, we need to hide about-to-be-added row (because we just flushed changes unrelated
+    //    to this addition)
+    // 2) outside of transaction, we need to hide about-to-be-removed row (because we're flushing right after
+    //    receiving the signal)
+    if (d->m_changesetInProgress) {
+        if (d->m_rowBeingAdded >= 0 && row >= d->m_rowBeingAdded) {
+            // there's an extra row in the backend, skip it by incrementing
+            row++;
+        }
+    } else {
+        if (d->m_rowBeingRemoved >= 0 && row >= d->m_rowBeingRemoved) {
+            // we need to skip the about-to-be-removed row
+            row++;
+        }
     }
 
     iter = dee_model_get_iter_at_row(d->m_deeModel, row);

=== modified file 'tests/CMakeLists.txt'
--- tests/CMakeLists.txt	2012-11-30 14:51:06 +0000
+++ tests/CMakeLists.txt	2013-09-19 17:47:15 +0000
@@ -15,9 +15,18 @@
 add_executable(conversiontest conversiontest.cpp)
 target_link_libraries(conversiontest ${OUR_QT_TEST_LIB} ${DEE_QT_LIBNAME})
 set_target_properties(conversiontest PROPERTIES COMPILE_FLAGS -fPIC)
-add_test(NAME conversiontest COMMAND "dbus-test-runner" "--task" "${CMAKE_CURRENT_BINARY_DIR}/conversiontest" "-p" "-xunitxml" "-p" "-o" "-p" "conversiontest-xunit.xml")
+add_test(NAME conversiontest COMMAND "${CMAKE_CURRENT_BINARY_DIR}/conversiontest" "-o" "${CMAKE_CURRENT_BINARY_DIR}/conversiontest-xunit.xml,xunitxml" "-o" "-,txt")
 set_property(TEST conversiontest PROPERTY ENVIRONMENT "LD_LIBRARY_PATH=.")
 
+if (WITHQT5)
+	# the test is using signal connections with lambdas, only available in Qt5
+	add_executable(signaltest signaltest.cpp)
+	target_link_libraries(signaltest ${OUR_QT_TEST_LIB} ${DEE_QT_LIBNAME})
+	set_target_properties(signaltest PROPERTIES COMPILE_FLAGS -fPIC)
+	add_test(NAME signaltest COMMAND "${CMAKE_CURRENT_BINARY_DIR}/signaltest" "-o" "${CMAKE_CURRENT_BINARY_DIR}/signaltest-xunit.xml,xunitxml" "-o" "-,txt")
+	set_property(TEST signaltest PROPERTY ENVIRONMENT "LD_LIBRARY_PATH=.")
+endif ()
+
 add_executable(test-helper test-helper.cpp)
 target_link_libraries(test-helper ${OUR_QT_CORE_LIB} ${OUR_QT_DBUS_LIB} ${DEE_LDFLAGS})
 set_target_properties(test-helper PROPERTIES COMPILE_FLAGS -fPIC)

=== modified file 'tests/conversiontest.cpp'
--- tests/conversiontest.cpp	2013-06-21 17:12:07 +0000
+++ tests/conversiontest.cpp	2013-09-19 17:47:15 +0000
@@ -31,15 +31,11 @@
       g_type_init();
     }
 
-    void GVariantToQVariantConversionTest()
+    void ModelQVariantConversionTest()
     {
-      DeeModel* model = dee_shared_model_new("com.deeqt.conversiontest");
+      DeeModel* model = dee_sequence_model_new();
       dee_model_set_schema(model, "b", "y", "n", "q", "i", "u", "x", "t", "d", "s", "a(ii)", "a{sv}", NULL);
 
-      // Doc says we need to be synchronized before doing anything
-      while(!dee_shared_model_is_synchronized(DEE_SHARED_MODEL(model)))
-        qApp->processEvents();
-
       GVariant **tuples = g_new(GVariant *, 2);
 
       GVariant **t1 = g_new(GVariant *, 2);
@@ -68,6 +64,7 @@
       QCOMPARE(model_qt.count(), 0);
 
       model_qt.setModel(model);
+      QCOMPARE(model_qt.synchronized(), true);
       QCOMPARE(model_qt.count(), 1);
 
       const QModelIndex row0Index = model_qt.index(0, 0);
@@ -99,6 +96,62 @@
       g_free(t2);
       g_object_unref(model);
     }
+
+    void GVariantToQVariantConversionTest()
+    {
+      GVariant **tuples = g_new(GVariant *, 2);
+
+      GVariant **t1 = g_new(GVariant *, 2);
+      t1[0] = g_variant_new_int32(1);
+      t1[1] = g_variant_new_int32(2);
+      tuples[0] = g_variant_new_tuple(t1, 2);
+
+      GVariant **t2 = g_new(GVariant *, 2);
+      t2[0] = g_variant_new_int32(3);
+      t2[1] = g_variant_new_int32(4);
+      tuples[1] = g_variant_new_tuple(t2, 2);
+
+      GVariant* array_of_tuples = g_variant_new_array(((const GVariantType *) "(ii)"), tuples, 2);
+
+      QVariant variant(DeeListModel::VariantForData(array_of_tuples));
+
+      QList< QVariant > expected_array;
+      QList< QVariant > tuple1, tuple2;
+      tuple1 << 1 << 2;
+      tuple2 << 3 << 4;
+      expected_array << QVariant(tuple1) << QVariant(tuple2);
+      QCOMPARE(variant, QVariant(expected_array));
+
+      g_free(t1);
+      g_free(t2);
+      g_free(tuples);
+
+      GVariant* nested_variant = g_variant_new_variant(g_variant_new_string("nested"));
+      variant = DeeListModel::VariantForData(nested_variant);
+      QCOMPARE(variant.toString(), QString("nested"));
+    }
+
+    void QVariantToGVariantConversionTest()
+    {
+      int cnt = 0;
+      GVariant **children = new GVariant*[8];
+      children[cnt++] = g_variant_new_dict_entry(g_variant_new_string("int"), g_variant_new_variant(g_variant_new_int32(-82)));
+      children[cnt++] = g_variant_new_dict_entry(g_variant_new_string("bool"), g_variant_new_variant(g_variant_new_boolean(TRUE)));
+      children[cnt++] = g_variant_new_dict_entry(g_variant_new_string("string"), g_variant_new_variant(g_variant_new_string("foo")));
+      children[cnt++] = g_variant_new_dict_entry(g_variant_new_string("uint"), g_variant_new_variant(g_variant_new_uint32(90)));
+      children[cnt++] = g_variant_new_dict_entry(g_variant_new_string("int64"), g_variant_new_variant(g_variant_new_int64(-401230)));
+      children[cnt++] = g_variant_new_dict_entry(g_variant_new_string("uint64"), g_variant_new_variant(g_variant_new_uint64(401230)));
+      children[cnt++] = g_variant_new_dict_entry(g_variant_new_string("double"), g_variant_new_variant(g_variant_new_double(3.1415)));
+      children[cnt++] = g_variant_new_dict_entry(g_variant_new_string("int-array"), g_variant_new_variant(g_variant_new_parsed("[1, 2, 3]")));
+      GVariant* hints = g_variant_new_array(G_VARIANT_TYPE("{sv}"), children, cnt);
+
+      QVariant variant(DeeListModel::VariantForData(hints));
+      GVariant* reconstructed_gvariant = DeeListModel::DataFromVariant(variant);
+
+      // the ordering in the variant might be different, so don't compare directly
+      QVERIFY(g_variant_type_equal(g_variant_get_type(hints), g_variant_get_type(reconstructed_gvariant)));
+      QCOMPARE(g_variant_n_children(hints), g_variant_n_children(reconstructed_gvariant));
+    }
 };
 
 QTEST_MAIN(ConversionTest)

=== modified file 'tests/deelistmodeltest.cpp'
--- tests/deelistmodeltest.cpp	2012-11-30 12:56:33 +0000
+++ tests/deelistmodeltest.cpp	2013-09-19 17:47:15 +0000
@@ -87,12 +87,10 @@
 
     void setExistingModelTest()
     {
-        DeeModel* model = dee_shared_model_new("com.deeqt.test.model");
-
         DeeListModel model_qt;
         QCOMPARE(model_qt.count(), 0);
 
-        model_qt.setModel(model);
+        model_qt.setName("com.deeqt.test.model");
         QCOMPARE(model_qt.synchronized(), false);
 
         while(!model_qt.synchronized())
@@ -101,6 +99,10 @@
         QCOMPARE(model_qt.synchronized(), true);
         QCOMPARE(model_qt.roleNames().count(), 1);
         QCOMPARE(model_qt.roleNames()[0], QByteArray("column_0"));
+
+        model_qt.setName("");
+        QCOMPARE(model_qt.synchronized(), false);
+        QCOMPARE(model_qt.rowCount(), 0);
     }
     
     void cleanupTestCase()

=== added file 'tests/signaltest.cpp'
--- tests/signaltest.cpp	1970-01-01 00:00:00 +0000
+++ tests/signaltest.cpp	2013-09-19 17:47:15 +0000
@@ -0,0 +1,574 @@
+/*
+ * Copyright (C) 2012 Canonical, Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <QtTest>
+#include <QObject>
+
+#include "deelistmodel.h"
+
+#include <dee.h>
+
+class DeeListModelTest : public QObject
+{
+    Q_OBJECT
+
+private Q_SLOTS:
+    void initTestCase()
+    {
+    }
+
+    void synchronizationTest()
+    {
+        DeeModel* model = dee_sequence_model_new();
+        dee_model_set_schema(model, "s", "i", NULL);
+
+        DeeListModel model_qt;
+        QCOMPARE(model_qt.rowCount(), 0);
+        QCOMPARE(model_qt.count(), 0);
+
+        model_qt.setModel(model);
+        QCOMPARE(model_qt.synchronized(), true);
+        QVERIFY(model_qt.name().isNull());
+
+        model_qt.setModel(NULL);
+        QCOMPARE(model_qt.synchronized(), false);
+        QCOMPARE(model_qt.rowCount(), 0);
+        QCOMPARE(model_qt.count(), 0);
+    }
+
+    void emitBasicSignalsTest()
+    {
+        DeeModel* model = dee_sequence_model_new();
+        dee_model_set_schema(model, "s", "i", NULL);
+
+        DeeListModel model_qt;
+        model_qt.setModel(model);
+
+        int num_insertions = 0;
+
+        connect(&model_qt, &QAbstractItemModel::rowsInserted, [&num_insertions] (const QModelIndex &parent, int start, int end) {
+            num_insertions++;
+        });
+
+        dee_model_append(model, "foo", 5);
+
+        QCOMPARE(num_insertions, 1);
+        QCOMPARE(model_qt.count(), 1);
+        QCOMPARE(model_qt.rowCount(), 1);
+        QCOMPARE(model_qt.data(model_qt.index(0, 0), 0).toString(), QString("foo"));
+        QCOMPARE(model_qt.data(model_qt.index(0, 0), 1).toInt(), 5);
+
+        int num_removals = 0;
+        connect(&model_qt, &QAbstractItemModel::rowsRemoved, [&num_removals] (const QModelIndex &parent, int start, int end) {
+            num_removals++;
+        });
+
+        dee_model_remove(model, dee_model_get_first_iter(model));
+
+        QCOMPARE(num_removals, 1);
+        QCOMPARE(model_qt.count(), 0);
+        QCOMPARE(model_qt.rowCount(), 0);
+        QCOMPARE(num_insertions, 1);
+    }
+
+    void emitMultipleSignalsTest()
+    {
+        DeeModel* model = dee_sequence_model_new();
+        dee_model_set_schema(model, "s", "i", NULL);
+
+        DeeListModel model_qt;
+        model_qt.setModel(model);
+
+        int num_insertions = 0;
+
+        connect(&model_qt, &QAbstractItemModel::rowsInserted, [&num_insertions] (const QModelIndex &parent, int start, int end) {
+            num_insertions++;
+        });
+
+        dee_model_append(model, "foo", 5);
+        QCOMPARE(num_insertions, 1);
+        QCOMPARE(model_qt.count(), 1);
+        QCOMPARE(model_qt.rowCount(), 1);
+        dee_model_append(model, "bar", 6);
+        QCOMPARE(num_insertions, 2);
+        QCOMPARE(model_qt.count(), 2);
+        QCOMPARE(model_qt.rowCount(), 2);
+        dee_model_append(model, "baz", 7);
+        QCOMPARE(num_insertions, 3);
+        QCOMPARE(model_qt.count(), 3);
+        QCOMPARE(model_qt.rowCount(), 3);
+        dee_model_append(model, "qoo", 8);
+
+        QCOMPARE(num_insertions, 4);
+        QCOMPARE(model_qt.count(), 4);
+        QCOMPARE(model_qt.rowCount(), 4);
+
+        QCOMPARE(model_qt.data(model_qt.index(0, 0), 0).toString(), QString("foo"));
+        QCOMPARE(model_qt.data(model_qt.index(0, 0), 1).toInt(), 5);
+        QCOMPARE(model_qt.data(model_qt.index(1, 0), 0).toString(), QString("bar"));
+        QCOMPARE(model_qt.data(model_qt.index(1, 0), 1).toInt(), 6);
+        QCOMPARE(model_qt.data(model_qt.index(2, 0), 0).toString(), QString("baz"));
+        QCOMPARE(model_qt.data(model_qt.index(2, 0), 1).toInt(), 7);
+        QCOMPARE(model_qt.data(model_qt.index(3, 0), 0).toString(), QString("qoo"));
+        QCOMPARE(model_qt.data(model_qt.index(3, 0), 1).toInt(), 8);
+
+        int num_removals = 0;
+        connect(&model_qt, &QAbstractItemModel::rowsRemoved, [&num_removals] (const QModelIndex &parent, int start, int end) {
+            num_removals++;
+        });
+
+        num_insertions = 0;
+
+        dee_model_remove(model, dee_model_get_first_iter(model));
+        QCOMPARE(num_removals, 1);
+        QCOMPARE(model_qt.count(), 3);
+        QCOMPARE(model_qt.rowCount(), 3);
+        dee_model_remove(model, dee_model_get_first_iter(model));
+        QCOMPARE(num_removals, 2);
+        QCOMPARE(model_qt.count(), 2);
+        QCOMPARE(model_qt.rowCount(), 2);
+        dee_model_remove(model, dee_model_get_first_iter(model));
+        QCOMPARE(num_removals, 3);
+        QCOMPARE(model_qt.count(), 1);
+        QCOMPARE(model_qt.rowCount(), 1);
+        dee_model_remove(model, dee_model_get_first_iter(model));
+        QCOMPARE(num_removals, 4);
+        QCOMPARE(model_qt.count(), 0);
+        QCOMPARE(model_qt.rowCount(), 0);
+        dee_model_clear(model);
+        QCOMPARE(num_removals, 4);
+        QCOMPARE(model_qt.count(), 0);
+        QCOMPARE(model_qt.rowCount(), 0);
+
+        QCOMPARE(num_insertions, 0);
+    }
+
+    void emitConsecutiveInsertsTest()
+    {
+        DeeModel* model = dee_sequence_model_new();
+        dee_model_set_schema(model, "s", "i", NULL);
+
+        DeeListModel model_qt;
+        model_qt.setModel(model);
+
+        int num_insertions = 0;
+
+        connect(&model_qt, &QAbstractItemModel::rowsInserted, [&num_insertions] (const QModelIndex &parent, int start, int end) {
+            num_insertions++;
+        });
+
+        dee_model_begin_changeset(model);
+
+        dee_model_append(model, "foo", 5);
+        dee_model_append(model, "bar", 6);
+        dee_model_append(model, "baz", 7);
+        dee_model_append(model, "qoo", 8);
+
+        QCOMPARE(num_insertions, 0);
+
+        dee_model_end_changeset(model);
+
+        QCOMPARE(num_insertions, 1);
+        QCOMPARE(model_qt.count(), 4);
+        QCOMPARE(model_qt.rowCount(), 4);
+
+        QCOMPARE(model_qt.data(model_qt.index(0, 0), 0).toString(), QString("foo"));
+        QCOMPARE(model_qt.data(model_qt.index(0, 0), 1).toInt(), 5);
+        QCOMPARE(model_qt.data(model_qt.index(1, 0), 0).toString(), QString("bar"));
+        QCOMPARE(model_qt.data(model_qt.index(1, 0), 1).toInt(), 6);
+        QCOMPARE(model_qt.data(model_qt.index(2, 0), 0).toString(), QString("baz"));
+        QCOMPARE(model_qt.data(model_qt.index(2, 0), 1).toInt(), 7);
+        QCOMPARE(model_qt.data(model_qt.index(3, 0), 0).toString(), QString("qoo"));
+        QCOMPARE(model_qt.data(model_qt.index(3, 0), 1).toInt(), 8);
+
+        QVariantMap row2 = model_qt.get(2);
+        QCOMPARE(row2["column_0"].toString(), QString("baz"));
+        QCOMPARE(row2["column_1"].toInt(), 7);
+    }
+
+    void emitConsecutiveRemovalsTest()
+    {
+        DeeModel* model = dee_sequence_model_new();
+        dee_model_set_schema(model, "s", "i", NULL);
+
+        DeeListModel model_qt;
+        model_qt.setModel(model);
+
+        dee_model_append(model, "foo", 5);
+        dee_model_append(model, "bar", 6);
+        dee_model_append(model, "baz", 7);
+        dee_model_append(model, "qoo", 8);
+
+        QCOMPARE(model_qt.count(), 4);
+        QCOMPARE(model_qt.rowCount(), 4);
+
+        int num_removals = 0;
+
+        connect(&model_qt, &QAbstractItemModel::rowsRemoved, [&num_removals] (const QModelIndex &parent, int start, int end) {
+            num_removals++;
+        });
+
+        dee_model_begin_changeset(model);
+
+        dee_model_clear(model);
+
+        dee_model_end_changeset(model);
+
+        QCOMPARE(num_removals, 1);
+        QCOMPARE(model_qt.count(), 0);
+        QCOMPARE(model_qt.rowCount(), 0);
+    }
+    
+    void emitConsecutiveInsertsWithChangeTest()
+    {
+        DeeModel* model = dee_sequence_model_new();
+        dee_model_set_schema(model, "s", "i", NULL);
+
+        DeeListModel model_qt;
+        model_qt.setModel(model);
+
+        int num_insertions = 0;
+
+        connect(&model_qt, &QAbstractItemModel::rowsInserted, [&num_insertions] (const QModelIndex &parent, int start, int end) {
+            num_insertions++;
+        });
+
+        dee_model_begin_changeset(model);
+
+        dee_model_append(model, "koo", -5);
+        dee_model_append(model, "bar", 6);
+        dee_model_append(model, "baz", 7);
+        dee_model_set(model, dee_model_get_first_iter(model), "foo", 5);
+        dee_model_append(model, "qoo", 8);
+
+        QCOMPARE(num_insertions, 1);
+        QCOMPARE(model_qt.count(), 3);
+        QCOMPARE(model_qt.rowCount(), 3);
+
+        QCOMPARE(model_qt.data(model_qt.index(0, 0), 0).toString(), QString("foo"));
+        QCOMPARE(model_qt.data(model_qt.index(0, 0), 1).toInt(), 5);
+        QCOMPARE(model_qt.data(model_qt.index(1, 0), 0).toString(), QString("bar"));
+        QCOMPARE(model_qt.data(model_qt.index(1, 0), 1).toInt(), 6);
+        QCOMPARE(model_qt.data(model_qt.index(2, 0), 0).toString(), QString("baz"));
+        QCOMPARE(model_qt.data(model_qt.index(2, 0), 1).toInt(), 7);
+
+        dee_model_end_changeset(model);
+
+        QCOMPARE(num_insertions, 2);
+        QCOMPARE(model_qt.count(), 4);
+        QCOMPARE(model_qt.rowCount(), 4);
+
+        QCOMPARE(model_qt.data(model_qt.index(0, 0), 0).toString(), QString("foo"));
+        QCOMPARE(model_qt.data(model_qt.index(0, 0), 1).toInt(), 5);
+        QCOMPARE(model_qt.data(model_qt.index(1, 0), 0).toString(), QString("bar"));
+        QCOMPARE(model_qt.data(model_qt.index(1, 0), 1).toInt(), 6);
+        QCOMPARE(model_qt.data(model_qt.index(2, 0), 0).toString(), QString("baz"));
+        QCOMPARE(model_qt.data(model_qt.index(2, 0), 1).toInt(), 7);
+        QCOMPARE(model_qt.data(model_qt.index(3, 0), 0).toString(), QString("qoo"));
+        QCOMPARE(model_qt.data(model_qt.index(3, 0), 1).toInt(), 8);
+    }
+
+    void emitSignalsMixedTest()
+    {
+        DeeModel* model = dee_sequence_model_new();
+        dee_model_set_schema(model, "s", "i", NULL);
+
+        DeeListModel model_qt;
+        model_qt.setModel(model);
+
+        int num_insertions = 0;
+        int num_removals = 0;
+
+        connect(&model_qt, &QAbstractItemModel::rowsInserted, [&num_insertions] (const QModelIndex &parent, int start, int end) {
+            num_insertions++;
+        });
+
+        connect(&model_qt, &QAbstractItemModel::rowsRemoved, [&num_removals] (const QModelIndex &parent, int start, int end) {
+            num_removals++;
+        });
+
+        dee_model_begin_changeset(model);
+
+        dee_model_append(model, "foo", 5);
+        dee_model_append(model, "bar", 6);
+        dee_model_append(model, "baz", 7);
+        dee_model_append(model, "qoo", 8);
+
+        dee_model_remove(model, dee_model_get_first_iter(model));
+        dee_model_remove(model, dee_model_get_first_iter(model));
+
+        dee_model_end_changeset(model);
+
+        QCOMPARE(num_insertions, 1);
+        QCOMPARE(num_removals, 1);
+        QCOMPARE(model_qt.count(), 2);
+        QCOMPARE(model_qt.rowCount(), 2);
+        QCOMPARE(model_qt.data(model_qt.index(0, 0), 0).toString(), QString("baz"));
+        QCOMPARE(model_qt.data(model_qt.index(0, 0), 1).toInt(), 7);
+        QCOMPARE(model_qt.data(model_qt.index(1, 0), 0).toString(), QString("qoo"));
+        QCOMPARE(model_qt.data(model_qt.index(1, 0), 1).toInt(), 8);
+
+        // continue with more changes that aren't consecutive
+        num_insertions = 0;
+        num_removals = 0;
+
+        dee_model_begin_changeset(model);
+        
+        dee_model_append(model, "foo", 5);
+        dee_model_remove(model, dee_model_get_iter_at_row(model, 1));
+        dee_model_remove(model, dee_model_get_iter_at_row(model, 0));
+        dee_model_prepend(model, "qoo", 8);
+        
+        dee_model_end_changeset(model);
+
+        QCOMPARE(num_insertions, 2);
+        QCOMPARE(num_removals, 2);
+        QCOMPARE(model_qt.count(), 2);
+        QCOMPARE(model_qt.rowCount(), 2);
+        QCOMPARE(model_qt.data(model_qt.index(0, 0), 0).toString(), QString("qoo"));
+        QCOMPARE(model_qt.data(model_qt.index(0, 0), 1).toInt(), 8);
+        QCOMPARE(model_qt.data(model_qt.index(1, 0), 0).toString(), QString("foo"));
+        QCOMPARE(model_qt.data(model_qt.index(1, 0), 1).toInt(), 5);
+
+        // and once again
+        num_insertions = 0;
+        num_removals = 0;
+
+        dee_model_begin_changeset(model);
+
+        dee_model_remove(model, dee_model_get_first_iter(model));   // ++ rem
+        dee_model_append(model, "foo", 5);                          // ++ ins
+        dee_model_clear(model);                                     // ++ rem
+        dee_model_append(model, "baz", 7);
+        dee_model_append(model, "qoo", 8);
+        dee_model_prepend(model, "bar", 6);
+        dee_model_prepend(model, "foo", 5);
+
+        dee_model_end_changeset(model);
+
+        QCOMPARE(num_insertions, 4);
+        QCOMPARE(num_removals, 2);
+        QCOMPARE(model_qt.count(), 4);
+        QCOMPARE(model_qt.rowCount(), 4);
+        QCOMPARE(model_qt.data(model_qt.index(0, 0), 0).toString(), QString("foo"));
+        QCOMPARE(model_qt.data(model_qt.index(0, 0), 1).toInt(), 5);
+        QCOMPARE(model_qt.data(model_qt.index(1, 0), 0).toString(), QString("bar"));
+        QCOMPARE(model_qt.data(model_qt.index(1, 0), 1).toInt(), 6);
+        QCOMPARE(model_qt.data(model_qt.index(2, 0), 0).toString(), QString("baz"));
+        QCOMPARE(model_qt.data(model_qt.index(2, 0), 1).toInt(), 7);
+        QCOMPARE(model_qt.data(model_qt.index(3, 0), 0).toString(), QString("qoo"));
+        QCOMPARE(model_qt.data(model_qt.index(3, 0), 1).toInt(), 8);
+    }
+
+    void readDuringTransactionTest()
+    {
+        DeeModel* model = dee_sequence_model_new();
+        dee_model_set_schema(model, "s", "i", NULL);
+
+        DeeListModel model_qt;
+        model_qt.setModel(model);
+
+        int num_insertions = 0;
+        int num_removals = 0;
+        int state = 0;
+
+        connect(&model_qt, &QAbstractItemModel::rowsInserted, [&] (const QModelIndex &parent, int start, int end) {
+            num_insertions++;
+            QVERIFY(state >= 0 && state <= 2);
+            if (state == 0) {
+                QCOMPARE(start, 0);
+                QCOMPARE(end, 1);
+                QCOMPARE(model_qt.rowCount(), 2);
+                QCOMPARE(model_qt.count(), 2);
+                QCOMPARE(model_qt.data(model_qt.index(0, 0), 0).toString(), QString("foo"));
+                QCOMPARE(model_qt.data(model_qt.index(0, 0), 1).toInt(), 5);
+                QCOMPARE(model_qt.data(model_qt.index(1, 0), 0).toString(), QString("baz"));
+                QCOMPARE(model_qt.data(model_qt.index(1, 0), 1).toInt(), 7);
+            } else if (state == 1) {
+                QCOMPARE(start, 0);
+                QCOMPARE(end, 0);
+                QCOMPARE(model_qt.rowCount(), 3);
+                QCOMPARE(model_qt.count(), 3);
+                QCOMPARE(model_qt.data(model_qt.index(0, 0), 0).toString(), QString("bar"));
+                QCOMPARE(model_qt.data(model_qt.index(0, 0), 1).toInt(), 6);
+                QCOMPARE(model_qt.data(model_qt.index(1, 0), 0).toString(), QString("foo"));
+                QCOMPARE(model_qt.data(model_qt.index(1, 0), 1).toInt(), 5);
+                QCOMPARE(model_qt.data(model_qt.index(2, 0), 0).toString(), QString("baz"));
+                QCOMPARE(model_qt.data(model_qt.index(2, 0), 1).toInt(), 7);
+            } else if (state == 2) {
+                QCOMPARE(start, 1);
+                QCOMPARE(end, 1);
+                QCOMPARE(model_qt.rowCount(), 2);
+                QCOMPARE(model_qt.count(), 2);
+                QCOMPARE(model_qt.data(model_qt.index(0, 0), 0).toString(), QString("baz"));
+                QCOMPARE(model_qt.data(model_qt.index(0, 0), 1).toInt(), 7);
+                QCOMPARE(model_qt.data(model_qt.index(1, 0), 0).toString(), QString("qoo"));
+                QCOMPARE(model_qt.data(model_qt.index(1, 0), 1).toInt(), 8);
+            }
+        });
+
+        connect(&model_qt, &QAbstractItemModel::rowsRemoved, [&] (const QModelIndex &parent, int start, int end) {
+            num_removals++;
+            QVERIFY(state >= 2 && state <= 2);
+            if (state == 2) {
+                QCOMPARE(start, 0);
+                QCOMPARE(end, 1);
+                QCOMPARE(model_qt.rowCount(), 1);
+                QCOMPARE(model_qt.count(), 1);
+                QCOMPARE(model_qt.data(model_qt.index(0, 0), 0).toString(), QString("baz"));
+                QCOMPARE(model_qt.data(model_qt.index(0, 0), 1).toInt(), 7);
+            }
+        });
+
+        dee_model_begin_changeset(model);
+
+        dee_model_append(model, "foo", 5);
+        dee_model_append(model, "baz", 7);
+        dee_model_prepend(model, "bar", 6);
+
+        state = 1;
+
+        dee_model_remove(model, dee_model_get_first_iter(model));
+        dee_model_remove(model, dee_model_get_first_iter(model));
+
+        state = 2;
+
+        dee_model_append(model, "qoo", 8);
+
+        dee_model_end_changeset(model);
+
+        QCOMPARE(num_insertions, 3);
+        QCOMPARE(num_removals, 1);
+        QCOMPARE(model_qt.count(), 2);
+        QCOMPARE(model_qt.rowCount(), 2);
+        QCOMPARE(model_qt.data(model_qt.index(0, 0), 0).toString(), QString("baz"));
+        QCOMPARE(model_qt.data(model_qt.index(0, 0), 1).toInt(), 7);
+        QCOMPARE(model_qt.data(model_qt.index(1, 0), 0).toString(), QString("qoo"));
+        QCOMPARE(model_qt.data(model_qt.index(1, 0), 1).toInt(), 8);
+    }
+
+    void readOutsideOfTransactionTest()
+    {
+        DeeModel* model = dee_sequence_model_new();
+        dee_model_set_schema(model, "s", "i", NULL);
+
+        DeeListModel model_qt;
+        model_qt.setModel(model);
+
+        int num_insertions = 0;
+        int num_removals = 0;
+        int state = 0;
+
+        connect(&model_qt, &QAbstractItemModel::rowsInserted, [&] (const QModelIndex &parent, int start, int end) {
+            num_insertions++;
+            QVERIFY((state >= 0 && state <= 2) || state == 5);
+            if (state == 0) {
+                QCOMPARE(start, 0);
+                QCOMPARE(end, 0);
+                QCOMPARE(model_qt.rowCount(), 1);
+                QCOMPARE(model_qt.count(), 1);
+                QCOMPARE(model_qt.data(model_qt.index(0, 0), 0).toString(), QString("foo"));
+                QCOMPARE(model_qt.data(model_qt.index(0, 0), 1).toInt(), 5);
+            } else if (state == 1) {
+                QCOMPARE(start, 1);
+                QCOMPARE(end, 1);
+                QCOMPARE(model_qt.rowCount(), 2);
+                QCOMPARE(model_qt.count(), 2);
+                QCOMPARE(model_qt.data(model_qt.index(0, 0), 0).toString(), QString("foo"));
+                QCOMPARE(model_qt.data(model_qt.index(0, 0), 1).toInt(), 5);
+                QCOMPARE(model_qt.data(model_qt.index(1, 0), 0).toString(), QString("baz"));
+                QCOMPARE(model_qt.data(model_qt.index(1, 0), 1).toInt(), 7);
+            } else if (state == 2) {
+                QCOMPARE(start, 0);
+                QCOMPARE(end, 0);
+                QCOMPARE(model_qt.rowCount(), 3);
+                QCOMPARE(model_qt.count(), 3);
+                QCOMPARE(model_qt.data(model_qt.index(0, 0), 0).toString(), QString("bar"));
+                QCOMPARE(model_qt.data(model_qt.index(0, 0), 1).toInt(), 6);
+                QCOMPARE(model_qt.data(model_qt.index(1, 0), 0).toString(), QString("foo"));
+                QCOMPARE(model_qt.data(model_qt.index(1, 0), 1).toInt(), 5);
+                QCOMPARE(model_qt.data(model_qt.index(2, 0), 0).toString(), QString("baz"));
+                QCOMPARE(model_qt.data(model_qt.index(2, 0), 1).toInt(), 7);
+            } else if (state == 5) {
+                QCOMPARE(start, 1);
+                QCOMPARE(end, 1);
+                QCOMPARE(model_qt.rowCount(), 2);
+                QCOMPARE(model_qt.count(), 2);
+                QCOMPARE(model_qt.data(model_qt.index(0, 0), 0).toString(), QString("baz"));
+                QCOMPARE(model_qt.data(model_qt.index(0, 0), 1).toInt(), 7);
+                QCOMPARE(model_qt.data(model_qt.index(1, 0), 0).toString(), QString("qoo"));
+                QCOMPARE(model_qt.data(model_qt.index(1, 0), 1).toInt(), 8);
+            }
+        });
+
+        connect(&model_qt, &QAbstractItemModel::rowsRemoved, [&] (const QModelIndex &parent, int start, int end) {
+            num_removals++;
+            QVERIFY(state >= 3 && state <= 4);
+            if (state == 3) {
+                QCOMPARE(start, 0);
+                QCOMPARE(end, 0);
+                QCOMPARE(model_qt.rowCount(), 2);
+                QCOMPARE(model_qt.count(), 2);
+                QCOMPARE(model_qt.data(model_qt.index(0, 0), 0).toString(), QString("foo"));
+                QCOMPARE(model_qt.data(model_qt.index(0, 0), 1).toInt(), 5);
+                QCOMPARE(model_qt.data(model_qt.index(1, 0), 0).toString(), QString("baz"));
+                QCOMPARE(model_qt.data(model_qt.index(1, 0), 1).toInt(), 7);
+            } else if (state == 4) {
+                QCOMPARE(start, 0);
+                QCOMPARE(end, 0);
+                QCOMPARE(model_qt.rowCount(), 1);
+                QCOMPARE(model_qt.count(), 1);
+                QCOMPARE(model_qt.data(model_qt.index(0, 0), 0).toString(), QString("baz"));
+                QCOMPARE(model_qt.data(model_qt.index(0, 0), 1).toInt(), 7);
+            }
+        });
+
+        dee_model_append(model, "foo", 5);
+
+        state = 1;
+
+        dee_model_append(model, "baz", 7);
+
+        state = 2;
+
+        dee_model_prepend(model, "bar", 6);
+
+        state = 3;
+
+        dee_model_remove(model, dee_model_get_first_iter(model));
+
+        state = 4;
+
+        dee_model_remove(model, dee_model_get_first_iter(model));
+
+        state = 5;
+
+        dee_model_append(model, "qoo", 8);
+
+        QCOMPARE(num_insertions, 4);
+        QCOMPARE(num_removals, 2);
+        QCOMPARE(model_qt.count(), 2);
+        QCOMPARE(model_qt.rowCount(), 2);
+        QCOMPARE(model_qt.data(model_qt.index(0, 0), 0).toString(), QString("baz"));
+        QCOMPARE(model_qt.data(model_qt.index(0, 0), 1).toInt(), 7);
+        QCOMPARE(model_qt.data(model_qt.index(1, 0), 0).toString(), QString("qoo"));
+        QCOMPARE(model_qt.data(model_qt.index(1, 0), 1).toInt(), 8);
+    }
+};
+
+QTEST_MAIN(DeeListModelTest)
+
+#include "signaltest.moc"