Merge lp:~azzar1/unity/fix-681503 into lp:unity

[Andrea Azzarone]

Add FavoriteStore external change support.

Add FavoriteStore external change support.

FavoriteStore can emit 3 signals:
* favorite_added
* favorite_removed
* reordered

Because favorite icons are not separated (in the launcher) from no-favorite icons, we do something like this:
- favorite_added.emit("a", "b", true) to say that we want to add the icon before (true) the icon b.
- favorite_added.emit("a", "", true) to say that we want to add the icon at the begin of the launcher.
- favorite_added.emit("a", "b", false) to say that we want to add the icon after (false) the icon b.

The reordered signal is not emitted if we don't really need it. For example:
- A B C D -> A C D we don't need the reordered signal
- A B C D -> A C E D we don't need it
- A B C D -> A F B H C D we don't need it
- A B C D -> A B D C we need it
- A B C D -> B A we need it
- A B C D -> B A F C D we need it

[Mirco Müller (macslow)]

There's a merge-conflict in plugins/unityshell/src/BamfLauncherIcon.h with trunk...

  const char* DesktopFile();
  bool IsSticky();
<<<<<<< TREE
  void Quit();
  void Stick();
=======
  void Stick(bool save = true);
>>>>>>> MERGE-SOURCE
  void UnStick();

review: Needs Fixing

[Andrea Azzarone (azzar1)]

> There's a merge-conflict in plugins/unityshell/src/BamfLauncherIcon.h with
> trunk...
>
> const char* DesktopFile();
> bool IsSticky();
> <<<<<<< TREE
> void Quit();
> void Stick();
> =======
> void Stick(bool save = true);
> >>>>>>> MERGE-SOURCE
> void UnStick();

Fixed.

[Mirco Müller (macslow)]

Looking good now.

review: Approve

[Unity Merger (unity-merger)]

Attempt to merge into lp:unity failed due to conflicts:

text conflict in tests/CMakeLists.txt

=== modified file 'plugins/unityshell/src/BamfLauncherIcon.cpp'
--- plugins/unityshell/src/BamfLauncherIcon.cpp	2012-01-24 02:19:04 +0000
+++ plugins/unityshell/src/BamfLauncherIcon.cpp	2012-01-26 14:42:28 +0000
@@ -871,7 +871,7 @@
   g_list_free(children);
 }
 
-void BamfLauncherIcon::Stick()
+void BamfLauncherIcon::Stick(bool save)
 {
   BamfView* view = BAMF_VIEW(m_App);
   
@@ -881,7 +881,7 @@
   const gchar* desktop_file = DesktopFile();
   bamf_view_set_sticky(view, true);
   
-  if (desktop_file && strlen(desktop_file) > 0)
+  if (save && desktop_file && strlen(desktop_file) > 0)
     FavoriteStore::GetDefault().AddFavorite(desktop_file, -1);
 }
 
 
=== modified file 'plugins/unityshell/src/BamfLauncherIcon.h'
--- plugins/unityshell/src/BamfLauncherIcon.h	2012-01-15 19:01:11 +0000
+++ plugins/unityshell/src/BamfLauncherIcon.h	2012-01-26 14:42:28 +0000
@@ -46,9 +46,9 @@
 
   const char* DesktopFile();
   bool IsSticky();
+  void Stick(bool save = true);
+  void UnStick();
   void Quit();
-  void Stick();
-  void UnStick();
 
   void ActivateLauncherIcon(ActionArg arg);
 
 
=== modified file 'plugins/unityshell/src/FavoriteStore.h'
--- plugins/unityshell/src/FavoriteStore.h	2011-07-21 14:59:25 +0000
+++ plugins/unityshell/src/FavoriteStore.h	2012-01-26 14:42:28 +0000
@@ -34,7 +34,7 @@
 // Use GetDefault () to get the correct store for the session
 typedef std::list<std::string> FavoriteList;
 
-class FavoriteStore : boost::noncopyable
+class FavoriteStore : public sigc::trackable, boost::noncopyable
 {
 public:
   virtual ~FavoriteStore();
@@ -54,12 +54,12 @@
   virtual void SetFavorites(FavoriteList const& desktop_paths) = 0;
 
   // Signals
-  // Therse only emit if something has changed the GSettings object externally
+  // These only emit if something has changed the GSettings object externally
 
-  //desktop_path, position
-  sigc::signal<void, std::string, int> favorite_added;
+  //desktop_path, position, before/after
+  sigc::signal<void, std::string const&, std::string const&, bool> favorite_added;
   //desktop_path
-  sigc::signal<void, std::string> favorite_removed;
+  sigc::signal<void, std::string const&> favorite_removed;
   sigc::signal<void> reordered;
 };
 
 
=== modified file 'plugins/unityshell/src/FavoriteStoreGSettings.cpp'
--- plugins/unityshell/src/FavoriteStoreGSettings.cpp	2011-11-28 15:19:31 +0000
+++ plugins/unityshell/src/FavoriteStoreGSettings.cpp	2012-01-26 14:42:28 +0000
@@ -17,15 +17,14 @@
 * Authored by: Neil Jagdish Patel <[e-mail]>
 */
 
-#include "FavoriteStoreGSettings.h"
-
 #include <algorithm>
-#include <iostream>
 
 #include <gio/gdesktopappinfo.h>
-
 #include <NuxCore/Logger.h>
 
