ceph/src/boost/libs/dll/test/shared_library_load_test.cpp

   1 // Copyright 2011-2012 Renato Tegon Forti
   2 // Copyright 2015 Antony Polukhin
   3 //
   4 // Distributed under the Boost Software License, Version 1.0.
   5 // (See accompanying file LICENSE_1_0.txt
   6 // or copy at http://www.boost.org/LICENSE_1_0.txt)
   7
   8 // For more information, see http://www.boost.org
   9
  10 #include "../example/b2_workarounds.hpp"
  11 #include <boost/dll.hpp>
  12 #include <boost/core/lightweight_test.hpp>
  13 #include <boost/filesystem.hpp>
  14 // Unit Tests
  15
  16
  17 inline boost::filesystem::path drop_version(const boost::filesystem::path& lhs) {
  18     boost::filesystem::path ext = lhs.filename().extension();
  19     if (ext.native().size() > 1 && std::isdigit(ext.string()[1])) {
  20         ext = lhs;
  21         ext.replace_extension().replace_extension().replace_extension();
  22         return ext;
  23     }
  24
  25     return lhs;
  26 }
  27
  28 inline bool lib_path_equal(const boost::filesystem::path& lhs, const boost::filesystem::path& rhs) {
  29     const bool res = (drop_version(lhs).filename() == drop_version(rhs).filename());
  30     if (!res) {
  31         std::cerr << "lhs != rhs: " << lhs << " != " << rhs << '\n';
  32     }
  33     return res;
  34 }
  35
  36 struct fs_copy_guard {
  37     const boost::filesystem::path actual_path_;
  38     const bool same_;
  39
  40     inline explicit fs_copy_guard(const boost::filesystem::path& shared_library_path)
  41         : actual_path_( drop_version(shared_library_path) )
  42         , same_(actual_path_ == shared_library_path)
  43     {
  44         if (!same_) {
  45             boost::system::error_code ignore;
  46             boost::filesystem::remove(actual_path_, ignore);
  47             boost::filesystem::copy(shared_library_path, actual_path_, ignore);
  48         }
  49     }
  50
  51     inline ~fs_copy_guard() {
  52         if (!same_) {
  53             boost::system::error_code ignore;
  54             boost::filesystem::remove(actual_path_, ignore);
  55         }
  56     }
  57 };
  58
  59 // Disgusting workarounds for b2 on Windows platform
  60 inline boost::filesystem::path do_find_correct_libs_path(int argc, char* argv[], const char* lib_name) {
  61     boost::filesystem::path ret;
  62
  63     for (int i = 1; i < argc; ++i) {
  64         ret = argv[i];
  65         if (ret.string().find(lib_name) != std::string::npos && b2_workarounds::is_shared_library(ret)) {
  66             return ret;
  67         }
  68     }
  69
  70     return lib_name;
  71 }
  72
  73 int main(int argc, char* argv[])
  74 {
  75     using namespace boost::dll;
  76
  77     BOOST_TEST(argc >= 3);
  78     boost::filesystem::path shared_library_path = do_find_correct_libs_path(argc, argv, "test_library");
  79     std::cout << "Library: " << shared_library_path;
  80
  81     {
  82         shared_library sl(shared_library_path);
  83         BOOST_TEST(sl.is_loaded());
  84         BOOST_TEST(lib_path_equal(sl.location(), shared_library_path));
  85
  86         shared_library sl2;
  87         BOOST_TEST(!sl2.is_loaded());
  88         BOOST_TEST(!sl2);
  89
  90         swap(sl, sl2);
  91         BOOST_TEST(!sl.is_loaded());
  92         BOOST_TEST(!sl);
  93         BOOST_TEST(sl2.is_loaded());
  94         BOOST_TEST(sl2);
  95
  96         sl.assign(sl2);
  97         BOOST_TEST(sl.is_loaded());
  98         BOOST_TEST(sl);
  99         BOOST_TEST(sl2.is_loaded());
 100         BOOST_TEST(sl2);
 101         BOOST_TEST(sl2.location() == sl.location());
 102
 103         sl.assign(sl2);
 104         BOOST_TEST(sl.is_loaded());
 105         BOOST_TEST(sl);
 106         BOOST_TEST(sl2.is_loaded());
 107         BOOST_TEST(sl2);
 108         BOOST_TEST(sl2.location() == sl.location());
 109
 110         sl2.assign(sl);
 111         BOOST_TEST(sl.is_loaded());
 112         BOOST_TEST(sl);
 113         BOOST_TEST(sl2.is_loaded());
 114         BOOST_TEST(sl2);
 115         BOOST_TEST(sl2.location() == sl.location());
 116
 117         // Assigning an empty shared library
 118         sl2.assign(shared_library());
 119         BOOST_TEST(sl.is_loaded());
 120         BOOST_TEST(sl);
 121         BOOST_TEST(!sl2.is_loaded());
 122         BOOST_TEST(!sl2);
 123         boost::system::error_code ec;
 124         BOOST_TEST(sl2.location(ec) != sl.location());
 125         BOOST_TEST(ec);
 126    }
 127
 128    {
 129         boost::system::error_code ec;
 130         shared_library sl(shared_library_path, ec);
 131         BOOST_TEST(sl.is_loaded());
 132         BOOST_TEST(sl);
 133         BOOST_TEST(!ec);
 134         BOOST_TEST(lib_path_equal(sl.location(), shared_library_path));
 135         BOOST_TEST(lib_path_equal(sl.location(ec), shared_library_path));
 136         BOOST_TEST(!ec);
 137
 138         // Checking self assignment #1
 139         sl.assign(sl);
 140         BOOST_TEST(sl.is_loaded());
 141         BOOST_TEST(sl);
 142         BOOST_TEST(!ec);
 143         BOOST_TEST(lib_path_equal(sl.location(), shared_library_path));
 144         BOOST_TEST(lib_path_equal(sl.location(ec), shared_library_path));
 145
 146         // Checking self assignment #2
 147         sl.assign(sl, ec);
 148         BOOST_TEST(sl.is_loaded());
 149         BOOST_TEST(sl);
 150         BOOST_TEST(!ec);
 151         BOOST_TEST(lib_path_equal(sl.location(), shared_library_path));
 152         BOOST_TEST(lib_path_equal(sl.location(ec), shared_library_path));
 153    }
 154
 155    {
 156         shared_library sl;
 157         BOOST_TEST(!sl.is_loaded());
 158
 159         sl.assign(sl);
 160         BOOST_TEST(!sl);
 161
 162         shared_library sl2(sl);
 163         BOOST_TEST(!sl);
 164         BOOST_TEST(!sl2);
 165
 166         sl2.assign(sl);
 167         BOOST_TEST(!sl);
 168         BOOST_TEST(!sl2);
 169    }
 170
 171    {
 172         shared_library sl;
 173         sl.load(shared_library_path);
 174         BOOST_TEST(sl.is_loaded());
 175         BOOST_TEST(sl);
 176         BOOST_TEST(lib_path_equal(sl.location(), shared_library_path));
 177    }
 178
 179    {
 180         shared_library sl;
 181         boost::system::error_code ec;
 182         sl.load(shared_library_path, ec);
 183         BOOST_TEST(sl.is_loaded());
 184         BOOST_TEST(sl);
 185         BOOST_TEST(!ec);
 186         BOOST_TEST(lib_path_equal(sl.location(), shared_library_path));
 187    }
 188
 189    {
 190         shared_library sl(shared_library_path, load_mode::load_with_altered_search_path );
 191         BOOST_TEST(sl.is_loaded());
 192         BOOST_TEST(sl);
 193         BOOST_TEST(lib_path_equal(sl.location(), shared_library_path));
 194    }
 195
 196    {
 197         boost::system::error_code ec;
 198         shared_library sl(shared_library_path, load_mode::load_with_altered_search_path, ec);
 199         BOOST_TEST(sl.is_loaded());
 200         BOOST_TEST(sl);
 201         BOOST_TEST(!ec);
 202         BOOST_TEST(lib_path_equal(sl.location(), shared_library_path));
 203         BOOST_TEST(lib_path_equal(sl.location(ec), shared_library_path));
 204         BOOST_TEST(!ec);
 205    }
 206
 207    {
 208         boost::system::error_code ec;
 209         shared_library sl(shared_library_path, load_mode::search_system_folders, ec);
 210         BOOST_TEST(sl.is_loaded());
 211         BOOST_TEST(sl);
 212         BOOST_TEST(!ec);
 213         BOOST_TEST(lib_path_equal(sl.location(), shared_library_path));
 214         BOOST_TEST(lib_path_equal(sl.location(ec), shared_library_path));
 215         BOOST_TEST(!ec);
 216    }
 217
 218    {
 219         try {
 220 #if BOOST_OS_WINDOWS
 221             boost::dll::shared_library("winmm.dll");
 222 #elif BOOST_OS_LINUX
 223             boost::dll::shared_library("libdl.so");
 224 #endif
 225             BOOST_TEST(false);
 226         } catch (...) {}
 227    }
 228
 229    {
 230         try {
 231 #if BOOST_OS_WINDOWS
 232             boost::dll::shared_library("winmm", load_mode::search_system_folders | load_mode::append_decorations);
 233 #elif BOOST_OS_LINUX
 234             boost::dll::shared_library("dl", boost::dll::load_mode::search_system_folders | load_mode::append_decorations);
 235 #endif
 236         } catch (...) {
 237             BOOST_TEST(false);
 238         }
 239    }
 240
 241    {
 242         shared_library sl;
 243         sl.load(shared_library_path, load_mode::load_with_altered_search_path);
 244         BOOST_TEST(sl.is_loaded());
 245         BOOST_TEST(sl);
 246         BOOST_TEST(lib_path_equal(sl.location(), shared_library_path));
 247    }
 248
 249    {
 250         shared_library sl;
 251         boost::system::error_code ec;
 252         sl.load(shared_library_path, load_mode::load_with_altered_search_path, ec);
 253         BOOST_TEST(sl.is_loaded());
 254         BOOST_TEST(sl);
 255         BOOST_TEST(lib_path_equal(sl.location(), shared_library_path));
 256    }
 257
 258    {
 259         shared_library sl(shared_library_path, load_mode::rtld_lazy | load_mode::rtld_global);
 260         BOOST_TEST(sl.is_loaded());
 261         BOOST_TEST(sl);
 262         BOOST_TEST(lib_path_equal(sl.location(), shared_library_path));
 263    }
 264
 265    {
 266         shared_library sl(shared_library_path, load_mode::rtld_local);
 267         BOOST_TEST(sl.is_loaded());
 268         BOOST_TEST(sl);
 269         BOOST_TEST(lib_path_equal(sl.location(), shared_library_path));
 270    }
 271
 272    {
 273         shared_library sl(shared_library_path, load_mode::rtld_now);
 274         BOOST_TEST(sl.is_loaded());
 275         BOOST_TEST(sl);
 276         BOOST_TEST(lib_path_equal(sl.location(), shared_library_path));
 277    }
 278
 279    {
 280         fs_copy_guard guard(shared_library_path);
 281
 282         boost::filesystem::path platform_independent_path = guard.actual_path_;
 283         platform_independent_path.replace_extension();
 284         if (platform_independent_path.filename().wstring().find(L"lib") == 0) {
 285             platform_independent_path
 286                 = platform_independent_path.parent_path() / platform_independent_path.filename().wstring().substr(3);
 287         }
 288         std::cerr << "platform_independent_path: " << platform_independent_path << '\n';
 289
 290         shared_library sl(platform_independent_path, load_mode::append_decorations);
 291         BOOST_TEST(sl.is_loaded());
 292         BOOST_TEST(sl);
 293         BOOST_TEST(lib_path_equal(sl.location(), shared_library_path));
 294
 295         sl.unload();
 296         BOOST_TEST(!sl.is_loaded());
 297         BOOST_TEST(!sl);
 298    }
 299
 300    {
 301         shared_library sl(shared_library_path, load_mode::rtld_now | load_mode::rtld_global | load_mode::load_with_altered_search_path);
 302         BOOST_TEST(sl.is_loaded());
 303         BOOST_TEST(sl);
 304    }
 305
 306    {
 307         boost::system::error_code ec;
 308         shared_library sl(shared_library_path, load_mode::rtld_lazy | load_mode::rtld_global, ec);
 309         BOOST_TEST(sl.is_loaded());
 310         BOOST_TEST(sl);
 311         BOOST_TEST(!ec);
 312         BOOST_TEST(lib_path_equal(sl.location(), shared_library_path));
 313    }
 314
 315    {
 316         shared_library sl;
 317         sl.load(shared_library_path, load_mode::rtld_lazy | load_mode::rtld_global);
 318         BOOST_TEST(sl.is_loaded());
 319         BOOST_TEST(sl);
 320         BOOST_TEST(lib_path_equal(sl.location(), shared_library_path));
 321    }
 322
 323
 324    {    // Non-default flags with assignment
 325         shared_library sl(shared_library_path,
 326             load_mode::rtld_now | load_mode::rtld_global | load_mode::load_with_altered_search_path | load_mode::rtld_deepbind
 327         );
 328         BOOST_TEST(sl.is_loaded());
 329         BOOST_TEST(sl);
 330
 331         boost::system::error_code ec;
 332         shared_library sl2(sl, ec);
 333         BOOST_TEST(!ec);
 334         BOOST_TEST(sl.is_loaded());
 335         BOOST_TEST(sl);
 336         BOOST_TEST(sl2.is_loaded());
 337         BOOST_TEST(sl2);
 338         BOOST_TEST(sl2.location() == sl.location());
 339
 340         shared_library sl3(sl);
 341         BOOST_TEST(sl.is_loaded());
 342         BOOST_TEST(sl);
 343         BOOST_TEST(sl3.is_loaded());
 344         BOOST_TEST(sl3);
 345
 346         shared_library sl4;
 347         sl4.assign(sl, ec);
 348         BOOST_TEST(!ec);
 349         BOOST_TEST(sl.is_loaded());
 350         BOOST_TEST(sl);
 351         BOOST_TEST(sl4.is_loaded());
 352         BOOST_TEST(sl4);
 353    }
 354
 355    {    // Non-default flags with assignment and error_code
 356         boost::system::error_code ec;
 357         shared_library sl(shared_library_path, load_mode::rtld_lazy | load_mode::rtld_global, ec);
 358         BOOST_TEST(sl.is_loaded());
 359         BOOST_TEST(sl);
 360         BOOST_TEST(!ec);
 361         BOOST_TEST(lib_path_equal(sl.location(), shared_library_path));
 362
 363         shared_library sl2(sl, ec);
 364         BOOST_TEST(!ec);
 365         BOOST_TEST(sl.is_loaded());
 366         BOOST_TEST(sl);
 367         BOOST_TEST(sl2.is_loaded());
 368         BOOST_TEST(sl2);
 369         BOOST_TEST(sl2.location() == sl.location());
 370
 371         shared_library sl3(sl);
 372         BOOST_TEST(sl.is_loaded());
 373         BOOST_TEST(sl);
 374         BOOST_TEST(sl3.is_loaded());
 375         BOOST_TEST(sl3);
 376         BOOST_TEST(sl3.location() == sl.location());
 377    }
 378
 379    {  // self_load
 380         shared_library sl(program_location());
 381         BOOST_TEST(sl.is_loaded());
 382         BOOST_TEST(sl);
 383         std::cout << "\nProgram location: " << program_location();
 384         std::cout << "\nLibrary location: " << sl.location();
 385         BOOST_TEST( boost::filesystem::equivalent(sl.location(), program_location()) );
 386
 387         boost::system::error_code ec;
 388         shared_library sl2(program_location());
 389         BOOST_TEST(sl2.is_loaded());
 390         BOOST_TEST( boost::filesystem::equivalent(sl2.location(), program_location()) );
 391         BOOST_TEST(sl2);
 392         BOOST_TEST(!ec);
 393
 394         BOOST_TEST(sl == sl2);
 395         BOOST_TEST(!(sl < sl2 || sl2 <sl));
 396         BOOST_TEST(!(sl != sl2));
 397
 398         sl.load(shared_library_path);
 399         BOOST_TEST(sl != sl2);
 400         BOOST_TEST(sl < sl2 || sl2 <sl);
 401         BOOST_TEST(!(sl == sl2));
 402
 403         sl.unload();
 404         BOOST_TEST(!sl);
 405         BOOST_TEST(sl != sl2);
 406         BOOST_TEST(sl < sl2 || sl2 <sl);
 407         BOOST_TEST(!(sl == sl2));
 408
 409         sl2.unload();
 410         BOOST_TEST(!sl2);
 411         BOOST_TEST(sl == sl2);
 412         BOOST_TEST(!(sl < sl2 || sl2 <sl));
 413         BOOST_TEST(!(sl != sl2));
 414
 415         // assigning self
 416         sl.load(program_location());
 417         sl2 = sl;
 418         BOOST_TEST(sl == sl2);
 419         BOOST_TEST(sl.location() == sl2.location());
 420    }
 421
 422    {
 423         shared_library sl;
 424         boost::system::error_code ec;
 425         sl.load(shared_library_path, load_mode::rtld_lazy | load_mode::rtld_global, ec);
 426         BOOST_TEST(sl.is_loaded());
 427         BOOST_TEST(sl);
 428         BOOST_TEST(!ec);
 429         BOOST_TEST(lib_path_equal(sl.location(), shared_library_path));
 430
 431         sl.load(program_location());
 432         BOOST_TEST(sl.is_loaded());
 433         BOOST_TEST(sl);
 434
 435         sl.load(program_location());
 436         BOOST_TEST(sl.is_loaded());
 437         BOOST_TEST(sl);
 438         BOOST_TEST(!ec);
 439    }
 440
 441    {  // self_load
 442         shared_library sl;
 443         boost::system::error_code ec;
 444         sl.load(program_location());
 445         BOOST_TEST(sl.is_loaded());
 446         BOOST_TEST(sl);
 447         BOOST_TEST(!ec);
 448    }
 449
 450    {  // unload
 451         shared_library sl(shared_library_path);
 452         BOOST_TEST(sl.is_loaded());
 453         BOOST_TEST(sl);
 454         BOOST_TEST(lib_path_equal(sl.location(), shared_library_path));
 455         sl.unload();
 456         BOOST_TEST(!sl.is_loaded());
 457         BOOST_TEST(!sl);
 458    }
 459
 460
 461    {  // error_code load calls test
 462         boost::system::error_code ec;
 463         shared_library sl(shared_library_path / "dir_that_does_not_exist", ec);
 464         BOOST_TEST(ec);
 465         BOOST_TEST(!sl.is_loaded());
 466         BOOST_TEST(!sl);
 467
 468         boost::filesystem::path bad_path(shared_library_path);
 469         bad_path += ".1.1.1.1.1.1";
 470         sl.load(bad_path, ec);
 471         BOOST_TEST(ec);
 472         BOOST_TEST(!sl.is_loaded());
 473         BOOST_TEST(!sl);
 474
 475         sl.load(shared_library_path, ec);
 476         BOOST_TEST(!ec);
 477         BOOST_TEST(sl.is_loaded());
 478         BOOST_TEST(sl);
 479
 480         shared_library sl2(bad_path, ec);
 481         BOOST_TEST(ec);
 482         BOOST_TEST(!sl2.is_loaded());
 483         BOOST_TEST(!sl2);
 484
 485         shared_library sl3(shared_library_path, ec);
 486         BOOST_TEST(!ec);
 487         BOOST_TEST(sl3.is_loaded());
 488         BOOST_TEST(sl3);
 489
 490         sl.load("", ec);
 491         BOOST_TEST(ec);
 492         BOOST_TEST(!sl.is_loaded());
 493         BOOST_TEST(!sl);
 494    }
 495
 496
 497     shared_library_path = do_find_correct_libs_path(argc, argv, "library1");
 498     fs_copy_guard guard(shared_library_path);
 499     shared_library starts_with_lib(
 500         boost::filesystem::path(guard.actual_path_).replace_extension(),
 501         load_mode::append_decorations
 502     );
 503
 504     starts_with_lib.load(
 505         boost::filesystem::path(guard.actual_path_).replace_extension(),
 506         load_mode::append_decorations
 507     );
 508
 509    return boost::report_errors();
 510 }