Add unit test for parcelable

Add unit test related DepInfoParcelable, CommandParcelable

Change-Id: Ib77bb0172e1723cce80ee3d76d8f62d8d11b0b05
Signed-off-by: Ilho Kim <ilho159.kim@samsung.com>

diff --git a/test/unit_tests/parcel_utils.cc b/test/unit_tests/parcel_utils.cc
index 8adbede..b9ead05 100644 (file)
--- a/test/unit_tests/parcel_utils.cc
+++ b/test/unit_tests/parcel_utils.cc
@@ -744,3 +744,32 @@ bool IsEqualCertInfo(const pkgmgr_certinfo_x *certA,
 
   return true;
 }
+
+dependency_x *GetTestDepInfo(std::string pkgid) {
+  dependency_x *dependency;
+  dependency = reinterpret_cast<dependency_x *>(
+      calloc(1, sizeof(dependency_x)));
+
+  dependency->pkgid = strdup(pkgid.c_str());
+  dependency->depends_on = strdup("test_depends_on");
+  dependency->required_version = strdup("test_required_version");
+  dependency->type = strdup("test_type");
+
+  return dependency;
+}
+
+bool IsEqualDepInfo(const std::vector<dependency_x *>& depA,
+    const std::vector<dependency_x *>& depB) {
+  INT_EQ(depA.size(), depB.size());
+
+  for (int i = 0; i < depA.size(); ++i) {
+    dependency_x *A = depA[0];
+    dependency_x *B = depB[0];
+    STR_EQ(A->depends_on, B->depends_on);
+    STR_EQ(A->pkgid, B->pkgid);
+    STR_EQ(A->required_version, B->required_version);
+    STR_EQ(A->type, B->type);
+  }
+
+  return true;
+}

diff --git a/test/unit_tests/parcel_utils.hh b/test/unit_tests/parcel_utils.hh
index a2d4554..ebd670f 100644 (file)
--- a/test/unit_tests/parcel_utils.hh
+++ b/test/unit_tests/parcel_utils.hh
@@ -38,3 +38,8 @@ pkgmgr_certinfo_x *GetTestCertInfo();
 
 bool IsEqualCertInfo(const pkgmgr_certinfo_x *certA,
     const pkgmgr_certinfo_x *certB);
+
+dependency_x *GetTestDepInfo(std::string pkgid);
+
+bool IsEqualDepInfo(const std::vector<dependency_x *>& depA,
+    const std::vector<dependency_x *>& depB);

diff --git a/test/unit_tests/test_parcel.cc b/test/unit_tests/test_parcel.cc
index 6ef72dd..7816e1a 100644 (file)
--- a/test/unit_tests/test_parcel.cc
+++ b/test/unit_tests/test_parcel.cc
@@ -26,6 +26,8 @@
 #include "common/parcel/abstract_parcelable.hh"
 #include "common/parcel/appinfo_parcelable.hh"
 #include "common/parcel/certinfo_parcelable.hh"
+#include "common/parcel/command_parcelable.hh"
+#include "common/parcel/depinfo_parcelable.hh"
 #include "common/parcel/filter_parcelable.hh"
 #include "common/parcel/parcelable_factory.hh"
 #include "common/parcel/pkginfo_parcelable.hh"
@@ -199,6 +201,32 @@ TEST_F(ParcelTest, QueryParcelable) {
   EXPECT_EQ(origin_parcelable.GetOpType(), new_parcelable.GetOpType());
 }
 
+TEST_F(ParcelTest, CommandParcelable) {
+  tizen_base::Parcel parcel;
+
+  pp::CommandParcelable origin_parcelable(0, RemoveCache);
+  pp::CommandParcelable new_parcelable;
+  parcel.WriteParcelable(origin_parcelable);
+  parcel.ReadParcelable(&new_parcelable);
+
+  EXPECT_EQ(origin_parcelable.GetCmd(), new_parcelable.GetCmd());
+}
+
+TEST_F(ParcelTest, DepInfoParcelable) {
+  tizen_base::Parcel parcel;
+  std::vector<dependency_x *> dependencies;
+  dependencies.emplace_back(GetTestDepInfo("pkg1"));
+  dependencies.emplace_back(GetTestDepInfo("pkg2"));
+  dependencies.emplace_back(GetTestDepInfo("pkg3"));
+
+  pp::DepInfoParcelable origin_parcelable(0, std::move(dependencies));
+  pp::DepInfoParcelable new_parcelable;
+  parcel.WriteParcelable(origin_parcelable);
+  parcel.ReadParcelable(&new_parcelable);
+
+  EXPECT_TRUE(IsEqualDepInfo(origin_parcelable.GetDependencyInfo(), new_parcelable.GetDependencyInfo()));
+}
+
 TEST_F(ParcelTest, ParcelableFactory) {
   tizen_base::Parcel parcel;
   std::unique_ptr<pp::AbstractParcelable> ptr;
@@ -208,6 +236,8 @@ TEST_F(ParcelTest, ParcelableFactory) {
   pp::PkgInfoParcelable pkginfo_parcelable;
   pp::QueryParcelable query_parcelable;
   pp::ResultParcelable result_parcelable;
+  pp::CommandParcelable command_parcelable;
+  pp::DepInfoParcelable depinfo_parcelable;
 
   parcel.WriteParcelable(appinfo_parcelable);
   ptr = pp::ParcelableFactory::GetInst().CreateParcel(&parcel.GetRaw()[0],
@@ -250,4 +280,18 @@ TEST_F(ParcelTest, ParcelableFactory) {
   EXPECT_NE(ptr, nullptr);
   EXPECT_EQ(ptr->GetType(), pp::ParcelableType::Result);
   parcel.Clear();
+
+  parcel.WriteParcelable(command_parcelable);
+  ptr = pp::ParcelableFactory::GetInst().CreateParcel(&parcel.GetRaw()[0],
+                                                      parcel.GetRaw().size());
+  EXPECT_NE(ptr, nullptr);
+  EXPECT_EQ(ptr->GetType(), pp::ParcelableType::Command);
+  parcel.Clear();
+
+  parcel.WriteParcelable(depinfo_parcelable);
+  ptr = pp::ParcelableFactory::GetInst().CreateParcel(&parcel.GetRaw()[0],
+                                                      parcel.GetRaw().size());
+  EXPECT_NE(ptr, nullptr);
+  EXPECT_EQ(ptr->GetType(), pp::ParcelableType::DepInfo);
+  parcel.Clear();
 }