+#include "FavoriteStoreGSettings.h"
+#include "FavoriteStorePrivate.h"
+
 #include "config.h"
 
 /**
@@ -103,7 +102,12 @@
 
 void FavoriteStoreGSettings::Refresh()
 {
-  favorites_.clear();
+  FillList(favorites_);
+}
+
+void FavoriteStoreGSettings::FillList(FavoriteList& list)
+{
+  list.clear();
 
   gchar** favs = g_settings_get_strv(settings_, "favorites");
 
@@ -114,7 +118,7 @@
     {
       if (g_file_test(favs[i], G_FILE_TEST_EXISTS))
       {
-        favorites_.push_back(favs[i]);
+        list.push_back(favs[i]);
       }
       else
       {
@@ -131,12 +135,11 @@
 
       if (filename)
       {
-        favorites_.push_back(filename);
+        list.push_back(filename);
       }
       else
       {
-        LOG_WARNING(logger) << "Unable to load GDesktopAppInfo for '"
-                         << favs[i] << "'";
+        LOG_WARNING(logger) << "Unable to load GDesktopAppInfo for '" << favs[i] << "'";
       }
     }
   }
@@ -222,7 +225,7 @@
   Refresh();
 }
 
-void FavoriteStoreGSettings::SaveFavorites(FavoriteList const& favorites)
+void FavoriteStoreGSettings::SaveFavorites(FavoriteList const& favorites, bool ignore)
 {
   const int size = favorites.size();
   const char* favs[size + 1];
@@ -244,7 +247,7 @@
     favs[index] = iter->c_str();
   }
 
-  ignore_signals_ = true;
+  ignore_signals_ = ignore;
   if (!g_settings_set_strv(settings_, "favorites", favs))
   {
     LOG_WARNING(logger) << "Saving favorites failed.";
@@ -254,10 +257,34 @@
 
 void FavoriteStoreGSettings::Changed(std::string const& key)
 {
-  if (ignore_signals_)
+  if (ignore_signals_ or key != "favorites")
     return;
-
-  LOG_DEBUG(logger) << "Changed: " << key;
+    
+  FavoriteList old(favorites_);
+  FillList(favorites_);
+
+  auto newbies = impl::GetNewbies(old, favorites_);
+
+  for (auto it : favorites_)
+  {
+    if (std::find(newbies.begin(), newbies.end(), it) == newbies.end())
+      continue;
+    
+    std::string pos;
+    bool before;
+    
+    impl::GetSignalAddedInfo(favorites_, newbies , it, pos, before);
+    favorite_added.emit(it, pos, before);
+  }
+                     
+  for (auto it : impl::GetRemoved(old, favorites_))
+  {
+    favorite_removed.emit(it); 
+  }
+  
+  if (impl::NeedToBeReordered(old, favorites_))
+    reordered.emit();
+ 
 }
 
 namespace
 
=== modified file 'plugins/unityshell/src/FavoriteStoreGSettings.h'
--- plugins/unityshell/src/FavoriteStoreGSettings.h	2011-07-21 14:59:25 +0000
+++ plugins/unityshell/src/FavoriteStoreGSettings.h	2012-01-26 14:42:28 +0000
@@ -42,6 +42,7 @@
   virtual void AddFavorite(std::string const& desktop_path, int position);
   virtual void RemoveFavorite(std::string const& desktop_path);
   virtual void MoveFavorite(std::string const& desktop_path, int position);
+  void SaveFavorites(FavoriteList const& favorites, bool ignore = true);
   virtual void SetFavorites(FavoriteList const& desktop_paths);
 
   //Methods
@@ -50,7 +51,7 @@
 private:
   void Init();
   void Refresh();
-  void SaveFavorites(FavoriteList const& favorites);
+  void FillList(FavoriteList& list);
 
   FavoriteList favorites_;
   glib::Object<GSettings> settings_;
 
=== added file 'plugins/unityshell/src/FavoriteStorePrivate.cpp'
--- plugins/unityshell/src/FavoriteStorePrivate.cpp	1970-01-01 00:00:00 +0000
+++ plugins/unityshell/src/FavoriteStorePrivate.cpp	2012-01-26 14:42:28 +0000
@@ -0,0 +1,130 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+* Copyright (C) 2011 Canonical Ltd
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU 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 General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*
+* Authored by: Andrea Azzaronea <[e-mail]>
+*/
+
+#include <algorithm>
+#include <boost/utility.hpp>
+
+#include "FavoriteStorePrivate.h"
+
+namespace unity
+{
+namespace internal
+{
+namespace impl
+{
+
+std::vector<std::string> GetNewbies(std::list<std::string> const& old, std::list<std::string> const& fresh)
+{
+  auto sorted_old(old);
+  auto sorted_fresh(fresh);
+
+  sorted_old.sort();
+  sorted_fresh.sort();
+
+  std::vector<std::string> result;
+  std::set_difference(sorted_fresh.begin(), sorted_fresh.end(), sorted_old.begin(), sorted_old.end(),
+                      std::inserter(result, result.end()));
+
+  return result;
+}
+
+void GetSignalAddedInfo(std::list<std::string> const& favs, std::vector<std::string> const& newbies,
+                        std::string const& path, std::string& position, bool& before)
+{
+  auto it = std::find(favs.begin(), favs.end(), path);
+  before = (it == favs.begin());
+  position = "";
+
+  if (before and favs.size() > 1)
+  {
+    while (it != favs.end() && std::find(newbies.begin(), newbies.end(), *it) != newbies.end())
+      ++it;
+
+    if (it != favs.end())
+      position = *it;
+  }
+  else if (!before)
+  {
+    position = *(boost::prior(it));
+  }
+
+}
+
+std::vector<std::string> GetRemoved(std::list<std::string> const& old, std::list<std::string> const& fresh)
+{
+  auto sorted_old(old);
+  auto sorted_fresh(fresh);
+
+  sorted_old.sort();
+  sorted_fresh.sort();
+
+  std::vector<std::string> result;
+  std::set_difference(sorted_old.begin(), sorted_old.end(), sorted_fresh.begin(), sorted_fresh.end(),
+                      std::inserter(result, result.end()));
+
+  return result;
+}
+
+
+bool NeedToBeReordered(std::list<std::string> const& old, std::list<std::string> const& fresh)
+{
+  auto sorted_old(old);
+  auto sorted_fresh(fresh);
+
+  sorted_old.sort();
+  sorted_fresh.sort();
+
+  std::vector<std::string> ignore_old, ignore_fresh;
+
+  std::set_difference(sorted_old.begin(), sorted_old.end(), sorted_fresh.begin(), sorted_fresh.end(),
+                      std::inserter(ignore_old, ignore_old.end()));
+  std::set_difference(sorted_fresh.begin(), sorted_fresh.end(), sorted_old.begin(), sorted_old.end(),
+                      std::inserter(ignore_fresh, ignore_fresh.end()));
+
+  auto it_old = old.begin();
+  auto it_fresh = fresh.begin();
+
+  while (it_old != old.end() && it_fresh != fresh.end())
+  {
+
+    while (it_old != old.end() && std::find(ignore_old.begin(), ignore_old.end(), *it_old) != ignore_old.end())
+      ++it_old;
+
+    while (it_fresh != fresh.end() && std::find(ignore_fresh.begin(), ignore_fresh.end(), *it_fresh) != ignore_fresh.end())
+      ++it_fresh;
+
+    if (it_old == old.end() || it_fresh == fresh.end())
+      break;
+
+    if (*it_old != *it_fresh)
+    {
+      return true;
+    }
+
+    ++it_old;
+    ++it_fresh;
+  }
+
+  return false;
+}
+
+
+} // namespace impl
+} // namespace internal
+} // namespace unity
 
