t_mat_morph.cpp

Go to the documentation of this file.

/*****************************************************************************\
*                                                                             *
*  Name   : test_mat_morph                                                    *
*  Author : Chris Koeritz                                                     *
*                                                                             *
*******************************************************************************
* Copyright (c) 2003-$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/guards.h>
#include <basis/istring.h>
#include <basis/log_base.h>
#include <data_struct/mat_morph.cpp>
#include <opsystem/application_shell.h>
#include <loggers/console_logger.h>
#include <data_struct/static_memory_gremlin.h>

// these are the dimensions of our test matrices.
const int DIM_ROWS = 10;
const int DIM_COLS = 10;

// fills the matrix "to_stuff" with the pure version of the ingredients.
#define STUFF_MATRIX(to_stuff, max_row, max_col) \
  to_stuff.reset(max_row, max_col); \
  for (int r = 0; r < max_row; r++) \
    for (int c = 0; c < max_col; c++) \
      to_stuff.put(r, c, new int(*test_pure.get(r, c))); \


// this class exhibits an old bug where the mat_morph was zeroing out its
// contents for a same size resize.  the zeroing allowed hell to spew forth.
class diggulite
{
public:
  diggulite() {}
  virtual ~diggulite() {}
};


class test_mat_morph : public application_shell
{
public:
  test_mat_morph();

  IMPLEMENT_CLASS_NAME("test_mat_morph");

  int execute();
    // performs main body of test.

  void print_mat_morph(const mat_morph<int> &to_print);
    // dumps "to_print" to the diagnostic output.
};


test_mat_morph::test_mat_morph() : application_shell(class_name())
{
}

void test_mat_morph::print_mat_morph(const mat_morph<int> &to_print)
{
  istring text;
  for (int t = 0; t < to_print.rows(); t++) {
    text += istring(istring::SPRINTF, "[%d] ", t);
    for (int c = 0; c < to_print.columns(); c++)
      text += !to_print.get(t, c) ? "--- "
          : isprintf("%03d ", *to_print.get(t, c));
    text += log_base::platform_ending();
  }
  log(text);
}

int test_mat_morph::execute()
{
  mat_morph<int> test_pure(DIM_ROWS, DIM_COLS);
    // this matrix is kept without modification.
  {
  for (int r = 0; r < DIM_ROWS; r++)
    for (int c = 0; c < DIM_COLS; c++)
      test_pure.put(r, c, new int(r * DIM_COLS + c));
  }

  // a copy to work with.  this will not be allowed to take our pointers down.
  mat_morph<int> test1(DIM_ROWS, DIM_COLS);
  {
  for (int r = 0; r < DIM_ROWS; r++)
    for (int c = 0; c < DIM_COLS; c++)
      test1.put(r, c, test_pure.get(r, c));
  }

  {
  for (int s = 0; s < DIM_ROWS; s++)
    for (int c = 0; c < DIM_COLS; c++)
      if (*test_pure.get(s, c) != *test1.get(s, c))
        deadly_error("test_mat_morph", "compare", "matrices are different");
  }

  {
  for (int s = 0; s < DIM_ROWS; s++)
    for (int c = 0; c < DIM_COLS; c++)
      test1.acquire(s, c);  // toss the pointer copy.
  }

  test1.reset();
  if (test1.rows() || test1.columns())
    deadly_error("test_mat_morph", "reset", "mat_morph is not empty");

  print_mat_morph(test_pure);

  mat_morph<int> computed(7, 14);
  for (int x1 = 0; x1 < 7; x1++) {
    for (int y1 = 0; y1 < 14; y1++) {
      computed.put(x1, y1, new int(1 + x1 * 100 + y1));
    }
  }

  for (int x2 = 6; x2 >= 0; x2--) {
    for (int y2 = 13; y2 >= 0; y2--) {
      if (*computed.get(x2, y2) != 1 + x2 * 100 + y2)
        deadly_error("test_mat_morph", "computed values", "a value is wrong");
    }
  }

  computed.redimension(3, 5);
  if ( (computed.rows() != 3) || (computed.columns() != 5) )
    deadly_error("test_mat_morph", "redimension",
        isprintf("size is wrong (want 3x5, got %dx%d).", computed.rows(),
            computed.columns()));
  for (int x3 = 2; x3 >= 0; x3--) {
    for (int y3 = 4; y3 >= 0; y3--) {
      if (*computed.get(x3, y3) != 1 + x3 * 100 + y3)
        deadly_error("test_mat_morph", "computed values 2", "a value is wrong");
    }
  }

  computed.redimension(0, 0);
  if (computed.rows() || computed.columns())
    deadly_error("test_mat_morph", "redimension to zero",
        "mat_morph is not empty");

  computed.reset(12, 20);
  if ( (computed.rows() != 12) || (computed.columns() != 20) )
    deadly_error("test_mat_morph", "resize", "size is wrong");

  {
    // this test block ensures that the mat_morph doesn't blow up from certain
    // resizing operations performed on a templated type that has a virtual
    // destructor.
    mat_morph<diggulite> grids;
    grids.reset();
    grids.redimension(0, 1);
    grids.redimension(1, 1);
    grids.reset(1, 1);
  }

  {
    // this block tests the zapping ops.
    mat_morph<int> test_zap;
    STUFF_MATRIX(test_zap, DIM_ROWS, DIM_COLS);

    log("mat_morph before zappage:");
    print_mat_morph(test_zap);
    test_zap.zap_row(5);
    log("mat_morph afterzappage of row 5:");
    print_mat_morph(test_zap);
    // reset test_zap again.
    STUFF_MATRIX(test_zap, DIM_ROWS, DIM_COLS);
    test_zap.zap_column(3);
    log("mat_morph afterzappage of column 3:");
    print_mat_morph(test_zap);

    // reset test_zap again.
    STUFF_MATRIX(test_zap, DIM_ROWS, DIM_COLS);
    test_zap.zap_column(0);
    test_zap.zap_row(0);
    test_zap.zap_row(test_zap.rows() - 1);
    test_zap.zap_column(test_zap.columns() - 1);
    log("mat_morph after zap of row 0, col 0, last row, last col");
    print_mat_morph(test_zap);
  }

  {
    // this block tests the inserting ops.
    mat_morph<int> test_insert;
    STUFF_MATRIX(test_insert, 4, 4);

    log("mat_morph before inserting:");
    print_mat_morph(test_insert);
    test_insert.insert_row(2);
    log("mat_morph after insert of row 2:");
    print_mat_morph(test_insert);
    // reset test_insert again.
    STUFF_MATRIX(test_insert, 5, 6);
    log("mat_morph before inserting:");
    print_mat_morph(test_insert);
    test_insert.insert_column(3);
    log("mat_morph after insert of column 3:");
    print_mat_morph(test_insert);

    // reset test_insert again.
    STUFF_MATRIX(test_insert, 3, 3);
    log("mat_morph before inserting:");
    print_mat_morph(test_insert);
    test_insert.insert_column(0);
    test_insert.insert_row(test_insert.rows());
    test_insert.insert_column(test_insert.columns());
    test_insert.insert_row(0);
    log("mat_morph after insert of col 0, last row, last col, row 0");
    print_mat_morph(test_insert);
  }

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

HOOPLE_MAIN(test_mat_morph, )

---