1240116Smarcel// 2240116Smarcel// Automated Testing Framework (atf) 3240116Smarcel// 4240116Smarcel// Copyright (c) 2010 The NetBSD Foundation, Inc. 5240116Smarcel// All rights reserved. 6240116Smarcel// 7240116Smarcel// Redistribution and use in source and binary forms, with or without 8240116Smarcel// modification, are permitted provided that the following conditions 9240116Smarcel// are met: 10240116Smarcel// 1. Redistributions of source code must retain the above copyright 11240116Smarcel// notice, this list of conditions and the following disclaimer. 12240116Smarcel// 2. Redistributions in binary form must reproduce the above copyright 13240116Smarcel// notice, this list of conditions and the following disclaimer in the 14240116Smarcel// documentation and/or other materials provided with the distribution. 15240116Smarcel// 16240116Smarcel// THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND 17240116Smarcel// CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, 18240116Smarcel// INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 19240116Smarcel// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 20240116Smarcel// IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS BE LIABLE FOR ANY 21240116Smarcel// DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 22240116Smarcel// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE 23240116Smarcel// GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 24240116Smarcel// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER 25240116Smarcel// IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 26240116Smarcel// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN 27240116Smarcel// IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 28240116Smarcel// 29240116Smarcel 30240116Smarcel#include "atf-c++/config.hpp" 31240116Smarcel#include "atf-c++/detail/text.hpp" 32240116Smarcel#include "atf-c++/macros.hpp" 33240116Smarcel 34240116Smarcel#include "requirements.hpp" 35240116Smarcel#include "user.hpp" 36240116Smarcel 37240116Smarcelnamespace impl = atf::atf_run; 38240116Smarcel 39240116Smarcel// ------------------------------------------------------------------------- 40240116Smarcel// Auxiliary functions. 41240116Smarcel// ------------------------------------------------------------------------- 42240116Smarcel 43240116Smarcelnamespace { 44240116Smarcel 45240116Smarcelconst atf::tests::vars_map no_config; 46240116Smarcel 47240116Smarcelvoid 48240116Smarceldo_check(const std::string& expected, const atf::tests::vars_map& metadata, 49240116Smarcel const atf::tests::vars_map& config = no_config) 50240116Smarcel{ 51240116Smarcel const std::string actual = impl::check_requirements(metadata, config); 52240116Smarcel if (!atf::text::match(actual, expected)) 53240116Smarcel ATF_FAIL("Requirements failure reason \"" + actual + "\" does not " 54240116Smarcel "match \"" + expected + "\""); 55240116Smarcel} 56240116Smarcel 57240116Smarcel} // anonymous namespace 58240116Smarcel 59240116Smarcel// ------------------------------------------------------------------------- 60240116Smarcel// Tests for the require.arch metadata property. 61240116Smarcel// ------------------------------------------------------------------------- 62240116Smarcel 63240116SmarcelATF_TEST_CASE(require_arch_one_ok); 64240116SmarcelATF_TEST_CASE_HEAD(require_arch_one_ok) {} 65240116SmarcelATF_TEST_CASE_BODY(require_arch_one_ok) { 66240116Smarcel atf::tests::vars_map metadata; 67240116Smarcel metadata["require.arch"] = atf::config::get("atf_arch"); 68240116Smarcel do_check("", metadata); 69240116Smarcel} 70240116Smarcel 71240116SmarcelATF_TEST_CASE(require_arch_one_fail); 72240116SmarcelATF_TEST_CASE_HEAD(require_arch_one_fail) {} 73240116SmarcelATF_TEST_CASE_BODY(require_arch_one_fail) { 74240116Smarcel atf::tests::vars_map metadata; 75240116Smarcel metadata["require.arch"] = "__fake_arch__"; 76240116Smarcel do_check("Requires the '__fake_arch__' architecture", metadata); 77240116Smarcel} 78240116Smarcel 79240116SmarcelATF_TEST_CASE(require_arch_many_ok); 80240116SmarcelATF_TEST_CASE_HEAD(require_arch_many_ok) {} 81240116SmarcelATF_TEST_CASE_BODY(require_arch_many_ok) { 82240116Smarcel atf::tests::vars_map metadata; 83240116Smarcel metadata["require.arch"] = "__foo__ " + atf::config::get("atf_arch") + 84240116Smarcel " __bar__"; 85240116Smarcel do_check("", metadata); 86240116Smarcel} 87240116Smarcel 88240116SmarcelATF_TEST_CASE(require_arch_many_fail); 89240116SmarcelATF_TEST_CASE_HEAD(require_arch_many_fail) {} 90240116SmarcelATF_TEST_CASE_BODY(require_arch_many_fail) { 91240116Smarcel atf::tests::vars_map metadata; 92240116Smarcel metadata["require.arch"] = "__foo__ __bar__ __baz__"; 93240116Smarcel do_check("Requires one of the '__foo__ __bar__ __baz__' architectures", 94240116Smarcel metadata); 95240116Smarcel} 96240116Smarcel 97240116Smarcel// ------------------------------------------------------------------------- 98240116Smarcel// Tests for the require.config metadata property. 99240116Smarcel// ------------------------------------------------------------------------- 100240116Smarcel 101240116SmarcelATF_TEST_CASE(require_config_one_ok); 102240116SmarcelATF_TEST_CASE_HEAD(require_config_one_ok) {} 103240116SmarcelATF_TEST_CASE_BODY(require_config_one_ok) { 104240116Smarcel atf::tests::vars_map metadata, config; 105240116Smarcel metadata["require.config"] = "var1"; 106240116Smarcel config["var1"] = "some-value"; 107240116Smarcel do_check("", metadata, config); 108240116Smarcel} 109240116Smarcel 110240116SmarcelATF_TEST_CASE(require_config_one_fail); 111240116SmarcelATF_TEST_CASE_HEAD(require_config_one_fail) {} 112240116SmarcelATF_TEST_CASE_BODY(require_config_one_fail) { 113240116Smarcel atf::tests::vars_map metadata, config; 114240116Smarcel metadata["require.config"] = "var1"; 115240116Smarcel do_check("Required configuration variable 'var1' not defined", metadata, 116240116Smarcel config); 117240116Smarcel} 118240116Smarcel 119240116SmarcelATF_TEST_CASE(require_config_many_ok); 120240116SmarcelATF_TEST_CASE_HEAD(require_config_many_ok) {} 121240116SmarcelATF_TEST_CASE_BODY(require_config_many_ok) { 122240116Smarcel atf::tests::vars_map metadata, config; 123240116Smarcel metadata["require.config"] = "var1 var2 var3"; 124240116Smarcel config["var1"] = "first-value"; 125240116Smarcel config["var2"] = "second-value"; 126240116Smarcel config["var3"] = "third-value"; 127240116Smarcel do_check("", metadata, config); 128240116Smarcel} 129240116Smarcel 130240116SmarcelATF_TEST_CASE(require_config_many_fail); 131240116SmarcelATF_TEST_CASE_HEAD(require_config_many_fail) {} 132240116SmarcelATF_TEST_CASE_BODY(require_config_many_fail) { 133240116Smarcel atf::tests::vars_map metadata, config; 134240116Smarcel metadata["require.config"] = "var1 var2 var3"; 135240116Smarcel config["var1"] = "first-value"; 136240116Smarcel config["var3"] = "third-value"; 137240116Smarcel do_check("Required configuration variable 'var2' not defined", metadata, 138240116Smarcel config); 139240116Smarcel} 140240116Smarcel 141240116Smarcel// ------------------------------------------------------------------------- 142240116Smarcel// Tests for the require.files metadata property. 143240116Smarcel// ------------------------------------------------------------------------- 144240116Smarcel 145240116SmarcelATF_TEST_CASE_WITHOUT_HEAD(require_files_one_ok); 146240116SmarcelATF_TEST_CASE_BODY(require_files_one_ok) { 147240116Smarcel atf::tests::vars_map metadata; 148240116Smarcel metadata["require.files"] = "/bin/ls"; 149240116Smarcel do_check("", metadata); 150240116Smarcel} 151240116Smarcel 152240116SmarcelATF_TEST_CASE_WITHOUT_HEAD(require_files_one_missing); 153240116SmarcelATF_TEST_CASE_BODY(require_files_one_missing) { 154240116Smarcel atf::tests::vars_map metadata; 155240116Smarcel metadata["require.files"] = "/non-existent/foo"; 156240116Smarcel do_check("Required file '/non-existent/foo' not found", metadata); 157240116Smarcel} 158240116Smarcel 159240116SmarcelATF_TEST_CASE_WITHOUT_HEAD(require_files_one_fail); 160240116SmarcelATF_TEST_CASE_BODY(require_files_one_fail) { 161240116Smarcel atf::tests::vars_map metadata; 162240116Smarcel metadata["require.files"] = "/bin/cp this-is-relative"; 163240116Smarcel ATF_REQUIRE_THROW_RE(std::runtime_error, "Relative.*(this-is-relative)", 164240116Smarcel impl::check_requirements(metadata, no_config)); 165240116Smarcel} 166240116Smarcel 167240116SmarcelATF_TEST_CASE_WITHOUT_HEAD(require_files_many_ok); 168240116SmarcelATF_TEST_CASE_BODY(require_files_many_ok) { 169240116Smarcel atf::tests::vars_map metadata; 170240116Smarcel metadata["require.files"] = "/bin/ls /bin/cp"; 171240116Smarcel do_check("", metadata); 172240116Smarcel} 173240116Smarcel 174240116SmarcelATF_TEST_CASE_WITHOUT_HEAD(require_files_many_missing); 175240116SmarcelATF_TEST_CASE_BODY(require_files_many_missing) { 176240116Smarcel atf::tests::vars_map metadata; 177240116Smarcel metadata["require.files"] = "/bin/ls /non-existent/bar /bin/cp"; 178240116Smarcel do_check("Required file '/non-existent/bar' not found", metadata); 179240116Smarcel} 180240116Smarcel 181240116SmarcelATF_TEST_CASE_WITHOUT_HEAD(require_files_many_fail); 182240116SmarcelATF_TEST_CASE_BODY(require_files_many_fail) { 183240116Smarcel atf::tests::vars_map metadata; 184240116Smarcel metadata["require.files"] = "/bin/cp also-relative"; 185240116Smarcel ATF_REQUIRE_THROW_RE(std::runtime_error, "Relative.*(also-relative)", 186240116Smarcel impl::check_requirements(metadata, no_config)); 187240116Smarcel} 188240116Smarcel 189240116Smarcel// ------------------------------------------------------------------------- 190240116Smarcel// Tests for the require.machine metadata property. 191240116Smarcel// ------------------------------------------------------------------------- 192240116Smarcel 193240116SmarcelATF_TEST_CASE(require_machine_one_ok); 194240116SmarcelATF_TEST_CASE_HEAD(require_machine_one_ok) {} 195240116SmarcelATF_TEST_CASE_BODY(require_machine_one_ok) { 196240116Smarcel atf::tests::vars_map metadata; 197240116Smarcel metadata["require.machine"] = atf::config::get("atf_machine"); 198240116Smarcel do_check("", metadata); 199240116Smarcel} 200240116Smarcel 201240116SmarcelATF_TEST_CASE(require_machine_one_fail); 202240116SmarcelATF_TEST_CASE_HEAD(require_machine_one_fail) {} 203240116SmarcelATF_TEST_CASE_BODY(require_machine_one_fail) { 204240116Smarcel atf::tests::vars_map metadata; 205240116Smarcel metadata["require.machine"] = "__fake_machine__"; 206240116Smarcel do_check("Requires the '__fake_machine__' machine type", metadata); 207240116Smarcel} 208240116Smarcel 209240116SmarcelATF_TEST_CASE(require_machine_many_ok); 210240116SmarcelATF_TEST_CASE_HEAD(require_machine_many_ok) {} 211240116SmarcelATF_TEST_CASE_BODY(require_machine_many_ok) { 212240116Smarcel atf::tests::vars_map metadata; 213240116Smarcel metadata["require.machine"] = "__foo__ " + atf::config::get("atf_machine") + 214240116Smarcel " __bar__"; 215240116Smarcel do_check("", metadata); 216240116Smarcel} 217240116Smarcel 218240116SmarcelATF_TEST_CASE(require_machine_many_fail); 219240116SmarcelATF_TEST_CASE_HEAD(require_machine_many_fail) {} 220240116SmarcelATF_TEST_CASE_BODY(require_machine_many_fail) { 221240116Smarcel atf::tests::vars_map metadata; 222240116Smarcel metadata["require.machine"] = "__foo__ __bar__ __baz__"; 223240116Smarcel do_check("Requires one of the '__foo__ __bar__ __baz__' machine types", 224240116Smarcel metadata); 225240116Smarcel} 226240116Smarcel 227240116Smarcel// ------------------------------------------------------------------------- 228240116Smarcel// Tests for the require.memory metadata property. 229240116Smarcel// ------------------------------------------------------------------------- 230240116Smarcel 231240116SmarcelATF_TEST_CASE_WITHOUT_HEAD(require_memory_ok); 232240116SmarcelATF_TEST_CASE_BODY(require_memory_ok) { 233240116Smarcel atf::tests::vars_map metadata; 234240116Smarcel metadata["require.memory"] = "1m"; 235240116Smarcel do_check("", metadata); 236240116Smarcel} 237240116Smarcel 238240116SmarcelATF_TEST_CASE_WITHOUT_HEAD(require_memory_not_enough); 239240116SmarcelATF_TEST_CASE_BODY(require_memory_not_enough) { 240240116Smarcel atf::tests::vars_map metadata; 241240116Smarcel metadata["require.memory"] = "128t"; 242243052Smarcel#if defined(__APPLE__) || defined(__DragonFly__) || \ 243243052Smarcel defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) 244240116Smarcel do_check("Not enough memory; needed 140737488355328, available [0-9]*", 245240116Smarcel metadata); 246240116Smarcel#else 247240116Smarcel skip("Don't know how to check for the amount of physical memory"); 248240116Smarcel#endif 249240116Smarcel} 250240116Smarcel 251240116SmarcelATF_TEST_CASE_WITHOUT_HEAD(require_memory_fail); 252240116SmarcelATF_TEST_CASE_BODY(require_memory_fail) { 253240116Smarcel atf::tests::vars_map metadata; 254240116Smarcel metadata["require.memory"] = "foo"; 255240116Smarcel ATF_REQUIRE_THROW(std::runtime_error, 256240116Smarcel impl::check_requirements(metadata, no_config)); 257240116Smarcel} 258240116Smarcel 259240116Smarcel// ------------------------------------------------------------------------- 260240116Smarcel// Tests for the require.progs metadata property. 261240116Smarcel// ------------------------------------------------------------------------- 262240116Smarcel 263240116SmarcelATF_TEST_CASE(require_progs_one_ok); 264240116SmarcelATF_TEST_CASE_HEAD(require_progs_one_ok) {} 265240116SmarcelATF_TEST_CASE_BODY(require_progs_one_ok) { 266240116Smarcel atf::tests::vars_map metadata; 267240116Smarcel metadata["require.progs"] = "cp"; 268240116Smarcel do_check("", metadata); 269240116Smarcel} 270240116Smarcel 271240116SmarcelATF_TEST_CASE(require_progs_one_missing); 272240116SmarcelATF_TEST_CASE_HEAD(require_progs_one_missing) {} 273240116SmarcelATF_TEST_CASE_BODY(require_progs_one_missing) { 274240116Smarcel atf::tests::vars_map metadata; 275240116Smarcel metadata["require.progs"] = "cp __non-existent__"; 276240116Smarcel do_check("Required program '__non-existent__' not found in the PATH", 277240116Smarcel metadata); 278240116Smarcel} 279240116Smarcel 280240116SmarcelATF_TEST_CASE(require_progs_one_fail); 281240116SmarcelATF_TEST_CASE_HEAD(require_progs_one_fail) {} 282240116SmarcelATF_TEST_CASE_BODY(require_progs_one_fail) { 283240116Smarcel atf::tests::vars_map metadata; 284240116Smarcel metadata["require.progs"] = "bin/cp"; 285240116Smarcel ATF_REQUIRE_THROW(std::runtime_error, 286240116Smarcel impl::check_requirements(metadata, no_config)); 287240116Smarcel} 288240116Smarcel 289240116SmarcelATF_TEST_CASE(require_progs_many_ok); 290240116SmarcelATF_TEST_CASE_HEAD(require_progs_many_ok) {} 291240116SmarcelATF_TEST_CASE_BODY(require_progs_many_ok) { 292240116Smarcel atf::tests::vars_map metadata; 293240116Smarcel metadata["require.progs"] = "cp ls mv"; 294240116Smarcel do_check("", metadata); 295240116Smarcel} 296240116Smarcel 297240116SmarcelATF_TEST_CASE(require_progs_many_missing); 298240116SmarcelATF_TEST_CASE_HEAD(require_progs_many_missing) {} 299240116SmarcelATF_TEST_CASE_BODY(require_progs_many_missing) { 300240116Smarcel atf::tests::vars_map metadata; 301240116Smarcel metadata["require.progs"] = "mv ls __foo__ cp"; 302240116Smarcel do_check("Required program '__foo__' not found in the PATH", metadata); 303240116Smarcel} 304240116Smarcel 305240116SmarcelATF_TEST_CASE(require_progs_many_fail); 306240116SmarcelATF_TEST_CASE_HEAD(require_progs_many_fail) {} 307240116SmarcelATF_TEST_CASE_BODY(require_progs_many_fail) { 308240116Smarcel atf::tests::vars_map metadata; 309240116Smarcel metadata["require.progs"] = "ls cp ../bin/cp"; 310240116Smarcel ATF_REQUIRE_THROW(std::runtime_error, 311240116Smarcel impl::check_requirements(metadata, no_config)); 312240116Smarcel} 313240116Smarcel 314240116Smarcel// ------------------------------------------------------------------------- 315240116Smarcel// Tests for the require.user metadata property. 316240116Smarcel// ------------------------------------------------------------------------- 317240116Smarcel 318240116SmarcelATF_TEST_CASE(require_user_root); 319240116SmarcelATF_TEST_CASE_HEAD(require_user_root) {} 320240116SmarcelATF_TEST_CASE_BODY(require_user_root) { 321240116Smarcel atf::tests::vars_map metadata; 322240116Smarcel metadata["require.user"] = "root"; 323240116Smarcel if (atf::atf_run::is_root()) 324240116Smarcel do_check("", metadata); 325240116Smarcel else 326240116Smarcel do_check("Requires root privileges", metadata); 327240116Smarcel} 328240116Smarcel 329240116SmarcelATF_TEST_CASE(require_user_unprivileged); 330240116SmarcelATF_TEST_CASE_HEAD(require_user_unprivileged) {} 331240116SmarcelATF_TEST_CASE_BODY(require_user_unprivileged) { 332240116Smarcel atf::tests::vars_map metadata; 333240116Smarcel metadata["require.user"] = "unprivileged"; 334240116Smarcel if (atf::atf_run::is_root()) 335240116Smarcel do_check("Requires an unprivileged user and the 'unprivileged-user' " 336240116Smarcel "configuration variable is not set", metadata); 337240116Smarcel else 338240116Smarcel do_check("", metadata); 339240116Smarcel} 340240116Smarcel 341240116SmarcelATF_TEST_CASE(require_user_fail); 342240116SmarcelATF_TEST_CASE_HEAD(require_user_fail) {} 343240116SmarcelATF_TEST_CASE_BODY(require_user_fail) { 344240116Smarcel atf::tests::vars_map metadata; 345240116Smarcel metadata["require.user"] = "nobody"; 346240116Smarcel ATF_REQUIRE_THROW(std::runtime_error, 347240116Smarcel impl::check_requirements(metadata, no_config)); 348240116Smarcel} 349240116Smarcel 350240116Smarcel// ------------------------------------------------------------------------- 351240116Smarcel// Main. 352240116Smarcel// ------------------------------------------------------------------------- 353240116Smarcel 354240116SmarcelATF_INIT_TEST_CASES(tcs) 355240116Smarcel{ 356240116Smarcel // Add test cases for require.arch. 357240116Smarcel ATF_ADD_TEST_CASE(tcs, require_arch_one_ok); 358240116Smarcel ATF_ADD_TEST_CASE(tcs, require_arch_one_fail); 359240116Smarcel ATF_ADD_TEST_CASE(tcs, require_arch_many_ok); 360240116Smarcel ATF_ADD_TEST_CASE(tcs, require_arch_many_fail); 361240116Smarcel 362240116Smarcel // Add test cases for require.config. 363240116Smarcel ATF_ADD_TEST_CASE(tcs, require_config_one_ok); 364240116Smarcel ATF_ADD_TEST_CASE(tcs, require_config_one_fail); 365240116Smarcel ATF_ADD_TEST_CASE(tcs, require_config_many_ok); 366240116Smarcel ATF_ADD_TEST_CASE(tcs, require_config_many_fail); 367240116Smarcel 368240116Smarcel // Add test cases for require.files. 369240116Smarcel ATF_ADD_TEST_CASE(tcs, require_files_one_ok); 370240116Smarcel ATF_ADD_TEST_CASE(tcs, require_files_one_missing); 371240116Smarcel ATF_ADD_TEST_CASE(tcs, require_files_one_fail); 372240116Smarcel ATF_ADD_TEST_CASE(tcs, require_files_many_ok); 373240116Smarcel ATF_ADD_TEST_CASE(tcs, require_files_many_missing); 374240116Smarcel ATF_ADD_TEST_CASE(tcs, require_files_many_fail); 375240116Smarcel 376240116Smarcel // Add test cases for require.machine. 377240116Smarcel ATF_ADD_TEST_CASE(tcs, require_machine_one_ok); 378240116Smarcel ATF_ADD_TEST_CASE(tcs, require_machine_one_fail); 379240116Smarcel ATF_ADD_TEST_CASE(tcs, require_machine_many_ok); 380240116Smarcel ATF_ADD_TEST_CASE(tcs, require_machine_many_fail); 381240116Smarcel 382240116Smarcel // Add test cases for require.memory. 383240116Smarcel ATF_ADD_TEST_CASE(tcs, require_memory_ok); 384240116Smarcel ATF_ADD_TEST_CASE(tcs, require_memory_not_enough); 385240116Smarcel ATF_ADD_TEST_CASE(tcs, require_memory_fail); 386240116Smarcel 387240116Smarcel // Add test cases for require.progs. 388240116Smarcel ATF_ADD_TEST_CASE(tcs, require_progs_one_ok); 389240116Smarcel ATF_ADD_TEST_CASE(tcs, require_progs_one_missing); 390240116Smarcel ATF_ADD_TEST_CASE(tcs, require_progs_one_fail); 391240116Smarcel ATF_ADD_TEST_CASE(tcs, require_progs_many_ok); 392240116Smarcel ATF_ADD_TEST_CASE(tcs, require_progs_many_missing); 393240116Smarcel ATF_ADD_TEST_CASE(tcs, require_progs_many_fail); 394240116Smarcel 395240116Smarcel // Add test cases for require.user. 396240116Smarcel ATF_ADD_TEST_CASE(tcs, require_user_root); 397240116Smarcel ATF_ADD_TEST_CASE(tcs, require_user_unprivileged); 398240116Smarcel ATF_ADD_TEST_CASE(tcs, require_user_fail); 399240116Smarcel} 400