=== added file 'plugins/unityshell/src/FavoriteStorePrivate.h'
--- plugins/unityshell/src/FavoriteStorePrivate.h	1970-01-01 00:00:00 +0000
+++ plugins/unityshell/src/FavoriteStorePrivate.h	2012-01-26 14:42:28 +0000
@@ -0,0 +1,47 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+* Copyright (C) 2011 Canonical Ltd
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU 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 General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*
+* Authored by: Andrea Azzaronea <[e-mail]>
+*/
+
+#ifndef UNITYSHELL_FAVORITESTOREPRIVATE_H
+#define UNITYSHELL_FAVORITESTOREPRIVATE_H
+
+#include <list>
+#include <string>
+
+namespace unity
+{
+namespace internal
+{
+namespace impl
+{
+
+std::vector<std::string> GetNewbies(std::list<std::string> const& old, std::list<std::string> const& fresh);
+
+void GetSignalAddedInfo(std::list<std::string> const& favs, std::vector<std::string> const& newbies, 
+                        std::string const& path, std::string& position, bool& before);
+
+std::vector<std::string> GetRemoved(std::list<std::string> const& old, std::list<std::string> const& fresh);
+
+bool NeedToBeReordered(std::list<std::string> const& old, std::list<std::string> const& fresh);
+
+} // namespace impl
+} // namespace internal
+} // namespace unity
+
+#endif
+
 
=== modified file 'plugins/unityshell/src/LauncherController.cpp'
--- plugins/unityshell/src/LauncherController.cpp	2012-01-23 13:07:40 +0000
+++ plugins/unityshell/src/LauncherController.cpp	2012-01-26 14:42:28 +0000
@@ -73,6 +73,11 @@
 
   void OnLauncherEntryRemoteAdded(LauncherEntryRemote* entry);
   void OnLauncherEntryRemoteRemoved(LauncherEntryRemote* entry);
+  
+  void OnFavoriteStoreFavoriteAdded(std::string const& entry, std::string const& pos, bool before);
+  void OnFavoriteStoreFavoriteRemoved(std::string const& entry);
+  void OnFavoriteStoreReordered();
+
 
   void InsertExpoAction();
   void RemoveExpoAction();
@@ -179,6 +184,10 @@
 
   remote_model_.entry_added.connect(sigc::mem_fun(this, &Impl::OnLauncherEntryRemoteAdded));
   remote_model_.entry_removed.connect(sigc::mem_fun(this, &Impl::OnLauncherEntryRemoteRemoved));
+  
+  FavoriteStore::GetDefault().favorite_added.connect(sigc::mem_fun(this, &Impl::OnFavoriteStoreFavoriteAdded));
+  FavoriteStore::GetDefault().favorite_removed.connect(sigc::mem_fun(this, &Impl::OnFavoriteStoreFavoriteRemoved));
+  FavoriteStore::GetDefault().reordered.connect(sigc::mem_fun(this, &Impl::OnFavoriteStoreReordered));
 
   RegisterIcon(new BFBLauncherIcon(raw_launcher));
   desktop_icon_ = new DesktopLauncherIcon(raw_launcher);
@@ -349,6 +358,82 @@
   }
 }
 
