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>
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"
34 #include "pkgmgrinfo_basic.h"
36 #include "parcel_utils.hh"
38 namespace pp = pkgmgr_common::parcel;
40 class AbstractParcelableTest : public pp::AbstractParcelable {
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);
49 AbstractParcelableTest()
50 : AbstractParcelable(), a_(nullptr), b_(nullptr), c_(nullptr) {}
52 ~AbstractParcelableTest() {
58 const char *GetA() const { return a_; }
60 const char *GetB() const { return b_; }
62 const char *GetC() const { return c_; }
64 virtual void WriteToParcel(tizen_base::Parcel *parcel) const {
65 WriteString(parcel, a_);
66 WriteString(parcel, b_);
67 WriteString(parcel, c_);
70 virtual void ReadFromParcel(tizen_base::Parcel *parcel) {
71 ReadString(parcel, &a_);
72 ReadString(parcel, &b_);
73 ReadString(parcel, &c_);
82 class ParcelTest : public ::testing::Test {
84 virtual void SetUp() {}
86 virtual void TearDown() {}
89 TEST_F(ParcelTest, AbstractParcelableTest) {
90 tizen_base::Parcel parcel;
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);
99 EXPECT_EQ(parcelableB.GetA(), nullptr);
100 EXPECT_STREQ(parcelableA.GetB(), parcelableB.GetB());
101 EXPECT_STREQ(parcelableA.GetC(), parcelableB.GetC());
104 TEST_F(ParcelTest, AppInfoParcelable) {
105 tizen_base::Parcel parcel;
106 std::vector<application_x *> origin_applications;
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);
115 EXPECT_TRUE(IsEqualApplications(origin_parcelable.GetAppInfo(),
116 new_parcelable.GetAppInfo()));
119 TEST_F(ParcelTest, PkgInfoParcelable) {
120 tizen_base::Parcel parcel;
121 std::vector<package_x *> origin_packages;
123 origin_packages.emplace_back(GetTestPackage("test_pkgid1"));
124 origin_packages.emplace_back(GetTestPackage("test_pkgid2"));
125 pp::PkgInfoParcelable origin_parcelable(0, std::move(origin_packages));
126 pp::PkgInfoParcelable new_parcelable;
127 parcel.WriteParcelable(origin_parcelable);
128 parcel.ReadParcelable(&new_parcelable);
130 EXPECT_TRUE(IsEqualPackages(origin_parcelable.GetPkgInfo(),
131 new_parcelable.GetPkgInfo()));
134 TEST_F(ParcelTest, FilterParcelable) {
135 tizen_base::Parcel parcel;
136 pkgmgrinfo_filter_x *filter = GetTestFilter();
139 pp::FilterParcelable origin_parcelable(0, filter, flag);
140 pp::FilterParcelable new_parcelable;
141 parcel.WriteParcelable(origin_parcelable);
142 parcel.ReadParcelable(&new_parcelable);
145 IsEqualFilter(origin_parcelable.GetFilter(), new_parcelable.GetFilter()));
146 EXPECT_EQ(origin_parcelable.GetFlag(), new_parcelable.GetFlag());
149 TEST_F(ParcelTest, CertInfoParcelable) {
150 tizen_base::Parcel parcel;
151 pkgmgr_certinfo_x *certinfo = GetTestCertInfo();
152 std::string test_str = "test_str";
154 pp::CertInfoParcelable origin_parcelable(0, certinfo, test_str);
155 pp::CertInfoParcelable new_parcelable;
156 parcel.WriteParcelable(origin_parcelable);
157 parcel.ReadParcelable(&new_parcelable);
159 EXPECT_TRUE(IsEqualCertInfo(origin_parcelable.GetCertInfo(),
160 new_parcelable.GetCertInfo()));
161 EXPECT_EQ(origin_parcelable.GetPkgId(), new_parcelable.GetPkgId());
164 TEST_F(ParcelTest, ResultParcelable) {
165 tizen_base::Parcel parcel;
166 std::vector<std::vector<std::string>> vt{{"a1", "a2"}, {"b1", "b2"}};
168 pp::ResultParcelable origin_parcelable(std::move(vt));
169 pp::ResultParcelable new_parcelable;
170 parcel.WriteParcelable(origin_parcelable);
171 parcel.ReadParcelable(&new_parcelable);
173 EXPECT_EQ(origin_parcelable.GetResult(), new_parcelable.GetResult());
176 TEST_F(ParcelTest, QueryParcelable) {
177 tizen_base::Parcel parcel;
178 std::vector<std::string> query;
179 query.emplace_back("select * from package_info");
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);
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());
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;
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);
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);
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);
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);
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);
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);