t_amorph.cpp

Go to the documentation of this file.

/*****************************************************************************\
*                                                                             *
*  Name   : test_byte_array_amorph                                            *
*  Author : Chris Koeritz                                                     *
*                                                                             *
*  Purpose:                                                                   *
*                                                                             *
*    Puts the amorph object through its paces.                                *
*                                                                             *
*******************************************************************************
* Copyright (c) 2000-$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                               *
\*****************************************************************************/

#define DEBUG_ARRAY
  // uncomment to enable array debugging.

#define DEBUG_AMORPH
  // uncomment to enable amorph debugging.

//#define DEBUG_TEST_AMORPH
  // uncomment for this program to be noisier.

#ifdef DEBUG_TEST_AMORPH
  #define LOG(to_print) EMERGENCY_LOG(program_wide_logger(), to_print)
#else
  #define LOG(to_print) {}
#endif

#include "bogon.cpp"
  // definition of bogon class and the amorph of bogons.

#include <basis/chaos.h>
#include <basis/function.h>
#include <basis/guards.h>
#include <data_struct/amorph.cpp>
#include <mechanisms/time_stamp.h>
#include <loggers/file_logger.h>
#include <data_struct/static_memory_gremlin.h>

#include <memory.h>
#include <stdlib.h>

using namespace basis;

HOOPLE_STARTUP_CODE;

#define static_class_name() "t_amorph"

const int default_test_iterations = 28;

const int MAX_LIMBS = 200;
  // the highest number of items stored in the amorphs here.

const int MIN_CHUBBY = 60;
  // the smallest chunk to allocate for storing text strings...  all strings
  // must therefore be shorter than this length.
const int MAX_RANDO = 275;
  // the maximum amount of space to add when allocating a randomly sized chunk.

#define PROGRAM_NAME "test_amorph"

int compare(amorph<byte_array> &one, amorph<byte_array> &two)
{
  FUNCDEF("compare amorph<byte_array>");
  if (one.elements() != two.elements()) return false;
  if (one.valid_fields() != two.valid_fields()) return false;
  for (int i = 0; i < one.elements(); i++) {
    if (!one.get(i) && !two.get(i)) continue;
    else if (!one.get(i) || !two.get(i)) {
      continuable_error(PROGRAM_NAME, func,
          istring(istring::SPRINTF, "one nil, one not, at %d!", i).s());
      return false;
    } else if (one.get(i)->length() != two.get(i)->length()) {
      continuable_error(PROGRAM_NAME, func,
          istring(istring::SPRINTF, "unequal sizes at %d!", i).s());
      return false;
    } else if (one.get(i)->length() > 0) {
      if (one[i]->observe() == two[i]->observe()) {
        continuable_error(PROGRAM_NAME, func,
            istring(istring::SPRINTF, "pointer in use twice at %d!", i).s());
        return false;
      }
      if (memcmp(one[i]->observe(), two[i]->observe(), one[i]->length())) {
        continuable_error(PROGRAM_NAME, func,
            istring(istring::SPRINTF, "unequal contents at %d!", i).s());
        LOG(istring(istring::SPRINTF, "a has: %s", one[i]->observe()));
        LOG(istring(istring::SPRINTF, "b has: %s", two[i]->observe()));
        return false;
      }
    }
  }
  return true;
}

struct blob_hold { int size; int offset; };
#define PACK_BLOB_SIZE(max_limbs) (max_limbs * sizeof(blob_hold))

