Back to index

lightning-sunbird  0.9+nobinonly
Classes | Typedefs | Functions
test_main.cpp File Reference
#include <iostream.h>
#include "nsStringIO.h"
#include "nsString.h"
#include "nsFragmentedString.h"
#include "nsReadableUtils.h"
#include "nsSlidingString.h"

Go to the source code of this file.

Classes

struct  string_class_traits< T >
struct  string_class_traits< PRUnichar >
struct  string_class_traits< char >

Typedefs

typedef nsString nsStdString
typedef nsCString nsStdCString
typedef voidvoid_ptr

Functions

template<class CharT >
basic_nsLiteralString< CharTliteral_hello (CharT *)
NS_SPECIALIZE_TEMPLATE
basic_nsLiteralString< char > 
literal_hello (char *)
NS_SPECIALIZE_TEMPLATE
basic_nsLiteralString
< PRUnichar
literal_hello (PRUnichar *)
static void CallCMid (nsACString &aResult, const nsACString &aSource, PRUint32 aStartPos, PRUint32 aLengthToCopy)
template<class CharT >
int test_multifragment_iterators (const basic_nsAString< CharT > &aString)
template<class CharT >
int test_Vidur_functions (const basic_nsAString< CharT > &aString)
template<class CharT >
int test_readable_hello (const basic_nsAString< CharT > &aReadable)
template<class CharT >
int test_SetLength (basic_nsAString< CharT > &aWritable)
template<class CharT >
int test_insert (basic_nsAString< CharT > &aWritable)
template<class CharT >
int test_cut (basic_nsAString< CharT > &aWritable)
template<class CharT >
int test_self_assign (basic_nsAString< CharT > &aWritable)
template<class CharT >
int test_self_append (basic_nsAString< CharT > &aWritable)
template<class CharT >
int test_self_insert (basic_nsAString< CharT > &aWritable)
template<class CharT >
int test_self_replace (basic_nsAString< CharT > &aWritable)
template<class CharT >
int test_writable (basic_nsAString< CharT > &aWritable)
int main ()
 main()

Class Documentation

struct string_class_traits

template<class T>
struct string_class_traits< T >

Definition at line 45 of file test_main.cpp.


Typedef Documentation

Definition at line 16 of file test_main.cpp.

Definition at line 15 of file test_main.cpp.

typedef void* void_ptr

Definition at line 422 of file test_main.cpp.


Function Documentation

static void CallCMid ( nsACString &  aResult,
const nsACString &  aSource,
PRUint32  aStartPos,
PRUint32  aLengthToCopy 
) [static]

Definition at line 70 of file test_main.cpp.

  {
    aSource.Mid(aResult, aStartPos, aLengthToCopy);
  }

Here is the caller graph for this function:

template<class CharT >
basic_nsLiteralString<CharT> literal_hello ( CharT )

Definition at line 21 of file test_main.cpp.

  {
  }

Here is the caller graph for this function:

NS_SPECIALIZE_TEMPLATE basic_nsLiteralString<char> literal_hello ( char *  )

Definition at line 27 of file test_main.cpp.

  {
    return basic_nsLiteralString<char>("Hello");
  }
NS_SPECIALIZE_TEMPLATE basic_nsLiteralString<PRUnichar> literal_hello ( PRUnichar )

Definition at line 34 of file test_main.cpp.

  {
#ifdef HAVE_CPP_2BYTE_WCHAR_T
    return basic_nsLiteralString<PRUnichar>(L"Hello");
#else
    static PRUnichar constant_unicode[] = { 'H', 'e', 'l', 'l', 'o', PRUnichar() };
    return basic_nsLiteralString<PRUnichar>(constant_unicode);
#endif
  }
int main ( void  )

main()

