summaryrefslogtreecommitdiffstats
path: root/src/libs/xpcom18a4/xpcom/tests/windows
diff options
context:
space:
mode:
Diffstat (limited to 'src/libs/xpcom18a4/xpcom/tests/windows')
-rw-r--r--src/libs/xpcom18a4/xpcom/tests/windows/.cvsignore1
-rw-r--r--src/libs/xpcom18a4/xpcom/tests/windows/Makefile.in60
-rw-r--r--src/libs/xpcom18a4/xpcom/tests/windows/TestCOM.cpp181
-rw-r--r--src/libs/xpcom18a4/xpcom/tests/windows/TestHelloXPLoop.cpp177
-rw-r--r--src/libs/xpcom18a4/xpcom/tests/windows/nsStringTest.cpp33
-rw-r--r--src/libs/xpcom18a4/xpcom/tests/windows/nsStringTest.h2277
-rw-r--r--src/libs/xpcom18a4/xpcom/tests/windows/nsStringTest2.h444
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("&#183;");
+ nsString str6("&xi;");
+ nsString str7("#xe3;");
+ nsString str8("#FF;");
+ nsCString str9("-#xa?a;"); //should return -10 (decimal)
+ nsCString str10("&#191;");
+ 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
+