byte_array fake_pack(amorph<byte_array> &me)
{
  // snagged from the packable_amorph pack function!
  // count the whole size needed to store the amorph.
  int amo_size = 0;
  amorph<byte_array> hold_packed_bits(me.elements());

  for (int i = 0; i < me.elements(); i++)
    if (me.get(i) && me.get(i)->length()) {
      byte_array packed_item;
      attach(packed_item, *me[i]);
      byte_array *to_stuff = new byte_array(packed_item);
      hold_packed_bits.put(i, to_stuff);
      amo_size += packed_item.length();
    }
  int len = amo_size + sizeof(int) + PACK_BLOB_SIZE(me.elements());

  // allocate a storage area for the packed form.
  byte_array to_return(len);
  int temp = me.elements();
  object_assign((int *)to_return.access(), &temp);
    // size of package is stored at the beginning of the memory.

  int current_offset = sizeof(int);
  // the indices into the packed form are located after the amorph header.
  blob_hold *blob_array = (blob_hold *)(to_return.access() + current_offset);
  current_offset += PACK_BLOB_SIZE(me.elements());

  // the entire amorph is replicated into the new buffer.
  for (int j = 0; j < me.elements(); j++) {
    // the offset of this limb in the packed area is saved in the hold.
    blob_array[j].size
      = (hold_packed_bits[j]? hold_packed_bits[j]->length() : 0);
    blob_array[j].offset = current_offset;
    if (hold_packed_bits[j] && hold_packed_bits[j]->length()) {
      // the actual data is copied....
      memory_assign(to_return.access() + current_offset,
            (byte *)hold_packed_bits[j]->observe(),
            hold_packed_bits[j]->length());
      // and the "address" is updated.
      current_offset += hold_packed_bits[j]->length();
    }
  }
  if (current_offset != len)
    deadly_error(static_class_name(), "pack", "offset is incorrect after packing");
  return to_return;
}

amorph<byte_array> *fake_amorph_unpack(byte_array &packed_amorph)
{
  // snagged from the packable_amorph unpack function!
  int max_limbs;
  object_assign(&max_limbs, (int *)packed_amorph.access());
  amorph<byte_array> *to_return = new amorph<byte_array>(max_limbs);

  blob_hold *blob_array = new blob_hold[max_limbs];
  memory_assign(blob_array, (blob_hold *)(packed_amorph.access()
     + sizeof(int)), PACK_BLOB_SIZE(max_limbs));
  for (int i = 0; i < to_return->elements(); i++)
    if (blob_array[i].size) {
      byte *source = packed_amorph.access() + blob_array[i].offset;
      byte_array packed_byte_array(blob_array[i].size, source);
      byte_array *unpacked = new byte_array;
      detach(packed_byte_array, *unpacked);
      to_return->put(i, unpacked);
    }
  delete [] blob_array;
  return to_return;
}