Definition at line 425 of file test_main.cpp.

  {    
    int tests_failed = 0;
       cout << "String unit tests.  Compiled " __DATE__ " " __TIME__ << endl;

#if 0
    {
      nsFragmentedCString fs0;
      fs0.Append("Hello");
      tests_failed += test_readable_hello(fs0);
      tests_failed += test_writable(fs0);
    }
#endif

    {
      NS_NAMED_LITERAL_STRING(literal, "Hello");
      PRUnichar* buffer = ToNewUnicode(literal);

      nsSlidingString ss0(buffer, buffer+5, buffer+6);
//    ss0.AppendBuffer(buffer, buffer+5, buffer+6);
      nsReadingIterator<PRUnichar> ri0;
      ss0.BeginReading(ri0);

      tests_failed += test_readable_hello(ss0);

      nsSlidingSubstring ss1(ss0);
      tests_failed += test_readable_hello(ss1);

      buffer = ToNewUnicode(literal);
      ss0.AppendBuffer(buffer, buffer+5, buffer+6);

      ri0.advance(5);
      ss0.DiscardPrefix(ri0);

      tests_failed += test_readable_hello(ss0);
      tests_failed += test_readable_hello(ss1);

      nsReadingIterator<PRUnichar> ri1;
      ss0.EndReading(ri1);

      nsSlidingSubstring ss2(ss0, ri0, ri1);
      tests_failed += test_readable_hello(ss2);
    }


    {
      nsLiteralCString s0("Patrick Beard made me write this: \"This is just a test\"\n");
      print_string(s0);

      const char* raw_string = "He also made me write this.\n";
      nsFileCharSink<char> output(stdout);
      copy_string(raw_string, raw_string+nsCharTraits<char>::length(raw_string), output);

      nsLiteralCString s1("This ", 5), s2("is ", 3), s3("a ", 2), s4("test\n", 5);
      print_string(s1+s2+s3+s4);

      nsLiteralCString s5( "This is " "a " "test" );
      print_string(s5+NS_LITERAL_CSTRING("\n"));

      print_string(nsLiteralCString("The value of the string |x| is \"") + Substring(s0, 0, s0.Length()-1) + NS_LITERAL_CSTRING("\".  Hope you liked it."));
    }


    {
      tests_failed += test_readable_hello(NS_LITERAL_STRING("Hello"));

      nsLiteralCString s1("Hello");
      tests_failed += test_readable_hello(s1);
    }

    {

      nsString s3( NS_LITERAL_STRING("Hello") );

      tests_failed += test_readable_hello(s3);
      tests_failed += test_writable(s3);

      nsCString s4("Hello");
      tests_failed += test_readable_hello(s4);
      tests_failed += test_writable(s4);
    }

    {
      nsStdString s5( NS_LITERAL_STRING("Hello") );

      tests_failed += test_readable_hello(s5);
      tests_failed += test_writable(s5);

      nsStdCString s6("Hello");
      tests_failed += test_readable_hello(s6);
      tests_failed += test_writable(s6);
    }

    {
      nsLiteralString s7(NS_LITERAL_STRING("He"));
      nsString        s8(NS_LITERAL_STRING("l"));
      nsStdString     s9(NS_LITERAL_STRING("lo"));

      tests_failed += test_readable_hello(s7+s8+s9);

      nsString s13( s7 + s8 + s9 );
      tests_failed += test_readable_hello(s13);

      nsStdString s14( s7 + s8 + s9 );
      tests_failed += test_readable_hello(s14);

      nsCString         s10("He");
      nsLiteralCString  s11("l");
      nsStdCString      s12("lo");
      
      tests_failed += test_readable_hello(s10+s11+s12);

      
    }

    {
      const char *foo = "this is a really long string";
      nsCString origString;
      nsCString string2;
      nsCString string3;

      origString = foo;

      string2 = Substring(origString, 0, 5);
      string3 = Substring(origString, 6, origString.Length() - 6);
    }

    {
      nsLiteralCString s13("He");
      nsCAutoString    s14("l");
      nsLiteralCString s15("lo");

      s14.Assign(s13 + s14 + s15);

      if ( int failures = test_readable_hello(s14) )
        {
          tests_failed += failures;
          cout << "FAILED to keep a promise." << endl;
        }
    }


    {
      nsLiteralCString str1("Hello");
      nsStdCString str2("Hello");

      nsLiteralCString str3("Hello there");

      if ( str1 != str2 )
        {
          cout << "string comparison using != failed" << endl;
          ++tests_failed;
        }

      if ( !(str3 > str2) )
        {
          cout << "string comparison using > failed" << endl;
          ++tests_failed;
        }

      if ( !(str2 < str3) )
        {
          cout << "string comparison using < failed" << endl;
          ++tests_failed;
        }

      if ( str1 != "Hello" )
        {
          cout << "string comparison using == failed" << endl;
          ++tests_failed;
        }
    }

#if 0
    nsStdCString extracted_middle("XXXXXXXXXX");
    CallCMid(extracted_middle, part1+part2a+part2b, 1, 3);
    
    cout << "The result of mid was \"" << extracted_middle << "\"" << endl;
    
    nsLiteralCString middle_answer("ell");
    if ( middle_answer != extracted_middle )
      {
        cout << "mid FAILED on nsConcatString" << endl;
        ++tests_failed;
      }



      //
      // |nsStdStringWrapper|, i.e., |nsStdCString|
      //

    {
      nsStdCString extracted_middle;
      CallCMid(extracted_middle, part1+part2a+part2b, 1, 3);

     cout << "The result of mid was \"" << extracted_middle << "\"" << endl;

      nsLiteralCString middle_answer("ell");
      if ( middle_answer != extracted_middle )
        {
          cout << "mid FAILED on nsStdCString" << endl;
          ++tests_failed;
        }
    }



    nsStdCString leftString;
    source.Left(leftString, 9);
    // cout << static_cast<const nsACString>(leftString) << endl;



    tests_failed += test_multifragment_iterators(part1+part2a+part2b);
#endif

    
    
    cout << "End of string unit tests." << endl;
    if ( !tests_failed )
      cout << "OK, all tests passed." << endl;
    else
      cout << "FAILED one or more tests." << endl;

       return tests_failed;
  }

