t_string.cpp

Go to the documentation of this file.

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

#ifndef EMBEDDED_BUILD
  #include "t_basis.rh"
#endif

//#define DEBUG_STRING
  // set this to enable debugging features of the string class.

#include <basis/chaos.h>
#include <basis/earth_time.h>
#include <basis/function.h>
#include <basis/guards.h>
#include <basis/istring.h>
#include <basis/sequence.h>
#include <basis/string_array.h>
#include <data_struct/static_memory_gremlin.h>
#include <mechanisms/time_stamp.h>
#include <loggers/file_logger.h>
#include <data_struct/static_memory_gremlin.h>
#include <textual/byte_format.h>
#include <textual/string_convert.h>
#include <textual/string_manipulation.h>

#ifdef __WIN32__
  #include <comdef.h>
#endif
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

HOOPLE_STARTUP_CODE;

using namespace earth_time;

chaos rando;

//#define DEBUG_STRING_TEST
  // uncomment for testing version.

#define out program_wide_logger()
#define static_class_name() "t_istring"

const float TEST_RUNTIME_DEFAULT = .5 * MINUTE_ms;
  // the test, by default, will run for this long.

#define WHERE __WHERE__.s()

//hmmm: this is really awful.  get a better macro...
// test: reports an error if the condition evaluates to true.
int compnum = 0;
#define test(expr) \
  compnum++; \
  if (expr) { \
    istring fred(istring::SPRINTF, "operator test %d did not work", ++compnum); \
    deadly_error(WHERE, func, fred.observe()); \
  }

static istring staticity_test("yo!");
  // used below to check whether static strings are looking right.

void run_test_01()
{
  FUNCDEF("run_test_01");

  const int TEST_EMPTY = 10000000;
  time_stamp started;
  for (int i = 0; i < TEST_EMPTY; i++) {
    istring glob = istring::empty_string();
  }
  int duration = int(time_stamp().value() - started.value());
  out.log(isprintf("duration of empty string test=%d ms", duration));

  // test simple string operations, like construction, length, equality.
  istring fred1("hyeargh!");
  istring fred2("matey.");
  istring fred3;
  fred3 = fred1;
  fred3 += fred2;
  istring fred4(fred2);

  if (fred1.length() != int(strlen(fred1.s())))
    deadly_error(WHERE, func, "length is incorrect (a).");
  if (fred2.length() != int(strlen(fred2.s())))
    deadly_error(WHERE, func, "length is incorrect (b).");
  if (fred3.length() != int(strlen(fred3.s())))
    deadly_error(WHERE, func, "length is incorrect (c).");
  if (fred4.length() != int(strlen(fred4.s())))
    deadly_error(WHERE, func, "length is incorrect (d).");

#ifdef DEBUG_STRING_TEST
  out.log("[ " + fred1 + " & " + fred2 + "] -> " + fred3);
#endif

  if (fred1 != istring("hyeargh!")) 
    deadly_error(WHERE, func, "failure in comparison (a).");
  if (fred2 != istring("matey."))
    deadly_error(WHERE, func, "failure in comparison (b).");
  if (fred3 != istring("hyeargh!matey."))
    deadly_error(WHERE, func, "failure in comparison (c).");
  if (fred4 != istring("matey."))
    deadly_error(WHERE, func, "failure in comparison (d-1).");
  if (fred4 != fred2)
    deadly_error(WHERE, func, "failure in comparison (d-2).");

  isprintf nullo;
  if ( (nullo != istring()) || (istring() != nullo) )
    deadly_error(WHERE, func, "blank isprintf isn't blank.");
  if ( (nullo != istring::empty_string())
      || (istring::empty_string() != nullo) )
    deadly_error(WHERE, func, "blank isprintf isn't empty.");

}

void run_test_02()
{
  FUNCDEF("run_test_02");
  // assorted tests involving strings as pointers.
  istring *fred1 = new istring("flipper ate");
  istring *fred2 = new istring(" my sandwich.");
  istring *fred3 = new istring;
  *fred3 = *fred1;
  *fred3 += *fred2;

  // testing adding a null to a string.
  *fred2 += (char *)NIL;
  *fred3 += (char *)NIL;

#ifdef DEBUG_STRING_TEST
  out.log(istring("[ ") + *fred1 + " & " + *fred2 + "] -> " + *fred3);
#endif

  int die = false;
  if (*fred1 != istring("flipper ate")) die++;
  if (*fred2 != istring(" my sandwich.")) die++;
  if (*fred3 != istring("flipper ate my sandwich.")) die++;
  if (die) deadly_error(WHERE, func, "failure in comparison");
  delete fred1;
  delete fred2;
  delete fred3;
}

void run_test_03()
{
  FUNCDEF("run_test_03");
  // tests some things about zap.
  istring fleermipe("hello my frobious.");
  fleermipe.zap(0, fleermipe.length() - 1);
  if (fleermipe.length() != 0)
    deadly_error(WHERE, func, "length not 0 after deleting entire istring");
}

void run_test_04()
{
  FUNCDEF("run_test_04");
  istring test_string("this test string will be chopped up.");
#ifdef DEBUG_STRING_TEST
  out.log(istring("original is: ") + test_string);
#endif
  istring fred(test_string.s());
  fred.zap(0, fred.find('w'));

#ifdef DEBUG_STRING_TEST
  out.log(istring("now, the one chopped through 'w' is: ") + fred);
#endif

  if (fred != istring("ill be chopped up."))
    deadly_error(WHERE, func, "first zap failed");

  istring blorg(test_string);
  blorg.zap(blorg.find('p'), blorg.length() - 1);
#ifdef DEBUG_STRING_TEST
  out.log(istring("now the one chopped from p to the end: ") + blorg);
#endif

  if (blorg != istring("this test string will be cho"))
    deadly_error(WHERE, func, "second zap failed");

  istring fleen;
  fleen += test_string;
  fleen.zap(7, 14);
#ifdef DEBUG_STRING_TEST
  out.log(istring("now the one with 7 through 14 missing: ") + fleen);
#endif

  if (fleen != istring("this teg will be chopped up."))
    deadly_error(WHERE, func, "third zap failed");

#ifdef DEBUG_STRING_TEST
  out.log(istring("original istring is now: ") + test_string);
#endif
  if (test_string != istring("this test string will be chopped up."))
    deadly_error(WHERE, func, "original istring was changed");
}

