Search  

---

C:/temp/src/j2k/Test/StrTest.cpp

Go to the documentation of this file.

// #define __J2K__QUIET

/*

StrData.cpp

Init( s, buffer )

changed to rip-off instead of letting strlen decide the size

now problems.

*/

#include <j2k/Fred/String/String.hpp>
#include <j2k/Fred/String/String.cpp>

  size_t sz = 20;

  JString s1a;
  JString s1b( strNull );

  JString s2( "Hello" );
  JString s3( "World", sz );

  JString s4a( (char*)NULL );

  // Was Problematic, not anymore!
  JString s4b( "", (size_t)NULL );  // Both are valid

  JString s4c( "", sz*2 );
  JString s4d( "  ", 10 ); // 2 of 10

  JString s5( s3 );


  JString s6a( "A" );
  JString s7a( "", sz );

  JString s6b( (char)'A' );
  JString s7b( (char)'#', 5 );
  JString s8( new JStringData( "Fred" ) );  // Verify this.
  JString s9("World", sz-10);
  JString strPI( "3.14159265358979" );

  JString temp( "", (size_t)80 );
  JString temp2;

void init() {
////////////////////////////////////////////////////////////////////////////
/// Constructor, Copy Constructor and Destructor                         ///
////////////////////////////////////////////////////////////////////////////

  s7a.FillBuffer( '#' );
  assert( s7a == "####################" );  // 20s#

  assert( s6b == "A" );

  assert( s7b == "#####" );


////////////////////////////////////////////////////////////////////////////
/// Simple Attributes & Operations...                                    ///
////////////////////////////////////////////////////////////////////////////
     
  assert( s1a == (char*)NULL );  // Both shall be valid
  assert( s1a == (char )NULL );  // The compiler doesn't know which one to choose.

  assert( s1b == (char*)NULL );
  assert( s1b == (char )NULL );

  assert( s1a == (char*)0    );  // Like C++ NULL
  assert( s1a == (char )0    );

  assert( s1b == (char*)0    );
  assert( s1b == (char )0    );

  assert( s1a == (char*)((void*)0) );  // Old way C NULL
  assert( s1a == (char )((void*)0) );

  assert( s1b == (char*)((void*)0) );
  assert( s1b == (char )((void*)0) );

  assert( s1a == (char*)'\0' );  // Forced
  assert( s1b == (char*)'\0' );

  assert( s1a == (char )'\0' );  // Default assumption
  assert( s1b == (char )'\0' );

  assert( s1a == '\0' );         // Default assumed (char)
  assert( s1b == '\0' );

  assert( s1a == ""   );
  assert( s1b == ""   );
 
  assert( s2  == "Hello" );
  assert( s3  == "World" );
  assert( s4a ==  s1a    );
  assert( s4b ==  s1a    );
  assert( s4c ==  s1a    );
  assert( s4a ==  s1b    );
  assert( s4b ==  s1b    );
  assert( s4c ==  s1b    );
  assert( s4d == "  "    );
  assert( s5  ==  s3     );

  assert( s6a == 'A'     );
  assert( s7a != '#'     );
  assert( s6b == 'A'     );
  assert( s7b != '#'     );

  assert( s8 == "Fred"  );
  assert( s9 == "World" );

  cout << "[s1a[" << s1a << "]\n";
  cout << "[s1b[" << s1b << "]\n";
  cout << "[s2["  << s2  << "]\n";
  cout << "[s3["  << s3  << "]\n";
  cout << "[s4a[" << s4a << "]\n";
  cout << "[s4b[" << s4b << "]\n";
  cout << "[s4c[" << s4c << "]\n";
  cout << "[s4d[" << s4d << "]\n";
  cout << "[s5["  << s5  << "]\n";
  cout << "[s6a[" << s6a << "]\n";
  cout << "[s6b[" << s6b << "]\n";
  cout << "[s7a[" << s7a << "]\n";
  cout << "[s7b[" << s7b << "]\n";
  cout << "[s8["  << s8  << "]\n";
  cout << "Is OK ?\n";

  assert( s1a.OK() );
  assert( s1b.OK() );
  assert(  s2.OK() );
  assert(  s3.OK() );
  assert( s4a.OK() );

  assert( s4b.OK() );

  assert( s4c.OK() );
  assert(  s5.OK() );
  assert( s6a.OK() );
  assert( s6b.OK() );
  assert( s7a.OK() );
  assert( s7b.OK() );
  assert(  s8.OK() );

  assert(  s1a.isEmpty() );
  assert(  s1b.isEmpty() );
  
  assert(  s4a.isEmpty() );
  assert(  s4b.isEmpty() );
  assert(  s4c.isEmpty() );

  assert(  !s2.isEmpty() );
  assert(  !s3.isEmpty() );

  assert(  !s5.isEmpty() );
  assert( !s6a.isEmpty() );
  assert( !s6b.isEmpty() );
  assert( !s7a.isEmpty() );
  assert( !s7b.isEmpty() );
  assert(  !s8.isEmpty() );
}