Here is the call graph for this function:

template<class CharT >
int test_cut ( basic_nsAString< CharT > &  aWritable)

Definition at line 305 of file test_main.cpp.

  {
    int tests_failed = 0;

    aWritable.Cut(0, aWritable.Length()+5);

    return tests_failed;
  }

Here is the caller graph for this function:

template<class CharT >
int test_insert ( basic_nsAString< CharT > &  aWritable)

Definition at line 274 of file test_main.cpp.

  {
    int tests_failed = 0;

    string_class_traits<CharT>::implementation_t oldValue(aWritable);

    if ( oldValue != aWritable )
      {
        cout << "FAILED saving the old string value in |test_insert|." << endl;
        ++tests_failed;
      }

    string_class_traits<CharT>::implementation_t insertable( string_class_traits<CharT>::literal_hello() );

    insertable.SetLength(1);
    aWritable.Insert(insertable, 0);

    if ( aWritable != (insertable + oldValue) )
      {
        cout << "FAILED in |test_insert|." << endl;
        ++tests_failed;
      }

    aWritable = oldValue;

    return tests_failed;
  }

Here is the caller graph for this function:

template<class CharT >
int test_multifragment_iterators ( const basic_nsAString< CharT > &  aString)

Definition at line 79 of file test_main.cpp.

  {
    typedef typename basic_nsAString<CharT>::const_iterator ConstIterator;

    int tests_failed = 0;

    ConstIterator iter1 = aString.BeginReading();
    ConstIterator iter2 = aString.BeginReading();
    ++iter2; ++iter2;

    ConstIterator iter3 = aString.EndReading();
    --iter3;
    ++iter1; ++iter1;
    if ( iter1 != iter2 )
      {
        cout << "FAILED in |test_multifragment_iterators|" << endl;
        ++tests_failed;
      }

    return tests_failed;
  }

Here is the caller graph for this function:

template<class CharT >
int test_readable_hello ( const basic_nsAString< CharT > &  aReadable)

