t_array.cpp

Go to the documentation of this file.

/*****************************************************************************\
*                                                                             *
*  Name   : test_array                                                        *
*  Author : Chris Koeritz                                                     *
*                                                                             *
*******************************************************************************
* Copyright (c) 1991-$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
  // when this flag is turned on, extra checking will be done in the allocator.

//hmmm: catch all outcomes returned from functions under test and complain
//      if they indicate unexpected failures.

#include <basis/byte_array.h>
#include <basis/chaos.h>
#include <basis/function.h>
#include <basis/guards.h>
#include <basis/istring.h>
#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 = 0.5 * MINUTE_ms;
  // each of the tests calling on the templated tester will take this long.

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

const int MIN_OBJECT = -30; // the smallest array we'll create.
const int MAX_OBJECT = 98; // the largest 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)


class test_array : public application_shell
{
public:
  test_array() : application_shell(class_name()) {}
  IMPLEMENT_CLASS_NAME("test_array");
  virtual int execute();
  void dump_array(array<void *> &ar, const char *name);
  void test_arrays_of_void_pointer();
  void test_iteration_speed();
};


void test_array::dump_array(array<void *> &ar, const char *name)
{
#ifdef DEBUG_TEST_ARRAY
  LOG(isprintf("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_array::test_arrays_of_void_pointer()
{
  FUNCDEF("void pointer test");
  if (sizeof(void *) != 4)
    deadly_error(class_name(), func, "the void pointer has an unexpected size!");
  const int MAX_VOID_ARRAY = 20;
  array<void *> argh(MAX_VOID_ARRAY, NIL, byte_array::SIMPLE_COPY
      | byte_array::EXPONE | byte_array::FLUSH_INVISIBLE);
  array<void *> argh2(argh);
  if (argh.length() != MAX_VOID_ARRAY)
    deadly_error(class_name(), func, "the first array length is incorrect!");
  if (argh2.length() != MAX_VOID_ARRAY)
    deadly_error(class_name(), func, "the copied array length is incorrect!");
  for (int o = 0; o < MAX_VOID_ARRAY; o++)
    if (argh[o] != argh2[o])
      deadly_error(class_name(), func, "the arrays have different contents!");
    
  // fill it with values.
  int starter;
  for (int i = 0; i < MAX_VOID_ARRAY; i++)
    argh[i] = (void *)(&starter + i);
  dump_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 *)((int *)argh[k] + 23);
  dump_array(argh, "second version");

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

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

//hmmm: add more tests if void pointer 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_arrays(const array<contents> &a, const 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;
}


// this is a templated test for 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 array_tester(test_array &ta, const contents &formal(bogus), u_short flags)
{
  // the space that all training for 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';

  array<contents> *testers[MAX_SIMULTANEOUS_OBJECTS];
  for (int c = 0; c < MAX_SIMULTANEOUS_OBJECTS; c++) {
    // set up the initial array guys.
    testers[c] = new array<contents>(ta.randomizer().inclusive(MIN_OBJECT, MAX_OBJECT),
        NIL, flags);
    // 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 array during the test.
  // the first and last elements must be identical to the first and last
  // tests to perform.
  enum actions { first, do_train = first, do_size, do_assign,
      do_access, do_zap, do_resizer, do_shrink, do_reset, do_indices,
      do_concatenating, do_concatenating2, do_subarray, do_insert,
      do_overwrite, do_stuff, do_memory_paring, do_snarf, do_flush,
      do_observe, last = do_observe };

  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_train: {
#ifdef DEBUG_TEST_ARRAY
        LOG(isprintf("do_train"));
#endif
        int new_size = ta.randomizer().inclusive(MIN_OBJECT, MAX_OBJECT);
        testers[index]->retrain(new_size, (contents *)junk_space);
        for (int i = 0; i < new_size; i++) {
          if (junk_space[i] != (*testers[index])[i])
            deadly_error(ta.class_name(), __WHERE__, "bad contents after retrain");
        }
        break;
      }
      case do_size: {
#ifdef DEBUG_TEST_ARRAY
        LOG(isprintf("do_size"));
#endif
        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.
        array<contents> equivalent(0, NIL, flags);
        if (at_front) {
          if (smaller) {
            equivalent = old_version.subarray(difference,
                old_version.length() - 1);
          } else {
            array<contents> blank(difference, NIL, flags);
            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 {
            array<contents> blank(difference, NIL, flags);
            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_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
        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_arrays(*testers[index], *testers[to_assign]))
          deadly_error(ta.class_name(), __WHERE__, "assign failed to copy array");
        *testers[to_assign] = arrh;  // recopy contents to new place.
        if (!compare_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);
        array<contents> accumulator(0, NIL, flags);
        for (int i = start; i < end; i++) {
          contents c = contents(ta.randomizer().inclusive(1, 255));
          testers[index]->access()[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_observe: {
#ifdef DEBUG_TEST_ARRAY
        LOG(isprintf("do_observe"));
#endif
        // tests contents returned by observe.
        int start = ta.randomizer().inclusive(0, testers[index]->length());
        int end = ta.randomizer().inclusive(0, testers[index]->length());
        flip_increasing(start, end);
        double total_1 = 0;
        for (int i = start; i < end; i++)
          total_1 += testers[index]->observe()[i];
        double total_2 = 0;
        for (int j = end - 1; j >= start; j--)
          total_2 += testers[index]->observe()[j];
        if (total_1 != total_2)
          deadly_error(ta.class_name(), __WHERE__, "totals didn't match");
        break;
      }
      case do_resizer: {
#ifdef DEBUG_TEST_ARRAY
        LOG(isprintf("do_resizer"));
#endif
        // tests whether the array will reuse space when it should be able to.
        array<contents> &arrh = *testers[index];
        // fill with known data.
        int i;
        for (i = 0; i < arrh.length(); i++)
          arrh[i] = contents((i + 23) % 256);
        // record the old starting point.
        const contents *start = arrh.internal_block_start();
        int zap_amount = ta.randomizer().inclusive(1, arrh.length() - 1);
        // now take out a chunk from the 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);
        // check the pointer; it should not have changed.
        if (start != arrh.internal_block_start())
          deadly_error(ta.class_name(), __WHERE__, "the resized form had "
              "a different start address");
        // 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);
          if (start != arrh.internal_block_start())
            deadly_error(ta.class_name(), __WHERE__, "the slowly resized "
                "form had a different start address");
        }
        // 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);
        // record the old starting point.
        start = arrh.internal_block_start();
        zap_amount = ta.randomizer().inclusive(1, arrh.length() - 1);
        // now take out a chunk from the 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);
        // check the pointer; it should not have changed.
        if (start != arrh.internal_block_start())
          deadly_error(ta.class_name(), __WHERE__, "the resized form had "
              "a different start address");
        // 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);
          if (start != arrh.internal_block_start())
            deadly_error(ta.class_name(), __WHERE__, "the slowly resized "
                "form had a different start address");
        }
        // 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);
        array<contents> old_version = *testers[index];
        testers[index]->zap(start, end);
        if (!erroneous) {
          array<contents> old_head = old_version.subarray(0, start - 1);
          array<contents> old_tail = old_version.subarray(end + 1,
              old_version.length() - 1);
          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_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, (contents *)&junk_space[junk_start]);
        if (testers[index]->length() != len)
          deadly_error(ta.class_name(), __WHERE__, "reset gave a bad length");
        for (int i = 0; i < len; 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_shrink: {
#ifdef DEBUG_TEST_ARRAY
        LOG(isprintf("do_shrink"));
#endif
        array<contents> garp = *testers[index];
        testers[index]->shrink();
        int new_diff = testers[index]->internal_real_length()
            - testers[index]->length();
        if (!compare_arrays(garp, *testers[index]))
          deadly_error(ta.class_name(), __WHERE__, "shrink failed to keep contents");
        // now force a real shrinkage.
        if (testers[index]->length() < 5) continue;  // need some room.
        // pick an element to keep that is not first or last.
        int kept = ta.randomizer().inclusive(1, testers[index]->last() - 1);
        // whack all but the lucky element.
        testers[index]->zap(kept + 1, testers[index]->last());
        testers[index]->zap(0, kept - 1);
        // shrink it again, now a big shrink.
        testers[index]->shrink();
        // check the difference now.
        new_diff = testers[index]->internal_real_length()
            - testers[index]->length();
        if (new_diff > 1) 
          deadly_error(ta.class_name(), __WHERE__, "massive shrink gave a bad size");

        // restore the original contents and block size.
        *testers[index] = garp;
        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);
        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);
        array<contents> grumzor = *testers[index];  // old copy.
        testers[index]->concatenate(flirpan);
        array<contents> bubula = grumzor + flirpan;
        if (!compare_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_concatenating2: {
        // this tests the new concatenate content array method for array.
#ifdef DEBUG_TEST_ARRAY
        LOG(isprintf("do_concatenating2"));
#endif
        array<contents> &flirpan = *testers[index];
        int new_len = ta.randomizer().inclusive(0, 140);
        contents *to_add = new contents[new_len];
        for (int i = 0; i < new_len; i++) {
          int rando = ta.randomizer().inclusive(0, MAX_BLOCK - 1);
          to_add[i] = junk_space[rando];
        }
        int old_len = flirpan.length();
        flirpan.concatenate(to_add, new_len);
        for (int i = 0; i < new_len; i++) {
          if (flirpan[i + old_len] != to_add[i])
            deadly_error(ta.class_name(), __WHERE__, "value wrong after "
                "content array concatenation");
        }
        delete [] to_add;  // clean up.
        break;
      }
      case do_subarray: {
#ifdef DEBUG_TEST_ARRAY
        LOG(isprintf("do_subarray"));
#endif
        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 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);
            testers[i]->shrink();
          }
        }
        break;
      }
      case do_snarf: {
#ifdef DEBUG_TEST_ARRAY
        LOG(isprintf("do_snarf"));
#endif
        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.
        array<contents> nugwort = *testers[rand_index];
        // perform a swap between two of our arrays.
        array<contents> temp_hold(0, NIL, flags);
        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 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 array B");
        break;
      }
      case do_flush: {
#ifdef DEBUG_TEST_ARRAY
        LOG(isprintf("do_flush"));
#endif
        array<contents> flirpan = *testers[index];




        break;
      }

      case do_insert: {
#ifdef DEBUG_TEST_ARRAY
        LOG(isprintf("do_insert"));
#endif
        array<contents> hold = *testers[index];
        int where = ta.randomizer().inclusive(0, hold.last());
        int how_many = ta.randomizer().inclusive(0, 25);
        testers[index]->insert(where, how_many);
        for (int i = 0; i < where; i++)
          if (hold[i] != testers[index]->get(i))
            deadly_error(ta.class_name(), __WHERE__, "bad contents on left after insert");
        for (int j = 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
        if (!testers[index]->length()) continue;
        array<contents> hold = *testers[index];
        int index2 = index;
        while (index2 == index)
          index2 = ta.randomizer().inclusive(0, MAX_SIMULTANEOUS_OBJECTS - 1);
        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;
      }
      case do_stuff: {
#ifdef DEBUG_TEST_ARRAY
        LOG(isprintf("do_stuff"));
#endif
        array<contents> &hold = *testers[index];
        contents burgers[100];
        int stuff_len = ta.randomizer().inclusive(0, hold.length());
        stuff_len = minimum(stuff_len, 100);
        outcome ret = hold.stuff(stuff_len, burgers);
        if (ret != common::OKAY)
          deadly_error(ta.class_name(), __WHERE__, istring("bad outcome=")
              + common::outcome_name(ret));
        for (int i = 0; i < stuff_len; i++)
          if (burgers[i] != hold[i])
            deadly_error(ta.class_name(), __WHERE__, "bad contents after stuff");
        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; }
};

void test_array::test_iteration_speed()
{
  const int MAX_CHUNK = 100000;
  const int MAX_REPS = 20;
  byte_array chunky(MAX_CHUNK);

  {
    time_stamp start;
    int sum = 0;
    for (int j = 0; j < MAX_REPS; j++) {
      for (int i = 0; i < MAX_CHUNK; i++) {
        sum += chunky[i];
      }
    }
    int duration = int(time_stamp().value() - start.value());

    LOG(isprintf("iteration over %d elements took %d ms,\tor %f ms per 1000 iters.",
        MAX_CHUNK * MAX_REPS, duration,
        double(duration) / double(MAX_CHUNK * MAX_REPS) * 1000.0));
  }

  {
    time_stamp start;
    int sum = 0;
    const byte *head = chunky.observe();
    for (int j = 0; j < MAX_REPS; j++) {
      for (int i = 0; i < MAX_CHUNK; i++) {
        sum += head[i];
      }
    }
    int duration = int(time_stamp().value() - start.value());

    LOG(isprintf("less-safe iteration over %d elements took %d ms,\tor %f ms per 1000 iters.",
        MAX_CHUNK * MAX_REPS, duration,
        double(duration) / double(MAX_CHUNK * MAX_REPS) * 1000.0));
  }
  {
    time_stamp start;
    boop tester;
//    int sum = 0;
    for (int j = 0; j < MAX_REPS; j++) {
      for (int i = 0; i < MAX_CHUNK; i++) {
//        chunky.modus().sampler();
        tester.boorba();
      }
    }
    int duration = int(time_stamp().value() - start.value());

    LOG(isprintf("virtual-function-only over %d elements took %d ms,\tor %f ms per 1000 iters.",
        MAX_CHUNK * MAX_REPS, duration,
        double(duration) / double(MAX_CHUNK * MAX_REPS) * 1000.0));
  }
}


int test_array::execute()
{
  test_iteration_speed();
  LOG(isprintf("did iteration 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);
  array_tester<float_plus<double> >(*this, bogus4,
      byte_array::SIMPLE_COPY | byte_array::EXPONE
          | byte_array::FLUSH_INVISIBLE);
  LOG(isprintf("did float array test.")); 

  int bogus2 = 39;
  array_tester<int>(*this, bogus2,
      byte_array::SIMPLE_COPY | byte_array::EXPONE
          | byte_array::FLUSH_INVISIBLE);
  LOG(isprintf("did int array test.")); 

  test_content bogus3(12);
  array_tester<test_content>(*this, bogus3, byte_array::EXPONE
      | byte_array::FLUSH_INVISIBLE);
  LOG(isprintf("did test_content array test.")); 

  test_arrays_of_void_pointer();
  LOG(isprintf("did void * array test.")); 

  byte bogus1 = 'c';
  array_tester<byte>(*this, bogus1,
      byte_array::SIMPLE_COPY | byte_array::EXPONE
          | byte_array::FLUSH_INVISIBLE);
  LOG(isprintf("did byte array test.")); 

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

  return 0;
}

HOOPLE_MAIN(test_array, )

---