1 // spcreconsole.cpp

     2 //

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

     4 // All rights reserved.

     5 //

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

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

     8 // met:

     9 //

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

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

    12 //     * Redistributions in binary form must reproduce the above

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

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

    15 // distribution.

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

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

    18 // this software without specific prior written permission.

    19 //

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

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

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

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

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

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

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

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

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

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

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

    31 //

    32 // Author: Sanjay Ghemawat

    33 //

    34 // Heavily refactored for Symbian OS by Accenture.

    35 

    36 

    37 #include <e32base.h>

    38 #include <e32std.h>

    39 #include <e32math.h>

    40 #include <e32cons.h>			// Console

    41 #include <bacline.h>

    42 #include <cregex.h>

    43 #include <tregexarg.h>

    44 #include <tregexoptions.h>

    45 

    46 //  Constants

    47 _LIT(KTextConsoleTitle, "Console");

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

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

    50 //  Global Variables

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

    52 TBool verboseMode = EFalse;

    53 

    54 //  Local Functions

    55 

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

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

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

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

    60 #define CHECK(condition)								\

    61 	{													\

    62 	if (!(condition))									\

    63 		{                                   			\

    64 		_LIT(KCondition, #condition);					\

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

    66 						__LINE__, &KCondition());		\

    67 		User::Leave(KErrGeneral);						\

    68 		}												\

    69 	}

    70 

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

    72 

    73 static void Timing1L(TInt aNumIters)

    74 	{

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

    76 	

    77 	// Same pattern lots of times

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

    79 	_LIT8(KString,"ruby:1234");

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

    81 

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

    83 		{

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

    85 		}

    86 	CleanupStack::PopAndDestroy(pattern);

    87 	}

    88 

    89 static void Timing2L(TInt aNumIters)

    90 	{

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

    92 	// Same pattern lots of times

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

    94 	_LIT8(KString,"ruby:1234");

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

    96 

    97 	TInt i;

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

    99 		{

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

   101 		CHECK_EQ(i, 1234);

   102 		}

   103 	CleanupStack::PopAndDestroy(pattern);

   104 	}

   105 

   106 static void Timing3L(TInt aNumIters)

   107 	{

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

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

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

   111 	TPtr8 pText = text->Des();

   112 

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

   114 		{

   115 		pText.Append(KLine());

   116 		}

   117 

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

   119 

   120 	TInt counter = 0;

   121 	while (lineMatcher->ConsumeL(pText))

   122 		{

   123 		counter++;

   124 		}

   125 	CleanupStack::PopAndDestroy(2, text);

   126 	CHECK_EQ(counter, aNumIters);

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

   128 	}

   129 

   130 

   131 static void RadixTestsL()

   132 	{

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

   134 

   135 	#define CHECK_HEX(type, value) 										\

   136 		{																\

   137 		type v;															\

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

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

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

   141 		CleanupStack::PopAndDestroy(re);								\

   142 		re = NULL;														\

   143 		}

   144 

   145 	CHECK_HEX(TInt64,     2baddeadbeefLL);

   146 	CHECK_HEX(TUint8,     abU);

   147 	CHECK_HEX(TUint16,    2badU);

   148 	CHECK_HEX(TUint32,    deadbeefUL);

   149 	CHECK_HEX(TUint,      cafebabeU);

   150 	#undef CHECK_HEX

   151 

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

   153 

   154 	#define CHECK_OCTAL(type, value) 									\

   155 		{																\

   156 		type v;															\

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

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

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

   160 		CleanupStack::PopAndDestroy(re);								\

   161 		re = NULL;														\

   162 		}

   163 

   164 	CHECK_OCTAL(TInt64,		777777777777LL);

   165 	CHECK_OCTAL(TUint8,		177U);

   166 	CHECK_OCTAL(TUint16,	177777U);

   167 	CHECK_OCTAL(TUint32,	3777777777UL);

   168 	CHECK_OCTAL(TUint,		3777777777U);

   169 	#undef CHECK_OCTAL

   170 

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

   172 	

   173 	#define CHECK_DECIMAL(type, value) 									\

   174 		{																\

   175 		type v;															\

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

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

   178 		CHECK_EQ(v, value);												\

   179 		CleanupStack::PopAndDestroy(re);								\

   180 		re = NULL;														\

   181 		}	

   182 	

   183 	CHECK_DECIMAL(TInt8,	-1);

   184 	CHECK_DECIMAL(TUint8,	1U);

   185 	CHECK_DECIMAL(TInt16,	-9999);

   186 	CHECK_DECIMAL(TUint16,	9999U);

   187 	CHECK_DECIMAL(TInt32,	-123456L);

   188 	CHECK_DECIMAL(TUint32,	123456U);

   189 	CHECK_DECIMAL(TInt64,	1234567890123456789LL);

   190 	CHECK_DECIMAL(TInt,		-1234567890);

   191 	CHECK_DECIMAL(TUint,	1234567890U);

   192 	#undef CHECK_DECIMAL

   193 }

   194 

   195 static void TestReplaceL()

   196 	{

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

   198 

   199 	struct ReplaceTest

   200 		{

   201 		TBuf8<32>	iRegExp;

   202 		TBuf8<32>	iRewrite;

   203 		TBuf8<64>	iOriginal;

   204 		TBuf8<64>	iSingle;

   205 		TBuf8<64>	iGlobal;

   206 		TInt		iGlobalCount; // the expected return value from ReplaceAll

   207 		};

   208 	

   209 	static const ReplaceTest tests[] =

   210 	{

   211 		// Test 1

   212 		{

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

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

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

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

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

   218 		9

   219 		},

   220 		// Test 2

   221 		{

   222 		_L8("\\w+"),

   223 		_L8("\\0-NOSPAM"),

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

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

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

   227 		4

   228 		},

   229 		// Test 3

   230 		{_L8("^"),

   231 		_L8("(START)"),

   232 		_L8("foo"),

   233 		_L8("(START)foo"),

   234 		_L8("(START)foo"),

   235 		1

   236 		},

   237 		// Test 4

   238 		{

   239 		_L8("^"),

   240 		_L8("(START)"),

   241 		_L8(""),

   242 		_L8("(START)"),

   243 		_L8("(START)"),

   244 		1

   245 		},

   246 		// Test 5

   247 		{

   248 		_L8("$"),

   249 		_L8("(END)"),

   250 		_L8(""),

   251 		_L8("(END)"),

   252 		_L8("(END)"),

   253 		1

   254 		},

   255 		// Test 6

   256 		{

   257 		_L8("b"),

   258 		_L8("bb"),

   259 		_L8("ababababab"),

   260 		_L8("abbabababab"),

   261 		_L8("abbabbabbabbabb"),

   262 		5

   263 		},

   264 		// Test 7

   265 		{

   266 		_L8("b"),

   267 		_L8("bb"),

   268 		_L8("bbbbbb"),

   269 		_L8("bbbbbbb"),

   270 		_L8("bbbbbbbbbbbb"),

   271 		6

   272 		},

   273 		// Test 8

   274 		{_L8("b+"),

   275 		_L8("bb"),

   276 		_L8("bbbbbb"),

   277 		_L8("bb"),

   278 		_L8("bb"),

   279 		1

   280 		},

   281 		// Test 9

   282 		{

   283 		_L8("b*"),

   284 		_L8("bb"),

   285 		_L8("bbbbbb"),

   286 		_L8("bb"),

   287 		_L8("bb"),

   288 		1

   289 		},

   290 		// Test 10

   291 		{

   292 		_L8("b*"),

   293 		_L8("bb"),

   294 		_L8("aaaaa"),

   295 		_L8("bbaaaaa"),

   296 		_L8("bbabbabbabbabbabb"),

   297 		6

   298 		},

   299 		// Test 11

   300 		{

   301 		_L8("b*"),

   302 		_L8("bb"),

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

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

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

   306 		7

   307 		},

   308 		// Test 12

   309 		{

   310 		_L8("b*"),

   311 		_L8("bb"),

   312 		_L8("aa\raa\r"),

   313 		_L8("bbaa\raa\r"),

   314 		_L8("bbabbabb\rbbabbabb\rbb"),

   315 		7

   316 		},

   317 		// Test 13

   318 		{

   319 		_L8("b*"),

   320 		_L8("bb"),

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

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

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

   324 		7

   325 		},

   326 #ifdef SUPPORT_UTF8

   327 		// Test 14

   328 		{	

   329 		_L8("b*"),

   330 		_L8("bb"),

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

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

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

   334 		5

   335 		},

   336 		// Test 15

   337 		{

   338 		_L8("b*"),

   339 		_L8("bb"),

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

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

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

   343 		9

   344 		},

   345 #endif

   346 		{

   347 		KNullDesC8(),

   348 		KNullDesC8(),

   349 		KNullDesC8(),

   350 		KNullDesC8(),

   351 		KNullDesC8(),

   352 		-1

   353 		}

   354 	};

   355 

   356 #ifdef SUPPORT_UTF8

   357 	const TBool supportUtf8 = ETrue;

   358 #else

   359 	const TBool supportUtf8 = EFalse;

   360 #endif

   361   

   362 	CRegEx* re = NULL;

   363 	TRegExOptions options = TRegExOptions(EPcreNewlineCrLf);

   364 	options.SetUtf8(supportUtf8);	

   365 	TInt i =0;

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

   367 		{		

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

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

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

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

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

   373 		CHECK_EQ(one, t->iSingle);

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

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

   376 		CHECK_EQ(all, t->iGlobal);

   377 		CHECK_EQ(replaceCount, t->iGlobalCount);		

   378 		CleanupStack::PopAndDestroy(re);

   379 		re = NULL;

   380 		}

   381 

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

   383 	{

   384 	TRegExOptions options2 = TRegExOptions(EPcreNewlineCr);

   385 	options2.SetUtf8(supportUtf8);

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

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

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

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

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

   391 	CleanupStack::PopAndDestroy(re);

   392 	re = NULL;	

   393 	}

   394 	{

   395 	TRegExOptions options3 = TRegExOptions(EPcreNewlineLf);

   396 	options3.SetUtf8(supportUtf8);

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

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

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

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

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

   402 	CleanupStack::PopAndDestroy(re);

   403 	re = NULL;	

   404 	}

   405 

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

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

   408 }

   409 

   410 static void TestExtractL()

   411 	{

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

   413 

   414 	TBuf8<32> s;	

   415 	CRegEx* re = NULL;

   416 	

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

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

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

   420 	CleanupStack::PopAndDestroy(re);

   421 	re = NULL;

   422 

   423 	// check the RE interface as well

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

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

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

   427 	CleanupStack::PopAndDestroy(re);

   428 	re = NULL;

   429 	

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

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

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

   433 	CleanupStack::PopAndDestroy(re);

   434 	}

   435 

   436 static void TestConsumeL()

   437 	{

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

   439 

   440 	TBuf8<3> word;

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

   442 

   443 	// matches a word, possibly proceeded by whitespace

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

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

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

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

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

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

   450 	CleanupStack::PopAndDestroy(re);

   451 	}

   452 

   453 static void TestFindAndConsumeL()

   454 	{

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

   456 

   457 	TBuf8<4> word;

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

   459 

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

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

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

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

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

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

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

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

   468 	CleanupStack::PopAndDestroy(re);

   469 	}

   470 

   471 static void TestMatchNumberPeculiarityL()

   472 	{

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

   474 

   475 	TBuf8<3> word1;

   476 	TBuf8<3> word2;

   477 	TBuf8<3> word3;

   478 

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

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

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

   482 	CHECK_EQ(word2, KNullDesC8());

   483 	CHECK_EQ(word3, KNullDesC8());

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

   485 	CHECK_EQ(word1, KNullDesC8());

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

   487 	CHECK_EQ(word3, KNullDesC8());

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

   489 	CHECK_EQ(word1, KNullDesC8());

   490 	CHECK_EQ(word2, KNullDesC8());

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

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

   493 

   494 	CleanupStack::PopAndDestroy(re);

   495 	re = NULL;

   496 

   497 	TBuf8<12> a;

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

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

   500 	CHECK_EQ(a, KNullDesC8());

   501 	CleanupStack::PopAndDestroy(re);

   502 	}

   503 

   504 static void TestRecursionL()

   505 	{

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

   507 	

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

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

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

   511 

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

   513 	// requires match_limit of at least 8192, and match_recursion_limit

   514 	// of at least 37.

   515 

   516 	TRegExOptions optionsMatchLimit;

   517 	optionsMatchLimit.SetMatchLimit(8192);

   518 	

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

   520 	CHECK(re->PartialMatchL(good));

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

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

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

   524 	CleanupStack::PopAndDestroy(re);

   525 	re = NULL;

   526 

   527 	optionsMatchLimit.SetMatchLimit(1024);

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

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

   530 	CHECK(re2->PartialMatchL(bad) == EFalse);

   531 	CHECK(re2->FullMatchL(good) == EFalse);

   532 	CHECK(re2->FullMatchL(bad) == EFalse);

   533 	CleanupStack::PopAndDestroy(re2);

   534 	re2 = NULL;

   535 	

   536 	TRegExOptions optionsMathLimitRecursion;

   537 	optionsMathLimitRecursion.SetMatchLimitRecursion(50);

   538 	CRegEx* re3 = CRegEx::NewLC(_L8("(\\w+)*b"), optionsMathLimitRecursion);

   539 	CHECK(re3->PartialMatchL(good));

   540 	CHECK(re3->PartialMatchL(bad) == EFalse);

   541 	CHECK(re3->FullMatchL(good) == EFalse);

   542 	CHECK(re3->FullMatchL(bad) == EFalse);

   543 	CleanupStack::PopAndDestroy(re3);

   544 	re3 = NULL;

   545 	

   546 	optionsMathLimitRecursion.SetMatchLimitRecursion(10);

   547 	CRegEx* re4 = CRegEx::NewLC(_L8("(\\w+)*b"), optionsMathLimitRecursion);

   548 	CHECK(re4->PartialMatchL(good) == EFalse);

   549 	CHECK(re4->PartialMatchL(bad) == EFalse);

   550 	CHECK(re4->FullMatchL(good) == EFalse);

   551 	CHECK(re4->FullMatchL(bad) == EFalse);

   552 	CleanupStack::PopAndDestroy(re4);

   553 	re4 = NULL;	

   554 	}

   555 

   556 // A meta-quoted string, interpreted as a pattern, should always match

   557 // the original unquoted string.

   558 static void TestQuoteMetaL(const TDesC8& aUnquoted, TRegExOptions aOptions =

   559 		TRegExOptions())

   560 	{

   561 	HBufC8* quoted = CRegEx::QuoteMetaL(aUnquoted);

   562 	CleanupStack::PushL(quoted);

   563 

   564 	CRegEx* re = CRegEx::NewLC(*quoted, aOptions);

   565 	CHECK(re->FullMatchL(aUnquoted));

   566 	CleanupStack::PopAndDestroy(2, quoted); // re

   567 	}

   568 

   569 // A string containing meaningful regexp characters, which is then meta-

   570 // quoted, should not generally match a string the unquoted string does.

   571 static void NegativeTestQuoteMetaL(const TDesC8& aUnquoted,

   572 		const TDesC8& aNotMatch, TRegExOptions aOptions = TRegExOptions())

   573 	{

   574 	HBufC8* quoted = CRegEx::QuoteMetaL(aUnquoted);

   575 	CleanupStack::PushL(quoted);

   576 

   577 	CRegEx* re = CRegEx::NewLC(*quoted, aOptions);

   578 	CHECK(!re->FullMatchL(aNotMatch));

   579 	CleanupStack::PopAndDestroy(2, quoted); // re

   580 	}

   581 

   582 // Tests that quoted meta characters match their original strings,

   583 // and that a few things that shouldn't match indeed do not.

   584 static void TestQuotaMetaSimpleL()

   585 	{

   586 	TestQuoteMetaL(_L8("foo"));

   587 	TestQuoteMetaL(_L8("foo.bar"));

   588 	TestQuoteMetaL(_L8("foo\\.bar"));

   589 	TestQuoteMetaL(_L8("[1-9]"));

   590 	TestQuoteMetaL(_L8("1.5-2.0?"));

   591 	TestQuoteMetaL(_L8("\\d"));

   592 	TestQuoteMetaL(_L8("Who doesn't like ice cream?"));

   593 	TestQuoteMetaL(_L8("((a|b)c?d*e+[f-h]i)"));

   594 	TestQuoteMetaL(_L8("((?!)xxx).*yyy"));

   595 	TestQuoteMetaL(_L8("(["));

   596 	TestQuoteMetaL(_L8("foo\0bar"));

   597 	}

   598 

   599 static void TestQuoteMetaSimpleNegativeL()

   600 	{

   601 	NegativeTestQuoteMetaL(_L8("foo"), _L8("bar"));

   602 	NegativeTestQuoteMetaL(_L8("..."), _L8("bar"));

   603 	NegativeTestQuoteMetaL(_L8("\\."), _L8("."));

   604 	NegativeTestQuoteMetaL(_L8("\\."), _L8(".."));

   605 	NegativeTestQuoteMetaL(_L8("(a)"), _L8("a"));

   606 	NegativeTestQuoteMetaL(_L8("(a|b)"), _L8("a"));

   607 	NegativeTestQuoteMetaL(_L8("(a|b)"), _L8("(a)"));

   608 	NegativeTestQuoteMetaL(_L8("(a|b)"), _L8("a|b"));

   609 	NegativeTestQuoteMetaL(_L8("[0-9]"), _L8("0"));

   610 	NegativeTestQuoteMetaL(_L8("[0-9]"), _L8("0-9"));

   611 	NegativeTestQuoteMetaL(_L8("[0-9]"), _L8("[9]"));

   612 	NegativeTestQuoteMetaL(_L8("((?!)xxx)"), _L8("xxx"));

   613 	}

   614 

   615 static void TestQuoteMetaLatin1L()

   616 	{

   617 	TestQuoteMetaL(_L8("3\xb2 = 9"));

   618 	}

   619 

   620 

   621 static void TestQuoteMetaUtf8L()

   622 	{

   623 #ifdef SUPPORT_UTF8

   624 	TRegExOptions options;

   625 	options.SetUtf8(ETrue);

   626 	TestQuoteMetaL(_L8("Pl\xc3\xa1\x63ido Domingo"), options);

   627 	TestQuoteMetaL(_L8("xyz"), options);            // No fancy utf8

   628 	TestQuoteMetaL(_L8("\xc2\xb0"), options);       // 2-byte utf8 (degree symbol)

   629 	TestQuoteMetaL(_L8("27\xc2\xb0 degrees"), options);  // As a middle character

   630 	TestQuoteMetaL(_L8("\xe2\x80\xb3"), options);   // 3-byte utf8 (double prime)

   631 	TestQuoteMetaL(_L8("\xf0\x9d\x85\x9f"), options); // 4-byte utf8 (music note)

   632 	TestQuoteMetaL(_L8("27\xc2\xb0")); // Interpreted as Latin-1, but should still work

   633 	NegativeTestQuoteMetaL(_L8("27\xc2\xb0"),               // 2-byte utf (degree symbol)

   634 			_L8("27\\\xc2\\\xb0"),

   635 			options);

   636 #endif

   637 	}

   638 

   639 

   640 static void TestQuoteMetaAllL()

   641 	{

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

   643 

   644 	TestQuotaMetaSimpleL();

   645 	TestQuoteMetaSimpleNegativeL();

   646 	TestQuoteMetaLatin1L();

   647 	TestQuoteMetaUtf8L();

   648 	}

   649 

   650 //

   651 // Options tests contributed by

   652 // Giuseppe Maxia, CTO, Stardata s.r.l.

   653 // July 2005

   654 //

   655 static void GetOneOptionResultL(

   656                 const TDesC& aOptionName,

   657                 const TDesC8& aRegEx,

   658                 const TDesC8& aString,

   659                 TRegExOptions& aOptions,

   660                 TBool aFull,

   661                 const TDesC8& aExpected)

   662 	{

   663 	console->Printf(_L("Testing Option <%S>\n"), &aOptionName);

   664 	

   665 	if(verboseMode)

   666 		{

   667 		TBuf<32> str;

   668 		str.Copy(aString);

   669 		TBuf<32> rx;

   670 		rx.Copy(aRegEx);

   671 		TBuf<32> expected;

   672 		expected.Copy(aExpected);

   673 

   674 		console->Printf(_L("/%S/ finds \"%S\" within \"%S\" \n"), &rx, &expected, &str);

   675 		}

   676 	

   677   TBuf8<32> captured;

   678   CRegEx* re = CRegEx::NewLC(aRegEx, aOptions);

   679   

   680   if (aFull)

   681 	  {

   682 	  CHECK(re->FullMatchL(aString, &captured));

   683 	  }    

   684   else

   685 	  {

   686 	  CHECK(re->PartialMatchL(aString, &captured));

   687 	  }   

   688   CHECK_EQ(captured, aExpected);

   689   

   690   CleanupStack::PopAndDestroy(re);

   691 }

   692 

   693 static void TestOneOptionL(

   694                 const TDesC& aOptionName,

   695                 const TDesC8& aRegEx,

   696                 const TDesC8& aString,

   697                 const TRegExOptions& aOptions,

   698                 TBool aFull,

   699                 TBool aAssertive = ETrue)

   700 	{

   701 	

   702 	console->Printf(_L("Testing Option <%S>\n"), &aOptionName);

   703 	if(verboseMode)

   704 		{

   705 		_LIT(KMatches, "matches");

   706 		_LIT(KNoMatch, "doesn't match");

   707 		TBuf<32> str;

   708 		str.Copy(aString);

   709 		TBuf<64> rx;

   710 		rx.Copy(aRegEx);

   711 		

   712 		console->Printf(_L("'%S' %S /%S/ \n"),

   713 	                  &str,

   714 	                  (aAssertive? &KMatches() : &KNoMatch()),

   715 	                  &rx);	

   716 		}

   717 

   718 	CRegEx* re = NULL;

   719 	TRAPD(err, re = CRegEx::NewLC(aRegEx, aOptions); CleanupStack::Pop());

   720 	

   721 	if(err)

   722 		{

   723 		CHECK_EQ(aAssertive, EFalse);

   724 		return;

   725 		}

   726 	

   727 	CleanupStack::PushL(re);

   728 	

   729 	if (aAssertive)

   730 		{

   731 		if (aFull)

   732 			{

   733 			CHECK(re->FullMatchL(aString));

   734 			}     

   735 		else

   736 			{

   737 			CHECK(re->PartialMatchL(aString));

   738 			}

   739 		}

   740 	else

   741 		{

   742 		if (aFull)

   743 			{

   744 			CHECK(!re->FullMatchL(aString));

   745 			}		  

   746 		else

   747 			{

   748 			CHECK(!re->PartialMatchL(aString));

   749 			}

   750 		}

   751 	CleanupStack::PopAndDestroy(re);	

   752 	}

   753 

   754 static void TestCaseLessL()

   755 	{

   756 	TRegExOptions options;

   757 	TRegExOptions options2;

   758 	TRegExOptions caseless;

   759 	caseless.SetCaseless(ETrue);

   760 

   761 	options.SetCaseless(ETrue);

   762 	TestOneOptionL(_L("CASELESS (class)"), _L8("HELLO"), _L8("hello"), options, EFalse);

   763 	TestOneOptionL(_L("CASELESS (class2)"), _L8("HELLO"), _L8("hello"), options2.SetCaseless(ETrue), EFalse);

   764 	TestOneOptionL(_L("CASELESS (class)"), _L8("^[A-Z]+$"), _L8("Hello"), options, EFalse);

   765 

   766 	TestOneOptionL(_L("CASELESS (function)"), _L8("HELLO"), _L8("hello"), caseless, EFalse);

   767 	TestOneOptionL(_L("CASELESS (function)"), _L8("^[A-Z]+$"), _L8("Hello"), caseless, EFalse);

   768 	options.SetCaseless(EFalse);

   769 	TestOneOptionL(_L("no CASELESS"), _L8("HELLO"), _L8("hello"), options, EFalse, EFalse);

   770 	}

   771 

   772 static void TestMultilineL()

   773 	{

   774 	TRegExOptions options;

   775 	TRegExOptions options2;

   776 	TRegExOptions multiline;

   777 	multiline.SetMultiline(ETrue);

   778 

   779 	TBuf8<32> str(_L8("HELLO\n" "cruel\n" "world\n"));

   780 

   781 	options.SetMultiline(ETrue);

   782 	TestOneOptionL(_L("MULTILINE (class)"), _L8("^cruel$"), str, options, EFalse);

   783 	TestOneOptionL(_L("MULTILINE (class2)"), _L8("^cruel$"), str, options2.SetMultiline(ETrue), EFalse);

   784 	TestOneOptionL(_L("MULTILINE (function)"), _L8("^cruel$"), str, multiline, EFalse);

   785 	options.SetMultiline(EFalse);

   786 	TestOneOptionL(_L("no MULTILINE"), _L8("^cruel$"), str, options, EFalse, EFalse);

   787 	}

   788 

   789 static void TestDotAllL()

   790 	{

   791 	TRegExOptions options;

   792 	TRegExOptions options2;

   793 	TRegExOptions dotAll;

   794 	dotAll.SetDotAll(ETrue);

   795 

   796 	TBuf8<32> str(_L8("HELLO\n" "cruel\n" "world"));

   797 

   798 	options.SetDotAll(ETrue);

   799 	TestOneOptionL(_L("DOTALL (class)"), _L8("HELLO.*world"),str, options, ETrue);

   800 	TestOneOptionL(_L("DOTALL (class2)"), _L8("HELLO.*world"),str, options2.SetDotAll(ETrue), ETrue);

   801 	TestOneOptionL(_L("DOTALL (function)"), _L8("HELLO.*world"),str, dotAll, ETrue);

   802 	options.SetDotAll(EFalse);

   803 	TestOneOptionL(_L("no DOTALL"), _L8("HELLO.*world"),str, options, ETrue, EFalse);

   804 	}

   805 

   806 static void TestDollarEndOnlyL()

   807 	{

   808 	TRegExOptions options;

   809 	TRegExOptions options2;

   810 	TRegExOptions dollarEndOnly;

   811 	dollarEndOnly.SetDollarEndOnly(ETrue);

   812 

   813 	TBuf8<32> str(_L8("HELLO world\n"));

   814 

   815 	TestOneOptionL(_L("no DOLLAR_ENDONLY"), _L8("world$"), str, options, EFalse);

   816 	options.SetDollarEndOnly(ETrue);

   817 	TestOneOptionL(_L("DOLLAR_ENDONLY 1"), _L8("world$"), str, options, EFalse, EFalse);

   818 	TestOneOptionL(_L("DOLLAR_ENDONLY 2"), _L8("world$"), str, options2.SetDollarEndOnly(ETrue), EFalse, EFalse);

   819 	}

   820 

   821 

   822 static void TestExtraL()

   823 	{	

   824 	TRegExOptions options;

   825 

   826 	TBuf8<32> str(_L8("HELLO"));

   827 	options.SetExtra(ETrue);

   828 	TestOneOptionL(_L("EXTRA 1"), _L8("\\HELL\\O"), str, options, ETrue, EFalse );

   829 	TestOneOptionL(_L("EXTRA 2"), _L8("\\HELL\\O"), str, TRegExOptions().SetExtra(ETrue), ETrue, EFalse );

   830 	options.SetExtra(EFalse);

   831 	TestOneOptionL(_L("no EXTRA"), _L8("\\HELL\\O"), str, options, ETrue );

   832 	}

   833 

   834 static void TestExtendedL()

   835 	{

   836 	TRegExOptions options;

   837 	TRegExOptions options2;

   838 	TRegExOptions extended;

   839 	extended.SetExtended(ETrue);

   840 

   841 	TBuf8<32> str(_L8("HELLO world"));

   842 

   843 	options.SetExtended(ETrue);

   844 	TestOneOptionL(_L("EXTENDED (class)"), _L8("HELLO world"), str, options, EFalse, EFalse);

   845 	TestOneOptionL(_L("EXTENDED (class2)"), _L8("HELLO world"), str, options2.SetExtended(ETrue), EFalse, EFalse);

   846 	TestOneOptionL(_L("EXTENDED (class)"), _L8("^ HE L{2} O \\s+        \\w+ $      "), str, options, EFalse);

   847 

   848 	TestOneOptionL(_L("EXTENDED (function)"), _L8("HELLO world"), str, extended, EFalse, EFalse);

   849 	TestOneOptionL(_L("EXTENDED (function)"), _L8("^ HE L{2} O \\s+        \\w+ $      "), str, extended, EFalse);

   850 

   851 	options.SetExtended(EFalse);

   852 	TestOneOptionL(_L("no EXTENDED"), _L8("HELLO world"), str, options, EFalse);

   853 	}

   854 

   855 static void TestNoAutoCaptureL()

   856 	{

   857 	TRegExOptions options;

   858 	TBuf8<32> str(_L8("HELLO world"));

   859 	TBuf8<5> captured;

   860 	console->Write(_L("Testing Option <no NO_AUTO_CAPTURE>\n"));

   861 	if (verboseMode)

   862 		{

   863 		console->Write(_L("parentheses capture text\n"));

   864 		}

   865 

   866 	CRegEx* re = CRegEx::NewLC(_L8("(world|universe)$"), options);

   867 	CHECK(re->ExtractL(_L8("\\1"), str , captured));

   868 	CHECK_EQ(captured, _L8("world"));

   869 	options.SetNoAutoCapture(ETrue);

   870 	console->Write(_L("testing Option <NO_AUTO_CAPTURE>\n"));

   871 

   872 	if (verboseMode)

   873 		{

   874 		console->Write(_L("parentheses do not capture text\n"));

   875 		}

   876 

   877 	re->ExtractL(_L8("\\1"),str, captured);

   878 	CHECK_EQ(captured, _L8("world"));

   879 	

   880 	CleanupStack::PopAndDestroy(re);

   881 	}

   882 

   883 static void TestUngreedyL()

   884 	{

   885 	TRegExOptions options;

   886 	TRegExOptions ungreedy;

   887 	ungreedy.SetUngreedy(ETrue);

   888 

   889 	TBuf8<32> str(_L8("HELLO, 'this' is the 'world'"));

   890 

   891 	options.SetUngreedy(ETrue);

   892 	GetOneOptionResultL(_L("UNGREEDY 1"), _L8("('.*')"), str, options, EFalse, _L8("'this'") );

   893 	GetOneOptionResultL(_L("UNGREEDY 2"), _L8("('.*')"), str, ungreedy, EFalse, _L8("'this'") );

   894 	GetOneOptionResultL(_L("UNGREEDY"), _L8("('.*?')"), str, options, EFalse, _L8("'this' is the 'world'") );

   895 

   896 	options.SetUngreedy(EFalse);

   897 	GetOneOptionResultL(_L("no UNGREEDY"), _L8("('.*')"), str, options, EFalse, _L8("'this' is the 'world'") );

   898 	GetOneOptionResultL(_L("no UNGREEDY"), _L8("('.*?')"), str, options, EFalse, _L8("'this'") );

   899 	}

   900 

   901 static void TestAllOptionsL()

   902 	{

   903 	TBuf8<32> str(_L8("HELLO\n" "cruel\n" "world"));

   904 	TRegExOptions options;

   905 	options.SetAllOptions(EPcreCaseless | EPcreDotAll);

   906 

   907 	TestOneOptionL(_L("all_options (CASELESS|DOTALL)"), _L8("^hello.*WORLD"), str , options, EFalse);

   908 	options.SetAllOptions(0);

   909 	TestOneOptionL(_L("all_options (0)"), _L8("^hello.*WORLD"), str , options, EFalse, EFalse);

   910 	options.SetAllOptions(EPcreMultiline | EPcreExtended);

   911 

   912 	TestOneOptionL(_L("all_options (MULTILINE|EXTENDED)"), _L8(" ^ c r u e l $ "), str, options, EFalse);

   913 	TestOneOptionL(_L("all_options (MULTILINE|EXTENDED) with constructor"),

   914 	_L8(" ^ c r u e l $ "),

   915 	str,

   916 	TRegExOptions(EPcreMultiline | EPcreExtended),

   917 	EFalse);

   918 

   919 	TRegExOptions multilineExtended = TRegExOptions().SetMultiline(ETrue);

   920 	multilineExtended.SetExtended(ETrue);

   921 

   922 	TestOneOptionL(_L("all_options (MULTILINE|EXTENDED) with concatenation"),

   923 	_L8(" ^ c r u e l $ "),

   924 	str,

   925 	multilineExtended, EFalse);

   926 

   927 	options.SetAllOptions(0);

   928 	TestOneOptionL(_L("all_options (0)"), _L8("^ c r u e l $"), str, options, EFalse, EFalse);

   929 	}

   930 

   931 static void TestOptionsL()

   932 	{

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

   934 	TestCaseLessL();

   935 	TestMultilineL();

   936 	TestDotAllL();

   937 	TestDollarEndOnlyL();

   938 	TestExtendedL();

   939 	TestNoAutoCaptureL();

   940 	TestUngreedyL();

   941 	TestExtraL();

   942 	TestAllOptionsL();

   943 	}

   944 

   945 

   946 LOCAL_C void MainL()

   947 	{

   948 	

   949 	_LIT(KTimingArg1, "timing1");

   950 	_LIT(KTimingArg2, "timing2");

   951 	_LIT(KTimingArg3, "timing3");

   952 	

   953 	CCommandLineArguments* args = CCommandLineArguments::NewLC();

   954 

   955 	// Treat any flag as --help

   956 	if(args->Count() > 1 && args->Arg(1)[0] == '-')

   957 		{

   958 		console->Printf(_L("Usage: %S [%S|%S|%S num-iters]\n"), &(args->Arg(0)), &KTimingArg1(), &KTimingArg2(), &KTimingArg3());

   959 		console->Write(_L("If 'timingX ###' is specified, run the given timing test\n"));

   960 		console->Write(_L("with the given number of iterations, rather than running\n"));

   961 		console->Write(_L("the default corectness test.\n"));

   962 		CleanupStack::PopAndDestroy(args);

   963 		return;		

   964 		}

   965 	if(args->Count() > 1)

   966 		{

   967 		if(args->Count() == 2)

   968 			{

   969 			console->Write(_L("timing mode needs a num-iters argument\n"));

   970 			CleanupStack::PopAndDestroy(args);

   971 			return;			

   972 			}

   973 		

   974 		TLex lex(args->Arg(2));

   975 		TInt iters;

   976 		TInt err = lex.Val(iters);

   977 		

   978 		if(err || iters == 0)

   979 			{

   980 			CleanupStack::PopAndDestroy(args);

   981 			return;	

   982 			}

   983 		

   984 		if(args->Arg(1) == KTimingArg1)

   985 			{

   986 			Timing1L(iters);

   987 			}

   988 		else if(args->Arg(1) == KTimingArg2)

   989 			{

   990 			Timing2L(iters);

   991 			}

   992 		else if(args->Arg(1) == KTimingArg3)

   993 			{

   994 			Timing3L(iters);

   995 			}		

   996 		else

   997 			{

   998 			console->Printf(_L("Unknown argument '%S'\n"), &(args->Arg(1)));

   999 			}

  1000 		CleanupStack::PopAndDestroy(args);

  1001 		return;			

  1002 		}

  1003 	CleanupStack::PopAndDestroy(args);

  1004 	

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

  1006 

  1007 	CRegEx* re = NULL;

  1008 	TInt i;

  1009 	TBuf8<10> s;

  1010 	

  1011 	/***** FullMatch with no args *****/

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

  1013 	CHECK(re->FullMatchL(_L8("hello")));

  1014 	CleanupStack::PopAndDestroy(re);

  1015 	re = NULL;

  1016 

  1017 	re = CRegEx::NewLC(_L8("h.*o")); // Must be anchored at front

  1018 	CHECK(!re->FullMatchL(_L8("othello")));

  1019 	CleanupStack::PopAndDestroy(re);

  1020 	re = NULL;

  1021 

  1022 	re = CRegEx::NewLC(_L8("h.*o")); // Must be anchored at end

  1023 	CHECK(!re->FullMatchL(_L8("hello!")));

  1024 	CleanupStack::PopAndDestroy(re);

  1025 	re = NULL;

  1026 

  1027 	re = CRegEx::NewLC(_L8("a*")); // Fullmatch with normal op

  1028 	CHECK(re->FullMatchL(_L8("aaaa")));

  1029 	CleanupStack::PopAndDestroy(re);

  1030 	re = NULL;

  1031 

  1032 	re = CRegEx::NewLC(_L8("a*?")); // Fullmatch with nongreedy op

  1033 	CHECK(re->FullMatchL(_L8("aaaa")));

  1034 	CleanupStack::PopAndDestroy(re);

  1035 	re = NULL;

  1036 

  1037 	re = CRegEx::NewLC(_L8("a*?\\z")); // Two unusual ops

  1038 	CHECK(re->FullMatchL(_L8("aaaa")));

  1039 	CleanupStack::PopAndDestroy(re);

  1040 	re = NULL;

  1041 

  1042 	/***** FullMatch with args *****/

  1043 

  1044 	// Zero-arg

  1045 	re = CRegEx::NewLC(_L8("\\d+"));

  1046 	CHECK(re->FullMatchL(_L8("1001")));

  1047 	CleanupStack::PopAndDestroy(re);

  1048 	re = NULL;	

  1049 

  1050 	// Single-arg

  1051 	re = CRegEx::NewLC(_L8("(\\d+)"));

  1052 	CHECK(re->FullMatchL(_L8("1001"), &i));

  1053 	CHECK_EQ(i, 1001);

  1054 	CleanupStack::PopAndDestroy(re);

  1055 	re = NULL;	

  1056 	

  1057 	re = CRegEx::NewLC(_L8("(-?\\d+)"));

  1058 	CHECK(re->FullMatchL(_L8("-123"), &i));

  1059 	CHECK_EQ(i, -123);

  1060 	CleanupStack::PopAndDestroy(re);

  1061 	re = NULL;

  1062 	

  1063 	re = CRegEx::NewLC(_L8("()\\d+"));

  1064 	CHECK(!re->FullMatchL(_L8("10"), &i));

  1065 	CleanupStack::PopAndDestroy(re);

  1066 	re = NULL;

  1067 	

  1068 	re = CRegEx::NewLC(_L8("(\\d+)"));

  1069 	CHECK(!re->FullMatchL(_L8("1234567890123456789012345678901234567890"), &i));

  1070 	CleanupStack::PopAndDestroy(re);

  1071 	re = NULL;	

  1072 

  1073 	// Digits surrounding integer-arg

  1074 	re = CRegEx::NewLC(_L8("1(\\d*)4"));

  1075 	CHECK(re->FullMatchL(_L8("1234"), &i));

  1076 	CHECK_EQ(i, 23);

  1077 	CleanupStack::PopAndDestroy(re);

  1078 	re = NULL;

  1079 	

  1080 	re = CRegEx::NewLC(_L8("(\\d)\\d+"));

  1081 	CHECK(re->FullMatchL(_L8("1234"), &i));

  1082 	CHECK_EQ(i, 1);

  1083 	CleanupStack::PopAndDestroy(re);

  1084 	re = NULL;

  1085 	

  1086 	re = CRegEx::NewLC(_L8("(-\\d)\\d+"));

  1087 	CHECK(re->FullMatchL(_L8("-1234"), &i));

  1088 	CHECK_EQ(i, -1);

  1089 	CleanupStack::PopAndDestroy(re);

  1090 	re = NULL;

  1091 	

  1092 	re = CRegEx::NewLC(_L8("(\\d)"));

  1093 	CHECK(re->PartialMatchL(_L8("1234"), &i));

  1094 	CHECK_EQ(i, 1);

  1095 	CleanupStack::PopAndDestroy(re);

  1096 	re = NULL;

  1097 

  1098 	re = CRegEx::NewLC(_L8("(-\\d)"));

  1099 	CHECK(re->PartialMatchL(_L8("-1234"), &i));

  1100 	CHECK_EQ(i, -1);

  1101 	CleanupStack::PopAndDestroy(re);

  1102 	re = NULL;

  1103 

  1104 	// String-arg

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

  1106 	CHECK(re->PartialMatchL(_L8("hello"), &s));

  1107 	CHECK_EQ(s, _L8("ell"));

  1108 	CleanupStack::PopAndDestroy(re);

  1109 	re = NULL;	

  1110 

  1111 	// Multi-arg

  1112 	re = CRegEx::NewLC(_L8("(\\w+):(\\d+)"));

  1113 	CHECK(re->PartialMatchL(_L8("ruby:1234"), &s, &i));

  1114 	CHECK_EQ(s.Length(), 4);

  1115 	CHECK_EQ(s, _L8("ruby"));

  1116 	CHECK_EQ(i, 1234);

  1117 	CleanupStack::PopAndDestroy(re);

  1118 	re = NULL;		

  1119 

  1120 	// Ignore non-void* NULL arg

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

  1122 	CHECK(re->FullMatchL(_L8("hello"), (TDes8*)NULL));

  1123 	CleanupStack::PopAndDestroy(re);

  1124 	re = NULL;		

  1125 	

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

  1127 	CHECK(re->FullMatchL(_L8("123"), (TInt8*)NULL));

  1128 	CleanupStack::PopAndDestroy(re);

  1129 	re = NULL;			

  1130 

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

  1132 	CHECK(re->FullMatchL(_L8("12345"), (TInt16*)NULL));

  1133 	CleanupStack::PopAndDestroy(re);

  1134 	re = NULL;			

  1135