Storage Framework

Merge lp:~michihenning/storage-framework/more-coverage into lp:storage-framework/devel

more-coverage
Merge into devel

Proposed by Michi Henning on 2016-07-29

Status:	Merged
Approved by:	James Henstridge on 2016-08-10
Approved revision:	80
Merged at revision:	41
Proposed branch:	lp:~michihenning/storage-framework/more-coverage
Merge into:	lp:storage-framework/devel
Prerequisite:	lp:~michihenning/storage-framework/increase-coverage
Diff against target:	4904 lines (+1998/-1062) 25 files modified include/unity/storage/qt/client/Exceptions.h (+1/-3) include/unity/storage/qt/client/internal/ItemBase.h (+2/-0) include/unity/storage/qt/client/internal/local_client/ItemImpl.h (+4/-4) include/unity/storage/qt/client/internal/local_client/UploaderImpl.h (+1/-5) include/unity/storage/qt/client/internal/local_client/storage_exception.h (+94/-0) include/unity/storage/qt/client/internal/make_future.h (+14/-74) include/unity/storage/qt/client/internal/remote_client/Handler.h (+1/-0) include/unity/storage/qt/client/internal/remote_client/ItemImpl.h (+0/-3) src/qt/client/Exceptions.cpp (+1/-7) src/qt/client/internal/ItemBase.cpp (+15/-0) src/qt/client/internal/local_client/CMakeLists.txt (+1/-0) src/qt/client/internal/local_client/DownloaderImpl.cpp (+9/-0) src/qt/client/internal/local_client/FileImpl.cpp (+23/-43) src/qt/client/internal/local_client/FolderImpl.cpp (+72/-106) src/qt/client/internal/local_client/ItemImpl.cpp (+131/-165) src/qt/client/internal/local_client/RootImpl.cpp (+67/-62) src/qt/client/internal/local_client/RuntimeImpl.cpp (+1/-0) src/qt/client/internal/local_client/UploaderImpl.cpp (+16/-39) src/qt/client/internal/local_client/storage_exception.cpp (+99/-0) src/qt/client/internal/remote_client/FileImpl.cpp (+12/-19) src/qt/client/internal/remote_client/FolderImpl.cpp (+19/-19) src/qt/client/internal/remote_client/ItemImpl.cpp (+44/-82) src/qt/client/internal/remote_client/RuntimeImpl.cpp (+1/-0) tests/local-client/local-client_test.cpp (+1361/-422) tests/remote-client/remote-client_test.cpp (+9/-9)
To merge this branch:	bzr merge lp:~michihenning/storage-framework/more-coverage
Related bugs:	Link a bug report

Reviewer	Review Type	Date Requested	Status
James Henstridge		2016-07-29	Approve on 2016-08-10
unity-api-1-bot	continuous-integration	2016-07-29	Needs Fixing on 2016-08-03
Review via email: mp+301450@code.launchpad.net

This proposal supersedes a proposal from 2016-07-29.

Commit message

Improved coverage. Better error reporting/handling.

Description of the change

Very boring branch. Lots of extra tests for proper coverage, particularly for error handling/reporting. Refactored a bunch of code to get rid of repeated exception checks.

Revision history for this message

unity-api-1-bot (unity-api-1-bot) wrote on 2016-07-29: Posted in a previous version of this proposal

FAILED: Continuous integration, rev:71
https://jenkins.canonical.com/unity-api-1/job/lp-storage-framework-ci/39/
Executed test runs:
FAILURE: https://jenkins.canonical.com/unity-api-1/job/build/260/console
FAILURE: https://jenkins.canonical.com/unity-api-1/job/build-0-fetch/268/console

Click here to trigger a rebuild:
https://jenkins.canonical.com/unity-api-1/job/lp-storage-framework-ci/39/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

unity-api-1-bot (unity-api-1-bot) wrote on 2016-08-02:

FAILED: Continuous integration, rev:75
https://jenkins.canonical.com/unity-api-1/job/lp-storage-framework-ci/42/
Executed test runs:
FAILURE: https://jenkins.canonical.com/unity-api-1/job/build/264/console

Click here to trigger a rebuild:
https://jenkins.canonical.com/unity-api-1/job/lp-storage-framework-ci/42/rebuild

review: Needs Fixing (continuous-integration)

lp:~michihenning/storage-framework/more-coverage updated on 2016-08-02

76. By Michi Henning on 2016-08-02: A few coverage suppressions.

Revision history for this message

unity-api-1-bot (unity-api-1-bot) wrote on 2016-08-02:

Click here to trigger a rebuild:
https://jenkins.canonical.com/unity-api-1/job/lp-storage-framework-ci/43/rebuild

review: Needs Fixing (continuous-integration)

lp:~michihenning/storage-framework/more-coverage updated on 2016-08-03

77. By Michi Henning on 2016-08-03: Fixed hang in test. Fixed sigpipe problem when cancelling upload.

Revision history for this message

unity-api-1-bot (unity-api-1-bot) wrote on 2016-08-03:

Click here to trigger a rebuild:
https://jenkins.canonical.com/unity-api-1/job/lp-storage-framework-ci/44/rebuild

review: Needs Fixing (continuous-integration)

lp:~michihenning/storage-framework/more-coverage updated on 2016-08-03

78. By Michi Henning on 2016-08-03: Added a few missing checks for destroyed runtime or item.

Revision history for this message

unity-api-1-bot (unity-api-1-bot) wrote on 2016-08-03:

Click here to trigger a rebuild:
https://jenkins.canonical.com/unity-api-1/job/lp-storage-framework-ci/47/rebuild

review: Needs Fixing (continuous-integration)

lp:~michihenning/storage-framework/more-coverage updated on 2016-08-03

79. By Michi Henning on 2016-08-03: Fixed incorrect check for parent destruction in copy() and move().
80. By Michi Henning on 2016-08-03: Fix typos.

Revision history for this message

unity-api-1-bot (unity-api-1-bot) wrote on 2016-08-03:

Click here to trigger a rebuild:
https://jenkins.canonical.com/unity-api-1/job/lp-storage-framework-ci/48/rebuild

review: Needs Fixing (continuous-integration)

Revision history for this message

James Henstridge (jamesh) wrote on 2016-08-10:

Let's merge this.

review: Approve

Preview Diff

[H/L] Next/Prev Comment, [J/K] Next/Prev File, [N/P] Next/Prev Hunk

Subscribers

People subscribed via source and target branches

to all changes:

Michi Henning

 === modified file 'include/unity/storage/qt/client/Exceptions.h'
 --- include/unity/storage/qt/client/Exceptions.h	2016-08-03 06:10:39 +0000
 +++ include/unity/storage/qt/client/Exceptions.h	2016-08-03 06:10:39 +0000
@@ -85,18 +85,16 @@
  class UNITY_STORAGE_EXPORT DeletedException : public StorageException
+ {
  public:
--    DeletedException(QString const& error_message, QString const& identity_, QString const& name_);
++    DeletedException(QString const& error_message, QString const& identity_);
      ~DeletedException();
      virtual DeletedException* clone() const override;
      virtual void raise() const override;
      QString native_identity() const;
--    QString name() const;
  private:
      QString identity_;
--    QString name_;
  };
  /**
 === modified file 'include/unity/storage/qt/client/internal/ItemBase.h'
 --- include/unity/storage/qt/client/internal/ItemBase.h	2016-08-03 06:10:39 +0000
 +++ include/unity/storage/qt/client/internal/ItemBase.h	2016-08-03 06:10:39 +0000
@@ -83,11 +83,13 @@
  protected:
      std::shared_ptr<Root> get_root() const noexcept;
++    void throw_if_destroyed(QString const& method) const;
      const QString identity_;
      const ItemType type_;
      std::weak_ptr<Root> root_;
      std::weak_ptr<Item> public_instance_;
++    bool deleted_ = false;
      friend class ItemImpl;
  };
 === modified file 'include/unity/storage/qt/client/internal/local_client/ItemImpl.h'
 --- include/unity/storage/qt/client/internal/local_client/ItemImpl.h	2016-08-03 06:10:39 +0000
 +++ include/unity/storage/qt/client/internal/local_client/ItemImpl.h	2016-08-03 06:10:39 +0000
@@ -68,14 +68,14 @@
      static boost::filesystem::path sanitize(QString const& name, QString const& method);
      static bool is_reserved_path(boost::filesystem::path const& path) noexcept;
--    DeletedException deleted_ex(QString const& method) const noexcept;
--
--    bool deleted_;
      QString name_;
      QString etag_;
      QDateTime modified_time_;
      QVariantMap metadata_;
--    std::mutex mutable mutex_;
++    std::recursive_mutex mutable mutex_;
++
++private:
++    static void copy_recursively(boost::filesystem::path const& source, boost::filesystem::path const& target);
  };
  }  // namespace local_client
 === modified file 'include/unity/storage/qt/client/internal/local_client/UploaderImpl.h'
 --- include/unity/storage/qt/client/internal/local_client/UploaderImpl.h	2016-08-03 06:10:39 +0000
 +++ include/unity/storage/qt/client/internal/local_client/UploaderImpl.h	2016-08-03 06:10:39 +0000
@@ -68,7 +68,6 @@
  private Q_SLOTS:
      void on_bytes_ready();
      void on_read_channel_finished();
--    void on_error();
  private:
      void read_and_write_chunk();
@@ -91,11 +90,8 @@
      QFutureInterface<std::shared_ptr<File>>& qf_;
      QFutureInterface<void>& worker_initialized_;
      QString error_msg_;
--<<<<<<< TREE
++    int error_code_ = 0;
      bool use_linkat_ = true;
--=======
--    int error_code_ = 0;
-->>>>>>> MERGE-SOURCE
  };
  class UploadThread : public QThread
 === added file 'include/unity/storage/qt/client/internal/local_client/storage_exception.h'
 --- include/unity/storage/qt/client/internal/local_client/storage_exception.h	1970-01-01 00:00:00 +0000
 +++ include/unity/storage/qt/client/internal/local_client/storage_exception.h	2016-08-03 06:10:39 +0000
@@ -0,0 +1,94 @@
++/*
++ * Copyright (C) 2016 Canonical Ltd
++ *
++ * This program is free software: you can redistribute it and/or modify
++ * it under the terms of the GNU Lesser General Public License version 3 as
++ * published by the Free Software Foundation.
++ *
++ * 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 Lesser General Public License for more details.
++ *
++ * You should have received a copy of the GNU Lesser General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ *
++ * Authors: Michi Henning <michi.henning@canonical.com>
++ */
++
++#pragma once
++
++#include <unity/storage/qt/client/Exceptions.h>
++#include <unity/storage/qt/client/internal/local_client/boost_filesystem.h>
++
++#pragma GCC diagnostic push
++#pragma GCC diagnostic ignored "-Wctor-dtor-privacy"
++#pragma GCC diagnostic ignored "-Wcast-align"
++#include <QFuture>
++#pragma GCC diagnostic pop
++#include <QFutureInterface>
++
++class QString;
++
++namespace unity
++{
++namespace storage
++{
++namespace qt
++{
++namespace client
++{
++namespace internal
++{
++namespace local_client
++{
++
++void throw_storage_exception(QString const& method,
++                             std::exception_ptr ep) __attribute__ ((noreturn));
++
++void throw_storage_exception(QString const& method,
++                             std::exception_ptr ep,
++                             QString const& key) __attribute__ ((noreturn));
++
++template<typename T>
++QFuture<T> make_exceptional_future(QString const& method, std::exception_ptr ep)
++{
++    try
++    {
++        throw_storage_exception(method, ep);
++    }
++    catch (StorageException const& e)
++    {
++        QFutureInterface<T> qf;
++        qf.reportException(e);
++        qf.reportFinished();
++        return qf.future();
++    }
++    abort();  // Impossible.  // LCOV_EXCL_LINE
++}
++
++template<typename T>
++QFuture<T> make_exceptional_future(QString const& method,
++                                   std::exception_ptr ep,
++                                   QString const& key)
++{
++    try
++    {
++        throw_storage_exception(method, ep, key);
++    }
++    catch (StorageException const& e)
++    {
++        QFutureInterface<T> qf;
++        qf.reportException(e);
++        qf.reportFinished();
++        return qf.future();
++    }
++    abort();  // Impossible.  // LCOV_EXCL_LINE
++}
++
++}  // namespace local_client
++}  // namespace internal
++}  // namespace client
++}  // namespace qt
++}  // namespace storage
++}  // namespace unity
 === renamed file 'include/unity/storage/qt/client/internal/local_client/tmpfile-prefix.h' => 'include/unity/storage/qt/client/internal/local_client/tmpfile_prefix.h'
 === modified file 'include/unity/storage/qt/client/internal/make_future.h'
 --- include/unity/storage/qt/client/internal/make_future.h	2016-08-03 06:10:39 +0000
 +++ include/unity/storage/qt/client/internal/make_future.h	2016-08-03 06:10:39 +0000
@@ -18,9 +18,6 @@
  #pragma once
--#include <unity/storage/qt/client/Exceptions.h>
--#include <unity/storage/qt/client/internal/boost_filesystem.h>
--
  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wctor-dtor-privacy"
  #pragma GCC diagnostic ignored "-Wcast-align"
@@ -39,21 +36,6 @@
  namespace internal
+ {
--template<typename T = void>
--QFuture<T> make_ready_future()
--{
--    QFutureInterface<void> qf;
--    qf.reportFinished();
--    return qf.future();
--}
--
--template<typename T = void>
--QFuture<T> make_ready_future(QFutureInterface<T> qf)
--{
--    qf.reportFinished();
--    return qf.future();
--}
--
  template<typename T>
  QFuture<T> make_ready_future(T const& val)
+ {
@@ -71,6 +53,20 @@
      return qf.future();
+ }
++template<typename T = void>
++QFuture<T> make_ready_future(QFutureInterface<T> qf)
++{
++    qf.reportFinished();
++    return qf.future();
++}
++
++template<typename T = void>
++QFuture<T> make_ready_future()
++{
++    QFutureInterface<void> qf;
++    return make_ready_future(qf);
++}
++
  template<typename E>
  QFuture<void> make_exceptional_future(E const& ex)
+ {
@@ -97,62 +93,6 @@
      return qf.future();
+ }
--template<typename T>
--QFuture<T> make_exceptional_future(QString const& msg, boost::filesystem::filesystem_error const& e)
--{
--    QFutureInterface<T> qf;
--    switch (e.code().value())
--    {
--        case EACCES:
--        case EPERM:
--        {
--            qf.reportException(PermissionException(msg));
--            break;
--        }
--        case EDQUOT:
--        case ENOSPC:
--        {
--            qf.reportException(QuotaException(msg));
--            break;
--        }
--        case ENOENT:
--        {
--            //qf.reportException(NotExistsException(msg));
--            qDebug() << "ENOENT";
--            qf.reportException(ResourceException(msg, e.code().value()));
--            break;
--        }
--        default:
--        {
--            qf.reportException(ResourceException(msg, e.code().value()));
--            break;
--        }
--    }
--    qf.reportFinished();
--    return qf.future();
--}
--
--template<typename T>
--QFuture<T> make_exceptional_future(QString const& msg, boost::filesystem::filesystem_error const& e, QString const& key)
--{
--    QFutureInterface<T> qf;
--    switch (e.code().value())
--    {
--        case ENOENT:
--        {
--            qf.reportException(NotExistsException(msg, key));
--            break;
--        }
--        default:
--        {
--            return make_exceptional_future<T>(msg, e);
--            break;
--        }
--    }
--    qf.reportFinished();
--    return qf.future();
--}
--
  }  // namespace internal
  }  // namespace client
  }  // namespace qt
 === modified file 'include/unity/storage/qt/client/internal/remote_client/Handler.h'
 --- include/unity/storage/qt/client/internal/remote_client/Handler.h	2016-08-03 06:10:39 +0000
 +++ include/unity/storage/qt/client/internal/remote_client/Handler.h	2016-08-03 06:10:39 +0000
@@ -18,6 +18,7 @@
  #pragma once
++#include <unity/storage/qt/client/Exceptions.h>
  #include <unity/storage/qt/client/internal/make_future.h>
  #include <unity/storage/qt/client/internal/remote_client/HandlerBase.h>
 === modified file 'include/unity/storage/qt/client/internal/remote_client/ItemImpl.h'
 --- include/unity/storage/qt/client/internal/remote_client/ItemImpl.h	2016-07-22 00:17:24 +0000
 +++ include/unity/storage/qt/client/internal/remote_client/ItemImpl.h	2016-08-03 06:10:39 +0000
@@ -66,9 +66,6 @@
      static std::shared_ptr<Item> make_item(storage::internal::ItemMetadata const& md, std::weak_ptr<Root> root);
  protected:
--    DeletedException deleted_ex(QString const& method) const noexcept;
--
--    bool deleted_ = false;
      storage::internal::ItemMetadata md_;
      friend class DeleteHandler;
 === modified file 'src/qt/client/Exceptions.cpp'
 --- src/qt/client/Exceptions.cpp	2016-08-03 06:10:39 +0000
 +++ src/qt/client/Exceptions.cpp	2016-08-03 06:10:39 +0000
@@ -81,10 +81,9 @@
      throw *this;
+ }
--DeletedException::DeletedException(QString const& error_message, QString const& identity, QString const& name)
++DeletedException::DeletedException(QString const& error_message, QString const& identity)
      : StorageException("DeletedException", error_message)
      , identity_(identity)
--    , name_(name)
+ {
+ }
@@ -105,11 +104,6 @@
      return identity_;
+ }
--QString DeletedException::name() const
--{
--    return name_;
--}
--
  RuntimeDestroyedException::RuntimeDestroyedException(QString const& method)
      : StorageException("RuntimeDestroyedException", method + ": Runtime was destroyed previously")
+ {
 === modified file 'src/qt/client/internal/ItemBase.cpp'
 --- src/qt/client/internal/ItemBase.cpp	2016-08-03 06:10:39 +0000
 +++ src/qt/client/internal/ItemBase.cpp	2016-08-03 06:10:39 +0000
@@ -48,11 +48,13 @@
  QString ItemBase::native_identity() const
+ {
++    throw_if_destroyed("Item::native_identity()");
      return identity_;
+ }
  ItemType ItemBase::type() const
+ {
++    throw_if_destroyed("Item::type()");
      return type_;
+ }
@@ -95,6 +97,19 @@
      return nullptr;
+ }
++void ItemBase::throw_if_destroyed(QString const& method) const
++{
++    if (deleted_)
++    {
++        QString msg = method + ": \"" + identity_ + "\" was deleted previously";
++        throw DeletedException(msg, identity_);
++    }
++    if (!get_root())
++    {
++        throw RuntimeDestroyedException(method);
++    }
++}
++
  }  // namespace internal
  }  // namespace client
  }  // namespace qt
 === modified file 'src/qt/client/internal/local_client/CMakeLists.txt'
 --- src/qt/client/internal/local_client/CMakeLists.txt	2016-07-22 00:17:24 +0000
 +++ src/qt/client/internal/local_client/CMakeLists.txt	2016-08-03 06:10:39 +0000
@@ -7,6 +7,7 @@
          ${CMAKE_CURRENT_SOURCE_DIR}/RootImpl.cpp
          ${CMAKE_CURRENT_SOURCE_DIR}/Runtime_create.cpp
          ${CMAKE_CURRENT_SOURCE_DIR}/RuntimeImpl.cpp
++        ${CMAKE_CURRENT_SOURCE_DIR}/storage_exception.cpp
          ${CMAKE_CURRENT_SOURCE_DIR}/UploaderImpl.cpp
          ${CMAKE_SOURCE_DIR}/include/unity/storage/qt/client/internal/local_client/DownloaderImpl.h
          ${CMAKE_SOURCE_DIR}/include/unity/storage/qt/client/internal/local_client/UploaderImpl.h
 === modified file 'src/qt/client/internal/local_client/DownloaderImpl.cpp'
 --- src/qt/client/internal/local_client/DownloaderImpl.cpp	2016-08-03 06:10:39 +0000
 +++ src/qt/client/internal/local_client/DownloaderImpl.cpp	2016-08-03 06:10:39 +0000
@@ -79,8 +79,10 @@
      input_file_.reset(new QFile(filename_));
      if (!input_file_->open(QIODevice::ReadOnly))
+     {
++        // LCOV_EXCL_START
          handle_error("cannot open " + filename_ + ": " + input_file_->errorString(), input_file_->error());
          return;
++        // LCOV_EXCL_STOP
+     }
      bytes_to_write_ = input_file_->size();
@@ -189,6 +191,7 @@
  void DownloadWorker::on_error()
+ {
++    disconnect(write_socket_.get(), nullptr, this, nullptr);
      handle_error(write_socket_->errorString(), write_socket_->error());
+ }
@@ -203,21 +206,27 @@
      auto bytes_read = input_file_->read(buf.data(), buf.size());
      if (bytes_read == -1)
+     {
++        // LCOV_EXCL_START
          handle_error(filename_ + ": read error: " + input_file_->errorString(), input_file_->error());
          return;
++        // LCOV_EXCL_STOP
+     }
      buf.resize(bytes_read);
      auto bytes_written = write_socket_->write(buf);
      if (bytes_written == -1)
+     {
++        // LCOV_EXCL_START
          handle_error(filename_ + ": socket error: " + write_socket_->errorString(), write_socket_->error());
++        // LCOV_EXCL_STOP
+     }
      else if (bytes_written != bytes_read)
+     {
++        // LCOV_EXCL_START
          QString msg = filename_ + ": write error, requested " + bytes_read + " B, but wrote only "
                        + bytes_written + " B.";
          handle_error(msg, 0);
++        // LCOV_EXCL_STOP
+     }
+ }
 === modified file 'src/qt/client/internal/local_client/FileImpl.cpp'
 --- src/qt/client/internal/local_client/FileImpl.cpp	2016-08-03 06:10:39 +0000
 +++ src/qt/client/internal/local_client/FileImpl.cpp	2016-08-03 06:10:39 +0000
