// spcreconsole.cpp

//

// Copyright (c) 2005 - 2006, Google Inc.

// All rights reserved.

//

// Redistribution and use in source and binary forms, with or without

// modification, are permitted provided that the following conditions are

// met:

//

//     * Redistributions of source code must retain the above copyright

// notice, this list of conditions and the following disclaimer.

//     * Redistributions in binary form must reproduce the above

// copyright notice, this list of conditions and the following disclaimer

// in the documentation and/or other materials provided with the

// distribution.

//     * Neither the name of Google Inc. nor the names of its

// contributors may be used to endorse or promote products derived from

// this software without specific prior written permission.

//

// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

//

// Author: Sanjay Ghemawat

//

// Heavily refactored for Symbian OS by Accenture.

#include <e32base.h>

#include <e32std.h>

#include <e32math.h>

#include <e32cons.h>			// Console

#include <bacline.h>

#include <cregex.h>

#include <tregexarg.h>

#include <tregexoptions.h>

//  Constants

_LIT(KTextConsoleTitle, "Console");

_LIT(KTextFailed, " failed, leave code = %d\n");

_LIT(KTextPressAnyKey, "[press any key]\n");

//  Global Variables

LOCAL_D CConsoleBase* console; // write all messages to this

TBool verboseMode = EFalse;

//  Local Functions

// CHECK dies with a fatal error if condition is not true.  It is *not*

// controlled by NDEBUG, so the check will be executed regardless of

// compilation mode.  Therefore, it is safe to do things like:

//    CHECK_EQ(fp->Write(x), 4)

