← Back to branch summary

~3v1n0/unity/scale-window-cast-protection

« back to all changes in this revision

Viewing changes to tests/test_application_launcher_icon.cpp

Merge with trunk

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/test_application_launcher_icon.cpp
26
26
 
27
27
#include "ApplicationLauncherIcon.h"
28
28
#include "FavoriteStore.h"
29
 
#include "StandaloneWindowManager.h"
 
29
#include "UBusWrapper.h"
 
30
#include "UBusMessages.h"
30
31
#include "ZeitgeistUtils.h"
31
32
#include "mock-application.h"
32
33
#include "test_utils.h"
 
34
#include "test_standalone_wm.h"
33
35
 
34
36
using namespace testing;
35
37
using namespace testmocks;
63
65
  MOCK_CONST_METHOD0(GetRemoteMenus, glib::Object<DbusmenuMenuitem>());
64
66
 
65
67
  bool LauncherIconIsSticky() const { return LauncherIcon::IsSticky(); }
 
68
  void LocalActivate(ActionArg a) { ApplicationLauncherIcon::ActivateLauncherIcon(a); }
66
69
 
67
70
  using ApplicationLauncherIcon::IsFileManager;
68
71
  using ApplicationLauncherIcon::LogUnityEvent;
69
72
  using ApplicationLauncherIcon::Remove;
 
73
  using ApplicationLauncherIcon::SetApplication;
 
74
  using ApplicationLauncherIcon::GetApplication;
70
75
};
71
76
 
72
77
MATCHER_P(AreArgsEqual, a, "")
82
87
{
83
88
  virtual void SetUp() override
84
89
  {
85
 
    WM = dynamic_cast<StandaloneWindowManager*>(&WindowManager::Default());
86
 
 
87
90
    usc_app = std::make_shared<MockApplication::Nice>(USC_DESKTOP, "softwarecenter");
88
91
    usc_icon = new NiceMock<MockApplicationLauncherIcon>(usc_app);
89
92
    ASSERT_EQ(usc_icon->DesktopFile(), USC_DESKTOP);
97
100
    ASSERT_TRUE(mock_icon->DesktopFile().empty());
98
101
  }
99
102
 
100
 
  virtual void TearDown() override
101
 
  {
102
 
    for (auto const& win : WM->GetStandaloneWindows())
103
 
      WM->Close(win->Xid());
104
 
  }
105
 
 
106
103
  void AddMockWindow(Window xid, int monitor, int desktop)
107
104
  {
108
105
    auto app_window = std::make_shared<MockApplicationWindow::Nice>(xid);
146
143
    return HasMenuItemWithLabel(icon->Menus(), label);
147
144
  }
148
145
 
149
 
  StandaloneWindowManager* WM;
 
146
  void VerifySignalsDisconnection(MockApplication::Ptr const& app)
 
147
  {
 
148
    EXPECT_TRUE(app->closed.empty());
 
149
    EXPECT_TRUE(app->window_opened.empty());
 
150
    EXPECT_TRUE(app->window_moved.empty());
 
151
    EXPECT_TRUE(app->window_closed.empty());
 
152
    EXPECT_TRUE(app->visible.changed.empty());
 
153
    EXPECT_TRUE(app->active.changed.empty());
 
154
    EXPECT_TRUE(app->running.changed.empty());
 
155
    EXPECT_TRUE(app->urgent.changed.empty());
 
156
    EXPECT_TRUE(app->desktop_file.changed.empty());
 
157
    EXPECT_TRUE(app->title.changed.empty());
 
158
    EXPECT_TRUE(app->icon.changed.empty());
 
159
  }
 
160
 
 
161
  testwrapper::StandaloneWM WM;
150
162
  MockApplication::Ptr usc_app;
151
163
  MockApplication::Ptr empty_app;
152
164
  MockApplication::Ptr mock_app;
163
175
    EXPECT_FALSE(app->closed.empty());
164
176
  }
165
177
 
166
 
  EXPECT_TRUE(app->closed.empty());
 
