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 {
operator <<(std::ostream & str,const std::wstring & ws)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(wcompare,  *boost::unit_test::timeout(5))
122 {
123     auto nat = boost::this_process::wenvironment();
124     bp::wenvironment env = nat;
125 
126     {
127         BOOST_CHECK_EQUAL(nat.size(), env.size());
128         auto ni = nat.begin();
129         auto ei = env.begin();
130 
131         while ((ni != nat.end()) &&(ei != env.end()))
132         {
133             BOOST_CHECK_EQUAL(ni->get_name(),  ei->get_name());
134             BOOST_CHECK_EQUAL(ni->to_string(), ei->to_string());
135             ni++; ei++;
136         }
137     }
138 
139     BOOST_TEST_PASSPOINT();
140     env.clear();
141     BOOST_TEST_PASSPOINT();
142 }
143 
144 BOOST_AUTO_TEST_CASE(insert_remove,  *boost::unit_test::timeout(5))
145 {
146     bp::environment env(boost::this_process::environment());
147 
148     auto sz = env.size();
149     BOOST_REQUIRE_GE(sz, 1u);
150     BOOST_REQUIRE_EQUAL(env.count("BOOST_TEST_VAR"), 0u);
151 
152     env["BOOST_TEST_VAR"] = {"some string", "badabumm"};
153 
154 #if defined(BOOST_WINDOWS_API)
155     BOOST_CHECK_EQUAL(env["BOOST_TEST_VAR"].to_string(), "some string;badabumm");
156 #else
157     BOOST_CHECK_EQUAL(env["BOOST_TEST_VAR"].to_string(), "some string:badabumm");
158 #endif
159     BOOST_CHECK_EQUAL(sz +1, env.size());
160 
161     env["BOOST_TEST_VAR"].clear();
162 
163     BOOST_CHECK_EQUAL(env.size(), sz);
164 
165     env.clear();
166 
167 }
168 
169 BOOST_AUTO_TEST_CASE(clear_empty_my,  *boost::unit_test::timeout(5))
170 {
171     bp::native_environment env;
172 
173     bp::environment e = env;
174 
175     const std::size_t sz = env.size();
176 
177     BOOST_TEST_MESSAGE("Current native size: " << sz);
178 
179     BOOST_REQUIRE_EQUAL(env.count("BOOST_PROCESS_TEST_VAR_a"), 0u);
180     BOOST_REQUIRE_EQUAL(env.count("BOOST_PROCESS_TEST_VAR_b"), 0u);
181     BOOST_REQUIRE_EQUAL(env.count("BOOST_PROCESS_TEST_VAR_c"), 0u);
182 
183     env["BOOST_PROCESS_TEST_VAR_a"] = "1";
184     env["BOOST_PROCESS_TEST_VAR_b"] = "2";
185     BOOST_CHECK(env.emplace("BOOST_PROCESS_TEST_VAR_c", "3").second);
186 
187     BOOST_CHECK_EQUAL(env.count("BOOST_PROCESS_TEST_VAR_a"), 1u);
188     BOOST_CHECK_EQUAL(env.count("BOOST_PROCESS_TEST_VAR_b"), 1u);
189     BOOST_CHECK_EQUAL(env.count("BOOST_PROCESS_TEST_VAR_c"), 1u);
190 
191     BOOST_CHECK_EQUAL(env.at("BOOST_PROCESS_TEST_VAR_a").to_string(), "1");
192     BOOST_CHECK_EQUAL(env.at("BOOST_PROCESS_TEST_VAR_b").to_string(), "2");
193     BOOST_CHECK_EQUAL(env.at("BOOST_PROCESS_TEST_VAR_c").to_string(), "3");
194     BOOST_CHECK_EQUAL(env.size(), sz + 3u);
195     BOOST_CHECK_EQUAL(std::distance(env.begin(),  env.end()),  sz + 3);
196     BOOST_CHECK_EQUAL(std::distance(env.cbegin(), env.cend()), sz + 3);
197 
198     env.erase("BOOST_PROCESS_TEST_VAR_a");
199     BOOST_CHECK_EQUAL(env.size(), sz + 2u);
200     BOOST_CHECK_EQUAL(env.count("BOOST_PROCESS_TEST_VAR_a"), 0u);
201     BOOST_CHECK_EQUAL(env.at   ("BOOST_PROCESS_TEST_VAR_b").to_string(), "2");
202     BOOST_CHECK_EQUAL(env.at   ("BOOST_PROCESS_TEST_VAR_c").to_string(), "3");
203 
204     BOOST_CHECK_EQUAL(std::distance(env.begin(),  env.end()),  sz + 2);
205     BOOST_CHECK_EQUAL(std::distance(env.cbegin(), env.cend()), sz + 2);
206 
207     env.erase("BOOST_PROCESS_TEST_VAR_b");
208     BOOST_CHECK_EQUAL(env.size(), sz + 1u);
209     BOOST_CHECK_EQUAL(env.count("BOOST_PROCESS_TEST_VAR_a"), 0u);
210     BOOST_CHECK_EQUAL(env.count("BOOST_PROCESS_TEST_VAR_b"), 0u);
211     BOOST_CHECK_EQUAL(env.at   ("BOOST_PROCESS_TEST_VAR_c").to_string(), "3");
212 
213     BOOST_CHECK_EQUAL(std::distance(env.begin(),  env.end()),  sz + 1);
214     BOOST_CHECK_EQUAL(std::distance(env.cbegin(), env.cend()), sz + 1);
215 
216     env.clear();
217     //note: windows puts an entry without a name into the list, so it might not be empty after clear.
218     BOOST_CHECK_LE(env.size(), sz);
219 
220     BOOST_CHECK_LE(std::distance(env.begin(),  env.end()),  sz);
221     BOOST_CHECK_LE(std::distance(env.cbegin(), env.cend()), sz);
222 
223     for (auto && ee : e)
224         env.emplace(ee.get_name(), ee.to_string());
225 }
226 
227 BOOST_AUTO_TEST_CASE(clear_empty,  *boost::unit_test::timeout(5))
228 {
229     bp::environment env;
230     BOOST_CHECK(env.empty());
231     BOOST_CHECK_EQUAL(env.size(), 0u);
232     env["a"] = "1";
233     env["b"] = "2";
234     env["c"] = "3";
235 
236     BOOST_CHECK_EQUAL(env.at("a").to_string(), "1");
237     BOOST_CHECK_EQUAL(env.at("b").to_string(), "2");
238     BOOST_CHECK_EQUAL(env.at("c").to_string(), "3");
239     BOOST_CHECK_EQUAL(env.size(), 3u);
240     BOOST_CHECK_EQUAL(std::distance(env.begin(), env.end()), 3u);
241     BOOST_CHECK_EQUAL(std::distance(env.cbegin(), env.cend()), 3u);
242 
243     env.erase("c");
244     BOOST_CHECK_EQUAL(env.size(), 2u);
245     BOOST_CHECK_EQUAL(env.at("a").to_string(), "1");
246     BOOST_CHECK_EQUAL(env.at("b").to_string(), "2");
247     BOOST_CHECK_EQUAL(env.count("c"), 0u);
248 
249     BOOST_CHECK_EQUAL(std::distance(env.begin(), env.end()), 2u);
250     BOOST_CHECK_EQUAL(std::distance(env.cbegin(), env.cend()), 2u);
251 
252     env.erase("b");
253     BOOST_CHECK_EQUAL(env.size(), 1u);
254     BOOST_CHECK_EQUAL(env.at("a").to_string(), "1");
255     BOOST_CHECK_EQUAL(env.count("b"), 0u);
256     BOOST_CHECK_EQUAL(env.count("c"), 0u);
257 
258     BOOST_CHECK_EQUAL(std::distance(env.begin(), env.end()), 1u);
259     BOOST_CHECK_EQUAL(std::distance(env.cbegin(), env.cend()), 1u);
260 
261     env.clear();
262     BOOST_CHECK(env.empty());
263     BOOST_CHECK_EQUAL(env.size(), 0u);
264 
265     BOOST_CHECK_EQUAL(std::distance(env.begin(), env.end()), 0u);
266     BOOST_CHECK_EQUAL(std::distance(env.cbegin(), env.cend()), 0u);
267 
268 }
269