void debug()
{
  printf( "Debug {\n "); 
  printf( "[s1a[%s]\n", (char*)s1a );
  printf( "[s1b[%s]\n", (char*)s1b );
  printf(  "[s2[%s]\n", (char*)s2  );
  printf(  "[s3[%s]\n", (char*)s3  );
  printf( "[s4a[%s]\n", (char*)s4a );
  printf( "[s4b[%s]\n", (char*)s4b );
  printf( "[s4c[%s]\n", (char*)s4c );
  printf( "[s4d[%s]\n", (char*)s4d );
  printf(  "[s5[%s]\n", (char*)s5  );
  printf( "[s6a[%s]\n", (char*)s6a );
  printf( "[s6b[%s]\n", (char*)s6b );
  printf( "[s7a[%s]\n", (char*)s7a );
  printf( "[s7b[%s]\n", (char*)s7b );
  printf(  "[s8[%s]\n", (char*)s8  );
  printf( "}\n "); 
  fflush( stdout );
}

void fill()
{
  s4c = s8;
  s4c.Clear();

#ifndef __J2K__QUIET
  cout << "[s4c[Clear[" << s4c << "]\n";
  cout << "[s8[" << s8 << "]\n";
#endif
  
  s4c = s3;

  assert( s3 == s4c );

  s4c.Empty();

#ifndef __J2K__QUIET
  cout << "[s3[Empty(" << s3 << ") == [" << s4c << "]\n";
#endif

  assert( s4d.length() ==  2 );

  cout << s4d.length() << "-" << s4d.getBufferSize() << endl;

  s4a.FillString( '1' );
  s4b.FillString( '1' );
  s4c.FillString( '1' );
  s4d.FillString( '1' );

#ifndef __J2K__QUIET
  cout << "[s4a[Fill(1)[" << s4a << "]\n";
  cout << "[s4b[Fill(1)[" << s4b << "]\n";
  cout << "[s4c[Fill(1)[" << s4c << "]\n";
  cout << "[s4d[Fill(1)[" << s4d << "]\n";
#endif

  cout << s4d.length() << "-" << s4d.getBufferSize() << endl;

  assert( s4d.length() ==  2 );
  assert( s4d.getBufferSize() ==  10 );

  s4a.FillBuffer( '2' );
  s4b.FillBuffer( '2' );
  s4c.FillBuffer( '2' );
  s4d.FillBuffer( '2' );

  assert( s4d.length() ==  10 );
  assert( s4d.getBufferSize() ==  10 );

  cout << s4d.length() << "-" << s4d.getBufferSize() << endl;

#ifndef __J2K__QUIET
  cout << "[s4a[FillBuf(2)[" << s4a << "]\n";
  cout << "[s4b[FillBuf(2)[" << s4b << "]\n";
  cout << "[s4c[FillBuf(2)[" << s4c << "]\n";
  cout << "[s4d[FillBuf(2)[" << s4d << "]\n";
#endif
}


