← Back to branch summary

~townsend/unity/fix-waiting-to-install

« back to all changes in this revision

Viewing changes to tests/mock-application.h

  • Committer: Chris Townsend
  • Date: 2013-07-17 16:24:40 UTC
  • mfrom: (3379.1.48 trunk)
  • Revision ID: christopher.townsend@canonical.com-20130717162440-zbeyzlbq0kdvnypo
Merge in trunk.

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/mock-application.h
15
15
 * <http://www.gnu.org/licenses/>
16
16
 *
17
17
 * Authored by: Tim Penhey  <tim.penhey@canonical.com>
 
18
 *              Marco Trevisan <marco.trevisan@canonical.com>
18
19
 */
19
20
#ifndef TESTS_MOCK_APPLICATION_H
20
21
#define TESTS_MOCK_APPLICATION_H
21
22
 
22
23
#include <map>
 
24
#include <gmock/gmock.h>
23
25
 
24
26
#include "unity-shared/ApplicationManager.h"
25
27
#include "unity-shared/WindowManager.h"
26
28
 
 
29
using namespace testing;
 
30
 
27
31
namespace testmocks
28
32
{
29
33
struct MockApplicationWindow : unity::ApplicationWindow
30
34
{
 
35
  typedef NiceMock<MockApplicationWindow> Nice;
 
36
 
31
37
  MockApplicationWindow(Window xid)
32
38
    : xid_(xid)
33
39
    , monitor_(0)
40
46
    visible.SetGetterFunction([this] { return visible_; });
41
47
    active.SetGetterFunction([this] { return active_; });
42
48
    urgent.SetGetterFunction([this] { return urgent_; });
 
49
    title.SetGetterFunction([this] { return title_; });
 
50
    icon.SetGetterFunction([this] { return icon_; });
 
51
 
 
52
    ON_CALL(*this, type()).WillByDefault(Invoke([this] { return type_; }));
 
53
    ON_CALL(*this, window_id()).WillByDefault(Invoke([this] { return xid_; }));
 
54
    ON_CALL(*this, monitor()).WillByDefault(Invoke([this] { return monitor_; }));
 
55
    ON_CALL(*this, Focus()).WillByDefault(Invoke([this] { return LocalFocus(); }));
 
56
    ON_CALL(*this, application()).WillByDefault(Invoke([this] { return unity::ApplicationPtr(); }));
43
57
  }
44
58
 
45
59
  Window xid_;
52
66
  bool active_;
53
67
  bool urgent_;
54
68
 
55
 
  virtual std::string title() const { return title_; }
56
 
  virtual std::string icon() const { return icon_; }
57
 
  virtual std::string type() const { return type_; }
58
 
 
59
 
  virtual Window window_id() const { return xid_; }
60
 
  virtual int monitor() const { return monitor_; }
61
 
 
62
 
  virtual unity::ApplicationPtr application() const { return unity::ApplicationPtr(); }
63
 
  virtual bool Focus() const
 
69
  MOCK_CONST_METHOD0(type, std::string());
 
70
  MOCK_CONST_METHOD0(window_id, Window());
 
71
  MOCK_CONST_METHOD0(monitor, int());
 
72
  MOCK_CONST_METHOD0(application, unity::ApplicationPtr());
 
73
  MOCK_CONST_METHOD0(Focus, bool());
 
74
  MOCK_CONST_METHOD0(Quit, void());
 
75
 
 
76
  virtual bool LocalFocus() const
64
77
  {
65
78
    auto& wm = unity::WindowManager::Default();
66
79
    wm.Raise(xid_);
67
80
    wm.Activate(xid_);
68
81
    return true;
69
82
  }
70
 
  virtual void Quit() const {}
 
83
 
 
84
  void SetTitle(std::string const& new_title)
 
85
  {
 
86
    if (new_title == title())
 
87
      return;
 
88
 
 
89
    title_ = new_title;
 
90
    title.changed(title_);
 
91
  }
 
92
 
 
93
  void SetIcon(std::string const& new_icon)
 
94
  {
 
95
    if (new_icon == icon())
 
96
      return;
 
97
 
 
98
    icon_ = new_icon;
 
99
    icon.changed(icon_);
 
100
  }
71
101
};
72
102
 
73
103
struct MockApplication : unity::Application
74
104
{
 
105
  typedef NiceMock<MockApplication> Nice;
 
106
 
 
107
  MockApplication()
 
108
    : MockApplication("")
 
109
  {}
 
110
 
75
111
  MockApplication(std::string const& desktop_file,
76
 
                  std::string const& icon = "",
77
 
                  std::string const& title = "")
 
112
                  std::string const& icon_name = "",
 
113
                  std::string const& title_str = "")
78
114
    : desktop_file_(desktop_file)