Definition at line 124 of file test_main.cpp.

  {
    int tests_failed = 0;

    if ( aReadable.Length() != 5 )
      {
        cout << "FAILED |test_readable_hello|: |Length()| --> " << aReadable.Length() << endl;
        ++tests_failed;
      }

    if ( aReadable.First() != CharT('H') )
      {
        cout << "FAILED |test_readable_hello|: |First()| --> '" << aReadable.First() << "'" << endl;
        ++tests_failed;
      }

    if ( aReadable.Last() != CharT('o') )
      {
        cout << "FAILED |test_readable_hello|: |Last()| --> '" << aReadable.Last() << "'" << endl;
        ++tests_failed;
      }

    if ( aReadable[3] != CharT('l') )
      {
        cout << "FAILED |test_readable_hello|: |operator[]| --> '" << aReadable[3] << "'" << endl;
        ++tests_failed;
      }

    if ( aReadable.CountChar( CharT('l') ) != 2 )
      {
        cout << "FAILED |test_readable_hello|: |CountChar('l')| --> " << aReadable.CountChar(CharT('l')) << endl;
        ++tests_failed;
      }

    basic_nsAString<CharT>::const_iterator iter = aReadable.BeginReading();
    if ( *iter != CharT('H') )
      {
        cout << "FAILED |test_readable_hello|: didn't start out pointing to the right thing, or else couldn't be dereferenced. --> '" << *iter << "'" << endl;
        ++tests_failed;
      }

    ++iter;

    if ( *iter != CharT('e') )
      {
        cout << "FAILED |test_readable_hello|: iterator couldn't be incremented, or else couldn't be dereferenced. --> '" << *iter << "'" << endl;
        ++tests_failed;
      }

    iter = aReadable.EndReading();
    --iter;
    if ( *iter != CharT('o') )
      {
        cout << "FAILED |test_readable_hello|: iterator couldn't be set to |EndReading()|, or else couldn't be decremented, or else couldn't be dereferenced. --> '" << *iter << "'" << endl;
        ++tests_failed;
      }

    basic_nsAString<CharT>::const_iterator iter1 = aReadable.BeginReading().advance(3);
    if ( *iter1 != CharT('l') )
      {
        cout << "FAILED |test_readable_hello|: iterator couldn't be set to |BeginReading()+=n|, or else couldn't be dereferenced. --> '" << *iter1 << "'" << endl;
        ++tests_failed;
      }

    basic_nsAString<CharT>::const_iterator iter2 = aReadable.EndReading().advance(-2);
    if ( *iter2 != CharT('l') )
      {
        cout << "FAILED |test_readable_hello|: iterator couldn't be set to |EndReading()-=n|, or else couldn't be dereferenced. --> '" << *iter2 << "'" << endl;
        ++tests_failed;
      }

    if ( iter1 != iter2 )
      {
        cout << "FAILED |test_readable_hello|: iterator comparison with !=." << endl;
        ++tests_failed;
      }

    if ( !(iter1 == iter2) )
      {
        cout << "FAILED |test_readable_hello|: iterator comparison with ==." << endl;
        ++tests_failed;
      }

    typedef CharT* CharT_ptr;
    if ( aReadable != literal_hello(CharT_ptr()) )
      {
        cout << "FAILED |test_readable_hello|: comparison with \"Hello\"" << endl;
        ++tests_failed;
      }

    tests_failed += test_multifragment_iterators(aReadable);
    // tests_failed += test_deprecated_GetBufferGetUnicode(aReadable);

    test_Vidur_functions(aReadable);

    return tests_failed;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

template<class CharT >
int test_self_append ( basic_nsAString< CharT > &  aWritable)

Definition at line 334 of file test_main.cpp.

  {
    int tests_failed = 0;
    string_class_traits<CharT>::implementation_t oldValue(aWritable);

    aWritable += aWritable;
    if ( aWritable != oldValue + oldValue )
      {
        cout << "FAILED self append." << endl;
        ++tests_failed;
      }

    aWritable = oldValue;
    return tests_failed;
  }

Here is the caller graph for this function:

template<class CharT >
int test_self_assign ( basic_nsAString< CharT > &  aWritable)

Definition at line 316 of file test_main.cpp.

  {
    int tests_failed = 0;
    string_class_traits<CharT>::implementation_t oldValue(aWritable);

    aWritable = aWritable;
    if ( aWritable != oldValue )
      {
        cout << "FAILED self assignment." << endl;
        ++tests_failed;
      }

    aWritable = oldValue;
    return tests_failed;
  }

Here is the caller graph for this function:

template<class CharT >
int test_self_insert ( basic_nsAString< CharT > &  aWritable)

Definition at line 352 of file test_main.cpp.

  {
    int tests_failed = 0;
    string_class_traits<CharT>::implementation_t oldValue(aWritable);

    aWritable.Insert(aWritable, 0);
    if ( aWritable != oldValue + oldValue )
      {
        cout << "FAILED self insert." << endl;
        ++tests_failed;
      }

    aWritable = oldValue;
    return tests_failed;
  }

Here is the caller graph for this function:

template<class CharT >
int test_self_replace ( basic_nsAString< CharT > &  aWritable)

Definition at line 370 of file test_main.cpp.

  {
    int tests_failed = 0;
    string_class_traits<CharT>::implementation_t oldValue(aWritable);

    aWritable.Replace(0, 0, aWritable);
    if ( aWritable != oldValue + oldValue )
      {
        cout << "FAILED self insert." << endl;
        ++tests_failed;
      }

    aWritable = oldValue;
    return tests_failed;
  }

Here is the caller graph for this function:

template<class CharT >
int test_SetLength ( basic_nsAString< CharT > &  aWritable)

Definition at line 225 of file test_main.cpp.

  {
    int tests_failed = 0;

    string_class_traits<CharT>::implementation_t oldValue(aWritable);


    size_t oldLength = aWritable.Length();

    if ( oldValue != Substring(aWritable, 0, oldLength) )
      {
        cout << "FAILED growing a string in |test_SetLength|, saving the value didn't work." << endl;
        ++tests_failed;
      }

    size_t newLength = 2*(oldLength+1);

    aWritable.SetLength(newLength);
    if ( aWritable.Length() != newLength )
      {
        cout << "FAILED growing a string in |test_SetLength|, length is wrong." << endl;
        ++tests_failed;
      }

    if ( oldValue != Substring(aWritable, 0, oldLength) )
      {
        cout << "FAILED growing a string in |test_SetLength|, contents damaged after growing." << endl;
        ++tests_failed;
      }

    aWritable.SetLength(oldLength);
    if ( aWritable.Length() != oldLength )
      {
        cout << "FAILED shrinking a string in |test_SetLength|." << endl;
        ++tests_failed;
      }

    if ( oldValue != Substring(aWritable, 0, oldLength) )
      {
        cout << "FAILED growing a string in |test_SetLength|, contents damaged after shrinking." << endl;
        ++tests_failed;
      }

    return tests_failed;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

template<class CharT >
int test_Vidur_functions ( const basic_nsAString< CharT > &  aString)

Definition at line 111 of file test_main.cpp.

  {
    char* char_copy = ToNewCString(aString);
    PRUnichar* PRUnichar_copy = ToNewUnicode(aString);

    nsMemory::Free(PRUnichar_copy);
    nsMemory::Free(char_copy);

    return 0;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

template<class CharT >
int test_writable ( basic_nsAString< CharT > &  aWritable)

Definition at line 390 of file test_main.cpp.

  {
    int tests_failed = 0;
    // ...


    {
      typedef CharT* CharT_ptr;
      aWritable = literal_hello(CharT_ptr());

      if ( aWritable != literal_hello(CharT_ptr()) )
        {
          cout << "FAILED assignment and/or comparison in |test_writable|." << endl;
          ++tests_failed;
        }

      tests_failed += test_readable_hello(aWritable);
    }

    tests_failed += test_SetLength(aWritable);
    tests_failed += test_insert(aWritable);
    tests_failed += test_cut(aWritable);
    tests_failed += test_self_assign(aWritable);
    tests_failed += test_self_append(aWritable);
    tests_failed += test_self_insert(aWritable);
    tests_failed += test_self_replace(aWritable);

    return tests_failed;
  }

Here is the call graph for this function:

Here is the caller graph for this function: