2 * Name : test_directory_tree
3 * Author : Chris Koeritz
5 * Tests the directory_tree object on some well-known directories.
7 * Copyright (c) 2001-$now By Author. This program is free software; you can
8 * redistribute it and/or modify it under the terms of the GNU General Public
9 * License as published by the Free Software Foundation; either version 2 of
10 * the License or (at your option) any later version. This is online at:
11 * http://www.fsf.org/copyleft/gpl.html
12 * Please send any updates to: fred@gruntose.com
15 #include <application/hoople_main.h>
16 #include <basis/functions.h>
17 #include <basis/guards.h>
18 #include <filesystem/directory_tree.h>
19 #include <filesystem/filename.h>
20 #include <filesystem/filename_list.h>
21 #include <loggers/critical_events.h>
22 #include <loggers/program_wide_logger.h>
23 #include <processes/launch_process.h>
24 #include <structures/static_memory_gremlin.h>
25 #include <structures/string_array.h>
26 #include <textual/string_manipulation.h>
27 #include <unit_test/unit_base.h>
29 using namespace application;
30 using namespace basis;
31 using namespace mathematics;
32 using namespace filesystem;
33 using namespace loggers;
34 using namespace processes;
35 using namespace structures;
36 using namespace textual;
37 using namespace timely;
38 using namespace unit_test;
40 const bool JUST_SIZES = false;
41 // determines if we'll only compare file size and time.
43 #define DEBUG_TEST_DIRECTORY_TREE
44 // uncomment if you want noisy logging.
46 #define LOG(s) CLASS_EMERGENCY_LOG(program_wide_logger::get(), s)
48 class test_directory_tree : public virtual unit_base, virtual public application_shell
51 test_directory_tree() : application_shell() {}
52 DEFINE_CLASS_NAME("test_directory_tree");
56 int test_directory_tree::execute()
61 astring path = "/usr/lib";
63 // default path for windoze uses an area that should always exist.
64 path = environment::get("COMMONPROGRAMFILES");
69 hmmm: this test shows that our algorithms are poor; the tree traversal on feisty meow apex
70 should not take as long as it does.
71 get some timing around this, comparing it with other linux tools, like ls -R and find.
72 see if we have some ugly bottlenecks, or where they are, and fix them.
75 // new approach for where to look is at feisty meow itself.
76 // some type of introspection to be sure.
77 astring path = environment::get("FEISTY_MEOW_APEX");
79 // process the command line parameters, which are optionally a directory name and
80 // a pattern to use when scanning.
81 if (_global_argc >= 2)
82 path = _global_argv[1];
84 astring pattern = "*";
85 if (_global_argc >= 3)
86 pattern = _global_argv[2];
89 #ifdef DEBUG_TEST_DIRECTORY_TREE
90 log(astring("Scanning directory tree at \"") + path + "\"");
91 log(astring("Using pattern-match \"") + pattern + "\"");
94 directory_tree dir(path, pattern.s());
95 ASSERT_TRUE(dir.good(), "directory_tree construction should succeed and be readable.");
97 dir_tree_iterator *ted = dir.start(directory_tree::prefix);
98 // create our iterator to do a prefix traversal.
100 int depth; // current depth in tree.
101 filename curr; // the current path the iterator is at.
102 string_array files; // the filenames held at the iterator.
104 while (directory_tree::current(*ted, curr, files)) {
105 // we have a good directory to show.
106 directory_tree::depth(*ted, depth);
107 #ifdef DEBUG_TEST_DIRECTORY_TREE
108 log(string_manipulation::indentation(depth * 2) + astring("[") + curr.raw() + "]");
112 for (int i = 0; i < files.length(); i++) names += files[i] + " ";
113 if (names.length()) {
115 string_manipulation::split_lines(names, split, depth * 2 + 2);
116 #ifdef DEBUG_TEST_DIRECTORY_TREE
121 // go to the next place.
122 directory_tree::next(*ted);
125 directory_tree::throw_out(ted);
129 // second test group. seek operation.
130 //scan the directory, create some temporary directories and junk filenames
131 //therein, then seek to that location.
136 // third test group. tree comparison operation.
137 // log(astring("Self-comparing directory tree at \"") + path + "\"");
138 // log(astring("Using pattern-match \"") + pattern + "\"");
140 // LOG("reading tree 1.");
141 directory_tree dir(path, pattern.s());
142 ASSERT_TRUE(dir.good(), "the directory should be readable for self-compare");
144 // now read a copy of the tree also.
145 // LOG("reading tree 2.");
146 directory_tree dir2(path, pattern.s());
147 ASSERT_TRUE(dir2.good(), "the directory should read the second time fine too");
149 LOG("comparing the two trees.");
151 directory_tree::compare_trees(dir, dir2, diffs, file_info::EQUAL_CHECKSUM_TIMESTAMP_FILESIZE);
152 LOG(diffs.text_form());
154 ASSERT_FALSE(diffs.elements(), "there should be no differences comparing identical dirs");
158 // fourth test: see if the calculate function works.
159 // log(astring("Calculating sums for tree at \"") + path + "\"");
160 // log(astring("Using pattern-match \"") + pattern + "\"");
162 // LOG("reading tree 1.");
163 directory_tree dir(path, pattern.s());
164 ASSERT_TRUE(dir.good(), "the directory should be readable for checksums");
166 // now read a copy of the tree also.
167 // LOG("reading tree 2.");
168 directory_tree dir2(path, pattern.s());
169 ASSERT_TRUE(dir2.good(), "checksummer should be able to read second time also");
171 // LOG("calculating checksums for tree 1.");
172 ASSERT_TRUE(dir.calculate(JUST_SIZES), "the first checksummer tree can be calculated");
174 // LOG("calculating checksums for tree 2.");
175 ASSERT_TRUE(dir2.calculate(JUST_SIZES), "the second checksummer tree can be calculated");
177 // LOG("comparing the two trees.");
179 directory_tree::compare_trees(dir, dir2, diffs, file_info::EQUAL_CHECKSUM_TIMESTAMP_FILESIZE);
180 //LOG(diffs.text_form());
182 ASSERT_FALSE(diffs.elements(), "no checksummer differences should be seen for identical directories");
186 // fifth test: see if the packing works.
187 // log(astring("Reading tree for packing at \"") + path + "\"");
188 // log(astring("Using pattern-match \"") + pattern + "\"");
190 // LOG("reading tree.");
191 directory_tree dir(path, pattern.s());
192 ASSERT_TRUE(dir.good(), "packer directory should be read");
194 // LOG("calculating checksums for tree.");
195 ASSERT_TRUE(dir.calculate(JUST_SIZES), "the first packer tree can be calculated");
197 byte_array packed_form;
198 int size_packed = dir.packed_size();
199 dir.pack(packed_form);
200 //LOG(a_sprintf("tree became %d abyte array", packed_form.length()));
201 ASSERT_EQUAL(size_packed, packed_form.length(), "packed size should be right");
204 ASSERT_TRUE(dir2.unpack(packed_form), "second tree can be unpacked from the first");
206 // LOG("comparing the two trees.");
208 directory_tree::compare_trees(dir, dir2, diffs, file_info::EQUAL_CHECKSUM_TIMESTAMP_FILESIZE);
209 //LOG(diffs.text_form());
211 ASSERT_FALSE(diffs.elements(), "identical directories should stay same after packing");
213 directory_tree::compare_trees(dir2, dir, diffs, file_info::EQUAL_CHECKSUM_TIMESTAMP_FILESIZE);
214 ASSERT_FALSE(diffs.elements(), "no differences for reverse compare identical dirs");
218 // sixth test: see if the make_directories function works.
219 LOG("reading tree to recreate");
220 directory_tree dir(path, pattern.s());
221 ASSERT_TRUE(dir.good(), "makedirs test directory reading");
222 filename tmpdir(environment::get("FEISTY_MEOW_GENERATED_STORE") + "/zz_balfazzaral");
223 LOG(astring("will write to tmp in ") + tmpdir);
224 basis::outcome result = dir.make_directories(tmpdir.raw());
225 ASSERT_EQUAL(result.value(), common::OKAY, "makedirs should succeed");
227 LOG("what happened with that? did it work? merely rhetorical, since we need more code here.");
229 //hmmm: compare the directories with what we expect to be made;
230 // do a dirtree iterator on the path, and make sure each of those exists in the target place.
233 // clean up the output directory.
234 //this won't do it; it's a directory!
235 // bool worked = tmpdir.recursive_unlink();
236 // ASSERT_TRUE(worked, "removing temporary files after test");
238 //hmmm: plug in real recursive delete here instead.
240 launch_process::run("/bin/rm", astring("-rf ") + tmpdir.raw(), launch_process::AWAIT_APP_EXIT, kid);
241 ASSERT_FALSE(kid, "removing temporary files after test");
247 // combine the results of the second test with a comparison like in the
248 // third test. delete all of those temporary files that were added.
249 // rescan tree. make sure that a tree containing the temporaries
250 // when compared with the current post-deletion tree produces a list
251 // that contains all the temporary files and directories.
256 return final_report();
259 HOOPLE_MAIN(test_directory_tree, )