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