void run_test_05()
{
  FUNCDEF("run_test_05");
#ifdef DEBUG_STRING_TEST
  out.log("about to test weird things:");
#endif
  istring frieda("glorp");
  istring jorb(frieda);
  istring *kleeg = new istring(jorb.s());
  istring plok = frieda;
  test(frieda != jorb);
  test(jorb != *kleeg);
  test(*kleeg != plok);
  test(plok != frieda);
  istring glorp("glorp");
  test(frieda != glorp);

  WHACK(kleeg);

#ifdef DEBUG_STRING_TEST
  out.log("strings matched up okay.");
#endif

  // test new features sprintf is relying upon.
  istring bubba("gumpternations");
  bubba += "_02193";
#ifdef DEBUG_STRING_TEST
  out.log(istring("bubba = ") + bubba);
#endif
  if (bubba != istring("gumpternations_02193"))
    deadly_error(WHERE, func, "+= on char pointer failed.");

  istring bubelah("laksos");
  bubelah += '3';
  bubelah += '8';
  bubelah += '2';
#ifdef DEBUG_STRING_TEST
  out.log(istring("bubelah = ") + bubelah);
#endif
  if (bubelah != istring("laksos382"))
    deadly_error(WHERE, func, "+= on char failed.");

  istring simple_spr0(istring::SPRINTF, "%% yoga splorch %%");
#ifdef DEBUG_STRING_TEST
  out.log(istring("simple sprintf 0 = ") + simple_spr0);
#endif
  if (simple_spr0 != istring("% yoga splorch %"))
    deadly_error(WHERE, func, "simple sprintf 0 is wrong");
  istring simple_spr1(istring::SPRINTF, "%d", 23);
#ifdef DEBUG_STRING_TEST
  out.log(istring("simple sprintf 1 = ") + simple_spr1);
#endif
  if (simple_spr1 != istring("23"))
    deadly_error(WHERE, func, "simple sprintf 1 is wrong");
  istring simple_spr2(istring::SPRINTF, "%s", "yoyo");
#ifdef DEBUG_STRING_TEST
  out.log(istring("simple sprintf 2 = ") + simple_spr2);
#endif
  if (simple_spr2 != istring("yoyo"))
    deadly_error(WHERE, func, "simple sprintf 2 is wrong");

  istring sprintest(istring::SPRINTF, "%s has got me up the %s some %d "
     "times, in %p with %d and %lu.", "marge", "ladder", 32, &kleeg,
     812377487L, 213123123L);
  istring sprintest2;
  sprintest2.reset(istring::SPRINTF, "%s has got me up the %s some %d "
     "times, in %p with %d and %lu.", "marge", "ladder", 32, &kleeg,
     812377487L, 213123123L);
  istring addr(istring::SPRINTF, "%p", &kleeg);
#ifdef DEBUG_STRING_TEST
  out.log("here is your istring sir...");
  out.log(sprintest);
  out.log("and addr we will see is...");
  out.log(addr);
#endif
  if (sprintest != istring(istring::SPRINTF, "marge has got me up the "
      "ladder some 32 times, in %s with 812377487 and 213123123.", addr.s()))
    deadly_error(WHERE, func, "constructed istring is wrong");
  if (sprintest2 != istring(istring::SPRINTF, "marge has got me up the "
      "ladder some 32 times, in %s with 812377487 and 213123123.", addr.s()))
    deadly_error(WHERE, func, "reset istring is wrong");
}

void run_test_06()
{
  FUNCDEF("run_test_06");
  istring bungee;
  bungee += "this istring";
  bungee += " has been constructed gradua";
  bungee += 'l';
  bungee += 'l';
  bungee += 'y';
  istring blorpun(istring::SPRINTF, " out of severa%c", 'l');
  bungee += blorpun;
  bungee += " different bits,\nincluding";
  istring freeple(istring::SPRINTF, "%s constructed %s blarg from %f ", " this", "silly", 3.14159265358);
  bungee += freeple;
  bungee += "radians awa";
  bungee += 'y';
  bungee += '.';
  bungee += "\nhow does it look?\n";
#ifdef DEBUG_STRING_TEST
  out.log(bungee);
#endif

//MessageBox(0, bungee.s(), "yo, got this", MB_ICONINFORMATION | MB_OK);
  if (bungee != istring("this istring has been constructed gradually out of several different bits,\nincluding this constructed silly blarg from 3.141593 radians away.\nhow does it look?\n"))
    deadly_error(WHERE, func, "constructed istring is wrong");
}

void run_test_07()
{
  FUNCDEF("run_test_07");
  istring a("axes");
  istring b("bakesales");
  istring x("xylophone");

  test(a >= x);
  test(a == b);
  test(a > b);
  test(b >= x);
  test(x <= a);
  test(x != x);
  test(a != a);
#ifdef DEBUG_STRING_TEST
  out.log("comparisons worked");
#endif
}

void run_test_08()
{
  FUNCDEF("run_test_08");
#ifdef DEBUG_STRING_TEST
  out.log("now testing + operator");
#endif
  istring a("fred");
  istring b(" is");
  istring c(" his");
  istring d(" name.");
  istring e;
  e = a + b + c + d;
#ifdef DEBUG_STRING_TEST
  out.log(istring("result is: ") + e);
#endif
  istring f;
  f = d + c + b + a;
#ifdef DEBUG_STRING_TEST
  out.log(istring("reverse is: ") + f);
#endif
  istring g;
  g = a + c + d + b;
#ifdef DEBUG_STRING_TEST
  out.log(istring("tibetan style is: ") + g);
#endif
  int die = false;
  if (e != istring("fred is his name.")) die++;
  if (f != istring(" name. his isfred")) die++;
  if (g != istring("fred his name. is")) die++;
  if (die) deadly_error(WHERE, func, "istring looks wrong");
}

void run_test_09()
{
  FUNCDEF("run_test_09");
  istring bleer(istring::SPRINTF, "urghla burgla #%d\n", 23);
  char holder[50];
  for (int i = 0; i < bleer.length(); i++) {
    bleer.stuff(holder, i);
#ifdef DEBUG_STRING_TEST
    out.log(istring(istring::SPRINTF, "%d", i) + " has: " + holder);
#endif
    istring my_copy(bleer);
    my_copy.zap(i, bleer.length() - 1);
    if (my_copy != istring(holder))
      deadly_error(WHERE, func, "inaccurate stuff");
  }
}