#define CHECK(condition)								\

	{													\

	if (!(condition))									\

		{                                   			\

		_LIT(KCondition, #condition);					\

		console->Printf(_L("%d: Check failed: %S\n"),	\

						__LINE__, &KCondition());		\

		User::Leave(KErrGeneral);						\

		}												\

	}

#define CHECK_EQ(a, b)   CHECK(a == b)

static void Timing1L(TInt aNumIters)

	{

	console->Printf(_L("Test Timing 1, %d iterations.\n"), aNumIters);

	// Same pattern lots of times

	_LIT8(KPattern, "ruby:\\d+");

	_LIT8(KString,"ruby:1234");

	CRegEx* pattern = CRegEx::NewLC(KPattern());

	for (TInt j = aNumIters; j > 0; j--)

		{

		CHECK(pattern->FullMatchL(KString()));

		}

	CleanupStack::PopAndDestroy(pattern);

	}

static void Timing2L(TInt aNumIters)

	{

	console->Printf(_L("Test Timing 2, %d iterations.\n"), aNumIters);

	// Same pattern lots of times

	_LIT8(KPattern, "ruby:(\\d+)");

	_LIT8(KString,"ruby:1234");

	CRegEx* pattern = CRegEx::NewLC(KPattern());

	TInt i;

	for (TInt j = aNumIters; j > 0; j--)

		{

		CHECK(pattern->FullMatchL(KString(), &i));

		CHECK_EQ(i, 1234);

		}

	CleanupStack::PopAndDestroy(pattern);

	}

static void Timing3L(TInt aNumIters)

	{

	console->Printf(_L("Test Timing 3, %d iterations.\n"), aNumIters);

	_LIT8(KLine, "this is another line\n");

	HBufC8* text = HBufC8::NewLC(KLine().Length() * aNumIters);

	TPtr8 pText = text->Des();

	for (int j = aNumIters; j > 0; j--)

		{

		pText.Append(KLine());

		}

	CRegEx* lineMatcher = CRegEx::NewLC(_L8(".*\n"));

	TInt counter = 0;

	while (lineMatcher->ConsumeL(pText))

		{

		counter++;

		}

	CleanupStack::PopAndDestroy(2, text);

	CHECK_EQ(counter, aNumIters);

	console->Printf(_L("Matched %d lines\n"), counter);

	}

static void RadixTestsL()

	{

	console->Write(_L("Testing hex\n"));

	#define CHECK_HEX(type, value) 										\

		{																\

		type v;															\

		CRegEx* re = CRegEx::NewLC(_L8("([0-9a-fA-F]+)[uUlL]*"));		\

		CHECK(re->FullMatchL(_L8(#value), Hex(&v)));					\

		CHECK_EQ(v, 0x ## value);										\

		CleanupStack::PopAndDestroy(re);								\

		re = NULL;														\

		}

	CHECK_HEX(TInt64,     2baddeadbeefLL);

	CHECK_HEX(TUint8,     abU);

	CHECK_HEX(TUint16,    2badU);

	CHECK_HEX(TUint32,    deadbeefUL);

	CHECK_HEX(TUint,      cafebabeU);

	#undef CHECK_HEX

	console->Write(_L("Testing octal\n"));

	#define CHECK_OCTAL(type, value) 									\

		{																\

		type v;															\

		CRegEx* re = CRegEx::NewLC(_L8("([0-7]+)[uUlL]*"));				\

		CHECK(re->FullMatchL(_L8(#value), Octal(&v)));					\

		CHECK_EQ(v, 0 ## value);										\

		CleanupStack::PopAndDestroy(re);								\

		re = NULL;														\

		}

	CHECK_OCTAL(TInt64,		777777777777LL);

	CHECK_OCTAL(TUint8,		177U);

	CHECK_OCTAL(TUint16,	177777U);

	CHECK_OCTAL(TUint32,	3777777777UL);

	CHECK_OCTAL(TUint,		3777777777U);

	#undef CHECK_OCTAL

	console->Write(_L("Testing decimal\n"));

	#define CHECK_DECIMAL(type, value) 									\

		{																\

		type v;															\

		CRegEx* re = CRegEx::NewLC(_L8("(-?[0-9]+)[uUlL]*"));			\

		CHECK(re->FullMatchL(_L8(#value), &v));							\

		CHECK_EQ(v, value);												\

		CleanupStack::PopAndDestroy(re);								\

		re = NULL;														\

		}	

	CHECK_DECIMAL(TInt8,	-1);

	CHECK_DECIMAL(TUint8,	1U);

	CHECK_DECIMAL(TInt16,	-9999);

	CHECK_DECIMAL(TUint16,	9999U);

	CHECK_DECIMAL(TInt32,	-123456L);

	CHECK_DECIMAL(TUint32,	123456U);

	CHECK_DECIMAL(TInt64,	1234567890123456789LL);

	CHECK_DECIMAL(TInt,		-1234567890);

	CHECK_DECIMAL(TUint,	1234567890U);

	#undef CHECK_DECIMAL

}

static void TestReplaceL()

	{

	console->Write(_L("Testing ReplaceL\n"));

	struct ReplaceTest

		{

		TBuf8<32>	iRegExp;

		TBuf8<32>	iRewrite;

		TBuf8<64>	iOriginal;

		TBuf8<64>	iSingle;

		TBuf8<64>	iGlobal;

		TInt		iGlobalCount; // the expected return value from ReplaceAll

		};

	static const ReplaceTest tests[] =

	{

		// Test 1

		{

		_L8("(qu|[b-df-hj-np-tv-z]*)([a-z]+)"),

		_L8("\\2\\1ay"),

		_L8("the quick brown fox jumps over the lazy dogs."),

		_L8("ethay quick brown fox jumps over the lazy dogs."),

		_L8("ethay ickquay ownbray oxfay umpsjay overay ethay azylay ogsday."),

		9

		},

		// Test 2

		{

		_L8("\\w+"),

		_L8("\\0-NOSPAM"),

		_L8("paul.haahr@google.com"),

		_L8("paul-NOSPAM.haahr@google.com"),

		_L8("paul-NOSPAM.haahr-NOSPAM@google-NOSPAM.com-NOSPAM"),

		4

		},

		// Test 3

		{_L8("^"),

		_L8("(START)"),

		_L8("foo"),

		_L8("(START)foo"),

		_L8("(START)foo"),

		1

		},

		// Test 4

		{

		_L8("^"),

		_L8("(START)"),

		_L8(""),

		_L8("(START)"),

		_L8("(START)"),

		1

		},

		// Test 5

		{

		_L8("$"),

		_L8("(END)"),

		_L8(""),

		_L8("(END)"),

		_L8("(END)"),

		1

		},

		// Test 6

		{

		_L8("b"),

		_L8("bb"),

		_L8("ababababab"),

		_L8("abbabababab"),

		_L8("abbabbabbabbabb"),

		5

		},

		// Test 7

		{

		_L8("b"),

		_L8("bb"),

		_L8("bbbbbb"),

		_L8("bbbbbbb"),

		_L8("bbbbbbbbbbbb"),

		6

		},

		// Test 8

		{_L8("b+"),

		_L8("bb"),

		_L8("bbbbbb"),

		_L8("bb"),

		_L8("bb"),

		1

		},

		// Test 9

		{

		_L8("b*"),

		_L8("bb"),

		_L8("bbbbbb"),

		_L8("bb"),

		_L8("bb"),

		1

		},

		// Test 10

		{

		_L8("b*"),

		_L8("bb"),

		_L8("aaaaa"),

		_L8("bbaaaaa"),

		_L8("bbabbabbabbabbabb"),

		6

		},

		// Test 11

		{

		_L8("b*"),

		_L8("bb"),

		_L8("aa\naa\n"),

		_L8("bbaa\naa\n"),

		_L8("bbabbabb\nbbabbabb\nbb"),

		7

		},

		// Test 12

		{

		_L8("b*"),

		_L8("bb"),

		_L8("aa\raa\r"),

		_L8("bbaa\raa\r"),

		_L8("bbabbabb\rbbabbabb\rbb"),

		7

		},

		// Test 13

		{

		_L8("b*"),

		_L8("bb"),

		_L8("aa\r\naa\r\n"),

		_L8("bbaa\r\naa\r\n"),

		_L8("bbabbabb\r\nbbabbabb\r\nbb"),

		7

		},

#ifdef SUPPORT_UTF8

		// Test 14

		{	

		_L8("b*"),

		_L8("bb"),

		_L8("\xE3\x83\x9B\xE3\x83\xBC\xE3\x83\xA0\xE3\x81\xB8"),   // utf8

		_L8("bb\xE3\x83\x9B\xE3\x83\xBC\xE3\x83\xA0\xE3\x81\xB8"),

		_L8("bb\xE3\x83\x9B""bb""\xE3\x83\xBC""bb""\xE3\x83\xA0""bb""\xE3\x81\xB8""bb"),

		5

		},

		// Test 15

		{

		_L8("b*"),

		_L8("bb"),

		_L8("\xE3\x83\x9B\r\n\xE3\x83\xBC\r\xE3\x83\xA0\n\xE3\x81\xB8\r\n"),   // utf8

		_L8("bb\xE3\x83\x9B\r\n\xE3\x83\xBC\r\xE3\x83\xA0\n\xE3\x81\xB8\r\n"),

		_L8("bb\xE3\x83\x9B""bb\r\nbb""\xE3\x83\xBC""bb\rbb""\xE3\x83\xA0""bb\nbb""\xE3\x81\xB8""bb\r\nbb"),

		9

		},

#endif

		{

		KNullDesC8(),

		KNullDesC8(),

		KNullDesC8(),

		KNullDesC8(),

		KNullDesC8(),

		-1

		}

	};

#ifdef SUPPORT_UTF8

	const TBool supportUtf8 = ETrue;

#else

	const TBool supportUtf8 = EFalse;

#endif

	CRegEx* re = NULL;

	TRegExOptions options = TRegExOptions(EPcreNewlineCrLf);

	options.SetUtf8(supportUtf8);	

	TInt i =0;

	for (const ReplaceTest* t = tests; t->iGlobalCount > -1; ++t)

		{		

		console->Printf(_L("Replace Test %d\n"), ++i);

		re = CRegEx::NewLC(t->iRegExp, options);

		CHECK_EQ(re->Error(), KErrNone);

		TBuf8<64> one(t->iOriginal);

		CHECK(re->ReplaceL(t->iRewrite, one));

		CHECK_EQ(one, t->iSingle);

		TBuf8<64> all(t->iOriginal);

		const TInt replaceCount = re->GlobalReplaceL(t->iRewrite, all);

		CHECK_EQ(all, t->iGlobal);

		CHECK_EQ(replaceCount, t->iGlobalCount);		

		CleanupStack::PopAndDestroy(re);

		re = NULL;

		}

	// One final test: test \r\n replacement when we're not in CRLF mode

	{

	TRegExOptions options2 = TRegExOptions(EPcreNewlineCr);

	options2.SetUtf8(supportUtf8);

	re = CRegEx::NewLC(_L8("b*"), options2);

	CHECK_EQ(re->Error(), KErrNone);

	TBuf8<32> all(_L8("aa\r\naa\r\n"));

	CHECK_EQ(re->GlobalReplaceL(_L8("bb"), all), 9);

	CHECK_EQ(all, _L8("bbabbabb\rbb\nbbabbabb\rbb\nbb"));

	CleanupStack::PopAndDestroy(re);

	re = NULL;	

	}

	{

	TRegExOptions options3 = TRegExOptions(EPcreNewlineLf);

	options3.SetUtf8(supportUtf8);

	re = CRegEx::NewLC(_L8("b*"), options3);

	CHECK_EQ(re->Error(), KErrNone);

	TBuf8<32> all(_L8("aa\r\naa\r\n"));

	CHECK_EQ(re->GlobalReplaceL(_L8("bb"), all), 9);

	CHECK_EQ(all, _L8("bbabbabb\rbb\nbbabbabb\rbb\nbb"));

	CleanupStack::PopAndDestroy(re);

	re = NULL;	

	}

	// TODO: test what happens when no PCRE_NEWLINE_* flag is set.

	//       Alas, the answer depends on how pcre was compiled.

}

static void TestExtractL()

	{

	console->Write(_L("Testing ExtractL\n"));

	TBuf8<32> s;	

	CRegEx* re = NULL;

	re = CRegEx::NewLC(_L8("(.*)@([^.]*)"));

	CHECK(re->ExtractL(_L8("\\2!\\1"), _L8("boris@kremvax.ru"), s));

	CHECK_EQ(s, _L8("kremvax!boris"));

	CleanupStack::PopAndDestroy(re);

	re = NULL;

	// check the RE interface as well

	re = CRegEx::NewLC(_L8(".*"));

	CHECK(re->ExtractL(_L8("'\\0'"), _L8("foo"), s));

	CHECK_EQ(s, _L8("'foo'"));

	CleanupStack::PopAndDestroy(re);

	re = NULL;

	re = CRegEx::NewLC(_L8("bar"));

	CHECK(!re->ExtractL(_L8("'\\0'"), _L8("baz"), s));

	CHECK_EQ(s, _L8("'foo'"));

	CleanupStack::PopAndDestroy(re);

	}

static void TestConsumeL()

	{

	console->Write(_L("Testing ConsumeL\n"));

	TBuf8<3> word;

	TBuf8<24> input(_L8("   aaa b!@#$@#$cccc"));

	// matches a word, possibly proceeded by whitespace

	CRegEx* re = CRegEx::NewLC(_L8("\\s*(\\w+)"));

	CHECK(re->ConsumeL(input, &word));

	CHECK_EQ(word, _L8("aaa"));

	CHECK(re->ConsumeL(input, &word));

	CHECK_EQ(word, _L8("b"));

	CHECK(!re->ConsumeL(input, &word));

	CleanupStack::PopAndDestroy(re);

	}

static void TestFindAndConsumeL()

	{

	console->Write(_L("Testing FindAndConsumeL\n"));

	TBuf8<4> word;

	TBuf8<24> input(_L8("   aaa b!@#$@#$cccc"));

	CRegEx* re = CRegEx::NewLC(_L8("(\\w+)")); // matches a word

	CHECK(re->FindAndConsumeL(input, &word));

	CHECK_EQ(word, _L8("aaa"));

	CHECK(re->FindAndConsumeL(input, &word));

	CHECK_EQ(word, _L8("b"));

	CHECK(re->FindAndConsumeL(input, &word));

	CHECK_EQ(word, _L8("cccc"));

	CHECK(!re->FindAndConsumeL(input, &word));

	CleanupStack::PopAndDestroy(re);

	}

static void TestMatchNumberPeculiarityL()

	{

	console->Write(_L("Testing match-number peculiarity\n"));

	TBuf8<3> word1;

	TBuf8<3> word2;

	TBuf8<3> word3;

	CRegEx* re = CRegEx::NewLC(_L8("(foo)|(bar)|(baz)"));

	CHECK(re->PartialMatchL(_L8("foo"), &word1, &word2, &word3));

	CHECK_EQ(word1, _L8("foo"));

	CHECK_EQ(word2, KNullDesC8());

	CHECK_EQ(word3, KNullDesC8());

	CHECK(re->PartialMatchL(_L8("bar"), &word1, &word2, &word3));

	CHECK_EQ(word1, KNullDesC8());

	CHECK_EQ(word2, _L8("bar"));

	CHECK_EQ(word3, KNullDesC8());

	CHECK(re->PartialMatchL(_L8("baz"), &word1, &word2, &word3));

	CHECK_EQ(word1, KNullDesC8());

	CHECK_EQ(word2, KNullDesC8());

	CHECK_EQ(word3, _L8("baz"));

	CHECK(!re->PartialMatchL(_L8("f"), &word1, &word2, &word3));

	CleanupStack::PopAndDestroy(re);

	re = NULL;

	TBuf8<12> a;

	re = CRegEx::NewLC(_L8("(foo)|hello"));

	CHECK(re->FullMatchL(_L8("hello"), &a));

	CHECK_EQ(a, KNullDesC8());

	CleanupStack::PopAndDestroy(re);

	}

static void TestRecursionL()

	{

	console->Write(_L("Testing recursion\n"));

	// Get one string that passes (sometimes), one that never does.

	TBuf8<12> good(_L8("abcdefghijk"));

	TBuf8<12> bad(_L8("acdefghijkl"));

	// According to pcretest, matching text_good against (\w+)*b

	// requires match_limit of at least 8192, and match_recursion_limit

	// of at least 37.

	TRegExOptions optionsMatchLimit;

	optionsMatchLimit.SetMatchLimit(8192);

	CRegEx* re = CRegEx::NewLC(_L8("(\\w+)*b"), optionsMatchLimit);

	CHECK(re->PartialMatchL(good));

	CHECK(re->PartialMatchL(bad) == EFalse);

	CHECK(re->FullMatchL(good) == EFalse);

	CHECK(re->FullMatchL(bad) == EFalse);	

	CleanupStack::PopAndDestroy(re);

	re = NULL;

	optionsMatchLimit.SetMatchLimit(1024);

	CRegEx* re2 = CRegEx::NewLC(_L8("(\\w+)*b"), optionsMatchLimit);

	CHECK(re2->PartialMatchL(good) == EFalse);   // because of match_limit