unittest/src/test_watch_holder.cc

   1 /*
   2  * Copyright (c) 2020 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <glib.h>
  18 #include <gtest/gtest.h>
  19 #include <gmock/gmock.h>
  20
  21 #include <watch_holder.hh>
  22 #include <watch.hh>
  23 #include <aul_mock.h>
  24 #include <appsvc_mock.h>
  25 #include <vconf_mock.h>
  26
  27 using namespace std;
  28 using namespace tizen_base;
  29 using namespace watch_holder;
  30
  31 class WatchHolderStub : public WatchHolder {
  32  public:
  33   WatchHolderStub(Evas_Object* win)
  34     : WatchHolder(win) {
  35   }
  36
  37   void InvokeAmbientChanged(bool enter, Bundle& extra) {
  38     OnAmbientChanged(enter, extra);
  39   }
  40   void InvokeAmbientEvent(EventType ev, string sender,
  41       Bundle extra) {
  42     OnAmbientEvent(ev, sender, extra);
  43   }
  44   void OnAdded(const WatchBase& watch) override {}
  45   void OnUpdated(const WatchBase& watch) override {}
  46   void OnRemoved(const WatchBase& watch) override {}
  47   void OnLaunched(const WatchBase& watch) override {}
  48   void OnDead(const WatchBase& watch) override {}
  49   void OnBound(const WatchBase& watch) override {}
  50
  51   std::shared_ptr<WatchBase> CreateWatch(int rid, std::string id,
  52       std::string appid, bool mock) override {
  53     return WatchHolder::CreateWatch(rid, id, appid, true);
  54   }
  55
  56   std::shared_ptr<WatchBase> CreateWatch(int rid, std::string id,
  57       std::string appid, tizen_base::Bundle extra, bool mock) override {
  58     return WatchHolder::CreateWatch(rid, id, appid, extra, true);
  59   }
  60 };
  61
  62 static int (*__app_com_cb)(const char *endpoint, aul_app_com_result_e result, bundle *envelope, void *user_data);
  63 static Bundle b;
  64 static string global_end;
  65 aul_app_com_connection_h *global_conn;
  66
  67 static int __aul_app_get_appid_bypid_fake(int pid, char* appid, int len) {
  68   snprintf(appid, len, "%s", "org.tizen.watch");
  69   return 0;
  70 }
  71
  72 static int __aul_app_com_create_fake(const char* end, aul_app_com_permission_h permission,
  73     app_com_cb cb, void* user_data, aul_app_com_connection_h* conn) {
  74   *conn = *global_conn;
  75   b = Bundle();
  76   b.Add("__AUL_APPID__", "org.tizen.watch");
  77   b.Add("__AUL_PID__", "111");
  78   b.Add("__AUL_IS_FAULT__", "is_fault");
  79   b.Add("__AUL_WIDGET_VIEWER__", "org.tizen.watch");
  80   b.Add("__AMBIENT_MODE__", "100");
  81   b.Add("__APP_AMBIENT_EVENT__", "0");
  82   b.Add("__APP_AMBIENT_SENDER__", "sender");
  83
  84   if(strcmp(end, global_end.c_str()) == 0)
  85      __app_com_cb = cb;
  86   return 0;
  87 }
  88
  89 static int __aul_app_com_leave_fake(aul_app_com_connection_h conn) {
  90   return 0;
  91 }
  92
  93 static int __appsvc_run_service_fake(bundle* b, int r, appsvc_res_fn cb, void* data) {
  94   return 0;
  95 }
  96
  97 class WatchHolderTest : public ::testing::Test {
  98  public:
  99   WatchHolderStub* stub;
 100
 101   virtual void SetUp() {
 102     aul_app_com_create_fake.custom_fake = __aul_app_com_create_fake;
 103     aul_app_com_leave_fake.custom_fake = __aul_app_com_leave_fake;
 104     aul_app_get_appid_bypid_fake.custom_fake = __aul_app_get_appid_bypid_fake;
 105     global_conn = (aul_app_com_connection_h*)malloc(sizeof(aul_app_com_connection_h));
 106
 107     Evas_Object* win = elm_win_add(NULL, "Watch Holder", ELM_WIN_BASIC);
 108     stub = new WatchHolderStub(win);
 109   }
 110   virtual void TearDown() {
 111     free(global_conn);
 112     delete stub;
 113   }
 114 };
 115
 116 TEST_F(WatchHolderTest, CreateInstance) {
 117   EXPECT_NE(WatchHolderTest::stub, nullptr);
 118 }
 119
 120 TEST_F(WatchHolderTest, CreateWatch) {
 121   std::shared_ptr<WatchBase> w =
 122     WatchHolderTest::stub->CreateWatch(1, string("id"), string("appid"), true);
 123   EXPECT_NE(w, nullptr);
 124
 125   Bundle b;
 126   b.Add("__APP_AMBIENT_EVENT__", "1");
 127   std::shared_ptr<WatchBase> w2 =
 128     WatchHolderTest::stub->CreateWatch(1, string("id"),
 129         string("appid"), b, true);
 130   EXPECT_NE(w2, nullptr);
 131 }
 132
 133 TEST_F(WatchHolderTest, LaunchWatch) {
 134   appsvc_run_service_fake.custom_fake = __appsvc_run_service_fake;
 135   string appid("org.tizen.watch");
 136   int ret;
 137
 138   ret = WatchHolderTest::stub->Launch(appid, false, nullptr);
 139   EXPECT_NE(ret, -1);
 140 }
 141
 142 TEST_F(WatchHolderTest, GetStack) {
 143   std::list<std::shared_ptr<WatchBase>> list;
 144   list = WatchHolderTest::stub->GetStack();
 145   EXPECT_EQ(list.size(), 0);
 146 }
 147
 148 TEST_F(WatchHolderTest, GetCurrent_N) {
 149   EXPECT_EQ(WatchHolderTest::stub->GetCurrent(), nullptr);
 150   global_end = "watch.launch";
 151 }
 152
 153 TEST_F(WatchHolderTest, OnLaunchSignal) {
 154   EXPECT_NE(WatchHolderTest::stub, nullptr);
 155   int ret;
 156   string appid("org.tizen.watch");
 157   ret = WatchHolderTest::stub->Launch(appid, false, b.GetHandle());
 158   EXPECT_NE(ret, -1);
 159   __app_com_cb("end", AUL_APP_COM_R_OK, b.GetHandle(), stub);
 160
 161   ret = WatchHolderTest::stub->Launch(appid, false, nullptr);
 162   EXPECT_NE(ret, -1);
 163   __app_com_cb("end", AUL_APP_COM_R_OK, b.GetHandle(), stub);
 164   global_end = "watch.dead";
 165 }
 166
 167 TEST_F(WatchHolderTest, OnDeadSignal) {
 168   EXPECT_NE(WatchHolderTest::stub, nullptr);
 169   __app_com_cb("end", AUL_APP_COM_R_OK, b.GetHandle(), stub);
 170   global_end = "watch.ambientchange";
 171 }
 172
 173 TEST_F(WatchHolderTest, OnAmbientChangedSignal) {
 174   EXPECT_NE(WatchHolderTest::stub, nullptr);
 175   __app_com_cb("end", AUL_APP_COM_R_OK, b.GetHandle(), stub);
 176   global_end = "aod.ambientevent";
 177 }
 178
 179 TEST_F(WatchHolderTest, OnReceiveSignal) {
 180   EXPECT_NE(WatchHolderTest::stub, nullptr);
 181   __app_com_cb("end", AUL_APP_COM_R_OK, b.GetHandle(), stub);
 182 }
 183
 184 TEST_F(WatchHolderTest, OnAmbientChanged) {
 185   Bundle *b = nullptr;
 186   EXPECT_NE(WatchHolderTest::stub, nullptr);
 187   WatchHolderTest::stub->InvokeAmbientChanged(true, *b);
 188 }
 189
 190 TEST_F(WatchHolderTest, OnAmbientEvent) {
 191   Bundle b;
 192   b.Add("__APP_AMBIENT_EVENT__", "1");
 193   EXPECT_NE(WatchHolderTest::stub, nullptr);
 194   WatchHolderTest::stub->InvokeAmbientEvent(AmbientListener::EVENT_AOD_READY, string("sender"), b);
 195 }