1240116Smarcel// Copyright (c) 2007 The NetBSD Foundation, Inc. 2240116Smarcel// All rights reserved. 3240116Smarcel// 4240116Smarcel// Redistribution and use in source and binary forms, with or without 5240116Smarcel// modification, are permitted provided that the following conditions 6240116Smarcel// are met: 7240116Smarcel// 1. Redistributions of source code must retain the above copyright 8240116Smarcel// notice, this list of conditions and the following disclaimer. 9240116Smarcel// 2. Redistributions in binary form must reproduce the above copyright 10240116Smarcel// notice, this list of conditions and the following disclaimer in the 11240116Smarcel// documentation and/or other materials provided with the distribution. 12240116Smarcel// 13240116Smarcel// THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND 14240116Smarcel// CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, 15240116Smarcel// INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 16240116Smarcel// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 17240116Smarcel// IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS BE LIABLE FOR ANY 18240116Smarcel// DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 19240116Smarcel// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE 20240116Smarcel// GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 21240116Smarcel// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER 22240116Smarcel// IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 23240116Smarcel// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN 24240116Smarcel// IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 25240116Smarcel 26275988Sngie#include "atf-c++/detail/fs.hpp" 27275988Sngie 28240116Smarcelextern "C" { 29240116Smarcel#include <sys/types.h> 30240116Smarcel#include <sys/stat.h> 31240116Smarcel} 32240116Smarcel 33240116Smarcel#include <fstream> 34240116Smarcel#include <cerrno> 35240116Smarcel#include <cstdio> 36240116Smarcel 37275988Sngie#include <atf-c++.hpp> 38240116Smarcel 39275988Sngie#include "atf-c++/detail/exceptions.hpp" 40240116Smarcel 41240116Smarcel// ------------------------------------------------------------------------ 42240116Smarcel// Auxiliary functions. 43240116Smarcel// ------------------------------------------------------------------------ 44240116Smarcel 45240116Smarcelstatic 46240116Smarcelvoid 47240116Smarcelcreate_files(void) 48240116Smarcel{ 49240116Smarcel ::mkdir("files", 0755); 50240116Smarcel ::mkdir("files/dir", 0755); 51240116Smarcel 52240116Smarcel std::ofstream os("files/reg"); 53240116Smarcel os.close(); 54240116Smarcel 55240116Smarcel // TODO: Should create all other file types (blk, chr, fifo, lnk, sock) 56240116Smarcel // and test for them... but the underlying file system may not support 57240116Smarcel // most of these. Specially as we are working on /tmp, which can be 58240116Smarcel // mounted with flags such as "nodev". See how to deal with this 59240116Smarcel // situation. 60240116Smarcel} 61240116Smarcel 62240116Smarcel// ------------------------------------------------------------------------ 63240116Smarcel// Test cases for the "path" class. 64240116Smarcel// ------------------------------------------------------------------------ 65240116Smarcel 66240116SmarcelATF_TEST_CASE(path_normalize); 67240116SmarcelATF_TEST_CASE_HEAD(path_normalize) 68240116Smarcel{ 69240116Smarcel set_md_var("descr", "Tests the path's normalization"); 70240116Smarcel} 71240116SmarcelATF_TEST_CASE_BODY(path_normalize) 72240116Smarcel{ 73240116Smarcel using atf::fs::path; 74240116Smarcel 75240116Smarcel ATF_REQUIRE_EQ(path(".").str(), "."); 76240116Smarcel ATF_REQUIRE_EQ(path("..").str(), ".."); 77240116Smarcel 78240116Smarcel ATF_REQUIRE_EQ(path("foo").str(), "foo"); 79240116Smarcel ATF_REQUIRE_EQ(path("foo/bar").str(), "foo/bar"); 80240116Smarcel ATF_REQUIRE_EQ(path("foo/bar/").str(), "foo/bar"); 81240116Smarcel 82240116Smarcel ATF_REQUIRE_EQ(path("/foo").str(), "/foo"); 83240116Smarcel ATF_REQUIRE_EQ(path("/foo/bar").str(), "/foo/bar"); 84240116Smarcel ATF_REQUIRE_EQ(path("/foo/bar/").str(), "/foo/bar"); 85240116Smarcel 86240116Smarcel ATF_REQUIRE_EQ(path("///foo").str(), "/foo"); 87240116Smarcel ATF_REQUIRE_EQ(path("///foo///bar").str(), "/foo/bar"); 88240116Smarcel ATF_REQUIRE_EQ(path("///foo///bar///").str(), "/foo/bar"); 89240116Smarcel} 90240116Smarcel 91240116SmarcelATF_TEST_CASE(path_is_absolute); 92240116SmarcelATF_TEST_CASE_HEAD(path_is_absolute) 93240116Smarcel{ 94240116Smarcel set_md_var("descr", "Tests the path::is_absolute function"); 95240116Smarcel} 96240116SmarcelATF_TEST_CASE_BODY(path_is_absolute) 97240116Smarcel{ 98240116Smarcel using atf::fs::path; 99240116Smarcel 100240116Smarcel ATF_REQUIRE( path("/").is_absolute()); 101240116Smarcel ATF_REQUIRE( path("////").is_absolute()); 102240116Smarcel ATF_REQUIRE( path("////a").is_absolute()); 103240116Smarcel ATF_REQUIRE( path("//a//").is_absolute()); 104240116Smarcel ATF_REQUIRE(!path("a////").is_absolute()); 105240116Smarcel ATF_REQUIRE(!path("../foo").is_absolute()); 106240116Smarcel} 107240116Smarcel 108240116SmarcelATF_TEST_CASE(path_is_root); 109240116SmarcelATF_TEST_CASE_HEAD(path_is_root) 110240116Smarcel{ 111240116Smarcel set_md_var("descr", "Tests the path::is_root function"); 112240116Smarcel} 113240116SmarcelATF_TEST_CASE_BODY(path_is_root) 114240116Smarcel{ 115240116Smarcel using atf::fs::path; 116240116Smarcel 117240116Smarcel ATF_REQUIRE( path("/").is_root()); 118240116Smarcel ATF_REQUIRE( path("////").is_root()); 119240116Smarcel ATF_REQUIRE(!path("////a").is_root()); 120240116Smarcel ATF_REQUIRE(!path("//a//").is_root()); 121240116Smarcel ATF_REQUIRE(!path("a////").is_root()); 122240116Smarcel ATF_REQUIRE(!path("../foo").is_root()); 123240116Smarcel} 124240116Smarcel 125240116SmarcelATF_TEST_CASE(path_branch_path); 126240116SmarcelATF_TEST_CASE_HEAD(path_branch_path) 127240116Smarcel{ 128240116Smarcel set_md_var("descr", "Tests the path::branch_path function"); 129240116Smarcel} 130240116SmarcelATF_TEST_CASE_BODY(path_branch_path) 131240116Smarcel{ 132240116Smarcel using atf::fs::path; 133240116Smarcel 134240116Smarcel ATF_REQUIRE_EQ(path(".").branch_path().str(), "."); 135240116Smarcel ATF_REQUIRE_EQ(path("foo").branch_path().str(), "."); 136240116Smarcel ATF_REQUIRE_EQ(path("foo/bar").branch_path().str(), "foo"); 137240116Smarcel ATF_REQUIRE_EQ(path("/foo").branch_path().str(), "/"); 138240116Smarcel ATF_REQUIRE_EQ(path("/foo/bar").branch_path().str(), "/foo"); 139240116Smarcel} 140240116Smarcel 141240116SmarcelATF_TEST_CASE(path_leaf_name); 142240116SmarcelATF_TEST_CASE_HEAD(path_leaf_name) 143240116Smarcel{ 144240116Smarcel set_md_var("descr", "Tests the path::leaf_name function"); 145240116Smarcel} 146240116SmarcelATF_TEST_CASE_BODY(path_leaf_name) 147240116Smarcel{ 148240116Smarcel using atf::fs::path; 149240116Smarcel 150240116Smarcel ATF_REQUIRE_EQ(path(".").leaf_name(), "."); 151240116Smarcel ATF_REQUIRE_EQ(path("foo").leaf_name(), "foo"); 152240116Smarcel ATF_REQUIRE_EQ(path("foo/bar").leaf_name(), "bar"); 153240116Smarcel ATF_REQUIRE_EQ(path("/foo").leaf_name(), "foo"); 154240116Smarcel ATF_REQUIRE_EQ(path("/foo/bar").leaf_name(), "bar"); 155240116Smarcel} 156240116Smarcel 157240116SmarcelATF_TEST_CASE(path_compare_equal); 158240116SmarcelATF_TEST_CASE_HEAD(path_compare_equal) 159240116Smarcel{ 160240116Smarcel set_md_var("descr", "Tests the comparison for equality between paths"); 161240116Smarcel} 162240116SmarcelATF_TEST_CASE_BODY(path_compare_equal) 163240116Smarcel{ 164240116Smarcel using atf::fs::path; 165240116Smarcel 166240116Smarcel ATF_REQUIRE(path("/") == path("///")); 167240116Smarcel ATF_REQUIRE(path("/a") == path("///a")); 168240116Smarcel ATF_REQUIRE(path("/a") == path("///a///")); 169240116Smarcel 170240116Smarcel ATF_REQUIRE(path("a/b/c") == path("a//b//c")); 171240116Smarcel ATF_REQUIRE(path("a/b/c") == path("a//b//c///")); 172240116Smarcel} 173240116Smarcel 174240116SmarcelATF_TEST_CASE(path_compare_different); 175240116SmarcelATF_TEST_CASE_HEAD(path_compare_different) 176240116Smarcel{ 177240116Smarcel set_md_var("descr", "Tests the comparison for difference between paths"); 178240116Smarcel} 179240116SmarcelATF_TEST_CASE_BODY(path_compare_different) 180240116Smarcel{ 181240116Smarcel using atf::fs::path; 182240116Smarcel 183240116Smarcel ATF_REQUIRE(path("/") != path("//a/")); 184240116Smarcel ATF_REQUIRE(path("/a") != path("a///")); 185240116Smarcel 186240116Smarcel ATF_REQUIRE(path("a/b/c") != path("a/b")); 187240116Smarcel ATF_REQUIRE(path("a/b/c") != path("a//b")); 188240116Smarcel ATF_REQUIRE(path("a/b/c") != path("/a/b/c")); 189240116Smarcel ATF_REQUIRE(path("a/b/c") != path("/a//b//c")); 190240116Smarcel} 191240116Smarcel 192240116SmarcelATF_TEST_CASE(path_concat); 193240116SmarcelATF_TEST_CASE_HEAD(path_concat) 194240116Smarcel{ 195240116Smarcel set_md_var("descr", "Tests the concatenation of multiple paths"); 196240116Smarcel} 197240116SmarcelATF_TEST_CASE_BODY(path_concat) 198240116Smarcel{ 199240116Smarcel using atf::fs::path; 200240116Smarcel 201240116Smarcel ATF_REQUIRE_EQ((path("foo") / "bar").str(), "foo/bar"); 202240116Smarcel ATF_REQUIRE_EQ((path("foo/") / "/bar").str(), "foo/bar"); 203240116Smarcel ATF_REQUIRE_EQ((path("foo/") / "/bar/baz").str(), "foo/bar/baz"); 204240116Smarcel ATF_REQUIRE_EQ((path("foo/") / "///bar///baz").str(), "foo/bar/baz"); 205240116Smarcel} 206240116Smarcel 207240116SmarcelATF_TEST_CASE(path_to_absolute); 208240116SmarcelATF_TEST_CASE_HEAD(path_to_absolute) 209240116Smarcel{ 210240116Smarcel set_md_var("descr", "Tests the conversion of a relative path to an " 211240116Smarcel "absolute one"); 212240116Smarcel} 213240116SmarcelATF_TEST_CASE_BODY(path_to_absolute) 214240116Smarcel{ 215240116Smarcel using atf::fs::file_info; 216240116Smarcel using atf::fs::path; 217240116Smarcel 218240116Smarcel create_files(); 219240116Smarcel 220240116Smarcel { 221240116Smarcel const path p("."); 222240116Smarcel path pa = p.to_absolute(); 223240116Smarcel ATF_REQUIRE(pa.is_absolute()); 224240116Smarcel 225240116Smarcel file_info fi(p); 226240116Smarcel file_info fia(pa); 227240116Smarcel ATF_REQUIRE_EQ(fi.get_device(), fia.get_device()); 228240116Smarcel ATF_REQUIRE_EQ(fi.get_inode(), fia.get_inode()); 229240116Smarcel } 230240116Smarcel 231240116Smarcel { 232240116Smarcel const path p("files/reg"); 233240116Smarcel path pa = p.to_absolute(); 234240116Smarcel ATF_REQUIRE(pa.is_absolute()); 235240116Smarcel 236240116Smarcel file_info fi(p); 237240116Smarcel file_info fia(pa); 238240116Smarcel ATF_REQUIRE_EQ(fi.get_device(), fia.get_device()); 239240116Smarcel ATF_REQUIRE_EQ(fi.get_inode(), fia.get_inode()); 240240116Smarcel } 241240116Smarcel} 242240116Smarcel 243240116SmarcelATF_TEST_CASE(path_op_less); 244240116SmarcelATF_TEST_CASE_HEAD(path_op_less) 245240116Smarcel{ 246240116Smarcel set_md_var("descr", "Tests that the path's less-than operator works"); 247240116Smarcel} 248240116SmarcelATF_TEST_CASE_BODY(path_op_less) 249240116Smarcel{ 250240116Smarcel using atf::fs::path; 251240116Smarcel 252240116Smarcel create_files(); 253240116Smarcel 254240116Smarcel ATF_REQUIRE(!(path("aaa") < path("aaa"))); 255240116Smarcel 256240116Smarcel ATF_REQUIRE( path("aab") < path("abc")); 257240116Smarcel ATF_REQUIRE(!(path("abc") < path("aab"))); 258240116Smarcel} 259240116Smarcel 260240116Smarcel// ------------------------------------------------------------------------ 261240116Smarcel// Test cases for the "directory" class. 262240116Smarcel// ------------------------------------------------------------------------ 263240116Smarcel 264240116SmarcelATF_TEST_CASE(directory_read); 265240116SmarcelATF_TEST_CASE_HEAD(directory_read) 266240116Smarcel{ 267240116Smarcel set_md_var("descr", "Tests the directory class creation, which reads " 268240116Smarcel "the contents of a directory"); 269240116Smarcel} 270240116SmarcelATF_TEST_CASE_BODY(directory_read) 271240116Smarcel{ 272240116Smarcel using atf::fs::directory; 273240116Smarcel using atf::fs::path; 274240116Smarcel 275240116Smarcel create_files(); 276240116Smarcel 277240116Smarcel directory d(path("files")); 278240116Smarcel ATF_REQUIRE_EQ(d.size(), 4); 279240116Smarcel ATF_REQUIRE(d.find(".") != d.end()); 280240116Smarcel ATF_REQUIRE(d.find("..") != d.end()); 281240116Smarcel ATF_REQUIRE(d.find("dir") != d.end()); 282240116Smarcel ATF_REQUIRE(d.find("reg") != d.end()); 283240116Smarcel} 284240116Smarcel 285240116SmarcelATF_TEST_CASE(directory_file_info); 286240116SmarcelATF_TEST_CASE_HEAD(directory_file_info) 287240116Smarcel{ 288240116Smarcel set_md_var("descr", "Tests that the file_info objects attached to the " 289240116Smarcel "directory are valid"); 290240116Smarcel} 291240116SmarcelATF_TEST_CASE_BODY(directory_file_info) 292240116Smarcel{ 293240116Smarcel using atf::fs::directory; 294240116Smarcel using atf::fs::file_info; 295240116Smarcel using atf::fs::path; 296240116Smarcel 297240116Smarcel create_files(); 298240116Smarcel 299240116Smarcel directory d(path("files")); 300240116Smarcel 301240116Smarcel { 302240116Smarcel directory::const_iterator iter = d.find("dir"); 303240116Smarcel ATF_REQUIRE(iter != d.end()); 304240116Smarcel const file_info& fi = (*iter).second; 305240116Smarcel ATF_REQUIRE(fi.get_type() == file_info::dir_type); 306240116Smarcel } 307240116Smarcel 308240116Smarcel { 309240116Smarcel directory::const_iterator iter = d.find("reg"); 310240116Smarcel ATF_REQUIRE(iter != d.end()); 311240116Smarcel const file_info& fi = (*iter).second; 312240116Smarcel ATF_REQUIRE(fi.get_type() == file_info::reg_type); 313240116Smarcel } 314240116Smarcel} 315240116Smarcel 316240116SmarcelATF_TEST_CASE(directory_names); 317240116SmarcelATF_TEST_CASE_HEAD(directory_names) 318240116Smarcel{ 319240116Smarcel set_md_var("descr", "Tests the directory's names method"); 320240116Smarcel} 321240116SmarcelATF_TEST_CASE_BODY(directory_names) 322240116Smarcel{ 323240116Smarcel using atf::fs::directory; 324240116Smarcel using atf::fs::path; 325240116Smarcel 326240116Smarcel create_files(); 327240116Smarcel 328240116Smarcel directory d(path("files")); 329240116Smarcel std::set< std::string > ns = d.names(); 330240116Smarcel ATF_REQUIRE_EQ(ns.size(), 4); 331240116Smarcel ATF_REQUIRE(ns.find(".") != ns.end()); 332240116Smarcel ATF_REQUIRE(ns.find("..") != ns.end()); 333240116Smarcel ATF_REQUIRE(ns.find("dir") != ns.end()); 334240116Smarcel ATF_REQUIRE(ns.find("reg") != ns.end()); 335240116Smarcel} 336240116Smarcel 337240116Smarcel// ------------------------------------------------------------------------ 338240116Smarcel// Test cases for the "file_info" class. 339240116Smarcel// ------------------------------------------------------------------------ 340240116Smarcel 341240116SmarcelATF_TEST_CASE(file_info_stat); 342240116SmarcelATF_TEST_CASE_HEAD(file_info_stat) 343240116Smarcel{ 344240116Smarcel set_md_var("descr", "Tests the file_info creation and its basic contents"); 345240116Smarcel} 346240116SmarcelATF_TEST_CASE_BODY(file_info_stat) 347240116Smarcel{ 348240116Smarcel using atf::fs::file_info; 349240116Smarcel using atf::fs::path; 350240116Smarcel 351240116Smarcel create_files(); 352240116Smarcel 353240116Smarcel { 354240116Smarcel path p("files/dir"); 355240116Smarcel file_info fi(p); 356240116Smarcel ATF_REQUIRE(fi.get_type() == file_info::dir_type); 357240116Smarcel } 358240116Smarcel 359240116Smarcel { 360240116Smarcel path p("files/reg"); 361240116Smarcel file_info fi(p); 362240116Smarcel ATF_REQUIRE(fi.get_type() == file_info::reg_type); 363240116Smarcel } 364240116Smarcel} 365240116Smarcel 366240116SmarcelATF_TEST_CASE(file_info_perms); 367240116SmarcelATF_TEST_CASE_HEAD(file_info_perms) 368240116Smarcel{ 369240116Smarcel set_md_var("descr", "Tests the file_info methods to get the file's " 370240116Smarcel "permissions"); 371240116Smarcel} 372240116SmarcelATF_TEST_CASE_BODY(file_info_perms) 373240116Smarcel{ 374240116Smarcel using atf::fs::file_info; 375240116Smarcel using atf::fs::path; 376240116Smarcel 377240116Smarcel path p("file"); 378240116Smarcel 379240116Smarcel std::ofstream os(p.c_str()); 380240116Smarcel os.close(); 381240116Smarcel 382240116Smarcel#define perms(ur, uw, ux, gr, gw, gx, othr, othw, othx) \ 383240116Smarcel { \ 384240116Smarcel file_info fi(p); \ 385240116Smarcel ATF_REQUIRE(fi.is_owner_readable() == ur); \ 386240116Smarcel ATF_REQUIRE(fi.is_owner_writable() == uw); \ 387240116Smarcel ATF_REQUIRE(fi.is_owner_executable() == ux); \ 388240116Smarcel ATF_REQUIRE(fi.is_group_readable() == gr); \ 389240116Smarcel ATF_REQUIRE(fi.is_group_writable() == gw); \ 390240116Smarcel ATF_REQUIRE(fi.is_group_executable() == gx); \ 391240116Smarcel ATF_REQUIRE(fi.is_other_readable() == othr); \ 392240116Smarcel ATF_REQUIRE(fi.is_other_writable() == othw); \ 393240116Smarcel ATF_REQUIRE(fi.is_other_executable() == othx); \ 394240116Smarcel } 395240116Smarcel 396240116Smarcel ::chmod(p.c_str(), 0000); 397240116Smarcel perms(false, false, false, false, false, false, false, false, false); 398240116Smarcel 399240116Smarcel ::chmod(p.c_str(), 0001); 400240116Smarcel perms(false, false, false, false, false, false, false, false, true); 401240116Smarcel 402240116Smarcel ::chmod(p.c_str(), 0010); 403240116Smarcel perms(false, false, false, false, false, true, false, false, false); 404240116Smarcel 405240116Smarcel ::chmod(p.c_str(), 0100); 406240116Smarcel perms(false, false, true, false, false, false, false, false, false); 407240116Smarcel 408240116Smarcel ::chmod(p.c_str(), 0002); 409240116Smarcel perms(false, false, false, false, false, false, false, true, false); 410240116Smarcel 411240116Smarcel ::chmod(p.c_str(), 0020); 412240116Smarcel perms(false, false, false, false, true, false, false, false, false); 413240116Smarcel 414240116Smarcel ::chmod(p.c_str(), 0200); 415240116Smarcel perms(false, true, false, false, false, false, false, false, false); 416240116Smarcel 417240116Smarcel ::chmod(p.c_str(), 0004); 418240116Smarcel perms(false, false, false, false, false, false, true, false, false); 419240116Smarcel 420240116Smarcel ::chmod(p.c_str(), 0040); 421240116Smarcel perms(false, false, false, true, false, false, false, false, false); 422240116Smarcel 423240116Smarcel ::chmod(p.c_str(), 0400); 424240116Smarcel perms(true, false, false, false, false, false, false, false, false); 425240116Smarcel 426240116Smarcel ::chmod(p.c_str(), 0644); 427240116Smarcel perms(true, true, false, true, false, false, true, false, false); 428240116Smarcel 429240116Smarcel ::chmod(p.c_str(), 0755); 430240116Smarcel perms(true, true, true, true, false, true, true, false, true); 431240116Smarcel 432240116Smarcel ::chmod(p.c_str(), 0777); 433240116Smarcel perms(true, true, true, true, true, true, true, true, true); 434240116Smarcel 435240116Smarcel#undef perms 436240116Smarcel} 437240116Smarcel 438240116Smarcel// ------------------------------------------------------------------------ 439240116Smarcel// Test cases for the free functions. 440240116Smarcel// ------------------------------------------------------------------------ 441240116Smarcel 442240116SmarcelATF_TEST_CASE(exists); 443240116SmarcelATF_TEST_CASE_HEAD(exists) 444240116Smarcel{ 445240116Smarcel set_md_var("descr", "Tests the exists function"); 446240116Smarcel} 447240116SmarcelATF_TEST_CASE_BODY(exists) 448240116Smarcel{ 449240116Smarcel using atf::fs::exists; 450240116Smarcel using atf::fs::path; 451240116Smarcel 452240116Smarcel create_files(); 453240116Smarcel 454240116Smarcel ATF_REQUIRE( exists(path("files"))); 455240116Smarcel ATF_REQUIRE(!exists(path("file"))); 456240116Smarcel ATF_REQUIRE(!exists(path("files2"))); 457240116Smarcel 458240116Smarcel ATF_REQUIRE( exists(path("files/."))); 459240116Smarcel ATF_REQUIRE( exists(path("files/.."))); 460240116Smarcel ATF_REQUIRE( exists(path("files/dir"))); 461240116Smarcel ATF_REQUIRE( exists(path("files/reg"))); 462240116Smarcel ATF_REQUIRE(!exists(path("files/foo"))); 463240116Smarcel} 464240116Smarcel 465240116SmarcelATF_TEST_CASE(is_executable); 466240116SmarcelATF_TEST_CASE_HEAD(is_executable) 467240116Smarcel{ 468240116Smarcel set_md_var("descr", "Tests the is_executable function"); 469240116Smarcel} 470240116SmarcelATF_TEST_CASE_BODY(is_executable) 471240116Smarcel{ 472240116Smarcel using atf::fs::is_executable; 473240116Smarcel using atf::fs::path; 474240116Smarcel 475240116Smarcel create_files(); 476240116Smarcel 477240116Smarcel ATF_REQUIRE( is_executable(path("files"))); 478240116Smarcel ATF_REQUIRE( is_executable(path("files/."))); 479240116Smarcel ATF_REQUIRE( is_executable(path("files/.."))); 480240116Smarcel ATF_REQUIRE( is_executable(path("files/dir"))); 481240116Smarcel 482240116Smarcel ATF_REQUIRE(!is_executable(path("non-existent"))); 483240116Smarcel 484240116Smarcel ATF_REQUIRE(!is_executable(path("files/reg"))); 485240116Smarcel ATF_REQUIRE(::chmod("files/reg", 0755) != -1); 486240116Smarcel ATF_REQUIRE( is_executable(path("files/reg"))); 487240116Smarcel} 488240116Smarcel 489240116SmarcelATF_TEST_CASE(remove); 490240116SmarcelATF_TEST_CASE_HEAD(remove) 491240116Smarcel{ 492240116Smarcel set_md_var("descr", "Tests the remove function"); 493240116Smarcel} 494240116SmarcelATF_TEST_CASE_BODY(remove) 495240116Smarcel{ 496240116Smarcel using atf::fs::exists; 497240116Smarcel using atf::fs::path; 498240116Smarcel using atf::fs::remove; 499240116Smarcel 500240116Smarcel create_files(); 501240116Smarcel 502240116Smarcel ATF_REQUIRE( exists(path("files/reg"))); 503240116Smarcel remove(path("files/reg")); 504240116Smarcel ATF_REQUIRE(!exists(path("files/reg"))); 505240116Smarcel 506240116Smarcel ATF_REQUIRE( exists(path("files/dir"))); 507240116Smarcel ATF_REQUIRE_THROW(atf::system_error, remove(path("files/dir"))); 508240116Smarcel ATF_REQUIRE( exists(path("files/dir"))); 509240116Smarcel} 510240116Smarcel 511240116Smarcel// ------------------------------------------------------------------------ 512240116Smarcel// Main. 513240116Smarcel// ------------------------------------------------------------------------ 514240116Smarcel 515240116SmarcelATF_INIT_TEST_CASES(tcs) 516240116Smarcel{ 517240116Smarcel // Add the tests for the "path" class. 518240116Smarcel ATF_ADD_TEST_CASE(tcs, path_normalize); 519240116Smarcel ATF_ADD_TEST_CASE(tcs, path_is_absolute); 520240116Smarcel ATF_ADD_TEST_CASE(tcs, path_is_root); 521240116Smarcel ATF_ADD_TEST_CASE(tcs, path_branch_path); 522240116Smarcel ATF_ADD_TEST_CASE(tcs, path_leaf_name); 523240116Smarcel ATF_ADD_TEST_CASE(tcs, path_compare_equal); 524240116Smarcel ATF_ADD_TEST_CASE(tcs, path_compare_different); 525240116Smarcel ATF_ADD_TEST_CASE(tcs, path_concat); 526240116Smarcel ATF_ADD_TEST_CASE(tcs, path_to_absolute); 527240116Smarcel ATF_ADD_TEST_CASE(tcs, path_op_less); 528240116Smarcel 529240116Smarcel // Add the tests for the "file_info" class. 530240116Smarcel ATF_ADD_TEST_CASE(tcs, file_info_stat); 531240116Smarcel ATF_ADD_TEST_CASE(tcs, file_info_perms); 532240116Smarcel 533240116Smarcel // Add the tests for the "directory" class. 534240116Smarcel ATF_ADD_TEST_CASE(tcs, directory_read); 535240116Smarcel ATF_ADD_TEST_CASE(tcs, directory_names); 536240116Smarcel ATF_ADD_TEST_CASE(tcs, directory_file_info); 537240116Smarcel 538240116Smarcel // Add the tests for the free functions. 539240116Smarcel ATF_ADD_TEST_CASE(tcs, exists); 540240116Smarcel ATF_ADD_TEST_CASE(tcs, is_executable); 541240116Smarcel ATF_ADD_TEST_CASE(tcs, remove); 542240116Smarcel} 543