ceph/src/boost/libs/stacktrace/test/test.cpp

   1 // Copyright Antony Polukhin, 2016-2017.
   2 //
   3 // Distributed under the Boost Software License, Version 1.0. (See
   4 // accompanying file LICENSE_1_0.txt or copy at
   5 // http://www.boost.org/LICENSE_1_0.txt)
   6
   7 #include <boost/stacktrace/stacktrace_fwd.hpp>
   8
   9 #include <boost/stacktrace.hpp>
  10 #include <stdexcept>
  11 #include <iostream>
  12 #include <sstream>
  13 #include <boost/core/lightweight_test.hpp>
  14
  15 #include <boost/functional/hash.hpp>
  16
  17
  18 using boost::stacktrace::stacktrace;
  19 using boost::stacktrace::frame;
  20
  21 #ifdef BOOST_STACKTRACE_DYN_LINK
  22 #   define BOOST_ST_API BOOST_SYMBOL_IMPORT
  23 #else
  24 #   define BOOST_ST_API
  25 #endif
  26
  27
  28 #if (defined(BOOST_GCC) && defined(BOOST_WINDOWS) && !defined(BOOST_STACKTRACE_USE_BACKTRACE) && !defined(BOOST_STACKTRACE_USE_ADDR2LINE)) \
  29     || defined(BOOST_STACKTRACE_TEST_NO_DEBUG_AT_ALL)
  30
  31 #   define BOOST_STACKTRACE_SYMNAME 0
  32 #else
  33 #   define BOOST_STACKTRACE_SYMNAME 1
  34 #endif
  35
  36 typedef std::pair<stacktrace, stacktrace> (*foo1_t)(int i);
  37 BOOST_ST_API std::pair<stacktrace, stacktrace> foo2(int i, foo1_t foo1);
  38 BOOST_ST_API stacktrace return_from_nested_namespaces();
  39 BOOST_ST_API boost::stacktrace::stacktrace bar1();
  40 BOOST_ST_API boost::stacktrace::stacktrace bar2();
  41
  42 BOOST_NOINLINE std::pair<stacktrace, stacktrace> foo1(int i) {
  43     if (i) {
  44         return foo2(i - 1, foo1);
  45     }
  46
  47     std::pair<stacktrace, stacktrace> ret;
  48     try {
  49         throw std::logic_error("test");
  50     } catch (const std::logic_error& /*e*/) {
  51         ret.second = stacktrace();
  52         return ret;
  53     }
  54 }
  55
  56 void test_deeply_nested_namespaces() {
  57     std::stringstream ss;
  58     ss << return_from_nested_namespaces();
  59     std::cout << ss.str() << '\n';
  60 #if BOOST_STACKTRACE_SYMNAME
  61     BOOST_TEST(ss.str().find("main") != std::string::npos);
  62
  63     BOOST_TEST(ss.str().find("get_backtrace_from_nested_namespaces") != std::string::npos
  64         || ss.str().find("1# return_from_nested_namespaces") != std::string::npos); // GCC with -O1 has strange inlining, so this line is true while the prev one is false.
  65
  66     BOOST_TEST(ss.str().find("return_from_nested_namespaces") != std::string::npos);
  67 #endif
  68
  69     stacktrace ns1 = return_from_nested_namespaces();
  70     BOOST_TEST(ns1 != return_from_nested_namespaces()); // Different addresses in test_deeply_nested_namespaces() function
  71 }
  72
  73 // Template parameter Depth is to produce different functions on each Depth. This simplifies debugging when one of the tests catches error
  74 template <std::size_t Depth>
  75 void test_nested() {
  76     std::pair<stacktrace, stacktrace> res = foo2(Depth, foo1);
  77
  78     std::stringstream ss1, ss2;
  79
  80     ss1 << res.first;
  81     ss2 << res.second;
  82     std::cout << "'" << ss1.str() << "'\n\n" << ss2.str() << std::endl;
  83     BOOST_TEST(!ss1.str().empty());
  84     BOOST_TEST(!ss2.str().empty());
  85
  86     BOOST_TEST(ss1.str().find(" 0# ") != std::string::npos);
  87     BOOST_TEST(ss2.str().find(" 0# ") != std::string::npos);
  88
  89     BOOST_TEST(ss1.str().find(" 1# ") != std::string::npos);
  90     BOOST_TEST(ss2.str().find(" 1# ") != std::string::npos);
  91
  92     BOOST_TEST(ss1.str().find(" in ") != std::string::npos);
  93     BOOST_TEST(ss2.str().find(" in ") != std::string::npos);
  94
  95 #if BOOST_STACKTRACE_SYMNAME
  96     BOOST_TEST(ss1.str().find("main") != std::string::npos);
  97     BOOST_TEST(ss2.str().find("main") != std::string::npos);
  98
  99     BOOST_TEST(ss1.str().find("foo2") != std::string::npos);
 100     BOOST_TEST(ss2.str().find("foo2") != std::string::npos);
 101
 102     BOOST_TEST(ss1.str().find("foo1") != std::string::npos);
 103     BOOST_TEST(ss2.str().find("foo1") != std::string::npos);
 104 #endif
 105
 106     //BOOST_TEST(false);
 107 }
 108
 109 template <class Bt>
 110 void test_comparisons_base(Bt nst, Bt st) {
 111     Bt cst(st);
 112     st = st;
 113     cst = cst;
 114     BOOST_TEST(nst);
 115     BOOST_TEST(st);
 116 #if !defined(BOOST_MSVC) && !defined(BOOST_STACKTRACE_USE_WINDBG)
 117     // This is very dependent on compiler and link flags. No sane way to make it work, because
 118     // BOOST_NOINLINE could be ignored by MSVC compiler if link-time optimization is enabled.
 119     BOOST_TEST(nst[0] != st[0]);
 120 #endif
 121
 122     BOOST_TEST(nst != st);
 123     BOOST_TEST(st != nst);
 124     BOOST_TEST(st == st);
 125     BOOST_TEST(nst == nst);
 126
 127     BOOST_TEST(nst != cst);
 128     BOOST_TEST(cst != nst);
 129     BOOST_TEST(cst == st);
 130     BOOST_TEST(cst == cst);
 131
 132     BOOST_TEST(nst < st || nst > st);
 133     BOOST_TEST(st < nst || nst < st);
 134     BOOST_TEST(st <= st);
 135     BOOST_TEST(nst <= nst);
 136     BOOST_TEST(st >= st);
 137     BOOST_TEST(nst >= nst);
 138
 139     BOOST_TEST(nst < cst || cst < nst);
 140     BOOST_TEST(nst > cst || cst > nst);
 141
 142
 143     BOOST_TEST(hash_value(nst) == hash_value(nst));
 144     BOOST_TEST(hash_value(cst) == hash_value(st));
 145
 146     BOOST_TEST(hash_value(nst) != hash_value(cst));
 147     BOOST_TEST(hash_value(st) != hash_value(nst));
 148 }
 149
 150 void test_comparisons() {
 151     stacktrace nst = return_from_nested_namespaces();
 152     stacktrace st;
 153     test_comparisons_base(nst, st);
 154 }
 155
 156 void test_iterators() {
 157     stacktrace st;
 158
 159     BOOST_TEST(st.begin() == st.begin());
 160     BOOST_TEST(st.cbegin() == st.cbegin());
 161     BOOST_TEST(st.crbegin() == st.crbegin());
 162     BOOST_TEST(st.rbegin() == st.rbegin());
 163
 164     BOOST_TEST(st.begin() + 1 == st.begin() + 1);
 165     BOOST_TEST(st.cbegin() + 1 == st.cbegin() + 1);
 166     BOOST_TEST(st.crbegin() + 1 == st.crbegin() + 1);
 167     BOOST_TEST(st.rbegin() + 1 == st.rbegin() + 1);
 168
 169     BOOST_TEST(st.end() == st.end());
 170     BOOST_TEST(st.cend() == st.cend());
 171     BOOST_TEST(st.crend() == st.crend());
 172     BOOST_TEST(st.rend() == st.rend());
 173
 174     BOOST_TEST(st.end() > st.begin());
 175     BOOST_TEST(st.end() > st.cbegin());
 176     BOOST_TEST(st.cend() > st.cbegin());
 177     BOOST_TEST(st.cend() > st.begin());
 178
 179     BOOST_TEST(st.size() == static_cast<std::size_t>(st.end() - st.begin()));
 180     BOOST_TEST(st.size() == static_cast<std::size_t>(st.end() - st.cbegin()));
 181     BOOST_TEST(st.size() == static_cast<std::size_t>(st.cend() - st.cbegin()));
 182     BOOST_TEST(st.size() == static_cast<std::size_t>(st.cend() - st.begin()));
 183
 184     BOOST_TEST(st.size() == static_cast<std::size_t>(std::distance(st.rbegin(), st.rend())));
 185     BOOST_TEST(st.size() == static_cast<std::size_t>(std::distance(st.crbegin(), st.rend())));
 186     BOOST_TEST(st.size() == static_cast<std::size_t>(std::distance(st.crbegin(), st.crend())));
 187     BOOST_TEST(st.size() == static_cast<std::size_t>(std::distance(st.rbegin(), st.crend())));
 188
 189
 190     boost::stacktrace::stacktrace::iterator it = st.begin();
 191     ++ it;
 192     BOOST_TEST(it == st.begin() + 1);
 193 }
 194
 195 void test_frame() {
 196     stacktrace nst = return_from_nested_namespaces();
 197     stacktrace st;
 198
 199     const std::size_t min_size = (nst.size() < st.size() ? nst.size() : st.size());
 200     BOOST_TEST(min_size > 2);
 201
 202     for (std::size_t i = 0; i < min_size; ++i) {
 203         BOOST_TEST(st[i] == st[i]);
 204         BOOST_TEST(st[i].source_file() == st[i].source_file());
 205         BOOST_TEST(st[i].source_line() == st[i].source_line());
 206         BOOST_TEST(st[i] <= st[i]);
 207         BOOST_TEST(st[i] >= st[i]);
 208
 209         frame fv = nst[i];
 210         BOOST_TEST(fv);
 211         if (i > 1 && i < min_size - 3) {       // Begin ...and end of the trace may match, skipping
 212             BOOST_TEST(st[i] != fv);
 213
 214 #if !(defined(BOOST_STACKTRACE_TEST_NO_DEBUG_AT_ALL) && defined(BOOST_MSVC))
 215             // MSVC can not get function name withhout debug symbols even if it is exported
 216             BOOST_TEST(st[i].name() != fv.name());
 217             BOOST_TEST(st[i] != fv);
 218             BOOST_TEST(st[i] < fv || st[i] > fv);
 219             BOOST_TEST(hash_value(st[i]) != hash_value(fv));
 220 #endif
 221
 222             if (st[i].source_line()) {
 223                 BOOST_TEST(st[i].source_file() != fv.source_file() || st[i].source_line() != fv.source_line());
 224             }
 225             BOOST_TEST(st[i]);
 226         }
 227
 228         fv = st[i];
 229         BOOST_TEST(hash_value(st[i]) == hash_value(fv));
 230     }
 231
 232     boost::stacktrace::frame empty_frame;
 233     BOOST_TEST(!empty_frame);
 234     BOOST_TEST(empty_frame.source_file() == "");
 235     BOOST_TEST(empty_frame.name() == "");
 236     BOOST_TEST(empty_frame.source_line() == 0);
 237 }
 238
 239 // Template parameter bool BySkip is to produce different functions on each BySkip. This simplifies debugging when one of the tests catches error
 240 template <bool BySkip>
 241 void test_empty_basic_stacktrace() {
 242     typedef boost::stacktrace::stacktrace st_t;
 243     st_t st = BySkip ? st_t(100500, 1024) :  st_t(0, 0);
 244
 245     BOOST_TEST(!st);
 246     BOOST_TEST(st.empty());
 247     BOOST_TEST(st.size() == 0);
 248     BOOST_TEST(st.begin() == st.end());
 249     BOOST_TEST(st.cbegin() == st.end());
 250     BOOST_TEST(st.cbegin() == st.cend());
 251     BOOST_TEST(st.begin() == st.cend());
 252
 253     BOOST_TEST(st.rbegin() == st.rend());
 254     BOOST_TEST(st.crbegin() == st.rend());
 255     BOOST_TEST(st.crbegin() == st.crend());
 256     BOOST_TEST(st.rbegin() == st.crend());
 257
 258     BOOST_TEST(hash_value(st) == hash_value(st_t(0, 0)));
 259     BOOST_TEST(st == st_t(0, 0));
 260     BOOST_TEST(!(st < st_t(0, 0)));
 261     BOOST_TEST(!(st > st_t(0, 0)));
 262 }
 263
 264 int main() {
 265     test_deeply_nested_namespaces();
 266     test_nested<15>();
 267     test_comparisons();
 268     test_iterators();
 269     test_frame();
 270     test_empty_basic_stacktrace<true>();
 271     test_empty_basic_stacktrace<false>();
 272
 273     BOOST_TEST(&bar1 != &bar2);
 274     boost::stacktrace::stacktrace b1 = bar1();
 275     BOOST_TEST(b1.size() == 4);
 276     boost::stacktrace::stacktrace b2 = bar2();
 277     BOOST_TEST(b2.size() == 4);
 278     test_comparisons_base(bar1(), bar2());
 279
 280     test_nested<300>();
 281     BOOST_TEST(boost::stacktrace::stacktrace(0, 1).size() == 1);
 282     BOOST_TEST(boost::stacktrace::stacktrace(1, 1).size() == 1);
 283
 284     return boost::report_errors();
 285 }