t_deep_array.cpp

Go to the documentation of this file.

/*****************************************************************************\
*                                                                             *
*  Name   : test_deep_array                                                   *
*  Author : Chris Koeritz                                                     *
*                                                                             *
*******************************************************************************
* Copyright (c) 2006-$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/chaos.h>
#include <basis/function.h>
#include <basis/guards.h>
#include <basis/istring.h>
#include <data_struct/deep_array.cpp>
#include <data_struct/matrix.cpp>
#include <mathematics/float_plus.h>
#include <mechanisms/time_stamp.h>
#include <opsystem/application_shell.h>
#include <loggers/console_logger.h>
#include <data_struct/static_memory_gremlin.h>

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 deep_arrays tested.

const int MIN_OBJECT = -30; // the smallest deep_array we'll create.
const int MAX_OBJECT = 98; // the largest deep_array we'll create.

const int MIN_BLOCK = 100;  // the smallest exemplar we'll use.
const int MAX_BLOCK = MAX_OBJECT * 2;  // the largest exempler.

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

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

typedef void *void_pointer;


class test_deep_array : public application_shell
{
public:
  test_deep_array() : application_shell(class_name()) {}
  IMPLEMENT_CLASS_NAME("test_deep_array");
  virtual int execute();
  void dump_deep_array(deep_array<void_pointer> &ar, const char *name);
  void test_deep_arrays_of_void_pointer();
  void test_packing_deep_arrays();
};


void test_deep_array::dump_deep_array(deep_array<void_pointer> &ar, const char *name)
{
#ifdef DEBUG_TEST_ARRAY
  LOG(isprintf("deep_array named \"%s\" has:", name)); 
  for (int i = 0; i < ar.length(); i++) {
    LOG(isprintf("\t%4d: %d", i, (int)ar[i]));
  }
#else
  if (ar.length() || name) {}
#endif
}

void test_deep_array::test_deep_arrays_of_void_pointer()
{
  FUNCDEF("void pointer test");
  if (sizeof(void_pointer) != 4)
    deadly_error(class_name(), func, "the void pointer has an unexpected size!");
  const int MAX_VOID_ARRAY = 20;
  deep_array<void_pointer> argh(MAX_VOID_ARRAY);
  deep_array<void_pointer> argh2(argh);
  if (argh.length() != MAX_VOID_ARRAY)
    deadly_error(class_name(), func, "the first deep_array length is incorrect!");
  if (argh2.length() != MAX_VOID_ARRAY)
    deadly_error(class_name(), func, "the copied deep_array length is incorrect!");
/* not appropriate for this type of content:
  for (int o = 0; o < MAX_VOID_ARRAY; o++)
    if (argh[o] != argh2[o])
      deadly_error(class_name(), func, "the deep_arrays have different contents!");
*/
    
  // fill it with values.
  int starter;
  for (int i = 0; i < MAX_VOID_ARRAY; i++)
    argh[i] = (void_pointer)(&starter + i);
  dump_deep_array(argh, "first version");

  // check the values.
  for (int j = 0; j < MAX_VOID_ARRAY; j++)
    if (argh[j] != (void *)(&starter + j))
      deadly_error(class_name(), func, "setting values are incorrect!");

  // add a constant to the values.
  for (int k = 0; k < MAX_VOID_ARRAY; k++)
    argh[k] = (void_pointer)((int *)argh[k] + 98);
  dump_deep_array(argh, "second version");

  // check assignment.
  argh2 = argh;
  for (int n = 0; n < MAX_VOID_ARRAY; n++)
    if (argh2[n] != (void_pointer)(&starter + n + 98))
      deadly_error(class_name(), func, "assign values are incorrect!");

  // now test that values are kept in place after rearrangement.
  argh.zap(3, 4);
  dump_deep_array(argh, "third version");
  for (int l = 0; l < 3; l++)
    if (argh[l] != (void_pointer)(&starter + l + 98))
      deadly_error(class_name(), func, "zap low values are incorrect!");
  for (int m = 3; m < MAX_VOID_ARRAY - 2; m++)
    if (argh[m] != (void_pointer)(&starter + m + 2 + 98))
      deadly_error(class_name(), func, "zap high values are incorrect!");

