t_tree.cpp

Go to the documentation of this file.

/*****************************************************************************\
*                                                                             *
*  Name   : test_tree                                                         *
*  Author : Chris Koeritz                                                     *
*                                                                             *
*  Purpose:                                                                   *
*                                                                             *
*    Tests out the tree class.                                                *
*                                                                             *
*******************************************************************************
* Copyright (c) 1993-$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/istring.h>
#include <basis/packable.h>
#include <nodes/node.h>
#include <nodes/tree.h>
#include <opsystem/application_shell.h>
#include <loggers/console_logger.h>
#include <data_struct/static_memory_gremlin.h>

using namespace nodes;

//#define DEBUG_TEST_TREE
  // uncomment if you want the noisy streams version.

const int test_iterations = 20;

class bogotre : public packable, public tree
{
public:
  bogotre(const char *start = NIL) : who_cares(42), i_sure_dont('l'),
        another_useless_int(23) {
    istring to_init(start);
    if (to_init.length() < 1) to_init += "ack";
    to_init.stuff(the_actual_string, minimum(to_init.length()+1, 500));
  }
  IMPLEMENT_CLASS_NAME("bogotre");
  virtual ~bogotre() {}
  virtual void pack(byte_array &packed_form) const;
  virtual bool unpack(byte_array &to_unpack);
  virtual byte *held() const { return (byte *)the_actual_string; }
  virtual void print() const {
#ifdef DEBUG_TEST_TREE
    printf(the_actual_string); 
#endif
  }

private:
  char the_actual_string[500];
  int who_cares;
  char i_sure_dont;
  int another_useless_int;
};


// forward.
typedef bogotre larch;
typedef void (applier)(larch *apply_to);
typedef tree::iterator traveller;

class test_tree : public application_shell
{
public:
  test_tree() : application_shell(class_name()) {}
  IMPLEMENT_CLASS_NAME("test_tree");
  virtual int execute();
  static void print_node(larch *curr_node);
  static larch *next(larch *&move, larch *hook, traveller &skip);
  static void apply(larch *apply_to, applier *to_apply,
          tree::traversal_directions order);
};


void bogotre::pack(byte_array &packed_form) const
{
  istring(the_actual_string).pack(packed_form);
  basis::attach(packed_form, who_cares);
  basis::attach(packed_form, i_sure_dont);
  basis::attach(packed_form, another_useless_int);
}

bool bogotre::unpack(byte_array &packed_form)
{
  // 5 is the magic knowledge of minimum packed string.
//hmmm: make the minimum packed size a property of packables?
  if (packed_form.length() < int(1 + sizeof(who_cares) + sizeof(i_sure_dont)
      + sizeof(another_useless_int)))
    deadly_error(class_name(), "bogotre_unpack", "size of package is too small");
  istring unpacked;
  if (!unpacked.unpack(packed_form))
    deadly_error(class_name(), "bogotre_unpack", "couldn't retrieve string");
  if (!basis::detach(packed_form, who_cares))
    deadly_error(class_name(), "bogotre_unpack", "couldn't retrieve who_cares");
  if (!basis::detach(packed_form, i_sure_dont))
    deadly_error(class_name(), "bogotre_unpack", "couldn't retrieve i_sure_dont");
  if (!basis::detach(packed_form, another_useless_int))
    deadly_error(class_name(), "bogotre_unpack", "couldn't retrieve another_...");

  if (who_cares != 42)
    deadly_error(class_name(), "bogotre_unpack", "wrong value held in first int");
  if (i_sure_dont != 'l')
    deadly_error(class_name(), "bogotre_unpack", "wrong character held");
  if (another_useless_int != 23)
    deadly_error(class_name(), "bogotre_unpack", "wrong value held in second int");
  return true;
}


/*
bogotre *togen(char *to_store)
{ bogotre *to_return = new bogotre(istring(to_store).s()); return to_return; }
*/

void test_tree::print_node(larch *curr_node)
{
  if (!curr_node)
    deadly_error(test_tree::static_class_name(), "print_node", "nil tree");
  bogotre *real_curr = dynamic_cast<bogotre *>(curr_node);
  if (!real_curr)
    deadly_error(test_tree::static_class_name(), "print_node", "nil contents");
  istring to_examine((char *)real_curr->held());
#ifdef DEBUG_TEST_TREE
  to_examine += " ";
  printf(to_examine.s());
//remove it again if we reenable the cut.
#endif
//  if (to_examine == to_look_for) real_curr->cut();
}

larch *test_tree::next(larch *&move, larch *formal(hook), traveller &skip)
{ move = dynamic_cast<larch *>(skip.next()); return move; }