void run_test_10()
{
  FUNCDEF("run_test_10");
#ifdef DEBUG_STRING_TEST
  out.log("The tenth ones:");
#endif
  istring george("this one will be mangled.");
  if (george.length() != int(strlen(george.s())))
    deadly_error(WHERE, func, "length is incorrect (q).");
  istring tmp1(george.substring(1, 7));  // constructor.
  istring tmp2 = george.substring(10, george.length() - 1);  // constructor.
#ifdef DEBUG_STRING_TEST
  out.log(tmp1 + "... " + tmp2);
#endif
  if (tmp1 == tmp2)
    deadly_error(WHERE, func, "bizarre equality occurred!!");
  if ( (tmp1 > tmp2) || (tmp2 < tmp1) )
    deadly_error(WHERE, func, "bizarre comparison error.");
  if (george.length() != int(strlen(george.s())))
    deadly_error(WHERE, func, "length is incorrect (z).");
#ifdef DEBUG_STRING_TEST
  out.log(george.substring(1, 7));
  out.log("... ");
  out.log(george.substring(10, george.length() - 1));
#endif
  if (george.length() != int(strlen(george.s())))
    deadly_error(WHERE, func, "length is incorrect (a).");
  george.insert(14, "terribly ");
  if (george.length() != int(strlen(george.s())))
    deadly_error(WHERE, func, "length is incorrect (b).");
#ifdef DEBUG_STRING_TEST
  out.log(george);
#endif
  istring chunky;
  istring mssr_boef_la_tet("eeyoy eye eye capn");
  mssr_boef_la_tet.substring(chunky, 2, 7);
  if (chunky != "yoy ey")
    deadly_error(WHERE, func, "contents wrong after substring");

  istring fred(george);
  if (!george.compare(fred, 0, 0, george.length() - 1))
    deadly_error(WHERE, func, "did not work");
  if (!george.compare(fred, 8, 8, george.length() - 1 - 8))
    deadly_error(WHERE, func, "partial did not work");

  if (george.length() != int(strlen(george.s())))
    deadly_error(WHERE, func, "length is incorrect (c).");
  george.zap(14, 22);
#ifdef DEBUG_STRING_TEST
  out.log(george);
#endif
  istring fred_part;
  fred_part = fred.substring(0, 13);
  if (fred_part.length() != int(strlen(fred_part.s())))
    deadly_error(WHERE, func, "length incorrect (d).");
  if (!george.compare(fred_part, 0, 0, 13))
    deadly_error(WHERE, func, "did not work");
  fred_part = fred.substring(23, fred.length() - 1);
  if (fred_part.length() != int(strlen(fred_part.s())))
    deadly_error(WHERE, func, "length incorrect (e).");
  if (!george.compare(fred_part, 14, 0, fred_part.length() - 1))
    deadly_error(WHERE, func, "did not work");
#ifdef DEBUG_STRING_TEST
  out.log("compares okay");
#endif
}

void run_test_11()
{
  FUNCDEF("run_test_11");
  istring empty;
  if (empty.length())
    deadly_error(WHERE, func, "empty string judged not");
  if (! (!empty.length()) )
    deadly_error(WHERE, func, "not on empty string doesn't work");
  istring non_empty("grungee");
  if (!non_empty.length())
    deadly_error(WHERE, func, "non-empty string judged empty");
  if (! (! (!non_empty.length()) ) )
    deadly_error(WHERE, func, "not on non-empty string doesn't work");
}

void run_test_12()
{
  FUNCDEF("run_test_12");
  istring elf0(istring::SPRINTF, "%%_%%_%%");
  if (strcmp(elf0.s(), "%_%_%"))
    deadly_error(WHERE, func, "failed %% printing");

  char fred[6] = { 'h', 'y', 'a', 'r', 'g', '\0' };
  istring fred_copy(istring::UNTERMINATED, fred, 5);
  if (fred_copy.length() != 5)
    deadly_error(WHERE, func, "length of copy is wrong");
  if (fred_copy != istring("hyarg"))
    deadly_error(WHERE, func, "length of copy is wrong");

  char hugh[6] = { 'o', 'y', 'o', 'b', 'o', 'y' };
  istring hugh_copy(istring::UNTERMINATED, hugh, 3);
  if (hugh_copy.length() != 3)
    deadly_error(WHERE, func, "length of copy is wrong");
  if (hugh_copy != istring("oyo"))
    deadly_error(WHERE, func, "length of copy is wrong");

  istring another_copy;
  another_copy.reset(istring::UNTERMINATED, fred, strlen(fred));
  if (another_copy.length() != 5)
    deadly_error(WHERE, func, "length of reset copy is wrong");
  if (another_copy != istring("hyarg"))
    deadly_error(WHERE, func, "length of reset copy is wrong");
}

void run_test_13()
{
  FUNCDEF("run_test_13");
  // check for possible memory leaks in these combined ops....  13th.
  const istring churg("borjh sjh oiweoklj");
  istring pud = churg;
  istring flug = "kase iqk aksjir kljasdo";
  const char *nerf = "ausd qwoeui sof zjh qwei";
  istring snorp = nerf;
  pud = "snugbo";
  snorp = flug;
  istring pundit("murph");
  pundit = nerf;
}

void run_test_14()
{
  FUNCDEF("run_test_14");
  // test the new dynamic sprintf'ing for long strings... 14th.
  const int longish_size = 5000;
  char temp[longish_size];
  for (int i = 0; i < longish_size; i++)
    temp[i] = char(rando.inclusive(1, 255));
  temp[longish_size - 1] = '\0';
  istring longish(istring::SPRINTF, "this is a really darned long string of stuff: %s,\nbut doesn't it look interesting?", temp);
  // still with us?
  longish.zap(longish.length() / 3, 2 * longish.length() / 3);
  longish += longish;
  if (longish.length() != int(strlen(longish.s())))
    deadly_error(WHERE, func, "length is incorrect.");
}

void run_test_15()
{
  FUNCDEF("run_test_15");
  // test the new dynamic sprintf'ing for long strings... 15th.
  int try_1 = 32767;
  istring testy(istring::SPRINTF, "%d", try_1);
  if (testy.convert(95) == 95)
    deadly_error(WHERE, func, "default value returned, so it failed.");
  else if (testy.convert(95) != try_1)
    deadly_error(WHERE, func, "correct value was not returned.");

  long try_2 = 2938754L;
  testy = istring(istring::SPRINTF, "%ld", try_2);
  if (testy.convert(98L) == 98L)
    deadly_error(WHERE, func, "default value returned, so it failed.");
  else if (testy.convert(98L) != try_2)
    deadly_error(WHERE, func, "correct value was not returned.");

  testy = istring(istring::SPRINTF, "%ld", try_2);
  if (testy.convert(98L) == 98L)
    deadly_error(WHERE, func, "default value returned, so it failed.");
  else if (testy.convert(98L) != try_2)
    deadly_error(WHERE, func, "correct value was not returned.");

#ifndef EMBEDDED_BUILD  // until float support added in (blocked out 3/8/96).
  float try_3 = float(2938.754);  // weird msvcpp error if don't cast.
  testy = istring(istring::SPRINTF, "%f", try_3);
  float found = testy.convert(float(98.6));
  if (found == 98.6)
    deadly_error(WHERE, func, "default value returned, so it failed.");
  else if (found != try_3)
    deadly_error(WHERE, func, "correct value was not returned.");

  {
    double try_4 = 25598437.712385;
    testy = istring(istring::SPRINTF, "%f", try_4);
    double found2 = testy.convert(double(98.6));
    if (found2 == 98.6)
      deadly_error(WHERE, func, "default value returned, so it failed.");
    else if (found2 != try_4)
      deadly_error(WHERE, func, "correct value was not returned.");
  }

  {
    double try_4 = 25598437.712385e38;
    testy = istring(istring::SPRINTF, "%f", try_4);
    double found2 = testy.convert(double(98.6));
    if (found2 == 98.6)
      deadly_error(WHERE, func, "default value returned, so it failed.");
    else if (found2 != try_4)
      deadly_error(WHERE, func, "correct value was not returned.");
  }
#endif
}

