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 <cstdio>
  20 #include <parcel.hh>
  21 #include <iostream>
  22 #include <tuple>
  23
  24 #include "common/database/abstract_db_handler.hh"
  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/filter_parcelable.hh"
  29 #include "common/parcel/parcelable_factory.hh"
  30 #include "common/parcel/pkginfo_parcelable.hh"
  31 #include "common/parcel/query_parcelable.hh"
  32 #include "common/parcel/result_parcelable.hh"
  33
  34 #include "pkgmgrinfo_basic.h"
  35
  36 #include "parcel_utils.hh"
  37
  38 namespace pp = pkgmgr_common::parcel;
  39
  40 class AbstractParcelableTest : public pp::AbstractParcelable {
  41  public:
  42   AbstractParcelableTest(char *a, char *b, char *c)
  43       : AbstractParcelable(), a_(nullptr), b_(nullptr), c_(nullptr) {
  44     if (a) a_ = strdup(a);
  45     if (b) b_ = strdup(b);
  46     if (c) c_ = strdup(c);
  47   }
  48
  49   AbstractParcelableTest()
  50       : AbstractParcelable(), a_(nullptr), b_(nullptr), c_(nullptr) {}
  51
  52   ~AbstractParcelableTest() {
  53     if (a_) free(a_);
  54     if (b_) free(b_);
  55     if (c_) free(c_);
  56   }
  57
  58   const char *GetA() const { return a_; }
  59
  60   const char *GetB() const { return b_; }
  61
  62   const char *GetC() const { return c_; }
  63
  64   virtual void WriteToParcel(tizen_base::Parcel *parcel) const {
  65     WriteString(parcel, a_);
  66     WriteString(parcel, b_);
  67     WriteString(parcel, c_);
  68   }
  69
  70   virtual void ReadFromParcel(tizen_base::Parcel *parcel) {
  71     ReadString(parcel, &a_);
  72     ReadString(parcel, &b_);
  73     ReadString(parcel, &c_);
  74   }
  75
  76  private:
  77   char *a_;
  78   char *b_;
  79   char *c_;
  80 };
  81
  82 class ParcelTest : public ::testing::Test {
  83  public:
  84   virtual void SetUp() {}
  85
  86   virtual void TearDown() {}
  87 };
  88
  89 TEST_F(ParcelTest, AbstractParcelableTest) {
  90   tizen_base::Parcel parcel;
  91   char *a = nullptr;
  92   char *b = const_cast<char *>("");
  93   char *c = const_cast<char *>("test_str");
  94   AbstractParcelableTest parcelableA(a, b, c);
  95   AbstractParcelableTest parcelableB;
  96   parcel.WriteParcelable(parcelableA);
  97   parcel.ReadParcelable(&parcelableB);
  98
  99   EXPECT_EQ(parcelableB.GetA(), nullptr);
 100   EXPECT_STREQ(parcelableA.GetB(), parcelableB.GetB());
 101   EXPECT_STREQ(parcelableA.GetC(), parcelableB.GetC());
 102 }
 103
 104 TEST_F(ParcelTest, AppInfoParcelable) {
 105   tizen_base::Parcel parcel;
 106   std::vector<application_x *> origin_applications;
 107
 108   origin_applications.emplace_back(GetTestApplication("test_appid1"));
 109   origin_applications.emplace_back(GetTestApplication("test_appid2"));
 110   pp::AppInfoParcelable origin_parcelable(std::move(origin_applications));
 111   pp::AppInfoParcelable new_parcelable;
 112   parcel.WriteParcelable(origin_parcelable);
 113   parcel.ReadParcelable(&new_parcelable);
 114
 115   EXPECT_TRUE(IsEqualApplications(origin_parcelable.GetAppInfo(),
 116                                   new_parcelable.GetAppInfo()));
 117 }
 118
 119 TEST_F(ParcelTest, PkgInfoParcelable) {
 120   tizen_base::Parcel parcel;
 121   std::vector<package_x *> origin_packages;
 122
 123   origin_packages.emplace_back(GetTestPackage("test_pkgid1"));
 124   origin_packages.emplace_back(GetTestPackage("test_pkgid2"));
 125   pp::PkgInfoParcelable origin_parcelable(std::move(origin_packages));
 126   pp::PkgInfoParcelable new_parcelable;
 127   parcel.WriteParcelable(origin_parcelable);
 128   parcel.ReadParcelable(&new_parcelable);
 129
 130   EXPECT_TRUE(IsEqualPackages(origin_parcelable.GetPkgInfo(),
 131                               new_parcelable.GetPkgInfo()));
 132 }
 133
 134 TEST_F(ParcelTest, FilterParcelable) {
 135   tizen_base::Parcel parcel;
 136   pkgmgrinfo_filter_x *filter = GetTestFilter();
 137   int flag = 0b101010;
 138
 139   pp::FilterParcelable origin_parcelable(0, filter, flag);
 140   pp::FilterParcelable new_parcelable;
 141   parcel.WriteParcelable(origin_parcelable);
 142   parcel.ReadParcelable(&new_parcelable);
 143
 144   EXPECT_TRUE(
 145       IsEqualFilter(origin_parcelable.GetFilter(), new_parcelable.GetFilter()));
 146   EXPECT_EQ(origin_parcelable.GetFlag(), new_parcelable.GetFlag());
 147 }
 148
 149 TEST_F(ParcelTest, CertInfoParcelable) {
 150   tizen_base::Parcel parcel;
 151   pkgmgr_certinfo_x *certinfo = GetTestCertInfo();
 152   std::string test_str = "test_str";
 153
 154   pp::CertInfoParcelable origin_parcelable(0, certinfo, test_str);
 155   pp::CertInfoParcelable new_parcelable;
 156   parcel.WriteParcelable(origin_parcelable);
 157   parcel.ReadParcelable(&new_parcelable);
 158
 159   EXPECT_TRUE(IsEqualCertInfo(origin_parcelable.GetCertInfo(),
 160                               new_parcelable.GetCertInfo()));
 161   EXPECT_EQ(origin_parcelable.GetPkgId(), new_parcelable.GetPkgId());
 162 }
 163
 164 TEST_F(ParcelTest, ResultParcelable) {
 165   tizen_base::Parcel parcel;
 166   std::vector<std::vector<std::string>> vt{{"a1", "a2"}, {"b1", "b2"}};
 167
 168   pp::ResultParcelable origin_parcelable(std::move(vt));
 169   pp::ResultParcelable new_parcelable;
 170   parcel.WriteParcelable(origin_parcelable);
 171   parcel.ReadParcelable(&new_parcelable);
 172
 173   EXPECT_EQ(origin_parcelable.GetResult(), new_parcelable.GetResult());
 174 }
 175
 176 TEST_F(ParcelTest, QueryParcelable) {
 177   tizen_base::Parcel parcel;
 178   std::vector<std::string> query;
 179   query.emplace_back("select * from package_info");
 180
 181   pp::QueryParcelable origin_parcelable(0, query,
 182       pkgmgr_common::database::AbstractDBHandler::DBType::DB_TYPE_FILE_PKGDB,
 183       pkgmgr_common::database::AbstractDBHandler::OperationType::OPERATION_TYPE_READ);
 184   pp::QueryParcelable new_parcelable;
 185   parcel.WriteParcelable(origin_parcelable);
 186   parcel.ReadParcelable(&new_parcelable);
 187
 188   EXPECT_EQ(origin_parcelable.GetQueries(), new_parcelable.GetQueries());
 189   EXPECT_EQ(origin_parcelable.GetDBType(), new_parcelable.GetDBType());
 190   EXPECT_EQ(origin_parcelable.GetOpType(), new_parcelable.GetOpType());
 191 }
 192
 193 TEST_F(ParcelTest, ParcelableFactory) {
 194   tizen_base::Parcel parcel;
 195   std::unique_ptr<pp::AbstractParcelable> ptr;
 196   pp::AppInfoParcelable appinfo_parcelable;
 197   pp::CertInfoParcelable certinfo_parcelable;
 198   pp::FilterParcelable filter_parcelable;
 199   pp::PkgInfoParcelable pkginfo_parcelable;
 200   pp::QueryParcelable query_parcelable;
 201   pp::ResultParcelable result_parcelable;
 202
 203   parcel.WriteParcelable(appinfo_parcelable);
 204   ptr = pp::ParcelableFactory::GetInst().CreateParcel(&parcel.GetRaw()[0],
 205                                                       parcel.GetRaw().size());
 206   EXPECT_NE(ptr, nullptr);
 207   EXPECT_EQ(ptr->GetType(), pp::ParcelableType::AppInfo);
 208   parcel.Clear();
 209
 210   parcel.WriteParcelable(certinfo_parcelable);
 211   ptr = pp::ParcelableFactory::GetInst().CreateParcel(&parcel.GetRaw()[0],
 212                                                       parcel.GetRaw().size());
 213   EXPECT_NE(ptr, nullptr);
 214   EXPECT_EQ(ptr->GetType(), pp::ParcelableType::CertInfo);
 215   parcel.Clear();
 216
 217   parcel.WriteParcelable(filter_parcelable);
 218   ptr = pp::ParcelableFactory::GetInst().CreateParcel(&parcel.GetRaw()[0],
 219                                                       parcel.GetRaw().size());
 220   EXPECT_NE(ptr, nullptr);
 221   EXPECT_EQ(ptr->GetType(), pp::ParcelableType::Filter);
 222   parcel.Clear();
 223
 224   parcel.WriteParcelable(pkginfo_parcelable);
 225   ptr = pp::ParcelableFactory::GetInst().CreateParcel(&parcel.GetRaw()[0],
 226                                                       parcel.GetRaw().size());
 227   EXPECT_NE(ptr, nullptr);
 228   EXPECT_EQ(ptr->GetType(), pp::ParcelableType::PkgInfo);
 229   parcel.Clear();
 230
 231   parcel.WriteParcelable(query_parcelable);
 232   ptr = pp::ParcelableFactory::GetInst().CreateParcel(&parcel.GetRaw()[0],
 233                                                       parcel.GetRaw().size());
 234   EXPECT_NE(ptr, nullptr);
 235   EXPECT_EQ(ptr->GetType(), pp::ParcelableType::Query);
 236   parcel.Clear();
 237
 238   parcel.WriteParcelable(result_parcelable);
 239   ptr = pp::ParcelableFactory::GetInst().CreateParcel(&parcel.GetRaw()[0],
 240                                                       parcel.GetRaw().size());
 241   EXPECT_NE(ptr, nullptr);
 242   EXPECT_EQ(ptr->GetType(), pp::ParcelableType::Result);
 243   parcel.Clear();
 244 }