fs_test.cpp revision 240117
153913Sarchie// 253913Sarchie// Automated Testing Framework (atf) 353913Sarchie// 453913Sarchie// Copyright (c) 2007 The NetBSD Foundation, Inc. 553913Sarchie// All rights reserved. 653913Sarchie// 753913Sarchie// Redistribution and use in source and binary forms, with or without 853913Sarchie// modification, are permitted provided that the following conditions 953913Sarchie// are met: 1053913Sarchie// 1. Redistributions of source code must retain the above copyright 1153913Sarchie// notice, this list of conditions and the following disclaimer. 1253913Sarchie// 2. Redistributions in binary form must reproduce the above copyright 1353913Sarchie// notice, this list of conditions and the following disclaimer in the 1453913Sarchie// documentation and/or other materials provided with the distribution. 1553913Sarchie// 1653913Sarchie// THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND 1753913Sarchie// CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, 1853913Sarchie// INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 1953913Sarchie// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 2053913Sarchie// IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS BE LIABLE FOR ANY 2153913Sarchie// DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 2253913Sarchie// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE 2353913Sarchie// GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 2453913Sarchie// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER 2553913Sarchie// IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 2653913Sarchie// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN 2753913Sarchie// IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 2853913Sarchie// 2953913Sarchie 3053913Sarchieextern "C" { 3153913Sarchie#include <sys/types.h> 3253913Sarchie#include <sys/stat.h> 3353913Sarchie} 3453913Sarchie 3553913Sarchie#include <fstream> 3653913Sarchie#include <cerrno> 3767506Sjulian#include <cstdio> 3853913Sarchie 3953913Sarchie#include "../macros.hpp" 4053913Sarchie 4153913Sarchie#include "exceptions.hpp" 4253913Sarchie#include "fs.hpp" 4353913Sarchie 4453913Sarchie// ------------------------------------------------------------------------ 4553913Sarchie// Auxiliary functions. 4653913Sarchie// ------------------------------------------------------------------------ 4753913Sarchie 4853913Sarchiestatic 4953913Sarchievoid 5053913Sarchiecreate_files(void) 5153913Sarchie{ 5253913Sarchie ::mkdir("files", 0755); 5353913Sarchie ::mkdir("files/dir", 0755); 5453913Sarchie 5553913Sarchie std::ofstream os("files/reg"); 5653913Sarchie os.close(); 5753913Sarchie 5853913Sarchie // TODO: Should create all other file types (blk, chr, fifo, lnk, sock) 5953913Sarchie // and test for them... but the underlying file system may not support 6053913Sarchie // most of these. Specially as we are working on /tmp, which can be 6153913Sarchie // mounted with flags such as "nodev". See how to deal with this 6253913Sarchie // situation. 6353913Sarchie} 6453913Sarchie 6553913Sarchie// ------------------------------------------------------------------------ 6653913Sarchie// Test cases for the "path" class. 6753913Sarchie// ------------------------------------------------------------------------ 6853913Sarchie 6953913SarchieATF_TEST_CASE(path_normalize); 7053913SarchieATF_TEST_CASE_HEAD(path_normalize) 7153913Sarchie{ 7253913Sarchie set_md_var("descr", "Tests the path's normalization"); 7353913Sarchie} 7453913SarchieATF_TEST_CASE_BODY(path_normalize) 7553913Sarchie{ 7653913Sarchie using atf::fs::path; 7764505Sarchie 7864505Sarchie ATF_REQUIRE_EQ(path(".").str(), "."); 7964505Sarchie ATF_REQUIRE_EQ(path("..").str(), ".."); 8064505Sarchie 8164505Sarchie ATF_REQUIRE_EQ(path("foo").str(), "foo"); 8253913Sarchie ATF_REQUIRE_EQ(path("foo/bar").str(), "foo/bar"); 8353913Sarchie ATF_REQUIRE_EQ(path("foo/bar/").str(), "foo/bar"); 8453913Sarchie 8553913Sarchie ATF_REQUIRE_EQ(path("/foo").str(), "/foo"); 8653913Sarchie ATF_REQUIRE_EQ(path("/foo/bar").str(), "/foo/bar"); 8753913Sarchie ATF_REQUIRE_EQ(path("/foo/bar/").str(), "/foo/bar"); 8853913Sarchie 8953913Sarchie ATF_REQUIRE_EQ(path("///foo").str(), "/foo"); 9053913Sarchie ATF_REQUIRE_EQ(path("///foo///bar").str(), "/foo/bar"); 9153913Sarchie ATF_REQUIRE_EQ(path("///foo///bar///").str(), "/foo/bar"); 9253913Sarchie} 9353913Sarchie 9453913SarchieATF_TEST_CASE(path_is_absolute); 9553913SarchieATF_TEST_CASE_HEAD(path_is_absolute) 9653913Sarchie{ 9753913Sarchie set_md_var("descr", "Tests the path::is_absolute function"); 9853913Sarchie} 9953913SarchieATF_TEST_CASE_BODY(path_is_absolute) 10053913Sarchie{ 10153913Sarchie using atf::fs::path; 10253913Sarchie 10353913Sarchie ATF_REQUIRE( path("/").is_absolute()); 10453913Sarchie ATF_REQUIRE( path("////").is_absolute()); 10553913Sarchie ATF_REQUIRE( path("////a").is_absolute()); 10653913Sarchie ATF_REQUIRE( path("//a//").is_absolute()); 10753913Sarchie ATF_REQUIRE(!path("a////").is_absolute()); 10853913Sarchie ATF_REQUIRE(!path("../foo").is_absolute()); 10953913Sarchie} 11053913Sarchie 11153913SarchieATF_TEST_CASE(path_is_root); 11253913SarchieATF_TEST_CASE_HEAD(path_is_root) 11353913Sarchie{ 11453913Sarchie set_md_var("descr", "Tests the path::is_root function"); 11553913Sarchie} 11653913SarchieATF_TEST_CASE_BODY(path_is_root) 11753913Sarchie{ 11853913Sarchie using atf::fs::path; 11953913Sarchie 12053913Sarchie ATF_REQUIRE( path("/").is_root()); 12153913Sarchie ATF_REQUIRE( path("////").is_root()); 12253913Sarchie ATF_REQUIRE(!path("////a").is_root()); 12353913Sarchie ATF_REQUIRE(!path("//a//").is_root()); 12453913Sarchie ATF_REQUIRE(!path("a////").is_root()); 12553913Sarchie ATF_REQUIRE(!path("../foo").is_root()); 12653913Sarchie} 12753913Sarchie 12853913SarchieATF_TEST_CASE(path_branch_path); 12953913SarchieATF_TEST_CASE_HEAD(path_branch_path) 13053913Sarchie{ 13153913Sarchie set_md_var("descr", "Tests the path::branch_path function"); 13253913Sarchie} 13353913SarchieATF_TEST_CASE_BODY(path_branch_path) 13453913Sarchie{ 13553913Sarchie using atf::fs::path; 13653913Sarchie 13753913Sarchie ATF_REQUIRE_EQ(path(".").branch_path().str(), "."); 13853913Sarchie ATF_REQUIRE_EQ(path("foo").branch_path().str(), "."); 13953913Sarchie ATF_REQUIRE_EQ(path("foo/bar").branch_path().str(), "foo"); 14053913Sarchie ATF_REQUIRE_EQ(path("/foo").branch_path().str(), "/"); 14153913Sarchie ATF_REQUIRE_EQ(path("/foo/bar").branch_path().str(), "/foo"); 14253913Sarchie} 14353913Sarchie 14453913SarchieATF_TEST_CASE(path_leaf_name); 14553913SarchieATF_TEST_CASE_HEAD(path_leaf_name) 14653913Sarchie{ 14753913Sarchie set_md_var("descr", "Tests the path::leaf_name function"); 14853913Sarchie} 14953913SarchieATF_TEST_CASE_BODY(path_leaf_name) 15053913Sarchie{ 15153913Sarchie using atf::fs::path; 15253913Sarchie 15353913Sarchie ATF_REQUIRE_EQ(path(".").leaf_name(), "."); 15453913Sarchie ATF_REQUIRE_EQ(path("foo").leaf_name(), "foo"); 15553913Sarchie ATF_REQUIRE_EQ(path("foo/bar").leaf_name(), "bar"); 15653913Sarchie ATF_REQUIRE_EQ(path("/foo").leaf_name(), "foo"); 15753913Sarchie ATF_REQUIRE_EQ(path("/foo/bar").leaf_name(), "bar"); 15853913Sarchie} 15953913Sarchie 16053913SarchieATF_TEST_CASE(path_compare_equal); 16153913SarchieATF_TEST_CASE_HEAD(path_compare_equal) 16253913Sarchie{ 16353913Sarchie set_md_var("descr", "Tests the comparison for equality between paths"); 16453913Sarchie} 16553913SarchieATF_TEST_CASE_BODY(path_compare_equal) 16653913Sarchie{ 16753913Sarchie using atf::fs::path; 16853913Sarchie 16953913Sarchie ATF_REQUIRE(path("/") == path("///")); 17053913Sarchie ATF_REQUIRE(path("/a") == path("///a")); 17153913Sarchie ATF_REQUIRE(path("/a") == path("///a///")); 17253913Sarchie 17353913Sarchie ATF_REQUIRE(path("a/b/c") == path("a//b//c")); 17453913Sarchie ATF_REQUIRE(path("a/b/c") == path("a//b//c///")); 17553913Sarchie} 17653913Sarchie 17753913SarchieATF_TEST_CASE(path_compare_different); 17853913SarchieATF_TEST_CASE_HEAD(path_compare_different) 17953913Sarchie{ 18053913Sarchie set_md_var("descr", "Tests the comparison for difference between paths"); 18153913Sarchie} 18253913SarchieATF_TEST_CASE_BODY(path_compare_different) 18353913Sarchie{ 18453913Sarchie using atf::fs::path; 18553913Sarchie 18653913Sarchie ATF_REQUIRE(path("/") != path("//a/")); 18753913Sarchie ATF_REQUIRE(path("/a") != path("a///")); 18853913Sarchie 18953913Sarchie ATF_REQUIRE(path("a/b/c") != path("a/b")); 19053913Sarchie ATF_REQUIRE(path("a/b/c") != path("a//b")); 19153913Sarchie ATF_REQUIRE(path("a/b/c") != path("/a/b/c")); 19253913Sarchie ATF_REQUIRE(path("a/b/c") != path("/a//b//c")); 19353913Sarchie} 19453913Sarchie 19553913SarchieATF_TEST_CASE(path_concat); 19653913SarchieATF_TEST_CASE_HEAD(path_concat) 19753913Sarchie{ 19853913Sarchie set_md_var("descr", "Tests the concatenation of multiple paths"); 19953913Sarchie} 20053913SarchieATF_TEST_CASE_BODY(path_concat) 20153913Sarchie{ 20253913Sarchie using atf::fs::path; 20353913Sarchie 20453913Sarchie ATF_REQUIRE_EQ((path("foo") / "bar").str(), "foo/bar"); 20553913Sarchie ATF_REQUIRE_EQ((path("foo/") / "/bar").str(), "foo/bar"); 20653913Sarchie ATF_REQUIRE_EQ((path("foo/") / "/bar/baz").str(), "foo/bar/baz"); 20753913Sarchie ATF_REQUIRE_EQ((path("foo/") / "///bar///baz").str(), "foo/bar/baz"); 20853913Sarchie} 20953913Sarchie 21053913SarchieATF_TEST_CASE(path_to_absolute); 21153913SarchieATF_TEST_CASE_HEAD(path_to_absolute) 21253913Sarchie{ 21353913Sarchie set_md_var("descr", "Tests the conversion of a relative path to an " 21453913Sarchie "absolute one"); 21553913Sarchie} 21653913SarchieATF_TEST_CASE_BODY(path_to_absolute) 21753913Sarchie{ 21853913Sarchie using atf::fs::file_info; 21953913Sarchie using atf::fs::path; 22053913Sarchie 22153913Sarchie create_files(); 22253913Sarchie 22353913Sarchie { 22453913Sarchie const path p("."); 22553913Sarchie path pa = p.to_absolute(); 22653913Sarchie ATF_REQUIRE(pa.is_absolute()); 22753913Sarchie 22853913Sarchie file_info fi(p); 22953913Sarchie file_info fia(pa); 23053913Sarchie ATF_REQUIRE_EQ(fi.get_device(), fia.get_device()); 23153913Sarchie ATF_REQUIRE_EQ(fi.get_inode(), fia.get_inode()); 23253913Sarchie } 23353913Sarchie 23453913Sarchie { 23553913Sarchie const path p("files/reg"); 23653913Sarchie path pa = p.to_absolute(); 23753913Sarchie ATF_REQUIRE(pa.is_absolute()); 23853913Sarchie 23953913Sarchie file_info fi(p); 24053913Sarchie file_info fia(pa); 24153913Sarchie ATF_REQUIRE_EQ(fi.get_device(), fia.get_device()); 24253913Sarchie ATF_REQUIRE_EQ(fi.get_inode(), fia.get_inode()); 24353913Sarchie } 24453913Sarchie} 24553913Sarchie 24653913SarchieATF_TEST_CASE(path_op_less); 24753913SarchieATF_TEST_CASE_HEAD(path_op_less) 24853913Sarchie{ 24953913Sarchie set_md_var("descr", "Tests that the path's less-than operator works"); 25053913Sarchie} 25153913SarchieATF_TEST_CASE_BODY(path_op_less) 25253913Sarchie{ 25353913Sarchie using atf::fs::path; 25453913Sarchie 25553913Sarchie create_files(); 25653913Sarchie 25753913Sarchie ATF_REQUIRE(!(path("aaa") < path("aaa"))); 25853913Sarchie 25953913Sarchie ATF_REQUIRE( path("aab") < path("abc")); 26053913Sarchie ATF_REQUIRE(!(path("abc") < path("aab"))); 26153913Sarchie} 26253913Sarchie 26353913Sarchie// ------------------------------------------------------------------------ 26453913Sarchie// Test cases for the "directory" class. 26553913Sarchie// ------------------------------------------------------------------------ 26653913Sarchie 26753913SarchieATF_TEST_CASE(directory_read); 26853913SarchieATF_TEST_CASE_HEAD(directory_read) 26953913Sarchie{ 27053913Sarchie set_md_var("descr", "Tests the directory class creation, which reads " 27153913Sarchie "the contents of a directory"); 27253913Sarchie} 27353913SarchieATF_TEST_CASE_BODY(directory_read) 27453913Sarchie{ 27553913Sarchie using atf::fs::directory; 27653913Sarchie using atf::fs::path; 27753913Sarchie 27853913Sarchie create_files(); 27953913Sarchie 28053913Sarchie directory d(path("files")); 28153913Sarchie ATF_REQUIRE_EQ(d.size(), 4); 28253913Sarchie ATF_REQUIRE(d.find(".") != d.end()); 28353913Sarchie ATF_REQUIRE(d.find("..") != d.end()); 28453913Sarchie ATF_REQUIRE(d.find("dir") != d.end()); 28553913Sarchie ATF_REQUIRE(d.find("reg") != d.end()); 28653913Sarchie} 28753913Sarchie 28853913SarchieATF_TEST_CASE(directory_file_info); 28953913SarchieATF_TEST_CASE_HEAD(directory_file_info) 29053913Sarchie{ 29153913Sarchie set_md_var("descr", "Tests that the file_info objects attached to the " 29253913Sarchie "directory are valid"); 29353913Sarchie} 29453913SarchieATF_TEST_CASE_BODY(directory_file_info) 29553913Sarchie{ 29653913Sarchie using atf::fs::directory; 29753913Sarchie using atf::fs::file_info; 29853913Sarchie using atf::fs::path; 29953913Sarchie 30053913Sarchie create_files(); 30153913Sarchie 30253913Sarchie directory d(path("files")); 30353913Sarchie 30453913Sarchie { 30553913Sarchie directory::const_iterator iter = d.find("dir"); 30653913Sarchie ATF_REQUIRE(iter != d.end()); 30753913Sarchie const file_info& fi = (*iter).second; 30853913Sarchie ATF_REQUIRE(fi.get_type() == file_info::dir_type); 30953913Sarchie } 31053913Sarchie 31153913Sarchie { 31253913Sarchie directory::const_iterator iter = d.find("reg"); 31353913Sarchie ATF_REQUIRE(iter != d.end()); 31453913Sarchie const file_info& fi = (*iter).second; 31553913Sarchie ATF_REQUIRE(fi.get_type() == file_info::reg_type); 31653913Sarchie } 31753913Sarchie} 31853913Sarchie 31953913SarchieATF_TEST_CASE(directory_names); 32053913SarchieATF_TEST_CASE_HEAD(directory_names) 32153913Sarchie{ 32253913Sarchie set_md_var("descr", "Tests the directory's names method"); 32353913Sarchie} 32453913SarchieATF_TEST_CASE_BODY(directory_names) 32553913Sarchie{ 32653913Sarchie using atf::fs::directory; 32753913Sarchie using atf::fs::path; 32853913Sarchie 32953913Sarchie create_files(); 33053913Sarchie 33153913Sarchie directory d(path("files")); 33253913Sarchie std::set< std::string > ns = d.names(); 33353913Sarchie ATF_REQUIRE_EQ(ns.size(), 4); 33453913Sarchie ATF_REQUIRE(ns.find(".") != ns.end()); 33553913Sarchie ATF_REQUIRE(ns.find("..") != ns.end()); 33653913Sarchie ATF_REQUIRE(ns.find("dir") != ns.end()); 33753913Sarchie ATF_REQUIRE(ns.find("reg") != ns.end()); 33853913Sarchie} 33953913Sarchie 34053913Sarchie// ------------------------------------------------------------------------ 34153913Sarchie// Test cases for the "file_info" class. 34253913Sarchie// ------------------------------------------------------------------------ 34353913Sarchie 34453913SarchieATF_TEST_CASE(file_info_stat); 34553913SarchieATF_TEST_CASE_HEAD(file_info_stat) 34653913Sarchie{ 34753913Sarchie set_md_var("descr", "Tests the file_info creation and its basic contents"); 34853913Sarchie} 34953913SarchieATF_TEST_CASE_BODY(file_info_stat) 35053913Sarchie{ 35153913Sarchie using atf::fs::file_info; 35253913Sarchie using atf::fs::path; 35353913Sarchie 35464505Sarchie create_files(); 35564505Sarchie 35653913Sarchie { 35753913Sarchie path p("files/dir"); 35853913Sarchie file_info fi(p); 35964505Sarchie ATF_REQUIRE(fi.get_type() == file_info::dir_type); 36064505Sarchie } 36164505Sarchie 36264505Sarchie { 36364505Sarchie path p("files/reg"); 36464505Sarchie file_info fi(p); 36564505Sarchie ATF_REQUIRE(fi.get_type() == file_info::reg_type); 36664505Sarchie } 36764505Sarchie} 36864505Sarchie 36964505SarchieATF_TEST_CASE(file_info_perms); 37064505SarchieATF_TEST_CASE_HEAD(file_info_perms) 37164505Sarchie{ 37264505Sarchie set_md_var("descr", "Tests the file_info methods to get the file's " 37364505Sarchie "permissions"); 37464505Sarchie} 37564505SarchieATF_TEST_CASE_BODY(file_info_perms) 37653913Sarchie{ 37753913Sarchie using atf::fs::file_info; 37853913Sarchie using atf::fs::path; 37953913Sarchie 38053913Sarchie path p("file"); 38153913Sarchie 38253913Sarchie std::ofstream os(p.c_str()); 38353913Sarchie os.close(); 38453913Sarchie 38553913Sarchie#define perms(ur, uw, ux, gr, gw, gx, othr, othw, othx) \ 38653913Sarchie { \ 38753913Sarchie file_info fi(p); \ 38853913Sarchie ATF_REQUIRE(fi.is_owner_readable() == ur); \ 38953913Sarchie ATF_REQUIRE(fi.is_owner_writable() == uw); \ 39053913Sarchie ATF_REQUIRE(fi.is_owner_executable() == ux); \ 39153913Sarchie ATF_REQUIRE(fi.is_group_readable() == gr); \ 39253913Sarchie ATF_REQUIRE(fi.is_group_writable() == gw); \ 39353913Sarchie ATF_REQUIRE(fi.is_group_executable() == gx); \ 39453913Sarchie ATF_REQUIRE(fi.is_other_readable() == othr); \ 39553913Sarchie ATF_REQUIRE(fi.is_other_writable() == othw); \ 39653913Sarchie ATF_REQUIRE(fi.is_other_executable() == othx); \ 39753913Sarchie } 39853913Sarchie 39953913Sarchie ::chmod(p.c_str(), 0000); 40053913Sarchie perms(false, false, false, false, false, false, false, false, false); 40153913Sarchie 40264505Sarchie ::chmod(p.c_str(), 0001); 40353913Sarchie perms(false, false, false, false, false, false, false, false, true); 40453913Sarchie 40553913Sarchie ::chmod(p.c_str(), 0010); 40653913Sarchie perms(false, false, false, false, false, true, false, false, false); 40753913Sarchie 40853913Sarchie ::chmod(p.c_str(), 0100); 40953913Sarchie perms(false, false, true, false, false, false, false, false, false); 41064505Sarchie 41164505Sarchie ::chmod(p.c_str(), 0002); 41264505Sarchie perms(false, false, false, false, false, false, false, true, false); 41364505Sarchie 41464505Sarchie ::chmod(p.c_str(), 0020); 41564505Sarchie perms(false, false, false, false, true, false, false, false, false); 41664505Sarchie 41764505Sarchie ::chmod(p.c_str(), 0200); 41864505Sarchie perms(false, true, false, false, false, false, false, false, false); 41964505Sarchie 42053913Sarchie ::chmod(p.c_str(), 0004); 42153913Sarchie perms(false, false, false, false, false, false, true, false, false); 42253913Sarchie 42353913Sarchie ::chmod(p.c_str(), 0040); 42453913Sarchie perms(false, false, false, true, false, false, false, false, false); 42553913Sarchie 42653913Sarchie ::chmod(p.c_str(), 0400); 42753913Sarchie perms(true, false, false, false, false, false, false, false, false); 42853913Sarchie 42953913Sarchie ::chmod(p.c_str(), 0644); 43053913Sarchie perms(true, true, false, true, false, false, true, false, false); 43153913Sarchie 43253913Sarchie ::chmod(p.c_str(), 0755); 43353913Sarchie perms(true, true, true, true, false, true, true, false, true); 43453913Sarchie 43553913Sarchie ::chmod(p.c_str(), 0777); 43653913Sarchie perms(true, true, true, true, true, true, true, true, true); 43753913Sarchie 43853913Sarchie#undef perms 43953913Sarchie} 44053913Sarchie 44153913Sarchie// ------------------------------------------------------------------------ 44253913Sarchie// Test cases for the free functions. 44353913Sarchie// ------------------------------------------------------------------------ 44453913Sarchie 44553913SarchieATF_TEST_CASE(exists); 44653913SarchieATF_TEST_CASE_HEAD(exists) 44764505Sarchie{ 44864505Sarchie set_md_var("descr", "Tests the exists function"); 44953913Sarchie} 45053913SarchieATF_TEST_CASE_BODY(exists) 45153913Sarchie{ 45264505Sarchie using atf::fs::exists; 45364505Sarchie using atf::fs::path; 45464505Sarchie 45564505Sarchie create_files(); 45664505Sarchie 45764505Sarchie ATF_REQUIRE( exists(path("files"))); 45864505Sarchie ATF_REQUIRE(!exists(path("file"))); 45964505Sarchie ATF_REQUIRE(!exists(path("files2"))); 46064505Sarchie 46164505Sarchie ATF_REQUIRE( exists(path("files/."))); 46264505Sarchie ATF_REQUIRE( exists(path("files/.."))); 46364505Sarchie ATF_REQUIRE( exists(path("files/dir"))); 46464505Sarchie ATF_REQUIRE( exists(path("files/reg"))); 46564505Sarchie ATF_REQUIRE(!exists(path("files/foo"))); 46664505Sarchie} 46764505Sarchie 46864505SarchieATF_TEST_CASE(is_executable); 46953913SarchieATF_TEST_CASE_HEAD(is_executable) 47053913Sarchie{ 47153913Sarchie set_md_var("descr", "Tests the is_executable function"); 47253913Sarchie} 47353913SarchieATF_TEST_CASE_BODY(is_executable) 47453913Sarchie{ 47553913Sarchie using atf::fs::is_executable; 47653913Sarchie using atf::fs::path; 47753913Sarchie 47853913Sarchie create_files(); 47953913Sarchie 48053913Sarchie ATF_REQUIRE( is_executable(path("files"))); 48153913Sarchie ATF_REQUIRE( is_executable(path("files/."))); 48253913Sarchie ATF_REQUIRE( is_executable(path("files/.."))); 48353913Sarchie ATF_REQUIRE( is_executable(path("files/dir"))); 48453913Sarchie 48553913Sarchie ATF_REQUIRE(!is_executable(path("non-existent"))); 48653913Sarchie 48753913Sarchie ATF_REQUIRE(!is_executable(path("files/reg"))); 48853913Sarchie ATF_REQUIRE(::chmod("files/reg", 0755) != -1); 48953913Sarchie ATF_REQUIRE( is_executable(path("files/reg"))); 49053913Sarchie} 49153913Sarchie 49253913SarchieATF_TEST_CASE(remove); 49353913SarchieATF_TEST_CASE_HEAD(remove) 49453913Sarchie{ 49564505Sarchie set_md_var("descr", "Tests the remove function"); 49653913Sarchie} 49753913SarchieATF_TEST_CASE_BODY(remove) 49853913Sarchie{ 49953913Sarchie using atf::fs::exists; 50053913Sarchie using atf::fs::path; 50153913Sarchie using atf::fs::remove; 50253913Sarchie 50364505Sarchie create_files(); 50464505Sarchie 50564505Sarchie ATF_REQUIRE( exists(path("files/reg"))); 50664505Sarchie remove(path("files/reg")); 50764505Sarchie ATF_REQUIRE(!exists(path("files/reg"))); 50864505Sarchie 50964505Sarchie ATF_REQUIRE( exists(path("files/dir"))); 51064505Sarchie ATF_REQUIRE_THROW(atf::system_error, remove(path("files/dir"))); 51164505Sarchie ATF_REQUIRE( exists(path("files/dir"))); 51264505Sarchie} 51353913Sarchie 51453913Sarchie// ------------------------------------------------------------------------ 51553913Sarchie// Main. 51653913Sarchie// ------------------------------------------------------------------------ 51753913Sarchie 51853913SarchieATF_INIT_TEST_CASES(tcs) 51953913Sarchie{ 52053913Sarchie // Add the tests for the "path" class. 52153913Sarchie ATF_ADD_TEST_CASE(tcs, path_normalize); 52253913Sarchie ATF_ADD_TEST_CASE(tcs, path_is_absolute); 52353913Sarchie ATF_ADD_TEST_CASE(tcs, path_is_root); 52453913Sarchie ATF_ADD_TEST_CASE(tcs, path_branch_path); 52553913Sarchie ATF_ADD_TEST_CASE(tcs, path_leaf_name); 52653913Sarchie ATF_ADD_TEST_CASE(tcs, path_compare_equal); 52754094Sarchie ATF_ADD_TEST_CASE(tcs, path_compare_different); 52854094Sarchie ATF_ADD_TEST_CASE(tcs, path_concat); 52953913Sarchie ATF_ADD_TEST_CASE(tcs, path_to_absolute); 53053913Sarchie ATF_ADD_TEST_CASE(tcs, path_op_less); 53153913Sarchie 53253913Sarchie // Add the tests for the "file_info" class. 53353913Sarchie ATF_ADD_TEST_CASE(tcs, file_info_stat); 53453913Sarchie ATF_ADD_TEST_CASE(tcs, file_info_perms); 53553913Sarchie 53653913Sarchie // Add the tests for the "directory" class. 53753913Sarchie ATF_ADD_TEST_CASE(tcs, directory_read); 53853913Sarchie ATF_ADD_TEST_CASE(tcs, directory_names); 53953913Sarchie ATF_ADD_TEST_CASE(tcs, directory_file_info); 54053913Sarchie 54164505Sarchie // Add the tests for the free functions. 54264505Sarchie ATF_ADD_TEST_CASE(tcs, exists); 54353913Sarchie ATF_ADD_TEST_CASE(tcs, is_executable); 54453913Sarchie ATF_ADD_TEST_CASE(tcs, remove); 54553913Sarchie} 54664505Sarchie