void run_test_16()
{
  FUNCDEF("run_test_16");
  // the 16th test group tests boundary checking.
  istring gorf("abc");
  for (int i = -3; i < 25; i++) gorf[i] = 't';
  if (gorf != istring("ttt"))
    deadly_error(WHERE, func, "correct value was not returned (a).");
  if (gorf.length() != 3)
    deadly_error(WHERE, func, "length is incorrect (a).");
  gorf.insert(3, istring("bru"));
  if (gorf != istring("tttbru"))
    deadly_error(WHERE, func, "correct value was not returned (b).");
  if (gorf.length() != 6)
    deadly_error(WHERE, func, "length is incorrect (b).");
  gorf.insert(35, istring("snu"));
  if (gorf != istring("tttbru"))
    deadly_error(WHERE, func, "correct value was not returned (c).");
  if (gorf.length() != 6)
    deadly_error(WHERE, func, "length is incorrect (c).");
  gorf.insert(-30, istring("eep"));
  if (gorf != istring("tttbru"))
    deadly_error(WHERE, func, "correct value was not returned (d).");
  if (gorf.length() != 6)
    deadly_error(WHERE, func, "length is incorrect (d).");
}

void run_test_17()
{
  FUNCDEF("run_test_17");
  // 17th test checks construction of temporaries.
/* this test set causes the obnoxious 16 bit codeguard error from hell, as
   does use of temporary objects in ostream << operators.  argh! */
  istring("jubjo");
  istring("obo");
  istring("flrrpominort").substring(3, 6);
}

void run_test_18()
{
  FUNCDEF("run_test_18");
  // 18th test group checks windows related functions.
#ifdef AFXDLL
  AfxSetResourceHandle(GET_INSTANCE_HANDLE());
    // required for mfc to see the proper instance handle.

  // this tests the "constructor from resource".
  istring libname = rc_string(IDS_BASIS_NAME);
  if (libname != istring("Basis Library"))
    deadly_error(WHERE, func, 
        (istring("library name is a mismatch: comes out as \"")
             + libname + istring("\".")).s());
  #define IDS_SOME_BAD_UNKNOWN_STRING_HANDLE 30802
  istring bogus_name = rc_string(IDS_SOME_BAD_UNKNOWN_STRING_HANDLE);
  if (bogus_name.length())
    deadly_error(WHERE, func, "bogus rc string had length");

  // tests conversions from CString to istring and back.
  istring george("yo yo yo");
  CString hal = convert(george);
  istring borgia = convert(hal);

#ifdef DEBUG_STRING_TEST
  out.log(istring("cstringy conversions: ") + george);
  out.log((const char *)hal);
  out.log(borgia);
#endif

  if (borgia != george)
    deadly_error(WHERE, func, "got the wrong value");
#endif
}

void run_test_19()
{
  FUNCDEF("run_test_19");
  // 19th test group is devoted to anthony wenzel's % printing bug.
  istring problematic_example(istring::SPRINTF, "this should have %d% more "
      "stuffing than before!", 20);
//MessageBox(0, istring("got a string of \"%s!\"", problematic_example.s()).s(), "yo!", MB_OK);
  if (problematic_example != istring("this should have 20% more stuffing than before!"))
    deadly_error(WHERE, func, "failure to print correct phrase");
}

void run_test_20()
{
  FUNCDEF("run_test_20");
  // 20th test group is devoted to another wenzelbug.

  // Hey, I just found out (in an ugly way) that the following doesn't work:
  char myText[] = "OK";
  istring myString(istring::SPRINTF, "%04s", myText);
#ifdef DEBUG_STRING_TEST
  out.log(istring("first try gets: ") + myString);
#endif

  char myText8[] = "OK";
  char my_text_4[90];
  sprintf(my_text_4, "%4s", myText8);
#ifdef DEBUG_STRING_TEST
  out.log(istring("second try gets: ") + istring(my_text_4));
#endif

#ifndef EMBEDDED_BUILD
  // Looks like you don't handle the "%04s" arguments properly.  I can make
  // it work as follows:
  char myText2[] = "OK";
  char myText3[50];
  sprintf(myText3, "%4s", myText2);
  istring myString2(myText3);
#ifdef DEBUG_STRING_TEST
  out.log(istring("third try gets: ") + myString2);
#endif
#endif // firmware.
}

void run_test_21()
{
  FUNCDEF("run_test_21");
  // 21st test group checks out the strip spaces and replace functions.
  istring spacey("   dufunk  ");
  istring temp = spacey;
  temp.strip_spaces(istring::FROM_FRONT);
  if (temp != istring("dufunk  "))
    deadly_error(WHERE, func, "created wrong string");
  temp = spacey;
  temp.strip_spaces(istring::FROM_END);
  if (temp != istring("   dufunk"))
    deadly_error(WHERE, func, "created wrong string");
  temp = spacey;
  temp.strip_spaces(istring::FROM_BOTH_SIDES);
  if (temp != istring("dufunk"))
    deadly_error(WHERE, func, "created wrong string");

  istring placemat("mary had a red hooded cobra she kept around her neck "
      "and it hissed at the people as they walked by her tent.");
  if (!placemat.replace("had", "bought"))
    deadly_error(WHERE, func, "replace failed");
  if (placemat.replace("hoded", "bought"))
    deadly_error(WHERE, func, "replace didn't fail but should have");
  if (!placemat.replace("she", "funkateria"))
    deadly_error(WHERE, func, "replace failed");
  if (!placemat.replace("hooded", "hood"))
    deadly_error(WHERE, func, "replace failed");
  if (!placemat.replace("cobra", "in the"))
    deadly_error(WHERE, func, "replace failed");

  int indy = placemat.find("kept");
  if (negative(indy))
    deadly_error(WHERE, func, "couldn't find string");
  placemat[indy - 1] = '.';
  placemat.zap(indy, placemat.end());
  if (placemat != istring("mary bought a red hood in the funkateria."))
    deadly_error(WHERE, func, "got wrong result string");
}

