StringTest.C

Go to the documentation of this file.

#include <stdio.h>
#include <string.h>

#include "String.h"

void checkRefCntVal( String s, size_t shouldBe, const char *prefix )
{
  if (s.getRefCnt() != shouldBe)
    printf("%s refCnt = %d (should be %d)\n", 
           prefix, s.getRefCnt(), shouldBe );
} // checkRefCntVal


void checkRefCnt( String &s, size_t shouldBe, const char *prefix )
{
  if (s.getRefCnt() != shouldBe)
    printf("%s refCnt = %d (should be %d)\n", 
           prefix, s.getRefCnt(), shouldBe );
} // checkRefCnt


void test_constructors()
{
  String a( "abcd" );
  String b( a );

  printf("Test String constructors\n");

  if (b.getRefCnt() != 2)
    printf("1. Reference count is wrong: refCnt = %d (should be 2)\n",
           b.getRefCnt() );

  String c = a;
  if (b.getRefCnt() != 3)
    printf("2. Reference count is wrong: refCnt = %d (should be 3)\n",
           b.getRefCnt() );

  if (a.getRefCnt() != 3)
    printf("3. Reference count is wrong: refCnt = %d (should be 3)\n",
           b.getRefCnt() );

  checkRefCntVal( a, 4, "4. ");

  if (a.getRefCnt() != 3)
    printf("4. Reference count is wrong: refCnt = %d (should be 3)\n",
           b.getRefCnt() );

  checkRefCnt( a, 3, "5. ");

  String d( 'd' );

  // test for construction with an empty string
  String e;
  String f( e );
  checkRefCnt( f, 2, "6. ");
  checkRefCntVal( f, 3, "7. ");

  // test of a pointer containing null
  const char *nullPtr = 0;
  String g( nullPtr );

  // test of a null address
  String h( (const char *)0 );

  String i( '\0' );
  if (i.strlen() != 0) {
    printf("8. Adding a null character should not increase length\n");
  }
} // test_constructors


void test_char_cast()
{
  printf("Test character cast\n");

  const char *testStr = "the quick brown fox";
  String a( testStr );
  const char *tmp = a;

  if (tmp == 0)
    printf("1. error: result of cast is null\n");
  else if (strcmp(testStr, tmp) != 0)
    printf("2. error: strings are not equal\n");

} // test_char_cast


/*
 * test_assign
 *

   The privious version of the String class created a new copy when
   ever the index operator ([]) was used.  I was surprised to 
   discover that this was the case even with the index operator
   was on the right hand size.  This function includes a test
   which checks that copy on read does not take place in this
   version.
   
 */
void test_assign()
{
  printf("Test assignment\n");

  const char *testStr = "my girl is the best";
  String a = "abcd";

  const char *tmp = a;

  if (strcmp(tmp, "abcd") != 0)
    printf("1. Assignment in declaration failed\n");

  const char *init_b = "this is not it";
  String b(init_b);
  String original_b;

  original_b = b;

  b = testStr;
  if (b.getRefCnt() != 1)
    printf("2. reference count for b is wrong\n");

  tmp = b;
  if (strcmp(tmp, testStr) != 0)
    printf("3. String has incorrect contents\n");

  if (original_b.getRefCnt() != 1)
     printf("4. reference count for original_b is wrong\n");

  if (original_b != init_b)
     printf("5. modification of b improperly changed original_b\n");

  String c( testStr );
  c = b;
  if (b.getRefCnt() != 2)
    printf("6. reference count is wrong\n");

  const char *nullPtr = 0;
  String d;

  if (d != "") {
    printf("7. comparision to a null string failed\n");
  }

  d = nullPtr;
  if (d != "") {
    printf("8. assignment of a null C-string failed\n");
  }

  d = testStr;
  tmp = d;
  if (strcmp(tmp, testStr) != 0)
    printf("9. String has incorrect contents\n");

  String e = String( testStr );
  tmp = e;
  if (strcmp(tmp, testStr) != 0)
    printf("10. String has incorrect contents\n");

  if (e.getRefCnt() != 1)
    printf("11. refCnt is wrong: refCnt = %d, should be 1\n",
           e.getRefCnt() );

  const char *constCStr = "1234567890";
  const size_t len = sizeof(constCStr) / sizeof(char);
  String foo = constCStr;
  String bar = foo;
  if (foo.getRefCnt() != 2) {
    printf("12. refcnt is wrong: refCnt = %d, should be 2\n",
           foo.getRefCnt() );
  }

  // This makes sure that the [] operator is implemented properly
  // and does not cause a "copy-on-write" on a read operation.
  bool contentOK = true;
  for (size_t i = 0; i < len; i++) {
    if (constCStr[i] != foo[i]) {
      contentOK = false;
      break;
    }
  }
  if (!contentOK) {
    printf("13: content is wrong\n");
  }
  // make sure refCnt is still OK
  if (bar.getRefCnt() != 2) {
    printf("14. refcnt is wrong: refCnt = %d, should be 2\n",
           bar.getRefCnt() );
  }

  const char *testStr2 = "null is a lonely number";
  String r = testStr2;
  String r2 = r;
  r = '\0';
  if (r != "") {
    printf("15. assignment of null character did not result in empty str\n");
  }

  if (r2 != testStr2) {
    printf("16. null character assignment changed a shared string\n");
  }

  if (r2.getRefCnt() != 1) {
    printf("17. reference count is wrong\n");
  }

  const char *testStr3 = "\"Writing tests is hard!\" said Barbie";
  String s = testStr3;
  String s2 = s;
  s = "";
  if (s != "") {
    printf("18. assignment of empty string did not result in empty str\n");
  }

  if (s2 != testStr3) {
    printf("19. empty string assignment changed a shared string\n");
  }

  if (s2.getRefCnt() != 1) {
    printf("17. reference count is wrong\n");
  }

  // Test chained assignment
  const char *testStr4 = "working on the chain gang";
  String w, x, y;
  w = x = y = testStr4;

  if (w != testStr4 ||
      x != testStr4 ||
      y != testStr4) {
    printf("18. chained assignment failed\n");
  }

  if (y.getRefCnt() != 3) {
    printf("19. reference count in chained assignment is wrong\n");
  }

  String z = "still working on the gang";
  w = x = y = z;
  if (w != x &&
      x != y &&
      y != z) {
    printf("20. chained assignment failed\n");
  }

  if (y.getRefCnt() != 4) {
    printf("21. reference count in chained assignment is wrong\n");
  }
} // test_assign


void test_plus_equal()
{
  const char *firstHalf = "abcd";
  const char *secondHalf = " efgh";
  const char *concatStr = "abcd efgh";

  printf("Test += operator\n");

  String a( firstHalf );

  a += secondHalf;

  const char *tmp = a;

  if (strcmp(tmp, concatStr) != 0)
    printf("1. Strings did not match: str = %s (should be [%s]\n",
           tmp, concatStr );

  String b;

  b += firstHalf;
  tmp = b;
  if (strcmp(tmp, firstHalf) != 0)
    printf("2. Strings did not match: str = %s (should be [%s]\n",
           tmp, firstHalf );

  String d, c;

  c += d;
  if (c.getRefCnt() != 1)
    printf("3. refCnt should (still) be 1\n");

  if (d != "" || c != "") {
    printf("4. Strings c and d should be the empty string, but are not\n");
  }

  c += secondHalf;
  tmp = c;
  if (strcmp(tmp, secondHalf) != 0)
    printf("5. Strings did not match: str = %s (should be [%s]\n",
           tmp, secondHalf );

  String e("1234");

  for (size_t i = 5; i < 10; i++) {
    e += (char)(i + (char)'0');
  }
  if (e != "123456789") {
    tmp = e;
    printf("6. Character concat failed: d = %s, should be 123456789\n",
           tmp );
  }

  const char *testStr1 = "metal jacket";
  String empty;
  String full(testStr1);

  empty += full;

  if (empty.getRefCnt() != 1) {
    printf("7. empty.getRefCnt() = %d, should be 1\n", empty.getRefCnt() );
  }

  if (empty != testStr1) {
    printf("8. empty string += String failed\n");
  }

  const char *testStr2 = "foo";
  String empty2;
  const char *str = testStr2;

  empty2 += str;
  if (empty2.getRefCnt() != 1) {
    printf("9. empty2.getRefCnt() = %d, should be 1\n", empty2.getRefCnt() );
  }

  if (empty2 != testStr2) {
    printf("10. empty string += C-string failed\n");
  }

  // test chained assignment
  const char *testStr3 = "twas brillig";
  String s1 = "twas ";
  String s2 = "brillig";
  String s3 = s1 += s2;

  if (s3 != s1 && s1 != testStr3) {
    printf("11. chained assignment with += failed\n");
  }

  if (s3.getRefCnt() != 2 &&
      s1.getRefCnt() != 2 &&
      s2.getRefCnt() != 1) {
    printf("12. reference count for chained assignment with += failed\n");
  }
} // test_plus_equal



