t_bitvec.cpp

Go to the documentation of this file.

/*****************************************************************************\
*                                                                             *
*  Name   : test_bit_vector                                                   *
*  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.cpp>
#include <basis/byte_array.h>
#include <basis/chaos.h>
#include <basis/function.h>
#include <basis/guards.h>
#include <basis/istring.h>
#include <data_struct/bit_vector.h>
#include <data_struct/static_memory_gremlin.h>

#include <stdlib.h>

HOOPLE_STARTUP_CODE;

#define WHERE __WHERE__.s()

#define MAX_TEST 100
#define FOOP_MAX 213

struct test_struct { u_int store; int posn; int size; };

int main(int formal(argc), char *formal(argv)[])
{
  const array<test_struct> unused;

  chaos randomizer;
  bit_vector foop(FOOP_MAX);

  for (int i = 0; i < MAX_TEST; i++) {
    // sets a random bit and finds that one.
    int rando = randomizer.inclusive(0, FOOP_MAX-1);
    foop.light(rando);
    int found = foop.find_first(true);
    if (found != rando)
      deadly_error(WHERE, "main", "find first did not work");
    foop.clear(rando);

    foop.resize(FOOP_MAX);
    if ( (foop.find_first(0) != 0)
        || (foop.find_first(1) != common::NOT_FOUND) )
      deadly_error(WHERE, "main", "find first on cleared didn't work");
    for (int i = 0; i < 12; i++) foop.light(i);
    if (foop.find_first(0) != 12)
      deadly_error(WHERE, "main", "on partial set, find_first didn't work");

    foop.light(FOOP_MAX);  // shouldn't work, but shouldn't die.
    if (foop.on(FOOP_MAX))
      deadly_error(WHERE, "main", "bit_on is lit past end of vector");

    // sets a bunch of random bits.
    for (int j = 0; j < 40; j++) {
      int rando = randomizer.inclusive(0, FOOP_MAX-1);
      foop.light(rando);
    }
    bit_vector foop2(FOOP_MAX, ((const byte_array &)foop).observe());
    if (foop != foop2)
      deadly_error(WHERE, "main", "vectors are not identical");

    {
      // this block tests the subvector and int storage/retrieval routines.
      if (foop.bits() < 90) foop.resize(90);  // make sure we have room to play.

      array<test_struct> tests;
      test_struct t1 = { 27, 15, 5 };
      tests += t1;
      test_struct t2 = { 8, 25, 4 };
      tests += t2;
      test_struct t3 = { 1485, 34, 16 };
      tests += t3;
      test_struct t4 = { 872465, 50, 32 };
      tests += t4;

      for (int i = 0; i < tests.length(); i++) {
// should print out which int and posn failed.
        if (!foop.set(tests[i].posn, tests[i].size, tests[i].store))
          deadly_error(WHERE, "main", "storing int in vector failed");
//        bit_vector found = foop.subvector(tests[i].posn, tests[i].posn+tests[i].size-1);
//        LOG(istring(istring::SPRINTF, "contents found:\n%s", found.text_form().s()));
        u_int to_check = foop.get(tests[i].posn, tests[i].size);
        if (to_check != tests[i].store)
          deadly_error(WHERE, "main", istring(istring::SPRINTF, "int found in "
              "vector (%u) is different than what was stored (%u).",
              to_check, tests[i].store).s());
      }
    }

    {
      // tests random resizings and resettings.
      int number_of_loops = randomizer.inclusive(50, 150);
      for (int i = 0; i < number_of_loops; i++) {
        int which_to_do = randomizer.inclusive(1, 3);
        switch (which_to_do) {
          case 1: {
            // resize.
            int new_size = randomizer.inclusive(0, 32000);
            foop.resize(new_size);
            break;
          }
          case 2: {
            // reset.
            int new_size = randomizer.inclusive(0, 32000);
            foop.reset(new_size);
            break;
          }
          case 3: {
            // random sets.
            int sets_to_do = randomizer.inclusive(40, 280);
            for (int i = 0; i < sets_to_do; i++) {
              int rando = randomizer.inclusive(0, foop.bits());
              if (randomizer.inclusive(0, 1)) foop.light(rando);
              else foop.clear(rando);
            }
            break;
          }
        }
      }
    }

    foop.reset(FOOP_MAX);  // to clear before next loop.
  }
  guards::alert_message("bit_vector:: works for those functions tested.");
  return 0;
}

---