+void Controller::Impl::OnFavoriteStoreFavoriteAdded(std::string const& entry, std::string const& pos, bool before)
+{  
+  auto bamf_list = model_->GetSublist<BamfLauncherIcon>();  
+  LauncherIcon* other = (bamf_list.size() > 0) ? *(bamf_list.begin()) : nullptr;
+  
+  if (!pos.empty())
+  {
+    for (auto it : bamf_list)
+    {
+      if (it->GetQuirk(LauncherIcon::QUIRK_VISIBLE) && pos == it->DesktopFile())
+        other = it;
+    }
+  }
+  
+  for (auto it : bamf_list)
+  {
+    if (entry == it->DesktopFile())
+    {
+      it->Stick(false);
+      if (!before)
+        model_->ReorderAfter(it, other);
+      else
+        model_->ReorderBefore(it, other, false);
+      return;
+    }
+  }
+
+  LauncherIcon* result = CreateFavorite(entry.c_str());
+  if (result)
+  {
+    RegisterIcon(result);
+    if (!before)
+      model_->ReorderAfter(result, other);
+    else
+      model_->ReorderBefore(result, other, false);
+  }
+}
+
+void Controller::Impl::OnFavoriteStoreFavoriteRemoved(std::string const& entry)
+{
+  for (auto it : model_->GetSublist<BamfLauncherIcon> ())
+  {
+    if (it->DesktopFile() == entry)
+    {
+      OnLauncherRemoveRequest(it);
+      break;
+     }
+  }
+}
+
+void Controller::Impl::OnFavoriteStoreReordered()
+{ 
+  FavoriteList const& favs = FavoriteStore::GetDefault().GetFavorites();
+  auto bamf_list = model_->GetSublist<BamfLauncherIcon>();
+  
+  int i = 0;
+  for (auto it : favs)
+  {    
+    auto icon = std::find_if(bamf_list.begin(), bamf_list.end(),
+    [&it](BamfLauncherIcon* x) { return (x->DesktopFile() == it); });
+    
+    if (icon != bamf_list.end())
+    {
+      (*icon)->SetSortPriority(i++);
+    }
+  }
+  
+  for (auto it : bamf_list)
+  {
+    if (!it->IsSticky())
+      it->SetSortPriority(i++);
+  }
+  
+  model_->Sort();
+}
+
 void Controller::Impl::OnExpoActivated()
 {
   WindowManager::Default()->InitiateExpo();
 
=== modified file 'plugins/unityshell/src/LauncherModel.cpp'
--- plugins/unityshell/src/LauncherModel.cpp	2012-01-25 03:02:57 +0000
+++ plugins/unityshell/src/LauncherModel.cpp	2012-01-26 14:42:28 +0000
@@ -188,6 +188,36 @@
 }
 
 void