void display() {
  cout << "Display all\n";
  s1a.Display();
  cout << endl;
  s1b.Display();
  cout << endl;
  s2.Display();
  cout << endl;
  s3.Display();
  cout << endl;
  s4a.Display();
  cout << endl;
  s4b.Display();
  cout << endl;
  s4c.Display();
  cout << endl;
  s4d.Display();
  cout << endl;
  s5.Display();
  cout << endl;
  s6a.Display();
  cout << endl;
  s6b.Display();
  cout << endl;
  s7a.Display();
  cout << endl;
  s7b.Display();
  cout << endl;
  s8.Display();
  cout << endl;
}

void displayTemp()
{
  temp.Display();
  cout << endl;

  temp2.Display();
  cout << endl;
}

void length() 
{
  assert( s1a.getLength() ==  0 );
  assert( s1b.getLength() ==  0 );
  assert(  s2.getLength() ==  5 );
  assert(  s3.getLength() ==  5 );
  assert( s4a.getLength() ==  0 );
  assert( s4b.getLength() ==  0 );
  assert( s4c.getLength() ==  0 );
  assert(  s5.getLength() ==  5 );
  assert( s6a.getLength() ==  1 );
  assert( s6b.getLength() ==  1 );
  assert( s7a.getLength() == 20 );
  assert( s7b.getLength() ==  5 );
  assert(  s8.getLength() ==  4 );

  assert( s1a.length() ==  0 );
  assert( s1b.length() ==  0 );
  assert(  s2.length() ==  5 );
  assert(  s3.length() ==  5 );
  assert( s4a.length() ==  0 );
  assert( s4b.length() ==  0 );
  assert( s4c.length() ==  0 );
  assert(  s5.length() ==  5 );
  assert( s6a.length() ==  1 );
  assert( s6b.length() ==  1 );
  assert( s7a.length() == 20 );
  assert( s7b.length() ==  5 );
  assert(  s8.length() ==  4 );

  assert( s1a.getLength() ==  s1a.length() );
  assert( s1b.getLength() ==  s1b.length() );
  assert(  s2.getLength() ==  s2.length() );
  assert(  s3.getLength() ==  s3.length() );
  assert( s4a.getLength() ==  s4a.length() );
  assert( s4b.getLength() ==  s4b.length() );
  assert( s4c.getLength() ==  s4c.length() );
  assert(  s5.getLength() ==  s5.length() );
  assert( s6a.getLength() ==  s6a.length() );
  assert( s6b.getLength() ==  s6b.length() );
  assert( s7a.getLength() ==  s7a.length() );
  assert( s7b.getLength() ==  s7b.length() );
  assert(  s8.getLength() ==  s8.length() );

  assert( s1a.getAllocLength() ==  0 );
  assert( s1b.getAllocLength() ==  0 );
  assert(  s2.getAllocLength() ==  5 );
  assert(  s3.getAllocLength() == 20 );
  assert( s4a.getAllocLength() ==  0 );
  assert( s4b.getAllocLength() ==  0 );
  assert( s4c.getAllocLength() ==  0 );
  assert(  s5.getAllocLength() == 20 );
  assert( s6a.getAllocLength() ==  1 );
  assert( s6b.getAllocLength() ==  1 );
  assert( s7a.getAllocLength() == 20 );
  assert( s7b.getAllocLength() ==  5 );
  assert(  s8.getAllocLength() ==  4 );

  assert( s1a.getBufferSize() ==  0 );
  assert( s1b.getBufferSize() ==  0 );
  assert(  s2.getBufferSize() ==  5 );
  assert(  s3.getBufferSize() == 20 );
  assert( s4a.getBufferSize() ==  0 );
  assert( s4b.getBufferSize() ==  0 );
  assert( s4c.getBufferSize() ==  0 );
  assert(  s5.getBufferSize() == 20 );
  assert( s6a.getBufferSize() ==  1 );
  assert( s6b.getBufferSize() ==  1 );
  assert( s7a.getBufferSize() == 20 );
  assert( s7b.getBufferSize() ==  5 );
  assert(  s8.getBufferSize() ==  4 );
}