void test_plus()
{
  printf("Test + operator\n");

  const char *firstHalf = "abcd";
  const char *secondHalf = " efgh";
  const char *concatStr = "abcd efgh";

  //
  // Test String + String
  //
  String t1( firstHalf );
  String t2( secondHalf );
  String a = t1 + t2;
  if (a.getRefCnt() != 1) {
    printf("1. refCnt is wrong: refCnt = %d, should be 1\n",
           a.getRefCnt() );
  }

  if (strcmp((const char *)a, concatStr) != 0)
    printf("2. String contents are not correct: a = %s (should be [%s])\n",
           (const char *)a, concatStr );

  //
  // Test String + const char *
  //
  String b = t1 + secondHalf;

  if (b.getRefCnt() != 1) {
    printf("3. refCnt is wrong: refCnt = %d, should be 1\n",
           b.getRefCnt() );
  }

  const char *tmp = b;
  if (strcmp(tmp, concatStr) != 0)
    printf("4. String contents are not correct: b = %s (should be [%s])\n",
           tmp, concatStr );

  //
  // test the global String addition operator const char * + String
  //
  String c = firstHalf + t2;
  tmp = c;
  if (strcmp(tmp, concatStr) != 0)
    printf("5. String contents are not correct: c = %s (should be [%s])\n",
           tmp, concatStr );

  //
  // Make sure that the operands of the addition are not altered by
  // the addition
  //
  String first( firstHalf );
  String second( secondHalf );
  String d = first + second;
  tmp = first;
  if (strcmp(tmp, firstHalf) != 0)
    printf("6. first has been altered: first = %s (should be [%s])\n",
           tmp, firstHalf );

  tmp = second;
  if (strcmp(tmp, secondHalf) != 0)
    printf("7. second has been altered: second = %s (should be [%s])\n",
           tmp, secondHalf );

  tmp = d;
  if (strcmp(tmp, concatStr) != 0)
    printf("8. String contents are not correct: d = %s (should be [%s])\n",
           tmp, concatStr );

  //
  // Test character concatenation.  Here the character operands
  // are converted to String objects.
  //
  String e("12345");
  String f;
  String g;

  f = e + '6' + '7' + '8' + '9';
  g = 'a' + f;

  if (e != "12345")
    printf("9. String e changed\n");

  if (f != "123456789") {
     const char *tmp = f;
     printf("10. String f is %s, it should be \"123456789\"\n", tmp);
  }

  if (g != "a123456789")
    printf("11. g is incorrect\n");

  // Test addition with chained assignment and string operands
  String w( "foo" );
  String x( "bar" );
  String y;
  String z = y = w + x;

  if (y != "foobar") {
     const char *tmp = y;
     printf("12. String y is %s, it should be \"foobar\"\n", tmp );
  }

  if (z != "foobar") {
     const char *tmp = z;
     printf("13. String z is %s, it should be \"foobar\"\n", tmp );
  }

  // The reference counts for w and x should both be 1
  if (w.getRefCnt() != 1) {
     printf("14. w.getRefCnt() = %d, it should be 1\n", w.getRefCnt() );
  }
  if (x.getRefCnt() != 1) {
     printf("15. x.getRefCnt() = %d, it should be 1\n", x.getRefCnt() );
  }

  if (y.getRefCnt() != 2) {
     printf("16. y.getRefCnt() = %d, it should be 2\n", y.getRefCnt() );
  }
  if (z.getRefCnt() != 2) {
     printf("17. z.getRefCnt() = %d, it should be 2\n", z.getRefCnt() );
  }
} // test_plus



