1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/ossrv/compressionlibs/ziplib/test/rtest/ezexample/ezexample.cpp Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,553 @@
1.4 +/* Portions Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).
1.5 + * All rights reserved.
1.6 + */
1.7 +
1.8 +/* ezexample.c -- usage example of the zlib compression library
1.9 + * Copyright (C) 1995-1998 Jean-loup Gailly.
1.10 + * For conditions of distribution and use, see copyright notice in zlib.h
1.11 + */
1.12 +
1.13 +/* @(#) $Id$ */
1.14 +
1.15 +#include <stdio.h>
1.16 +#include <ezlib.h>
1.17 +#include <e32test.h>
1.18 +
1.19 +static RTest test(_L("ezexample.exe"));
1.20 +
1.21 +_LIT(KTestTitle, "Open Source Library Defect Tests.");
1.22 +
1.23 +#ifdef STDC
1.24 +# include <string.h>
1.25 +# include <stdlib.h>
1.26 +#else
1.27 + extern void exit OF((int));
1.28 +#endif
1.29 +
1.30 +#if defined(VMS) || defined(RISCOS)
1.31 +# define TESTFILE "foo-gz"
1.32 +#else
1.33 +# define TESTFILE "foo.gz"
1.34 +#endif
1.35 +
1.36 +/* Test macro and function */
1.37 +void Check(TInt aValue, TInt aExpected, TInt aLine)
1.38 + {
1.39 + if (aValue != aExpected)
1.40 + {
1.41 + test.Printf(_L("*** Expected error: %d, got: %d\r\n"), aExpected, aValue);
1.42 + test.operator()(EFalse, aLine);
1.43 + }
1.44 + }
1.45 +#define test2(a, b) Check(a, b, __LINE__)
1.46 +
1.47 +const char hello[] = "hello, hello!";
1.48 +/* "hello world" would be more standard, but the repeated "hello"
1.49 + * stresses the compression code better, sorry...
1.50 + */
1.51 +
1.52 +const char dictionary[] = "hello";
1.53 +uLong dictId; /* Adler32 value of the dictionary */
1.54 +
1.55 +void test_compress OF((Byte *compr, uLong comprLen,
1.56 + Byte *uncompr, uLong uncomprLen));
1.57 +void test_deflate OF((Byte *compr, uLong comprLen));
1.58 +void test_inflate OF((Byte *compr, uLong comprLen,
1.59 + Byte *uncompr, uLong uncomprLen));
1.60 +void test_large_deflate OF((Byte *compr, uLong comprLen,
1.61 + Byte *uncompr, uLong uncomprLen));
1.62 +void test_large_inflate OF((Byte *compr, uLong comprLen,
1.63 + Byte *uncompr, uLong uncomprLen));
1.64 +void test_flush OF((Byte *compr, uLong *comprLen));
1.65 +void test_sync OF((Byte *compr, uLong comprLen,
1.66 + Byte *uncompr, uLong uncomprLen));
1.67 +void test_dict_deflate OF((Byte *compr, uLong comprLen));
1.68 +void test_dict_inflate OF((Byte *compr, uLong comprLen,
1.69 + Byte *uncompr, uLong uncomprLen));
1.70 +void PrintString(TRefByValue<const TDesC> aFmt, char* string);
1.71 +void RunTest();
1.72 +
1.73 +/**
1.74 +Test compress() and uncompress()
1.75 +
1.76 +@SYMTestCaseID SYSLIB-EZLIB-CT-0820-0001
1.77 +@SYMTestCaseDesc Compression and decompression of a buffer test.
1.78 +@SYMTestPriority High
1.79 +@SYMTestActions Compress and uncompress string "hello" and check for integrity of the operation done.
1.80 +@SYMTestExpectedResults The test must not fail.
1.81 +@SYMREQ REQ0000
1.82 +*/
1.83 +void test_compress(
1.84 + Byte *compr, uLong comprLen, Byte *uncompr,
1.85 + uLong uncomprLen)
1.86 +{
1.87 + test.Next(_L("test_compress"));
1.88 + test.Next(_L(" @SYMTestCaseID:SYSLIB-EZLIB-CT-0820-0001 "));
1.89 + int err;
1.90 + uLong len = strlen(hello)+1;
1.91 +
1.92 + err = compress(compr, &comprLen, (const Bytef*)hello, len);
1.93 + test2(err, Z_OK);
1.94 +
1.95 + strcpy((char*)uncompr, "garbage");
1.96 +
1.97 + err = uncompress(uncompr, &uncomprLen, compr, comprLen);
1.98 + test2(err, Z_OK);
1.99 +
1.100 + test2(strcmp((char*)uncompr, hello), 0); /* Fails if bad uncompress */
1.101 +
1.102 + PrintString(_L("uncompress(): %S\n"), (char*)uncompr);
1.103 +}
1.104 +
1.105 +/**
1.106 +@SYMTestCaseID SYSLIB-EZLIB-CT-0821-0001
1.107 +@SYMTestCaseDesc Read and write of .gz files test
1.108 +@SYMTestPriority High
1.109 +@SYMTestActions Tests deflate() with small buffers
1.110 +@SYMTestExpectedResults The test must not fail.
1.111 +@SYMREQ REQ0000
1.112 +*/
1.113 +void test_deflate(
1.114 + Byte *compr,
1.115 + uLong comprLen)
1.116 +{
1.117 + test.Next(_L("test_deflate"));
1.118 + test.Next(_L(" @SYMTestCaseID:SYSLIB-EZLIB-CT-0821-0001 "));
1.119 + z_stream c_stream; /* compression stream */
1.120 + int err;
1.121 + int len = strlen(hello)+1;
1.122 +
1.123 + c_stream.zalloc = (alloc_func)0;
1.124 + c_stream.zfree = (free_func)0;
1.125 + c_stream.opaque = (voidpf)0;
1.126 +
1.127 + err = deflateInit(&c_stream, Z_DEFAULT_COMPRESSION);
1.128 + test2(err, Z_OK);
1.129 +
1.130 + c_stream.next_in = (Bytef*)hello;
1.131 + c_stream.next_out = compr;
1.132 +
1.133 + while (c_stream.total_in != (uLong)len && c_stream.total_out < comprLen) {
1.134 + c_stream.avail_in = c_stream.avail_out = 1; /* force small buffers */
1.135 + err = deflate(&c_stream, Z_NO_FLUSH);
1.136 + test2(err, Z_OK);
1.137 + }
1.138 + /* Finish the stream, still forcing small buffers: */
1.139 + for (;;) {
1.140 + c_stream.avail_out = 1;
1.141 + err = deflate(&c_stream, Z_FINISH);
1.142 + if (err == Z_STREAM_END) break;
1.143 + test2(err, Z_OK);
1.144 + }
1.145 +
1.146 + err = deflateEnd(&c_stream);
1.147 + test2(err, Z_OK);
1.148 +}
1.149 +
1.150 +/**
1.151 +@SYMTestCaseID SYSLIB-EZLIB-CT-0822-0001
1.152 +@SYMTestCaseDesc Read and write of .gz files test
1.153 +@SYMTestPriority High
1.154 +@SYMTestActions Tests inflate() with small buffers
1.155 +@SYMTestExpectedResults The test must not fail.
1.156 +@SYMREQ REQ0000
1.157 +*/
1.158 +void test_inflate(
1.159 + Byte *compr, uLong comprLen, Byte *uncompr,
1.160 + uLong uncomprLen)
1.161 +{
1.162 + test.Next(_L("test_inflate"));
1.163 + test.Next(_L(" @SYMTestCaseID:SYSLIB-EZLIB-CT-0822-0001 "));
1.164 + int err;
1.165 + z_stream d_stream; /* decompression stream */
1.166 +
1.167 + strcpy((char*)uncompr, "garbage");
1.168 +
1.169 + d_stream.zalloc = (alloc_func)0;
1.170 + d_stream.zfree = (free_func)0;
1.171 + d_stream.opaque = (voidpf)0;
1.172 +
1.173 + d_stream.next_in = compr;
1.174 + d_stream.avail_in = 0;
1.175 + d_stream.next_out = uncompr;
1.176 +
1.177 + err = inflateInit(&d_stream);
1.178 + test2(err, Z_OK);
1.179 +
1.180 + while (d_stream.total_out < uncomprLen && d_stream.total_in < comprLen) {
1.181 + d_stream.avail_in = d_stream.avail_out = 1; /* force small buffers */
1.182 + err = inflate(&d_stream, Z_NO_FLUSH);
1.183 + if (err == Z_STREAM_END) break;
1.184 + test2(err, Z_OK);
1.185 + }
1.186 +
1.187 + err = inflateEnd(&d_stream);
1.188 + test2(err, Z_OK);
1.189 +
1.190 + test2(strcmp((char*)uncompr, hello), 0); /* Fails if bad inflate */
1.191 +
1.192 + PrintString(_L("inflate(): %S\n"), (char*)uncompr);
1.193 +}
1.194 +
1.195 +/**
1.196 +@SYMTestCaseID SYSLIB-EZLIB-CT-0823-0001
1.197 +@SYMTestCaseDesc Deflate with large buffers test
1.198 +@SYMTestPriority High
1.199 +@SYMTestActions Test deflate() with large buffers and dynamic change of compression level
1.200 +@SYMTestExpectedResults The test must not fail.
1.201 +@SYMREQ REQ0000
1.202 +*/
1.203 +void test_large_deflate(
1.204 + Byte *compr, uLong comprLen, Byte *uncompr,
1.205 + uLong uncomprLen)
1.206 +{
1.207 + test.Next(_L("test_large_deflate"));
1.208 + test.Next(_L(" @SYMTestCaseID:SYSLIB-EZLIB-CT-0823-0001 "));
1.209 + z_stream c_stream; /* compression stream */
1.210 + int err;
1.211 +
1.212 + c_stream.zalloc = (alloc_func)0;
1.213 + c_stream.zfree = (free_func)0;
1.214 + c_stream.opaque = (voidpf)0;
1.215 +
1.216 + err = deflateInit(&c_stream, Z_BEST_SPEED);
1.217 + test2(err, Z_OK);
1.218 +
1.219 + c_stream.next_out = compr;
1.220 + c_stream.avail_out = (uInt)comprLen;
1.221 +
1.222 + /* At this point, uncompr is still mostly zeroes, so it should compress
1.223 + * very well:
1.224 + */
1.225 + c_stream.next_in = uncompr;
1.226 + c_stream.avail_in = (uInt)uncomprLen;
1.227 + err = deflate(&c_stream, Z_NO_FLUSH);
1.228 + test2(err, Z_OK);
1.229 +
1.230 + test2(c_stream.avail_in, 0); /* Fails if deflate not greedy */
1.231 +
1.232 + /* Feed in already compressed data and switch to no compression: */
1.233 + deflateParams(&c_stream, Z_NO_COMPRESSION, Z_DEFAULT_STRATEGY);
1.234 + c_stream.next_in = compr;
1.235 + c_stream.avail_in = (uInt)comprLen/2;
1.236 + err = deflate(&c_stream, Z_NO_FLUSH);
1.237 + test2(err, Z_OK);
1.238 +
1.239 + /* Switch back to compressing mode: */
1.240 + deflateParams(&c_stream, Z_BEST_COMPRESSION, Z_FILTERED);
1.241 + c_stream.next_in = uncompr;
1.242 + c_stream.avail_in = (uInt)uncomprLen;
1.243 + err = deflate(&c_stream, Z_NO_FLUSH);
1.244 + test2(err, Z_OK);
1.245 +
1.246 + err = deflate(&c_stream, Z_FINISH);
1.247 + test2(err, Z_STREAM_END);
1.248 +
1.249 + err = deflateEnd(&c_stream);
1.250 + test2(err, Z_OK);
1.251 +}
1.252 +
1.253 +/**
1.254 +@SYMTestCaseID SYSLIB-EZLIB-CT-0824-0001
1.255 +@SYMTestCaseDesc Inflate with large buffers test
1.256 +@SYMTestPriority High
1.257 +@SYMTestActions Tests inflate() with large buffers
1.258 +@SYMTestExpectedResults The test must not fail.
1.259 +@SYMREQ REQ0000
1.260 +*/
1.261 +
1.262 +void test_large_inflate(
1.263 + Byte *compr, uLong comprLen, Byte *uncompr,
1.264 + uLong uncomprLen)
1.265 +{
1.266 + test.Next(_L(" @SYMTestCaseID:SYSLIB-EZLIB-CT-0824-0001 test_large_inflate "));
1.267 + int err;
1.268 + z_stream d_stream; /* decompression stream */
1.269 +
1.270 + strcpy((char*)uncompr, "garbage");
1.271 +
1.272 + d_stream.zalloc = (alloc_func)0;
1.273 + d_stream.zfree = (free_func)0;
1.274 + d_stream.opaque = (voidpf)0;
1.275 +
1.276 + d_stream.next_in = compr;
1.277 + d_stream.avail_in = (uInt)comprLen;
1.278 +
1.279 + err = inflateInit(&d_stream);
1.280 + test2(err, Z_OK);
1.281 +
1.282 + for (;;) {
1.283 + d_stream.next_out = uncompr; /* discard the output */
1.284 + d_stream.avail_out = (uInt)uncomprLen;
1.285 + err = inflate(&d_stream, Z_NO_FLUSH);
1.286 + if (err == Z_STREAM_END) break;
1.287 + test2(err, Z_OK);
1.288 + }
1.289 +
1.290 + err = inflateEnd(&d_stream);
1.291 + test2(err, Z_OK);
1.292 +
1.293 + test2(d_stream.total_out, (2*uncomprLen + comprLen/2)); /* Fails if bad large inflate */
1.294 +
1.295 + test.Printf(_L("large_inflate(): OK\n"));
1.296 +}
1.297 +
1.298 +/**
1.299 +@SYMTestCaseID SYSLIB-EZLIB-CT-0825-0001
1.300 +@SYMTestCaseDesc Test deflate() with full flush
1.301 +@SYMTestPriority High
1.302 +@SYMTestActions Test by flushing the output as random access is desired
1.303 +@SYMTestExpectedResults The test must not fail.
1.304 +@SYMREQ REQ0000
1.305 +*/
1.306 +void test_flush(
1.307 + Byte *compr,
1.308 + uLong *comprLen)
1.309 +{
1.310 + test.Next(_L("test_flush"));
1.311 + test.Next(_L(" @SYMTestCaseID:SYSLIB-EZLIB-CT-0825-0001 "));
1.312 + z_stream c_stream; /* compression stream */
1.313 + int err;
1.314 + int len = strlen(hello)+1;
1.315 +
1.316 + c_stream.zalloc = (alloc_func)0;
1.317 + c_stream.zfree = (free_func)0;
1.318 + c_stream.opaque = (voidpf)0;
1.319 +
1.320 + err = deflateInit(&c_stream, Z_DEFAULT_COMPRESSION);
1.321 + test2(err, Z_OK);
1.322 +
1.323 + c_stream.next_in = (Bytef*)hello;
1.324 + c_stream.next_out = compr;
1.325 + c_stream.avail_in = 3;
1.326 + c_stream.avail_out = (uInt)*comprLen;
1.327 + err = deflate(&c_stream, Z_FULL_FLUSH);
1.328 + test2(err, Z_OK);
1.329 +
1.330 + compr[3]++; /* force an error in first compressed block */
1.331 + c_stream.avail_in = len - 3;
1.332 +
1.333 + err = deflate(&c_stream, Z_FINISH);
1.334 + if (err != Z_STREAM_END) {
1.335 + test2(err, Z_OK);
1.336 + }
1.337 + err = deflateEnd(&c_stream);
1.338 + test2(err, Z_OK);
1.339 +
1.340 + *comprLen = c_stream.total_out;
1.341 +}
1.342 +
1.343 +/**
1.344 +@SYMTestCaseID SYSLIB-EZLIB-CT-0826-0001
1.345 +@SYMTestCaseDesc Test the inflateSync() function
1.346 +@SYMTestPriority High
1.347 +@SYMTestActions Tests for reading of compressed data with damaged parts and check for errors.
1.348 +@SYMTestExpectedResults The test must not fail.
1.349 +@SYMREQ REQ0000
1.350 +*/
1.351 +void test_sync(
1.352 + Byte *compr, uLong comprLen, Byte *uncompr,
1.353 + uLong uncomprLen)
1.354 +{
1.355 + test.Next(_L("test_sync"));
1.356 + test.Next(_L(" @SYMTestCaseID:SYSLIB-EZLIB-CT-0826-0001 "));
1.357 + int err;
1.358 + z_stream d_stream; /* decompression stream */
1.359 +
1.360 + strcpy((char*)uncompr, "garbage");
1.361 +
1.362 + d_stream.zalloc = (alloc_func)0;
1.363 + d_stream.zfree = (free_func)0;
1.364 + d_stream.opaque = (voidpf)0;
1.365 +
1.366 + d_stream.next_in = compr;
1.367 + d_stream.avail_in = 2; /* just read the zlib header */
1.368 +
1.369 + err = inflateInit(&d_stream);
1.370 + test2(err, Z_OK);
1.371 +
1.372 + d_stream.next_out = uncompr;
1.373 + d_stream.avail_out = (uInt)uncomprLen;
1.374 +
1.375 + inflate(&d_stream, Z_NO_FLUSH);
1.376 + test2(err, Z_OK);
1.377 +
1.378 + d_stream.avail_in = (uInt)comprLen-2; /* read all compressed data */
1.379 + err = inflateSync(&d_stream); /* but skip the damaged part */
1.380 + test2(err, Z_OK);
1.381 +
1.382 + err = inflate(&d_stream, Z_FINISH);
1.383 + test2(err, Z_DATA_ERROR); /* inflate should report DATA_ERROR because of incorrect adler32 */
1.384 +
1.385 + err = inflateEnd(&d_stream);
1.386 + test2(err, Z_OK);
1.387 +
1.388 + PrintString(_L("after inflateSync(): hel%S\n"), (char*)uncompr);
1.389 +}
1.390 +
1.391 +/**
1.392 +@SYMTestCaseID SYSLIB-EZLIB-CT-0827-0001
1.393 +@SYMTestCaseDesc Deflation functionality test
1.394 +@SYMTestPriority High
1.395 +@SYMTestActions Test deflate() function with preset dictionary
1.396 +@SYMTestExpectedResults The test must not fail.
1.397 +@SYMREQ REQ0000
1.398 +*/
1.399 +void test_dict_deflate(
1.400 + Byte *compr,
1.401 + uLong comprLen)
1.402 +{
1.403 + test.Next(_L("test_dict_deflate"));
1.404 + test.Next(_L(" @SYMTestCaseID:SYSLIB-EZLIB-CT-0827-0001 "));
1.405 + z_stream c_stream; /* compression stream */
1.406 + int err;
1.407 +
1.408 + c_stream.zalloc = (alloc_func)0;
1.409 + c_stream.zfree = (free_func)0;
1.410 + c_stream.opaque = (voidpf)0;
1.411 +
1.412 + err = deflateInit(&c_stream, Z_BEST_COMPRESSION);
1.413 + test2(err, Z_OK);
1.414 +
1.415 + err = deflateSetDictionary(&c_stream,
1.416 + (const Bytef*)dictionary, sizeof(dictionary));
1.417 + test2(err, Z_OK);
1.418 +
1.419 + dictId = c_stream.adler;
1.420 + c_stream.next_out = compr;
1.421 + c_stream.avail_out = (uInt)comprLen;
1.422 +
1.423 + c_stream.next_in = (Bytef*)hello;
1.424 + c_stream.avail_in = (uInt)strlen(hello)+1;
1.425 +
1.426 + err = deflate(&c_stream, Z_FINISH);
1.427 + test2(err, Z_STREAM_END);
1.428 +
1.429 + err = deflateEnd(&c_stream);
1.430 + test2(err, Z_OK);
1.431 +}
1.432 +
1.433 +/**
1.434 +@SYMTestCaseID SYSLIB-EZLIB-CT-0828-0001
1.435 +@SYMTestCaseDesc Inflation functionality test
1.436 +@SYMTestPriority High
1.437 +@SYMTestActions Test inflate() with a preset dictionary
1.438 +@SYMTestExpectedResults The test must not fail.
1.439 +@SYMREQ REQ0000
1.440 +*/
1.441 +void test_dict_inflate(
1.442 + Byte *compr, uLong comprLen, Byte *uncompr,
1.443 + uLong uncomprLen)
1.444 +{
1.445 + test.Next(_L("test_dict_inflate"));
1.446 + test.Next(_L(" @SYMTestCaseID:SYSLIB-EZLIB-CT-0828-0001 "));
1.447 + int err;
1.448 + z_stream d_stream; /* decompression stream */
1.449 +
1.450 + strcpy((char*)uncompr, "garbage");
1.451 +
1.452 + d_stream.zalloc = (alloc_func)0;
1.453 + d_stream.zfree = (free_func)0;
1.454 + d_stream.opaque = (voidpf)0;
1.455 +
1.456 + d_stream.next_in = compr;
1.457 + d_stream.avail_in = (uInt)comprLen;
1.458 +
1.459 + err = inflateInit(&d_stream);
1.460 + test2(err, Z_OK);
1.461 +
1.462 + d_stream.next_out = uncompr;
1.463 + d_stream.avail_out = (uInt)uncomprLen;
1.464 +
1.465 + for (;;) {
1.466 + err = inflate(&d_stream, Z_NO_FLUSH);
1.467 + if (err == Z_STREAM_END) break;
1.468 + if (err == Z_NEED_DICT) {
1.469 + test2(d_stream.adler, dictId); /* Fails if unexpected dictionary */
1.470 +
1.471 + err = inflateSetDictionary(&d_stream, (const Bytef*)dictionary,
1.472 + sizeof(dictionary));
1.473 + }
1.474 + test2(err, Z_OK);
1.475 + }
1.476 +
1.477 + err = inflateEnd(&d_stream);
1.478 + test2(err, Z_OK);
1.479 +
1.480 + test2(strcmp((char*)uncompr, hello), 0); /* Fails if bad inflate with dictionary */
1.481 +
1.482 + PrintString(_L("inflate with dictionary: %S\n"), (char*)uncompr);
1.483 +}
1.484 +
1.485 +/* ===========================================================================
1.486 + * Usage: example [output.gz [input.gz]]
1.487 + */
1.488 +
1.489 +void PrintString(TRefByValue<const TDesC> aFmt, char* string)
1.490 + {
1.491 + TPtrC8 ptrc8;
1.492 + TBuf<100> buf;
1.493 + ptrc8.Set((TUint8*)string, strlen(string));
1.494 + buf.Copy(ptrc8);
1.495 + test.Printf(aFmt, &buf);
1.496 + }
1.497 +
1.498 +void RunTest()
1.499 +{
1.500 + Byte *compr, *uncompr;
1.501 + uLong comprLen = 10000*sizeof(int); /* don't overflow on MSDOS */
1.502 + uLong uncomprLen = comprLen;
1.503 + static const char* myVersion = ZLIB_VERSION;
1.504 +
1.505 + test2(zlibVersion()[0], myVersion[0]); /* Fails if incompatible zlib version */
1.506 +
1.507 + if (strcmp(zlibVersion(), ZLIB_VERSION) != 0) {
1.508 + test.Printf(_L("warning: different zlib version\n"));
1.509 + }
1.510 +
1.511 + compr = (Byte*)calloc((uInt)comprLen, 1);
1.512 + uncompr = (Byte*)calloc((uInt)uncomprLen, 1);
1.513 + /* compr and uncompr are cleared to avoid reading uninitialized
1.514 + * data and to ensure that uncompr compresses well.
1.515 + */
1.516 + test2((compr == Z_NULL || uncompr == Z_NULL), 0); /* Fails if out of memory */
1.517 +
1.518 + test_compress(compr, comprLen, uncompr, uncomprLen);
1.519 +
1.520 + test_deflate(compr, comprLen);
1.521 + test_inflate(compr, comprLen, uncompr, uncomprLen);
1.522 +
1.523 + test_large_deflate(compr, comprLen, uncompr, uncomprLen);
1.524 + test_large_inflate(compr, comprLen, uncompr, uncomprLen);
1.525 +
1.526 + test_flush(compr, &comprLen);
1.527 + test_sync(compr, comprLen, uncompr, uncomprLen);
1.528 + comprLen = uncomprLen;
1.529 +
1.530 + test_dict_deflate(compr, comprLen);
1.531 + test_dict_inflate(compr, comprLen, uncompr, uncomprLen);
1.532 +
1.533 + delete compr;
1.534 + delete uncompr;
1.535 +}
1.536 +
1.537 +GLDEF_C TInt E32Main()
1.538 + {
1.539 + __UHEAP_MARK;
1.540 +
1.541 + test.Printf(_L("\n"));
1.542 + test.Title();
1.543 + test.Start(KTestTitle);
1.544 +
1.545 + CTrapCleanup* cleanup = CTrapCleanup::New();
1.546 +
1.547 + TRAPD(err, RunTest());
1.548 + test2(err, KErrNone);
1.549 +
1.550 + test.End();
1.551 + test.Close();
1.552 + delete cleanup;
1.553 +
1.554 + __UHEAP_MARKEND;
1.555 + return KErrNone;
1.556 + }