void lock() 
{
  // Nobody holds a lock
  assert( s1a.getLockNb() ==  0 );
  assert( s1b.getLockNb() ==  0 );
  assert(  s2.getLockNb() ==  0 );
  assert(  s3.getLockNb() ==  0 );
  assert( s4a.getLockNb() ==  0 );
  assert( s4b.getLockNb() ==  0 );
  assert( s4c.getLockNb() ==  0 );
  assert(  s5.getLockNb() ==  0 );
  assert( s6a.getLockNb() ==  0 );
  assert( s6b.getLockNb() ==  0 );
  assert( s7a.getLockNb() ==  0 );
  assert( s7b.getLockNb() ==  0 );
  assert(  s8.getLockNb() ==  0 );

  assert( !s1a.isLock() );
  assert( !s1b.isLock() );
  assert(  !s2.isLock() );
  assert(  !s3.isLock() );
  assert( !s4a.isLock() );
  assert( !s4b.isLock() );
  assert( !s4c.isLock() );
  assert(  !s5.isLock() );
  assert( !s6a.isLock() );
  assert( !s6b.isLock() );
  assert( !s7a.isLock() );
  assert( !s7b.isLock() );
  assert(  !s8.isLock() );

  assert(  s1a.isUnlock() );
  assert(  s1b.isUnlock() );
  assert(   s2.isUnlock() );
  assert(   s3.isUnlock() );
  assert(  s4a.isUnlock() );
  assert(  s4b.isUnlock() );
  assert(  s4c.isUnlock() );
  assert(   s5.isUnlock() );
  assert(  s6a.isUnlock() );
  assert(  s6b.isUnlock() );
  assert(  s7a.isUnlock() );
  assert(  s7b.isUnlock() );
  assert(   s8.isUnlock() );
}

void comp() {
////////////////////////////////////////////////////
/// Compare utilities...                         ///
////////////////////////////////////////////////////

/* Not Implemented Yet.
  int CompareNoCase(const char* s) const;   // ignore case
  int Collate(const char *s) const;         // NLS aware
*/

#ifndef __J2K__QUIET
  cout << "Compare:\n";
#endif

  assert( s3.compare( s9 ) == 0 );
  assert( s3.compare( (char*)s9 ) == 0 );
  assert( s3.compare( "World" ) == 0 );
  assert( s9.compare( s3 ) == 0 );

  assert( s2 < s3  );
  assert( s2 < "Z" );
  assert( s3 > s2  );
  assert( s3 > "A" );

  assert( s2 <= s3  );
  assert( s2 <= "Z" );
  assert( s3 >= s2  );
  assert( s3 >= "A" );

  assert( s3 == s9 );
  assert( s3 == "World" );

  assert( s2 != s3 );
  assert( s3 != "Hello" );
}

void parse() {
//////////////////////////////////////////////////////////
/// Parsing and Casting utilities...                   ///
//////////////////////////////////////////////////////////

  // CAN BE DANGEROUS !

  assert( !strcmp( (char*)strPI, "3.14159265358979" ) );

  assert( ((int)(strPI)   ) == 3 );
  assert( ((long)(strPI)  ) == 3 );
  assert( ((double)(strPI)) == 3.14159265358979 );

#ifndef __J2K__QUIET
  cout << "Compare PI:\n";
#endif

  assert( strPI.parseInt()    == 3 );
  assert( strPI.parseLong()   == 3 );
  assert( strPI.parseDouble() == 3.14159265358979 );

  assert( !strcmp( strPI.parseString(), "3.14159265358979" ) );

  assert( !strcmp( strPI.toString(),  "3.14159265358979" ) );
  assert( !strcmp( strPI.getText(),   "3.14159265358979" ) );

///////////////////////////////////////////////////
/// Stream utilities...                         ///
///////////////////////////////////////////////////
#ifndef __J2K__QUIET
  cout  << "[strPI[" << strPI  << "]\n";
#endif

}