178
  VerifySignalsDisconnection(app);
167
179
}
168
180
 
169
181
TEST_F(TestApplicationLauncherIcon, Position)
200
212
  EXPECT_TRUE(usc_icon->IsVisible());
201
213
  EXPECT_FALSE(saved);
202
214
 
 
215
  EXPECT_CALL(*unity_app_, LogEvent(ApplicationEventType::ACCESS, _)).Times(1);
203
216
  usc_icon->Stick(true);
204
 
  EXPECT_FALSE(saved);
 
217
  EXPECT_TRUE(saved);
205
218
}
206
219
 
207
220
TEST_F(TestApplicationLauncherIcon, StickDesktopLessApp)
1109
1122
  usc_icon->Remove();
1110
1123
}
1111
1124
 
1112
 
}
 
1125
TEST_F(TestApplicationLauncherIcon, ClosesOverlayOnActivation)
 
1126
{
 
1127
  bool closes_overlay = false;
 
1128
  UBusManager manager;
 
1129
  manager.RegisterInterest(UBUS_OVERLAY_CLOSE_REQUEST, [&closes_overlay] (GVariant* v) {
 
1130
    ASSERT_THAT(v, IsNull());
 
1131
    closes_overlay = true;
 
1132
  });
 
1133
 
 
1134
  // XXX: we should abstract the application activation into application::Manager
 
1135
  ON_CALL(*mock_icon, ActivateLauncherIcon(_)).WillByDefault(Invoke([this] (ActionArg a) { mock_icon->LocalActivate(a); }));
 
1136
  mock_icon->Activate(ActionArg());
 
1137
  Utils::WaitUntil(closes_overlay);
 
1138
 
 
1139
  EXPECT_TRUE(closes_overlay);
 
1140
}
 
1141
 
 
1142
TEST_F(TestApplicationLauncherIcon, RemovedPropertyOnRemove)
 
1143
{
 
1144
  ASSERT_FALSE(mock_icon->removed);
 
1145
  mock_icon->Remove();
 
1146
  EXPECT_TRUE(mock_icon->removed);
 
1147
}
 
1148
 
 
1149
TEST_F(TestApplicationLauncherIcon, RemoveDisconnectsSignals)
 
1150
{
 
1151
  ASSERT_FALSE(mock_app->closed.empty());
 
1152
  mock_icon->Remove();
 
1153
  VerifySignalsDisconnection(mock_app);
 
1154
}
 
1155
 
 
1156
TEST_F(TestApplicationLauncherIcon, RemoveUnsetsAppParameters)
 
1157
{
 
1158
  usc_icon->Stick();
 
1159
  ASSERT_TRUE(usc_app->seen);
 
1160
  ASSERT_TRUE(usc_app->sticky);
 
1161
 
 
1162
  usc_icon->Remove();
 
1163
  EXPECT_FALSE(usc_app->seen);
 
1164
  EXPECT_FALSE(usc_app->sticky);
 
1165
}
 
1166
 
 
1167
TEST_F(TestApplicationLauncherIcon, DestructionUnsetsAppParameters)
 
1168
{
 
1169
  usc_icon->Stick();
 
1170
  ASSERT_TRUE(usc_app->seen);
 
1171
  ASSERT_TRUE(usc_app->sticky);
 
1172
 
 
1173
  usc_icon = nullptr;
 
1174
  EXPECT_FALSE(usc_app->seen);
 
1175
  EXPECT_FALSE(usc_app->sticky);
 
1176
}
 
1177
 
 
1178
TEST_F(TestApplicationLauncherIcon, DestructionDontUnsetsAppSeenIfRemoved)
 
1179
{
 
1180
  ASSERT_TRUE(mock_app->seen);
 
1181
 
 
1182
  mock_icon->Remove();
 
1183
  ASSERT_FALSE(mock_app->seen);
 
1184
 
 
1185
  mock_app->seen = true;
 
1186
  mock_icon = nullptr;
 
1187
 
 
1188
  EXPECT_TRUE(mock_app->seen);
 
1189
}
 
