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.cpp>
#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 int 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 =