void assign() {
///////////////////////////////////////////////////
/// JString Assignment                          ///
///////////////////////////////////////////////////

  temp = strPI;

  strPI = "9.81";

  assert( strPI.parseDouble() == 9.81 );

  strPI = temp;

  assert(  strPI == temp   );
  assert( !( strPI != temp ) );

#ifndef __J2K__QUIET
  cout << "[temp[" << temp << "]\n";
#endif

  temp = 'a';

#ifndef __J2K__QUIET
  cout << "[temp[" << temp << "]\n";
#endif

  
  assert( !strcmp( temp, "a" )  );

  temp = "Fred";

  assert( temp == "Fred" );
  assert( temp != "FRED" );
  assert( temp != "fred" );
}

void concat() {
/////////////////////////////////////////////////////
/// JString Concatenation                         ///
/////////////////////////////////////////////////////

#ifndef __J2K__QUIET
  cout << "Additions:\n";
#endif

  temp = s2;

  s2.Append( " Fred...", 8 );

  assert( s2 == "Hello Fred...");

  s2 = temp;

  s2 += s3;

  assert( s2 == "HelloWorld" );

  s2 = temp;

  JString temp3 = s3;

  temp2 = s3;

  assert( temp2 == temp3 );

  s3 += s2;

  assert( s3 == "WorldHello" );
  assert( s2.OK() );
  assert( s3.OK() );

  s3 += "!";
  assert( s3.OK() );
  assert( s3 == "WorldHello!" );

  s2 += temp2;
  s2 += "$";
  assert( s2.OK() );

  assert( temp  == "Hello" );
  assert( temp2 == "World" );
  assert( s2 == "HelloWorld$" );

  s2 += " Fred $ ";

  assert( s2 == "HelloWorld$ Fred $ " );

  s3 = temp2;
  s2 = temp;

  assert( s3 == "World" );
  assert( s2 == "Hello" );
}

void add() {
////////////////////////////////////////////////////////////////////////////
/// JString Addition                                                     ///
////////////////////////////////////////////////////////////////////////////

  temp = s2 + s3;
  temp += '!';

  char* A = "Alpha";
  char* B = "Beta";

  assert( temp == "HelloWorld!" );

  temp += A;
  temp += B;

  assert( temp == "HelloWorld!AlphaBeta" );

  temp = temp + "=)";

  assert( temp == "HelloWorld!AlphaBeta=)" );

  temp = "=]" + temp + " =}";

  assert( temp == "=]HelloWorld!AlphaBeta=) =}" );

  temp = "{" + temp;

  assert( temp == "{=]HelloWorld!AlphaBeta=) =}" );

  temp2 = temp;
}