void run_test_22()
{
  FUNCDEF("run_test_22");
  // 22nd test: morgan's find bug.
  istring B("buzz*buzz*");
  {
    int x = B.find('*');  // correctly finds the first *.
    if (x != 4)
      deadly_error(WHERE, func, "got wrong index for first");
    x++;   
    x = B.find('*', x);  // correctly finds the second *.
    if (x != 9)
      deadly_error(WHERE, func, "got wrong index for second");
    x++;  // now x == B.length().
    x = B.find('*', x);
      // error was: finds the second * again (and again and again and 
      // again...).  At this point it should return OUT_OF_RANGE.
    if (x > 0)
      deadly_error(WHERE, func, "got wrong outcome for third");
  }
  {
    int x = B.find("z*");  // correctly finds the first z*.
    if (x != 3)
      deadly_error(WHERE, func, "got wrong index for fourth");
    x++;   
    x = B.find("z*", x);  // correctly finds the second *.
    if (x != 8)
      deadly_error(WHERE, func, "got wrong index for fifth");
    x++;  // now x == B.length().
    x = B.find("z*", x);
      // error was: finds the second * again (and again and again and 
      // again...).  At this point it should return OUT_OF_RANGE.
    if (x > 0)
      deadly_error(WHERE, func, "got wrong outcome for sixth");
  }
//hmmm: add a reverse version of the test!
}

void run_test_23()
{
  FUNCDEF("run_test_23");
  // 23rd test: test the new strip function.
  istring strip_string("!@#$%^&*()");
  
  istring no_stripper("this shouldn't change");
  no_stripper.strip(strip_string, istring::FROM_BOTH_SIDES);
  if (no_stripper != istring("this shouldn't change"))
    deadly_error(WHERE, func, "first test failed comparison");

  istring strippee_orig("&$(*(@&@*()()!()@*(@(*fudge#((@(*@**#)(@#)(#");
  istring strippee(strippee_orig);
  strippee.strip(strip_string, istring::FROM_BOTH_SIDES);
  if (strippee != istring("fudge"))
    deadly_error(WHERE, func, "second test failed comparison");

  strippee = strippee_orig;
  strippee.strip(strip_string, istring::FROM_FRONT);
  if (strippee != istring("fudge#((@(*@**#)(@#)(#"))
    deadly_error(WHERE, func, "third test failed comparison");

  strippee = strippee_orig;
  strippee.strip(strip_string, istring::FROM_END);
  if (strippee != istring("&$(*(@&@*()()!()@*(@(*fudge"))
    deadly_error(WHERE, func, "fourth test failed comparison");
}

void run_test_24()
{
  FUNCDEF("run_test_24");
#ifdef __WIN32__
  // 24th test group tests _bstr_t conversions.
  _bstr_t beast("abcdefgh");
#ifdef DEBUG_STRING_TEST
  out.log(istring("the beast is ") + beast.operator char *() +
      istring(istring::SPRINTF, " with length %d", beast.length()));
#endif
  istring convert = beast;
#ifdef DEBUG_STRING_TEST
  out.log(istring("the convert is ") + convert
      + istring(istring::SPRINTF, " with length %d", convert.length()));
#endif
  if (convert != "abcdefgh")
    deadly_error(WHERE, func, "first test failed comparison");

  istring jethro("i want a hog sandwich");
  _bstr_t pork = string_convert::to_bstr_t(jethro);
  if (strcmp(pork.operator char *(), jethro.s()))
    deadly_error(WHERE, func, "second test failed comparison");
#endif
}

void run_test_25()
{
  FUNCDEF("run_test_25");
  // 25th test group tests simple comparisons.
  istring fred = "asdoiuaoisud";
  if (fred != "") {}
  else
    deadly_error(WHERE, func, "first test failed comparison");
  istring bub = fred;
  if (fred != bub)
    deadly_error(WHERE, func, "second test failed comparison");
  fred = "";
  if (fred != "")
    deadly_error(WHERE, func, "third test failed comparison");
  else if (fred.length())
    deadly_error(WHERE, func, "fourth test failed comparison");
}

void run_test_26()
{
  FUNCDEF("run_test_26");
  // 26th test group does simple timestamp operations.  these are more for
  // ensuring boundschecker gets to see some of this.
  istring t1 = timestamp(false, false);
  istring t2 = timestamp(false, true);
  istring t3 = timestamp(true, false);
  istring t4 = timestamp(true, true);
}

void run_test_27()
{
  FUNCDEF("run_test_27");
  // 27th test group plays around with idate in an attempt to get
  // boundschecker to complain.
  earth_time::day_in_year d1 = date_now();
  earth_time::clock_time t1 = time_now();
  earth_time::time_locus dt1 = now();
  istring sd1 = d1.text_form();
  istring st1 = t1.text_form();
  istring sdt1 = dt1.text_form();
}

void run_test_28()
{
  FUNCDEF("run_test_28");
  // 28th test group does sprintfs on shorts and such.
  u_int in1 = 27;
  u_short in2 = 39;
  char in3 = 'Q';
  istring testy(istring::SPRINTF, "%u:%hu:%c", in1, in2, in3);
  if (testy != "27:39:Q")
    deadly_error(WHERE, func, "fourth test failed comparison");
}

void run_test_29()
{
  FUNCDEF("run_test_29");
  // 29th test group tries out the packing support.
  istring a("would an onion smell so sweet?");
  byte_array p1;
  a.pack(p1);
  istring b;
  if (!b.unpack(p1))
    deadly_error(WHERE, func, "first unpack failed");
  if (b != a)
    deadly_error(WHERE, func, "first comparison failed");
  a = "128 salamanders cannot be wrong.";
  a.pack(p1);
  if (!b.unpack(p1))
    deadly_error(WHERE, func, "second unpack failed");
  if (b != a)
    deadly_error(WHERE, func, "second comparison failed");
}

void standard_sprintf_test(const char *parm_string)
{
  FUNCDEF("standard_sprintf_test");
  istring print_into(' ', 20000);
  print_into[0] = '\0';
  sprintf(print_into.s(), "%d %ld %u %hu %s", int(rando.inclusive(0, 23945)),
      long(rando.inclusive(-2394, 2998238)), u_int(rando.inclusive(0, 124395)),
      u_short(rando.inclusive(0, 65535)), parm_string);
  sprintf(print_into.s(), "%c %d %c %s %s %lu", char(rando.inclusive('a', 'z')),
      int(rando.inclusive(0, 23945)), char(rando.inclusive('A', 'Z')),
      parm_string, parm_string, u_long(rando.inclusive(0, 2998238)));
}