//hmmm: add more tests if void pointer deep_arrays seem in question.
}


static istring blank_string;

// jethro is a simple object for containment below.
class jethro
{
public:
  jethro(const istring &i = blank_string) : _truck(i) {}

  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:
  byte _q;
  istring _ted;
  istring _jed;
  int_array _ned;
  matrix<jethro> _med;
  int_matrix _red;

  test_content(byte q = 3)
  : _q(q), _ted("bl"), _jed("orp"),
    _ned(12, NIL),
    _med(3, 2),
    _red(2, 4)
  {
    for (int i = 0; i < _ned.length(); i++)
      _ned[i] = -i;
    for (int r = 0; r < _med.rows(); r++)
      for (int c = 0; c < _med.columns(); c++)
        _med[r][c] = jethro(istring((r*c) % 256, 1));
    for (int j = 0; j < _red.rows(); j++)
      for (int k = 0; k < _red.columns(); k++)
        _red[j][k] = j * k;
  }

  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;

    if (tc._red.rows() != _red.rows())
      return false;
    if (tc._red.columns() != _red.columns())
      return false;
    for (int j = 0; j < _red.rows(); j++)
      for (int k = 0; k < _red.columns(); k++)
        if (tc._red.get(j, k) != _red.get(j, k))
          return false;

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

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


template <class contents>
bool compare_deep_arrays(const deep_array<contents> &a, const deep_array<contents> &b)
{
  if (a.length() != b.length()) return false;
  for (int i = 0; i < a.length(); i++)
    if (a[i] != b[i]) return false;
  return true;
}

template <class contents>
void fill_in(deep_array<contents> &to_fill, const contents &filler)
{
  for (int i = 0; i < to_fill.length(); i++)
    if (!to_fill.restore(i))
      to_fill.put(i, filler);
}


// this is a templated test for deep_arrays, with some requirements.  the
// contents object must support a constructor that takes a simple byte,
// whether that's meaningful for the object or not.  if your type to test
// doesn't have that, derive a simple object from it, give it that
// constructor, and then it can be used below.  the object must also support
// comparison with == and != for this test to be used.  it must also provide
// a conversion to integer that returns the value passed to the constructor.

template <class contents>
void deep_array_tester(test_deep_array &ta, const contents &bogus)
{
  // the space that all training for deep_arrays comes from.
  contents *junk_space = new contents[MAX_OBJECT + MAX_BLOCK];
  for (int i = 0; i < MAX_OBJECT - 1; i++)
    junk_space[i] = contents(ta.randomizer().inclusive('a', 'z'));
  junk_space[MAX_OBJECT + MAX_BLOCK - 1] = '\0';

  deep_array<contents> *testers[MAX_SIMULTANEOUS_OBJECTS];
  for (int c = 0; c < MAX_SIMULTANEOUS_OBJECTS; c++) {
    // set up the initial deep_array guys.
    testers[c] = new deep_array<contents>(ta.randomizer().inclusive(MIN_OBJECT, MAX_OBJECT));
    // copy the randomized junk space into the new object.
    for (int i = 0; i < testers[c]->length(); i++)
      testers[c]->put(i, junk_space[i]);
  }

  // these are the actions we try out with the deep_array during the test.
  // the first and last elements must be identical to the first and last
  // tests to perform.
  enum actions { first, do_size = first, do_assign, do_access, do_zap,
      do_reset, do_resizer, do_indices, do_concatenating, do_subarray,
      do_insert, do_overwrite, do_memory_paring, do_snarf, last = do_snarf };

  time_stamp exit_time(MAX_TEST_DURATION);
  while (time_stamp() < exit_time) {
    int index = ta.randomizer().inclusive(0, MAX_SIMULTANEOUS_OBJECTS - 1);
    int choice = ta.randomizer().inclusive(first, last);
    switch (choice) {
      case do_size: {
#ifdef DEBUG_TEST_ARRAY
        LOG(isprintf("do_size"));
#endif
        deep_array<contents> old_version = *testers[index];
        bool at_front = bool(ta.randomizer().inclusive(0, 1));
        int new_size = ta.randomizer().inclusive(MIN_OBJECT, MAX_OBJECT);
        bool smaller = new_size < old_version.length();
        int difference = absolute_value(new_size - old_version.length());
        testers[index]->resize(new_size, at_front? common::NEW_AT_BEGINNING
            : common::NEW_AT_END);
        if (!smaller && difference) {
          // neuter the contents in the new section so we can compare.  this
          // space is filled with whatever the object's constructor chooses.
          if (at_front) {
            for (int i = 0; i < difference; i++)
              testers[index]->put(i, 'Q');
          } else {
            for (int i = old_version.length();
                i < old_version.length() + difference; i++)
              testers[index]->put(i, 'Q');
          }
        }
        // now compute an equivalent form of what the state should be.
        deep_array<contents> equivalent(0);
        if (at_front) {
          if (smaller) {
            equivalent = old_version.subarray(difference,
                old_version.length() - 1);
          } else {
            deep_array<contents> blank(difference);
            for (int i = 0; i < blank.length(); i++)
              blank[i] = 'Q';
            equivalent = blank + old_version;
          }
        } else {
          if (smaller) {
            equivalent = old_version.subarray(0, old_version.length()
                - difference - 1);
          } else {
            deep_array<contents> blank(difference);
            for (int i = 0; i < blank.length(); i++)
              blank[i] = 'Q';
            equivalent = old_version + blank;
          }
        }
        if (equivalent.length() != testers[index]->length())
          deadly_error(ta.class_name(), __WHERE__, "the resized form had "
              "erroneous length");
        if (!compare_deep_arrays(*testers[index], equivalent))
          deadly_error(ta.class_name(), __WHERE__, "the resized form had "
              "erroneous contents");
        break;
      }
      case do_assign: {
#ifdef DEBUG_TEST_ARRAY
        LOG(isprintf("do_assign"));
#endif
        deep_array<contents> arrh = *testers[index];  // copy old value.
        int to_assign = ta.randomizer().inclusive(0, MAX_SIMULTANEOUS_OBJECTS - 1);
        *testers[index] = *testers[to_assign];
        if (!compare_deep_arrays(*testers[index], *testers[to_assign]))
          deadly_error(ta.class_name(), __WHERE__, "assign failed to copy deep_array");
        *testers[to_assign] = arrh;  // recopy contents to new place.
        if (!compare_deep_arrays(*testers[to_assign], arrh))
          deadly_error(ta.class_name(), __WHERE__, "second assign failed");
        break;
      }
      case do_access: {
#ifdef DEBUG_TEST_ARRAY
        LOG(isprintf("do_access"));
#endif
        int start = ta.randomizer().inclusive(0, testers[index]->length());
        int end = ta.randomizer().inclusive(0, testers[index]->length());
        flip_increasing(start, end);
        deep_array<contents> accumulator(0);
        for (int i = start; i < end; i++) {
          contents c = contents(ta.randomizer().inclusive(1, 255));
          testers[index]->put(i, c);
          accumulator += c;
        }
        for (int j = start; j < end; j++)
          if (accumulator[j - start] != (*testers[index])[j])
            deadly_error(ta.class_name(), __WHERE__, "accessing failed");
        break;
      }
      case do_indices: {
#ifndef CATCH_ERRORS  // only works if not catching errors.
  #ifdef DEBUG_TEST_ARRAY
        LOG(isprintf("do_indices"));
  #endif
        // does some tests on bad indices.
        contents c1 = testers[index]->operator[](-50);
        contents c2 = testers[index]->operator[](-MAX_OBJECT);
        bool test = (c1 == c2);
        if (!test)
          deadly_error(ta.class_name(), __WHERE__, "invalid values were not same");
        int tests = ta.randomizer().inclusive(100, 500);
        for (int i = 0; i < tests; i++) {
          int indy = ta.randomizer().inclusive(-1000, MAX_OBJECT * 3);
          // testing if we can access without explosions.
          contents c3 = testers[index]->operator[](indy);
          contents c4 = c3;
          if (c3 != c4) 
            deadly_error(ta.class_name(), __WHERE__, "values were not same");
        }
#endif
        break;
      }
      case do_resizer: {
#ifdef DEBUG_TEST_ARRAY
        LOG(isprintf("do_resizer"));
#endif
        // tests whether the deep_array will reuse space when it should be able to.
        deep_array<contents> &arrh = *testers[index];
        // fill with known data.
        int i;
        for (i = 0; i < arrh.length(); i++)
          arrh[i] = contents((i + 23) % 256);
        int zap_amount = ta.randomizer().inclusive(1, arrh.length() - 1);
        // now take out a chunk from the deep_array at the beginning.
        arrh.zap(0, zap_amount - 1);
        // test the contents.
        for (i = 0; i < arrh.length(); i++)
          if (arrh[i] != contents((i + 23 + zap_amount) % 256))
            deadly_error(ta.class_name(), __WHERE__, "the resized form "
                "had different contents");
        // now add back in the space we ate.
        arrh.resize(arrh.length() + zap_amount, common::NEW_AT_END);
        // test the contents again.  they should start at zero and have the
        // same zap_amount offset.  the stuff past the original point shouldn't
        // be tested since we haven't set it.
        for (i = 0; i < arrh.length() - zap_amount; i++)
          if (arrh[i] != contents((i + 23 + zap_amount) % 256))
            deadly_error(ta.class_name(), __WHERE__, "the resized form "
                "had different contents");
        // now a test of all values through the zap_amount.
        arrh.zap(0, zap_amount - 1);
        for (i = 0; i < zap_amount; i++) {
          arrh.resize(arrh.length() + 1, common::NEW_AT_END);
        }
        // test the contents once more.  they should start at zero and have
        // double the zap_amount offset.  the stuff past the original point
        // shouldn't be tested since we haven't set it.
        for (i = 0; i < arrh.length() - 2 * zap_amount; i++)
          if (arrh[i] != contents((i + 23 + 2 * zap_amount) % 256))
            deadly_error(ta.class_name(), __WHERE__, "the slowly resized "
                "form had different contents");

        // the tests below should be nearly identical to the ones above, but
        // they use the NEW_AT_BEGINNING style of copying.

        // fill with known data.
        for (i = 0; i < arrh.length(); i++)
          arrh[i] = contents((i + 23) % 256);
        zap_amount = ta.randomizer().inclusive(1, arrh.length() - 1);
        // now take out a chunk from the deep_array at the beginning.
        arrh.zap(0, zap_amount - 1);
        // test the contents.
        for (i = 0; i < arrh.length(); i++)
          if (arrh[i] != contents((i + 23 + zap_amount) % 256))
            deadly_error(ta.class_name(), __WHERE__, "the resized form "
                "had different contents");
        // now add back in the space we ate.
        arrh.resize(arrh.length() + zap_amount,
            common::NEW_AT_BEGINNING);
        // test the contents again.  they should start at zap_amount but have
        // the same zap_amount offset.  the stuff before the original point
        // shouldn't be tested since we haven't set it.
        for (i = zap_amount; i < arrh.length(); i++)
          if (arrh[i] != contents((i + 23) % 256))
            deadly_error(ta.class_name(), __WHERE__, "the resized form "
                "had different contents");
        // now a test of all values through the zap_amount.
        arrh.zap(0, zap_amount - 1);
        for (i = 0; i < zap_amount; i++) {
          arrh.resize(arrh.length() + 1, common::NEW_AT_BEGINNING);
        }
        // test the contents once more.  the zap_amount offset should stay the
        // same since we clobbered the place we added originally, then added
        // more space in.  so we skip the first part still.
        for (i = zap_amount; i < arrh.length(); i++)
          if (arrh[i] != contents((i + 23) % 256))
            deadly_error(ta.class_name(), __WHERE__, "the slowly resized "
                "form had different contents");
        break;
      }
      case do_zap: {
#ifdef DEBUG_TEST_ARRAY
        LOG(isprintf("do_zap"));
#endif
        int start;
        int end;
        bool erroneous = false;
        int chose = ta.randomizer().inclusive(1, 100);
        if (chose <= 90) {
          // there's a ninety percent chance we pick a range that's valid.
          start = ta.randomizer().inclusive(0, testers[index]->length() - 1);
          end = ta.randomizer().inclusive(0, testers[index]->length() - 1);
        } else if (chose <= 95) {
          // and a 5 percent chance we pick to choose the zero index as our
          // start; this gets at the code for fast zapping.
          start = 0;
          end = ta.randomizer().inclusive(0, testers[index]->length() - 1);
        } else {
          // and a 5 percent chance we'll allow picking a bad index.  the
          // actual chance of picking a bad one is less.
          erroneous = true;
          start = ta.randomizer().inclusive(-2, testers[index]->length() + 3);
          end = ta.randomizer().inclusive(-2, testers[index]->length() + 3);
        }
        flip_increasing(start, end);
        deep_array<contents> old_version = *testers[index];
        testers[index]->zap(start, end);
        if (!erroneous) {
          deep_array<contents> old_head = old_version.subarray(0, start - 1);
          deep_array<contents> old_tail = old_version.subarray(end + 1,
              old_version.length() - 1);
          deep_array<contents> equivalent = old_head + old_tail;
          if (equivalent.length() != testers[index]->length())
            deadly_error(ta.class_name(), __WHERE__, "the zapped form had "
                "erroneous length");
          if (!compare_deep_arrays(*testers[index], equivalent))
            deadly_error(ta.class_name(), __WHERE__, "the zapped form had "
                "erroneous contents");
        }
        break;
      }
      case do_reset: {
#ifdef DEBUG_TEST_ARRAY
        LOG(isprintf("do_reset"));
#endif
        int junk_start = ta.randomizer().inclusive(MIN_BLOCK, MAX_BLOCK);
        int junk_end = ta.randomizer().inclusive(MIN_BLOCK, MAX_BLOCK);
        flip_increasing(junk_start, junk_end);
        int len = junk_end - junk_start + 1;
        testers[index]->reset(len);
        if (testers[index]->length() != len)
          deadly_error(ta.class_name(), __WHERE__, "reset gave a bad length");
        for (int i = 0; i < len; i++) {
          testers[index]->put(i, junk_space[junk_start + i]);
          if (testers[index]->get(i) != junk_space[junk_start + i])
            deadly_error(ta.class_name(), __WHERE__, "reset failed to copy data");
        }
        break;
      }
      case do_concatenating: {
#ifdef DEBUG_TEST_ARRAY
        LOG(isprintf("do_concatenating"));
#endif
        for (int i = 0; i < ta.randomizer().inclusive(1, 20); i++) {
          contents new_c = contents(ta.randomizer().inclusive('a', 'z'));
          testers[index]->concatenate(new_c);
          if (new_c != testers[index]->get(testers[index]->last()))
            deadly_error(ta.class_name(), __WHERE__,
                "value wrong after concatenate");
        }
        int indy = ta.randomizer().inclusive(0, MAX_SIMULTANEOUS_OBJECTS - 1);
        deep_array<contents> flirpan = *testers[indy];
        int start = ta.randomizer().inclusive(0, flirpan.length() - 1);
        int end = ta.randomizer().inclusive(0, flirpan.length() - 1);
        flip_increasing(start, end);
        flirpan = flirpan.subarray(start, end);
        deep_array<contents> grumzor = *testers[index];  // old copy.
        testers[index]->concatenate(flirpan);
        deep_array<contents> bubula = grumzor + flirpan;
        if (!compare_deep_arrays(bubula, *testers[index]))
          deadly_error(ta.class_name(), __WHERE__,
              "contents wrong after concatenate or concatenation");
        contents first_value;
        contents second_value;
        if (testers[index]->length() >= 1)
          first_value = testers[index]->get(0);
        if (testers[index]->length() >= 2)
          second_value = testers[index]->get(1);
        const int max_iters = ta.randomizer().inclusive(1, 42);
        for (int j = 0; j < max_iters; j++) {
          contents new_c = contents(ta.randomizer().inclusive('a', 'z'));
          *testers[index] = *testers[index] + new_c;
          // correct our value checks if new indices became available.
          if (testers[index]->length() == 1) {
            first_value = testers[index]->get(0);
          } else if (testers[index]->length() == 2) {
            second_value = testers[index]->get(1);
          }

          if (new_c != testers[index]->get(testers[index]->last()))
            deadly_error(ta.class_name(), __WHERE__, "value wrong after "
                "concatenation");

          if ( (testers[index]->length() >= 1)
              && (first_value != testers[index]->get(0)) )
            deadly_error(ta.class_name(), __WHERE__, "first value got "
                "corrupted");
          if ( (testers[index]->length() >= 2)
              && (second_value != testers[index]->get(1)) )
            deadly_error(ta.class_name(), __WHERE__, "second value got "
                "corrupted");

          *testers[index] += new_c;
          // we don't have to correct the first value any more, but might have
          // to correct the second.
          if (testers[index]->length() == 2) {
            second_value = testers[index]->get(1);
          }
          if (new_c != testers[index]->get(testers[index]->last()))
            deadly_error(ta.class_name(), __WHERE__, "value wrong after "
                "second concatenation");
          if ( (testers[index]->length() >= 1)
              && (first_value != testers[index]->get(0)) )
            deadly_error(ta.class_name(), __WHERE__, "first value got "
                "corrupted after second concat");
          if ( (testers[index]->length() >= 2)
              && (second_value != testers[index]->get(1)) )
            deadly_error(ta.class_name(), __WHERE__, "second value got "
                "corrupted after second concat");
        }
        break;
      }
      case do_subarray: {
#ifdef DEBUG_TEST_ARRAY
        LOG(isprintf("do_subarray"));
#endif
        fill_in(*testers[index], bogus);  // make sure items are comparable.
        deep_array<contents> flirpan = *testers[index];
        int start = ta.randomizer().inclusive(0, flirpan.length() - 1);
        int end = ta.randomizer().inclusive(0, flirpan.length() - 1);
        flip_increasing(start, end);
        flirpan = flirpan.subarray(start, end);
        for (int i = 0; i < end - start; i++)
          if (flirpan[i] != testers[index]->get(i + start))
            deadly_error(ta.class_name(), __WHERE__, "subarray produced wrong deep_array");
        break;
      }
      case do_memory_paring: {
#ifdef DEBUG_TEST_ARRAY
        LOG(isprintf("do_memory_paring"));
#endif
        for (int i = 0; i < MAX_SIMULTANEOUS_OBJECTS; i++) {
          // zap extra junk off so we bound the memory usage.
          if (testers[i]->length() > MAX_OBJECT) {
            testers[i]->zap(MAX_OBJECT, testers[i]->length() - 1);
          }
        }
        break;
      }
      case do_snarf: {
//this test becomes the acquire test?
/*
#ifdef DEBUG_TEST_ARRAY
        LOG(isprintf("do_snarf"));
#endif
        deep_array<contents> flirpan = *testers[index];
//        int start = ta.randomizer().inclusive(0, flirpan.length() - 1);
//        int end = ta.randomizer().inclusive(0, flirpan.length() - 1);
//        flip_increasing(start, end);
//        flirpan = flirpan.subarray(start, end);
        int rand_index = ta.randomizer().inclusive(0, MAX_SIMULTANEOUS_OBJECTS - 1);
        if (index == rand_index) continue;  // skip it; try again later.
        deep_array<contents> nugwort = *testers[rand_index];
        // perform a swap between two of our deep_arrays.
        deep_array<contents> temp_hold(0);
        temp_hold.snarf(*testers[index]);
        testers[index]->snarf(*testers[rand_index]);
        testers[rand_index]->snarf(temp_hold);
        // the copies should have flipped places now.  check them.
        if (flirpan.length() != testers[rand_index]->length())
          deadly_error(ta.class_name(), __WHERE__, "snarf produced wrong length A");
        for (int i = 0; i < flirpan.length(); i++)
          if (flirpan[i] != testers[rand_index]->get(i))
            deadly_error(ta.class_name(), __WHERE__, "snarf produced wrong deep_array A");
        if (nugwort.length() != testers[index]->length())
          deadly_error(ta.class_name(), __WHERE__, "snarf produced wrong length B");
        for (int j = 0; j < nugwort.length(); j++)
          if (nugwort[j] != testers[index]->get(j))
            deadly_error(ta.class_name(), __WHERE__, "snarf produced wrong deep_array B");
*/
      }
      case do_insert: {
#ifdef DEBUG_TEST_ARRAY
        LOG(isprintf("do_insert"));
#endif
        fill_in(*testers[index], bogus);  // make sure items are comparable.
        deep_array<contents> hold = *testers[index];
        int put_where = ta.randomizer().inclusive(0, hold.last());
        int how_many = ta.randomizer().inclusive(0, 25);
        testers[index]->insert(put_where, how_many);
        for (int i = 0; i < put_where; i++)
          if (hold[i] != testers[index]->get(i))
            deadly_error(ta.class_name(), __WHERE__, "bad contents on left after insert");
        for (int j = put_where + how_many; j < testers[index]->length(); j++)
          if (hold[j - how_many] != testers[index]->get(j))
            deadly_error(ta.class_name(), __WHERE__, "bad contents on right after insert");
        break;
      }
      case do_overwrite: {
#ifdef DEBUG_TEST_ARRAY
        LOG(isprintf("do_overwrite"));
#endif
        fill_in(*testers[index], bogus);  // make sure items are comparable.
        if (!testers[index]->length()) continue;
        fill_in(*testers[index], bogus);  // make sure items are comparable.
        deep_array<contents> hold = *testers[index];
        int index2 = index;
        while (index2 == index)
          index2 = ta.randomizer().inclusive(0, MAX_SIMULTANEOUS_OBJECTS - 1);
        fill_in(*testers[index2], bogus);  // make sure items are comparable.
        deep_array<contents> &hold2 = *testers[index2];
        if (!hold2.length()) continue;
        int write_indy = ta.randomizer().inclusive(0, hold.last());
        int write_len = minimum(hold2.length(), (hold.length() - write_indy));
// LOG(isprintf("len1 = %d len2 = %d wrindy=%d wrlen=%d", hold.length(), hold2.length(), write_indy, write_len));
        outcome ret = testers[index]->overwrite(write_indy,
            *testers[index2], write_len);
        if (ret != common::OKAY)
          deadly_error(ta.class_name(), __WHERE__, istring("bad outcome=")
              + common::outcome_name(ret));
        for (int i = 0; i < write_indy; i++)
          if (hold[i] != testers[index]->get(i))
            deadly_error(ta.class_name(), __WHERE__,
                "bad contents on left after overwrite");
        for (int j = write_indy; j < write_indy + write_len; j++)
          if (hold2[j - write_indy] != testers[index]->get(j))
            deadly_error(ta.class_name(), __WHERE__,
                "bad contents in middle after overwrite");
        for (int k = write_indy + write_len; k < testers[index]->length(); k++)
          if (hold[k] != testers[index]->get(k))
            deadly_error(ta.class_name(), __WHERE__,
                "bad contents on right after overwrite");
        break;
      }
      default: {
        deadly_error(ta.class_name(), "action choice", "invalid choice!");
        break;
      }
    }
  }

  // clean up.
  delete [] junk_space;
  for (int d = 0; d < MAX_SIMULTANEOUS_OBJECTS; d++) delete testers[d];
}


struct gerkin { int l; byte *p; char *r; void *pffttt; };

gerkin borgia;

class foop
{
public:
  virtual ~foop() {}
  virtual gerkin *boorba() = 0;
};

class boop : public foop
{
public:
  virtual gerkin *boorba() { return &borgia; }
};


class deep_pack_object : public packable
{
public:
  istring _glunk;
  int _foof;