void test_byte_array_amorph()
{
  FUNCDEF("test_byte_array_amorph");
  LOG("start of amorph of byte array test");
  for (int qq = 0; qq < default_test_iterations; qq++) {
    LOG(istring(istring::SPRINTF, "index %d", qq));
    {
      // some simple creation and stuffing tests....
      amorph<byte_array> fred(20);
      amorph<byte_array> gen(10);
      for (int i=0; i < 10; i++)  {
        byte_array *gens = new byte_array(8, (byte *)"goodbye");
        gen.put(i, gens);
      }
      for (int j = 0; j < 20; j++)  {
        byte_array *freds = new byte_array(6, (byte *)"hello");
         fred.put(j, freds);
      }
      amorph_assign(gen, fred);
      LOG("done with fred & gen");
    }

    LOG("before fred creation");
    chaos randomizer;
    amorph<byte_array> fred(MAX_LIMBS - 1);
    fred.append(NIL);  // add one to make it max limbs big.
    LOG("after append nil");
    {
      for (int i = 0; i < fred.elements(); i++) {
        int size = MIN_CHUBBY + randomizer.inclusive(0, MAX_RANDO);
        istring text("bogus burfonium nuggets");
        istring burph(istring::SPRINTF, " ung %d ", i);
        text += burph;
        byte *temp = new byte[size];
        text.stuff((char *)temp, text.length()+1);
        byte_array *to_stuff = new byte_array(size, temp);
        fred.put(i, to_stuff);
        delete [] temp;
      }
    }
    LOG("after first loop");
    {
      amorph<byte_array> bungee3;
      amorph_assign(bungee3, fred);
      amorph<byte_array> burglar2;
      amorph_assign(burglar2, bungee3);
      amorph<byte_array> trunklid;
      amorph_assign(trunklid, burglar2);
      if (!trunklid.elements())
        deadly_error(static_class_name(), "const constructor test", "no elements!");
    }
    LOG("after copies performed");
    {
      istring text;
      text = "hello this is part one.";
      LOG(istring(istring::SPRINTF, "len is %d, content is %s",
          text.length(), text.observe()));
      char *tadr = text.access();
      byte *badr = (byte *)tadr;
      byte_array *to_stuff = new byte_array(text.length() + 1, badr);
      fred.put(183, to_stuff);
      text = "wonky tuniea bellowbop";
      byte_array *to_stuff1 = new byte_array(text.length()+1, (byte *)text.s());
      fred.put(90, to_stuff1);

      text = "frunkwioioio";
      byte_array *to_stuff2 = new byte_array(text.length()+1, (byte *)text.s());
      fred.put(12, to_stuff2);

      fred.clear(98); fred.clear(122); fred.clear(123);
      fred.clear(256);
      fred.clear(129);
      fred.zap(82, 90);
      fred.zap(93, 107);
    }
    LOG("after second loop");
    {
      byte_array packed = fake_pack(fred);
      LOG(istring(istring::SPRINTF, "done packing in %s, pack has %d "
          "elems.", static_class_name(), packed.length()));
      amorph<byte_array> *new_fred = fake_amorph_unpack(packed);
      LOG("done unpacking in test_amorph");
      if (!compare(fred, *new_fred))
        deadly_error(static_class_name(), "first pack test", "amorphs not the same");
      byte *cont1
        = (new_fred->get(14)? (*new_fred)[14]->access() : (byte *)"NIL");
      byte *cont2
        = (new_fred->get(20)? (*new_fred)[20]->access() : (byte *)"NIL");
      byte *cont3
        = (new_fred->get(36)? (*new_fred)[36]->access() : (byte *)"NIL");

      if (cont1) LOG(istring(istring::SPRINTF, "14: %s", cont1));
      if (cont2) LOG(istring(istring::SPRINTF, "20: %s", cont2));
      if (cont3) LOG(istring(istring::SPRINTF, "36: %s", cont3));
      LOG("fields all compare identically after pack and unpack");
      byte_array packed_second = fake_pack(*new_fred);
      delete new_fred;
      amorph<byte_array> *newer_fred = fake_amorph_unpack(packed_second);
      if (!compare(*newer_fred, fred))
        deadly_error(static_class_name(), "second pack test", "amorphs not the same");
      delete newer_fred;
    }

    {
      amorph<byte_array> fred(randomizer.inclusive(20, 30));
      int size = MIN_CHUBBY + randomizer.inclusive(0, MAX_RANDO);
      istring text("bogus burfonium nuggets");
      istring burph(istring::SPRINTF, " ung %d ", 2314);
      text += burph;
      byte_array intermed(size);

      for (int i = 0; i < fred.elements(); i += 5) {
        byte_array *to_stuff = new byte_array(size, intermed.access());
        memory_assign(intermed.access(), (byte *)text.s(), text.length() + 1);
        fred.put(i, to_stuff);
      }
      fred.clear_all();
      for (int j = 0; j < fred.elements(); j += 5) {
        byte_array *to_stuff = new byte_array(size, intermed.access());
        memory_assign(intermed.access(), (byte *)text.s(), text.length() + 1);
        fred.put(j, to_stuff);
      }
      text = "frunkwioioio";
      byte_array *to_stuff = new byte_array(text.length()+1, (byte *)text.s());
      fred.put(12, to_stuff);
      fred.clear_all();
    }
    LOG("survived the clear_alls");
    {
      amorph<byte_array> *ted = new amorph<byte_array>(0);
      amorph_assign(*ted, fred);
      if (!compare(*ted, fred))
        deadly_error(static_class_name(), func, "ted and fred aren't the same");
      {
        amorph<byte_array> *george = new amorph<byte_array>(0);
        amorph_assign(*george, fred);
        if (!compare(*george, fred))
          deadly_error(static_class_name(), func, "fred and george aren't the same");
        ted->zap(3, 20);
        george->zap(3, 10);
        george->zap(3, 12);
        if (!compare(*ted, *george))
          deadly_error(static_class_name(), "after zap", "ted and george aren't the same");
        ted->adjust(ted->elements() - 20);
        george->adjust(george->elements() - 5);
        george->adjust(george->elements() - 5);
        george->adjust(george->elements() - 5);
        george->adjust(george->elements() - 5);
        if (!compare(*ted, *george))
          deadly_error(static_class_name(), "after zap", "ted and george aren't the same");
        delete george;
      }
      delete ted;
    }
  }
}

