t_stringtab.cpp

Go to the documentation of this file.

/*****************************************************************************\
*                                                                             *
*  Name   : test_string_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/string_table.h>
#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.

//#define TEST_SIZE_TABLE
  // uncomment for testing of the size of a string_table.

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

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

const int test_iterations = 100;

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

const int TEST_SIZE_TABLE_COUNT = 10000;
  // the number of string_table elements we create for checking how
  // big one of them is.

console_logger out;

#define LOG(to_print) { out.log(to_print); }

HOOPLE_STARTUP_CODE;

#define WHERE __WHERE__.s()

double time_in_add = 0;
double time_in_find = 0;
double time_in_pack = 0;
double time_in_unpack = 0;
u_int operations = 0;

void ADD(string_table &syms, const istring &name, const istring &to_add)
{
  time_stamp start;
  outcome added = syms.add(name, to_add);
  operations++;
  if (added == common::EXISTING)
    deadly_error(WHERE, "ADD", "already in table");
  time_stamp end;
  time_in_add += end.value() - start.value();
}

void FIND(const string_table &syms, const istring &name, const istring &to_find)
{
  for (int i = 0; i < FIND_ITERATIONS; i++) {
    time_stamp start;
    istring *found = syms.find(name);
    operations++;
    time_stamp end;
    time_in_find += end.value() - start.value();
    if (!found)
      deadly_error(WHERE, "FIND", "not in table");
    if (*found != to_find)
      deadly_error(WHERE, "FIND", "string in table was incorrect");
  }
}


#define static_class_name() "test_string_table"

void test_string_table()
{
  FUNCDEF("test_string_table");
#ifdef TEST_SIZE_TABLE
  {
    array<string_table> symso(TEST_SIZE_TABLE_COUNT);
    operations++;
    guards::alert_message(istring(istring::SPRINTF, "we should effectively "
        "have swamped out the size of other code in the program now.  the size "
        "should represent %d string_table instantiations.  take the current "
        "memory size (minus maybe 2 megs) and divide by %d and you will have "
        "a fairly accurate cost for instantiating a string table.  hit a key.",
        TEST_SIZE_TABLE_COUNT, TEST_SIZE_TABLE_COUNT));
    #ifdef _CONSOLE
    getchar();
    #elif defined(__UNIX__)
    getchar();
    #endif
  }
#endif

  string_table syms;
  string_table new_syms;
  string_table newer_syms;
  operations += 3;
  for (int qq = 0; qq < test_iterations; qq++) {
    syms.reset();  // still could be costly.
    operations++;
#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 of the string tables.
    string_table chronos = syms;
    operations++;
    {
      string_table mary = syms;
      operations++;
      string_table june = mary;
      operations++;
      if (mary != syms)
        deadly_error(WHERE, "copy test", "failed to compare properly");
      operations++;
    }
    if (syms != chronos)
      deadly_error(WHERE, "copy test", "original was harmed");
    operations++;

    {
      // test the bug we think we found in the operator =.
      string_table fred;
      fred.add("urp", "rarp");
      fred.add("hyurgh", "ralph");
      string_table med;
      med.add("urp", "rarp");
      med.add("hyurgh", "ralph");
      fred = med;  // the deadly assignment.
      fred = med;  // the deadly assignment.
      fred = med;  // the deadly assignment.
      fred = med;  // the deadly assignment.
      fred.add("urp", "rarp");
      fred.add("gurp", "flaarp");  // a new entry.
      istring *urp = fred.find("urp");
      istring *hyurgh = fred.find("hyurgh");
      if (!urp)
        deadly_error(static_class_name(), func, "missing urp");
      if (!hyurgh)
        deadly_error(static_class_name(), func, "missing hyurgh");
#ifdef DEBUG_SYMBOL_TABLE
      LOG(istring("got urp as ") + (urp? *urp : "empty!!!!"));
      LOG(istring("got hyurgh as ") + (hyurgh? *hyurgh : "empty!!!!"));
#endif
      istring urp_val = fred[0];
        // AH HA!  this one finds it.  accessing via bracket or other methods
        // that use the internal get() method will fail.
        // if there is no outright crash, then the bug is gone.
#ifdef DEBUG_SYMBOL_TABLE
      LOG(istring("got urp_val as ") + (urp_val.t()? urp_val : "empty!!!!"));
#endif
    }

#ifdef DEBUG_SYMBOL_TABLE
    LOG("now packing the symbol table...");
#endif
    byte_array packed_form;
    time_stamp start;
    syms.pack(packed_form);
    operations++;
    time_stamp end;
    time_in_pack += end.value() - start.value();
#ifdef DEBUG_SYMBOL_TABLE
    LOG("now unpacking from packed form");
#endif
    start.reset();
    if (!new_syms.unpack(packed_form))
      deadly_error(WHERE, "unpack test", "failed to unpack");
    operations++;
    end.reset();  // click, off.
    time_in_unpack += end.value() - start.value();

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

#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.
    new_syms.pack(packed_again);
    operations++;
    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();
    newer_syms.unpack(packed_again);
    operations++;
    end = time_stamp();
    time_in_unpack += end.value() - start.value();
#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");
    operations++;

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


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

  out.log(istring(istring::SPRINTF, "time in add=%f", time_in_add));
  out.log(istring(istring::SPRINTF, "time in find=%f", time_in_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));
  out.log(istring(istring::SPRINTF, "total operations=%u", operations));

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

#undef static_class_name

---