2 * Copyright (c) 2021 Samsung Electronics Co., Ltd.
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
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
17 #include <gtest/gtest.h>
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"
36 #include "pkgmgrinfo_basic.h"
38 #include "parcel_utils.hh"
40 namespace pp = pkgmgr_common::parcel;
42 class AbstractParcelableTest : public pp::AbstractParcelable {
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);
51 AbstractParcelableTest()
52 : AbstractParcelable(), a_(nullptr), b_(nullptr), c_(nullptr) {}
54 ~AbstractParcelableTest() {
60 const char *GetA() const { return a_; }
62 const char *GetB() const { return b_; }
64 const char *GetC() const { return c_; }
66 virtual void WriteToParcel(tizen_base::Parcel *parcel) const {
67 WriteString(parcel, a_);
68 WriteString(parcel, b_);
69 WriteString(parcel, c_);
72 virtual void ReadFromParcel(tizen_base::Parcel *parcel) {
73 ReadString(parcel, &a_);
74 ReadString(parcel, &b_);
75 ReadString(parcel, &c_);
84 class ParcelTest : public ::testing::Test {
86 virtual void SetUp() {}
88 virtual void TearDown() {}
91 TEST_F(ParcelTest, AbstractParcelableTest) {
92 tizen_base::Parcel parcel;
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);
101 EXPECT_EQ(parcelableB.GetA(), nullptr);
102 EXPECT_STREQ(parcelableA.GetB(), parcelableB.GetB());
103 EXPECT_STREQ(parcelableA.GetC(), parcelableB.GetC());
106 TEST_F(ParcelTest, AppInfoParcelable) {
107 tizen_base::Parcel parcel;
108 std::vector<std::shared_ptr<application_x>> origin_applications;
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);
117 EXPECT_TRUE(IsEqualApplicationsStructure(origin_parcelable.GetAppInfo(),
118 new_parcelable.GetAppInfo()));
121 TEST_F(ParcelTest, PkgInfoParcelable) {
122 tizen_base::Parcel parcel;
123 std::vector<std::shared_ptr<package_x>> origin_packages;
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);
132 EXPECT_TRUE(IsEqualPackagesStructure(origin_parcelable.GetPkgInfo(),
133 new_parcelable.GetPkgInfo()));
136 TEST_F(ParcelTest, FilterParcelable) {
137 tizen_base::Parcel parcel;
138 pkgmgrinfo_filter_x *filter = GetTestFilter();
141 pp::FilterParcelable origin_parcelable(0, filter, flag);
142 pp::FilterParcelable new_parcelable;
143 parcel.WriteParcelable(origin_parcelable);
144 parcel.ReadParcelable(&new_parcelable);
147 IsEqualFilter(origin_parcelable.GetFilter(), new_parcelable.GetFilter()));
148 EXPECT_EQ(origin_parcelable.GetFlag(), new_parcelable.GetFlag());
151 TEST_F(ParcelTest, CertInfoParcelable) {
152 tizen_base::Parcel parcel;
153 pkgmgr_certinfo_x *certinfo = GetTestCertInfo();
154 std::string test_str = "test_str";
156 pp::CertInfoParcelable origin_parcelable(0, certinfo, test_str);
157 pp::CertInfoParcelable new_parcelable;
158 parcel.WriteParcelable(origin_parcelable);
159 parcel.ReadParcelable(&new_parcelable);
161 EXPECT_TRUE(IsEqualCertInfoStructure(origin_parcelable.GetCertInfo(),
162 new_parcelable.GetCertInfo()));
163 EXPECT_EQ(origin_parcelable.GetPkgId(), new_parcelable.GetPkgId());
166 TEST_F(ParcelTest, ResultParcelable) {
167 tizen_base::Parcel parcel;
168 std::vector<std::vector<const char*>> raw_result{
173 EXPECT_NE(raw_result.size(), 0);
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];
182 vt[i][j] = std::nullopt;
186 pp::ResultParcelable origin_parcelable(0, std::move(vt));
187 pp::ResultParcelable new_parcelable;
188 parcel.WriteParcelable(origin_parcelable);
189 parcel.ReadParcelable(&new_parcelable);
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());
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" } },
201 { 2, { nullptr, "arg2" } }
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);
211 auto origin_args = origin_parcelable.ExtractQueryArgs();
212 auto new_args = new_parcelable.ExtractQueryArgs();
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());
219 TEST_F(ParcelTest, CommandParcelable) {
220 tizen_base::Parcel parcel;
222 pp::CommandParcelable origin_parcelable(0, UpdatePendingCache, {});
223 pp::CommandParcelable new_parcelable;
224 parcel.WriteParcelable(origin_parcelable);
225 parcel.ReadParcelable(&new_parcelable);
227 EXPECT_EQ(origin_parcelable.GetCmd(), new_parcelable.GetCmd());
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"));
237 pp::DepInfoParcelable origin_parcelable(0, std::move(dependencies));
238 pp::DepInfoParcelable new_parcelable;
239 parcel.WriteParcelable(origin_parcelable);
240 parcel.ReadParcelable(&new_parcelable);
242 EXPECT_TRUE(IsEqualDepInfo(origin_parcelable.GetDependencyInfo(),
243 new_parcelable.GetDependencyInfo()));
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;
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);
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);
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);
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);
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);
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);
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);
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);