@@ -22,6 +22,7 @@
  #include <unity/storage/qt/client/Exceptions.h>
  #include <unity/storage/qt/client/File.h>
  #include <unity/storage/qt/client/internal/local_client/DownloaderImpl.h>
++#include <unity/storage/qt/client/internal/local_client/storage_exception.h>
  #include <unity/storage/qt/client/internal/local_client/UploaderImpl.h>
  #include <unity/storage/qt/client/internal/make_future.h>
  #include <unity/storage/qt/client/Uploader.h>
@@ -50,65 +51,44 @@
  QString FileImpl::name() const
+ {
--    lock_guard<mutex> guard(mutex_);
++    lock_guard<decltype(mutex_)> guard(mutex_);
--    if (deleted_)
--    {
--        throw deleted_ex("File::name()");
--    }
--    if (!get_root())
--    {
--        throw RuntimeDestroyedException("File::name()");
--    }
++    throw_if_destroyed("File::name()");
      return name_;
+ }
  int64_t FileImpl::size() const
+ {
--    lock_guard<mutex> guard(mutex_);
--
--    if (deleted_)
--    {
--        throw deleted_ex("File::size()");
--    }
--    if (!get_root())
--    {
--        throw RuntimeDestroyedException("File::size()");
--    }
--
++    lock_guard<decltype(mutex_)> guard(mutex_);
++
++    throw_if_destroyed("File::size()");
      try
+     {
          boost::filesystem::path p = identity_.toStdString();
          return file_size(p);
+     }
--    catch (boost::filesystem::filesystem_error const& e)
--    {
--        throw ResourceException(e.what(), e.code().value());
--    }
--    catch (std::exception const& e)
--    {
--        throw ResourceException(e.what(), 0);
++    catch (std::exception const&)
++    {
++        throw_storage_exception(QString("File::size()"), current_exception());
+     }
+ }
  QFuture<Uploader::SPtr> FileImpl::create_uploader(ConflictPolicy policy, int64_t size)
+ {
--    lock_guard<mutex> guard(mutex_);
++    lock_guard<decltype(mutex_)> guard(mutex_);
--    if (deleted_)
--    {
--        return make_exceptional_future<Uploader::SPtr>(deleted_ex("File::create_uploader()"));
++    try
++    {
++        throw_if_destroyed("File::create_uploader()");
++    }
++    catch (StorageException const& e)
++    {
++        return internal::make_exceptional_future<Uploader::SPtr>(e);
+     }
      if (size < 0)
+     {
          QString msg = "File::create_uploader(): size must be >= 0";
--        return make_exceptional_future<shared_ptr<Uploader>>(InvalidArgumentException(msg));
--    }
--
--    auto root = get_root();
--    if (!root)
--    {
--        return make_exceptional_future<Uploader::SPtr>(RuntimeDestroyedException("File::create_uploader()"));
++        return internal::make_exceptional_future<shared_ptr<Uploader>>(InvalidArgumentException(msg));
+     }
      auto file = dynamic_pointer_cast<File>(public_instance_.lock());
@@ -120,15 +100,15 @@
  QFuture<Downloader::SPtr> FileImpl::create_downloader()
+ {
--    lock_guard<mutex> guard(mutex_);
++    lock_guard<decltype(mutex_)> guard(mutex_);
--    if (deleted_)
++    try
+     {
--        return make_exceptional_future<Downloader::SPtr>(deleted_ex("File::create_downloader()"));
++        throw_if_destroyed("File::create_downloader()");
+     }
--    if (!get_root())
++    catch (StorageException const& e)
+     {
--        throw RuntimeDestroyedException("File::create_downloader()");
++        return internal::make_exceptional_future<Downloader::SPtr>(e);
+     }
      auto pi = public_instance_.lock();
 === modified file 'src/qt/client/internal/local_client/FolderImpl.cpp'
 --- src/qt/client/internal/local_client/FolderImpl.cpp	2016-08-03 06:10:39 +0000
 +++ src/qt/client/internal/local_client/FolderImpl.cpp	2016-08-03 06:10:39 +0000
@@ -24,7 +24,8 @@
  #include <unity/storage/qt/client/Uploader.h>
  #include <unity/storage/qt/client/internal/make_future.h>
  #include <unity/storage/qt/client/internal/local_client/FileImpl.h>
--#include <unity/storage/qt/client/internal/local_client/tmpfile-prefix.h>
++#include <unity/storage/qt/client/internal/local_client/storage_exception.h>
++#include <unity/storage/qt/client/internal/local_client/tmpfile_prefix.h>
  #include <unity/storage/qt/client/internal/local_client/UploaderImpl.h>
  #include <boost/algorithm/string/predicate.hpp>
@@ -64,36 +65,34 @@
  QString FolderImpl::name() const
+ {
--    lock_guard<mutex> guard(mutex_);
++    lock_guard<decltype(mutex_)> guard(mutex_);
--    if (deleted_)
--    {
--        throw deleted_ex("Folder::name()");
--    }
++    throw_if_destroyed("Folder::name()");
      return name_;
+ }
  QFuture<QVector<Item::SPtr>> FolderImpl::list() const
+ {
++    try
++    {
++        throw_if_destroyed("Folder::list()");
++    }
++    catch (StorageException const& e)
++    {
++        return internal::make_exceptional_future<QVector<Item::SPtr>>(e);
++    }
++
      auto This = dynamic_pointer_cast<FolderImpl const>(shared_from_this());  // Keep this folder alive while the lambda is alive.
      auto list = [This]()
+     {
--        lock_guard<mutex> guard(This->mutex_);
--
--        if (This->deleted_)
--        {
--            throw This->deleted_ex("Folder::list()");
--        }
--        auto root = This->get_root();
--        if (!root)
--        {
--            throw RuntimeDestroyedException("Folder::list()");
--        }
--
++        lock_guard<decltype(mutex_)> guard(This->mutex_);
++
++        This->throw_if_destroyed("Folder::list()");
          try
+         {
              using namespace boost::filesystem;
++            auto root = This->root_.lock();
              QVector<Item::SPtr> results;
              for (directory_iterator it(This->native_identity().toStdString()); it != directory_iterator(); ++it)
+             {
@@ -119,13 +118,9 @@
+             }
              return results;
+         }
--        catch (boost::filesystem::filesystem_error const& e)
--        {
--            throw ResourceException(QString("Folder::list(): ") + e.what(), e.code().value());
--        }
--        catch (std::exception const& e)
--        {
--            throw ResourceException(QString("Folder::list(): ") + e.what(), errno);
++        catch (std::exception const&)
++        {
++            throw_storage_exception("Folder::list()", current_exception());
+         }
      };
      return QtConcurrent::run(list);
@@ -133,30 +128,31 @@
  QFuture<QVector<Item::SPtr>> FolderImpl::lookup(QString const& name) const
+ {
++    try
++    {
++        throw_if_destroyed("Folder::lookup()");
++    }
++    catch (StorageException const& e)
++    {
++        return internal::make_exceptional_future<QVector<Item::SPtr>>(e);
++    }
++
      auto This = dynamic_pointer_cast<FolderImpl const>(shared_from_this());  // Keep this folder alive while the lambda is alive.
      auto lookup = [This, name]() -> QVector<Item::SPtr>
+     {
--        lock_guard<mutex> guard(This->mutex_);
--
--        if (This->deleted_)
--        {
--            throw This->deleted_ex("Folder::lookup()");
--        }
--        auto root = This->get_root();
--        if (!root)
--        {
--            throw RuntimeDestroyedException("Folder::lookup()");
--        }
--
++        lock_guard<decltype(mutex_)> guard(This->mutex_);
++
++        This->throw_if_destroyed("Folder::lookup()");  // LCOV_EXCL_LINE
          try
+         {
              using namespace boost::filesystem;
++            auto root = This->root_.lock();
              path p = This->native_identity().toStdString();
              auto sanitized_name = sanitize(name, "Folder::lookup()");
              if (is_reserved_path(sanitized_name))
+             {
--                throw NotExistsException("Folder::lookup(): no such item: " + name, name);
++                throw NotExistsException("Folder::lookup(): no such item: \"" + name + "\"", name);
+             }
              p /= sanitized_name;
              file_status s = status(p);
@@ -172,23 +168,11 @@
                  v.append(FileImpl::make_file(QString::fromStdString(p.native()), root));
                  return v;
+             }
--            throw NotExistsException("Folder::lookup(): no such item: " + name, name);
--        }
--        catch (StorageException const&)
--        {
--            throw;
--        }
--        catch (boost::filesystem::filesystem_error const& e)
--        {
--            if (e.code().value() == ENOENT)
--            {
--                throw NotExistsException("Folder::lookup(): no such item: " + name, name);
--            }
--            throw ResourceException(QString("Folder::lookup(): ") + e.what(), e.code().value());
--        }
--        catch (std::exception const& e)
--        {
--            throw ResourceException(QString("Folder::lookup(): ") + e.what(), errno);
++            throw NotExistsException("Folder::lookup(): no such item: \"" + name + "\"", name);
++        }
++        catch (std::exception const&)
++        {
++            throw_storage_exception("Folder::lookup()", current_exception());
+         }
      };
      return QtConcurrent::run(lookup);
@@ -196,17 +180,15 @@
  QFuture<Folder::SPtr> FolderImpl::create_folder(QString const& name)
+ {
--    lock_guard<mutex> guard(mutex_);
++    lock_guard<decltype(mutex_)> guard(mutex_);
--    QFutureInterface<Folder::SPtr> qf;
--    if (deleted_)
++    try
+     {
--        return make_exceptional_future<Folder::SPtr>(deleted_ex("Folder::create_folder()"));
++        throw_if_destroyed("Folder::create_folder()");
+     }
--    auto root = get_root();
--    if (!root)
++    catch (StorageException const& e)
+     {
--        return make_exceptional_future<Folder::SPtr>(RuntimeDestroyedException("Folder::create_folder()"));
++        return internal::make_exceptional_future<Folder::SPtr>(e);
+     }
      try
@@ -217,46 +199,40 @@
          auto sanitized_name = sanitize(name, "Folder::create_folder()");
          if (is_reserved_path(sanitized_name))
+         {
--            QString msg = "Folder::create_folder(): names beginning with " + QString(TMPFILE_PREFIX) + " are reserved";
--            return make_exceptional_future<Folder::SPtr>(InvalidArgumentException(msg));
++            QString msg = "Folder::create_folder(): names beginning with \"" + QString(TMPFILE_PREFIX) + "\" are reserved";
++            throw InvalidArgumentException(msg);
+         }
          p /= sanitized_name;
++        if (exists(p))
++        {
++            QString msg = "Folder::create_folder(): item with name \"" + name + "\" exists already";
++            throw ExistsException(msg, native_identity() + "/" + name, name);
++        }
          create_directory(p);
--        return make_ready_future(make_folder(QString::fromStdString(p.native()), root));
--    }
--    catch (StorageException const& e)
--    {
--        return make_exceptional_future<Folder::SPtr>(e);
--    }
--    catch (boost::filesystem::filesystem_error const& e)
--    {
--        return make_exceptional_future<Folder::SPtr>(ResourceException(QString("Folder::create_folder: ") + e.what(),
--                                                                       e.code().value()));
--    }
--    catch (std::exception const& e)
--    {
--        return make_exceptional_future<Folder::SPtr>(ResourceException(QString("Folder::create_folder: ") + e.what(),
--                                                                       errno));
++        return make_ready_future(make_folder(QString::fromStdString(p.native()), root_));
++    }
++    catch (std::exception const&)
++    {
++        return make_exceptional_future<Folder::SPtr>("Folder::create_folder()", current_exception());
+     }
+ }
  QFuture<shared_ptr<Uploader>> FolderImpl::create_file(QString const& name, int64_t size)
+ {
--    unique_lock<mutex> guard(mutex_);
++    lock_guard<decltype(mutex_)> guard(mutex_);
--    if (deleted_)
--    {
--        return make_exceptional_future<Uploader::SPtr>(deleted_ex("Folder::create_file()"));
++    try
++    {
++        throw_if_destroyed("Folder::create_file()");
++    }
++    catch (StorageException const& e)
++    {
++        return internal::make_exceptional_future<shared_ptr<Uploader>>(e);
+     }
      if (size < 0)
+     {
          QString msg = "Folder::create_file(): size must be >= 0";
--        return make_exceptional_future<shared_ptr<Uploader>>(InvalidArgumentException(msg));
--    }
--    auto root = get_root();
--    if (!root)
--    {
--        return make_exceptional_future<Uploader::SPtr>(RuntimeDestroyedException("Folder::create_file()"));
++        return internal::make_exceptional_future<shared_ptr<Uploader>>(InvalidArgumentException(msg));
+     }
      try
@@ -267,36 +243,26 @@
          auto sanitized_name = sanitize(name, "Folder::create_file()");
          if (is_reserved_path(sanitized_name))
+         {
--            QString msg = "Folder::create_file(): names beginning with " + QString(TMPFILE_PREFIX) + " are reserved";
--            return make_exceptional_future<Uploader::SPtr>(InvalidArgumentException(msg));
++            QString msg = "Folder::create_file(): names beginning with \"" + QString(TMPFILE_PREFIX) + "\" are reserved";
++            throw InvalidArgumentException(msg);
+         }
          p /= sanitized_name;
          if (exists(p))
+         {
              QString msg = "Folder::create_file(): item with name \"" + name + "\" exists already";
--            return make_exceptional_future<Uploader::SPtr>(ExistsException(msg, native_identity(), name));
++            throw ExistsException(msg, native_identity() + "/" + name, name);
+         }
          auto impl = new UploaderImpl(shared_ptr<File>(),
                                       size,
                                       QString::fromStdString(p.native()),
                                       ConflictPolicy::error_if_conflict,
--                                     root);
++                                     root_);
          Uploader::SPtr uploader(new Uploader(impl));
          return make_ready_future(uploader);
+     }
--    catch (StorageException const& e)
--    {
--        return make_exceptional_future<Uploader::SPtr>(e);
--    }
--    catch (boost::filesystem::filesystem_error const& e)
--    {
--        return make_exceptional_future<Uploader::SPtr>(ResourceException(QString("Folder::create_file: ") + e.what(),
--                                                                         e.code().value()));
--    }
--    catch (std::exception const& e)
--    {
--        return make_exceptional_future<Uploader::SPtr>(ResourceException(QString("Folder::create_file: ") + e.what(),
--                                                                         errno));
++    catch (std::exception const&)
++    {
++        return make_exceptional_future<Uploader::SPtr>("Folder::create_file()", current_exception());
+     }
+ }
 === modified file 'src/qt/client/internal/local_client/ItemImpl.cpp'
 --- src/qt/client/internal/local_client/ItemImpl.cpp	2016-08-03 06:10:39 +0000
 +++ src/qt/client/internal/local_client/ItemImpl.cpp	2016-08-03 06:10:39 +0000
@@ -21,11 +21,12 @@
  #include <unity/storage/internal/safe_strerror.h>
  #include <unity/storage/qt/client/Account.h>
  #include <unity/storage/qt/client/Exceptions.h>
--#include <unity/storage/qt/client/internal/make_future.h>
  #include <unity/storage/qt/client/internal/local_client/AccountImpl.h>
  #include <unity/storage/qt/client/internal/local_client/FileImpl.h>
  #include <unity/storage/qt/client/internal/local_client/RootImpl.h>
--#include <unity/storage/qt/client/internal/local_client/tmpfile-prefix.h>
++#include <unity/storage/qt/client/internal/local_client/storage_exception.h>
++#include <unity/storage/qt/client/internal/local_client/tmpfile_prefix.h>
++#include <unity/storage/qt/client/internal/make_future.h>
  #include <boost/algorithm/string/predicate.hpp>
  #pragma GCC diagnostic push
@@ -54,7 +55,6 @@
  ItemImpl::ItemImpl(QString const& identity, ItemType type)
      : ItemBase(identity, type)
--    , deleted_(false)
+ {
      assert(!identity.isEmpty());
      auto path = boost::filesystem::canonical(identity.toStdString());
@@ -66,87 +66,49 @@
  QString ItemImpl::etag() const
+ {
--    lock_guard<mutex> guard(mutex_);
++    lock_guard<decltype(mutex_)> guard(mutex_);
--    if (deleted_)
--    {
--        throw deleted_ex("Item::etag()");
--    }
--    if (!get_root())
--    {
--        throw RuntimeDestroyedException("Item::etag()");
--    }
++    throw_if_destroyed("Item::etag()");
      return etag_;
+ }
  QVariantMap ItemImpl::metadata() const
+ {
--    lock_guard<mutex> guard(mutex_);
++    lock_guard<decltype(mutex_)> guard(mutex_);
--    if (deleted_)
--    {
--        throw deleted_ex("Item::metadata()");
--    }
--    if (!get_root())
--    {
--        throw RuntimeDestroyedException("Item::metadata()");
--    }
++    throw_if_destroyed("Item::metadata()");
      return metadata_;
+ }
  QDateTime ItemImpl::last_modified_time() const
+ {
--    lock_guard<mutex> guard(mutex_);
++    lock_guard<decltype(mutex_)> guard(mutex_);
--    if (deleted_)
--    {
--        throw deleted_ex("Item::last_modified_time()");
--    }
--    if (!get_root())
--    {
--        throw RuntimeDestroyedException("Item::last_modified_time()");
--    }
++    throw_if_destroyed("Item::last_modified_time()");
      return modified_time_;
+ }
--namespace
--{
--
--using namespace boost::filesystem;
--
--void copy_recursively(path const& source, path const& target)
--{
--    auto s = status(source);
--    if (is_regular_file(s))
--    {
--        copy_file(source, target);
--        return;
--    }
--    else if (is_directory(s))
--    {
--        copy_directory(source, target);  // Poorly named in boost; this creates the target dir without recursion
--        for (directory_iterator it(source); it != directory_iterator(); ++it)
--        {
--            path source_entry = it->path();
--            path target_entry = target;
--            target_entry /= source_entry.filename();
--            copy_recursively(source_entry, target_entry);
--        }
--    }
--    else
--    {
--        // Ignore everything that's not a directory or file.
--    }
--}
--
--}  // namespace
--
  QFuture<shared_ptr<Item>> ItemImpl::copy(shared_ptr<Folder> const& new_parent, QString const& new_name)
+ {
      if (!new_parent)
+     {
          QString msg = "Item::copy(): new_parent cannot be nullptr";
--        return make_exceptional_future<shared_ptr<Item>>(InvalidArgumentException(msg));
++        return internal::make_exceptional_future<shared_ptr<Item>>(InvalidArgumentException(msg));
++    }
++    auto new_parent_impl = dynamic_pointer_cast<FolderImpl>(new_parent->p_);
++
++    lock(mutex_, new_parent_impl->mutex_);
++    lock_guard<decltype(mutex_)> this_guard(mutex_, std::adopt_lock);
++    lock_guard<decltype(mutex_)> other_guard(new_parent_impl->mutex_, adopt_lock);
++
++    try
++    {
++        throw_if_destroyed("Item::copy()");
++        new_parent_impl->throw_if_destroyed("Item::copy()");
++    }
++    catch (StorageException const& e)
++    {
++        return internal::make_exceptional_future<shared_ptr<Item>>(e);
+     }
      auto This = dynamic_pointer_cast<ItemImpl>(shared_from_this());  // Keep this item alive while the lambda is alive.
@@ -155,23 +117,17 @@
          auto new_parent_impl = dynamic_pointer_cast<FolderImpl>(new_parent->p_);
          lock(This->mutex_, new_parent_impl->mutex_);
--        lock_guard<mutex> this_guard(This->mutex_, std::adopt_lock);
--        lock_guard<mutex> other_guard(new_parent_impl->mutex_, adopt_lock);
++        lock_guard<decltype(mutex_)> this_guard(This->mutex_, std::adopt_lock);
++        lock_guard<decltype(mutex_)> other_guard(new_parent_impl->mutex_, adopt_lock);
--        if (This->deleted_)
--        {
--            throw This->deleted_ex("Item::copy()");
--        }
--        if (new_parent_impl->deleted_)
--        {
--            throw new_parent_impl->deleted_ex("Item::copy()");
--        }
++        This->throw_if_destroyed("Item::copy()");
++        new_parent_impl->throw_if_destroyed("Item::copy()");
          // TODO: This needs to deeply compare account identity because the client may have refreshed the accounts list.
          if (This->root()->account() != new_parent->root()->account())  // Throws if account or runtime were destroyed.
+         {
              // Can't do cross-account copy.
--            QString msg = QString("Item::copy(): Source (") + This->name_ + ") and target ("
++            QString msg = QString("Item::copy(): source (") + This->name_ + ") and target ("
                            + new_name + ") must belong to the same account";
              throw LogicException(msg);
+         }
@@ -187,22 +143,22 @@
              target_path /= sanitized_name;
              if (is_reserved_path(target_path))
+             {
--                QString msg = "Item::copy(): names beginning with " + QString(TMPFILE_PREFIX) + " are reserved";
++                QString msg = "Item::copy(): names beginning with \"" + QString(TMPFILE_PREFIX) + "\" are reserved";
                  throw InvalidArgumentException(msg);
+             }
++            if (exists(target_path))
++            {
++                QString msg = "Item::copy(): item with name \"" + new_name + "\" exists already";
++                throw ExistsException(msg, This->identity_, This->name_);
++            }
++
              if (This->type_ == ItemType::file)
+             {
                  copy_file(source_path, target_path);
                  return FileImpl::make_file(QString::fromStdString(target_path.native()), new_parent_impl->root_);
+             }
--            if (exists(target_path))
--            {
--                QString msg = "Item::copy(): item with name \"" + new_name + "\" exists already";
--                throw ExistsException(msg, This->identity_, This->name_);
--            }
--
              // For recursive copy, we create a temporary directory in lieu of target_path and recursively copy
              // everything into the temporary directory. This ensures that we don't invalidate directory iterators
              // by creating things while we are iterating, potentially getting trapped in an infinite loop.
@@ -211,7 +167,7 @@
              create_directories(tmp_path);
              for (directory_iterator it(source_path); it != directory_iterator(); ++it)
+             {
--                if (tmp_path.compare(canonical(it->path())) == 0)
++                if (is_reserved_path(it->path()))
+                 {
                      continue;  // Don't recurse into the temporary directory
+                 }
@@ -221,23 +177,15 @@
                      path source_entry = it->path();
                      path target_entry = tmp_path;
                      target_entry /= source_entry.filename();
--                    copy_recursively(source_entry, target_entry);
++                    ItemImpl::copy_recursively(source_entry, target_entry);
+                 }
+             }
              rename(tmp_path, target_path);
              return FolderImpl::make_folder(QString::fromStdString(target_path.native()), new_parent_impl->root_);
+         }
--        catch (StorageException const&)
--        {
--            throw;
--        }
--        catch (boost::filesystem::filesystem_error const& e)
--        {
--            throw ResourceException(QString("Item::copy(): ") + e.what(), e.code().value());
--        }
--        catch (std::exception const& e)
--        {
--            throw ResourceException(QString("Item::copy(): ") + e.what(), errno);
++        catch (std::exception const&)
++        {
++            throw_storage_exception("Item::copy()", current_exception());
+         }
      };
      return QtConcurrent::run(copy);
@@ -248,7 +196,22 @@
      if (!new_parent)
+     {
          QString msg = "Item::move(): new_parent cannot be nullptr";
--        return make_exceptional_future<shared_ptr<Item>>(InvalidArgumentException(msg));
++        return internal::make_exceptional_future<shared_ptr<Item>>(InvalidArgumentException(msg));
++    }
++    auto new_parent_impl = dynamic_pointer_cast<FolderImpl>(new_parent->p_);
++
++    lock(mutex_, new_parent_impl->mutex_);
++    lock_guard<decltype(mutex_)> this_guard(mutex_, std::adopt_lock);
++    lock_guard<decltype(mutex_)> other_guard(new_parent_impl->mutex_, adopt_lock);
++
++    try
++    {
++        throw_if_destroyed("Item::move()");
++        new_parent_impl->throw_if_destroyed("Item::move()");
++    }
++    catch (StorageException const& e)
++    {
++        return internal::make_exceptional_future<shared_ptr<Item>>(e);
+     }
      auto This = dynamic_pointer_cast<ItemImpl>(shared_from_this());  // Keep this item alive while the lambda is alive.
@@ -257,30 +220,24 @@
          auto new_parent_impl = dynamic_pointer_cast<FolderImpl>(new_parent->p_);
          lock(This->mutex_, new_parent_impl->mutex_);
--        lock_guard<mutex> this_guard(This->mutex_, std::adopt_lock);
--        lock_guard<mutex> other_guard(new_parent_impl->mutex_, adopt_lock);
++        lock_guard<decltype(mutex_)> this_guard(This->mutex_, std::adopt_lock);
++        lock_guard<decltype(mutex_)> other_guard(new_parent_impl->mutex_, adopt_lock);
--        if (This->deleted_)
--        {
--            throw This->deleted_ex("Item::move()");
--        }
--        if (new_parent_impl->deleted_)
--        {
--            throw new_parent_impl->deleted_ex("Item::move()");
--        }
++        This->throw_if_destroyed("Item::move()");
++        new_parent_impl->throw_if_destroyed("Item::move()");
          // TODO: This needs to deeply compare account identity because the client may have refreshed the accounts list.
          if (This->root()->account() != new_parent->root()->account())  // Throws if account or runtime were destroyed.
+         {
              // Can't do cross-account move.
--            QString msg = QString("Item::move(): Source (") + This->name_ + ") and target ("
++            QString msg = QString("Item::move(): source (") + This->name_ + ") and target ("
                            + new_name + ") must belong to the same account";
              throw LogicException(msg);
+         }
          if (This->type_ == ItemType::root)
+         {
              // Can't move a root.
--            throw LogicException("Item::move(): Cannot move root folder");
++            throw LogicException("Item::move(): cannot move root folder");
+         }
          try
@@ -296,7 +253,7 @@
+             }
              if (is_reserved_path(target_path))
+             {
--                QString msg = "Item::move(): names beginning with " + QString(TMPFILE_PREFIX) + " are reserved";
++                QString msg = "Item::move(): names beginning with \"" + QString(TMPFILE_PREFIX) + "\" are reserved";
                  throw InvalidArgumentException(msg);
+             }
              rename(This->native_identity().toStdString(), target_path);
@@ -307,17 +264,9 @@
+             }
              return FileImpl::make_file(QString::fromStdString(target_path.native()), new_parent_impl->root_);
+         }
--        catch (StorageException const&)
--        {
--            throw;
--        }
--        catch (boost::filesystem::filesystem_error const& e)
--        {
--            throw ResourceException(QString("Item::move(): ") + e.what(), e.code().value());
--        }
--        catch (std::exception const& e)
--        {
--            throw ResourceException(QString("Item::move(): ") + e.what(), errno);
++        catch (std::exception const&)
++        {
++            throw_storage_exception(QString("Item::move(): "), current_exception());
+         }
      };
      return QtConcurrent::run(move);
@@ -325,18 +274,15 @@
  QFuture<QVector<Folder::SPtr>> ItemImpl::parents() const
+ {
--    lock_guard<mutex> guard(mutex_);
++    lock_guard<decltype(mutex_)> guard(mutex_);
--    QFutureInterface<QVector<Folder::SPtr>> qf;
--    if (deleted_)
++    try
+     {
--        return make_exceptional_future<QVector<Folder::SPtr>>(deleted_ex("Item::parents()"));
++        throw_if_destroyed("Item::parents()");
+     }
--
--    auto root = get_root();
--    if (!root)
++    catch (StorageException const& e)
+     {
--        return make_exceptional_future<QVector<Folder::SPtr>>(RuntimeDestroyedException("Item::parents()"));
++        return internal::make_exceptional_future<QVector<Folder::SPtr>>(e);
+     }
      using namespace boost::filesystem;
@@ -345,6 +291,7 @@
      path p = native_identity().toStdString();
      QString parent_path = QString::fromStdString(p.parent_path().native());
++    auto root = root_.lock();
      QVector<Folder::SPtr> results;
      if (parent_path != root->native_identity())
+     {
@@ -359,16 +306,9 @@
  QVector<QString> ItemImpl::parent_ids() const
+ {
--    lock_guard<mutex> guard(mutex_);
++    lock_guard<decltype(mutex_)> guard(mutex_);
--    if (deleted_)
--    {
--        throw deleted_ex("Item::parent_ids()");
--    }
--    if (!get_root())
--    {
--        throw RuntimeDestroyedException("Item::parent_ids()");
--    }
++    throw_if_destroyed("Item::parent_ids()");
      using namespace boost::filesystem;
@@ -383,36 +323,31 @@
  QFuture<void> ItemImpl::delete_item()
+ {
++    lock_guard<decltype(mutex_)> guard(mutex_);
++
++    try
++    {
++        throw_if_destroyed("Item::delete_item()");
++    }
++    catch (StorageException const& e)
++    {
++        return internal::make_exceptional_future(e);
++    }
++
      auto This = dynamic_pointer_cast<ItemImpl>(shared_from_this());  // Keep this item alive while the lambda is alive.
      auto destroy = [This]()
+     {
--        lock_guard<mutex> guard(This->mutex_);
--
--        if (This->deleted_)
--        {
--            throw This->deleted_ex("Item::delete_item()");
--        }
--        if (!This->get_root())
--        {
--            throw RuntimeDestroyedException("Item::delete_item()");
--        }
--
++        lock_guard<decltype(mutex_)> guard(This->mutex_);
++
++        This->throw_if_destroyed("Item::delete_item()");
          try
+         {
              boost::filesystem::remove_all(This->native_identity().toStdString());
              This->deleted_ = true;
+         }
--        catch (StorageException const&)
--        {
--            throw;
--        }
--        catch (boost::filesystem::filesystem_error const& e)
--        {
--            throw ResourceException(QString("Item::delete_item(): ") + e.what(), e.code().value());
--        }
--        catch (std::exception const& e)
--        {
--            throw ResourceException(QString("Item::delete_item(): ") + e.what(), errno);
++        catch (std::exception const&)
++        {
++            throw_storage_exception(QString("Item::delete_item()"), current_exception());
+         }
      };
      return QtConcurrent::run(destroy);
@@ -420,11 +355,17 @@
  QDateTime ItemImpl::creation_time() const
+ {
++    lock_guard<decltype(mutex_)> guard(mutex_);
++
++    throw_if_destroyed("Item::creation_time()");
      return QDateTime();
+ }
  MetadataMap ItemImpl::native_metadata() const
+ {
++    lock_guard<decltype(mutex_)> guard(mutex_);
++
++    throw_if_destroyed("Item::native_metadata()");
      return MetadataMap();
+ }
@@ -438,8 +379,8 @@
+     }
      lock(mutex_, other_impl->mutex_);
--    lock_guard<mutex> this_guard(mutex_, std::adopt_lock);
--    lock_guard<mutex> other_guard(other_impl->mutex_, adopt_lock);
++    lock_guard<decltype(mutex_)> this_guard(mutex_, std::adopt_lock);
++    lock_guard<decltype(mutex_)> other_guard(other_impl->mutex_, adopt_lock);
      if (deleted_ || other_impl->deleted_)
+     {
@@ -450,7 +391,7 @@
  void ItemImpl::set_timestamps() noexcept
+ {
--    lock_guard<mutex> guard(mutex_);
++    lock_guard<decltype(mutex_)> guard(mutex_);
      string id = identity_.toStdString();
      // Use nano-second resolution for the ETag, if the file system supports it.
@@ -467,7 +408,7 @@
  bool ItemImpl::has_conflict() const noexcept
+ {
--    lock_guard<mutex> guard(mutex_);
++    lock_guard<decltype(mutex_)> guard(mutex_);
      string id = identity_.toStdString();
      struct stat st;
@@ -515,10 +456,35 @@
      return boost::starts_with(filename, TMPFILE_PREFIX);
+ }
--DeletedException ItemImpl::deleted_ex(QString const& method) const noexcept
++void ItemImpl::copy_recursively(boost::filesystem::path const& source, boost::filesystem::path const& target)
+ {
--    QString msg = method + ": \"" + identity_ + "\" was deleted previously";
--    return DeletedException(msg, identity_, name_);
++    using namespace boost::filesystem;
++
++    if (is_reserved_path(source))
++    {
++        return;  // Don't copy temporary directories.
++    }
++
++    auto s = status(source);
++    if (is_regular_file(s))
++    {
++        copy_file(source, target);
++    }
++    else if (is_directory(s))
++    {
++        copy_directory(source, target);  // Poorly named in boost; this creates the target dir without recursion
++        for (directory_iterator it(source); it != directory_iterator(); ++it)
++        {
++            path source_entry = it->path();
++            path target_entry = target;
++            target_entry /= source_entry.filename();
++            copy_recursively(source_entry, target_entry);
++        }
++    }
++    else
++    {
++        // Ignore everything that's not a directory or file.
++    }
+ }
  }  // namespace local_client
 === modified file 'src/qt/client/internal/local_client/RootImpl.cpp'
 --- src/qt/client/internal/local_client/RootImpl.cpp	2016-08-03 06:10:39 +0000
 +++ src/qt/client/internal/local_client/RootImpl.cpp	2016-08-03 06:10:39 +0000
@@ -21,6 +21,7 @@
  #include <unity/storage/qt/client/Exceptions.h>
  #include <unity/storage/qt/client/internal/make_future.h>
  #include <unity/storage/qt/client/internal/local_client/FileImpl.h>
++#include <unity/storage/qt/client/internal/local_client/storage_exception.h>
  #include <unity/storage/qt/client/Root.h>
  using namespace std;
@@ -68,46 +69,55 @@
  QString RootImpl::name() const
+ {
--    if (!get_root())
--    {
--        throw RuntimeDestroyedException("Root::name()");
--    }
++    lock_guard<decltype(mutex_)> guard(mutex_);
++
++    throw_if_destroyed("Root::name()");
      return "";
+ }
  QFuture<QVector<Folder::SPtr>> RootImpl::parents() const
+ {
--    if (!get_root())
--    {
--        throw RuntimeDestroyedException("Root::parents()");
--    }
++    lock_guard<decltype(mutex_)> guard(mutex_);
++
++    throw_if_destroyed("Root::parents()");
      return make_ready_future(QVector<Folder::SPtr>());  // For the root, we return an empty vector.
+ }
  QVector<QString> RootImpl::parent_ids() const
+ {
--    if (!get_root())
--    {
--        throw RuntimeDestroyedException("Root::parent_ids()");
--    }
++    lock_guard<decltype(mutex_)> guard(mutex_);
++
++    throw_if_destroyed("Root::parent_ids()");
      return QVector<QString>();  // For the root, we return an empty vector.
+ }
  QFuture<void> RootImpl::delete_item()
+ {
--    if (!get_root())
--    {
--        throw RuntimeDestroyedException("Root::delete_item()");
++    lock_guard<decltype(mutex_)> guard(mutex_);
++
++    try
++    {
++        throw_if_destroyed("Root::delete_item()");
++    }
++    catch (StorageException const& e)
++    {
++        return internal::make_exceptional_future(e);
+     }
      // Cannot delete root.
--    return make_exceptional_future(LogicException("Root::delete_item(): Cannot delete root folder"));
++    return internal::make_exceptional_future(LogicException("Root::delete_item(): Cannot delete root folder"));
+ }
  QFuture<int64_t> RootImpl::free_space_bytes() const
+ {
--    if (!get_root())
--    {
--        throw RuntimeDestroyedException("Root::free_space_bytes()");
++    lock_guard<decltype(mutex_)> guard(mutex_);
++
++    try
++    {
++        throw_if_destroyed("Root::free_space_bytes()");
++    }
++    catch (StorageException const& e)
++    {
++        return internal::make_exceptional_future<int64_t>(e);
+     }
      using namespace boost::filesystem;
@@ -118,24 +128,24 @@
          return make_ready_future<int64_t>(si.available);
+     }
      // LCOV_EXCL_START
--    catch (boost::filesystem::filesystem_error const& e)
--    {
--        return make_exceptional_future<int64_t>(ResourceException(QString("Root::free_space_bytes(): ") + e.what(),
--                                                                  e.code().value()));
--    }
--    catch (std::exception const& e)
--    {
--        return make_exceptional_future<int64_t>(ResourceException(QString("Root::free_space_bytes(): ") + e.what(),
--                                                                  errno));
++    catch (std::exception const&)
++    {
++        return make_exceptional_future<int64_t>(QString("Root::free_space_bytes()"), current_exception());
+     }
      // LCOV_EXCL_STOP
+ }
  QFuture<int64_t> RootImpl::used_space_bytes() const
+ {
--    if (!get_root())
--    {
--        throw RuntimeDestroyedException("Root::used_space_bytes()");
++    lock_guard<decltype(mutex_)> guard(mutex_);
++
++    try
++    {
++        throw_if_destroyed("Root::used_space_bytes()");
++    }
++    catch (StorageException const& e)
++    {
++        return internal::make_exceptional_future<int64_t>(e);
+     }
      using namespace boost::filesystem;
@@ -146,25 +156,30 @@
          return make_ready_future<int64_t>(si.capacity - si.available);
+     }
      // LCOV_EXCL_START
--    catch (boost::filesystem::filesystem_error const& e)
--    {
--        return make_exceptional_future<int64_t>(ResourceException(QString("Root::used_space_bytes(): ") + e.what(),
--                                                                  e.code().value()));
--    }
--    catch (std::exception const& e)
--    {
--        return make_exceptional_future<int64_t>(ResourceException(QString("Root::used_space_bytes(): ") + e.what(),
--                                                                  errno));
++    catch (std::exception const&)
++    {
++        return make_exceptional_future<int64_t>(QString("Root::used_space_bytes()"), current_exception());
+     }
      // LCOV_EXCL_STOP
+ }
  QFuture<Item::SPtr> RootImpl::get(QString native_identity) const
+ {
++    lock_guard<decltype(mutex_)> guard(mutex_);
++
++    try
++    {
++        throw_if_destroyed("Root::get()");
++    }
++    catch (StorageException const& e)
++    {
++        return internal::make_exceptional_future<Item::SPtr>(e);
++    }
++
      auto root = get_root();
      if (!root)
+     {
--        throw RuntimeDestroyedException("Root::native_identity()");
++        return internal::make_exceptional_future<Item::SPtr>(RuntimeDestroyedException("Root::get()"));
+     }
      using namespace boost::filesystem;
@@ -176,7 +191,7 @@
          if (!id_path.is_absolute())
+         {
              QString msg = "Root::get(): identity \"" + native_identity + "\" must be an absolute path";
--            return make_exceptional_future<Item::SPtr>(InvalidArgumentException(msg));
++            throw InvalidArgumentException(msg);
+         }
          // Make sure that native_identity is contained in or equal to the root path.
@@ -189,14 +204,14 @@
              // Too few components, or wrong path prefix. Therefore, native_identity can't
              // possibly point at something below the root.
              QString msg = QString("Root::get(): identity \"") + native_identity + "\" points outside the root folder";
--            return make_exceptional_future<Item::SPtr>(InvalidArgumentException(msg));
++            throw InvalidArgumentException(msg);
+         }
          // Don't allow reserved files to be found.
          if (is_reserved_path(id_path))
+         {
--            QString msg = "Root::get(): no such item: " + native_identity;
--            return make_exceptional_future<Item::SPtr>(NotExistsException(msg, native_identity));
++            QString msg = "Root::get(): no such item: \"" + native_identity + "\"";
++            throw NotExistsException(msg, native_identity);
+         }
          file_status s = status(id_path);
@@ -213,23 +228,13 @@
+         {
              return make_ready_future<Item::SPtr>(FileImpl::make_file(path, root));
+         }
--        QString msg = "Root::get(): no such item: " + native_identity;
--        return make_exceptional_future<Item::SPtr>(NotExistsException(msg, native_identity));
--    }
--    catch (StorageException const& e)
--    {
--        return make_exceptional_future<Item::SPtr>(e);
--    }
--    catch (boost::filesystem::filesystem_error const& e)
--    {
--        return make_exceptional_future<Item::SPtr>(QString("Root::get(): ") + e.what(), e, native_identity);
--    }
--    // LCOV_EXCL_START
--    catch (std::exception const& e)
--    {
--        return make_exceptional_future<Item::SPtr>(ResourceException(QString("Root::get(): ") + e.what(), errno));
--    }
--    // LCOV_EXCL_STOP
++        QString msg = "Root::get(): no such item: \"" + native_identity + "\"";
++        throw NotExistsException(msg, native_identity);
++    }
++    catch (std::exception const&)
++    {
++        return make_exceptional_future<Item::SPtr>(QString("Root::get()"), current_exception(), native_identity);
++    }
+ }
  Root::SPtr RootImpl::make_root(QString const& identity, std::weak_ptr<Account> const& account)
 === modified file 'src/qt/client/internal/local_client/RuntimeImpl.cpp'
 --- src/qt/client/internal/local_client/RuntimeImpl.cpp	2016-08-03 06:10:39 +0000
 +++ src/qt/client/internal/local_client/RuntimeImpl.cpp	2016-08-03 06:10:39 +0000
@@ -19,6 +19,7 @@
  #include <unity/storage/qt/client/internal/local_client/RuntimeImpl.h>
  #include <unity/storage/qt/client/Account.h>
++#include <unity/storage/qt/client/Exceptions.h>
  #include <unity/storage/qt/client/internal/make_future.h>
  #include <unity/storage/qt/client/internal/local_client/AccountImpl.h>
 === modified file 'src/qt/client/internal/local_client/UploaderImpl.cpp'
 --- src/qt/client/internal/local_client/UploaderImpl.cpp	2016-08-03 06:10:39 +0000
 +++ src/qt/client/internal/local_client/UploaderImpl.cpp	2016-08-03 06:10:39 +0000
@@ -22,7 +22,7 @@
  #include <unity/storage/qt/client/Exceptions.h>
  #include <unity/storage/qt/client/File.h>
  #include <unity/storage/qt/client/internal/local_client/FileImpl.h>
--#include <unity/storage/qt/client/internal/local_client/tmpfile-prefix.h>
++#include <unity/storage/qt/client/internal/local_client/tmpfile_prefix.h>
  #include <unity/storage/qt/client/internal/make_future.h>
  #include <QLocalSocket>
@@ -93,8 +93,6 @@
      // Monitor read socket for ready-to-read, disconnected, and error events.
      connect(read_socket_.get(), &QLocalSocket::readyRead, this, &UploadWorker::on_bytes_ready);
      connect(read_socket_.get(), &QIODevice::readChannelFinished, this, &UploadWorker::on_read_channel_finished);
--    connect(read_socket_.get(), static_cast<void(QLocalSocket::*)(QLocalSocket::LocalSocketError)>(&QLocalSocket::error),
--            this, &UploadWorker::on_error);
      using namespace boost::filesystem;
@@ -114,10 +112,11 @@
          tmp_fd_.reset(mkstemp(const_cast<char*>(tmpfile.data())));
          if (tmp_fd_.get() == -1)
+         {
++            int error_code = errno;
              worker_initialized_.reportFinished();
              QString msg = "cannot create temp file \"" + QString::fromStdString(tmpfile)
                            + "\": " + QString::fromStdString(storage::internal::safe_strerror(errno));
--            handle_error(msg);
++            handle_error(msg, error_code);
              return;
+         }
          output_file_.reset(new QFile(QString::fromStdString(tmpfile)));
@@ -140,11 +139,6 @@
  void UploadWorker::do_finish()
+ {
--    if (qf_.future().isFinished())
--    {
--        return;  // Future was set previously, no point in continuing.
--    }
--
      switch (state_)
+     {
          case in_progress:
@@ -165,8 +159,10 @@
+         }
          case error:
+         {
++            // LCOV_EXCL_START
              make_exceptional_future(qf_, ResourceException(error_msg_, error_code_));
              break;
++            // LCOV_EXCL_STOP
+         }
          default:
+         {
@@ -201,23 +197,15 @@
          auto bytes_written = output_file_->write(buf);
          if (bytes_written == -1)
+         {
--<<<<<<< TREE
--            handle_error("socket error: " + output_file_->errorString());  // LCOV_EXCL_LINE
--=======
--            handle_error("socket error: " + output_file_->errorString(), output_file_->error());
-->>>>>>> MERGE-SOURCE
++            handle_error("socket error: " + output_file_->errorString(), output_file_->error());  // LCOV_EXCL_LINE
+         }
          else if (bytes_written != buf.size())
+         {
              // LCOV_EXCL_START
              QString msg = "write error, requested " + QString::number(buf.size()) + " B, but wrote only "
                            + bytes_written + " B.";
--<<<<<<< TREE
--            handle_error(msg);
--            // LCOV_EXCL_STOP
--=======
              handle_error(msg, 0);
-->>>>>>> MERGE-SOURCE
++            // LCOV_EXCL_STOP
+         }
+     }
+ }
@@ -228,11 +216,6 @@
      do_finish();
+ }
--void UploadWorker::on_error()
--{
--    handle_error(read_socket_->errorString(), read_socket_->error());
--}
--
  void UploadWorker::finalize()
+ {
      auto file = file_.lock();
@@ -287,7 +270,6 @@
+     }
      // Link the anonymous tmp file into the file system.
--<<<<<<< TREE
      auto new_path = file->native_identity().toStdString();
      if (use_linkat_)
+     {
@@ -296,11 +278,12 @@
          if (linkat(-1, old_path.c_str(), tmp_fd_.get(), new_path.c_str(), AT_SYMLINK_FOLLOW) == -1)
+         {
              // LCOV_EXCL_START
++            int error_code = errno;
              state_ = error;
              QString msg = "Uploader::finish_upload(): linkat \"" + QString::fromStdString(old_path)
                            + "\" to \"" + file->native_identity() + "\" failed: "
                            + QString::fromStdString(storage::internal::safe_strerror(errno));
--            make_exceptional_future(qf_, ResourceException(msg));
++            make_exceptional_future(qf_, ResourceException(msg, error_code));
              return;
              // LCOV_EXCL_STOP
+         }
@@ -311,26 +294,15 @@
          auto old_path = output_file_->fileName().toStdString();
          if (rename(old_path.c_str(), new_path.c_str()) == -1)
+         {
++            int error_code = errno;
              state_ = error;
              QString msg = "Uploader::finish_upload(): rename \"" + QString::fromStdString(old_path)
                            + "\" to \"" + file->native_identity() + "\" failed: "
                            + QString::fromStdString(storage::internal::safe_strerror(errno));
--            make_exceptional_future(qf_, ResourceException(msg));
++            make_exceptional_future(qf_, ResourceException(msg, error_code));
              return;
+         }
          // LCOV_EXCL_STOP
--=======
--    string oldpath = string("/proc/self/fd/") + std::to_string(tmp_fd_.get());
--    string newpath = file->native_identity().toStdString();
--    ::unlink(newpath.c_str());  // linkat() will not remove existing file: http://lwn.net/Articles/559969/
--    if (linkat(-1, oldpath.c_str(), tmp_fd_.get(), newpath.c_str(), AT_SYMLINK_FOLLOW) == -1)
--    {
--        state_ = error;
--        QString msg = "Uploader::finish_upload(): linkat \"" + file->native_identity() + "\" failed: "
--                      + QString::fromStdString(storage::internal::safe_strerror(errno));
--        make_exceptional_future(qf_, ResourceException(msg, errno));
--        return;
-->>>>>>> MERGE-SOURCE
+     }
      state_ = finalized;
@@ -339,6 +311,7 @@
      make_ready_future(qf_, file);
+ }
++// LCOV_EXCL_START
  void UploadWorker::handle_error(QString const& msg, int error_code)
+ {
      if (state_ == in_progress)
@@ -351,6 +324,7 @@
      error_code_ = error_code;
      do_finish();
+ }
++// LCOV_EXCL_STOP
  UploadThread::UploadThread(UploadWorker* worker)
      : worker_(worker)
@@ -427,6 +401,7 @@
      if (write_socket_->state() == QLocalSocket::ConnectedState)
+     {
          write_socket_->disconnectFromServer();
++        write_socket_->close();
+     }
      return qf_.future();
+ }
@@ -434,6 +409,8 @@
  QFuture<void> UploaderImpl::cancel() noexcept
+ {
      Q_EMIT do_cancel();
++    upload_thread_->wait();
++    write_socket_->abort();
      return qf_.future();
+ }
 === added file 'src/qt/client/internal/local_client/storage_exception.cpp'
 --- src/qt/client/internal/local_client/storage_exception.cpp	1970-01-01 00:00:00 +0000
 +++ src/qt/client/internal/local_client/storage_exception.cpp	2016-08-03 06:10:39 +0000
@@ -0,0 +1,99 @@
++/*
++ * Copyright (C) 2016 Canonical Ltd
++ *
++ * This program is free software: you can redistribute it and/or modify
++ * it under the terms of the GNU Lesser General Public License version 3 as
++ * published by the Free Software Foundation.
++ *
++ * 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 Lesser General Public License for more details.
++ *
++ * You should have received a copy of the GNU Lesser General Public License
++ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
++ *
++ * Authors: Michi Henning <michi.henning@canonical.com>
++ */
++
++#include <unity/storage/qt/client/Exceptions.h>
++#include <unity/storage/qt/client/internal/local_client/storage_exception.h>
++
++namespace unity
++{
++namespace storage
++{
++namespace qt
++{
++namespace client
++{
++namespace internal
++{
++namespace local_client
++{
++
++using namespace boost::filesystem;
++
++void throw_storage_exception(QString const& method, std::exception_ptr ep)
++{
++    int error_code = errno;
++    try
++    {
++        std::rethrow_exception(ep);
++    }
++    catch (StorageException const&)
++    {
++        throw;
++    }
++    catch (filesystem_error const& e)
++    {
++        QString msg = method + ": " + e.what();
++        switch (e.code().value())
++        {
++            case EACCES:
++            case EPERM:
++            {
++                throw PermissionException(msg);
++            }
++            case EDQUOT:
++            case ENOSPC:
++            {
++                throw QuotaException(msg);  // Too messy to cover with a test case.  // LCOV_EXCL_LINE
++            }
++            default:
++            {
++                throw ResourceException(msg, e.code().value());
++            }
++        }
++    }
++    // LCOV_EXCL_START
++    catch (std::exception const& e)
++    {
++        QString msg = method + ": " + e.what();
++        throw ResourceException(msg, error_code);
++    }
++    // LCOV_EXCL_STOP
++}
++
++void throw_storage_exception(QString const& method, std::exception_ptr ep, QString const& key)
++{
++    try
++    {
++        std::rethrow_exception(ep);
++    }
++    catch (filesystem_error const& e)
++    {
++        if (e.code().value() == ENOENT)
++        {
++            throw NotExistsException(method + ": " + e.what(), key);
++        }
++    }
++    throw_storage_exception(method, ep);
++}
++
++}  // namespace local_client
++}  // namespace internal
++}  // namespace client
++}  // namespace qt
++}  // namespace storage
++}  // namespace unity
 === modified file 'src/qt/client/internal/remote_client/FileImpl.cpp'
 --- src/qt/client/internal/remote_client/FileImpl.cpp	2016-08-03 06:10:39 +0000
 +++ src/qt/client/internal/remote_client/FileImpl.cpp	2016-08-03 06:10:39 +0000
@@ -48,32 +48,25 @@
  int64_t FileImpl::size() const
+ {
--    if (deleted_)
--    {
--        throw deleted_ex("File::size()");
--    }
--    if (!get_root())
--    {
--        throw RuntimeDestroyedException("File::size()");
--    }
++    throw_if_destroyed("File::size()");
      return 0;  // TODO
+ }
  QFuture<shared_ptr<Uploader>> FileImpl::create_uploader(ConflictPolicy policy, int64_t size)
+ {
--    if (deleted_)
--    {
--        return make_exceptional_future<shared_ptr<Uploader>>(deleted_ex("File::create_uploader()"));
++    try
++    {
++        throw_if_destroyed("File::create_uploader()()");
++    }
++    catch (StorageException const& e)
++    {
++        return make_exceptional_future<shared_ptr<Uploader>>(e);
+     }
      if (size < 0)
+     {
          QString msg = "File::create_uploader(): size must be >= 0";
          return make_exceptional_future<shared_ptr<Uploader>>(InvalidArgumentException(msg));
+     }
--    if (!get_root())
--    {
--        return make_exceptional_future<shared_ptr<Uploader>>(RuntimeDestroyedException("File::create_uploader()"));
--    }
      QString old_etag = policy == ConflictPolicy::overwrite ? "" : md_.etag;
      auto prov = provider();
@@ -108,13 +101,13 @@
  QFuture<shared_ptr<Downloader>> FileImpl::create_downloader()
+ {
--    if (deleted_)
++    try
+     {
--        return make_exceptional_future<shared_ptr<Downloader>>(deleted_ex("File::create_downloader()"));
++        throw_if_destroyed("File::create_downloader()()");
+     }
--    if (!get_root())
++    catch (StorageException const& e)
+     {
--        return make_exceptional_future<shared_ptr<Downloader>>(RuntimeDestroyedException("File::create_downloader()"));
++        return make_exceptional_future<shared_ptr<Downloader>>(e);
+     }
      auto prov = provider();
 === modified file 'src/qt/client/internal/remote_client/FolderImpl.cpp'
 --- src/qt/client/internal/remote_client/FolderImpl.cpp	2016-08-03 06:10:39 +0000
 +++ src/qt/client/internal/remote_client/FolderImpl.cpp	2016-08-03 06:10:39 +0000
@@ -57,13 +57,13 @@
  QFuture<QVector<shared_ptr<Item>>> FolderImpl::list() const
+ {
--    if (deleted_)
++    try
+     {
--        return make_exceptional_future<QVector<shared_ptr<Item>>>(deleted_ex("Folder::list()"));
++        throw_if_destroyed("Folder::list()");
+     }
--    if (!get_root())
++    catch (StorageException const& e)
+     {
--        return make_exceptional_future<QVector<shared_ptr<Item>>>(RuntimeDestroyedException("Folder::list()"));
++        return make_exceptional_future<QVector<shared_ptr<Item>>>(e);
+     }
      auto prov = provider();
@@ -117,13 +117,13 @@
  QFuture<QVector<shared_ptr<Item>>> FolderImpl::lookup(QString const& name) const
+ {
--    if (deleted_)
++    try
+     {
--        return make_exceptional_future<QVector<shared_ptr<Item>>>(deleted_ex("Folder::lookup()"));
++        throw_if_destroyed("Folder::lookup()");
+     }
--    if (!get_root())
++    catch (StorageException const& e)
+     {
--        return make_exceptional_future<QVector<shared_ptr<Item>>>(RuntimeDestroyedException("Folder::lookup()"));
++        return make_exceptional_future<QVector<shared_ptr<Item>>>(e);
+     }
      auto prov = provider();
@@ -163,13 +163,13 @@
  QFuture<shared_ptr<Folder>> FolderImpl::create_folder(QString const& name)
+ {
--    if (deleted_)
++    try
+     {
--        return make_exceptional_future<shared_ptr<Folder>>(deleted_ex("Folder::create_folder()"));
++        throw_if_destroyed("Folder::create_folder()");
+     }
--    if (!get_root())
++    catch (StorageException const& e)
+     {
--        return make_exceptional_future<shared_ptr<Folder>>(RuntimeDestroyedException("Folder::create_folder()"));
++        return make_exceptional_future<shared_ptr<Folder>>(e);
+     }
      auto prov = provider();
@@ -203,19 +203,19 @@
  QFuture<shared_ptr<Uploader>> FolderImpl::create_file(QString const& name, int64_t size)
+ {
--    if (deleted_)
--    {
--        return make_exceptional_future<shared_ptr<Uploader>>(deleted_ex("Folder::create_file()"));
++    try
++    {
++        throw_if_destroyed("Folder::create_file()");
++    }
++    catch (StorageException const& e)
++    {
++        return make_exceptional_future<shared_ptr<Uploader>>(e);
+     }
      if (size < 0)
+     {
          QString msg = "Folder::create_file(): size must be >= 0";
          return make_exceptional_future<shared_ptr<Uploader>>(InvalidArgumentException(msg));
+     }
--    if (!get_root())
--    {
--        return make_exceptional_future<shared_ptr<Uploader>>(RuntimeDestroyedException("Folder::create_file()"));
--    }
      auto prov = provider();
      auto reply = prov->CreateFile(md_.item_id, name, size, "application/octet-stream", false);
 === modified file 'src/qt/client/internal/remote_client/ItemImpl.cpp'
 --- src/qt/client/internal/remote_client/ItemImpl.cpp	2016-08-03 06:10:39 +0000
 +++ src/qt/client/internal/remote_client/ItemImpl.cpp	2016-08-03 06:10:39 +0000
@@ -50,68 +50,48 @@
  QString ItemImpl::name() const
+ {
--    if (deleted_)
--    {
--        throw deleted_ex("Item::name()");
--    }
--    if (!get_root())
--    {
--        throw RuntimeDestroyedException("Item::name()");
--    }
++    throw_if_destroyed("Item::name()");
      return md_.name;
+ }
  QString ItemImpl::etag() const
+ {
--    if (deleted_)
--    {
--        throw deleted_ex("Item::etag()");
--    }
--    if (!get_root())
--    {
--        throw RuntimeDestroyedException("Item::etag()");
--    }
++    throw_if_destroyed("Item::etag()");
      return md_.etag;
+ }
  QVariantMap ItemImpl::metadata() const
+ {
--    if (deleted_)
--    {
--        throw deleted_ex("Item::metadata()");
--    }
--    if (!get_root())
--    {
--        throw RuntimeDestroyedException("Item::metadata()");
--    }
++    throw_if_destroyed("Item::metadata()");
      // TODO: need to agree on metadata representation
      return QVariantMap();
+ }
  QDateTime ItemImpl::last_modified_time() const
+ {
--    if (deleted_)
--    {
--        throw deleted_ex("Item::last_modified_time()");
--    }
--    if (!get_root())
--    {
--        throw RuntimeDestroyedException("Item::last_modified_time()");
--    }
++    throw_if_destroyed("Item::last_modified_time()");
      // TODO: need to agree on metadata representation
      return QDateTime();
+ }
  QFuture<shared_ptr<Item>> ItemImpl::copy(shared_ptr<Folder> const& new_parent, QString const& new_name)
+ {
--    if (deleted_)
--    {
--        return make_exceptional_future<shared_ptr<Item>>(deleted_ex("Item::copy()"));
--    }
--    if (!get_root())
--    {
--        return make_exceptional_future<shared_ptr<Item>>(RuntimeDestroyedException("Item::copy()"));
--    }
++    if (!new_parent)
++    {
++        QString msg = "Item::copy(): new_parent cannot be nullptr";
++        return internal::make_exceptional_future<shared_ptr<Item>>(InvalidArgumentException(msg));
++    }
++
++    try
++    {
++        throw_if_destroyed("Item::copy()");
++    }
++    catch (StorageException const& e)
++    {
++        return make_exceptional_future<shared_ptr<Item>>(e);
++    }
++    auto new_parent_impl = dynamic_pointer_cast<FolderImpl>(new_parent->p_);
++    new_parent_impl->throw_if_destroyed("Item::copy()");
      auto prov = provider();
      auto reply = prov->Copy(md_.item_id, new_parent->native_identity(), new_name);
@@ -144,14 +124,22 @@
  QFuture<shared_ptr<Item>> ItemImpl::move(shared_ptr<Folder> const& new_parent, QString const& new_name)
+ {
--    if (deleted_)
--    {
--        return make_exceptional_future<shared_ptr<Item>>(deleted_ex("Item::move()"));
--    }
--    if (!get_root())
--    {
--        return make_exceptional_future<shared_ptr<Item>>(RuntimeDestroyedException("Item::copy()"));
--    }
++    if (!new_parent)
++    {
++        QString msg = "Item::move(): new_parent cannot be nullptr";
++        return internal::make_exceptional_future<shared_ptr<Item>>(InvalidArgumentException(msg));
++    }
++
++    try
++    {
++        throw_if_destroyed("Item::move()");
++    }
++    catch (StorageException const& e)
++    {
++        return make_exceptional_future<shared_ptr<Item>>(e);
++    }
++    auto new_parent_impl = dynamic_pointer_cast<FolderImpl>(new_parent->p_);
++    new_parent_impl->throw_if_destroyed("Item::move()");
      auto prov = provider();
      if (!prov)
@@ -186,13 +174,13 @@
  QFuture<QVector<Folder::SPtr>> ItemImpl::parents() const
+ {
--    if (deleted_)
++    try
+     {
--        return make_exceptional_future<QVector<Folder::SPtr>>(deleted_ex("Item::parents()"));
++        throw_if_destroyed("Item::parents()");
+     }
--    if (!get_root())
++    catch (StorageException const& e)
+     {
--        return make_exceptional_future<QVector<Folder::SPtr>>(RuntimeDestroyedException("Item::parents()"));
++        return make_exceptional_future<QVector<Folder::SPtr>>(e);
+     }
      // TODO, need different metadata representation, affects xml
      return QFuture<QVector<Folder::SPtr>>();
@@ -200,28 +188,14 @@
  QVector<QString> ItemImpl::parent_ids() const
+ {
--    if (deleted_)
--    {
--        throw deleted_ex("Item::parent_ids()");
--    }
--    if (!get_root())
--    {
--        RuntimeDestroyedException("Item::parent_ids()");
--    }
++    throw_if_destroyed("Item::parent_ids()");
      // TODO, need different metadata representation, affects xml
      return QVector<QString>();
+ }
  QFuture<void> ItemImpl::delete_item()
+ {
--    if (deleted_)
--    {
--        return make_exceptional_future(deleted_ex("Item::delete_item()"));
--    }
--    if (!get_root())
--    {
--        return make_exceptional_future(RuntimeDestroyedException("Item::parents()"));
--    }
++    throw_if_destroyed("Item::delete_item()");
      auto prov = provider();
      auto reply = prov->Delete(md_.item_id);
@@ -238,20 +212,14 @@
  QDateTime ItemImpl::creation_time() const
+ {
--    if (deleted_)
--    {
--        throw deleted_ex("Item::creation_time()");
--    }
++    throw_if_destroyed("Item::creation_time()");
      // TODO: need to agree on metadata representation
      return QDateTime();
+ }
  MetadataMap ItemImpl::native_metadata() const
+ {
--    if (deleted_)
--    {
--        throw deleted_ex("Item::native_metadata()");
--    }
++    throw_if_destroyed("Item::native_metadata()");
      // TODO: need to agree on metadata representation
      return MetadataMap();
+ }
@@ -316,12 +284,6 @@
      return item;
+ }
--DeletedException ItemImpl::deleted_ex(QString const& method) const noexcept
--{
--    QString msg = method + ": " + identity_ + " was deleted previously";
--    return DeletedException(msg, identity_, md_.name);
--}
--
  }  // namespace remote_client
  }  // namespace internal
  }  // namespace client
 === modified file 'src/qt/client/internal/remote_client/RuntimeImpl.cpp'
 --- src/qt/client/internal/remote_client/RuntimeImpl.cpp	2016-08-03 06:10:39 +0000
 +++ src/qt/client/internal/remote_client/RuntimeImpl.cpp	2016-08-03 06:10:39 +0000
@@ -19,6 +19,7 @@
  #include <unity/storage/qt/client/internal/remote_client/RuntimeImpl.h>
  #include <unity/storage/qt/client/Account.h>
++#include <unity/storage/qt/client/Exceptions.h>
  #include <unity/storage/qt/client/internal/make_future.h>
  #include <unity/storage/qt/client/internal/remote_client/AccountImpl.h>
  #include <unity/storage/qt/client/internal/remote_client/dbusmarshal.h>
 === modified file 'tests/local-client/local-client_test.cpp'
 --- tests/local-client/local-client_test.cpp	2016-08-03 06:10:39 +0000
 +++ tests/local-client/local-client_test.cpp	2016-08-03 06:10:39 +0000
@@ -18,12 +18,8 @@
  #include <unity/storage/qt/client/client-api.h>
--<<<<<<< TREE
  #include <unity/storage/qt/client/internal/local_client/boost_filesystem.h>
--=======
--#include <unity/storage/qt/client/internal/boost_filesystem.h>
--#include <unity/storage/qt/client/internal/local_client/tmpfile-prefix.h>
-->>>>>>> MERGE-SOURCE
++#include <unity/storage/qt/client/internal/local_client/tmpfile_prefix.h>
  #include <gtest/gtest.h>
  #include <QCoreApplication>
@@ -39,6 +35,8 @@
  #include <fstream>
++Q_DECLARE_METATYPE(QLocalSocket::LocalSocketState)
++
  using namespace unity::storage;
  using namespace unity::storage::qt::client;
  using namespace std;
@@ -47,31 +45,61 @@
  // Bunch of helper function to reduce the amount of noise in the tests.
++template<typename T>
++void wait(T fut)
++{
++    QFutureWatcher<decltype(fut.result())> w;
++    QSignalSpy spy(&w, &decltype(w)::finished);
++    w.setFuture(fut);
++    ASSERT_TRUE(spy.wait(SIGNAL_WAIT_TIME));
++}
++
++template<>
++void wait(QFuture<void> fut)
++{
++    QFutureWatcher<void> w;
++    QSignalSpy spy(&w, &decltype(w)::finished);
++    w.setFuture(fut);
++    ASSERT_TRUE(spy.wait(SIGNAL_WAIT_TIME));
++}
++
++template <typename T>
++T call(QFuture<T> fut)
++{
++    wait(fut);
++    return fut.result();
++}
++
++template <>
++void call(QFuture<void> fut)
++{
++    wait(fut);
++    fut.waitForFinished();
++}
++
  Account::SPtr get_account(Runtime::SPtr const& runtime)
+ {
--    auto accounts = runtime->accounts().result();
--    assert(accounts.size() == 1);
++    auto accounts = call(runtime->accounts());
      return accounts[0];
+ }
  Root::SPtr get_root(Runtime::SPtr const& runtime)
+ {
      auto acc = get_account(runtime);
--    auto roots = acc->roots().result();
--    assert(roots.size() == 1);
++    auto roots = call(acc->roots());
      return roots[0];
+ }
  Folder::SPtr get_parent(Item::SPtr const& item)
+ {
      assert(item->type() != ItemType::root);
--    auto parents = item->parents().result();
++    auto parents = call(item->parents());
      return parents[0];
+ }
  void clear_folder(Folder::SPtr folder)
+ {
--    auto items = folder->list().result();
++    auto items = call(folder->list());
      for (auto i : items)
+     {
          i->delete_item().waitForFinished();
@@ -86,7 +114,7 @@
      return buf == expected;
+ }
--void write_file(Folder::SPtr const& folder, QString const& name, QByteArray const& contents)
++File::SPtr write_file(Folder::SPtr const& folder, QString const& name, QByteArray const& contents)
+ {
      QString ofile = folder->native_identity() + "/" + name;
      QFile f(ofile);
@@ -95,6 +123,23 @@
+     {
          assert(f.write(contents));
+     }
++    f.close();
++    auto items = call(folder->lookup(name));
++    return dynamic_pointer_cast<File>(items[0]);
++}
++
++File::SPtr make_deleted_file(Folder::SPtr parent, QString const& name)
++{
++    auto file = write_file(parent, name, "bytes");
++    call(file->delete_item());
++    return file;
++}
++
++Folder::SPtr make_deleted_folder(Folder::SPtr parent, QString const& name)
++{
++    auto folder = call(parent->create_folder(name));
++    call(folder->delete_item());
++    return folder;
+ }
  TEST(Runtime, lifecycle)
@@ -123,11 +168,11 @@
      auto runtime = Runtime::create();
      auto acc = get_account(runtime);
--    auto roots = acc->roots().result();
++    auto roots = call(acc->roots());
      EXPECT_EQ(1, roots.size());
      // Get roots again, to get coverage for lazy initialization.
--    roots = acc->roots().result();
++    roots = call(acc->roots());
      ASSERT_EQ(1, roots.size());
+ }
@@ -142,23 +187,31 @@
      EXPECT_EQ("", root->name());
      EXPECT_NE("", root->etag());
--    auto parents = root->parents().result();
--    EXPECT_TRUE(parents.isEmpty());
--    EXPECT_TRUE(root->parent_ids().isEmpty());
++    {
++        auto parents = call(root->parents());
++        EXPECT_TRUE(parents.isEmpty());
++        EXPECT_TRUE(root->parent_ids().isEmpty());
++    }
--    // get(<root-path>) must return the root.
--    auto item = root->get(root->native_identity()).result();
--    EXPECT_NE(nullptr, dynamic_pointer_cast<Root>(item));
--    EXPECT_TRUE(root->equal_to(item));
++    {
++        // get(<root-path>) must return the root.
++        auto item = call(root->get(root->native_identity()));
++        EXPECT_NE(nullptr, dynamic_pointer_cast<Root>(item));
++        EXPECT_TRUE(root->equal_to(item));
++    }
      // Free and used space can be anything, but must be > 0.
--    auto free_space = root->free_space_bytes().result();
--    cerr << "bytes free: " << free_space << endl;
--    EXPECT_GT(free_space, 0);
++    {
++        auto free_space = call(root->free_space_bytes());
++        cerr << "bytes free: " << free_space << endl;
++        EXPECT_GT(free_space, 0);
++    }
--    auto used_space = root->used_space_bytes().result();
--    cerr << "bytes used: " << used_space << endl;
--    EXPECT_GT(used_space, 0);
++    {
++        auto used_space = call(root->used_space_bytes());
++        cerr << "bytes used: " << used_space << endl;
++        EXPECT_GT(used_space, 0);
++    }
+ }
  TEST(Folder, basic)
@@ -169,43 +222,43 @@
      auto root = get_root(runtime);
      clear_folder(root);
--    auto items = root->list().result();
++    auto items = call(root->list());
      EXPECT_TRUE(items.isEmpty());
      // Create a file and check that it was created with correct type, name, and size 0.
--    auto uploader = root->create_file("file1", 0).result();
--    auto file = uploader->finish_upload().result();
++    auto uploader = call(root->create_file("file1", 0));
++    auto file = call(uploader->finish_upload());
      EXPECT_EQ(ItemType::file, file->type());
      EXPECT_EQ("file1", file->name());
      EXPECT_EQ(0, file->size());
      EXPECT_EQ(root->native_identity() + "/file1", file->native_identity());
      // Create a folder and check that it was created with correct type and name.
--    auto folder = root->create_folder("folder1").result();
++    auto folder = call(root->create_folder("folder1"));
      EXPECT_EQ(ItemType::folder, folder->type());
      EXPECT_EQ("folder1", folder->name());
      EXPECT_EQ(root->native_identity() + "/folder1", folder->native_identity());
      // Check that we can find both file1 and folder1.
--    auto item = root->lookup("file1").result()[0];
++    auto item = call(root->lookup("file1"))[0];
      file = dynamic_pointer_cast<File>(item);
      ASSERT_NE(nullptr, file);
      EXPECT_EQ("file1", file->name());
      EXPECT_EQ(0, file->size());
--    item = root->lookup("folder1").result()[0];
++    item = call(root->lookup("folder1"))[0];
      folder = dynamic_pointer_cast<Folder>(item);
      ASSERT_NE(nullptr, folder);
      ASSERT_EQ(nullptr, dynamic_pointer_cast<Root>(folder));
      EXPECT_EQ("folder1", folder->name());
--    item = root->get(file->native_identity()).result();
++    item = call(root->get(file->native_identity()));
      file = dynamic_pointer_cast<File>(item);
      ASSERT_NE(nullptr, file);
      EXPECT_EQ("file1", file->name());
      EXPECT_EQ(0, file->size());
--    item = root->get(folder->native_identity()).result();
++    item = call(root->get(folder->native_identity()));
      folder = dynamic_pointer_cast<Folder>(item);
      ASSERT_NE(nullptr, folder);
      ASSERT_EQ(nullptr, dynamic_pointer_cast<Root>(folder));
@@ -241,8 +294,8 @@
      EXPECT_EQ(root->native_identity(), folder->parent_ids()[0]);
      // Delete the file and check that only the directory is left.
--    file->delete_item().waitForFinished();
--    items = root->list().result();
++    call(file->delete_item());
++    items = call(root->list());
      ASSERT_EQ(1, items.size());
      folder = dynamic_pointer_cast<Folder>(items[0]);
      ASSERT_NE(nullptr, folder);
@@ -250,7 +303,7 @@
      // Delete the folder and check that the root is empty.
      folder->delete_item().waitForFinished();
--    items = root->list().result();
++    items = call(root->list());
      ASSERT_EQ(0, items.size());
+ }
@@ -262,8 +315,8 @@
      auto root = get_root(runtime);
      clear_folder(root);
--    auto d1 = root->create_folder("d1").result();
--    auto d2 = d1->create_folder("d2").result();
++    auto d1 = call(root->create_folder("d1"));
++    auto d2 = call(d1->create_folder("d2"));
      // Parent of d2 must be d1.
      EXPECT_TRUE(get_parent(d2)->equal_to(d1));
@@ -271,28 +324,10 @@
      // Delete is recursive
      d1->delete_item().waitForFinished();
--    auto items = root->list().result();
++    auto items = call(root->list());
      ASSERT_EQ(0, items.size());
+ }
--template<typename T>
--bool wait(T fut)
--{
--    QFutureWatcher<decltype(fut.result())> w;
--    QSignalSpy spy(&w, &decltype(w)::finished);
--    w.setFuture(fut);
--    return spy.wait(SIGNAL_WAIT_TIME);
--}
--
--template<>
--bool wait(QFuture<void> fut)
--{
--    QFutureWatcher<void> w;
--    QSignalSpy spy(&w, &decltype(w)::finished);
--    w.setFuture(fut);
--    return spy.wait(SIGNAL_WAIT_TIME);
--}
--
  TEST(File, upload)
+ {
      auto runtime = Runtime::create();
@@ -304,79 +339,73 @@
+     {
          // Upload a few bytes.
          QByteArray const contents = "Hello\n";
--        auto uploader = root->create_file("new_file", contents.size()).result();
++        auto uploader = call(root->create_file("new_file", contents.size()));
          auto written = uploader->socket()->write(contents);
          ASSERT_EQ(contents.size(), written);
--        auto file_fut = uploader->finish_upload();
--        ASSERT_TRUE(wait(file_fut));
--        auto file = file_fut.result();
++        auto file = call(uploader->finish_upload());
          EXPECT_EQ(contents.size(), file->size());
          ASSERT_TRUE(content_matches(file, contents));
          // Calling finish_upload() more than once must return the original future.
--        auto file2 = uploader->finish_upload().result();
++        auto file2 = call(uploader->finish_upload());
          EXPECT_TRUE(file2->equal_to(file));
          // Calling cancel() after finish_upload must do nothing.
          uploader->cancel();
--        file2 = uploader->finish_upload().result();
++        file2 = call(uploader->finish_upload());
          EXPECT_TRUE(file2->equal_to(file));
--        file->delete_item().waitForFinished();
++        call(file->delete_item());
+     }
+     {
          // Upload exactly 64 KB.
          QByteArray const contents(64 * 1024, 'a');
--        auto uploader = root->create_file("new_file", contents.size()).result();
++        auto uploader = call(root->create_file("new_file", contents.size()));
          auto written = uploader->socket()->write(contents);
          ASSERT_EQ(contents.size(), written);
--        auto file_fut = uploader->finish_upload();
--        ASSERT_TRUE(wait(file_fut));
--        auto file = file_fut.result();
++        auto file = call(uploader->finish_upload());
          EXPECT_EQ(contents.size(), file->size());
          ASSERT_TRUE(content_matches(file, contents));
--        file->delete_item().waitForFinished();
++        call(file->delete_item());
+     }
+     {
          // Upload 1000 KBj
          QByteArray const contents(1000 * 1024, 'a');
--        auto uploader = root->create_file("new_file", contents.size()).result();
++        auto uploader = call(root->create_file("new_file", contents.size()));
          auto written = uploader->socket()->write(contents);
          ASSERT_EQ(contents.size(), written);
--        auto file_fut = uploader->finish_upload();
--        ASSERT_TRUE(wait(file_fut));
--        auto file = file_fut.result();
++        auto file = call(uploader->finish_upload());
          EXPECT_EQ(contents.size(), file->size());
          ASSERT_TRUE(content_matches(file, contents));
--        file->delete_item().waitForFinished();
++        call(file->delete_item());
+     }
+     {
          // Upload empty file.
--        auto uploader = root->create_file("new_file", 0).result();
--        auto file = uploader->finish_upload().result();
++        auto uploader = call(root->create_file("new_file", 0));
++        auto file = call(uploader->finish_upload());
          ASSERT_EQ(0, file->size());
          // Again, and check that the ETag is different.
          auto old_etag = file->etag();
          sleep(1);
--        uploader = file->create_uploader(ConflictPolicy::overwrite, 0).result();
--        file = uploader->finish_upload().result();
++        uploader = call(file->create_uploader(ConflictPolicy::overwrite, 0));
++        file = call(uploader->finish_upload());
          EXPECT_NE(old_etag, file->etag());
--        file->delete_item().waitForFinished();
++        call(file->delete_item());
+     }
+     {
          // Let the uploader go out of scope and check that the file was not created.
--        root->create_file("new_file", 0).result();
++        call(root->create_file("new_file", 0));
          boost::filesystem::path path(TEST_DIR "/storage-framework/new_file");
          auto status = boost::filesystem::status(path);
          ASSERT_FALSE(boost::filesystem::exists(status));
@@ -392,31 +421,25 @@
      clear_folder(root);
      // Make a new file first.
--    auto uploader = root->create_file("new_file", 0).result();
--    auto file_fut = uploader->finish_upload();
--    ASSERT_TRUE(wait(file_fut));
--    auto file = file_fut.result();
++    auto uploader = call(root->create_file("new_file", 0));
++    auto file = call(uploader->finish_upload());
      EXPECT_EQ(0, file->size());
      auto old_etag = file->etag();
      // Create uploader for the file and write nothing.
--    uploader = file->create_uploader(ConflictPolicy::overwrite, 0).result();
--    file_fut = uploader->finish_upload();
--    ASSERT_TRUE(wait(file_fut));
--    file = file_fut.result();
++    uploader = call(file->create_uploader(ConflictPolicy::overwrite, 0));
++    file = call(uploader->finish_upload());
      EXPECT_EQ(0, file->size());
      // Same test again, but this time, we write a bunch of data.
      std::string s(1000000, 'a');
--    uploader = file->create_uploader(ConflictPolicy::overwrite, s.size()).result();
++    uploader = call(file->create_uploader(ConflictPolicy::overwrite, s.size()));
      uploader->socket()->write(&s[0], s.size());
      // Need to sleep here, otherwise it is possible for the
      // upload to finish within the granularity of the file system time stamps.
      sleep(1);
--    file_fut = uploader->finish_upload();
--    ASSERT_TRUE(wait(file_fut));
--    file = file_fut.result();
++    file = call(uploader->finish_upload());
      EXPECT_EQ(1000000, file->size());
      EXPECT_NE(old_etag, file->etag());
@@ -432,12 +455,12 @@
      clear_folder(root);
+     {
--        auto uploader = root->create_file("new_file", 20).result();
++        auto uploader = call(root->create_file("new_file", 20));
          // We haven't called finish_upload(), so the cancel is guaranteed
          // to catch the uploader in the in_progress state.
          uploader->cancel();
--        EXPECT_THROW(uploader->finish_upload().result(), CancelledException);
++        EXPECT_THROW(call(uploader->finish_upload()), CancelledException);
          boost::filesystem::path path(TEST_DIR "/storage-framework/new_file");
          auto status = boost::filesystem::status(path);
@@ -447,28 +470,25 @@
+     {
          // Create a file with a few bytes.
          QByteArray original_contents = "Hello World!\n";
--        write_file(root, "new_file", original_contents);
--        auto file = dynamic_pointer_cast<File>(root->lookup("new_file").result()[0]);
--        ASSERT_NE(nullptr, file);
++        auto file = write_file(root, "new_file", original_contents);
          // Create an uploader for the file and write a bunch of bytes.
--        auto uploader = file->create_uploader(ConflictPolicy::overwrite, original_contents.size()).result();
++        auto uploader = call(file->create_uploader(ConflictPolicy::overwrite, original_contents.size()));
          QByteArray const contents(1024 * 1024, 'a');
          auto written = uploader->socket()->write(contents);
          ASSERT_EQ(contents.size(), written);
          // No finish_upload() here, so the transfer is still in progress. Now cancel.
--        auto cancel_fut = uploader->cancel();
--        ASSERT_TRUE(wait(cancel_fut));
++        uploader->cancel();
          // finish_upload() must indicate that the upload was cancelled.
--        EXPECT_THROW(uploader->finish_upload().result(), CancelledException);
++        EXPECT_THROW(call(uploader->finish_upload()), CancelledException);
          // The original file contents must still be intact.
          EXPECT_EQ(original_contents.size(), file->size());
          ASSERT_TRUE(content_matches(file, original_contents));
--        file->delete_item().waitForFinished();
++        call(file->delete_item());
+     }
+ }
@@ -482,10 +502,8 @@
      // Make a new file on disk.
      QByteArray const contents = "";
--    write_file(root, "new_file", contents);
--    auto file = dynamic_pointer_cast<File>(root->lookup("new_file").result()[0]);
--    ASSERT_NE(nullptr, file);
--    auto uploader = file->create_uploader(ConflictPolicy::error_if_conflict, contents.size()).result();
++    auto file = write_file(root, "new_file", contents);
++    auto uploader = call(file->create_uploader(ConflictPolicy::error_if_conflict, contents.size()));
      // Touch the file on disk to give it a new time stamp.
      sleep(1);
@@ -494,7 +512,7 @@
      try
+     {
          // Must get an exception because the time stamps no longer match.
--        uploader->finish_upload().result();
++        call(uploader->finish_upload());
          FAIL();
+     }
      catch (ConflictException const&)
@@ -502,7 +520,52 @@
          // TODO: check exception details.
+     }
--    file->delete_item().waitForFinished();
++    call(file->delete_item());
++}
++
++TEST(File, upload_error)
++{
++    auto runtime = Runtime::create();
++
++    auto acc = get_account(runtime);
++    auto root = get_root(runtime);
++    clear_folder(root);
++
++    auto uploader = call(root->create_file("new_file", 0));
++    // Make new_file, so it gets in the way during finish_upload().
++    write_file(root, "new_file", "");
++
++    try
++    {
++        call(uploader->finish_upload());
++        FAIL();
++    }
++    catch (ExistsException const& e)
++    {
++        EXPECT_TRUE(e.error_message().startsWith("Uploader::finish_upload(): item with name \""));
++        EXPECT_TRUE(e.error_message().endsWith("\" exists already"));
++        EXPECT_EQ(TEST_DIR "/storage-framework/new_file", e.native_identity()) << e.native_identity().toStdString();
++        EXPECT_EQ("new_file", e.name());
++    }
++}
++
++TEST(File, create_uploader_bad_arg)
++{
++    auto runtime = Runtime::create();
++
++    auto acc = get_account(runtime);
++    auto root = get_root(runtime);
++    clear_folder(root);
++
++    auto file = write_file(root, "new_file", 0);
++    try
++    {
++        call(file->create_uploader(ConflictPolicy::overwrite, -1));
++    }
++    catch (InvalidArgumentException const& e)
++    {
++        EXPECT_EQ("File::create_uploader(): size must be >= 0", e.error_message());
++    }
+ }
  TEST(File, download)
@@ -516,13 +579,9 @@
+     {
          // Download a few bytes.
          QByteArray const contents = "Hello\n";
--        write_file(root, "file", contents);
--
--        auto item = root->lookup("file").result()[0];
--        File::SPtr file = dynamic_pointer_cast<File>(item);
--        ASSERT_FALSE(file == nullptr);
--
--        auto downloader = file->create_downloader().result();
++        auto file = write_file(root, "file", contents);
++
++        auto downloader = call(file->create_downloader());
          EXPECT_TRUE(file->equal_to(downloader->file()));
          auto socket = downloader->socket();
@@ -530,17 +589,20 @@
          do
+         {
              // Need to pump the event loop while the socket does its thing.
--            QSignalSpy spy(downloader->socket().get(), &QIODevice::readyRead);
--            ASSERT_TRUE(spy.wait(SIGNAL_WAIT_TIME));
++            QSignalSpy spy(socket.get(), &QIODevice::readyRead);
              auto bytes_to_read = socket->bytesAvailable();
++            if (bytes_to_read == 0)
++            {
++                ASSERT_TRUE(spy.wait(SIGNAL_WAIT_TIME));
++            }
              buf.append(socket->read(bytes_to_read));
          } while (buf.size() < contents.size());
          // Wait for disconnected signal.
--        QSignalSpy spy(downloader->socket().get(), &QLocalSocket::disconnected);
++        QSignalSpy spy(socket.get(), &QLocalSocket::disconnected);
          ASSERT_TRUE(spy.wait(SIGNAL_WAIT_TIME));
--        ASSERT_NO_THROW(downloader->finish_download().waitForFinished());
++        ASSERT_NO_THROW(call(downloader->finish_download()));
          // Contents must match.
          EXPECT_EQ(contents, buf);
@@ -549,13 +611,9 @@
+     {
          // Download exactly 64 KB.
          QByteArray const contents(64 * 1024, 'a');
--        write_file(root, "file", contents);
--
--        auto item = root->lookup("file").result()[0];
--        File::SPtr file = dynamic_pointer_cast<File>(item);
--        ASSERT_FALSE(file == nullptr);
--
--        auto downloader = file->create_downloader().result();
++        auto file = write_file(root, "file", contents);
++
++        auto downloader = call(file->create_downloader());
          EXPECT_TRUE(file->equal_to(downloader->file()));
          auto socket = downloader->socket();
@@ -563,17 +621,20 @@
          do
+         {
              // Need to pump the event loop while the socket does its thing.
--            QSignalSpy spy(downloader->socket().get(), &QIODevice::readyRead);
--            ASSERT_TRUE(spy.wait(SIGNAL_WAIT_TIME));
++            QSignalSpy spy(socket.get(), &QIODevice::readyRead);
              auto bytes_to_read = socket->bytesAvailable();
++            if (bytes_to_read == 0)
++            {
++                ASSERT_TRUE(spy.wait(SIGNAL_WAIT_TIME));
++            }
              buf.append(socket->read(bytes_to_read));
          } while (buf.size() < contents.size());
          // Wait for disconnected signal.
--        QSignalSpy spy(downloader->socket().get(), &QLocalSocket::disconnected);
++        QSignalSpy spy(socket.get(), &QLocalSocket::disconnected);
          ASSERT_TRUE(spy.wait(SIGNAL_WAIT_TIME));
--        ASSERT_NO_THROW(downloader->finish_download().waitForFinished());
++        ASSERT_NO_THROW(call(downloader->finish_download()));
          // Contents must match
          EXPECT_EQ(contents, buf);
@@ -582,13 +643,9 @@
+     {
          // Download 1 MB + 1 bytes.
          QByteArray const contents(1024 * 1024 + 1, 'a');
--        write_file(root, "file", contents);
--
--        auto item = root->lookup("file").result()[0];
--        File::SPtr file = dynamic_pointer_cast<File>(item);
--        ASSERT_FALSE(file == nullptr);
--
--        auto downloader = file->create_downloader().result();
++        auto file = write_file(root, "file", contents);
++
++        auto downloader = call(file->create_downloader());
          EXPECT_TRUE(file->equal_to(downloader->file()));
          auto socket = downloader->socket();
@@ -596,17 +653,20 @@
          do
+         {
              // Need to pump the event loop while the socket does its thing.
--            QSignalSpy spy(downloader->socket().get(), &QIODevice::readyRead);
--            ASSERT_TRUE(spy.wait(SIGNAL_WAIT_TIME));
++            QSignalSpy spy(socket.get(), &QIODevice::readyRead);
              auto bytes_to_read = socket->bytesAvailable();
++            if (bytes_to_read == 0)
++            {
++                ASSERT_TRUE(spy.wait(SIGNAL_WAIT_TIME));
++            }
              buf.append(socket->read(bytes_to_read));
          } while (buf.size() < contents.size());
          // Wait for disconnected signal.
--        QSignalSpy spy(downloader->socket().get(), &QLocalSocket::disconnected);
++        QSignalSpy spy(socket.get(), &QLocalSocket::disconnected);
          ASSERT_TRUE(spy.wait(SIGNAL_WAIT_TIME));
--        ASSERT_NO_THROW(downloader->finish_download().waitForFinished());
++        ASSERT_NO_THROW(call(downloader->finish_download()));
          // Contents must match
          EXPECT_EQ(contents, buf);
@@ -615,85 +675,84 @@
+     {
          // Download file containing zero bytes
          QByteArray const contents;
--        write_file(root, "file", contents);
--
--        auto item = root->lookup("file").result()[0];
--        File::SPtr file = dynamic_pointer_cast<File>(item);
--        ASSERT_FALSE(file == nullptr);
--
--        auto downloader = file->create_downloader().result();
++        auto file = write_file(root, "file", contents);
++
++        auto downloader = call(file->create_downloader());
          EXPECT_TRUE(file->equal_to(downloader->file()));
          auto socket = downloader->socket();
--        // No readyRead every arrives in this case, just wait for disconnected.
--        QSignalSpy spy(downloader->socket().get(), &QLocalSocket::disconnected);
--        ASSERT_TRUE(spy.wait(SIGNAL_WAIT_TIME));
++        // No readyRead ever arrives in this case, just wait for disconnected.
++        QSignalSpy spy(socket.get(), &QLocalSocket::disconnected);
++        if (socket->state() != QLocalSocket::UnconnectedState)
++        {
++            ASSERT_TRUE(spy.wait(SIGNAL_WAIT_TIME));
++        }
--        ASSERT_NO_THROW(downloader->finish_download().waitForFinished());
++        ASSERT_NO_THROW(call(downloader->finish_download()));
+     }
+     {
          // Don't ever call read on empty file.
          QByteArray const contents;
--        write_file(root, "file", contents);
--
--        auto item = root->lookup("file").result()[0];
--        File::SPtr file = dynamic_pointer_cast<File>(item);
--        ASSERT_FALSE(file == nullptr);
--
--        auto downloader = file->create_downloader().result();
++        auto file = write_file(root, "file", contents);
++
++        auto downloader = call(file->create_downloader());
          EXPECT_TRUE(file->equal_to(downloader->file()));
++        auto socket = downloader->socket();
++
          // No readyRead ever arrives in this case, just wait for disconnected.
--        QSignalSpy spy(downloader->socket().get(), &QLocalSocket::disconnected);
--        ASSERT_TRUE(spy.wait(SIGNAL_WAIT_TIME));
++        QSignalSpy spy(socket.get(), &QLocalSocket::disconnected);
++        if (socket->state() != QLocalSocket::UnconnectedState)
++        {
++            ASSERT_TRUE(spy.wait(SIGNAL_WAIT_TIME));
++        }
          // This succeeds because the provider disconnects as soon
          // as it realizes that there is nothing to write.
--        ASSERT_NO_THROW(downloader->finish_download().waitForFinished());
++        ASSERT_NO_THROW(call(downloader->finish_download()));
+     }
+     {
          // Don't ever call read on small file.
          QByteArray const contents("some contents");
--        write_file(root, "file", contents);
--
--        auto item = root->lookup("file").result()[0];
--        File::SPtr file = dynamic_pointer_cast<File>(item);
--        ASSERT_FALSE(file == nullptr);
--
--        auto downloader = file->create_downloader().result();
++        auto file = write_file(root, "file", contents);
++
++        auto downloader = call(file->create_downloader());
          EXPECT_TRUE(file->equal_to(downloader->file()));
++        auto socket = downloader->socket();
++
          // Wait for disconnected.
--        QSignalSpy spy(downloader->socket().get(), &QLocalSocket::disconnected);
--        ASSERT_TRUE(spy.wait(SIGNAL_WAIT_TIME));
++        if (socket->state() != QLocalSocket::UnconnectedState)
++        {
++            QSignalSpy spy(socket.get(), &QLocalSocket::disconnected);
++            ASSERT_TRUE(spy.wait(SIGNAL_WAIT_TIME));
++        }
          // This succeeds because the provider has written everything and disconnected.
--        ASSERT_NO_THROW(downloader->finish_download().waitForFinished());
++        ASSERT_NO_THROW(call(downloader->finish_download()));
+     }
+     {
          // Don't ever call read on large file.
          QByteArray const contents(1024 * 1024, 'a');
--        write_file(root, "file", contents);
--
--        auto item = root->lookup("file").result()[0];
--        File::SPtr file = dynamic_pointer_cast<File>(item);
--        ASSERT_FALSE(file == nullptr);
--
--        auto downloader = file->create_downloader().result();
++        auto file = write_file(root, "file", contents);
++
++        auto downloader = call(file->create_downloader());
          EXPECT_TRUE(file->equal_to(downloader->file()));
++        auto socket = downloader->socket();
++
          // Wait for first readyRead. Not all data fits into the socket buffer.
--        QSignalSpy spy(downloader->socket().get(), &QLocalSocket::readyRead);
++        QSignalSpy spy(socket.get(), &QLocalSocket::readyRead);
          ASSERT_TRUE(spy.wait(SIGNAL_WAIT_TIME));
          // This fails because the provider still has data left to write.
          try
+         {
--            downloader->finish_download().waitForFinished();
++            call(downloader->finish_download());
              FAIL();
+         }
          catch (StorageException const& e)
@@ -705,25 +764,17 @@
+     {
          // Let downloader go out of scope.
          QByteArray const contents(1024 * 1024, 'a');
--        write_file(root, "file", contents);
--
--        auto item = root->lookup("file").result()[0];
--        File::SPtr file = dynamic_pointer_cast<File>(item);
--        ASSERT_FALSE(file == nullptr);
--
--        auto downloader = file->create_downloader().result();
++        auto file = write_file(root, "file", contents);
++
++        auto downloader = call(file->create_downloader());
+     }
+     {
          // Let downloader future go out of scope.
          QByteArray const contents(1024 * 1024, 'a');
--        write_file(root, "file", contents);
--
--        auto item = root->lookup("file").result()[0];
--        File::SPtr file = dynamic_pointer_cast<File>(item);
--        ASSERT_FALSE(file == nullptr);
--
--        auto downloader_fut = file->create_downloader();
++        auto file = write_file(root, "file", contents);
++
++        file->create_downloader();
+     }
+ }
@@ -738,55 +789,111 @@
+     {
          // Download enough bytes to prevent a single write in the provider from completing the download.
          QByteArray const contents(1024 * 1024, 'a');
--        write_file(root, "file", contents);
--
--        auto item = root->lookup("file").result()[0];
--        File::SPtr file = dynamic_pointer_cast<File>(item);
--        ASSERT_FALSE(file == nullptr);
--
--        auto download_fut = file->create_downloader();
--        ASSERT_TRUE(wait(download_fut));
--        auto downloader = download_fut.result();
++        auto file = write_file(root, "file", contents);
++
++        auto downloader = call(file->create_downloader());
          // We haven't read anything, so the cancel is guaranteed to catch the
          // downloader in the in_progress state.
--        auto cancel_fut = downloader->cancel();
--        ASSERT_TRUE(wait(cancel_fut));
--        ASSERT_THROW(downloader->finish_download().waitForFinished(), CancelledException);
++        downloader->cancel();
++        ASSERT_THROW(call(downloader->finish_download()), CancelledException);
+     }
+     {
          // Download a few bytes.
          QByteArray const contents = "Hello\n";
--        write_file(root, "file", contents);
--
--        auto item = root->lookup("file").result()[0];
--        File::SPtr file = dynamic_pointer_cast<File>(item);
--        ASSERT_FALSE(file == nullptr);
++        auto file = write_file(root, "file", contents);
          // Finish the download.
--        auto downloader = file->create_downloader().result();
++        auto downloader = call(file->create_downloader());
          auto socket = downloader->socket();
          QByteArray buf;
          do
+         {
              // Need to pump the event loop while the socket does its thing.
--            QSignalSpy spy(downloader->socket().get(), &QIODevice::readyRead);
--            ASSERT_TRUE(spy.wait(SIGNAL_WAIT_TIME));
++            QSignalSpy spy(socket.get(), &QIODevice::readyRead);
              auto bytes_to_read = socket->bytesAvailable();
++            if (bytes_to_read == 0)
++            {
++                ASSERT_TRUE(spy.wait(SIGNAL_WAIT_TIME));
++            }
              buf.append(socket->read(bytes_to_read));
          } while (buf.size() < contents.size());
          // Wait for disconnected signal.
--        QSignalSpy spy(downloader->socket().get(), &QLocalSocket::disconnected);
--        ASSERT_TRUE(spy.wait(SIGNAL_WAIT_TIME));
++        if (socket->state() != QLocalSocket::UnconnectedState)
++        {
++            QSignalSpy spy(socket.get(), &QLocalSocket::disconnected);
++            ASSERT_TRUE(spy.wait(SIGNAL_WAIT_TIME));
++        }
          // Now send the cancel. The download is finished already, and the cancel
          // is too late, so finish_download() must report that the download
          // worked OK.
          downloader->cancel();
--        ASSERT_NO_THROW(downloader->finish_download().waitForFinished());
--    }
++        ASSERT_NO_THROW(call(downloader->finish_download()));
++    }
++}
++
++TEST(File, download_error)
++{
++    auto runtime = Runtime::create();
++
++    auto acc = get_account(runtime);
++    auto root = get_root(runtime);
++    clear_folder(root);
++
++    QByteArray const contents(1024 * 1024, 'a');
++    auto file = write_file(root, "file", contents);
++
++    auto downloader = call(file->create_downloader());
++    EXPECT_TRUE(file->equal_to(downloader->file()));
++
++    auto socket = downloader->socket();
++
++    {
++        // Wait for first readyRead. Not all data fits into the socket buffer.
++        QSignalSpy spy(socket.get(), &QLocalSocket::readyRead);
++        ASSERT_TRUE(spy.wait(SIGNAL_WAIT_TIME));
++    }
++
++    {
++        // Now close the socket, to force an error at the writing end.
++        // This gives us coverage of the error handling logic in the download worker.
++        socket->abort();
++        // Wait a little, to give the worker a chance to notice the problem.
++        // We don't wait for a signal here because all attempts to disable the
++        // socket (via close(), abort(), or disconnectFromServer() also
++        // stop the stateChanged signal from arriving.
++        QTimer timer;
++        QSignalSpy spy(&timer, &QTimer::timeout);
++        timer.start(1000);
++        spy.wait();
++    }
++
++    try
++    {
++        call(downloader->finish_download());
++        FAIL();
++    }
++    catch (ResourceException const& e)
++    {
++        EXPECT_TRUE(e.error_message().startsWith("Downloader: QLocalSocket: "));
++    }
++}
++
++TEST(File, size_error)
++{
++    auto runtime = Runtime::create();
++
++    auto acc = get_account(runtime);
++    auto root = get_root(runtime);
++    clear_folder(root);
++
++    auto file = write_file(root, "file", "");
++
++    ASSERT_EQ(0, system("rm " TEST_DIR "/storage-framework/file"));
++    EXPECT_THROW(file->size(), ResourceException);
+ }
  TEST(Item, move)
@@ -799,25 +906,22 @@
      // Check that rename works within the same folder.
      QByteArray const contents = "Hello\n";
--    write_file(root, "f1", contents);
--    auto f1 = root->lookup("f1").result()[0];
--    auto f2 = f1->move(root, "f2").result();
--    EXPECT_EQ("f2", f2->name());
--    EXPECT_THROW(f1->name(), DeletedException);  // TODO: check exception details.
++    auto f1 = write_file(root, "f1", contents);
++    auto f2 = call(f1->move(root, "f2"));
      // File must be found under new name.
--    auto items = root->list().result();
++    auto items = call(root->list());
      ASSERT_EQ(1, items.size());
      f2 = dynamic_pointer_cast<File>(items[0]);
      ASSERT_FALSE(f2 == nullptr);
      // Make a folder and move f2 into it.
--    auto folder = root->create_folder("folder").result();
--    f2 = f2->move(folder, "f2").result();
++    auto folder = call(root->create_folder("folder"));
++    f2 = call(f2->move(folder, "f2"));
      EXPECT_TRUE(get_parent(f2)->equal_to(folder));
      // Move the folder
--    auto item = folder->move(root, "folder2").result();
++    auto item = call(folder->move(root, "folder2"));
      folder = dynamic_pointer_cast<Folder>(item);
      EXPECT_EQ("folder2", folder->name());
+ }
@@ -831,10 +935,8 @@
      clear_folder(root);
      QByteArray const contents = "hello\n";
--    write_file(root, "file", contents);
--
--    auto item = root->lookup("file").result()[0];
--    auto copied_item = item->copy(root, "copy_of_file").result();
++    auto item = write_file(root, "file", contents);
++    auto copied_item = call(item->copy(root, "copy_of_file"));
      EXPECT_EQ("copy_of_file", copied_item->name());
      File::SPtr copied_file = dynamic_pointer_cast<File>(item);
      ASSERT_NE(nullptr, copied_file);
@@ -854,7 +956,9 @@
      // folder/empty_folder
      // folder/non_empty_folder
      // folder/non_empty_folder/nested_file
++    // folder/non_empty_folder/<TMPFILE_PREFIX>1234-1234-1234-1234
      // folder/file
++    // folder/<TMPFILE_PREFIX>1234-1234-1234-1234
      string root_path = root->native_identity().toStdString();
      ASSERT_EQ(0, mkdir((root_path + "/folder").c_str(), 0700));
@@ -863,23 +967,26 @@
      ofstream(root_path + "/folder/non_empty_folder/nested_file");
      ofstream(root_path + "/folder/file");
++    // Add dirs that look like a tmp dirs, to get coverage on skipping those.
++    ASSERT_EQ(0, mkdir((root_path + "/folder/" + TMPFILE_PREFIX "1234-1234-1234-1234").c_str(), 0700));
++    ASSERT_EQ(0, mkdir((root_path + "/folder/non_empty_folder/" + TMPFILE_PREFIX "1234-1234-1234-1234").c_str(), 0700));
      // Copy folder to folder2
--    auto folder = dynamic_pointer_cast<Folder>(root->lookup("folder").result()[0]);
++    auto folder = dynamic_pointer_cast<Folder>(call(root->lookup("folder"))[0]);
      ASSERT_NE(nullptr, folder);
--    auto item = folder->copy(root, "folder2").result();
++    auto item = call(folder->copy(root, "folder2"));
      // Verify that folder2 now contains the same structure as folder.
      auto folder2 = dynamic_pointer_cast<Folder>(item);
      ASSERT_NE(nullptr, folder2);
--    EXPECT_NO_THROW(folder2->lookup("empty_folder").result()[0]);
--    item = folder2->lookup("non_empty_folder").result()[0];
++    EXPECT_NO_THROW(call(folder2->lookup("empty_folder"))[0]);
++    item = call(folder2->lookup("non_empty_folder"))[0];
      auto non_empty_folder = dynamic_pointer_cast<Folder>(item);
      ASSERT_NE(nullptr, non_empty_folder);
--    EXPECT_NO_THROW(non_empty_folder->lookup("nested_file").result()[0]);
--    EXPECT_NO_THROW(folder2->lookup("file").result()[0]);
++    EXPECT_NO_THROW(call(non_empty_folder->lookup("nested_file"))[0]);
++    EXPECT_NO_THROW(call(folder2->lookup("file"))[0]);
+ }
--TEST(Item, modified_time)
++TEST(Item, time)
+ {
      auto runtime = Runtime::create();
@@ -889,14 +996,15 @@
      auto now = QDateTime::currentDateTimeUtc();
      sleep(1);
--    auto uploader = root->create_file("file", 0).result();
--    auto file_fut = uploader->finish_upload();
--    ASSERT_TRUE(wait(file_fut));
--    auto file = file_fut.result();
++    auto uploader = call(root->create_file("file", 0));
++    auto file = call(uploader->finish_upload());
      auto t = file->last_modified_time();
      // Rough check that the time is sane.
      EXPECT_LE(now, t);
      EXPECT_LE(t, now.addSecs(5));
++
++    auto creation_time = file->creation_time();
++    EXPECT_FALSE(creation_time.isValid());
+ }
  TEST(Item, comparison)
@@ -908,36 +1016,338 @@
      clear_folder(root);
      // Create two files.
--    auto uploader = root->create_file("file1", 0).result();
--    auto file_fut = uploader->finish_upload();
--    ASSERT_TRUE(wait(file_fut));
--    auto file1 = file_fut.result();
++    auto uploader = call(root->create_file("file1", 0));
++    auto file1 = call(uploader->finish_upload());
--    uploader = root->create_file("file2", 0).result();
--    file_fut = uploader->finish_upload();
--    ASSERT_TRUE(wait(file_fut));
--    auto file2 = file_fut.result();
++    uploader = call(root->create_file("file2", 0));
++    auto file2 = call(uploader->finish_upload());
      EXPECT_FALSE(file1->equal_to(file2));
      // Retrieve file1 via lookup, so we get a different proxy.
--    auto item = root->lookup("file1").result()[0];
++    auto item = call(root->lookup("file1"))[0];
      auto other_file1 = dynamic_pointer_cast<File>(item);
      EXPECT_NE(file1, other_file1);              // Compares shared_ptr values
      EXPECT_TRUE(file1->equal_to(other_file1));  // Deep comparison
      // Comparing against a deleted file must return false.
--    auto delete_fut = file1->delete_item();
--    ASSERT_TRUE(wait(delete_fut));
++    call(file1->delete_item());
      EXPECT_FALSE(file1->equal_to(file2));
      EXPECT_FALSE(file2->equal_to(file1));
      // Delete file2 as well and compare again.
--    delete_fut = file2->delete_item();
--    ASSERT_TRUE(wait(delete_fut));
++    call(file2->delete_item());
      EXPECT_FALSE(file1->equal_to(file2));
+ }
++TEST(Item, exceptions)
++{
++    auto runtime = Runtime::create();
++
++    auto acc = get_account(runtime);
++    auto root = get_root(runtime);
++    clear_folder(root);
++
++    try
++    {
++        call(root->copy(nullptr, "new name"));
++        FAIL();
++    }
++    catch (InvalidArgumentException const& e)
++    {
++        EXPECT_EQ("Item::copy(): new_parent cannot be nullptr", e.error_message());
++    }
++
++    auto file = write_file(root, "file", 0);
++
++    try
++    {
++        call(file->copy(root, TMPFILE_PREFIX "copy_of_file"));
++        FAIL();
++    }
++    catch (InvalidArgumentException const& e)
++    {
++        EXPECT_EQ("Item::copy(): names beginning with \".storage-framework-\" are reserved", e.error_message());
++    }
++
++    try
++    {
++        call(file->copy(root, file->name()));
++        FAIL();
++    }
++    catch (ExistsException const& e)
++    {
++        EXPECT_EQ("Item::copy(): item with name \"file\" exists already", e.error_message());
++        EXPECT_EQ("file", e.name());
++        EXPECT_EQ(TEST_DIR "/storage-framework/file", e.native_identity());
++    }
++
++    try
++    {
++        auto file = write_file(root, "file", "");
++        ASSERT_EQ(0, unlink(file->native_identity().toStdString().c_str()));
++
++        call(file->copy(root, file->name()));
++        FAIL();
++    }
++    catch (ResourceException const& e)
++    {
++        EXPECT_TRUE(e.error_message().startsWith("Item::copy(): "));
++    }
++
++    try
++    {
++        auto file = write_file(root, "file", "");
++        ASSERT_EQ(0, unlink(file->native_identity().toStdString().c_str()));
++
++        call(file->move(root, "new_name"));
++        FAIL();
++    }
++    catch (ResourceException const& e)
++    {
++        EXPECT_TRUE(e.error_message().startsWith("Item::move(): "));
++    }
++
++    try
++    {
++        auto file = write_file(root, "file", "");
++        ASSERT_EQ(0, unlink(file->native_identity().toStdString().c_str()));
++        ASSERT_EQ(0, system("chmod -x " TEST_DIR "/storage-framework"));
++
++        call(file->delete_item());
++        FAIL();
++    }
++    catch (PermissionException const& e)
++    {
++        ASSERT_EQ(0, system("chmod +x " TEST_DIR "/storage-framework"));
++        EXPECT_TRUE(e.error_message().startsWith("Item::delete_item(): "));
++    }
++    catch (std::exception const&)
++    {
++        ASSERT_EQ(0, system("chmod +x " TEST_DIR "/storage-framework"));
++        FAIL();
++    }
++    ASSERT_EQ(0, system("chmod +x " TEST_DIR "/storage-framework"));
++
++    try
++    {
++        call(root->move(nullptr, "new name"));
++        FAIL();
++    }
++    catch (InvalidArgumentException const& e)
++    {
++        EXPECT_EQ("Item::move(): new_parent cannot be nullptr", e.error_message());
++    }
++
++    try
++    {
++        call(root->move(root, "new name"));
++        FAIL();
++    }
++    catch (LogicException const& e)
++    {
++        EXPECT_EQ("Item::move(): cannot move root folder", e.error_message());
++    }
++
++    try
++    {
++        auto file = write_file(root, "file", "");
++        call(file->move(root, file->name()));
++        FAIL();
++    }
++    catch (ExistsException const& e)
++    {
++        EXPECT_EQ("Item::move(): item with name \"file\" exists already", e.error_message());
++        EXPECT_EQ("file", e.name());
++        EXPECT_EQ(TEST_DIR "/storage-framework/file", e.native_identity());
++    }
++
++    try
++    {
++        call(file->move(root, TMPFILE_PREFIX "copy_of_file"));
++        FAIL();
++    }
++    catch (InvalidArgumentException const& e)
++    {
++        EXPECT_EQ("Item::move(): names beginning with \".storage-framework-\" are reserved", e.error_message());
++    }
++
++    try
++    {
++        call(root->lookup("abc/def"));
++    }
++    catch (InvalidArgumentException const& e)
++    {
++        EXPECT_EQ("Folder::lookup(): name \"abc/def\" contains more than one path component",
++                  e.error_message()) << e.what();
++    }
++
++    try
++    {
++        call(root->create_folder(".."));
++    }
++    catch (InvalidArgumentException const& e)
++    {
++        EXPECT_EQ("Folder::create_folder(): invalid name: \"..\"", e.error_message()) << e.what();
++    }
++}
++
++TEST(Folder, exceptions)
++{
++    auto runtime = Runtime::create();
++
++    auto acc = get_account(runtime);
++    auto root = get_root(runtime);
++    clear_folder(root);
++
++    try
++    {
++        write_file(root, TMPFILE_PREFIX "file", "");
++        call(root->lookup(TMPFILE_PREFIX "file"));
++        FAIL();
++    }
++    catch (NotExistsException const& e)
++    {
++        string cmd = "rm ";
++        cmd += string(TEST_DIR) + "/storage-framework/" + TMPFILE_PREFIX "file";
++        ASSERT_EQ(0, system(cmd.c_str()));
++        EXPECT_EQ("Folder::lookup(): no such item: \".storage-framework-file\"", e.error_message());
++        EXPECT_EQ(".storage-framework-file", e.key());
++    }
++
++    {
++        auto fifo_id = root->native_identity() + "/fifo";
++        string cmd = "mkfifo " + fifo_id.toStdString();
++        ASSERT_EQ(0, system(cmd.c_str()));
++
++        try
++        {
++            call(root->lookup("fifo"));
++            FAIL();
++        }
++        catch (NotExistsException const& e)
++        {
++            EXPECT_EQ("Folder::lookup(): no such item: \"fifo\"", e.error_message()) << e.what();
++            EXPECT_EQ("fifo", e.key());
++        }
++
++        cmd = "rm " + fifo_id.toStdString();
++        ASSERT_EQ(0, system(cmd.c_str()));
++    }
++
++    try
++    {
++        call(root->lookup("no_such_file"));
++        FAIL();
++    }
++    catch (NotExistsException const& e)
++    {
++        EXPECT_EQ("Folder::lookup(): no such item: \"no_such_file\"", e.error_message());
++        EXPECT_EQ("no_such_file", e.key());
++    }
++
++    try
++    {
++        call(root->create_folder(TMPFILE_PREFIX "folder"));
++        FAIL();
++    }
++    catch (InvalidArgumentException const& e)
++    {
++        EXPECT_EQ("Folder::create_folder(): names beginning with \".storage-framework-\" are reserved", e.error_message());
++    }
++
++    try
++    {
++        EXPECT_NO_THROW(call(root->create_folder("folder")));
++        call(root->create_folder("folder"));
++        FAIL();
++    }
++    catch (ExistsException const& e)
++    {
++        EXPECT_EQ("Folder::create_folder(): item with name \"folder\" exists already", e.error_message());
++        EXPECT_EQ("folder", e.name());
++        EXPECT_EQ(TEST_DIR "/storage-framework/folder", e.native_identity());
++    }
++
++    try
++    {
++        call(root->create_file("new_file", -1));
++        FAIL();
++    }
++    catch (InvalidArgumentException const& e)
++    {
++        EXPECT_EQ("Folder::create_file(): size must be >= 0", e.error_message());
++    }
++
++    try
++    {
++        call(root->create_file(TMPFILE_PREFIX "new_file", 0));
++        FAIL();
++    }
++    catch (InvalidArgumentException const& e)
++    {
++        EXPECT_EQ("Folder::create_file(): names beginning with \".storage-framework-\" are reserved", e.error_message());
++    }
++
++    try
++    {
++        write_file(root, "file", "");
++        call(root->create_file("file", 0));
++        FAIL();
++    }
++    catch (ExistsException const& e)
++    {
++        EXPECT_EQ("Folder::create_file(): item with name \"file\" exists already", e.error_message());
++        EXPECT_EQ("file", e.name());
++        EXPECT_EQ(TEST_DIR "/storage-framework/file", e.native_identity());
++    }
++
++    ASSERT_EQ(0, system("chmod -x " TEST_DIR "/storage-framework"));
++    try
++    {
++        call(root->create_file("new_file", 0));
++        FAIL();
++    }
++    catch (PermissionException const& e)
++    {
++        EXPECT_TRUE(e.error_message().startsWith("Folder::create_file(): "));
++        ASSERT_EQ(0, system("chmod +x " TEST_DIR "/storage-framework"));
++    }
++    catch (std::exception const& e)
++    {
++        ASSERT_EQ(0, system("chmod +x " TEST_DIR "/storage-framework"));
++        FAIL();
++    }
++    ASSERT_EQ(0, system("chmod +x " TEST_DIR "/storage-framework"));
++
++    ASSERT_EQ(0, system("chmod -x " TEST_DIR "/storage-framework"));
++    try
++    {
++        call(root->create_folder("new_folder"));
++        FAIL();
++    }
++    catch (PermissionException const& e)
++    {
++        EXPECT_TRUE(e.error_message().startsWith("Folder::create_folder(): "));
++        ASSERT_EQ(0, system("chmod +x " TEST_DIR "/storage-framework"));
++    }
++    catch (std::exception const& e)
++    {
++        ASSERT_EQ(0, system("chmod +x " TEST_DIR "/storage-framework"));
++        FAIL();
++    }
++    ASSERT_EQ(0, system("chmod +x " TEST_DIR "/storage-framework"));
++
++    try
++    {
++        call(root->create_file("new_file", -1));
++    }
++    catch (InvalidArgumentException const& e)
++    {
++        EXPECT_EQ("Folder::create_file(): size must be >= 0", e.error_message());
++    }
++}
++
  TEST(Root, root_exceptions)
+ {
      auto runtime = Runtime::create();
@@ -946,51 +1356,39 @@
      auto root = get_root(runtime);
      clear_folder(root);
--    {
--        auto fut = root->delete_item();
--        try
--        {
--            fut.waitForFinished();
--            FAIL();
--        }
--        catch (LogicException const& e)
--        {
--            EXPECT_EQ("Root::delete_item(): Cannot delete root folder", e.error_message());
--        }
--    }
--
--    {
--        auto fut = root->get("abc");
--        try
--        {
--            fut.waitForFinished();
--            FAIL();
--        }
--        catch (InvalidArgumentException const& e)
--        {
--            EXPECT_EQ("Root::get(): identity \"abc\" must be an absolute path", e.error_message());
--        }
--    }
--
--    {
--        auto fut = root->get("/etc");
--        try
--        {
--            fut.waitForFinished();
--            FAIL();
--        }
--        catch (InvalidArgumentException const& e)
--        {
--            EXPECT_EQ("Root::get(): identity \"/etc\" points outside the root folder", e.error_message());
--        }
--    }
--
--    {
--        auto folder = root->create_folder("folder").result();
--        write_file(root, "folder/testfile", "hello");
--
--        auto file = dynamic_pointer_cast<File>(folder->lookup("testfile").result()[0]);
--        ASSERT_NE(nullptr, file);
++    try
++    {
++        call(root->delete_item());
++        FAIL();
++    }
++    catch (LogicException const& e)
++    {
++        EXPECT_EQ("Root::delete_item(): Cannot delete root folder", e.error_message());
++    }
++
++    try
++    {
++        call(root->get("abc"));
++        FAIL();
++    }
++    catch (InvalidArgumentException const& e)
++    {
++        EXPECT_EQ("Root::get(): identity \"abc\" must be an absolute path", e.error_message());
++    }
++
++    try
++    {
++        call(root->get("/etc"));
++        FAIL();
++    }
++    catch (InvalidArgumentException const& e)
++    {
++        EXPECT_EQ("Root::get(): identity \"/etc\" points outside the root folder", e.error_message());
++    }
++
++    {
++        auto folder = call(root->create_folder("folder"));
++        auto file = write_file(folder, "testfile", "hello");
          // Remove permission from folder.
          string cmd = "chmod -x " + folder->native_identity().toStdString();
@@ -998,7 +1396,7 @@
          try
+         {
--            file = dynamic_pointer_cast<File>(root->get(file->native_identity()).result());
++            file = dynamic_pointer_cast<File>(call(root->get(file->native_identity())));
              FAIL();
+         }
          catch (PermissionException const& e)
@@ -1006,6 +1404,11 @@
              EXPECT_TRUE(e.error_message().startsWith("Root::get(): "));
              EXPECT_TRUE(e.error_message().contains("Permission denied"));
+         }
++        catch (...)
++        {
++            cmd = "chmod +x " + folder->native_identity().toStdString();
++            ASSERT_EQ(0, system(cmd.c_str()));
++        }
          cmd = "chmod +x " + folder->native_identity().toStdString();
          ASSERT_EQ(0, system(cmd.c_str()));
@@ -1014,17 +1417,14 @@
+     }
+     {
--        write_file(root, "testfile", "hello");
--
--        auto file = dynamic_pointer_cast<File>(root->lookup("testfile").result()[0]);
--        ASSERT_NE(nullptr, file);
++        auto file = write_file(root, "testfile", "hello");
          QString id = file->native_identity();
          id.append("_doesnt_exist");
          try
+         {
--            file = dynamic_pointer_cast<File>(root->get(id).result());
++            file = dynamic_pointer_cast<File>(call(root->get(id)));
              FAIL();
+         }
          catch (NotExistsException const& e)
@@ -1042,7 +1442,7 @@
          try
+         {
--            root->get(fifo_id).result();
++            call(root->get(fifo_id));
              FAIL();
+         }
          catch (NotExistsException const& e)
@@ -1051,17 +1451,20 @@
+         }
          cmd = "rm " + fifo_id.toStdString();
--        system(cmd.c_str());
++        ASSERT_EQ(0, system(cmd.c_str()));
+     }
+     {
--        QString reserved_name = TMPFILE_PREFIX "somefile";
--        write_file(root, reserved_name, "some bytes");
++        string reserved_name = TMPFILE_PREFIX "somefile";
++        string full_path = string(TEST_DIR) + "/storage-framework/" + reserved_name;
++        string cmd = "touch ";
++        cmd += full_path;
++        ASSERT_EQ(0, system(cmd.c_str()));
--        auto reserved_id = QString(TEST_DIR) + "/storage-framework/" + reserved_name;
++        auto reserved_id = QString::fromStdString(full_path);
          try
+         {
--            root->get(reserved_id).result();
++            call(root->get(reserved_id));
              FAIL();
+         }
          catch (NotExistsException const& e)
@@ -1073,27 +1476,6 @@
+     }
+ }
--File::SPtr make_deleted_file(Folder::SPtr parent, QString const& name)
--{
--    write_file(parent, name, "bytes");
--    auto file_fut = parent->lookup("file");
--    assert(wait(file_fut));
--    auto file = dynamic_pointer_cast<File>(file_fut.result()[0]);
--    auto void_fut = file->delete_item();
--    assert(wait(void_fut));
--    return file;
--}
--
--Folder::SPtr make_deleted_folder(Folder::SPtr parent, QString const& name)
--{
--    auto fut = parent->create_folder(name);
--    assert(wait(fut));
--    auto folder = fut.result();
--    auto void_fut = folder->delete_item();
--    assert(wait(void_fut));
--    return folder;
--}
--
  TEST(Item, deleted_exceptions)
+ {
      auto runtime = Runtime::create();
@@ -1110,7 +1492,6 @@
+     }
      catch (DeletedException const& e)
+     {
--        EXPECT_EQ("file", e.name());
          EXPECT_TRUE(e.error_message().startsWith("Item::etag(): "));
          EXPECT_TRUE(e.error_message().endsWith(" was deleted previously"));
          EXPECT_EQ(TEST_DIR "/storage-framework/file", e.native_identity());
@@ -1124,7 +1505,6 @@
+     }
      catch (DeletedException const& e)
+     {
--        EXPECT_EQ("file", e.name());
          EXPECT_TRUE(e.error_message().startsWith("Item::metadata(): "));
+     }
@@ -1136,7 +1516,6 @@
+     }
      catch (DeletedException const& e)
+     {
--        EXPECT_EQ("file", e.name());
          EXPECT_TRUE(e.error_message().startsWith("Item::last_modified_time(): "));
+     }
@@ -1144,14 +1523,11 @@
+     {
          // Copying deleted file must fail.
          auto file = make_deleted_file(root, "file");
--        auto fut = file->copy(root, "copy_of_file");
--        ASSERT_TRUE(wait(fut));
--        fut.result();
++        call(file->copy(root, "copy_of_file"));
          FAIL();
+     }
      catch (DeletedException const& e)
+     {
--        EXPECT_EQ("file", e.name());
          EXPECT_TRUE(e.error_message().startsWith("Item::copy(): "));
+     }
@@ -1160,30 +1536,20 @@
          // Copying file into deleted folder must fail.
          // Make target folder.
--        auto fut = root->create_folder("folder");
--        ASSERT_TRUE(wait(fut));
--        auto folder = fut.result();
++        auto folder = call(root->create_folder("folder"));
          // Make a file in the root.
--        auto uploader_fut = root->create_file("file", 0);
--        ASSERT_TRUE(wait(uploader_fut));
--        auto uploader = uploader_fut.result();
--        auto finish_fut = uploader->finish_upload();
--        ASSERT_TRUE(wait(finish_fut));
--        auto file = finish_fut.result();
++        auto uploader = call(root->create_file("file", 0));
++        auto file = call(uploader->finish_upload());
          // Delete folder.
--        auto void_fut = folder->delete_item();
--        ASSERT_TRUE(wait(void_fut));
++        call(folder->delete_item());
--        auto copy_fut = file->copy(folder, "file");
--        ASSERT_TRUE(wait(copy_fut));
--        copy_fut.result();
++        call(file->copy(folder, "file"));
          FAIL();
+     }
      catch (DeletedException const& e)
+     {
--        EXPECT_EQ("folder", e.name());
          EXPECT_TRUE(e.error_message().startsWith("Item::copy(): "));
+     }
      clear_folder(root);
@@ -1192,14 +1558,11 @@
+     {
          // Moving deleted file must fail.
          auto file = make_deleted_file(root, "file");
--        auto fut = file->move(root, "moved_file");
--        ASSERT_TRUE(wait(fut));
--        fut.result();
++        call(file->move(root, "moved_file"));
          FAIL();
+     }
      catch (DeletedException const& e)
+     {
--        EXPECT_EQ("file", e.name());
          EXPECT_TRUE(e.error_message().startsWith("Item::move(): "));
+     }
@@ -1208,30 +1571,20 @@
          // Moving file into deleted folder must fail.
          // Make target folder.
--        auto fut = root->create_folder("folder");
--        ASSERT_TRUE(wait(fut));
--        auto folder = fut.result();
++        auto folder = call(root->create_folder("folder"));
          // Make a file in the root.
--        auto uploader_fut = root->create_file("file", 0);
--        ASSERT_TRUE(wait(uploader_fut));
--        auto uploader = uploader_fut.result();
--        auto finish_fut = uploader->finish_upload();
--        ASSERT_TRUE(wait(finish_fut));
--        auto file = finish_fut.result();
++        auto uploader = call(root->create_file("file", 0));
++        auto file = call(uploader->finish_upload());
          // Delete folder.
--        auto void_fut = folder->delete_item();
--        ASSERT_TRUE(wait(void_fut));
++        call(folder->delete_item());
--        auto move_fut = file->move(folder, "file");
--        ASSERT_TRUE(wait(move_fut));
--        move_fut.result();
++        call(file->move(folder, "file"));
          FAIL();
+     }
      catch (DeletedException const& e)
+     {
--        EXPECT_EQ("folder", e.name());
          EXPECT_TRUE(e.error_message().startsWith("Item::move(): "));
+     }
      clear_folder(root);
@@ -1239,12 +1592,11 @@
      try
+     {
          auto file = make_deleted_file(root, "file");
--        file->parents().result();
++        call(file->parents());
          FAIL();
+     }
      catch (DeletedException const& e)
+     {
--        EXPECT_EQ("file", e.name());
          EXPECT_TRUE(e.error_message().startsWith("Item::parents(): "));
+     }
@@ -1256,7 +1608,6 @@
+     }
      catch (DeletedException const& e)
+     {
--        EXPECT_EQ("file", e.name());
          EXPECT_TRUE(e.error_message().startsWith("Item::parent_ids(): "));
+     }
@@ -1264,14 +1615,11 @@
+     {
          // Deleting a deleted item must fail.
          auto file = make_deleted_file(root, "file");
--        auto delete_fut = file->delete_item();
--        ASSERT_TRUE(wait(delete_fut));
--        delete_fut.waitForFinished();
++        call(file->delete_item());
          FAIL();
+     }
      catch (DeletedException const& e)
+     {
--        EXPECT_EQ("file", e.name());
          EXPECT_TRUE(e.error_message().startsWith("Item::delete_item(): "));
+     }
+ }
@@ -1292,65 +1640,146 @@
+     }
      catch (DeletedException const& e)
+     {
--        EXPECT_EQ("folder", e.name());
          EXPECT_TRUE(e.error_message().startsWith("Folder::name(): "));
+     }
      try
+     {
          auto folder = make_deleted_folder(root, "folder");
--        auto fut = folder->list();
--        ASSERT_TRUE(wait(fut));
--        fut.result();
++        call(folder->list());
          FAIL();
+     }
      catch (DeletedException const& e)
+     {
--        EXPECT_EQ("folder", e.name());
          EXPECT_TRUE(e.error_message().startsWith("Folder::list(): "));
+     }
      try
+     {
          auto folder = make_deleted_folder(root, "folder");
--        auto fut = folder->lookup("something");
--        ASSERT_TRUE(wait(fut));
--        fut.result();
++        call(folder->lookup("something"));
          FAIL();
+     }
      catch (DeletedException const& e)
+     {
--        EXPECT_EQ("folder", e.name());
          EXPECT_TRUE(e.error_message().startsWith("Folder::lookup(): "));
+     }
      try
+     {
          auto folder = make_deleted_folder(root, "folder");
--        auto fut = folder->create_folder("nested_folder");
--        ASSERT_TRUE(wait(fut));
--        fut.result();
--        FAIL();
--    }
--    catch (DeletedException const& e)
--    {
--        EXPECT_EQ("folder", e.name());
++        call(folder->list());
++        FAIL();
++    }
++    catch (DeletedException const& e)
++    {
++        EXPECT_TRUE(e.error_message().startsWith("Folder::list(): "));
++    }
++
++    try
++    {
++        auto folder = make_deleted_folder(root, "folder");
++        call(folder->create_folder("nested_folder"));
++        FAIL();
++    }
++    catch (DeletedException const& e)
++    {
          EXPECT_TRUE(e.error_message().startsWith("Folder::create_folder(): "));
+     }
      try
+     {
          auto folder = make_deleted_folder(root, "folder");
--        auto fut = folder->create_file("nested_file", 0);
--        ASSERT_TRUE(wait(fut));
--        fut.result();
++        call(folder->create_file("nested_file", 0));
          FAIL();
+     }
      catch (DeletedException const& e)
+     {
--        EXPECT_EQ("folder", e.name());
          EXPECT_TRUE(e.error_message().startsWith("Folder::create_file(): "));
+     }
++
++    try
++    {
++        auto folder = make_deleted_folder(root, "folder");
++        folder->creation_time();
++        FAIL();
++    }
++    catch (DeletedException const& e)
++    {
++        EXPECT_TRUE(e.error_message().startsWith("Item::creation_time(): ")) << e.what();
++    }
++
++    try
++    {
++        auto folder = make_deleted_folder(root, "folder");
++        folder->native_metadata();
++        FAIL();
++    }
++    catch (DeletedException const& e)
++    {
++        EXPECT_TRUE(e.error_message().startsWith("Item::native_metadata(): ")) << e.what();
++    }
++}
++
++TEST(File, deleted_exceptions)
++{
++    auto runtime = Runtime::create();
++
++    auto acc = get_account(runtime);
++    auto root = get_root(runtime);
++    clear_folder(root);
++
++    try
++    {
++        auto file = make_deleted_file(root, "file");
++        file->name();
++        FAIL();
++    }
++    catch (DeletedException const& e)
++    {
++        EXPECT_TRUE(e.error_message().startsWith("File::name(): "));
++        EXPECT_TRUE(e.error_message().endsWith(" was deleted previously"));
++        EXPECT_EQ(TEST_DIR "/storage-framework/file", e.native_identity());
++    }
++
++    try
++    {
++        auto file = make_deleted_file(root, "file");
++        file->size();
++        FAIL();
++    }
++    catch (DeletedException const& e)
++    {
++        EXPECT_TRUE(e.error_message().startsWith("File::size(): "));
++        EXPECT_TRUE(e.error_message().endsWith(" was deleted previously"));
++        EXPECT_EQ(TEST_DIR "/storage-framework/file", e.native_identity());
++    }
++
++    try
++    {
++        auto file = make_deleted_file(root, "file");
++        call(file->create_uploader(ConflictPolicy::overwrite, 0));
++        FAIL();
++    }
++    catch (DeletedException const& e)
++    {
++        EXPECT_TRUE(e.error_message().startsWith("File::create_uploader(): "));
++        EXPECT_TRUE(e.error_message().endsWith(" was deleted previously"));
++        EXPECT_EQ(TEST_DIR "/storage-framework/file", e.native_identity());
++    }
++
++    try
++    {
++        auto file = make_deleted_file(root, "file");
++        call(file->create_downloader());
++        FAIL();
++    }
++    catch (DeletedException const& e)
++    {
++        EXPECT_TRUE(e.error_message().startsWith("File::create_downloader(): "));
++        EXPECT_TRUE(e.error_message().endsWith(" was deleted previously"));
++        EXPECT_EQ(TEST_DIR "/storage-framework/file", e.native_identity());
++    }
+ }
  TEST(Runtime, runtime_destroyed_exceptions)