1190
 
 
1191
TEST_F(TestApplicationLauncherIcon, DestructionDontUnsetsAppSeenIfReplaced)
 
1192
{
 
1193
  ASSERT_TRUE(mock_app->seen);
 
1194
 
 
1195
  mock_icon->Remove();
 
1196
  ASSERT_FALSE(mock_app->seen);
 
1197
 
 
1198
  MockApplicationLauncherIcon::Ptr new_icon(new NiceMock<MockApplicationLauncherIcon>(mock_app));
 
1199
  mock_icon = nullptr;
 
1200
 
 
1201
  EXPECT_TRUE(mock_app->seen);
 
1202
}
 
1203
 
 
1204
TEST_F(TestApplicationLauncherIcon, SetApplicationEqual)
 
1205
{
 
1206
  ASSERT_TRUE(usc_app->seen);
 
1207
  usc_icon->SetApplication(usc_app);
 
1208
  EXPECT_EQ(usc_app, usc_icon->GetApplication());
 
1209
  EXPECT_TRUE(usc_app->seen);
 
1210
  EXPECT_FALSE(usc_icon->removed);
 
1211
}
 
1212
 
 
1213
TEST_F(TestApplicationLauncherIcon, SetApplicationNull)
 
1214
{
 
1215
  usc_icon->Stick();
 
1216
  ASSERT_TRUE(usc_app->seen);
 
1217
  ASSERT_TRUE(usc_app->sticky);
 
1218
 
 
1219
  usc_icon->SetApplication(nullptr);
 
1220
 
 
1221
  EXPECT_EQ(usc_app, usc_icon->GetApplication());
 
1222
  EXPECT_FALSE(usc_app->seen);
 
1223
  EXPECT_FALSE(usc_app->sticky);
 
1224
  EXPECT_TRUE(usc_icon->removed);
 
1225
  VerifySignalsDisconnection(usc_app);
 
1226
}
 
1227
 
 
1228
TEST_F(TestApplicationLauncherIcon, SetApplicationNewUpdatesApp)
 
1229
{
 
1230
  usc_icon->Stick();
 
1231
  ASSERT_TRUE(usc_app->seen);
 
1232
  ASSERT_TRUE(usc_app->sticky);
 
1233
  ASSERT_TRUE(usc_icon->IsSticky());
 
1234
 
 
1235
  auto new_app = std::make_shared<MockApplication::Nice>(UM_DESKTOP);
 
1236
  ASSERT_FALSE(new_app->seen);
 
1237
  ASSERT_FALSE(new_app->sticky);
 
1238
 
 
1239
  usc_icon->SetApplication(new_app);
 
1240
 
 
1241
  EXPECT_EQ(new_app, usc_icon->GetApplication());
 
1242
  EXPECT_FALSE(usc_app->seen);
 
1243
  EXPECT_FALSE(usc_app->sticky);
 
1244
  EXPECT_FALSE(usc_icon->removed);
 
1245
  VerifySignalsDisconnection(usc_app);
 
1246
 
 
1247
  EXPECT_TRUE(new_app->seen);
 
1248
  EXPECT_TRUE(new_app->sticky);
 
1249
  EXPECT_TRUE(usc_icon->IsSticky());
 
1250
}
 
1251
 
 
1252
TEST_F(TestApplicationLauncherIcon, SetApplicationNewUpdatesFlags)
 
