ceph/src/boost/libs/process/test/environment.cpp

   1 // Copyright (c) 2006, 2007 Julio M. Merino Vidal
   2 // Copyright (c) 2008 Ilya Sokolov, Boris Schaeling
   3 // Copyright (c) 2009 Boris Schaeling
   4 // Copyright (c) 2010 Felipe Tanus, Boris Schaeling
   5 // Copyright (c) 2011, 2012 Jeff Flinn, Boris Schaeling
   6 //
   7 // Distributed under the Boost Software License, Version 1.0. (See accompanying
   8 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
   9
  10 #define BOOST_TEST_MAIN
  11 #define BOOST_TEST_IGNORE_SIGCHLD
  12 #include <boost/test/included/unit_test.hpp>
  13 #include <boost/process/environment.hpp>
  14
  15 namespace bp = boost::process;
  16
  17
  18 namespace std
  19 {
  20 std::ostream & operator<<(std::ostream & str, const std::wstring & ws)
  21 {
  22     str << bp::detail::convert(ws);
  23     return str;
  24 }
  25 }
  26
  27 BOOST_AUTO_TEST_CASE(empty,  *boost::unit_test::timeout(5))
  28 {
  29     bp::environment ev ;
  30     BOOST_CHECK(ev.empty());
  31     BOOST_CHECK_EQUAL(ev.size(), 0u);
  32     BOOST_CHECK_EQUAL(ev.end() - ev.begin(), 0);
  33     ev["Thingy"] = "My value";
  34
  35     BOOST_CHECK(!ev.empty());
  36     BOOST_CHECK_EQUAL(ev.size(), 1u);
  37     BOOST_CHECK_EQUAL(ev.end() - ev.begin(), 1);
  38
  39     for (auto  x : ev)
  40     {
  41         BOOST_CHECK_EQUAL(x.to_string(), "My value");
  42         BOOST_CHECK_EQUAL(x.get_name(), "Thingy");
  43     }
  44
  45     ev["Thingy"].clear();
  46     BOOST_CHECK(ev.empty());
  47     BOOST_CHECK_EQUAL(ev.size(), 0u);
  48     BOOST_CHECK_EQUAL(ev.end() - ev.begin(), 0);
  49     ev.clear();
  50 }
  51
  52 BOOST_AUTO_TEST_CASE(wempty,  *boost::unit_test::timeout(5))
  53 {
  54     bp::wenvironment ev ;
  55     BOOST_CHECK(ev.empty());
  56     BOOST_CHECK_EQUAL(ev.size(), 0u);
  57     BOOST_CHECK_EQUAL(ev.end() - ev.begin(), 0);
  58     ev[L"Thingy"] = L"My value";
  59
  60     BOOST_CHECK(!ev.empty());
  61     BOOST_CHECK_EQUAL(ev.size(), 1u);
  62     BOOST_CHECK_EQUAL(ev.end() - ev.begin(), 1);
  63
  64     for (auto  x : ev)
  65     {
  66         BOOST_CHECK(x.to_string() == L"My value");
  67         BOOST_CHECK(x.get_name()  == L"Thingy");
  68     }
  69
  70     ev[L"Thingy"].clear();
  71     BOOST_CHECK(ev.empty());
  72     BOOST_CHECK_EQUAL(ev.size(), 0u);
  73     BOOST_CHECK_EQUAL(ev.end() - ev.begin(), 0);
  74     ev.clear();
  75 }
  76
  77 BOOST_AUTO_TEST_CASE(compare,  *boost::unit_test::timeout(5))
  78 {
  79     auto nat = boost::this_process::environment();
  80     bp::environment env = nat;
  81
  82     {
  83         BOOST_CHECK_EQUAL(nat.size(), env.size());
  84         auto ni = nat.begin();
  85         auto ei = env.begin();
  86
  87         while ((ni != nat.end()) &&(ei != env.end()))
  88         {
  89             BOOST_CHECK_EQUAL(ni->get_name(),  ei->get_name());
  90             BOOST_CHECK_EQUAL(ni->to_string(), ei->to_string());
  91             ni++; ei++;
  92         }
  93     }
  94
  95     //ok check if I can convert it.
  96     bp::wenvironment wenv{env};
  97     auto wnat = boost::this_process::wenvironment();
  98     BOOST_CHECK_EQUAL(wenv.size(), env.size());
  99     BOOST_CHECK_EQUAL(wnat.size(), nat.size());
 100     {
 101         BOOST_CHECK_EQUAL(wnat.size(), wenv.size());
 102         auto ni = wnat.begin();
 103         auto ei = wenv.begin();
 104
 105         while ((ni != wnat.end()) && (ei != wenv.end()))
 106         {
 107             BOOST_CHECK_EQUAL(ni->get_name() , ei->get_name());
 108             BOOST_CHECK_EQUAL(ni->to_string(), ei->to_string());
 109             ni++; ei++;
 110         }
 111
 112         BOOST_CHECK(ni == wnat.end());
 113     }
 114     BOOST_TEST_PASSPOINT();
 115     env.clear();
 116     BOOST_TEST_PASSPOINT();
 117     wenv.clear();
 118     BOOST_TEST_PASSPOINT();
 119 }
 120
 121 BOOST_AUTO_TEST_CASE(insert_remove,  *boost::unit_test::timeout(5))
 122 {
 123     bp::environment env(boost::this_process::environment());
 124
 125     auto sz = env.size();
 126     BOOST_REQUIRE_GE(sz, 1u);
 127     BOOST_REQUIRE_EQUAL(env.count("BOOST_TEST_VAR"), 0u);
 128
 129     env["BOOST_TEST_VAR"] = {"some string", "badabumm"};
 130
 131 #if defined(BOOST_WINDOWS_API)
 132     BOOST_CHECK_EQUAL(env["BOOST_TEST_VAR"].to_string(), "some string;badabumm");
 133 #else
 134     BOOST_CHECK_EQUAL(env["BOOST_TEST_VAR"].to_string(), "some string:badabumm");
 135 #endif
 136     BOOST_CHECK_EQUAL(sz +1, env.size());
 137
 138     env["BOOST_TEST_VAR"].clear();
 139
 140     BOOST_CHECK_EQUAL(env.size(), sz);
 141
 142     env.clear();
 143
 144 }
 145
 146 BOOST_AUTO_TEST_CASE(clear_empty_my,  *boost::unit_test::timeout(5))
 147 {
 148     bp::native_environment env;
 149
 150     bp::environment e = env;
 151
 152     const std::size_t sz = env.size();
 153
 154     BOOST_TEST_MESSAGE("Current native size: " << sz);
 155
 156     BOOST_REQUIRE_EQUAL(env.count("BOOST_PROCESS_TEST_VAR_a"), 0u);
 157     BOOST_REQUIRE_EQUAL(env.count("BOOST_PROCESS_TEST_VAR_b"), 0u);
 158     BOOST_REQUIRE_EQUAL(env.count("BOOST_PROCESS_TEST_VAR_c"), 0u);
 159
 160     env["BOOST_PROCESS_TEST_VAR_a"] = "1";
 161     env["BOOST_PROCESS_TEST_VAR_b"] = "2";
 162     BOOST_CHECK(env.emplace("BOOST_PROCESS_TEST_VAR_c", "3").second);
 163
 164     BOOST_CHECK_EQUAL(env.count("BOOST_PROCESS_TEST_VAR_a"), 1u);
 165     BOOST_CHECK_EQUAL(env.count("BOOST_PROCESS_TEST_VAR_b"), 1u);
 166     BOOST_CHECK_EQUAL(env.count("BOOST_PROCESS_TEST_VAR_c"), 1u);
 167
 168     BOOST_CHECK_EQUAL(env.at("BOOST_PROCESS_TEST_VAR_a").to_string(), "1");
 169     BOOST_CHECK_EQUAL(env.at("BOOST_PROCESS_TEST_VAR_b").to_string(), "2");
 170     BOOST_CHECK_EQUAL(env.at("BOOST_PROCESS_TEST_VAR_c").to_string(), "3");
 171     BOOST_CHECK_EQUAL(env.size(), sz + 3u);
 172     BOOST_CHECK_EQUAL(std::distance(env.begin(),  env.end()),  sz + 3);
 173     BOOST_CHECK_EQUAL(std::distance(env.cbegin(), env.cend()), sz + 3);
 174
 175     env.erase("BOOST_PROCESS_TEST_VAR_a");
 176     BOOST_CHECK_EQUAL(env.size(), sz + 2u);
 177     BOOST_CHECK_EQUAL(env.count("BOOST_PROCESS_TEST_VAR_a"), 0u);
 178     BOOST_CHECK_EQUAL(env.at   ("BOOST_PROCESS_TEST_VAR_b").to_string(), "2");
 179     BOOST_CHECK_EQUAL(env.at   ("BOOST_PROCESS_TEST_VAR_c").to_string(), "3");
 180
 181     BOOST_CHECK_EQUAL(std::distance(env.begin(),  env.end()),  sz + 2);
 182     BOOST_CHECK_EQUAL(std::distance(env.cbegin(), env.cend()), sz + 2);
 183
 184     env.erase("BOOST_PROCESS_TEST_VAR_b");
 185     BOOST_CHECK_EQUAL(env.size(), sz + 1u);
 186     BOOST_CHECK_EQUAL(env.count("BOOST_PROCESS_TEST_VAR_a"), 0u);
 187     BOOST_CHECK_EQUAL(env.count("BOOST_PROCESS_TEST_VAR_b"), 0u);
 188     BOOST_CHECK_EQUAL(env.at   ("BOOST_PROCESS_TEST_VAR_c").to_string(), "3");
 189
 190     BOOST_CHECK_EQUAL(std::distance(env.begin(),  env.end()),  sz + 1);
 191     BOOST_CHECK_EQUAL(std::distance(env.cbegin(), env.cend()), sz + 1);
 192
 193     env.clear();
 194     //note: windows puts an entry without a name into the list, so it might not be empty after clear.
 195     BOOST_CHECK_LE(env.size(), sz);
 196
 197     BOOST_CHECK_LE(std::distance(env.begin(),  env.end()),  sz);
 198     BOOST_CHECK_LE(std::distance(env.cbegin(), env.cend()), sz);
 199
 200     for (auto && ee : e)
 201         env.emplace(ee.get_name(), ee.to_string());
 202 }
 203
 204 BOOST_AUTO_TEST_CASE(clear_empty,  *boost::unit_test::timeout(5))
 205 {
 206     bp::environment env;
 207     BOOST_CHECK(env.empty());
 208     BOOST_CHECK_EQUAL(env.size(), 0u);
 209     env["a"] = "1";
 210     env["b"] = "2";
 211     env["c"] = "3";
 212
 213     BOOST_CHECK_EQUAL(env.at("a").to_string(), "1");
 214     BOOST_CHECK_EQUAL(env.at("b").to_string(), "2");
 215     BOOST_CHECK_EQUAL(env.at("c").to_string(), "3");
 216     BOOST_CHECK_EQUAL(env.size(), 3u);
 217     BOOST_CHECK_EQUAL(std::distance(env.begin(), env.end()), 3u);
 218     BOOST_CHECK_EQUAL(std::distance(env.cbegin(), env.cend()), 3u);
 219
 220     env.erase("c");
 221     BOOST_CHECK_EQUAL(env.size(), 2u);
 222     BOOST_CHECK_EQUAL(env.at("a").to_string(), "1");
 223     BOOST_CHECK_EQUAL(env.at("b").to_string(), "2");
 224     BOOST_CHECK_EQUAL(env.count("c"), 0u);
 225
 226     BOOST_CHECK_EQUAL(std::distance(env.begin(), env.end()), 2u);
 227     BOOST_CHECK_EQUAL(std::distance(env.cbegin(), env.cend()), 2u);
 228
 229     env.erase("b");
 230     BOOST_CHECK_EQUAL(env.size(), 1u);
 231     BOOST_CHECK_EQUAL(env.at("a").to_string(), "1");
 232     BOOST_CHECK_EQUAL(env.count("b"), 0u);
 233     BOOST_CHECK_EQUAL(env.count("c"), 0u);
 234
 235     BOOST_CHECK_EQUAL(std::distance(env.begin(), env.end()), 1u);
 236     BOOST_CHECK_EQUAL(std::distance(env.cbegin(), env.cend()), 1u);
 237
 238     env.clear();
 239     BOOST_CHECK(env.empty());
 240     BOOST_CHECK_EQUAL(env.size(), 0u);
 241
 242     BOOST_CHECK_EQUAL(std::distance(env.begin(), env.end()), 0u);
 243     BOOST_CHECK_EQUAL(std::distance(env.cbegin(), env.cend()), 0u);
 244
 245 }