@@ -1387,6 +1816,21 @@
+         }
+     }
++    // Getting accounts after shutting down the runtime must fail.
++    {
++        auto runtime = Runtime::create();
++        runtime->shutdown();
++        try
++        {
++            runtime->accounts();
++            FAIL();
++        }
++        catch (RuntimeDestroyedException const& e)
++        {
++            EXPECT_EQ("Runtime::accounts(): Runtime was destroyed previously", e.error_message());
++        }
++    }
++
      // Getting the account from a root with a destroyed runtime must fail.
+     {
          auto runtime = Runtime::create();
@@ -1429,13 +1873,7 @@
          auto root = get_root(runtime);
          clear_folder(root);
--        auto create_fut = root->create_file("file1", 0);
--        ASSERT_TRUE(wait(create_fut));
--        auto uploader = create_fut.result();
--        auto finish_fut = uploader->finish_upload();
--        ASSERT_TRUE(wait(finish_fut));
--        auto file = finish_fut.result();
--
++        auto file = write_file(root, "file", "");
          runtime.reset();
          try
+         {
@@ -1455,17 +1893,9 @@
          auto root = get_root(runtime);
          clear_folder(root);
--        auto create_fut = root->create_file("file1", 0);
--        ASSERT_TRUE(wait(create_fut));
--        auto uploader = create_fut.result();
--        auto finish_fut = uploader->finish_upload();
--        ASSERT_TRUE(wait(finish_fut));
--        auto file = finish_fut.result();
--
++        auto file = write_file(root, "file", "");
          runtime.reset();
--        qDebug() << "shared count:" << acc.use_count();
          acc.reset();
--        qDebug() << "shared count:" << acc.use_count();
          root.reset();
          try
+         {
@@ -1478,7 +1908,515 @@
+         }
+     }
--    // TODO: Lots more places to cover here.
++    // etag() with destroyed runtime must fail.
++    {
++        auto runtime = Runtime::create();
++        auto acc = get_account(runtime);
++        auto root = get_root(runtime);
++        clear_folder(root);
++
++        auto file = write_file(root, "file", "");
++        runtime->shutdown();
++        try
++        {
++            file->etag();
++            FAIL();
++        }
++        catch (RuntimeDestroyedException const& e)
++        {
++            EXPECT_EQ("Item::etag(): Runtime was destroyed previously", e.error_message());
++        }
++    }
++
++    // metadata() with destroyed runtime must fail.
++    {
++        auto runtime = Runtime::create();
++        auto acc = get_account(runtime);
++        auto root = get_root(runtime);
++        clear_folder(root);
++
++        auto file = write_file(root, "file", "");
++        runtime->shutdown();
++        try
++        {
++            file->metadata();
++            FAIL();
++        }
++        catch (RuntimeDestroyedException const& e)
++        {
++            EXPECT_EQ("Item::metadata(): Runtime was destroyed previously", e.error_message());
++        }
++    }
++
++    // last_modified_time() with destroyed runtime must fail.
++    {
++        auto runtime = Runtime::create();
++        auto acc = get_account(runtime);
++        auto root = get_root(runtime);
++        clear_folder(root);
++
++        auto file = write_file(root, "file", "");
++        runtime->shutdown();
++        try
++        {
++            file->last_modified_time();
++            FAIL();
++        }
++        catch (RuntimeDestroyedException const& e)
++        {
++            EXPECT_EQ("Item::last_modified_time(): Runtime was destroyed previously", e.error_message());
++        }
++    }
++
++    // copy() with destroyed runtime must fail.
++    {
++        auto runtime = Runtime::create();
++        auto acc = get_account(runtime);
++        auto root = get_root(runtime);
++        clear_folder(root);
++
++        auto file = write_file(root, "file", "");
++        runtime->shutdown();
++        try
++        {
++            call(file->copy(root, "file2"));
++            FAIL();
++        }
++        catch (RuntimeDestroyedException const& e)
++        {
++            EXPECT_EQ("Item::copy(): Runtime was destroyed previously", e.error_message());
++        }
++    }
++
++    // move() with destroyed runtime must fail.
++    {
++        auto runtime = Runtime::create();
++        auto acc = get_account(runtime);
++        auto root = get_root(runtime);
++        clear_folder(root);
++
++        auto file = write_file(root, "file", "");
++        runtime->shutdown();
++        try
++        {
++            call(file->move(root, "file2"));
++            FAIL();
++        }
++        catch (RuntimeDestroyedException const& e)
++        {
++            EXPECT_EQ("Item::move(): Runtime was destroyed previously", e.error_message());
++        }
++    }
++
++    // parents() on root with destroyed runtime must fail.
++    {
++        auto runtime = Runtime::create();
++        auto acc = get_account(runtime);
++        auto root = get_root(runtime);
++        clear_folder(root);
++
++        auto file = write_file(root, "file", "");
++        runtime->shutdown();
++        try
++        {
++            call(root->parents());
++            FAIL();
++        }
++        catch (RuntimeDestroyedException const& e)
++        {
++            EXPECT_EQ("Root::parents(): Runtime was destroyed previously", e.error_message());
++        }
++    }
++
++    // parents() on file with destroyed runtime must fail.
++    {
++        auto runtime = Runtime::create();
++        auto acc = get_account(runtime);
++        auto root = get_root(runtime);
++        clear_folder(root);
++
++        auto file = write_file(root, "file", "");
++        runtime->shutdown();
++        try
++        {
++            call(file->parents());
++            FAIL();
++        }
++        catch (RuntimeDestroyedException const& e)
++        {
++            EXPECT_EQ("Item::parents(): Runtime was destroyed previously", e.error_message());
++        }
++    }
++
++    // parent_ids() with destroyed runtime must fail.
++    {
++        auto runtime = Runtime::create();
++        auto acc = get_account(runtime);
++        auto root = get_root(runtime);
++        clear_folder(root);
++
++        auto file = write_file(root, "file", "");
++        runtime->shutdown();
++        try
++        {
++            file->parent_ids();
++            FAIL();
++        }
++        catch (RuntimeDestroyedException const& e)
++        {
++            EXPECT_EQ("Item::parent_ids(): Runtime was destroyed previously", e.error_message());
++        }
++    }
++
++    // parent_ids() on root with destroyed runtime must fail.
++    {
++        auto runtime = Runtime::create();
++        auto acc = get_account(runtime);
++        auto root = get_root(runtime);
++        clear_folder(root);
++
++        runtime->shutdown();
++        try
++        {
++            root->parent_ids();
++            FAIL();
++        }
++        catch (RuntimeDestroyedException const& e)
++        {
++            EXPECT_EQ("Root::parent_ids(): Runtime was destroyed previously", e.error_message());
++        }
++    }
++
++    // delete_item() with destroyed runtime must fail.
++    {
++        auto runtime = Runtime::create();
++        auto acc = get_account(runtime);
++        auto root = get_root(runtime);
++        clear_folder(root);
++
++        auto file = write_file(root, "file", "");
++        runtime->shutdown();
++        try
++        {
++            call(file->delete_item());
++            FAIL();
++        }
++        catch (RuntimeDestroyedException const& e)
++        {
++            EXPECT_EQ("Item::delete_item(): Runtime was destroyed previously", e.error_message());
++        }
++    }
++
++    // delete_item() on root with destroyed runtime must fail.
++    {
++        auto runtime = Runtime::create();
++        auto acc = get_account(runtime);
++        auto root = get_root(runtime);
++        clear_folder(root);
++
++        runtime->shutdown();
++        try
++        {
++            call(root->delete_item());
++            FAIL();
++        }
++        catch (RuntimeDestroyedException const& e)
++        {
++            EXPECT_EQ("Root::delete_item(): Runtime was destroyed previously", e.error_message());
++        }
++    }
++
++    // creation_time() with destroyed runtime must fail.
++    {
++        auto runtime = Runtime::create();
++        auto acc = get_account(runtime);
++        auto root = get_root(runtime);
++        clear_folder(root);
++
++        auto file = write_file(root, "file", "");
++        runtime->shutdown();
++        try
++        {
++            file->creation_time();
++            FAIL();
++        }
++        catch (RuntimeDestroyedException const& e)
++        {
++            EXPECT_EQ("Item::creation_time(): Runtime was destroyed previously", e.error_message());
++        }
++    }
++
++    // native_metadata() with destroyed runtime must fail.
++    {
++        auto runtime = Runtime::create();
++        auto acc = get_account(runtime);
++        auto root = get_root(runtime);
++        clear_folder(root);
++
++        auto file = write_file(root, "file", "");
++        runtime->shutdown();
++        try
++        {
++            file->native_metadata();
++            FAIL();
++        }
++        catch (RuntimeDestroyedException const& e)
++        {
++            EXPECT_EQ("Item::native_metadata(): Runtime was destroyed previously", e.error_message());
++        }
++    }
++
++    // name() on root with destroyed runtime must fail.
++    {
++        auto runtime = Runtime::create();
++        auto acc = get_account(runtime);
++        auto root = get_root(runtime);
++        clear_folder(root);
++
++        runtime->shutdown();
++        try
++        {
++            root->name();
++            FAIL();
++        }
++        catch (RuntimeDestroyedException const& e)
++        {
++            EXPECT_EQ("Root::name(): Runtime was destroyed previously", e.error_message());
++        }
++    }
++
++    // name() on folder with destroyed runtime must fail.
++    {
++        auto runtime = Runtime::create();
++        auto acc = get_account(runtime);
++        auto root = get_root(runtime);
++        clear_folder(root);
++
++        auto folder = call(root->create_folder("folder"));
++        runtime->shutdown();
++        try
++        {
++            folder->name();
++            FAIL();
++        }
++        catch (RuntimeDestroyedException const& e)
++        {
++            EXPECT_EQ("Folder::name(): Runtime was destroyed previously", e.error_message());
++        }
++    }
++
++    // name() on file with destroyed runtime must fail.
++    {
++        auto runtime = Runtime::create();
++        auto acc = get_account(runtime);
++        auto root = get_root(runtime);
++        clear_folder(root);
++
++        auto file = write_file(root, "file", "");
++        runtime->shutdown();
++        try
++        {
++            file->name();
++            FAIL();
++        }
++        catch (RuntimeDestroyedException const& e)
++        {
++            EXPECT_EQ("File::name(): Runtime was destroyed previously", e.error_message());
++        }
++    }
++
++    // list() with destroyed runtime must fail.
++    {
++        auto runtime = Runtime::create();
++        auto acc = get_account(runtime);
++        auto root = get_root(runtime);
++        clear_folder(root);
++
++        runtime->shutdown();
++        try
++        {
++            call(root->list());
++            FAIL();
++        }
++        catch (RuntimeDestroyedException const& e)
++        {
++            EXPECT_EQ("Folder::list(): Runtime was destroyed previously", e.error_message());
++        }
++    }
++
++    // lookup() with destroyed runtime must fail.
++    {
++        auto runtime = Runtime::create();
++        auto acc = get_account(runtime);
++        auto root = get_root(runtime);
++        clear_folder(root);
++
++        runtime->shutdown();
++        try
++        {
++            call(root->lookup("file"));
++            FAIL();
++        }
++        catch (RuntimeDestroyedException const& e)
++        {
++            EXPECT_EQ("Folder::lookup(): Runtime was destroyed previously", e.error_message());
++        }
++    }
++
++    // create_folder() with destroyed runtime must fail.
++    {
++        auto runtime = Runtime::create();
++        auto acc = get_account(runtime);
++        auto root = get_root(runtime);
++        clear_folder(root);
++
++        runtime->shutdown();
++        try
++        {
++            call(root->create_folder("folder"));
++            FAIL();
++        }
++        catch (RuntimeDestroyedException const& e)
++        {
++            EXPECT_EQ("Folder::create_folder(): Runtime was destroyed previously", e.error_message());
++        }
++    }
++
++    // create_file() with destroyed runtime must fail.
++    {
++        auto runtime = Runtime::create();
++        auto acc = get_account(runtime);
++        auto root = get_root(runtime);
++        clear_folder(root);
++
++        runtime->shutdown();
++        try
++        {
++            call(root->create_file("file", 0));
++            FAIL();
++        }
++        catch (RuntimeDestroyedException const& e)
++        {
++            EXPECT_EQ("Folder::create_file(): Runtime was destroyed previously", e.error_message());
++        }
++    }
++
++    // size() with destroyed runtime must fail.
++    {
++        auto runtime = Runtime::create();
++        auto acc = get_account(runtime);
++        auto root = get_root(runtime);
++        clear_folder(root);
++
++        auto file = write_file(root, "file", "");
++        runtime->shutdown();
++        try
++        {
++            file->size();
++            FAIL();
++        }
++        catch (RuntimeDestroyedException const& e)
++        {
++            EXPECT_EQ("File::size(): Runtime was destroyed previously", e.error_message());
++        }
++    }
++
++    // create_uploader() with destroyed runtime must fail.
++    {
++        auto runtime = Runtime::create();
++        auto acc = get_account(runtime);
++        auto root = get_root(runtime);
++        clear_folder(root);
++
++        auto file = write_file(root, "file", "");
++        runtime->shutdown();
++        try
++        {
++            call(file->create_uploader(ConflictPolicy::overwrite, 0));
++            FAIL();
++        }
++        catch (RuntimeDestroyedException const& e)
++        {
++            EXPECT_EQ("File::create_uploader(): Runtime was destroyed previously", e.error_message());
++        }
++    }
++
++    // create_downloader() with destroyed runtime must fail.
++    {
++        auto runtime = Runtime::create();
++        auto acc = get_account(runtime);
++        auto root = get_root(runtime);
++        clear_folder(root);
++
++        auto file = write_file(root, "file", "");
++        runtime->shutdown();
++        try
++        {
++            call(file->create_downloader());
++            FAIL();
++        }
++        catch (RuntimeDestroyedException const& e)
++        {
++            EXPECT_EQ("File::create_downloader(): Runtime was destroyed previously", e.error_message());
++        }
++    }
++
++    // free_space_bytes() with destroyed runtime must fail.
++    {
++        auto runtime = Runtime::create();
++        auto acc = get_account(runtime);
++        auto root = get_root(runtime);
++        clear_folder(root);
++
++        runtime->shutdown();
++        try
++        {
++            call(root->free_space_bytes());
++            FAIL();
++        }
++        catch (RuntimeDestroyedException const& e)
++        {
++            EXPECT_EQ("Root::free_space_bytes(): Runtime was destroyed previously", e.error_message());
++        }
++    }
++
++    // used_space_bytes() with destroyed runtime must fail.
++    {
++        auto runtime = Runtime::create();
++        auto acc = get_account(runtime);
++        auto root = get_root(runtime);
++        clear_folder(root);
++
++        runtime->shutdown();
++        try
++        {
++            call(root->used_space_bytes());
++            FAIL();
++        }
++        catch (RuntimeDestroyedException const& e)
++        {
++            EXPECT_EQ("Root::used_space_bytes(): Runtime was destroyed previously", e.error_message());
++        }
++    }
++
++    // get() with destroyed runtime must fail.
++    {
++        auto runtime = Runtime::create();
++        auto acc = get_account(runtime);
++        auto root = get_root(runtime);
++        clear_folder(root);
++
++        runtime->shutdown();
++        try
++        {
++            call(root->get("some_id"));
++            FAIL();
++        }
++        catch (RuntimeDestroyedException const& e)
++        {
++            EXPECT_EQ("Root::get(): Runtime was destroyed previously", e.error_message());
++        }
++    }
+ }
  int main(int argc, char** argv)