int compare(const amorph<bogon> &one, const amorph<bogon> &two)
{
  FUNCDEF("compare amorph<bogon>");
  if (one.elements() != two.elements()) return false;
  for (int i = 0; i < one.elements(); i++) {
    if (!one.get(i) && !two.get(i)) continue;
    else if (!one.get(i) || !two.get(i)) {
      continuable_error(PROGRAM_NAME, func, istring(istring::SPRINTF, "one nil, one not, at %d!", i).s());
      return false;
    } else if (one.get(i)->size() != two.get(i)->size()) {
      continuable_error(PROGRAM_NAME, func, istring(istring::SPRINTF, "unequal sizes at %d!", i).s());
      return false;
    } else if (one.get(i)->size() > 0) {
      if (one.get(i)->held() == two.get(i)->held()) {
        continuable_error(PROGRAM_NAME, func, istring(istring::SPRINTF, "pointer in use twice at %d!", i).s());
        return false;
      }
      if (memcmp(one.get(i)->held(), two.get(i)->held(), one.get(i)->size())) {
        continuable_error(PROGRAM_NAME, func, istring(istring::SPRINTF, "unequal contents at %d!", i).s());
        return false;
      }
    }
  }
  return true;
}

void test_bogon_amorph()
{
  FUNCDEF("test_bogon_amorph");
  LOG("start of amorph of bogon test");
  for (int qq = 0; qq < default_test_iterations; qq++) {
    LOG(istring(istring::SPRINTF, "index %d", qq));
    {
      // some simple creation and stuffing tests....
      amorph<bogon> fred(20);
      amorph<bogon> gen(10);
      for (int i = 0; i < 10; i++)  {
        bogon *gens = new bogon((byte *)"goodbye");
        gen.put(i, gens);
      }
      for (int j = 0; j < 20; j++)  {
        bogon *freds = new bogon((byte *)"hello");
        fred.put(j, freds);
      }
      if (compare(fred, gen))
        deadly_error(static_class_name(), func, "fred and gen ARE the same");
      amorph_assign(gen, fred);
      if (!compare(gen, fred))
        deadly_error(static_class_name(), func, "gen and fred aren't the same");
    }

    chaos randomizer;

    amorph<bogon> fred(MAX_LIMBS);

    LOG("after append nil");
    {
      for (int i = 0; i < fred.elements(); i++) {
        int size = MIN_CHUBBY + randomizer.inclusive(0, MAX_RANDO);
        istring text("bogus burfonium nuggets");
        istring burph(istring::SPRINTF, " ung %d ", i);
        text += burph;
        byte *temp = new byte[size];
        text.stuff((char *)temp, text.length()+1);
        bogon *to_stuff = new bogon(temp);
        fred.put(i, to_stuff);
        delete [] temp;
      }
    }

    LOG("after first loop");
    {
      amorph<bogon> bungee3;
      amorph_assign(bungee3, fred);
      amorph<bogon> burglar2;
      amorph_assign(burglar2, bungee3);
      amorph_assign(burglar2, bungee3);
      amorph<bogon> trunklid;
      amorph_assign(trunklid, burglar2);
      if (!trunklid.elements())
        deadly_error(static_class_name(), "const constructor test", "no elements!");
    }
    {
      istring text;
      text = "hello this is part one.";
      bogon *to_stuff = new bogon((byte *)text.s());
      fred.put(32, to_stuff);

      text = "wonky tuniea bellowbop";
      bogon *to_stuff1 = new bogon((byte *)text.s());
      fred.put(84, to_stuff1);

      text = "frunkwioioio";
      bogon *to_stuff2 = new bogon((byte *)text.s());
      fred.put(27, to_stuff2);

      fred.clear(98); fred.clear(122); fred.clear(123);
      fred.clear(256);
      fred.clear(129);
      fred.zap(82, 90);
      fred.zap(93, 107);
    }
    LOG("after second loop");
    {
      amorph<bogon> fred(randomizer.inclusive(20, 30));
      istring text("bogus burfonium nuggets");
      istring burph(istring::SPRINTF, " ung %d ", 2314);
      text += burph;

      for (int i = 0; i < fred.elements(); i += 5) {
        bogon *to_stuff = new bogon((byte *)text.s());
        fred.put(i, to_stuff);
      }
      fred.clear_all();
      for (int j = 0; j < fred.elements(); j += 5) {
        bogon *to_stuff = new bogon((byte *)text.s());
        fred.put(j, to_stuff);
      }
      text = "frunkwioioio";
      bogon *to_stuff = new bogon((byte *)text.s());
      fred.put(6, to_stuff);
      fred.clear_all();
    }
    LOG("survived the clear_alls");
    {
      amorph<bogon> *ted = new amorph<bogon>();
      amorph_assign(*ted, fred);
      if (!compare(*ted, fred))
        deadly_error(static_class_name(), func, "ted and fred aren't the same");
      {
        amorph<bogon> *george = new amorph<bogon>();
        amorph_assign(*george, fred);
        if (!compare(*george, fred))
          deadly_error(static_class_name(), func, "fred and george aren't the same");
        ted->zap(3, 20);
        george->zap(3, 10);
        george->zap(3, 12);
        if (!compare(*ted, *george))
          deadly_error(static_class_name(), "after zap", "ted and george aren't the same");
        ted->adjust(ted->elements()-20);
        george->adjust(george->elements()-5);
        george->adjust(george->elements()-5);
        george->adjust(george->elements()-5);
        george->adjust(george->elements()-5);
        if (!compare(*ted, *george))
          deadly_error(static_class_name(), "after zap", "ted and george aren't the same");
        delete george;
      }
      delete ted;
    }
  }
}