void istring_sprintf_test(const char *parm_string)
{
  FUNCDEF("istring_sprintf_test");
  istring print_into(' ', 20000);
  print_into[0] = '\0';
  print_into.sprintf("%d %ld %u %hu %s", int(rando.inclusive(0, 23945)),
      long(rando.inclusive(-2394, 2998238)), u_int(rando.inclusive(0, 124395)),
      u_short(rando.inclusive(0, 65535)), parm_string);
  print_into.sprintf("%c %d %c %s %s %lu", char(rando.inclusive('a', 'z')),
      int(rando.inclusive(0, 23945)), char(rando.inclusive('A', 'Z')),
      parm_string, parm_string, u_long(rando.inclusive(0, 2998238)));
}

void run_test_30()
{
  FUNCDEF("run_test_30");
  // 30th test group examines the difference between sprintf and istring's
  // version.
  istring parm_string = string_manipulation::make_random_name(40, 140);
  time_stamp start;
  const int iterations = 3000;
  for (int i = 0; i < iterations; i++)
    standard_sprintf_test(parm_string.s());
  double standard_took = time_stamp().value() - start.value();
  start.reset();
  for (int j = 0; j < iterations; j++)
    istring_sprintf_test(parm_string.s());
  double istring_took = time_stamp().value() - start.value();
#ifdef DEBUG_STRING_TEST
  out.log(istring(istring::SPRINTF, "the standard sprintf took %f ms "
      "while the istring sprintf took %f", standard_took, istring_took));
#endif

  float ratio = float(istring_took) / float(standard_took);
//#ifdef DEBUG_STRING_TEST
  out.log(istring(istring::SPRINTF, "istring was %03.3f%% slower "
      "than standard.", ratio * 100.0));
//#endif

  if (istring_took <= standard_took) {
    out.log("istring was faster or equal to sprintf.");
  } else {
    // make sure the difference is not too massive.
    if (ratio >= .50)
      out.log(istring(istring::SPRINTF, "istring took way too much longer "
          "than sprintf: ratio was %f.", ratio));
  }
}

void run_test_31()
{
  FUNCDEF("run_test_31");
  // testing of character repeat constructor.
  istring dashes('-', 20);
  istring non_plusses('+', 0);
  istring plusses('+', 1);
  if (dashes.length() != 20)
    deadly_error(WHERE, func, istring("dashes has wrong length!"));
  if (dashes != istring("--------------------"))
    deadly_error(WHERE, func, istring("dashes has wrong contents!"));
  if (non_plusses.length())
    deadly_error(WHERE, func, istring("non_plusses has wrong length!"));
  if (plusses.length() != 1)
    deadly_error(WHERE, func, istring("plusses has wrong length!"));
  if (plusses != istring("+"))
    deadly_error(WHERE, func, istring("plusses has wrong contents!"));
  if (plusses != istring('+', 1))
    deadly_error(WHERE, func, istring("plusses second compare failed!"));
}

void run_test_32()
{
  FUNCDEF("run_test_32");
  // tests creating a huge string and ripping it apart.

  const int CHUNK_SIZE = 2 * MEGABYTE;
    // the block factor for our string.  we expect not to go above this during
    // the testing.
  const int MIN_ADDITION = 10000;  const int MAX_ADDITION = 80000;
    // these are the largest chunk we add to a string at a time.
  const int BUILD_AND_BURN_ITERATIONS = 7;
    // number of times to test building up and tearing down.

  // the string we build up and tear down.
  istring slab;

//hmmm: maybe have a mixed phase where tearing and adding
//      happens frequently and interspersed.

  for (int iters = 0; iters < BUILD_AND_BURN_ITERATIONS; iters++) {

    int size = 0;  // independent count of expected size.
    // we don't want to bother allocating the big chunk more than once, so
    // we'll add to the string until it's within range of going over.
    while (slab.length() < CHUNK_SIZE - MAX_ADDITION - 20) {
//make this into add_a_chunk
      istring addition = string_manipulation::make_random_name(MIN_ADDITION,
          MAX_ADDITION);
      slab += addition;
      size += addition.length();
      if (size != slab.length())
        deadly_error(WHERE, func, istring("size is incorrect after add!"));
    }

    // now we eat it up.
    while (slab.length()) {
//make this into zap_a_chunk
      int zap_start = rando.inclusive(0, slab.end());
      int zap_end = rando.inclusive(0, slab.end());
      flip_increasing(zap_start, zap_end);
      int range_length = zap_end - zap_start + 1;
      if (negative(range_length))
        deadly_error(WHERE, func, istring("flip_increasing failed!"));
      slab.zap(zap_start, zap_end);
      size -= range_length;
      if (size != slab.length())
        deadly_error(WHERE, func, istring("size is incorrect after zap!"));
    }
  }
}

void run_test_33()
{
  FUNCDEF("run_test_33");
  // 33rd test group exercises the replace functions.
  {
    istring to_modify("\\\\feeby\\path\\yo");
    if (!to_modify.replace("\\", "/"))
      deadly_error(WHERE, func, "failed to replace the string");
    if (to_modify != "/\\feeby\\path\\yo")
      deadly_error(WHERE, func, "produced wrong resultant string");
    while (to_modify.replace("\\", "/")) {}
    if (to_modify != "//feeby/path/yo")
      deadly_error(WHERE, func, "produced wrong final string");
  }
  {
    istring to_modify("\\superduper\\dynamo\\looper");
    if (!to_modify.replace("\\", "/"))
      deadly_error(WHERE, func, "failed to replace the string");
    if (to_modify != istring("/superduper\\dynamo\\looper"))
      deadly_error(WHERE, func, "produced wrong resultant string");
    while (to_modify.replace("\\", "/")) {}
    if (to_modify != "/superduper/dynamo/looper")
      deadly_error(WHERE, func, "produced wrong final string");
  }
  {
    istring id = "/SRV=1/SRC=1";
    istring id1 = id;
    while (id1.replace("/", " ")) {}
//    out.log(istring("replacing / with ' ' in first test (was ") + id +
//        ") gives " + id1);
    if (id1 != " SRV=1 SRC=1")
      deadly_error(WHERE, func, "produced wrong final string");

    istring id2 = id;
    while (id2.replace("=", ":")) {}
//    out.log(istring("replacing = with : in second test (was ") + id +
//        ") gives " + id2);
    if (id2 != "/SRV:1/SRC:1")
      deadly_error(WHERE, func, "produced wrong final string");
  }
}

