findfile_sequence_unittest_.h

用STL的方式封装了WindowsAPI、COM调用、ACE、ATL、MFC、WTL等多种组件

        ss_bool_t ffs_test_absolute_pattern_case(basic_file_path_buffer<char> const &wd, unittest_reporter *r)
        {
            ss_bool_t               bSuccess    =   true;

            typedef filesystem_traits<char> traits_t;

        // ./ffs-test/dir0.ffs/file00.ffs
        // ./ffs-test/dir0.ffs/file01.ffs

//fprintf(stderr, "wd: %s\n", wd.c_str());

            basic_file_path_buffer<char>    pattern(wd);

            traits_t::ensure_dir_end(&pattern[0]);
            traits_t::str_cat(&pattern[0], "./dir0.ffs/./../dir0.ffs/file0?.ffs");

//fprintf(stderr, "pattern: %s\n", pattern.c_str());

            findfile_sequence_a                 ffs(pattern.c_str(), findfile_sequence_a::files);
            findfile_sequence_a::const_iterator b   =   ffs.begin();
            findfile_sequence_a::const_iterator e   =   ffs.end();

#if 0
{
findfile_sequence_a::const_iterator b   =   ffs.begin();
findfile_sequence_a::const_iterator e   =   ffs.end();

fprintf(stderr, "Enumerating contents of %s (%s)\n", current_directory_a().c_str(), ffs.get_directory());

::Sleep(2 * 1000);

for(; b != e; ++b)
{
    fprintf(stderr, " [%s]\n", (*b).get_path());
}

}
#endif /* 0 */
            if(b == e)
            {
                r->report("findfile_sequence <absolute-pattern> case: search returned empty sequence", __LINE__);
                bSuccess = false;
            }
            else
            {
                // Filename should be "."

                if(0 != ::lstrcmpA("file00.ffs", (*b).get_filename()))
                {
//fprintf(stderr, "get_filename(): \"%s\"\n", (*b).get_filename());
                    r->report("findfile_sequence <absolute-pattern> case: (*).get_filename() does not equal \"file0?.ffs\"", __LINE__);
                    bSuccess = false;
                }

                if(++b == e)
                {
                    r->report("findfile_sequence <absolute-pattern> case: search returned one file, not two", __LINE__);
                    bSuccess = false;
                }
                else
                {
                    if(0 != ::lstrcmpA("file01.ffs", (*b).get_filename()))
                    {
    //fprintf(stderr, "get_filename(): \"%s\"\n", (*b).get_filename());
                        r->report("findfile_sequence <absolute-pattern> case: (*).get_filename() does not equal \"file0?.ffs\"", __LINE__);
                        bSuccess = false;
                    }
                }
            }

            return bSuccess;
        }

        ss_bool_t test_winstl_filesystem_findfile_sequence(unittest_reporter *r)
        {
            using stlsoft::unittest::unittest_initialiser;

            typedef filesystem_traits<char> traits_t;

            ss_bool_t               bSuccess    =   true;

            unittest_initialiser    init(r, "WinSTL", "filesystem/findfile_sequence", __FILE__);

            basic_file_path_buffer<char>    tempDir;

            try
            {
                // 1. Test the ".", "." functionality
                if(!ffs_test_dot_special_case(r))
                {
                    bSuccess = false;
                }

                // 2. Create the test files/directories
                if(!GetTempPath(tempDir.size(), &tempDir[0]))
                {
                    r->report("findfile_sequence: could not acquire a temporary path", __LINE__);

                    return bSuccess;
                }
                else
                {
                    traits_t::ensure_dir_end(&tempDir[0]);
                    ::lstrcatA(&tempDir[0], FFS_TEST);

//fprintf(stderr, "TempPath: %s\n", tempDir.c_str());

                    if(ffs_create_test_fs_entries(tempDir))
                    {
                        if(!ffs_test_absolute_pattern_case(tempDir, r))
                        {
                            bSuccess = false;
                        }

                        { // 3. Test the explicit directory search
                            findfile_sequence_a                 ffs(tempDir.c_str(), "*.ffs", findfile_sequence_a::directories);
                            findfile_sequence_a::const_iterator b   =   ffs.begin();
                            findfile_sequence_a::const_iterator e   =   ffs.end();
                            size_t                              i;

                            {
                                basic_file_path_buffer<char>    dir0(tempDir);
                                basic_file_path_buffer<char>    dir1;

                                traits_t::str_copy(&dir1[0], ffs.get_directory());

                                traits_t::ensure_dir_end(&dir0[0]);
                                traits_t::ensure_dir_end(&dir1[0]);

                                if(0 != ::lstrcmpiA(dir0.c_str(), dir1.c_str()))
                                {
//fprintf(stderr, "[%s][%s]\n", tempDir.c_str(), ffs.get_directory());
                                    r->report("findfile_sequence (explicit directory): get_directory() returns invalid value", __LINE__);
                                    bSuccess = false;
                                }
                            }

                            for(i = 0; bSuccess && i < STLSOFT_NUM_ELEMENTS(FFS_DIRS); ++i)
                            {
                                if(b == e)
                                {
                                    r->report("findfile_sequence (explicit directory): directory search empty", __LINE__);
                                    bSuccess = false;
                                }
                                else
                                {
//fprintf(stderr, "%s\n", (*b).get_filename());

                                    if(0 != ::lstrcmpA(FFS_DIRS[i], (*b).get_filename()))
                                    {
//fprintf(stderr, "%d: %s;%s\n", i, FFS_DIRS[i], (*b).get_filename());
                                        r->report("findfile_sequence (explicit directory): not expected entry filename", __LINE__);
                                        bSuccess = false;
                                    }

                                    basic_file_path_buffer<char>    dir2(tempDir);

                                    traits_t::ensure_dir_end(&dir2[0]);
                                    traits_t::str_cat(&dir2[0], (*b).get_filename());

                                    if(0 != ::lstrcmpA(dir2.c_str(), (*b).get_path()))
                                    {
//fprintf(stderr, "%d: %s;%s\n", i, dir2.c_str(), (*b).get_path());
                                        r->report("findfile_sequence (explicit directory): not expected entry path", __LINE__);
                                        bSuccess = false;
                                    }

                                    if(!ffs_is_entry_path_equal_ffs_directory_plus_entry_name(ffs, *b))
                                    {
                                        r->report("findfile_sequence (explicit directory): entry::path != ffs directory+entry::filename", __LINE__);
                                        bSuccess = false;
                                    }
                                }

                                if(bSuccess)
                                {
                                    ++b;
                                }
                            }
                        }

                        { // 4. Test the implicit directory search
                            basic_file_path_buffer<char>    cwd;
                            size_t                          cwdLen  =   ::GetCurrentDirectoryA(cwd.size(), &cwd[0]);

                            if(0 != cwdLen)
                            {
                                ::SetCurrentDirectoryA(tempDir.c_str());

                                findfile_sequence_a                 ffs("*.ffs", findfile_sequence_a::directories);
                                findfile_sequence_a::const_iterator b   =   ffs.begin();
                                findfile_sequence_a::const_iterator e   =   ffs.end();
                                size_t                              i;

                                {
                                    basic_file_path_buffer<char>    dir0(tempDir);
                                    basic_file_path_buffer<char>    dir1;

                                    traits_t::str_copy(&dir1[0], ffs.get_directory());

                                    traits_t::ensure_dir_end(&dir0[0]);
                                    traits_t::ensure_dir_end(&dir1[0]);

                                    if(0 != ::lstrcmpiA(dir0.c_str(), dir1.c_str()))
                                    {
//fprintf(stderr, "[%s][%s]\n", tempDir.c_str(), ffs.get_directory());
                                        r->report("findfile_sequence (implicit directory): get_directory() returns invalid value", __LINE__);
                                        bSuccess = false;
                                    }
                                }

                                for(i = 0; bSuccess && i < STLSOFT_NUM_ELEMENTS(FFS_DIRS); ++i)
                                {
                                    if(b == e)
                                    {
                                        r->report("findfile_sequence (implicit  directory): directory search empty", __LINE__);
                                        bSuccess = false;
                                    }
                                    else
                                    {
//fprintf(stderr, "%s\n", (*b).get_filename());

                                        if(0 != ::lstrcmpA(FFS_DIRS[i], (*b).get_filename()))
                                        {
//fprintf(stderr, "%d: %s;%s\n", i, FFS_DIRS[i], (*b).get_filename());
                                            r->report("findfile_sequence (implicit  directory): not expected entry filename", __LINE__);
                                            bSuccess = false;
                                        }

                                        basic_file_path_buffer<char>    dir2(tempDir);

                                        traits_t::ensure_dir_end(&dir2[0]);
                                        traits_t::str_cat(&dir2[0], (*b).get_filename());

                                        if(0 != ::lstrcmpA(dir2.c_str(), (*b).get_path()))
                                        {
//fprintf(stderr, "%d: %s;%s\n", i, dir2.c_str(), (*b).get_path());
                                            r->report("findfile_sequence (implicit  directory): not expected entry path", __LINE__);
                                            bSuccess = false;
                                        }

                                        if(!ffs_is_entry_path_equal_ffs_directory_plus_entry_name(ffs, *b))
                                        {
                                            r->report("findfile_sequence (implicit directory): entry::path != ffs directory+entry::filename", __LINE__);
                                            bSuccess = false;
                                        }
                                    }

                                    if(bSuccess)
                                    {
                                        ++b;
                                    }
                                }

                                ::SetCurrentDirectoryA(cwd.c_str());
                            }
                        }

                        { // 5. Test the implicit directory search of files, with pattern containing subdir
                            basic_file_path_buffer<char>    cwd;
                            size_t                          cwdLen  =   ::GetCurrentDirectoryA(cwd.size(), &cwd[0]);

                            if(0 != cwdLen)