uglyNames Class Reference

Inheritance diagram for uglyNames:

Collaboration diagram for uglyNames:

Public Member Functions
	uglyNames ()
void	execute (const std::vector< std::string > &remainingOptions) override
Public Member Functions inherited from baseTest
	baseTest (const std::string &aName, const std::string &aDescription, const decltype(parameters)&aParameters, const decltype(options)&aOptions={})
void	ensuredWrite (int fd, const std::string &data)
void	ensuredRead (int fd, std::string &data)
void	Execute (const std::vector< std::string > &remainingOptions)

Additional Inherited Members
Static Public Member Functions inherited from baseTest
static std::map< std::string, baseTest * > &	getList ()
static void	setUpOptions ()
static const std::string &	getDescriptions ()
Protected Attributes inherited from baseTest
std::string	name
std::string	description
std::list< std::pair< std::string, std::string > >	parameters
std::list< std::pair< options::base &, std::string > >	options
std::set< std::string >	createdFiles
Static Protected Attributes inherited from baseTest
static options::single< unsigned int >	repeat
static options::single< bool >	cleanup
static options::single< bool >	urandom
static options::single< bool >	einsZweiDrei
static options::single< std::string >	contentFile
static options::single< size_t >	size
static options::single< unsigned int >	blocks
static options::single< std::string >	content
static options::single< bool >	truncate
static options::single< std::chrono::duration< double > >	time
static options::single< unsigned long >	syncus
static options::single< unsigned long >	skewus
static std::string	descriptions = "\npossible actions and their parameters:\n"

Detailed Description

Definition at line 737 of file fileOpsTests.cpp.

Constructor & Destructor Documentation

uglyNames()

uglyNames::uglyNames ( )

inline

Definition at line 739 of file fileOpsTests.cpp.

               : baseTest("uglyNames",
                                 "write files with ugly names", {
        {"dir", "directory to create the files in"
        }
    }) {};

Member Function Documentation

execute()

void uglyNames::execute ( const std::vector< std::string > &  remainingOptions )

inlineoverridevirtual

Implements baseTest.

Definition at line 744 of file fileOpsTests.cpp.

                                                                        {
        auto dir = remainingOptions.at(0);
        auto dirfd = throwcall::badval(open(dir.c_str(),O_PATH | O_DIRECTORY),-1,"can't open ",dir);
        std::list<std::string> names{"name with spaces",
                                     "name\nwith\nnewlines",
                                     "name\rwith\rreturns",
                                     "name\r\nwith\r\nCRLF",
                                     "name_with_\033[91mred\033[0m_part",
                                     "name_with_\xe2\x80\xadleft-to-right\xe2\x80\x8e_part",
                                     "name_with_\xe2\x82\xac_euro",
                                     "name_with_ɄɳɨȻʘΔε_unicode",
                                     "name_with_🤔💩☢_emojis",
                                     "name_with_䭫顙_more_unicode"
        };
        {
            std::list<std::pair<std::string,unsigned char>> ControlChars{
                {"SOH", 001},   {"STX", 002},   {"ETX", 003},   {"EOT", 004},
                                {"ENQ", 005},   {"ACK", 006},
                                        {"BEL", 007},
                                            {"BS", 010},
                                                {"HT", 011},
                                                    {"LF", 012},
                                                        {"VT", 013},
                                                            {"FF", 014},
                                                                {"CR", 015},
                                                                    {"SO", 016},
                                                                        {"SI", 017},
                                                                            {"DLE", 020},
                                                                                {"DC1", 021},
                                                                                    {"DC2", 022},
                                                                                        {"DC3", 023},
                                                                                            {"DC4", 024},
                                                                                                {"NAK", 025},
                                                                                                    {"SYN", 026},
                                                                                                        {"ETB", 027},
                                                                                                            {"CAN", 030},
                                                                                                                {"EM", 031},
{"SUB", 032},
{"ESC", 033},
{"FS", 034},
{"GS", 035},
{"RS", 036},
{"US", 037},
{"DEL",0177}
            };
            for (const auto& cc: ControlChars) {
                std::string ugly("name_with_");
                ugly.push_back(cc.second);
                ugly+="_char_";
                ugly+=std::to_string(cc.second);
                ugly+="_";
                ugly+=cc.first;
                names.push_back(ugly);
            }
        }
        {
            std::vector<std::pair<unsigned char, unsigned char>> ranges{{32,46},{58,63},{91,96},{123,126}};
            for (const auto& range: ranges) { 
                for (unsigned char c=range.first; c<=range.second; c++) {
                    std::string ugly("name_with_");
                    ugly.push_back(c);
                    ugly+="_char_";
                    ugly+=std::to_string(c);
                    names.push_back(ugly);
                }
            }
        }
        for (unsigned char c=128; c!=0; c++) {
            std::string ugly("name_with_");
            ugly.push_back(c);
            ugly+="_char_";
            ugly+=std::to_string(c);
            names.push_back(ugly);
        }
        {
            auto nameMax = throwcall::badval(fpathconf(dirfd,_PC_NAME_MAX),-1,"can't get max name length");
            auto ugly = std::to_string(nameMax);
            ugly.resize(nameMax,'b');
            names.push_back(ugly);
        }
 
        for (const auto& ugly: names) {
            std::string file(dir);
            file+="/";
            file+=ugly;
            auto fd = openat(dirfd,ugly.c_str(), O_WRONLY | O_CREAT | O_TRUNC, 0744);
            if (fd == -1 && errno == EINVAL) {
                std::cerr << "illegal file name \" << ugly << \" tried: ";
                for (auto c : ugly) {
                    std::cerr << std::hex << std::setw(2) << c;
                }
                std::cerr << std::dec << "\n";
                continue;
            } else {
                throwcall::badval(fd,-1, "open ", file);
            }
            ensuredWrite(fd, ugly);
            throwcall::good0(close(fd), "close ", file);
            createdFiles.emplace(file);
        }
    };

References throwcall::badval(), baseTest::createdFiles, baseTest::ensuredWrite(), and throwcall::good0().

Here is the call graph for this function:

---

The documentation for this class was generated from the following file:

• src/fileOpsTests.cpp (v0.19-24-g0617ca1 with changes)