test/unit_tests/test_parcel.cc

   1 /*
   2  * Copyright (c) 2021 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 <gtest/gtest.h>
  18
  19 #include <parcel.hh>
  20
  21 #include <cstdio>
  22 #include <iostream>
  23 #include <tuple>
  24
  25 #include "common/parcel/abstract_parcelable.hh"
  26 #include "common/parcel/appinfo_parcelable.hh"
  27 #include "common/parcel/certinfo_parcelable.hh"
  28 #include "common/parcel/command_parcelable.hh"
  29 #include "common/parcel/depinfo_parcelable.hh"
  30 #include "common/parcel/filter_parcelable.hh"
  31 #include "common/parcel/parcelable_factory.hh"
  32 #include "common/parcel/pkginfo_parcelable.hh"
  33 #include "common/parcel/query_parcelable.hh"
  34 #include "common/parcel/result_parcelable.hh"
  35
  36 #include "pkgmgrinfo_basic.h"
  37
  38 #include "parcel_utils.hh"
  39
  40 namespace pp = pkgmgr_common::parcel;
  41
  42 class AbstractParcelableTest : public pp::AbstractParcelable {
  43  public:
  44   AbstractParcelableTest(char *a, char *b, char *c)
  45       : AbstractParcelable(), a_(nullptr), b_(nullptr), c_(nullptr) {
  46     if (a) a_ = strdup(a);
  47     if (b) b_ = strdup(b);
  48     if (c) c_ = strdup(c);
  49   }
  50
  51   AbstractParcelableTest()
  52       : AbstractParcelable(), a_(nullptr), b_(nullptr), c_(nullptr) {}
  53
  54   ~AbstractParcelableTest() {
  55     if (a_) free(a_);
  56     if (b_) free(b_);
  57     if (c_) free(c_);
  58   }
  59
  60   const char *GetA() const { return a_; }
  61
  62   const char *GetB() const { return b_; }
  63
  64   const char *GetC() const { return c_; }
  65
  66   virtual void WriteToParcel(tizen_base::Parcel *parcel) const {
  67     WriteString(parcel, a_);
  68     WriteString(parcel, b_);
  69     WriteString(parcel, c_);
  70   }
  71
  72   virtual void ReadFromParcel(tizen_base::Parcel *parcel) {
  73     ReadString(parcel, &a_);
  74     ReadString(parcel, &b_);
  75     ReadString(parcel, &c_);
  76   }
  77
  78  private:
  79   char *a_;
  80   char *b_;
  81   char *c_;
  82 };
  83
  84 class ParcelTest : public ::testing::Test {
  85  public:
  86   virtual void SetUp() {}
  87
  88   virtual void TearDown() {}
  89 };
  90
  91 TEST_F(ParcelTest, AbstractParcelableTest) {
  92   tizen_base::Parcel parcel;
  93   char *a = nullptr;
  94   char *b = const_cast<char *>("");
  95   char *c = const_cast<char *>("test_str");
  96   AbstractParcelableTest parcelableA(a, b, c);
  97   AbstractParcelableTest parcelableB;
  98   parcel.WriteParcelable(parcelableA);
  99   parcel.ReadParcelable(&parcelableB);
 100
 101   EXPECT_EQ(parcelableB.GetA(), nullptr);
 102   EXPECT_STREQ(parcelableA.GetB(), parcelableB.GetB());
 103   EXPECT_STREQ(parcelableA.GetC(), parcelableB.GetC());
 104 }
 105
 106 TEST_F(ParcelTest, AppInfoParcelable) {
 107   tizen_base::Parcel parcel;
 108   std::vector<application_x *> origin_applications;
 109
 110   origin_applications.emplace_back(GetTestApplication("test_appid1"));
 111   origin_applications.emplace_back(GetTestApplication("test_appid2"));
 112   pp::AppInfoParcelable origin_parcelable(0, std::move(origin_applications));
 113   pp::AppInfoParcelable new_parcelable;
 114   parcel.WriteParcelable(origin_parcelable);
 115   parcel.ReadParcelable(&new_parcelable);
 116
 117   EXPECT_TRUE(IsEqualApplicationsStructure(origin_parcelable.GetAppInfo(),
 118                                   new_parcelable.GetAppInfo()));
 119 }
 120
 121 TEST_F(ParcelTest, PkgInfoParcelable) {
 122   tizen_base::Parcel parcel;
 123   std::vector<package_x *> origin_packages;
 124
 125   origin_packages.emplace_back(GetTestPackage("test_pkgid1"));
 126   origin_packages.emplace_back(GetTestPackage("test_pkgid2"));
 127   pp::PkgInfoParcelable origin_parcelable(0, std::move(origin_packages));
 128   pp::PkgInfoParcelable new_parcelable;
 129   parcel.WriteParcelable(origin_parcelable);
 130   parcel.ReadParcelable(&new_parcelable);
 131
 132   EXPECT_TRUE(IsEqualPackagesStructure(origin_parcelable.GetPkgInfo(),
 133                               new_parcelable.GetPkgInfo()));
 134 }
 135
 136 TEST_F(ParcelTest, FilterParcelable) {
 137   tizen_base::Parcel parcel;
 138   pkgmgrinfo_filter_x *filter = GetTestFilter();
 139   int flag = 0b101010;
 140
 141   pp::FilterParcelable origin_parcelable(0, filter, flag);
 142   pp::FilterParcelable new_parcelable;
 143   parcel.WriteParcelable(origin_parcelable);
 144   parcel.ReadParcelable(&new_parcelable);
 145
 146   EXPECT_TRUE(
 147       IsEqualFilter(origin_parcelable.GetFilter(), new_parcelable.GetFilter()));
 148   EXPECT_EQ(origin_parcelable.GetFlag(), new_parcelable.GetFlag());
 149 }
 150
 151 TEST_F(ParcelTest, CertInfoParcelable) {
 152   tizen_base::Parcel parcel;
 153   pkgmgr_certinfo_x *certinfo = GetTestCertInfo();
 154   std::string test_str = "test_str";
 155
 156   pp::CertInfoParcelable origin_parcelable(0, certinfo, test_str);
 157   pp::CertInfoParcelable new_parcelable;
 158   parcel.WriteParcelable(origin_parcelable);
 159   parcel.ReadParcelable(&new_parcelable);
 160
 161   EXPECT_TRUE(IsEqualCertInfo(origin_parcelable.GetCertInfo(),
 162                               new_parcelable.GetCertInfo()));
 163   EXPECT_EQ(origin_parcelable.GetPkgId(), new_parcelable.GetPkgId());
 164 }
 165
 166 TEST_F(ParcelTest, ResultParcelable) {
 167   tizen_base::Parcel parcel;
 168   std::vector<std::vector<std::string>> vt{{"a1", "a2"}, {"b1", "b2"}};
 169
 170   pp::ResultParcelable origin_parcelable(0, std::move(vt));
 171   pp::ResultParcelable new_parcelable;
 172   parcel.WriteParcelable(origin_parcelable);
 173   parcel.ReadParcelable(&new_parcelable);
 174
 175   EXPECT_EQ(origin_parcelable.GetResult(), new_parcelable.GetResult());
 176 }
 177
 178 TEST_F(ParcelTest, QueryParcelable) {
 179   tizen_base::Parcel parcel;
 180   std::vector<std::pair<int, std::vector<std::string>>> query_args = {
 181     { 0, { "arg1", "arg2" } },
 182     { 1, { "arg1" } }
 183   };
 184
 185   pp::QueryParcelable origin_parcelable(0, query_args,
 186       pkgmgr_common::DBType::DB_TYPE_FILE_PKGDB,
 187       pkgmgr_common::DBOperationType::OPERATION_TYPE_READ);
 188   pp::QueryParcelable new_parcelable;
 189   parcel.WriteParcelable(origin_parcelable);
 190   parcel.ReadParcelable(&new_parcelable);
 191
 192   EXPECT_EQ(origin_parcelable.GetQueryArgs().size(), new_parcelable.GetQueryArgs().size());
 193   EXPECT_EQ(origin_parcelable.GetQueryArgs()[0].first, new_parcelable.GetQueryArgs()[0].first);
 194   EXPECT_EQ(origin_parcelable.GetQueryArgs()[1].first, new_parcelable.GetQueryArgs()[1].first);
 195   EXPECT_EQ(origin_parcelable.GetQueryArgs()[0].second[0], new_parcelable.GetQueryArgs()[0].second[0]);
 196   EXPECT_EQ(origin_parcelable.GetQueryArgs()[0].second[1], new_parcelable.GetQueryArgs()[0].second[1]);
 197   EXPECT_EQ(origin_parcelable.GetQueryArgs()[1].second[0], new_parcelable.GetQueryArgs()[1].second[0]);
 198   EXPECT_EQ(origin_parcelable.GetDBType(), new_parcelable.GetDBType());
 199   EXPECT_EQ(origin_parcelable.GetOpType(), new_parcelable.GetOpType());
 200 }
 201
 202 TEST_F(ParcelTest, CommandParcelable) {
 203   tizen_base::Parcel parcel;
 204
 205   pp::CommandParcelable origin_parcelable(0, RemoveCache);
 206   pp::CommandParcelable new_parcelable;
 207   parcel.WriteParcelable(origin_parcelable);
 208   parcel.ReadParcelable(&new_parcelable);
 209
 210   EXPECT_EQ(origin_parcelable.GetCmd(), new_parcelable.GetCmd());
 211 }
 212
 213 TEST_F(ParcelTest, DepInfoParcelable) {
 214   tizen_base::Parcel parcel;
 215   std::vector<dependency_x *> dependencies;
 216   dependencies.emplace_back(GetTestDepInfo("pkg1"));
 217   dependencies.emplace_back(GetTestDepInfo("pkg2"));
 218   dependencies.emplace_back(GetTestDepInfo("pkg3"));
 219
 220   pp::DepInfoParcelable origin_parcelable(0, std::move(dependencies));
 221   pp::DepInfoParcelable new_parcelable;
 222   parcel.WriteParcelable(origin_parcelable);
 223   parcel.ReadParcelable(&new_parcelable);
 224
 225   EXPECT_TRUE(IsEqualDepInfo(origin_parcelable.GetDependencyInfo(), new_parcelable.GetDependencyInfo()));
 226 }
 227
 228 TEST_F(ParcelTest, ParcelableFactory) {
 229   tizen_base::Parcel parcel;
 230   std::unique_ptr<pp::AbstractParcelable> ptr;
 231   pp::AppInfoParcelable appinfo_parcelable;
 232   pp::CertInfoParcelable certinfo_parcelable;
 233   pp::FilterParcelable filter_parcelable;
 234   pp::PkgInfoParcelable pkginfo_parcelable;
 235   pp::QueryParcelable query_parcelable;
 236   pp::ResultParcelable result_parcelable;
 237   pp::CommandParcelable command_parcelable;
 238   pp::DepInfoParcelable depinfo_parcelable;
 239
 240   parcel.WriteParcelable(appinfo_parcelable);
 241   ptr = pp::ParcelableFactory::GetInst().CreateParcel(&parcel.GetRaw()[0],
 242                                                       parcel.GetRaw().size());
 243   EXPECT_NE(ptr, nullptr);
 244   EXPECT_EQ(ptr->GetType(), pp::ParcelableType::AppInfo);
 245   parcel.Clear();
 246
 247   parcel.WriteParcelable(certinfo_parcelable);
 248   ptr = pp::ParcelableFactory::GetInst().CreateParcel(&parcel.GetRaw()[0],
 249                                                       parcel.GetRaw().size());
 250   EXPECT_NE(ptr, nullptr);
 251   EXPECT_EQ(ptr->GetType(), pp::ParcelableType::CertInfo);
 252   parcel.Clear();
 253
 254   parcel.WriteParcelable(filter_parcelable);
 255   ptr = pp::ParcelableFactory::GetInst().CreateParcel(&parcel.GetRaw()[0],
 256                                                       parcel.GetRaw().size());
 257   EXPECT_NE(ptr, nullptr);
 258   EXPECT_EQ(ptr->GetType(), pp::ParcelableType::Filter);
 259   parcel.Clear();
 260
 261   parcel.WriteParcelable(pkginfo_parcelable);
 262   ptr = pp::ParcelableFactory::GetInst().CreateParcel(&parcel.GetRaw()[0],
 263                                                       parcel.GetRaw().size());
 264   EXPECT_NE(ptr, nullptr);
 265   EXPECT_EQ(ptr->GetType(), pp::ParcelableType::PkgInfo);
 266   parcel.Clear();
 267
 268   parcel.WriteParcelable(query_parcelable);
 269   ptr = pp::ParcelableFactory::GetInst().CreateParcel(&parcel.GetRaw()[0],
 270                                                       parcel.GetRaw().size());
 271   EXPECT_NE(ptr, nullptr);
 272   EXPECT_EQ(ptr->GetType(), pp::ParcelableType::Query);
 273   parcel.Clear();
 274
 275   parcel.WriteParcelable(result_parcelable);
 276   ptr = pp::ParcelableFactory::GetInst().CreateParcel(&parcel.GetRaw()[0],
 277                                                       parcel.GetRaw().size());
 278   EXPECT_NE(ptr, nullptr);
 279   EXPECT_EQ(ptr->GetType(), pp::ParcelableType::Result);
 280   parcel.Clear();
 281
 282   parcel.WriteParcelable(command_parcelable);
 283   ptr = pp::ParcelableFactory::GetInst().CreateParcel(&parcel.GetRaw()[0],
 284                                                       parcel.GetRaw().size());
 285   EXPECT_NE(ptr, nullptr);
 286   EXPECT_EQ(ptr->GetType(), pp::ParcelableType::Command);
 287   parcel.Clear();
 288
 289   parcel.WriteParcelable(depinfo_parcelable);
 290   ptr = pp::ParcelableFactory::GetInst().CreateParcel(&parcel.GetRaw()[0],
 291                                                       parcel.GetRaw().size());
 292   EXPECT_NE(ptr, nullptr);
 293   EXPECT_EQ(ptr->GetType(), pp::ParcelableType::DepInfo);
 294   parcel.Clear();
 295 }