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<std::shared_ptr<application_x>> origin_applications;
 109
 110   origin_applications.emplace_back(GetTestApplication("test_appid1"), std::free);
 111   origin_applications.emplace_back(GetTestApplication("test_appid2"), std::free);
 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<std::shared_ptr<package_x>> origin_packages;
 124
 125   origin_packages.emplace_back(GetTestPackage("test_pkgid1"), std::free);
 126   origin_packages.emplace_back(GetTestPackage("test_pkgid2"), std::free);
 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(IsEqualCertInfoStructure(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<const char*>> raw_result{
 169     {"a1", "a2"},
 170     {"b1", "b2"},
 171     {"c1", nullptr}
 172   };
 173   EXPECT_NE(raw_result.size(), 0);
 174
 175   std::vector<pp::StrArgs> vt(raw_result.size());
 176   for (unsigned int i = 0; i < raw_result.size(); i++) {
 177     vt[i].resize(raw_result[i].size());
 178     for (unsigned int j = 0; j < raw_result[i].size(); j++) {
 179       if (raw_result[i][j])
 180         vt[i][j] = raw_result[i][j];
 181       else
 182         vt[i][j] = std::nullopt;
 183     }
 184   }
 185
 186   pp::ResultParcelable origin_parcelable(0, std::move(vt));
 187   pp::ResultParcelable new_parcelable;
 188   parcel.WriteParcelable(origin_parcelable);
 189   parcel.ReadParcelable(&new_parcelable);
 190
 191   EXPECT_EQ(origin_parcelable.GetRow(), new_parcelable.GetRow());
 192   EXPECT_EQ(origin_parcelable.GetCol(), new_parcelable.GetCol());
 193   EXPECT_EQ(origin_parcelable.GetResult(), new_parcelable.GetResult());
 194 }
 195
 196 TEST_F(ParcelTest, QueryParcelable) {
 197   tizen_base::Parcel parcel;
 198   std::vector<std::pair<int, std::vector<const char*>>> query_args = {
 199     { 0, { "arg1", "arg2" } },
 200     { 1, { "arg1" } },
 201     { 2, { nullptr, "arg2" } }
 202   };
 203
 204   pp::QueryParcelable origin_parcelable(0, query_args,
 205       pkgmgr_common::DBType::DB_TYPE_FILE_PKGDB,
 206       pkgmgr_common::DBOperationType::OPERATION_TYPE_READ);
 207   pp::QueryParcelable new_parcelable;
 208   parcel.WriteParcelable(origin_parcelable);
 209   parcel.ReadParcelable(&new_parcelable);
 210
 211   auto origin_args = origin_parcelable.ExtractQueryArgs();
 212   auto new_args = new_parcelable.ExtractQueryArgs();
 213
 214   EXPECT_EQ(origin_args, new_args);
 215   EXPECT_EQ(origin_parcelable.GetDBType(), new_parcelable.GetDBType());
 216   EXPECT_EQ(origin_parcelable.GetOpType(), new_parcelable.GetOpType());
 217 }
 218
 219 TEST_F(ParcelTest, CommandParcelable) {
 220   tizen_base::Parcel parcel;
 221
 222   pp::CommandParcelable origin_parcelable(0, RemoveCache);
 223   pp::CommandParcelable new_parcelable;
 224   parcel.WriteParcelable(origin_parcelable);
 225   parcel.ReadParcelable(&new_parcelable);
 226
 227   EXPECT_EQ(origin_parcelable.GetCmd(), new_parcelable.GetCmd());
 228 }
 229
 230 TEST_F(ParcelTest, DepInfoParcelable) {
 231   tizen_base::Parcel parcel;
 232   std::vector<dependency_x *> dependencies;
 233   dependencies.emplace_back(GetTestDepInfo("pkg1"));
 234   dependencies.emplace_back(GetTestDepInfo("pkg2"));
 235   dependencies.emplace_back(GetTestDepInfo("pkg3"));
 236
 237   pp::DepInfoParcelable origin_parcelable(0, std::move(dependencies));
 238   pp::DepInfoParcelable new_parcelable;
 239   parcel.WriteParcelable(origin_parcelable);
 240   parcel.ReadParcelable(&new_parcelable);
 241
 242   EXPECT_TRUE(IsEqualDepInfo(origin_parcelable.GetDependencyInfo(),
 243       new_parcelable.GetDependencyInfo()));
 244 }
 245
 246 TEST_F(ParcelTest, ParcelableFactory) {
 247   tizen_base::Parcel parcel;
 248   std::unique_ptr<pp::AbstractParcelable> ptr;
 249   pp::AppInfoParcelable appinfo_parcelable;
 250   pp::CertInfoParcelable certinfo_parcelable;
 251   pp::FilterParcelable filter_parcelable;
 252   pp::PkgInfoParcelable pkginfo_parcelable;
 253   pp::QueryParcelable query_parcelable;
 254   pp::ResultParcelable result_parcelable;
 255   pp::CommandParcelable command_parcelable;
 256   pp::DepInfoParcelable depinfo_parcelable;
 257
 258   parcel.WriteParcelable(appinfo_parcelable);
 259   ptr = pp::ParcelableFactory::GetInst().CreateParcel(parcel.GetData(),
 260       parcel.GetDataSize(), true);
 261   EXPECT_NE(ptr, nullptr);
 262   EXPECT_EQ(ptr->GetType(), pp::ParcelableType::AppInfo);
 263   parcel.Clear();
 264
 265   parcel.WriteParcelable(certinfo_parcelable);
 266   ptr = pp::ParcelableFactory::GetInst().CreateParcel(parcel.GetData(),
 267       parcel.GetDataSize(), true);
 268   EXPECT_NE(ptr, nullptr);
 269   EXPECT_EQ(ptr->GetType(), pp::ParcelableType::CertInfo);
 270   parcel.Clear();
 271
 272   parcel.WriteParcelable(filter_parcelable);
 273   ptr = pp::ParcelableFactory::GetInst().CreateParcel(parcel.GetData(),
 274       parcel.GetDataSize(), true);
 275   EXPECT_NE(ptr, nullptr);
 276   EXPECT_EQ(ptr->GetType(), pp::ParcelableType::Filter);
 277   parcel.Clear();
 278
 279   parcel.WriteParcelable(pkginfo_parcelable);
 280   ptr = pp::ParcelableFactory::GetInst().CreateParcel(parcel.GetData(),
 281       parcel.GetDataSize(), true);
 282   EXPECT_NE(ptr, nullptr);
 283   EXPECT_EQ(ptr->GetType(), pp::ParcelableType::PkgInfo);
 284   parcel.Clear();
 285
 286   parcel.WriteParcelable(query_parcelable);
 287   ptr = pp::ParcelableFactory::GetInst().CreateParcel(parcel.GetData(),
 288       parcel.GetDataSize(), true);
 289   EXPECT_NE(ptr, nullptr);
 290   EXPECT_EQ(ptr->GetType(), pp::ParcelableType::Query);
 291   parcel.Clear();
 292
 293   parcel.WriteParcelable(result_parcelable);
 294   ptr = pp::ParcelableFactory::GetInst().CreateParcel(parcel.GetData(),
 295       parcel.GetDataSize(), true);
 296   EXPECT_NE(ptr, nullptr);
 297   EXPECT_EQ(ptr->GetType(), pp::ParcelableType::Result);
 298   parcel.Clear();
 299
 300   parcel.WriteParcelable(command_parcelable);
 301   ptr = pp::ParcelableFactory::GetInst().CreateParcel(parcel.GetData(),
 302       parcel.GetDataSize(), true);
 303   EXPECT_NE(ptr, nullptr);
 304   EXPECT_EQ(ptr->GetType(), pp::ParcelableType::Command);
 305   parcel.Clear();
 306
 307   parcel.WriteParcelable(depinfo_parcelable);
 308   ptr = pp::ParcelableFactory::GetInst().CreateParcel(parcel.GetData(),
 309       parcel.GetDataSize(), true);
 310   EXPECT_NE(ptr, nullptr);
 311   EXPECT_EQ(ptr->GetType(), pp::ParcelableType::DepInfo);
 312   parcel.Clear();
 313 }