t_symtab.cpp

Go to the documentation of this file.

/*****************************************************************************\
*                                                                             *
*  Name   : test_symbol_table                                                 *
*  Author : Chris Koeritz                                                     *
*                                                                             *
*******************************************************************************
* Copyright (c) 1994-$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/byte_array.h>
#include <basis/guards.h>
#include <basis/istring.h>
#include <data_struct/matrix.cpp>
#include <data_struct/symbol_table.cpp>
#include <mechanisms/time_stamp.h>
#include <loggers/console_logger.h>
#include <data_struct/static_memory_gremlin.h>
#include <textual/string_manipulation.h>

#include <stdio.h>
#include <stdlib.h>

//#define DEBUG_SYMBOL_TABLE
  // uncomment for noisy version.

using namespace basis;  // pull in the auto compare functions.

//const int test_iterations = 1000;
const int test_iterations = 20;

const int FIND_ITERATIONS = 100;
const int MAXIMUM_RANDOM_ADDS = 200;

console_logger out;

#ifdef DEBUG_SYMBOL_TABLE
  #define LOG(to_print) { out.log(to_print); fflush(0); }
#endif

HOOPLE_STARTUP_CODE;

#define WHERE __WHERE__.s()

//#define OLD_TEST
  // uncomment for the older version of symbol table.

double time_in_add = 0;
double time_in_dep_find = 0;
double time_in_new_find = 0;
double time_in_pack = 0;
double time_in_unpack = 0;
double time_in_copy = 0;

class my_table_def : public symbol_table<byte_array>
{
public:
  bool operator == (const my_table_def &to_compare) const {
    if (symbols() != to_compare.symbols()) return false;
    for (int i = 0; i < symbols(); i++) {
      if (name(i) != to_compare.name(i)) return false;
      if (operator [](i) != to_compare[i]) return false;
    }
    return true;
  }
};

void ADD(my_table_def &syms, const istring &name, const istring &to_add)
{
  byte_array to_stuff(to_add.length() + 1, (byte *)to_add.s());
  time_stamp start;
  outcome added = syms.add(name, to_stuff);
  if (added == common::EXISTING)
    deadly_error(WHERE, "ADD", "already in table");
  time_stamp end;
  time_in_add += end.value() - start.value();
  start.reset();
#ifdef OLD_TEST
  int indy = syms.find(name);
  if (negative(indy))
    deadly_error(WHERE, "ADD", "not in table after add");
  end.reset();
  time_in_dep_find += end.value() - start.value();
  const byte_array *found = &syms[indy];
#else
  byte_array *found = syms.find(name);
  if (!found)
    deadly_error(WHERE, "ADD", "not in table after add");
  end.reset();
  time_in_new_find += end.value() - start.value();
#endif
  if (*found != to_stuff)
    deadly_error(WHERE, "ADD", "wrong value in table after add");
}

void FIND(my_table_def &syms, const istring &name, const istring &to_add)
{
  byte_array to_stuff(to_add.length() + 1, (byte *)to_add.s());
  for (int i = 0; i < FIND_ITERATIONS; i++) {
    time_stamp start;
#ifdef OLD_TEST
    // double the calls so we roughly match the other test.
    int indy = syms.find(name);
    if (negative(indy)) deadly_error(WHERE, "FIND", "not in table");
    indy = syms.find(name);
    if (negative(indy)) deadly_error(WHERE, "FIND", "not in table");
    byte_array *found = &syms[indy];
    time_stamp end;
    time_in_dep_find += end.value() - start.value();
#else
    int indy = syms.dep_find(name);
    if (negative(indy)) deadly_error(WHERE, "FIND", "not in table (dep_find)");
    time_stamp end;
    time_in_dep_find += end.value() - start.value();
    start.reset();
    byte_array *found = syms.find(name);
    if (!found) deadly_error(WHERE, "FIND", "not in table (new_find)");
    end.reset();
    time_in_new_find += end.value() - start.value();
#endif
  }
}

void pack(byte_array &packed_form, const my_table_def &to_pack)
{
  attach(packed_form, to_pack.symbols());
  istring name;
  byte_array content;
  for (int i = 0; i < to_pack.symbols(); i++) {
    to_pack.retrieve(i, name, content);
    name.pack(packed_form);
    attach(packed_form, content);
  }
}

bool unpack(byte_array &packed_form, my_table_def &to_unpack)
{
  to_unpack.reset();
  int syms = 0;
  if (!detach(packed_form, syms)) return false;
  istring name;
  byte_array chunk;
  for (int i = 0; i < syms; i++) {
    if (!name.unpack(packed_form)) return false;
    if (!detach(packed_form, chunk)) return false;
    ADD(to_unpack, name, (char *)chunk.observe());
  }
  return true;
}


my_table_def creatapose()
{
  my_table_def to_return;
  istring name;
  istring content;
  for (int y = 0; y < MAXIMUM_RANDOM_ADDS; y++) {
    name = string_manipulation::make_random_name(40, 108);
    content = string_manipulation::make_random_name(300, 1000);
    byte_array to_stuff(content.length() + 1, (byte *)content.s());
    to_return.add(name, to_stuff);
  }
  return to_return;
}


void test_byte_table()
{
  my_table_def syms;
  my_table_def new_syms;
  my_table_def newer_syms;
  for (int qq = 0; qq < test_iterations; qq++) {
    syms.reset();  // still could be costly.
#ifdef DEBUG_SYMBOL_TABLE
    LOG(istring(istring::SPRINTF, "index %d", qq));
#endif
    istring freudname("blurgh");
    istring freud("Sigmund Freud was a very freaked dude.");
    ADD(syms, freudname, freud);
    istring borgname("borg");
    istring borg("You will be assimilated.");
    ADD(syms, borgname, borg);
    istring xname("X-Men");
    istring x("The great unknown superhero cartoon.");
    ADD(syms, xname, x);
    istring aname("fleeny-brickle");
    istring a("lallax menick publum.");
    ADD(syms, aname, a);
    istring axname("ax");
    istring ax("Lizzy Borden has a very large hatchet.");
    ADD(syms, axname, ax);
    istring bloinkname("urg.");
    istring bloink("this is a short and stupid string");
    ADD(syms, bloinkname, bloink);
    istring faxname("fax");
    istring fax("alligators in my teacup.");
    ADD(syms, faxname, fax);
    istring zname("eagle ovaries");
    istring z("malfeasors beware");
    ADD(syms, zname, z);

    FIND(syms, freudname, freud);
    FIND(syms, borgname, borg);
    FIND(syms, xname, x);
    FIND(syms, aname, a);
    FIND(syms, axname, ax);
    FIND(syms, bloinkname, bloink);
    FIND(syms, faxname, fax);
    FIND(syms, zname, z);

    istring name;
    istring content;
    for (int y = 0; y < MAXIMUM_RANDOM_ADDS; y++) {
      name = string_manipulation::make_random_name(40, 108);
      content = string_manipulation::make_random_name(300, 1000);
      ADD(syms, name, content);
      FIND(syms, name, content);
    }

    // test copying the table.
    time_stamp start;  // click, on.
    my_table_def copy1(syms);
    {
      my_table_def joe(copy1);
      my_table_def joe2 = joe;
      if (joe2 != joe)
        deadly_error(WHERE, "copy test A", "different symbol tables");
      my_table_def joe3 = creatapose();  // on stack.
      my_table_def joe4 = joe3;
      my_table_def joe5 = joe4;
      if (joe5 != joe3) 
        deadly_error(WHERE, "copy test A2", "different symbol tables");
    }
    if (! (syms == copy1) )
      deadly_error(WHERE, "copy test B", "different symbol tables");
    time_stamp end;
    time_in_copy += end.value() - start.value();

#ifdef DEBUG_SYMBOL_TABLE
    LOG("now packing the symbol table...");
#endif

#ifdef DEBUG_SYMBOL_TABLE
    LOG("now unpacking from packed form");
#endif
    byte_array packed_form;
    pack(packed_form, syms);
    if (!unpack(packed_form, new_syms))
      deadly_error(WHERE, "unpack test", "failed to unpack");

#ifdef DEBUG_SYMBOL_TABLE
#endif
    if (! (syms == new_syms) )
      deadly_error(WHERE, "unpacked test", "different symbol tables");

#ifdef DEBUG_SYMBOL_TABLE
    LOG("now deleting old symbol table...");
#endif

#ifdef DEBUG_SYMBOL_TABLE
    LOG("packing the symbol table again...");
#endif
    byte_array packed_again(0);
    start.reset();  // click, on.
    pack(packed_again, new_syms);
    end.reset();  // click, off.
    time_in_pack += end.value() - start.value();
#ifdef DEBUG_SYMBOL_TABLE
    LOG("now unpacking from packed form again...");
#endif
    start = time_stamp();
    unpack(packed_again, newer_syms);
    end = time_stamp();
    time_in_unpack += end.value() - start.value();
#ifdef DEBUG_SYMBOL_TABLE
#endif
    if (new_syms != newer_syms)
      deadly_error(WHERE, "unpacked test", "different symbol tables");

#ifdef DEBUG_SYMBOL_TABLE
    LOG("now deleting new and newer symbol table...");
#endif
  }
}


// jethro is a simple object for containment below.
class jethro
{
public:
  istring _truck;

  bool operator ==(const jethro &tc) const { return tc._truck == _truck; }
  bool operator !=(const jethro &tc) const { return !(*this == tc); }
};


// the test_content object is an object with proper copy constructor
// and assignment operator that also has deep contents.
class test_content
{
public:
  int _q;
  istring _ted;
  istring _jed;
  int_array _ned;
  matrix<jethro> _med;

  test_content() : _q(9) {}

  test_content(const istring &ted, const istring &jed) : _q(4), _ted(ted),
          _jed(jed) {}

  bool operator ==(const test_content &tc) const {
    if (tc._q != _q) return false;
    if (tc._ted != _ted) return false;
    if (tc._jed != _jed) return false;
    if (tc._ned.length() != _ned.length()) return false;
    for (int i = 0; i < _ned.length(); i++)
      if (tc._ned[i] != _ned[i]) return false;
    
    if (tc._med.rows() != _med.rows()) return false;
    if (tc._med.columns() != _med.columns()) return false;
    for (int c = 0; c < _med.columns(); c++)
      for (int r = 0; r < _med.rows(); r++)
        if (tc._med.get(r, c) != _med.get(r, c)) return false;

    return true;
  }
  bool operator !=(const test_content &tc) const { return !operator ==(tc); }

  operator int() const { return _q; }
};


class second_table_def : public symbol_table<test_content>
{
public:
  bool operator == (const second_table_def &to_compare) {
    if (symbols() != to_compare.symbols()) return false;
    for (int i = 0; i < symbols(); i++) {
      if ((*this)[i] != to_compare[i]) return false;
    }
    return true;
  }
  bool operator != (const second_table_def &to_compare)
      { return !(*this == to_compare); }
};

void ADD2(second_table_def &syms, const istring &name,
    const test_content &to_add)
{ 
  time_stamp start;
  outcome added = syms.add(name, to_add);
  if (added == common::EXISTING)
    deadly_error(WHERE, "ADD2", "already in table");
  time_stamp end;
  time_in_add += end.value() - start.value();
  start = time_stamp();  // reset start.
#ifdef OLD_TEST
  int indy = syms.find(name);
  if (negative(indy))
    deadly_error(WHERE, "ADD2", "not found after add");
  // refind to balance timing.
  indy = syms.find(name);
  if (negative(indy))
    deadly_error(WHERE, "ADD2", "not found after add");
  end = time_stamp();  // reset end.
  time_in_dep_find += end.value() - start.value();
#else
  int indy = syms.dep_find(name);
  if (negative(indy))
    deadly_error(WHERE, "ADD2", "not found after add");
  end = time_stamp();  // reset end.
  time_in_dep_find += end.value() - start.value();
  start = time_stamp();
  test_content *found = syms.find(name);
  if (!found)
    deadly_error(WHERE, "ADD2", "not found after add");
  end = time_stamp();  // reset end.
  time_in_new_find += end.value() - start.value();
#endif
  istring name_out;
  test_content content_out;
  if (syms.retrieve(indy, name_out, content_out) != common::OKAY) {
    if (name_out != name)
      deadly_error(WHERE, "ADD2", "name is incorrect after retrieve");
    if (content_out != to_add)
      deadly_error(WHERE, "ADD2", "content is incorrect after retrieve");
  }
}


void test_tc_table()
{
  second_table_def syms;
  second_table_def new_syms;
  second_table_def newer_syms;
  for (int qq = 0; qq < test_iterations; qq++) {
    syms.reset();
#ifdef DEBUG_SYMBOL_TABLE
    LOG(istring(istring::SPRINTF, "index %d", qq));
#endif
    istring freudname("blurgh");
    test_content freud("Sigmund Freud was a very freaked dude.", "flutenorf");
    ADD2(syms, freudname, freud);
    istring borgname("borg");
    test_content borg("You will be assimilated.", "alabaster");
    ADD2(syms, borgname, borg);
    istring xname("X-Men");
    test_content x("The great unknown superhero cartoon.", "somnambulist");
    ADD2(syms, xname, x);
    istring aname("fleeny-brickle");
    test_content a("lallax menick publum.", "aglos bagnort pavlod");
    ADD2(syms, aname, a);
    istring axname("ax");
    test_content ax("Lizzy Borden has a very large hatchet.", "chop");
    ADD2(syms, axname, ax);
    istring bloinkname("urg.");
    test_content bloink("this is a short and stupid string", "not that short");
    ADD2(syms, bloinkname, bloink);
    istring faxname("fax");
    test_content fax("alligators in my teacup.", "lake placid");
    ADD2(syms, faxname, fax);
    istring zname("eagle ovaries");
    test_content z("malfeasors beware", "endangered");
    ADD2(syms, zname, z);

    // test copying the table.
    time_stamp start;
    second_table_def copy1(syms);
    {
      second_table_def joe(copy1);
      second_table_def joe2 = joe;
      if (joe2 != joe)
        deadly_error(WHERE, "copy test C", "different symbol tables");
    }
    if (! (syms == copy1) )
      deadly_error(WHERE, "copy test D", "different symbol tables");
    time_stamp end;
    time_in_copy += end.value() - start.value();

/* need packing support on jethro or whatever.
#ifdef DEBUG_SYMBOL_TABLE
    LOG(istring(istring::SPRINTF,"This is the symbol table before any manipulation\n%s", syms->text_form()));
    LOG("now packing the symbol table...");
#endif

#ifdef DEBUG_SYMBOL_TABLE
    LOG("now unpacking from packed form");
#endif
    byte_array packed_form;
    syms->pack(packed_form);
    new_syms->unpack(packed_form);
#ifdef DEBUG_SYMBOL_TABLE
    LOG(istring(istring::SPRINTF, "unpacked form has:\n%s", new_syms->text_form().s()));
#endif
    if (! (*syms == *new_syms) )
      deadly_error(WHERE, "unpacked test", "different symbol tables");

#ifdef DEBUG_SYMBOL_TABLE
    LOG("now deleting old symbol table...");
#endif
    delete syms;

#ifdef DEBUG_SYMBOL_TABLE
    LOG(istring(istring::SPRINTF, "got the unpacked form, and dumping it:\n%s", new_syms->text_form().s()));
    LOG("packing the symbol table again...");
#endif
    byte_array packed_again(0);
    new_syms->pack(packed_again);
#ifdef DEBUG_SYMBOL_TABLE
    LOG("now unpacking from packed form again...");
#endif
    newer_syms->unpack(packed_again);
#ifdef DEBUG_SYMBOL_TABLE
    LOG(istring(istring::SPRINTF, "got the unpacked form, and dumping it:\n%s", newer_syms->text_form().s()));
#endif
    if (*new_syms != *newer_syms)
      deadly_error(WHERE, "unpacked test", "different symbol tables");

#ifdef DEBUG_SYMBOL_TABLE
    LOG("now deleting new and newer symbol table...");
#endif
    delete new_syms;
    delete newer_syms;
*/
  }
}


int main(int formal(argc), char *formal(argv)[])
{
  out.log(istring("starting test 1: ") + timestamp(true, true));
  test_byte_table();
  out.log(istring("done test 1: ") + timestamp(true, true));
  out.log(istring("starting test 2: ") + timestamp(true, true));
  test_tc_table();
  out.log(istring("done test 2: ") + timestamp(true, true));

  out.log(istring(istring::SPRINTF, "time in add=%f", time_in_add));
  out.log(istring(istring::SPRINTF, "time in dep_find=%f", time_in_dep_find));
  out.log(istring(istring::SPRINTF, "time in new_find=%f", time_in_new_find));
  out.log(istring(istring::SPRINTF, "time in pack=%f", time_in_pack));
  out.log(istring(istring::SPRINTF, "time in unpack=%f", time_in_unpack));

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

---