+LauncherModel::ReorderAfter(LauncherIcon* icon, LauncherIcon* other)
+{
+  if (icon == other)
+    return;
+
+  int i = 0;
+  for (LauncherModel::iterator it = begin(); it != end(); ++it)
+  {
+    if ((*it) == icon)
+      continue;
+
+    if ((*it) == other)
+    {
+      (*it)->SetSortPriority(i);
+      ++i;
+
+      icon->SetSortPriority(i);
+      ++i;
+    }
+    else
+    {
+      (*it)->SetSortPriority(i);
+      ++i;
+    }
+  }
+
+  Sort();
+}
+
+void
 LauncherModel::ReorderBefore(LauncherIcon* icon, LauncherIcon* other, bool save)
 {
   if (icon == other)
 
=== modified file 'plugins/unityshell/src/LauncherModel.h'
--- plugins/unityshell/src/LauncherModel.h	2011-10-05 23:55:59 +0000
+++ plugins/unityshell/src/LauncherModel.h	2012-01-26 14:42:28 +0000
@@ -51,6 +51,7 @@
 
   bool IconHasSister(LauncherIcon* icon);
 
+  void ReorderAfter(LauncherIcon* icon, LauncherIcon* other);
   void ReorderBefore(LauncherIcon* icon, LauncherIcon* other, bool save);
 
   void ReorderSmart(LauncherIcon* icon, LauncherIcon* other, bool save);
 
=== modified file 'tests/CMakeLists.txt'
--- tests/CMakeLists.txt	2012-01-26 08:25:52 +0000
+++ tests/CMakeLists.txt	2012-01-26 14:42:28 +0000
@@ -119,6 +119,7 @@
                  test_glib_variant.cpp
                  ${CMAKE_CURRENT_BINARY_DIR}/test_glib_signals_utils_marshal.cpp
                  test_favorite_store_gsettings.cpp
+                 test_favorite_store_private.cpp
                  test_home_lens.cpp
                  test_shortcut_model.cpp
                  test_shortcut_private.cpp
@@ -137,6 +138,8 @@
                  ${UNITY_SRC}/FavoriteStore.h
                  ${UNITY_SRC}/FavoriteStoreGSettings.cpp
                  ${UNITY_SRC}/FavoriteStoreGSettings.h
+                 ${UNITY_SRC}/FavoriteStorePrivate.cpp
+                 ${UNITY_SRC}/FavoriteStorePrivate.h
                  ${UNITY_SRC}/MockLauncherIcon.h
                  ${UNITY_SRC}/MockShortcutHint.h
                  ${UNITY_SRC}/ShortcutModel.cpp
 
=== modified file 'tests/test_favorite_store_gsettings.cpp'
--- tests/test_favorite_store_gsettings.cpp	2011-11-28 16:02:32 +0000
+++ tests/test_favorite_store_gsettings.cpp	2012-01-26 14:42:28 +0000
@@ -42,8 +42,8 @@
 const gchar* SCHEMA_DIRECTORY = BUILDDIR"/settings";
 const gchar* BASE_STORE_FILE = BUILDDIR"/settings/test-favorite-store-gsettings.store";
 const gchar* BASE_STORE_CONTENTS = "[desktop/unity/launcher]\n" \
-                                  "favorites=['%s', '%s', '%s']";
-                                  
+                                   "favorites=['%s', '%s', '%s']";
+
 const char* base_store_favs[] = { BUILDDIR"/tests/data/ubuntuone-installer.desktop",
                                   BUILDDIR"/tests/data/ubuntu-software-center.desktop",
                                   BUILDDIR"/tests/data/update-manager.desktop",
@@ -222,5 +222,271 @@
   EXPECT_EQ(at(favs, 2), base_store_favs[2]);
 }
 
+TEST_F(TestFavoriteStoreGSettings, TestFavoriteAddedSignalFirst)
+{
+  internal::FavoriteStoreGSettings settings(backend.RawPtr());
+  bool signal_received = false;
+  std::string position;
+  bool before = false;
+  
+  settings.favorite_added.connect([&](std::string const& path, std::string const& pos, bool bef)
+  {
+    signal_received = true;
+    position = pos;
+    before = bef;
+  });
+  
+  FavoriteList favs;
+  favs.push_back(other_desktop);
+  favs.push_back(base_store_favs[0]);
+  favs.push_back(base_store_favs[1]);
+  favs.push_back(base_store_favs[2]);
+  settings.SaveFavorites(favs, false);
+                     
+  sleep(1);
+  
+  ASSERT_TRUE(signal_received);
+  EXPECT_EQ(position, base_store_favs[0]);
+  EXPECT_TRUE(before);
+}
+
+TEST_F(TestFavoriteStoreGSettings, TestFavoriteAddedSignalMiddle)
+{
+  internal::FavoriteStoreGSettings settings(backend.RawPtr());
+  bool signal_received = false;
+  std::string position;
+  bool before = true;
+  
+  settings.favorite_added.connect([&](std::string const& path, std::string const& pos, bool bef)
+  {
+    signal_received = true;
+    position = pos;
+    before = bef;
+  });
+  
+  FavoriteList favs;
+  favs.push_back(base_store_favs[0]);
+  favs.push_back(base_store_favs[1]);
+  favs.push_back(other_desktop);
+  favs.push_back(base_store_favs[2]);
+  settings.SaveFavorites(favs, false);
+                     
+  sleep(1);
+  
+  ASSERT_TRUE(signal_received);
+  EXPECT_EQ(position, base_store_favs[1]);
+  EXPECT_FALSE(before);
+}
+
+TEST_F(TestFavoriteStoreGSettings, TestFavoriteAddedSignalEnd)
+{
+  internal::FavoriteStoreGSettings settings(backend.RawPtr());
+  bool signal_received = false;
+  std::string position;
+  bool before = true;
+  
+  settings.favorite_added.connect([&](std::string const& path, std::string const& pos, bool bef)
+  {
+    signal_received = true;
+    position = pos;
+    before = bef;
+  });
+  
+  FavoriteList favs;
+  favs.push_back(base_store_favs[0]);
+  favs.push_back(base_store_favs[1]);
+  favs.push_back(base_store_favs[2]);
+  favs.push_back(other_desktop);
+  settings.SaveFavorites(favs, false);
+                     
+  sleep(1);
+  
+  ASSERT_TRUE(signal_received);
+  EXPECT_EQ(position, base_store_favs[2]);
+  EXPECT_FALSE(before);
+}
+
+TEST_F(TestFavoriteStoreGSettings, TestFavoriteAddedSignalEmpty)
+{
+  internal::FavoriteStoreGSettings settings(backend.RawPtr());
+  bool signal_received = false;
+  std::string position;
+  bool before = false;
+  
+  settings.favorite_added.connect([&](std::string const& path, std::string const& pos, bool bef)
+  {
+    signal_received = true;
+    position = pos;
+    before = bef;
+  });
+  
+  FavoriteList favs;
+  favs.push_back(other_desktop);
+  settings.SaveFavorites(favs, false);
+                     
+  sleep(1);
+  
+  ASSERT_TRUE(signal_received);
+  EXPECT_EQ(position, "");
+  EXPECT_TRUE(before);
+}
+
+TEST_F(TestFavoriteStoreGSettings, TestFavoriteRemoved)
+{
+  internal::FavoriteStoreGSettings settings(backend.RawPtr());
+  bool signal_received = false;
+  std::string path_removed;
+  
+  settings.favorite_removed.connect([&](std::string const& path)
+  {
+    signal_received = true;
+    path_removed = path;
+  });
+  
+  FavoriteList favs;
+  favs.push_back(base_store_favs[0]);
+  favs.push_back(base_store_favs[2]);
+  settings.SaveFavorites(favs, false);
+                     
+  sleep(1);
+  
+  ASSERT_TRUE(signal_received);
+  EXPECT_EQ(path_removed, base_store_favs[1]);
+}
+
+TEST_F(TestFavoriteStoreGSettings, TestFavoriteReordered)
+{
+  internal::FavoriteStoreGSettings settings(backend.RawPtr());
+  bool signal_received = false;
+  
+  settings.reordered.connect([&]()
+  {
+    signal_received = true;
+  });
+  
+  FavoriteList favs;
+  favs.push_back(base_store_favs[0]);
+  favs.push_back(base_store_favs[2]);
+  favs.push_back(base_store_favs[1]);
+  settings.SaveFavorites(favs, false);
+                     
+  sleep(1);
+  
+  ASSERT_TRUE(signal_received);
+  
+  signal_received = false;
+  favs.push_back(base_store_favs[0]);
+  favs.push_back(base_store_favs[2]);
+  favs.push_back(base_store_favs[1]);
+  settings.SaveFavorites(favs, false);
+                     
+  sleep(1);
+  
+  ASSERT_FALSE(signal_received);
+}
+
+TEST_F(TestFavoriteStoreGSettings, TestFavoriteSignalsMixed1)
+{
+  internal::FavoriteStoreGSettings settings(backend.RawPtr());
+  bool added_received = false;
+  bool removed_received = false;
+  bool reordered_received = false;
+  
+  settings.favorite_added.connect([&](std::string const& path, std::string const& pos, bool bef)
+  {
+    added_received = true;
+  });
+  
+  settings.favorite_removed.connect([&](std::string const& path)
+  {
+    removed_received = true;
+  });
+  
+  settings.reordered.connect([&]()
+  {
+    reordered_received = true;
+  });
+  
+  FavoriteList favs;
+  favs.push_back(base_store_favs[0]);
+  favs.push_back(base_store_favs[1]);
+  favs.push_back(other_desktop);
+  settings.SaveFavorites(favs, false);
+                     
+  sleep(1);
+  
+  EXPECT_TRUE(added_received);
+  EXPECT_TRUE(removed_received);
+  EXPECT_FALSE(reordered_received);
+}
+
+TEST_F(TestFavoriteStoreGSettings, TestFavoriteSignalsMixed2)
+{
+  internal::FavoriteStoreGSettings settings(backend.RawPtr());
+  bool added_received = false;
+  bool removed_received = false;
+  bool reordered_received = false;
+  
+  settings.favorite_added.connect([&](std::string const& path, std::string const& pos, bool bef)
+  {
+    added_received = true;
+  });
+  
+  settings.favorite_removed.connect([&](std::string const& path)
+  {
+    removed_received = true;
+  });
+  
+  settings.reordered.connect([&]()
+  {
+    reordered_received = true;
+  });
+  
+  FavoriteList favs;
+  favs.push_back(base_store_favs[1]);
+  favs.push_back(other_desktop);
+  favs.push_back(base_store_favs[0]);
+  settings.SaveFavorites(favs, false);
+                     
+  sleep(1);
+  
+  EXPECT_TRUE(added_received);
+  EXPECT_TRUE(removed_received);
+  EXPECT_TRUE(reordered_received);
+}
+
+TEST_F(TestFavoriteStoreGSettings, TestFavoriteSignalsMixed3)
+{
+  internal::FavoriteStoreGSettings settings(backend.RawPtr());
+  bool added_received = false;
+  bool removed_received = false;
+  bool reordered_received = false;
+  
+  settings.favorite_added.connect([&](std::string const& path, std::string const& pos, bool bef)
+  {
+    added_received = true;
+  });
+  
+  settings.favorite_removed.connect([&](std::string const& path)
+  {
+    removed_received = true;
+  });
+  
+  settings.reordered.connect([&]()
+  {
+    reordered_received = true;
+  });
+  
+  FavoriteList favs;
+  favs.push_back(base_store_favs[1]);
+  favs.push_back(base_store_favs[0]);
+  settings.SaveFavorites(favs, false);
+                     
+  sleep(1);
+  
+  EXPECT_FALSE(added_received);
+  EXPECT_TRUE(removed_received);
+  EXPECT_TRUE(reordered_received);
+}
 
 } // anonymous namespace
 