79
 
    , icon_(icon)
80
 
    , title_(title)
 
115
    , icon_(icon_name)
 
116
    , title_(title_str)
81
117
    , seen_(false)
82
118
    , sticky_(false)
83
119
    , visible_(false)
86
122
    , urgent_(false)
87
123
    , type_("mock")
88
124
    {
89
 
      seen.SetGetterFunction(sigc::mem_fun(this, &MockApplication::GetSeen));
90
125
      seen.SetSetterFunction(sigc::mem_fun(this, &MockApplication::SetSeen));
91
 
      sticky.SetGetterFunction(sigc::mem_fun(this, &MockApplication::GetSticky));
92
126
      sticky.SetSetterFunction(sigc::mem_fun(this, &MockApplication::SetSticky));
93
 
      visible.SetGetterFunction(sigc::mem_fun(this, &MockApplication::GetVisible));
94
 
      active.SetGetterFunction(sigc::mem_fun(this, &MockApplication::GetActive));
95
 
      running.SetGetterFunction(sigc::mem_fun(this, &MockApplication::GetRunning));
96
 
      urgent.SetGetterFunction(sigc::mem_fun(this, &MockApplication::GetUrgent));
 
127
 
 
128
      seen.SetGetterFunction([this] { return seen_; });
 
129
      sticky.SetGetterFunction([this] { return sticky_; });
 
130
      visible.SetGetterFunction([this] { return visible_; });
 
131
      active.SetGetterFunction([this] { return active_; });
 
132
      running.SetGetterFunction([this] { return running_; });
 
133
      urgent.SetGetterFunction([this] { return urgent_; });
 
134
      title.SetGetterFunction([this] { return title_; });
 
135
      icon.SetGetterFunction([this] { return icon_; });
 
136
 
 
137
      ON_CALL(*this, desktop_file()).WillByDefault(Invoke([this] { return desktop_file_; }));
 
138
      ON_CALL(*this, type()).WillByDefault(Invoke([this] { return type_; }));
 
139
      ON_CALL(*this, repr()).WillByDefault(Invoke([this] { return "MockApplication"; }));
 
140
      ON_CALL(*this, GetWindows()).WillByDefault(Invoke([this] { return windows_; }));
 
141
      ON_CALL(*this, OwnsWindow(_)).WillByDefault(Invoke([this] (Window xid) { return LocalOwnsWindow(xid); }));
97
142
    }
98
143
 
99
144
  std::string desktop_file_;
108
153
  unity::WindowList windows_;
109
154
  std::string type_;
110
155
 
111
 
 
112
 
  virtual std::string icon() const { return icon_; }
113
 
  virtual std::string title() const { return title_; }
114
 
  virtual std::string desktop_file() const { return desktop_file_; }
115
 
  virtual std::string type() const { return type_; }
116
 
  virtual std::string repr() const { return "MockApplication"; }
117
 
 
118
 
  virtual unity::WindowList GetWindows() const { return windows_; }