const int MAX_TEST_DURATION = 1 * MINUTE_ms;
  // each of the tests calling on the templated tester will take this long.

const int MAX_SIMULTANEOUS_OBJECTS = 42;  // the maximum length tested.

//hmmm: this test_amorph_of is not completed.

template <class contents>
void test_amorph_of(const contents &bogus)
{
  chaos rando;

  // these are the actions we try on the amorph during the test.
  // the first and last elements must be identical to the first and last
  // tests to perform.
  enum actions { first, do_zap = first, do_adjust, do_assign,


      do_borrow, last = do_borrow};

  time_stamp exit_time(::MAX_TEST_DURATION);
  while (time_stamp() < exit_time) {
    int index = rando.inclusive(0, ::MAX_SIMULTANEOUS_OBJECTS - 1);
    int choice = rando.inclusive(first, last);
    switch (choice) {
      case do_zap: {

        break;
      }
      case do_adjust: {

        break;
      }
      case do_assign: {

        break;
      }
      case do_borrow: {

        break;
      }
    }
  }
}

int main(int formal(argc), char *formal(argv)[])
{
  SET_DEFAULT_COMBO_LOGGER;
  test_byte_array_amorph();
  test_bogon_amorph();
  guards::alert_message("amorph:: works for those functions tested.");
  return 0;
}

#undef static_class_name

---