void run_test_34()
{
  FUNCDEF("run_test_34");
  // 34th test group tries out the slow_strncasecmp function for use on
  // platforms without strcasecmp-like functions.
  // it also now tests out the faster icompare methods also.
//currently called oy_compare to avoid colliding with old name of slow_strncasecmp.
  {

//hmmm: add a simple auto-testing helper here that counts which
//      of the tests is in error and prints out the number.

    const char *hebba1 = "hebba heeba hoobalah beeb";
    const char *hebba2 = "hebba heeba hoobalah beeba";
    // slow static char * version.
    if (istring::slow_strncasecmp(hebba1, hebba2) >= 0)
      deadly_error(WHERE, func, "A: slow_strncasecmp was incorrect");
    if (istring::slow_strncasecmp(hebba2, hebba1) <= 0)
      deadly_error(WHERE, func, "A: slow_strncasecmp was incorrect");
    const char *hebba3 = "hebba heeba hoobalah beeba";
    if (istring::slow_strncasecmp(hebba3, hebba2) != 0)
      deadly_error(WHERE, func, "A: slow_strncasecmp was incorrect");
    if (istring::slow_strncasecmp(hebba2, hebba3) != 0)
      deadly_error(WHERE, func, "A: slow_strncasecmp was incorrect");
    const char *hebba4 = "hebba heeba hoobalah beea";
    if (istring::slow_strncasecmp(hebba4, hebba1) >= 0)
      deadly_error(WHERE, func, "A: slow_strncasecmp was incorrect");
    if (istring::slow_strncasecmp(hebba1, hebba4) <= 0)
      deadly_error(WHERE, func, "A: slow_strncasecmp was incorrect");

    // testing begins and ends methods.
    istring ends_pat1 = "crungohila.exe";
    istring ends_mat1 = ".exe";
    if (!ends_pat1.ends(ends_mat1))
      deadly_error(WHERE, func, "A: ends was incorrect");
    istring ends_pat2 = "link_parser.obj";
    istring ends_mat2 = ".res";
    if (ends_pat2.ends(ends_mat2))
      deadly_error(WHERE, func, "B: ends was incorrect");
    istring begins_pat1 = "fudzolioc";
    istring begins_mat1 = "fudz";
    if (!begins_pat1.begins(begins_mat1))
      deadly_error(WHERE, func, "begins was incorrect");

    // testing ibegins and iends methods.
    istring iends_pat1 = "cruNgoHila.Exe";
    istring iends_mat1 = ".eXE";
    if (!iends_pat1.iends(iends_mat1))
      deadly_error(WHERE, func, "A: iends was incorrect");
    istring iends_pat2 = "link_paRser.Obj";
    istring iends_mat2 = ".rEs";
    if (iends_pat2.ibegins(iends_mat2))
      deadly_error(WHERE, func, "B: iends was incorrect");
    istring ibegins_pat1 = "fuDZoliOc";
    istring ibegins_mat1 = "fudz";
    if (!ibegins_pat1.ibegins(ibegins_mat1))
      deadly_error(WHERE, func, "ibegins was incorrect");

    // now do an iterative test since we've weeded out some easy errors.
    array<istring> strings;
const int MAX_NAMES = 100;
    for (int i = 0; i < MAX_NAMES; i++)
      strings += string_manipulation::make_random_name();
const int MAX_TESTS = 400;
    for (int j = 0; j < MAX_TESTS; j++) {
      int str1 = rando.inclusive(0, MAX_NAMES - 1);
      int str2 = rando.inclusive(0, MAX_NAMES - 1);
      int result1 = istring::slow_strncasecmp(strings[str1].s(), strings[str2].s());
      if (result1)
        result1 = result1 / absolute_value(result1);
      istring s1 = strings[str1].lower();
      istring s2 = strings[str2].lower();
      int result2 = strcmp(s1.s(), s2.s());
      if (result2)
        result2 = result2 / absolute_value(result2);
      if (result1 != result2)
        deadly_error(WHERE, func,
            istring(istring::SPRINTF, "slow_strncasecmp was different "
                "from strcmp:\r\n"
                "the first was %s, second was %s, res1=%d, res2=%d",
                s1.s(), s2.s(), result1, result2));
    }
  }
}

void run_test_35()
{
  FUNCDEF("run_test_35");
  // test the shrink method.
  istring termo('R', 2812);
  termo[1008] = '\0';
  termo.shrink();
  if (termo.get_implem().internal_real_length() != 1010)
    deadly_error(WHERE, func, isprintf("failure in shrunken size: "
        "wanted 1010 and got %d.", termo.get_implem().internal_real_length()));
  istring termo2('R', 1008);
  if (termo != termo2)
    deadly_error(WHERE, func, "wrong value produced");
}

void run_test_36()
{
  FUNCDEF("run_test_36");
  // test the text form on a string array (which is mildly related to strings;
  // this could be moved to a common templates test someday).
  string_array torpid;
  torpid += "york";
  torpid += "burger";
  torpid += "petunia";
  torpid += "dumptruck";
  if (torpid.text_form() != "\"york\",\"burger\",\"petunia\",\"dumptruck\"")
    deadly_error(WHERE, func, "wrong value computed");
  string_array sacral;
  sacral += "gumboat";
  if (sacral.text_form() != "\"gumboat\"")
    deadly_error(WHERE, func, "wrong value computed");

  string_array paknid;
  paknid += "gorboochy";
  paknid += "rangolent";
  byte_array packed;
  basis::pack(packed, paknid);

  string_array upnort;
  if (!basis::unpack(packed, upnort))
    deadly_error(WHERE, func, "failed to unpack");
  if (packed.length())
    deadly_error(WHERE, func, "array still has bytes!");

  string_array stongent;
  stongent += "pemulack";
  stongent += "bluzzent";
  stongent += "crupto";
  stongent += "floonack";
  stongent += "atoona";
  packed.reset();
  basis::pack(packed, stongent);

  string_array belzorp;
  if (!basis::unpack(packed, belzorp))
    deadly_error(WHERE, func, "failed to unpack");
  if (packed.length())
    deadly_error(WHERE, func, "array still has bytes!");
}

void run_test_37()
{
  FUNCDEF("run_test_37");
  // 37th test group used to try out the old packing support, but now is
  // just the same as test 29.  it would be good to make this different.
  istring a("would an onion smell so sweet?");
  byte_array p1;
  a.pack(p1);
  istring b;
  if (!b.unpack(p1))
    deadly_error(WHERE, func, "first unpack failed");
  if (b != a)
    deadly_error(WHERE, func, "first comparison failed");
  a = "128 salamanders cannot be wrong.";
  a.pack(p1);
  if (!b.unpack(p1))
    deadly_error(WHERE, func, "second unpack failed");
  if (b != a)
    deadly_error(WHERE, func, "second comparison failed");
}

