t_spanmn.cpp

Go to the documentation of this file.

/*****************************************************************************\
*                                                                             *
*  Name   : test_span_manager                                                 *
*  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                               *
\*****************************************************************************/

#include <basis/array.h>
#include <basis/function.h>
#include <basis/guards.h>
#include <data_struct/span_manager.h>
#include <loggers/file_logger.h>
#include <data_struct/static_memory_gremlin.h>

#define DEBUG_SPAN_MANAGER
  // uncomment for noisier output.

#define LOG(to_print) { program_wide_logger().log(to_print); }

HOOPLE_STARTUP_CODE;

#define WHERE __WHERE__.s()

#define MAX_SPANS 8

// INIT_STUFF gets the macros ready for use.
#define INIT_STUFF int_array stuffer;

// STUFF puts two numbers (a span) into the next place in the storage array.
#define STUFF(a, b) \
  if (stuffer.length() / 2 + 1 > MAX_SPANS) deadly_error(WHERE, "STUFF", "too many"); \
  stuffer.concatenate(a); stuffer.concatenate(b);

// SEND updates the span manager with the current state of the storage array and resets the
// counter for the next set of spans.
#define SEND(send_to) \
  send_to.update(stuffer); stuffer.reset(0);

// COMP compares the list of spans at position "i" with a value "to_compare".
#define COMP(to_compare, i) \
  if (to_compare != rec_list[i]) \
    deadly_error(WHERE, "comparison", istring(istring::SPRINTF, \
        "index %d incorrect", i).s())

int main(int formal(argc), char *formal(argv)[])
{
  span_manager fred(452);

  INIT_STUFF;

  // stuffs a bunch of spans into the storage array.
  STUFF(8, 8);
  STUFF(27, 29);
  STUFF(28, 31);
  STUFF(3, 5);
  STUFF(80, 83);
  STUFF(96, 123);
  STUFF(3, 6);
  STUFF(212, 430);
  SEND(fred);
  
  // stuffs the rest few in.
  STUFF(13, 17);
  STUFF(151, 250);
  SEND(fred);

#ifdef DEBUG_SPAN_MANAGER
  LOG(istring(istring::SPRINTF, "received sequence so far is %d",
      fred.received_sequence()));
  LOG("making received list:");
#endif

  int_array rec_list;
  fred.make_received_list(rec_list);

#ifdef DEBUG_SPAN_MANAGER
  LOG(fred.print_received_list());
#endif

  // the loop goes through the list of received spans and sees if they're
  // in the right places.
  for (int i = 0; i < rec_list.length(); i += 2) {
    switch (i) {
    case 0: COMP(3, i); COMP(6, i+1); break;
    case 2: COMP(8, i); COMP(8, i+1); break;
    case 4: COMP(13, i); COMP(17, i+1); break;
    case 6: COMP(27, i); COMP(31, i+1); break;
    case 8: COMP(80, i); COMP(83, i+1); break;
    case 10: COMP(96, i); COMP(123, i+1); break;
    case 12: COMP(151, i); COMP(430, i+1); break;
    }
  }

  if (fred.missing_sequence() != 0)
    deadly_error(WHERE, "missing", "wrong sequence");

  // some more items are stuffed in, including the beginning few.
  STUFF(0, 5);
  STUFF(7, 7);
  STUFF(9, 12);
  SEND(fred);
  if (fred.missing_sequence() != 18)
    deadly_error(WHERE, "missing 2", "wrong sequence");
#ifdef DEBUG_SPAN_MANAGER
  LOG("here are the missing ones now:");
  LOG(fred.print_missing_list());
#endif
  fred.make_missing_list(rec_list);
  // this loop looks into the list of missing places and makes sure they're
  // the right holes.
  for (int j = 0; j < rec_list.length(); j+=2) {
    switch (j) {
      case 0: COMP(18, j); COMP(26, j+1); break;
      case 2: COMP(32, j); COMP(79, j+1); break;
      case 4: COMP(84, j); COMP(95, j+1); break;
      case 6: COMP(124, j); COMP(150, j+1); break;
      case 8: COMP(431, j); COMP(451, j+1); break;
    }
  }

  STUFF(0, 451);
  SEND(fred);
#ifdef DEBUG_SPAN_MANAGER
  LOG("should be filled out now:");
  LOG(fred.print_received_list());
#endif
  if (fred.received_sequence() != 451)
    deadly_error(WHERE, "received sequence", "wrong--should be filled out");
  guards::alert_message("span_manager:: works for those functions tested.");
  return 0;
}

---