Improves coverage for watch_holder

Change-Id: I3d8d0f40710e8ce31af173ef55958cfea80519a3
Signed-off-by: Inkyun Kil <inkyun.kil@samsung.com>

diff --git a/unittest/mock/evas_mock.h b/unittest/mock/evas_mock.h
index 603998f..9086375 100644 (file)
--- a/unittest/mock/evas_mock.h
+++ b/unittest/mock/evas_mock.h
@@ -29,7 +29,11 @@ extern "C" {
 DECLARE_FAKE_VALUE_FUNC(Evas_Object *, elm_win_add, Evas_Object *,
                const char *, Elm_Win_Type);
 
+DECLARE_FAKE_VALUE_FUNC(int, elm_win_aux_hint_add, Evas_Object *, const char *,
+               const char *);
+
 DECLARE_FAKE_VALUE_FUNC(Evas_Object *, elm_layout_add, Evas_Object *);
+DECLARE_FAKE_VALUE_FUNC(Evas *, evas_object_evas_get, const Eo *);
 
 DECLARE_FAKE_VALUE_FUNC(Eina_Bool, elm_layout_file_set, Eo *, const char *,
                const char *);
@@ -46,6 +50,11 @@ DECLARE_FAKE_VOID_FUNC(evas_object_event_callback_add, Evas_Object *,
 DECLARE_FAKE_VOID_FUNC(elm_object_signal_callback_add, Evas_Object *,
                const char *, const char *, Edje_Signal_Cb, void *);
 
+DECLARE_FAKE_VOID_FUNC(evas_object_smart_callback_add, Evas_Object *,
+               const char *, Evas_Smart_Cb, const void *);
+DECLARE_FAKE_VALUE_FUNC(void *, evas_object_smart_callback_del, Evas_Object *,
+               const char *, Evas_Smart_Cb);
+
 DECLARE_FAKE_VOID_FUNC(elm_object_part_content_set, Evas_Object *, const char *,
                Evas_Object *);
 
@@ -63,6 +72,15 @@ DECLARE_FAKE_VALUE_FUNC(int, tbm_surface_map, tbm_surface_h,
     int, tbm_surface_info_s *);
 DECLARE_FAKE_VALUE_FUNC(int, tbm_surface_unmap, tbm_surface_h);
 
+DECLARE_FAKE_VALUE_FUNC(Ecore_Evas*, ecore_evas_ecore_evas_get, const Evas*);
+DECLARE_FAKE_VALUE_FUNC(Ecore_Wl2_Window*, ecore_evas_wayland2_window_get,
+                        const Ecore_Evas*);
+
+DECLARE_FAKE_VALUE_FUNC(const char*, elm_win_aux_msg_key_get,
+                        Evas_Object*, Elm_Win_Aux_Message*);
+DECLARE_FAKE_VALUE_FUNC(const char*, elm_win_aux_msg_val_get,
+                        Evas_Object*, Elm_Win_Aux_Message*);
+
 #ifdef __cplusplus
 }
 #endif

diff --git a/unittest/mock/mock.cc b/unittest/mock/mock.cc
index 8693789..10b321b 100644 (file)
--- a/unittest/mock/mock.cc
+++ b/unittest/mock/mock.cc
@@ -36,6 +36,9 @@ DEFINE_FAKE_VALUE_FUNC(int, cynara_creds_gdbus_get_user, GDBusConnection*,
 /* evas */
 DEFINE_FAKE_VALUE_FUNC(Evas_Object *, elm_win_add, Evas_Object *,
                const char *, Elm_Win_Type);
+DEFINE_FAKE_VALUE_FUNC(int, elm_win_aux_hint_add, Evas_Object *, const char *,
+               const char *);
+DEFINE_FAKE_VALUE_FUNC(Evas *, evas_object_evas_get, const Eo *);
 DEFINE_FAKE_VALUE_FUNC(Evas_Object *, elm_layout_add, Evas_Object *);
 DEFINE_FAKE_VALUE_FUNC(Eina_Bool, elm_layout_file_set, Eo *, const char *,
                const char *);
@@ -47,6 +50,10 @@ DEFINE_FAKE_VOID_FUNC(evas_object_event_callback_add, Evas_Object *,
                Evas_Callback_Type, Evas_Object_Event_Cb, const void *);
 DEFINE_FAKE_VOID_FUNC(elm_object_signal_callback_add, Evas_Object *,
                const char *, const char *, Edje_Signal_Cb, void *);
+DEFINE_FAKE_VOID_FUNC(evas_object_smart_callback_add, Evas_Object *,
+               const char *, Evas_Smart_Cb, const void *);
+DEFINE_FAKE_VALUE_FUNC(void *, evas_object_smart_callback_del, Evas_Object *,
+               const char *, Evas_Smart_Cb);
 DEFINE_FAKE_VOID_FUNC(elm_object_part_content_set, Evas_Object *, const char *,
                Evas_Object *);
 DEFINE_FAKE_VALUE_FUNC(Evas_Object *, elm_object_part_content_get,
@@ -60,6 +67,13 @@ DEFINE_FAKE_VALUE_FUNC(Evas_Native_Surface *,
 DEFINE_FAKE_VALUE_FUNC(int, tbm_surface_map, tbm_surface_h,
     int, tbm_surface_info_s *);
 DEFINE_FAKE_VALUE_FUNC(int, tbm_surface_unmap, tbm_surface_h);
+DEFINE_FAKE_VALUE_FUNC(Ecore_Evas*, ecore_evas_ecore_evas_get, const Evas*);
+DEFINE_FAKE_VALUE_FUNC(Ecore_Wl2_Window*, ecore_evas_wayland2_window_get,
+                        const Ecore_Evas*);
+DEFINE_FAKE_VALUE_FUNC(const char*, elm_win_aux_msg_key_get,
+                        Evas_Object*, Elm_Win_Aux_Message*);
+DEFINE_FAKE_VALUE_FUNC(const char*, elm_win_aux_msg_val_get,
+                        Evas_Object*, Elm_Win_Aux_Message*);
 
 /* aul */
 DEFINE_FAKE_VALUE_FUNC(int, aul_app_get_appid_bypid, int, char *, int);

diff --git a/unittest/src/test_watch.cc b/unittest/src/test_watch.cc
index 4da4ed5..771514f 100644 (file)
--- a/unittest/src/test_watch.cc
+++ b/unittest/src/test_watch.cc
@@ -21,10 +21,48 @@
 #include <watch.hh>
 #include <watch_mirror.hh>
 
+#include <evas_mock.h>
+
 using namespace std;
 using namespace tizen_base;
 using namespace watch_holder;
 
+gchar __not_null;
+
+Ecore_Evas* __ecore_evas_ecore_evas_get_fake(const Evas* obj) {
+  return nullptr;
+}
+
+Ecore_Wl2_Window* __ecore_evas_wayland2_window_get_fake(const Ecore_Evas* obj) {
+  return nullptr;
+}
+
+int __elm_win_aux_hint_add_fake(Evas_Object* obj, const char* h, const char* v) {
+  return 0;
+}
+
+void __evas_object_smart_callback_add_fake(Evas_Object* obj, const char* event,
+  Evas_Smart_Cb func, const void* data) {
+  func((void*)data, nullptr, nullptr);
+}
+
+void* __evas_object_smart_callback_del_fake(Evas_Object* obj, const char* event,
+  Evas_Smart_Cb func) {
+  return nullptr;
+}
+
+Evas* __evas_object_evas_get_fake(const Eo *obj) {
+  return nullptr;
+}
+
+const char* __elm_win_aux_msg_key_get_fake(Evas_Object* obj, Elm_Win_Aux_Message *msg) {
+  return "tz_remote_surface_mng";
+}
+
+const char* __elm_win_aux_msg_val_get_fake(Evas_Object* obj, Elm_Win_Aux_Message *msg) {
+  return "prebind";
+}
+
 class WatchMirrorStub : public WatchMirror {
  public:
   WatchMirrorStub(Evas_Object* win)
@@ -51,6 +89,28 @@ class WatchStub : public Watch{
   WatchStub(int rid, std::string id, string appid, Evas_Object* win, tizen_base::Bundle extra, WatchMirrorStub* listener)
     : Watch(rid, id, appid, win, extra, listener, true) {
   }
+
+  void InvokeEvasAdded() {
+    screen_connector::EvasObject eo(reinterpret_cast<Evas_Object*>(&__not_null),
+        false);
+    OnEvasAdded("TestAppId", "TestInstId", 99, eo);
+  }
+
+  void InvokeEvasRemoved() {
+    screen_connector::EvasObject eo(reinterpret_cast<Evas_Object*>(&__not_null),
+        false);
+    OnEvasRemoved("TestAppId", "TestInstId", 99, eo);
+  }
+
+  void InvokeEvasChanged() {
+    screen_connector::EvasObject eo(reinterpret_cast<Evas_Object*>(&__not_null),
+        false);
+    OnEvasChanged("TestAppId", "TestInstId", 99, eo);
+  }
+
+  void InvokeSetFaulted(bool faulted) {
+    SetFaulted(faulted);
+  }
 };
 
 class WatchTest : public ::testing::Test {
@@ -77,6 +137,7 @@ TEST_F(WatchTest, CreateInstance) {
 TEST_F(WatchTest, CreateInstance2) {
   Evas_Object* mirwin = elm_win_add(NULL, "Watch Mirror", ELM_WIN_BASIC);
   WatchMirrorStub* mirrorstub = new WatchMirrorStub(mirwin);
+  EXPECT_NE(mirrorstub, nullptr);
   Evas_Object* win = elm_win_add(NULL, "Watch", ELM_WIN_BASIC);
   WatchStub* stub = new WatchStub(0, string("id"), string("test"), win, mirrorstub);
   EXPECT_NE(stub, nullptr);
@@ -90,6 +151,7 @@ TEST_F(WatchTest, CreateInstance3) {
   b.Add("__APP_AMBIENT_SENDER__", "test");
   Evas_Object* mirwin = elm_win_add(NULL, "Watch Mirror", ELM_WIN_BASIC);
   WatchMirrorStub* mirrorstub = new WatchMirrorStub(mirwin);
+  EXPECT_NE(mirrorstub, nullptr);
   Evas_Object* win = elm_win_add(NULL, "Watch", ELM_WIN_BASIC);
   WatchStub* stub = new WatchStub(string("test"), win, b, mirrorstub);
   EXPECT_NE(stub, nullptr);
@@ -103,6 +165,7 @@ TEST_F(WatchTest, CreateInstance4) {
   b.Add("__APP_AMBIENT_SENDER__", "test");
   Evas_Object* mirwin = elm_win_add(NULL, "Watch Mirror", ELM_WIN_BASIC);
   WatchMirrorStub* mirrorstub = new WatchMirrorStub(mirwin);
+  EXPECT_NE(mirrorstub, nullptr);
   Evas_Object* win = elm_win_add(NULL, "Watch", ELM_WIN_BASIC);
   WatchStub* stub = new WatchStub(0, string("id"), string("test"), win, b,mirrorstub);
   EXPECT_NE(stub, nullptr);
@@ -110,30 +173,90 @@ TEST_F(WatchTest, CreateInstance4) {
   delete mirrorstub;
 }
 
-TEST_F(WatchTest, Terminate) {
-  WatchTest::stub->Terminate();
+TEST_F(WatchTest, Terminate_N) {
+  int ret;
+  ret = WatchTest::stub->Terminate();
+  EXPECT_NE(ret, 0);
 }
 
 TEST_F(WatchTest, GetPid) {
-  WatchTest::stub->GetPid();
+  int ret;
+  ret = WatchTest::stub->GetPid();
+  EXPECT_EQ(ret, 0);
 }
 
 TEST_F(WatchTest, IsBound) {
-  WatchTest::stub->IsBound();
+  bool is_bound;
+  is_bound = WatchTest::stub->IsBound();
+  EXPECT_EQ(is_bound, false);
 }
 
 TEST_F(WatchTest, GetAppId) {
-  WatchTest::stub->GetAppId();
+  string appid;
+  appid = WatchTest::stub->GetAppId();
+  EXPECT_EQ(appid, "test");
 }
 
-TEST_F(WatchTest, GetCurrentImage) {
-  WatchTest::stub->GetCurrentImage();
+TEST_F(WatchTest, GetCurrentImage_N) {
+  Evas_Object* cur;
+  cur = WatchTest::stub->GetCurrentImage();
+  EXPECT_EQ(cur, nullptr);
 }
 
 TEST_F(WatchTest, GetExtra) {
-  WatchTest::stub->GetExtra();
+  Bundle b;
+  b = WatchTest::stub->GetExtra();
+  EXPECT_EQ(b.GetCount(), 0);
 }
 
 TEST_F(WatchTest, IsFaulted) {
-  WatchTest::stub->IsFaulted();
+  bool is_faulted;
+  is_faulted = WatchTest::stub->IsFaulted();
+  EXPECT_EQ(is_faulted, false);
+}
+
+TEST_F(WatchTest, SetFaulted) {
+  bool is_faulted;
+  WatchTest::stub->InvokeSetFaulted(true);
+  is_faulted = WatchTest::stub->IsFaulted();
+  EXPECT_EQ(is_faulted, true);
+}
+
+TEST_F(WatchTest, BlockUpdate) {
+  EXPECT_NE(WatchTest::stub, nullptr);
+  WatchTest::stub->BlockUpdate(true);
+}
+
+TEST_F(WatchTest, NotifyChangedEvent_N) {
+  EXPECT_EQ(-1, WatchTest::stub->NotifyChangedEvent());
+}
+
+TEST_F(WatchTest, Bind) {
+  ecore_evas_ecore_evas_get_fake.custom_fake = __ecore_evas_ecore_evas_get_fake;
+  ecore_evas_wayland2_window_get_fake.custom_fake = __ecore_evas_wayland2_window_get_fake;
+  elm_win_aux_hint_add_fake.custom_fake = __elm_win_aux_hint_add_fake;
+  evas_object_smart_callback_add_fake.custom_fake = __evas_object_smart_callback_add_fake;
+  evas_object_smart_callback_del_fake.custom_fake = __evas_object_smart_callback_del_fake;
+  evas_object_evas_get_fake.custom_fake = __evas_object_evas_get_fake;
+  elm_win_aux_msg_key_get_fake.custom_fake = __elm_win_aux_msg_key_get_fake;
+  elm_win_aux_msg_val_get_fake.custom_fake = __elm_win_aux_msg_val_get_fake;
+
+  Evas_Object* bindwin = elm_win_add(NULL, "Bind Window", ELM_WIN_BASIC);
+  EXPECT_NE(WatchTest::stub, nullptr);
+  WatchTest::stub->Bind(bindwin);
+}
+
+TEST_F(WatchTest, OnEvasAdded) {
+  EXPECT_NE(WatchTest::stub, nullptr);
+  WatchTest::stub->InvokeEvasAdded();
+}
+
+TEST_F(WatchTest, OnEvasRemoved) {
+  EXPECT_NE(WatchTest::stub, nullptr);
+  WatchTest::stub->InvokeEvasRemoved();
+}
+
+TEST_F(WatchTest, OnEvasChanged) {
+  EXPECT_NE(WatchTest::stub, nullptr);
+  WatchTest::stub->InvokeEvasChanged();
 }
\ No newline at end of file

diff --git a/unittest/src/test_watch_holder.cc b/unittest/src/test_watch_holder.cc
index aa6a863..6d11977 100644 (file)
--- a/unittest/src/test_watch_holder.cc
+++ b/unittest/src/test_watch_holder.cc
@@ -34,34 +34,51 @@ class WatchHolderStub : public WatchHolder {
     : WatchHolder(win) {
   }
 
-  void OnAmbientChanged(bool enter, Bundle& extra) override {}
-  void OnAmbientEvent(EventType ev, string sender,
-      Bundle extra) override {}
+  void InvokeAmbientChanged(bool enter, Bundle& extra) {
+    OnAmbientChanged(enter, extra);
+  }
+  void InvokeAmbientEvent(EventType ev, string sender,
+      Bundle extra) {
+    OnAmbientEvent(ev, sender, extra);
+  }
   void OnAdded(const Watch& watch) override {}
   void OnUpdated(const Watch& watch) override {}
   void OnRemoved(const Watch& watch) override {}
   void OnLaunched(const Watch& watch) override {}
   void OnDead(const Watch& watch) override {}
   void OnBound(const Watch& watch) override {}
+
+  std::shared_ptr<Watch> CreateWatch(int rid, std::string id,
+      std::string appid, Evas_Object* viewer_win,
+      Watch::IEvent* listener, bool mock) override {
+    return WatchHolder::CreateWatch(rid, id, appid, viewer_win, listener, true);
+  }
+  std::shared_ptr<Watch> CreateWatch(int rid, std::string id,
+      std::string appid, Evas_Object* viewer_win, tizen_base::Bundle extra,
+      Watch::IEvent* listener, bool mock) override {
+    return WatchHolder::CreateWatch(rid, id, appid, viewer_win, extra, listener, true);
+  }
+
 };
 
 static int (*__app_com_cb)(const char *endpoint, aul_app_com_result_e result, bundle *envelope, void *user_data);
 static Bundle b;
 static string global_end;
+aul_app_com_connection_h *global_conn;
 
 static int __aul_app_get_appid_bypid_fake(int pid, char* appid, int len) {
-  snprintf(appid, len, "%s", "org.tizen.test");
+  snprintf(appid, len, "%s", "org.tizen.watch");
   return 0;
 }
 
 static int __aul_app_com_create_fake(const char* end, aul_app_com_permission_h permission,
     app_com_cb cb, void* user_data, aul_app_com_connection_h* conn) {
-  *conn = nullptr;
+  *conn = *global_conn;
   b = Bundle();
-  b.Add("__AUL_APPID__", "appid");
+  b.Add("__AUL_APPID__", "org.tizen.watch");
   b.Add("__AUL_PID__", "111");
   b.Add("__AUL_IS_FAULT__", "is_fault");
-  b.Add("__AUL_WIDGET_VIEWER__", "fake");
+  b.Add("__AUL_WIDGET_VIEWER__", "org.tizen.watch");
   b.Add("__AMBIENT_MODE__", "100");
   b.Add("__APP_AMBIENT_EVENT__", "0");
   b.Add("__APP_AMBIENT_SENDER__", "sender");
@@ -87,11 +104,13 @@ class WatchHolderTest : public ::testing::Test {
     aul_app_com_create_fake.custom_fake = __aul_app_com_create_fake;
     aul_app_com_leave_fake.custom_fake = __aul_app_com_leave_fake;
     aul_app_get_appid_bypid_fake.custom_fake = __aul_app_get_appid_bypid_fake;
+    global_conn = (aul_app_com_connection_h*)malloc(sizeof(aul_app_com_connection_h));
 
     Evas_Object* win = elm_win_add(NULL, "Watch Holder", ELM_WIN_BASIC);
     stub = new WatchHolderStub(win);
   }
   virtual void TearDown() {
+    free(global_conn);
     delete stub;
   }
 };
@@ -100,6 +119,21 @@ TEST_F(WatchHolderTest, CreateInstance) {
   EXPECT_NE(WatchHolderTest::stub, nullptr);
 }
 
+TEST_F(WatchHolderTest, CreateWatch) {
+  Evas_Object* watchwin = elm_win_add(NULL, "Watch", ELM_WIN_BASIC);
+  std::shared_ptr<Watch> w =
+    WatchHolderTest::stub->CreateWatch(1, string("id"), string("appid"),
+    watchwin, WatchHolderTest::stub, true);
+  EXPECT_NE(w, nullptr);
+
+  Bundle b;
+  b.Add("__APP_AMBIENT_EVENT__", "1");
+  std::shared_ptr<Watch> w2 =
+    WatchHolderTest::stub->CreateWatch(1, string("id"), string("appid"),
+    watchwin, b, WatchHolderTest::stub, true);
+  EXPECT_NE(w2, nullptr);
+}
+
 TEST_F(WatchHolderTest, LaunchWatch) {
   appsvc_run_service_fake.custom_fake = __appsvc_run_service_fake;
   string appid("org.tizen.watch");
@@ -122,6 +156,14 @@ TEST_F(WatchHolderTest, GetCurrent_N) {
 
 TEST_F(WatchHolderTest, OnLaunchSignal) {
   EXPECT_NE(WatchHolderTest::stub, nullptr);
+  int ret;
+  string appid("org.tizen.watch");
+  ret = WatchHolderTest::stub->Launch(appid, false, b.GetHandle());
+  EXPECT_NE(ret, -1);
+  __app_com_cb("end", AUL_APP_COM_R_OK, b.GetHandle(), stub);
+
+  ret = WatchHolderTest::stub->Launch(appid, false, nullptr);
+  EXPECT_NE(ret, -1);
   __app_com_cb("end", AUL_APP_COM_R_OK, b.GetHandle(), stub);
   global_end = "watch.dead";
 }
@@ -141,4 +183,27 @@ TEST_F(WatchHolderTest, OnAmbientChangedSignal) {
 TEST_F(WatchHolderTest, OnReceiveSignal) {
   EXPECT_NE(WatchHolderTest::stub, nullptr);
   __app_com_cb("end", AUL_APP_COM_R_OK, b.GetHandle(), stub);
+}
+
+TEST_F(WatchHolderTest, EnableRendering) {
+  EXPECT_NE(WatchHolderTest::stub, nullptr);
+  WatchHolderTest::stub->EnableRendering();
+}
+
+TEST_F(WatchHolderTest, DisableRendering) {
+  EXPECT_NE(WatchHolderTest::stub, nullptr);
+  WatchHolderTest::stub->DisableRendering(0);
+}
+
+TEST_F(WatchHolderTest, OnAmbientChanged) {
+  Bundle *b = nullptr;
+  EXPECT_NE(WatchHolderTest::stub, nullptr);
+  WatchHolderTest::stub->InvokeAmbientChanged(true, *b);
+}
+
+TEST_F(WatchHolderTest, OnAmbientEvent) {
+  Bundle b;
+  b.Add("__APP_AMBIENT_EVENT__", "1");
+  EXPECT_NE(WatchHolderTest::stub, nullptr);
+  WatchHolderTest::stub->InvokeAmbientEvent(AmbientListener::EVENT_AOD_READY, string("sender"), b);
 }
\ No newline at end of file

diff --git a/unittest/src/test_watch_mirror.cc b/unittest/src/test_watch_mirror.cc
index 26f11c5..a8e3774 100644 (file)
--- a/unittest/src/test_watch_mirror.cc
+++ b/unittest/src/test_watch_mirror.cc
@@ -38,11 +38,30 @@ class WatchMirrorStub : public WatchMirror {
   void OnRemoved(const ISharableWatch& watch) override {}
 };
 
+class SharableWatchStub : public ISharableWatch {
+ public:
+
+  void Resume() override;
+  void Pause() override;
+  Evas_Object* GetCurrentImage() const override;
+  bool IsBound() const override;
+  std::string GetAppId() const override;
+  int GetPid() const override;
+  tizen_base::Bundle GetExtra() const override;
+  bool IsFaulted() const override;
+  void BlockUpdate(bool enable) override;
+};
+
 static int __vconf_notify_key_changed_fake(const char* key, vconf_callback_fn cb,
   void* data) {
   return 0;
 }
 
+static int __vconf_notify_key_changed_fake2(const char* key, vconf_callback_fn cb,
+  void* data) {
+  return -1;
+}
+
 static char* __vconf_get_str_fake(const char* key) {
   bundle_raw* raw;
   int len;
@@ -83,8 +102,80 @@ TEST_F(WatchMirrorTest, MirrorListen) {
   EXPECT_EQ(ret, 0);
 }
 
+TEST_F(WatchMirrorTest, MirrorListen_N) {
+  int ret;
+
+  vconf_notify_key_changed_fake.custom_fake = __vconf_notify_key_changed_fake2;
+
+  ret = WatchMirrorTest::mirrorstub->Listen();
+  EXPECT_NE(ret, 0);
+}
+
 TEST_F(WatchMirrorTest, MirrorGetCurrent_N) {
   shared_ptr<ISharableWatch> sw;
   sw = WatchMirrorTest::mirrorstub->GetCurrent();
   EXPECT_EQ(sw, nullptr);
 }
+
+TEST_F(WatchMirrorTest, OnChanged) {
+  Evas_Object* watchwin = elm_win_add(NULL, "Watch", ELM_WIN_BASIC);
+  Watch *w = new Watch(string("test"), watchwin, WatchMirrorTest::mirrorstub);
+  EXPECT_NE(w, nullptr);
+  WatchMirror *mr = new WatchMirror(watchwin);
+  EXPECT_NE(mr, nullptr);
+  mr->OnChanged(*w);
+  delete w;
+  delete mr;
+}
+
+TEST_F(WatchMirrorTest, OnAdded) {
+  Evas_Object* watchwin = elm_win_add(NULL, "Watch", ELM_WIN_BASIC);
+  SharableWatchStub *w = nullptr;
+
+  WatchMirror *mr = new WatchMirror(watchwin);
+  EXPECT_NE(mr, nullptr);
+  mr->OnAdded(*w);
+
+  delete mr;
+}
+
+TEST_F(WatchMirrorTest, OnUpdated) {
+  Evas_Object* watchwin = elm_win_add(NULL, "Watch", ELM_WIN_BASIC);
+  SharableWatchStub *w = nullptr;
+
+  WatchMirror *mr = new WatchMirror(watchwin);
+  EXPECT_NE(mr, nullptr);
+  mr->OnUpdated(*w);
+
+  delete mr;
+}
+
+TEST_F(WatchMirrorTest, OnRemoved) {
+  Evas_Object* watchwin = elm_win_add(NULL, "Watch", ELM_WIN_BASIC);
+  SharableWatchStub *w = nullptr;
+
+  WatchMirror *mr = new WatchMirror(watchwin);
+  EXPECT_NE(mr, nullptr);
+  mr->OnRemoved(*w);
+
+  delete mr;
+}
+
+TEST_F(WatchMirrorTest, OnAmbientChanged) {
+  Bundle *b = nullptr;
+  Evas_Object* watchwin = elm_win_add(NULL, "Watch", ELM_WIN_BASIC);
+  WatchMirror *mr = new WatchMirror(watchwin);
+  EXPECT_NE(mr, nullptr);
+  mr->OnAmbientChanged(true, *b);
+  delete mr;
+}
+
+TEST_F(WatchMirrorTest, OnAmbientEvent) {
+  Bundle b;
+  b.Add("__APP_AMBIENT_EVENT__", "1");
+  Evas_Object* watchwin = elm_win_add(NULL, "Watch", ELM_WIN_BASIC);
+  WatchMirror *mr = new WatchMirror(watchwin);
+  EXPECT_NE(mr, nullptr);
+  mr->OnAmbientEvent(AmbientListener::EVENT_AOD_READY, string("sender"), b);
+  delete mr;
+}
\ No newline at end of file

diff --git a/watch-holder/src/watch.hh b/watch-holder/src/watch.hh
index 5e168cc..8e93518 100644 (file)
--- a/watch-holder/src/watch.hh
+++ b/watch-holder/src/watch.hh
@@ -64,7 +64,7 @@ class EXPORT_API Watch : private screen_connector::RemoteSurfaceEvas,
   bool IsFaulted() const override;
   void BlockUpdate(bool enable) override;
 
- private:
+ protected:
   friend class WatchHolder;
   void OnEvasAdded(const std::string& appId, const std::string& instId,
     int pid, const screen_connector::EvasObject& image) override;

diff --git a/watch-holder/src/watch_holder.cc b/watch-holder/src/watch_holder.cc
index 5fa82ac..ff7afac 100644 (file)
--- a/watch-holder/src/watch_holder.cc
+++ b/watch-holder/src/watch_holder.cc
@@ -59,6 +59,32 @@ WatchHolder::WatchHolder(Evas_Object* win) : win_(win) {
   appid_ = appid_buf;
 }
 
+std::shared_ptr<Watch> WatchHolder::CreateWatch(std::string appid,
+    Evas_Object* viewer_win, Watch::IEvent* listener, bool mock) {
+  return make_shared<Watch>(std::move(appid), viewer_win, listener, mock);
+}
+
+std::shared_ptr<Watch> WatchHolder::CreateWatch(int rid, std::string id,
+    std::string appid, Evas_Object* viewer_win, Watch::IEvent* listener,
+    bool mock) {
+  return make_shared<Watch>(rid, std::move(id), std::move(appid), viewer_win,
+    listener, mock);
+}
+
+std::shared_ptr<Watch> WatchHolder::CreateWatch(std::string appid,
+    Evas_Object* viewer_win, tizen_base::Bundle extra,
+    Watch::IEvent* listener, bool mock) {
+  return make_shared<Watch>(std::move(appid), viewer_win, std::move(extra),
+    listener, mock);
+}
+
+std::shared_ptr<Watch> WatchHolder::CreateWatch(int rid, std::string id,
+    std::string appid, Evas_Object* viewer_win, tizen_base::Bundle extra,
+    Watch::IEvent* listener, bool mock) {
+  return make_shared<Watch>(rid, std::move(id), std::move(appid), viewer_win,
+    std::move(extra), listener, mock);
+}
+
 int WatchHolder::Launch(
     string watch_appid, bool background, bundle* extra) {
   Evas_Coord x, y, w, h;
@@ -147,10 +173,10 @@ int WatchHolder::OnLaunchSignal(const char *endpoint,
 
   if (holder->extra_map_.find(watch_appid) != holder->extra_map_.end()) {
     Bundle extra(holder->extra_map_[watch_appid]);
-    holder->stack_.push_back(make_shared<Watch>(watch_appid, holder->win_, extra, holder));
+    holder->stack_.push_back(holder->CreateWatch(watch_appid, holder->win_, extra, holder));
     holder->extra_map_.erase(watch_appid);
   } else {
-    holder->stack_.push_back(make_shared<Watch>(watch_appid, holder->win_, holder));
+    holder->stack_.push_back(holder->CreateWatch(watch_appid, holder->win_, holder));
   }
   holder->OnLaunched(*holder->GetCurrent());
   LOGI("LAUNCH DONE (%s)", viewer_appid.c_str());

diff --git a/watch-holder/src/watch_holder.hh b/watch-holder/src/watch_holder.hh
index ce81d66..e4b61a3 100644 (file)
--- a/watch-holder/src/watch_holder.hh
+++ b/watch-holder/src/watch_holder.hh
@@ -48,6 +48,19 @@ class EXPORT_API WatchHolder : public Watch::IEvent, public AmbientListener {
   virtual void OnAmbientEvent(EventType ev, std::string sender,
       tizen_base::Bundle extra) override;
 
+ protected:
+  virtual std::shared_ptr<Watch> CreateWatch(std::string appid,
+    Evas_Object* viewer_win, Watch::IEvent* listener, bool mock = false);
+  virtual std::shared_ptr<Watch> CreateWatch(int rid, std::string id,
+    std::string appid, Evas_Object* viewer_win, Watch::IEvent* listener,
+    bool mock = false);
+  virtual std::shared_ptr<Watch> CreateWatch(std::string appid,
+    Evas_Object* viewer_win, tizen_base::Bundle extra,
+    Watch::IEvent* listener, bool mock = false);
+  virtual std::shared_ptr<Watch> CreateWatch(int rid, std::string id,
+    std::string appid, Evas_Object* viewer_win, tizen_base::Bundle extra,
+    Watch::IEvent* listener, bool mock = false);
+
  private:
   static int OnDeadSignal(const char *endpoint, aul_app_com_result_e e,
     bundle *envelope, void *user_data);