void test_relops()
{
  printf("Test relational operators\n");

  const char *less = "abcd";
  const char *greater = "wxyz";
  const char *equal = "abcd";
  String lessString( less );
  String greaterString( greater );
  String equalString( equal );  // note that equalString == lessString == less
  String same;

  same = less;

  //
  // ==
  //
  // String String
  //
  // Check the case where both strings contain no data
  // (and so are equal).
  String x, y;  // two empty strings
  if (x != y)
    printf("0. empty strings are not equal\n");

  if (x != "") {
    printf("0.5: String not equal to empty C string\n");
  }

  if (! (lessString == equalString))
    printf("1. String == String failed\n");

  // String const char *
  if (! (lessString == equal))
    printf("2. String == const char * failed\n");

  // const char *  String
  if (! (equal == lessString))
    printf("3. const char * == String failed\n");

  if (! (same == less))
    printf("String == String failed for String objs w/same shared data\n");

  //
  // !=
  //
  // String String
  if (! (lessString != greaterString))
    printf("4. String != String failed\n");

  // String const char *
  if (! (lessString != greater))
    printf("5. String != const char * failed\n");

  // const char *  String
  if (! (less != greaterString))
    printf("6. const char * != String failed\n");

  //
  // >=
  //
  // String String
  if (! (greaterString >= lessString))
    printf("7. String >= String failed for >\n");

  if (! (lessString >= equalString))
    printf("8. String >= String failed for ==\n");

  // String const char *
  if (! (greaterString >= less))
    printf("9. String >= const char * failed for >\n");

  if (! (lessString >= equal))
    printf("10. String >= const char * failed ==\n");

  // const char *  String
  if (! (greater >= lessString))
    printf("11. const char * >= String failed for >\n");

  if (! (equal >= lessString))
    printf("12. const char * >= String failed for ==\n");

  //
  // <=
  //
  // String String
  if (! (lessString <= greaterString))
    printf("13. String <= String failed for <\n");

  if (! (lessString <= equalString))
    printf("14. String <= String failed for ==\n");

  // String const char *
  if (! (lessString <= greater))
    printf("15. String <= const char * failed for <\n");

  if (! (lessString <= equal))
    printf("16. String <= const char * failed for ==\n");

  // const char *  String
  if (! (less <= greaterString))
    printf("17. const char * <= String failed for <\n");

  if (! (equal <= lessString))
    printf("18. const char * <= String failed for ==\n");

  //
  // >
  //
  // String String
  if (! (greaterString > lessString))
    printf("19. String > String failed\n");

  // String const char *
  if (! (greaterString > less))
    printf("20. String > const char * failed\n");

  // const char *  String
  if (! (greater > lessString))
    printf("21. const char * > String failed\n");

  //
  // <
  //
  // String String
  if (! (lessString < greaterString))
    printf("22. String < String failed\n");

  // String const char *
  if (! (lessString < greater))
    printf("23. String < const char * failed\n");

  // const char *  String
  if (! (less < greaterString))
    printf("24. const char * < String failed\n");

} // test_relops



void test_arrayop()
{
  const char *jabbar     = "He took his vorpal sword in hand";
  const char *newJabbar1 = "He took her vorpal sword in hand";
  //     index 9   -----------------^
  const char *newJabbar2 = "He took her vorpal ruler in hand";
  //     index 19  ----------------------------^
  const char *newWord = "ruler";

  const size_t len = strlen( jabbar );
  String jabbarString( jabbar );
  String jabbarRefStr = jabbarString;

  //
  // Make sure that integer operators on the RHS work properly
  //
  if (jabbarString[3] != 't') {
    printf("0. string index failed\n");
  }

  // make sure than in index operation does not cause a copy
  if (jabbarRefStr.getRefCnt() != 2) {
    printf("0.5. string index seems to have caused a copy\n");
  }

  for (size_t i = 0; i < len; i++) {
    char lhsCh = jabbarString[i];
    char rhsCh = jabbar[i];
    if (lhsCh != rhsCh) {
      printf("1. mismatch on rhs String index\n");
    }
  }

  // references are jabbarString, jabbarRefStr and now, "a"
  String a = jabbarString;
  if (a.getRefCnt() != 3)
    printf("2. reference count is wrong\n");

  a[9] = 'e';
  a[10] = 'r';

  // The string has been changed, so a "copy on write" should 
  // have taken place.  Now there is a single copy, with the
  // change.
  if (a.getRefCnt() != 1)
    printf("3. 'a' reference count is wrong\n");

  if (jabbarString.getRefCnt() != 2)
    printf("4. jabbarString reference count is wrong\n");
  
  const char *tmp = a;
  if (strcmp(tmp, newJabbar1) != 0) {
    printf("5. strings don't match: a = %s, should be %s\n",
           tmp, newJabbar1 );
  }

  // make sure that the original string is unchanged
  tmp = jabbarString;
  if (strcmp(tmp, jabbar) != 0) {
    printf("6. strings don't match: a = %s, should be %s\n",
           tmp, jabbar );
  }

} // test_arrayop




