t_stack.cpp

Go to the documentation of this file.

/*****************************************************************************\
*                                                                             *
*  Name   : t_stack                                                           *
*  Author : Chris Koeritz                                                     *
*                                                                             *
*  Purpose:                                                                   *
*                                                                             *
*    Tests out the stack object with both flat objects (byte_array) but also  *
*  deep objects (pointer to byte_array).  Both bounded and unbounded stacks   *
*  are tested for each.                                                       *
*                                                                             *
*******************************************************************************
* Copyright (c) 1992-$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/guards.h>
#include <basis/istring.h>
#include <data_struct/stack.cpp>
#include <data_struct/static_memory_gremlin.h>

#ifdef DEBUG_STACK
  #include <loggers/console_logger.h>
  #include <stdio.h>
  console_logger out;
  #define LOG(to_print) { out.log(to_print); fflush(0); }
#endif

#include <stdlib.h>
#include <string.h>

HOOPLE_STARTUP_CODE;

//#define DEBUG_STACK
  // uncomment for a noisier version.

const int test_iterations = 40;

#define WHERE __WHERE__.s()

// CHECK_STACK_RESULT: a function that takes care of error testing for a
// stack command.  if executing the command ends in full or empty, then
// that is reported.
void CHECK_STACK_RESULT(outcome retval, const istring &place)
{
#ifdef DEBUG_STACK
  if (retval == common::IS_FULL)
    LOG(istring(istring::SPRINTF, "returned IS_FULL at %s", place.s()))
  else if (retval == common::IS_EMPTY)
    LOG(istring(istring::SPRINTF, "returned IS_EMPTY at %s", place.s()));
#else
  if (retval.value() || !place) {}
#endif
}

byte_array generate_flat(const char *to_store)
{
  byte_array to_return = byte_array(int(strlen(to_store) + 1), (byte *)to_store);
  return to_return;
}

byte_array *generate_deep(const char *to_store)
{
  byte_array *to_return = new byte_array(int(strlen(to_store) + 1),
      (byte *)to_store);
  return to_return;
}

istring text_form(stack<byte_array *> &s)
{
  istring to_return;
  for (int i = 0; i < s.elements(); i++) {
    to_return += istring(istring::SPRINTF, "#%d: %s\n", i, s[i]->observe());
  }
  return to_return;
}

istring text_form(stack<byte_array> &s)
{
  istring to_return;
  for (int i = 0; i < s.elements(); i++) {
    to_return += istring(istring::SPRINTF, "#%d: %s\n", i, s[i].observe());
  }
  return to_return;
}

void test_stack_with_objects()
{
  for (int qq = 0; qq < test_iterations; qq++) {
#ifdef DEBUG_STACK
    LOG(istring(istring::SPRINTF, "index %d", qq));
#endif
    stack<byte_array > bounded_stack(3);
    stack<byte_array > unlimited_stack(0);
    chaos randomizer;

    {
#ifdef DEBUG_STACK
      LOG("testing the bounded stack first:");
#endif
      CHECK_STACK_RESULT(bounded_stack.push(generate_flat("the first line")), "first push");
      CHECK_STACK_RESULT(bounded_stack.push(generate_flat("the second line")), "second push");
      CHECK_STACK_RESULT(bounded_stack.push(generate_flat("the final and third")), "third push");
      byte_array gend = generate_flat("this shouldn't work");
      if (bounded_stack.push(gend) != common::IS_FULL)
        deadly_error(WHERE, "main", "the bounded stack push didn't catch IS_FULL");
#ifdef DEBUG_STACK
      LOG("pushing worked successfully...");
      LOG("printing the stack in element order");
#endif
      for (int i = 0; i < bounded_stack.size(); i++) {
#ifdef DEBUG_STACK
        LOG(istring(istring::SPRINTF, "depth %d has %s.", i,
            bounded_stack[i].observe()));
#endif
      }
#ifdef DEBUG_STACK
      LOG("now popping the stack all the way back.");
#endif
      int full_size = bounded_stack.size();
      for (int j = 0; j < full_size; j++) {
#ifdef DEBUG_STACK
        LOG(istring(istring::SPRINTF, "pop %d, stack size is %d, has %s", j+1,
            bounded_stack.size(), bounded_stack.top().observe()));
#endif
        byte_array found;
        bounded_stack.acquire_pop(found);
        istring got((char *)found.observe());
        switch (j) {
        case 0: if (got != istring("the final and third"))
          deadly_error(WHERE, "acquire_pop", "wrong contents at 2"); break;
        case 1: if (got != istring("the second line"))
          deadly_error(WHERE, "acquire_pop", "wrong contents at 1"); break;
        case 2: if (got != istring("the first line"))
          deadly_error(WHERE, "acquire_pop", "wrong contents at 0"); break;
        }
      }
      if (bounded_stack.pop() != common::IS_EMPTY)
        deadly_error(WHERE, "main", "bounded pop failure");
    }

    {
#ifdef DEBUG_STACK
      LOG("testing the unbounded stack now:");
#endif
      for (int j = 0; j < 24; j++) {
        istring line(istring::SPRINTF, "{posn %d here}", j);
        CHECK_STACK_RESULT(unlimited_stack.push(generate_flat(line.s())), "unbound push");
      }
#ifdef DEBUG_STACK
      LOG("unbounded stack in element order:");
#endif
      for (int k = 0; k < unlimited_stack.size(); k++) {
#ifdef DEBUG_STACK
        LOG(istring(istring::SPRINTF, "#%d is %s", k, unlimited_stack[k].observe()));
#endif
      }
#ifdef DEBUG_STACK
      LOG("now popping fresh order:");
#endif
      while (unlimited_stack.size()) {
#ifdef DEBUG_STACK
        LOG(istring(istring::SPRINTF, "size %d, content %s",
            unlimited_stack.size(), unlimited_stack.top().observe()));
#endif
        unlimited_stack.pop();
      }
#ifdef DEBUG_STACK
      LOG("");
#endif
      if (unlimited_stack.pop() != common::IS_EMPTY)
        deadly_error(WHERE, "main", "pop did not return empty as expected");
#ifdef DEBUG_STACK
      LOG("\
----------------------------------------------\n\
both types of stack exercises were successful.\n\
----------------------------------------------");
#endif
    }

#ifdef DEBUG_STACK
    LOG("now setting up some simple stacks...");
#endif

    {
#ifdef DEBUG_STACK
      LOG("bounded first...");
#endif
      stack<byte_array > bounder(randomizer.inclusive(30, 80));
#ifdef DEBUG_STACK
      LOG(istring(istring::SPRINTF, "length of bounder is max %d, curr %d", bounder.elements(), bounder.size()));
#endif
      int max = bounder.elements();
      for (int i = 0; i < max; i++) {
        if (bounder.size() != i)
          deadly_error(WHERE, "bounder size", "out of step with loop");
        int byte_array_size = randomizer.inclusive(259, 287);
        byte_array to_stuff(byte_array_size);
        istring visible(istring::SPRINTF, "entry %d...", i);
        visible.stuff((char *)to_stuff.access(), visible.length() + 1);
        for (int j = visible.length() + 1; j < to_stuff.length(); j++)
          *(to_stuff.access() + j) = '\0';
#ifdef DEBUG_STACK
        LOG(istring(istring::SPRINTF, "pushing index %d", i));
#endif
        outcome ret = bounder.push(to_stuff);
        if (ret != common::OKAY)
          deadly_error(WHERE, "pushing",
              isprintf("%d failure in simple test", ret.value()));
      }
      if (bounder.elements() != bounder.size())
        deadly_error(WHERE, "bounder set", "size and max disagree");
#ifdef DEBUG_STACK
      LOG("inverting:");
#endif
      bounder.invert();
#ifdef DEBUG_STACK
      LOG(istring(istring::SPRINTF, "inverted is:\n%s", text_form(bounder).s()));
#endif
      while (bounder.size()) bounder.pop();
    }
  }
}

void test_stack_with_pointers()
{
  for (int qq = 0; qq < test_iterations; qq++) {
#ifdef DEBUG_STACK
    LOG(istring(istring::SPRINTF, "index %d", qq));
#endif
    stack<byte_array *> bounded_stack(3);
    stack<byte_array *> unlimited_stack(0);
    chaos randomizer;

    {
#ifdef DEBUG_STACK
      LOG("testing the bounded stack first:");
#endif
      CHECK_STACK_RESULT(bounded_stack.push(generate_deep("the first line")), "first push");
      CHECK_STACK_RESULT(bounded_stack.push(generate_deep("the second line")), "second push");
      CHECK_STACK_RESULT(bounded_stack.push(generate_deep("the final and third")), "third push");
      byte_array *gend = generate_deep("this shouldn't work");
      if (bounded_stack.push(gend) != common::IS_FULL)
        deadly_error(WHERE, "main", "the bounded stack push didn't catch IS_FULL");
      delete gend;
#ifdef DEBUG_STACK
      LOG("pushing worked successfully...");
      LOG("printing the stack in element order");
#endif
      for (int i = 0; i < bounded_stack.size(); i++) {
#ifdef DEBUG_STACK
        LOG(istring(istring::SPRINTF, "depth %d has: %s", i, bounded_stack[i]->observe()));
#endif
      }
#ifdef DEBUG_STACK
      LOG("now popping the stack all the way back.");
#endif
      int full_size = bounded_stack.size();
      for (int j = 0; j < full_size; j++) {
#ifdef DEBUG_STACK
        LOG(istring(istring::SPRINTF, "pop %d, stack size is %d, has %s", j+1, bounded_stack.size(), bounded_stack.top()->observe()));
#endif
        byte_array *found;
        bounded_stack.acquire_pop(found);
        if (!found) deadly_error(WHERE, "acquire_pop test", "nil returned");
        if (!found->observe())
          deadly_error(WHERE, "acquire_pop test", "observe is nil");
        istring got((char *)found->observe());
        switch (j) {
        case 0: if (got != istring("the final and third"))
          deadly_error(WHERE, "acquire_top", "wrong contents at 2"); break;
        case 1: if (got != istring("the second line"))
          deadly_error(WHERE, "acquire_top", "wrong contents at 1"); break;
        case 2: if (got != istring("the first line"))
          deadly_error(WHERE, "acquire_top", "wrong contents at 0"); break;
        }
        delete found;
      }
      if (bounded_stack.pop() != common::IS_EMPTY)
        deadly_error(WHERE, "main", "bounded pop failure");
    }

    {
#ifdef DEBUG_STACK
      LOG("testing the unbounded stack now:");
#endif
      for (int j = 0; j < 24; j++) {
        istring line(istring::SPRINTF, "{posn %d here}", j);
        CHECK_STACK_RESULT(unlimited_stack.push(generate_deep(line.s())), "unbound push");
      }
#ifdef DEBUG_STACK
      LOG("unbounded stack in element order:");
#endif
      for (int k = 0; k < unlimited_stack.size(); k++) {
#ifdef DEBUG_STACK
        LOG(istring(istring::SPRINTF, "#%d is %s", k, unlimited_stack[k]->observe()));
#endif
      }
#ifdef DEBUG_STACK
      LOG("\nnow popping order:");
#endif
      while (unlimited_stack.size()) {
#ifdef DEBUG_STACK
        LOG(istring(istring::SPRINTF, "size %d, content %s", unlimited_stack.size(), unlimited_stack.top()->observe()));
#endif
        byte_array *to_zap = unlimited_stack.top();
        unlimited_stack.pop();
        delete to_zap;
          // okay because the pointer was copied, and the reference from top
          // is not being relied on.
      }
#ifdef DEBUG_STACK
      LOG("");
#endif
      if (unlimited_stack.pop() != common::IS_EMPTY)
        deadly_error(WHERE, "main", "pop did not return empty as expected");
#ifdef DEBUG_STACK
      LOG("\n\
----------------------------------------------\n\
both types of stack exercises were successful.\n\
----------------------------------------------");
#endif
    }

#ifdef DEBUG_STACK
    LOG("now setting up some simple stacks...");
#endif

    {
#ifdef DEBUG_STACK
      LOG("bounded first...");
#endif
      stack<byte_array *> bounder(randomizer.inclusive(30, 80));
#ifdef DEBUG_STACK
      LOG(istring(istring::SPRINTF, "length of bounder is max %d, curr %d",
          bounder.elements(), bounder.size()));
#endif
      int max = bounder.elements();
      for (int i = 0; i < max; i++) {
        if (bounder.size() != i)
          deadly_error(WHERE, "bounder size", "out of step with loop");
        int byte_array_size = randomizer.inclusive(259, 287);
        byte_array *to_stuff = new byte_array(byte_array(byte_array_size));
        istring visible(istring::SPRINTF, "entry %d...", i);
        visible.stuff((char *)to_stuff->observe(), visible.length() + 1);
        for (int j = visible.length() + 1; j < to_stuff->length(); j++)
          *(to_stuff->access() + j) = '\0';
        if (bounder.push(to_stuff) != common::OKAY)
          deadly_error(WHERE, "pushing", "failure in simple test");
      }
      if (bounder.elements() != bounder.size())
        deadly_error(WHERE, "bounder set", "size and max disagree");
#ifdef DEBUG_STACK
      LOG("inverting:");
#endif
      bounder.invert();
#ifdef DEBUG_STACK
      LOG(istring(istring::SPRINTF, "inverted is:\n%s", text_form(bounder).s()));
#endif
      while (bounder.size()) {
        byte_array *to_zap = bounder.top();
        bounder.pop();
        delete to_zap;
      }
    }
  }
}

int main(int formal(argc), char *formal(argv)[])
{
  test_stack_with_objects();
  test_stack_with_pointers();
  guards::alert_message("stack:: works for those functions tested.");
  return 0;
}

---