From 51948b288bff89f56c3c97cba12ad3c42903c026 Mon Sep 17 00:00:00 2001 From: "scc%netscape.com" Date: Tue, 14 Mar 2000 15:56:34 +0000 Subject: [PATCH] First Checked In. git-svn-id: svn://10.0.0.236/trunk@62939 18797224-902f-48f8-a5cc-f745e15eee43 --- .../StringFactoringTests/StringTest.Prefix | 4 + .../tests/StringFactoringTests/StringTest.mcp | Bin 0 -> 183178 bytes .../StringTestProfileNew.Prefix | 3 + .../StringTestProfileOld.Prefix | 4 + .../StringTestProfileStd.Prefix | 5 + .../StringFactoringTests/nsStdStringWrapper.h | 242 +++++++++++ .../StringFactoringTests/profile_main.cpp | 353 ++++++++++++++++ .../tests/StringFactoringTests/test_main.cc | 391 ++++++++++++++++++ 8 files changed, 1002 insertions(+) create mode 100644 mozilla/xpcom/tests/StringFactoringTests/StringTest.Prefix create mode 100644 mozilla/xpcom/tests/StringFactoringTests/StringTest.mcp create mode 100644 mozilla/xpcom/tests/StringFactoringTests/StringTestProfileNew.Prefix create mode 100644 mozilla/xpcom/tests/StringFactoringTests/StringTestProfileOld.Prefix create mode 100644 mozilla/xpcom/tests/StringFactoringTests/StringTestProfileStd.Prefix create mode 100644 mozilla/xpcom/tests/StringFactoringTests/nsStdStringWrapper.h create mode 100644 mozilla/xpcom/tests/StringFactoringTests/profile_main.cpp create mode 100644 mozilla/xpcom/tests/StringFactoringTests/test_main.cc diff --git a/mozilla/xpcom/tests/StringFactoringTests/StringTest.Prefix b/mozilla/xpcom/tests/StringFactoringTests/StringTest.Prefix new file mode 100644 index 00000000000..4290c83c3de --- /dev/null +++ b/mozilla/xpcom/tests/StringFactoringTests/StringTest.Prefix @@ -0,0 +1,4 @@ +// StringTest.Prefix + +#define SCC_TESTS +#define NEW_STRING_APIS diff --git a/mozilla/xpcom/tests/StringFactoringTests/StringTest.mcp b/mozilla/xpcom/tests/StringFactoringTests/StringTest.mcp new file mode 100644 index 0000000000000000000000000000000000000000..d57a61b829c69fb5ff526ab34a47fc566bbd60f0 GIT binary patch literal 183178 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 aO@DmwM&w`A^4aT%O*=l0Z6muy{{H~~-|rs) literal 0 HcmV?d00001 diff --git a/mozilla/xpcom/tests/StringFactoringTests/StringTestProfileNew.Prefix b/mozilla/xpcom/tests/StringFactoringTests/StringTestProfileNew.Prefix new file mode 100644 index 00000000000..b6ca50d3e37 --- /dev/null +++ b/mozilla/xpcom/tests/StringFactoringTests/StringTestProfileNew.Prefix @@ -0,0 +1,3 @@ +// StringTestProfileNew.Prefix + +#include "StringTest.Prefix" diff --git a/mozilla/xpcom/tests/StringFactoringTests/StringTestProfileOld.Prefix b/mozilla/xpcom/tests/StringFactoringTests/StringTestProfileOld.Prefix new file mode 100644 index 00000000000..ed7d2c0c4fe --- /dev/null +++ b/mozilla/xpcom/tests/StringFactoringTests/StringTestProfileOld.Prefix @@ -0,0 +1,4 @@ +// StringTestProfileOld.Prefix + +#include "StringTest.Prefix" +#undef NEW_STRING_APIS diff --git a/mozilla/xpcom/tests/StringFactoringTests/StringTestProfileStd.Prefix b/mozilla/xpcom/tests/StringFactoringTests/StringTestProfileStd.Prefix new file mode 100644 index 00000000000..e24f036db88 --- /dev/null +++ b/mozilla/xpcom/tests/StringFactoringTests/StringTestProfileStd.Prefix @@ -0,0 +1,5 @@ +// StringTestProfileOld.Prefix + +#include "StringTest.Prefix" +#undef NEW_STRING_APIS +#define TEST_STD_STRING diff --git a/mozilla/xpcom/tests/StringFactoringTests/nsStdStringWrapper.h b/mozilla/xpcom/tests/StringFactoringTests/nsStdStringWrapper.h new file mode 100644 index 00000000000..3e75e433639 --- /dev/null +++ b/mozilla/xpcom/tests/StringFactoringTests/nsStdStringWrapper.h @@ -0,0 +1,242 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* + * The contents of this file are subject to the Netscape Public + * License Version 1.1 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.mozilla.org/NPL/ + * + * Software distributed under the License is distributed on an "AS + * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or + * implied. See the License for the specific language governing + * rights and limitations under the License. + * + * The Original Code is mozilla.org code. + * + * The Initial Developer of the Original Code is Netscape + * Communications Corporation. Portions created by Netscape are + * Copyright (C) 1998 Netscape Communications Corporation. All + * Rights Reserved. + * + * Contributor(s): + * Scott Collins + */ + +#ifndef _nsStdStringWrapper_h__ +#define _nsStdStringWrapper_h__ + +#include +#include "nsAWritableString.h" + + +template +class nsStringAllocator + : public std::allocator // temporarily + { + // ... + }; + + +template < class CharT, class TraitsT = char_traits, class AllocatorT = nsStringAllocator > +class basic_nsStdStringWrapper + : public basic_nsAWritableString + /* + ... + */ + { + protected: + std::basic_string mRawString; + + typedef typename basic_nsAWritableString::FragmentRequest FragmentRequest; + typedef typename basic_nsAWritableString::ConstFragment ConstFragment; + typedef typename basic_nsAWritableString::Fragment Fragment; + + typedef std::basic_string basic_string_t; + + using typename basic_string_t::traits_type; + using typename basic_string_t::value_type; + using typename basic_string_t::allocator_type; + using typename basic_string_t::size_type; + using typename basic_string_t::difference_type; + using typename basic_string_t::reference; + using typename basic_string_t::const_reference; + using typename basic_string_t::pointer; + using typename basic_string_t::const_pointer; + using typename basic_string_t::iterator; + using typename basic_string_t::const_iterator; + using typename basic_string_t::reverse_iterator; + using typename basic_string_t::const_reverse_iterator; + + static const size_type npos = size_type(-1); + + protected: + virtual const char* Implementation() const; + + virtual const CharT* GetConstFragment( ConstFragment&, FragmentRequest, PRUint32 ) const; + virtual CharT* GetFragment( Fragment&, FragmentRequest, PRUint32 ); + + public: + explicit + basic_nsStdStringWrapper( const AllocatorT& a = AllocatorT() ) + : mRawString(a) + { + } + + basic_nsStdStringWrapper( const basic_nsAReadableString& str ) + : mRawString(str.Begin(), str.End()) + { + } + + basic_nsStdStringWrapper( const basic_string_t& str, size_type pos = 0, size_type n = npos ) + : mRawString(str, pos, n) + { + } + + basic_nsStdStringWrapper( const basic_string_t& str, size_type pos, size_type n, const AllocatorT& a ) + : mRawString(str, pos, n, a) + { + } + + basic_nsStdStringWrapper( const CharT* s, size_type n, const AllocatorT& a = AllocatorT() ) + : mRawString(s, n, a) + { + } + + basic_nsStdStringWrapper( const CharT* s, const AllocatorT& a = AllocatorT() ) + : mRawString(s, a) + { + } + + basic_nsStdStringWrapper( size_type n, CharT c, const AllocatorT& a = AllocatorT() ) + : mRawString(n, c, a) + { + } + + + virtual + PRUint32 + Length() const + { + return mRawString.length(); + } + + virtual + void + SetCapacity( PRUint32 aNewCapacity ) + { + mRawString.reserve(aNewCapacity); + } + + virtual + void + SetLength( PRUint32 aNewLength ) + { + mRawString.resize(aNewLength); + } + + virtual void Assign( const basic_nsAReadableString& ); + virtual void Append( const basic_nsAReadableString& ); + virtual void AppendChar( CharT ); + virtual void Insert( const basic_nsAReadableString&, PRUint32 pos ); + virtual void Cut( PRUint32 pos, PRUint32 len ); + + // ... + }; + +NS_DEF_STRING_COMPARISONS(basic_nsStdStringWrapper) + + + +template +const char* +basic_nsStdStringWrapper::Implementation() const + { + static const char* implementation = "nsStdStringWrapper"; + return implementation; + } + + +template +const CharT* +basic_nsStdStringWrapper::GetConstFragment( ConstFragment& aFragment, FragmentRequest aRequest, PRUint32 aOffset ) const + { + switch ( aRequest ) + { + case kFirstFragment: + case kLastFragment: + case kFragmentAt: + aFragment.mEnd = (aFragment.mStart = mRawString.data()) + mRawString.length(); + return aFragment.mStart + aOffset; + + case kPrevFragment: + case kNextFragment: + default: + return 0; + } + } + +template +CharT* +basic_nsStdStringWrapper::GetFragment( Fragment& aFragment, FragmentRequest aRequest, PRUint32 aOffset ) + { + switch ( aRequest ) + { + case kFirstFragment: + case kLastFragment: + case kFragmentAt: + aFragment.mEnd = (aFragment.mStart = NS_CONST_CAST(CharT*, mRawString.data())) + mRawString.length(); + return aFragment.mStart + aOffset; + + case kPrevFragment: + case kNextFragment: + default: + return 0; + } + } + +template +void +basic_nsStdStringWrapper::Assign( const basic_nsAReadableString& rhs ) + { + typedef basic_nsStdStringWrapper this_t; + + if ( rhs.Implementation() == Implementation() ) + mRawString = NS_STATIC_CAST(this_t, rhs).mRawString; + else + mRawString.assign(rhs.Begin(), rhs.End()); + } + +template +void +basic_nsStdStringWrapper::Append( const basic_nsAReadableString& rhs ) + { + mRawString.append(rhs.Begin(), rhs.End()); + } + +template +void +basic_nsStdStringWrapper::AppendChar( CharT c ) + { + mRawString.append(1, c); + } + +template +void +basic_nsStdStringWrapper::Insert( const basic_nsAReadableString& rhs, PRUint32 atPosition ) + { + mRawString.insert(mRawString.begin()+atPosition, rhs.Begin(), rhs.End()); + } + +template +void +basic_nsStdStringWrapper::Cut( PRUint32 cutStart, PRUint32 cutLength ) + { + mRawString.erase(cutStart, cutLength); + } + + + +typedef basic_nsStdStringWrapper nsStdString; +typedef basic_nsStdStringWrapper nsStdCString; + + +#endif // !defined(_basic_nsStdStringWrapper_h__) diff --git a/mozilla/xpcom/tests/StringFactoringTests/profile_main.cpp b/mozilla/xpcom/tests/StringFactoringTests/profile_main.cpp new file mode 100644 index 00000000000..bfc8dc37113 --- /dev/null +++ b/mozilla/xpcom/tests/StringFactoringTests/profile_main.cpp @@ -0,0 +1,353 @@ +// profile_main.cpp + +#include "nscore.h" +#include "prlong.h" +#include +#include +#include + +#ifndef TEST_STD_STRING +#include "nsString.h" +#else +#include "nsStdStringWrapper.h" +typedef nsStdCString nsCString; +#endif + +#include + +static const int kTestSucceeded = 0; +static const int kTestFailed = 1; + + +template +inline +PRUint32 +TotalLength( const T& s ) + { + return s.Length(); + } + +template <> +inline +PRUint32 +TotalLength( const string& s ) + { + return s.length(); + } + +template +inline +PRUint32 +Find( const T& text, const T& pattern ) + { + return text.Find(pattern); + } + +template <> +inline +PRUint32 +Find( const string& text, const string& pattern ) + { + return text.find(pattern); + } + +inline +UnsignedWide +operator-( const UnsignedWide& lhs, const UnsignedWide& rhs ) + { + PRInt64 a = LL_INIT(lhs.hi, lhs.lo); + PRInt64 b = LL_INIT(rhs.hi, rhs.lo); + PRInt64 c; + LL_SUB(c, a, b); + + UnsignedWide result = {c.hi, c.lo}; + + return result; + } + +class TestTimer + { + public: + TestTimer() { Microseconds(&mStartTime); } + + ~TestTimer() + { + UnsignedWide stopTime; + Microseconds(&stopTime); + UnsignedWide totalTime = stopTime - mStartTime; + if ( totalTime.hi ) + cout << "*"; + cout << setw(10) << totalTime.lo << " µs : "; + } + + private: + UnsignedWide mStartTime; + }; + +static +int +test_concat() + { + //---------|---------|---------|---------|---------|---------|---------| + nsCString s1("This is a reasonable length string with some text in it and it is good."); + nsCString s2("This is another string that I will use in the concatenation test."); + nsCString s3("This is yet a third string that I will use in the concatenation test."); + + PRUint32 len = TotalLength( s1 + s2 + s3 + s1 + s2 + s3 ); + if ( len != (71 + 65 + 69 + 71 + 65 + 69) ) + { + cout << "|test_concat()| FAILED" << endl; + return kTestFailed; + } + + + { + TestTimer timer; + for ( int i=0; i<100000; ++i ) + len += TotalLength( s1 + s2 + s3 + s1 + s2 + s3 ); + } + cout << "TotalLength( s1 + s2 + s3 + s1 + s2 + s3 )" << endl; + + + { + TestTimer timer; + for ( int i=0; i<100000; ++i ) + len += TotalLength( s1 + s2 ); + } + cout << "TotalLength( s1 + s2 )" << endl; + + return kTestSucceeded; + } + +static +int +test_concat_and_assign() + { + //---------|---------|---------|---------|---------|---------|---------| + nsCString s1("This is a reasonable length string with some text in it and it is good."); + nsCString s2("This is another string that I will use in the concatenation test."); + nsCString s3("This is yet a third string that I will use in the concatenation test."); + + nsCString s4 = s1 + s2 + s3 + s1 + s2 + s3; + if ( TotalLength(s4) != (71 + 65 + 69 + 71 + 65 + 69) ) + { + cout << "|test_concat()| FAILED" << endl; + return kTestFailed; + } + + + + { + TestTimer timer; + for ( int i=0; i<100000; ++i ) + s4 = s1 + s2 + s3 + s1 + s2 + s3; + } + cout << "s4 = s1 + s2 + s3 + s1 + s2 + s3" << endl; + + { + TestTimer timer; + for ( int i=0; i<100000; ++i ) + s4 = s1 + s2; + } + cout << "s4 = s1 + s2" << endl; + + + return kTestSucceeded; + } + +static +int +test_compare() + { + nsCString s1("This is a reasonable length string with some text in it and it is good."); + nsCString s2("This is a reasonable length string with some text in it and it is bad."); + + int count = 0; + { + TestTimer timer; + for ( int i=0; i<100000; ++i ) + if ( s1 > s2 ) + ++count; + } + cout << "s1 > s2" << endl; + + { + TestTimer timer; + for ( int i=0; i<100000; ++i ) + if ( s1 == s1 ) + ++count; + } + cout << "s1 == s1" << endl; + + return kTestSucceeded; + } + +static +int +test_countchar() + { + nsCString s1("This is a reasonable length string with some text in it and it is good."); + + if ( s1.CountChar('e') != 5 ) + { + cout << "|test_countchar()| FAILED: found a count of " << s1.CountChar('e') << endl; + return kTestFailed; + } + + PRUint32 total = 0; + { + TestTimer timer; + for ( int i=0; i<100000; ++i ) + total += s1.CountChar('e'); + } + cout << "s1.CountChar('e')" << endl; + + return kTestSucceeded; + } + +static +int +test_append_string() + { + nsCString s1("This is a reasonable length string with some text in it and it is good."); + nsCString s2("This is another string that I will use in the concatenation test."); + + PRUint32 len = 0; + + { + TestTimer timer; + for ( int i=0; i<100000; ++i ) + { + nsCString s3; + s3.Append(s1); + s3.Append(s2); + len += TotalLength(s3); + } + } + cout << "s3.Append(s1); s3.Append(s2)" << endl; + + return kTestSucceeded; + } + +static +int +test_repeated_append_string() + { + nsCString s1("This is a reasonable length string with some text in it and it is good."); + nsCString s2("This is another string that I will use in the concatenation test."); + + PRUint32 len = 0; + + { + TestTimer timer; + for ( int i=0; i<1000; ++i ) + { + nsCString s3; + for ( int j=0; j<100; ++j ) + { + s3.Append(s1); + s3.Append(s2); + len += TotalLength(s3); + } + } + } + cout << "repeated s3.Append(s1); s3.Append(s2)" << endl; + + return kTestSucceeded; + } + +static +int +test_repeated_append_char() + { + PRUint32 len = 0; + + { + TestTimer timer; + for ( int i=0; i<1000; ++i ) + { + nsCString s1; + for ( int j=0; j<1000; ++j ) + { + s1.AppendChar('e'); + len += TotalLength(s1); + } + } + } + cout << "repeated s1.Append('e')" << endl; + + return kTestSucceeded; + } + +static +int +test_insert_string() + { + nsCString s1("This is a reasonable length string with some text in it and it is good."); + + PRUint32 len = 0; + + { + TestTimer timer; + for ( int i=0; i<100000; ++i ) + { + nsCString s2("This is another string that I will use in the concatenation test."); + s2.Insert(s1, 3); + len += TotalLength(s2); + } + } + cout << "s2.Insert(s1, 3)" << endl; + + return kTestSucceeded; + } + +#if 0 +static +int +test_find_string() + { + nsCString text("aaaaaaaaaab"); + nsCString pattern("aab"); + + PRUint32 position = 0; + { + TestTimer timer; + for ( int i=0; i<100000; ++i ) + position = Find(text, pattern); + } + cout << "text.Find(pattern)" << endl; + + return kTestSucceeded; + } +#endif + +int +main() + { + cout << "String performance profiling. Compiled " __DATE__ " " __TIME__ << endl; +#ifdef TEST_STD_STRING + cout << "Testing std::string." << endl; +#elif defined(NEW_STRING_APIS) + cout << "Testing factored nsString." << endl; +#else + cout << "Testing raw nsString." << endl; +#endif + + int tests_failed = 0; + + tests_failed += test_concat(); + tests_failed += test_concat_and_assign(); + tests_failed += test_compare(); + tests_failed += test_countchar(); + tests_failed += test_append_string(); + tests_failed += test_repeated_append_string(); + tests_failed += test_repeated_append_char(); + tests_failed += test_insert_string(); + // tests_failed += test_find_string(); + + if ( tests_failed ) + cout << "One or more tests FAILED. Measurements may be invalid." << endl; + + cout << "End of string performance profiling." << endl; + return 0; + } diff --git a/mozilla/xpcom/tests/StringFactoringTests/test_main.cc b/mozilla/xpcom/tests/StringFactoringTests/test_main.cc new file mode 100644 index 00000000000..8b6a7810a8d --- /dev/null +++ b/mozilla/xpcom/tests/StringFactoringTests/test_main.cc @@ -0,0 +1,391 @@ +#include +using namespace std; + +#include "nsString.h" +#include "nsStdStringWrapper.h" +#include "nsLiteralString.h" + + +#if 0 +static +void +Call_ToLowerCase( const nsAReadableCString& aSource, nsAWritableCString& aResult ) + { + aSource.ToLowerCase(aResult); + } + +static +void +Call_ToUpperCase( const nsAReadableCString& aSource, nsAWritableCString& aResult ) + { + aSource.ToUpperCase(aResult); + } +#endif + +static +ostream& +print_string( const nsAReadableString& s, ostream& os = std::cout ) + { + struct PRUnichar_to_char + { + char operator()( PRUnichar c ) { return char(c); } + }; + + transform(s.Begin(), s.End(), ostream_iterator(os), PRUnichar_to_char()); + return os; + } + + +template +basic_nsLiteralString +make_a_hello_string( CharT* ) + { + } + +NS_SPECIALIZE_TEMPLATE +basic_nsLiteralString +make_a_hello_string( char* ) + { + return basic_nsLiteralString("Hello"); + } + +NS_SPECIALIZE_TEMPLATE +basic_nsLiteralString +make_a_hello_string( PRUnichar* ) + { + static PRUnichar constant_unicode[] = { 'H', 'e', 'l', 'l', 'o', PRUnichar() }; + return basic_nsLiteralString(constant_unicode); + } + +static +void +CallCMid( nsAWritableCString& aResult, const nsAReadableCString& aSource, PRUint32 aStartPos, PRUint32 aLengthToCopy ) + { + aSource.Mid(aResult, aStartPos, aLengthToCopy); + } + + + +template +int +readable_hello_tests( const basic_nsAReadableString& str, ostream& os = std::cout ) + { + int tests_failed = 0; + + if ( str.Length() != 5 ) + { + os << "Length() FAILED" << endl; + ++tests_failed; + } + + if ( str.First() != CharT('H') ) + { + cout << "|First()| FAILED" << endl; + ++tests_failed; + } + + if ( str.Last() != CharT('o') ) + { + cout << "|Last()| FAILED" << endl; + ++tests_failed; + } + + if ( str[3] != CharT('l') ) + { + cout << "|operator[]()| FAILED" << endl; + ++tests_failed; + } + + if ( str.CountChar( CharT('l') ) != 2 ) + { + cout << "|CountChar()| FAILED" << endl; + ++tests_failed; + } + + basic_nsAReadableString::ConstIterator iter = str.Begin(); + if ( *iter != CharT('H') ) + { + cout << "iterator FAILED: didn't start out pointing at the right thign or couldn't be dereferenced." << endl; + ++tests_failed; + } + + ++iter; + + if ( *iter != CharT('e') ) + { + cout << "iterator FAILED: couldn't be incremented, or else couldn't be dereferenced." << endl; + ++tests_failed; + } + + iter = str.End(); + --iter; + if ( *iter != CharT('o') ) + { + cout << "iterator FAILED: couldn't be set to End(), or else couldn't be decremented, or else couldn't be dereferenced." << endl; + ++tests_failed; + } + + basic_nsAReadableString::ConstIterator iter1 = str.Begin(3); + if ( *iter1 != CharT('l') ) + { + cout << "iterator FAILED: couldn't be set to Begin(n), or else couldn't be dereferenced." << endl; + ++tests_failed; + } + + basic_nsAReadableString::ConstIterator iter2 = str.End(2); + if ( *iter2 != CharT('l') ) + { + cout << "iterator FAILED: couldn't be set to End(n), or else couldn't be dereferenced." << endl; + ++tests_failed; + } + + if ( iter1 != iter2 ) + { + cout << "iterator comparison with != FAILED" << endl; + ++tests_failed; + } + + if ( !(iter1 == iter2) ) + { + cout << "iterator comparison with == FAILED" << endl; + ++tests_failed; + } + + typedef CharT* CharT_ptr; + + if ( str != make_a_hello_string( CharT_ptr() ) ) + { + cout << "comparison with hello string FAILED" << endl; + ++tests_failed; + } + + return tests_failed; + } + +static +inline +bool +compare_equals( const nsAReadableCString& lhs, const nsAReadableCString& rhs ) + { + return bool(lhs == rhs); + } + +static +inline +bool +compare_equals( const nsLiteralCString& lhs, const nsAReadableCString& rhs ) + { + return bool(lhs == rhs); + } + +static +inline +bool +compare_equals( const nsAReadableCString& lhs, const nsLiteralCString& rhs ) + { + return bool(lhs == rhs); + } + + +template +int +test_goofy_iterators( const basic_nsAReadableString& aString ) + { + typedef typename basic_nsAReadableString::ConstIterator ConstIterator; + + int tests_failed = 0; + + ConstIterator iter1 = aString.Begin(); + ConstIterator iter2 = aString.Begin(); + ++iter2; ++iter2; + + ConstIterator iter3 = aString.End(); + --iter3; + ++iter1; ++iter1; + if ( iter1 != iter2 ) + { + cout << "goofy iterator test FAILED" << endl; + ++tests_failed; + } + + return tests_failed; + } + + + +typedef void* void_ptr; + +int +main() + { + int tests_failed = 0; + cout << "String unit tests. Compiled " __DATE__ " " __TIME__ << endl; + + + // + // |nsLiteralString| + // + + + PRUnichar constant_unicode[] = { 'H', 'e', 'l', 'l', 'o', PRUnichar() }; + nsLiteralString aLiteralString(constant_unicode); + tests_failed += readable_hello_tests(aLiteralString); + + cout << "\""; + print_string(aLiteralString) << "\"" << endl; + + { + const PRUnichar* buffer = aLiteralString.GetUnicode(); + if ( !buffer ) + { + cout << "|nsLiteralString::GetUnicode()| FAILED: should have returned non-|0|" << endl; + ++tests_failed; + } + + const char* cbuffer = aLiteralString.GetBuffer(); + if ( cbuffer ) + { + cout << "|nsLiteralString::GetBuffer()| FAILED: should have returned |0|" << endl; + ++tests_failed; + } + } + + { + nsCString aCString("Hello"); + tests_failed += readable_hello_tests(aCString); + } + + { + nsStdCString aCString("Hello"); + tests_failed += readable_hello_tests(aCString); + } + + { + nsLiteralCString aLiteralCString("Hello"); + tests_failed += readable_hello_tests(aLiteralCString); + } + + { + 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; + } + } + + nsLiteralCString part1("He"), part2("llo"); + tests_failed += readable_hello_tests(part1+part2); + + nsLiteralCString part2a("l"), part2b("lo"); + tests_failed += readable_hello_tests(part1+part2a+part2b); + + cout << "The summed string is \"" << part1 + part2a + part2b << "\"" << endl; + + 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; + } + + // + // |nsLiteralCString| + // + + + nsLiteralCString aLiteralCString("Goodbye"); + cout << "\"" << aLiteralCString << "\"" << endl; + if ( aLiteralCString.Length() == 7 ) + cout << "|nsLiteralCString::Length()| OK" << endl; + else + cout << "|nsLiteralCString::Length()| FAILED" << endl; + cout << aLiteralCString << endl; + + const char* cbuffer = aLiteralCString.GetBuffer(); + cout << "GetBuffer()-->" << showbase << void_ptr(cbuffer) << endl; + cout << "GetUnicode()-->" << void_ptr( aLiteralCString.GetUnicode() ) << endl; + cout << "The length of the string \"" << aLiteralCString << "\" is " << aLiteralCString.Length() << endl; + + + // + // |nsStdStringWrapper|, i.e., |nsStdCString| + // + + + nsStdCString aCString("Hello"); + if ( aCString.Length() == 5 ) + cout << "|nsStdCString::Length()| OK" << endl; + else + cout << "|nsStdCString::Length()| FAILED" << endl; + + { + 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; + } + } + + cbuffer = aCString.GetBuffer(); + cout << "GetBuffer()-->" << showbase << void_ptr(cbuffer) << endl; + cout << "GetUnicode()-->" << void_ptr( aCString.GetUnicode() ) << endl; + + // cout << "The length of the string \"" << static_cast(aCString) << "\" is " << aCString.Length() << endl; + + + nsLiteralCString source("This is a string long enough to be interesting."); + cout << source << endl; + + nsStdCString leftString; + source.Left(leftString, 9); + // cout << static_cast(leftString) << endl; + + + + tests_failed += test_goofy_iterators(part1+part2a+part2b); + + + + + cout << "End of string unit tests. "; + if ( !tests_failed ) + cout << "All tests OK." << endl; + else + cout << "One or more tests FAILED." << endl; + + return 0; + }