@@ -1488,6 +2426,7 @@
      setenv("STORAGE_FRAMEWORK_ROOT", TEST_DIR, true);
      QCoreApplication app(argc, argv);
++    qRegisterMetaType<QLocalSocket::LocalSocketState>();
      ::testing::InitGoogleTest(&argc, argv);
      return RUN_ALL_TESTS();
 === modified file 'tests/remote-client/remote-client_test.cpp'
 --- tests/remote-client/remote-client_test.cpp	2016-08-03 06:10:39 +0000
 +++ tests/remote-client/remote-client_test.cpp	2016-08-03 06:10:39 +0000
@@ -262,7 +262,7 @@
          QFutureWatcher<QVector<Item::SPtr>> w;
          QSignalSpy spy(&w, &decltype(w)::finished);
          w.setFuture(list_fut);
--        assert(spy.wait(SIGNAL_WAIT_TIME));
++        ASSERT_TRUE(spy.wait(SIGNAL_WAIT_TIME));
+     }
      auto items = list_fut.result();
      ASSERT_EQ(1, items.size());
@@ -273,7 +273,7 @@
          QFutureWatcher<Uploader::SPtr> w;
          QSignalSpy spy(&w, &decltype(w)::finished);
          w.setFuture(create_file_fut);
--        assert(spy.wait(SIGNAL_WAIT_TIME));
++        ASSERT_TRUE(spy.wait(SIGNAL_WAIT_TIME));
+     }
      auto uploader = create_file_fut.result();
      auto finish_upload_fut = uploader->finish_upload();
