t_directory_tree.cpp

Go to the documentation of this file.

/*****************************************************************************\
*                                                                             *
*  Name   : test_directory_tree                                               *
*  Author : Chris Koeritz                                                     *
*                                                                             *
*  Purpose:                                                                   *
*                                                                             *
*    Tests the directory_tree object on some well-known directories.          *
*                                                                             *
*******************************************************************************
* Copyright (c) 2001-$now By Author.  This program is free software; you can  *
* redistribute it and/or modify it under the terms of the GNU General Public  *
* License as published by the Free Software Foundation; either version 2 of   *
* the License or (at your option) any later version.  This is online at:      *
*     http://www.fsf.org/copyleft/gpl.html                                    *
* Please send any updates to: fred@gruntose.com                               *
\*****************************************************************************/

#include <basis/function.h>
#include <basis/guards.h>
#include <basis/string_array.h>
#include <opsystem/application_shell.h>
#include <loggers/console_logger.h>
#include <opsystem/directory_tree.h>
#include <opsystem/filename.h>
#include <opsystem/filename_list.h>
#include <data_struct/static_memory_gremlin.h>
#include <textual/string_manipulation.h>

#define LOG(s) CLASS_EMERGENCY_LOG(program_wide_logger(), s)

class test_directory_tree : public application_shell
{
public:
  test_directory_tree() : application_shell(static_class_name()) {}
  IMPLEMENT_CLASS_NAME("test_directory_tree");
  int execute();
};

int test_directory_tree::execute()
{
  FUNCDEF("execute");

//temp junk!
uint16 a = 23; // 10111
uint16 b = 7;  // 00111
if ((a ^ b) != 16) deadly_error("check", "check", "not working as expect");
a = 0;
b = 19;  // 10011
if ((a ^ b) != 19) deadly_error("check", "check2", "not working as expect");


  // process the command line parameters, which are a directory name and
  // a pattern to use when scanning.
  istring path = "/usr/local";  // default path.
#ifdef __WIN32__
  // default path for windoze.
  path = portable::env_string("COMMONPROGRAMFILES");
#endif
  if (__argc >= 2)
    path = __argv[1];

  istring pattern = "*";
  if (__argc >= 3)
    pattern = __argv[2];

  {
    log(istring("Scanning directory tree at \"") + path + "\"");
    log(istring("Using pattern-match \"") + pattern + "\"");

    directory_tree dir(path, pattern.s());
    if (!dir.good())
      deadly_error(class_name(), "directory_tree construction",
          "the directory could not be read");

    dir_tree_iterator *ted = dir.start(directory_tree::prefix);
      // create our iterator to do a prefix traversal.

    int depth;  // current depth in tree.
    filename curr;  // the current path the iterator is at.
    string_array files;  // the filenames held at the iterator.

    while (directory_tree::current(*ted, curr, files)) {
      // we have a good directory to show.
      directory_tree::depth(*ted, depth);
      log(string_manipulation::indentation(depth * 2) + istring("[")
          + curr.raw() + "]");
      istring names;
      for (int i = 0; i < files.length(); i++) names += files[i] + " ";
      if (names.length()) {
        istring split;
        string_manipulation::split_lines(names, split, depth * 2 + 2);
        log(split);
      }

      // go to the next place.
      directory_tree::next(*ted);
    }

    directory_tree::throw_out(ted);

  }

  {
    // second test group.  seek operation.
//scan the directory, create some temporary directories and junk filenames
//therein, then seek to that location.

  }

  {
    // third test group.  tree comparison operation.
    log(istring("Self-comparing directory tree at \"") + path + "\"");
    log(istring("Using pattern-match \"") + pattern + "\"");

    LOG("reading tree 1.");
    directory_tree dir(path, pattern.s());
    if (!dir.good())
      deadly_error(class_name(), "directory_tree construction",
          "the directory could not be read");

    // now read a copy of the tree also.
    LOG("reading tree 2.");
    directory_tree dir2(path, pattern.s());
    if (!dir2.good())
      deadly_error(class_name(), "directory_tree construction",
          "the directory could not be read the second time?!");

    LOG("comparing the two trees.");
    filename_list diffs;
    directory_tree::compare_trees(dir, dir2, diffs);
LOG(diffs.text_form());

    if (diffs.elements())
      deadly_error(class_name(), "directory_tree comparison",
          "there were differences when comparing identical directories!");
  }

  {
    // fourth test: see if the calculate function works.
    log(istring("Calculating sums for tree at \"") + path + "\"");
    log(istring("Using pattern-match \"") + pattern + "\"");

    LOG("reading tree 1.");
    directory_tree dir(path, pattern.s());
    if (!dir.good())
      deadly_error(class_name(), "directory_tree construction",
          "the directory could not be read");

    // now read a copy of the tree also.
    LOG("reading tree 2.");
    directory_tree dir2(path, pattern.s());
    if (!dir2.good())
      deadly_error(class_name(), "directory_tree construction",
          "the directory could not be read the second time?!");

    LOG("calculating checksums for tree 1.");
    if (!dir.calculate())
      deadly_error(class_name(), "directory_tree calculation",
          "the first tree could not be calculated");

    LOG("calculating checksums for tree 2.");
    if (!dir2.calculate())
      deadly_error(class_name(), "directory_tree calculation",
          "the second tree could not be calculated");

    LOG("comparing the two trees.");
    filename_list diffs;
    directory_tree::compare_trees(dir, dir2, diffs);
LOG(diffs.text_form());

    if (diffs.elements())
      deadly_error(class_name(), "directory_tree comparison",
          "there were differences when comparing identical directories!");
  }

  {
    // fifth test: see if the packing works.
    log(istring("Reading tree for packing at \"") + path + "\"");
    log(istring("Using pattern-match \"") + pattern + "\"");

    LOG("reading tree.");
    directory_tree dir(path, pattern.s());
    if (!dir.good())
      deadly_error(class_name(), "directory_tree construction",
          "the directory could not be read");

    LOG("calculating checksums for tree.");
    if (!dir.calculate())
      deadly_error(class_name(), "directory_tree calculation",
          "the first tree could not be calculated");

    byte_array packed_form;
    dir.pack(packed_form);
LOG(isprintf("tree became %d byte array", packed_form.length()));

    directory_tree dir2;
    if (!dir2.unpack(packed_form)) 
      deadly_error(class_name(), "directory_tree calculation",
          "the second tree could not be unpacked from the first");

    LOG("comparing the two trees.");
    filename_list diffs;
    directory_tree::compare_trees(dir, dir2, diffs);
LOG(diffs.text_form());

    if (diffs.elements())
      deadly_error(class_name(), "directory_tree comparison",
          "there were differences when comparing identical directories!");

    directory_tree::compare_trees(dir2, dir, diffs);
    if (diffs.elements())
      deadly_error(class_name(), "directory_tree comparison",
          "there were differences when reverse comparing identical dirs!");

  }

// nth test:
// combine the results of the second test with a comparison like in the
// third test.  delete all of those temporary files that were added.
// rescan tree. make sure that a tree containing the temporaries
// when compared with the current post-deletion tree produces a list
// that contains all the temporary files and directories.


//more tests!

  guards::alert_message("directory_tree:: works for those functions tested.");
  return 0;
}

HOOPLE_MAIN(test_directory_tree, )

---