  deep_pack_object() : packable(), _glunk("arf"), _foof(2398) {}
  virtual ~deep_pack_object() { _glunk = ""; _foof = 0; }

  virtual void pack(byte_array &packed_form) const {
    _glunk.pack(packed_form);
    basis::attach(packed_form, _foof);
  }

  virtual bool unpack(byte_array &packed_form) {
    if (!_glunk.unpack(packed_form)) return false;
    if (!basis::detach(packed_form, _foof)) return false;
    return true;
  }

  virtual int packed_size() const {
      return _glunk.length() + 1
          + sizeof(int);
  }
};

void test_deep_array::test_packing_deep_arrays()
{
  FUNCDEF("test_packing_deep_arrays");
  deep_array<deep_pack_object> fred1;
  for (int i = 0; i < 3 + chaos().inclusive(0, 80); i++)
    fred1 += deep_pack_object(); 
  byte_array packed_form;
  data_structure::pack(packed_form, fred1);
  if (data_structure::packed_size(fred1) != packed_form.length())
    deadly_error(func, "packed_size", "calculated wrong packed size");
  deep_array<deep_pack_object> fred2;
  if (!data_structure::unpack(packed_form, fred2)) 
    deadly_error(func, "unpack", "unpacking failed on deep array");
  if (fred2.length() != fred1.length()) 
    deadly_error(func, "unpack", "unpacking got wrong length in result");
  for (int i = 0; i < fred2.length(); i++) {
    if (fred2[i]._foof != 2398)
      deadly_error(func, "unpack", "unpacking got wrong int content");
    if (fred2[i]._glunk != "arf")
      deadly_error(func, "unpack", "unpacking got wrong string content");
  }
}


int test_deep_array::execute()
{
  test_packing_deep_arrays();
  LOG(isprintf("did deep_array packing test.")); 

  int_array checking_start;
  if (checking_start.length())
    deadly_error(class_name(), "int_array length",
        "has contents from empty constructor!");

  float_plus<double> bogus4 = float(12.32);
  deep_array_tester<float_plus<double> >(*this, bogus4);
  LOG(isprintf("did float deep_array test.")); 

  int bogus2 = 39;
  deep_array_tester<int>(*this, bogus2);
  LOG(isprintf("did int deep_array test.")); 

  test_content bogus3(12);
  deep_array_tester<test_content>(*this, bogus3);
  LOG(isprintf("did test_content deep_array test.")); 

  test_deep_arrays_of_void_pointer();
  LOG(isprintf("did void * deep_array test.")); 

  byte bogus1 = 'c';
  deep_array_tester<byte>(*this, bogus1);
  LOG(isprintf("did byte deep_array test.")); 

  guards::alert_message("deep_array:: works for those functions tested.");

  return 0;
}

HOOPLE_MAIN(test_deep_array, )

---