void run_test_38()
{
  FUNCDEF("run_test_38");
  double to_print = 2.345;
  isprintf non_deadly("%.1f", to_print);

  to_print = 1.797E+254;
    // this value breaks things.

  char bucket[2000];
  bucket[0] = '\0';
  sprintf(bucket, "%.1f", to_print);

  isprintf deadly("%.1f", to_print);
}

void run_test_39()
{
  FUNCDEF("run_test_39");
  istring find_set = "!?.;";
  istring test_1 = "how do i get to balthazar square?  it stinks!";
  if (test_1.find_any(find_set) != 32)
    deadly_error(WHERE, func, "first find returned wrong result");
  if (test_1.find_any(find_set, 33) != 44)
    deadly_error(WHERE, func, "second find returned wrong result");
  if (test_1.find_any(find_set, 40, true) != 32)
    deadly_error(WHERE, func, "third find returned wrong result");
}

void run_test_40()
{
  FUNCDEF("run_test_40");
  int test_num = 1;
  #define test_name() isprintf("test %d: ", test_num)
  {
    istring target = "xabab";
    istring from = "ab";
    istring to = "dc";
    if (!target.replace_all(from, to))
      deadly_error(WHERE, func, test_name() + "didn't find from string");
    if (target != "xdcdc")
      deadly_error(WHERE, func, test_name() + "didn't replace properly");
    test_num++;
  }
  {
    istring target = "xabab";
    istring from = "ab";
    istring to = "ab";
    if (!target.replace_all(from, to))
      deadly_error(WHERE, func, test_name() + "didn't find from string");
    if (target != "xabab")
      deadly_error(WHERE, func, test_name() + "didn't replace properly");
    test_num++;
  }
  {
    istring target = "xabab";
    istring from = "ab";
    istring to = "a";
    if (!target.replace_all(from, to))
      deadly_error(WHERE, func, test_name() + "didn't find from string");
    if (target != "xaa")
      deadly_error(WHERE, func, test_name() + "didn't replace properly");
    test_num++;
  }
  {
    istring target = "ababx";
    istring from = "ab";
    istring to = "a";
    if (!target.replace_all(from, to))
      deadly_error(WHERE, func, test_name() + "didn't find from string");
    if (target != "aax")
      deadly_error(WHERE, func, test_name() + "didn't replace properly");
    test_num++;
  }
  {
    istring target = "suzzle rumpetzzes gnargle rezztor";
    istring from = "zz";
    istring to = "zzz";
    if (!target.replace_all(from, to))
      deadly_error(WHERE, func, test_name() + "didn't find from string");
    if (target != "suzzzle rumpetzzzes gnargle rezzztor")
      deadly_error(WHERE, func, test_name() + "didn't replace properly");
    test_num++;
  }
  {
    istring target = "qqqq";
    istring from = "q";
    istring to = "qqq";
    if (!target.replace_all(from, to))
      deadly_error(WHERE, func, test_name() + "didn't find from string");
    if (target != "qqqqqqqqqqqq")
      deadly_error(WHERE, func, test_name() + "didn't replace properly");
    test_num++;
  }
  {
    istring target = "glorg snorp pendle funk";
    istring from = " ";
    istring to = "";
    if (!target.replace_all(from, to))
      deadly_error(WHERE, func, test_name() + "didn't find from string");
    if (target != "glorgsnorppendlefunk")
      deadly_error(WHERE, func, test_name() + "didn't replace properly");
    test_num++;
  }
}

void run_test_41()
{
  FUNCDEF("run_test_41");
  int test_num = 0;
  #define test_name() isprintf("test %d: ", test_num)
  {
    test_num++;
    istring target = "xabab";
    istring finding1 = "ab";
    if (target.find_non_match(finding1, 0, false) != 0)
      deadly_error(WHERE, func, test_name() + "didn't find right location A");
    istring finding2 = "xb";
    if (target.find_non_match(finding2, target.length() - 1, true) != 3)
      deadly_error(WHERE, func, test_name() + "didn't find right location B");
    istring finding3 = "c";
    if (target.find_non_match(finding3, 0, false) != 0)
      deadly_error(WHERE, func, test_name() + "wrong answer for test C");
    if (target.find_non_match(finding3, target.length() - 1, true)
        != target.length() - 1)
      deadly_error(WHERE, func, test_name() + "wrong answer for test D");
  }
  {
    test_num++;
    istring target = "abcadefghoota";
    istring finding1 = "bcdfghot";
    if (target.find_non_match(finding1, 0, false) != 0)
      deadly_error(WHERE, func, test_name() + "didn't find right location A");
    if (target.find_non_match(finding1, 1, false) != 3)
      deadly_error(WHERE, func, test_name() + "didn't find right location B");
    if (target.find_non_match(finding1, target.length() - 1, true)
        != target.length() - 1)
      deadly_error(WHERE, func, test_name() + "didn't find right location C");
    if (target.find_non_match(finding1, target.length() - 2, true) != 5)
      deadly_error(WHERE, func, test_name() + "didn't find right location D");
    if (target.find_non_match(finding1, 3, false) != 3)
      deadly_error(WHERE, func, test_name() + "didn't find right location E");
    if (target.find_non_match(finding1, 4, false) != 5)
      deadly_error(WHERE, func, test_name() + "didn't find right location F");

  }


}

int main(int formal(argc), char *formal(argv)[])
{
  FUNCDEF("main");
  SET_DEFAULT_COMBO_LOGGER;  // program wide logger is now ready.

  if (staticity_test != istring("yo!"))
    deadly_error(WHERE, func, "wrong contents");

  time_stamp end_time(TEST_RUNTIME_DEFAULT);
    // when we're done testing.

  int i = 0;  // iteration counter.
  while (time_stamp() < end_time) {
    // we run the test until our time runs out.
    i++;  // next iteration.
#ifdef DEBUG_STRING_TEST
    out.log(istring(istring::SPRINTF, "index %d", i));
#endif

//temp
run_test_41();

    // beginning of test sets.
    run_test_01(); run_test_02(); run_test_03(); run_test_04(); run_test_05();
    run_test_06(); run_test_07(); run_test_08(); run_test_09(); run_test_10();
    run_test_11(); run_test_12(); run_test_13(); run_test_14(); run_test_15();
    run_test_16(); run_test_17(); run_test_18(); run_test_19(); run_test_20();
    run_test_21(); run_test_22(); run_test_23(); run_test_24(); run_test_25();
    run_test_26(); run_test_27(); run_test_28(); run_test_29(); run_test_30();
    run_test_31(); run_test_32(); run_test_33(); run_test_34(); run_test_35();
    run_test_36(); run_test_37(); run_test_38(); run_test_39(); run_test_40();
    run_test_41();
  }

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

#undef static_class_name