=== added file 'tests/test_favorite_store_private.cpp'
--- tests/test_favorite_store_private.cpp	1970-01-01 00:00:00 +0000
+++ tests/test_favorite_store_private.cpp	2012-01-26 14:42:28 +0000
@@ -0,0 +1,417 @@
+/*
+ * Copyright 2011 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU 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 warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY or FITNESS FOR A PARTICULAR
+ * PURPOSE.  See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * version 3 along with this program.  If not, see
+ * <http://www.gnu.org/licenses/>
+ *
+ * Authored by: Andrea Azzarone <[e-mail]>
+ *
+ */
+
+#include <gtest/gtest.h>
+ 
+#include "FavoriteStorePrivate.h"
+
+using namespace unity;
+
+TEST(TestFavoriteStorePrivate, TestGetNewbies)
+{
+  std::list<std::string> old;
+  std::list<std::string> fresh;
+  std::vector<std::string> result;
+  
+  old.push_back("a");
+  old.push_back("b");
+  old.push_back("c");
+  old.push_back("d");
+  
+  // No change.
+  fresh.push_back("a");
+  fresh.push_back("b");
+  fresh.push_back("c");
+  fresh.push_back("d");
+  
+  result = internal::impl::GetNewbies(old, fresh);
+  
+  EXPECT_TRUE(result.empty());
+  
+  // Permutation.
+  fresh.clear();
+  result.clear();
+  fresh.push_back("a");
+  fresh.push_back("c");
+  fresh.push_back("b");
+  fresh.push_back("d");
+  
+  result = internal::impl::GetNewbies(old, fresh);
+  
+  EXPECT_TRUE(result.empty());
+  
+  // a b c d -> a c b
+  fresh.clear();
+  result.clear();
+  fresh.push_back("a");
+  fresh.push_back("c");
+  fresh.push_back("b");
+  
+  result = internal::impl::GetNewbies(old, fresh);
+        
+  EXPECT_TRUE(result.empty());
+  
+  // a b c d -> a b c d e f
+  fresh.clear();
+  result.clear();
+  fresh.push_back("a");
+  fresh.push_back("b");
+  fresh.push_back("c");
+  fresh.push_back("d");
+  fresh.push_back("e");
+  fresh.push_back("f");
+  
+  result = internal::impl::GetNewbies(old, fresh);
+  
+  EXPECT_EQ(result.size(), 2);
+  EXPECT_EQ(result[0], "e");
+  EXPECT_EQ(result[1], "f");
+  
+  // a b c d -> a b c e f
+  fresh.clear();
+  result.clear();
+  fresh.push_back("a");
+  fresh.push_back("b");
+  fresh.push_back("c");
+  fresh.push_back("e");
+  fresh.push_back("f");
+  
+  result = internal::impl::GetNewbies(old, fresh);
+  
+  EXPECT_EQ(result.size(), 2);
+  EXPECT_EQ(result[0], "e");
+  EXPECT_EQ(result[1], "f");
+}
+
+TEST(TestFavoriteStorePrivate, TestGetSignalAddedInfo)
+{
+  std::list<std::string> favs;
+  std::vector<std::string> newbies;
+  std::string position;
+  bool before;
+  
+  favs.push_back("a");
+  favs.push_back("b");
+  favs.push_back("c");
+  favs.push_back("d");
+  favs.push_back("e");
+  
+  // b c d e -> a b c d e
+  newbies.push_back("a");
+  internal::impl::GetSignalAddedInfo(favs, newbies, "a", position, before);
+  EXPECT_TRUE(before);
+  EXPECT_EQ(position, "b");
+  
+  // a c d e -> a b c d e
+  newbies.clear();
+  newbies.push_back("b");
+  internal::impl::GetSignalAddedInfo(favs, newbies, "b", position, before);
+  EXPECT_FALSE(before);
+  EXPECT_EQ(position, "a");
+  
+  // a b d e -> a b c d e
+  newbies.clear();
+  newbies.push_back("c");
+  internal::impl::GetSignalAddedInfo(favs, newbies, "c", position, before);
+  EXPECT_FALSE(before);
+  EXPECT_EQ(position, "b");
+  
+  // a b c e -> a b c d e
+  newbies.clear();
+  newbies.push_back("d");
+  internal::impl::GetSignalAddedInfo(favs, newbies, "d", position, before);
+  EXPECT_FALSE(before);
+  EXPECT_EQ(position, "c");
+  
+  // a b c d -> a b c d e
+  newbies.clear();
+  newbies.push_back("e");
+  internal::impl::GetSignalAddedInfo(favs, newbies, "e", position, before);
+  EXPECT_FALSE(before);
+  EXPECT_EQ(position, "d");
+  
+  // -> b a c
+  favs.clear();
+  favs.push_back("b");
+  favs.push_back("a");
+  favs.push_back("c");
+  newbies.clear();
+  newbies.push_back("a");
+  newbies.push_back("b");
+  newbies.push_back("c");
+  
+  internal::impl::GetSignalAddedInfo(favs, newbies, "b", position, before);
+  EXPECT_TRUE(before);
+  EXPECT_EQ(position, "");
+  
+  internal::impl::GetSignalAddedInfo(favs, newbies, "a", position, before);
+  EXPECT_FALSE(before);
+  EXPECT_EQ(position, "b");
+  
+  internal::impl::GetSignalAddedInfo(favs, newbies, "c", position, before);
+  EXPECT_FALSE(before);
+  EXPECT_EQ(position, "a");
+}
+
+
+TEST(TestFavoriteStorePrivate, TestGetRemoved)
+{
+  std::list<std::string> old;
+  std::list<std::string> fresh;
+  std::vector<std::string> result;
+  
+  old.push_back("a");
+  old.push_back("b");
+  old.push_back("c");
+  old.push_back("d");
+  
+  // No change.
+  fresh.push_back("a");
+  fresh.push_back("b");
+  fresh.push_back("c");
+  fresh.push_back("d");
+  
+  result = internal::impl::GetRemoved(old, fresh);
+  
+  EXPECT_TRUE(result.empty());
+  
+  // Permutation.
+  fresh.clear();
+  result.clear();
+  fresh.push_back("a");
+  fresh.push_back("c");
+  fresh.push_back("b");
+  fresh.push_back("d");
+  
+  result = internal::impl::GetRemoved(old, fresh);
+  
+  EXPECT_TRUE(result.empty());
+  
+  // a b c d -> b c
+  fresh.clear();
+  result.clear();
+  fresh.push_back("b");
+  fresh.push_back("c");
+  
+  result = internal::impl::GetRemoved(old, fresh);
+  
+  EXPECT_EQ(result.size(), 2);
+  EXPECT_EQ(result[0], "a");
+  EXPECT_EQ(result[1], "d");
+  
+  // a b c d -> a e f d
+  fresh.clear();
+  result.clear();
+  fresh.push_back("a");
+  fresh.push_back("e");
+  fresh.push_back("f");
+  fresh.push_back("d");
+  
+  
+  result = internal::impl::GetRemoved(old, fresh);
+  
+  EXPECT_EQ(result.size(), 2);
+  EXPECT_EQ(result[0], "b");
+  EXPECT_EQ(result[1], "c");
+}
+  
+
+TEST(TestFavoriteStorePrivate, TestNeedToBeReorderedBasic)
+{
+  std::list<std::string> old;
+  std::list<std::string> fresh;
+  
+  old.push_back("a");
+  old.push_back("b");
+  old.push_back("c");
+  old.push_back("d");
+  
+  // No change.
+  fresh.push_back("a");
+  fresh.push_back("b");
+  fresh.push_back("c");
+  fresh.push_back("d");
+  
+  EXPECT_FALSE(internal::impl::NeedToBeReordered(old, fresh));
+  
+  // Permutation.
+  fresh.clear();
+  fresh.push_back("a");
+  fresh.push_back("c");
+  fresh.push_back("b");
+  fresh.push_back("d");
+  
+  EXPECT_TRUE(internal::impl::NeedToBeReordered(old, fresh));
+  
+  // Empty.
+  fresh.clear();
+  
+  EXPECT_FALSE(internal::impl::NeedToBeReordered(old, fresh));
+}
+ 
+TEST(TestFavoriteStorePrivate, TestNeedToBeReorderedLess)
+{
+  std::list<std::string> old;
+  std::list<std::string> fresh;
+  
+  old.push_back("a");
+  old.push_back("b");
+  old.push_back("c");
+  old.push_back("d");
+   
+  // a b c d -> a b c
+  fresh.clear();
+  fresh.push_back("a");
+  fresh.push_back("b");
+  fresh.push_back("c");
+  
+  EXPECT_FALSE(internal::impl::NeedToBeReordered(old, fresh));
+  
+  // a b c d ->  b c d
+  fresh.clear();
+  fresh.push_back("b");
+  fresh.push_back("c");
+  fresh.push_back("d");
+  
+  EXPECT_FALSE(internal::impl::NeedToBeReordered(old, fresh));
+  
+  // a b c d -> a b d
+  fresh.clear();
+  fresh.push_back("a");
+  fresh.push_back("b");
+  fresh.push_back("d");
+  
+  EXPECT_FALSE(internal::impl::NeedToBeReordered(old, fresh));
+  
+  // a b c d -> a
+  fresh.clear();
+  fresh.push_back("a");
+  
+  EXPECT_FALSE(internal::impl::NeedToBeReordered(old, fresh));
+  
+  // a b c d ->  a d b
+  fresh.clear();
+  fresh.push_back("a");
+  fresh.push_back("d");
+  fresh.push_back("b");
+  
+  EXPECT_TRUE(internal::impl::NeedToBeReordered(old, fresh));
+  
+  // a b c d ->  b a c
+  fresh.clear();
+  fresh.push_back("b");
+  fresh.push_back("a");
+  fresh.push_back("c");
+  
+  EXPECT_TRUE(internal::impl::NeedToBeReordered(old, fresh));
+}
+
+TEST(TestFavoriteStorePrivate, TestNeedToBeReorderedPlus)
+{
+  std::list<std::string> old;
+  std::list<std::string> fresh;
+  
+  old.push_back("a");
+  old.push_back("b");
+  old.push_back("c");
+  old.push_back("d");
+   
+  // All new elements.
+  fresh.clear();
+  fresh.push_back("e");
+  fresh.push_back("f");
+  fresh.push_back("g");
+  fresh.push_back("h");
+  
+  EXPECT_FALSE(internal::impl::NeedToBeReordered(old, fresh));
+  
+  // a b c d -> a b c d e
+  fresh.clear();
+  fresh.push_back("a");
+  fresh.push_back("b");
+  fresh.push_back("c");
+  fresh.push_back("d");
+  fresh.push_back("e");
+  
+  EXPECT_FALSE(internal::impl::NeedToBeReordered(old, fresh));
+  
+  // a b c d -> a b e c d
+  fresh.clear();
+  fresh.push_back("a");
+  fresh.push_back("b");
+  fresh.push_back("e");
+  fresh.push_back("c");
+  fresh.push_back("d");
+  
+  EXPECT_FALSE(internal::impl::NeedToBeReordered(old, fresh));
+  
+  // a b c d -> a b e d c
+  fresh.clear();
+  fresh.push_back("a");
+  fresh.push_back("b");
+  fresh.push_back("e");
+  fresh.push_back("d");
+  fresh.push_back("c");
+  
+  EXPECT_TRUE(internal::impl::NeedToBeReordered(old, fresh));
+  
+  // a b c d -> f a b c d
+  fresh.clear();
+  fresh.push_back("f");
+  fresh.push_back("a");
+  fresh.push_back("b");
+  fresh.push_back("c");
+  fresh.push_back("d");
+  
+  EXPECT_FALSE(internal::impl::NeedToBeReordered(old, fresh));
+}
+
+TEST(TestFavoriteStorePrivate, TestNeedToBeReorderedMixed)
+{
+  std::list<std::string> old;
+  std::list<std::string> fresh;
+  
+  old.push_back("a");
+  old.push_back("b");
+  old.push_back("c");
+  old.push_back("d");
+  
+  // a b c d -> b f c g h
+  fresh.clear();
+  fresh.push_back("b");
+  fresh.push_back("f");
+  fresh.push_back("c");
+  fresh.push_back("g");
+  fresh.push_back("h");
+  
+  EXPECT_FALSE(internal::impl::NeedToBeReordered(old, fresh));
+  
+  
+  // a b c d -> c f b g h
+  fresh.clear();
+  fresh.push_back("c");
+  fresh.push_back("f");
+  fresh.push_back("b");
+  fresh.push_back("g");
+  fresh.push_back("h");
+  
+  EXPECT_TRUE(internal::impl::NeedToBeReordered(old, fresh));
+}
+