t_sequence.cpp

Go to the documentation of this file.

/*****************************************************************************\
*                                                                             *
*  Name   : test_sequence                                                     *
*  Author : Chris Koeritz                                                     *
*                                                                             *
*******************************************************************************
* 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/function.h>
#include <basis/guards.h>
#include <basis/istring.h>
#include <basis/sequence.cpp>
#include <opsystem/application_shell.h>
#include <loggers/console_logger.h>
#include <data_struct/static_memory_gremlin.h>

#include <stdio.h>

//#define DEBUG_SEQUENCE

#define WHERE __WHERE__.s()

const int test_iterations = 100000;

int compnum = 0;

#define LOG(s) EMERGENCY_LOG(program_wide_logger(), s)

// test: reports an error if the condition evaluates to true.
#define test(expr) \
  compnum++; \
  if (expr) { \
    char temp[500]; \
    sprintf(temp, "operator test %d", compnum); \
    deadly_error(WHERE, temp, "failure"); \
    return 1; \
  }


#ifndef EMBEDDED_BUILD
  typedef sequence<char> fake_string;
#else
  #define fake_string sequence<char>
#endif

class test_sequence : public application_shell
{
public:
  test_sequence() : application_shell(class_name()) {}
  IMPLEMENT_CLASS_NAME("test_sequence");
  virtual int execute();
};

const int flags = byte_array::SIMPLE_COPY | byte_array::EXPONE;

int test_sequence::execute()
{
  for (int i = 0; i < test_iterations; i++) {
#ifdef DEBUG_SEQUENCE
    LOG(isprintf("index %d", i));
#endif
    fake_string nil_seq(1, "\0", flags);
    {
      fake_string fred1 = fake_string(int(strlen("hyeargh!")+1), "hyeargh!", flags);
      fake_string fred2 = fake_string(int(strlen("matey.")+1), "matey.", flags);
      fake_string fred3 = fake_string(0, NIL, flags);
      fake_string fred4 = fake_string(fred1);
      fake_string fred5 = fake_string(fred2);

      fred3 = fred1.subarray(0, fred1.length() - 2);
      fred3.concatenate(fred2);
      fred4.put(2, 'u');
      fred4.put(3, 'r');
      fred5.reset(int(strlen("a leather hell.")+1), "a leather hell.");

#ifdef DEBUG_SEQUENCE
      LOG(istring("[ ") + fred1 + " & " + fred2 + "] -> " + fred3);
      LOG("to first debug block.");
#endif

      // do not blame me for this stupid test: one compiler (saber) complains
      // that "temporary in || that needs destructor is not implemented"....
      int die = false;
      if (fred1 != fake_string(int(strlen("hyeargh!")+1), "hyeargh!", flags))
        die++;
      if (fred2 != fake_string(int(strlen("matey.")+1), "matey.", flags))
        die++;
      if (fred3 != fake_string(int(strlen("hyeargh!matey.")+1),
          "hyeargh!matey.", flags))
        die++;
      if (fred4 != fake_string(int(strlen("hyurrgh!")+1), "hyurrgh!", flags))
        die++;
      if (fred5 != fake_string(int(strlen("a leather hell.")+1),
          "a leather hell.", flags))
        die++;
      if ( (fred5[2] != 'l') || (fred5[5] != 't') ) die++;
      if (die) deadly_error(WHERE, "first test group", "failure in comparison");
    }
    {
      fake_string *fred1 = new fake_string
        (int(strlen("flipper ate") + 1), "flipper ate", flags);
      fake_string *fred2 = new fake_string
        (int(strlen(" my sandwich.")+1), " my sandwich.", flags);
      fake_string *fred3 = new fake_string(0, NIL, flags);
      fred3->operator = (fred1->subarray(0, fred1->length() - 2));
      fred3->concatenate(*fred2);

#ifdef DEBUG_SEQUENCE
      LOG(istring("[ ") + *fred1 + " & " + *fred2 + "] -> " + *fred3);
#endif

      int die = false;
      if (*fred1 != fake_string(int(strlen("flipper ate")+1),
          "flipper ate", flags))
        die++;
      if (*fred2 != fake_string(int(strlen(" my sandwich.")+1),
          " my sandwich.", flags))
        die++;
      if (*fred3 != fake_string(int(strlen("flipper ate my sandwich.")+1),
          "flipper ate my sandwich.", flags))
        die++;
      if (die)
        deadly_error(WHERE, "second test group", "failure in comparison");
      delete fred1;
      delete fred2;
      delete fred3;
    }

    {
      fake_string fleermipe = fake_string(int(strlen("hello my frobious.")+1),
          "hello my frobious.", flags);
      fleermipe.zap(0, fleermipe.length() - 1);
      if (fleermipe.length() != 0)
        deadly_error(WHERE, "third test group",
            "length not 0 after deleting entire sequence");
    }

    {
      fake_string test_sequence = fake_string(int(strlen("this test "
          "sequence will be chopped up.")+1),
          "this test sequence will be chopped up.", flags);

#ifdef DEBUG_SEQUENCE
      LOG(istring("original is: ") + test_sequence);
#endif

      fake_string fred = fake_string(test_sequence);
      int found = 0;
      outcome outcome;
      fred.zap(0, fred.find('w', found, outcome));
#ifdef DEBUG_SEQUENCE
      LOG(istring("now, the one chopped through 'w' is: ") + fred);
#endif

      if (fred != fake_string(int(strlen("ill be chopped up.")+1),
          "ill be chopped up.", flags))
        deadly_error(WHERE, "fourth test group", "first zap failed");

      fake_string blorg = fake_string(test_sequence);
      int pos = 0;
      blorg.zap(blorg.find('p', pos, outcome), blorg.length() - 2);
#ifdef DEBUG_SEQUENCE
      LOG(istring("now the one chopped from p to the end: ") + blorg);
#endif

      if (blorg != fake_string(int(strlen("this test sequence will be cho")+1),
          "this test sequence will be cho", flags))
        deadly_error(WHERE, "fourth test group", "second zap failed");

      fake_string fleen = fake_string(0, NIL, flags);
      fleen.concatenate(test_sequence);
      fleen.zap(7, 14);
#ifdef DEBUG_SEQUENCE
      LOG(istring("now the one with 7 through 14 missing: ") + fleen);
#endif

      if (fleen != fake_string(int(strlen("this tence will be chopped up.")+1),
          "this tence will be chopped up.", flags))
        deadly_error(WHERE, "fourth test group", "third zap failed");

#ifdef DEBUG_SEQUENCE
      LOG(istring("original sequence is now: ") + test_sequence);
#endif
      if (test_sequence != fake_string(int(
          strlen("this test sequence will be chopped up.")+1),
         "this test sequence will be chopped up.", flags))
        deadly_error(WHERE, "fourth test group", "original sequence was changed");
    }

    {
#ifdef DEBUG_SEQUENCE
      LOG("about to test weird things:");
#endif
      fake_string frieda = fake_string(int(strlen("glorp")+1), "glorp", flags);
      fake_string jorb = fake_string(frieda);
      fake_string *kleeg = new fake_string(jorb);
      fake_string plok = frieda;
      test(frieda != jorb);
      test(jorb != *kleeg);
      test(*kleeg != plok);
      test(plok != frieda);
      fake_string glorp = fake_string(int(strlen("glorp")+1), "glorp", flags);
      test(frieda != glorp);
      delete kleeg;

#ifdef DEBUG_SEQUENCE
      LOG("sequences matched up okay.");
#endif
    }

    {
      fake_string bungee = fake_string(0, NIL, flags);
      bungee.concatenate(fake_string(int(strlen("this sequence")),
          "this sequence", flags));
      bungee.concatenate(fake_string(
        int(strlen(" has been constructed gradually")),
        " has been constructed gradually"));
      fake_string blorpun = fake_string(int(strlen(" out of sever")), " out of sever", flags);
      bungee.concatenate(blorpun);
      fake_string signow = fake_string(1, "a", flags);
      bungee.concatenate(signow);
      bungee.concatenate('l');
      bungee.concatenate(fake_string(int(strlen(" different bits,\nincluding")),
        " different bits,\nincluding", flags));
      bungee = bungee.concatenation(fake_string
        (int(strlen(" arrrrooooo")), " arrrrooooo", flags));
      bungee.concatenate(fake_string
        (int(strlen(" radians away.")), " radians away.", flags));
      bungee.concatenate(fake_string(int(strlen("\nhow does it look?\n")+1),
        "\nhow does it look?\n", flags));
#ifdef DEBUG_SEQUENCE
      LOG(bungee);
#endif

      if (bungee != fake_string(int(strlen("this \
sequence has been constructed gradually out of several \
different bits,\nincluding arrrrooooo radians away.\nhow \
does it look?\n")+1), "this sequence has been constructed \
gradually out of several different bits,\
\nincluding arrrrooooo radians away.\nhow does it look?\n", flags))
        deadly_error(WHERE, "sixth test group", "constructed sequence is wrong");
    }

    {
      fake_string a = fake_string(int(strlen("axes")+1), "axes", flags);
      fake_string b = fake_string(int(strlen("bakesales")+1), "bakesales", flags);
      fake_string x = fake_string(int(strlen("xylophone")+1), "xylophone", flags);

      test(a >= x);
      test(a == b);
      test(a > b);
      test(b >= x);
      test(x <= a);
      test(x != x);
      test(a != a);
#ifdef DEBUG_SEQUENCE
      LOG("comparisons worked");
#endif
    }

    {
#ifdef DEBUG_SEQUENCE
      LOG("now testing concatenation operator");
#endif
      fake_string a = fake_string(int(strlen("fred")), "fred", flags);
      fake_string b = fake_string(int(strlen(" is")), " is", flags);
      fake_string c = fake_string(int(strlen(" his")), " his", flags);
      fake_string d = fake_string(int(strlen(" name.")), " name.", flags);
      fake_string e = fake_string(0, NIL, flags);
      e = a.concatenation(b.concatenation(c.concatenation(d)));
      e.concatenate(nil_seq);
#ifdef DEBUG_SEQUENCE
      LOG(istring("result is: ") + e);
#endif
      fake_string f = fake_string(0, NIL, flags);
      f.concatenate(d.concatenation(c.concatenation(b.concatenation(a))));
      f.concatenate(nil_seq);
#ifdef DEBUG_SEQUENCE
      LOG(istring("reverse is: ") + f);
#endif
      fake_string g = fake_string(0, NIL, flags);
      g.concatenate(a.concatenation(c.concatenation(d.concatenation(b))));
      g.concatenate(nil_seq);
#ifdef DEBUG_SEQUENCE
      LOG(istring("tibetan style is: ") + g);
#endif
      int die = false;
      if (e != fake_string(int(strlen("fred is his name.")+1),
          "fred is his name.", flags))
        die++;
      if (f != fake_string(int(strlen(" name. his isfred")+1),
          " name. his isfred", flags))
        die++;
      if (g != fake_string(int(strlen("fred his name. is")+1),
          "fred his name. is", flags))
        die++;
      if (die) deadly_error(WHERE, "eighth test group", "sequence looks wrong");
    }

    {
      fake_string bleer = fake_string(int(strlen("urghla burgla #23\n")+1),
          "urghla burgla #23\n", flags);
      for (int i = 0; i < bleer.length()-2; i++) {
        fake_string temp = fake_string(bleer.subarray(0, i));
        fake_string holder = fake_string(i + 1, NIL, flags);
        holder.overwrite(0, temp);
        holder.concatenate(nil_seq);
#ifdef DEBUG_SEQUENCE
        LOG(isprintf("[%d] has ", i) + holder);
#endif
        fake_string my_copy = fake_string(bleer);
        my_copy.zap(i+1, my_copy.length() - 2);
        if (my_copy != holder)
          deadly_error(WHERE, "ninth test group", "inaccurate stuff");
      }
    }
    {
#ifdef DEBUG_SEQUENCE
      LOG("The tenth ones:");
#endif
      fake_string george = fake_string(int(strlen("this one will be mangled.")+1),
          "this one will be mangled.", flags);
      fake_string tmp1 = fake_string(george.subarray(1, 7));  // constructor.
      fake_string tmp2 = george.subarray(10, george.length() - 1);  // constructor.
      if (tmp1 == tmp2)
        deadly_error(WHERE, "tenth compare", "bizarre equality occurred!!");
      if ( (tmp1 > tmp2) || (tmp2 < tmp1) )
        deadly_error(WHERE, "tenth compare", "bizarre comparison error.");
#ifdef DEBUG_SEQUENCE
      LOG(istring(fake_string(george.subarray(1, 7))) + "... "
           + fake_string(george.subarray(10, george.length() - 1)));
#endif
      int place_to_stuff = george.length() - 1;
      george.insert(place_to_stuff, int(strlen("terribly ")));
      george.overwrite(place_to_stuff,
          fake_string(int(strlen("terribly ")), "terribly ", flags));
#ifdef DEBUG_SEQUENCE
      LOG(george);
#endif

      fake_string fred = fake_string(george);
      george.zap(place_to_stuff - 7, place_to_stuff);
#ifdef DEBUG_SEQUENCE
      LOG(george);
#endif

      fake_string fred_part = fake_string(0, NIL, flags);
      fred_part = fred.subarray(0, 13);
#ifdef DEBUG_SEQUENCE
      LOG(fred_part);
#endif
      fred_part = fred.subarray(13, fred.length() - 1);
#ifdef DEBUG_SEQUENCE
      LOG(fred_part);
      LOG("compares okay");
#endif
    }
    {
      // 11th test:
      char junk[20];
      fake_string glob = fake_string(int(strlen("too long to all fit in junk")),
        "too long to all fit in junk", flags);
      glob.stuff(19, junk);
      junk[19] = '\0';
      if (strcmp(junk, "too long to all fit"))
        deadly_error(WHERE, "stuff test group", "failure in comparison");
    }
    {
// turned off until array with limits is working.
#if 0
      // 12th test:
      const char *test1 = "this is a test string that will be too long";
      fake_string limitted = fake_string(int(strlen(test1)+1), test1, flags);
      fake_string lim_copy = fake_string(limitted);
      lim_copy.limit(1000);
      if (lim_copy != limitted)
        deadly_error(WHERE, "limit test group", "failure in simple comparison");
      lim_copy.limit(12);
      lim_copy += nil_seq;
guards::alert_message(istring("limitted guy is now: %s", lim_copy.observe()).s());
      fake_string new_val = fake_string(int(strlen("this is a te") + 1), "this is a te", flags);
      if (lim_copy != new_val)
        deadly_error(WHERE, "limit test group", "failure in limitted comparison");
      lim_copy.limit(35);
      for (int j = 0; j < 20; j++) {
        lim_copy += fake_string(int(strlen("extra stuff") + 1), "extra stuff", flags);
        if (lim_copy.length() > 35)
          deadly_error(WHERE, "limit test group", "failure to keep under limit");
      }
      if (lim_copy.length() != 35)
        deadly_error(WHERE, "limit test group", "final limit check");
#endif
    }
    {
// test 13 is now open for business.  the prior test has been tossed.
      // 13th test: unknown?
    }
  }  // end of test iterations..
  fake_string to_print = fake_string(int(strlen("sequence:: works for those functions tested.")+1),
     "sequence:: works for those functions tested.", flags);
  guards::alert_message(to_print.observe());
  return 0;
}

HOOPLE_MAIN(test_sequence, )

---