@@ -281,7 +281,7 @@
          QFutureWatcher<File::SPtr> w;
          QSignalSpy spy(&w, &decltype(w)::finished);
          w.setFuture(finish_upload_fut);
--        assert(spy.wait(SIGNAL_WAIT_TIME));
++        ASSERT_TRUE(spy.wait(SIGNAL_WAIT_TIME));
+     }
      auto file = finish_upload_fut.result();
      EXPECT_EQ(ItemType::file, file->type());
@@ -295,7 +295,7 @@
          QFutureWatcher<Item::SPtr> w;
          QSignalSpy spy(&w, &decltype(w)::finished);
          w.setFuture(get_fut);
--        assert(spy.wait(SIGNAL_WAIT_TIME));
++        ASSERT_TRUE(spy.wait(SIGNAL_WAIT_TIME));
+     }
      file = dynamic_pointer_cast<File>(get_fut.result());
      EXPECT_EQ("child_id", file->native_identity());
@@ -308,7 +308,7 @@
          QFutureWatcher<Folder::SPtr> w;
          QSignalSpy spy(&w, &decltype(w)::finished);
          w.setFuture(create_folder_fut);
--        assert(spy.wait(SIGNAL_WAIT_TIME));
++        ASSERT_TRUE(spy.wait(SIGNAL_WAIT_TIME));
+     }
      EXPECT_EQ(ItemType::folder, folder->type());
      EXPECT_EQ("folder1", folder->name());