119
 
  virtual bool OwnsWindow(Window window_id) const {
 
156
  MOCK_CONST_METHOD0(desktop_file, std::string());
 
157
  MOCK_CONST_METHOD0(type, std::string());
 
158
  MOCK_CONST_METHOD0(repr, std::string());
 
159
  MOCK_CONST_METHOD0(GetWindows, unity::WindowList());
 
160
  MOCK_CONST_METHOD1(OwnsWindow, bool(Window));
 
161
  MOCK_CONST_METHOD0(GetSupportedMimeTypes, std::vector<std::string>());
 
162
  MOCK_CONST_METHOD0(GetFocusableWindow, unity::ApplicationWindowPtr());
 
163
  MOCK_CONST_METHOD2(Focus, void(bool, int));
 
164
  MOCK_CONST_METHOD0(Quit, void());
 
165
 
 
166
  bool LocalOwnsWindow(Window window_id) const {
120
167
    auto end = std::end(windows_);
121
168
    return std::find_if(std::begin(windows_), end, [window_id] (unity::ApplicationWindowPtr window) {
122
169
      return window->window_id() == window_id;
123
170
    }) != end;
124
171
  }
125
172
 
126
 
  virtual std::vector<std::string> GetSupportedMimeTypes() const { return {}; }
127
 
 
128
 
  virtual unity::ApplicationWindowPtr GetFocusableWindow() const { return unity::ApplicationWindowPtr(); }
129
 
  virtual void Focus(bool show_on_visible, int monitor) const  {}
130
 
  virtual void Quit() const {}
131
173
  void SetRunState(bool state) {
132
174
    running_ = state;
133
175
    running.changed.emit(state);
134
176
    }
135
177
 
136
 
  bool GetSeen() const { return seen_; }
137
178
  bool SetSeen(bool const& param) {
138
179
    if (param != seen_) {
139
180
      seen_ = param;
142
183
    return false;
143
184
  }
144
185
 
145
 
  bool GetSticky() const { return sticky_; }
146
186
  bool SetSticky(bool const& param) {
147
187
    if (param != sticky_) {
148
188
      sticky_ = param;
159
199
    active.changed.emit(state);
160
200
  }
161
201
 
162
 
  bool GetVisible() const { return visible_; }
163
 
  bool GetActive() const { return active_; }
164
 
  bool GetRunning() const { return running_; }
165
 
  bool GetUrgent() const { return urgent_; }
 
202
  void SetTitle(std::string const& new_title)
 
203
  {
 
204
    if (new_title == title())
 
205
      return;
 
206
 
 
207
    title_ = new_title;
 
208
    title.changed(title_);
 
209
  }
 
210
 
 
211
  void SetIcon(std::string const& new_icon)
 
212
  {
 
213
    if (new_icon == icon())
 
214
      return;
 
215
 
 
216
    icon_ = new_icon;
 
217
    icon.changed(icon_);
 
218
  }
166
219
};
167
220
 
168
 
class MockApplicationManager : public unity::ApplicationManager
 
221
struct MockApplicationManager : public unity::ApplicationManager
169
222
{
170
 
public:
 
223
  typedef NiceMock<MockApplicationManager> Nice;
 
224
 
 
225
  MockApplicationManager()
 
226
  {
 
227
    ON_CALL(*this, GetApplicationForDesktopFile(_)).WillByDefault(Invoke(this, &MockApplicationManager::LocalGetApplicationForDesktopFile));
 
228
    ON_CALL(*this, GetActiveWindow()).WillByDefault(Invoke([this] { return unity::ApplicationWindowPtr(); } ));
 
229
    ON_CALL(*this, GetRunningApplications()).WillByDefault(Invoke([this] { return unity::ApplicationList(); } ));
 
230
    ON_CALL(*this, GetApplicationForWindow(_)).WillByDefault(Invoke([this] (Window) { return unity::ApplicationPtr(); } ));
 
231
  }
 
232
 
171
233
  static void StartApp(std::string const& desktop_file)
172
234
  {
173
 
      // We know the application manager is a mock one so we can cast it.
174
 
      auto self = dynamic_cast<MockApplicationManager&>(unity::ApplicationManager::Default());
175
 
      auto app = self.GetApplicationForDesktopFile(desktop_file);
176
 
      self.application_started.emit(app);
177
 
  }
178
 
 
179
 
  virtual unity::ApplicationWindowPtr GetActiveWindow()
180
 
  {
181
 
      return unity::ApplicationWindowPtr();
182
 
  }
183
 
 
184
 
  unity::ApplicationPtr GetApplicationForDesktopFile(std::string const& desktop_file)
 
235
    // We know the application manager is a mock one so we can cast it.
 
236
    auto& app_manager = unity::ApplicationManager::Default();
 
237
    auto self = dynamic_cast<MockApplicationManager*>(&app_manager);
 
238
    auto app = self->LocalGetApplicationForDesktopFile(desktop_file);
 
239
    app_manager.application_started.emit(app);
 
240
  }
 
241
 
 
242
  MOCK_METHOD0(GetActiveWindow, unity::ApplicationWindowPtr());
 
243
  MOCK_METHOD1(GetApplicationForDesktopFile, unity::ApplicationPtr(std::string const&));
 
244
  MOCK_METHOD0(GetRunningApplications, unity::ApplicationList());
 
245
  MOCK_METHOD1(GetApplicationForWindow, unity::ApplicationPtr(Window));
 
246
 
 
247
  unity::ApplicationPtr LocalGetApplicationForDesktopFile(std::string const& desktop_file)
185
248
  {
186
249
    AppMap::iterator iter = app_map_.find(desktop_file);
187
250
    if (iter == app_map_.end())
188
251
    {
189
 
      unity::ApplicationPtr app(new MockApplication(desktop_file));
 
252
      auto app = std::make_shared<NiceMock<MockApplication>>(desktop_file);
190
253
      app_map_.insert(AppMap::value_type(desktop_file, app));
191
254
      return app;
192
255
    }
196
259
    }
197
260
  }
198
261
 
199
 
  unity::ApplicationList GetRunningApplications()
200
 
  {
201
 
      return unity::ApplicationList();
202
 
  }
203
 
 
204
 
  unity::ApplicationPtr GetApplicationForWindow(Window xid)
205
 
  {
206
 
    return unity::ApplicationPtr();
207
 
  }
208
 
 
209
262
private:
210
263
  typedef std::map<std::string, unity::ApplicationPtr> AppMap;
211
264
  AppMap app_map_;