void tools() {
////////////////////////////////////////////////////////////////////////////
/// Upper/Lower/Reverse Conversion (QuickBasic Compatible)               ///
////////////////////////////////////////////////////////////////////////////
/// Defined in:  StrTools.cpp                                            ///
////////////////////////////////////////////////////////////////////////////
  cout << "\nTesting tools()...\n" << endl;

  assert( temp == "{=]HelloWorld!AlphaBeta=) =}" );

  displayTemp();

  temp.MakeUpper();

  displayTemp();

  assert( temp == "{=]HELLOWORLD!ALPHABETA=) =}" );
  
  temp.MakeLower();
  assert( temp == "{=]helloworld!alphabeta=) =}" );

  temp.MakeReverse();

  assert( temp == "}= )=atebahpla!dlrowolleh]={" );
  
  temp.MakeReverse();
  assert( temp == "{=]helloworld!alphabeta=) =}" );

  temp.UCase();
  assert( temp == "{=]HELLOWORLD!ALPHABETA=) =}" );
  
  temp.LCase();
  assert( temp == "{=]helloworld!alphabeta=) =}" );

  temp.Reverse();

#ifndef __J2K__QUIET
  cout << "T:" << "[temp[" << temp << "]\n";
  cout << "R:" << Reverse( temp ) << endl;
#endif

  assert( temp == "}= )=atebahpla!dlrowolleh]={" );
  assert( Reverse( temp ) == "{=]helloworld!alphabeta=) =}" );

  temp = temp2;

#ifndef __J2K__QUIET
  cout << "T:" << "[temp[" << temp << "]\n";
  cout << "U:" << UCase( temp ) << endl;
  cout << "RR:" << LCase( temp ) << endl;
  cout << "RR:" << Reverse( Reverse( temp2 ) ) << endl;
  cout << "URR:" << UCase( Reverse( Reverse( temp2 ) ) ) << endl;
  cout << "LRR:" << LCase( Reverse( Reverse( temp2 ) ) ) << endl;
#endif

  assert( temp == temp2 );
  assert( temp == "{=]HelloWorld!AlphaBeta=) =}" );
  assert( UCase( temp ) == "{=]HELLOWORLD!ALPHABETA=) =}" );
  assert( LCase( temp ) == "{=]helloworld!alphabeta=) =}" );
  assert( Reverse( Reverse( temp2 ) ) == temp2 );
  assert( UCase( Reverse( Reverse( temp2 ) ) ) == "{=]HELLOWORLD!ALPHABETA=) =}" );
  assert( LCase( Reverse( Reverse( temp2 ) ) ) == "{=]helloworld!alphabeta=) =}" );

  assert( temp == temp2 );
  assert( temp == "{=]HelloWorld!AlphaBeta=) =}" );
  assert( temp.setUpper() == "{=]HELLOWORLD!ALPHABETA=) =}" );
  assert( temp.setLower() == "{=]helloworld!alphabeta=) =}" );

  temp = temp2;
  assert( temp == temp2 );
  assert( temp == "{=]HelloWorld!AlphaBeta=) =}" );
  assert( temp.setReverse().setReverse() == temp2 );
  assert( temp.setUpper().setReverse().setReverse() == "{=]HELLOWORLD!ALPHABETA=) =}" );
  assert( temp.setLower().setReverse().setReverse() == "{=]helloworld!alphabeta=) =}" );

  temp = temp2;
  assert( temp == temp2 );
  assert( !strcmp(temp.getUpper(), "{=]HELLOWORLD!ALPHABETA=) =}" ));
  assert( !strcmp(temp.getLower(), "{=]helloworld!alphabeta=) =}" ));

  temp = temp2;
  assert( temp == temp2 );
  assert( temp == "{=]HelloWorld!AlphaBeta=) =}" );
  assert( !strcmp(temp.setReverse().getReverse(), temp2.toString() ) );
  assert( !strcmp(temp.setReverse().getUpper(), "{=]HELLOWORLD!ALPHABETA=) =}"));
  assert( !strcmp(temp.setReverse().setReverse().getLower(), "{=]helloworld!alphabeta=) =}"));
}

void qbtools() {
////////////////////////////////////////////////////////////////////////////
/// Search/Find/ReverseFind function (QuickBasic Compatible)             ///
////////////////////////////////////////////////////////////////////////////

  cout << "QB Tools:\n";
  // searching (return starting index,
  // or -1 if not found)
  // look for a single character match
  temp = LCase( temp2 );
  assert( temp2 == "{=]HelloWorld!AlphaBeta=) =}" );
  assert( temp.Find( 'w' ) == 8 );  // i.e. temp[8] == 'w'
  assert( Reverse( temp ).Find( 'w' ) == 19 );
  assert( UCase( Reverse( temp ) ).Find( 'w' ) == -1 );
  assert( UCase( Reverse( temp ) ).Find( 'W' ) == 19 );
  assert( UCase( Reverse( temp ) ).ReverseFind( 'W' ) == 8 );

  assert( temp.Find( "hello"    ) == 3 );
  assert( temp.Find( "hello", 3 ) == 0 );

  assert( temp.Find( 'w' ) == 8 );  // i.e. temp[8] == 'w'
  assert( temp.setReverse().Find( 'w' ) == 19 );
  
  temp = temp2;
  assert( temp.setReverse().setUpper().Find( 'w' ) == -1 );
  
  temp = temp2;
  assert( temp.setReverse().setUpper().Find( 'W' ) == 19 );

  temp = temp2;
  assert( temp.setReverse().setUpper().ReverseFind( 'W' ) == 8 );

  temp = temp2;
  assert( temp.setReverse().setReverse().Find( "Hello"    ) == 3 );
  assert( temp.setReverse().setReverse().Find( "Hello", 3 ) == 0 );
}