@@ -408,7 +408,7 @@
          QFutureWatcher<QVector<Item::SPtr>> w;
          QSignalSpy spy(&w, &decltype(w)::finished);
          w.setFuture(lookup_fut);
--        assert(spy.wait(SIGNAL_WAIT_TIME));
++        ASSERT_TRUE(spy.wait(SIGNAL_WAIT_TIME));
+     }
      auto children = lookup_fut.result();
      ASSERT_EQ(1, children.size());
@@ -421,7 +421,7 @@
          QFutureWatcher<Uploader::SPtr> w;
          QSignalSpy spy(&w, &decltype(w)::finished);
          w.setFuture(create_uploader_fut);
--        assert(spy.wait(SIGNAL_WAIT_TIME));
++        ASSERT_TRUE(spy.wait(SIGNAL_WAIT_TIME));
+     }
      auto uploader = create_uploader_fut.result();
@@ -430,7 +430,7 @@
          QFutureWatcher<File::SPtr> w;
          QSignalSpy spy(&w, &decltype(w)::finished);
          w.setFuture(finish_upload_fut);
--        assert(spy.wait(SIGNAL_WAIT_TIME));
++        ASSERT_TRUE(spy.wait(SIGNAL_WAIT_TIME));
+     }
      auto uploaded_file = finish_upload_fut.result();
      EXPECT_EQ("some_id", uploaded_file->native_identity());
@@ -446,7 +446,7 @@
              QFutureWatcher<File::SPtr> w;
              QSignalSpy spy(&w, &decltype(w)::finished);
              w.setFuture(finish_upload_fut);
--            assert(spy.wait(SIGNAL_WAIT_TIME));
++            ASSERT_TRUE(spy.wait(SIGNAL_WAIT_TIME));
+         }
          auto file = finish_upload_fut.result();
+     }