1253
{
 
1254
  auto new_app = std::make_shared<MockApplication::Nice>(UM_DESKTOP, "um_icon", "um_title");
 
1255
  new_app->active_ = true;
 
1256
  new_app->visible_ = true;
 
1257
  new_app->running_ = true;
 
1258
 
 
1259
  // This is needed to really make the new_app active
 
1260
  auto win = std::make_shared<MockApplicationWindow::Nice>(g_random_int());
 
1261
  new_app->windows_ = { win };
 
1262
  WM->AddStandaloneWindow(std::make_shared<StandaloneWindow>(win->window_id()));
 
1263
 
 
1264
  ASSERT_NE(usc_app->title(), new_app->title());
 
1265
  ASSERT_NE(usc_app->icon(), new_app->icon());
 
1266
  ASSERT_NE(usc_app->visible(), new_app->visible());
 
1267
  ASSERT_NE(usc_app->active(), new_app->active());
 
1268
  ASSERT_NE(usc_app->running(), new_app->running());
 
1269
  ASSERT_NE(usc_app->desktop_file(), new_app->desktop_file());
 
1270
 
 
1271
  usc_icon->SetApplication(new_app);
 
1272
 
 
1273
  EXPECT_EQ(new_app->title(), usc_icon->tooltip_text());
 
1274
  EXPECT_EQ(new_app->icon(), usc_icon->icon_name());
 
1275
  EXPECT_EQ(new_app->visible(), usc_icon->IsVisible());
 
1276
  EXPECT_EQ(new_app->active(), usc_icon->IsActive());
 
1277
  EXPECT_EQ(new_app->running(), usc_icon->IsRunning());
 
1278
  EXPECT_EQ(new_app->desktop_file(), usc_icon->DesktopFile());
 
1279
}
 
1280
 
 
1281
TEST_F(TestApplicationLauncherIcon, SetApplicationEmitsChangedSignalsInOrder)
 
1282
{
 
1283
  auto new_app = std::make_shared<MockApplication::Nice>(UM_DESKTOP, "um_icon", "um_title");
 
1284
  new_app->active_ = true;
 
1285
  new_app->visible_ = true;
 
1286
  new_app->running_ = true;
 
1287
 
 
1288
  struct SignalsHandler
 
1289
  {
 
1290
    MOCK_METHOD1(TitleUpdated, void(std::string const&));
 
1291
    MOCK_METHOD1(IconUpdated, void(std::string const&));
 
1292
    MOCK_METHOD1(DesktopUpdated, void(std::string const&));
 
1293
    MOCK_METHOD1(ActiveUpdated, void(bool));
 
1294
    MOCK_METHOD1(VisibleUpdated, void(bool));
 
1295
    MOCK_METHOD1(RunningUpdated, void(bool));
 
1296
  };
 
1297
 
 
1298
  SignalsHandler handler;
 
1299
  new_app->title.changed.connect(sigc::mem_fun(handler, &SignalsHandler::TitleUpdated));
 
1300
  new_app->icon.changed.connect(sigc::mem_fun(handler, &SignalsHandler::IconUpdated));
 
1301
  new_app->visible.changed.connect(sigc::mem_fun(handler, &SignalsHandler::VisibleUpdated));
 
1302
  new_app->active.changed.connect(sigc::mem_fun(handler, &SignalsHandler::ActiveUpdated));
 
1303
  new_app->running.changed.connect(sigc::mem_fun(handler, &SignalsHandler::RunningUpdated));
 
1304
  new_app->desktop_file.changed.connect(sigc::mem_fun(handler, &SignalsHandler::DesktopUpdated));
 
1305
 
 
1306
  // The desktop file must be updated as last item!
 
1307
  ExpectationSet unordered_calls;
 
1308
  unordered_calls += EXPECT_CALL(handler, TitleUpdated(new_app->title()));
 
1309
  unordered_calls += EXPECT_CALL(handler, IconUpdated(new_app->icon()));
 
1310
  unordered_calls += EXPECT_CALL(handler, VisibleUpdated(new_app->visible()));
 
1311
  unordered_calls += EXPECT_CALL(handler, ActiveUpdated(new_app->active()));
 
1312
  unordered_calls += EXPECT_CALL(handler, RunningUpdated(new_app->running()));
 
1313
  EXPECT_CALL(handler, DesktopUpdated(new_app->desktop_file())).After(unordered_calls);
 
1314
 
 
1315
  usc_icon->SetApplication(new_app);
 
1316
}
 
1317
 
 
1318
} // anonymous namespace