diff options
Diffstat (limited to '')
| -rw-r--r-- | src/libs/xpcom18a4/xpcom/tests/windows/.cvsignore | 1 | ||||
| -rw-r--r-- | src/libs/xpcom18a4/xpcom/tests/windows/Makefile.in | 60 | ||||
| -rw-r--r-- | src/libs/xpcom18a4/xpcom/tests/windows/TestCOM.cpp | 181 | ||||
| -rw-r--r-- | src/libs/xpcom18a4/xpcom/tests/windows/TestHelloXPLoop.cpp | 177 | ||||
| -rw-r--r-- | src/libs/xpcom18a4/xpcom/tests/windows/nsStringTest.cpp | 33 | ||||
| -rw-r--r-- | src/libs/xpcom18a4/xpcom/tests/windows/nsStringTest.h | 2277 | ||||
| -rw-r--r-- | src/libs/xpcom18a4/xpcom/tests/windows/nsStringTest2.h | 444 |
7 files changed, 3173 insertions, 0 deletions
diff --git a/src/libs/xpcom18a4/xpcom/tests/windows/.cvsignore b/src/libs/xpcom18a4/xpcom/tests/windows/.cvsignore new file mode 100644 index 00000000..f3c7a7c5 --- /dev/null +++ b/src/libs/xpcom18a4/xpcom/tests/windows/.cvsignore @@ -0,0 +1 @@ +Makefile diff --git a/src/libs/xpcom18a4/xpcom/tests/windows/Makefile.in b/src/libs/xpcom18a4/xpcom/tests/windows/Makefile.in new file mode 100644 index 00000000..8bd782c8 --- /dev/null +++ b/src/libs/xpcom18a4/xpcom/tests/windows/Makefile.in @@ -0,0 +1,60 @@ +# +# ***** BEGIN LICENSE BLOCK ***** +# Version: MPL 1.1/GPL 2.0/LGPL 2.1 +# +# The contents of this file are subject to the Mozilla 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/MPL/ +# +# 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 the Initial Developer are Copyright (C) 2001 +# the Initial Developer. All Rights Reserved. +# +# Contributor(s): +# +# Alternatively, the contents of this file may be used under the terms of +# either of the GNU General Public License Version 2 or later (the "GPL"), +# or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), +# in which case the provisions of the GPL or the LGPL are applicable instead +# of those above. If you wish to allow use of your version of this file only +# under the terms of either the GPL or the LGPL, and not to allow others to +# use your version of this file under the terms of the MPL, indicate your +# decision by deleting the provisions above and replace them with the notice +# and other provisions required by the GPL or the LGPL. If you do not delete +# the provisions above, a recipient may use your version of this file under +# the terms of any one of the MPL, the GPL or the LGPL. +# +# ***** END LICENSE BLOCK ***** + +DEPTH = ../../.. +topsrcdir = @top_srcdir@ +srcdir = @srcdir@ +VPATH = @srcdir@ + +include $(DEPTH)/config/autoconf.mk + +MODULE = xpcom + +REQUIRES = string + +CPPSRCS = TestCOM.cpp +#TestHelloXPLoop.cpp nsStringTest.cpp + +SIMPLE_PROGRAMS = $(CPPSRCS:.cpp=$(BIN_SUFFIX)) + +include $(topsrcdir)/config/config.mk + +include $(topsrcdir)/config/rules.mk + +OS_LIBS = $(call EXPAND_LIBNAME,rpcrt4 uuid) + +LIBS = $(XPCOM_LIBS) $(NSPR_LIBS) diff --git a/src/libs/xpcom18a4/xpcom/tests/windows/TestCOM.cpp b/src/libs/xpcom18a4/xpcom/tests/windows/TestCOM.cpp new file mode 100644 index 00000000..b76eccb4 --- /dev/null +++ b/src/libs/xpcom18a4/xpcom/tests/windows/TestCOM.cpp @@ -0,0 +1,181 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0/LGPL 2.1 + * + * The contents of this file are subject to the Mozilla 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/MPL/ + * + * 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 the Initial Developer are Copyright (C) 1998 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Pierre Phaneuf <pp@ludusdesign.com> + * + * Alternatively, the contents of this file may be used under the terms of + * either of the GNU General Public License Version 2 or later (the "GPL"), + * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), + * in which case the provisions of the GPL or the LGPL are applicable instead + * of those above. If you wish to allow use of your version of this file only + * under the terms of either the GPL or the LGPL, and not to allow others to + * use your version of this file under the terms of the MPL, indicate your + * decision by deleting the provisions above and replace them with the notice + * and other provisions required by the GPL or the LGPL. If you do not delete + * the provisions above, a recipient may use your version of this file under + * the terms of any one of the MPL, the GPL or the LGPL. + * + * ***** END LICENSE BLOCK ***** */ + +#include <windows.h> +#include <unknwn.h> +#include <stdio.h> +#include "nsISupports.h" +#include "nsIFactory.h" + +// unknwn.h is needed to build with WIN32_LEAN_AND_MEAN +#include <unknwn.h> + +// {5846BA30-B856-11d1-A98A-00805F8A7AC4} +#define NS_ITEST_COM_IID \ +{ 0x5846ba30, 0xb856, 0x11d1, \ + { 0xa9, 0x8a, 0x0, 0x80, 0x5f, 0x8a, 0x7a, 0xc4 } } + +class nsITestCom: public nsISupports +{ +public: + NS_DEFINE_STATIC_IID_ACCESSOR(NS_ITEST_COM_IID) + NS_IMETHOD Test() = 0; +}; + +/* + * nsTestCom + */ + +class nsTestCom: public nsITestCom { + NS_DECL_ISUPPORTS + +public: + nsTestCom() { + } + + NS_IMETHOD Test() { + printf("Accessed nsITestCom::Test() from COM\n"); + return NS_OK; + } + +private: + ~nsTestCom() { + printf("nsTestCom instance successfully deleted\n"); + } +}; + +NS_IMPL_QUERY_INTERFACE1(nsTestCom, nsITestCom) + +nsrefcnt nsTestCom::AddRef() +{ + nsrefcnt res = ++mRefCnt; + NS_LOG_ADDREF(this, mRefCnt, "nsTestCom", sizeof(*this)); + printf("nsTestCom: Adding ref = %d\n", res); + return res; +} + +nsrefcnt nsTestCom::Release() +{ + nsrefcnt res = --mRefCnt; + NS_LOG_RELEASE(this, mRefCnt, "nsTestCom"); + printf("nsTestCom: Releasing = %d\n", res); + if (res == 0) { + delete this; + } + return res; +} + +class nsTestComFactory: public nsIFactory { + NS_DECL_ISUPPORTS +public: + nsTestComFactory() { + } + + NS_IMETHOD CreateInstance(nsISupports *aOuter, + const nsIID &aIID, + void **aResult); + + NS_IMETHOD LockFactory(PRBool aLock) { + printf("nsTestComFactory: "); + printf("%s", (aLock == PR_TRUE ? "Locking server" : "Unlocking server")); + printf("\n"); + return S_OK; + } +}; + +NS_IMPL_ISUPPORTS1(nsTestComFactory, nsIFactory) + +nsresult nsTestComFactory::CreateInstance(nsISupports *aOuter, + const nsIID &aIID, + void **aResult) +{ + if (aOuter != NULL) { + return NS_ERROR_NO_AGGREGATION; + } + + nsTestCom *t = new nsTestCom(); + + if (t == NULL) { + return NS_ERROR_OUT_OF_MEMORY; + } + + NS_ADDREF(t); + nsresult res = t->QueryInterface(aIID, aResult); + NS_RELEASE(t); + + if (NS_SUCCEEDED(res)) { + printf("nsTestComFactory: successfully created nsTestCom instance\n"); + } + + return res; +} + +/* + * main + */ + +int main(int argc, char *argv[]) +{ + nsTestComFactory *inst = new nsTestComFactory(); + IClassFactory *iFactory; + inst->QueryInterface(NS_GET_IID(nsIFactory), (void **) &iFactory); + + IUnknown *iUnknown; + nsITestCom *iTestCom; + + nsresult res; + iFactory->LockServer(TRUE); + res = iFactory->CreateInstance(NULL, + IID_IUnknown, + (void **) &iUnknown); + iFactory->LockServer(FALSE); + + GUID testGUID = NS_ITEST_COM_IID; + HRESULT hres; + hres= iUnknown->QueryInterface(testGUID, + (void **) &iTestCom); + + iTestCom->Test(); + + iUnknown->Release(); + iTestCom->Release(); + iFactory->Release(); + + return 0; +} + diff --git a/src/libs/xpcom18a4/xpcom/tests/windows/TestHelloXPLoop.cpp b/src/libs/xpcom18a4/xpcom/tests/windows/TestHelloXPLoop.cpp new file mode 100644 index 00000000..fdfa1218 --- /dev/null +++ b/src/libs/xpcom18a4/xpcom/tests/windows/TestHelloXPLoop.cpp @@ -0,0 +1,177 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0/LGPL 2.1 + * + * The contents of this file are subject to the Mozilla 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/MPL/ + * + * 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 the Mozilla browser. + * + * The Initial Developer of the Original Code is + * Netscape Communications, Inc. + * Portions created by the Initial Developer are Copyright (C) 1999 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Travis Bogard <travis@netscape.com> + * + * Alternatively, the contents of this file may be used under the terms of + * either of the GNU General Public License Version 2 or later (the "GPL"), + * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), + * in which case the provisions of the GPL or the LGPL are applicable instead + * of those above. If you wish to allow use of your version of this file only + * under the terms of either the GPL or the LGPL, and not to allow others to + * use your version of this file under the terms of the MPL, indicate your + * decision by deleting the provisions above and replace them with the notice + * and other provisions required by the GPL or the LGPL. If you do not delete + * the provisions above, a recipient may use your version of this file under + * the terms of any one of the MPL, the GPL or the LGPL. + * + * ***** END LICENSE BLOCK ***** */ + +#include "nsIServiceManager.h" +#include "nsCOMPtr.h" +#include "nsCNativeApp.h" +#include "nsIEventLoop.h" +#include <windows.h> + +static NS_DEFINE_CID(kNativeAppCID, NS_NATIVE_APP_CID); + +LRESULT CALLBACK WndProc(HWND wnd, UINT msg, WPARAM wParam, LPARAM lParam); + +void ErrorBox(LPSTR text) +{ + MessageBox(NULL, text, "XP Event Loop", MB_OK | MB_ICONSTOP); +} + +void InfoBox(LPSTR text) +{ + MessageBox(NULL, text, "XP Event Loop", MB_OK | MB_ICONINFORMATION); +} + +int WINAPI WinMain(HINSTANCE inst, + HINSTANCE prevInstance, + LPSTR lpszCmdLine, + int nShowCmd) +{ + char* lpszAppName = "HelloWorld"; + HWND wnd; + WNDCLASSEX wndclass; + int retCode; + + { // Needed to scope all nsCOMPtr within XPCOM Init and Shutdown + nsresult rv; + nsCOMPtr<nsIServiceManager> servMan; + rv = NS_InitXPCOM2(getter_AddRefs(servMan), nsnull, nsnull); + if(NS_FAILED(rv)) + { + ErrorBox("Failed to initalize xpcom."); + return -1; + } + + nsCOMPtr<nsIComponentRegistrar> registrar = do_QueryInterface(servMan); + NS_ASSERTION(registrar, "Null nsIComponentRegistrar"); + registrar->AutoRegister(nsnull); + + nsCOMPtr<nsINativeApp> nativeAppService(do_GetService(kNativeAppCID, &rv)); + + if(NS_FAILED(rv)) + { + ErrorBox("Failed to get nativeAppService"); + return -1; + } + wndclass.cbSize = sizeof(wndclass); + wndclass.style = CS_HREDRAW | CS_VREDRAW; + wndclass.lpfnWndProc = WndProc; + wndclass.cbClsExtra = 0; + wndclass.cbWndExtra = 0; + wndclass.hInstance = inst; + wndclass.hIcon = LoadIcon(NULL, IDI_APPLICATION); + wndclass.hCursor = LoadCursor(NULL, IDC_ARROW); + wndclass.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH); + wndclass.lpszMenuName = NULL; + wndclass.lpszClassName = lpszAppName; + wndclass.hIconSm = LoadIcon(NULL, IDI_APPLICATION); + + RegisterClassEx(&wndclass) ; + + wnd = CreateWindow(lpszAppName, "The Hello World", + WS_OVERLAPPEDWINDOW, + CW_USEDEFAULT, CW_USEDEFAULT, + CW_USEDEFAULT, CW_USEDEFAULT, + NULL, NULL, inst, NULL); + + ShowWindow(wnd, nShowCmd); + UpdateWindow(wnd); + + nsCOMPtr<nsIEventLoop> eventLoop; + + if(NS_FAILED(nativeAppService->CreateEventLoop(L"_MainLoop", + nsEventLoopTypes::MainAppLoop, getter_AddRefs(eventLoop)))) + { + ErrorBox("Failed to create event Loop"); + return 0; + } + + eventLoop->Run(nsnull, nsnull, nsnull, &retCode); + eventLoop = nsnull; // Clear out before Shutting down XPCOM + + InfoBox("Hello World app is out of loop"); + } + NS_ShutdownXPCOM(nsnull); + InfoBox("Hello World app is exiting"); + return retCode; +} + +LRESULT CALLBACK WndProc(HWND wnd, UINT msg, WPARAM wParam, LPARAM lParam) +{ + HDC hdc; + PAINTSTRUCT ps; + RECT rect; + + switch(msg) + { + case WM_PAINT: + hdc = BeginPaint(wnd, &ps); + + GetClientRect(wnd, &rect); + + DrawText(hdc, "Hello, XP Event Loop!", -1, &rect, + DT_SINGLELINE | DT_CENTER | DT_VCENTER); + + EndPaint(wnd, &ps); + return 0; + + case WM_DESTROY: + { + nsresult rv; + nsCOMPtr<nsINativeApp> nativeAppService = + do_GetService(kNativeAppCID, &rv); + if(NS_FAILED(rv)) + { + ErrorBox("Could not get NativeAppService"); + return 0; + } + nsCOMPtr<nsIEventLoop> eventLoop; + + if(NS_FAILED(nativeAppService->FindEventLoop(L"_MainLoop", + getter_AddRefs(eventLoop)))) + { + ErrorBox("Failed to find event Loop"); + return 0; + } + eventLoop->Exit(0); + } + return 0; + } + + return DefWindowProc(wnd, msg, wParam, lParam); +} diff --git a/src/libs/xpcom18a4/xpcom/tests/windows/nsStringTest.cpp b/src/libs/xpcom18a4/xpcom/tests/windows/nsStringTest.cpp new file mode 100644 index 00000000..6719ed38 --- /dev/null +++ b/src/libs/xpcom18a4/xpcom/tests/windows/nsStringTest.cpp @@ -0,0 +1,33 @@ + +#include <iostream.h> +#include "nsStr.h" +#include "nsStringTest2.h" +#include "nsString.h" +#include "nsReadableUtils.h" + +int main(){ + + nsString temp("\t\t\n\r\n\r25,* \t \n\n \t"); + temp.CompressWhitespace(); + + nsString temp1("\t\t\n\r\n\r25,* \t \n\n \t"); + temp1.CompressSet("\t\n\r ",' ',false,false); + + nsString temp3(""); + char* s = ToNewCString(temp3); + delete s; + + char* f = ToNewCString(nsAutoString("")); + char* f1 = ToNewCString(nsCAutoString("")); + delete f; + delete f1; + + + CStringTester gStringTester; + + gStringTester.TestI18nString(); + + return 0; +} + + diff --git a/src/libs/xpcom18a4/xpcom/tests/windows/nsStringTest.h b/src/libs/xpcom18a4/xpcom/tests/windows/nsStringTest.h new file mode 100644 index 00000000..8244a5a1 --- /dev/null +++ b/src/libs/xpcom18a4/xpcom/tests/windows/nsStringTest.h @@ -0,0 +1,2277 @@ +/******************************************************************************************** + * + * MODULES NOTES: + * + * This file is designed to help test the new nsString classes. + * + * Contributor(s): + * Rick Gessner <rickg@netscape.com> + * + * History: + * + * 02.29.2000: Original files (rickg) + * 03.02.2000: Flesh out the interface to be compatible with old library (rickg) + * + ********************************************************************************************/ + +#ifndef _STRINGTEST +#define _STRINGTEST + + +#include "nsString.h" +#include "nsReadableUtils.h" +#include <time.h> + +#define USE_STL + +#ifdef USE_STL +#include <string> +using namespace std; +#endif + +#define USE_WIDE 1 +#ifdef USE_WIDE + #define stringtype nsString + #define astringtype nsAutoString + #define chartype PRUnichar +#else + #define stringtype nsCString + #define astringtype nsCAutoString + #define chartype char +#endif + + +#include <stdio.h> + + + +static const char* kConstructorError = "constructor error"; +static const char* kComparisonError = "Comparision error!"; +static const char* kEqualsError = "Equals error!"; + +static char* kNumbers[]={"0123456789","0\01\02\03\04\05\06\07\08\09\0\0\0"}; +static char* kLetters[]={"abcdefghij","a\0b\0c\0d\0e\0f\0g\0h\0i\0j\0\0\0"}; +static char* kAAA[]={"AAA","A\0A\0A\0\0\0"}; +static char* kBBB[]={"BBB","B\0B\0B\0\0\0"}; +static char* kHello[]={"hello","h\0e\0l\0l\0o\0\0\0"}; +static char* kWSHello[]={" hello "," \0 \0h\0e\0l\0l\0o\0 \0 \0\0\0"}; + + + +/******************************************************** + + This class's only purpose in life is to test the + netscape string library. We exercise the string + API's here, and do a bit of performance testing + against the standard c++ library string (from STL). + + ********************************************************/ +class CStringTester { +public: + CStringTester() { + TestConstructors(); + TestAutoStrings(); + TestAppend(); + TestAssignAndAdd(); + TestInsert(); + TestDelete(); + TestTruncate(); + TestLogical(); + TestLexomorphic(); + TestCreators(); + TestNumerics(); + TestExtractors(); + TestSearching(); + TestSubsumables(); + TestRandomOps(); + TestReplace(); + TestRegressions(); + TestStringPerformance(); + TestWideStringPerformance(); + } +protected: + int TestConstructors(); + int TestLogical(); + int TestAutoStrings(); + int TestAppend(); + int TestAssignAndAdd(); + int TestInsert(); + int TestDelete(); + int TestTruncate(); + int TestLexomorphic(); + int TestCreators(); + int TestNumerics(); + int TestExtractors(); + int TestSearching(); + int TestSubsumables(); + int TestRandomOps(); + int TestReplace(); + int TestStringPerformance(); + int TestWideStringPerformance(); + int TestRegressions(); +}; + + +class Stopwatch { +public: + Stopwatch() { + start=clock(); + } + + void Stop() { + stop=clock(); + } + + double Elapsed() { + return (double)(stop - start) / CLOCKS_PER_SEC; + } + + void Print(const char* msg= "") { + printf("%s %f\n",msg,Elapsed()); + } + + clock_t start,stop; +}; + +/** + * + * @update gess10/30/98 + * @param + * @return + */ +int CStringTester::TestSearching(){ + int result=0; + + + + PRUnichar pbuf[10]={'e','f','g',0}; + PRUnichar pbuf2[10]={'a','b','c',0}; + + + //Since there is so much ground to cover with searching, we use a typedef to + //allow you to vary the string type being searched... + + + stringtype theDest("abcdefghijkabc"); + nsString s1("ijk"); + nsCString c1("ijk"); + + PRInt32 pos=theDest.Find(pbuf); + NS_ASSERTION(pos==4,"Error: Find routine"); + + pos=theDest.Find(pbuf2,PR_FALSE,-1); + NS_ASSERTION(pos==0,"Error: Find routine"); + + pos=theDest.Find(pbuf2,PR_FALSE,pos+1); + NS_ASSERTION(pos==11,"Error: Find routine"); + + pos=theDest.FindChar('a'); + NS_ASSERTION(pos==0,"Error: Find routine"); + + pos=theDest.FindChar('a',PR_FALSE,pos+1); + NS_ASSERTION(pos==11,"Error: Find routine"); + + pos=theDest.Find("efg"); + NS_ASSERTION(pos==4,"Error: Find routine"); + + pos=theDest.Find("EFG",PR_TRUE); + NS_ASSERTION(pos==4,"Error: Find routine"); + + pos=theDest.FindChar('d'); + NS_ASSERTION(pos==3,"Error: Find char routine"); + + pos=theDest.Find(s1); + NS_ASSERTION(pos==8,"Error: Find char routine"); + + pos=theDest.FindCharInSet("12k"); + NS_ASSERTION(pos==10,"Error: Findcharinset routine"); + + pos=theDest.FindCharInSet(pbuf); + NS_ASSERTION(pos==4,"Error: Findcharinset routine"); + + pos=theDest.FindCharInSet(s1); + NS_ASSERTION(pos==8,"Error: Findcharinset routine"); + + pos=theDest.Find("efg",PR_FALSE,2); + NS_ASSERTION(pos==4,"Error: Find routine"); + + pos=theDest.RFindCharInSet("12k"); + NS_ASSERTION(pos==10,"Error: RFindcharinset routine"); + + pos=theDest.RFindCharInSet("xyz"); + NS_ASSERTION(pos==-1,"Error: RFindcharinset routine"); + + pos=theDest.RFindCharInSet(pbuf); + NS_ASSERTION(pos==6,"Error: RFindcharinset routine"); + + pos=theDest.RFindCharInSet(s1); + NS_ASSERTION(pos==10,"Error: RFindcharinset routine"); + + pos=theDest.RFind("efg"); + NS_ASSERTION(pos==4,"Error: RFind routine"); + + pos=theDest.RFind("xxx"); + NS_ASSERTION(pos==-1,"Error: RFind routine"); //this should fail + + pos=theDest.RFind(""); + NS_ASSERTION(pos==-1,"Error: RFind routine"); //this too should fail. + + pos=theDest.RFindChar('a',PR_FALSE,4); + NS_ASSERTION(pos==-1,"Error: RFind routine"); + + + //now try searching with FindChar using offset and count... + { + stringtype s1("hello there rick"); + + PRInt32 pos=s1.FindChar('r'); //this will search from the beginning, and for the length of the string. + NS_ASSERTION(pos==9,"Error: FindChar() with offset and count"); + + pos=s1.FindChar('r',PR_FALSE,0,5); //this will search from the front using count. THIS WILL FAIL! + NS_ASSERTION(pos==-1,"Error: FindChar() with offset and count"); + + pos=s1.FindChar('r',PR_FALSE,0,10); //this will search from the front using count. THIS WILL SUCCEED! + NS_ASSERTION(pos==9,"Error: FindChar() with offset and count"); + + pos=s1.FindChar('i',PR_FALSE,5,5); //this will search from the middle using count. THIS WILL FAIL! + NS_ASSERTION(pos==-1,"Error: FindChar() with offset and count"); + + pos=s1.FindChar('i',PR_FALSE,5,10); //this will search from the middle using count. THIS WILL SUCCEED! + NS_ASSERTION(pos==13,"Error: FindChar() with offset and count"); + + pos=s1.FindChar('k',PR_FALSE,10,2); //this will search from near the end using count. THIS WILL FAIL! + NS_ASSERTION(pos==-1,"Error: FindChar() with offset and count"); + + pos=s1.FindChar('k',PR_FALSE,10,7); //this will search from near the end using count. THIS WILL SUCCEED! + NS_ASSERTION(pos==15,"Error: FindChar() with offset and count"); + + //now let's try a few with bad data... + + pos=s1.FindChar('k',PR_FALSE,100,2); //this will search from a bad offset. THIS WILL FAIL! + NS_ASSERTION(pos==-1,"Error: FindChar() with offset and count"); + + pos=s1.FindChar('k',PR_FALSE,10,0); //this will search for a bad count. THIS WILL FAIL! + NS_ASSERTION(pos==-1,"Error: FindChar() with offset and count"); + + pos=s1.FindChar('k',PR_FALSE,10,20); //this will search for a bad count. THIS WILL SUCCEED! + NS_ASSERTION(pos==15,"Error: FindChar() with offset and count"); + + pos=s1.FindChar('k',PR_FALSE,10,4); //this will search for a bad count. THIS WILL FAIL! + NS_ASSERTION(pos==-1,"Error: FindChar() with offset and count"); + + pos=10; + } + + //now try searching with RFindChar using offset and count... + { + stringtype s1("hello there rick"); + + PRInt32 pos=s1.RFindChar('o'); //this will search from the end, and for the length of the string. + NS_ASSERTION(pos==4,"Error: RFindChar() with offset and count"); + + pos=s1.RFindChar('i'); //this will search from the end, and for the length of the string. + NS_ASSERTION(pos==13,"Error: RFindChar() with offset and count"); + + pos=s1.RFindChar(' ',PR_FALSE,-1,4); //this will search from the end, and for the length of the string. + NS_ASSERTION(pos==-1,"Error: RFindChar() with offset and count"); //THIS WILL FAIL + + pos=s1.RFindChar(' ',PR_FALSE,12,1); //this will search from the middle, and for the length of 1. + NS_ASSERTION(pos==-1,"Error: RFindChar() with offset and count"); //THIS WILL FAIL + + pos=s1.RFindChar(' ',PR_FALSE,12,2); //this will search from the middle, and for the length of 2. + NS_ASSERTION(pos==11,"Error: RFindChar() with offset and count"); //THIS WILL SUCCEED + + pos=s1.RFindChar('o',PR_FALSE,-1,5); //this will search from the end using count. THIS WILL FAIL! + NS_ASSERTION(pos==-1,"Error: RFindChar() with offset and count"); + + pos=s1.RFindChar('o',PR_FALSE,-1,12); //this will search from the front using count. THIS WILL SUCCEED! + NS_ASSERTION(pos==4,"Error: RFindChar() with offset and count"); + + pos=s1.RFindChar('l',PR_FALSE,8,2); //this will search from the middle using count. THIS WILL FAIL! + NS_ASSERTION(pos==-1,"Error: RFindChar() with offset and count"); + + pos=s1.RFindChar('l',PR_FALSE,8,7); //this will search from the middle using count. THIS WILL SUCCEED! + NS_ASSERTION(pos==3,"Error: RFindChar() with offset and count"); + +//*** + + pos=s1.RFindChar('h',PR_FALSE,3,2); //this will search from near the end using count. THIS WILL FAIL! + NS_ASSERTION(pos==-1,"Error: RFindChar() with offset and count"); + + pos=s1.RFindChar('h',PR_FALSE,3,7); //this will search from near the end using count. THIS WILL SUCCEED! + NS_ASSERTION(pos==0,"Error: RFindChar() with offset and count"); + + //now let's try a few with bad data... + + pos=s1.RFindChar('k',PR_FALSE,100,2); //this will search from a bad offset. THIS WILL FAIL! + NS_ASSERTION(pos==-1,"Error: RFindChar() with offset and count"); + + pos=s1.RFindChar('k',PR_FALSE,10,0); //this will search for a bad count. THIS WILL FAIL! + NS_ASSERTION(pos==-1,"Error: RFindChar() with offset and count"); + + pos=10; + } + + //now try searching with Find() using offset and count... + { + stringtype s1("hello there rick"); + + PRInt32 pos= s1.Find("there",PR_FALSE,0,4); //first search from front using offset + NS_ASSERTION(pos==-1,"Error: Find() with offset and count"); //THIS WILL FAIL + + pos= s1.Find("there",PR_FALSE,0,8); //first search from front using count + NS_ASSERTION(pos==6,"Error: Find) with offset and count"); //THIS WILL SUCCEED + + pos= s1.Find("there",PR_FALSE,4,1); //first search from front using count + NS_ASSERTION(pos==-1,"Error: Find() with offset and count"); //THIS WILL FAIL + + pos= s1.Find("there",PR_FALSE,5,2); //first search from front using count + NS_ASSERTION(pos==6,"Error: Find() with offset and count"); //THIS WILL SUCCEED + + pos= s1.Find("there",PR_FALSE,6,1); //first search from front using count + NS_ASSERTION(pos==6,"Error: Find() with offset and count"); //THIS WILL SUCCEED + + pos= s1.Find("there",PR_FALSE,6,0); //first search from front using a bogus count + NS_ASSERTION(pos==-1,"Error: Find() with offset and count"); //THIS WILL FAIL + + pos= s1.Find("k",PR_FALSE,15,1); //first search from end using a count + NS_ASSERTION(pos==15,"Error: Find() with offset and count"); //THIS WILL SUCCEED + + pos= s1.Find("k",PR_FALSE,15,10); //first search from end using a LARGE count + NS_ASSERTION(pos==15,"Error: Find() with offset and count"); //THIS WILL SUCCEED + + pos= s1.Find("k",PR_FALSE,25,10); //first search from bogus offset using a LARGE count + NS_ASSERTION(pos==-1,"Error: Find() with offset and count"); //THIS WILL FAIL + + pos=10; + } + + //now try substringsearching with RFind() using offset and count... + { + nsString s1("abcdefghijklmnopqrstuvwxyz"); + + PRInt32 pos= s1.RFind("ghi"); //first search from end using count + NS_ASSERTION(pos==6,"Error: RFind() with offset and count"); //THIS WILL SUCCEED! + + pos= s1.RFind("nop",PR_FALSE,-1,4); //first search from end using count + NS_ASSERTION(pos==-1,"Error: RFind() with offset and count"); //THIS WILL FAIL + + pos= s1.RFind("nop",PR_FALSE,-1,15); //first search from end using count + NS_ASSERTION(pos==13,"Error: RFind() with offset and count"); //THIS WILL SUCCEED + + pos= s1.RFind("nop",PR_FALSE,16,3); //first search from middle using count + NS_ASSERTION(pos==-1,"Error: RFind() with offset and count"); //THIS WILL FAIL + + pos= s1.RFind("nop",PR_FALSE,16,7); //first search from middle using count + NS_ASSERTION(pos==13,"Error: RFind() with offset and count"); //THIS WILL SUCCEED + + pos= s1.RFind("nop",PR_FALSE,0,1); //first search from front using count + NS_ASSERTION(pos==-1,"Error: RFind() with offset and count"); //THIS WILL FAIL + + pos= s1.RFind("abc",PR_FALSE,0,1); //first search from middle using count + NS_ASSERTION(pos==0,"Error: RFind() with offset and count"); //THIS WILL SUCCEED + + pos= s1.RFind("foo",PR_FALSE,10,100); //first search from front using bogus count + NS_ASSERTION(pos==-1,"Error: RFind() with offset and count"); //THIS WILL FAIL + + pos= s1.RFind("ghi",PR_FALSE,30,1); //first search from middle using bogus offset + NS_ASSERTION(pos==-1,"Error: RFind() with offset and count"); //THIS WILL FAIL + + pos=10; + } + + //Various UNICODE tests... + { + //do some searching against chinese unicode chars... + + PRUnichar chinese[] = {0x4e41,0x4e42, 0x4e43, 0x0000}; // 3 chinese unicode + + nsString T2(chinese); + nsString T2copy(chinese); + + pos = T2.FindCharInSet("A"); + NS_ASSERTION(kNotFound==pos,"Error in FindCharInSet"); + + pos=T2.RFindCharInSet("A",2); + NS_ASSERTION(kNotFound==pos,"Error in RFindCharInSet"); + + pos=T2.Find("A", PR_FALSE, 0, 1); + NS_ASSERTION(kNotFound==pos,"Error in Find"); + + pos=T2.RFind("A", PR_FALSE, 2, 1); + NS_ASSERTION(kNotFound==pos,"Error in RFind"); + + T2.ReplaceChar("A",' '); + NS_ASSERTION(T2==T2copy,"Error in ReplaceChar"); + + //Here's the 3rd FTang unicode test... + + static char test4[]="ABCDEF"; + static char test4b[]=" BCDEF"; + + PRUnichar test5[]={0x4e41, 0x0000}; + PRUnichar test6[]={0x0041, 0x0000}; + + nsCString T4(test4); + nsCString T4copy(test4); + nsCString T4copyb(test4b); + nsCString T5(test5); + nsCString T6(test6); + + pos = T4.FindCharInSet(T5.get()); + NS_ASSERTION(0==pos,"Error in FindcharInSet"); //This should succeed. + + pos = T4.FindCharInSet(T6.get()); + NS_ASSERTION(kNotFound<pos,"Error in FindcharInSet"); //This should succeed. + + pos = T4.RFindCharInSet(T5.get(),2); + NS_ASSERTION(0==pos,"Error in RFindCharInSet"); //This should fail. + + pos = T4.RFindCharInSet(T6.get(),2); + NS_ASSERTION(kNotFound<pos,"Error in RFindCharInSet"); //This should fail. + + pos = T4.Find(T5.get(), PR_FALSE, 0, 1); + NS_ASSERTION(0==pos,"Error in Find"); //This should succeed. + + pos= T4.Find(T6.get(), PR_FALSE, 0, 1); + NS_ASSERTION(kNotFound<pos,"Error in Find"); //This should fail. + + pos = T4.RFind(T5.get(), PR_FALSE, 2, 1); + NS_ASSERTION(kNotFound==pos,"Error in RFind"); + + pos =T4.RFind(T6.get(), PR_FALSE, 2, 1); + NS_ASSERTION(kNotFound==pos,"Error in RFind"); + + +/* + NOT WORKING IN NEW STRING YET... + + T4.ReplaceChar(PRUnichar(0x4E41),PRUnichar(' ')); + if(T4 != T4copy) + printf("nsCString::ReplaceChar(PRUnichar, PRUnichar) error- replace when it should not\n"); + + T4 = test4; + T4.ReplaceChar(PRUnichar(0x0041),PRUnichar(' ')); + if(T4 != T4copyb) + printf("nsCString::ReplaceChar(PRUnichar, PRUnichar) error- not replace when it should\n"); + +*/ + + } + + return result; +} + +/** + * + * @update gess10/30/98 + * @param + * @return + */ +int CStringTester::TestConstructors(){ + int result=0; + PRUnichar pbuf[10]={'f','o','o',0}; + PRUnichar* buf=pbuf; + + nsString s1("hello world"); + nsCString c1("what's up"); + + + //Test nsCString constructors... + { + nsCString temp0; + nsCString temp1(s1); + NS_ASSERTION(temp1==s1,"nsCString Constructor error"); + + nsCString temp2(c1); + NS_ASSERTION(temp2==c1,"nsCString Constructor error"); + + nsCString temp3("hello world"); + NS_ASSERTION(temp3=="hello world","nsCString Constructor error"); + + nsCString temp4(pbuf); + NS_ASSERTION(temp4==pbuf,"nsCString Constructor error"); + + nsCString temp5('a'); + NS_ASSERTION(temp5=="a","nsCString Constructor error"); + + nsCString temp6(PRUnichar('a')); + NS_ASSERTION(temp5=="a","nsCString Constructor error"); + } + + //now just for fun, let's construct 2byte from 1byte and back... + { + nsCString temp0("hello"); + nsString temp1(temp0); + nsCString temp2(temp1); + } + + return result; +} + +/** + * + * @update gess10/30/98 + * @param + * @return + */ +int CStringTester::TestLogical(){ + int result=0; + stringtype temp8("aaaa"); + stringtype temp8a("AAAA"); + stringtype temp9("bbbb"); + + const char* aaaa="aaaa"; + const char* bbbb="bbbb"; + + + //First, test a known error that got checked into the tree... + { + nsString mURL("file:///c|/test/foo.txt"); + PRBool result=mURL.Equals("file:/",PR_FALSE); + NS_ASSERTION(!result,kEqualsError); + result=mURL.Equals("file:/",PR_FALSE,5); + NS_ASSERTION(result,kEqualsError); + result=mURL.Equals("file:/",PR_FALSE,-1); + NS_ASSERTION(!result,kEqualsError); + + nsString s1("rick"); + result=s1.Equals("rick",PR_FALSE,6); + result++; + } + + + { + //this little piece of code tests to see whether the PL_strcmp series works + //correctly even when we have strings whose buffers contain nulls. + + char *buf1 = "what's up \0\0 doc?"; + char *buf2 = "what's up \0\0 dog?"; + + nsString s1(buf2,17); + + PRInt32 result=s1.Compare(buf1,PR_TRUE,17); + result=s1.FindChar('?'); + result++; + } + + { + nsString foo("__moz_text"); + PRInt32 cmp=foo.Compare("pre",PR_FALSE,-1); + cmp=cmp; + } + + //First test the string compare routines... + + NS_ASSERTION(0>temp8.Compare(bbbb),kComparisonError); + NS_ASSERTION(0>temp8.Compare(temp9),kComparisonError); + NS_ASSERTION(0<temp9.Compare(temp8),kComparisonError); + NS_ASSERTION(0==temp8.Compare(temp8a,PR_TRUE),kComparisonError); + NS_ASSERTION(0==temp8.Compare(aaaa),kComparisonError); + + //Now test the boolean operators... + NS_ASSERTION(temp8==temp8,kComparisonError); + NS_ASSERTION(temp8==aaaa,kComparisonError); + + NS_ASSERTION(temp8!=temp9,kComparisonError); + NS_ASSERTION(temp8!=bbbb,kComparisonError); + + NS_ASSERTION(((temp8<temp9) && (temp9>=temp8)),kComparisonError); + + NS_ASSERTION(((temp9>temp8) && (temp8<=temp9)),kComparisonError); + NS_ASSERTION(temp9>aaaa,kComparisonError); + + NS_ASSERTION(temp8<=temp8,kComparisonError); + NS_ASSERTION(temp8<=temp9,kComparisonError); + NS_ASSERTION(temp8<=bbbb,kComparisonError); + + NS_ASSERTION(((temp9>=temp8) && (temp8<temp9)),kComparisonError); + NS_ASSERTION(temp9>=temp8,kComparisonError); + NS_ASSERTION(temp9>=aaaa,kComparisonError); + + NS_ASSERTION(temp8.Equals(temp8),kEqualsError); + NS_ASSERTION(temp8.Equals(aaaa),kEqualsError); + + stringtype temp10(temp8); + ToUpperCase(temp10); + NS_ASSERTION(temp8.Equals(temp10,PR_TRUE),kEqualsError); + NS_ASSERTION(temp8.Equals("AAAA",PR_TRUE),kEqualsError); + + + //now test the new string Equals APIs.. + { + nsCString s1("hello there"); + NS_ASSERTION(s1.Equals("hello there"),kEqualsError); + NS_ASSERTION(s1.Equals("hello rick",PR_FALSE,5),kEqualsError); + NS_ASSERTION(!s1.Equals("hello rick",PR_FALSE-1),kEqualsError); + + nsCString s2(""); + NS_ASSERTION(s2.Equals(""),kEqualsError); + + nsCString s3("view-source:"); + NS_ASSERTION(s3.Equals("VIEW-SOURCE:",PR_TRUE,12),kEqualsError); + } + + //now test the count argument... + { + nsString s1("rickgessner"); + nsString s2("rickricardo"); + PRInt32 result=s1.Compare(s2); //assume no case conversion, and full-length comparison... + result=s1.Compare(s2,PR_FALSE,4); + result=s1.Compare(s2,PR_FALSE,5); + + PRBool b=s1.Equals(s2); + b=s1.Equals("rick",PR_FALSE,4); + b=s1.Equals("rickz",PR_FALSE,5); + + result=10; + + nsString s3("view"); + +#define kString "view-source" + + b=s3.Equals(kString); + result=10; + } + + return result; +} + +/** + * + * @update gess10/30/98 + * @param + * @return + */ +int CStringTester::TestAssignAndAdd(){ + int result=0; + + static const char* s1="hello"; + static const char* s2="world"; + static const PRUnichar pbuf[] = {' ','w','o','r','l','d',0}; + + nsString ns1("I'm an nsString"); + nsCString nc1("I'm an nsCString"); + + nsAutoString as1("nsAutoString source"); + nsCAutoString ac1("nsCAutoString source"); + + + { + //**** Test assignments to nsCString... + + nsCString theDest; + theDest.Assign(theDest); //assign nsString to itself + theDest.Assign(ns1); //assign an nsString to an nsString + NS_ASSERTION(theDest==ns1,"Assignment error"); + + theDest.Assign(nc1); //assign an nsCString to an nsString + NS_ASSERTION(theDest==nc1,"Assignment error"); + + theDest.Assign(as1); //assign an nsAutoString to an nsString +// NS_ASSERTION(theDest==as1,"Assignment error"); + + theDest.Assign(ac1); //assign an nsCAutoString to an nsString +// NS_ASSERTION(theDest==ac1,"Assignment error"); + + theDest.Assign("simple char*"); //assign a char* to an nsString + NS_ASSERTION(theDest=="simple char*","Assignment error"); + + theDest.Assign(pbuf); //assign a PRUnichar* to an nsString + NS_ASSERTION(theDest==pbuf,"Assignment error"); + + theDest.Assign('!'); //assign a char to an nsString + NS_ASSERTION(theDest=="!","Assignment error"); + + theDest.Assign(PRUnichar('$')); //assign a char to an nsString + NS_ASSERTION(theDest=="$","Assignment error"); + + theDest=ns1; + NS_ASSERTION(theDest==ns1,"Assignment error"); + + theDest=nc1; + NS_ASSERTION(theDest==nc1,"Assignment error"); + + theDest='a'; + NS_ASSERTION(theDest=="a","Assignment error"); + + theDest=PRUnichar('a'); + NS_ASSERTION(theDest=="a","Assignment error"); + + theDest=s1; + NS_ASSERTION(theDest==s1,"Assignment error"); + + theDest=pbuf; + NS_ASSERTION(theDest==pbuf,"Assignment error"); + + } + + //test operator+()... + { + + /* NOT WORKING YET... + nsString s1("hello"); + nsString s2(" world"); + nsCString c1(" world"); + + stringtype theDest; + + theDest=s1+s2; + NS_ASSERTION(theDest=="hello world","Assignment error"); + + theDest=s1+c1; + NS_ASSERTION(theDest=="hello world","Assignment error"); + + theDest=s1+" world"; + NS_ASSERTION(theDest=="hello world","Assignment error"); + + theDest=s1+pbuf; + NS_ASSERTION(theDest=="hello world","Assignment error"); + + theDest=s1+'!'; + NS_ASSERTION(theDest=="hello!","Assignment error"); + + theDest=s1+PRUnichar('!'); + NS_ASSERTION(theDest=="hello!","Assignment error"); +*/ + + } + + return result; +} + + +/** + * + * @update gess10/30/98 + * @param + * @return + */ +int CStringTester::TestAppend(){ + int result=0; + + + static const char* s1="hello"; + static const char* s2="world"; + static const PRUnichar pbuf[] = {' ','w','o','r','l','d',0}; + static const PRUnichar pbuf1[] = {'a','b','c','d','l','d'}; + + + stringtype theDest; + theDest.Append((float)100.100); + NS_ASSERTION(theDest=="100.1","Append(float) error"); + + theDest.Truncate(); + theDest.Append(12345); + NS_ASSERTION(theDest=="12345","Append(int) error"); + + theDest.Truncate(); + theDest.Append(pbuf1,1); + NS_ASSERTION(theDest=="a","Append(PRUnichar*,count) error"); + + theDest.Truncate(); + theDest.Append('a'); + NS_ASSERTION(theDest=="a","Append(char) error"); + + + static const PRUnichar pbuf2[] = {'w','h','a','t','s',' ','u','p',' ','d','o','c','?',0}; + + theDest.Truncate(); + theDest.Append(pbuf,20); //try appending more chars than actual length of pbuf + NS_ASSERTION(theDest!=pbuf,"Append(PRUnichar*) error"); + //(NOTE: if you tell me to append X chars, I'll assume you really have X chars, and the length + // get's set accordingly. This test really is correct; it just seems odd. + + theDest.Truncate(0); + theDest.Append(pbuf,5); //try appending fewer chars than actual length of pbuf + NS_ASSERTION(theDest==" worl","Append(PRUnichar*) error"); + + theDest.Truncate(0); + theDest.Append(pbuf); //try appending all of pbuf + NS_ASSERTION(theDest==pbuf,"Append(PRUnichar*) error"); + + char* ss=0; + theDest.Truncate(); + theDest.Append(ss); //try appending NULL + NS_ASSERTION(theDest=="","Append(nullstr) error"); + + theDest.Append(pbuf,0); //try appending nothing + NS_ASSERTION(theDest=="","Append(nullstr) error"); + + + { + //test improvement to unichar appends... + stringtype s1("hello"); + char c='!'; + s1+=c; + NS_ASSERTION(s1=="hello!","operator+=() error"); + + c=(char)0xfa; + s1+=c; + s1.Append(c); + + PRUnichar theChar='f'; + s1+=theChar; + + char theChar2='g'; + s1+=theChar2; + +// long theLong= 1234; +// s1+=theLong; + + } + + { + //this just proves we can append nulls in our buffers... + stringtype c("hello"); + stringtype s(" there"); + c.Append(s); + char buf[]={'a','b',0,'d','e'}; + s.Append(buf,5); + } + + + stringtype temp2("there"); + + theDest.Append(temp2); + theDest.Append(" xxx "); + theDest.Append(pbuf); + theDest.Append('4'); + theDest.Append(PRUnichar('Z')); + + stringtype a(s1); + stringtype b(s2); + + theDest.Truncate(); + temp2.Truncate(); + +/* NOT WORKING YET... + theDest=a+b; + temp2=a+"world!"; + temp2=a+pbuf; + stringtype temp3; + temp3=temp2+'!'; +*/ + return result; +} + + +/** + * + * @update gess10/30/98 + * @param + * @return + */ +int CStringTester::TestExtractors(){ + int result=0; + + //first test the 2 byte version... + + + { + nsString temp1("hello there rick"); + nsString temp2; + + temp1.Left(temp2,10); + NS_ASSERTION(temp2=="hello ther","Left() error"); + + temp1.Mid(temp2,6,5); + NS_ASSERTION(temp2=="there","Mid() error"); + + temp1.Right(temp2,4); + NS_ASSERTION(temp2=="rick","Right() error"); + + //Now test the character accessor methods... + nsString theString("hello"); + PRUint32 len=theString.Length(); + PRUnichar theChar; + for(PRUint32 i=0;i<len;i++) { + theChar=theString.CharAt(i); + } + +/* NOT WORKING YET... + theChar=theString.First(); + theChar=theString.Last(); + theChar=theString[3]; + theString.SetCharAt('X',3); +*/ + } + + //now test the 1 byte version + { + nsCString temp1("hello there rick"); + nsCString temp2; + temp1.Left(temp2,10); + temp1.Mid(temp2,6,5); + temp1.Right(temp2,4); + + //Now test the character accessor methods... + nsCString theString("hello"); + PRUint32 len=theString.Length(); + char ch; + for(PRUint32 i=0;i<len;i++) { + ch=theString.CharAt(i); + } + +/* NOT WORKING YET... + + ch=theString.First(); + ch=theString.Last(); + ch=theString[3]; + theString.SetCharAt('X',3); +*/ + } + + + return result; +} + + + +/** + * + * @update gess10/30/98 + * @param + * @return + */ +int CStringTester::TestCreators(){ + int result=0; + +/* NOT WORKING YET + { + nsString theString5(""); + char* str0 = ToNewCString(theString5); + Recycle(str0); + + theString5+="hello rick"; + nsString* theString6=theString5.ToNewString(); + delete theString6; + + nsString theString1("hello again"); + PRUnichar* thePBuf=ToNewUnicode(theString1); + if(thePBuf) + Recycle(thePBuf); + + char* str = ToNewCString(theString5); + if(str) + Recycle(str); + + char buffer[6]; + theString5.ToCString(buffer,sizeof(buffer)); + + } + + { + nsCString theString5("hello rick"); + nsCString* theString6=theString5.ToNewString(); + delete theString6; + + PRUnichar* thePBuf=ToNewUnicode(theString5); + if(thePBuf) + Recycle(thePBuf); + + char* str = ToNewCString(theString5); + if(str) + Recycle(str); + + char buffer[100]; + theString5.ToCString(buffer,sizeof(buffer)-1); + nsCString theOther=theString5.GetBuffer(); + } + */ + return result; +} + + +/** + * + * @update gess10/30/98 + * @param + * @return + */ +int CStringTester::TestInsert(){ + int result=0; + + { + static const char pbuf[] = " world"; + + nsCString temp1("hello rick"); + temp1.Insert("there ",6); //char* insertion + NS_ASSERTION(temp1=="hello there rick","Insert error"); + + temp1.Insert(pbuf,3); //prunichar* insertion + NS_ASSERTION(temp1=="hel worldlo there rick","Insert error"); + + temp1.Insert("?",10); //char insertion + NS_ASSERTION(temp1=="hel worldl?o there rick","Insert error"); + + temp1.Insert('*',10); //char insertion + NS_ASSERTION(temp1=="hel worldl*?o there rick","Insert error"); + + temp1.Insert("xxx",100,3); //this should append. + NS_ASSERTION(temp1=="hel worldl*?o there rickxxx","Insert error"); + + nsCString temp2("abcdefghijklmnopqrstuvwxyz"); +// temp2.Insert(temp1,10); + temp2.Cut(20,5); + NS_ASSERTION(temp2=="abcdefghijklmnopqrstz","Insert error"); + + temp2.Cut(100,100); //this should fail. + NS_ASSERTION(temp2=="abcdefghijklmnopqrstz","Insert error"); + + } + + { + static const PRUnichar pbuf[] = {' ','w','o','r','l','d',0}; + + + nsString temp1("llo rick"); + + temp1.Insert("he",0); //char* insertion + NS_ASSERTION(temp1=="hello rick","Insert error"); + + temp1.Insert("there ",6); //char* insertion + NS_ASSERTION(temp1=="hello there rick","Insert error"); + + temp1.Insert(pbuf,3); //prunichar* insertion + NS_ASSERTION(temp1=="hel worldlo there rick","Insert error"); + + temp1.Insert("?",10); //char insertion + NS_ASSERTION(temp1=="hel worldl?o there rick","Insert error"); + + temp1.Insert('*',10); //char insertion + NS_ASSERTION(temp1=="hel worldl*?o there rick","Insert error"); + + temp1.Insert("xxx",100,3); //this should append. + NS_ASSERTION(temp1=="hel worldl*?o there rickxxx","Insert error"); + + nsString temp2("abcdefghijklmnopqrstuvwxyz"); +// temp2.Insert(temp1,10); + temp2.Cut(20,5); + NS_ASSERTION(temp2=="abcdefghijklmnopqrstz","Insert error"); + + temp2.Cut(100,100); //this should fail. + NS_ASSERTION(temp2=="abcdefghijklmnopqrstz","Insert error"); + + } + + return result; +} + + + +/** + * + * @update gess10/30/98 + * @param + * @return + */ +int CStringTester::TestDelete(){ + int result=0; + + //NOTE: You need to run this test program twice for this method to work. + // Once with USE_WIDE defined, and once without (to test nsCString) + + //let's try some whacky string deleting calls + { + const char* pbuf = "whats up doc?"; + + nsCString s1(pbuf); + s1.Cut(3,20); //try deleting more chars than actual length of pbuf + NS_ASSERTION(s1=="wha","Cut error"); + + s1=pbuf; + s1.Cut(3,-10); + NS_ASSERTION(s1==pbuf,"Cut error"); + + s1=pbuf; + s1.Cut(3,2); + NS_ASSERTION(s1=="wha up doc?","Cut error"); + + } + + //let's try some whacky string deleting calls + { + const PRUnichar pbuf[] = {'w','h','a','t','s',' ','u','p',' ','d','o','c','?',0}; + + nsString s1(pbuf); + s1.Cut(3,20); //try deleting more chars than actual length of pbuf + NS_ASSERTION(s1=="wha","Cut error"); + + s1=pbuf; + s1.Cut(3,-10); + NS_ASSERTION(s1==pbuf,"Cut error"); + + s1=pbuf; + s1.Cut(3,2); + NS_ASSERTION(s1=="wha up doc?","Cut error"); + } + + + { + nsCString s; + int i; + for(i=0;i<518;i++) { + s.Append("0123456789"); + } + s+="abc"; + s.Cut(0,5); + } + + { + astringtype ab("ab"); + stringtype abcde("cde"); + stringtype cut("abcdef"); + cut.Cut(7,10); //this is out of bounds, so ignore... + //cut.DebugDump(cout); + cut.Cut(5,2); //cut last chars + //cut.DebugDump(cout); + cut.Cut(1,1); //cut first char + //cut.DebugDump(cout); + cut.Cut(2,1); //cut one from the middle + //cut.DebugDump(cout); + cut="Hello there Rick"; + //cut.DebugDump(cout); +} + + return result; +} + +/** + * + * @update gess10/30/98 + * @param + * @return + */ +int CStringTester::TestTruncate(){ + int result=0; + //test delete against a twobyte string... + + { + nsCString s0; + nsCString s1(kNumbers[0]); + s0=s1; + s0.Truncate(100); //should fail + s0.Truncate(5); //should work + s0.Truncate(0); //should work + } + + { + nsString s0; + nsString s1(kNumbers[0]); + s0=s1; + s0.Truncate(100); //should fail + s0.Truncate(5); //should work + s0.Truncate(0); //should work + } + return result; +} + +/** + * + * @update gess10/30/98 + * @param + * @return + */ +int CStringTester::TestNumerics(){ + int result=0; + + //try a few numeric conversion routines... + { + nsCString str1("-12345"); + NS_ASSERTION(str1=="-12345","Append(int) error"); + + nsString str2("hello"); + nsString str3; + nsString str4("0"); + nsString str5("·"); + nsString str6("ξ"); + nsString str7("#xe3;"); + nsString str8("#FF;"); + nsCString str9("-#xa?a;"); //should return -10 (decimal) + nsCString str10("¿"); + nsCString str11("&#vvv;"); + nsCString str12("-vvv;"); + nsCString str13("-f"); + + PRInt32 err; + PRInt32 theInt=str1.ToInteger(&err); + theInt=str2.ToInteger(&err); + NS_ASSERTION(theInt==14,"ToInteger error"); + + theInt=str3.ToInteger(&err); + NS_ASSERTION(theInt==0,"ToInteger error"); + + theInt=str4.ToInteger(&err); + NS_ASSERTION(theInt==0,"ToInteger error"); + + theInt=str5.ToInteger(&err); + NS_ASSERTION(theInt==183,"ToInteger error"); + + theInt=str6.ToInteger(&err); + NS_ASSERTION(theInt==0,"ToInteger error"); + + theInt=str7.ToInteger(&err,16); + NS_ASSERTION(theInt==227,"ToInteger error"); + + theInt=str8.ToInteger(&err,kAutoDetect); + NS_ASSERTION(theInt==255,"ToInteger error"); + + theInt=str9.ToInteger(&err,kAutoDetect); + NS_ASSERTION(theInt==-10,"ToInteger error"); + + theInt=str10.ToInteger(&err); + NS_ASSERTION(theInt==191,"ToInteger error"); + + theInt=str11.ToInteger(&err); + NS_ASSERTION(theInt==0,"ToInteger error"); + + theInt=str12.ToInteger(&err); + NS_ASSERTION(theInt==0,"ToInteger error"); + + theInt=str13.ToInteger(&err); + NS_ASSERTION(theInt==-15,"ToInteger error"); + + + Stopwatch watch; + int i; + for(i=0;i<1000000;i++){ + theInt=str1.ToInteger(&err,16); + } + watch.Stop(); + watch.Print("ToInteger() "); + + str1="100.100"; + float theFloat=str1.ToFloat(&err); + } + //try a few numeric conversion routines... + { + nsCString str1("10000"); + nsCString str2("hello"); + nsCString str3; + PRInt32 err; + PRInt32 theInt=str1.ToInteger(&err); + NS_ASSERTION(theInt==10000,"ToInteger error"); + + theInt=str2.ToInteger(&err); + NS_ASSERTION(theInt==14,"ToInteger error"); + + theInt=str3.ToInteger(&err); + NS_ASSERTION(theInt==0,"ToInteger error"); + + str1="100.100"; + float theFloat=str1.ToFloat(&err); + } + return 0; +} + +/** + * + * @update gess10/30/98 + * @param + * @return + */ +int CStringTester::TestLexomorphic(){ + int result=0; + //test delete against a twobyte string... + + //NOTE: You need to run this test program twice for this method to work. + // Once with USE_WIDE defined, and once without (to test nsCString) + + + { + nsString theTag("FOO"); + nsString theLower; + theTag.ToLowerCase(theLower); + int x=5; + } + + PRUnichar pbuf[] = {'h','e','l','l','o','\n','\n','\n','\n',250,'\n','\n','\n','\n','\n','\n','r','i','c','k',0}; + + //and hey, why not do a few lexo-morphic tests... + nsString s0(pbuf); + ToUpperCase(s0); + ToLowerCase(s0); + s0.StripChars("l"); + s0.StripChars("\n"); + s0.StripChar(250); + NS_ASSERTION(s0=="heorick","Stripchars error"); + + { + nsAutoString s1(pbuf); + s1.CompressSet("\n ",' '); + } + + { + + char pbuf[] = { 0x1C, 0x04, 0x1D, 0x04, 0x20, 0x00, 0x2D, 0x00, 0x20, 0x00, 0x23, 0x04, 0x20, 0x00, 0x40, 0x04, + 0x43, 0x04, 0x3B, 0x04, 0x4F, 0x04, 0x20, 0x00, 0x30, 0x04, 0x40, 0x04, 0x3C, 0x04, 0x38, 0x04, + 0x38, 0x04, 0x20, 0x00, 0x2D, 0x00, 0x20, 0x00, 0x32, 0x04, 0x42, 0x04, 0x3E, 0x04, 0x40, 0x04, + 0x3E, 0x04, 0x41, 0x04, 0x42, 0x04, 0x35, 0x04, 0x3F, 0x04, 0x35, 0x04, 0x3D, 0x04, 0x3D, 0x04, + 0x4B, 0x04, 0x35, 0x04, 0x20, 0x00, 0x3B, 0x04, 0x38, 0x04, 0x46, 0x04, 0x30, 0x04, 0x20, 0x00, + 0x2D, 0x00, 0x20, 0x00, 0x30, 0x00, 0x39, 0x00, 0x2F, 0x00, 0x32, 0x00, 0x30, 0x00, 0x30, 0x00, + 0x30, 0x00, 0x00, 0x00}; + + nsAutoString temp((PRUnichar*)pbuf); + nsAutoString temp1(temp); + temp.CompressWhitespace(); + PRBool equals=temp.Equals(temp1); + + } + + { + nsString s1(" "); + s1.Trim("; \t"); + s1="helvetica"; + s1.Trim("; \t"); + } + + s0.Insert(" ",0); + NS_ASSERTION(s0==" heorick","Stripchars error"); + + s0.Append(" "); + NS_ASSERTION(s0==" heorick ","Stripchars error"); + + s0.Trim(" ",PR_TRUE,PR_TRUE); + NS_ASSERTION(s0=="heorick","Stripchars error"); + + s0.Append(" abc 123 xyz "); + s0.CompressWhitespace(); + NS_ASSERTION(s0=="heorick abc 123 xyz","CompressWS error"); + + s0.ReplaceChar('r','b'); + NS_ASSERTION(s0=="heobick abc 123 xyz","ReplaceChar error"); + + s0=pbuf; + ToUpperCase(s0); + ToLowerCase(s0); + s0.Append("\n\n\n \r \r \r \t \t \t"); + s0.StripWhitespace(); + + nsCAutoString s1("\n\r hello \n\n\n\r\r\r\t rick \t\t "); + ToUpperCase(s1); + ToLowerCase(s1); + s1.StripChars("o"); + s1.Trim(" ",PR_TRUE,PR_TRUE); + s1.CompressWhitespace(); + NS_ASSERTION(s1=="hell rick","Compress Error"); + + s1.ReplaceChar('h','w'); + NS_ASSERTION(s1=="well rick","Compress Error"); + + ToUpperCase(s1); + NS_ASSERTION(s1=="WELL RICK","Compress Error"); + + ToLowerCase(s1); + s1.Append("\n\n\n \r \r \r \t \t \t"); + s1.StripWhitespace(); + NS_ASSERTION(s1=="wellrick","Compress Error"); + + { + nsCString temp("aaaa"); + int i; + for(i=0;i<100;i++) { + temp+="0123456789."; + } + temp.StripChars("a2468"); + i=5; + + temp=" hello rick "; + temp.StripChars("\n\r\t\b "); + NS_ASSERTION(temp=="hellorick","This isn't good"); + } + + return result; +} + +/** + * + * @update gess10/30/98 + * @param + * @return + */ +int CStringTester::TestAutoStrings(){ + int result=0; + + PRUnichar pbuf[] = {'h','e','l','l','o',0}; + + //this test makes sure that autostrings who assume ownership of a buffer, + //don't also try to copy that buffer onto itself... (was a bug) + { + nsAutoString temp0; + nsAutoString temp1("hello rick"); + nsAutoString temp3(pbuf); + +/* NOT WORKING... + nsAutoString temp4(CBufDescriptor((char*)pbuf,PR_TRUE,5,5)); +*/ + nsAutoString temp5(temp3); + nsString s(pbuf); + nsAutoString temp6(s); + +/* NOT WORKING... + char buffer[500]; + nsAutoString temp7(CBufDescriptor((PRUnichar*)buffer,PR_TRUE,sizeof(buffer)-10/2,0)); + temp7="hello, my name is inigo montoya."; +*/ + + nsAutoString as; + int i; + for(i=0;i<30;i++){ + as+='a'; + } + PRBool b=PR_TRUE; //this line doesn't do anything, it just gives a convenient breakpoint. + NS_ASSERTION(as=="aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa","error in operator+=()"); + } + + + { + nsCAutoString temp0; + nsCAutoString temp1("hello rick"); + + + //nsCAutoString temp2("hello rick",PR_TRUE,5); + nsCAutoString temp3(pbuf); + + { + const char* buf="hello rick"; + int len=strlen(buf); + +// nsAutoString temp4(CBufDescriptor(buf,PR_TRUE,len+1,len)); //NOT WORKING + } + + nsCAutoString temp5(temp3); + nsString s(pbuf); + nsCAutoString temp6(s); //create one from a nsString + + nsCAutoString as; + int i; + for(i=0;i<30;i++){ + as+='a'; + } + PRBool b=PR_TRUE; + +#if 0 + +/* NOT WORKING + char buffer[500]; + + nsCAutoString s3(CBufDescriptor(buffer,PR_TRUE,sizeof(buffer)-1,0)); + s3="hello, my name is inigo montoya."; + */ + //make an autostring that copies an nsString... + nsString s0("eat icecream"); + nsCAutoString s4(s0); + nsCAutoString s5(s0.get()); + nsString aaa("hi there rick"); +#endif + } + + const char* st="hello again"; + nsString s; //this also forces nsString to run it's selftest. + s=st; + nsAutoString astr; + astr=st; + + return result; +} + +/** + * + * @update gess10/30/98 + * @param + * @return + */ +int CStringTester::TestSubsumables(){ + int result=0; + char* buf="hello rick"; + + return result; +} + +/** + * + * @update gess10/30/98 + * @param + * @return + */ +int CStringTester::TestRandomOps(){ + int result=0; + +#if 0 + + char* str[]={"abc ","xyz ","123 ","789 ","*** ","... "}; + + string theSTLString; + nsString theString; + nsString thePrevString; + + enum ops {eNOP,eAppend,eDelete,eInsert}; + char* opStrs[] = {"nop","append","delete","insert"}; + + srand( (unsigned)time( NULL ) ); + + int err[] = {1,7,9,6,0,4,1,1,1,1}; + + ops theOp=eNOP; + int pos,len,index; + + fstream output("c:/temp/out.file",ios::out); + output<<"dump!"; + + for(int theOpIndex=0;theOpIndex<1000000;theOpIndex++){ + + int r=rand(); + char buf[100]; + sprintf(buf,"%i",r); + len=strlen(buf); + index=buf[len-1]-'0'; + + //debug... index=err[theOp]; + + switch(index) { + case 0: + case 1: + case 2: + theSTLString.append(str[index]); + theString.Append(str[index]); + theOp=eAppend; + break; + + case 3: + case 4: + case 5: + theOp=eInsert; + if (theString.Length()>2) { + pos=theString.Length()/2; + theSTLString.insert(pos,str[index],4); + theString.Insert(str[index],pos); + } + break; + + case 6: + case 7: + case 8: + case 9: + theOp=eDelete; + if(theString.Length()>10) { + len=theString.Length()/2; + pos=theString.Length()/4; + theSTLString.erase(pos,len); + theString.Cut(pos,len); + } + break; + + default: + theOp=eNOP; + + } //for + + if(eNOP<theOp) { + + int lendiff=theString.Length()-theSTLString.length(); + PRBool equals=theString.Equals(theSTLString.c_str()); + if(((lendiff)) || (!equals)) { + printf("Error in %s at:%i len:%i (%s)!\n",opStrs[theOp],pos,len,str[index]); + output.close(); + theString.Equals(theSTLString.c_str()); + + if(theOp==eInsert) { + thePrevString.Insert(str[index],pos); + } + else if(theOp==eAppend) { + thePrevString.Append(str[index]); + } + return 0; + } + +#if FOO + output<< opStrs[theOp]; + if((eInsert==theOp) || (eAppend==theOp)){ + output<< "(" << str[index] << ", " << pos << ") "; + } + + thePrevString.ToCString(buffer,1000,0); + output << " Old: [" << buffer << "]"; + theString.ToCString(buffer,1000,0); + output << " New: [" << buffer << "]"; + output << " STL: [" << theSTLString.c_str() << "]" << endl; + + if(theString.mStringValue.mLength>300) { + theString.Truncate(); + theSTLString.erase(); + } +#endif + thePrevString=theString; + } + } +#endif + return result; +} + + +/** + * + * @update gess10/30/98 + * @param + * @return + */ +int CStringTester::TestReplace(){ + int result=0; + + const char* find=".."; + const char* rep= "+"; + + const char* s1="hello..there..rick..gessner."; + const char* s2="hello+there+rick+gessner."; + + nsCString s(s1); + s.ReplaceSubstring(find,rep); + NS_ASSERTION(s==s2,"ReplaceSubstring error"); + + s.ReplaceSubstring(rep,find); + NS_ASSERTION(s==s1,"ReplaceSubstring error"); + + return result; +} + + +/** + * This method tests the performance of various methods. + * + * + * @return + */ +int CStringTester::TestWideStringPerformance() { + + printf("Widestring performance tests...\n"); + + char* libname[] = {"STL","nsString",0}; + + + //************************************************** + //Test Construction against STL::wstring... + //************************************************** + { + nsString theConst; + for(int z=0;z<10;z++){ + theConst.Append("0123456789"); + } + + Stopwatch watch1; + int i; + for(i=0;i<1000000;i++){ + nsString s(theConst); + } + watch1.Stop(); + + wchar_t wbuf[] = {'a','b','c','d','e','f','g','h','i','j',0}; + wstring theConst2; + for(int w=0;w<10;w++){ + theConst2.append(wbuf); + } + + Stopwatch watch2; +#ifdef USE_STL + for(i=0;i<1000000;i++){ + wstring s(theConst2); + } +#endif + watch2.Stop(); + + printf("Construct(abcde) NSString: %f STL: %f\n",watch1.Elapsed(),watch2.Elapsed()); + } + + + //************************************************** + //Test append("abcde") against STL::wstring... + //************************************************** + { + + PRUnichar pbuf[10]={'a','b','c','d','e',0}; + + Stopwatch watch1; + int i; + for(i=0;i<1000;i++){ + nsString s; + for(int j=0;j<200;j++){ + s.Append("abcde"); + } + } + watch1.Stop(); + + wchar_t wbuf[10] = {'a','b','c','d','e',0}; + + Stopwatch watch2; +#ifdef USE_STL + for(i=0;i<1000;i++){ + wstring s; + for(int j=0;j<200;j++){ + s.append(wbuf); + } + } +#endif + watch2.Stop(); + + printf("Append(abcde) NSString: %f STL: %f\n",watch1.Elapsed(),watch2.Elapsed()); + } + + //************************************************** + //Test append(char) against STL::wstring + //************************************************** + { + + Stopwatch watch1; + int i; + for(i=0;i<500;i++){ + nsString s; + for(int j=0;j<200;j++){ + s.Append('a'); + } + } + watch1.Stop(); + + + Stopwatch watch2; +#ifdef USE_STL + for(i=0;i<500;i++){ + wstring s; + wchar_t theChar('a'); + for(int j=0;j<200;j++){ + s.append('a',1); + } + } +#endif + watch2.Stop(); + + printf("Append('a') NSString: %f STL: %f\n",watch1.Elapsed(),watch2.Elapsed()); + int x=0; + } + + //************************************************** + //Test insert("123") against STL::wstring + //************************************************** + { + + PRUnichar pbuf1[10]={'a','b','c','d','e','f',0}; + PRUnichar pbuf2[10]={'1','2','3',0}; + + Stopwatch watch1; + int i; + for(i=0;i<1000;i++){ + nsString s("abcdef"); + int inspos=3; + for(int j=0;j<100;j++){ + s.Insert(pbuf2,inspos); + inspos+=3; + } + } + watch1.Stop(); + + + wchar_t wbuf1[10] = {'a','b','c','d','e','f',0}; + wchar_t wbuf2[10] = {'1','2','3',0}; + + Stopwatch watch2; +#ifdef USE_STL + for(i=0;i<1000;i++){ + wstring s(wbuf1); + int inspos=3; + for(int j=0;j<100;j++){ + s.insert(inspos,wbuf2); + inspos+=3; + } + } +#endif + watch2.Stop(); + + printf("Insert(123) NSString: %f STL: %f\n",watch1.Elapsed(),watch2.Elapsed()); + int x=0; + } + + //************************************************** + //Let's test substring searching performance... + //************************************************** + { + PRUnichar pbuf1[] = {'a','a','a','a','a','a','a','a','a','a','b',0}; + PRUnichar pbuf2[] = {'a','a','b',0}; + + nsString s(pbuf1); + nsString target(pbuf2); + + Stopwatch watch1; + int i; + for(i=-1;i<200000;i++) { + PRInt32 result=s.Find(target,PR_FALSE); + } + watch1.Stop(); + + Stopwatch watch2; +#ifdef USE_STL + wchar_t wbuf1[] = {'a','a','a','a','a','a','a','a','a','a','b',0}; + wchar_t wbuf2[] = {'a','a','b',0}; + wstring ws(wbuf1); + wstring wtarget(wbuf2); + + for(i=-1;i<200000;i++) { + PRInt32 result=ws.find(wtarget); + } +#endif + watch2.Stop(); + + printf("Find(aab) NSString: %f STL: %f\n",watch1.Elapsed(),watch2.Elapsed()); + } + + //************************************************** + //Now let's test comparisons... + //************************************************** + { + nsString s("aaaaaaaaaaaaaaaaaaab"); + PRUnichar target[]={'a','a','a','a','a','a','a','a','a','a','a','a','a','b',0}; + size_t theLen=(sizeof(target)-1)/2; + + Stopwatch watch1; + int result=0; + int i; + for(i=-1;i<1000000;i++) { + result=s.Compare(target,PR_FALSE,theLen); + result++; + } + watch1.Stop(); + + Stopwatch watch2; +#ifdef USE_STL + wchar_t buf[]={'a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','b',0}; + wstring ws(buf); + wchar_t wtarget[]={'a','a','a','a','a','a','a','a','a','a','a','a','a','b',0}; + + for(i=-1;i<1000000;i++) { + result=ws.compare(0,theLen,wtarget); + result++; + } +#endif + watch2.Stop(); + + printf("Compare(aaaaaaaab) NSString: %f STL: %f\n",watch1.Elapsed(),watch2.Elapsed()); + + } + + //************************************************** + //Now lets test string deletions... + //************************************************** + { + + int strcount=6000; + int outerIter=100; + int innerIter=100; + + PRUnichar pbuf[] = {'1','2','3','4','5','6','7','8','9','0',0}; + nsString source1; //build up our target string... + int i; + for(i=0;i<strcount;i++) { + source1.Append(pbuf); + } + + Stopwatch watch1; + + for(i=0;i<outerIter;i++) { + nsString s1(source1); + for(int j=0;j<100;j++){ + s1.Cut(20,50); + } + } + watch1.Stop(); + printf("Cut(...) NSString: %f ",watch1.Elapsed()); + +#ifdef USE_STL + + wchar_t wbuf[] = {'1','2','3','4','5','6','7','8','9','0',0}; + wstring source2; //build up our target string... + + for(i=0;i<strcount;i++) { + source2.append(wbuf); + } + + Stopwatch watch2; + + for(i=0;i<outerIter;i++) { + wstring s2(source2); + for(int j=0;j<100;j++){ + s2.erase(20,50); + } + } + watch2.Stop(); + + printf(" STL: %f",watch2.Elapsed()); +#endif + printf("\n"); + + } + + //************************************************** + //Now let's test the findChar routine... + //************************************************** + { + + nsString s1; + int i; + for(i=0;i<100;i++) { + s1.Append("1234567890",10); + } + s1+="xyz"; + + Stopwatch watch1; + for(i=0;i<100000;i++) { + int f=s1.FindChar('z',PR_FALSE,0); + } + watch1.Stop(); + printf("FindChar('z') NSString: %f",watch1.Elapsed()); + +#ifdef USE_STL + wchar_t wbuf[] = {'1','2','3','4','5','6','7','8','9','0',0}; + wstring s2; + for( i=0;i<100;i++) { + s2.append(wbuf); + } + wchar_t wbuf2[] = {'x','y','z',0}; + s2.append(wbuf2); + + Stopwatch watch2; + + for(i=0;i<100000;i++) { + int f=s2.find_first_of('z',0); + } + watch2.Stop(); + printf(" STL: %f",watch2.Elapsed()); +#endif + printf("\n"); + + } + return 0; +} + + +/************************************************************************************************ + * + * This method tests the performance of various methods. + * + ************************************************************************************************/ +int CStringTester::TestStringPerformance() { + printf("c-String performance tests...\n"); + + char* libname[] = {"STL","nsString",0}; + + //************************************************** + //Test Construction against STL::wstring... + //************************************************** + { + nsCString theConst; + for(int z=0;z<10;z++){ + theConst.Append("0123456789"); + } + + Stopwatch watch1; + int i; + for(i=0;i<1000000;i++){ + nsCString s(theConst); + } + watch1.Stop(); + + char wbuf[] = {'a','b','c','d','e','f','g','h','i','j',0}; + string theConst2; + for(int w=0;w<10;w++){ + theConst2.append(wbuf); + } + + Stopwatch watch2; +#ifdef USE_STL + for(i=0;i<1000000;i++){ + string s(theConst2); + } +#endif + watch2.Stop(); + + printf("Construct(abcde) NSCString: %f STL: %f\n",watch1.Elapsed(),watch2.Elapsed()); + } + + //************************************************** + //Test append("abcde") against STL... + //************************************************** + + { + + Stopwatch watch1; + int i; + for(i=0;i<1000;i++){ + nsCString s; + for(int j=0;j<200;j++){ + s.Append("abcde",5); + } + } + watch1.Stop(); + + Stopwatch watch2; +#ifdef USE_STL + for(i=0;i<1000;i++){ + string s; + for(int j=0;j<200;j++){ + s.append("abcde",5); + } + } +#endif + watch2.Stop(); + + printf("Append(abcde) NSCString: %f STL: %f\n",watch1.Elapsed(),watch2.Elapsed()); + int x=0; + } + + //************************************************** + //Test append(char) against STL + //************************************************** + { + + Stopwatch watch1; + int i; + for(i=0;i<500;i++){ + nsCString s; + for(int j=0;j<200;j++){ + s.Append('a'); + } + } + watch1.Stop(); + + Stopwatch watch2; +#ifdef USE_STL + for(i=0;i<500;i++){ + string s; + wchar_t theChar('a'); + for(int j=0;j<200;j++){ + s.append('a',1); + } + } +#endif + watch2.Stop(); + + printf("Append('a') NSCString: %f STL: %f\n",watch1.Elapsed(),watch2.Elapsed()); + int x=0; + } + + //************************************************** + //Test insert("123") against STL + //************************************************** + { + + char pbuf1[10]={'a','b','c','d','e','f',0}; + char pbuf2[10]={'1','2','3',0}; + + Stopwatch watch1; + int i; + for(i=0;i<1000;i++){ + nsCString s("abcdef"); + int inspos=3; + for(int j=0;j<100;j++){ + s.Insert(pbuf2,inspos); + inspos+=3; + } + } + watch1.Stop(); + + Stopwatch watch2; +#ifdef USE_STL + for(i=0;i<1000;i++){ + string s(pbuf1); + int inspos=3; + for(int j=0;j<100;j++){ + s.insert(inspos,pbuf2); + inspos+=3; + } + } +#endif + watch2.Stop(); + + printf("insert(123) NSCString: %f STL: %f\n",watch1.Elapsed(),watch2.Elapsed()); + int x=0; + } + + //************************************************** + //Let's test substring searching performance... + //************************************************** + { + char *pbuf1 = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" \ + "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" + "aab"; + + char *pbuf2 = "aab"; + + nsCString s(pbuf1); + + Stopwatch watch1; + int i; + for(i=-1;i<20000;i++) { + PRInt32 result=s.Find(pbuf2,PR_FALSE); + } + watch1.Stop(); + + Stopwatch watch2; +#ifdef USE_STL + string ws(pbuf1); + for(i=-1;i<20000;i++) { + PRInt32 result=ws.find(pbuf2); + } +#endif + watch2.Stop(); + + printf("Find(aab) NSCString: %f STL: %f\n",watch1.Elapsed(),watch2.Elapsed()); + } + + //************************************************** + //Now let's test comparisons... + //************************************************** + { + char* target="aaaaaaaaaaaaab"; + size_t theLen=strlen(target); + + Stopwatch watch1; + nsCString s("aaaaaaaaaaaaaaaaaaab"); + int result=0; + int i; + for(i=-1;i<1000000;i++) { + result=s.Compare(target,PR_FALSE,theLen); + result++; + } + watch1.Stop(); + + Stopwatch watch2; +#ifdef USE_STL + string ws("aaaaaaaaaaaaaaaaaaab"); + for(i=-1;i<1000000;i++) { + result=ws.compare(0,theLen,target); + result++; + } +#endif + watch2.Stop(); + + printf("Compare(aaaaaaaab) NSCString: %f STL: %f\n",watch1.Elapsed(),watch2.Elapsed()); + + } + + //************************************************** + //Now lets test string deletions... + //************************************************** + { + + int strcount=6000; + int outerIter=100; + int innerIter=100; + + char* buffer = "1234567890"; + nsCString source1; //build up our target string... + int i; + for(i=0;i<strcount;i++) { + source1.Append(buffer); + } + + Stopwatch watch1; + for(i=0;i<outerIter;i++) { + nsCString s1(source1); + for(int j=0;j<innerIter;j++){ + s1.Cut(20,50); + } + } + watch1.Stop(); + printf("Cut(...) NSCString: %f ",watch1.Elapsed()); + +#ifdef USE_STL + string source2; //build up our target string... + for(i=0;i<strcount;i++) { + source2.append(buffer); + } + + Stopwatch watch2; + for(i=0;i<outerIter;i++) { + string s2(source2); + for(int j=0;j<innerIter;j++){ + s2.erase(20,50); + } + } + watch2.Stop(); + + printf(" STL: %f",watch2.Elapsed()); +#endif + printf("\n"); + } + + + //************************************************** + //Now let's test the findChar routine... + //************************************************** + { + + nsCString s1; + int i; + for(i=0;i<100;i++) { + s1.Append("1234567890",10); + } + s1+="xyz"; + + Stopwatch watch1; + for(i=0;i<100000;i++) { + int f=s1.FindChar('z',PR_FALSE,0); + } + watch1.Stop(); + printf("FindChar('z') NSCString: %f ",watch1.Elapsed()); + +#ifdef USE_STL + string s2; + for( i=0;i<100;i++) { + s2.append("1234567890"); + } + s2.append("xyz"); + + Stopwatch watch2; + for(i=0;i<100000;i++) { + int f=s2.find_first_of('z',0); + } + watch2.Stop(); + printf(" STL: %f\n",watch1.Elapsed(),watch2.Elapsed()); +#endif + printf("\n"); + + } + return 0; +} + + +/** + * This method is here as a place to put known regressions... + * + * + * @return + */ +int CStringTester::TestRegressions() { + + nsString s("FTP: Netscape</a>"); + PRInt32 result=s.Find("</A>",PR_TRUE); + + //this was a known bug... + { + nsString s0(""); + PRInt32 pos=s0.RFind("-->"); + nsString s1("debug"); + pos=s1.RFind("b"); + pos=s1.RFind("de",PR_FALSE,1); + pos=10; + } + + //this was a known bug... + { + nsString s0("RDF:RDF"); + PRInt32 pos=s0.Find(":"); + pos=10; + } + + return result; +} + +#endif + diff --git a/src/libs/xpcom18a4/xpcom/tests/windows/nsStringTest2.h b/src/libs/xpcom18a4/xpcom/tests/windows/nsStringTest2.h new file mode 100644 index 00000000..16ffc11a --- /dev/null +++ b/src/libs/xpcom18a4/xpcom/tests/windows/nsStringTest2.h @@ -0,0 +1,444 @@ +/******************************************************************************************** + * + * MODULES NOTES: + * + * This file is designed to help test the new nsString classes. + * + * Contributor(s): + * Rick Gessner <rickg@netscape.com> + * + * History: + * + * 02.29.2000: Original files (rickg) + * 03.02.2000: Flesh out the interface to be compatible with old library (rickg) + * + ********************************************************************************************/ + +#ifndef _STRINGTEST2 +#define _STRINGTEST2 + + +#include "nsString.h" +#include <time.h> + +#define USE_STL + +#ifdef USE_STL +#include <string> +using namespace std; +#endif + +#define USE_WIDE 1 +#ifdef USE_WIDE + #define stringtype nsString + #define astringtype nsAutoString + #define chartype PRUnichar +#else + #define stringtype nsCString + #define astringtype nsCAutoString + #define chartype char +#endif + +#include <stdio.h> +const double gTicks = 1.0e-7; + + + + + +/******************************************************** + + This class's only purpose in life is to test the + netscape string library. We exercise the string + API's here, and do a bit of performance testing + against the standard c++ library string (from STL). + + ********************************************************/ +class CStringTester { + +public: + + int TestI18nString(); + +}; + + + + +//test 1: unicode char is stripped correctly using StripChars() +void nsStringTest1(){ + PRUnichar test[]={0x0041,0x0051,0x0052,0x0000}; + nsString T(test); + PRUnichar result[]={0x0051,0x0052,0x0000}; + nsString R(result); + T.StripChars("ABC"); + NS_ASSERTION(T.Equals(R), "Test 1: Unicode comparison error"); +} +//test 2: unicode char is not matched and stripped when high-order byte is not 0x00 +void nsStringTest2(){ + PRUnichar test[]={0x4e41,0x4e51,0x4e52,0x4e53,0x0000}; + nsAutoString T(test); + PRUnichar result[]={0x4e41,0x4e51,0x4e52,0x4e53,0x0000}; + nsAutoString R(result); + T.StripChars("ABC"); + NS_ASSERTION(T.Equals(R), "Unicode comparison error"); +} + //test 3: unicode char is not matched and stripped when high-order byte is 0xFF +void nsStringTest3(){ + + PRUnichar test[] = {0xFF41,0x4e51,0x4e52,0x4e53,0x0000}; + nsAutoString T(test); + PRUnichar result[] = {0xFF41,0x4e51,0x4e52,0x4e53,0x0000}; + nsAutoString R(test); + T.StripChars("ABC"); + NS_ASSERTION(T.Equals(R), "Unicode comparison error"); +} +void nsStringTest4(){ + //test 4: unicode char is matched and stripped correctly using StripChar() + PRUnichar test[] = {0x0041,0x0051,0x0052,0x0000}; + nsAutoString T(test); + PRUnichar result[] = {0x0051,0x0052,0x0000}; + nsAutoString R(result); + T.StripChar('A'); + NS_ASSERTION(T.Equals(R), "Unicode comparison error"); +} +void nsStringTest5(){ + //test 5: unicode char is not matched and stripped when high-order byte is not 0x00 + + PRUnichar test[]={0x4e41,0x4e51,0x4e52,0x4e53,0x0000}; + nsAutoString T(test); + PRUnichar result[]={0x4e41,0x4e51,0x4e52,0x4e53,0x0000}; + nsAutoString R(result); + T.StripChar('A'); + NS_ASSERTION(T.Equals(R), "Unicode comparison error"); +} +void nsStringTest6(){ + //test 6: unicode char is not matched and stripped when high-order byte is 0xFF + + PRUnichar test[] = {0xFF41,0x4e51,0x4e52,0x4e53,0x0000}; + nsAutoString T(test); + PRUnichar result[] = {0xFF41,0x4e51,0x4e52,0x4e53,0x0000}; + nsAutoString R(result); + T.StripChar('A'); + NS_ASSERTION(T.Equals(R), "Unicode comparison error"); +} +void nsStringTest7(){ + //test 7: unicode char is matched and replaced correctly using ReplaceChar() + + PRUnichar test[] = {0x0041,0x0051,0x0052,0x0000}; + nsAutoString T(test); + PRUnichar result[] = {0x0050,0x0051,0x0052,0x0000}; + nsAutoString R(result); + T.ReplaceChar('A',0x50); + NS_ASSERTION(T.Equals(R), "Unicode comparison error"); +} +void nsStringTest8(){ + //test 8: unicode char is not matched or replaced when high-order byte != 0x00 + + PRUnichar test[] = {0x4e41,0x4e51,0x4e52,0x4e53,0x0000}; + nsAutoString T(test); + PRUnichar result[] = {0x4e41,0x4e51,0x4e52,0x4e53,0x0000}; + nsAutoString R(result); + T.ReplaceChar('A',0x50); + NS_ASSERTION(T.Equals(R), "Unicode comparison error"); +} +void nsStringTest9(){ + //test 9: unicode char is not matched or replaced when high-order byte matches search char + + PRUnichar test[] = {0x4150,0x4e51,0x4e52,0x4e53,0x0000}; + nsAutoString T(test); + PRUnichar result[] = {0x4150,0x4e51,0x4e52,0x4e53,0x0000}; + nsAutoString R(result); + T.ReplaceChar('A',0x50); + NS_ASSERTION(T.Equals(R), "Unicode comparison error"); +} +void nsStringTest10(){ + //test 10: unicode char is not matched or replaced when high-order byte == 0xFF + + PRUnichar test[] = {0xFFc1,0x4e51,0x4e52,0x4e53,0x0000}; + nsAutoString T(test); + PRUnichar result[] = {0xFFc1,0x4e51,0x4e52,0x4e53,0x0000}; + nsAutoString R(result); + T.ReplaceChar('A',0x50); + NS_ASSERTION(T.Equals(R), "Unicode comparison error"); +} + +void nsStringTest11(){ + //test 11: unicode char is correctly replaced when parameter 1 is a string + + PRUnichar test[] = {0x0041,0x0051,0x0052,0x0000}; + nsAutoString T(test); + PRUnichar result[] = {0x0050,0x0051,0x0052,0x0000}; + nsAutoString R(result); + T.ReplaceChar("ABC",0x50); + NS_ASSERTION(T.Equals(R), "Unicode comparison error"); +} +void nsStringTest12(){ + //test 12: unicode char is not replaced when high-order byte != 0x00 + + PRUnichar test[] = {0x4e41,0x0051,0x0052,0x0000}; + nsAutoString T(test); + PRUnichar result[] = {0x4e41,0x0051,0x0052,0x0000}; + nsAutoString R(result); + T.ReplaceChar("ABC",0x50); + NS_ASSERTION(T.Equals(R), "Unicode comparison error"); + +} +void nsStringTest13(){ + //test 13: unicode char is not replaced when high-order byte matches char in search string + PRUnichar test[] = {0x4150,0x4e51,0x4e52,0x4e53,0x0000}; + nsAutoString T(test); + PRUnichar result[] = {0x4150,0x4e51,0x4e52,0x4e53,0x0000}; + nsAutoString R(result); + T.ReplaceChar("ABC",'T'); + NS_ASSERTION(T.Equals(R), "Unicode comparison error"); + +} +void nsStringTest14(){ + PRUnichar test[] = {0xFFc2,0x4e51,0x4e52,0x4e53,0x0000}; + nsAutoString T(test); + PRUnichar result[] = {0xFFc2,0x4e51,0x4e52,0x4e53,0x0000}; + nsAutoString R(result); + T.ReplaceChar("ABC",'T'); + NS_ASSERTION(T.Equals(R), "Unicode comparison error"); +} +void nsStringTest15(){ + PRUnichar test[] = {0xFFc2,0x4e51,0x4e52,0x4e53,0x0000}; + nsAutoString T(test); + PRUnichar result[] = {0xFFc2,0x4e51,0x4e52,0x4e53,0x0000}; + nsAutoString R(result); + PRUnichar s = 0xc2; //compiler error on this line + T.ReplaceChar(s,'T'); + NS_ASSERTION(T.Equals(R), "Unicode comparison error"); +} + +void nsStringTest16(){ + /* TESTS for ReplaceSubstring()*/ + + PRUnichar test[] = {0x0041,0x0042,0x0043,0x0044,0x0045,0x0000}; + nsAutoString T(test); + PRUnichar result[] = {0x0044,0x0045,0x0046,0x0044,0x0045}; + nsAutoString R(result); + T.ReplaceSubstring("ABC","DEF"); + NS_ASSERTION(T.Equals(R), "Unicode comparison error"); + +} +void nsStringTest17(){ + + PRUnichar test[] = {0x0041,0x4e42,0x0043,0x0044,0x0045,0x0000}; + nsAutoString T(test); + PRUnichar result[] = {0x0041,0x4e42,0x0043,0x0044,0x0045,0x0000}; + nsAutoString R(result); + T.ReplaceSubstring("ABC","DEF"); + NS_ASSERTION(T.Equals(R), "Unicode comparison error"); +} +void nsStringTest18(){ + /*TESTS for Trim()*/ + + PRUnichar test[] = {0x0041,0x4e51,0x4e52,0x4e53,0x0000}; + nsAutoString T(test); + PRUnichar result[] = {0x4e51,0x4e52,0x4e53,0x0000}; + nsAutoString R (result); + T.Trim("ABC"); + NS_ASSERTION(T.Equals(R), "Unicode comparison error"); +} +void nsStringTest19(){ + PRUnichar test[] = {0x4e41,0x4e51,0x4e52,0x4e53,0x0000}; + nsAutoString T(test); + PRUnichar result[] = {0x4e41,0x4e51,0x4e52,0x4e53,0x0000}; + nsAutoString R(result); + T.Trim("ABC"); + NS_ASSERTION(T.Equals(R), "Unicode comparison error"); +} +void nsStringTest22(){ + PRUnichar test[] = {0x4e51,0x4e52,0x4e53,0x4e41,0x0000}; + nsAutoString T(test); + PRUnichar result[] = {0x4e51,0x4e52,0x4e53,0x4e41,0x0000}; + nsAutoString R(result); + T.Trim("ABC"); + NS_ASSERTION(T.Equals(R), "Unicode comparison error"); + +} +//void nsStringTest23(){ +// PRUnichar test[] = {0x4e51,0x4e52,0x4e53,0x4e22,0x0000}; +// nsAutoString T(test); +// PRUnichar s(0x4e22); +// PRUnichar result[] = {0x4e51,0x4e52,0x4e53,0x0000}; +// nsAutoString R(result); +// T.Trim(s,PR_TRUE,PR_TRUE,PR_FALSE); +// NS_ASSERTION(T.Equals(R), "Unicode comparison error"); +//} +void nsStringTest24(){ + /*TESTS for Find()*/ + PRUnichar test[] = {0x0041,0x0042,0x0043,0x0051,0x0052,0x0000}; + nsAutoString T(test); + NS_ASSERTION(T.Find("ABC") == 0, "Unicode comparison error"); + +} +void nsStringTest25(){ + PRUnichar test[] = {0x4e41,0x4e42,0x4e43,0x4e53,0x0000}; + nsAutoString T(test); + NS_ASSERTION(T.Find("ABC") == -1, "Unicode comparison error"); + +} +void nsStringTest26(){ + PRUnichar test[] = {0xFFc1,0x0051,0x0052,0x0053,0x0000}; + nsAutoString T(test); + PRUnichar str[] = {0xc1,0x51,0x52}; + nsAutoString S(str); + NS_ASSERTION(T.Find(S) == -1, "Unicode comparison error"); +} +void nsStringTest27(){ + /*TESTS for FindChar()*/ + + PRUnichar test[] = {0x0041,0x0051,0x0052,0x0000}; + nsAutoString T(test); + NS_ASSERTION(T.FindChar('A') == 0, "Unicode comparison error"); +} +void nsStringTest28(){ + PRUnichar test[] = {0x4e41,0x4e42,0x4e43,0x4e53,0x0000}; + nsAutoString T(test); + NS_ASSERTION(T.FindChar('A') == -1, "Unicode comparison error"); +} +void nsStringTest29(){ + PRUnichar test[] = {0xFFc1,0x4e51,0x4e52,0x4e53,0x0000}; + nsAutoString T(test); + NS_ASSERTION(T.FindChar(0xc1) == -1, "Unicode comparison error"); + +} +void nsStringTest30(){ + PRUnichar test[] = {0x4132,0x0051,0x0052,0x0000}; + nsAutoString T(test); + NS_ASSERTION(T.FindChar('A1') == -1, "Unicode comparison error"); +} + /*TESTS for FindCharInSet()*/ +void nsStringTest31(){ + PRUnichar test[] = {0x0041,0x0051,0x0052,0x0000}; + nsAutoString T(test); + NS_ASSERTION(T.FindCharInSet("ABC") == 0, "Unicode comparison error"); +} +void nsStringTest32(){ + PRUnichar test[] = {0x4e41,0x4e42,0x4e43,0x4e53,0x0000}; + nsAutoString T(test); + NS_ASSERTION(T.FindCharInSet("ABC") == -1, "Unicode comparison error"); + +} +void nsStringTest33(){ + PRUnichar test[] = {0xFFc1,0x4e51,0x4e52,0x4e53,0x0000}; + nsAutoString T(test); + PRUnichar str[] = {0xc1,0x51,0x52}; + nsAutoString s(str); + NS_ASSERTION(T.FindCharInSet(s) == -1, "Unicode comparison error"); +} +void nsStringTest34(){ + PRUnichar test[] = {0x4132,0x5132,0x5232,0x0000}; + nsAutoString T(test); + NS_ASSERTION(T.FindCharInSet("ABC") == -1, "Unicode comparison error"); +} + /*TESTS for RFind()*/ +void nsStringTest35(){ + + PRUnichar test[] = {0x0051,0x0052,0x0041,0x0042,0x0043,0x0000}; + nsAutoString T(test); + NS_ASSERTION(T.RFind("ABC") == 2, "Unicode comparison error"); +} +void nsStringTest36(){ + PRUnichar test[] = {0x4e41,0x4e42,0x4e43,0x4e53,0x0000}; + nsAutoString T(test); + NS_ASSERTION(T.RFind("ABC") == -1, "Unicode comparison error"); +} +void nsStringTest37(){ + PRUnichar test[] = {0xFFc1,0xFFc2,0xFFc3,0x4e53,0x0000}; + nsAutoString T(test); + PRUnichar str[] = {0xc1,0xc2,0xc3}; + nsAutoString s(str); + NS_ASSERTION(T.RFind(s) == -1, "Unicode comparison error"); +} + /*TESTS for RFindCharInSet*/ +void nsStringTest38(){ + + PRUnichar test[] = {0x0041,0x0042,0x0043,0x0000}; + nsAutoString T(test); + int res = T.RFindCharInSet("ABC"); + NS_ASSERTION(res==0, "Unicode comparison error"); +} +void nsStringTest39(){ + PRUnichar test[] = {0x4e41,0x4e42,0x4e43,0x4e53,0x0000}; + nsAutoString T(test); + NS_ASSERTION(T.RFindCharInSet("ABC") == -1, "Unicode comparison error"); +} +void nsStringTest40(){ + PRUnichar test[] = {0xFFc1,0x4e51,0x4e52,0x4e53,0x0000}; + nsAutoString T(test); + PRUnichar str[] = {0xc1,0xc2,0xc3}; + nsAutoString s(str); + NS_ASSERTION(T.RFindCharInSet(s) == -1, "Unicode comparison error"); +} +void nsStringTest41(){ + PRUnichar test[] = {0x4132,0x0051,0x0052,0x0000}; + nsAutoString T(test); + NS_ASSERTION(T.RFindCharInSet("ABC") == -1, "Unicode comparison error"); +} + /* TESTS for Compare() */ +void nsStringTest42(){ + PRUnichar test[] = {0x0041,0x0042,0x0043,0x0000}; + nsAutoString T(test); + NS_ASSERTION(T.Compare("ABC") == 0, "Unicode comparison error"); +} +void nsStringTest43(){ + PRUnichar test[] = {0xc341,0xc342,0xc343}; + nsAutoString T(test); + NS_ASSERTION(T.Compare("ABC") == 1, "Unicode comparison error"); +} + + +int CStringTester::TestI18nString(){ + nsStringTest1(); + nsStringTest2(); + nsStringTest3(); + nsStringTest4(); + nsStringTest5(); + nsStringTest6(); + nsStringTest7(); + nsStringTest8(); + nsStringTest9(); + nsStringTest10(); + nsStringTest11(); + nsStringTest12(); + nsStringTest13(); + nsStringTest14(); + nsStringTest15(); + nsStringTest16(); + nsStringTest17(); + nsStringTest18(); + nsStringTest19(); + //nsStringTest20(); + //nsStringTest21(); + nsStringTest22(); + //nsStringTest23(); + nsStringTest24(); + nsStringTest25(); + nsStringTest26(); + nsStringTest27(); + nsStringTest28(); + nsStringTest29(); + nsStringTest30(); + nsStringTest31(); + nsStringTest32(); + nsStringTest33(); + nsStringTest34(); + nsStringTest35(); + nsStringTest36(); + nsStringTest37(); + nsStringTest38(); + nsStringTest39(); + nsStringTest40(); + nsStringTest41(); + nsStringTest42(); + nsStringTest43(); + + return 0; +} + +#endif + |