test/smoke_tests/manifest_test.cc

   1 // Copyright (c) 2015 Samsung Electronics Co., Ltd All Rights Reserved
   2 // Use of this source code is governed by an apache-2.0 license that can be
   3 // found in the LICENSE file.
   4
   5 #include <boost/filesystem/path.hpp>
   6
   7 #include <common/installer_context.h>
   8 #include <common/utils/glist_range.h>
   9 #include <common/utils/request.h>
  10
  11 #include <wgt_manifest_handlers/setting_handler.h>
  12
  13 #include <glib.h>
  14 #include <gtest/gtest.h>
  15
  16 #include <map>
  17 #include <memory>
  18 #include <string>
  19 #include <vector>
  20
  21 #include "wgt/step/configuration/step_parse.h"
  22 #include "wgt/utils/wgt_backend_data.h"
  23
  24 #define ASSERT_CSTR_EQ(STR1, STR2)                                             \
  25   ASSERT_EQ(strcmp(STR1, STR2), 0)                                             \
  26
  27 namespace bf = boost::filesystem;
  28 namespace ci = common_installer;
  29
  30 namespace {
  31
  32 const char kManifestTestcaseData[] =
  33     "/usr/share/wgt-installer-ut/test_samples/manifest/";
  34
  35 template<typename T>
  36 gint Size(GListRange<T>* range) {
  37   return std::distance(range->begin(), range->end());
  38 }
  39
  40 class StepParseRunner {
  41  public:
  42   explicit StepParseRunner(const std::string& dir_suffix,
  43                            bool ignore_start_files = true)
  44       : dir_suffix_(dir_suffix),
  45         ignore_start_files_(ignore_start_files),
  46         context_(nullptr) {
  47   }
  48
  49   bool Run() {
  50     PrepareContext();
  51     wgt::configuration::StepParse step(context_.get(),
  52         wgt::configuration::StepParse::ConfigLocation::PACKAGE,
  53         !ignore_start_files_);
  54     return step.process() == ci::Step::Status::OK;
  55   }
  56
  57   wgt::WgtBackendData* GetBackendData() const {
  58     return static_cast<wgt::WgtBackendData*>(context_->backend_data.get());
  59   }
  60
  61   manifest_x* GetManifest() const {
  62     return context_->manifest_data.get();
  63   }
  64
  65  private:
  66   void PrepareContext() {
  67     context_.reset(new ci::InstallerContext());
  68     context_->root_application_path.set(ci::GetRootAppPath(false, getuid()));
  69     context_->unpacked_dir_path.set(
  70         bf::path(kManifestTestcaseData) / dir_suffix_);
  71     context_->backend_data.set(new wgt::WgtBackendData());
  72   }
  73
  74   std::string dir_suffix_;
  75   bool ignore_start_files_;
  76   std::unique_ptr<ci::InstallerContext> context_;
  77 };
  78
  79 }  // namespace
  80
  81 class ManifestTest : public testing::Test {
  82  public:
  83   std::string GetMyName() const {
  84     std::string suite =
  85         testing::UnitTest::GetInstance()->current_test_info()->test_case_name();
  86     std::string case_name =
  87         testing::UnitTest::GetInstance()->current_test_info()->name();
  88     return suite + '.' + case_name;
  89   }
  90 };
  91
  92 TEST_F(ManifestTest, WidgetElement_Valid) {
  93   StepParseRunner runner(GetMyName());
  94   ASSERT_TRUE(runner.Run());
  95   manifest_x* m = runner.GetManifest();
  96   ASSERT_NE(m, nullptr);
  97   ASSERT_CSTR_EQ(m->package, "package0id");
  98   auto apps = GListRange<application_x*>(m->application);
  99   ASSERT_EQ(Size(&apps), 1);
 100   application_x* app = *apps.begin();
 101   ASSERT_CSTR_EQ(app->appid, "package0id.appid");
 102 }
 103
 104 TEST_F(ManifestTest, WidgetElement_InvalidNamespace) {
 105   StepParseRunner runner(GetMyName());
 106   ASSERT_FALSE(runner.Run());
 107 }
 108
 109 TEST_F(ManifestTest, WidgetElement_MissingNamespace) {
 110   StepParseRunner runner(GetMyName());
 111   ASSERT_FALSE(runner.Run());
 112 }
 113
 114 TEST_F(ManifestTest, WidgetElement_ManyNamespaces) {
 115   StepParseRunner runner(GetMyName());
 116   ASSERT_FALSE(runner.Run());
 117 }
 118
 119 TEST_F(ManifestTest, ApplicationElement_ManyElements) {
 120   StepParseRunner runner(GetMyName());
 121   ASSERT_FALSE(runner.Run());
 122 }
 123
 124 TEST_F(ManifestTest, ApplicationElement_ValidAppId) {
 125   StepParseRunner runner(GetMyName());
 126   ASSERT_TRUE(runner.Run());
 127   manifest_x* m = runner.GetManifest();
 128   ASSERT_NE(m, nullptr);
 129   auto apps = GListRange<application_x*>(m->application);
 130   application_x* app = *apps.begin();
 131   ASSERT_NE(app, nullptr);
 132   ASSERT_CSTR_EQ(app->appid, "package0id.appid");
 133 }
 134
 135 TEST_F(ManifestTest, ApplicationElement_MissingAppId) {
 136   StepParseRunner runner(GetMyName());
 137   ASSERT_FALSE(runner.Run());
 138 }
 139
 140 TEST_F(ManifestTest, ApplicationElement_InvalidAppId) {
 141   StepParseRunner runner(GetMyName());
 142   ASSERT_FALSE(runner.Run());
 143 }
 144
 145 TEST_F(ManifestTest, ApplicationElement_ValidPackage) {
 146   StepParseRunner runner(GetMyName());
 147   ASSERT_TRUE(runner.Run());
 148   manifest_x* m = runner.GetManifest();
 149   ASSERT_NE(m, nullptr);
 150   ASSERT_CSTR_EQ(m->package, "package0id");
 151 }
 152
 153 TEST_F(ManifestTest, ApplicationElement_InvalidPackage) {
 154   StepParseRunner runner(GetMyName());
 155   ASSERT_FALSE(runner.Run());
 156 }
 157
 158 TEST_F(ManifestTest, ApplicationElement_MissingPackage) {
 159   StepParseRunner runner(GetMyName());
 160   ASSERT_FALSE(runner.Run());
 161 }
 162
 163 TEST_F(ManifestTest, ApplicationElement_ValidVersion) {
 164   StepParseRunner runner(GetMyName());
 165   ASSERT_TRUE(runner.Run());
 166   manifest_x* m = runner.GetManifest();
 167   ASSERT_NE(m, nullptr);
 168   ASSERT_CSTR_EQ(m->api_version, "3.0");
 169 }
 170
 171 TEST_F(ManifestTest, ApplicationElement_InvalidVersion) {
 172   StepParseRunner runner(GetMyName());
 173   ASSERT_FALSE(runner.Run());
 174 }
 175
 176 TEST_F(ManifestTest, ApplicationElement_MissingVersion) {
 177   StepParseRunner runner(GetMyName());
 178   ASSERT_FALSE(runner.Run());
 179 }
 180
 181 TEST_F(ManifestTest, PrivilegeElement_ValidName) {
 182   StepParseRunner runner(GetMyName());
 183   ASSERT_TRUE(runner.Run());
 184   manifest_x* m = runner.GetManifest();
 185   ASSERT_NE(m, nullptr);
 186   std::vector<std::string> priv_vec;
 187   for (privilege_x* priv : GListRange<privilege_x*>(m->privileges)) {
 188     priv_vec.push_back(priv->value);
 189   }
 190   ASSERT_FALSE(priv_vec.empty());
 191   const char* expected_name = "http://tizen.org/privilege/application.launch";
 192   ASSERT_CSTR_EQ(priv_vec[0].c_str(), expected_name);
 193 }
 194
 195 TEST_F(ManifestTest, PrivilegeElement_ManyElements) {
 196   StepParseRunner runner(GetMyName());
 197   ASSERT_TRUE(runner.Run());
 198   manifest_x* m = runner.GetManifest();
 199   ASSERT_NE(m, nullptr);
 200   std::vector<std::string> priv_vec;
 201   for (privilege_x* priv : GListRange<privilege_x*>(m->privileges)) {
 202     priv_vec.push_back(priv->value);
 203   }
 204   ASSERT_EQ(priv_vec.size(), 2);
 205   const char* first_priv = "http://tizen.org/privilege/application.close";
 206   ASSERT_CSTR_EQ(priv_vec[0].c_str(), first_priv);
 207   const char* second_priv = "http://tizen.org/privilege/application.launch";
 208   ASSERT_CSTR_EQ(priv_vec[1].c_str(), second_priv);
 209 }
 210
 211 TEST_F(ManifestTest, PrivilegeElement_InvalidName) {
 212   StepParseRunner runner(GetMyName());
 213   ASSERT_FALSE(runner.Run());
 214 }
 215
 216 TEST_F(ManifestTest, PrivilegeElement_MissingName) {
 217   StepParseRunner runner(GetMyName());
 218   ASSERT_FALSE(runner.Run());
 219 }
 220
 221 TEST_F(ManifestTest, AppDefinedPrivilegeElement_Invalid_NotURI) {
 222   StepParseRunner runner(GetMyName());
 223   ASSERT_FALSE(runner.Run());
 224 }
 225
 226 TEST_F(ManifestTest, AppDefinedPrivilegeElement_Invalid_OverLength) {
 227   StepParseRunner runner(GetMyName());
 228   ASSERT_FALSE(runner.Run());
 229 }
 230
 231 TEST_F(ManifestTest, AppDefinedPrivilegeElement_ValidName) {
 232   StepParseRunner runner(GetMyName());
 233   ASSERT_TRUE(runner.Run());
 234   manifest_x* m = runner.GetManifest();
 235   ASSERT_NE(m, nullptr);
 236   std::vector<std::string> priv_vec;
 237   for (appdefined_privilege_x* priv :
 238       GListRange<appdefined_privilege_x*>(m->appdefined_privileges)) {
 239     priv_vec.push_back(priv->value);
 240   }
 241   ASSERT_FALSE(priv_vec.empty());
 242   const char* expected_name = "http://package0id/appdefined/test.read";
 243   ASSERT_CSTR_EQ(priv_vec[0].c_str(), expected_name);
 244 }
 245
 246 TEST_F(ManifestTest, AppDefinedPrivilegeElement_ManyElements) {
 247   StepParseRunner runner(GetMyName());
 248   ASSERT_TRUE(runner.Run());
 249   manifest_x* m = runner.GetManifest();
 250   ASSERT_NE(m, nullptr);
 251   std::vector<std::string> priv_vec;
 252   for (appdefined_privilege_x* priv :
 253       GListRange<appdefined_privilege_x*>(m->appdefined_privileges)) {
 254     priv_vec.push_back(priv->value);
 255   }
 256   ASSERT_EQ(priv_vec.size(), 2);
 257   const char* first_priv = "http://package0id/appdefined/test.read";
 258   ASSERT_CSTR_EQ(priv_vec[0].c_str(), first_priv);
 259   const char* second_priv = "http://package0id/appdefined/test.write";
 260   ASSERT_CSTR_EQ(priv_vec[1].c_str(), second_priv);
 261 }
 262
 263 TEST_F(ManifestTest, AppDefinedPrivilegeElement_WithLicenseValidName) {
 264   StepParseRunner runner(GetMyName());
 265   ASSERT_TRUE(runner.Run());
 266   manifest_x* m = runner.GetManifest();
 267   ASSERT_NE(m, nullptr);
 268   std::vector<std::string> priv_vec;
 269   std::vector<std::string> license_vec;
 270   for (appdefined_privilege_x* priv :
 271       GListRange<appdefined_privilege_x*>(m->appdefined_privileges)) {
 272     priv_vec.push_back(priv->value);
 273     license_vec.push_back(priv->license);
 274   }
 275   ASSERT_FALSE(priv_vec.empty());
 276   const char* expected_name = "http://package0id/appdefined/test.read";
 277   ASSERT_CSTR_EQ(priv_vec[0].c_str(), expected_name);
 278   ASSERT_FALSE(license_vec.empty());
 279   bf::path path(m->root_path);
 280   path /= "res/cert";
 281   ASSERT_CSTR_EQ(license_vec[0].c_str(), path.c_str());
 282 }
 283
 284 TEST_F(ManifestTest, AppDefinedPrivilegeElement_WithLicenseManyElements) {
 285   StepParseRunner runner(GetMyName());
 286   ASSERT_TRUE(runner.Run());
 287   manifest_x* m = runner.GetManifest();
 288   ASSERT_NE(m, nullptr);
 289   std::vector<std::string> priv_vec;
 290   std::vector<std::string> license_vec;
 291   for (appdefined_privilege_x* priv :
 292       GListRange<appdefined_privilege_x*>(m->appdefined_privileges)) {
 293     priv_vec.push_back(priv->value);
 294     license_vec.push_back(priv->license);
 295   }
 296   ASSERT_EQ(priv_vec.size(), 2);
 297   const char* first_priv = "http://package0id/appdefined/test.read";
 298   ASSERT_CSTR_EQ(priv_vec[0].c_str(), first_priv);
 299   const char* second_priv = "http://package0id/appdefined/test.write";
 300   ASSERT_CSTR_EQ(priv_vec[1].c_str(), second_priv);
 301   ASSERT_EQ(license_vec.size(), 2);
 302   bf::path path(m->root_path);
 303   path /= "res/cert";
 304   ASSERT_CSTR_EQ(license_vec[0].c_str(), path.c_str());
 305   ASSERT_CSTR_EQ(license_vec[1].c_str(), path.c_str());
 306 }
 307
 308 TEST_F(ManifestTest, AppDefinedPrivilegeElement_InvalidName) {
 309   StepParseRunner runner(GetMyName());
 310   ASSERT_FALSE(runner.Run());
 311 }
 312
 313 TEST_F(ManifestTest, AppDefinedPrivilegeElement_MissingName) {
 314   StepParseRunner runner(GetMyName());
 315   ASSERT_FALSE(runner.Run());
 316 }
 317
 318 TEST_F(ManifestTest, ProvidesAppDefinedPrivilegeElement_Invalid_NotURI) {
 319   StepParseRunner runner(GetMyName());
 320   ASSERT_FALSE(runner.Run());
 321 }
 322
 323 TEST_F(ManifestTest, ProvidesAppDefinedPrivilegeElement_Invalid_NoPKGID) {
 324   StepParseRunner runner(GetMyName());
 325   ASSERT_FALSE(runner.Run());
 326 }
 327
 328 TEST_F(ManifestTest, ProvidesAppDefinedPrivilegeElement_Invalid_OverLength) {
 329   StepParseRunner runner(GetMyName());
 330   ASSERT_FALSE(runner.Run());
 331 }
 332
 333 TEST_F(ManifestTest, ProvidesAppDefinedPrivilegeElement_ValidName) {
 334   StepParseRunner runner(GetMyName());
 335   ASSERT_TRUE(runner.Run());
 336   manifest_x* m = runner.GetManifest();
 337   ASSERT_NE(m, nullptr);
 338   std::vector<std::string> priv_vec;
 339   for (appdefined_privilege_x* priv : GListRange<appdefined_privilege_x*>(
 340       m->provides_appdefined_privileges)) {
 341     priv_vec.push_back(priv->value);
 342   }
 343   ASSERT_FALSE(priv_vec.empty());
 344   const char* expected_name = "http://package0id/appdefined/test.read";
 345   ASSERT_CSTR_EQ(priv_vec[0].c_str(), expected_name);
 346 }
 347
 348 TEST_F(ManifestTest, ProvidesAppDefinedPrivilegeElement_ManyElements) {
 349   StepParseRunner runner(GetMyName());
 350   ASSERT_TRUE(runner.Run());
 351   manifest_x* m = runner.GetManifest();
 352   ASSERT_NE(m, nullptr);
 353   std::vector<std::string> priv_vec;
 354   for (appdefined_privilege_x* priv : GListRange<appdefined_privilege_x*>(
 355       m->provides_appdefined_privileges)) {
 356     priv_vec.push_back(priv->value);
 357   }
 358   ASSERT_EQ(priv_vec.size(), 2);
 359   const char* first_priv = "http://package0id/appdefined/test.read";
 360   ASSERT_CSTR_EQ(priv_vec[0].c_str(), first_priv);
 361   const char* second_priv = "http://package0id/appdefined/test.write";
 362   ASSERT_CSTR_EQ(priv_vec[1].c_str(), second_priv);
 363 }
 364
 365 TEST_F(ManifestTest, ProvidesAppDefinedPrivilegeElement_WithLicenseValidName) {
 366   StepParseRunner runner(GetMyName());
 367   ASSERT_TRUE(runner.Run());
 368   manifest_x* m = runner.GetManifest();
 369   ASSERT_NE(m, nullptr);
 370   std::vector<std::string> priv_vec;
 371   std::vector<std::string> license_vec;
 372   for (appdefined_privilege_x* priv : GListRange<appdefined_privilege_x*>(
 373       m->provides_appdefined_privileges)) {
 374     priv_vec.push_back(priv->value);
 375     license_vec.push_back(priv->license);
 376   }
 377   ASSERT_FALSE(priv_vec.empty());
 378   const char* expected_name = "http://package0id/appdefined/test.read";
 379   ASSERT_CSTR_EQ(priv_vec[0].c_str(), expected_name);
 380   ASSERT_FALSE(license_vec.empty());
 381   bf::path path(m->root_path);
 382   path /= "res/cert";
 383   ASSERT_CSTR_EQ(license_vec[0].c_str(), path.c_str());
 384 }
 385
 386 TEST_F(ManifestTest,
 387        ProvidesAppDefinedPrivilegeElement_WithLicenseManyElements) {
 388   StepParseRunner runner(GetMyName());
 389   ASSERT_TRUE(runner.Run());
 390   manifest_x* m = runner.GetManifest();
 391   ASSERT_NE(m, nullptr);
 392   std::vector<std::string> priv_vec;
 393   std::vector<std::string> license_vec;
 394   for (appdefined_privilege_x* priv : GListRange<appdefined_privilege_x*>(
 395       m->provides_appdefined_privileges)) {
 396     priv_vec.push_back(priv->value);
 397     license_vec.push_back(priv->license);
 398   }
 399   ASSERT_EQ(priv_vec.size(), 2);
 400   const char* first_priv = "http://package0id/appdefined/test.read";
 401   ASSERT_CSTR_EQ(priv_vec[0].c_str(), first_priv);
 402   const char* second_priv = "http://package0id/appdefined/test.write";
 403   ASSERT_CSTR_EQ(priv_vec[1].c_str(), second_priv);
 404   ASSERT_EQ(license_vec.size(), 2);
 405   bf::path path(m->root_path);
 406   path /= "res/cert";
 407   ASSERT_CSTR_EQ(license_vec[0].c_str(), path.c_str());
 408   ASSERT_CSTR_EQ(license_vec[1].c_str(), path.c_str());
 409 }
 410
 411 TEST_F(ManifestTest, ProvidesAppDefinedPrivilegeElement_InvalidName) {
 412   StepParseRunner runner(GetMyName());
 413   ASSERT_FALSE(runner.Run());
 414 }
 415
 416 TEST_F(ManifestTest, ProvidesAppDefinedPrivilegeElement_MissingName) {
 417   StepParseRunner runner(GetMyName());
 418   ASSERT_FALSE(runner.Run());
 419 }
 420
 421 TEST_F(ManifestTest, AppControlElement_Valid) {
 422   StepParseRunner runner(GetMyName());
 423   ASSERT_TRUE(runner.Run());
 424   manifest_x* m = runner.GetManifest();
 425   ASSERT_NE(m, nullptr);
 426   auto apps = GListRange<application_x*>(m->application);
 427   application_x* app = *apps.begin();
 428   ASSERT_NE(app, nullptr);
 429   std::vector<appcontrol_x*> app_controls;
 430   for (appcontrol_x* app_control : GListRange<appcontrol_x*>(app->appcontrol)) {
 431     app_controls.push_back(app_control);
 432   }
 433   ASSERT_EQ(app_controls.size(), 1);
 434   ASSERT_CSTR_EQ(app_controls[0]->mime, "image/jpg");
 435   ASSERT_CSTR_EQ(app_controls[0]->operation,
 436                  "http://tizen.org/appcontrol/operation/edit");
 437   ASSERT_CSTR_EQ(app_controls[0]->uri, "myapp");
 438 }
 439
 440 TEST_F(ManifestTest, AppControlElement_MissingMIME) {
 441   StepParseRunner runner(GetMyName());
 442   ASSERT_TRUE(runner.Run());
 443   manifest_x* m = runner.GetManifest();
 444   ASSERT_NE(m, nullptr);
 445   auto apps = GListRange<application_x*>(m->application);
 446   application_x* app = *apps.begin();
 447   ASSERT_NE(app, nullptr);
 448   std::vector<appcontrol_x*> app_controls;
 449   for (appcontrol_x* app_control : GListRange<appcontrol_x*>(app->appcontrol)) {
 450     app_controls.push_back(app_control);
 451   }
 452   ASSERT_CSTR_EQ(app_controls[0]->mime, "");
 453 }
 454
 455 TEST_F(ManifestTest, AppControlElement_MissingOperation) {
 456   StepParseRunner runner(GetMyName());
 457   ASSERT_FALSE(runner.Run());
 458 }
 459
 460 TEST_F(ManifestTest, AppControlElement_MissingSrc) {
 461   StepParseRunner runner(GetMyName());
 462   ASSERT_FALSE(runner.Run());
 463 }
 464
 465 TEST_F(ManifestTest, AppControlElement_MissingURI) {
 466   StepParseRunner runner(GetMyName());
 467   ASSERT_TRUE(runner.Run());
 468   manifest_x* m = runner.GetManifest();
 469   ASSERT_NE(m, nullptr);
 470   auto apps = GListRange<application_x*>(m->application);
 471   application_x* app = *apps.begin();
 472   ASSERT_NE(app, nullptr);
 473   std::vector<appcontrol_x*> app_controls;
 474   for (appcontrol_x* app_control : GListRange<appcontrol_x*>(app->appcontrol)) {
 475     app_controls.push_back(app_control);
 476   }
 477   ASSERT_CSTR_EQ(app_controls[0]->uri, "");
 478 }
 479
 480 TEST_F(ManifestTest, SettingsElement_Valid) {
 481   StepParseRunner runner(GetMyName());
 482   ASSERT_TRUE(runner.Run());
 483   manifest_x* m = runner.GetManifest();
 484   ASSERT_NE(m, nullptr);
 485   auto backend_data = runner.GetBackendData();
 486   auto settings = backend_data->settings.get();
 487
 488   ASSERT_EQ(settings.background_support_enabled(), true);
 489   ASSERT_EQ(settings.context_menu_enabled(), false);
 490   ASSERT_EQ(settings.encryption_enabled(), true);
 491   ASSERT_EQ(settings.screen_orientation(),
 492             wgt::parse::SettingInfo::ScreenOrientation::LANDSCAPE);
 493   ASSERT_EQ(settings.install_location(),
 494             wgt::parse::SettingInfo::InstallLocation::INTERNAL);
 495   ASSERT_EQ(settings.hwkey_enabled(), true);
 496   ASSERT_EQ(settings.background_vibration(), true);
 497 }
 498
 499 TEST_F(ManifestTest, SettingsElement_BackgroundSupportEnabled) {
 500   StepParseRunner runner(GetMyName());
 501   ASSERT_TRUE(runner.Run());
 502   manifest_x* m = runner.GetManifest();
 503   ASSERT_NE(m, nullptr);
 504   auto backend_data = runner.GetBackendData();
 505   auto settings = backend_data->settings.get();
 506   ASSERT_EQ(settings.background_support_enabled(), true);
 507 }
 508
 509 TEST_F(ManifestTest, SettingsElement_BackgroundSupportDisabled) {
 510   StepParseRunner runner(GetMyName());
 511   ASSERT_TRUE(runner.Run());
 512   manifest_x* m = runner.GetManifest();
 513   ASSERT_NE(m, nullptr);
 514   auto backend_data = runner.GetBackendData();
 515   auto settings = backend_data->settings.get();
 516   ASSERT_EQ(settings.background_support_enabled(), false);
 517 }
 518
 519 TEST_F(ManifestTest, SettingsElement_MissingBackgroundSupport) {
 520   StepParseRunner runner(GetMyName());
 521   ASSERT_TRUE(runner.Run());
 522   manifest_x* m = runner.GetManifest();
 523   ASSERT_NE(m, nullptr);
 524   auto backend_data = runner.GetBackendData();
 525   auto settings = backend_data->settings.get();
 526   ASSERT_EQ(settings.background_support_enabled(), false);
 527 }
 528
 529 TEST_F(ManifestTest, SettingsElement_BackgroundVibrationEnabled) {
 530   StepParseRunner runner(GetMyName());
 531   ASSERT_TRUE(runner.Run());
 532   manifest_x* m = runner.GetManifest();
 533   ASSERT_NE(m, nullptr);
 534   auto backend_data = runner.GetBackendData();
 535   auto settings = backend_data->settings.get();
 536   ASSERT_EQ(settings.background_vibration(), true);
 537 }
 538
 539 TEST_F(ManifestTest, SettingsElement_BackgroundVibrationDisabled) {
 540   StepParseRunner runner(GetMyName());
 541   ASSERT_TRUE(runner.Run());
 542   manifest_x* m = runner.GetManifest();
 543   ASSERT_NE(m, nullptr);
 544   auto backend_data = runner.GetBackendData();
 545   auto settings = backend_data->settings.get();
 546   ASSERT_EQ(settings.background_vibration(), false);
 547 }
 548
 549 TEST_F(ManifestTest, SettingsElement_MissingBackgroundVibration) {
 550   StepParseRunner runner(GetMyName());
 551   ASSERT_TRUE(runner.Run());
 552   manifest_x* m = runner.GetManifest();
 553   ASSERT_NE(m, nullptr);
 554   auto backend_data = runner.GetBackendData();
 555   auto settings = backend_data->settings.get();
 556   ASSERT_EQ(settings.background_vibration(), false);
 557 }
 558
 559 TEST_F(ManifestTest, SettingsElement_ContextMenuEnabled) {
 560   StepParseRunner runner(GetMyName());
 561   ASSERT_TRUE(runner.Run());
 562   manifest_x* m = runner.GetManifest();
 563   ASSERT_NE(m, nullptr);
 564   auto backend_data = runner.GetBackendData();
 565   auto settings = backend_data->settings.get();
 566   ASSERT_EQ(settings.context_menu_enabled(), true);
 567 }
 568
 569 TEST_F(ManifestTest, SettingsElement_ContextMenuDisabled) {
 570   StepParseRunner runner(GetMyName());
 571   ASSERT_TRUE(runner.Run());
 572   manifest_x* m = runner.GetManifest();
 573   ASSERT_NE(m, nullptr);
 574   auto backend_data = runner.GetBackendData();
 575   auto settings = backend_data->settings.get();
 576   ASSERT_EQ(settings.context_menu_enabled(), false);
 577 }
 578
 579 TEST_F(ManifestTest, SettingsElement_MissingContextMenu) {
 580   StepParseRunner runner(GetMyName());
 581   ASSERT_TRUE(runner.Run());
 582   manifest_x* m = runner.GetManifest();
 583   ASSERT_NE(m, nullptr);
 584   auto backend_data = runner.GetBackendData();
 585   auto settings = backend_data->settings.get();
 586   ASSERT_EQ(settings.context_menu_enabled(), true);
 587 }
 588
 589 TEST_F(ManifestTest, SettingsElement_EncryptionEnabled) {
 590   StepParseRunner runner(GetMyName());
 591   ASSERT_TRUE(runner.Run());
 592   manifest_x* m = runner.GetManifest();
 593   ASSERT_NE(m, nullptr);
 594   auto backend_data = runner.GetBackendData();
 595   auto settings = backend_data->settings.get();
 596   ASSERT_EQ(settings.encryption_enabled(), true);
 597 }
 598
 599 TEST_F(ManifestTest, SettingsElement_EncryptionDisabled) {
 600   StepParseRunner runner(GetMyName());
 601   ASSERT_TRUE(runner.Run());
 602   manifest_x* m = runner.GetManifest();
 603   ASSERT_NE(m, nullptr);
 604   auto backend_data = runner.GetBackendData();
 605   auto settings = backend_data->settings.get();
 606   ASSERT_EQ(settings.encryption_enabled(), false);
 607 }
 608
 609 TEST_F(ManifestTest, SettingsElement_MissingEncryption) {
 610   StepParseRunner runner(GetMyName());
 611   ASSERT_TRUE(runner.Run());
 612   manifest_x* m = runner.GetManifest();
 613   ASSERT_NE(m, nullptr);
 614   auto backend_data = runner.GetBackendData();
 615   auto settings = backend_data->settings.get();
 616   ASSERT_EQ(settings.encryption_enabled(), false);
 617 }
 618
 619 TEST_F(ManifestTest, SettingsElement_HwKeyEnabled) {
 620   StepParseRunner runner(GetMyName());
 621   ASSERT_TRUE(runner.Run());
 622   manifest_x* m = runner.GetManifest();
 623   ASSERT_NE(m, nullptr);
 624   auto backend_data = runner.GetBackendData();
 625   auto settings = backend_data->settings.get();
 626   ASSERT_EQ(settings.hwkey_enabled(), true);
 627 }
 628
 629 TEST_F(ManifestTest, SettingsElement_HwKeyDisabled) {
 630   StepParseRunner runner(GetMyName());
 631   ASSERT_TRUE(runner.Run());
 632   manifest_x* m = runner.GetManifest();
 633   ASSERT_NE(m, nullptr);
 634   auto backend_data = runner.GetBackendData();
 635   auto settings = backend_data->settings.get();
 636   ASSERT_EQ(settings.hwkey_enabled(), false);
 637 }
 638
 639 TEST_F(ManifestTest, SettingsElement_MissingHwKeyEvent) {
 640   StepParseRunner runner(GetMyName());
 641   ASSERT_TRUE(runner.Run());
 642   manifest_x* m = runner.GetManifest();
 643   ASSERT_NE(m, nullptr);
 644   auto backend_data = runner.GetBackendData();
 645   auto settings = backend_data->settings.get();
 646   ASSERT_EQ(settings.hwkey_enabled(), true);
 647 }
 648
 649 TEST_F(ManifestTest, SettingsElement_MissingInstallLocation) {
 650   StepParseRunner runner(GetMyName());
 651   ASSERT_TRUE(runner.Run());
 652   manifest_x* m = runner.GetManifest();
 653   ASSERT_NE(m, nullptr);
 654   auto backend_data = runner.GetBackendData();
 655   auto settings = backend_data->settings.get();
 656   ASSERT_EQ(settings.install_location(),
 657             wgt::parse::SettingInfo::InstallLocation::AUTO);
 658 }
 659
 660 TEST_F(ManifestTest, SettingsElement_MissingScreenOrientation) {
 661   StepParseRunner runner(GetMyName());
 662   ASSERT_TRUE(runner.Run());
 663   manifest_x* m = runner.GetManifest();
 664   ASSERT_NE(m, nullptr);
 665   auto backend_data = runner.GetBackendData();
 666   auto settings = backend_data->settings.get();
 667   ASSERT_EQ(settings.screen_orientation(),
 668             wgt::parse::SettingInfo::ScreenOrientation::AUTO);
 669 }
 670
 671 TEST_F(ManifestTest, MetadataElement_Valid) {
 672   StepParseRunner runner(GetMyName());
 673   ASSERT_TRUE(runner.Run());
 674   manifest_x* m = runner.GetManifest();
 675   ASSERT_NE(m, nullptr);
 676   auto apps = GListRange<application_x*>(m->application);
 677   application_x* app = *apps.begin();
 678
 679   std::map<std::string, std::string> meta_data_map;
 680   for (metadata_x* meta_data : GListRange<metadata_x*>(app->metadata)) {
 681     if (meta_data->value)
 682       meta_data_map[meta_data->key] = meta_data->value;
 683     else
 684       meta_data_map[meta_data->key] = std::string();
 685   }
 686   ASSERT_EQ(meta_data_map.size(), 2);
 687   ASSERT_CSTR_EQ(meta_data_map["key1"].c_str(), "");
 688   ASSERT_CSTR_EQ(meta_data_map["key2"].c_str(), "value2");
 689 }
 690
 691 TEST_F(ManifestTest, MetadataElement_DuplicateKey) {
 692   StepParseRunner runner(GetMyName());
 693   ASSERT_TRUE(runner.Run());
 694   manifest_x* m = runner.GetManifest();
 695   ASSERT_NE(m, nullptr);
 696   auto apps = GListRange<application_x*>(m->application);
 697   application_x* app = *apps.begin();
 698
 699   std::map<std::string, std::string> meta_data_map;
 700   for (metadata_x* meta_data : GListRange<metadata_x*>(app->metadata)) {
 701     meta_data_map[meta_data->key] = meta_data->value;
 702   }
 703   ASSERT_EQ(meta_data_map.size(), 2);
 704   ASSERT_CSTR_EQ(meta_data_map["key1"].c_str(), "key1value");
 705   ASSERT_CSTR_EQ(meta_data_map["key2"].c_str(), "key2value");
 706 }
 707
 708 TEST_F(ManifestTest, MetadataElement_MissingValue) {
 709   StepParseRunner runner(GetMyName());
 710   ASSERT_TRUE(runner.Run());
 711   manifest_x* m = runner.GetManifest();
 712   ASSERT_NE(m, nullptr);
 713   auto apps = GListRange<application_x*>(m->application);
 714   application_x* app = *apps.begin();
 715
 716   std::map<std::string, std::string> meta_data_map;
 717   for (metadata_x* meta_data : GListRange<metadata_x*>(app->metadata)) {
 718     if (meta_data->value)
 719       meta_data_map[meta_data->key] = meta_data->value;
 720     else
 721       meta_data_map[meta_data->key] = std::string();
 722   }
 723   ASSERT_EQ(meta_data_map.size(), 2);
 724   ASSERT_CSTR_EQ(meta_data_map["key1"].c_str(), "");
 725   ASSERT_CSTR_EQ(meta_data_map["key2"].c_str(), "");
 726 }
 727
 728 TEST_F(ManifestTest, MetadataElement_MissingKey) {
 729   StepParseRunner runner(GetMyName());
 730   ASSERT_FALSE(runner.Run());
 731 }
 732
 733 TEST_F(ManifestTest, CategoryElement_Valid) {
 734   StepParseRunner runner(GetMyName());
 735   ASSERT_TRUE(runner.Run());
 736   manifest_x* m = runner.GetManifest();
 737   ASSERT_NE(m, nullptr);
 738   auto apps = GListRange<application_x*>(m->application);
 739   application_x* app = *apps.begin();
 740
 741   std::vector<std::string> categories;
 742   for (const char* category : GListRange<char*>(app->category)) {
 743     categories.push_back(category);
 744   }
 745   ASSERT_EQ(categories.size(), 1);
 746   ASSERT_CSTR_EQ(categories[0].c_str(),
 747                  "http://tizen.org/category/wearable_clock");
 748 }
 749
 750 TEST_F(ManifestTest, CategoryElement_MissingName) {
 751   StepParseRunner runner(GetMyName());
 752   ASSERT_FALSE(runner.Run());
 753 }
 754
 755 TEST_F(ManifestTest, CategoryElement_MultipleElements) {
 756   StepParseRunner runner(GetMyName());
 757   ASSERT_TRUE(runner.Run());
 758   manifest_x* m = runner.GetManifest();
 759   ASSERT_NE(m, nullptr);
 760   auto apps = GListRange<application_x*>(m->application);
 761   application_x* app = *apps.begin();
 762
 763   std::vector<std::string> categories;
 764   for (const char* category : GListRange<char*>(app->category)) {
 765     categories.push_back(category);
 766   }
 767   ASSERT_EQ(categories.size(), 3);
 768   ASSERT_CSTR_EQ(categories[0].c_str(),
 769                  "http://tizen.org/category/category_0");
 770   ASSERT_CSTR_EQ(categories[1].c_str(),
 771                  "http://tizen.org/category/category_1");
 772   ASSERT_CSTR_EQ(categories[2].c_str(),
 773                  "http://tizen.org/category/category_2");
 774 }
 775
 776 int main(int argc, char** argv) {
 777   int ret = -1;
 778   try {
 779     testing::InitGoogleTest(&argc, argv);
 780   } catch(...) {
 781     std::cout << "Exception occurred" << std::endl;
 782   }
 783
 784   try {
 785     ret = RUN_ALL_TESTS();
 786   } catch (const ::testing::internal::GoogleTestFailureException& e) {
 787     ret = -1;
 788     std::cout << "GoogleTestFailureException was thrown:" << e.what()
 789               << std::endl;
 790   }
 791
 792   return ret;
 793 }