void atX() {

//////////////////////////////////////////////////
/// At X do this...                            ///
//////////////////////////////////////////////////

  cout << "AtX()\n";

  s4d = "World";

  assert( s4d == "World" );

  // Should check with at( -1 )
  s1a = temp.at(  temp.setReverse().Find( s4d.getReverse() )  ).setReverse();
  assert( s1a == "{=]HelloWorld" );

  s1b = s1a.at(  s1a.Find( s4d )  );
  assert( s1b.at() == "World" );

  temp.setReverse();
  assert( temp == temp2 );

  long start = temp.Find( s4d );
  long len   = s4d.length();

  assert( start == 8 ); // Find "World"
  assert( len   == 5 );

  JString atxy = temp.at( start, len );
 
  assert( atxy == s4d );  // in steps
  assert( temp.at( temp.Find( s4d ), s4d.length() ) == s4d );  // One shot pipelined

  atxy = temp.at( temp.Find( s4d ), s4d.length() ).setReverse();

  cout << s4d.getReverse() << endl;
  displayTemp();

  assert( atxy == s4d.getReverse() ); // In steps
  assert( temp.at( temp.Find( s4d ), s4d.length() ).setReverse() == s4d.getReverse() ); // One Shot

  temp = temp2;

  s4d = "World";

  assert( s4d == "World" );


// With operator()

  // Should check with at( -1 )
  s1a = temp(  temp.setReverse().Find( s4d.getReverse() )  ).setReverse();
  assert( s1a == "{=]HelloWorld" );

  s1b = s1a(  s1a.Find( s4d )  );
  assert( s1b.at() == "World" );

  temp.setReverse();
  assert( temp == temp2 );

  assert( temp( temp.Find( s4d ), s4d.length() ) == s4d );
  assert( temp( temp.Find( s4d ), s4d.length() ).setReverse() == s4d.getReverse() );

  assert( temp.at( s4d.getText(), 0 ).left(5) == s4d );

  assert( temp.at( s4d, 0 ).left(5).right(2) == "ld" );
  assert( temp.mid( s4d, 0, 5 ).right( 2 ) == "ld" );

  cout << temp.at( s4d.getText(), 0 ).left(5) << "]\n";
  cout << "\n[" << temp( s4d.getText(), 0 ) << "]\n";

  // Use at()  for trim

  s1a = temp.setAt( temp.Find( s4d ), 'w' );
  assert( s1a.at( s4d.setLower(), 0 ).left(5) == LCase( s4d ) );
  
}