void test_tree::apply(larch *apply_to, applier *to_apply,
    tree::traversal_directions order)
{
  larch *curr = NIL;
  for (traveller skippy = apply_to->start(order);
       next(curr, apply_to, skippy); ) to_apply(curr);
}

int test_tree::execute()
{
  for (int qq = 0; qq < test_iterations; qq++) {
  larch *e1 = new larch("a");
  larch *e2 = new larch("b");
  larch *e3 = new larch("+");
  e3->attach(e1);
  e3->attach(e2);

  larch *e4 = new larch("c");
  larch *e5 = new larch("-");
  e5->attach(e3);
  e5->attach(e4);

  larch *e6 = new larch(">");
  larch *e7 = new larch("23");
  e6->attach(e5);
  e6->attach(e7);

  larch *e8 = new larch("d");
  larch *e9 = new larch("=");
  e9->attach(e8);
  e9->attach(e6);

#ifdef DEBUG_TEST_TREE
  printf("infix is ");
#endif
  apply(e9, print_node, tree::infix);
#ifdef DEBUG_TEST_TREE
  printf("\nprefix is ");
#endif
  apply(e9, print_node, tree::prefix);
#ifdef DEBUG_TEST_TREE
  printf("\npostfix is ");
#endif
  apply(e9, print_node, tree::postfix);
#ifdef DEBUG_TEST_TREE
  printf("\n");
  printf("branches is ");
#endif
  apply(e9, print_node, tree::to_branches);
#ifdef DEBUG_TEST_TREE
  printf("\n");
  printf("branches reversed is ");
#endif
  apply(e9, print_node, tree::reverse_branches);
#ifdef DEBUG_TEST_TREE
  printf("\n");
  printf("before first pack");
#endif
  byte_array packed_e9(0);
  e9->pack(packed_e9);
#ifdef DEBUG_TEST_TREE
  printf("after first pack, size is %d\n", packed_e9.length());
#endif
  larch *new_e9 = new larch();
  new_e9->unpack(packed_e9);
#ifdef DEBUG_TEST_TREE
  printf("New tree after unpacking is (infix order):\n");
#endif
  apply(new_e9, print_node, tree::infix);
#ifdef DEBUG_TEST_TREE
  printf("\n");
#endif
/*
#ifdef DEBUG_TEST_TREE
  printf("the following dumps are in the order: infix, prefix, postfix.\n\n");
  printf("now trying cut on the character '>':\n");
#endif
  to_look_for = ">";
  new_e9->apply(&print_node, tree::infix);
#ifdef DEBUG_TEST_TREE
  p("\n");
#endif
  new_e9->apply(&print_node, tree::prefix);
#ifdef DEBUG_TEST_TREE
  p("\n");
#endif
  new_e9->apply(&print_node, tree::postfix);
#ifdef DEBUG_TEST_TREE
  p("\nnow trying cut on the character +:\n");
#endif
  to_look_for = "+";
  new_e9->apply(&print_node, tree::infix);
#ifdef DEBUG_TEST_TREE
  p("\n");
#endif
  new_e9->apply(&print_node, tree::prefix);
#ifdef DEBUG_TEST_TREE
  p("\n");
#endif
  new_e9->apply(&print_node, tree::postfix);
#ifdef DEBUG_TEST_TREE
  p("\n");
#endif
  to_look_for = "";

#ifdef DEBUG_TEST_TREE
  p("okay, trying to resume at -\n");
#endif
  e5->resume(&print_node, tree::infix);
#ifdef DEBUG_TEST_TREE
  p("\n");
#endif
  e5->resume(&print_node, tree::prefix);
#ifdef DEBUG_TEST_TREE
  p("\n");
#endif
  e5->resume(&print_node, tree::postfix);
#ifdef DEBUG_TEST_TREE
  p("\n");
#endif
*/
#ifdef DEBUG_TEST_TREE
  printf("deleting\n");
#endif
  delete e9;
/*
printf("second pack\n");
  byte_array second_pack;
printf("packing\n");
  new_e9->pack(second_pack);
#ifdef DEBUG_TEST_TREE
  printf("after second pack, size is %d\n", size);
#endif
*/
  delete new_e9;
/*
  larch *newest_e9 = new larch(SELF_CLEANING);
  newest_e9->unpack(second_pack);
#ifdef DEBUG_TEST_TREE
  printf("after second unpack... tree is (infix):\n");
#endif
  newest_e9->apply(print_node, tree::infix);
  delete newest_e9;
#ifdef DEBUG_TEST_TREE
  p("\n");
#endif
*/
  }
  guards::alert_message("tree:: works for those functions tested.");
  return 0;
}

HOOPLE_MAIN(test_tree, )

---