1 // 2 // Automated Testing Framework (atf) 3 // 4 // Copyright (c) 2008 The NetBSD Foundation, Inc. 5 // All rights reserved. 6 // 7 // Redistribution and use in source and binary forms, with or without 8 // modification, are permitted provided that the following conditions 9 // are met: 10 // 1. Redistributions of source code must retain the above copyright 11 // notice, this list of conditions and the following disclaimer. 12 // 2. Redistributions in binary form must reproduce the above copyright 13 // notice, this list of conditions and the following disclaimer in the 14 // documentation and/or other materials provided with the distribution. 15 // 16 // THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND 17 // CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, 18 // INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 19 // MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 20 // IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS BE LIABLE FOR ANY 21 // DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 22 // DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE 23 // GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 24 // INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER 25 // IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 26 // OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN 27 // IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 28 // 29 30 #include <cstdlib> 31 #include <cstring> 32 33 #include "../macros.hpp" 34 35 #include "process.hpp" 36 #include "test_helpers.hpp" 37 38 // TODO: Testing the fork function is a huge task and I'm afraid of 39 // copy/pasting tons of stuff from the C version. I'd rather not do that 40 // until some code can be shared, which cannot happen until the C++ binding 41 // is cleaned by a fair amount. Instead... just rely (at the moment) on 42 // the system tests for the tools using this module. 43 44 // ------------------------------------------------------------------------ 45 // Auxiliary functions. 46 // ------------------------------------------------------------------------ 47 48 static 49 std::size_t 50 array_size(const char* const* array) 51 { 52 std::size_t size = 0; 53 54 for (const char* const* ptr = array; *ptr != NULL; ptr++) 55 size++; 56 57 return size; 58 } 59 60 static 61 atf::process::status 62 exec_process_helpers(const atf::tests::tc& tc, const char* helper_name) 63 { 64 using atf::process::exec; 65 66 std::vector< std::string > argv; 67 argv.push_back(get_process_helpers_path(tc, true).leaf_name()); 68 argv.push_back(helper_name); 69 70 return exec(get_process_helpers_path(tc, true), 71 atf::process::argv_array(argv), 72 atf::process::stream_inherit(), 73 atf::process::stream_inherit()); 74 } 75 76 // ------------------------------------------------------------------------ 77 // Tests for the "argv_array" type. 78 // ------------------------------------------------------------------------ 79 80 ATF_TEST_CASE(argv_array_init_carray); 81 ATF_TEST_CASE_HEAD(argv_array_init_carray) 82 { 83 set_md_var("descr", "Tests that argv_array is correctly constructed " 84 "from a C-style array of strings"); 85 } 86 ATF_TEST_CASE_BODY(argv_array_init_carray) 87 { 88 { 89 const char* const carray[] = { NULL }; 90 atf::process::argv_array argv(carray); 91 92 ATF_REQUIRE_EQ(argv.size(), 0); 93 } 94 95 { 96 const char* const carray[] = { "arg0", NULL }; 97 atf::process::argv_array argv(carray); 98 99 ATF_REQUIRE_EQ(argv.size(), 1); 100 ATF_REQUIRE(std::strcmp(argv[0], carray[0]) == 0); 101 } 102 103 { 104 const char* const carray[] = { "arg0", "arg1", "arg2", NULL }; 105 atf::process::argv_array argv(carray); 106 107 ATF_REQUIRE_EQ(argv.size(), 3); 108 ATF_REQUIRE(std::strcmp(argv[0], carray[0]) == 0); 109 ATF_REQUIRE(std::strcmp(argv[1], carray[1]) == 0); 110 ATF_REQUIRE(std::strcmp(argv[2], carray[2]) == 0); 111 } 112 } 113 114 ATF_TEST_CASE(argv_array_init_col); 115 ATF_TEST_CASE_HEAD(argv_array_init_col) 116 { 117 set_md_var("descr", "Tests that argv_array is correctly constructed " 118 "from a string collection"); 119 } 120 ATF_TEST_CASE_BODY(argv_array_init_col) 121 { 122 { 123 std::vector< std::string > col; 124 atf::process::argv_array argv(col); 125 126 ATF_REQUIRE_EQ(argv.size(), 0); 127 } 128 129 { 130 std::vector< std::string > col; 131 col.push_back("arg0"); 132 atf::process::argv_array argv(col); 133 134 ATF_REQUIRE_EQ(argv.size(), 1); 135 ATF_REQUIRE_EQ(argv[0], col[0]); 136 } 137 138 { 139 std::vector< std::string > col; 140 col.push_back("arg0"); 141 col.push_back("arg1"); 142 col.push_back("arg2"); 143 atf::process::argv_array argv(col); 144 145 ATF_REQUIRE_EQ(argv.size(), 3); 146 ATF_REQUIRE_EQ(argv[0], col[0]); 147 ATF_REQUIRE_EQ(argv[1], col[1]); 148 ATF_REQUIRE_EQ(argv[2], col[2]); 149 } 150 } 151 152 ATF_TEST_CASE(argv_array_init_empty); 153 ATF_TEST_CASE_HEAD(argv_array_init_empty) 154 { 155 set_md_var("descr", "Tests that argv_array is correctly constructed " 156 "by the default constructor"); 157 } 158 ATF_TEST_CASE_BODY(argv_array_init_empty) 159 { 160 atf::process::argv_array argv; 161 162 ATF_REQUIRE_EQ(argv.size(), 0); 163 } 164 165 ATF_TEST_CASE(argv_array_init_varargs); 166 ATF_TEST_CASE_HEAD(argv_array_init_varargs) 167 { 168 set_md_var("descr", "Tests that argv_array is correctly constructed " 169 "from a variable list of arguments"); 170 } 171 ATF_TEST_CASE_BODY(argv_array_init_varargs) 172 { 173 { 174 atf::process::argv_array argv("arg0", NULL); 175 176 ATF_REQUIRE_EQ(argv.size(), 1); 177 ATF_REQUIRE_EQ(argv[0], std::string("arg0")); 178 } 179 180 { 181 atf::process::argv_array argv("arg0", "arg1", "arg2", NULL); 182 183 ATF_REQUIRE_EQ(argv.size(), 3); 184 ATF_REQUIRE_EQ(argv[0], std::string("arg0")); 185 ATF_REQUIRE_EQ(argv[1], std::string("arg1")); 186 ATF_REQUIRE_EQ(argv[2], std::string("arg2")); 187 } 188 } 189 190 ATF_TEST_CASE(argv_array_assign); 191 ATF_TEST_CASE_HEAD(argv_array_assign) 192 { 193 set_md_var("descr", "Tests that assigning an argv_array works"); 194 } 195 ATF_TEST_CASE_BODY(argv_array_assign) 196 { 197 using atf::process::argv_array; 198 199 const char* const carray1[] = { "arg1", NULL }; 200 const char* const carray2[] = { "arg1", "arg2", NULL }; 201 202 std::auto_ptr< argv_array > argv1(new argv_array(carray1)); 203 std::auto_ptr< argv_array > argv2(new argv_array(carray2)); 204 205 *argv2 = *argv1; 206 ATF_REQUIRE_EQ(argv2->size(), argv1->size()); 207 ATF_REQUIRE(std::strcmp((*argv2)[0], (*argv1)[0]) == 0); 208 209 ATF_REQUIRE(argv2->exec_argv() != argv1->exec_argv()); 210 argv1.release(); 211 { 212 const char* const* eargv2 = argv2->exec_argv(); 213 ATF_REQUIRE(std::strcmp(eargv2[0], carray1[0]) == 0); 214 ATF_REQUIRE_EQ(eargv2[1], static_cast< const char* >(NULL)); 215 } 216 217 argv2.release(); 218 } 219 220 ATF_TEST_CASE(argv_array_copy); 221 ATF_TEST_CASE_HEAD(argv_array_copy) 222 { 223 set_md_var("descr", "Tests that copying an argv_array constructed from " 224 "a C-style array of strings works"); 225 } 226 ATF_TEST_CASE_BODY(argv_array_copy) 227 { 228 using atf::process::argv_array; 229 230 const char* const carray[] = { "arg0", NULL }; 231 232 std::auto_ptr< argv_array > argv1(new argv_array(carray)); 233 std::auto_ptr< argv_array > argv2(new argv_array(*argv1)); 234 235 ATF_REQUIRE_EQ(argv2->size(), argv1->size()); 236 ATF_REQUIRE(std::strcmp((*argv2)[0], (*argv1)[0]) == 0); 237 238 ATF_REQUIRE(argv2->exec_argv() != argv1->exec_argv()); 239 argv1.release(); 240 { 241 const char* const* eargv2 = argv2->exec_argv(); 242 ATF_REQUIRE(std::strcmp(eargv2[0], carray[0]) == 0); 243 ATF_REQUIRE_EQ(eargv2[1], static_cast< const char* >(NULL)); 244 } 245 246 argv2.release(); 247 } 248 249 ATF_TEST_CASE(argv_array_exec_argv); 250 ATF_TEST_CASE_HEAD(argv_array_exec_argv) 251 { 252 set_md_var("descr", "Tests that the exec argv provided by an argv_array " 253 "is correct"); 254 } 255 ATF_TEST_CASE_BODY(argv_array_exec_argv) 256 { 257 using atf::process::argv_array; 258 259 { 260 argv_array argv; 261 const char* const* eargv = argv.exec_argv(); 262 ATF_REQUIRE_EQ(array_size(eargv), 0); 263 ATF_REQUIRE_EQ(eargv[0], static_cast< const char* >(NULL)); 264 } 265 266 { 267 const char* const carray[] = { "arg0", NULL }; 268 argv_array argv(carray); 269 const char* const* eargv = argv.exec_argv(); 270 ATF_REQUIRE_EQ(array_size(eargv), 1); 271 ATF_REQUIRE(std::strcmp(eargv[0], "arg0") == 0); 272 ATF_REQUIRE_EQ(eargv[1], static_cast< const char* >(NULL)); 273 } 274 275 { 276 std::vector< std::string > col; 277 col.push_back("arg0"); 278 argv_array argv(col); 279 const char* const* eargv = argv.exec_argv(); 280 ATF_REQUIRE_EQ(array_size(eargv), 1); 281 ATF_REQUIRE(std::strcmp(eargv[0], "arg0") == 0); 282 ATF_REQUIRE_EQ(eargv[1], static_cast< const char* >(NULL)); 283 } 284 } 285 286 ATF_TEST_CASE(argv_array_iter); 287 ATF_TEST_CASE_HEAD(argv_array_iter) 288 { 289 set_md_var("descr", "Tests that an argv_array can be iterated"); 290 } 291 ATF_TEST_CASE_BODY(argv_array_iter) 292 { 293 using atf::process::argv_array; 294 295 std::vector< std::string > vector; 296 vector.push_back("arg0"); 297 vector.push_back("arg1"); 298 vector.push_back("arg2"); 299 300 argv_array argv(vector); 301 ATF_REQUIRE_EQ(argv.size(), 3); 302 std::vector< std::string >::size_type pos = 0; 303 for (argv_array::const_iterator iter = argv.begin(); iter != argv.end(); 304 iter++) { 305 ATF_REQUIRE_EQ(*iter, vector[pos]); 306 pos++; 307 } 308 } 309 310 // ------------------------------------------------------------------------ 311 // Tests cases for the free functions. 312 // ------------------------------------------------------------------------ 313 314 ATF_TEST_CASE(exec_failure); 315 ATF_TEST_CASE_HEAD(exec_failure) 316 { 317 set_md_var("descr", "Tests execing a command that reports failure"); 318 } 319 ATF_TEST_CASE_BODY(exec_failure) 320 { 321 const atf::process::status s = exec_process_helpers(*this, "exit-failure"); 322 ATF_REQUIRE(s.exited()); 323 ATF_REQUIRE_EQ(s.exitstatus(), EXIT_FAILURE); 324 } 325 326 ATF_TEST_CASE(exec_success); 327 ATF_TEST_CASE_HEAD(exec_success) 328 { 329 set_md_var("descr", "Tests execing a command that reports success"); 330 } 331 ATF_TEST_CASE_BODY(exec_success) 332 { 333 const atf::process::status s = exec_process_helpers(*this, "exit-success"); 334 ATF_REQUIRE(s.exited()); 335 ATF_REQUIRE_EQ(s.exitstatus(), EXIT_SUCCESS); 336 } 337 338 // ------------------------------------------------------------------------ 339 // Main. 340 // ------------------------------------------------------------------------ 341 342 ATF_INIT_TEST_CASES(tcs) 343 { 344 // Add the test cases for the "argv_array" type. 345 ATF_ADD_TEST_CASE(tcs, argv_array_assign); 346 ATF_ADD_TEST_CASE(tcs, argv_array_copy); 347 ATF_ADD_TEST_CASE(tcs, argv_array_exec_argv); 348 ATF_ADD_TEST_CASE(tcs, argv_array_init_carray); 349 ATF_ADD_TEST_CASE(tcs, argv_array_init_col); 350 ATF_ADD_TEST_CASE(tcs, argv_array_init_empty); 351 ATF_ADD_TEST_CASE(tcs, argv_array_init_varargs); 352 ATF_ADD_TEST_CASE(tcs, argv_array_iter); 353 354 // Add the test cases for the free functions. 355 ATF_ADD_TEST_CASE(tcs, exec_failure); 356 ATF_ADD_TEST_CASE(tcs, exec_success); 357 } 358