void ansi() {
//////////////////////////////////////////////////////////////
/// Every function str* from ANSI definition               ///
//////////////////////////////////////////////////////////////

  cout << temp << endl;
  cout << temp.firstCharFound( 'l' ) << endl; // forward pos
  cout << temp.lastCharFound( 'l'  ) << endl; // forward pos

  assert( temp[ temp.firstCharFound( 'l' ) ] == 'l' );
  assert( temp[ temp.lastCharFound( 'l' )  ] == 'l' );

  assert( temp.getAt( temp.firstCharFound( 'l' ) ) == 'l' );
  assert( temp.getAt( temp.lastCharFound( 'l' )  ) == 'l' );

  assert( temp.firstCharFound( 'l' ) ==  5 );
  assert( temp.lastCharFound( 'l' )  == 15 );

/*
  char*    getConcatenate( const char* src );
  JString& setConcatenate( const char* src );
  int      compare( const char* src );
  int      compareIgnoreCase( const char* src );
  int      compareUsingLocaleCollate( const char* src );
  char*    copy();
  JString& getCopy();
  size_t   getNbCharNotFromCharSet( const char* charset );
  JString& getDate();  // MM/DD/YY format (not Y2K complient !)
  JString& setDate();  // MM/DD/YY format (not Y2K complient !)

  JString& setTime( size_t maxSize, const char* format, const struct tm* currTime );
 
  char*    duplicate();
  JString& duplicateString();
  JString& getError( int errnb );
  JString& setError( int errnb );
  JString& getTimeFormat( size_t maxSize, const char* format, const struct tm* currTime );
  JString& setTimeFormat( size_t maxSize, const char* format, const struct tm* currTime );
  JString& getTime();  // HH:MM:SS  (24h)
  JString& setTime();  // HH:MM:SS  (24h)

  char*    getConcatenateWithLimits( const char* src, size_t n );
  JString& setConcatenateWithLimits( const char* src, size_t n );
  int      compareWithLimits( const char* src, size_t n );
  int      compareIgnoreCaseWithLimits( const char* src, size_t n );
  char*    copyWithLimits( size_t n );
  JString& getCopyWithLimits( size_t n );
  char*    getFillWithChar( const int ch );
  JString& setFillWithChar( const int ch );
  char*    getFillWithChar( const int ch, size_t n );
  JString& setFillWithChar( const int ch, size_t n );
 
  // Return Where is the first charset in String
  long   locateCharSet( const char* charset );
  long   locateCharSet( const char* charset, size_t startAt );

  // Return How much of charset in String
  size_t   findCharset( const char* charset );
  size_t   findCharset( const char* charset, size_t startAt );


  // Return Where is the first String given in String
  long   findString( const char* s );
  long   findString( const char* s, size_t startAt );

  double   toDouble();
  double   toDouble( size_t startAt );

  long   toLong();
  long   toLong( size_t base );
  long   toLong( size_t startAt, size_t base );

  ULONG  toULONG();
  ULONG  toULONG( size_t base );
  ULONG  toULONG( size_t startAt, size_t base );

  char*    getTransform( const char* src, size_t n );
  JString& setTransform( const char* src, size_t n );
  char*    getTokens( const char* delims, size_t startAt );
  char*    getMoreTokens( const char* delims );
  JString& getStringTokens( const char* delims, size_t startAt );
  JString& getMoreStringTokens( const char* delims );

*/

/**************************************************************************
 *  NOT DEFINED YET !
 **************************************************************************/

////////////////////////////////////////////////////////////////////////////
/// Trimming Space  (QuickBasic compatible)                              ///
////////////////////////////////////////////////////////////////////////////
/*
  void TrimRight();   // lib g++ format
  void TrimLeft();

  // Might return JString object in the future...
  inline void LTrim();  // QB format
  inline void RTrim();
  inline void Trim();

////////////////////////////////////////////////////////////////////////////
/// Span Include/Exclude function                                        ///
////////////////////////////////////////////////////////////////////////////
  JString SpanIncluding(const char* s) const;
  JString SpanExcluding(const char* s) const;

////////////////////////////////////////////////////////////////////////////
/// Simple formatting function ( using  "sprintf"  Format )              ///
////////////////////////////////////////////////////////////////////////////
  // simple formatting
  void Format(const char* s Format, ...);
  void Format(size_t nFormatID, ...);
  void FormatV(const char* lpszFormat, va_list argList);

*************************************************************************

*/

////////////////////////////////////////////////////////////////////////////
/// Unlock/Lock Buffer turn Ref counting on/off (MFC JString compatible) ///
/// AND everything else related to Buffer and Allocation...        ///
////////////////////////////////////////////////////////////////////////////
/// Defined in:  StrExtra.cpp   (NOT FULLY SUPPORTED YET)        ///
////////////////////////////////////////////////////////////////////////////
/*  
  inline void AllocBuffer(size_t nLen);
  inline void AllocBeforeWrite(size_t nLen);

  inline char* LockBuffer();
  inline void  UnlockBuffer();

  void  FreeExtra();
  char* GetBuffer(size_t minBufferLength);

  inline void  ReleaseBuffer();
  */
}

int main() 
{
  debug();
  init();
  fill();

  display();
  displayTemp();

  length();
  lock();
  comp();
  parse();
  assign();
  concat();
  add();
  tools();
  qbtools();
  atX();

  ansi();

  cout << "Done! \n";

  return 0;
}

---