void test_insert()
{
  printf("Test string insert\n");

  const char *origA = "abcdefgh";
  const char *rslt1 = "abcd1234efgh";
  String a(origA);
  String b("1234");
  String c = a;

  // test insert of a String into a String

  // reference count should be 2, since a and c have the
  // same shared data
  if (a.getRefCnt() != 2)
    printf("1. reference count is wrong\n");

  a(4,0) = b;
  // make sure a is "abcd1234efgh"
  if (a != rslt1) {
    printf("2. insert failed. a = [%s], should be [%s]\n",
           (const char *)a, rslt1 );
  }

  // a should be unique
  if (a.getRefCnt() != 1)
    printf("3. reference count in a is wrong\n");

  // c should be unique
  if (c.getRefCnt() != 1)
    printf("4. reference count in c is wrong\n");

  // The contents of c should be unchanged
  if (c != origA)
    printf("5. contents of c is wrong\n");

  // test insert of C-string into a String
  String d = c;
  d(4,0) = "1234";
  // make sure d is "abcd1234efgh"
  if (d != rslt1) {
    printf("6. insert failed. d = [%s], should be [%s]\n",
           (const char *)d, rslt1 );
  }  

  String c_prime = c;  // reference count is 2

  // test insert of a zero length C string into a String
  // (remember, c is still "abcdefgh")
  c(4, 0) = "";
  // make sure c is "abcdefgh" (e.g., nothing happened)
  if (c != origA) {
    printf("7. insert failed. c = [%s], should be [%s]\n",
           (const char *)c, origA );
  }

  // Insert a null string into a String object (should do nothing)
  c_prime(4, 0) = (const char *)0;
  // make sure that reference count is still 2
  if (c.getRefCnt() != 2)
    printf("8. c.getRefCnt() = %d, should be 2\n", c.getRefCnt());

  if (c_prime.getRefCnt() != 2)
    printf("9. c_prime.getRefCnt() = %d, should be 2\n", c_prime.getRefCnt());

  if (c_prime != origA) {
    printf("10. insert failed. c_prime = [%s], should be [%s]\n",
           (const char *)c_prime, origA );
  }

  // test insert of an empty String into "c", an non-empty string.
  String emptyString;

  // try insert at index 0
  c(0,0) = emptyString;
  // make sure c is "abcdefgh" (e.g., nothing happened)
  if (c != origA) {
    printf("11. insert failed. c = [%s], should be [%s]\n",
           (const char *)c, origA );
  }

  // try insert at index 4
  c(4,0) = emptyString;
  // make sure c is "abcdefgh" (e.g., nothing happened)
  if (c != origA) {
    printf("12. insert failed. c = [%s], should be [%s]\n",
           (const char *)c, origA );
  }
} // test_insert


void test_substr_func_valarg( SubString sub, size_t errorNum )
{
  if (sub.getRefCnt() != 1) {
    printf("%d. sub.getRefCnt() = %d, should be 1\n", 
           errorNum, sub.getRefCnt() );
  }

  if (sub != "de") {
    printf("%d. sub.string = %s, should be \"de\"\n",
           errorNum + 1, (const char *)((String)sub) );
  }
} // test_substr_func_valarg


