[Reform] Apply Coding Style

diff --git a/src/common/parcel/certinfo_parcelable.cc b/src/common/parcel/certinfo_parcelable.cc
index 0745ce0..5625334 100644 (file)
--- a/src/common/parcel/certinfo_parcelable.cc
+++ b/src/common/parcel/certinfo_parcelable.cc
@@ -25,32 +25,34 @@ namespace parcel {
 
 CertInfoParcelable::CertInfoParcelable()
     : AbstractParcelable(0, ParcelableType::CertInfo),
-        cert_info_(nullptr), pkgid_("") {}
+      cert_info_(nullptr),
+      pkgid_("") {}
 
-CertInfoParcelable::CertInfoParcelable(uid_t uid, pkgmgr_certinfo_x *cert_info)
+CertInfoParcelable::CertInfoParcelable(uid_t uid, pkgmgr_certinfo_x* cert_info)
     : AbstractParcelable(uid, ParcelableType::CertInfo),
-        cert_info_(cert_info), pkgid_("") {}
+      cert_info_(cert_info),
+      pkgid_("") {}
 
 CertInfoParcelable::CertInfoParcelable(uid_t uid, std::string pkgid)
     : AbstractParcelable(uid, ParcelableType::CertInfo),
-        cert_info_(nullptr), pkgid_(pkgid) {}
+      cert_info_(nullptr),
+      pkgid_(pkgid) {}
 
-CertInfoParcelable::CertInfoParcelable(uid_t uid,
-    pkgmgr_certinfo_x *cert_info, std::string pkgid)
+CertInfoParcelable::CertInfoParcelable(uid_t uid, pkgmgr_certinfo_x* cert_info,
+                                       std::string pkgid)
     : AbstractParcelable(uid, ParcelableType::CertInfo),
-        cert_info_(cert_info), pkgid_(pkgid) {}
+      cert_info_(cert_info),
+      pkgid_(pkgid) {}
 
 CertInfoParcelable::~CertInfoParcelable() {
   pkgmgrinfo_pkginfo_destroy_certinfo(cert_info_);
 }
 
-const pkgmgr_certinfo_x *CertInfoParcelable::GetCertInfo() {
+const pkgmgr_certinfo_x* CertInfoParcelable::GetCertInfo() {
   return cert_info_;
 }
 
-const std::string& CertInfoParcelable::GetPkgId() {
-  return pkgid_;
-}
+const std::string& CertInfoParcelable::GetPkgId() { return pkgid_; }
 
 void CertInfoParcelable::WriteToParcel(tizen_base::Parcel* parcel) const {
   AbstractParcelable::WriteToParcel(parcel);
@@ -83,13 +85,12 @@ bool CertInfoParcelable::WriteCertInfo(tizen_base::Parcel* parcel) const {
 
 void CertInfoParcelable::ReadCertInfo(tizen_base::Parcel* parcel) {
   bool is_null = false;
-  if (parcel->ReadBool(&is_null) != TIZEN_ERROR_NONE)
-    return;
+  if (parcel->ReadBool(&is_null) != TIZEN_ERROR_NONE) return;
 
-  if (is_null)
-    return;
+  if (is_null) return;
 
-  cert_info_ = reinterpret_cast<pkgmgr_certinfo_x *>(calloc(1, sizeof(pkgmgr_certinfo_x)));
+  cert_info_ = reinterpret_cast<pkgmgr_certinfo_x*>(
+      calloc(1, sizeof(pkgmgr_certinfo_x)));
   ReadInt(parcel, &cert_info_->for_all_users);
   ReadString(parcel, &cert_info_->pkgid);
   ReadString(parcel, &cert_info_->cert_value);
@@ -109,7 +110,8 @@ void CertInfoParcelable::ReadPkgId(tizen_base::Parcel* parcel) {
   pkgid_ = parcel->ReadString();
 }
 
-std::unique_ptr<AbstractParcelable> CertInfoParcelable::Factory::CreateParcel() {
+std::unique_ptr<AbstractParcelable>
+CertInfoParcelable::Factory::CreateParcel() {
   return nullptr;
 }
 

diff --git a/test/unit_tests/test_parcel.cc b/test/unit_tests/test_parcel.cc
index f4fb50d..7bf0164 100644 (file)
--- a/test/unit_tests/test_parcel.cc
+++ b/test/unit_tests/test_parcel.cc
@@ -40,45 +40,33 @@ class AbstractParcelableTest : public pp::AbstractParcelable {
  public:
   AbstractParcelableTest(char *a, char *b, char *c)
       : AbstractParcelable(), a_(nullptr), b_(nullptr), c_(nullptr) {
-    if (a)
-      a_ = strdup(a);
-    if (b)
-      b_ = strdup(b);
-    if (c)
-      c_ = strdup(c);
+    if (a) a_ = strdup(a);
+    if (b) b_ = strdup(b);
+    if (c) c_ = strdup(c);
   }
 
-  AbstractParcelableTest() : AbstractParcelable(),
-      a_(nullptr), b_(nullptr), c_(nullptr) {}
+  AbstractParcelableTest()
+      : AbstractParcelable(), a_(nullptr), b_(nullptr), c_(nullptr) {}
 
   ~AbstractParcelableTest() {
-    if (a_)
-      free(a_);
-    if (b_)
-      free(b_);
-    if (c_)
-      free(c_);
+    if (a_) free(a_);
+    if (b_) free(b_);
+    if (c_) free(c_);
   }
 
-  const char * GetA() const {
-    return a_;
-  }
+  const char *GetA() const { return a_; }
 
-  const char * GetB() const {
-    return b_;
-  }
+  const char *GetB() const { return b_; }
 
-  const char * GetC() const {
-    return c_;
-  }
+  const char *GetC() const { return c_; }
 
-  virtual void WriteToParcel(tizen_base::Parcel* parcel) const {
+  virtual void WriteToParcel(tizen_base::Parcel *parcel) const {
     WriteString(parcel, a_);
     WriteString(parcel, b_);
     WriteString(parcel, c_);
   }
 
-  virtual void ReadFromParcel(tizen_base::Parcel* parcel) {
+  virtual void ReadFromParcel(tizen_base::Parcel *parcel) {
     ReadString(parcel, &a_);
     ReadString(parcel, &b_);
     ReadString(parcel, &c_);
@@ -92,11 +80,9 @@ class AbstractParcelableTest : public pp::AbstractParcelable {
 
 class ParcelTest : public ::testing::Test {
  public:
-  virtual void SetUp() {
-  }
+  virtual void SetUp() {}
 
-  virtual void TearDown() {
-  }
+  virtual void TearDown() {}
 };
 
 TEST_F(ParcelTest, AbstractParcelableTest) {
@@ -125,8 +111,8 @@ TEST_F(ParcelTest, AppInfoParcelable) {
   parcel.WriteParcelable(origin_parcelable);
   parcel.ReadParcelable(&new_parcelable);
 
-  EXPECT_TRUE(IsEqualApplications(
-      origin_parcelable.GetAppInfo(), new_parcelable.GetAppInfo()));
+  EXPECT_TRUE(IsEqualApplications(origin_parcelable.GetAppInfo(),
+                                  new_parcelable.GetAppInfo()));
 }
 
 TEST_F(ParcelTest, PkgInfoParcelable) {
@@ -140,8 +126,8 @@ TEST_F(ParcelTest, PkgInfoParcelable) {
   parcel.WriteParcelable(origin_parcelable);
   parcel.ReadParcelable(&new_parcelable);
 
-  EXPECT_TRUE(IsEqualPackages(
-      origin_parcelable.GetPkgInfo(), new_parcelable.GetPkgInfo()));
+  EXPECT_TRUE(IsEqualPackages(origin_parcelable.GetPkgInfo(),
+                              new_parcelable.GetPkgInfo()));
 }
 
 TEST_F(ParcelTest, FilterParcelable) {
@@ -154,8 +140,8 @@ TEST_F(ParcelTest, FilterParcelable) {
   parcel.WriteParcelable(origin_parcelable);
   parcel.ReadParcelable(&new_parcelable);
 
-  EXPECT_TRUE(IsEqualFilter(
-      origin_parcelable.GetFilter(), new_parcelable.GetFilter()));
+  EXPECT_TRUE(
+      IsEqualFilter(origin_parcelable.GetFilter(), new_parcelable.GetFilter()));
   EXPECT_EQ(origin_parcelable.GetFlag(), new_parcelable.GetFlag());
 }
 
@@ -169,17 +155,14 @@ TEST_F(ParcelTest, CertInfoParcelable) {
   parcel.WriteParcelable(origin_parcelable);
   parcel.ReadParcelable(&new_parcelable);
 
-  EXPECT_TRUE(IsEqualCertInfo(
-      origin_parcelable.GetCertInfo(), new_parcelable.GetCertInfo()));
+  EXPECT_TRUE(IsEqualCertInfo(origin_parcelable.GetCertInfo(),
+                              new_parcelable.GetCertInfo()));
   EXPECT_EQ(origin_parcelable.GetPkgId(), new_parcelable.GetPkgId());
 }
 
 TEST_F(ParcelTest, ResultParcelable) {
   tizen_base::Parcel parcel;
-  std::vector<std::vector<std::string>> vt {
-    { "a1", "a2" },
-    { "b1", "b2" }
-  };
+  std::vector<std::vector<std::string>> vt{{"a1", "a2"}, {"b1", "b2"}};
 
   pp::ResultParcelable origin_parcelable(std::move(vt));
   pp::ResultParcelable new_parcelable;
@@ -212,37 +195,43 @@ TEST_F(ParcelTest, ParcelableFactory) {
   pp::ResultParcelable result_parcelable;
 
   parcel.WriteParcelable(appinfo_parcelable);
-  ptr = pp::ParcelableFactory::GetInst().CreateParcel(&parcel.GetRaw()[0], parcel.GetRaw().size());
+  ptr = pp::ParcelableFactory::GetInst().CreateParcel(&parcel.GetRaw()[0],
+                                                      parcel.GetRaw().size());
   EXPECT_NE(ptr, nullptr);
   EXPECT_EQ(ptr->GetType(), pp::ParcelableType::AppInfo);
   parcel.Clear();
 
   parcel.WriteParcelable(certinfo_parcelable);
-  ptr = pp::ParcelableFactory::GetInst().CreateParcel(&parcel.GetRaw()[0], parcel.GetRaw().size());
+  ptr = pp::ParcelableFactory::GetInst().CreateParcel(&parcel.GetRaw()[0],
+                                                      parcel.GetRaw().size());
   EXPECT_NE(ptr, nullptr);
   EXPECT_EQ(ptr->GetType(), pp::ParcelableType::CertInfo);
   parcel.Clear();
 
   parcel.WriteParcelable(filter_parcelable);
-  ptr = pp::ParcelableFactory::GetInst().CreateParcel(&parcel.GetRaw()[0], parcel.GetRaw().size());
+  ptr = pp::ParcelableFactory::GetInst().CreateParcel(&parcel.GetRaw()[0],
+                                                      parcel.GetRaw().size());
   EXPECT_NE(ptr, nullptr);
   EXPECT_EQ(ptr->GetType(), pp::ParcelableType::Filter);
   parcel.Clear();
 
   parcel.WriteParcelable(pkginfo_parcelable);
-  ptr = pp::ParcelableFactory::GetInst().CreateParcel(&parcel.GetRaw()[0], parcel.GetRaw().size());
+  ptr = pp::ParcelableFactory::GetInst().CreateParcel(&parcel.GetRaw()[0],
+                                                      parcel.GetRaw().size());
   EXPECT_NE(ptr, nullptr);
   EXPECT_EQ(ptr->GetType(), pp::ParcelableType::PkgInfo);
   parcel.Clear();
 
   parcel.WriteParcelable(query_parcelable);
-  ptr = pp::ParcelableFactory::GetInst().CreateParcel(&parcel.GetRaw()[0], parcel.GetRaw().size());
+  ptr = pp::ParcelableFactory::GetInst().CreateParcel(&parcel.GetRaw()[0],
+                                                      parcel.GetRaw().size());
   EXPECT_NE(ptr, nullptr);
   EXPECT_EQ(ptr->GetType(), pp::ParcelableType::Query);
   parcel.Clear();
 
   parcel.WriteParcelable(result_parcelable);
-  ptr = pp::ParcelableFactory::GetInst().CreateParcel(&parcel.GetRaw()[0], parcel.GetRaw().size());
+  ptr = pp::ParcelableFactory::GetInst().CreateParcel(&parcel.GetRaw()[0],
+                                                      parcel.GetRaw().size());
   EXPECT_NE(ptr, nullptr);
   EXPECT_EQ(ptr->GetType(), pp::ParcelableType::Result);
   parcel.Clear();