void test_substring()
{
  printf("Test sub-string operations\n");
  const char *init_a = "abcdefgh";
  String a(init_a);

  if (a(3, 4).getRefCnt() != 1) {
    printf("1. reference count is wrong\n");
  }

  test_substr_func_valarg( a(3, 2 ), 2 );

  String b = a;

  // b is "abcdefgh
  // insert "1234" at position 3
  b(3, 4) = "1234";

  if (a != init_a) {
    printf("3. \"a\" was altered when b(3, 4) was changed\n");
  }

  if (b != "abc1234h") {
    printf("4. b = %s, should be \"abc1234h\"\n", (const char *)b);
  }

  if (a.getRefCnt() != 1 || b.getRefCnt() != 1) {
    printf("5. a.getRefCnt() = %d, b.getRefCnt() = %d (both should be 1)\n",
           a.getRefCnt(), b.getRefCnt() );
  }

  String c;
  c = b(3, 4);
  if (c != "1234") {
    printf("6. c = %s, should be \"1234\"\n", (const char *)c);
  }

  if (c.strlen() != 4) {
    printf("7. c.strlen() = %d, should be 4\n", c.strlen());
  }

  String d("1234abcdefgh");
  String e;

  e = d(4, 8) + d(0, 4); // e = d << 4
  if (e != "abcdefgh1234") {
    printf("8. e = %s, should be \"abcdefgh1234\"\n", (const char *)e );
  }

  if (d != "1234abcdefgh") {
    printf("9. d was changed by the SubString operations\n");
  }

  if (d.getRefCnt() != 1) {
    printf("10. d.getRefCnt() = %d, it should be 1\n", d.getRefCnt());
  }

  //
  // According to 10.4.10 Temporary Objects in "The C++ Programming
  // Language", Third Edition, by Stroustrup:
  //
  //   Unless bound to a reference or used to initialize a named
  //   object, a temporary object is destroyed at the end of teh full
  //   expression in which it was created.  A full expression is an
  //   expression that is not a subexpression of some other
  //   expression.
  //
  // Stroustrup goes on to provide an example using the Standard
  // Template Library (STL) "string" class.  Here the c_str()
  // function returns a "C" language string.
  //
  //    const char* cs = (s1 + s2).c_str().
  //
  //    A temporary object of class string is created to hold s1+s2.
  //    Next, a pointer to a C-style string is extracted from the
  //    object.  Then - at the end of the expression - the temporary
  //    object is deleted.  Now, where was the C-style string
  //    allocated?  Probably as part of the temporary object holding
  //    s1+s2, and that storage is not guaranteed to exist after that
  //    temporary is destroyted.  Consequently, cs points to
  //    deallocated storage.
  //
  // In the case of the String container, the expression
  //
  //     e = d(4, 8) + d(0, 4);
  // 
  // creates a String object temporary, which is assigned to "e"
  //
  //   <allocate String temporary object CompilerTemp>
  //   <CompilerTemp> = d(4, 8) + d(0, 4);
  //   e = <CompilerTemp>     Note: at this point getRefCnt = 2
  //   <destructor called for CompilerTemp> Note: refCnt decremented
  //   next statement
  //
  // By the time we reach "next statement" the destructor is called
  // and the reference counter for "e" is 1, which is what we would
  // expect.
  //
  // If this example does not convience you that C++ is a complicated
  // language, nothing will.
  //
  if (e.getRefCnt() != 1) {
    printf("11. e.getRefCnt() = %d, it should be 1\n", e.getRefCnt());
  }

  //
  // Note that the SubString object created by the () operator is
  // a new object and so has a reference count of 1, although the
  // String associated with it has a reference count of two.
  String z = "lost Z-man";
  String y = z; // refCnt is now 2
  if (z(5, 5).getRefCnt() != 1) {
    printf("12. z(8, 4).getRefCnt() = %d, should be 1\n",
           z(8, 4).getRefCnt() );
  }

  String f("chopsock");

  f(4, 4) = f(0, 4);
  
  if (f != "chopchop") {
    printf("13. f = %s, should be \"chopchop\"\n", (const char *)f );
  }
} // test_substring



void test_resize()
{
  const char *init_a = "01234567890123456789";
  String a( init_a );
  String b = a;
  const char *tmp;

  printf("Test resize\n");

  b.resize(10);  // set size of String b to 10
  if (b.strlen() != 10)
    printf("1. b.strlen() = %d, should be 10\n", b.strlen() );

  if (b != "0123456789") {
    tmp = b;
    printf("2. b = %s, should be \"0123456789\"\n", tmp );
  }

  if (a != init_a)
    printf("3. a was improperly modified by resizing b\n");

  if (a.strlen() != 20)
    printf("4. a.strlen() = %d, should be 20\n", a.strlen() );

  b.resize(20);
  if (b != "0123456789          ") {
    tmp = b;
    printf("5. b = %s, should be \"0123456789          \"\n", tmp );
  }
  if (b.strlen() != 20)
    printf("6. b.strlen() = %d, should be 20\n", b.strlen() );

  if (a != init_a)
    printf("8. resizing b modified a\n");

  b.resize( 0 );

  String empty;

  if (b != empty)
    printf("9. b is not the same as the empty string\n");

  if (a != init_a)
    printf("10. resizing b modified a\n");

  if (b.strlen() != 0)
    printf("11. b.strlen() = %d, should be 0\n", b.strlen() );

  if (b != "") {
    printf("12. b should be the same as the empty string\n");
  }

} // test_resize


main()
{
  test_constructors();
  test_char_cast();
  test_assign();
  test_plus_equal();
  test_plus();
  test_relops();
  test_arrayop();
  test_insert();
  test_substring();
  test_resize();
  return 0;
}

---