graphicsdeviceinterface/gdi/tgdi/TBiDi.cpp
changeset 183 6a1564a2f3e6
parent 168 2bd88482bfe5
child 194 18f84489a694
equal deleted inserted replaced
168:2bd88482bfe5 183:6a1564a2f3e6
     1 // Copyright (c) 2003-2009 Nokia Corporation and/or its subsidiary(-ies).
       
     2 // All rights reserved.
       
     3 // This component and the accompanying materials are made available
       
     4 // under the terms of "Eclipse Public License v1.0"
       
     5 // which accompanies this distribution, and is available
       
     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".
       
     7 //
       
     8 // Initial Contributors:
       
     9 // Nokia Corporation - initial contribution.
       
    10 //
       
    11 // Contributors:
       
    12 //
       
    13 // Description:
       
    14 //
       
    15 
       
    16 #include "BidiCompact.h"
       
    17 #include "BidiVisual.h"
       
    18 #include <s32mem.h>
       
    19 #include <biditext.h>
       
    20 #include <linebreak.h>
       
    21 #include "TGraphicsContext.h"
       
    22 #include "TBiDi.h"
       
    23 
       
    24 //
       
    25 // Constants
       
    26 //
       
    27 static const TInt KBufferSize = 1024;
       
    28 static const TInt KHalfBufferSize = KBufferSize/2;
       
    29 static const TInt KQuarterBufferSize = KBufferSize/4;
       
    30 static const TInt KThreeQuarterBufferSize = KQuarterBufferSize*3;
       
    31 static const TInt KUnicodeNoSuchCharacter = 0xFFFF;
       
    32 static const TInt KUnicodeLeftToRightMark = 0x200E;
       
    33 static const TInt KUnicodeRightToLeftMark = 0x200F;
       
    34 static const TInt KUnicodeLeftToRightEmbedding = 0x202A;
       
    35 static const TInt KUnicodeRightToLeftEmbedding = 0x202B;
       
    36 static const TInt KUnicodePopDirectionFormat = 0x202C;
       
    37 static const TInt KUnicodeLeftToRightOverride = 0x202D;
       
    38 static const TInt KUnicodeRightToLeftOverride = 0x202E;
       
    39 static const TInt KUnicodeZeroWidthJoiner = 0x200D;
       
    40 static const TInt KUnicodeSpace = 0x0020;
       
    41 static const TInt KUnicodeLinebreak = 0x2028;
       
    42 
       
    43 const TText16 KAlef = 0x627;
       
    44 //const TText16 KBeh = 0x628;
       
    45 //const TText16  KTehMarbuta = 0x629;
       
    46 const TText16  KTeh = 0x62A;
       
    47 //const TText16  KTheh = 0x62B;
       
    48 //const TText16  KJeem = 0x62C;
       
    49 //const TText16  KHah = 0x62D;
       
    50 //const TText16  KKhah = 0x62E;
       
    51 //const TText16  KDal = 0x62F;
       
    52 //const TText16  KThal = 0x630;
       
    53 const TText16  KReh = 0x631;
       
    54 //const TText16  KZain = 0x632;
       
    55 //const TText16  KSeen = 0x633;
       
    56 //const TText16  KSheen = 0x634;
       
    57 //const TText16  KSad = 0x635;
       
    58 //const TText16  KDad = 0x636;
       
    59 //const TText16  KTah = 0x637;
       
    60 //const TText16  KZah = 0x638;
       
    61 //const TText16  KAin = 0x639;
       
    62 //const TText16  KGhain = 0x63A;
       
    63 const TText16  KFeh = 0x641;
       
    64 //const TText16  KQaf = 0x642;
       
    65 const TText16  KKaf = 0x643;
       
    66 //const TText16  KLam = 0x644;
       
    67 //const TText16  KMeem = 0x645;
       
    68 const TText16  KNoon = 0x646;
       
    69 //const TText16  KHeh = 0x647;
       
    70 //const TText16  KWaw = 0x648;
       
    71 //const TText16  KAlefMaksura = 0x649;
       
    72 const TText16  KYeh = 0x64A;
       
    73 const TText16 KEllipsis = 0x2026;
       
    74 
       
    75 // List of all glyphs that have mirrors as per Unicode 3.0.1
       
    76 
       
    77 _LIT(KMirrors,"\x28\x29\x3C\x3E\x5B\x5D\x7B\x7D\xAB\xBB\x2039\x203A\x2045\x2046"
       
    78 L"\x207D\x207E\x208D\x208E\x2208\x2209\x220A\x220B\x220C\x220D\x223C\x223D\x2243"
       
    79 L"\x2252\x2253\x2254\x2255\x2264\x2265\x2266\x2267\x2268\x2269\x226A\x226B\x226E"
       
    80 L"\x226F\x2270\x2271\x2272\x2273\x2274\x2275\x2276\x2277\x2278\x2279\x227A\x227B"
       
    81 L"\x227C\x227D\x227E\x227F\x2280\x2281\x2282\x2283\x2284\x2285\x2286\x2287\x2288"
       
    82 L"\x2289\x228A\x228B\x228F\x2290\x2291\x2292\x22A2\x22A3\x22B0\x22B1\x22B2\x22B3"
       
    83 L"\x22B4\x22B5\x22B6\x22B7\x22C9\x22CA\x22CB\x22CC\x22CD\x22D0\x22D1\x22D6\x22D7"
       
    84 L"\x22D8\x22D9\x22DA\x22DB\x22DC\x22DD\x22DE\x22DF\x22E0\x22E1\x22E2\x22E3\x22E4"
       
    85 L"\x22E5\x22E6\x22E7\x22E8\x22E9\x22EA\x22EB\x22EC\x22ED\x22F0\x22F1\x2308\x2309"
       
    86 L"\x230A\x230B\x2329\x232A\x3008\x3009\x300A\x300B\x300C\x300D\x300E\x300F\x3010"
       
    87 L"\x3011\x3014\x3015\x3016\x3017\x3018\x3019\x301A\x301B");
       
    88 
       
    89 // KMirrord()[Pos] is the mirror of KMirrors()[Pos]
       
    90 
       
    91 _LIT(KMirrord,"\x29\x28\x3E\x3C\x5D\x5B\x7D\x7B\xBB\xAB\x203A\x2039\x2046\x2045"
       
    92 L"\x207E\x207D\x208E\x208D\x220B\x220C\x220D\x2208\x2209\x220A\x223D\x223C\x22CD"
       
    93 L"\x2253\x2252\x2255\x2254\x2265\x2264\x2267\x2266\x2269\x2268\x226B\x226A\x226F"
       
    94 L"\x226E\x2271\x2270\x2273\x2272\x2275\x2274\x2277\x2276\x2279\x2278\x227B\x227A"
       
    95 L"\x227D\x227C\x227F\x227E\x2281\x2280\x2283\x2282\x2285\x2284\x2287\x2286\x2289"
       
    96 L"\x2288\x228B\x228A\x2290\x228F\x2292\x2291\x22A3\x22A2\x22B1\x22B0\x22B3\x22B2"
       
    97 L"\x22B5\x22B4\x22B7\x22B6\x22CA\x22C9\x22CC\x22CB\x2243\x22D1\x22D0\x22D7\x22D6"
       
    98 L"\x22D9\x22D8\x22DB\x22DA\x22DD\x22DC\x22DF\x22DE\x22E1\x22E0\x22E3\x22E2\x22E5"
       
    99 L"\x22E4\x22E7\x22E6\x22E9\x22E8\x22EB\x22EA\x22ED\x22EC\x22F1\x22F0\x2309\x2308"
       
   100 L"\x230B\x230A\x232A\x2329\x3009\x3008\x300B\x300A\x300D\x300C\x300F\x300E\x3011"
       
   101 L"\x3010\x3015\x3014\x3017\x3016\x3019\x3018\x301B\x301A");
       
   102 
       
   103 // This constant defines the Unicode characters in the "LeftToRight" (L) category.
       
   104 // A conventional _LIT cannot be used here because of the Microsoft limit of 
       
   105 // 2048 bytes for literal strings.
       
   106 // Note: Remove all "mark" from this array, i.e, category = Mn, Mc or Me. That's
       
   107 //       because a "mark" always follow its base character. This feature will
       
   108 //       lead RLOLeftToRightTest() to fail.
       
   109 // Note: Remove all unpaired surrogate.
       
   110 static const TUint16 KLeftToRight[] = 
       
   111 	{
       
   112 	0x0041,0x0042,0x0043,0x0044,0x0045,0x0046,0x0047,0x0048,0x0049,0x004a,
       
   113 	0x004b,0x004c,0x004d,0x004e,0x004f,0x0050,0x0051,0x0052,0x0053,0x0054,
       
   114 	0x0055,0x0056,0x0057,0x0058,0x0059,0x005a,0x0061,0x0062,0x0063,0x0064,
       
   115 	0x0065,0x0066,0x0067,0x0068,0x0069,0x006a,0x006b,0x006c,0x006d,0x006e,
       
   116 	0x006f,0x0070,0x0071,0x0072,0x0073,0x0074,0x0075,0x0076,0x0077,0x0078,
       
   117 	0x0079,0x007a,0x00aa,0x00b5,0x00ba,0x00c0,0x00c1,0x00c2,0x00c3,0x00c4,
       
   118 	0x00c5,0x00c6,0x00c7,0x00c8,0x00c9,0x00ca,0x00cb,0x00cc,0x00cd,0x00ce,
       
   119 	0x00cf,0x00d0,0x00d1,0x00d2,0x00d3,0x00d4,0x00d5,0x00d6,0x00d8,0x00d9,
       
   120 	0x00da,0x00db,0x00dc,0x00dd,0x00de,0x00df,0x00e0,0x00e1,0x00e2,0x00e3,
       
   121 	0x00e4,0x00e5,0x00e6,0x00e7,0x00e8,0x00e9,0x00ea,0x00eb,0x00ec,0x00ed,
       
   122 	0x00ee,0x00ef,0x00f0,0x00f1,0x00f2,0x00f3,0x00f4,0x00f5,0x00f6,0x00f8,
       
   123 	0x00f9,0x00fa,0x00fb,0x00fc,0x00fd,0x00fe,0x00ff,0x0100,0x0101,0x0102,
       
   124 	0x0103,0x0104,0x0105,0x0106,0x0107,0x0108,0x0109,0x010a,0x010b,0x010c,
       
   125 	0x010d,0x010e,0x010f,0x0110,0x0111,0x0112,0x0113,0x0114,0x0115,0x0116,
       
   126 	0x0117,0x0118,0x0119,0x011a,0x011b,0x011c,0x011d,0x011e,0x011f,0x0120,
       
   127 	0x0121,0x0122,0x0123,0x0124,0x0125,0x0126,0x0127,0x0128,0x0129,0x012a,
       
   128 	0x012b,0x012c,0x012d,0x012e,0x012f,0x0130,0x0131,0x0132,0x0133,0x0134,
       
   129 	0x0135,0x0136,0x0137,0x0138,0x0139,0x013a,0x013b,0x013c,0x013d,0x013e,
       
   130 	0x013f,0x0140,0x0141,0x0142,0x0143,0x0144,0x0145,0x0146,0x0147,0x0148,
       
   131 	0x0149,0x014a,0x014b,0x014c,0x014d,0x014e,0x014f,0x0150,0x0151,0x0152,
       
   132 	0x0153,0x0154,0x0155,0x0156,0x0157,0x0158,0x0159,0x015a,0x015b,0x015c,
       
   133 	0x015d,0x015e,0x015f,0x0160,0x0161,0x0162,0x0163,0x0164,0x0165,0x0166,
       
   134 	0x0167,0x0168,0x0169,0x016a,0x016b,0x016c,0x016d,0x016e,0x016f,0x0170,
       
   135 	0x0171,0x0172,0x0173,0x0174,0x0175,0x0176,0x0177,0x0178,0x0179,0x017a,
       
   136 	0x017b,0x017c,0x017d,0x017e,0x017f,0x0180,0x0181,0x0182,0x0183,0x0184,
       
   137 	0x0185,0x0186,0x0187,0x0188,0x0189,0x018a,0x018b,0x018c,0x018d,0x018e,
       
   138 	0x018f,0x0190,0x0191,0x0192,0x0193,0x0194,0x0195,0x0196,0x0197,0x0198,
       
   139 	0x0199,0x019a,0x019b,0x019c,0x019d,0x019e,0x019f,0x01a0,0x01a1,0x01a2,
       
   140 	0x01a3,0x01a4,0x01a5,0x01a6,0x01a7,0x01a8,0x01a9,0x01aa,0x01ab,0x01ac,
       
   141 	0x01ad,0x01ae,0x01af,0x01b0,0x01b1,0x01b2,0x01b3,0x01b4,0x01b5,0x01b6,
       
   142 	0x01b7,0x01b8,0x01b9,0x01ba,0x01bb,0x01bc,0x01bd,0x01be,0x01bf,0x01c0,
       
   143 	0x01c1,0x01c2,0x01c3,0x01c4,0x01c5,0x01c6,0x01c7,0x01c8,0x01c9,0x01ca,
       
   144 	0x01cb,0x01cc,0x01cd,0x01ce,0x01cf,0x01d0,0x01d1,0x01d2,0x01d3,0x01d4,
       
   145 	0x01d5,0x01d6,0x01d7,0x01d8,0x01d9,0x01da,0x01db,0x01dc,0x01dd,0x01de,
       
   146 	0x01df,0x01e0,0x01e1,0x01e2,0x01e3,0x01e4,0x01e5,0x01e6,0x01e7,0x01e8,
       
   147 	0x01e9,0x01ea,0x01eb,0x01ec,0x01ed,0x01ee,0x01ef,0x01f0,0x01f1,0x01f2,
       
   148 	0x01f3,0x01f4,0x01f5,0x01f6,0x01f7,0x01f8,0x01f9,0x01fa,0x01fb,0x01fc,
       
   149 	0x01fd,0x01fe,0x01ff,0x0200,0x0201,0x0202,0x0203,0x0204,0x0205,0x0206,
       
   150 	0x0207,0x0208,0x0209,0x020a,0x020b,0x020c,0x020d,0x020e,0x020f,0x0210,
       
   151 	0x0211,0x0212,0x0213,0x0214,0x0215,0x0216,0x0217,0x0218,0x0219,0x021a,
       
   152 	0x021b,0x021c,0x021d,0x021e,0x021f,0x0220,0x0221,0x0222,0x0223,0x0224,
       
   153 	0x0225,0x0226,0x0227,0x0228,0x0229,0x022a,0x022b,0x022c,0x022d,0x022e,
       
   154 	0x022f,0x0230,0x0231,0x0232,0x0233,0x0234,0x0235,0x0236,0x0237,0x0238,
       
   155 	0x0239,0x023a,0x023b,0x023c,0x023d,0x023e,0x023f,0x0240,0x0241,0x0242,
       
   156 	0x0243,0x0244,0x0245,0x0246,0x0247,0x0248,0x0249,0x024a,0x024b,0x024c,
       
   157 	0x024d,0x024e,0x024f,0x0250,0x0251,0x0252,0x0253,0x0254,0x0255,0x0256,
       
   158 	0x0257,0x0258,0x0259,0x025a,0x025b,0x025c,0x025d,0x025e,0x025f,0x0260,
       
   159 	0x0261,0x0262,0x0263,0x0264,0x0265,0x0266,0x0267,0x0268,0x0269,0x026a,
       
   160 	0x026b,0x026c,0x026d,0x026e,0x026f,0x0270,0x0271,0x0272,0x0273,0x0274,
       
   161 	0x0275,0x0276,0x0277,0x0278,0x0279,0x027a,0x027b,0x027c,0x027d,0x027e,
       
   162 	0x027f,0x0280,0x0281,0x0282,0x0283,0x0284,0x0285,0x0286,0x0287,0x0288,
       
   163 	0x0289,0x028a,0x028b,0x028c,0x028d,0x028e,0x028f,0x0290,0x0291,0x0292,
       
   164 	0x0293,0x0294,0x0295,0x0296,0x0297,0x0298,0x0299,0x029a,0x029b,0x029c,
       
   165 	0x029d,0x029e,0x029f,0x02a0,0x02a1,0x02a2,0x02a3,0x02a4,0x02a5,0x02a6,
       
   166 	0x02a7,0x02a8,0x02a9,0x02aa,0x02ab,0x02ac,0x02ad,0x02ae,0x02af,0x02b0,
       
   167 	0x02b1,0x02b2,0x02b3,0x02b4,0x02b5,0x02b6,0x02b7,0x02b8,0x02bb,0x02bc,
       
   168 	0x02bd,0x02be,0x02bf,0x02c0,0x02c1,0x02d0,0x02d1,0x02e0,0x02e1,0x02e2,
       
   169 	0x02e3,0x02e4,0x02ee,0x037a,0x037b,0x037c,0x037d,0x0386,0x0388,0x0389,
       
   170 	0x038a,0x038c,0x038e,0x038f,0x0390,0x0391,0x0392,0x0393,0x0394,0x0395,
       
   171 	0x0396,0x0397,0x0398,0x0399,0x039a,0x039b,0x039c,0x039d,0x039e,0x039f,
       
   172 	0x03a0,0x03a1,0x03a3,0x03a4,0x03a5,0x03a6,0x03a7,0x03a8,0x03a9,0x03aa,
       
   173 	0x03ab,0x03ac,0x03ad,0x03ae,0x03af,0x03b0,0x03b1,0x03b2,0x03b3,0x03b4,
       
   174 	0x03b5,0x03b6,0x03b7,0x03b8,0x03b9,0x03ba,0x03bb,0x03bc,0x03bd,0x03be,
       
   175 	0x03bf,0x03c0,0x03c1,0x03c2,0x03c3,0x03c4,0x03c5,0x03c6,0x03c7,0x03c8,
       
   176 	0x03c9,0x03ca,0x03cb,0x03cc,0x03cd,0x03ce,0x03d0,0x03d1,0x03d2,0x03d3,
       
   177 	0x03d4,0x03d5,0x03d6,0x03d7,0x03d8,0x03d9,0x03da,0x03db,0x03dc,0x03dd,
       
   178 	0x03de,0x03df,0x03e0,0x03e1,0x03e2,0x03e3,0x03e4,0x03e5,0x03e6,0x03e7,
       
   179 	0x03e8,0x03e9,0x03ea,0x03eb,0x03ec,0x03ed,0x03ee,0x03ef,0x03f0,0x03f1,
       
   180 	0x03f2,0x03f3,0x03f4,0x03f5,0x03f7,0x03f8,0x03f9,0x03fa,0x03fb,0x03fc,
       
   181 	0x03fd,0x03fe,0x03ff,0x0400,0x0401,0x0402,0x0403,0x0404,0x0405,0x0406,
       
   182 	0x0407,0x0408,0x0409,0x040a,0x040b,0x040c,0x040d,0x040e,0x040f,0x0410,
       
   183 	0x0411,0x0412,0x0413,0x0414,0x0415,0x0416,0x0417,0x0418,0x0419,0x041a,
       
   184 	0x041b,0x041c,0x041d,0x041e,0x041f,0x0420,0x0421,0x0422,0x0423,0x0424,
       
   185 	0x0425,0x0426,0x0427,0x0428,0x0429,0x042a,0x042b,0x042c,0x042d,0x042e,
       
   186 	0x042f,0x0430,0x0431,0x0432,0x0433,0x0434,0x0435,0x0436,0x0437,0x0438,
       
   187 	0x0439,0x043a,0x043b,0x043c,0x043d,0x043e,0x043f,0x0440,0x0441,0x0442,
       
   188 	0x0443,0x0444,0x0445,0x0446,0x0447,0x0448,0x0449,0x044a,0x044b,0x044c,
       
   189 	0x044d,0x044e,0x044f,0x0450,0x0451,0x0452,0x0453,0x0454,0x0455,0x0456,
       
   190 	0x0457,0x0458,0x0459,0x045a,0x045b,0x045c,0x045d,0x045e,0x045f,0x0460,
       
   191 	0x0461,0x0462,0x0463,0x0464,0x0465,0x0466,0x0467,0x0468,0x0469,0x046a,
       
   192 	0x046b,0x046c,0x046d,0x046e,0x046f,0x0470,0x0471,0x0472,0x0473,0x0474,
       
   193 	0x0475,0x0476,0x0477,0x0478,0x0479,0x047a,0x047b,0x047c,0x047d,0x047e,
       
   194 	0x047f,0x0480,0x0481,0x0482,0x048a,0x048b,0x048c,0x048d,0x048e,0x048f,
       
   195 	0x0490,0x0491,0x0492,0x0493,0x0494,0x0495,0x0496,0x0497,0x0498,0x0499,
       
   196 	0x049a,0x049b,0x049c,0x049d,0x049e,0x049f,0x04a0,0x04a1,0x04a2,0x04a3,
       
   197 	0x04a4,0x04a5,0x04a6,0x04a7,0x04a8,0x04a9,0x04aa,0x04ab,0x04ac,0x04ad,
       
   198 	0x04ae,0x04af,0x04b0,0x04b1,0x04b2,0x04b3,0x04b4,0x04b5,0x04b6,0x04b7,
       
   199 	0x04b8,0x04b9,0x04ba,0x04bb,0x04bc,0x04bd,0x04be,0x04bf,0x04c0,0x04c1,
       
   200 	0x04c2,0x04c3,0x04c4,0x04c5,0x04c6,0x04c7,0x04c8,0x04c9,0x04ca,0x04cb,
       
   201 	0x04cc,0x04cd,0x04ce,0x04cf,0x04d0,0x04d1,0x04d2,0x04d3,0x04d4,0x04d5,
       
   202 	0x04d6,0x04d7,0x04d8,0x04d9,0x04da,0x04db,0x04dc,0x04dd,0x04de,0x04df,
       
   203 	0x04e0,0x04e1,0x04e2,0x04e3,0x04e4,0x04e5,0x04e6,0x04e7,0x04e8,0x04e9,
       
   204 	0x04ea,0x04eb,0x04ec,0x04ed,0x04ee,0x04ef,0x04f0,0x04f1,0x04f2,0x04f3,
       
   205 	0x04f4,0x04f5,0x04f6,0x04f7,0x04f8,0x04f9,0x04fa,0x04fb,0x04fc,0x04fd,
       
   206 	0x04fe,0x04ff,0x0500,0x0501,0x0502,0x0503,0x0504,0x0505,0x0506,0x0507,
       
   207 	0x0508,0x0509,0x050a,0x050b,0x050c,0x050d,0x050e,0x050f,0x0510,0x0511,
       
   208 	0x0512,0x0513,0x0531,0x0532,0x0533,0x0534,0x0535,0x0536,0x0537,0x0538,
       
   209 	0x0539,0x053a,0x053b,0x053c,0x053d,0x053e,0x053f,0x0540,0x0541,0x0542,
       
   210 	0x0543,0x0544,0x0545,0x0546,0x0547,0x0548,0x0549,0x054a,0x054b,0x054c,
       
   211 	0x054d,0x054e,0x054f,0x0550,0x0551,0x0552,0x0553,0x0554,0x0555,0x0556,
       
   212 	0x0559,0x055a,0x055b,0x055c,0x055d,0x055e,0x055f,0x0561,0x0562,0x0563,
       
   213 	0x0564,0x0565,0x0566,0x0567,0x0568,0x0569,0x056a,0x056b,0x056c,0x056d,
       
   214 	0x056e,0x056f,0x0570,0x0571,0x0572,0x0573,0x0574,0x0575,0x0576,0x0577,
       
   215 	0x0578,0x0579,0x057a,0x057b,0x057c,0x057d,0x057e,0x057f,0x0580,0x0581,
       
   216 	0x0582,0x0583,0x0584,0x0585,0x0586,0x0587,0x0589,0x0904,0x0905,0x0906,
       
   217 	0x0907,0x0908,0x0909,0x090a,0x090b,0x090c,0x090d,0x090e,0x090f,0x0910,
       
   218 	0x0911,0x0912,0x0913,0x0914,0x0915,0x0916,0x0917,0x0918,0x0919,0x091a,
       
   219 	0x091b,0x091c,0x091d,0x091e,0x091f,0x0920,0x0921,0x0922,0x0923,0x0924,
       
   220 	0x0925,0x0926,0x0927,0x0928,0x0929,0x092a,0x092b,0x092c,0x092d,0x092e,
       
   221 	0x092f,0x0930,0x0931,0x0932,0x0933,0x0934,0x0935,0x0936,0x0937,0x0938,
       
   222 	0x0939,0x093d,0x0950,0x0958,0x0959,0x095a,0x095b,0x095c,0x095d,0x095e,
       
   223 	0x095f,0x0960,0x0961,0x0964,0x0965,0x0966,0x0967,0x0968,0x0969,0x096a,
       
   224 	0x096b,0x096c,0x096d,0x096e,0x096f,0x0970,0x097b,0x097c,0x097d,0x097e,
       
   225 	0x097f,0x0985,0x0986,0x0987,0x0988,0x0989,0x098a,0x098b,0x098c,0x098f,
       
   226 	0x0990,0x0993,0x0994,0x0995,0x0996,0x0997,0x0998,0x0999,0x099a,0x099b,
       
   227 	0x099c,0x099d,0x099e,0x099f,0x09a0,0x09a1,0x09a2,0x09a3,0x09a4,0x09a5,
       
   228 	0x09a6,0x09a7,0x09a8,0x09aa,0x09ab,0x09ac,0x09ad,0x09ae,0x09af,0x09b0,
       
   229 	0x09b2,0x09b6,0x09b7,0x09b8,0x09b9,0x09bd,0x09ce,0x09dc,0x09dd,0x09df,
       
   230 	0x09e0,0x09e1,0x09e6,0x09e7,0x09e8,0x09e9,0x09ea,0x09eb,0x09ec,0x09ed,
       
   231 	0x09ee,0x09ef,0x09f0,0x09f1,0x09f4,0x09f5,0x09f6,0x09f7,0x09f8,0x09f9,
       
   232 	0x09fa,0x0a05,0x0a06,0x0a07,0x0a08,0x0a09,0x0a0a,0x0a0f,0x0a10,0x0a13,
       
   233 	0x0a14,0x0a15,0x0a16,0x0a17,0x0a18,0x0a19,0x0a1a,0x0a1b,0x0a1c,0x0a1d,
       
   234 	0x0a1e,0x0a1f,0x0a20,0x0a21,0x0a22,0x0a23,0x0a24,0x0a25,0x0a26,0x0a27,
       
   235 	0x0a28,0x0a2a,0x0a2b,0x0a2c,0x0a2d,0x0a2e,0x0a2f,0x0a30,0x0a32,0x0a33,
       
   236 	0x0a35,0x0a36,0x0a38,0x0a39,0x0a59,0x0a5a,0x0a5b,0x0a5c,0x0a5e,0x0a66,
       
   237 	0x0a67,0x0a68,0x0a69,0x0a6a,0x0a6b,0x0a6c,0x0a6d,0x0a6e,0x0a6f,0x0a72,
       
   238 	0x0a73,0x0a74,0x0a85,0x0a86,0x0a87,0x0a88,0x0a89,0x0a8a,0x0a8b,0x0a8c,
       
   239 	0x0a8d,0x0a8f,0x0a90,0x0a91,0x0a93,0x0a94,0x0a95,0x0a96,0x0a97,0x0a98,
       
   240 	0x0a99,0x0a9a,0x0a9b,0x0a9c,0x0a9d,0x0a9e,0x0a9f,0x0aa0,0x0aa1,0x0aa2,
       
   241 	0x0aa3,0x0aa4,0x0aa5,0x0aa6,0x0aa7,0x0aa8,0x0aaa,0x0aab,0x0aac,0x0aad,
       
   242 	0x0aae,0x0aaf,0x0ab0,0x0ab2,0x0ab3,0x0ab5,0x0ab6,0x0ab7,0x0ab8,0x0ab9,
       
   243 	0x0abd,0x0ad0,0x0ae0,0x0ae1,0x0ae6,0x0ae7,0x0ae8,0x0ae9,0x0aea,0x0aeb,
       
   244 	0x0aec,0x0aed,0x0aee,0x0aef,0x0b05,0x0b06,0x0b07,0x0b08,0x0b09,0x0b0a,
       
   245 	0x0b0b,0x0b0c,0x0b0f,0x0b10,0x0b13,0x0b14,0x0b15,0x0b16,0x0b17,0x0b18,
       
   246 	0x0b19,0x0b1a,0x0b1b,0x0b1c,0x0b1d,0x0b1e,0x0b1f,0x0b20,0x0b21,0x0b22,
       
   247 	0x0b23,0x0b24,0x0b25,0x0b26,0x0b27,0x0b28,0x0b2a,0x0b2b,0x0b2c,0x0b2d,
       
   248 	0x0b2e,0x0b2f,0x0b30,0x0b32,0x0b33,0x0b35,0x0b36,0x0b37,0x0b38,0x0b39,
       
   249 	0x0b3d,0x0b5c,0x0b5d,0x0b5f,0x0b60,0x0b61,0x0b66,0x0b67,0x0b68,0x0b69,
       
   250 	0x0b6a,0x0b6b,0x0b6c,0x0b6d,0x0b6e,0x0b6f,0x0b70,0x0b71,0x0b83,0x0b85,
       
   251 	0x0b86,0x0b87,0x0b88,0x0b89,0x0b8a,0x0b8e,0x0b8f,0x0b90,0x0b92,0x0b93,
       
   252 	0x0b94,0x0b95,0x0b99,0x0b9a,0x0b9c,0x0b9e,0x0b9f,0x0ba3,0x0ba4,0x0ba8,
       
   253 	0x0ba9,0x0baa,0x0bae,0x0baf,0x0bb0,0x0bb1,0x0bb2,0x0bb3,0x0bb4,0x0bb5,
       
   254 	0x0bb6,0x0bb7,0x0bb8,0x0bb9,0x0be6,0x0be7,0x0be8,0x0be9,0x0bea,0x0beb,
       
   255 	0x0bec,0x0bed,0x0bee,0x0bef,0x0bf0,0x0bf1,0x0bf2,0x0c05,0x0c06,0x0c07,
       
   256 	0x0c08,0x0c09,0x0c0a,0x0c0b,0x0c0c,0x0c0e,0x0c0f,0x0c10,0x0c12,0x0c13,
       
   257 	0x0c14,0x0c15,0x0c16,0x0c17,0x0c18,0x0c19,0x0c1a,0x0c1b,0x0c1c,0x0c1d,
       
   258 	0x0c1e,0x0c1f,0x0c20,0x0c21,0x0c22,0x0c23,0x0c24,0x0c25,0x0c26,0x0c27,
       
   259 	0x0c28,0x0c2a,0x0c2b,0x0c2c,0x0c2d,0x0c2e,0x0c2f,0x0c30,0x0c31,0x0c32,
       
   260 	0x0c33,0x0c35,0x0c36,0x0c37,0x0c38,0x0c39,0x0c60,0x0c61,0x0c66,0x0c67,
       
   261 	0x0c68,0x0c69,0x0c6a,0x0c6b,0x0c6c,0x0c6d,0x0c6e,0x0c6f,0x0c85,0x0c86,
       
   262 	0x0c87,0x0c88,0x0c89,0x0c8a,0x0c8b,0x0c8c,0x0c8e,0x0c8f,0x0c90,0x0c92,
       
   263 	0x0c93,0x0c94,0x0c95,0x0c96,0x0c97,0x0c98,0x0c99,0x0c9a,0x0c9b,0x0c9c,
       
   264 	0x0c9d,0x0c9e,0x0c9f,0x0ca0,0x0ca1,0x0ca2,0x0ca3,0x0ca4,0x0ca5,0x0ca6,
       
   265 	0x0ca7,0x0ca8,0x0caa,0x0cab,0x0cac,0x0cad,0x0cae,0x0caf,0x0cb0,0x0cb1,
       
   266 	0x0cb2,0x0cb3,0x0cb5,0x0cb6,0x0cb7,0x0cb8,0x0cb9,0x0cbd,0x0cde,0x0ce0,
       
   267 	0x0ce1,0x0ce6,0x0ce7,0x0ce8,0x0ce9,0x0cea,0x0ceb,0x0cec,0x0ced,0x0cee,
       
   268 	0x0cef,0x0d05,0x0d06,0x0d07,0x0d08,0x0d09,0x0d0a,0x0d0b,0x0d0c,0x0d0e,
       
   269 	0x0d0f,0x0d10,0x0d12,0x0d13,0x0d14,0x0d15,0x0d16,0x0d17,0x0d18,0x0d19,
       
   270 	0x0d1a,0x0d1b,0x0d1c,0x0d1d,0x0d1e,0x0d1f,0x0d20,0x0d21,0x0d22,0x0d23,
       
   271 	0x0d24,0x0d25,0x0d26,0x0d27,0x0d28,0x0d2a,0x0d2b,0x0d2c,0x0d2d,0x0d2e,
       
   272 	0x0d2f,0x0d30,0x0d31,0x0d32,0x0d33,0x0d34,0x0d35,0x0d36,0x0d37,0x0d38,
       
   273 	0x0d39,0x0d60,0x0d61,0x0d66,0x0d67,0x0d68,0x0d69,0x0d6a,0x0d6b,0x0d6c,
       
   274 	0x0d6d,0x0d6e,0x0d6f,0x0d85,0x0d86,0x0d87,0x0d88,0x0d89,0x0d8a,0x0d8b,
       
   275 	0x0d8c,0x0d8d,0x0d8e,0x0d8f,0x0d90,0x0d91,0x0d92,0x0d93,0x0d94,0x0d95,
       
   276 	0x0d96,0x0d9a,0x0d9b,0x0d9c,0x0d9d,0x0d9e,0x0d9f,0x0da0,0x0da1,0x0da2,
       
   277 	0x0da3,0x0da4,0x0da5,0x0da6,0x0da7,0x0da8,0x0da9,0x0daa,0x0dab,0x0dac,
       
   278 	0x0dad,0x0dae,0x0daf,0x0db0,0x0db1,0x0db3,0x0db4,0x0db5,0x0db6,0x0db7,
       
   279 	0x0db8,0x0db9,0x0dba,0x0dbb,0x0dbd,0x0dc0,0x0dc1,0x0dc2,0x0dc3,0x0dc4,
       
   280 	0x0dc5,0x0dc6,0x0df4,0x0e01,0x0e02,0x0e03,0x0e04,0x0e05,0x0e06,0x0e07,
       
   281 	0x0e08,0x0e09,0x0e0a,0x0e0b,0x0e0c,0x0e0d,0x0e0e,0x0e0f,0x0e10,0x0e11,
       
   282 	0x0e12,0x0e13,0x0e14,0x0e15,0x0e16,0x0e17,0x0e18,0x0e19,0x0e1a,0x0e1b,
       
   283 	0x0e1c,0x0e1d,0x0e1e,0x0e1f,0x0e20,0x0e21,0x0e22,0x0e23,0x0e24,0x0e25,
       
   284 	0x0e26,0x0e27,0x0e28,0x0e29,0x0e2a,0x0e2b,0x0e2c,0x0e2d,0x0e2e,0x0e2f,
       
   285 	0x0e30,0x0e32,0x0e33,0x0e40,0x0e41,0x0e42,0x0e43,0x0e44,0x0e45,0x0e46,
       
   286 	0x0e4f,0x0e50,0x0e51,0x0e52,0x0e53,0x0e54,0x0e55,0x0e56,0x0e57,0x0e58,
       
   287 	0x0e59,0x0e5a,0x0e5b,0x0e81,0x0e82,0x0e84,0x0e87,0x0e88,0x0e8a,0x0e8d,
       
   288 	0x0e94,0x0e95,0x0e96,0x0e97,0x0e99,0x0e9a,0x0e9b,0x0e9c,0x0e9d,0x0e9e,
       
   289 	0x0e9f,0x0ea1,0x0ea2,0x0ea3,0x0ea5,0x0ea7,0x0eaa,0x0eab,0x0ead,0x0eae,
       
   290 	0x0eaf,0x0eb0,0x0eb2,0x0eb3,0x0ebd,0x0ec0,0x0ec1,0x0ec2,0x0ec3,0x0ec4,
       
   291 	0x0ec6,0x0ed0,0x0ed1,0x0ed2,0x0ed3,0x0ed4,0x0ed5,0x0ed6,0x0ed7,0x0ed8,
       
   292 	0x0ed9,0x0edc,0x0edd,0x0f00,0x0f01,0x0f02,0x0f03,0x0f04,0x0f05,0x0f06,
       
   293 	0x0f07,0x0f08,0x0f09,0x0f0a,0x0f0b,0x0f0c,0x0f0d,0x0f0e,0x0f0f,0x0f10,
       
   294 	0x0f11,0x0f12,0x0f13,0x0f14,0x0f15,0x0f16,0x0f17,0x0f1a,0x0f1b,0x0f1c,
       
   295 	0x0f1d,0x0f1e,0x0f1f,0x0f20,0x0f21,0x0f22,0x0f23,0x0f24,0x0f25,0x0f26,
       
   296 	0x0f27,0x0f28,0x0f29,0x0f2a,0x0f2b,0x0f2c,0x0f2d,0x0f2e,0x0f2f,0x0f30,
       
   297 	0x0f31,0x0f32,0x0f33,0x0f34,0x0f36,0x0f38,0x0f40,0x0f41,0x0f42,0x0f43,
       
   298 	0x0f44,0x0f45,0x0f46,0x0f47,0x0f49,0x0f4a,0x0f4b,0x0f4c,0x0f4d,0x0f4e,
       
   299 	0x0f4f,0x0f50,0x0f51,0x0f52,0x0f53,0x0f54,0x0f55,0x0f56,0x0f57,0x0f58,
       
   300 	0x0f59,0x0f5a,0x0f5b,0x0f5c,0x0f5d,0x0f5e,0x0f5f,0x0f60,0x0f61,0x0f62,
       
   301 	0x0f63,0x0f64,0x0f65,0x0f66,0x0f67,0x0f68,0x0f69,0x0f6a,0x0f85,0x0f88,
       
   302 	0x0f89,0x0f8a,0x0f8b,0x0fbe,0x0fbf,0x0fc0,0x0fc1,0x0fc2,0x0fc3,0x0fc4,
       
   303 	0x0fc5,0x0fc7,0x0fc8,0x0fc9,0x0fca,0x0fcb,0x0fcc,0x0fcf,0x0fd0,0x0fd1,
       
   304 	0x1000,0x1001,0x1002,0x1003,0x1004,0x1005,0x1006,0x1007,0x1008,0x1009,
       
   305 	0x100a,0x100b,0x100c,0x100d,0x100e,0x100f,0x1010,0x1011,0x1012,0x1013,
       
   306 	0x1014,0x1015,0x1016,0x1017,0x1018,0x1019,0x101a,0x101b,0x101c,0x101d,
       
   307 	0x101e,0x101f,0x1020,0x1021,0x1023,0x1024,0x1025,0x1026,0x1027,0x1029,
       
   308 	0x102a,0x1040,0x1041,0x1042,0x1043,0x1044,0x1045,0x1046,0x1047,0x1048,
       
   309 	0x1049,0x104a,0x104b,0x104c,0x104d,0x104e,0x104f,0x1050,0x1051,0x1052,
       
   310 	0x1053,0x1054,0x1055,0x10a0,0x10a1,0x10a2,0x10a3,0x10a4,0x10a5,0x10a6,
       
   311 	0x10a7,0x10a8,0x10a9,0x10aa,0x10ab,0x10ac,0x10ad,0x10ae,0x10af,0x10b0,
       
   312 	0x10b1,0x10b2,0x10b3,0x10b4,0x10b5,0x10b6,0x10b7,0x10b8,0x10b9,0x10ba,
       
   313 	0x10bb,0x10bc,0x10bd,0x10be,0x10bf,0x10c0,0x10c1,0x10c2,0x10c3,0x10c4,
       
   314 	0x10c5,0x10d0,0x10d1,0x10d2,0x10d3,0x10d4,0x10d5,0x10d6,0x10d7,0x10d8,
       
   315 	0x10d9,0x10da,0x10db,0x10dc,0x10dd,0x10de,0x10df,0x10e0,0x10e1,0x10e2,
       
   316 	0x10e3,0x10e4,0x10e5,0x10e6,0x10e7,0x10e8,0x10e9,0x10ea,0x10eb,0x10ec,
       
   317 	0x10ed,0x10ee,0x10ef,0x10f0,0x10f1,0x10f2,0x10f3,0x10f4,0x10f5,0x10f6,
       
   318 	0x10f7,0x10f8,0x10f9,0x10fa,0x10fb,0x10fc,0x1100,0x1101,0x1102,0x1103,
       
   319 	0x1104,0x1105,0x1106,0x1107,0x1108,0x1109,0x110a,0x110b,0x110c,0x110d,
       
   320 	0x110e,0x110f,0x1110,0x1111,0x1112,0x1113,0x1114,0x1115,0x1116,0x1117,
       
   321 	0x1118,0x1119,0x111a,0x111b,0x111c,0x111d,0x111e,0x111f,0x1120,0x1121,
       
   322 	0x1122,0x1123,0x1124,0x1125,0x1126,0x1127,0x1128,0x1129,0x112a,0x112b,
       
   323 	0x112c,0x112d,0x112e,0x112f,0x1130,0x1131,0x1132,0x1133,0x1134,0x1135,
       
   324 	0x1136,0x1137,0x1138,0x1139,0x113a,0x113b,0x113c,0x113d,0x113e,0x113f,
       
   325 	0x1140,0x1141,0x1142,0x1143,0x1144,0x1145,0x1146,0x1147,0x1148,0x1149,
       
   326 	0x114a,0x114b,0x114c,0x114d,0x114e,0x114f,0x1150,0x1151,0x1152,0x1153,
       
   327 	0x1154,0x1155,0x1156,0x1157,0x1158,0x1159,0x115f,0x1160,0x1161,0x1162,
       
   328 	0x1163,0x1164,0x1165,0x1166,0x1167,0x1168,0x1169,0x116a,0x116b,0x116c,
       
   329 	0x116d,0x116e,0x116f,0x1170,0x1171,0x1172,0x1173,0x1174,0x1175,0x1176,
       
   330 	0x1177,0x1178,0x1179,0x117a,0x117b,0x117c,0x117d,0x117e,0x117f,0x1180,
       
   331 	0x1181,0x1182,0x1183,0x1184,0x1185,0x1186,0x1187,0x1188,0x1189,0x118a,
       
   332 	0x118b,0x118c,0x118d,0x118e,0x118f,0x1190,0x1191,0x1192,0x1193,0x1194,
       
   333 	0x1195,0x1196,0x1197,0x1198,0x1199,0x119a,0x119b,0x119c,0x119d,0x119e,
       
   334 	0x119f,0x11a0,0x11a1,0x11a2,0x11a8,0x11a9,0x11aa,0x11ab,0x11ac,0x11ad,
       
   335 	0x11ae,0x11af,0x11b0,0x11b1,0x11b2,0x11b3,0x11b4,0x11b5,0x11b6,0x11b7,
       
   336 	0x11b8,0x11b9,0x11ba,0x11bb,0x11bc,0x11bd,0x11be,0x11bf,0x11c0,0x11c1,
       
   337 	0x11c2,0x11c3,0x11c4,0x11c5,0x11c6,0x11c7,0x11c8,0x11c9,0x11ca,0x11cb,
       
   338 	0x11cc,0x11cd,0x11ce,0x11cf,0x11d0,0x11d1,0x11d2,0x11d3,0x11d4,0x11d5,
       
   339 	0x11d6,0x11d7,0x11d8,0x11d9,0x11da,0x11db,0x11dc,0x11dd,0x11de,0x11df,
       
   340 	0x11e0,0x11e1,0x11e2,0x11e3,0x11e4,0x11e5,0x11e6,0x11e7,0x11e8,0x11e9,
       
   341 	0x11ea,0x11eb,0x11ec,0x11ed,0x11ee,0x11ef,0x11f0,0x11f1,0x11f2,0x11f3,
       
   342 	0x11f4,0x11f5,0x11f6,0x11f7,0x11f8,0x11f9,0x1200,0x1201,0x1202,0x1203,
       
   343 	0x1204,0x1205,0x1206,0x1207,0x1208,0x1209,0x120a,0x120b,0x120c,0x120d,
       
   344 	0x120e,0x120f,0x1210,0x1211,0x1212,0x1213,0x1214,0x1215,0x1216,0x1217,
       
   345 	0x1218,0x1219,0x121a,0x121b,0x121c,0x121d,0x121e,0x121f,0x1220,0x1221,
       
   346 	0x1222,0x1223,0x1224,0x1225,0x1226,0x1227,0x1228,0x1229,0x122a,0x122b,
       
   347 	0x122c,0x122d,0x122e,0x122f,0x1230,0x1231,0x1232,0x1233,0x1234,0x1235,
       
   348 	0x1236,0x1237,0x1238,0x1239,0x123a,0x123b,0x123c,0x123d,0x123e,0x123f,
       
   349 	0x1240,0x1241,0x1242,0x1243,0x1244,0x1245,0x1246,0x1247,0x1248,0x124a,
       
   350 	0x124b,0x124c,0x124d,0x1250,0x1251,0x1252,0x1253,0x1254,0x1255,0x1256,
       
   351 	0x1258,0x125a,0x125b,0x125c,0x125d,0x1260,0x1261,0x1262,0x1263,0x1264,
       
   352 	0x1265,0x1266,0x1267,0x1268,0x1269,0x126a,0x126b,0x126c,0x126d,0x126e,
       
   353 	0x126f,0x1270,0x1271,0x1272,0x1273,0x1274,0x1275,0x1276,0x1277,0x1278,
       
   354 	0x1279,0x127a,0x127b,0x127c,0x127d,0x127e,0x127f,0x1280,0x1281,0x1282,
       
   355 	0x1283,0x1284,0x1285,0x1286,0x1287,0x1288,0x128a,0x128b,0x128c,0x128d,
       
   356 	0x1290,0x1291,0x1292,0x1293,0x1294,0x1295,0x1296,0x1297,0x1298,0x1299,
       
   357 	0x129a,0x129b,0x129c,0x129d,0x129e,0x129f,0x12a0,0x12a1,0x12a2,0x12a3,
       
   358 	0x12a4,0x12a5,0x12a6,0x12a7,0x12a8,0x12a9,0x12aa,0x12ab,0x12ac,0x12ad,
       
   359 	0x12ae,0x12af,0x12b0,0x12b2,0x12b3,0x12b4,0x12b5,0x12b8,0x12b9,0x12ba,
       
   360 	0x12bb,0x12bc,0x12bd,0x12be,0x12c0,0x12c2,0x12c3,0x12c4,0x12c5,0x12c8,
       
   361 	0x12c9,0x12ca,0x12cb,0x12cc,0x12cd,0x12ce,0x12cf,0x12d0,0x12d1,0x12d2,
       
   362 	0x12d3,0x12d4,0x12d5,0x12d6,0x12d8,0x12d9,0x12da,0x12db,0x12dc,0x12dd,
       
   363 	0x12de,0x12df,0x12e0,0x12e1,0x12e2,0x12e3,0x12e4,0x12e5,0x12e6,0x12e7,
       
   364 	0x12e8,0x12e9,0x12ea,0x12eb,0x12ec,0x12ed,0x12ee,0x12ef,0x12f0,0x12f1,
       
   365 	0x12f2,0x12f3,0x12f4,0x12f5,0x12f6,0x12f7,0x12f8,0x12f9,0x12fa,0x12fb,
       
   366 	0x12fc,0x12fd,0x12fe,0x12ff,0x1300,0x1301,0x1302,0x1303,0x1304,0x1305,
       
   367 	0x1306,0x1307,0x1308,0x1309,0x130a,0x130b,0x130c,0x130d,0x130e,0x130f,
       
   368 	0x1310,0x1312,0x1313,0x1314,0x1315,0x1318,0x1319,0x131a,0x131b,0x131c,
       
   369 	0x131d,0x131e,0x131f,0x1320,0x1321,0x1322,0x1323,0x1324,0x1325,0x1326,
       
   370 	0x1327,0x1328,0x1329,0x132a,0x132b,0x132c,0x132d,0x132e,0x132f,0x1330,
       
   371 	0x1331,0x1332,0x1333,0x1334,0x1335,0x1336,0x1337,0x1338,0x1339,0x133a,
       
   372 	0x133b,0x133c,0x133d,0x133e,0x133f,0x1340,0x1341,0x1342,0x1343,0x1344,
       
   373 	0x1345,0x1346,0x1347,0x1348,0x1349,0x134a,0x134b,0x134c,0x134d,0x134e,
       
   374 	0x134f,0x1350,0x1351,0x1352,0x1353,0x1354,0x1355,0x1356,0x1357,0x1358,
       
   375 	0x1359,0x135a,0x1360,0x1361,0x1362,0x1363,0x1364,0x1365,0x1366,0x1367,
       
   376 	0x1368,0x1369,0x136a,0x136b,0x136c,0x136d,0x136e,0x136f,0x1370,0x1371,
       
   377 	0x1372,0x1373,0x1374,0x1375,0x1376,0x1377,0x1378,0x1379,0x137a,0x137b,
       
   378 	0x137c,0x1380,0x1381,0x1382,0x1383,0x1384,0x1385,0x1386,0x1387,0x1388,
       
   379 	0x1389,0x138a,0x138b,0x138c,0x138d,0x138e,0x138f,0x13a0,0x13a1,0x13a2,
       
   380 	0x13a3,0x13a4,0x13a5,0x13a6,0x13a7,0x13a8,0x13a9,0x13aa,0x13ab,0x13ac,
       
   381 	0x13ad,0x13ae,0x13af,0x13b0,0x13b1,0x13b2,0x13b3,0x13b4,0x13b5,0x13b6,
       
   382 	0x13b7,0x13b8,0x13b9,0x13ba,0x13bb,0x13bc,0x13bd,0x13be,0x13bf,0x13c0,
       
   383 	0x13c1,0x13c2,0x13c3,0x13c4,0x13c5,0x13c6,0x13c7,0x13c8,0x13c9,0x13ca,
       
   384 	0x13cb,0x13cc,0x13cd,0x13ce,0x13cf,0x13d0,0x13d1,0x13d2,0x13d3,0x13d4,
       
   385 	0x13d5,0x13d6,0x13d7,0x13d8,0x13d9,0x13da,0x13db,0x13dc,0x13dd,0x13de,
       
   386 	0x13df,0x13e0,0x13e1,0x13e2,0x13e3,0x13e4,0x13e5,0x13e6,0x13e7,0x13e8,
       
   387 	0x13e9,0x13ea,0x13eb,0x13ec,0x13ed,0x13ee,0x13ef,0x13f0,0x13f1,0x13f2,
       
   388 	0x13f3,0x13f4,0x1401,0x1402,0x1403,0x1404,0x1405,0x1406,0x1407,0x1408,
       
   389 	0x1409,0x140a,0x140b,0x140c,0x140d,0x140e,0x140f,0x1410,0x1411,0x1412,
       
   390 	0x1413,0x1414,0x1415,0x1416,0x1417,0x1418,0x1419,0x141a,0x141b,0x141c,
       
   391 	0x141d,0x141e,0x141f,0x1420,0x1421,0x1422,0x1423,0x1424,0x1425,0x1426,
       
   392 	0x1427,0x1428,0x1429,0x142a,0x142b,0x142c,0x142d,0x142e,0x142f,0x1430,
       
   393 	0x1431,0x1432,0x1433,0x1434,0x1435,0x1436,0x1437,0x1438,0x1439,0x143a,
       
   394 	0x143b,0x143c,0x143d,0x143e,0x143f,0x1440,0x1441,0x1442,0x1443,0x1444,
       
   395 	0x1445,0x1446,0x1447,0x1448,0x1449,0x144a,0x144b,0x144c,0x144d,0x144e,
       
   396 	0x144f,0x1450,0x1451,0x1452,0x1453,0x1454,0x1455,0x1456,0x1457,0x1458,
       
   397 	0x1459,0x145a,0x145b,0x145c,0x145d,0x145e,0x145f,0x1460,0x1461,0x1462,
       
   398 	0x1463,0x1464,0x1465,0x1466,0x1467,0x1468,0x1469,0x146a,0x146b,0x146c,
       
   399 	0x146d,0x146e,0x146f,0x1470,0x1471,0x1472,0x1473,0x1474,0x1475,0x1476,
       
   400 	0x1477,0x1478,0x1479,0x147a,0x147b,0x147c,0x147d,0x147e,0x147f,0x1480,
       
   401 	0x1481,0x1482,0x1483,0x1484,0x1485,0x1486,0x1487,0x1488,0x1489,0x148a,
       
   402 	0x148b,0x148c,0x148d,0x148e,0x148f,0x1490,0x1491,0x1492,0x1493,0x1494,
       
   403 	0x1495,0x1496,0x1497,0x1498,0x1499,0x149a,0x149b,0x149c,0x149d,0x149e,
       
   404 	0x149f,0x14a0,0x14a1,0x14a2,0x14a3,0x14a4,0x14a5,0x14a6,0x14a7,0x14a8,
       
   405 	0x14a9,0x14aa,0x14ab,0x14ac,0x14ad,0x14ae,0x14af,0x14b0,0x14b1,0x14b2,
       
   406 	0x14b3,0x14b4,0x14b5,0x14b6,0x14b7,0x14b8,0x14b9,0x14ba,0x14bb,0x14bc,
       
   407 	0x14bd,0x14be,0x14bf,0x14c0,0x14c1,0x14c2,0x14c3,0x14c4,0x14c5,0x14c6,
       
   408 	0x14c7,0x14c8,0x14c9,0x14ca,0x14cb,0x14cc,0x14cd,0x14ce,0x14cf,0x14d0,
       
   409 	0x14d1,0x14d2,0x14d3,0x14d4,0x14d5,0x14d6,0x14d7,0x14d8,0x14d9,0x14da,
       
   410 	0x14db,0x14dc,0x14dd,0x14de,0x14df,0x14e0,0x14e1,0x14e2,0x14e3,0x14e4,
       
   411 	0x14e5,0x14e6,0x14e7,0x14e8,0x14e9,0x14ea,0x14eb,0x14ec,0x14ed,0x14ee,
       
   412 	0x14ef,0x14f0,0x14f1,0x14f2,0x14f3,0x14f4,0x14f5,0x14f6,0x14f7,0x14f8,
       
   413 	0x14f9,0x14fa,0x14fb,0x14fc,0x14fd,0x14fe,0x14ff,0x1500,0x1501,0x1502,
       
   414 	0x1503,0x1504,0x1505,0x1506,0x1507,0x1508,0x1509,0x150a,0x150b,0x150c,
       
   415 	0x150d,0x150e,0x150f,0x1510,0x1511,0x1512,0x1513,0x1514,0x1515,0x1516,
       
   416 	0x1517,0x1518,0x1519,0x151a,0x151b,0x151c,0x151d,0x151e,0x151f,0x1520,
       
   417 	0x1521,0x1522,0x1523,0x1524,0x1525,0x1526,0x1527,0x1528,0x1529,0x152a,
       
   418 	0x152b,0x152c,0x152d,0x152e,0x152f,0x1530,0x1531,0x1532,0x1533,0x1534,
       
   419 	0x1535,0x1536,0x1537,0x1538,0x1539,0x153a,0x153b,0x153c,0x153d,0x153e,
       
   420 	0x153f,0x1540,0x1541,0x1542,0x1543,0x1544,0x1545,0x1546,0x1547,0x1548,
       
   421 	0x1549,0x154a,0x154b,0x154c,0x154d,0x154e,0x154f,0x1550,0x1551,0x1552,
       
   422 	0x1553,0x1554,0x1555,0x1556,0x1557,0x1558,0x1559,0x155a,0x155b,0x155c,
       
   423 	0x155d,0x155e,0x155f,0x1560,0x1561,0x1562,0x1563,0x1564,0x1565,0x1566,
       
   424 	0x1567,0x1568,0x1569,0x156a,0x156b,0x156c,0x156d,0x156e,0x156f,0x1570,
       
   425 	0x1571,0x1572,0x1573,0x1574,0x1575,0x1576,0x1577,0x1578,0x1579,0x157a,
       
   426 	0x157b,0x157c,0x157d,0x157e,0x157f,0x1580,0x1581,0x1582,0x1583,0x1584,
       
   427 	0x1585,0x1586,0x1587,0x1588,0x1589,0x158a,0x158b,0x158c,0x158d,0x158e,
       
   428 	0x158f,0x1590,0x1591,0x1592,0x1593,0x1594,0x1595,0x1596,0x1597,0x1598,
       
   429 	0x1599,0x159a,0x159b,0x159c,0x159d,0x159e,0x159f,0x15a0,0x15a1,0x15a2,
       
   430 	0x15a3,0x15a4,0x15a5,0x15a6,0x15a7,0x15a8,0x15a9,0x15aa,0x15ab,0x15ac,
       
   431 	0x15ad,0x15ae,0x15af,0x15b0,0x15b1,0x15b2,0x15b3,0x15b4,0x15b5,0x15b6,
       
   432 	0x15b7,0x15b8,0x15b9,0x15ba,0x15bb,0x15bc,0x15bd,0x15be,0x15bf,0x15c0,
       
   433 	0x15c1,0x15c2,0x15c3,0x15c4,0x15c5,0x15c6,0x15c7,0x15c8,0x15c9,0x15ca,
       
   434 	0x15cb,0x15cc,0x15cd,0x15ce,0x15cf,0x15d0,0x15d1,0x15d2,0x15d3,0x15d4,
       
   435 	0x15d5,0x15d6,0x15d7,0x15d8,0x15d9,0x15da,0x15db,0x15dc,0x15dd,0x15de,
       
   436 	0x15df,0x15e0,0x15e1,0x15e2,0x15e3,0x15e4,0x15e5,0x15e6,0x15e7,0x15e8,
       
   437 	0x15e9,0x15ea,0x15eb,0x15ec,0x15ed,0x15ee,0x15ef,0x15f0,0x15f1,0x15f2,
       
   438 	0x15f3,0x15f4,0x15f5,0x15f6,0x15f7,0x15f8,0x15f9,0x15fa,0x15fb,0x15fc,
       
   439 	0x15fd,0x15fe,0x15ff,0x1600,0x1601,0x1602,0x1603,0x1604,0x1605,0x1606,
       
   440 	0x1607,0x1608,0x1609,0x160a,0x160b,0x160c,0x160d,0x160e,0x160f,0x1610,
       
   441 	0x1611,0x1612,0x1613,0x1614,0x1615,0x1616,0x1617,0x1618,0x1619,0x161a,
       
   442 	0x161b,0x161c,0x161d,0x161e,0x161f,0x1620,0x1621,0x1622,0x1623,0x1624,
       
   443 	0x1625,0x1626,0x1627,0x1628,0x1629,0x162a,0x162b,0x162c,0x162d,0x162e,
       
   444 	0x162f,0x1630,0x1631,0x1632,0x1633,0x1634,0x1635,0x1636,0x1637,0x1638,
       
   445 	0x1639,0x163a,0x163b,0x163c,0x163d,0x163e,0x163f,0x1640,0x1641,0x1642,
       
   446 	0x1643,0x1644,0x1645,0x1646,0x1647,0x1648,0x1649,0x164a,0x164b,0x164c,
       
   447 	0x164d,0x164e,0x164f,0x1650,0x1651,0x1652,0x1653,0x1654,0x1655,0x1656,
       
   448 	0x1657,0x1658,0x1659,0x165a,0x165b,0x165c,0x165d,0x165e,0x165f,0x1660,
       
   449 	0x1661,0x1662,0x1663,0x1664,0x1665,0x1666,0x1667,0x1668,0x1669,0x166a,
       
   450 	0x166b,0x166c,0x166d,0x166e,0x166f,0x1670,0x1671,0x1672,0x1673,0x1674,
       
   451 	0x1675,0x1676,0x1681,0x1682,0x1683,0x1684,0x1685,0x1686,0x1687,0x1688,
       
   452 	0x1689,0x168a,0x168b,0x168c,0x168d,0x168e,0x168f,0x1690,0x1691,0x1692,
       
   453 	0x1693,0x1694,0x1695,0x1696,0x1697,0x1698,0x1699,0x169a,0x16a0,0x16a1,
       
   454 	0x16a2,0x16a3,0x16a4,0x16a5,0x16a6,0x16a7,0x16a8,0x16a9,0x16aa,0x16ab,
       
   455 	0x16ac,0x16ad,0x16ae,0x16af,0x16b0,0x16b1,0x16b2,0x16b3,0x16b4,0x16b5,
       
   456 	0x16b6,0x16b7,0x16b8,0x16b9,0x16ba,0x16bb,0x16bc,0x16bd,0x16be,0x16bf,
       
   457 	0x16c0,0x16c1,0x16c2,0x16c3,0x16c4,0x16c5,0x16c6,0x16c7,0x16c8,0x16c9,
       
   458 	0x16ca,0x16cb,0x16cc,0x16cd,0x16ce,0x16cf,0x16d0,0x16d1,0x16d2,0x16d3,
       
   459 	0x16d4,0x16d5,0x16d6,0x16d7,0x16d8,0x16d9,0x16da,0x16db,0x16dc,0x16dd,
       
   460 	0x16de,0x16df,0x16e0,0x16e1,0x16e2,0x16e3,0x16e4,0x16e5,0x16e6,0x16e7,
       
   461 	0x16e8,0x16e9,0x16ea,0x16eb,0x16ec,0x16ed,0x16ee,0x16ef,0x16f0,0x1700,
       
   462 	0x1701,0x1702,0x1703,0x1704,0x1705,0x1706,0x1707,0x1708,0x1709,0x170a,
       
   463 	0x170b,0x170c,0x170e,0x170f,0x1710,0x1711,0x1720,0x1721,0x1722,0x1723,
       
   464 	0x1724,0x1725,0x1726,0x1727,0x1728,0x1729,0x172a,0x172b,0x172c,0x172d,
       
   465 	0x172e,0x172f,0x1730,0x1731,0x1735,0x1736,0x1740,0x1741,0x1742,0x1743,
       
   466 	0x1744,0x1745,0x1746,0x1747,0x1748,0x1749,0x174a,0x174b,0x174c,0x174d,
       
   467 	0x174e,0x174f,0x1750,0x1751,0x1760,0x1761,0x1762,0x1763,0x1764,0x1765,
       
   468 	0x1766,0x1767,0x1768,0x1769,0x176a,0x176b,0x176c,0x176e,0x176f,0x1770,
       
   469 	0x1780,0x1781,0x1782,0x1783,0x1784,0x1785,0x1786,0x1787,0x1788,0x1789,
       
   470 	0x178a,0x178b,0x178c,0x178d,0x178e,0x178f,0x1790,0x1791,0x1792,0x1793,
       
   471 	0x1794,0x1795,0x1796,0x1797,0x1798,0x1799,0x179a,0x179b,0x179c,0x179d,
       
   472 	0x179e,0x179f,0x17a0,0x17a1,0x17a2,0x17a3,0x17a4,0x17a5,0x17a6,0x17a7,
       
   473 	0x17a8,0x17a9,0x17aa,0x17ab,0x17ac,0x17ad,0x17ae,0x17af,0x17b0,0x17b1,
       
   474 	0x17b2,0x17b3,0x17b4,0x17b5,0x17d4,0x17d5,0x17d6,0x17d7,0x17d8,0x17d9,
       
   475 	0x17da,0x17dc,0x17e0,0x17e1,0x17e2,0x17e3,0x17e4,0x17e5,0x17e6,0x17e7,
       
   476 	0x17e8,0x17e9,0x1810,0x1811,0x1812,0x1813,0x1814,0x1815,0x1816,0x1817,
       
   477 	0x1818,0x1819,0x1820,0x1821,0x1822,0x1823,0x1824,0x1825,0x1826,0x1827,
       
   478 	0x1828,0x1829,0x182a,0x182b,0x182c,0x182d,0x182e,0x182f,0x1830,0x1831,
       
   479 	0x1832,0x1833,0x1834,0x1835,0x1836,0x1837,0x1838,0x1839,0x183a,0x183b,
       
   480 	0x183c,0x183d,0x183e,0x183f,0x1840,0x1841,0x1842,0x1843,0x1844,0x1845,
       
   481 	0x1846,0x1847,0x1848,0x1849,0x184a,0x184b,0x184c,0x184d,0x184e,0x184f,
       
   482 	0x1850,0x1851,0x1852,0x1853,0x1854,0x1855,0x1856,0x1857,0x1858,0x1859,
       
   483 	0x185a,0x185b,0x185c,0x185d,0x185e,0x185f,0x1860,0x1861,0x1862,0x1863,
       
   484 	0x1864,0x1865,0x1866,0x1867,0x1868,0x1869,0x186a,0x186b,0x186c,0x186d,
       
   485 	0x186e,0x186f,0x1870,0x1871,0x1872,0x1873,0x1874,0x1875,0x1876,0x1877,
       
   486 	0x1880,0x1881,0x1882,0x1883,0x1884,0x1885,0x1886,0x1887,0x1888,0x1889,
       
   487 	0x188a,0x188b,0x188c,0x188d,0x188e,0x188f,0x1890,0x1891,0x1892,0x1893,
       
   488 	0x1894,0x1895,0x1896,0x1897,0x1898,0x1899,0x189a,0x189b,0x189c,0x189d,
       
   489 	0x189e,0x189f,0x18a0,0x18a1,0x18a2,0x18a3,0x18a4,0x18a5,0x18a6,0x18a7,
       
   490 	0x18a8,0x1900,0x1901,0x1902,0x1903,0x1904,0x1905,0x1906,0x1907,0x1908,
       
   491 	0x1909,0x190a,0x190b,0x190c,0x190d,0x190e,0x190f,0x1910,0x1911,0x1912,
       
   492 	0x1913,0x1914,0x1915,0x1916,0x1917,0x1918,0x1919,0x191a,0x191b,0x191c,
       
   493 	0x1946,0x1947,0x1948,0x1949,0x194a,0x194b,0x194c,0x194d,0x194e,0x194f,
       
   494 	0x1950,0x1951,0x1952,0x1953,0x1954,0x1955,0x1956,0x1957,0x1958,0x1959,
       
   495 	0x195a,0x195b,0x195c,0x195d,0x195e,0x195f,0x1960,0x1961,0x1962,0x1963,
       
   496 	0x1964,0x1965,0x1966,0x1967,0x1968,0x1969,0x196a,0x196b,0x196c,0x196d,
       
   497 	0x1970,0x1971,0x1972,0x1973,0x1974,0x1980,0x1981,0x1982,0x1983,0x1984,
       
   498 	0x1985,0x1986,0x1987,0x1988,0x1989,0x198a,0x198b,0x198c,0x198d,0x198e,
       
   499 	0x198f,0x1990,0x1991,0x1992,0x1993,0x1994,0x1995,0x1996,0x1997,0x1998,
       
   500 	0x1999,0x199a,0x199b,0x199c,0x199d,0x199e,0x199f,0x19a0,0x19a1,0x19a2,
       
   501 	0x19a3,0x19a4,0x19a5,0x19a6,0x19a7,0x19a8,0x19a9,0x19c1,0x19c2,0x19c3,
       
   502 	0x19c4,0x19c5,0x19c6,0x19c7,0x19d0,0x19d1,0x19d2,0x19d3,0x19d4,0x19d5,
       
   503 	0x19d6,0x19d7,0x19d8,0x19d9,0x1a00,0x1a01,0x1a02,0x1a03,0x1a04,0x1a05,
       
   504 	0x1a06,0x1a07,0x1a08,0x1a09,0x1a0a,0x1a0b,0x1a0c,0x1a0d,0x1a0e,0x1a0f,
       
   505 	0x1a10,0x1a11,0x1a12,0x1a13,0x1a14,0x1a15,0x1a16,0x1a1e,0x1a1f,0x1b05,
       
   506 	0x1b06,0x1b07,0x1b08,0x1b09,0x1b0a,0x1b0b,0x1b0c,0x1b0d,0x1b0e,0x1b0f,
       
   507 	0x1b10,0x1b11,0x1b12,0x1b13,0x1b14,0x1b15,0x1b16,0x1b17,0x1b18,0x1b19,
       
   508 	0x1b1a,0x1b1b,0x1b1c,0x1b1d,0x1b1e,0x1b1f,0x1b20,0x1b21,0x1b22,0x1b23,
       
   509 	0x1b24,0x1b25,0x1b26,0x1b27,0x1b28,0x1b29,0x1b2a,0x1b2b,0x1b2c,0x1b2d,
       
   510 	0x1b2e,0x1b2f,0x1b30,0x1b31,0x1b32,0x1b33,0x1b45,0x1b46,0x1b47,0x1b48,
       
   511 	0x1b49,0x1b4a,0x1b4b,0x1b50,0x1b51,0x1b52,0x1b53,0x1b54,0x1b55,0x1b56,
       
   512 	0x1b57,0x1b58,0x1b59,0x1b5a,0x1b5b,0x1b5c,0x1b5d,0x1b5e,0x1b5f,0x1b60,
       
   513 	0x1b61,0x1b62,0x1b63,0x1b64,0x1b65,0x1b66,0x1b67,0x1b68,0x1b69,0x1b6a,
       
   514 	0x1b74,0x1b75,0x1b76,0x1b77,0x1b78,0x1b79,0x1b7a,0x1b7b,0x1b7c,0x1d00,
       
   515 	0x1d01,0x1d02,0x1d03,0x1d04,0x1d05,0x1d06,0x1d07,0x1d08,0x1d09,0x1d0a,
       
   516 	0x1d0b,0x1d0c,0x1d0d,0x1d0e,0x1d0f,0x1d10,0x1d11,0x1d12,0x1d13,0x1d14,
       
   517 	0x1d15,0x1d16,0x1d17,0x1d18,0x1d19,0x1d1a,0x1d1b,0x1d1c,0x1d1d,0x1d1e,
       
   518 	0x1d1f,0x1d20,0x1d21,0x1d22,0x1d23,0x1d24,0x1d25,0x1d26,0x1d27,0x1d28,
       
   519 	0x1d29,0x1d2a,0x1d2b,0x1d2c,0x1d2d,0x1d2e,0x1d2f,0x1d30,0x1d31,0x1d32,
       
   520 	0x1d33,0x1d34,0x1d35,0x1d36,0x1d37,0x1d38,0x1d39,0x1d3a,0x1d3b,0x1d3c,
       
   521 	0x1d3d,0x1d3e,0x1d3f,0x1d40,0x1d41,0x1d42,0x1d43,0x1d44,0x1d45,0x1d46,
       
   522 	0x1d47,0x1d48,0x1d49,0x1d4a,0x1d4b,0x1d4c,0x1d4d,0x1d4e,0x1d4f,0x1d50,
       
   523 	0x1d51,0x1d52,0x1d53,0x1d54,0x1d55,0x1d56,0x1d57,0x1d58,0x1d59,0x1d5a,
       
   524 	0x1d5b,0x1d5c,0x1d5d,0x1d5e,0x1d5f,0x1d60,0x1d61,0x1d62,0x1d63,0x1d64,
       
   525 	0x1d65,0x1d66,0x1d67,0x1d68,0x1d69,0x1d6a,0x1d6b,0x1d6c,0x1d6d,0x1d6e,
       
   526 	0x1d6f,0x1d70,0x1d71,0x1d72,0x1d73,0x1d74,0x1d75,0x1d76,0x1d77,0x1d78,
       
   527 	0x1d79,0x1d7a,0x1d7b,0x1d7c,0x1d7d,0x1d7e,0x1d7f,0x1d80,0x1d81,0x1d82,
       
   528 	0x1d83,0x1d84,0x1d85,0x1d86,0x1d87,0x1d88,0x1d89,0x1d8a,0x1d8b,0x1d8c,
       
   529 	0x1d8d,0x1d8e,0x1d8f,0x1d90,0x1d91,0x1d92,0x1d93,0x1d94,0x1d95,0x1d96,
       
   530 	0x1d97,0x1d98,0x1d99,0x1d9a,0x1d9b,0x1d9c,0x1d9d,0x1d9e,0x1d9f,0x1da0,
       
   531 	0x1da1,0x1da2,0x1da3,0x1da4,0x1da5,0x1da6,0x1da7,0x1da8,0x1da9,0x1daa,
       
   532 	0x1dab,0x1dac,0x1dad,0x1dae,0x1daf,0x1db0,0x1db1,0x1db2,0x1db3,0x1db4,
       
   533 	0x1db5,0x1db6,0x1db7,0x1db8,0x1db9,0x1dba,0x1dbb,0x1dbc,0x1dbd,0x1dbe,
       
   534 	0x1dbf,0x1e00,0x1e01,0x1e02,0x1e03,0x1e04,0x1e05,0x1e06,0x1e07,0x1e08,
       
   535 	0x1e09,0x1e0a,0x1e0b,0x1e0c,0x1e0d,0x1e0e,0x1e0f,0x1e10,0x1e11,0x1e12,
       
   536 	0x1e13,0x1e14,0x1e15,0x1e16,0x1e17,0x1e18,0x1e19,0x1e1a,0x1e1b,0x1e1c,
       
   537 	0x1e1d,0x1e1e,0x1e1f,0x1e20,0x1e21,0x1e22,0x1e23,0x1e24,0x1e25,0x1e26,
       
   538 	0x1e27,0x1e28,0x1e29,0x1e2a,0x1e2b,0x1e2c,0x1e2d,0x1e2e,0x1e2f,0x1e30,
       
   539 	0x1e31,0x1e32,0x1e33,0x1e34,0x1e35,0x1e36,0x1e37,0x1e38,0x1e39,0x1e3a,
       
   540 	0x1e3b,0x1e3c,0x1e3d,0x1e3e,0x1e3f,0x1e40,0x1e41,0x1e42,0x1e43,0x1e44,
       
   541 	0x1e45,0x1e46,0x1e47,0x1e48,0x1e49,0x1e4a,0x1e4b,0x1e4c,0x1e4d,0x1e4e,
       
   542 	0x1e4f,0x1e50,0x1e51,0x1e52,0x1e53,0x1e54,0x1e55,0x1e56,0x1e57,0x1e58,
       
   543 	0x1e59,0x1e5a,0x1e5b,0x1e5c,0x1e5d,0x1e5e,0x1e5f,0x1e60,0x1e61,0x1e62,
       
   544 	0x1e63,0x1e64,0x1e65,0x1e66,0x1e67,0x1e68,0x1e69,0x1e6a,0x1e6b,0x1e6c,
       
   545 	0x1e6d,0x1e6e,0x1e6f,0x1e70,0x1e71,0x1e72,0x1e73,0x1e74,0x1e75,0x1e76,
       
   546 	0x1e77,0x1e78,0x1e79,0x1e7a,0x1e7b,0x1e7c,0x1e7d,0x1e7e,0x1e7f,0x1e80,
       
   547 	0x1e81,0x1e82,0x1e83,0x1e84,0x1e85,0x1e86,0x1e87,0x1e88,0x1e89,0x1e8a,
       
   548 	0x1e8b,0x1e8c,0x1e8d,0x1e8e,0x1e8f,0x1e90,0x1e91,0x1e92,0x1e93,0x1e94,
       
   549 	0x1e95,0x1e96,0x1e97,0x1e98,0x1e99,0x1e9a,0x1e9b,0x1ea0,0x1ea1,0x1ea2,
       
   550 	0x1ea3,0x1ea4,0x1ea5,0x1ea6,0x1ea7,0x1ea8,0x1ea9,0x1eaa,0x1eab,0x1eac,
       
   551 	0x1ead,0x1eae,0x1eaf,0x1eb0,0x1eb1,0x1eb2,0x1eb3,0x1eb4,0x1eb5,0x1eb6,
       
   552 	0x1eb7,0x1eb8,0x1eb9,0x1eba,0x1ebb,0x1ebc,0x1ebd,0x1ebe,0x1ebf,0x1ec0,
       
   553 	0x1ec1,0x1ec2,0x1ec3,0x1ec4,0x1ec5,0x1ec6,0x1ec7,0x1ec8,0x1ec9,0x1eca,
       
   554 	0x1ecb,0x1ecc,0x1ecd,0x1ece,0x1ecf,0x1ed0,0x1ed1,0x1ed2,0x1ed3,0x1ed4,
       
   555 	0x1ed5,0x1ed6,0x1ed7,0x1ed8,0x1ed9,0x1eda,0x1edb,0x1edc,0x1edd,0x1ede,
       
   556 	0x1edf,0x1ee0,0x1ee1,0x1ee2,0x1ee3,0x1ee4,0x1ee5,0x1ee6,0x1ee7,0x1ee8,
       
   557 	0x1ee9,0x1eea,0x1eeb,0x1eec,0x1eed,0x1eee,0x1eef,0x1ef0,0x1ef1,0x1ef2,
       
   558 	0x1ef3,0x1ef4,0x1ef5,0x1ef6,0x1ef7,0x1ef8,0x1ef9,0x1f00,0x1f01,0x1f02,
       
   559 	0x1f03,0x1f04,0x1f05,0x1f06,0x1f07,0x1f08,0x1f09,0x1f0a,0x1f0b,0x1f0c,
       
   560 	0x1f0d,0x1f0e,0x1f0f,0x1f10,0x1f11,0x1f12,0x1f13,0x1f14,0x1f15,0x1f18,
       
   561 	0x1f19,0x1f1a,0x1f1b,0x1f1c,0x1f1d,0x1f20,0x1f21,0x1f22,0x1f23,0x1f24,
       
   562 	0x1f25,0x1f26,0x1f27,0x1f28,0x1f29,0x1f2a,0x1f2b,0x1f2c,0x1f2d,0x1f2e,
       
   563 	0x1f2f,0x1f30,0x1f31,0x1f32,0x1f33,0x1f34,0x1f35,0x1f36,0x1f37,0x1f38,
       
   564 	0x1f39,0x1f3a,0x1f3b,0x1f3c,0x1f3d,0x1f3e,0x1f3f,0x1f40,0x1f41,0x1f42,
       
   565 	0x1f43,0x1f44,0x1f45,0x1f48,0x1f49,0x1f4a,0x1f4b,0x1f4c,0x1f4d,0x1f50,
       
   566 	0x1f51,0x1f52,0x1f53,0x1f54,0x1f55,0x1f56,0x1f57,0x1f59,0x1f5b,0x1f5d,
       
   567 	0x1f5f,0x1f60,0x1f61,0x1f62,0x1f63,0x1f64,0x1f65,0x1f66,0x1f67,0x1f68,
       
   568 	0x1f69,0x1f6a,0x1f6b,0x1f6c,0x1f6d,0x1f6e,0x1f6f,0x1f70,0x1f71,0x1f72,
       
   569 	0x1f73,0x1f74,0x1f75,0x1f76,0x1f77,0x1f78,0x1f79,0x1f7a,0x1f7b,0x1f7c,
       
   570 	0x1f7d,0x1f80,0x1f81,0x1f82,0x1f83,0x1f84,0x1f85,0x1f86,0x1f87,0x1f88,
       
   571 	0x1f89,0x1f8a,0x1f8b,0x1f8c,0x1f8d,0x1f8e,0x1f8f,0x1f90,0x1f91,0x1f92,
       
   572 	0x1f93,0x1f94,0x1f95,0x1f96,0x1f97,0x1f98,0x1f99,0x1f9a,0x1f9b,0x1f9c,
       
   573 	0x1f9d,0x1f9e,0x1f9f,0x1fa0,0x1fa1,0x1fa2,0x1fa3,0x1fa4,0x1fa5,0x1fa6,
       
   574 	0x1fa7,0x1fa8,0x1fa9,0x1faa,0x1fab,0x1fac,0x1fad,0x1fae,0x1faf,0x1fb0,
       
   575 	0x1fb1,0x1fb2,0x1fb3,0x1fb4,0x1fb6,0x1fb7,0x1fb8,0x1fb9,0x1fba,0x1fbb,
       
   576 	0x1fbc,0x1fbe,0x1fc2,0x1fc3,0x1fc4,0x1fc6,0x1fc7,0x1fc8,0x1fc9,0x1fca,
       
   577 	0x1fcb,0x1fcc,0x1fd0,0x1fd1,0x1fd2,0x1fd3,0x1fd6,0x1fd7,0x1fd8,0x1fd9,
       
   578 	0x1fda,0x1fdb,0x1fe0,0x1fe1,0x1fe2,0x1fe3,0x1fe4,0x1fe5,0x1fe6,0x1fe7,
       
   579 	0x1fe8,0x1fe9,0x1fea,0x1feb,0x1fec,0x1ff2,0x1ff3,0x1ff4,0x1ff6,0x1ff7,
       
   580 	0x1ff8,0x1ff9,0x1ffa,0x1ffb,0x1ffc,0x200e,0x2071,0x207f,0x2090,0x2091,
       
   581 	0x2092,0x2093,0x2094,0x2102,0x2107,0x210a,0x210b,0x210c,0x210d,0x210e,
       
   582 	0x210f,0x2110,0x2111,0x2112,0x2113,0x2115,0x2119,0x211a,0x211b,0x211c,
       
   583 	0x211d,0x2124,0x2126,0x2128,0x212a,0x212b,0x212c,0x212d,0x212f,0x2130,
       
   584 	0x2131,0x2132,0x2133,0x2134,0x2135,0x2136,0x2137,0x2138,0x2139,0x213c,
       
   585 	0x213d,0x213e,0x213f,0x2145,0x2146,0x2147,0x2148,0x2149,0x214e,0x2160,
       
   586 	0x2161,0x2162,0x2163,0x2164,0x2165,0x2166,0x2167,0x2168,0x2169,0x216a,
       
   587 	0x216b,0x216c,0x216d,0x216e,0x216f,0x2170,0x2171,0x2172,0x2173,0x2174,
       
   588 	0x2175,0x2176,0x2177,0x2178,0x2179,0x217a,0x217b,0x217c,0x217d,0x217e,
       
   589 	0x217f,0x2180,0x2181,0x2182,0x2183,0x2184,0x2336,0x2337,0x2338,0x2339,
       
   590 	0x233a,0x233b,0x233c,0x233d,0x233e,0x233f,0x2340,0x2341,0x2342,0x2343,
       
   591 	0x2344,0x2345,0x2346,0x2347,0x2348,0x2349,0x234a,0x234b,0x234c,0x234d,
       
   592 	0x234e,0x234f,0x2350,0x2351,0x2352,0x2353,0x2354,0x2355,0x2356,0x2357,
       
   593 	0x2358,0x2359,0x235a,0x235b,0x235c,0x235d,0x235e,0x235f,0x2360,0x2361,
       
   594 	0x2362,0x2363,0x2364,0x2365,0x2366,0x2367,0x2368,0x2369,0x236a,0x236b,
       
   595 	0x236c,0x236d,0x236e,0x236f,0x2370,0x2371,0x2372,0x2373,0x2374,0x2375,
       
   596 	0x2376,0x2377,0x2378,0x2379,0x237a,0x2395,0x249c,0x249d,0x249e,0x249f,
       
   597 	0x24a0,0x24a1,0x24a2,0x24a3,0x24a4,0x24a5,0x24a6,0x24a7,0x24a8,0x24a9,
       
   598 	0x24aa,0x24ab,0x24ac,0x24ad,0x24ae,0x24af,0x24b0,0x24b1,0x24b2,0x24b3,
       
   599 	0x24b4,0x24b5,0x24b6,0x24b7,0x24b8,0x24b9,0x24ba,0x24bb,0x24bc,0x24bd,
       
   600 	0x24be,0x24bf,0x24c0,0x24c1,0x24c2,0x24c3,0x24c4,0x24c5,0x24c6,0x24c7,
       
   601 	0x24c8,0x24c9,0x24ca,0x24cb,0x24cc,0x24cd,0x24ce,0x24cf,0x24d0,0x24d1,
       
   602 	0x24d2,0x24d3,0x24d4,0x24d5,0x24d6,0x24d7,0x24d8,0x24d9,0x24da,0x24db,
       
   603 	0x24dc,0x24dd,0x24de,0x24df,0x24e0,0x24e1,0x24e2,0x24e3,0x24e4,0x24e5,
       
   604 	0x24e6,0x24e7,0x24e8,0x24e9,0x26ac,0x2800,0x2801,0x2802,0x2803,0x2804,
       
   605 	0x2805,0x2806,0x2807,0x2808,0x2809,0x280a,0x280b,0x280c,0x280d,0x280e,
       
   606 	0x280f,0x2810,0x2811,0x2812,0x2813,0x2814,0x2815,0x2816,0x2817,0x2818,
       
   607 	0x2819,0x281a,0x281b,0x281c,0x281d,0x281e,0x281f,0x2820,0x2821,0x2822,
       
   608 	0x2823,0x2824,0x2825,0x2826,0x2827,0x2828,0x2829,0x282a,0x282b,0x282c,
       
   609 	0x282d,0x282e,0x282f,0x2830,0x2831,0x2832,0x2833,0x2834,0x2835,0x2836,
       
   610 	0x2837,0x2838,0x2839,0x283a,0x283b,0x283c,0x283d,0x283e,0x283f,0x2840,
       
   611 	0x2841,0x2842,0x2843,0x2844,0x2845,0x2846,0x2847,0x2848,0x2849,0x284a,
       
   612 	0x284b,0x284c,0x284d,0x284e,0x284f,0x2850,0x2851,0x2852,0x2853,0x2854,
       
   613 	0x2855,0x2856,0x2857,0x2858,0x2859,0x285a,0x285b,0x285c,0x285d,0x285e,
       
   614 	0x285f,0x2860,0x2861,0x2862,0x2863,0x2864,0x2865,0x2866,0x2867,0x2868,
       
   615 	0x2869,0x286a,0x286b,0x286c,0x286d,0x286e,0x286f,0x2870,0x2871,0x2872,
       
   616 	0x2873,0x2874,0x2875,0x2876,0x2877,0x2878,0x2879,0x287a,0x287b,0x287c,
       
   617 	0x287d,0x287e,0x287f,0x2880,0x2881,0x2882,0x2883,0x2884,0x2885,0x2886,
       
   618 	0x2887,0x2888,0x2889,0x288a,0x288b,0x288c,0x288d,0x288e,0x288f,0x2890,
       
   619 	0x2891,0x2892,0x2893,0x2894,0x2895,0x2896,0x2897,0x2898,0x2899,0x289a,
       
   620 	0x289b,0x289c,0x289d,0x289e,0x289f,0x28a0,0x28a1,0x28a2,0x28a3,0x28a4,
       
   621 	0x28a5,0x28a6,0x28a7,0x28a8,0x28a9,0x28aa,0x28ab,0x28ac,0x28ad,0x28ae,
       
   622 	0x28af,0x28b0,0x28b1,0x28b2,0x28b3,0x28b4,0x28b5,0x28b6,0x28b7,0x28b8,
       
   623 	0x28b9,0x28ba,0x28bb,0x28bc,0x28bd,0x28be,0x28bf,0x28c0,0x28c1,0x28c2,
       
   624 	0x28c3,0x28c4,0x28c5,0x28c6,0x28c7,0x28c8,0x28c9,0x28ca,0x28cb,0x28cc,
       
   625 	0x28cd,0x28ce,0x28cf,0x28d0,0x28d1,0x28d2,0x28d3,0x28d4,0x28d5,0x28d6,
       
   626 	0x28d7,0x28d8,0x28d9,0x28da,0x28db,0x28dc,0x28dd,0x28de,0x28df,0x28e0,
       
   627 	0x28e1,0x28e2,0x28e3,0x28e4,0x28e5,0x28e6,0x28e7,0x28e8,0x28e9,0x28ea,
       
   628 	0x28eb,0x28ec,0x28ed,0x28ee,0x28ef,0x28f0,0x28f1,0x28f2,0x28f3,0x28f4,
       
   629 	0x28f5,0x28f6,0x28f7,0x28f8,0x28f9,0x28fa,0x28fb,0x28fc,0x28fd,0x28fe,
       
   630 	0x28ff,0x2c00,0x2c01,0x2c02,0x2c03,0x2c04,0x2c05,0x2c06,0x2c07,0x2c08,
       
   631 	0x2c09,0x2c0a,0x2c0b,0x2c0c,0x2c0d,0x2c0e,0x2c0f,0x2c10,0x2c11,0x2c12,
       
   632 	0x2c13,0x2c14,0x2c15,0x2c16,0x2c17,0x2c18,0x2c19,0x2c1a,0x2c1b,0x2c1c,
       
   633 	0x2c1d,0x2c1e,0x2c1f,0x2c20,0x2c21,0x2c22,0x2c23,0x2c24,0x2c25,0x2c26,
       
   634 	0x2c27,0x2c28,0x2c29,0x2c2a,0x2c2b,0x2c2c,0x2c2d,0x2c2e,0x2c30,0x2c31,
       
   635 	0x2c32,0x2c33,0x2c34,0x2c35,0x2c36,0x2c37,0x2c38,0x2c39,0x2c3a,0x2c3b,
       
   636 	0x2c3c,0x2c3d,0x2c3e,0x2c3f,0x2c40,0x2c41,0x2c42,0x2c43,0x2c44,0x2c45,
       
   637 	0x2c46,0x2c47,0x2c48,0x2c49,0x2c4a,0x2c4b,0x2c4c,0x2c4d,0x2c4e,0x2c4f,
       
   638 	0x2c50,0x2c51,0x2c52,0x2c53,0x2c54,0x2c55,0x2c56,0x2c57,0x2c58,0x2c59,
       
   639 	0x2c5a,0x2c5b,0x2c5c,0x2c5d,0x2c5e,0x2c60,0x2c61,0x2c62,0x2c63,0x2c64,
       
   640 	0x2c65,0x2c66,0x2c67,0x2c68,0x2c69,0x2c6a,0x2c6b,0x2c6c,0x2c74,0x2c75,
       
   641 	0x2c76,0x2c77,0x2c80,0x2c81,0x2c82,0x2c83,0x2c84,0x2c85,0x2c86,0x2c87,
       
   642 	0x2c88,0x2c89,0x2c8a,0x2c8b,0x2c8c,0x2c8d,0x2c8e,0x2c8f,0x2c90,0x2c91,
       
   643 	0x2c92,0x2c93,0x2c94,0x2c95,0x2c96,0x2c97,0x2c98,0x2c99,0x2c9a,0x2c9b,
       
   644 	0x2c9c,0x2c9d,0x2c9e,0x2c9f,0x2ca0,0x2ca1,0x2ca2,0x2ca3,0x2ca4,0x2ca5,
       
   645 	0x2ca6,0x2ca7,0x2ca8,0x2ca9,0x2caa,0x2cab,0x2cac,0x2cad,0x2cae,0x2caf,
       
   646 	0x2cb0,0x2cb1,0x2cb2,0x2cb3,0x2cb4,0x2cb5,0x2cb6,0x2cb7,0x2cb8,0x2cb9,
       
   647 	0x2cba,0x2cbb,0x2cbc,0x2cbd,0x2cbe,0x2cbf,0x2cc0,0x2cc1,0x2cc2,0x2cc3,
       
   648 	0x2cc4,0x2cc5,0x2cc6,0x2cc7,0x2cc8,0x2cc9,0x2cca,0x2ccb,0x2ccc,0x2ccd,
       
   649 	0x2cce,0x2ccf,0x2cd0,0x2cd1,0x2cd2,0x2cd3,0x2cd4,0x2cd5,0x2cd6,0x2cd7,
       
   650 	0x2cd8,0x2cd9,0x2cda,0x2cdb,0x2cdc,0x2cdd,0x2cde,0x2cdf,0x2ce0,0x2ce1,
       
   651 	0x2ce2,0x2ce3,0x2ce4,0x2d00,0x2d01,0x2d02,0x2d03,0x2d04,0x2d05,0x2d06,
       
   652 	0x2d07,0x2d08,0x2d09,0x2d0a,0x2d0b,0x2d0c,0x2d0d,0x2d0e,0x2d0f,0x2d10,
       
   653 	0x2d11,0x2d12,0x2d13,0x2d14,0x2d15,0x2d16,0x2d17,0x2d18,0x2d19,0x2d1a,
       
   654 	0x2d1b,0x2d1c,0x2d1d,0x2d1e,0x2d1f,0x2d20,0x2d21,0x2d22,0x2d23,0x2d24,
       
   655 	0x2d25,0x2d30,0x2d31,0x2d32,0x2d33,0x2d34,0x2d35,0x2d36,0x2d37,0x2d38,
       
   656 	0x2d39,0x2d3a,0x2d3b,0x2d3c,0x2d3d,0x2d3e,0x2d3f,0x2d40,0x2d41,0x2d42,
       
   657 	0x2d43,0x2d44,0x2d45,0x2d46,0x2d47,0x2d48,0x2d49,0x2d4a,0x2d4b,0x2d4c,
       
   658 	0x2d4d,0x2d4e,0x2d4f,0x2d50,0x2d51,0x2d52,0x2d53,0x2d54,0x2d55,0x2d56,
       
   659 	0x2d57,0x2d58,0x2d59,0x2d5a,0x2d5b,0x2d5c,0x2d5d,0x2d5e,0x2d5f,0x2d60,
       
   660 	0x2d61,0x2d62,0x2d63,0x2d64,0x2d65,0x2d6f,0x2d80,0x2d81,0x2d82,0x2d83,
       
   661 	0x2d84,0x2d85,0x2d86,0x2d87,0x2d88,0x2d89,0x2d8a,0x2d8b,0x2d8c,0x2d8d,
       
   662 	0x2d8e,0x2d8f,0x2d90,0x2d91,0x2d92,0x2d93,0x2d94,0x2d95,0x2d96,0x2da0,
       
   663 	0x2da1,0x2da2,0x2da3,0x2da4,0x2da5,0x2da6,0x2da8,0x2da9,0x2daa,0x2dab,
       
   664 	0x2dac,0x2dad,0x2dae,0x2db0,0x2db1,0x2db2,0x2db3,0x2db4,0x2db5,0x2db6,
       
   665 	0x2db8,0x2db9,0x2dba,0x2dbb,0x2dbc,0x2dbd,0x2dbe,0x2dc0,0x2dc1,0x2dc2,
       
   666 	0x2dc3,0x2dc4,0x2dc5,0x2dc6,0x2dc8,0x2dc9,0x2dca,0x2dcb,0x2dcc,0x2dcd,
       
   667 	0x2dce,0x2dd0,0x2dd1,0x2dd2,0x2dd3,0x2dd4,0x2dd5,0x2dd6,0x2dd8,0x2dd9,
       
   668 	0x2dda,0x2ddb,0x2ddc,0x2ddd,0x2dde,0x3005,0x3006,0x3007,0x3021,0x3022,
       
   669 	0x3023,0x3024,0x3025,0x3026,0x3027,0x3028,0x3029,0x3031,0x3032,0x3033,
       
   670 	0x3034,0x3035,0x3038,0x3039,0x303a,0x303b,0x303c,0x3041,0x3042,0x3043,
       
   671 	0x3044,0x3045,0x3046,0x3047,0x3048,0x3049,0x304a,0x304b,0x304c,0x304d,
       
   672 	0x304e,0x304f,0x3050,0x3051,0x3052,0x3053,0x3054,0x3055,0x3056,0x3057,
       
   673 	0x3058,0x3059,0x305a,0x305b,0x305c,0x305d,0x305e,0x305f,0x3060,0x3061,
       
   674 	0x3062,0x3063,0x3064,0x3065,0x3066,0x3067,0x3068,0x3069,0x306a,0x306b,
       
   675 	0x306c,0x306d,0x306e,0x306f,0x3070,0x3071,0x3072,0x3073,0x3074,0x3075,
       
   676 	0x3076,0x3077,0x3078,0x3079,0x307a,0x307b,0x307c,0x307d,0x307e,0x307f,
       
   677 	0x3080,0x3081,0x3082,0x3083,0x3084,0x3085,0x3086,0x3087,0x3088,0x3089,
       
   678 	0x308a,0x308b,0x308c,0x308d,0x308e,0x308f,0x3090,0x3091,0x3092,0x3093,
       
   679 	0x3094,0x3095,0x3096,0x309d,0x309e,0x309f,0x30a1,0x30a2,0x30a3,0x30a4,
       
   680 	0x30a5,0x30a6,0x30a7,0x30a8,0x30a9,0x30aa,0x30ab,0x30ac,0x30ad,0x30ae,
       
   681 	0x30af,0x30b0,0x30b1,0x30b2,0x30b3,0x30b4,0x30b5,0x30b6,0x30b7,0x30b8,
       
   682 	0x30b9,0x30ba,0x30bb,0x30bc,0x30bd,0x30be,0x30bf,0x30c0,0x30c1,0x30c2,
       
   683 	0x30c3,0x30c4,0x30c5,0x30c6,0x30c7,0x30c8,0x30c9,0x30ca,0x30cb,0x30cc,
       
   684 	0x30cd,0x30ce,0x30cf,0x30d0,0x30d1,0x30d2,0x30d3,0x30d4,0x30d5,0x30d6,
       
   685 	0x30d7,0x30d8,0x30d9,0x30da,0x30db,0x30dc,0x30dd,0x30de,0x30df,0x30e0,
       
   686 	0x30e1,0x30e2,0x30e3,0x30e4,0x30e5,0x30e6,0x30e7,0x30e8,0x30e9,0x30ea,
       
   687 	0x30eb,0x30ec,0x30ed,0x30ee,0x30ef,0x30f0,0x30f1,0x30f2,0x30f3,0x30f4,
       
   688 	0x30f5,0x30f6,0x30f7,0x30f8,0x30f9,0x30fa,0x30fc,0x30fd,0x30fe,0x30ff,
       
   689 	0x3105,0x3106,0x3107,0x3108,0x3109,0x310a,0x310b,0x310c,0x310d,0x310e,
       
   690 	0x310f,0x3110,0x3111,0x3112,0x3113,0x3114,0x3115,0x3116,0x3117,0x3118,
       
   691 	0x3119,0x311a,0x311b,0x311c,0x311d,0x311e,0x311f,0x3120,0x3121,0x3122,
       
   692 	0x3123,0x3124,0x3125,0x3126,0x3127,0x3128,0x3129,0x312a,0x312b,0x312c,
       
   693 	0x3131,0x3132,0x3133,0x3134,0x3135,0x3136,0x3137,0x3138,0x3139,0x313a,
       
   694 	0x313b,0x313c,0x313d,0x313e,0x313f,0x3140,0x3141,0x3142,0x3143,0x3144,
       
   695 	0x3145,0x3146,0x3147,0x3148,0x3149,0x314a,0x314b,0x314c,0x314d,0x314e,
       
   696 	0x314f,0x3150,0x3151,0x3152,0x3153,0x3154,0x3155,0x3156,0x3157,0x3158,
       
   697 	0x3159,0x315a,0x315b,0x315c,0x315d,0x315e,0x315f,0x3160,0x3161,0x3162,
       
   698 	0x3163,0x3164,0x3165,0x3166,0x3167,0x3168,0x3169,0x316a,0x316b,0x316c,
       
   699 	0x316d,0x316e,0x316f,0x3170,0x3171,0x3172,0x3173,0x3174,0x3175,0x3176,
       
   700 	0x3177,0x3178,0x3179,0x317a,0x317b,0x317c,0x317d,0x317e,0x317f,0x3180,
       
   701 	0x3181,0x3182,0x3183,0x3184,0x3185,0x3186,0x3187,0x3188,0x3189,0x318a,
       
   702 	0x318b,0x318c,0x318d,0x318e,0x3190,0x3191,0x3192,0x3193,0x3194,0x3195,
       
   703 	0x3196,0x3197,0x3198,0x3199,0x319a,0x319b,0x319c,0x319d,0x319e,0x319f,
       
   704 	0x31a0,0x31a1,0x31a2,0x31a3,0x31a4,0x31a5,0x31a6,0x31a7,0x31a8,0x31a9,
       
   705 	0x31aa,0x31ab,0x31ac,0x31ad,0x31ae,0x31af,0x31b0,0x31b1,0x31b2,0x31b3,
       
   706 	0x31b4,0x31b5,0x31b6,0x31b7,0x31f0,0x31f1,0x31f2,0x31f3,0x31f4,0x31f5,
       
   707 	0x31f6,0x31f7,0x31f8,0x31f9,0x31fa,0x31fb,0x31fc,0x31fd,0x31fe,0x31ff,
       
   708 	0x3200,0x3201,0x3202,0x3203,0x3204,0x3205,0x3206,0x3207,0x3208,0x3209,
       
   709 	0x320a,0x320b,0x320c,0x320d,0x320e,0x320f,0x3210,0x3211,0x3212,0x3213,
       
   710 	0x3214,0x3215,0x3216,0x3217,0x3218,0x3219,0x321a,0x321b,0x321c,0x3220,
       
   711 	0x3221,0x3222,0x3223,0x3224,0x3225,0x3226,0x3227,0x3228,0x3229,0x322a,
       
   712 	0x322b,0x322c,0x322d,0x322e,0x322f,0x3230,0x3231,0x3232,0x3233,0x3234,
       
   713 	0x3235,0x3236,0x3237,0x3238,0x3239,0x323a,0x323b,0x323c,0x323d,0x323e,
       
   714 	0x323f,0x3240,0x3241,0x3242,0x3243,0x3260,0x3261,0x3262,0x3263,0x3264,
       
   715 	0x3265,0x3266,0x3267,0x3268,0x3269,0x326a,0x326b,0x326c,0x326d,0x326e,
       
   716 	0x326f,0x3270,0x3271,0x3272,0x3273,0x3274,0x3275,0x3276,0x3277,0x3278,
       
   717 	0x3279,0x327a,0x327b,0x327f,0x3280,0x3281,0x3282,0x3283,0x3284,0x3285,
       
   718 	0x3286,0x3287,0x3288,0x3289,0x328a,0x328b,0x328c,0x328d,0x328e,0x328f,
       
   719 	0x3290,0x3291,0x3292,0x3293,0x3294,0x3295,0x3296,0x3297,0x3298,0x3299,
       
   720 	0x329a,0x329b,0x329c,0x329d,0x329e,0x329f,0x32a0,0x32a1,0x32a2,0x32a3,
       
   721 	0x32a4,0x32a5,0x32a6,0x32a7,0x32a8,0x32a9,0x32aa,0x32ab,0x32ac,0x32ad,
       
   722 	0x32ae,0x32af,0x32b0,0x32c0,0x32c1,0x32c2,0x32c3,0x32c4,0x32c5,0x32c6,
       
   723 	0x32c7,0x32c8,0x32c9,0x32ca,0x32cb,0x32d0,0x32d1,0x32d2,0x32d3,0x32d4,
       
   724 	0x32d5,0x32d6,0x32d7,0x32d8,0x32d9,0x32da,0x32db,0x32dc,0x32dd,0x32de,
       
   725 	0x32df,0x32e0,0x32e1,0x32e2,0x32e3,0x32e4,0x32e5,0x32e6,0x32e7,0x32e8,
       
   726 	0x32e9,0x32ea,0x32eb,0x32ec,0x32ed,0x32ee,0x32ef,0x32f0,0x32f1,0x32f2,
       
   727 	0x32f3,0x32f4,0x32f5,0x32f6,0x32f7,0x32f8,0x32f9,0x32fa,0x32fb,0x32fc,
       
   728 	0x32fd,0x32fe,0x3300,0x3301,0x3302,0x3303,0x3304,0x3305,0x3306,0x3307,
       
   729 	0x3308,0x3309,0x330a,0x330b,0x330c,0x330d,0x330e,0x330f,0x3310,0x3311,
       
   730 	0x3312,0x3313,0x3314,0x3315,0x3316,0x3317,0x3318,0x3319,0x331a,0x331b,
       
   731 	0x331c,0x331d,0x331e,0x331f,0x3320,0x3321,0x3322,0x3323,0x3324,0x3325,
       
   732 	0x3326,0x3327,0x3328,0x3329,0x332a,0x332b,0x332c,0x332d,0x332e,0x332f,
       
   733 	0x3330,0x3331,0x3332,0x3333,0x3334,0x3335,0x3336,0x3337,0x3338,0x3339,
       
   734 	0x333a,0x333b,0x333c,0x333d,0x333e,0x333f,0x3340,0x3341,0x3342,0x3343,
       
   735 	0x3344,0x3345,0x3346,0x3347,0x3348,0x3349,0x334a,0x334b,0x334c,0x334d,
       
   736 	0x334e,0x334f,0x3350,0x3351,0x3352,0x3353,0x3354,0x3355,0x3356,0x3357,
       
   737 	0x3358,0x3359,0x335a,0x335b,0x335c,0x335d,0x335e,0x335f,0x3360,0x3361,
       
   738 	0x3362,0x3363,0x3364,0x3365,0x3366,0x3367,0x3368,0x3369,0x336a,0x336b,
       
   739 	0x336c,0x336d,0x336e,0x336f,0x3370,0x3371,0x3372,0x3373,0x3374,0x3375,
       
   740 	0x3376,0x337b,0x337c,0x337d,0x337e,0x337f,0x3380,0x3381,0x3382,0x3383,
       
   741 	0x3384,0x3385,0x3386,0x3387,0x3388,0x3389,0x338a,0x338b,0x338c,0x338d,
       
   742 	0x338e,0x338f,0x3390,0x3391,0x3392,0x3393,0x3394,0x3395,0x3396,0x3397,
       
   743 	0x3398,0x3399,0x339a,0x339b,0x339c,0x339d,0x339e,0x339f,0x33a0,0x33a1,
       
   744 	0x33a2,0x33a3,0x33a4,0x33a5,0x33a6,0x33a7,0x33a8,0x33a9,0x33aa,0x33ab,
       
   745 	0x33ac,0x33ad,0x33ae,0x33af,0x33b0,0x33b1,0x33b2,0x33b3,0x33b4,0x33b5,
       
   746 	0x33b6,0x33b7,0x33b8,0x33b9,0x33ba,0x33bb,0x33bc,0x33bd,0x33be,0x33bf,
       
   747 	0x33c0,0x33c1,0x33c2,0x33c3,0x33c4,0x33c5,0x33c6,0x33c7,0x33c8,0x33c9,
       
   748 	0x33ca,0x33cb,0x33cc,0x33cd,0x33ce,0x33cf,0x33d0,0x33d1,0x33d2,0x33d3,
       
   749 	0x33d4,0x33d5,0x33d6,0x33d7,0x33d8,0x33d9,0x33da,0x33db,0x33dc,0x33dd,
       
   750 	0x33e0,0x33e1,0x33e2,0x33e3,0x33e4,0x33e5,0x33e6,0x33e7,0x33e8,0x33e9,
       
   751 	0x33ea,0x33eb,0x33ec,0x33ed,0x33ee,0x33ef,0x33f0,0x33f1,0x33f2,0x33f3,
       
   752 	0x33f4,0x33f5,0x33f6,0x33f7,0x33f8,0x33f9,0x33fa,0x33fb,0x33fc,0x33fd,
       
   753 	0x33fe,0x3400,0x4db5,0x4e00,0x9fbb,0xa000,0xa001,0xa002,0xa003,0xa004,
       
   754 	0xa005,0xa006,0xa007,0xa008,0xa009,0xa00a,0xa00b,0xa00c,0xa00d,0xa00e,
       
   755 	0xa00f,0xa010,0xa011,0xa012,0xa013,0xa014,0xa015,0xa016,0xa017,0xa018,
       
   756 	0xa019,0xa01a,0xa01b,0xa01c,0xa01d,0xa01e,0xa01f,0xa020,0xa021,0xa022,
       
   757 	0xa023,0xa024,0xa025,0xa026,0xa027,0xa028,0xa029,0xa02a,0xa02b,0xa02c,
       
   758 	0xa02d,0xa02e,0xa02f,0xa030,0xa031,0xa032,0xa033,0xa034,0xa035,0xa036,
       
   759 	0xa037,0xa038,0xa039,0xa03a,0xa03b,0xa03c,0xa03d,0xa03e,0xa03f,0xa040,
       
   760 	0xa041,0xa042,0xa043,0xa044,0xa045,0xa046,0xa047,0xa048,0xa049,0xa04a,
       
   761 	0xa04b,0xa04c,0xa04d,0xa04e,0xa04f,0xa050,0xa051,0xa052,0xa053,0xa054,
       
   762 	0xa055,0xa056,0xa057,0xa058,0xa059,0xa05a,0xa05b,0xa05c,0xa05d,0xa05e,
       
   763 	0xa05f,0xa060,0xa061,0xa062,0xa063,0xa064,0xa065,0xa066,0xa067,0xa068,
       
   764 	0xa069,0xa06a,0xa06b,0xa06c,0xa06d,0xa06e,0xa06f,0xa070,0xa071,0xa072,
       
   765 	0xa073,0xa074,0xa075,0xa076,0xa077,0xa078,0xa079,0xa07a,0xa07b,0xa07c,
       
   766 	0xa07d,0xa07e,0xa07f,0xa080,0xa081,0xa082,0xa083,0xa084,0xa085,0xa086,
       
   767 	0xa087,0xa088,0xa089,0xa08a,0xa08b,0xa08c,0xa08d,0xa08e,0xa08f,0xa090,
       
   768 	0xa091,0xa092,0xa093,0xa094,0xa095,0xa096,0xa097,0xa098,0xa099,0xa09a,
       
   769 	0xa09b,0xa09c,0xa09d,0xa09e,0xa09f,0xa0a0,0xa0a1,0xa0a2,0xa0a3,0xa0a4,
       
   770 	0xa0a5,0xa0a6,0xa0a7,0xa0a8,0xa0a9,0xa0aa,0xa0ab,0xa0ac,0xa0ad,0xa0ae,
       
   771 	0xa0af,0xa0b0,0xa0b1,0xa0b2,0xa0b3,0xa0b4,0xa0b5,0xa0b6,0xa0b7,0xa0b8,
       
   772 	0xa0b9,0xa0ba,0xa0bb,0xa0bc,0xa0bd,0xa0be,0xa0bf,0xa0c0,0xa0c1,0xa0c2,
       
   773 	0xa0c3,0xa0c4,0xa0c5,0xa0c6,0xa0c7,0xa0c8,0xa0c9,0xa0ca,0xa0cb,0xa0cc,
       
   774 	0xa0cd,0xa0ce,0xa0cf,0xa0d0,0xa0d1,0xa0d2,0xa0d3,0xa0d4,0xa0d5,0xa0d6,
       
   775 	0xa0d7,0xa0d8,0xa0d9,0xa0da,0xa0db,0xa0dc,0xa0dd,0xa0de,0xa0df,0xa0e0,
       
   776 	0xa0e1,0xa0e2,0xa0e3,0xa0e4,0xa0e5,0xa0e6,0xa0e7,0xa0e8,0xa0e9,0xa0ea,
       
   777 	0xa0eb,0xa0ec,0xa0ed,0xa0ee,0xa0ef,0xa0f0,0xa0f1,0xa0f2,0xa0f3,0xa0f4,
       
   778 	0xa0f5,0xa0f6,0xa0f7,0xa0f8,0xa0f9,0xa0fa,0xa0fb,0xa0fc,0xa0fd,0xa0fe,
       
   779 	0xa0ff,0xa100,0xa101,0xa102,0xa103,0xa104,0xa105,0xa106,0xa107,0xa108,
       
   780 	0xa109,0xa10a,0xa10b,0xa10c,0xa10d,0xa10e,0xa10f,0xa110,0xa111,0xa112,
       
   781 	0xa113,0xa114,0xa115,0xa116,0xa117,0xa118,0xa119,0xa11a,0xa11b,0xa11c,
       
   782 	0xa11d,0xa11e,0xa11f,0xa120,0xa121,0xa122,0xa123,0xa124,0xa125,0xa126,
       
   783 	0xa127,0xa128,0xa129,0xa12a,0xa12b,0xa12c,0xa12d,0xa12e,0xa12f,0xa130,
       
   784 	0xa131,0xa132,0xa133,0xa134,0xa135,0xa136,0xa137,0xa138,0xa139,0xa13a,
       
   785 	0xa13b,0xa13c,0xa13d,0xa13e,0xa13f,0xa140,0xa141,0xa142,0xa143,0xa144,
       
   786 	0xa145,0xa146,0xa147,0xa148,0xa149,0xa14a,0xa14b,0xa14c,0xa14d,0xa14e,
       
   787 	0xa14f,0xa150,0xa151,0xa152,0xa153,0xa154,0xa155,0xa156,0xa157,0xa158,
       
   788 	0xa159,0xa15a,0xa15b,0xa15c,0xa15d,0xa15e,0xa15f,0xa160,0xa161,0xa162,
       
   789 	0xa163,0xa164,0xa165,0xa166,0xa167,0xa168,0xa169,0xa16a,0xa16b,0xa16c,
       
   790 	0xa16d,0xa16e,0xa16f,0xa170,0xa171,0xa172,0xa173,0xa174,0xa175,0xa176,
       
   791 	0xa177,0xa178,0xa179,0xa17a,0xa17b,0xa17c,0xa17d,0xa17e,0xa17f,0xa180,
       
   792 	0xa181,0xa182,0xa183,0xa184,0xa185,0xa186,0xa187,0xa188,0xa189,0xa18a,
       
   793 	0xa18b,0xa18c,0xa18d,0xa18e,0xa18f,0xa190,0xa191,0xa192,0xa193,0xa194,
       
   794 	0xa195,0xa196,0xa197,0xa198,0xa199,0xa19a,0xa19b,0xa19c,0xa19d,0xa19e,
       
   795 	0xa19f,0xa1a0,0xa1a1,0xa1a2,0xa1a3,0xa1a4,0xa1a5,0xa1a6,0xa1a7,0xa1a8,
       
   796 	0xa1a9,0xa1aa,0xa1ab,0xa1ac,0xa1ad,0xa1ae,0xa1af,0xa1b0,0xa1b1,0xa1b2,
       
   797 	0xa1b3,0xa1b4,0xa1b5,0xa1b6,0xa1b7,0xa1b8,0xa1b9,0xa1ba,0xa1bb,0xa1bc,
       
   798 	0xa1bd,0xa1be,0xa1bf,0xa1c0,0xa1c1,0xa1c2,0xa1c3,0xa1c4,0xa1c5,0xa1c6,
       
   799 	0xa1c7,0xa1c8,0xa1c9,0xa1ca,0xa1cb,0xa1cc,0xa1cd,0xa1ce,0xa1cf,0xa1d0,
       
   800 	0xa1d1,0xa1d2,0xa1d3,0xa1d4,0xa1d5,0xa1d6,0xa1d7,0xa1d8,0xa1d9,0xa1da,
       
   801 	0xa1db,0xa1dc,0xa1dd,0xa1de,0xa1df,0xa1e0,0xa1e1,0xa1e2,0xa1e3,0xa1e4,
       
   802 	0xa1e5,0xa1e6,0xa1e7,0xa1e8,0xa1e9,0xa1ea,0xa1eb,0xa1ec,0xa1ed,0xa1ee,
       
   803 	0xa1ef,0xa1f0,0xa1f1,0xa1f2,0xa1f3,0xa1f4,0xa1f5,0xa1f6,0xa1f7,0xa1f8,
       
   804 	0xa1f9,0xa1fa,0xa1fb,0xa1fc,0xa1fd,0xa1fe,0xa1ff,0xa200,0xa201,0xa202,
       
   805 	0xa203,0xa204,0xa205,0xa206,0xa207,0xa208,0xa209,0xa20a,0xa20b,0xa20c,
       
   806 	0xa20d,0xa20e,0xa20f,0xa210,0xa211,0xa212,0xa213,0xa214,0xa215,0xa216,
       
   807 	0xa217,0xa218,0xa219,0xa21a,0xa21b,0xa21c,0xa21d,0xa21e,0xa21f,0xa220,
       
   808 	0xa221,0xa222,0xa223,0xa224,0xa225,0xa226,0xa227,0xa228,0xa229,0xa22a,
       
   809 	0xa22b,0xa22c,0xa22d,0xa22e,0xa22f,0xa230,0xa231,0xa232,0xa233,0xa234,
       
   810 	0xa235,0xa236,0xa237,0xa238,0xa239,0xa23a,0xa23b,0xa23c,0xa23d,0xa23e,
       
   811 	0xa23f,0xa240,0xa241,0xa242,0xa243,0xa244,0xa245,0xa246,0xa247,0xa248,
       
   812 	0xa249,0xa24a,0xa24b,0xa24c,0xa24d,0xa24e,0xa24f,0xa250,0xa251,0xa252,
       
   813 	0xa253,0xa254,0xa255,0xa256,0xa257,0xa258,0xa259,0xa25a,0xa25b,0xa25c,
       
   814 	0xa25d,0xa25e,0xa25f,0xa260,0xa261,0xa262,0xa263,0xa264,0xa265,0xa266,
       
   815 	0xa267,0xa268,0xa269,0xa26a,0xa26b,0xa26c,0xa26d,0xa26e,0xa26f,0xa270,
       
   816 	0xa271,0xa272,0xa273,0xa274,0xa275,0xa276,0xa277,0xa278,0xa279,0xa27a,
       
   817 	0xa27b,0xa27c,0xa27d,0xa27e,0xa27f,0xa280,0xa281,0xa282,0xa283,0xa284,
       
   818 	0xa285,0xa286,0xa287,0xa288,0xa289,0xa28a,0xa28b,0xa28c,0xa28d,0xa28e,
       
   819 	0xa28f,0xa290,0xa291,0xa292,0xa293,0xa294,0xa295,0xa296,0xa297,0xa298,
       
   820 	0xa299,0xa29a,0xa29b,0xa29c,0xa29d,0xa29e,0xa29f,0xa2a0,0xa2a1,0xa2a2,
       
   821 	0xa2a3,0xa2a4,0xa2a5,0xa2a6,0xa2a7,0xa2a8,0xa2a9,0xa2aa,0xa2ab,0xa2ac,
       
   822 	0xa2ad,0xa2ae,0xa2af,0xa2b0,0xa2b1,0xa2b2,0xa2b3,0xa2b4,0xa2b5,0xa2b6,
       
   823 	0xa2b7,0xa2b8,0xa2b9,0xa2ba,0xa2bb,0xa2bc,0xa2bd,0xa2be,0xa2bf,0xa2c0,
       
   824 	0xa2c1,0xa2c2,0xa2c3,0xa2c4,0xa2c5,0xa2c6,0xa2c7,0xa2c8,0xa2c9,0xa2ca,
       
   825 	0xa2cb,0xa2cc,0xa2cd,0xa2ce,0xa2cf,0xa2d0,0xa2d1,0xa2d2,0xa2d3,0xa2d4,
       
   826 	0xa2d5,0xa2d6,0xa2d7,0xa2d8,0xa2d9,0xa2da,0xa2db,0xa2dc,0xa2dd,0xa2de,
       
   827 	0xa2df,0xa2e0,0xa2e1,0xa2e2,0xa2e3,0xa2e4,0xa2e5,0xa2e6,0xa2e7,0xa2e8,
       
   828 	0xa2e9,0xa2ea,0xa2eb,0xa2ec,0xa2ed,0xa2ee,0xa2ef,0xa2f0,0xa2f1,0xa2f2,
       
   829 	0xa2f3,0xa2f4,0xa2f5,0xa2f6,0xa2f7,0xa2f8,0xa2f9,0xa2fa,0xa2fb,0xa2fc,
       
   830 	0xa2fd,0xa2fe,0xa2ff,0xa300,0xa301,0xa302,0xa303,0xa304,0xa305,0xa306,
       
   831 	0xa307,0xa308,0xa309,0xa30a,0xa30b,0xa30c,0xa30d,0xa30e,0xa30f,0xa310,
       
   832 	0xa311,0xa312,0xa313,0xa314,0xa315,0xa316,0xa317,0xa318,0xa319,0xa31a,
       
   833 	0xa31b,0xa31c,0xa31d,0xa31e,0xa31f,0xa320,0xa321,0xa322,0xa323,0xa324,
       
   834 	0xa325,0xa326,0xa327,0xa328,0xa329,0xa32a,0xa32b,0xa32c,0xa32d,0xa32e,
       
   835 	0xa32f,0xa330,0xa331,0xa332,0xa333,0xa334,0xa335,0xa336,0xa337,0xa338,
       
   836 	0xa339,0xa33a,0xa33b,0xa33c,0xa33d,0xa33e,0xa33f,0xa340,0xa341,0xa342,
       
   837 	0xa343,0xa344,0xa345,0xa346,0xa347,0xa348,0xa349,0xa34a,0xa34b,0xa34c,
       
   838 	0xa34d,0xa34e,0xa34f,0xa350,0xa351,0xa352,0xa353,0xa354,0xa355,0xa356,
       
   839 	0xa357,0xa358,0xa359,0xa35a,0xa35b,0xa35c,0xa35d,0xa35e,0xa35f,0xa360,
       
   840 	0xa361,0xa362,0xa363,0xa364,0xa365,0xa366,0xa367,0xa368,0xa369,0xa36a,
       
   841 	0xa36b,0xa36c,0xa36d,0xa36e,0xa36f,0xa370,0xa371,0xa372,0xa373,0xa374,
       
   842 	0xa375,0xa376,0xa377,0xa378,0xa379,0xa37a,0xa37b,0xa37c,0xa37d,0xa37e,
       
   843 	0xa37f,0xa380,0xa381,0xa382,0xa383,0xa384,0xa385,0xa386,0xa387,0xa388,
       
   844 	0xa389,0xa38a,0xa38b,0xa38c,0xa38d,0xa38e,0xa38f,0xa390,0xa391,0xa392,
       
   845 	0xa393,0xa394,0xa395,0xa396,0xa397,0xa398,0xa399,0xa39a,0xa39b,0xa39c,
       
   846 	0xa39d,0xa39e,0xa39f,0xa3a0,0xa3a1,0xa3a2,0xa3a3,0xa3a4,0xa3a5,0xa3a6,
       
   847 	0xa3a7,0xa3a8,0xa3a9,0xa3aa,0xa3ab,0xa3ac,0xa3ad,0xa3ae,0xa3af,0xa3b0,
       
   848 	0xa3b1,0xa3b2,0xa3b3,0xa3b4,0xa3b5,0xa3b6,0xa3b7,0xa3b8,0xa3b9,0xa3ba,
       
   849 	0xa3bb,0xa3bc,0xa3bd,0xa3be,0xa3bf,0xa3c0,0xa3c1,0xa3c2,0xa3c3,0xa3c4,
       
   850 	0xa3c5,0xa3c6,0xa3c7,0xa3c8,0xa3c9,0xa3ca,0xa3cb,0xa3cc,0xa3cd,0xa3ce,
       
   851 	0xa3cf,0xa3d0,0xa3d1,0xa3d2,0xa3d3,0xa3d4,0xa3d5,0xa3d6,0xa3d7,0xa3d8,
       
   852 	0xa3d9,0xa3da,0xa3db,0xa3dc,0xa3dd,0xa3de,0xa3df,0xa3e0,0xa3e1,0xa3e2,
       
   853 	0xa3e3,0xa3e4,0xa3e5,0xa3e6,0xa3e7,0xa3e8,0xa3e9,0xa3ea,0xa3eb,0xa3ec,
       
   854 	0xa3ed,0xa3ee,0xa3ef,0xa3f0,0xa3f1,0xa3f2,0xa3f3,0xa3f4,0xa3f5,0xa3f6,
       
   855 	0xa3f7,0xa3f8,0xa3f9,0xa3fa,0xa3fb,0xa3fc,0xa3fd,0xa3fe,0xa3ff,0xa400,
       
   856 	0xa401,0xa402,0xa403,0xa404,0xa405,0xa406,0xa407,0xa408,0xa409,0xa40a,
       
   857 	0xa40b,0xa40c,0xa40d,0xa40e,0xa40f,0xa410,0xa411,0xa412,0xa413,0xa414,
       
   858 	0xa415,0xa416,0xa417,0xa418,0xa419,0xa41a,0xa41b,0xa41c,0xa41d,0xa41e,
       
   859 	0xa41f,0xa420,0xa421,0xa422,0xa423,0xa424,0xa425,0xa426,0xa427,0xa428,
       
   860 	0xa429,0xa42a,0xa42b,0xa42c,0xa42d,0xa42e,0xa42f,0xa430,0xa431,0xa432,
       
   861 	0xa433,0xa434,0xa435,0xa436,0xa437,0xa438,0xa439,0xa43a,0xa43b,0xa43c,
       
   862 	0xa43d,0xa43e,0xa43f,0xa440,0xa441,0xa442,0xa443,0xa444,0xa445,0xa446,
       
   863 	0xa447,0xa448,0xa449,0xa44a,0xa44b,0xa44c,0xa44d,0xa44e,0xa44f,0xa450,
       
   864 	0xa451,0xa452,0xa453,0xa454,0xa455,0xa456,0xa457,0xa458,0xa459,0xa45a,
       
   865 	0xa45b,0xa45c,0xa45d,0xa45e,0xa45f,0xa460,0xa461,0xa462,0xa463,0xa464,
       
   866 	0xa465,0xa466,0xa467,0xa468,0xa469,0xa46a,0xa46b,0xa46c,0xa46d,0xa46e,
       
   867 	0xa46f,0xa470,0xa471,0xa472,0xa473,0xa474,0xa475,0xa476,0xa477,0xa478,
       
   868 	0xa479,0xa47a,0xa47b,0xa47c,0xa47d,0xa47e,0xa47f,0xa480,0xa481,0xa482,
       
   869 	0xa483,0xa484,0xa485,0xa486,0xa487,0xa488,0xa489,0xa48a,0xa48b,0xa48c,
       
   870 	0xa800,0xa801,0xa803,0xa804,0xa805,0xa807,0xa808,0xa809,0xa80a,0xa80c,
       
   871 	0xa80d,0xa80e,0xa80f,0xa810,0xa811,0xa812,0xa813,0xa814,0xa815,0xa816,
       
   872 	0xa817,0xa818,0xa819,0xa81a,0xa81b,0xa81c,0xa81d,0xa81e,0xa81f,0xa820,
       
   873 	0xa821,0xa822,0xa840,0xa841,0xa842,0xa843,0xa844,0xa845,0xa846,0xa847,
       
   874 	0xa848,0xa849,0xa84a,0xa84b,0xa84c,0xa84d,0xa84e,0xa84f,0xa850,0xa851,
       
   875 	0xa852,0xa853,0xa854,0xa855,0xa856,0xa857,0xa858,0xa859,0xa85a,0xa85b,
       
   876 	0xa85c,0xa85d,0xa85e,0xa85f,0xa860,0xa861,0xa862,0xa863,0xa864,0xa865,
       
   877 	0xa866,0xa867,0xa868,0xa869,0xa86a,0xa86b,0xa86c,0xa86d,0xa86e,0xa86f,
       
   878 	0xa870,0xa871,0xa872,0xa873,0xac00,0xd7a3,0xe000,0xf8ff,0xf900,0xf901,
       
   879 	0xf902,0xf903,0xf904,0xf905,0xf906,0xf907,0xf908,0xf909,0xf90a,0xf90b,
       
   880 	0xf90c,0xf90d,0xf90e,0xf90f,0xf910,0xf911,0xf912,0xf913,0xf914,0xf915,
       
   881 	0xf916,0xf917,0xf918,0xf919,0xf91a,0xf91b,0xf91c,0xf91d,0xf91e,0xf91f,
       
   882 	0xf920,0xf921,0xf922,0xf923,0xf924,0xf925,0xf926,0xf927,0xf928,0xf929,
       
   883 	0xf92a,0xf92b,0xf92c,0xf92d,0xf92e,0xf92f,0xf930,0xf931,0xf932,0xf933,
       
   884 	0xf934,0xf935,0xf936,0xf937,0xf938,0xf939,0xf93a,0xf93b,0xf93c,0xf93d,
       
   885 	0xf93e,0xf93f,0xf940,0xf941,0xf942,0xf943,0xf944,0xf945,0xf946,0xf947,
       
   886 	0xf948,0xf949,0xf94a,0xf94b,0xf94c,0xf94d,0xf94e,0xf94f,0xf950,0xf951,
       
   887 	0xf952,0xf953,0xf954,0xf955,0xf956,0xf957,0xf958,0xf959,0xf95a,0xf95b,
       
   888 	0xf95c,0xf95d,0xf95e,0xf95f,0xf960,0xf961,0xf962,0xf963,0xf964,0xf965,
       
   889 	0xf966,0xf967,0xf968,0xf969,0xf96a,0xf96b,0xf96c,0xf96d,0xf96e,0xf96f,
       
   890 	0xf970,0xf971,0xf972,0xf973,0xf974,0xf975,0xf976,0xf977,0xf978,0xf979,
       
   891 	0xf97a,0xf97b,0xf97c,0xf97d,0xf97e,0xf97f,0xf980,0xf981,0xf982,0xf983,
       
   892 	0xf984,0xf985,0xf986,0xf987,0xf988,0xf989,0xf98a,0xf98b,0xf98c,0xf98d,
       
   893 	0xf98e,0xf98f,0xf990,0xf991,0xf992,0xf993,0xf994,0xf995,0xf996,0xf997,
       
   894 	0xf998,0xf999,0xf99a,0xf99b,0xf99c,0xf99d,0xf99e,0xf99f,0xf9a0,0xf9a1,
       
   895 	0xf9a2,0xf9a3,0xf9a4,0xf9a5,0xf9a6,0xf9a7,0xf9a8,0xf9a9,0xf9aa,0xf9ab,
       
   896 	0xf9ac,0xf9ad,0xf9ae,0xf9af,0xf9b0,0xf9b1,0xf9b2,0xf9b3,0xf9b4,0xf9b5,
       
   897 	0xf9b6,0xf9b7,0xf9b8,0xf9b9,0xf9ba,0xf9bb,0xf9bc,0xf9bd,0xf9be,0xf9bf,
       
   898 	0xf9c0,0xf9c1,0xf9c2,0xf9c3,0xf9c4,0xf9c5,0xf9c6,0xf9c7,0xf9c8,0xf9c9,
       
   899 	0xf9ca,0xf9cb,0xf9cc,0xf9cd,0xf9ce,0xf9cf,0xf9d0,0xf9d1,0xf9d2,0xf9d3,
       
   900 	0xf9d4,0xf9d5,0xf9d6,0xf9d7,0xf9d8,0xf9d9,0xf9da,0xf9db,0xf9dc,0xf9dd,
       
   901 	0xf9de,0xf9df,0xf9e0,0xf9e1,0xf9e2,0xf9e3,0xf9e4,0xf9e5,0xf9e6,0xf9e7,
       
   902 	0xf9e8,0xf9e9,0xf9ea,0xf9eb,0xf9ec,0xf9ed,0xf9ee,0xf9ef,0xf9f0,0xf9f1,
       
   903 	0xf9f2,0xf9f3,0xf9f4,0xf9f5,0xf9f6,0xf9f7,0xf9f8,0xf9f9,0xf9fa,0xf9fb,
       
   904 	0xf9fc,0xf9fd,0xf9fe,0xf9ff,0xfa00,0xfa01,0xfa02,0xfa03,0xfa04,0xfa05,
       
   905 	0xfa06,0xfa07,0xfa08,0xfa09,0xfa0a,0xfa0b,0xfa0c,0xfa0d,0xfa0e,0xfa0f,
       
   906 	0xfa10,0xfa11,0xfa12,0xfa13,0xfa14,0xfa15,0xfa16,0xfa17,0xfa18,0xfa19,
       
   907 	0xfa1a,0xfa1b,0xfa1c,0xfa1d,0xfa1e,0xfa1f,0xfa20,0xfa21,0xfa22,0xfa23,
       
   908 	0xfa24,0xfa25,0xfa26,0xfa27,0xfa28,0xfa29,0xfa2a,0xfa2b,0xfa2c,0xfa2d,
       
   909 	0xfa30,0xfa31,0xfa32,0xfa33,0xfa34,0xfa35,0xfa36,0xfa37,0xfa38,0xfa39,
       
   910 	0xfa3a,0xfa3b,0xfa3c,0xfa3d,0xfa3e,0xfa3f,0xfa40,0xfa41,0xfa42,0xfa43,
       
   911 	0xfa44,0xfa45,0xfa46,0xfa47,0xfa48,0xfa49,0xfa4a,0xfa4b,0xfa4c,0xfa4d,
       
   912 	0xfa4e,0xfa4f,0xfa50,0xfa51,0xfa52,0xfa53,0xfa54,0xfa55,0xfa56,0xfa57,
       
   913 	0xfa58,0xfa59,0xfa5a,0xfa5b,0xfa5c,0xfa5d,0xfa5e,0xfa5f,0xfa60,0xfa61,
       
   914 	0xfa62,0xfa63,0xfa64,0xfa65,0xfa66,0xfa67,0xfa68,0xfa69,0xfa6a,0xfa70,
       
   915 	0xfa71,0xfa72,0xfa73,0xfa74,0xfa75,0xfa76,0xfa77,0xfa78,0xfa79,0xfa7a,
       
   916 	0xfa7b,0xfa7c,0xfa7d,0xfa7e,0xfa7f,0xfa80,0xfa81,0xfa82,0xfa83,0xfa84,
       
   917 	0xfa85,0xfa86,0xfa87,0xfa88,0xfa89,0xfa8a,0xfa8b,0xfa8c,0xfa8d,0xfa8e,
       
   918 	0xfa8f,0xfa90,0xfa91,0xfa92,0xfa93,0xfa94,0xfa95,0xfa96,0xfa97,0xfa98,
       
   919 	0xfa99,0xfa9a,0xfa9b,0xfa9c,0xfa9d,0xfa9e,0xfa9f,0xfaa0,0xfaa1,0xfaa2,
       
   920 	0xfaa3,0xfaa4,0xfaa5,0xfaa6,0xfaa7,0xfaa8,0xfaa9,0xfaaa,0xfaab,0xfaac,
       
   921 	0xfaad,0xfaae,0xfaaf,0xfab0,0xfab1,0xfab2,0xfab3,0xfab4,0xfab5,0xfab6,
       
   922 	0xfab7,0xfab8,0xfab9,0xfaba,0xfabb,0xfabc,0xfabd,0xfabe,0xfabf,0xfac0,
       
   923 	0xfac1,0xfac2,0xfac3,0xfac4,0xfac5,0xfac6,0xfac7,0xfac8,0xfac9,0xfaca,
       
   924 	0xfacb,0xfacc,0xfacd,0xface,0xfacf,0xfad0,0xfad1,0xfad2,0xfad3,0xfad4,
       
   925 	0xfad5,0xfad6,0xfad7,0xfad8,0xfad9,0xfb00,0xfb01,0xfb02,0xfb03,0xfb04,
       
   926 	0xfb05,0xfb06,0xfb13,0xfb14,0xfb15,0xfb16,0xfb17,0xff21,0xff22,0xff23,
       
   927 	0xff24,0xff25,0xff26,0xff27,0xff28,0xff29,0xff2a,0xff2b,0xff2c,0xff2d,
       
   928 	0xff2e,0xff2f,0xff30,0xff31,0xff32,0xff33,0xff34,0xff35,0xff36,0xff37,
       
   929 	0xff38,0xff39,0xff3a,0xff41,0xff42,0xff43,0xff44,0xff45,0xff46,0xff47,
       
   930 	0xff48,0xff49,0xff4a,0xff4b,0xff4c,0xff4d,0xff4e,0xff4f,0xff50,0xff51,
       
   931 	0xff52,0xff53,0xff54,0xff55,0xff56,0xff57,0xff58,0xff59,0xff5a,0xff66,
       
   932 	0xff67,0xff68,0xff69,0xff6a,0xff6b,0xff6c,0xff6d,0xff6e,0xff6f,0xff70,
       
   933 	0xff71,0xff72,0xff73,0xff74,0xff75,0xff76,0xff77,0xff78,0xff79,0xff7a,
       
   934 	0xff7b,0xff7c,0xff7d,0xff7e,0xff7f,0xff80,0xff81,0xff82,0xff83,0xff84,
       
   935 	0xff85,0xff86,0xff87,0xff88,0xff89,0xff8a,0xff8b,0xff8c,0xff8d,0xff8e,
       
   936 	0xff8f,0xff90,0xff91,0xff92,0xff93,0xff94,0xff95,0xff96,0xff97,0xff98,
       
   937 	0xff99,0xff9a,0xff9b,0xff9c,0xff9d,0xff9e,0xff9f,0xffa0,0xffa1,0xffa2,
       
   938 	0xffa3,0xffa4,0xffa5,0xffa6,0xffa7,0xffa8,0xffa9,0xffaa,0xffab,0xffac,
       
   939 	0xffad,0xffae,0xffaf,0xffb0,0xffb1,0xffb2,0xffb3,0xffb4,0xffb5,0xffb6,
       
   940 	0xffb7,0xffb8,0xffb9,0xffba,0xffbb,0xffbc,0xffbd,0xffbe,0xffc2,0xffc3,
       
   941 	0xffc4,0xffc5,0xffc6,0xffc7,0xffca,0xffcb,0xffcc,0xffcd,0xffce,0xffcf,
       
   942 	0xffd2,0xffd3,0xffd4,0xffd5,0xffd6,0xffd7,0xffda,0xffdb,0xffdc,
       
   943 	0xd800,0xdc00,0xd800,0xdc01,0xd800,0xdc02,0xd800,0xdc03,0xd800,0xdc04,
       
   944 	0xd800,0xdc05,0xd800,0xdc06,0xd800,0xdc07,0xd800,0xdc08,0xd800,0xdc09,
       
   945 	0xd800,0xdc0a,0xd800,0xdc0b,0xd800,0xdc0d,0xd800,0xdc0e,0xd800,0xdc0f,
       
   946 	0xd800,0xdc10,0xd800,0xdc11,0xd800,0xdc12,0xd800,0xdc13,0xd800,0xdc14,
       
   947 	0xd800,0xdc15,0xd800,0xdc16,0xd800,0xdc17,0xd800,0xdc18,0xd800,0xdc19,
       
   948 	0xd800,0xdc1a,0xd800,0xdc1b,0xd800,0xdc1c,0xd800,0xdc1d,0xd800,0xdc1e,
       
   949 	0xd800,0xdc1f,0xd800,0xdc20,0xd800,0xdc21,0xd800,0xdc22,0xd800,0xdc23,
       
   950 	0xd800,0xdc24,0xd800,0xdc25,0xd800,0xdc26,0xd800,0xdc28,0xd800,0xdc29,
       
   951 	0xd800,0xdc2a,0xd800,0xdc2b,0xd800,0xdc2c,0xd800,0xdc2d,0xd800,0xdc2e,
       
   952 	0xd800,0xdc2f,0xd800,0xdc30,0xd800,0xdc31,0xd800,0xdc32,0xd800,0xdc33,
       
   953 	0xd800,0xdc34,0xd800,0xdc35,0xd800,0xdc36,0xd800,0xdc37,0xd800,0xdc38,
       
   954 	0xd800,0xdc39,0xd800,0xdc3a,0xd800,0xdc3c,0xd800,0xdc3d,0xd800,0xdc3f,
       
   955 	0xd800,0xdc40,0xd800,0xdc41,0xd800,0xdc42,0xd800,0xdc43,0xd800,0xdc44,
       
   956 	0xd800,0xdc45,0xd800,0xdc46,0xd800,0xdc47,0xd800,0xdc48,0xd800,0xdc49,
       
   957 	0xd800,0xdc4a,0xd800,0xdc4b,0xd800,0xdc4c,0xd800,0xdc4d,0xd800,0xdc50,
       
   958 	0xd800,0xdc51,0xd800,0xdc52,0xd800,0xdc53,0xd800,0xdc54,0xd800,0xdc55,
       
   959 	0xd800,0xdc56,0xd800,0xdc57,0xd800,0xdc58,0xd800,0xdc59,0xd800,0xdc5a,
       
   960 	0xd800,0xdc5b,0xd800,0xdc5c,0xd800,0xdc5d,0xd800,0xdc80,0xd800,0xdc81,
       
   961 	0xd800,0xdc82,0xd800,0xdc83,0xd800,0xdc84,0xd800,0xdc85,0xd800,0xdc86,
       
   962 	0xd800,0xdc87,0xd800,0xdc88,0xd800,0xdc89,0xd800,0xdc8a,0xd800,0xdc8b,
       
   963 	0xd800,0xdc8c,0xd800,0xdc8d,0xd800,0xdc8e,0xd800,0xdc8f,0xd800,0xdc90,
       
   964 	0xd800,0xdc91,0xd800,0xdc92,0xd800,0xdc93,0xd800,0xdc94,0xd800,0xdc95,
       
   965 	0xd800,0xdc96,0xd800,0xdc97,0xd800,0xdc98,0xd800,0xdc99,0xd800,0xdc9a,
       
   966 	0xd800,0xdc9b,0xd800,0xdc9c,0xd800,0xdc9d,0xd800,0xdc9e,0xd800,0xdc9f,
       
   967 	0xd800,0xdca0,0xd800,0xdca1,0xd800,0xdca2,0xd800,0xdca3,0xd800,0xdca4,
       
   968 	0xd800,0xdca5,0xd800,0xdca6,0xd800,0xdca7,0xd800,0xdca8,0xd800,0xdca9,
       
   969 	0xd800,0xdcaa,0xd800,0xdcab,0xd800,0xdcac,0xd800,0xdcad,0xd800,0xdcae,
       
   970 	0xd800,0xdcaf,0xd800,0xdcb0,0xd800,0xdcb1,0xd800,0xdcb2,0xd800,0xdcb3,
       
   971 	0xd800,0xdcb4,0xd800,0xdcb5,0xd800,0xdcb6,0xd800,0xdcb7,0xd800,0xdcb8,
       
   972 	0xd800,0xdcb9,0xd800,0xdcba,0xd800,0xdcbb,0xd800,0xdcbc,0xd800,0xdcbd,
       
   973 	0xd800,0xdcbe,0xd800,0xdcbf,0xd800,0xdcc0,0xd800,0xdcc1,0xd800,0xdcc2,
       
   974 	0xd800,0xdcc3,0xd800,0xdcc4,0xd800,0xdcc5,0xd800,0xdcc6,0xd800,0xdcc7,
       
   975 	0xd800,0xdcc8,0xd800,0xdcc9,0xd800,0xdcca,0xd800,0xdccb,0xd800,0xdccc,
       
   976 	0xd800,0xdccd,0xd800,0xdcce,0xd800,0xdccf,0xd800,0xdcd0,0xd800,0xdcd1,
       
   977 	0xd800,0xdcd2,0xd800,0xdcd3,0xd800,0xdcd4,0xd800,0xdcd5,0xd800,0xdcd6,
       
   978 	0xd800,0xdcd7,0xd800,0xdcd8,0xd800,0xdcd9,0xd800,0xdcda,0xd800,0xdcdb,
       
   979 	0xd800,0xdcdc,0xd800,0xdcdd,0xd800,0xdcde,0xd800,0xdcdf,0xd800,0xdce0,
       
   980 	0xd800,0xdce1,0xd800,0xdce2,0xd800,0xdce3,0xd800,0xdce4,0xd800,0xdce5,
       
   981 	0xd800,0xdce6,0xd800,0xdce7,0xd800,0xdce8,0xd800,0xdce9,0xd800,0xdcea,
       
   982 	0xd800,0xdceb,0xd800,0xdcec,0xd800,0xdced,0xd800,0xdcee,0xd800,0xdcef,
       
   983 	0xd800,0xdcf0,0xd800,0xdcf1,0xd800,0xdcf2,0xd800,0xdcf3,0xd800,0xdcf4,
       
   984 	0xd800,0xdcf5,0xd800,0xdcf6,0xd800,0xdcf7,0xd800,0xdcf8,0xd800,0xdcf9,
       
   985 	0xd800,0xdcfa,0xd800,0xdd00,0xd800,0xdd02,0xd800,0xdd07,0xd800,0xdd08,
       
   986 	0xd800,0xdd09,0xd800,0xdd0a,0xd800,0xdd0b,0xd800,0xdd0c,0xd800,0xdd0d,
       
   987 	0xd800,0xdd0e,0xd800,0xdd0f,0xd800,0xdd10,0xd800,0xdd11,0xd800,0xdd12,
       
   988 	0xd800,0xdd13,0xd800,0xdd14,0xd800,0xdd15,0xd800,0xdd16,0xd800,0xdd17,
       
   989 	0xd800,0xdd18,0xd800,0xdd19,0xd800,0xdd1a,0xd800,0xdd1b,0xd800,0xdd1c,
       
   990 	0xd800,0xdd1d,0xd800,0xdd1e,0xd800,0xdd1f,0xd800,0xdd20,0xd800,0xdd21,
       
   991 	0xd800,0xdd22,0xd800,0xdd23,0xd800,0xdd24,0xd800,0xdd25,0xd800,0xdd26,
       
   992 	0xd800,0xdd27,0xd800,0xdd28,0xd800,0xdd29,0xd800,0xdd2a,0xd800,0xdd2b,
       
   993 	0xd800,0xdd2c,0xd800,0xdd2d,0xd800,0xdd2e,0xd800,0xdd2f,0xd800,0xdd30,
       
   994 	0xd800,0xdd31,0xd800,0xdd32,0xd800,0xdd33,0xd800,0xdd37,0xd800,0xdd38,
       
   995 	0xd800,0xdd39,0xd800,0xdd3a,0xd800,0xdd3b,0xd800,0xdd3c,0xd800,0xdd3d,
       
   996 	0xd800,0xdd3e,0xd800,0xdd3f,0xd800,0xdf00,0xd800,0xdf01,0xd800,0xdf02,
       
   997 	0xd800,0xdf03,0xd800,0xdf04,0xd800,0xdf05,0xd800,0xdf06,0xd800,0xdf07,
       
   998 	0xd800,0xdf08,0xd800,0xdf09,0xd800,0xdf0a,0xd800,0xdf0b,0xd800,0xdf0c,
       
   999 	0xd800,0xdf0d,0xd800,0xdf0e,0xd800,0xdf0f,0xd800,0xdf10,0xd800,0xdf11,
       
  1000 	0xd800,0xdf12,0xd800,0xdf13,0xd800,0xdf14,0xd800,0xdf15,0xd800,0xdf16,
       
  1001 	0xd800,0xdf17,0xd800,0xdf18,0xd800,0xdf19,0xd800,0xdf1a,0xd800,0xdf1b,
       
  1002 	0xd800,0xdf1c,0xd800,0xdf1d,0xd800,0xdf1e,0xd800,0xdf20,0xd800,0xdf21,
       
  1003 	0xd800,0xdf22,0xd800,0xdf23,0xd800,0xdf30,0xd800,0xdf31,0xd800,0xdf32,
       
  1004 	0xd800,0xdf33,0xd800,0xdf34,0xd800,0xdf35,0xd800,0xdf36,0xd800,0xdf37,
       
  1005 	0xd800,0xdf38,0xd800,0xdf39,0xd800,0xdf3a,0xd800,0xdf3b,0xd800,0xdf3c,
       
  1006 	0xd800,0xdf3d,0xd800,0xdf3e,0xd800,0xdf3f,0xd800,0xdf40,0xd800,0xdf41,
       
  1007 	0xd800,0xdf42,0xd800,0xdf43,0xd800,0xdf44,0xd800,0xdf45,0xd800,0xdf46,
       
  1008 	0xd800,0xdf47,0xd800,0xdf48,0xd800,0xdf49,0xd800,0xdf4a,0xd800,0xdf80,
       
  1009 	0xd800,0xdf81,0xd800,0xdf82,0xd800,0xdf83,0xd800,0xdf84,0xd800,0xdf85,
       
  1010 	0xd800,0xdf86,0xd800,0xdf87,0xd800,0xdf88,0xd800,0xdf89,0xd800,0xdf8a,
       
  1011 	0xd800,0xdf8b,0xd800,0xdf8c,0xd800,0xdf8d,0xd800,0xdf8e,0xd800,0xdf8f,
       
  1012 	0xd800,0xdf90,0xd800,0xdf91,0xd800,0xdf92,0xd800,0xdf93,0xd800,0xdf94,
       
  1013 	0xd800,0xdf95,0xd800,0xdf96,0xd800,0xdf97,0xd800,0xdf98,0xd800,0xdf99,
       
  1014 	0xd800,0xdf9a,0xd800,0xdf9b,0xd800,0xdf9c,0xd800,0xdf9d,0xd800,0xdf9f,
       
  1015 	0xd800,0xdfa0,0xd800,0xdfa1,0xd800,0xdfa2,0xd800,0xdfa3,0xd800,0xdfa4,
       
  1016 	0xd800,0xdfa5,0xd800,0xdfa6,0xd800,0xdfa7,0xd800,0xdfa8,0xd800,0xdfa9,
       
  1017 	0xd800,0xdfaa,0xd800,0xdfab,0xd800,0xdfac,0xd800,0xdfad,0xd800,0xdfae,
       
  1018 	0xd800,0xdfaf,0xd800,0xdfb0,0xd800,0xdfb1,0xd800,0xdfb2,0xd800,0xdfb3,
       
  1019 	0xd800,0xdfb4,0xd800,0xdfb5,0xd800,0xdfb6,0xd800,0xdfb7,0xd800,0xdfb8,
       
  1020 	0xd800,0xdfb9,0xd800,0xdfba,0xd800,0xdfbb,0xd800,0xdfbc,0xd800,0xdfbd,
       
  1021 	0xd800,0xdfbe,0xd800,0xdfbf,0xd800,0xdfc0,0xd800,0xdfc1,0xd800,0xdfc2,
       
  1022 	0xd800,0xdfc3,0xd800,0xdfc8,0xd800,0xdfc9,0xd800,0xdfca,0xd800,0xdfcb,
       
  1023 	0xd800,0xdfcc,0xd800,0xdfcd,0xd800,0xdfce,0xd800,0xdfcf,0xd800,0xdfd0,
       
  1024 	0xd800,0xdfd1,0xd800,0xdfd2,0xd800,0xdfd3,0xd800,0xdfd4,0xd800,0xdfd5,
       
  1025 	0xd801,0xdc00,0xd801,0xdc01,0xd801,0xdc02,0xd801,0xdc03,0xd801,0xdc04,
       
  1026 	0xd801,0xdc05,0xd801,0xdc06,0xd801,0xdc07,0xd801,0xdc08,0xd801,0xdc09,
       
  1027 	0xd801,0xdc0a,0xd801,0xdc0b,0xd801,0xdc0c,0xd801,0xdc0d,0xd801,0xdc0e,
       
  1028 	0xd801,0xdc0f,0xd801,0xdc10,0xd801,0xdc11,0xd801,0xdc12,0xd801,0xdc13,
       
  1029 	0xd801,0xdc14,0xd801,0xdc15,0xd801,0xdc16,0xd801,0xdc17,0xd801,0xdc18,
       
  1030 	0xd801,0xdc19,0xd801,0xdc1a,0xd801,0xdc1b,0xd801,0xdc1c,0xd801,0xdc1d,
       
  1031 	0xd801,0xdc1e,0xd801,0xdc1f,0xd801,0xdc20,0xd801,0xdc21,0xd801,0xdc22,
       
  1032 	0xd801,0xdc23,0xd801,0xdc24,0xd801,0xdc25,0xd801,0xdc26,0xd801,0xdc27,
       
  1033 	0xd801,0xdc28,0xd801,0xdc29,0xd801,0xdc2a,0xd801,0xdc2b,0xd801,0xdc2c,
       
  1034 	0xd801,0xdc2d,0xd801,0xdc2e,0xd801,0xdc2f,0xd801,0xdc30,0xd801,0xdc31,
       
  1035 	0xd801,0xdc32,0xd801,0xdc33,0xd801,0xdc34,0xd801,0xdc35,0xd801,0xdc36,
       
  1036 	0xd801,0xdc37,0xd801,0xdc38,0xd801,0xdc39,0xd801,0xdc3a,0xd801,0xdc3b,
       
  1037 	0xd801,0xdc3c,0xd801,0xdc3d,0xd801,0xdc3e,0xd801,0xdc3f,0xd801,0xdc40,
       
  1038 	0xd801,0xdc41,0xd801,0xdc42,0xd801,0xdc43,0xd801,0xdc44,0xd801,0xdc45,
       
  1039 	0xd801,0xdc46,0xd801,0xdc47,0xd801,0xdc48,0xd801,0xdc49,0xd801,0xdc4a,
       
  1040 	0xd801,0xdc4b,0xd801,0xdc4c,0xd801,0xdc4d,0xd801,0xdc4e,0xd801,0xdc4f,
       
  1041 	0xd801,0xdc50,0xd801,0xdc51,0xd801,0xdc52,0xd801,0xdc53,0xd801,0xdc54,
       
  1042 	0xd801,0xdc55,0xd801,0xdc56,0xd801,0xdc57,0xd801,0xdc58,0xd801,0xdc59,
       
  1043 	0xd801,0xdc5a,0xd801,0xdc5b,0xd801,0xdc5c,0xd801,0xdc5d,0xd801,0xdc5e,
       
  1044 	0xd801,0xdc5f,0xd801,0xdc60,0xd801,0xdc61,0xd801,0xdc62,0xd801,0xdc63,
       
  1045 	0xd801,0xdc64,0xd801,0xdc65,0xd801,0xdc66,0xd801,0xdc67,0xd801,0xdc68,
       
  1046 	0xd801,0xdc69,0xd801,0xdc6a,0xd801,0xdc6b,0xd801,0xdc6c,0xd801,0xdc6d,
       
  1047 	0xd801,0xdc6e,0xd801,0xdc6f,0xd801,0xdc70,0xd801,0xdc71,0xd801,0xdc72,
       
  1048 	0xd801,0xdc73,0xd801,0xdc74,0xd801,0xdc75,0xd801,0xdc76,0xd801,0xdc77,
       
  1049 	0xd801,0xdc78,0xd801,0xdc79,0xd801,0xdc7a,0xd801,0xdc7b,0xd801,0xdc7c,
       
  1050 	0xd801,0xdc7d,0xd801,0xdc7e,0xd801,0xdc7f,0xd801,0xdc80,0xd801,0xdc81,
       
  1051 	0xd801,0xdc82,0xd801,0xdc83,0xd801,0xdc84,0xd801,0xdc85,0xd801,0xdc86,
       
  1052 	0xd801,0xdc87,0xd801,0xdc88,0xd801,0xdc89,0xd801,0xdc8a,0xd801,0xdc8b,
       
  1053 	0xd801,0xdc8c,0xd801,0xdc8d,0xd801,0xdc8e,0xd801,0xdc8f,0xd801,0xdc90,
       
  1054 	0xd801,0xdc91,0xd801,0xdc92,0xd801,0xdc93,0xd801,0xdc94,0xd801,0xdc95,
       
  1055 	0xd801,0xdc96,0xd801,0xdc97,0xd801,0xdc98,0xd801,0xdc99,0xd801,0xdc9a,
       
  1056 	0xd801,0xdc9b,0xd801,0xdc9c,0xd801,0xdc9d,0xd801,0xdca0,0xd801,0xdca1,
       
  1057 	0xd801,0xdca2,0xd801,0xdca3,0xd801,0xdca4,0xd801,0xdca5,0xd801,0xdca6,
       
  1058 	0xd801,0xdca7,0xd801,0xdca8,0xd801,0xdca9,0xd808,0xdc00,0xd808,0xdc01,
       
  1059 	0xd808,0xdc02,0xd808,0xdc03,0xd808,0xdc04,0xd808,0xdc05,0xd808,0xdc06,
       
  1060 	0xd808,0xdc07,0xd808,0xdc08,0xd808,0xdc09,0xd808,0xdc0a,0xd808,0xdc0b,
       
  1061 	0xd808,0xdc0c,0xd808,0xdc0d,0xd808,0xdc0e,0xd808,0xdc0f,0xd808,0xdc10,
       
  1062 	0xd808,0xdc11,0xd808,0xdc12,0xd808,0xdc13,0xd808,0xdc14,0xd808,0xdc15,
       
  1063 	0xd808,0xdc16,0xd808,0xdc17,0xd808,0xdc18,0xd808,0xdc19,0xd808,0xdc1a,
       
  1064 	0xd808,0xdc1b,0xd808,0xdc1c,0xd808,0xdc1d,0xd808,0xdc1e,0xd808,0xdc1f,
       
  1065 	0xd808,0xdc20,0xd808,0xdc21,0xd808,0xdc22,0xd808,0xdc23,0xd808,0xdc24,
       
  1066 	0xd808,0xdc25,0xd808,0xdc26,0xd808,0xdc27,0xd808,0xdc28,0xd808,0xdc29,
       
  1067 	0xd808,0xdc2a,0xd808,0xdc2b,0xd808,0xdc2c,0xd808,0xdc2d,0xd808,0xdc2e,
       
  1068 	0xd808,0xdc2f,0xd808,0xdc30,0xd808,0xdc31,0xd808,0xdc32,0xd808,0xdc33,
       
  1069 	0xd808,0xdc34,0xd808,0xdc35,0xd808,0xdc36,0xd808,0xdc37,0xd808,0xdc38,
       
  1070 	0xd808,0xdc39,0xd808,0xdc3a,0xd808,0xdc3b,0xd808,0xdc3c,0xd808,0xdc3d,
       
  1071 	0xd808,0xdc3e,0xd808,0xdc3f,0xd808,0xdc40,0xd808,0xdc41,0xd808,0xdc42,
       
  1072 	0xd808,0xdc43,0xd808,0xdc44,0xd808,0xdc45,0xd808,0xdc46,0xd808,0xdc47,
       
  1073 	0xd808,0xdc48,0xd808,0xdc49,0xd808,0xdc4a,0xd808,0xdc4b,0xd808,0xdc4c,
       
  1074 	0xd808,0xdc4d,0xd808,0xdc4e,0xd808,0xdc4f,0xd808,0xdc50,0xd808,0xdc51,
       
  1075 	0xd808,0xdc52,0xd808,0xdc53,0xd808,0xdc54,0xd808,0xdc55,0xd808,0xdc56,
       
  1076 	0xd808,0xdc57,0xd808,0xdc58,0xd808,0xdc59,0xd808,0xdc5a,0xd808,0xdc5b,
       
  1077 	0xd808,0xdc5c,0xd808,0xdc5d,0xd808,0xdc5e,0xd808,0xdc5f,0xd808,0xdc60,
       
  1078 	0xd808,0xdc61,0xd808,0xdc62,0xd808,0xdc63,0xd808,0xdc64,0xd808,0xdc65,
       
  1079 	0xd808,0xdc66,0xd808,0xdc67,0xd808,0xdc68,0xd808,0xdc69,0xd808,0xdc6a,
       
  1080 	0xd808,0xdc6b,0xd808,0xdc6c,0xd808,0xdc6d,0xd808,0xdc6e,0xd808,0xdc6f,
       
  1081 	0xd808,0xdc70,0xd808,0xdc71,0xd808,0xdc72,0xd808,0xdc73,0xd808,0xdc74,
       
  1082 	0xd808,0xdc75,0xd808,0xdc76,0xd808,0xdc77,0xd808,0xdc78,0xd808,0xdc79,
       
  1083 	0xd808,0xdc7a,0xd808,0xdc7b,0xd808,0xdc7c,0xd808,0xdc7d,0xd808,0xdc7e,
       
  1084 	0xd808,0xdc7f,0xd808,0xdc80,0xd808,0xdc81,0xd808,0xdc82,0xd808,0xdc83,
       
  1085 	0xd808,0xdc84,0xd808,0xdc85,0xd808,0xdc86,0xd808,0xdc87,0xd808,0xdc88,
       
  1086 	0xd808,0xdc89,0xd808,0xdc8a,0xd808,0xdc8b,0xd808,0xdc8c,0xd808,0xdc8d,
       
  1087 	0xd808,0xdc8e,0xd808,0xdc8f,0xd808,0xdc90,0xd808,0xdc91,0xd808,0xdc92,
       
  1088 	0xd808,0xdc93,0xd808,0xdc94,0xd808,0xdc95,0xd808,0xdc96,0xd808,0xdc97,
       
  1089 	0xd808,0xdc98,0xd808,0xdc99,0xd808,0xdc9a,0xd808,0xdc9b,0xd808,0xdc9c,
       
  1090 	0xd808,0xdc9d,0xd808,0xdc9e,0xd808,0xdc9f,0xd808,0xdca0,0xd808,0xdca1,
       
  1091 	0xd808,0xdca2,0xd808,0xdca3,0xd808,0xdca4,0xd808,0xdca5,0xd808,0xdca6,
       
  1092 	0xd808,0xdca7,0xd808,0xdca8,0xd808,0xdca9,0xd808,0xdcaa,0xd808,0xdcab,
       
  1093 	0xd808,0xdcac,0xd808,0xdcad,0xd808,0xdcae,0xd808,0xdcaf,0xd808,0xdcb0,
       
  1094 	0xd808,0xdcb1,0xd808,0xdcb2,0xd808,0xdcb3,0xd808,0xdcb4,0xd808,0xdcb5,
       
  1095 	0xd808,0xdcb6,0xd808,0xdcb7,0xd808,0xdcb8,0xd808,0xdcb9,0xd808,0xdcba,
       
  1096 	0xd808,0xdcbb,0xd808,0xdcbc,0xd808,0xdcbd,0xd808,0xdcbe,0xd808,0xdcbf,
       
  1097 	0xd808,0xdcc0,0xd808,0xdcc1,0xd808,0xdcc2,0xd808,0xdcc3,0xd808,0xdcc4,
       
  1098 	0xd808,0xdcc5,0xd808,0xdcc6,0xd808,0xdcc7,0xd808,0xdcc8,0xd808,0xdcc9,
       
  1099 	0xd808,0xdcca,0xd808,0xdccb,0xd808,0xdccc,0xd808,0xdccd,0xd808,0xdcce,
       
  1100 	0xd808,0xdccf,0xd808,0xdcd0,0xd808,0xdcd1,0xd808,0xdcd2,0xd808,0xdcd3,
       
  1101 	0xd808,0xdcd4,0xd808,0xdcd5,0xd808,0xdcd6,0xd808,0xdcd7,0xd808,0xdcd8,
       
  1102 	0xd808,0xdcd9,0xd808,0xdcda,0xd808,0xdcdb,0xd808,0xdcdc,0xd808,0xdcdd,
       
  1103 	0xd808,0xdcde,0xd808,0xdcdf,0xd808,0xdce0,0xd808,0xdce1,0xd808,0xdce2,
       
  1104 	0xd808,0xdce3,0xd808,0xdce4,0xd808,0xdce5,0xd808,0xdce6,0xd808,0xdce7,
       
  1105 	0xd808,0xdce8,0xd808,0xdce9,0xd808,0xdcea,0xd808,0xdceb,0xd808,0xdcec,
       
  1106 	0xd808,0xdced,0xd808,0xdcee,0xd808,0xdcef,0xd808,0xdcf0,0xd808,0xdcf1,
       
  1107 	0xd808,0xdcf2,0xd808,0xdcf3,0xd808,0xdcf4,0xd808,0xdcf5,0xd808,0xdcf6,
       
  1108 	0xd808,0xdcf7,0xd808,0xdcf8,0xd808,0xdcf9,0xd808,0xdcfa,0xd808,0xdcfb,
       
  1109 	0xd808,0xdcfc,0xd808,0xdcfd,0xd808,0xdcfe,0xd808,0xdcff,0xd808,0xdd00,
       
  1110 	0xd808,0xdd01,0xd808,0xdd02,0xd808,0xdd03,0xd808,0xdd04,0xd808,0xdd05,
       
  1111 	0xd808,0xdd06,0xd808,0xdd07,0xd808,0xdd08,0xd808,0xdd09,0xd808,0xdd0a,
       
  1112 	0xd808,0xdd0b,0xd808,0xdd0c,0xd808,0xdd0d,0xd808,0xdd0e,0xd808,0xdd0f,
       
  1113 	0xd808,0xdd10,0xd808,0xdd11,0xd808,0xdd12,0xd808,0xdd13,0xd808,0xdd14,
       
  1114 	0xd808,0xdd15,0xd808,0xdd16,0xd808,0xdd17,0xd808,0xdd18,0xd808,0xdd19,
       
  1115 	0xd808,0xdd1a,0xd808,0xdd1b,0xd808,0xdd1c,0xd808,0xdd1d,0xd808,0xdd1e,
       
  1116 	0xd808,0xdd1f,0xd808,0xdd20,0xd808,0xdd21,0xd808,0xdd22,0xd808,0xdd23,
       
  1117 	0xd808,0xdd24,0xd808,0xdd25,0xd808,0xdd26,0xd808,0xdd27,0xd808,0xdd28,
       
  1118 	0xd808,0xdd29,0xd808,0xdd2a,0xd808,0xdd2b,0xd808,0xdd2c,0xd808,0xdd2d,
       
  1119 	0xd808,0xdd2e,0xd808,0xdd2f,0xd808,0xdd30,0xd808,0xdd31,0xd808,0xdd32,
       
  1120 	0xd808,0xdd33,0xd808,0xdd34,0xd808,0xdd35,0xd808,0xdd36,0xd808,0xdd37,
       
  1121 	0xd808,0xdd38,0xd808,0xdd39,0xd808,0xdd3a,0xd808,0xdd3b,0xd808,0xdd3c,
       
  1122 	0xd808,0xdd3d,0xd808,0xdd3e,0xd808,0xdd3f,0xd808,0xdd40,0xd808,0xdd41,
       
  1123 	0xd808,0xdd42,0xd808,0xdd43,0xd808,0xdd44,0xd808,0xdd45,0xd808,0xdd46,
       
  1124 	0xd808,0xdd47,0xd808,0xdd48,0xd808,0xdd49,0xd808,0xdd4a,0xd808,0xdd4b,
       
  1125 	0xd808,0xdd4c,0xd808,0xdd4d,0xd808,0xdd4e,0xd808,0xdd4f,0xd808,0xdd50,
       
  1126 	0xd808,0xdd51,0xd808,0xdd52,0xd808,0xdd53,0xd808,0xdd54,0xd808,0xdd55,
       
  1127 	0xd808,0xdd56,0xd808,0xdd57,0xd808,0xdd58,0xd808,0xdd59,0xd808,0xdd5a,
       
  1128 	0xd808,0xdd5b,0xd808,0xdd5c,0xd808,0xdd5d,0xd808,0xdd5e,0xd808,0xdd5f,
       
  1129 	0xd808,0xdd60,0xd808,0xdd61,0xd808,0xdd62,0xd808,0xdd63,0xd808,0xdd64,
       
  1130 	0xd808,0xdd65,0xd808,0xdd66,0xd808,0xdd67,0xd808,0xdd68,0xd808,0xdd69,
       
  1131 	0xd808,0xdd6a,0xd808,0xdd6b,0xd808,0xdd6c,0xd808,0xdd6d,0xd808,0xdd6e,
       
  1132 	0xd808,0xdd6f,0xd808,0xdd70,0xd808,0xdd71,0xd808,0xdd72,0xd808,0xdd73,
       
  1133 	0xd808,0xdd74,0xd808,0xdd75,0xd808,0xdd76,0xd808,0xdd77,0xd808,0xdd78,
       
  1134 	0xd808,0xdd79,0xd808,0xdd7a,0xd808,0xdd7b,0xd808,0xdd7c,0xd808,0xdd7d,
       
  1135 	0xd808,0xdd7e,0xd808,0xdd7f,0xd808,0xdd80,0xd808,0xdd81,0xd808,0xdd82,
       
  1136 	0xd808,0xdd83,0xd808,0xdd84,0xd808,0xdd85,0xd808,0xdd86,0xd808,0xdd87,
       
  1137 	0xd808,0xdd88,0xd808,0xdd89,0xd808,0xdd8a,0xd808,0xdd8b,0xd808,0xdd8c,
       
  1138 	0xd808,0xdd8d,0xd808,0xdd8e,0xd808,0xdd8f,0xd808,0xdd90,0xd808,0xdd91,
       
  1139 	0xd808,0xdd92,0xd808,0xdd93,0xd808,0xdd94,0xd808,0xdd95,0xd808,0xdd96,
       
  1140 	0xd808,0xdd97,0xd808,0xdd98,0xd808,0xdd99,0xd808,0xdd9a,0xd808,0xdd9b,
       
  1141 	0xd808,0xdd9c,0xd808,0xdd9d,0xd808,0xdd9e,0xd808,0xdd9f,0xd808,0xdda0,
       
  1142 	0xd808,0xdda1,0xd808,0xdda2,0xd808,0xdda3,0xd808,0xdda4,0xd808,0xdda5,
       
  1143 	0xd808,0xdda6,0xd808,0xdda7,0xd808,0xdda8,0xd808,0xdda9,0xd808,0xddaa,
       
  1144 	0xd808,0xddab,0xd808,0xddac,0xd808,0xddad,0xd808,0xddae,0xd808,0xddaf,
       
  1145 	0xd808,0xddb0,0xd808,0xddb1,0xd808,0xddb2,0xd808,0xddb3,0xd808,0xddb4,
       
  1146 	0xd808,0xddb5,0xd808,0xddb6,0xd808,0xddb7,0xd808,0xddb8,0xd808,0xddb9,
       
  1147 	0xd808,0xddba,0xd808,0xddbb,0xd808,0xddbc,0xd808,0xddbd,0xd808,0xddbe,
       
  1148 	0xd808,0xddbf,0xd808,0xddc0,0xd808,0xddc1,0xd808,0xddc2,0xd808,0xddc3,
       
  1149 	0xd808,0xddc4,0xd808,0xddc5,0xd808,0xddc6,0xd808,0xddc7,0xd808,0xddc8,
       
  1150 	0xd808,0xddc9,0xd808,0xddca,0xd808,0xddcb,0xd808,0xddcc,0xd808,0xddcd,
       
  1151 	0xd808,0xddce,0xd808,0xddcf,0xd808,0xddd0,0xd808,0xddd1,0xd808,0xddd2,
       
  1152 	0xd808,0xddd3,0xd808,0xddd4,0xd808,0xddd5,0xd808,0xddd6,0xd808,0xddd7,
       
  1153 	0xd808,0xddd8,0xd808,0xddd9,0xd808,0xddda,0xd808,0xdddb,0xd808,0xdddc,
       
  1154 	0xd808,0xdddd,0xd808,0xddde,0xd808,0xdddf,0xd808,0xdde0,0xd808,0xdde1,
       
  1155 	0xd808,0xdde2,0xd808,0xdde3,0xd808,0xdde4,0xd808,0xdde5,0xd808,0xdde6,
       
  1156 	0xd808,0xdde7,0xd808,0xdde8,0xd808,0xdde9,0xd808,0xddea,0xd808,0xddeb,
       
  1157 	0xd808,0xddec,0xd808,0xdded,0xd808,0xddee,0xd808,0xddef,0xd808,0xddf0,
       
  1158 	0xd808,0xddf1,0xd808,0xddf2,0xd808,0xddf3,0xd808,0xddf4,0xd808,0xddf5,
       
  1159 	0xd808,0xddf6,0xd808,0xddf7,0xd808,0xddf8,0xd808,0xddf9,0xd808,0xddfa,
       
  1160 	0xd808,0xddfb,0xd808,0xddfc,0xd808,0xddfd,0xd808,0xddfe,0xd808,0xddff,
       
  1161 	0xd808,0xde00,0xd808,0xde01,0xd808,0xde02,0xd808,0xde03,0xd808,0xde04,
       
  1162 	0xd808,0xde05,0xd808,0xde06,0xd808,0xde07,0xd808,0xde08,0xd808,0xde09,
       
  1163 	0xd808,0xde0a,0xd808,0xde0b,0xd808,0xde0c,0xd808,0xde0d,0xd808,0xde0e,
       
  1164 	0xd808,0xde0f,0xd808,0xde10,0xd808,0xde11,0xd808,0xde12,0xd808,0xde13,
       
  1165 	0xd808,0xde14,0xd808,0xde15,0xd808,0xde16,0xd808,0xde17,0xd808,0xde18,
       
  1166 	0xd808,0xde19,0xd808,0xde1a,0xd808,0xde1b,0xd808,0xde1c,0xd808,0xde1d,
       
  1167 	0xd808,0xde1e,0xd808,0xde1f,0xd808,0xde20,0xd808,0xde21,0xd808,0xde22,
       
  1168 	0xd808,0xde23,0xd808,0xde24,0xd808,0xde25,0xd808,0xde26,0xd808,0xde27,
       
  1169 	0xd808,0xde28,0xd808,0xde29,0xd808,0xde2a,0xd808,0xde2b,0xd808,0xde2c,
       
  1170 	0xd808,0xde2d,0xd808,0xde2e,0xd808,0xde2f,0xd808,0xde30,0xd808,0xde31,
       
  1171 	0xd808,0xde32,0xd808,0xde33,0xd808,0xde34,0xd808,0xde35,0xd808,0xde36,
       
  1172 	0xd808,0xde37,0xd808,0xde38,0xd808,0xde39,0xd808,0xde3a,0xd808,0xde3b,
       
  1173 	0xd808,0xde3c,0xd808,0xde3d,0xd808,0xde3e,0xd808,0xde3f,0xd808,0xde40,
       
  1174 	0xd808,0xde41,0xd808,0xde42,0xd808,0xde43,0xd808,0xde44,0xd808,0xde45,
       
  1175 	0xd808,0xde46,0xd808,0xde47,0xd808,0xde48,0xd808,0xde49,0xd808,0xde4a,
       
  1176 	0xd808,0xde4b,0xd808,0xde4c,0xd808,0xde4d,0xd808,0xde4e,0xd808,0xde4f,
       
  1177 	0xd808,0xde50,0xd808,0xde51,0xd808,0xde52,0xd808,0xde53,0xd808,0xde54,
       
  1178 	0xd808,0xde55,0xd808,0xde56,0xd808,0xde57,0xd808,0xde58,0xd808,0xde59,
       
  1179 	0xd808,0xde5a,0xd808,0xde5b,0xd808,0xde5c,0xd808,0xde5d,0xd808,0xde5e,
       
  1180 	0xd808,0xde5f,0xd808,0xde60,0xd808,0xde61,0xd808,0xde62,0xd808,0xde63,
       
  1181 	0xd808,0xde64,0xd808,0xde65,0xd808,0xde66,0xd808,0xde67,0xd808,0xde68,
       
  1182 	0xd808,0xde69,0xd808,0xde6a,0xd808,0xde6b,0xd808,0xde6c,0xd808,0xde6d,
       
  1183 	0xd808,0xde6e,0xd808,0xde6f,0xd808,0xde70,0xd808,0xde71,0xd808,0xde72,
       
  1184 	0xd808,0xde73,0xd808,0xde74,0xd808,0xde75,0xd808,0xde76,0xd808,0xde77,
       
  1185 	0xd808,0xde78,0xd808,0xde79,0xd808,0xde7a,0xd808,0xde7b,0xd808,0xde7c,
       
  1186 	0xd808,0xde7d,0xd808,0xde7e,0xd808,0xde7f,0xd808,0xde80,0xd808,0xde81,
       
  1187 	0xd808,0xde82,0xd808,0xde83,0xd808,0xde84,0xd808,0xde85,0xd808,0xde86,
       
  1188 	0xd808,0xde87,0xd808,0xde88,0xd808,0xde89,0xd808,0xde8a,0xd808,0xde8b,
       
  1189 	0xd808,0xde8c,0xd808,0xde8d,0xd808,0xde8e,0xd808,0xde8f,0xd808,0xde90,
       
  1190 	0xd808,0xde91,0xd808,0xde92,0xd808,0xde93,0xd808,0xde94,0xd808,0xde95,
       
  1191 	0xd808,0xde96,0xd808,0xde97,0xd808,0xde98,0xd808,0xde99,0xd808,0xde9a,
       
  1192 	0xd808,0xde9b,0xd808,0xde9c,0xd808,0xde9d,0xd808,0xde9e,0xd808,0xde9f,
       
  1193 	0xd808,0xdea0,0xd808,0xdea1,0xd808,0xdea2,0xd808,0xdea3,0xd808,0xdea4,
       
  1194 	0xd808,0xdea5,0xd808,0xdea6,0xd808,0xdea7,0xd808,0xdea8,0xd808,0xdea9,
       
  1195 	0xd808,0xdeaa,0xd808,0xdeab,0xd808,0xdeac,0xd808,0xdead,0xd808,0xdeae,
       
  1196 	0xd808,0xdeaf,0xd808,0xdeb0,0xd808,0xdeb1,0xd808,0xdeb2,0xd808,0xdeb3,
       
  1197 	0xd808,0xdeb4,0xd808,0xdeb5,0xd808,0xdeb6,0xd808,0xdeb7,0xd808,0xdeb8,
       
  1198 	0xd808,0xdeb9,0xd808,0xdeba,0xd808,0xdebb,0xd808,0xdebc,0xd808,0xdebd,
       
  1199 	0xd808,0xdebe,0xd808,0xdebf,0xd808,0xdec0,0xd808,0xdec1,0xd808,0xdec2,
       
  1200 	0xd808,0xdec3,0xd808,0xdec4,0xd808,0xdec5,0xd808,0xdec6,0xd808,0xdec7,
       
  1201 	0xd808,0xdec8,0xd808,0xdec9,0xd808,0xdeca,0xd808,0xdecb,0xd808,0xdecc,
       
  1202 	0xd808,0xdecd,0xd808,0xdece,0xd808,0xdecf,0xd808,0xded0,0xd808,0xded1,
       
  1203 	0xd808,0xded2,0xd808,0xded3,0xd808,0xded4,0xd808,0xded5,0xd808,0xded6,
       
  1204 	0xd808,0xded7,0xd808,0xded8,0xd808,0xded9,0xd808,0xdeda,0xd808,0xdedb,
       
  1205 	0xd808,0xdedc,0xd808,0xdedd,0xd808,0xdede,0xd808,0xdedf,0xd808,0xdee0,
       
  1206 	0xd808,0xdee1,0xd808,0xdee2,0xd808,0xdee3,0xd808,0xdee4,0xd808,0xdee5,
       
  1207 	0xd808,0xdee6,0xd808,0xdee7,0xd808,0xdee8,0xd808,0xdee9,0xd808,0xdeea,
       
  1208 	0xd808,0xdeeb,0xd808,0xdeec,0xd808,0xdeed,0xd808,0xdeee,0xd808,0xdeef,
       
  1209 	0xd808,0xdef0,0xd808,0xdef1,0xd808,0xdef2,0xd808,0xdef3,0xd808,0xdef4,
       
  1210 	0xd808,0xdef5,0xd808,0xdef6,0xd808,0xdef7,0xd808,0xdef8,0xd808,0xdef9,
       
  1211 	0xd808,0xdefa,0xd808,0xdefb,0xd808,0xdefc,0xd808,0xdefd,0xd808,0xdefe,
       
  1212 	0xd808,0xdeff,0xd808,0xdf00,0xd808,0xdf01,0xd808,0xdf02,0xd808,0xdf03,
       
  1213 	0xd808,0xdf04,0xd808,0xdf05,0xd808,0xdf06,0xd808,0xdf07,0xd808,0xdf08,
       
  1214 	0xd808,0xdf09,0xd808,0xdf0a,0xd808,0xdf0b,0xd808,0xdf0c,0xd808,0xdf0d,
       
  1215 	0xd808,0xdf0e,0xd808,0xdf0f,0xd808,0xdf10,0xd808,0xdf11,0xd808,0xdf12,
       
  1216 	0xd808,0xdf13,0xd808,0xdf14,0xd808,0xdf15,0xd808,0xdf16,0xd808,0xdf17,
       
  1217 	0xd808,0xdf18,0xd808,0xdf19,0xd808,0xdf1a,0xd808,0xdf1b,0xd808,0xdf1c,
       
  1218 	0xd808,0xdf1d,0xd808,0xdf1e,0xd808,0xdf1f,0xd808,0xdf20,0xd808,0xdf21,
       
  1219 	0xd808,0xdf22,0xd808,0xdf23,0xd808,0xdf24,0xd808,0xdf25,0xd808,0xdf26,
       
  1220 	0xd808,0xdf27,0xd808,0xdf28,0xd808,0xdf29,0xd808,0xdf2a,0xd808,0xdf2b,
       
  1221 	0xd808,0xdf2c,0xd808,0xdf2d,0xd808,0xdf2e,0xd808,0xdf2f,0xd808,0xdf30,
       
  1222 	0xd808,0xdf31,0xd808,0xdf32,0xd808,0xdf33,0xd808,0xdf34,0xd808,0xdf35,
       
  1223 	0xd808,0xdf36,0xd808,0xdf37,0xd808,0xdf38,0xd808,0xdf39,0xd808,0xdf3a,
       
  1224 	0xd808,0xdf3b,0xd808,0xdf3c,0xd808,0xdf3d,0xd808,0xdf3e,0xd808,0xdf3f,
       
  1225 	0xd808,0xdf40,0xd808,0xdf41,0xd808,0xdf42,0xd808,0xdf43,0xd808,0xdf44,
       
  1226 	0xd808,0xdf45,0xd808,0xdf46,0xd808,0xdf47,0xd808,0xdf48,0xd808,0xdf49,
       
  1227 	0xd808,0xdf4a,0xd808,0xdf4b,0xd808,0xdf4c,0xd808,0xdf4d,0xd808,0xdf4e,
       
  1228 	0xd808,0xdf4f,0xd808,0xdf50,0xd808,0xdf51,0xd808,0xdf52,0xd808,0xdf53,
       
  1229 	0xd808,0xdf54,0xd808,0xdf55,0xd808,0xdf56,0xd808,0xdf57,0xd808,0xdf58,
       
  1230 	0xd808,0xdf59,0xd808,0xdf5a,0xd808,0xdf5b,0xd808,0xdf5c,0xd808,0xdf5d,
       
  1231 	0xd808,0xdf5e,0xd808,0xdf5f,0xd808,0xdf60,0xd808,0xdf61,0xd808,0xdf62,
       
  1232 	0xd808,0xdf63,0xd808,0xdf64,0xd808,0xdf65,0xd808,0xdf66,0xd808,0xdf67,
       
  1233 	0xd808,0xdf68,0xd808,0xdf69,0xd808,0xdf6a,0xd808,0xdf6b,0xd808,0xdf6c,
       
  1234 	0xd808,0xdf6d,0xd808,0xdf6e,0xd809,0xdc00,0xd809,0xdc01,0xd809,0xdc02,
       
  1235 	0xd809,0xdc03,0xd809,0xdc04,0xd809,0xdc05,0xd809,0xdc06,0xd809,0xdc07,
       
  1236 	0xd809,0xdc08,0xd809,0xdc09,0xd809,0xdc0a,0xd809,0xdc0b,0xd809,0xdc0c,
       
  1237 	0xd809,0xdc0d,0xd809,0xdc0e,0xd809,0xdc0f,0xd809,0xdc10,0xd809,0xdc11,
       
  1238 	0xd809,0xdc12,0xd809,0xdc13,0xd809,0xdc14,0xd809,0xdc15,0xd809,0xdc16,
       
  1239 	0xd809,0xdc17,0xd809,0xdc18,0xd809,0xdc19,0xd809,0xdc1a,0xd809,0xdc1b,
       
  1240 	0xd809,0xdc1c,0xd809,0xdc1d,0xd809,0xdc1e,0xd809,0xdc1f,0xd809,0xdc20,
       
  1241 	0xd809,0xdc21,0xd809,0xdc22,0xd809,0xdc23,0xd809,0xdc24,0xd809,0xdc25,
       
  1242 	0xd809,0xdc26,0xd809,0xdc27,0xd809,0xdc28,0xd809,0xdc29,0xd809,0xdc2a,
       
  1243 	0xd809,0xdc2b,0xd809,0xdc2c,0xd809,0xdc2d,0xd809,0xdc2e,0xd809,0xdc2f,
       
  1244 	0xd809,0xdc30,0xd809,0xdc31,0xd809,0xdc32,0xd809,0xdc33,0xd809,0xdc34,
       
  1245 	0xd809,0xdc35,0xd809,0xdc36,0xd809,0xdc37,0xd809,0xdc38,0xd809,0xdc39,
       
  1246 	0xd809,0xdc3a,0xd809,0xdc3b,0xd809,0xdc3c,0xd809,0xdc3d,0xd809,0xdc3e,
       
  1247 	0xd809,0xdc3f,0xd809,0xdc40,0xd809,0xdc41,0xd809,0xdc42,0xd809,0xdc43,
       
  1248 	0xd809,0xdc44,0xd809,0xdc45,0xd809,0xdc46,0xd809,0xdc47,0xd809,0xdc48,
       
  1249 	0xd809,0xdc49,0xd809,0xdc4a,0xd809,0xdc4b,0xd809,0xdc4c,0xd809,0xdc4d,
       
  1250 	0xd809,0xdc4e,0xd809,0xdc4f,0xd809,0xdc50,0xd809,0xdc51,0xd809,0xdc52,
       
  1251 	0xd809,0xdc53,0xd809,0xdc54,0xd809,0xdc55,0xd809,0xdc56,0xd809,0xdc57,
       
  1252 	0xd809,0xdc58,0xd809,0xdc59,0xd809,0xdc5a,0xd809,0xdc5b,0xd809,0xdc5c,
       
  1253 	0xd809,0xdc5d,0xd809,0xdc5e,0xd809,0xdc5f,0xd809,0xdc60,0xd809,0xdc61,
       
  1254 	0xd809,0xdc62,0xd809,0xdc70,0xd809,0xdc71,0xd809,0xdc72,0xd809,0xdc73,
       
  1255 	0xd834,0xdc00,0xd834,0xdc01,0xd834,0xdc02,0xd834,0xdc03,0xd834,0xdc04,
       
  1256 	0xd834,0xdc05,0xd834,0xdc06,0xd834,0xdc07,0xd834,0xdc08,0xd834,0xdc09,
       
  1257 	0xd834,0xdc0a,0xd834,0xdc0b,0xd834,0xdc0c,0xd834,0xdc0d,0xd834,0xdc0e,
       
  1258 	0xd834,0xdc0f,0xd834,0xdc10,0xd834,0xdc11,0xd834,0xdc12,0xd834,0xdc13,
       
  1259 	0xd834,0xdc14,0xd834,0xdc15,0xd834,0xdc16,0xd834,0xdc17,0xd834,0xdc18,
       
  1260 	0xd834,0xdc19,0xd834,0xdc1a,0xd834,0xdc1b,0xd834,0xdc1c,0xd834,0xdc1d,
       
  1261 	0xd834,0xdc1e,0xd834,0xdc1f,0xd834,0xdc20,0xd834,0xdc21,0xd834,0xdc22,
       
  1262 	0xd834,0xdc23,0xd834,0xdc24,0xd834,0xdc25,0xd834,0xdc26,0xd834,0xdc27,
       
  1263 	0xd834,0xdc28,0xd834,0xdc29,0xd834,0xdc2a,0xd834,0xdc2b,0xd834,0xdc2c,
       
  1264 	0xd834,0xdc2d,0xd834,0xdc2e,0xd834,0xdc2f,0xd834,0xdc30,0xd834,0xdc31,
       
  1265 	0xd834,0xdc32,0xd834,0xdc33,0xd834,0xdc34,0xd834,0xdc35,0xd834,0xdc36,
       
  1266 	0xd834,0xdc37,0xd834,0xdc38,0xd834,0xdc39,0xd834,0xdc3a,0xd834,0xdc3b,
       
  1267 	0xd834,0xdc3c,0xd834,0xdc3d,0xd834,0xdc3e,0xd834,0xdc3f,0xd834,0xdc40,
       
  1268 	0xd834,0xdc41,0xd834,0xdc42,0xd834,0xdc43,0xd834,0xdc44,0xd834,0xdc45,
       
  1269 	0xd834,0xdc46,0xd834,0xdc47,0xd834,0xdc48,0xd834,0xdc49,0xd834,0xdc4a,
       
  1270 	0xd834,0xdc4b,0xd834,0xdc4c,0xd834,0xdc4d,0xd834,0xdc4e,0xd834,0xdc4f,
       
  1271 	0xd834,0xdc50,0xd834,0xdc51,0xd834,0xdc52,0xd834,0xdc53,0xd834,0xdc54,
       
  1272 	0xd834,0xdc55,0xd834,0xdc56,0xd834,0xdc57,0xd834,0xdc58,0xd834,0xdc59,
       
  1273 	0xd834,0xdc5a,0xd834,0xdc5b,0xd834,0xdc5c,0xd834,0xdc5d,0xd834,0xdc5e,
       
  1274 	0xd834,0xdc5f,0xd834,0xdc60,0xd834,0xdc61,0xd834,0xdc62,0xd834,0xdc63,
       
  1275 	0xd834,0xdc64,0xd834,0xdc65,0xd834,0xdc66,0xd834,0xdc67,0xd834,0xdc68,
       
  1276 	0xd834,0xdc69,0xd834,0xdc6a,0xd834,0xdc6b,0xd834,0xdc6c,0xd834,0xdc6d,
       
  1277 	0xd834,0xdc6e,0xd834,0xdc6f,0xd834,0xdc70,0xd834,0xdc71,0xd834,0xdc72,
       
  1278 	0xd834,0xdc73,0xd834,0xdc74,0xd834,0xdc75,0xd834,0xdc76,0xd834,0xdc77,
       
  1279 	0xd834,0xdc78,0xd834,0xdc79,0xd834,0xdc7a,0xd834,0xdc7b,0xd834,0xdc7c,
       
  1280 	0xd834,0xdc7d,0xd834,0xdc7e,0xd834,0xdc7f,0xd834,0xdc80,0xd834,0xdc81,
       
  1281 	0xd834,0xdc82,0xd834,0xdc83,0xd834,0xdc84,0xd834,0xdc85,0xd834,0xdc86,
       
  1282 	0xd834,0xdc87,0xd834,0xdc88,0xd834,0xdc89,0xd834,0xdc8a,0xd834,0xdc8b,
       
  1283 	0xd834,0xdc8c,0xd834,0xdc8d,0xd834,0xdc8e,0xd834,0xdc8f,0xd834,0xdc90,
       
  1284 	0xd834,0xdc91,0xd834,0xdc92,0xd834,0xdc93,0xd834,0xdc94,0xd834,0xdc95,
       
  1285 	0xd834,0xdc96,0xd834,0xdc97,0xd834,0xdc98,0xd834,0xdc99,0xd834,0xdc9a,
       
  1286 	0xd834,0xdc9b,0xd834,0xdc9c,0xd834,0xdc9d,0xd834,0xdc9e,0xd834,0xdc9f,
       
  1287 	0xd834,0xdca0,0xd834,0xdca1,0xd834,0xdca2,0xd834,0xdca3,0xd834,0xdca4,
       
  1288 	0xd834,0xdca5,0xd834,0xdca6,0xd834,0xdca7,0xd834,0xdca8,0xd834,0xdca9,
       
  1289 	0xd834,0xdcaa,0xd834,0xdcab,0xd834,0xdcac,0xd834,0xdcad,0xd834,0xdcae,
       
  1290 	0xd834,0xdcaf,0xd834,0xdcb0,0xd834,0xdcb1,0xd834,0xdcb2,0xd834,0xdcb3,
       
  1291 	0xd834,0xdcb4,0xd834,0xdcb5,0xd834,0xdcb6,0xd834,0xdcb7,0xd834,0xdcb8,
       
  1292 	0xd834,0xdcb9,0xd834,0xdcba,0xd834,0xdcbb,0xd834,0xdcbc,0xd834,0xdcbd,
       
  1293 	0xd834,0xdcbe,0xd834,0xdcbf,0xd834,0xdcc0,0xd834,0xdcc1,0xd834,0xdcc2,
       
  1294 	0xd834,0xdcc3,0xd834,0xdcc4,0xd834,0xdcc5,0xd834,0xdcc6,0xd834,0xdcc7,
       
  1295 	0xd834,0xdcc8,0xd834,0xdcc9,0xd834,0xdcca,0xd834,0xdccb,0xd834,0xdccc,
       
  1296 	0xd834,0xdccd,0xd834,0xdcce,0xd834,0xdccf,0xd834,0xdcd0,0xd834,0xdcd1,
       
  1297 	0xd834,0xdcd2,0xd834,0xdcd3,0xd834,0xdcd4,0xd834,0xdcd5,0xd834,0xdcd6,
       
  1298 	0xd834,0xdcd7,0xd834,0xdcd8,0xd834,0xdcd9,0xd834,0xdcda,0xd834,0xdcdb,
       
  1299 	0xd834,0xdcdc,0xd834,0xdcdd,0xd834,0xdcde,0xd834,0xdcdf,0xd834,0xdce0,
       
  1300 	0xd834,0xdce1,0xd834,0xdce2,0xd834,0xdce3,0xd834,0xdce4,0xd834,0xdce5,
       
  1301 	0xd834,0xdce6,0xd834,0xdce7,0xd834,0xdce8,0xd834,0xdce9,0xd834,0xdcea,
       
  1302 	0xd834,0xdceb,0xd834,0xdcec,0xd834,0xdced,0xd834,0xdcee,0xd834,0xdcef,
       
  1303 	0xd834,0xdcf0,0xd834,0xdcf1,0xd834,0xdcf2,0xd834,0xdcf3,0xd834,0xdcf4,
       
  1304 	0xd834,0xdcf5,0xd834,0xdd00,0xd834,0xdd01,0xd834,0xdd02,0xd834,0xdd03,
       
  1305 	0xd834,0xdd04,0xd834,0xdd05,0xd834,0xdd06,0xd834,0xdd07,0xd834,0xdd08,
       
  1306 	0xd834,0xdd09,0xd834,0xdd0a,0xd834,0xdd0b,0xd834,0xdd0c,0xd834,0xdd0d,
       
  1307 	0xd834,0xdd0e,0xd834,0xdd0f,0xd834,0xdd10,0xd834,0xdd11,0xd834,0xdd12,
       
  1308 	0xd834,0xdd13,0xd834,0xdd14,0xd834,0xdd15,0xd834,0xdd16,0xd834,0xdd17,
       
  1309 	0xd834,0xdd18,0xd834,0xdd19,0xd834,0xdd1a,0xd834,0xdd1b,0xd834,0xdd1c,
       
  1310 	0xd834,0xdd1d,0xd834,0xdd1e,0xd834,0xdd1f,0xd834,0xdd20,0xd834,0xdd21,
       
  1311 	0xd834,0xdd22,0xd834,0xdd23,0xd834,0xdd24,0xd834,0xdd25,0xd834,0xdd26,
       
  1312 	0xd834,0xdd2a,0xd834,0xdd2b,0xd834,0xdd2c,0xd834,0xdd2d,0xd834,0xdd2e,
       
  1313 	0xd834,0xdd2f,0xd834,0xdd30,0xd834,0xdd31,0xd834,0xdd32,0xd834,0xdd33,
       
  1314 	0xd834,0xdd34,0xd834,0xdd35,0xd834,0xdd36,0xd834,0xdd37,0xd834,0xdd38,
       
  1315 	0xd834,0xdd39,0xd834,0xdd3a,0xd834,0xdd3b,0xd834,0xdd3c,0xd834,0xdd3d,
       
  1316 	0xd834,0xdd3e,0xd834,0xdd3f,0xd834,0xdd40,0xd834,0xdd41,0xd834,0xdd42,
       
  1317 	0xd834,0xdd43,0xd834,0xdd44,0xd834,0xdd45,0xd834,0xdd46,0xd834,0xdd47,
       
  1318 	0xd834,0xdd48,0xd834,0xdd49,0xd834,0xdd4a,0xd834,0xdd4b,0xd834,0xdd4c,
       
  1319 	0xd834,0xdd4d,0xd834,0xdd4e,0xd834,0xdd4f,0xd834,0xdd50,0xd834,0xdd51,
       
  1320 	0xd834,0xdd52,0xd834,0xdd53,0xd834,0xdd54,0xd834,0xdd55,0xd834,0xdd56,
       
  1321 	0xd834,0xdd57,0xd834,0xdd58,0xd834,0xdd59,0xd834,0xdd5a,0xd834,0xdd5b,
       
  1322 	0xd834,0xdd5c,0xd834,0xdd5d,0xd834,0xdd5e,0xd834,0xdd5f,0xd834,0xdd60,
       
  1323 	0xd834,0xdd61,0xd834,0xdd62,0xd834,0xdd63,0xd834,0xdd64,0xd834,0xdd6a,
       
  1324 	0xd834,0xdd6b,0xd834,0xdd6c,0xd834,0xdd83,0xd834,0xdd84,0xd834,0xdd8c,
       
  1325 	0xd834,0xdd8d,0xd834,0xdd8e,0xd834,0xdd8f,0xd834,0xdd90,0xd834,0xdd91,
       
  1326 	0xd834,0xdd92,0xd834,0xdd93,0xd834,0xdd94,0xd834,0xdd95,0xd834,0xdd96,
       
  1327 	0xd834,0xdd97,0xd834,0xdd98,0xd834,0xdd99,0xd834,0xdd9a,0xd834,0xdd9b,
       
  1328 	0xd834,0xdd9c,0xd834,0xdd9d,0xd834,0xdd9e,0xd834,0xdd9f,0xd834,0xdda0,
       
  1329 	0xd834,0xdda1,0xd834,0xdda2,0xd834,0xdda3,0xd834,0xdda4,0xd834,0xdda5,
       
  1330 	0xd834,0xdda6,0xd834,0xdda7,0xd834,0xdda8,0xd834,0xdda9,0xd834,0xddae,
       
  1331 	0xd834,0xddaf,0xd834,0xddb0,0xd834,0xddb1,0xd834,0xddb2,0xd834,0xddb3,
       
  1332 	0xd834,0xddb4,0xd834,0xddb5,0xd834,0xddb6,0xd834,0xddb7,0xd834,0xddb8,
       
  1333 	0xd834,0xddb9,0xd834,0xddba,0xd834,0xddbb,0xd834,0xddbc,0xd834,0xddbd,
       
  1334 	0xd834,0xddbe,0xd834,0xddbf,0xd834,0xddc0,0xd834,0xddc1,0xd834,0xddc2,
       
  1335 	0xd834,0xddc3,0xd834,0xddc4,0xd834,0xddc5,0xd834,0xddc6,0xd834,0xddc7,
       
  1336 	0xd834,0xddc8,0xd834,0xddc9,0xd834,0xddca,0xd834,0xddcb,0xd834,0xddcc,
       
  1337 	0xd834,0xddcd,0xd834,0xddce,0xd834,0xddcf,0xd834,0xddd0,0xd834,0xddd1,
       
  1338 	0xd834,0xddd2,0xd834,0xddd3,0xd834,0xddd4,0xd834,0xddd5,0xd834,0xddd6,
       
  1339 	0xd834,0xddd7,0xd834,0xddd8,0xd834,0xddd9,0xd834,0xddda,0xd834,0xdddb,
       
  1340 	0xd834,0xdddc,0xd834,0xdddd,0xd834,0xdf60,0xd834,0xdf61,0xd834,0xdf62,
       
  1341 	0xd834,0xdf63,0xd834,0xdf64,0xd834,0xdf65,0xd834,0xdf66,0xd834,0xdf67,
       
  1342 	0xd834,0xdf68,0xd834,0xdf69,0xd834,0xdf6a,0xd834,0xdf6b,0xd834,0xdf6c,
       
  1343 	0xd834,0xdf6d,0xd834,0xdf6e,0xd834,0xdf6f,0xd834,0xdf70,0xd834,0xdf71,
       
  1344 	0xd835,0xdc00,0xd835,0xdc01,0xd835,0xdc02,0xd835,0xdc03,0xd835,0xdc04,
       
  1345 	0xd835,0xdc05,0xd835,0xdc06,0xd835,0xdc07,0xd835,0xdc08,0xd835,0xdc09,
       
  1346 	0xd835,0xdc0a,0xd835,0xdc0b,0xd835,0xdc0c,0xd835,0xdc0d,0xd835,0xdc0e,
       
  1347 	0xd835,0xdc0f,0xd835,0xdc10,0xd835,0xdc11,0xd835,0xdc12,0xd835,0xdc13,
       
  1348 	0xd835,0xdc14,0xd835,0xdc15,0xd835,0xdc16,0xd835,0xdc17,0xd835,0xdc18,
       
  1349 	0xd835,0xdc19,0xd835,0xdc1a,0xd835,0xdc1b,0xd835,0xdc1c,0xd835,0xdc1d,
       
  1350 	0xd835,0xdc1e,0xd835,0xdc1f,0xd835,0xdc20,0xd835,0xdc21,0xd835,0xdc22,
       
  1351 	0xd835,0xdc23,0xd835,0xdc24,0xd835,0xdc25,0xd835,0xdc26,0xd835,0xdc27,
       
  1352 	0xd835,0xdc28,0xd835,0xdc29,0xd835,0xdc2a,0xd835,0xdc2b,0xd835,0xdc2c,
       
  1353 	0xd835,0xdc2d,0xd835,0xdc2e,0xd835,0xdc2f,0xd835,0xdc30,0xd835,0xdc31,
       
  1354 	0xd835,0xdc32,0xd835,0xdc33,0xd835,0xdc34,0xd835,0xdc35,0xd835,0xdc36,
       
  1355 	0xd835,0xdc37,0xd835,0xdc38,0xd835,0xdc39,0xd835,0xdc3a,0xd835,0xdc3b,
       
  1356 	0xd835,0xdc3c,0xd835,0xdc3d,0xd835,0xdc3e,0xd835,0xdc3f,0xd835,0xdc40,
       
  1357 	0xd835,0xdc41,0xd835,0xdc42,0xd835,0xdc43,0xd835,0xdc44,0xd835,0xdc45,
       
  1358 	0xd835,0xdc46,0xd835,0xdc47,0xd835,0xdc48,0xd835,0xdc49,0xd835,0xdc4a,
       
  1359 	0xd835,0xdc4b,0xd835,0xdc4c,0xd835,0xdc4d,0xd835,0xdc4e,0xd835,0xdc4f,
       
  1360 	0xd835,0xdc50,0xd835,0xdc51,0xd835,0xdc52,0xd835,0xdc53,0xd835,0xdc54,
       
  1361 	0xd835,0xdc56,0xd835,0xdc57,0xd835,0xdc58,0xd835,0xdc59,0xd835,0xdc5a,
       
  1362 	0xd835,0xdc5b,0xd835,0xdc5c,0xd835,0xdc5d,0xd835,0xdc5e,0xd835,0xdc5f,
       
  1363 	0xd835,0xdc60,0xd835,0xdc61,0xd835,0xdc62,0xd835,0xdc63,0xd835,0xdc64,
       
  1364 	0xd835,0xdc65,0xd835,0xdc66,0xd835,0xdc67,0xd835,0xdc68,0xd835,0xdc69,
       
  1365 	0xd835,0xdc6a,0xd835,0xdc6b,0xd835,0xdc6c,0xd835,0xdc6d,0xd835,0xdc6e,
       
  1366 	0xd835,0xdc6f,0xd835,0xdc70,0xd835,0xdc71,0xd835,0xdc72,0xd835,0xdc73,
       
  1367 	0xd835,0xdc74,0xd835,0xdc75,0xd835,0xdc76,0xd835,0xdc77,0xd835,0xdc78,
       
  1368 	0xd835,0xdc79,0xd835,0xdc7a,0xd835,0xdc7b,0xd835,0xdc7c,0xd835,0xdc7d,
       
  1369 	0xd835,0xdc7e,0xd835,0xdc7f,0xd835,0xdc80,0xd835,0xdc81,0xd835,0xdc82,
       
  1370 	0xd835,0xdc83,0xd835,0xdc84,0xd835,0xdc85,0xd835,0xdc86,0xd835,0xdc87,
       
  1371 	0xd835,0xdc88,0xd835,0xdc89,0xd835,0xdc8a,0xd835,0xdc8b,0xd835,0xdc8c,
       
  1372 	0xd835,0xdc8d,0xd835,0xdc8e,0xd835,0xdc8f,0xd835,0xdc90,0xd835,0xdc91,
       
  1373 	0xd835,0xdc92,0xd835,0xdc93,0xd835,0xdc94,0xd835,0xdc95,0xd835,0xdc96,
       
  1374 	0xd835,0xdc97,0xd835,0xdc98,0xd835,0xdc99,0xd835,0xdc9a,0xd835,0xdc9b,
       
  1375 	0xd835,0xdc9c,0xd835,0xdc9e,0xd835,0xdc9f,0xd835,0xdca2,0xd835,0xdca5,
       
  1376 	0xd835,0xdca6,0xd835,0xdca9,0xd835,0xdcaa,0xd835,0xdcab,0xd835,0xdcac,
       
  1377 	0xd835,0xdcae,0xd835,0xdcaf,0xd835,0xdcb0,0xd835,0xdcb1,0xd835,0xdcb2,
       
  1378 	0xd835,0xdcb3,0xd835,0xdcb4,0xd835,0xdcb5,0xd835,0xdcb6,0xd835,0xdcb7,
       
  1379 	0xd835,0xdcb8,0xd835,0xdcb9,0xd835,0xdcbb,0xd835,0xdcbd,0xd835,0xdcbe,
       
  1380 	0xd835,0xdcbf,0xd835,0xdcc0,0xd835,0xdcc1,0xd835,0xdcc2,0xd835,0xdcc3,
       
  1381 	0xd835,0xdcc5,0xd835,0xdcc6,0xd835,0xdcc7,0xd835,0xdcc8,0xd835,0xdcc9,
       
  1382 	0xd835,0xdcca,0xd835,0xdccb,0xd835,0xdccc,0xd835,0xdccd,0xd835,0xdcce,
       
  1383 	0xd835,0xdccf,0xd835,0xdcd0,0xd835,0xdcd1,0xd835,0xdcd2,0xd835,0xdcd3,
       
  1384 	0xd835,0xdcd4,0xd835,0xdcd5,0xd835,0xdcd6,0xd835,0xdcd7,0xd835,0xdcd8,
       
  1385 	0xd835,0xdcd9,0xd835,0xdcda,0xd835,0xdcdb,0xd835,0xdcdc,0xd835,0xdcdd,
       
  1386 	0xd835,0xdcde,0xd835,0xdcdf,0xd835,0xdce0,0xd835,0xdce1,0xd835,0xdce2,
       
  1387 	0xd835,0xdce3,0xd835,0xdce4,0xd835,0xdce5,0xd835,0xdce6,0xd835,0xdce7,
       
  1388 	0xd835,0xdce8,0xd835,0xdce9,0xd835,0xdcea,0xd835,0xdceb,0xd835,0xdcec,
       
  1389 	0xd835,0xdced,0xd835,0xdcee,0xd835,0xdcef,0xd835,0xdcf0,0xd835,0xdcf1,
       
  1390 	0xd835,0xdcf2,0xd835,0xdcf3,0xd835,0xdcf4,0xd835,0xdcf5,0xd835,0xdcf6,
       
  1391 	0xd835,0xdcf7,0xd835,0xdcf8,0xd835,0xdcf9,0xd835,0xdcfa,0xd835,0xdcfb,
       
  1392 	0xd835,0xdcfc,0xd835,0xdcfd,0xd835,0xdcfe,0xd835,0xdcff,0xd835,0xdd00,
       
  1393 	0xd835,0xdd01,0xd835,0xdd02,0xd835,0xdd03,0xd835,0xdd04,0xd835,0xdd05,
       
  1394 	0xd835,0xdd07,0xd835,0xdd08,0xd835,0xdd09,0xd835,0xdd0a,0xd835,0xdd0d,
       
  1395 	0xd835,0xdd0e,0xd835,0xdd0f,0xd835,0xdd10,0xd835,0xdd11,0xd835,0xdd12,
       
  1396 	0xd835,0xdd13,0xd835,0xdd14,0xd835,0xdd16,0xd835,0xdd17,0xd835,0xdd18,
       
  1397 	0xd835,0xdd19,0xd835,0xdd1a,0xd835,0xdd1b,0xd835,0xdd1c,0xd835,0xdd1e,
       
  1398 	0xd835,0xdd1f,0xd835,0xdd20,0xd835,0xdd21,0xd835,0xdd22,0xd835,0xdd23,
       
  1399 	0xd835,0xdd24,0xd835,0xdd25,0xd835,0xdd26,0xd835,0xdd27,0xd835,0xdd28,
       
  1400 	0xd835,0xdd29,0xd835,0xdd2a,0xd835,0xdd2b,0xd835,0xdd2c,0xd835,0xdd2d,
       
  1401 	0xd835,0xdd2e,0xd835,0xdd2f,0xd835,0xdd30,0xd835,0xdd31,0xd835,0xdd32,
       
  1402 	0xd835,0xdd33,0xd835,0xdd34,0xd835,0xdd35,0xd835,0xdd36,0xd835,0xdd37,
       
  1403 	0xd835,0xdd38,0xd835,0xdd39,0xd835,0xdd3b,0xd835,0xdd3c,0xd835,0xdd3d,
       
  1404 	0xd835,0xdd3e,0xd835,0xdd40,0xd835,0xdd41,0xd835,0xdd42,0xd835,0xdd43,
       
  1405 	0xd835,0xdd44,0xd835,0xdd46,0xd835,0xdd4a,0xd835,0xdd4b,0xd835,0xdd4c,
       
  1406 	0xd835,0xdd4d,0xd835,0xdd4e,0xd835,0xdd4f,0xd835,0xdd50,0xd835,0xdd52,
       
  1407 	0xd835,0xdd53,0xd835,0xdd54,0xd835,0xdd55,0xd835,0xdd56,0xd835,0xdd57,
       
  1408 	0xd835,0xdd58,0xd835,0xdd59,0xd835,0xdd5a,0xd835,0xdd5b,0xd835,0xdd5c,
       
  1409 	0xd835,0xdd5d,0xd835,0xdd5e,0xd835,0xdd5f,0xd835,0xdd60,0xd835,0xdd61,
       
  1410 	0xd835,0xdd62,0xd835,0xdd63,0xd835,0xdd64,0xd835,0xdd65,0xd835,0xdd66,
       
  1411 	0xd835,0xdd67,0xd835,0xdd68,0xd835,0xdd69,0xd835,0xdd6a,0xd835,0xdd6b,
       
  1412 	0xd835,0xdd6c,0xd835,0xdd6d,0xd835,0xdd6e,0xd835,0xdd6f,0xd835,0xdd70,
       
  1413 	0xd835,0xdd71,0xd835,0xdd72,0xd835,0xdd73,0xd835,0xdd74,0xd835,0xdd75,
       
  1414 	0xd835,0xdd76,0xd835,0xdd77,0xd835,0xdd78,0xd835,0xdd79,0xd835,0xdd7a,
       
  1415 	0xd835,0xdd7b,0xd835,0xdd7c,0xd835,0xdd7d,0xd835,0xdd7e,0xd835,0xdd7f,
       
  1416 	0xd835,0xdd80,0xd835,0xdd81,0xd835,0xdd82,0xd835,0xdd83,0xd835,0xdd84,
       
  1417 	0xd835,0xdd85,0xd835,0xdd86,0xd835,0xdd87,0xd835,0xdd88,0xd835,0xdd89,
       
  1418 	0xd835,0xdd8a,0xd835,0xdd8b,0xd835,0xdd8c,0xd835,0xdd8d,0xd835,0xdd8e,
       
  1419 	0xd835,0xdd8f,0xd835,0xdd90,0xd835,0xdd91,0xd835,0xdd92,0xd835,0xdd93,
       
  1420 	0xd835,0xdd94,0xd835,0xdd95,0xd835,0xdd96,0xd835,0xdd97,0xd835,0xdd98,
       
  1421 	0xd835,0xdd99,0xd835,0xdd9a,0xd835,0xdd9b,0xd835,0xdd9c,0xd835,0xdd9d,
       
  1422 	0xd835,0xdd9e,0xd835,0xdd9f,0xd835,0xdda0,0xd835,0xdda1,0xd835,0xdda2,
       
  1423 	0xd835,0xdda3,0xd835,0xdda4,0xd835,0xdda5,0xd835,0xdda6,0xd835,0xdda7,
       
  1424 	0xd835,0xdda8,0xd835,0xdda9,0xd835,0xddaa,0xd835,0xddab,0xd835,0xddac,
       
  1425 	0xd835,0xddad,0xd835,0xddae,0xd835,0xddaf,0xd835,0xddb0,0xd835,0xddb1,
       
  1426 	0xd835,0xddb2,0xd835,0xddb3,0xd835,0xddb4,0xd835,0xddb5,0xd835,0xddb6,
       
  1427 	0xd835,0xddb7,0xd835,0xddb8,0xd835,0xddb9,0xd835,0xddba,0xd835,0xddbb,
       
  1428 	0xd835,0xddbc,0xd835,0xddbd,0xd835,0xddbe,0xd835,0xddbf,0xd835,0xddc0,
       
  1429 	0xd835,0xddc1,0xd835,0xddc2,0xd835,0xddc3,0xd835,0xddc4,0xd835,0xddc5,
       
  1430 	0xd835,0xddc6,0xd835,0xddc7,0xd835,0xddc8,0xd835,0xddc9,0xd835,0xddca,
       
  1431 	0xd835,0xddcb,0xd835,0xddcc,0xd835,0xddcd,0xd835,0xddce,0xd835,0xddcf,
       
  1432 	0xd835,0xddd0,0xd835,0xddd1,0xd835,0xddd2,0xd835,0xddd3,0xd835,0xddd4,
       
  1433 	0xd835,0xddd5,0xd835,0xddd6,0xd835,0xddd7,0xd835,0xddd8,0xd835,0xddd9,
       
  1434 	0xd835,0xddda,0xd835,0xdddb,0xd835,0xdddc,0xd835,0xdddd,0xd835,0xddde,
       
  1435 	0xd835,0xdddf,0xd835,0xdde0,0xd835,0xdde1,0xd835,0xdde2,0xd835,0xdde3,
       
  1436 	0xd835,0xdde4,0xd835,0xdde5,0xd835,0xdde6,0xd835,0xdde7,0xd835,0xdde8,
       
  1437 	0xd835,0xdde9,0xd835,0xddea,0xd835,0xddeb,0xd835,0xddec,0xd835,0xdded,
       
  1438 	0xd835,0xddee,0xd835,0xddef,0xd835,0xddf0,0xd835,0xddf1,0xd835,0xddf2,
       
  1439 	0xd835,0xddf3,0xd835,0xddf4,0xd835,0xddf5,0xd835,0xddf6,0xd835,0xddf7,
       
  1440 	0xd835,0xddf8,0xd835,0xddf9,0xd835,0xddfa,0xd835,0xddfb,0xd835,0xddfc,
       
  1441 	0xd835,0xddfd,0xd835,0xddfe,0xd835,0xddff,0xd835,0xde00,0xd835,0xde01,
       
  1442 	0xd835,0xde02,0xd835,0xde03,0xd835,0xde04,0xd835,0xde05,0xd835,0xde06,
       
  1443 	0xd835,0xde07,0xd835,0xde08,0xd835,0xde09,0xd835,0xde0a,0xd835,0xde0b,
       
  1444 	0xd835,0xde0c,0xd835,0xde0d,0xd835,0xde0e,0xd835,0xde0f,0xd835,0xde10,
       
  1445 	0xd835,0xde11,0xd835,0xde12,0xd835,0xde13,0xd835,0xde14,0xd835,0xde15,
       
  1446 	0xd835,0xde16,0xd835,0xde17,0xd835,0xde18,0xd835,0xde19,0xd835,0xde1a,
       
  1447 	0xd835,0xde1b,0xd835,0xde1c,0xd835,0xde1d,0xd835,0xde1e,0xd835,0xde1f,
       
  1448 	0xd835,0xde20,0xd835,0xde21,0xd835,0xde22,0xd835,0xde23,0xd835,0xde24,
       
  1449 	0xd835,0xde25,0xd835,0xde26,0xd835,0xde27,0xd835,0xde28,0xd835,0xde29,
       
  1450 	0xd835,0xde2a,0xd835,0xde2b,0xd835,0xde2c,0xd835,0xde2d,0xd835,0xde2e,
       
  1451 	0xd835,0xde2f,0xd835,0xde30,0xd835,0xde31,0xd835,0xde32,0xd835,0xde33,
       
  1452 	0xd835,0xde34,0xd835,0xde35,0xd835,0xde36,0xd835,0xde37,0xd835,0xde38,
       
  1453 	0xd835,0xde39,0xd835,0xde3a,0xd835,0xde3b,0xd835,0xde3c,0xd835,0xde3d,
       
  1454 	0xd835,0xde3e,0xd835,0xde3f,0xd835,0xde40,0xd835,0xde41,0xd835,0xde42,
       
  1455 	0xd835,0xde43,0xd835,0xde44,0xd835,0xde45,0xd835,0xde46,0xd835,0xde47,
       
  1456 	0xd835,0xde48,0xd835,0xde49,0xd835,0xde4a,0xd835,0xde4b,0xd835,0xde4c,
       
  1457 	0xd835,0xde4d,0xd835,0xde4e,0xd835,0xde4f,0xd835,0xde50,0xd835,0xde51,
       
  1458 	0xd835,0xde52,0xd835,0xde53,0xd835,0xde54,0xd835,0xde55,0xd835,0xde56,
       
  1459 	0xd835,0xde57,0xd835,0xde58,0xd835,0xde59,0xd835,0xde5a,0xd835,0xde5b,
       
  1460 	0xd835,0xde5c,0xd835,0xde5d,0xd835,0xde5e,0xd835,0xde5f,0xd835,0xde60,
       
  1461 	0xd835,0xde61,0xd835,0xde62,0xd835,0xde63,0xd835,0xde64,0xd835,0xde65,
       
  1462 	0xd835,0xde66,0xd835,0xde67,0xd835,0xde68,0xd835,0xde69,0xd835,0xde6a,
       
  1463 	0xd835,0xde6b,0xd835,0xde6c,0xd835,0xde6d,0xd835,0xde6e,0xd835,0xde6f,
       
  1464 	0xd835,0xde70,0xd835,0xde71,0xd835,0xde72,0xd835,0xde73,0xd835,0xde74,
       
  1465 	0xd835,0xde75,0xd835,0xde76,0xd835,0xde77,0xd835,0xde78,0xd835,0xde79,
       
  1466 	0xd835,0xde7a,0xd835,0xde7b,0xd835,0xde7c,0xd835,0xde7d,0xd835,0xde7e,
       
  1467 	0xd835,0xde7f,0xd835,0xde80,0xd835,0xde81,0xd835,0xde82,0xd835,0xde83,
       
  1468 	0xd835,0xde84,0xd835,0xde85,0xd835,0xde86,0xd835,0xde87,0xd835,0xde88,
       
  1469 	0xd835,0xde89,0xd835,0xde8a,0xd835,0xde8b,0xd835,0xde8c,0xd835,0xde8d,
       
  1470 	0xd835,0xde8e,0xd835,0xde8f,0xd835,0xde90,0xd835,0xde91,0xd835,0xde92,
       
  1471 	0xd835,0xde93,0xd835,0xde94,0xd835,0xde95,0xd835,0xde96,0xd835,0xde97,
       
  1472 	0xd835,0xde98,0xd835,0xde99,0xd835,0xde9a,0xd835,0xde9b,0xd835,0xde9c,
       
  1473 	0xd835,0xde9d,0xd835,0xde9e,0xd835,0xde9f,0xd835,0xdea0,0xd835,0xdea1,
       
  1474 	0xd835,0xdea2,0xd835,0xdea3,0xd835,0xdea4,0xd835,0xdea5,0xd835,0xdea8,
       
  1475 	0xd835,0xdea9,0xd835,0xdeaa,0xd835,0xdeab,0xd835,0xdeac,0xd835,0xdead,
       
  1476 	0xd835,0xdeae,0xd835,0xdeaf,0xd835,0xdeb0,0xd835,0xdeb1,0xd835,0xdeb2,
       
  1477 	0xd835,0xdeb3,0xd835,0xdeb4,0xd835,0xdeb5,0xd835,0xdeb6,0xd835,0xdeb7,
       
  1478 	0xd835,0xdeb8,0xd835,0xdeb9,0xd835,0xdeba,0xd835,0xdebb,0xd835,0xdebc,
       
  1479 	0xd835,0xdebd,0xd835,0xdebe,0xd835,0xdebf,0xd835,0xdec0,0xd835,0xdec1,
       
  1480 	0xd835,0xdec2,0xd835,0xdec3,0xd835,0xdec4,0xd835,0xdec5,0xd835,0xdec6,
       
  1481 	0xd835,0xdec7,0xd835,0xdec8,0xd835,0xdec9,0xd835,0xdeca,0xd835,0xdecb,
       
  1482 	0xd835,0xdecc,0xd835,0xdecd,0xd835,0xdece,0xd835,0xdecf,0xd835,0xded0,
       
  1483 	0xd835,0xded1,0xd835,0xded2,0xd835,0xded3,0xd835,0xded4,0xd835,0xded5,
       
  1484 	0xd835,0xded6,0xd835,0xded7,0xd835,0xded8,0xd835,0xded9,0xd835,0xdeda,
       
  1485 	0xd835,0xdedb,0xd835,0xdedc,0xd835,0xdedd,0xd835,0xdede,0xd835,0xdedf,
       
  1486 	0xd835,0xdee0,0xd835,0xdee1,0xd835,0xdee2,0xd835,0xdee3,0xd835,0xdee4,
       
  1487 	0xd835,0xdee5,0xd835,0xdee6,0xd835,0xdee7,0xd835,0xdee8,0xd835,0xdee9,
       
  1488 	0xd835,0xdeea,0xd835,0xdeeb,0xd835,0xdeec,0xd835,0xdeed,0xd835,0xdeee,
       
  1489 	0xd835,0xdeef,0xd835,0xdef0,0xd835,0xdef1,0xd835,0xdef2,0xd835,0xdef3,
       
  1490 	0xd835,0xdef4,0xd835,0xdef5,0xd835,0xdef6,0xd835,0xdef7,0xd835,0xdef8,
       
  1491 	0xd835,0xdef9,0xd835,0xdefa,0xd835,0xdefb,0xd835,0xdefc,0xd835,0xdefd,
       
  1492 	0xd835,0xdefe,0xd835,0xdeff,0xd835,0xdf00,0xd835,0xdf01,0xd835,0xdf02,
       
  1493 	0xd835,0xdf03,0xd835,0xdf04,0xd835,0xdf05,0xd835,0xdf06,0xd835,0xdf07,
       
  1494 	0xd835,0xdf08,0xd835,0xdf09,0xd835,0xdf0a,0xd835,0xdf0b,0xd835,0xdf0c,
       
  1495 	0xd835,0xdf0d,0xd835,0xdf0e,0xd835,0xdf0f,0xd835,0xdf10,0xd835,0xdf11,
       
  1496 	0xd835,0xdf12,0xd835,0xdf13,0xd835,0xdf14,0xd835,0xdf15,0xd835,0xdf16,
       
  1497 	0xd835,0xdf17,0xd835,0xdf18,0xd835,0xdf19,0xd835,0xdf1a,0xd835,0xdf1b,
       
  1498 	0xd835,0xdf1c,0xd835,0xdf1d,0xd835,0xdf1e,0xd835,0xdf1f,0xd835,0xdf20,
       
  1499 	0xd835,0xdf21,0xd835,0xdf22,0xd835,0xdf23,0xd835,0xdf24,0xd835,0xdf25,
       
  1500 	0xd835,0xdf26,0xd835,0xdf27,0xd835,0xdf28,0xd835,0xdf29,0xd835,0xdf2a,
       
  1501 	0xd835,0xdf2b,0xd835,0xdf2c,0xd835,0xdf2d,0xd835,0xdf2e,0xd835,0xdf2f,
       
  1502 	0xd835,0xdf30,0xd835,0xdf31,0xd835,0xdf32,0xd835,0xdf33,0xd835,0xdf34,
       
  1503 	0xd835,0xdf35,0xd835,0xdf36,0xd835,0xdf37,0xd835,0xdf38,0xd835,0xdf39,
       
  1504 	0xd835,0xdf3a,0xd835,0xdf3b,0xd835,0xdf3c,0xd835,0xdf3d,0xd835,0xdf3e,
       
  1505 	0xd835,0xdf3f,0xd835,0xdf40,0xd835,0xdf41,0xd835,0xdf42,0xd835,0xdf43,
       
  1506 	0xd835,0xdf44,0xd835,0xdf45,0xd835,0xdf46,0xd835,0xdf47,0xd835,0xdf48,
       
  1507 	0xd835,0xdf49,0xd835,0xdf4a,0xd835,0xdf4b,0xd835,0xdf4c,0xd835,0xdf4d,
       
  1508 	0xd835,0xdf4e,0xd835,0xdf4f,0xd835,0xdf50,0xd835,0xdf51,0xd835,0xdf52,
       
  1509 	0xd835,0xdf53,0xd835,0xdf54,0xd835,0xdf55,0xd835,0xdf56,0xd835,0xdf57,
       
  1510 	0xd835,0xdf58,0xd835,0xdf59,0xd835,0xdf5a,0xd835,0xdf5b,0xd835,0xdf5c,
       
  1511 	0xd835,0xdf5d,0xd835,0xdf5e,0xd835,0xdf5f,0xd835,0xdf60,0xd835,0xdf61,
       
  1512 	0xd835,0xdf62,0xd835,0xdf63,0xd835,0xdf64,0xd835,0xdf65,0xd835,0xdf66,
       
  1513 	0xd835,0xdf67,0xd835,0xdf68,0xd835,0xdf69,0xd835,0xdf6a,0xd835,0xdf6b,
       
  1514 	0xd835,0xdf6c,0xd835,0xdf6d,0xd835,0xdf6e,0xd835,0xdf6f,0xd835,0xdf70,
       
  1515 	0xd835,0xdf71,0xd835,0xdf72,0xd835,0xdf73,0xd835,0xdf74,0xd835,0xdf75,
       
  1516 	0xd835,0xdf76,0xd835,0xdf77,0xd835,0xdf78,0xd835,0xdf79,0xd835,0xdf7a,
       
  1517 	0xd835,0xdf7b,0xd835,0xdf7c,0xd835,0xdf7d,0xd835,0xdf7e,0xd835,0xdf7f,
       
  1518 	0xd835,0xdf80,0xd835,0xdf81,0xd835,0xdf82,0xd835,0xdf83,0xd835,0xdf84,
       
  1519 	0xd835,0xdf85,0xd835,0xdf86,0xd835,0xdf87,0xd835,0xdf88,0xd835,0xdf89,
       
  1520 	0xd835,0xdf8a,0xd835,0xdf8b,0xd835,0xdf8c,0xd835,0xdf8d,0xd835,0xdf8e,
       
  1521 	0xd835,0xdf8f,0xd835,0xdf90,0xd835,0xdf91,0xd835,0xdf92,0xd835,0xdf93,
       
  1522 	0xd835,0xdf94,0xd835,0xdf95,0xd835,0xdf96,0xd835,0xdf97,0xd835,0xdf98,
       
  1523 	0xd835,0xdf99,0xd835,0xdf9a,0xd835,0xdf9b,0xd835,0xdf9c,0xd835,0xdf9d,
       
  1524 	0xd835,0xdf9e,0xd835,0xdf9f,0xd835,0xdfa0,0xd835,0xdfa1,0xd835,0xdfa2,
       
  1525 	0xd835,0xdfa3,0xd835,0xdfa4,0xd835,0xdfa5,0xd835,0xdfa6,0xd835,0xdfa7,
       
  1526 	0xd835,0xdfa8,0xd835,0xdfa9,0xd835,0xdfaa,0xd835,0xdfab,0xd835,0xdfac,
       
  1527 	0xd835,0xdfad,0xd835,0xdfae,0xd835,0xdfaf,0xd835,0xdfb0,0xd835,0xdfb1,
       
  1528 	0xd835,0xdfb2,0xd835,0xdfb3,0xd835,0xdfb4,0xd835,0xdfb5,0xd835,0xdfb6,
       
  1529 	0xd835,0xdfb7,0xd835,0xdfb8,0xd835,0xdfb9,0xd835,0xdfba,0xd835,0xdfbb,
       
  1530 	0xd835,0xdfbc,0xd835,0xdfbd,0xd835,0xdfbe,0xd835,0xdfbf,0xd835,0xdfc0,
       
  1531 	0xd835,0xdfc1,0xd835,0xdfc2,0xd835,0xdfc3,0xd835,0xdfc4,0xd835,0xdfc5,
       
  1532 	0xd835,0xdfc6,0xd835,0xdfc7,0xd835,0xdfc8,0xd835,0xdfc9,0xd835,0xdfca,
       
  1533 	0xd835,0xdfcb,0xd840,0xdc00,0xd869,0xded6,0xd87e,0xdc00,0xd87e,0xdc01,
       
  1534 	0xd87e,0xdc02,0xd87e,0xdc03,0xd87e,0xdc04,0xd87e,0xdc05,0xd87e,0xdc06,
       
  1535 	0xd87e,0xdc07,0xd87e,0xdc08,0xd87e,0xdc09,0xd87e,0xdc0a,0xd87e,0xdc0b,
       
  1536 	0xd87e,0xdc0c,0xd87e,0xdc0d,0xd87e,0xdc0e,0xd87e,0xdc0f,0xd87e,0xdc10,
       
  1537 	0xd87e,0xdc11,0xd87e,0xdc12,0xd87e,0xdc13,0xd87e,0xdc14,0xd87e,0xdc15,
       
  1538 	0xd87e,0xdc16,0xd87e,0xdc17,0xd87e,0xdc18,0xd87e,0xdc19,0xd87e,0xdc1a,
       
  1539 	0xd87e,0xdc1b,0xd87e,0xdc1c,0xd87e,0xdc1d,0xd87e,0xdc1e,0xd87e,0xdc1f,
       
  1540 	0xd87e,0xdc20,0xd87e,0xdc21,0xd87e,0xdc22,0xd87e,0xdc23,0xd87e,0xdc24,
       
  1541 	0xd87e,0xdc25,0xd87e,0xdc26,0xd87e,0xdc27,0xd87e,0xdc28,0xd87e,0xdc29,
       
  1542 	0xd87e,0xdc2a,0xd87e,0xdc2b,0xd87e,0xdc2c,0xd87e,0xdc2d,0xd87e,0xdc2e,
       
  1543 	0xd87e,0xdc2f,0xd87e,0xdc30,0xd87e,0xdc31,0xd87e,0xdc32,0xd87e,0xdc33,
       
  1544 	0xd87e,0xdc34,0xd87e,0xdc35,0xd87e,0xdc36,0xd87e,0xdc37,0xd87e,0xdc38,
       
  1545 	0xd87e,0xdc39,0xd87e,0xdc3a,0xd87e,0xdc3b,0xd87e,0xdc3c,0xd87e,0xdc3d,
       
  1546 	0xd87e,0xdc3e,0xd87e,0xdc3f,0xd87e,0xdc40,0xd87e,0xdc41,0xd87e,0xdc42,
       
  1547 	0xd87e,0xdc43,0xd87e,0xdc44,0xd87e,0xdc45,0xd87e,0xdc46,0xd87e,0xdc47,
       
  1548 	0xd87e,0xdc48,0xd87e,0xdc49,0xd87e,0xdc4a,0xd87e,0xdc4b,0xd87e,0xdc4c,
       
  1549 	0xd87e,0xdc4d,0xd87e,0xdc4e,0xd87e,0xdc4f,0xd87e,0xdc50,0xd87e,0xdc51,
       
  1550 	0xd87e,0xdc52,0xd87e,0xdc53,0xd87e,0xdc54,0xd87e,0xdc55,0xd87e,0xdc56,
       
  1551 	0xd87e,0xdc57,0xd87e,0xdc58,0xd87e,0xdc59,0xd87e,0xdc5a,0xd87e,0xdc5b,
       
  1552 	0xd87e,0xdc5c,0xd87e,0xdc5d,0xd87e,0xdc5e,0xd87e,0xdc5f,0xd87e,0xdc60,
       
  1553 	0xd87e,0xdc61,0xd87e,0xdc62,0xd87e,0xdc63,0xd87e,0xdc64,0xd87e,0xdc65,
       
  1554 	0xd87e,0xdc66,0xd87e,0xdc67,0xd87e,0xdc68,0xd87e,0xdc69,0xd87e,0xdc6a,
       
  1555 	0xd87e,0xdc6b,0xd87e,0xdc6c,0xd87e,0xdc6d,0xd87e,0xdc6e,0xd87e,0xdc6f,
       
  1556 	0xd87e,0xdc70,0xd87e,0xdc71,0xd87e,0xdc72,0xd87e,0xdc73,0xd87e,0xdc74,
       
  1557 	0xd87e,0xdc75,0xd87e,0xdc76,0xd87e,0xdc77,0xd87e,0xdc78,0xd87e,0xdc79,
       
  1558 	0xd87e,0xdc7a,0xd87e,0xdc7b,0xd87e,0xdc7c,0xd87e,0xdc7d,0xd87e,0xdc7e,
       
  1559 	0xd87e,0xdc7f,0xd87e,0xdc80,0xd87e,0xdc81,0xd87e,0xdc82,0xd87e,0xdc83,
       
  1560 	0xd87e,0xdc84,0xd87e,0xdc85,0xd87e,0xdc86,0xd87e,0xdc87,0xd87e,0xdc88,
       
  1561 	0xd87e,0xdc89,0xd87e,0xdc8a,0xd87e,0xdc8b,0xd87e,0xdc8c,0xd87e,0xdc8d,
       
  1562 	0xd87e,0xdc8e,0xd87e,0xdc8f,0xd87e,0xdc90,0xd87e,0xdc91,0xd87e,0xdc92,
       
  1563 	0xd87e,0xdc93,0xd87e,0xdc94,0xd87e,0xdc95,0xd87e,0xdc96,0xd87e,0xdc97,
       
  1564 	0xd87e,0xdc98,0xd87e,0xdc99,0xd87e,0xdc9a,0xd87e,0xdc9b,0xd87e,0xdc9c,
       
  1565 	0xd87e,0xdc9d,0xd87e,0xdc9e,0xd87e,0xdc9f,0xd87e,0xdca0,0xd87e,0xdca1,
       
  1566 	0xd87e,0xdca2,0xd87e,0xdca3,0xd87e,0xdca4,0xd87e,0xdca5,0xd87e,0xdca6,
       
  1567 	0xd87e,0xdca7,0xd87e,0xdca8,0xd87e,0xdca9,0xd87e,0xdcaa,0xd87e,0xdcab,
       
  1568 	0xd87e,0xdcac,0xd87e,0xdcad,0xd87e,0xdcae,0xd87e,0xdcaf,0xd87e,0xdcb0,
       
  1569 	0xd87e,0xdcb1,0xd87e,0xdcb2,0xd87e,0xdcb3,0xd87e,0xdcb4,0xd87e,0xdcb5,
       
  1570 	0xd87e,0xdcb6,0xd87e,0xdcb7,0xd87e,0xdcb8,0xd87e,0xdcb9,0xd87e,0xdcba,
       
  1571 	0xd87e,0xdcbb,0xd87e,0xdcbc,0xd87e,0xdcbd,0xd87e,0xdcbe,0xd87e,0xdcbf,
       
  1572 	0xd87e,0xdcc0,0xd87e,0xdcc1,0xd87e,0xdcc2,0xd87e,0xdcc3,0xd87e,0xdcc4,
       
  1573 	0xd87e,0xdcc5,0xd87e,0xdcc6,0xd87e,0xdcc7,0xd87e,0xdcc8,0xd87e,0xdcc9,
       
  1574 	0xd87e,0xdcca,0xd87e,0xdccb,0xd87e,0xdccc,0xd87e,0xdccd,0xd87e,0xdcce,
       
  1575 	0xd87e,0xdccf,0xd87e,0xdcd0,0xd87e,0xdcd1,0xd87e,0xdcd2,0xd87e,0xdcd3,
       
  1576 	0xd87e,0xdcd4,0xd87e,0xdcd5,0xd87e,0xdcd6,0xd87e,0xdcd7,0xd87e,0xdcd8,
       
  1577 	0xd87e,0xdcd9,0xd87e,0xdcda,0xd87e,0xdcdb,0xd87e,0xdcdc,0xd87e,0xdcdd,
       
  1578 	0xd87e,0xdcde,0xd87e,0xdcdf,0xd87e,0xdce0,0xd87e,0xdce1,0xd87e,0xdce2,
       
  1579 	0xd87e,0xdce3,0xd87e,0xdce4,0xd87e,0xdce5,0xd87e,0xdce6,0xd87e,0xdce7,
       
  1580 	0xd87e,0xdce8,0xd87e,0xdce9,0xd87e,0xdcea,0xd87e,0xdceb,0xd87e,0xdcec,
       
  1581 	0xd87e,0xdced,0xd87e,0xdcee,0xd87e,0xdcef,0xd87e,0xdcf0,0xd87e,0xdcf1,
       
  1582 	0xd87e,0xdcf2,0xd87e,0xdcf3,0xd87e,0xdcf4,0xd87e,0xdcf5,0xd87e,0xdcf6,
       
  1583 	0xd87e,0xdcf7,0xd87e,0xdcf8,0xd87e,0xdcf9,0xd87e,0xdcfa,0xd87e,0xdcfb,
       
  1584 	0xd87e,0xdcfc,0xd87e,0xdcfd,0xd87e,0xdcfe,0xd87e,0xdcff,0xd87e,0xdd00,
       
  1585 	0xd87e,0xdd01,0xd87e,0xdd02,0xd87e,0xdd03,0xd87e,0xdd04,0xd87e,0xdd05,
       
  1586 	0xd87e,0xdd06,0xd87e,0xdd07,0xd87e,0xdd08,0xd87e,0xdd09,0xd87e,0xdd0a,
       
  1587 	0xd87e,0xdd0b,0xd87e,0xdd0c,0xd87e,0xdd0d,0xd87e,0xdd0e,0xd87e,0xdd0f,
       
  1588 	0xd87e,0xdd10,0xd87e,0xdd11,0xd87e,0xdd12,0xd87e,0xdd13,0xd87e,0xdd14,
       
  1589 	0xd87e,0xdd15,0xd87e,0xdd16,0xd87e,0xdd17,0xd87e,0xdd18,0xd87e,0xdd19,
       
  1590 	0xd87e,0xdd1a,0xd87e,0xdd1b,0xd87e,0xdd1c,0xd87e,0xdd1d,0xd87e,0xdd1e,
       
  1591 	0xd87e,0xdd1f,0xd87e,0xdd20,0xd87e,0xdd21,0xd87e,0xdd22,0xd87e,0xdd23,
       
  1592 	0xd87e,0xdd24,0xd87e,0xdd25,0xd87e,0xdd26,0xd87e,0xdd27,0xd87e,0xdd28,
       
  1593 	0xd87e,0xdd29,0xd87e,0xdd2a,0xd87e,0xdd2b,0xd87e,0xdd2c,0xd87e,0xdd2d,
       
  1594 	0xd87e,0xdd2e,0xd87e,0xdd2f,0xd87e,0xdd30,0xd87e,0xdd31,0xd87e,0xdd32,
       
  1595 	0xd87e,0xdd33,0xd87e,0xdd34,0xd87e,0xdd35,0xd87e,0xdd36,0xd87e,0xdd37,
       
  1596 	0xd87e,0xdd38,0xd87e,0xdd39,0xd87e,0xdd3a,0xd87e,0xdd3b,0xd87e,0xdd3c,
       
  1597 	0xd87e,0xdd3d,0xd87e,0xdd3e,0xd87e,0xdd3f,0xd87e,0xdd40,0xd87e,0xdd41,
       
  1598 	0xd87e,0xdd42,0xd87e,0xdd43,0xd87e,0xdd44,0xd87e,0xdd45,0xd87e,0xdd46,
       
  1599 	0xd87e,0xdd47,0xd87e,0xdd48,0xd87e,0xdd49,0xd87e,0xdd4a,0xd87e,0xdd4b,
       
  1600 	0xd87e,0xdd4c,0xd87e,0xdd4d,0xd87e,0xdd4e,0xd87e,0xdd4f,0xd87e,0xdd50,
       
  1601 	0xd87e,0xdd51,0xd87e,0xdd52,0xd87e,0xdd53,0xd87e,0xdd54,0xd87e,0xdd55,
       
  1602 	0xd87e,0xdd56,0xd87e,0xdd57,0xd87e,0xdd58,0xd87e,0xdd59,0xd87e,0xdd5a,
       
  1603 	0xd87e,0xdd5b,0xd87e,0xdd5c,0xd87e,0xdd5d,0xd87e,0xdd5e,0xd87e,0xdd5f,
       
  1604 	0xd87e,0xdd60,0xd87e,0xdd61,0xd87e,0xdd62,0xd87e,0xdd63,0xd87e,0xdd64,
       
  1605 	0xd87e,0xdd65,0xd87e,0xdd66,0xd87e,0xdd67,0xd87e,0xdd68,0xd87e,0xdd69,
       
  1606 	0xd87e,0xdd6a,0xd87e,0xdd6b,0xd87e,0xdd6c,0xd87e,0xdd6d,0xd87e,0xdd6e,
       
  1607 	0xd87e,0xdd6f,0xd87e,0xdd70,0xd87e,0xdd71,0xd87e,0xdd72,0xd87e,0xdd73,
       
  1608 	0xd87e,0xdd74,0xd87e,0xdd75,0xd87e,0xdd76,0xd87e,0xdd77,0xd87e,0xdd78,
       
  1609 	0xd87e,0xdd79,0xd87e,0xdd7a,0xd87e,0xdd7b,0xd87e,0xdd7c,0xd87e,0xdd7d,
       
  1610 	0xd87e,0xdd7e,0xd87e,0xdd7f,0xd87e,0xdd80,0xd87e,0xdd81,0xd87e,0xdd82,
       
  1611 	0xd87e,0xdd83,0xd87e,0xdd84,0xd87e,0xdd85,0xd87e,0xdd86,0xd87e,0xdd87,
       
  1612 	0xd87e,0xdd88,0xd87e,0xdd89,0xd87e,0xdd8a,0xd87e,0xdd8b,0xd87e,0xdd8c,
       
  1613 	0xd87e,0xdd8d,0xd87e,0xdd8e,0xd87e,0xdd8f,0xd87e,0xdd90,0xd87e,0xdd91,
       
  1614 	0xd87e,0xdd92,0xd87e,0xdd93,0xd87e,0xdd94,0xd87e,0xdd95,0xd87e,0xdd96,
       
  1615 	0xd87e,0xdd97,0xd87e,0xdd98,0xd87e,0xdd99,0xd87e,0xdd9a,0xd87e,0xdd9b,
       
  1616 	0xd87e,0xdd9c,0xd87e,0xdd9d,0xd87e,0xdd9e,0xd87e,0xdd9f,0xd87e,0xdda0,
       
  1617 	0xd87e,0xdda1,0xd87e,0xdda2,0xd87e,0xdda3,0xd87e,0xdda4,0xd87e,0xdda5,
       
  1618 	0xd87e,0xdda6,0xd87e,0xdda7,0xd87e,0xdda8,0xd87e,0xdda9,0xd87e,0xddaa,
       
  1619 	0xd87e,0xddab,0xd87e,0xddac,0xd87e,0xddad,0xd87e,0xddae,0xd87e,0xddaf,
       
  1620 	0xd87e,0xddb0,0xd87e,0xddb1,0xd87e,0xddb2,0xd87e,0xddb3,0xd87e,0xddb4,
       
  1621 	0xd87e,0xddb5,0xd87e,0xddb6,0xd87e,0xddb7,0xd87e,0xddb8,0xd87e,0xddb9,
       
  1622 	0xd87e,0xddba,0xd87e,0xddbb,0xd87e,0xddbc,0xd87e,0xddbd,0xd87e,0xddbe,
       
  1623 	0xd87e,0xddbf,0xd87e,0xddc0,0xd87e,0xddc1,0xd87e,0xddc2,0xd87e,0xddc3,
       
  1624 	0xd87e,0xddc4,0xd87e,0xddc5,0xd87e,0xddc6,0xd87e,0xddc7,0xd87e,0xddc8,
       
  1625 	0xd87e,0xddc9,0xd87e,0xddca,0xd87e,0xddcb,0xd87e,0xddcc,0xd87e,0xddcd,
       
  1626 	0xd87e,0xddce,0xd87e,0xddcf,0xd87e,0xddd0,0xd87e,0xddd1,0xd87e,0xddd2,
       
  1627 	0xd87e,0xddd3,0xd87e,0xddd4,0xd87e,0xddd5,0xd87e,0xddd6,0xd87e,0xddd7,
       
  1628 	0xd87e,0xddd8,0xd87e,0xddd9,0xd87e,0xddda,0xd87e,0xdddb,0xd87e,0xdddc,
       
  1629 	0xd87e,0xdddd,0xd87e,0xddde,0xd87e,0xdddf,0xd87e,0xdde0,0xd87e,0xdde1,
       
  1630 	0xd87e,0xdde2,0xd87e,0xdde3,0xd87e,0xdde4,0xd87e,0xdde5,0xd87e,0xdde6,
       
  1631 	0xd87e,0xdde7,0xd87e,0xdde8,0xd87e,0xdde9,0xd87e,0xddea,0xd87e,0xddeb,
       
  1632 	0xd87e,0xddec,0xd87e,0xdded,0xd87e,0xddee,0xd87e,0xddef,0xd87e,0xddf0,
       
  1633 	0xd87e,0xddf1,0xd87e,0xddf2,0xd87e,0xddf3,0xd87e,0xddf4,0xd87e,0xddf5,
       
  1634 	0xd87e,0xddf6,0xd87e,0xddf7,0xd87e,0xddf8,0xd87e,0xddf9,0xd87e,0xddfa,
       
  1635 	0xd87e,0xddfb,0xd87e,0xddfc,0xd87e,0xddfd,0xd87e,0xddfe,0xd87e,0xddff,
       
  1636 	0xd87e,0xde00,0xd87e,0xde01,0xd87e,0xde02,0xd87e,0xde03,0xd87e,0xde04,
       
  1637 	0xd87e,0xde05,0xd87e,0xde06,0xd87e,0xde07,0xd87e,0xde08,0xd87e,0xde09,
       
  1638 	0xd87e,0xde0a,0xd87e,0xde0b,0xd87e,0xde0c,0xd87e,0xde0d,0xd87e,0xde0e,
       
  1639 	0xd87e,0xde0f,0xd87e,0xde10,0xd87e,0xde11,0xd87e,0xde12,0xd87e,0xde13,
       
  1640 	0xd87e,0xde14,0xd87e,0xde15,0xd87e,0xde16,0xd87e,0xde17,0xd87e,0xde18,
       
  1641 	0xd87e,0xde19,0xd87e,0xde1a,0xd87e,0xde1b,0xd87e,0xde1c,0xd87e,0xde1d,
       
  1642 	0xdb80,0xdc00,0xdbbf,0xdffd,0xdbc0,0xdc00,0xdbff,0xdffd,
       
  1643 };
       
  1644 static const TUint KLeftToRightLength = 8309 + 6998;
       
  1645 
       
  1646 // This constant defines the Unicode characters in the "LeftToRightOverride" (LRO) category.
       
  1647 static const TUint16 KLeftToRightOverride[] = 
       
  1648 	{
       
  1649 	0x202d
       
  1650 	};
       
  1651 
       
  1652 // This constant defines the Unicode characters in the "RightToLeft" (R) category.
       
  1653 static const TUint16 KRightToLeft[] = 
       
  1654 	{
       
  1655 	0x05be,0x05c0,0x05c3,0x05c6,0x05d0,0x05d1,0x05d2,0x05d3,0x05d4,0x05d5,
       
  1656 	0x05d6,0x05d7,0x05d8,0x05d9,0x05da,0x05db,0x05dc,0x05dd,0x05de,0x05df,
       
  1657 	0x05e0,0x05e1,0x05e2,0x05e3,0x05e4,0x05e5,0x05e6,0x05e7,0x05e8,0x05e9,
       
  1658 	0x05ea,0x05f0,0x05f1,0x05f2,0x05f3,0x05f4,0x07c0,0x07c1,0x07c2,0x07c3,
       
  1659 	0x07c4,0x07c5,0x07c6,0x07c7,0x07c8,0x07c9,0x07ca,0x07cb,0x07cc,0x07cd,
       
  1660 	0x07ce,0x07cf,0x07d0,0x07d1,0x07d2,0x07d3,0x07d4,0x07d5,0x07d6,0x07d7,
       
  1661 	0x07d8,0x07d9,0x07da,0x07db,0x07dc,0x07dd,0x07de,0x07df,0x07e0,0x07e1,
       
  1662 	0x07e2,0x07e3,0x07e4,0x07e5,0x07e6,0x07e7,0x07e8,0x07e9,0x07ea,0x07f4,
       
  1663 	0x07f5,0x07fa,0x200f,0xfb1d,0xfb1f,0xfb20,0xfb21,0xfb22,0xfb23,0xfb24,
       
  1664 	0xfb25,0xfb26,0xfb27,0xfb28,0xfb2a,0xfb2b,0xfb2c,0xfb2d,0xfb2e,0xfb2f,
       
  1665 	0xfb30,0xfb31,0xfb32,0xfb33,0xfb34,0xfb35,0xfb36,0xfb38,0xfb39,0xfb3a,
       
  1666 	0xfb3b,0xfb3c,0xfb3e,0xfb40,0xfb41,0xfb43,0xfb44,0xfb46,0xfb47,0xfb48,
       
  1667 	0xfb49,0xfb4a,0xfb4b,0xfb4c,0xfb4d,0xfb4e,0xfb4f,0xd802,0xdc00,
       
  1668 	0xd802,0xdc01,0xd802,0xdc02,0xd802,0xdc03,0xd802,0xdc04,0xd802,0xdc05,
       
  1669 	0xd802,0xdc08,0xd802,0xdc0a,0xd802,0xdc0b,0xd802,0xdc0c,0xd802,0xdc0d,
       
  1670 	0xd802,0xdc0e,0xd802,0xdc0f,0xd802,0xdc10,0xd802,0xdc11,0xd802,0xdc12,
       
  1671 	0xd802,0xdc13,0xd802,0xdc14,0xd802,0xdc15,0xd802,0xdc16,0xd802,0xdc17,
       
  1672 	0xd802,0xdc18,0xd802,0xdc19,0xd802,0xdc1a,0xd802,0xdc1b,0xd802,0xdc1c,
       
  1673 	0xd802,0xdc1d,0xd802,0xdc1e,0xd802,0xdc1f,0xd802,0xdc20,0xd802,0xdc21,
       
  1674 	0xd802,0xdc22,0xd802,0xdc23,0xd802,0xdc24,0xd802,0xdc25,0xd802,0xdc26,
       
  1675 	0xd802,0xdc27,0xd802,0xdc28,0xd802,0xdc29,0xd802,0xdc2a,0xd802,0xdc2b,
       
  1676 	0xd802,0xdc2c,0xd802,0xdc2d,0xd802,0xdc2e,0xd802,0xdc2f,0xd802,0xdc30,
       
  1677 	0xd802,0xdc31,0xd802,0xdc32,0xd802,0xdc33,0xd802,0xdc34,0xd802,0xdc35,
       
  1678 	0xd802,0xdc37,0xd802,0xdc38,0xd802,0xdc3c,0xd802,0xdc3f,0xd802,0xdd00,
       
  1679 	0xd802,0xdd01,0xd802,0xdd02,0xd802,0xdd03,0xd802,0xdd04,0xd802,0xdd05,
       
  1680 	0xd802,0xdd06,0xd802,0xdd07,0xd802,0xdd08,0xd802,0xdd09,0xd802,0xdd0a,
       
  1681 	0xd802,0xdd0b,0xd802,0xdd0c,0xd802,0xdd0d,0xd802,0xdd0e,0xd802,0xdd0f,
       
  1682 	0xd802,0xdd10,0xd802,0xdd11,0xd802,0xdd12,0xd802,0xdd13,0xd802,0xdd14,
       
  1683 	0xd802,0xdd15,0xd802,0xdd16,0xd802,0xdd17,0xd802,0xdd18,0xd802,0xdd19,
       
  1684 	0xd802,0xde00,0xd802,0xde10,0xd802,0xde11,0xd802,0xde12,0xd802,0xde13,
       
  1685 	0xd802,0xde15,0xd802,0xde16,0xd802,0xde17,0xd802,0xde19,0xd802,0xde1a,
       
  1686 	0xd802,0xde1b,0xd802,0xde1c,0xd802,0xde1d,0xd802,0xde1e,0xd802,0xde1f,
       
  1687 	0xd802,0xde20,0xd802,0xde21,0xd802,0xde22,0xd802,0xde23,0xd802,0xde24,
       
  1688 	0xd802,0xde25,0xd802,0xde26,0xd802,0xde27,0xd802,0xde28,0xd802,0xde29,
       
  1689 	0xd802,0xde2a,0xd802,0xde2b,0xd802,0xde2c,0xd802,0xde2d,0xd802,0xde2e,
       
  1690 	0xd802,0xde2f,0xd802,0xde30,0xd802,0xde31,0xd802,0xde32,0xd802,0xde33,
       
  1691 	0xd802,0xde40,0xd802,0xde41,0xd802,0xde42,0xd802,0xde43,0xd802,0xde44,
       
  1692 	0xd802,0xde45,0xd802,0xde46,0xd802,0xde47,0xd802,0xde50,0xd802,0xde51,
       
  1693 	0xd802,0xde52,0xd802,0xde53,0xd802,0xde54,0xd802,0xde55,0xd802,0xde56,
       
  1694 	0xd802,0xde57,0xd802,0xde58,
       
  1695 	};
       
  1696 static const TUint KRightToLeftLength = 127 + 266;
       
  1697 
       
  1698 // This constant defines the Unicode characters in the "RightToLeftArabic" (AL) category.
       
  1699 static const TUint16 KRightToLeftArabic[] = 
       
  1700 	{
       
  1701 	0x0600,0x0601,0x0602,0x0603,0x060b,0x060d,0x061b,0x061e,0x061f,0x0621,
       
  1702 	0x0622,0x0623,0x0624,0x0625,0x0626,0x0627,0x0628,0x0629,0x062a,0x062b,
       
  1703 	0x062c,0x062d,0x062e,0x062f,0x0630,0x0631,0x0632,0x0633,0x0634,0x0635,
       
  1704 	0x0636,0x0637,0x0638,0x0639,0x063a,0x0640,0x0641,0x0642,0x0643,0x0644,
       
  1705 	0x0645,0x0646,0x0647,0x0648,0x0649,0x064a,0x066d,0x066e,0x066f,0x0671,
       
  1706 	0x0672,0x0673,0x0674,0x0675,0x0676,0x0677,0x0678,0x0679,0x067a,0x067b,
       
  1707 	0x067c,0x067d,0x067e,0x067f,0x0680,0x0681,0x0682,0x0683,0x0684,0x0685,
       
  1708 	0x0686,0x0687,0x0688,0x0689,0x068a,0x068b,0x068c,0x068d,0x068e,0x068f,
       
  1709 	0x0690,0x0691,0x0692,0x0693,0x0694,0x0695,0x0696,0x0697,0x0698,0x0699,
       
  1710 	0x069a,0x069b,0x069c,0x069d,0x069e,0x069f,0x06a0,0x06a1,0x06a2,0x06a3,
       
  1711 	0x06a4,0x06a5,0x06a6,0x06a7,0x06a8,0x06a9,0x06aa,0x06ab,0x06ac,0x06ad,
       
  1712 	0x06ae,0x06af,0x06b0,0x06b1,0x06b2,0x06b3,0x06b4,0x06b5,0x06b6,0x06b7,
       
  1713 	0x06b8,0x06b9,0x06ba,0x06bb,0x06bc,0x06bd,0x06be,0x06bf,0x06c0,0x06c1,
       
  1714 	0x06c2,0x06c3,0x06c4,0x06c5,0x06c6,0x06c7,0x06c8,0x06c9,0x06ca,0x06cb,
       
  1715 	0x06cc,0x06cd,0x06ce,0x06cf,0x06d0,0x06d1,0x06d2,0x06d3,0x06d4,0x06d5,
       
  1716 	0x06dd,0x06e5,0x06e6,0x06ee,0x06ef,0x06fa,0x06fb,0x06fc,0x06fd,0x06fe,
       
  1717 	0x06ff,0x0700,0x0701,0x0702,0x0703,0x0704,0x0705,0x0706,0x0707,0x0708,
       
  1718 	0x0709,0x070a,0x070b,0x070c,0x070d,0x0710,0x0712,0x0713,0x0714,0x0715,
       
  1719 	0x0716,0x0717,0x0718,0x0719,0x071a,0x071b,0x071c,0x071d,0x071e,0x071f,
       
  1720 	0x0720,0x0721,0x0722,0x0723,0x0724,0x0725,0x0726,0x0727,0x0728,0x0729,
       
  1721 	0x072a,0x072b,0x072c,0x072d,0x072e,0x072f,0x074d,0x074e,0x074f,0x0750,
       
  1722 	0x0751,0x0752,0x0753,0x0754,0x0755,0x0756,0x0757,0x0758,0x0759,0x075a,
       
  1723 	0x075b,0x075c,0x075d,0x075e,0x075f,0x0760,0x0761,0x0762,0x0763,0x0764,
       
  1724 	0x0765,0x0766,0x0767,0x0768,0x0769,0x076a,0x076b,0x076c,0x076d,0x0780,
       
  1725 	0x0781,0x0782,0x0783,0x0784,0x0785,0x0786,0x0787,0x0788,0x0789,0x078a,
       
  1726 	0x078b,0x078c,0x078d,0x078e,0x078f,0x0790,0x0791,0x0792,0x0793,0x0794,
       
  1727 	0x0795,0x0796,0x0797,0x0798,0x0799,0x079a,0x079b,0x079c,0x079d,0x079e,
       
  1728 	0x079f,0x07a0,0x07a1,0x07a2,0x07a3,0x07a4,0x07a5,0x07b1,0xfb50,0xfb51,
       
  1729 	0xfb52,0xfb53,0xfb54,0xfb55,0xfb56,0xfb57,0xfb58,0xfb59,0xfb5a,0xfb5b,
       
  1730 	0xfb5c,0xfb5d,0xfb5e,0xfb5f,0xfb60,0xfb61,0xfb62,0xfb63,0xfb64,0xfb65,
       
  1731 	0xfb66,0xfb67,0xfb68,0xfb69,0xfb6a,0xfb6b,0xfb6c,0xfb6d,0xfb6e,0xfb6f,
       
  1732 	0xfb70,0xfb71,0xfb72,0xfb73,0xfb74,0xfb75,0xfb76,0xfb77,0xfb78,0xfb79,
       
  1733 	0xfb7a,0xfb7b,0xfb7c,0xfb7d,0xfb7e,0xfb7f,0xfb80,0xfb81,0xfb82,0xfb83,
       
  1734 	0xfb84,0xfb85,0xfb86,0xfb87,0xfb88,0xfb89,0xfb8a,0xfb8b,0xfb8c,0xfb8d,
       
  1735 	0xfb8e,0xfb8f,0xfb90,0xfb91,0xfb92,0xfb93,0xfb94,0xfb95,0xfb96,0xfb97,
       
  1736 	0xfb98,0xfb99,0xfb9a,0xfb9b,0xfb9c,0xfb9d,0xfb9e,0xfb9f,0xfba0,0xfba1,
       
  1737 	0xfba2,0xfba3,0xfba4,0xfba5,0xfba6,0xfba7,0xfba8,0xfba9,0xfbaa,0xfbab,
       
  1738 	0xfbac,0xfbad,0xfbae,0xfbaf,0xfbb0,0xfbb1,0xfbd3,0xfbd4,0xfbd5,0xfbd6,
       
  1739 	0xfbd7,0xfbd8,0xfbd9,0xfbda,0xfbdb,0xfbdc,0xfbdd,0xfbde,0xfbdf,0xfbe0,
       
  1740 	0xfbe1,0xfbe2,0xfbe3,0xfbe4,0xfbe5,0xfbe6,0xfbe7,0xfbe8,0xfbe9,0xfbea,
       
  1741 	0xfbeb,0xfbec,0xfbed,0xfbee,0xfbef,0xfbf0,0xfbf1,0xfbf2,0xfbf3,0xfbf4,
       
  1742 	0xfbf5,0xfbf6,0xfbf7,0xfbf8,0xfbf9,0xfbfa,0xfbfb,0xfbfc,0xfbfd,0xfbfe,
       
  1743 	0xfbff,0xfc00,0xfc01,0xfc02,0xfc03,0xfc04,0xfc05,0xfc06,0xfc07,0xfc08,
       
  1744 	0xfc09,0xfc0a,0xfc0b,0xfc0c,0xfc0d,0xfc0e,0xfc0f,0xfc10,0xfc11,0xfc12,
       
  1745 	0xfc13,0xfc14,0xfc15,0xfc16,0xfc17,0xfc18,0xfc19,0xfc1a,0xfc1b,0xfc1c,
       
  1746 	0xfc1d,0xfc1e,0xfc1f,0xfc20,0xfc21,0xfc22,0xfc23,0xfc24,0xfc25,0xfc26,
       
  1747 	0xfc27,0xfc28,0xfc29,0xfc2a,0xfc2b,0xfc2c,0xfc2d,0xfc2e,0xfc2f,0xfc30,
       
  1748 	0xfc31,0xfc32,0xfc33,0xfc34,0xfc35,0xfc36,0xfc37,0xfc38,0xfc39,0xfc3a,
       
  1749 	0xfc3b,0xfc3c,0xfc3d,0xfc3e,0xfc3f,0xfc40,0xfc41,0xfc42,0xfc43,0xfc44,
       
  1750 	0xfc45,0xfc46,0xfc47,0xfc48,0xfc49,0xfc4a,0xfc4b,0xfc4c,0xfc4d,0xfc4e,
       
  1751 	0xfc4f,0xfc50,0xfc51,0xfc52,0xfc53,0xfc54,0xfc55,0xfc56,0xfc57,0xfc58,
       
  1752 	0xfc59,0xfc5a,0xfc5b,0xfc5c,0xfc5d,0xfc5e,0xfc5f,0xfc60,0xfc61,0xfc62,
       
  1753 	0xfc63,0xfc64,0xfc65,0xfc66,0xfc67,0xfc68,0xfc69,0xfc6a,0xfc6b,0xfc6c,
       
  1754 	0xfc6d,0xfc6e,0xfc6f,0xfc70,0xfc71,0xfc72,0xfc73,0xfc74,0xfc75,0xfc76,
       
  1755 	0xfc77,0xfc78,0xfc79,0xfc7a,0xfc7b,0xfc7c,0xfc7d,0xfc7e,0xfc7f,0xfc80,
       
  1756 	0xfc81,0xfc82,0xfc83,0xfc84,0xfc85,0xfc86,0xfc87,0xfc88,0xfc89,0xfc8a,
       
  1757 	0xfc8b,0xfc8c,0xfc8d,0xfc8e,0xfc8f,0xfc90,0xfc91,0xfc92,0xfc93,0xfc94,
       
  1758 	0xfc95,0xfc96,0xfc97,0xfc98,0xfc99,0xfc9a,0xfc9b,0xfc9c,0xfc9d,0xfc9e,
       
  1759 	0xfc9f,0xfca0,0xfca1,0xfca2,0xfca3,0xfca4,0xfca5,0xfca6,0xfca7,0xfca8,
       
  1760 	0xfca9,0xfcaa,0xfcab,0xfcac,0xfcad,0xfcae,0xfcaf,0xfcb0,0xfcb1,0xfcb2,
       
  1761 	0xfcb3,0xfcb4,0xfcb5,0xfcb6,0xfcb7,0xfcb8,0xfcb9,0xfcba,0xfcbb,0xfcbc,
       
  1762 	0xfcbd,0xfcbe,0xfcbf,0xfcc0,0xfcc1,0xfcc2,0xfcc3,0xfcc4,0xfcc5,0xfcc6,
       
  1763 	0xfcc7,0xfcc8,0xfcc9,0xfcca,0xfccb,0xfccc,0xfccd,0xfcce,0xfccf,0xfcd0,
       
  1764 	0xfcd1,0xfcd2,0xfcd3,0xfcd4,0xfcd5,0xfcd6,0xfcd7,0xfcd8,0xfcd9,0xfcda,
       
  1765 	0xfcdb,0xfcdc,0xfcdd,0xfcde,0xfcdf,0xfce0,0xfce1,0xfce2,0xfce3,0xfce4,
       
  1766 	0xfce5,0xfce6,0xfce7,0xfce8,0xfce9,0xfcea,0xfceb,0xfcec,0xfced,0xfcee,
       
  1767 	0xfcef,0xfcf0,0xfcf1,0xfcf2,0xfcf3,0xfcf4,0xfcf5,0xfcf6,0xfcf7,0xfcf8,
       
  1768 	0xfcf9,0xfcfa,0xfcfb,0xfcfc,0xfcfd,0xfcfe,0xfcff,0xfd00,0xfd01,0xfd02,
       
  1769 	0xfd03,0xfd04,0xfd05,0xfd06,0xfd07,0xfd08,0xfd09,0xfd0a,0xfd0b,0xfd0c,
       
  1770 	0xfd0d,0xfd0e,0xfd0f,0xfd10,0xfd11,0xfd12,0xfd13,0xfd14,0xfd15,0xfd16,
       
  1771 	0xfd17,0xfd18,0xfd19,0xfd1a,0xfd1b,0xfd1c,0xfd1d,0xfd1e,0xfd1f,0xfd20,
       
  1772 	0xfd21,0xfd22,0xfd23,0xfd24,0xfd25,0xfd26,0xfd27,0xfd28,0xfd29,0xfd2a,
       
  1773 	0xfd2b,0xfd2c,0xfd2d,0xfd2e,0xfd2f,0xfd30,0xfd31,0xfd32,0xfd33,0xfd34,
       
  1774 	0xfd35,0xfd36,0xfd37,0xfd38,0xfd39,0xfd3a,0xfd3b,0xfd3c,0xfd3d,0xfd50,
       
  1775 	0xfd51,0xfd52,0xfd53,0xfd54,0xfd55,0xfd56,0xfd57,0xfd58,0xfd59,0xfd5a,
       
  1776 	0xfd5b,0xfd5c,0xfd5d,0xfd5e,0xfd5f,0xfd60,0xfd61,0xfd62,0xfd63,0xfd64,
       
  1777 	0xfd65,0xfd66,0xfd67,0xfd68,0xfd69,0xfd6a,0xfd6b,0xfd6c,0xfd6d,0xfd6e,
       
  1778 	0xfd6f,0xfd70,0xfd71,0xfd72,0xfd73,0xfd74,0xfd75,0xfd76,0xfd77,0xfd78,
       
  1779 	0xfd79,0xfd7a,0xfd7b,0xfd7c,0xfd7d,0xfd7e,0xfd7f,0xfd80,0xfd81,0xfd82,
       
  1780 	0xfd83,0xfd84,0xfd85,0xfd86,0xfd87,0xfd88,0xfd89,0xfd8a,0xfd8b,0xfd8c,
       
  1781 	0xfd8d,0xfd8e,0xfd8f,0xfd92,0xfd93,0xfd94,0xfd95,0xfd96,0xfd97,0xfd98,
       
  1782 	0xfd99,0xfd9a,0xfd9b,0xfd9c,0xfd9d,0xfd9e,0xfd9f,0xfda0,0xfda1,0xfda2,
       
  1783 	0xfda3,0xfda4,0xfda5,0xfda6,0xfda7,0xfda8,0xfda9,0xfdaa,0xfdab,0xfdac,
       
  1784 	0xfdad,0xfdae,0xfdaf,0xfdb0,0xfdb1,0xfdb2,0xfdb3,0xfdb4,0xfdb5,0xfdb6,
       
  1785 	0xfdb7,0xfdb8,0xfdb9,0xfdba,0xfdbb,0xfdbc,0xfdbd,0xfdbe,0xfdbf,0xfdc0,
       
  1786 	0xfdc1,0xfdc2,0xfdc3,0xfdc4,0xfdc5,0xfdc6,0xfdc7,0xfdf0,0xfdf1,0xfdf2,
       
  1787 	0xfdf3,0xfdf4,0xfdf5,0xfdf6,0xfdf7,0xfdf8,0xfdf9,0xfdfa,0xfdfb,0xfdfc,
       
  1788 	0xfe70,0xfe71,0xfe72,0xfe73,0xfe74,0xfe76,0xfe77,0xfe78,0xfe79,0xfe7a,
       
  1789 	0xfe7b,0xfe7c,0xfe7d,0xfe7e,0xfe7f,0xfe80,0xfe81,0xfe82,0xfe83,0xfe84,
       
  1790 	0xfe85,0xfe86,0xfe87,0xfe88,0xfe89,0xfe8a,0xfe8b,0xfe8c,0xfe8d,0xfe8e,
       
  1791 	0xfe8f,0xfe90,0xfe91,0xfe92,0xfe93,0xfe94,0xfe95,0xfe96,0xfe97,0xfe98,
       
  1792 	0xfe99,0xfe9a,0xfe9b,0xfe9c,0xfe9d,0xfe9e,0xfe9f,0xfea0,0xfea1,0xfea2,
       
  1793 	0xfea3,0xfea4,0xfea5,0xfea6,0xfea7,0xfea8,0xfea9,0xfeaa,0xfeab,0xfeac,
       
  1794 	0xfead,0xfeae,0xfeaf,0xfeb0,0xfeb1,0xfeb2,0xfeb3,0xfeb4,0xfeb5,0xfeb6,
       
  1795 	0xfeb7,0xfeb8,0xfeb9,0xfeba,0xfebb,0xfebc,0xfebd,0xfebe,0xfebf,0xfec0,
       
  1796 	0xfec1,0xfec2,0xfec3,0xfec4,0xfec5,0xfec6,0xfec7,0xfec8,0xfec9,0xfeca,
       
  1797 	0xfecb,0xfecc,0xfecd,0xfece,0xfecf,0xfed0,0xfed1,0xfed2,0xfed3,0xfed4,
       
  1798 	0xfed5,0xfed6,0xfed7,0xfed8,0xfed9,0xfeda,0xfedb,0xfedc,0xfedd,0xfede,
       
  1799 	0xfedf,0xfee0,0xfee1,0xfee2,0xfee3,0xfee4,0xfee5,0xfee6,0xfee7,0xfee8,
       
  1800 	0xfee9,0xfeea,0xfeeb,0xfeec,0xfeed,0xfeee,0xfeef,0xfef0,0xfef1,0xfef2,
       
  1801 	0xfef3,0xfef4,0xfef5,0xfef6,0xfef7,0xfef8,0xfef9,0xfefa,0xfefb,0xfefc,
       
  1802 	};
       
  1803 static const TUint KRightToLeftArabicLength = 1010;
       
  1804 
       
  1805 // This constant defines the Unicode characters in the "RightToLeftOverride" (RLO) category.
       
  1806 static const TUint16 KRightToLeftOverride[] = 
       
  1807 	{
       
  1808 	0x202e
       
  1809 	};
       
  1810 
       
  1811 // This constant defines the Unicode characters in the "PopDirectionalFormat" (PDF) category.
       
  1812 static const TUint16 KPopDirectionalFormat[] = 
       
  1813 	{
       
  1814 	0x202c
       
  1815 	};
       
  1816 
       
  1817 // This constant defines the Unicode characters in the "EuropeanNumber" (EN) category.
       
  1818 static const TUint16 KEuropeanNumber[] = 
       
  1819 	{
       
  1820 	0x0030,0x0031,0x0032,0x0033,0x0034,0x0035,0x0036,0x0037,0x0038,0x0039,
       
  1821 	0x00b2,0x00b3,0x00b9,0x06f0,0x06f1,0x06f2,0x06f3,0x06f4,0x06f5,0x06f6,
       
  1822 	0x06f7,0x06f8,0x06f9,0x2070,0x2074,0x2075,0x2076,0x2077,0x2078,0x2079,
       
  1823 	0x2080,0x2081,0x2082,0x2083,0x2084,0x2085,0x2086,0x2087,0x2088,0x2089,
       
  1824 	0x2488,0x2489,0x248a,0x248b,0x248c,0x248d,0x248e,0x248f,0x2490,0x2491,
       
  1825 	0x2492,0x2493,0x2494,0x2495,0x2496,0x2497,0x2498,0x2499,0x249a,0x249b,
       
  1826 	0xff10,0xff11,0xff12,0xff13,0xff14,0xff15,0xff16,0xff17,0xff18,0xff19,
       
  1827 	0xd835,0xdfce,0xd835,0xdfcf,0xd835,0xdfd0,0xd835,0xdfd1,0xd835,0xdfd2,
       
  1828 	0xd835,0xdfd3,0xd835,0xdfd4,0xd835,0xdfd5,0xd835,0xdfd6,0xd835,0xdfd7,
       
  1829 	0xd835,0xdfd8,0xd835,0xdfd9,0xd835,0xdfda,0xd835,0xdfdb,0xd835,0xdfdc,
       
  1830 	0xd835,0xdfdd,0xd835,0xdfde,0xd835,0xdfdf,0xd835,0xdfe0,0xd835,0xdfe1,
       
  1831 	0xd835,0xdfe2,0xd835,0xdfe3,0xd835,0xdfe4,0xd835,0xdfe5,0xd835,0xdfe6,
       
  1832 	0xd835,0xdfe7,0xd835,0xdfe8,0xd835,0xdfe9,0xd835,0xdfea,0xd835,0xdfeb,
       
  1833 	0xd835,0xdfec,0xd835,0xdfed,0xd835,0xdfee,0xd835,0xdfef,0xd835,0xdff0,
       
  1834 	0xd835,0xdff1,0xd835,0xdff2,0xd835,0xdff3,0xd835,0xdff4,0xd835,0xdff5,
       
  1835 	0xd835,0xdff6,0xd835,0xdff7,0xd835,0xdff8,0xd835,0xdff9,0xd835,0xdffa,
       
  1836 	0xd835,0xdffb,0xd835,0xdffc,0xd835,0xdffd,0xd835,0xdffe,0xd835,0xdfff,
       
  1837 	};
       
  1838 static const TUint KEuropeanNumberLength = 70 + 100;
       
  1839 
       
  1840 // This constant defines the Unicode characters in the "EuropeanNumberTerminator" (ET) category.
       
  1841 static const TUint16 KEuropeanNumberTerminator[] = 
       
  1842 	{
       
  1843 	0x0023,0x0024,0x0025,0x00a2,0x00a3,0x00a4,0x00a5,0x00b0,0x00b1,0x066a,
       
  1844 	0x09f2,0x09f3,0x0af1,0x0bf9,0x0e3f,0x17db,0x2030,0x2031,0x2032,0x2033,
       
  1845 	0x2034,0x20a0,0x20a1,0x20a2,0x20a3,0x20a4,0x20a5,0x20a6,0x20a7,0x20a8,
       
  1846 	0x20a9,0x20aa,0x20ab,0x20ac,0x20ad,0x20ae,0x20af,0x20b0,0x20b1,0x20b2,
       
  1847 	0x20b3,0x20b4,0x20b5,0x212e,0x2213,0xfe5f,0xfe69,0xfe6a,0xff03,0xff04,
       
  1848 	0xff05,0xffe0,0xffe1,0xffe5,0xffe6,
       
  1849 	};
       
  1850 static const TUint KEuropeanNumberTerminatorLength = 55;
       
  1851 
       
  1852 
       
  1853 // This constant defines the Unicode characters in the "ArabicNumber" (AN) category.
       
  1854 static const TUint16 KArabicNumber[] = 
       
  1855 	{
       
  1856 	0x0660,0x0661,0x0662,0x0663,0x0664,0x0665,0x0666,0x0667,0x0668,0x0669,
       
  1857 	0x066b,0x066c,
       
  1858 	};
       
  1859 
       
  1860 static const TUint KArabicNumberLength = 12;
       
  1861 
       
  1862 // This constant defines the Unicode characters in the "OtherNeutrals" category.
       
  1863 // A conventional _LIT cannot be used here because of the Microsoft limit of 
       
  1864 // 2048 bytes for literal strings.
       
  1865 static const TUint16 KOtherNeutrals[] = 
       
  1866 	{
       
  1867 	0x0021,0x0022,0x0026,0x0027,0x0028,0x0029,0x002a,0x003b,0x003c,0x003d,
       
  1868 	0x003e,0x003f,0x0040,0x005b,0x005c,0x005d,0x005e,0x005f,0x0060,0x007b,
       
  1869 	0x007c,0x007d,0x007e,0x00a1,0x00a6,0x00a7,0x00a8,0x00a9,0x00ab,0x00ac,
       
  1870 	0x00ae,0x00af,0x00b4,0x00b6,0x00b7,0x00b8,0x00bb,0x00bc,0x00bd,0x00be,
       
  1871 	0x00bf,0x00d7,0x00f7,0x02b9,0x02ba,0x02c2,0x02c3,0x02c4,0x02c5,0x02c6,
       
  1872 	0x02c7,0x02c8,0x02c9,0x02ca,0x02cb,0x02cc,0x02cd,0x02ce,0x02cf,0x02d2,
       
  1873 	0x02d3,0x02d4,0x02d5,0x02d6,0x02d7,0x02d8,0x02d9,0x02da,0x02db,0x02dc,
       
  1874 	0x02dd,0x02de,0x02df,0x02e5,0x02e6,0x02e7,0x02e8,0x02e9,0x02ea,0x02eb,
       
  1875 	0x02ec,0x02ed,0x02ef,0x02f0,0x02f1,0x02f2,0x02f3,0x02f4,0x02f5,0x02f6,
       
  1876 	0x02f7,0x02f8,0x02f9,0x02fa,0x02fb,0x02fc,0x02fd,0x02fe,0x02ff,0x0374,
       
  1877 	0x0375,0x037e,0x0384,0x0385,0x0387,0x03f6,0x058a,0x060e,0x060f,0x06e9,
       
  1878 	0x07f6,0x07f7,0x07f8,0x07f9,0x0bf3,0x0bf4,0x0bf5,0x0bf6,0x0bf7,0x0bf8,
       
  1879 	0x0bfa,0x0cf1,0x0cf2,0x0f3a,0x0f3b,0x0f3c,0x0f3d,0x1390,0x1391,0x1392,
       
  1880 	0x1393,0x1394,0x1395,0x1396,0x1397,0x1398,0x1399,0x169b,0x169c,0x17f0,
       
  1881 	0x17f1,0x17f2,0x17f3,0x17f4,0x17f5,0x17f6,0x17f7,0x17f8,0x17f9,0x1800,
       
  1882 	0x1801,0x1802,0x1803,0x1804,0x1805,0x1806,0x1807,0x1808,0x1809,0x180a,
       
  1883 	0x1940,0x1944,0x1945,0x19de,0x19df,0x19e0,0x19e1,0x19e2,0x19e3,0x19e4,
       
  1884 	0x19e5,0x19e6,0x19e7,0x19e8,0x19e9,0x19ea,0x19eb,0x19ec,0x19ed,0x19ee,
       
  1885 	0x19ef,0x19f0,0x19f1,0x19f2,0x19f3,0x19f4,0x19f5,0x19f6,0x19f7,0x19f8,
       
  1886 	0x19f9,0x19fa,0x19fb,0x19fc,0x19fd,0x19fe,0x19ff,0x1fbd,0x1fbf,0x1fc0,
       
  1887 	0x1fc1,0x1fcd,0x1fce,0x1fcf,0x1fdd,0x1fde,0x1fdf,0x1fed,0x1fee,0x1fef,
       
  1888 	0x1ffd,0x1ffe,0x2010,0x2011,0x2012,0x2013,0x2014,0x2015,0x2016,0x2017,
       
  1889 	0x2018,0x2019,0x201a,0x201b,0x201c,0x201d,0x201e,0x201f,0x2020,0x2021,
       
  1890 	0x2022,0x2023,0x2024,0x2025,0x2026,0x2027,0x2035,0x2036,0x2037,0x2038,
       
  1891 	0x2039,0x203a,0x203b,0x203c,0x203d,0x203e,0x203f,0x2040,0x2041,0x2042,
       
  1892 	0x2043,0x2045,0x2046,0x2047,0x2048,0x2049,0x204a,0x204b,0x204c,0x204d,
       
  1893 	0x204e,0x204f,0x2050,0x2051,0x2052,0x2053,0x2054,0x2055,0x2056,0x2057,
       
  1894 	0x2058,0x2059,0x205a,0x205b,0x205c,0x205d,0x205e,0x207c,0x207d,0x207e,
       
  1895 	0x208c,0x208d,0x208e,0x2100,0x2101,0x2103,0x2104,0x2105,0x2106,0x2108,
       
  1896 	0x2109,0x2114,0x2116,0x2117,0x2118,0x211e,0x211f,0x2120,0x2121,0x2122,
       
  1897 	0x2123,0x2125,0x2127,0x2129,0x213a,0x213b,0x2140,0x2141,0x2142,0x2143,
       
  1898 	0x2144,0x214a,0x214b,0x214c,0x214d,0x2153,0x2154,0x2155,0x2156,0x2157,
       
  1899 	0x2158,0x2159,0x215a,0x215b,0x215c,0x215d,0x215e,0x215f,0x2190,0x2191,
       
  1900 	0x2192,0x2193,0x2194,0x2195,0x2196,0x2197,0x2198,0x2199,0x219a,0x219b,
       
  1901 	0x219c,0x219d,0x219e,0x219f,0x21a0,0x21a1,0x21a2,0x21a3,0x21a4,0x21a5,
       
  1902 	0x21a6,0x21a7,0x21a8,0x21a9,0x21aa,0x21ab,0x21ac,0x21ad,0x21ae,0x21af,
       
  1903 	0x21b0,0x21b1,0x21b2,0x21b3,0x21b4,0x21b5,0x21b6,0x21b7,0x21b8,0x21b9,
       
  1904 	0x21ba,0x21bb,0x21bc,0x21bd,0x21be,0x21bf,0x21c0,0x21c1,0x21c2,0x21c3,
       
  1905 	0x21c4,0x21c5,0x21c6,0x21c7,0x21c8,0x21c9,0x21ca,0x21cb,0x21cc,0x21cd,
       
  1906 	0x21ce,0x21cf,0x21d0,0x21d1,0x21d2,0x21d3,0x21d4,0x21d5,0x21d6,0x21d7,
       
  1907 	0x21d8,0x21d9,0x21da,0x21db,0x21dc,0x21dd,0x21de,0x21df,0x21e0,0x21e1,
       
  1908 	0x21e2,0x21e3,0x21e4,0x21e5,0x21e6,0x21e7,0x21e8,0x21e9,0x21ea,0x21eb,
       
  1909 	0x21ec,0x21ed,0x21ee,0x21ef,0x21f0,0x21f1,0x21f2,0x21f3,0x21f4,0x21f5,
       
  1910 	0x21f6,0x21f7,0x21f8,0x21f9,0x21fa,0x21fb,0x21fc,0x21fd,0x21fe,0x21ff,
       
  1911 	0x2200,0x2201,0x2202,0x2203,0x2204,0x2205,0x2206,0x2207,0x2208,0x2209,
       
  1912 	0x220a,0x220b,0x220c,0x220d,0x220e,0x220f,0x2210,0x2211,0x2214,0x2215,
       
  1913 	0x2216,0x2217,0x2218,0x2219,0x221a,0x221b,0x221c,0x221d,0x221e,0x221f,
       
  1914 	0x2220,0x2221,0x2222,0x2223,0x2224,0x2225,0x2226,0x2227,0x2228,0x2229,
       
  1915 	0x222a,0x222b,0x222c,0x222d,0x222e,0x222f,0x2230,0x2231,0x2232,0x2233,
       
  1916 	0x2234,0x2235,0x2236,0x2237,0x2238,0x2239,0x223a,0x223b,0x223c,0x223d,
       
  1917 	0x223e,0x223f,0x2240,0x2241,0x2242,0x2243,0x2244,0x2245,0x2246,0x2247,
       
  1918 	0x2248,0x2249,0x224a,0x224b,0x224c,0x224d,0x224e,0x224f,0x2250,0x2251,
       
  1919 	0x2252,0x2253,0x2254,0x2255,0x2256,0x2257,0x2258,0x2259,0x225a,0x225b,
       
  1920 	0x225c,0x225d,0x225e,0x225f,0x2260,0x2261,0x2262,0x2263,0x2264,0x2265,
       
  1921 	0x2266,0x2267,0x2268,0x2269,0x226a,0x226b,0x226c,0x226d,0x226e,0x226f,
       
  1922 	0x2270,0x2271,0x2272,0x2273,0x2274,0x2275,0x2276,0x2277,0x2278,0x2279,
       
  1923 	0x227a,0x227b,0x227c,0x227d,0x227e,0x227f,0x2280,0x2281,0x2282,0x2283,
       
  1924 	0x2284,0x2285,0x2286,0x2287,0x2288,0x2289,0x228a,0x228b,0x228c,0x228d,
       
  1925 	0x228e,0x228f,0x2290,0x2291,0x2292,0x2293,0x2294,0x2295,0x2296,0x2297,
       
  1926 	0x2298,0x2299,0x229a,0x229b,0x229c,0x229d,0x229e,0x229f,0x22a0,0x22a1,
       
  1927 	0x22a2,0x22a3,0x22a4,0x22a5,0x22a6,0x22a7,0x22a8,0x22a9,0x22aa,0x22ab,
       
  1928 	0x22ac,0x22ad,0x22ae,0x22af,0x22b0,0x22b1,0x22b2,0x22b3,0x22b4,0x22b5,
       
  1929 	0x22b6,0x22b7,0x22b8,0x22b9,0x22ba,0x22bb,0x22bc,0x22bd,0x22be,0x22bf,
       
  1930 	0x22c0,0x22c1,0x22c2,0x22c3,0x22c4,0x22c5,0x22c6,0x22c7,0x22c8,0x22c9,
       
  1931 	0x22ca,0x22cb,0x22cc,0x22cd,0x22ce,0x22cf,0x22d0,0x22d1,0x22d2,0x22d3,
       
  1932 	0x22d4,0x22d5,0x22d6,0x22d7,0x22d8,0x22d9,0x22da,0x22db,0x22dc,0x22dd,
       
  1933 	0x22de,0x22df,0x22e0,0x22e1,0x22e2,0x22e3,0x22e4,0x22e5,0x22e6,0x22e7,
       
  1934 	0x22e8,0x22e9,0x22ea,0x22eb,0x22ec,0x22ed,0x22ee,0x22ef,0x22f0,0x22f1,
       
  1935 	0x22f2,0x22f3,0x22f4,0x22f5,0x22f6,0x22f7,0x22f8,0x22f9,0x22fa,0x22fb,
       
  1936 	0x22fc,0x22fd,0x22fe,0x22ff,0x2300,0x2301,0x2302,0x2303,0x2304,0x2305,
       
  1937 	0x2306,0x2307,0x2308,0x2309,0x230a,0x230b,0x230c,0x230d,0x230e,0x230f,
       
  1938 	0x2310,0x2311,0x2312,0x2313,0x2314,0x2315,0x2316,0x2317,0x2318,0x2319,
       
  1939 	0x231a,0x231b,0x231c,0x231d,0x231e,0x231f,0x2320,0x2321,0x2322,0x2323,
       
  1940 	0x2324,0x2325,0x2326,0x2327,0x2328,0x2329,0x232a,0x232b,0x232c,0x232d,
       
  1941 	0x232e,0x232f,0x2330,0x2331,0x2332,0x2333,0x2334,0x2335,0x237b,0x237c,
       
  1942 	0x237d,0x237e,0x237f,0x2380,0x2381,0x2382,0x2383,0x2384,0x2385,0x2386,
       
  1943 	0x2387,0x2388,0x2389,0x238a,0x238b,0x238c,0x238d,0x238e,0x238f,0x2390,
       
  1944 	0x2391,0x2392,0x2393,0x2394,0x2396,0x2397,0x2398,0x2399,0x239a,0x239b,
       
  1945 	0x239c,0x239d,0x239e,0x239f,0x23a0,0x23a1,0x23a2,0x23a3,0x23a4,0x23a5,
       
  1946 	0x23a6,0x23a7,0x23a8,0x23a9,0x23aa,0x23ab,0x23ac,0x23ad,0x23ae,0x23af,
       
  1947 	0x23b0,0x23b1,0x23b2,0x23b3,0x23b4,0x23b5,0x23b6,0x23b7,0x23b8,0x23b9,
       
  1948 	0x23ba,0x23bb,0x23bc,0x23bd,0x23be,0x23bf,0x23c0,0x23c1,0x23c2,0x23c3,
       
  1949 	0x23c4,0x23c5,0x23c6,0x23c7,0x23c8,0x23c9,0x23ca,0x23cb,0x23cc,0x23cd,
       
  1950 	0x23ce,0x23cf,0x23d0,0x23d1,0x23d2,0x23d3,0x23d4,0x23d5,0x23d6,0x23d7,
       
  1951 	0x23d8,0x23d9,0x23da,0x23db,0x23dc,0x23dd,0x23de,0x23df,0x23e0,0x23e1,
       
  1952 	0x23e2,0x23e3,0x23e4,0x23e5,0x23e6,0x23e7,0x2400,0x2401,0x2402,0x2403,
       
  1953 	0x2404,0x2405,0x2406,0x2407,0x2408,0x2409,0x240a,0x240b,0x240c,0x240d,
       
  1954 	0x240e,0x240f,0x2410,0x2411,0x2412,0x2413,0x2414,0x2415,0x2416,0x2417,
       
  1955 	0x2418,0x2419,0x241a,0x241b,0x241c,0x241d,0x241e,0x241f,0x2420,0x2421,
       
  1956 	0x2422,0x2423,0x2424,0x2425,0x2426,0x2440,0x2441,0x2442,0x2443,0x2444,
       
  1957 	0x2445,0x2446,0x2447,0x2448,0x2449,0x244a,0x2460,0x2461,0x2462,0x2463,
       
  1958 	0x2464,0x2465,0x2466,0x2467,0x2468,0x2469,0x246a,0x246b,0x246c,0x246d,
       
  1959 	0x246e,0x246f,0x2470,0x2471,0x2472,0x2473,0x2474,0x2475,0x2476,0x2477,
       
  1960 	0x2478,0x2479,0x247a,0x247b,0x247c,0x247d,0x247e,0x247f,0x2480,0x2481,
       
  1961 	0x2482,0x2483,0x2484,0x2485,0x2486,0x2487,0x24ea,0x24eb,0x24ec,0x24ed,
       
  1962 	0x24ee,0x24ef,0x24f0,0x24f1,0x24f2,0x24f3,0x24f4,0x24f5,0x24f6,0x24f7,
       
  1963 	0x24f8,0x24f9,0x24fa,0x24fb,0x24fc,0x24fd,0x24fe,0x24ff,0x2500,0x2501,
       
  1964 	0x2502,0x2503,0x2504,0x2505,0x2506,0x2507,0x2508,0x2509,0x250a,0x250b,
       
  1965 	0x250c,0x250d,0x250e,0x250f,0x2510,0x2511,0x2512,0x2513,0x2514,0x2515,
       
  1966 	0x2516,0x2517,0x2518,0x2519,0x251a,0x251b,0x251c,0x251d,0x251e,0x251f,
       
  1967 	0x2520,0x2521,0x2522,0x2523,0x2524,0x2525,0x2526,0x2527,0x2528,0x2529,
       
  1968 	0x252a,0x252b,0x252c,0x252d,0x252e,0x252f,0x2530,0x2531,0x2532,0x2533,
       
  1969 	0x2534,0x2535,0x2536,0x2537,0x2538,0x2539,0x253a,0x253b,0x253c,0x253d,
       
  1970 	0x253e,0x253f,0x2540,0x2541,0x2542,0x2543,0x2544,0x2545,0x2546,0x2547,
       
  1971 	0x2548,0x2549,0x254a,0x254b,0x254c,0x254d,0x254e,0x254f,0x2550,0x2551,
       
  1972 	0x2552,0x2553,0x2554,0x2555,0x2556,0x2557,0x2558,0x2559,0x255a,0x255b,
       
  1973 	0x255c,0x255d,0x255e,0x255f,0x2560,0x2561,0x2562,0x2563,0x2564,0x2565,
       
  1974 	0x2566,0x2567,0x2568,0x2569,0x256a,0x256b,0x256c,0x256d,0x256e,0x256f,
       
  1975 	0x2570,0x2571,0x2572,0x2573,0x2574,0x2575,0x2576,0x2577,0x2578,0x2579,
       
  1976 	0x257a,0x257b,0x257c,0x257d,0x257e,0x257f,0x2580,0x2581,0x2582,0x2583,
       
  1977 	0x2584,0x2585,0x2586,0x2587,0x2588,0x2589,0x258a,0x258b,0x258c,0x258d,
       
  1978 	0x258e,0x258f,0x2590,0x2591,0x2592,0x2593,0x2594,0x2595,0x2596,0x2597,
       
  1979 	0x2598,0x2599,0x259a,0x259b,0x259c,0x259d,0x259e,0x259f,0x25a0,0x25a1,
       
  1980 	0x25a2,0x25a3,0x25a4,0x25a5,0x25a6,0x25a7,0x25a8,0x25a9,0x25aa,0x25ab,
       
  1981 	0x25ac,0x25ad,0x25ae,0x25af,0x25b0,0x25b1,0x25b2,0x25b3,0x25b4,0x25b5,
       
  1982 	0x25b6,0x25b7,0x25b8,0x25b9,0x25ba,0x25bb,0x25bc,0x25bd,0x25be,0x25bf,
       
  1983 	0x25c0,0x25c1,0x25c2,0x25c3,0x25c4,0x25c5,0x25c6,0x25c7,0x25c8,0x25c9,
       
  1984 	0x25ca,0x25cb,0x25cc,0x25cd,0x25ce,0x25cf,0x25d0,0x25d1,0x25d2,0x25d3,
       
  1985 	0x25d4,0x25d5,0x25d6,0x25d7,0x25d8,0x25d9,0x25da,0x25db,0x25dc,0x25dd,
       
  1986 	0x25de,0x25df,0x25e0,0x25e1,0x25e2,0x25e3,0x25e4,0x25e5,0x25e6,0x25e7,
       
  1987 	0x25e8,0x25e9,0x25ea,0x25eb,0x25ec,0x25ed,0x25ee,0x25ef,0x25f0,0x25f1,
       
  1988 	0x25f2,0x25f3,0x25f4,0x25f5,0x25f6,0x25f7,0x25f8,0x25f9,0x25fa,0x25fb,
       
  1989 	0x25fc,0x25fd,0x25fe,0x25ff,0x2600,0x2601,0x2602,0x2603,0x2604,0x2605,
       
  1990 	0x2606,0x2607,0x2608,0x2609,0x260a,0x260b,0x260c,0x260d,0x260e,0x260f,
       
  1991 	0x2610,0x2611,0x2612,0x2613,0x2614,0x2615,0x2616,0x2617,0x2618,0x2619,
       
  1992 	0x261a,0x261b,0x261c,0x261d,0x261e,0x261f,0x2620,0x2621,0x2622,0x2623,
       
  1993 	0x2624,0x2625,0x2626,0x2627,0x2628,0x2629,0x262a,0x262b,0x262c,0x262d,
       
  1994 	0x262e,0x262f,0x2630,0x2631,0x2632,0x2633,0x2634,0x2635,0x2636,0x2637,
       
  1995 	0x2638,0x2639,0x263a,0x263b,0x263c,0x263d,0x263e,0x263f,0x2640,0x2641,
       
  1996 	0x2642,0x2643,0x2644,0x2645,0x2646,0x2647,0x2648,0x2649,0x264a,0x264b,
       
  1997 	0x264c,0x264d,0x264e,0x264f,0x2650,0x2651,0x2652,0x2653,0x2654,0x2655,
       
  1998 	0x2656,0x2657,0x2658,0x2659,0x265a,0x265b,0x265c,0x265d,0x265e,0x265f,
       
  1999 	0x2660,0x2661,0x2662,0x2663,0x2664,0x2665,0x2666,0x2667,0x2668,0x2669,
       
  2000 	0x266a,0x266b,0x266c,0x266d,0x266e,0x266f,0x2670,0x2671,0x2672,0x2673,
       
  2001 	0x2674,0x2675,0x2676,0x2677,0x2678,0x2679,0x267a,0x267b,0x267c,0x267d,
       
  2002 	0x267e,0x267f,0x2680,0x2681,0x2682,0x2683,0x2684,0x2685,0x2686,0x2687,
       
  2003 	0x2688,0x2689,0x268a,0x268b,0x268c,0x268d,0x268e,0x268f,0x2690,0x2691,
       
  2004 	0x2692,0x2693,0x2694,0x2695,0x2696,0x2697,0x2698,0x2699,0x269a,0x269b,
       
  2005 	0x269c,0x26a0,0x26a1,0x26a2,0x26a3,0x26a4,0x26a5,0x26a6,0x26a7,0x26a8,
       
  2006 	0x26a9,0x26aa,0x26ab,0x26ad,0x26ae,0x26af,0x26b0,0x26b1,0x26b2,0x2701,
       
  2007 	0x2702,0x2703,0x2704,0x2706,0x2707,0x2708,0x2709,0x270c,0x270d,0x270e,
       
  2008 	0x270f,0x2710,0x2711,0x2712,0x2713,0x2714,0x2715,0x2716,0x2717,0x2718,
       
  2009 	0x2719,0x271a,0x271b,0x271c,0x271d,0x271e,0x271f,0x2720,0x2721,0x2722,
       
  2010 	0x2723,0x2724,0x2725,0x2726,0x2727,0x2729,0x272a,0x272b,0x272c,0x272d,
       
  2011 	0x272e,0x272f,0x2730,0x2731,0x2732,0x2733,0x2734,0x2735,0x2736,0x2737,
       
  2012 	0x2738,0x2739,0x273a,0x273b,0x273c,0x273d,0x273e,0x273f,0x2740,0x2741,
       
  2013 	0x2742,0x2743,0x2744,0x2745,0x2746,0x2747,0x2748,0x2749,0x274a,0x274b,
       
  2014 	0x274d,0x274f,0x2750,0x2751,0x2752,0x2756,0x2758,0x2759,0x275a,0x275b,
       
  2015 	0x275c,0x275d,0x275e,0x2761,0x2762,0x2763,0x2764,0x2765,0x2766,0x2767,
       
  2016 	0x2768,0x2769,0x276a,0x276b,0x276c,0x276d,0x276e,0x276f,0x2770,0x2771,
       
  2017 	0x2772,0x2773,0x2774,0x2775,0x2776,0x2777,0x2778,0x2779,0x277a,0x277b,
       
  2018 	0x277c,0x277d,0x277e,0x277f,0x2780,0x2781,0x2782,0x2783,0x2784,0x2785,
       
  2019 	0x2786,0x2787,0x2788,0x2789,0x278a,0x278b,0x278c,0x278d,0x278e,0x278f,
       
  2020 	0x2790,0x2791,0x2792,0x2793,0x2794,0x2798,0x2799,0x279a,0x279b,0x279c,
       
  2021 	0x279d,0x279e,0x279f,0x27a0,0x27a1,0x27a2,0x27a3,0x27a4,0x27a5,0x27a6,
       
  2022 	0x27a7,0x27a8,0x27a9,0x27aa,0x27ab,0x27ac,0x27ad,0x27ae,0x27af,0x27b1,
       
  2023 	0x27b2,0x27b3,0x27b4,0x27b5,0x27b6,0x27b7,0x27b8,0x27b9,0x27ba,0x27bb,
       
  2024 	0x27bc,0x27bd,0x27be,0x27c0,0x27c1,0x27c2,0x27c3,0x27c4,0x27c5,0x27c6,
       
  2025 	0x27c7,0x27c8,0x27c9,0x27ca,0x27d0,0x27d1,0x27d2,0x27d3,0x27d4,0x27d5,
       
  2026 	0x27d6,0x27d7,0x27d8,0x27d9,0x27da,0x27db,0x27dc,0x27dd,0x27de,0x27df,
       
  2027 	0x27e0,0x27e1,0x27e2,0x27e3,0x27e4,0x27e5,0x27e6,0x27e7,0x27e8,0x27e9,
       
  2028 	0x27ea,0x27eb,0x27f0,0x27f1,0x27f2,0x27f3,0x27f4,0x27f5,0x27f6,0x27f7,
       
  2029 	0x27f8,0x27f9,0x27fa,0x27fb,0x27fc,0x27fd,0x27fe,0x27ff,0x2900,0x2901,
       
  2030 	0x2902,0x2903,0x2904,0x2905,0x2906,0x2907,0x2908,0x2909,0x290a,0x290b,
       
  2031 	0x290c,0x290d,0x290e,0x290f,0x2910,0x2911,0x2912,0x2913,0x2914,0x2915,
       
  2032 	0x2916,0x2917,0x2918,0x2919,0x291a,0x291b,0x291c,0x291d,0x291e,0x291f,
       
  2033 	0x2920,0x2921,0x2922,0x2923,0x2924,0x2925,0x2926,0x2927,0x2928,0x2929,
       
  2034 	0x292a,0x292b,0x292c,0x292d,0x292e,0x292f,0x2930,0x2931,0x2932,0x2933,
       
  2035 	0x2934,0x2935,0x2936,0x2937,0x2938,0x2939,0x293a,0x293b,0x293c,0x293d,
       
  2036 	0x293e,0x293f,0x2940,0x2941,0x2942,0x2943,0x2944,0x2945,0x2946,0x2947,
       
  2037 	0x2948,0x2949,0x294a,0x294b,0x294c,0x294d,0x294e,0x294f,0x2950,0x2951,
       
  2038 	0x2952,0x2953,0x2954,0x2955,0x2956,0x2957,0x2958,0x2959,0x295a,0x295b,
       
  2039 	0x295c,0x295d,0x295e,0x295f,0x2960,0x2961,0x2962,0x2963,0x2964,0x2965,
       
  2040 	0x2966,0x2967,0x2968,0x2969,0x296a,0x296b,0x296c,0x296d,0x296e,0x296f,
       
  2041 	0x2970,0x2971,0x2972,0x2973,0x2974,0x2975,0x2976,0x2977,0x2978,0x2979,
       
  2042 	0x297a,0x297b,0x297c,0x297d,0x297e,0x297f,0x2980,0x2981,0x2982,0x2983,
       
  2043 	0x2984,0x2985,0x2986,0x2987,0x2988,0x2989,0x298a,0x298b,0x298c,0x298d,
       
  2044 	0x298e,0x298f,0x2990,0x2991,0x2992,0x2993,0x2994,0x2995,0x2996,0x2997,
       
  2045 	0x2998,0x2999,0x299a,0x299b,0x299c,0x299d,0x299e,0x299f,0x29a0,0x29a1,
       
  2046 	0x29a2,0x29a3,0x29a4,0x29a5,0x29a6,0x29a7,0x29a8,0x29a9,0x29aa,0x29ab,
       
  2047 	0x29ac,0x29ad,0x29ae,0x29af,0x29b0,0x29b1,0x29b2,0x29b3,0x29b4,0x29b5,
       
  2048 	0x29b6,0x29b7,0x29b8,0x29b9,0x29ba,0x29bb,0x29bc,0x29bd,0x29be,0x29bf,
       
  2049 	0x29c0,0x29c1,0x29c2,0x29c3,0x29c4,0x29c5,0x29c6,0x29c7,0x29c8,0x29c9,
       
  2050 	0x29ca,0x29cb,0x29cc,0x29cd,0x29ce,0x29cf,0x29d0,0x29d1,0x29d2,0x29d3,
       
  2051 	0x29d4,0x29d5,0x29d6,0x29d7,0x29d8,0x29d9,0x29da,0x29db,0x29dc,0x29dd,
       
  2052 	0x29de,0x29df,0x29e0,0x29e1,0x29e2,0x29e3,0x29e4,0x29e5,0x29e6,0x29e7,
       
  2053 	0x29e8,0x29e9,0x29ea,0x29eb,0x29ec,0x29ed,0x29ee,0x29ef,0x29f0,0x29f1,
       
  2054 	0x29f2,0x29f3,0x29f4,0x29f5,0x29f6,0x29f7,0x29f8,0x29f9,0x29fa,0x29fb,
       
  2055 	0x29fc,0x29fd,0x29fe,0x29ff,0x2a00,0x2a01,0x2a02,0x2a03,0x2a04,0x2a05,
       
  2056 	0x2a06,0x2a07,0x2a08,0x2a09,0x2a0a,0x2a0b,0x2a0c,0x2a0d,0x2a0e,0x2a0f,
       
  2057 	0x2a10,0x2a11,0x2a12,0x2a13,0x2a14,0x2a15,0x2a16,0x2a17,0x2a18,0x2a19,
       
  2058 	0x2a1a,0x2a1b,0x2a1c,0x2a1d,0x2a1e,0x2a1f,0x2a20,0x2a21,0x2a22,0x2a23,
       
  2059 	0x2a24,0x2a25,0x2a26,0x2a27,0x2a28,0x2a29,0x2a2a,0x2a2b,0x2a2c,0x2a2d,
       
  2060 	0x2a2e,0x2a2f,0x2a30,0x2a31,0x2a32,0x2a33,0x2a34,0x2a35,0x2a36,0x2a37,
       
  2061 	0x2a38,0x2a39,0x2a3a,0x2a3b,0x2a3c,0x2a3d,0x2a3e,0x2a3f,0x2a40,0x2a41,
       
  2062 	0x2a42,0x2a43,0x2a44,0x2a45,0x2a46,0x2a47,0x2a48,0x2a49,0x2a4a,0x2a4b,
       
  2063 	0x2a4c,0x2a4d,0x2a4e,0x2a4f,0x2a50,0x2a51,0x2a52,0x2a53,0x2a54,0x2a55,
       
  2064 	0x2a56,0x2a57,0x2a58,0x2a59,0x2a5a,0x2a5b,0x2a5c,0x2a5d,0x2a5e,0x2a5f,
       
  2065 	0x2a60,0x2a61,0x2a62,0x2a63,0x2a64,0x2a65,0x2a66,0x2a67,0x2a68,0x2a69,
       
  2066 	0x2a6a,0x2a6b,0x2a6c,0x2a6d,0x2a6e,0x2a6f,0x2a70,0x2a71,0x2a72,0x2a73,
       
  2067 	0x2a74,0x2a75,0x2a76,0x2a77,0x2a78,0x2a79,0x2a7a,0x2a7b,0x2a7c,0x2a7d,
       
  2068 	0x2a7e,0x2a7f,0x2a80,0x2a81,0x2a82,0x2a83,0x2a84,0x2a85,0x2a86,0x2a87,
       
  2069 	0x2a88,0x2a89,0x2a8a,0x2a8b,0x2a8c,0x2a8d,0x2a8e,0x2a8f,0x2a90,0x2a91,
       
  2070 	0x2a92,0x2a93,0x2a94,0x2a95,0x2a96,0x2a97,0x2a98,0x2a99,0x2a9a,0x2a9b,
       
  2071 	0x2a9c,0x2a9d,0x2a9e,0x2a9f,0x2aa0,0x2aa1,0x2aa2,0x2aa3,0x2aa4,0x2aa5,
       
  2072 	0x2aa6,0x2aa7,0x2aa8,0x2aa9,0x2aaa,0x2aab,0x2aac,0x2aad,0x2aae,0x2aaf,
       
  2073 	0x2ab0,0x2ab1,0x2ab2,0x2ab3,0x2ab4,0x2ab5,0x2ab6,0x2ab7,0x2ab8,0x2ab9,
       
  2074 	0x2aba,0x2abb,0x2abc,0x2abd,0x2abe,0x2abf,0x2ac0,0x2ac1,0x2ac2,0x2ac3,
       
  2075 	0x2ac4,0x2ac5,0x2ac6,0x2ac7,0x2ac8,0x2ac9,0x2aca,0x2acb,0x2acc,0x2acd,
       
  2076 	0x2ace,0x2acf,0x2ad0,0x2ad1,0x2ad2,0x2ad3,0x2ad4,0x2ad5,0x2ad6,0x2ad7,
       
  2077 	0x2ad8,0x2ad9,0x2ada,0x2adb,0x2adc,0x2add,0x2ade,0x2adf,0x2ae0,0x2ae1,
       
  2078 	0x2ae2,0x2ae3,0x2ae4,0x2ae5,0x2ae6,0x2ae7,0x2ae8,0x2ae9,0x2aea,0x2aeb,
       
  2079 	0x2aec,0x2aed,0x2aee,0x2aef,0x2af0,0x2af1,0x2af2,0x2af3,0x2af4,0x2af5,
       
  2080 	0x2af6,0x2af7,0x2af8,0x2af9,0x2afa,0x2afb,0x2afc,0x2afd,0x2afe,0x2aff,
       
  2081 	0x2b00,0x2b01,0x2b02,0x2b03,0x2b04,0x2b05,0x2b06,0x2b07,0x2b08,0x2b09,
       
  2082 	0x2b0a,0x2b0b,0x2b0c,0x2b0d,0x2b0e,0x2b0f,0x2b10,0x2b11,0x2b12,0x2b13,
       
  2083 	0x2b14,0x2b15,0x2b16,0x2b17,0x2b18,0x2b19,0x2b1a,0x2b20,0x2b21,0x2b22,
       
  2084 	0x2b23,0x2ce5,0x2ce6,0x2ce7,0x2ce8,0x2ce9,0x2cea,0x2cf9,0x2cfa,0x2cfb,
       
  2085 	0x2cfc,0x2cfd,0x2cfe,0x2cff,0x2e00,0x2e01,0x2e02,0x2e03,0x2e04,0x2e05,
       
  2086 	0x2e06,0x2e07,0x2e08,0x2e09,0x2e0a,0x2e0b,0x2e0c,0x2e0d,0x2e0e,0x2e0f,
       
  2087 	0x2e10,0x2e11,0x2e12,0x2e13,0x2e14,0x2e15,0x2e16,0x2e17,0x2e1c,0x2e1d,
       
  2088 	0x2e80,0x2e81,0x2e82,0x2e83,0x2e84,0x2e85,0x2e86,0x2e87,0x2e88,0x2e89,
       
  2089 	0x2e8a,0x2e8b,0x2e8c,0x2e8d,0x2e8e,0x2e8f,0x2e90,0x2e91,0x2e92,0x2e93,
       
  2090 	0x2e94,0x2e95,0x2e96,0x2e97,0x2e98,0x2e99,0x2e9b,0x2e9c,0x2e9d,0x2e9e,
       
  2091 	0x2e9f,0x2ea0,0x2ea1,0x2ea2,0x2ea3,0x2ea4,0x2ea5,0x2ea6,0x2ea7,0x2ea8,
       
  2092 	0x2ea9,0x2eaa,0x2eab,0x2eac,0x2ead,0x2eae,0x2eaf,0x2eb0,0x2eb1,0x2eb2,
       
  2093 	0x2eb3,0x2eb4,0x2eb5,0x2eb6,0x2eb7,0x2eb8,0x2eb9,0x2eba,0x2ebb,0x2ebc,
       
  2094 	0x2ebd,0x2ebe,0x2ebf,0x2ec0,0x2ec1,0x2ec2,0x2ec3,0x2ec4,0x2ec5,0x2ec6,
       
  2095 	0x2ec7,0x2ec8,0x2ec9,0x2eca,0x2ecb,0x2ecc,0x2ecd,0x2ece,0x2ecf,0x2ed0,
       
  2096 	0x2ed1,0x2ed2,0x2ed3,0x2ed4,0x2ed5,0x2ed6,0x2ed7,0x2ed8,0x2ed9,0x2eda,
       
  2097 	0x2edb,0x2edc,0x2edd,0x2ede,0x2edf,0x2ee0,0x2ee1,0x2ee2,0x2ee3,0x2ee4,
       
  2098 	0x2ee5,0x2ee6,0x2ee7,0x2ee8,0x2ee9,0x2eea,0x2eeb,0x2eec,0x2eed,0x2eee,
       
  2099 	0x2eef,0x2ef0,0x2ef1,0x2ef2,0x2ef3,0x2f00,0x2f01,0x2f02,0x2f03,0x2f04,
       
  2100 	0x2f05,0x2f06,0x2f07,0x2f08,0x2f09,0x2f0a,0x2f0b,0x2f0c,0x2f0d,0x2f0e,
       
  2101 	0x2f0f,0x2f10,0x2f11,0x2f12,0x2f13,0x2f14,0x2f15,0x2f16,0x2f17,0x2f18,
       
  2102 	0x2f19,0x2f1a,0x2f1b,0x2f1c,0x2f1d,0x2f1e,0x2f1f,0x2f20,0x2f21,0x2f22,
       
  2103 	0x2f23,0x2f24,0x2f25,0x2f26,0x2f27,0x2f28,0x2f29,0x2f2a,0x2f2b,0x2f2c,
       
  2104 	0x2f2d,0x2f2e,0x2f2f,0x2f30,0x2f31,0x2f32,0x2f33,0x2f34,0x2f35,0x2f36,
       
  2105 	0x2f37,0x2f38,0x2f39,0x2f3a,0x2f3b,0x2f3c,0x2f3d,0x2f3e,0x2f3f,0x2f40,
       
  2106 	0x2f41,0x2f42,0x2f43,0x2f44,0x2f45,0x2f46,0x2f47,0x2f48,0x2f49,0x2f4a,
       
  2107 	0x2f4b,0x2f4c,0x2f4d,0x2f4e,0x2f4f,0x2f50,0x2f51,0x2f52,0x2f53,0x2f54,
       
  2108 	0x2f55,0x2f56,0x2f57,0x2f58,0x2f59,0x2f5a,0x2f5b,0x2f5c,0x2f5d,0x2f5e,
       
  2109 	0x2f5f,0x2f60,0x2f61,0x2f62,0x2f63,0x2f64,0x2f65,0x2f66,0x2f67,0x2f68,
       
  2110 	0x2f69,0x2f6a,0x2f6b,0x2f6c,0x2f6d,0x2f6e,0x2f6f,0x2f70,0x2f71,0x2f72,
       
  2111 	0x2f73,0x2f74,0x2f75,0x2f76,0x2f77,0x2f78,0x2f79,0x2f7a,0x2f7b,0x2f7c,
       
  2112 	0x2f7d,0x2f7e,0x2f7f,0x2f80,0x2f81,0x2f82,0x2f83,0x2f84,0x2f85,0x2f86,
       
  2113 	0x2f87,0x2f88,0x2f89,0x2f8a,0x2f8b,0x2f8c,0x2f8d,0x2f8e,0x2f8f,0x2f90,
       
  2114 	0x2f91,0x2f92,0x2f93,0x2f94,0x2f95,0x2f96,0x2f97,0x2f98,0x2f99,0x2f9a,
       
  2115 	0x2f9b,0x2f9c,0x2f9d,0x2f9e,0x2f9f,0x2fa0,0x2fa1,0x2fa2,0x2fa3,0x2fa4,
       
  2116 	0x2fa5,0x2fa6,0x2fa7,0x2fa8,0x2fa9,0x2faa,0x2fab,0x2fac,0x2fad,0x2fae,
       
  2117 	0x2faf,0x2fb0,0x2fb1,0x2fb2,0x2fb3,0x2fb4,0x2fb5,0x2fb6,0x2fb7,0x2fb8,
       
  2118 	0x2fb9,0x2fba,0x2fbb,0x2fbc,0x2fbd,0x2fbe,0x2fbf,0x2fc0,0x2fc1,0x2fc2,
       
  2119 	0x2fc3,0x2fc4,0x2fc5,0x2fc6,0x2fc7,0x2fc8,0x2fc9,0x2fca,0x2fcb,0x2fcc,
       
  2120 	0x2fcd,0x2fce,0x2fcf,0x2fd0,0x2fd1,0x2fd2,0x2fd3,0x2fd4,0x2fd5,0x2ff0,
       
  2121 	0x2ff1,0x2ff2,0x2ff3,0x2ff4,0x2ff5,0x2ff6,0x2ff7,0x2ff8,0x2ff9,0x2ffa,
       
  2122 	0x2ffb,0x3001,0x3002,0x3003,0x3004,0x3008,0x3009,0x300a,0x300b,0x300c,
       
  2123 	0x300d,0x300e,0x300f,0x3010,0x3011,0x3012,0x3013,0x3014,0x3015,0x3016,
       
  2124 	0x3017,0x3018,0x3019,0x301a,0x301b,0x301c,0x301d,0x301e,0x301f,0x3020,
       
  2125 	0x3030,0x3036,0x3037,0x303d,0x303e,0x303f,0x309b,0x309c,0x30a0,0x30fb,
       
  2126 	0x31c0,0x31c1,0x31c2,0x31c3,0x31c4,0x31c5,0x31c6,0x31c7,0x31c8,0x31c9,
       
  2127 	0x31ca,0x31cb,0x31cc,0x31cd,0x31ce,0x31cf,0x321d,0x321e,0x3250,0x3251,
       
  2128 	0x3252,0x3253,0x3254,0x3255,0x3256,0x3257,0x3258,0x3259,0x325a,0x325b,
       
  2129 	0x325c,0x325d,0x325e,0x325f,0x327c,0x327d,0x327e,0x32b1,0x32b2,0x32b3,
       
  2130 	0x32b4,0x32b5,0x32b6,0x32b7,0x32b8,0x32b9,0x32ba,0x32bb,0x32bc,0x32bd,
       
  2131 	0x32be,0x32bf,0x32cc,0x32cd,0x32ce,0x32cf,0x3377,0x3378,0x3379,0x337a,
       
  2132 	0x33de,0x33df,0x33ff,0x4dc0,0x4dc1,0x4dc2,0x4dc3,0x4dc4,0x4dc5,0x4dc6,
       
  2133 	0x4dc7,0x4dc8,0x4dc9,0x4dca,0x4dcb,0x4dcc,0x4dcd,0x4dce,0x4dcf,0x4dd0,
       
  2134 	0x4dd1,0x4dd2,0x4dd3,0x4dd4,0x4dd5,0x4dd6,0x4dd7,0x4dd8,0x4dd9,0x4dda,
       
  2135 	0x4ddb,0x4ddc,0x4ddd,0x4dde,0x4ddf,0x4de0,0x4de1,0x4de2,0x4de3,0x4de4,
       
  2136 	0x4de5,0x4de6,0x4de7,0x4de8,0x4de9,0x4dea,0x4deb,0x4dec,0x4ded,0x4dee,
       
  2137 	0x4def,0x4df0,0x4df1,0x4df2,0x4df3,0x4df4,0x4df5,0x4df6,0x4df7,0x4df8,
       
  2138 	0x4df9,0x4dfa,0x4dfb,0x4dfc,0x4dfd,0x4dfe,0x4dff,0xa490,0xa491,0xa492,
       
  2139 	0xa493,0xa494,0xa495,0xa496,0xa497,0xa498,0xa499,0xa49a,0xa49b,0xa49c,
       
  2140 	0xa49d,0xa49e,0xa49f,0xa4a0,0xa4a1,0xa4a2,0xa4a3,0xa4a4,0xa4a5,0xa4a6,
       
  2141 	0xa4a7,0xa4a8,0xa4a9,0xa4aa,0xa4ab,0xa4ac,0xa4ad,0xa4ae,0xa4af,0xa4b0,
       
  2142 	0xa4b1,0xa4b2,0xa4b3,0xa4b4,0xa4b5,0xa4b6,0xa4b7,0xa4b8,0xa4b9,0xa4ba,
       
  2143 	0xa4bb,0xa4bc,0xa4bd,0xa4be,0xa4bf,0xa4c0,0xa4c1,0xa4c2,0xa4c3,0xa4c4,
       
  2144 	0xa4c5,0xa4c6,0xa700,0xa701,0xa702,0xa703,0xa704,0xa705,0xa706,0xa707,
       
  2145 	0xa708,0xa709,0xa70a,0xa70b,0xa70c,0xa70d,0xa70e,0xa70f,0xa710,0xa711,
       
  2146 	0xa712,0xa713,0xa714,0xa715,0xa716,0xa717,0xa718,0xa719,0xa71a,0xa720,
       
  2147 	0xa721,0xa828,0xa829,0xa82a,0xa82b,0xa874,0xa875,0xa876,0xa877,0xfd3e,
       
  2148 	0xfd3f,0xfdfd,0xfe10,0xfe11,0xfe12,0xfe13,0xfe14,0xfe15,0xfe16,0xfe17,
       
  2149 	0xfe18,0xfe19,0xfe30,0xfe31,0xfe32,0xfe33,0xfe34,0xfe35,0xfe36,0xfe37,
       
  2150 	0xfe38,0xfe39,0xfe3a,0xfe3b,0xfe3c,0xfe3d,0xfe3e,0xfe3f,0xfe40,0xfe41,
       
  2151 	0xfe42,0xfe43,0xfe44,0xfe45,0xfe46,0xfe47,0xfe48,0xfe49,0xfe4a,0xfe4b,
       
  2152 	0xfe4c,0xfe4d,0xfe4e,0xfe4f,0xfe51,0xfe54,0xfe56,0xfe57,0xfe58,0xfe59,
       
  2153 	0xfe5a,0xfe5b,0xfe5c,0xfe5d,0xfe5e,0xfe60,0xfe61,0xfe64,0xfe65,0xfe66,
       
  2154 	0xfe68,0xfe6b,0xff01,0xff02,0xff06,0xff07,0xff08,0xff09,0xff0a,0xff1b,
       
  2155 	0xff1c,0xff1d,0xff1e,0xff1f,0xff20,0xff3b,0xff3c,0xff3d,0xff3e,0xff3f,
       
  2156 	0xff40,0xff5b,0xff5c,0xff5d,0xff5e,0xff5f,0xff60,0xff61,0xff62,0xff63,
       
  2157 	0xff64,0xff65,0xffe2,0xffe3,0xffe4,0xffe8,0xffe9,0xffea,0xffeb,0xffec,
       
  2158 	0xffed,0xffee,0xfff9,0xfffa,0xfffb,0xfffc,0xfffd,0xd800,0xdd01,
       
  2159 	0xd800,0xdd40,0xd800,0xdd41,0xd800,0xdd42,0xd800,0xdd43,0xd800,0xdd44,
       
  2160 	0xd800,0xdd45,0xd800,0xdd46,0xd800,0xdd47,0xd800,0xdd48,0xd800,0xdd49,
       
  2161 	0xd800,0xdd4a,0xd800,0xdd4b,0xd800,0xdd4c,0xd800,0xdd4d,0xd800,0xdd4e,
       
  2162 	0xd800,0xdd4f,0xd800,0xdd50,0xd800,0xdd51,0xd800,0xdd52,0xd800,0xdd53,
       
  2163 	0xd800,0xdd54,0xd800,0xdd55,0xd800,0xdd56,0xd800,0xdd57,0xd800,0xdd58,
       
  2164 	0xd800,0xdd59,0xd800,0xdd5a,0xd800,0xdd5b,0xd800,0xdd5c,0xd800,0xdd5d,
       
  2165 	0xd800,0xdd5e,0xd800,0xdd5f,0xd800,0xdd60,0xd800,0xdd61,0xd800,0xdd62,
       
  2166 	0xd800,0xdd63,0xd800,0xdd64,0xd800,0xdd65,0xd800,0xdd66,0xd800,0xdd67,
       
  2167 	0xd800,0xdd68,0xd800,0xdd69,0xd800,0xdd6a,0xd800,0xdd6b,0xd800,0xdd6c,
       
  2168 	0xd800,0xdd6d,0xd800,0xdd6e,0xd800,0xdd6f,0xd800,0xdd70,0xd800,0xdd71,
       
  2169 	0xd800,0xdd72,0xd800,0xdd73,0xd800,0xdd74,0xd800,0xdd75,0xd800,0xdd76,
       
  2170 	0xd800,0xdd77,0xd800,0xdd78,0xd800,0xdd79,0xd800,0xdd7a,0xd800,0xdd7b,
       
  2171 	0xd800,0xdd7c,0xd800,0xdd7d,0xd800,0xdd7e,0xd800,0xdd7f,0xd800,0xdd80,
       
  2172 	0xd800,0xdd81,0xd800,0xdd82,0xd800,0xdd83,0xd800,0xdd84,0xd800,0xdd85,
       
  2173 	0xd800,0xdd86,0xd800,0xdd87,0xd800,0xdd88,0xd800,0xdd89,0xd800,0xdd8a,
       
  2174 	0xd802,0xdd1f,0xd834,0xde00,0xd834,0xde01,0xd834,0xde02,0xd834,0xde03,
       
  2175 	0xd834,0xde04,0xd834,0xde05,0xd834,0xde06,0xd834,0xde07,0xd834,0xde08,
       
  2176 	0xd834,0xde09,0xd834,0xde0a,0xd834,0xde0b,0xd834,0xde0c,0xd834,0xde0d,
       
  2177 	0xd834,0xde0e,0xd834,0xde0f,0xd834,0xde10,0xd834,0xde11,0xd834,0xde12,
       
  2178 	0xd834,0xde13,0xd834,0xde14,0xd834,0xde15,0xd834,0xde16,0xd834,0xde17,
       
  2179 	0xd834,0xde18,0xd834,0xde19,0xd834,0xde1a,0xd834,0xde1b,0xd834,0xde1c,
       
  2180 	0xd834,0xde1d,0xd834,0xde1e,0xd834,0xde1f,0xd834,0xde20,0xd834,0xde21,
       
  2181 	0xd834,0xde22,0xd834,0xde23,0xd834,0xde24,0xd834,0xde25,0xd834,0xde26,
       
  2182 	0xd834,0xde27,0xd834,0xde28,0xd834,0xde29,0xd834,0xde2a,0xd834,0xde2b,
       
  2183 	0xd834,0xde2c,0xd834,0xde2d,0xd834,0xde2e,0xd834,0xde2f,0xd834,0xde30,
       
  2184 	0xd834,0xde31,0xd834,0xde32,0xd834,0xde33,0xd834,0xde34,0xd834,0xde35,
       
  2185 	0xd834,0xde36,0xd834,0xde37,0xd834,0xde38,0xd834,0xde39,0xd834,0xde3a,
       
  2186 	0xd834,0xde3b,0xd834,0xde3c,0xd834,0xde3d,0xd834,0xde3e,0xd834,0xde3f,
       
  2187 	0xd834,0xde40,0xd834,0xde41,0xd834,0xde45,0xd834,0xdf00,0xd834,0xdf01,
       
  2188 	0xd834,0xdf02,0xd834,0xdf03,0xd834,0xdf04,0xd834,0xdf05,0xd834,0xdf06,
       
  2189 	0xd834,0xdf07,0xd834,0xdf08,0xd834,0xdf09,0xd834,0xdf0a,0xd834,0xdf0b,
       
  2190 	0xd834,0xdf0c,0xd834,0xdf0d,0xd834,0xdf0e,0xd834,0xdf0f,0xd834,0xdf10,
       
  2191 	0xd834,0xdf11,0xd834,0xdf12,0xd834,0xdf13,0xd834,0xdf14,0xd834,0xdf15,
       
  2192 	0xd834,0xdf16,0xd834,0xdf17,0xd834,0xdf18,0xd834,0xdf19,0xd834,0xdf1a,
       
  2193 	0xd834,0xdf1b,0xd834,0xdf1c,0xd834,0xdf1d,0xd834,0xdf1e,0xd834,0xdf1f,
       
  2194 	0xd834,0xdf20,0xd834,0xdf21,0xd834,0xdf22,0xd834,0xdf23,0xd834,0xdf24,
       
  2195 	0xd834,0xdf25,0xd834,0xdf26,0xd834,0xdf27,0xd834,0xdf28,0xd834,0xdf29,
       
  2196 	0xd834,0xdf2a,0xd834,0xdf2b,0xd834,0xdf2c,0xd834,0xdf2d,0xd834,0xdf2e,
       
  2197 	0xd834,0xdf2f,0xd834,0xdf30,0xd834,0xdf31,0xd834,0xdf32,0xd834,0xdf33,
       
  2198 	0xd834,0xdf34,0xd834,0xdf35,0xd834,0xdf36,0xd834,0xdf37,0xd834,0xdf38,
       
  2199 	0xd834,0xdf39,0xd834,0xdf3a,0xd834,0xdf3b,0xd834,0xdf3c,0xd834,0xdf3d,
       
  2200 	0xd834,0xdf3e,0xd834,0xdf3f,0xd834,0xdf40,0xd834,0xdf41,0xd834,0xdf42,
       
  2201 	0xd834,0xdf43,0xd834,0xdf44,0xd834,0xdf45,0xd834,0xdf46,0xd834,0xdf47,
       
  2202 	0xd834,0xdf48,0xd834,0xdf49,0xd834,0xdf4a,0xd834,0xdf4b,0xd834,0xdf4c,
       
  2203 	0xd834,0xdf4d,0xd834,0xdf4e,0xd834,0xdf4f,0xd834,0xdf50,0xd834,0xdf51,
       
  2204 	0xd834,0xdf52,0xd834,0xdf53,0xd834,0xdf54,0xd834,0xdf55,0xd834,0xdf56,
       
  2205 	};
       
  2206 static const TUint KOtherNeutralsLength = 2917 + 462;
       
  2207 
       
  2208 //This test data is an extract from the Project Gutenberg version of 
       
  2209 //The War Of The Worlds by H G Wells
       
  2210 
       
  2211 static const TUint16 KArab1Data[] = 
       
  2212 	{
       
  2213 	0xfeff, 0x0623, 0x0633, 0x0627, 0x0633, 0x064b, 0x0627, 0x060c,
       
  2214 	0x0020, 0x000d, 0x000a, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020,
       
  2215 	0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020,
       
  2216 	0x0020, 0x062a, 0x062a, 0x0639, 0x0627, 0x0645, 0x0644, 0x0020,
       
  2217 	0x0627, 0x0644, 0x062d, 0x0648, 0x0627, 0x0633, 0x064a, 0x0628,
       
  2218 	0x0020, 0x0641, 0x0642, 0x0637, 0x0020, 0x0645, 0x0639, 0x0020,
       
  2219 	0x0627, 0x0644, 0x0623, 0x0631, 0x0642, 0x0627, 0x0645, 0x060c,
       
  2220 	0x0020, 0x0648, 0x062a, 0x0642, 0x0648, 0x0645, 0x0020, 0x0628,
       
  2221 	0x062a, 0x062e, 0x0632, 0x064a, 0x0646, 0x0020, 0x0627, 0x0644,
       
  2222 	0x0623, 0x062d, 0x0631, 0x0641, 0x0020, 0x0648, 0x0627, 0x0644,
       
  2223 	0x0645, 0x062d, 0x0627, 0x0631, 0x0641, 0x0020, 0x000d, 0x000a,
       
  2224 	0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020,
       
  2225 	0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0627, 0x0644,
       
  2226 	0x0623, 0x062e, 0x0631, 0x0649, 0x0020, 0x0628, 0x0639, 0x062f,
       
  2227 	0x0020, 0x0623, 0x0646, 0x0020, 0x062a, 0x064f, 0x0639, 0x0637,
       
  2228 	0x064a, 0x0020, 0x0631, 0x0642, 0x0645, 0x0627, 0x0020, 0x0645,
       
  2229 	0x0639, 0x064a, 0x0646, 0x0627, 0x0020, 0x0644, 0x0643, 0x0644,
       
  2230 	0x0020, 0x0648, 0x0627, 0x062d, 0x062f, 0x0020, 0x0645, 0x0646,
       
  2231 	0x0647, 0x0627, 0x002e, 0x0020, 0x0648, 0x0642, 0x0628, 0x0644,
       
  2232 	0x0020, 0x0627, 0x062e, 0x062a, 0x0631, 0x0627, 0x0639, 0x0020,
       
  2233 	0x000d, 0x000a, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020,
       
  2234 	0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020,
       
  2235 	0x0022, 0x064a, 0x0648, 0x0646, 0x0650, 0x0643, 0x0648, 0x062f,
       
  2236 	0x0022, 0x060c, 0x0020, 0x0643, 0x0627, 0x0646, 0x0020, 0x0647,
       
  2237 	0x0646, 0x0627, 0x0643, 0x0020, 0x0645, 0x0626, 0x0627, 0x062a,
       
  2238 	0x0020, 0x0627, 0x0644, 0x0623, 0x0646, 0x0638, 0x0645, 0x0629,
       
  2239 	0x0020, 0x0644, 0x0644, 0x062a, 0x0634, 0x0641, 0x064a, 0x0631,
       
  2240 	0x0020, 0x0648, 0x062a, 0x062e, 0x0635, 0x064a, 0x0635, 0x0020,
       
  2241 	0x0647, 0x0630, 0x0647, 0x0020, 0x0627, 0x0644, 0x0623, 0x0631,
       
  2242 	0x0642, 0x0627, 0x0645, 0x0020, 0x000d, 0x000a, 0x0020, 0x0020,
       
  2243 	0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020,
       
  2244 	0x0020, 0x0020, 0x0020, 0x0020, 0x0644, 0x0644, 0x0645, 0x062d,
       
  2245 	0x0627, 0x0631, 0x0641, 0x060c, 0x0020, 0x0648, 0x0644, 0x0645,
       
  2246 	0x0020, 0x064a, 0x0648, 0x062c, 0x062f, 0x0020, 0x0646, 0x0638,
       
  2247 	0x0627, 0x0645, 0x0020, 0x062a, 0x0634, 0x0641, 0x064a, 0x0631,
       
  2248 	0x0020, 0x0648, 0x0627, 0x062d, 0x062f, 0x0020, 0x064a, 0x062d,
       
  2249 	0x062a, 0x0648, 0x064a, 0x0020, 0x0639, 0x0644, 0x0649, 0x0020,
       
  2250 	0x062c, 0x0645, 0x064a, 0x0639, 0x0020, 0x0627, 0x0644, 0x0645,
       
  2251 	0x062d, 0x0627, 0x0631, 0x0641, 0x0020, 0x0627, 0x0644, 0x0636,
       
  2252 	0x0631, 0x0648, 0x0631, 0x064a, 0x0629, 0x002e, 0x0020, 0x000d,
       
  2253 	0x000a, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020,
       
  2254 	0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0648,
       
  2255 	0x0639, 0x0644, 0x0649, 0x0020, 0x0633, 0x0628, 0x064a, 0x0644,
       
  2256 	0x0020, 0x0627, 0x0644, 0x0645, 0x062b, 0x0627, 0x0644, 0x060c,
       
  2257 	0x0020, 0x0641, 0x0625, 0x0646, 0x0020, 0x0627, 0x0644, 0x0627,
       
  2258 	0x062a, 0x062d, 0x0627, 0x062f, 0x0020, 0x0627, 0x0644, 0x0623,
       
  2259 	0x0648, 0x0631, 0x0648, 0x0628, 0x064a, 0x0020, 0x0644, 0x0648,
       
  2260 	0x062d, 0x062f, 0x0647, 0x060c, 0x0020, 0x0627, 0x062d, 0x062a,
       
  2261 	0x0648, 0x0649, 0x0020, 0x0627, 0x0644, 0x0639, 0x062f, 0x064a,
       
  2262 	0x062f, 0x0020, 0x0645, 0x0646, 0x0020, 0x000d, 0x000a, 0x0020,
       
  2263 	0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020,
       
  2264 	0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0627, 0x0644, 0x0634,
       
  2265 	0x0641, 0x0631, 0x0627, 0x062a, 0x0020, 0x0627, 0x0644, 0x0645,
       
  2266 	0x062e, 0x062a, 0x0644, 0x0641, 0x0629, 0x0020, 0x0644, 0x064a,
       
  2267 	0x063a, 0x0637, 0x064a, 0x0020, 0x062c, 0x0645, 0x064a, 0x0639,
       
  2268 	0x0020, 0x0627, 0x0644, 0x0644, 0x063a, 0x0627, 0x062a, 0x0020,
       
  2269 	0x0627, 0x0644, 0x0645, 0x0633, 0x062a, 0x062e, 0x062f, 0x0645,
       
  2270 	0x0629, 0x0020, 0x0641, 0x064a, 0x0020, 0x0627, 0x0644, 0x0627,
       
  2271 	0x062a, 0x062d, 0x0627, 0x062f, 0x002e, 0x0020, 0x0648, 0x062d,
       
  2272 	0x062a, 0x0649, 0x0020, 0x0644, 0x0648, 0x0020, 0x000d, 0x000a,
       
  2273 	0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020,
       
  2274 	0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0627, 0x0639,
       
  2275 	0x062a, 0x0628, 0x0631, 0x0646, 0x0627, 0x0020, 0x0644, 0x063a,
       
  2276 	0x0629, 0x0020, 0x0648, 0x0627, 0x062d, 0x062f, 0x0629, 0x060c,
       
  2277 	0x0020, 0x0643, 0x0627, 0x0644, 0x0644, 0x063a, 0x0629, 0x0020,
       
  2278 	0x0627, 0x0644, 0x0625, 0x0646, 0x062c, 0x0644, 0x064a, 0x0632,
       
  2279 	0x064a, 0x0629, 0x060c, 0x0020, 0x0641, 0x0625, 0x0646, 0x0020,
       
  2280 	0x062c, 0x062f, 0x0648, 0x0644, 0x0020, 0x0634, 0x0641, 0x0631,
       
  2281 	0x0629, 0x0020, 0x0648, 0x0627, 0x062d, 0x062f, 0x0020, 0x0644,
       
  2282 	0x0645, 0x0020, 0x064a, 0x0643, 0x0641, 0x0020, 0x000d, 0x000a,
       
  2283 	0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020,
       
  2284 	0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0644, 0x0627,
       
  2285 	0x0633, 0x062a, 0x064a, 0x0639, 0x0627, 0x0628, 0x0020, 0x062c,
       
  2286 	0x0645, 0x064a, 0x0639, 0x0020, 0x0627, 0x0644, 0x0623, 0x062d,
       
  2287 	0x0631, 0x0641, 0x0020, 0x0648, 0x0639, 0x0644, 0x0627, 0x0645,
       
  2288 	0x0627, 0x062a, 0x0020, 0x0627, 0x0644, 0x062a, 0x0631, 0x0642,
       
  2289 	0x064a, 0x0645, 0x0020, 0x0648, 0x0627, 0x0644, 0x0631, 0x0645,
       
  2290 	0x0648, 0x0632, 0x0020, 0x0627, 0x0644, 0x0641, 0x0646, 0x064a,
       
  2291 	0x0629, 0x0020, 0x0648, 0x0627, 0x0644, 0x0639, 0x0644, 0x0645,
       
  2292 	0x064a, 0x0629, 0x0020, 0x000d, 0x000a, 0x0020, 0x0020, 0x0020,
       
  2293 	0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020,
       
  2294 	0x0020, 0x0020, 0x0020, 0x0627, 0x0644, 0x0634, 0x0627, 0x0626,
       
  2295 	0x0639, 0x0629, 0x0020, 0x0627, 0x0644, 0x0627, 0x0633, 0x062a,
       
  2296 	0x0639, 0x0645, 0x0627
       
  2297 	};
       
  2298 
       
  2299 static const TInt KArab1Length = sizeof(KArab1Data)/sizeof(TUint16);
       
  2300 
       
  2301 static const TPtrC KArab1(KArab1Data, KArab1Length);
       
  2302 
       
  2303 //Test data for Arabic Illegal Linebreaking
       
  2304 
       
  2305 static const TUint16 KArabicDualJoiningLettersData[] = 
       
  2306 	{
       
  2307 	0x0626, 0x0628, 0x062a, 0x062b, 0x062c, 0x062e, 0x0633, 0x0634, 0x0637, 0x0638, 0x0639, 0x063a,
       
  2308 	0x0641, 0x0642, 0x0643, 0x0644, 0x0645, 0x0647, 0x0648, 0x0649, 0x064a, 0x0678, 0x0679, 0x067a, 
       
  2309 	0x067b, 0x067c, 0x067d, 0x067e, 0x067f, 0x0680, 0x0681, 0x0682, 0x0683, 0x0684, 0x0685, 0x0686,
       
  2310 	0x0687, 0x069a, 0x069b, 0x069c, 0x069d, 0x069e, 0x069f, 0x06a0, 0x06a1, 0x06a2, 0x06a3, 0x06a4,
       
  2311 	0x06a5, 0x06a6, 0x06a7, 0x06a9, 0x06aa, 0x06ab, 0x06ac, 0x06ad, 0x06ae, 0x06af, 0x06b0, 0x06b1,
       
  2312 	0x06b2, 0x06b3, 0x06b4, 0x06b5, 0x06b6, 0x06b7, 0x06b8, 0x06b9, 0x06ba, 0x06bb, 0x06bc, 0x06bd,
       
  2313 	0x06be, 0x06bf, 0x06c1, 0x06cc, 0x06ce, 0x06d0, 0x06d1, 0x06fa, 0x06fb, 0x06fc
       
  2314 	};
       
  2315 
       
  2316 static const TInt KArabicDualJoiningLettersLength = sizeof(KArabicDualJoiningLettersData)/sizeof(TUint16);
       
  2317 
       
  2318 static const TPtrC KArabicDualJoiningLetters(KArabicDualJoiningLettersData, KArabicDualJoiningLettersLength);
       
  2319 
       
  2320 static const TUint16 KArabicRightJoiningLettersData[] = 
       
  2321 	{
       
  2322 	0x0622, 0x0623, 0x0624, 0x0625, 0x0627, 0x0629, 0x062f, 0x0630, 0x0631, 0x0632, 0x0648, 0x0671,
       
  2323 	0x0672, 0x0673, 0x0675, 0x0676, 0x0677, 0x0688, 0x0689, 0x068a, 0x068b, 0x068c, 0x068d, 0x068e,
       
  2324 	0x068f, 0x0690, 0x0691, 0x0692, 0x0693, 0x0694, 0x0695, 0x0696, 0x0697, 0x0698, 0x0699, 0x06c0,
       
  2325 	0x06c2, 0x06c3, 0x06c4, 0x06c5, 0x06c6, 0x06c7, 0x06c8, 0x06c9, 0x06ca, 0x06cb, 0x06cd, 0x06cf,
       
  2326 	0x06d2, 0x06d3
       
  2327 	};
       
  2328 
       
  2329 static const TInt KArabicRightJoiningLettersLength = sizeof(KArabicRightJoiningLettersData)/sizeof(TUint16);
       
  2330 
       
  2331 static const TPtrC KArabicRightJoiningLetters(KArabicRightJoiningLettersData, KArabicRightJoiningLettersLength);
       
  2332 
       
  2333 static const TUint16 KArabicNonJoiningLettersData[] = 
       
  2334 	{
       
  2335 	0x0640, 0x0674, 0x06D5
       
  2336 	};
       
  2337 
       
  2338 static const TInt KArabicNonJoiningLettersLength = sizeof(KArabicNonJoiningLettersData)/sizeof(TUint16);
       
  2339 
       
  2340 static const TPtrC KArabicNonJoiningLetters(KArabicNonJoiningLettersData, KArabicNonJoiningLettersLength);
       
  2341 
       
  2342 static const TUint16 KAlefJoiningGroupData[] = 
       
  2343 	{
       
  2344 	0x0622, 0x0623, 0x0625, 0x0671, 0x0672, 0x0673, 0x0675
       
  2345 	};
       
  2346 
       
  2347 static const TInt KAlefJoiningGroupLength = sizeof(KAlefJoiningGroupData)/sizeof(TUint16);
       
  2348 
       
  2349 static const TPtrC KAlefJoiningGroup(KAlefJoiningGroupData, KAlefJoiningGroupLength);
       
  2350 
       
  2351 static const TUint16 KWawJoiningGroupData[] = 
       
  2352 	{
       
  2353 	0x0624, 0x0648, 0x0676, 0x0677, 0x06c4, 0x06c5, 0x06c6, 0x06c7, 0x06c8, 0x06c9, 0x06ca, 0x06cb,
       
  2354 	0x06cf
       
  2355 	};
       
  2356 
       
  2357 static const TInt KWawJoiningGroupLength = sizeof(KWawJoiningGroupData)/sizeof(TUint16);
       
  2358 
       
  2359 static const TPtrC KWawJoiningGroup(KWawJoiningGroupData, KWawJoiningGroupLength);
       
  2360 
       
  2361 
       
  2362 static const TUint16 KYehJoiningGroupData[] = 
       
  2363 	{
       
  2364 	0x0626, 0x0649, 0x064a, 0x0678, 0x06cc, 0x06ce, 0x06d0, 0x06d1
       
  2365 	};
       
  2366 
       
  2367 
       
  2368 static const TInt KYehJoiningGroupLength = sizeof(KYehJoiningGroupData)/sizeof(TUint16);
       
  2369 
       
  2370 static const TPtrC KYehJoiningGroup(KYehJoiningGroupData, KYehJoiningGroupLength);
       
  2371 
       
  2372 static const TUint16 KBehJoiningGroupData[] = 
       
  2373 	{
       
  2374 	0x0628, 0x062a, 0x062b, 0x0679, 0x067a, 0x067b, 0x067c, 0x067d, 0x067e, 0x067f, 0x0680 
       
  2375 	};
       
  2376 
       
  2377 static const TInt KBehJoiningGroupLength = sizeof(KBehJoiningGroupData)/sizeof(TUint16);
       
  2378 
       
  2379 static const TPtrC KBehJoiningGroup(KBehJoiningGroupData, KBehJoiningGroupLength);
       
  2380 
       
  2381 static const TUint16 KTehMarbutaJoiningGroupData[] = 
       
  2382 	{
       
  2383 	0x0629, 0x06c0
       
  2384 	};
       
  2385 
       
  2386 static const TInt KTehMarbutaJoiningGroupLength = sizeof(KTehMarbutaJoiningGroupData)/sizeof(TUint16);
       
  2387 
       
  2388 static const TPtrC KTehMarbutaJoiningGroup(KTehMarbutaJoiningGroupData, KTehMarbutaJoiningGroupLength);
       
  2389 
       
  2390 static const TUint16 KHahJoiningGroupData[] = 
       
  2391 	{
       
  2392 	0x062c, 0x062d, 0x062e, 0x0681, 0x0682, 0x0683, 0x0684, 0x0685, 0x0686, 0x0687
       
  2393 	};
       
  2394 
       
  2395 static const TInt KHahJoiningGroupLength = sizeof(KHahJoiningGroupData)/sizeof(TUint16);
       
  2396 
       
  2397 static const TPtrC KHahJoiningGroup(KHahJoiningGroupData, KHahJoiningGroupLength);
       
  2398 
       
  2399 static const TUint16 KDalJoiningGroupData[] = 
       
  2400 	{
       
  2401 	0x062f, 0x0688, 0x0689, 0x068a, 0x068b, 0x068c, 0x068d, 0x068e, 0x068f, 0x0690
       
  2402 	};
       
  2403 
       
  2404 static const TInt KDalJoiningGroupLength = sizeof(KDalJoiningGroupData)/sizeof(TUint16);
       
  2405 
       
  2406 static const TPtrC KDalJoiningGroup(KDalJoiningGroupData, KDalJoiningGroupLength);
       
  2407 
       
  2408 
       
  2409 static const TUint16 KRehJoiningGroupData[] = 
       
  2410 	{
       
  2411 	0x0631, 0x0632, 0x0691, 0x0692, 0x0693, 0x0694, 0x0695, 0x0696, 0x0697, 0x0698, 0x0699
       
  2412 	};
       
  2413 
       
  2414 static const TInt KRehJoiningGroupLength = sizeof(KRehJoiningGroupData)/sizeof(TUint16);
       
  2415 
       
  2416 static const TPtrC KRehJoiningGroup(KRehJoiningGroupData, KRehJoiningGroupLength);
       
  2417 
       
  2418 static const TUint16 KSeenJoiningGroupData[] = 
       
  2419 	{
       
  2420 	0x0633, 0x0634, 0x069a, 0x069b, 0x069c, 0x06fa
       
  2421 	};
       
  2422 
       
  2423 static const TInt KSeenJoiningGroupLength = sizeof(KSeenJoiningGroupData)/sizeof(TUint16);
       
  2424 
       
  2425 static const TPtrC KSeenJoiningGroup(KSeenJoiningGroupData, KSeenJoiningGroupLength);
       
  2426 
       
  2427 static const TUint16 KSadJoiningGroupData[] = 
       
  2428 	{
       
  2429 	0x0635, 0x0636, 0x069d, 0x069e, 0x06fb
       
  2430 	};
       
  2431 
       
  2432 static const TInt KSadJoiningGroupLength = sizeof(KSadJoiningGroupData)/sizeof(TUint16);
       
  2433 
       
  2434 static const TPtrC KSadJoiningGroup(KSadJoiningGroupData, KSadJoiningGroupLength);
       
  2435 
       
  2436 static const TUint16 KTahJoiningGroupData[] = 
       
  2437 	{
       
  2438 	0x0637, 0x0638, 0x069f
       
  2439 	};
       
  2440 
       
  2441 static const TInt KTahJoiningGroupLength = sizeof(KTahJoiningGroupData)/sizeof(TUint16);
       
  2442 
       
  2443 static const TPtrC KTahJoiningGroup(KTahJoiningGroupData, KTahJoiningGroupLength);
       
  2444 
       
  2445 static const TUint16 KAinJoiningGroupData[] = 
       
  2446 	{
       
  2447 	0x0639, 0x063a, 0x6a0, 0x06fc
       
  2448 	};
       
  2449 
       
  2450 static const TInt KAinJoiningGroupLength = sizeof(KAinJoiningGroupData)/sizeof(TUint16);
       
  2451 
       
  2452 static const TPtrC KAinJoiningGroup(KAinJoiningGroupData, KAinJoiningGroupLength);
       
  2453 
       
  2454 static const TUint16 KFehJoiningGroupData[] = 
       
  2455 	{
       
  2456 	0x0641, 0x06a1, 0x06a2, 0x06a3, 0x06a4, 0x06a5, 0x06a6
       
  2457 	};
       
  2458 
       
  2459 
       
  2460 static const TInt KFehJoiningGroupLength = sizeof(KFehJoiningGroupData)/sizeof(TUint16);
       
  2461 
       
  2462 static const TPtrC KFehJoiningGroup(KFehJoiningGroupData, KFehJoiningGroupLength);
       
  2463 
       
  2464 static const TUint16 KQafJoiningGroupData[] = 
       
  2465 	{
       
  2466 	0x0642, 0x06a7, 0x06a8
       
  2467 	};
       
  2468 
       
  2469 static const TInt KQafJoiningGroupLength = sizeof(KQafJoiningGroupData)/sizeof(TUint16);
       
  2470 
       
  2471 static const TPtrC KQafJoiningGroup(KQafJoiningGroupData, KQafJoiningGroupLength);
       
  2472 
       
  2473 static const TUint16 KKafJoiningGroupData[] = 
       
  2474 	{
       
  2475 	0x0643, 0x06aa, 0x06ac, 0x06ad, 0x06ae
       
  2476 	};
       
  2477 
       
  2478 static const TInt KKafJoiningGroupLength = sizeof(KKafJoiningGroupData)/sizeof(TUint16);
       
  2479 
       
  2480 static const TPtrC KKafJoiningGroup(KKafJoiningGroupData, KKafJoiningGroupLength);
       
  2481 
       
  2482 static const TUint16 KLamJoiningGroupData[] = 
       
  2483 	{
       
  2484 	0x0644, 0x06b5, 0x06b6, 0x06b7, 0x06b8
       
  2485 	};
       
  2486 
       
  2487 static const TInt KLamJoiningGroupLength = sizeof(KLamJoiningGroupData)/sizeof(TUint16);
       
  2488 
       
  2489 static const TPtrC KLamJoiningGroup(KLamJoiningGroupData, KLamJoiningGroupLength);
       
  2490 
       
  2491 static const TUint16 KMeemJoiningGroupData[] = 
       
  2492 	{
       
  2493 	0x0645
       
  2494 	};
       
  2495 
       
  2496 static const TInt KMeemJoiningGroupLength = sizeof(KMeemJoiningGroupData)/sizeof(TUint16);
       
  2497 
       
  2498 static const TPtrC KMeemJoiningGroup(KMeemJoiningGroupData, KMeemJoiningGroupLength);
       
  2499 
       
  2500 static const TUint16 KNoonJoiningGroupData[] = 
       
  2501 	{
       
  2502 	0x0646, 0x06b9, 0x06ba, 0x06bb, 0x06bc, 0x06bd
       
  2503 	};
       
  2504 
       
  2505 static const TInt KNoonJoiningGroupLength = sizeof(KNoonJoiningGroupData)/sizeof(TUint16);
       
  2506 
       
  2507 static const TPtrC KNoonJoiningGroup(KNoonJoiningGroupData, KNoonJoiningGroupLength);
       
  2508 
       
  2509 static const TUint16 KHehJoiningGroupData[] = 
       
  2510 	{
       
  2511 	0x0647
       
  2512 	};
       
  2513 
       
  2514 static const TInt KHehJoiningGroupLength = sizeof(KHehJoiningGroupData)/sizeof(TUint16);
       
  2515 
       
  2516 static const TPtrC KHehJoiningGroup(KHehJoiningGroupData, KHehJoiningGroupLength);
       
  2517 
       
  2518 static const TUint16 KGafJoiningGroupData[] = 
       
  2519 	{
       
  2520 	0x06a9, 0x06ab, 0x06af, 0x06b0, 0x06b1, 0x06b2, 0x06b3, 0x06b4 
       
  2521 	};
       
  2522 
       
  2523 static const TInt KGafJoiningGroupLength = sizeof(KGafJoiningGroupData)/sizeof(TUint16);
       
  2524 
       
  2525 static const TPtrC KGafJoiningGroup(KGafJoiningGroupData, KGafJoiningGroupLength);
       
  2526 
       
  2527 static const TUint16 KKnottedHehJoiningGroupData[] = 
       
  2528 	{
       
  2529 	0x06be
       
  2530 	};
       
  2531 
       
  2532 static const TInt KKnottedHehJoiningGroupLength = sizeof(KKnottedHehJoiningGroupData)/sizeof(TUint16);
       
  2533 
       
  2534 static const TPtrC KKnottedHehJoiningGroup(KKnottedHehJoiningGroupData, KKnottedHehJoiningGroupLength);
       
  2535 
       
  2536 static const TUint16 KHehGoalJoiningGroupData[] = 
       
  2537 	{
       
  2538 	0x06c1
       
  2539 	};
       
  2540 
       
  2541 static const TInt KHehGoalJoiningGroupLength = sizeof(KHehGoalJoiningGroupData)/sizeof(TUint16);
       
  2542 
       
  2543 static const TPtrC KHehGoalJoiningGroup(KHehGoalJoiningGroupData, KHehGoalJoiningGroupLength);
       
  2544 
       
  2545 static const TUint16 KHamzaOnHehGoalJoiningGroupData[] = 
       
  2546 	{
       
  2547 	0x06c2, 0x06c3
       
  2548 	};
       
  2549 
       
  2550 static const TInt KHamzaOnHehGoalJoiningGroupLength = sizeof(KHamzaOnHehGoalJoiningGroupData)/sizeof(TUint16);
       
  2551 
       
  2552 static const TPtrC KHamzaOnHehGoalJoiningGroup(KHamzaOnHehGoalJoiningGroupData, KHamzaOnHehGoalJoiningGroupLength);
       
  2553 
       
  2554 static const TUint16 KYehWithTailJoiningGroupData[] = 
       
  2555 	{
       
  2556 	0x06cd
       
  2557 	};
       
  2558 
       
  2559 static const TInt KYehWithTailJoiningGroupLength = sizeof(KYehWithTailJoiningGroupData)/sizeof(TUint16);
       
  2560 
       
  2561 static const TPtrC KYehWithTailJoiningGroup(KYehWithTailJoiningGroupData, KYehWithTailJoiningGroupLength);
       
  2562 
       
  2563 static const TUint16 KYehBarreeJoiningGroupData[] = 
       
  2564 	{
       
  2565 	0x06d2, 0x06d3
       
  2566 	};
       
  2567 
       
  2568 static const TInt KYehBarreeJoiningGroupLength = sizeof(KYehBarreeJoiningGroupData)/sizeof(TUint16);
       
  2569 
       
  2570 static const TPtrC KYehBarreeJoiningGroup(KYehBarreeJoiningGroupData, KYehBarreeJoiningGroupLength);
       
  2571 
       
  2572 enum JoiningGroupType
       
  2573 	{
       
  2574 	EAlefJoiningGroup,
       
  2575 	EWawJoiningGroup,
       
  2576 	EYehJoiningGroup,
       
  2577 	EBehJoiningGroup,
       
  2578 	ETehMarbutaJoiningGroup,
       
  2579 	EHahJoiningGroup,
       
  2580 	EDalJoiningGroup,
       
  2581 	ERehJoiningGroup,
       
  2582 	ESeenJoiningGroup,
       
  2583 	ESadJoiningGroup,
       
  2584 	ETahJoiningGroup,
       
  2585 	EAinJoiningGroup,
       
  2586 	EFehJoiningGroup,
       
  2587 	EQafJoiningGroup,
       
  2588 	EKafJoiningGroup,
       
  2589 	ELamJoiningGroup,
       
  2590 	EMeemJoiningGroup,
       
  2591 	ENoonJoiningGroup,
       
  2592 	EHehJoiningGroup,
       
  2593 	EGafJoiningGroup,
       
  2594 	EKnottedHehJoiningGroup,
       
  2595 	EHehGoalJoiningGroup,
       
  2596 	EHamzaOnHehGoalJoiningGroup,
       
  2597 	EYehWithTailJoiningGroup,
       
  2598 	EYehBarreeJoiningGroup
       
  2599 	};
       
  2600 
       
  2601 struct JoiningGroupListData 
       
  2602 	{
       
  2603 	TInt iGroupType;
       
  2604 	const TPtrC* iGroup;
       
  2605 	};
       
  2606 
       
  2607 // Structure to hold basic shape glyph values
       
  2608 
       
  2609 struct ArabicLetterShapes
       
  2610 	{
       
  2611 	TUint16 iCode;	//base Unicode value for character
       
  2612 	TUint16 iIsolated;
       
  2613 	TUint16 iFinal;
       
  2614 	TUint16 iInitial;
       
  2615 	TUint16 iMedial;
       
  2616 	};
       
  2617 
       
  2618 static const ArabicLetterShapes KArabicShapeList[] =
       
  2619 	{
       
  2620 	{ 0x0622, 0xfe81, 0xfe82, 0x0622, 0x0622 },
       
  2621 	{ 0x0623, 0xfe83, 0xfe84, 0x0623, 0x0623 },
       
  2622 	{ 0x0624, 0xfe85, 0xfe86, 0x0624, 0x0624 },
       
  2623 	{ 0x0625, 0xfe87, 0xfe88, 0x0625, 0x0625 },
       
  2624 	{ 0x0626, 0xfe89, 0xfe8a, 0xfe8b, 0xfe8c },
       
  2625 	{ 0x0627, 0xfe8d, 0xfe8e, 0x0627, 0x0627 },
       
  2626 	{ 0x0628, 0xfe8f, 0xfe90, 0xfe91, 0xfe92 },
       
  2627 	{ 0x0629, 0xfe93, 0xfe94, 0x0629, 0x0629 },
       
  2628 	{ 0x062a, 0xfe95, 0xfe96, 0xfe97, 0xfe98 },
       
  2629 	{ 0x062b, 0xfe99, 0xfe9a, 0xfe9b, 0xfe9c },
       
  2630 	{ 0x062c, 0xfe9d, 0xfe9e, 0xfe9f, 0xfea0 },
       
  2631 	{ 0x062d, 0xfea1, 0xfea2, 0xfea3, 0xfea4 },
       
  2632 	{ 0x062e, 0xfea5, 0xfea6, 0xfea7, 0xfea8 },
       
  2633 	{ 0x062f, 0xfea9, 0xfeaa, 0x062f, 0x062f },
       
  2634 	{ 0x0630, 0xfeab, 0xfeac, 0x0630, 0x0630 },
       
  2635 	{ 0x0631, 0xfead, 0xfeae, 0x0631, 0x0631 },
       
  2636 	{ 0x0632, 0xfeaf, 0xfeb0, 0x0632, 0x0632 },
       
  2637 	{ 0x0633, 0xfeb1, 0xfeb2, 0xfeb3, 0xfeb4 },
       
  2638 	{ 0x0634, 0xfeb5, 0xfeb6, 0xfeb7, 0xfeb8 },
       
  2639 	{ 0x0635, 0xfeb9, 0xfeba, 0xfebb, 0xfebc },
       
  2640 	{ 0x0636, 0xfebd, 0xfebe, 0xfebf, 0xfec0 },
       
  2641 	{ 0x0637, 0xfec1, 0xfec2, 0xfec3, 0xfec4 },
       
  2642 	{ 0x0638, 0xfec5, 0xfec6, 0xfec7, 0xfec8 },
       
  2643 	{ 0x0639, 0xfec9, 0xfeca, 0xfecb, 0xfecc },
       
  2644 	{ 0x063a, 0xfecd, 0xfece, 0xfecf, 0xfed0 },
       
  2645 	{ 0x0641, 0xfed1, 0xfed2, 0xfed3, 0xfed4 },
       
  2646 	{ 0x0642, 0xfed5, 0xfed6, 0xfed7, 0xfed8 },
       
  2647 	{ 0x0643, 0xfed9, 0xfeda, 0xfedb, 0xfedc },
       
  2648 	{ 0x0644, 0xfedd, 0xfede, 0xfedf, 0xfee0 },
       
  2649 	{ 0x0645, 0xfee1, 0xfee2, 0xfee3, 0xfee4 },
       
  2650 	{ 0x0646, 0xfee5, 0xfee6, 0xfee7, 0xfee8 },
       
  2651 	{ 0x0647, 0xfee9, 0xfeea, 0xfeeb, 0xfeec },
       
  2652 	{ 0x0648, 0xfeed, 0xfeee, 0x0648, 0x0648 },
       
  2653 	{ 0x0649, 0xfeef, 0xfef0, 0xfbe8, 0xfbe9 },
       
  2654 	{ 0x064a, 0xfef1, 0xfef2, 0xfef3, 0xfef4 },
       
  2655 	{ 0x0671, 0xfb50, 0xfb51, 0x0671, 0x0671 },
       
  2656 	{ 0x0677, 0xfbdd, 0x0677, 0x0677, 0x0677 },
       
  2657 	{ 0x0679, 0xfb66, 0xfb67, 0xfb68, 0xfb69 },
       
  2658 	{ 0x067a, 0xfb5e, 0xfb5f, 0xfb60, 0xfb61 },
       
  2659 	{ 0x067b, 0xfb52, 0xfb53, 0xfb54, 0xfb55 },
       
  2660 	{ 0x067e, 0xfb56, 0xfb57, 0xfb58, 0xfb59 },
       
  2661 	{ 0x067f, 0xfb62, 0xfb63, 0xfb64, 0xfb65 },
       
  2662 	{ 0x0680, 0xfb5a, 0xfb5b, 0xfb5c, 0xfb5d },
       
  2663 	{ 0x0683, 0xfb76, 0xfb77, 0xfb78, 0xfb79 },
       
  2664 	{ 0x0684, 0xfb72, 0xfb73, 0xfb74, 0xfb75 },
       
  2665 	{ 0x0686, 0xfb7a, 0xfb7b, 0xfb7c, 0xfb7d },
       
  2666 	{ 0x0687, 0xfb7e, 0xfb7f, 0xfb80, 0xfb81 },
       
  2667 	{ 0x0688, 0xfb88, 0xfb89, 0x0688, 0x0688 },
       
  2668 	{ 0x068c, 0xfb84, 0xfb85, 0x068c, 0x068c },
       
  2669 	{ 0x068d, 0xfb82, 0xfb83, 0x068d, 0x068d },
       
  2670 	{ 0x068e, 0xfb86, 0xfb87, 0x068e, 0x068e },
       
  2671 	{ 0x0691, 0xfb8c, 0xfb8d, 0x0691, 0x0691 },
       
  2672 	{ 0x0698, 0xfb8a, 0xfb8b, 0x0698, 0x0698 },
       
  2673 	{ 0x06a4, 0xfb6a, 0xfb6b, 0xfb6c, 0xfb6d },
       
  2674 	{ 0x06a6, 0xfb6e, 0xfb6f, 0xfb70, 0xfb71 },
       
  2675 	{ 0x06a9, 0xfb8e, 0xfb8f, 0xfb90, 0xfb91 },
       
  2676 	{ 0x06ad, 0xfbd3, 0xfbd4, 0xfbd5, 0xfbd6 },
       
  2677 	{ 0x06af, 0xfb92, 0xfb93, 0xfb94, 0xfb95 },
       
  2678 	{ 0x06b1, 0xfb9a, 0xfb9b, 0xfb9c, 0xfb9d },
       
  2679 	{ 0x06b3, 0xfb96, 0xfb97, 0xfb98, 0xfb99 },
       
  2680 	{ 0x06ba, 0xfb9e, 0xfb9f, 0x06ba, 0x06ba },
       
  2681 	{ 0x06bb, 0xfba0, 0xfba1, 0xfba2, 0xfba3 },
       
  2682 	{ 0x06be, 0xfbaa, 0xfbab, 0xfbac, 0xfbad },
       
  2683 	{ 0x06c0, 0xfba4, 0xfba5, 0x06c0, 0x06c0 },
       
  2684 	{ 0x06c1, 0xfba6, 0xfba7, 0xfba8, 0xfba9 },
       
  2685 	{ 0x06c5, 0xfbe0, 0xfbe1, 0x06c5, 0x06c5 },
       
  2686 	{ 0x06c6, 0xfbd9, 0xfbda, 0x06c6, 0x06c6 },
       
  2687 	{ 0x06c7, 0xfbd7, 0xfbd8, 0x06c7, 0x06c7 },
       
  2688 	{ 0x06c8, 0xfbdb, 0xfbdc, 0x06c8, 0x06c8 },
       
  2689 	{ 0x06c9, 0xfbe2, 0xfbe3, 0x06c9, 0x06c9 },
       
  2690 	{ 0x06cb, 0xfbde, 0xfbdf, 0x06cb, 0x06cb },
       
  2691 	{ 0x06cc, 0xfbfc, 0xfbfd, 0xfbfe, 0xfbff },
       
  2692 	{ 0x06d0, 0xfbe4, 0xfbe5, 0xfbe6, 0xfbe7 },
       
  2693 	{ 0x06d2, 0xfbae, 0xfbaf, 0x06d2, 0x06d2 },
       
  2694 	{ 0x06d3, 0xfbb0, 0xfbb1, 0x06d3, 0x06d3 }
       
  2695 	};
       
  2696 
       
  2697 static const TInt KArabicShapeListLength = sizeof(KArabicShapeList) / sizeof (ArabicLetterShapes);
       
  2698 
       
  2699 LOCAL_C TInt GetArabicShapeDataIndex(const TUint16 aCode )
       
  2700 	{
       
  2701 	for (TInt i = 0 ; i < KArabicShapeListLength ; ++i)
       
  2702 		{
       
  2703 		if (aCode == KArabicShapeList[i].iCode)
       
  2704 			{
       
  2705 			return i;
       
  2706 			}
       
  2707 		}
       
  2708 	return -1;//not found
       
  2709 	}
       
  2710 
       
  2711 #ifdef USE_ISOLATED
       
  2712 LOCAL_C TUint16 GetIsolatedForm(const TUint16 aCode)
       
  2713 	{
       
  2714 	TInt index = GetArabicShapeDataIndex(aCode);
       
  2715 	return (index >= 0) ? KArabicShapeList[index].iIsolated : aCode;
       
  2716 	}
       
  2717 #endif /* USE_ISOLATED */
       
  2718 
       
  2719 LOCAL_C TUint16 GetFinalForm(const TUint16 aCode)
       
  2720 	{
       
  2721 	TInt index = GetArabicShapeDataIndex(aCode);
       
  2722 	return (index >= 0) ? KArabicShapeList[index].iFinal : aCode;
       
  2723 	}
       
  2724 
       
  2725 LOCAL_C TUint16 GetInitialForm(const TUint16 aCode)
       
  2726 	{
       
  2727 	TInt index = GetArabicShapeDataIndex(aCode);
       
  2728 	return (index >= 0) ? KArabicShapeList[index].iInitial : aCode;
       
  2729 	}
       
  2730 
       
  2731 LOCAL_C TUint16 GetMedialForm(const TUint16 aCode)
       
  2732 	{
       
  2733 	TInt index = GetArabicShapeDataIndex(aCode);
       
  2734 	return (index >= 0) ? KArabicShapeList[index].iMedial : aCode;
       
  2735 	}
       
  2736 
       
  2737 // Utility functions to show contents of test data using aTest->INFO_PRINTF1
       
  2738 
       
  2739 _LIT(KAddressMarker, "> ");
       
  2740 _LIT(KSpace, " ");
       
  2741 _LIT(KLength, ", Length of Data = %d 16-bit words\r\n");
       
  2742 _LIT(KSpaces, "                                                                      ");
       
  2743 _LIT(KPeriod, ".");
       
  2744 _LIT(KSingleString, "%s\r\n");
       
  2745 _LIT(KDoubleString, "%s <%s>\r\n");
       
  2746 
       
  2747 
       
  2748 
       
  2749 class MOOMTest
       
  2750 	{
       
  2751 public:
       
  2752 	virtual TInt ConsecutivePassesRequired() const { return 1; }
       
  2753 	virtual void SetUpL() = 0;
       
  2754 	virtual void ManipulateL() = 0;
       
  2755 	virtual void TestLeftCleanlyL(CTGraphicsBase* /*aTest*/) {};
       
  2756 	virtual void TestIfPassedL(CTGraphicsBase* /*aTest*/) {};
       
  2757 	virtual void TearDown() = 0;
       
  2758 	};
       
  2759 
       
  2760 // Test the internals of the algorithm for Unicode compliance.
       
  2761 class TBdLevelTest
       
  2762 	{
       
  2763 public:
       
  2764 	TChar::TBdCategory iCat;
       
  2765 	TInt iLevel;	// or -1 for "no test"
       
  2766 	TChar::TBdCategory iChangedCat;
       
  2767 	};
       
  2768 
       
  2769 class CTBiDi : public CTGraphicsBase
       
  2770 	{
       
  2771 public:
       
  2772 	CTBiDi(CTestStep* aStep);
       
  2773 
       
  2774 	void DoTestTextDrawPanic();
       
  2775 	TInt DoTestPanicSetTextL();
       
  2776 	TInt DoTestPanicMinimumSizeLineGap();
       
  2777 	TInt DoTestPanicMinimumSizeMaxLines();
       
  2778 	TInt DoTestPanicMinimumSizeWidth();
       
  2779 	TInt DoTestPanicMinimumNumberOfLinesL();
       
  2780 	static void FillRunArray(const TBdLevelTest* aTests, TBidirectionalState::TRunInfo* aRuns, TInt aArraySize, TBidirectionalState::TReorderContext& aContext);
       
  2781 	static void SetContext(TBidirectionalState::TReorderContext& aContext, TChar::TBdCategory aCat);
       
  2782 protected:
       
  2783 //from 	CTGraphicsStep
       
  2784 	virtual void RunTestCaseL(TInt aCurTestCase);
       
  2785 private:
       
  2786 	void PrintTestData (const TDesC& aTitle , const TDesC16& aData);
       
  2787 	void PrintTestData(const TDesC& aTitle, const TText16* aDataBuffer, const TInt aSize);
       
  2788 	void TestReorderTextL();
       
  2789 	void TestOOML(MOOMTest& aOOMTest);
       
  2790 	void PrintRunCategories(const TBidirectionalState::TRunInfo* aRunArray, const TInt aRuns, const TText* aText, const TBool aInternal);
       
  2791 	void PrintRunArray(const TBidirectionalState::TRunInfo* aRunArray, const TInt aRuns, const TText*  aText);
       
  2792 	void DoTestRRunInfoArrayInternalsL();
       
  2793 	void DoTestTBidiTextNewL();
       
  2794 	void DoTestTBidiTextSetTextL();
       
  2795 	void DoTestTBidiTextMinimumSizeL();
       
  2796 	void DoTestTBidiTextMinimumSizePanics();
       
  2797 	void TestCrApos69qd7nL();
       
  2798 	void TUnicodeExampleTestL();
       
  2799 	void NoLineBreakDrawTestL();
       
  2800 	void RightToLeftArabicDrawTestL();
       
  2801 	void TRunInfoCompactReorderTest();
       
  2802 	void TBidiLogicalToVisualGetVisualLineTest();
       
  2803 	void TestScriptDirectionality();
       
  2804 	void LeftToRightDrawTestL();
       
  2805 	TBool GlyphTestL(const TDesC16& aTitle, const TDesC16& aOriginal, const TDesC16& aDesired, const TInt aWrapWidth);
       
  2806 	void LigatureTestsL();
       
  2807 	void ArabicIllegalLinebreakTestsL();
       
  2808 	TInt TestPanic(TThreadFunction aFunction);
       
  2809 	void DEF043323L();
       
  2810 	void DEF052191L();
       
  2811 	void TestBidiTextClassL();
       
  2812 	void TestBidiLogicalToVisualClassL();
       
  2813 	void TestCatToNumber(TInt aIn, TInt aOut);
       
  2814 	void CheckRunResults(const TBdLevelTest* aTests, TBidirectionalState::TRunInfo* aRuns,
       
  2815 		TInt aArraySize);
       
  2816 	void TestTBidirectionalStateInternalsL();
       
  2817 	void DoXTests(TBidirectionalState& aState,
       
  2818 		TBidirectionalState::TReorderContext& aContext,
       
  2819 		TBidirectionalState::TRunInfo* aRuns);
       
  2820 	void DoKW123TestsLeft(TBidirectionalState& aState,
       
  2821 		TBidirectionalState::TReorderContext& aContext,
       
  2822 		TBidirectionalState::TRunInfo* aRuns) ;
       
  2823 	void DoKW123TestsRight(TBidirectionalState& aState,
       
  2824 		TBidirectionalState::TReorderContext& aContext,
       
  2825 		TBidirectionalState::TRunInfo* aRuns);
       
  2826 	void DoKW456Tests(TBidirectionalState& aState,
       
  2827 		TBidirectionalState::TReorderContext& aContext,
       
  2828 		TBidirectionalState::TRunInfo* aRuns);
       
  2829 	void DoKW7TestsLeft(TBidirectionalState& aState,
       
  2830 		TBidirectionalState::TReorderContext& aContext,
       
  2831 		TBidirectionalState::TRunInfo* aRuns);
       
  2832 	void DoKW7TestsRight(TBidirectionalState& aState,
       
  2833 		TBidirectionalState::TReorderContext& aContext,
       
  2834 		TBidirectionalState::TRunInfo* aRuns) ;
       
  2835 	void DoKN12TestsLeft(TBidirectionalState& aState,
       
  2836 		TBidirectionalState::TReorderContext& aContext,
       
  2837 		TBidirectionalState::TRunInfo* aRuns) ;
       
  2838 	void DoKN12TestsRight(TBidirectionalState& aState,
       
  2839 		TBidirectionalState::TReorderContext& aContext,
       
  2840 		TBidirectionalState::TRunInfo* aRuns) ;
       
  2841 	void DoKN12TestsRRL(TBidirectionalState& aState,
       
  2842 		TBidirectionalState::TReorderContext& aContext,
       
  2843 		TBidirectionalState::TRunInfo* aRuns) ;
       
  2844 	void DoKN12TestsLRR(TBidirectionalState& aState,
       
  2845 		TBidirectionalState::TReorderContext& aContext,
       
  2846 		TBidirectionalState::TRunInfo* aRuns) ;
       
  2847 	void DoKN12TestsLRP(TBidirectionalState& aState,
       
  2848 		TBidirectionalState::TReorderContext& aContext,
       
  2849 		TBidirectionalState::TRunInfo* aRuns) ;
       
  2850 	void DoKN12TestsRLP(TBidirectionalState& aState,
       
  2851 		TBidirectionalState::TReorderContext& aContext,
       
  2852 		TBidirectionalState::TRunInfo* aRuns) ;
       
  2853 	void DoCarryOverTest1(TBidirectionalState& aState,
       
  2854 		TBidirectionalState::TReorderContext& aContext,
       
  2855 		TBidirectionalState::TRunInfo* aRuns);
       
  2856 	void INC086135TestL();
       
  2857 	
       
  2858 	TInt iTestThreadCounter;
       
  2859 	};
       
  2860 
       
  2861 void CTBiDi::PrintTestData (const TDesC& aTitle , const TDesC16& aData)
       
  2862 	{
       
  2863 	TInt i;
       
  2864 	TInt j;
       
  2865 	TInt end;
       
  2866 
       
  2867 	TInt length = aData.Length();
       
  2868 
       
  2869 	TBuf<80> buffer;
       
  2870 
       
  2871 	buffer.Zero();
       
  2872 	buffer.Append(aTitle);
       
  2873 	buffer.Append(KLength);
       
  2874 
       
  2875 	INFO_PRINTF2(buffer, length);
       
  2876 
       
  2877 	for (i = 0 ; i < length ; i += 8)
       
  2878 		{
       
  2879 		buffer.Zero();
       
  2880 		buffer.AppendNumFixedWidth(i, EHex, 8);
       
  2881 		buffer += KAddressMarker;
       
  2882 
       
  2883 		end = ((length-i) >= 8) ? i+8 : length;
       
  2884 
       
  2885 		for (j = i ; j < end ; ++j)
       
  2886 			{
       
  2887 			buffer.AppendNumFixedWidth(aData[j], EHex, 4);
       
  2888 			buffer += KSpace;
       
  2889 			}
       
  2890 		buffer += TPtrC(KSpaces().Ptr(), ((8-(j-i))*5)+4);
       
  2891 
       
  2892 		for (j = i ; j < end ; ++j)
       
  2893 			{
       
  2894 			if (aData[j] >= 32) 
       
  2895 				{
       
  2896 				buffer.Append(aData[j]);
       
  2897 				}
       
  2898 			else
       
  2899 				{
       
  2900 				buffer += KPeriod;
       
  2901 				}
       
  2902 			}
       
  2903 		buffer.ZeroTerminate();
       
  2904 		INFO_PRINTF2(KSingleString, buffer.Ptr());
       
  2905 		}
       
  2906 			
       
  2907 	}
       
  2908 
       
  2909 void CTBiDi::PrintTestData(const TDesC& aTitle, const TText16* aDataBuffer, const TInt aSize)
       
  2910 	{
       
  2911 	PrintTestData(aTitle, TPtrC16(aDataBuffer, aSize));
       
  2912 	}
       
  2913 
       
  2914 _LIT(KArabicFontName, ""); //any name will do
       
  2915 
       
  2916 //This replicates the definition in TBidirectionalState
       
  2917 //because TCategory is declared as private there 
       
  2918 enum TCategory
       
  2919 	{
       
  2920 	ELeftToRight = 1 << TChar::ELeftToRight, 
       
  2921 	ELeftToRightEmbedding = 1 << TChar::ELeftToRightEmbedding,
       
  2922 	ELeftToRightOverride = 1 << TChar::ELeftToRightOverride,
       
  2923 	ERightToLeft = 1 << TChar::ERightToLeft,
       
  2924 	ERightToLeftArabic = 1 << TChar::ERightToLeftArabic,
       
  2925 	ERightToLeftEmbedding = 1 << TChar::ERightToLeftEmbedding, 
       
  2926 	ERightToLeftOverride = 1 << TChar::ERightToLeftOverride,
       
  2927 	EPopDirectionalFormat = 1 << TChar::EPopDirectionalFormat, 
       
  2928 	EEuropeanNumber = 1 << TChar::EEuropeanNumber, 
       
  2929 	EEuropeanNumberSeparator = 1 << TChar::EEuropeanNumberSeparator, 
       
  2930 	EEuropeanNumberTerminator = 1 << TChar::EEuropeanNumberTerminator, 
       
  2931 	EArabicNumber = 1 << TChar::EArabicNumber,
       
  2932 	ECommonNumberSeparator = 1 << TChar::ECommonNumberSeparator, 
       
  2933 	ENonSpacingMark = 1 << TChar::ENonSpacingMark, 
       
  2934 	EBoundaryNeutral = 1 << TChar::EBoundaryNeutral, 
       
  2935 	EParagraphSeparator = 1 << TChar::EParagraphSeparator, 
       
  2936 	ESegmentSeparator = 1 << TChar::ESegmentSeparator, 
       
  2937 	EWhitespace = 1 << TChar::EWhitespace, 
       
  2938 	EOtherNeutral = 1 << TChar::EOtherNeutral,
       
  2939 
       
  2940 	// categories used internally by the bidirectional algorithm
       
  2941 	EStartOfParagraph = 1 << (TChar::EOtherNeutral + 1),
       
  2942 	EEndOfParagraph = 1 << (TChar::EOtherNeutral + 2),
       
  2943 
       
  2944 	// useful groups
       
  2945 	EBdControlsGroup = ELeftToRightEmbedding | ERightToLeftEmbedding |
       
  2946 					   ELeftToRightOverride | ERightToLeftOverride | EPopDirectionalFormat,
       
  2947 	ELeftToRightGroup = ELeftToRight | EEuropeanNumber | ELeftToRightOverride | ELeftToRightEmbedding,
       
  2948 	ERightToLeftGroup = ERightToLeft | EArabicNumber | ERightToLeftArabic | ERightToLeftOverride |
       
  2949 						ERightToLeftEmbedding,
       
  2950 	};
       
  2951 
       
  2952 // Helper function
       
  2953 void AppendCharacter(HBufC *aDes, TUint aChar)
       
  2954 	{
       
  2955 	if (IsSupplementary(aChar))
       
  2956 		{
       
  2957 		TText16 high = GetHighSurrogate(aChar);
       
  2958 		TText16 low = GetLowSurrogate(aChar);
       
  2959 		aDes->Des().Append(high);
       
  2960 		aDes->Des().Append(low);
       
  2961 		}
       
  2962 	else
       
  2963 		{
       
  2964 		aDes->Des().Append(aChar);
       
  2965 		}
       
  2966 	}
       
  2967 
       
  2968 void AppendCharacter(TBuf<24> *aDes, TUint aChar)
       
  2969 	{
       
  2970 	if (IsSupplementary(aChar))
       
  2971 		{
       
  2972 		TText16 high = GetHighSurrogate(aChar);
       
  2973 		TText16 low = GetLowSurrogate(aChar);
       
  2974 		aDes->Append(high);
       
  2975 		aDes->Append(low);
       
  2976 		}
       
  2977 	else
       
  2978 		{
       
  2979 		aDes->Append(aChar);
       
  2980 		}
       
  2981 	}
       
  2982 
       
  2983 //Class to store the start and end of a run of characters
       
  2984 class TTestDataRun
       
  2985 	{
       
  2986 public:
       
  2987 	TInt iStart;
       
  2988 	TInt iLength;
       
  2989 	};
       
  2990 
       
  2991 
       
  2992 class TestTBidirectionalState
       
  2993 	{
       
  2994 public:
       
  2995 	enum 
       
  2996 		{
       
  2997 		EParaLToR = EFalse,
       
  2998 		EParaRToL = ETrue
       
  2999 		};
       
  3000 
       
  3001 /**
       
  3002  *
       
  3003  * Checks that two blocks of 16-bit text contain the same characters in the same order
       
  3004  * NOT a collating function!.
       
  3005  *
       
  3006  *
       
  3007  * @param     "const TText* aOldText"
       
  3008  *            Pointer to block of text
       
  3009  * @param     "const TText* aNewText"
       
  3010  *            Pointer to block of text. 
       
  3011  *			  This may point to the same buffer as oldText.
       
  3012  * @param     "const TUint aSize"
       
  3013  *            Unsigned integer representing size of text blocks.
       
  3014  *
       
  3015  * @return    ETrue: test succeeded EFalse: test failed.
       
  3016  *
       
  3017  */
       
  3018 	static TBool TextInSameOrder (const TText* aOldText , const TText* aNewText, const TUint aSize)
       
  3019 		{
       
  3020 
       
  3021 		__ASSERT_ALWAYS(aOldText, User::Invariant());
       
  3022 		__ASSERT_ALWAYS(aNewText, User::Invariant());
       
  3023 		__ASSERT_ALWAYS(0 < aSize, User::Invariant());
       
  3024 
       
  3025 		if (aOldText == aNewText)
       
  3026 			{
       
  3027 			//By definition, if both point to the same buffer, it's identical!
       
  3028 			return ETrue;
       
  3029 			}
       
  3030 
       
  3031 		for (TUint i = 0 ; i < aSize ; ++i)
       
  3032 			{
       
  3033 			if (aOldText[i] != aNewText[i])
       
  3034 				{
       
  3035 				return EFalse;
       
  3036 				}
       
  3037 			}
       
  3038 
       
  3039 		return ETrue;
       
  3040 		}
       
  3041 
       
  3042 /**
       
  3043  *
       
  3044  * Checks that two blocks of 16-bit text contain the same characters but in reverse order
       
  3045  * NOT a collating function.
       
  3046  *
       
  3047  *
       
  3048  * @param     "const TText* aOldText"
       
  3049  *            Pointer to block of text
       
  3050  * @param     "const TText* aNewText"
       
  3051  *            Pointer to block of text. 
       
  3052  *			  This may point to the same buffer as oldText.
       
  3053  * @param     "const TUint aSize"
       
  3054  *            The size of the text blocks.
       
  3055  *
       
  3056  * @return    ETrue: test succeeded EFalse: test failed.
       
  3057  *
       
  3058  */
       
  3059 	static TBool TextInReverseOrder (const TText* aOldText , const TText* aNewText, const TUint aSize, CTGraphicsBase* aTest=NULL)
       
  3060 		{
       
  3061 		__ASSERT_ALWAYS(aOldText, User::Invariant());
       
  3062 		__ASSERT_ALWAYS(aNewText, User::Invariant());
       
  3063 		__ASSERT_ALWAYS(0 < aSize, User::Invariant());
       
  3064 
       
  3065 		TUint i = 0;			// index into aOldText
       
  3066 		TUint j = aSize - 1;	// index into aNewText
       
  3067 		while (i < aSize)
       
  3068 			{
       
  3069 			if (IsHighSurrogate(aOldText[i]))
       
  3070 				{
       
  3071 				if (aOldText[i] != aNewText[j-1] || aOldText[i+1] != aNewText[j])
       
  3072 					{
       
  3073 					if (aTest)
       
  3074 						{
       
  3075 						_LIT(KMismatchFormat, "TextInReverseOrder report mismatch: aOldText[%d]=%04X != aNewText[%d]=%04X || aOldText[%d]=%04X != aNewText[%d]=%04X\r\n");
       
  3076 						aTest->Logger().LogExtra(((TText8*)__FILE__), __LINE__, ESevrWarn, KMismatchFormat,
       
  3077 								i, aOldText[i], j-1, aNewText[j-1], i+1, aOldText[i+1], j, aNewText[j]); 
       
  3078 						}
       
  3079 					return EFalse;
       
  3080 					}
       
  3081 				i += 2;
       
  3082 				j -= 2;
       
  3083 				}
       
  3084 			else
       
  3085 				{
       
  3086 				if (aOldText[i] != aNewText[j])
       
  3087 					{
       
  3088 					if (aTest)
       
  3089 						{
       
  3090 						_LIT(KMismatchFormat, "TextInReverseOrder report mismatch: aOldText[%d]=%04X != aNewText[%d]=%04X\r\n");
       
  3091 						aTest->INFO_PRINTF5(KMismatchFormat, i, aOldText[i], j, aNewText[j]);
       
  3092 						}
       
  3093 					return EFalse;
       
  3094 					}
       
  3095 				i++;
       
  3096 				j--;
       
  3097 				}
       
  3098 			}
       
  3099 
       
  3100 		return ETrue;
       
  3101 		}
       
  3102 
       
  3103 /**
       
  3104  *
       
  3105  * Checks that two blocks of 16-bit text contain the same characters but in
       
  3106  * reverse order, skipping any zero-width joiners in aNewText.
       
  3107  *
       
  3108  * @param     "const TText* aOldText"
       
  3109  *            Pointer to block of text
       
  3110  * @param     "const TText* aNewText"
       
  3111  *            Pointer to block of text. 
       
  3112  *			  This may point to the same buffer as oldText.
       
  3113  * @param     "const TUint aSize"
       
  3114  *            The size of aOldText.
       
  3115  *
       
  3116  * @return
       
  3117  *		0 if the text did not match, or a pointer one past the end of aNewText's
       
  3118  *		match if it did.
       
  3119  *
       
  3120  */
       
  3121 	static const TText* TextInReverseOrderIgnoringJoiners(
       
  3122 		const TText* aOldText , const TText* aNewText, const TUint aSize)
       
  3123 		{
       
  3124 		__ASSERT_ALWAYS(aOldText, User::Invariant());
       
  3125 		__ASSERT_ALWAYS(aNewText, User::Invariant());
       
  3126 		__ASSERT_ALWAYS(0 < aSize, User::Invariant());
       
  3127 
       
  3128 		const TText* newText = aNewText;
       
  3129 		for (const TText* old = aOldText + aSize - 1;
       
  3130 			aOldText <= old;
       
  3131 			--old, ++newText)
       
  3132 			{
       
  3133 			while (*newText == KUnicodeZeroWidthJoiner)
       
  3134 				++newText;
       
  3135 			if (*newText != *old)
       
  3136 				return 0;
       
  3137 			}
       
  3138 
       
  3139 		while (*newText == KUnicodeZeroWidthJoiner)
       
  3140 			++newText;
       
  3141 		return newText;
       
  3142 		}
       
  3143 
       
  3144 /**
       
  3145  *
       
  3146  * Compares two pointers. 
       
  3147  * If the second pointer does not point to the same place as the first, the
       
  3148  * block of memory it points to is deleted as an array.
       
  3149  *
       
  3150  *
       
  3151  * @param     "const TText* aOldText"
       
  3152  *            Pointer to block of text
       
  3153  * @param     "TText*& aNewText"
       
  3154  *            Pointer to block of text. 
       
  3155  *			  This may point to the same buffer as aOldText.
       
  3156  * @param     "CTGraphicsBase* aTest"
       
  3157  *            Pointer to the test object 
       
  3158  */	
       
  3159 	
       
  3160     static void DeleteText( const TText* aOldText, TText*& aNewText, CTGraphicsBase* aTest)
       
  3161 		{
       
  3162 			if (aNewText != aOldText)
       
  3163 				{
       
  3164 				TInt diff;
       
  3165 				if (aNewText > aOldText)
       
  3166 					{
       
  3167 					diff = aNewText-aOldText;
       
  3168 					}
       
  3169 				else
       
  3170 					{
       
  3171 					diff = aOldText-aNewText;
       
  3172 					}
       
  3173 				if (diff < KBufferSize)
       
  3174 					{
       
  3175 					aTest->INFO_PRINTF2(_L("Bad free detected - diff %d\r\n"), diff);
       
  3176 					aTest->TEST(EFalse);
       
  3177 					}
       
  3178 
       
  3179 				delete[] aNewText;
       
  3180 				aNewText = 0;
       
  3181 				}
       
  3182 		}
       
  3183 /**
       
  3184  *
       
  3185  * Test Internalization and Externalization of TBidirectionalState class. 
       
  3186  *
       
  3187  *
       
  3188  * @param     "TBidirectionalState& aState"
       
  3189  *            Reference to a TBidirectionalState object. 
       
  3190  *            The state object is assumed not to be newly created, i.e. it has
       
  3191  *            non-default internal state.
       
  3192  *            
       
  3193  * @param     "TBidirectionalState& aState2"
       
  3194  *            Reference to a TBidirectionalState object. 
       
  3195  *            The state object is assumed not to be newly created, i.e. it has
       
  3196  *            non-default internal state. This state is also assumed to be
       
  3197  *            different to that of aState
       
  3198  *
       
  3199  * @param     "CTGraphicsBase* aTest"
       
  3200  *            Pointer to the test object 
       
  3201  */	
       
  3202 	static void TestInternalizeL(TBidirectionalState& aState, TBidirectionalState& aState2, CTGraphicsBase* aTest)
       
  3203 		{
       
  3204 		//Now test internalization and externalization functions
       
  3205 
       
  3206 		//Create memory-based streams to externalize into
       
  3207 		
       
  3208 		CBufStore* rStore = CBufStore::NewLC(KBufferSize);
       
  3209 		CBufStore* lStore = CBufStore::NewLC(KBufferSize);
       
  3210 
       
  3211 		RStoreWriteStream lWStream;
       
  3212 		RStoreWriteStream rWStream;
       
  3213 
       
  3214 		TStreamId lStreamID = lWStream.CreateLC(*lStore);
       
  3215 		TStreamId rStreamID = rWStream.CreateLC(*rStore);
       
  3216 
       
  3217 		//Now externalize the states.
       
  3218 
       
  3219 		aState.ExternalizeL(lWStream);
       
  3220 		aState2.ExternalizeL(rWStream);
       
  3221 
       
  3222 		lWStream.Close();
       
  3223 		rWStream.Close();
       
  3224 
       
  3225 		//Now read the externalised streams into two new state objects
       
  3226 
       
  3227 		TBidirectionalState newLState;
       
  3228 		TBidirectionalState newRState;
       
  3229 
       
  3230 		RStoreReadStream rRStream;
       
  3231 		RStoreReadStream lRStream;
       
  3232 
       
  3233 		lRStream.OpenLC(*lStore, lStreamID);
       
  3234 		rRStream.OpenLC(*rStore, rStreamID);
       
  3235 
       
  3236 		newLState.InternalizeL(lRStream);
       
  3237 		newRState.InternalizeL(rRStream);
       
  3238 
       
  3239 		//Now establish that the internalization has changed the state
       
  3240 
       
  3241 		aTest->TEST(!newLState.IsDefault());
       
  3242 		aTest->TEST(!newRState.IsDefault());
       
  3243 
       
  3244 		//Make sure that two distinct sets of data exist
       
  3245 
       
  3246 		aTest->TEST(!(newLState == newRState));
       
  3247 
       
  3248 		//check that the new state objects are equivalent to the old ones
       
  3249 
       
  3250 		aTest->TEST(newLState == aState);
       
  3251 		aTest->TEST(newRState == aState2);
       
  3252 
       
  3253 		//Now check that the externalization / internalization has
       
  3254 		//produced true copies, i.e. that there are no shared buffers
       
  3255 		//anywhere
       
  3256 
       
  3257 		aState.Reset();
       
  3258 		aTest->TEST (aState.IsDefault());
       
  3259 		aTest->TEST (!(aState2 == aState));
       
  3260 		aTest->TEST (!(aState == aState2));
       
  3261 		aTest->TEST (!(aState == newLState));
       
  3262 		aTest->TEST(!newLState.IsDefault());
       
  3263 		aTest->TEST(!newRState.IsDefault()); 
       
  3264 
       
  3265 		aState2.Reset();
       
  3266 		aTest->TEST (aState2.IsDefault());
       
  3267 		aTest->TEST (aState == aState2);
       
  3268 		aTest->TEST (aState2 == aState);
       
  3269 		aTest->TEST (!(aState2 == newRState));
       
  3270 		aTest->TEST(!newLState.IsDefault());
       
  3271 		aTest->TEST(!newRState.IsDefault()); 
       
  3272 
       
  3273 		//End of tests - deal with cleanup stack
       
  3274 
       
  3275 		CleanupStack::PopAndDestroy(6);
       
  3276 		}
       
  3277 
       
  3278 /**
       
  3279  *
       
  3280  * Test API of TBidirectionalState class. 
       
  3281  *
       
  3282  *  with the exception of BidirectionalState::ReorderText
       
  3283  *
       
  3284  * @param     "CTGraphicsBase* aTest"
       
  3285  *            Pointer to the test object
       
  3286  *
       
  3287  */
       
  3288 	static void TestAPIL(CTGraphicsBase* aTest)
       
  3289 		{
       
  3290 		 TInt run;
       
  3291 		 TInt i;
       
  3292 
       
  3293 		//General tests for the DLL API to TBidirectionalState
       
  3294 
       
  3295 		aTest->INFO_PRINTF1(_L("TBidirectionalState general exported API test\r\n"));
       
  3296 
       
  3297 #ifdef PRINT_RUNS
       
  3298 		_LIT(KRunTitle, "Populating aOldText buffer with embedded runs of characters as follows:\r\n");
       
  3299 		_LIT(KRunFormat, "Run %d begins with %04x\r\n");
       
  3300 		_LIT(KEndRunFormat, "End of Run %d begins with %04x\r\n");
       
  3301 		
       
  3302 #endif // PRINT_RUNS 
       
  3303 	
       
  3304 		const TInt KRuns = 64;
       
  3305 		const TInt KRunSize = ((KBufferSize/KRuns)/2 );
       
  3306 		
       
  3307 		//Create buffer to hold test data
       
  3308 
       
  3309 		HBufC* oldTextBufPtr = HBufC::NewLC(KBufferSize);
       
  3310 
       
  3311 		for (i = 0 ; i < KBufferSize ; ++i)
       
  3312 			{
       
  3313 			oldTextBufPtr->Des().Append(0);
       
  3314 			}
       
  3315 
       
  3316 		TPtr oldText(oldTextBufPtr->Des());
       
  3317 		
       
  3318 
       
  3319 		TBidirectionalState::TRunInfo* lRunInfoArray = new(ELeave) TBidirectionalState::TRunInfo[KRuns];
       
  3320 		CleanupArrayDeletePushL(lRunInfoArray);
       
  3321 		TBidirectionalState::TRunInfo* rRunInfoArray = new(ELeave) TBidirectionalState::TRunInfo[KRuns];
       
  3322 		CleanupArrayDeletePushL(rRunInfoArray);
       
  3323 
       
  3324 
       
  3325 		//Build up a lot of levels of L-R and R-L text
       
  3326 
       
  3327 		 TextIterator ltorIterator(KLeftToRight, KLeftToRightLength);
       
  3328 		 TextIterator rtolIterator(KRightToLeft, KRightToLeftLength);
       
  3329 
       
  3330 		 //Loop through all available test data
       
  3331 		 //There are more Left-To-Right characters than Right-To-Left, so
       
  3332 		 //use ltorIterator as the guide
       
  3333 
       
  3334 		 while (!ltorIterator.Wrapped())
       
  3335 			{
       
  3336 			//Build up runs
       
  3337 			 TInt index = 0;
       
  3338 	#ifdef PRINT_RUNS
       
  3339 			 aTest->INFO_PRINTF1(KRunTitle);
       
  3340 	#endif // PRINT_RUNS
       
  3341 			 for (run = 0 ; run < KRuns ; run++) 
       
  3342 				{
       
  3343 				TUint first; 
       
  3344 				lRunInfoArray[run].iStart = rRunInfoArray[run].iStart = index;
       
  3345 				lRunInfoArray[run].iIndex = rRunInfoArray[run].iIndex = 0;
       
  3346 				lRunInfoArray[run].iEmbeddingLevel = rRunInfoArray[run].iEmbeddingLevel = 0;
       
  3347 
       
  3348 				if ((run & 1) == 0)
       
  3349 					{
       
  3350 					//Odd values of Run use R-L, even use L-R
       
  3351 
       
  3352 					first = ltorIterator.NextChar();
       
  3353 	#ifdef PRINT_RUNS
       
  3354 					aTest->INFO_PRINTF3(KRunFormat, run, first);
       
  3355 	#endif // PRINT_RUNS
       
  3356 					ltorIterator.NextCharInto(oldText, index, -1, ETrue, EFalse);
       
  3357 					for (i = 1; i < KRunSize ; ++i)
       
  3358 						{
       
  3359 						if (!ltorIterator.NextCharInto(oldText, index))
       
  3360 							break;
       
  3361 						}
       
  3362 					lRunInfoArray[run].iDirection = rRunInfoArray[run].iDirection = 0;
       
  3363 	#ifdef PRINT_RUNS
       
  3364 					aTest->INFO_PRINTF4(KRunFormat, run, (first & 0xffff), 0);
       
  3365 	#endif // PRINT_RUN
       
  3366 						
       
  3367 					}
       
  3368 				else
       
  3369 					{
       
  3370 					first = rtolIterator.NextChar();
       
  3371 					oldText[index++] = first;
       
  3372 					for (i = 1; i < KRunSize ; ++i)
       
  3373 						{
       
  3374 						oldText[index++] = rtolIterator.NextChar();
       
  3375 						}
       
  3376 					lRunInfoArray[run].iDirection = rRunInfoArray[run].iDirection = 1;
       
  3377 					}
       
  3378 	#ifdef PRINT_RUNS
       
  3379 					aTest->INFO_PRINTF4(KRunFormat, run, (first & 0xffff) , 1);
       
  3380 	#endif // PRINT_RUNS
       
  3381 				lRunInfoArray[run].iCategory = rRunInfoArray[run].iCategory = TChar(first).GetBdCategory();
       
  3382 				lRunInfoArray[run].iLength = rRunInfoArray[run].iLength = KRunSize;
       
  3383 				}
       
  3384 					
       
  3385 #ifdef PRINT_ARRAYS
       
  3386 			 _LIT(KArrayData, "Data\r\n");
       
  3387 			 PrintTestData(KArrayData, oldText.Ptr(), KBufferSize);
       
  3388 #endif // PRINT_ARRAYS
       
  3389 
       
  3390 			TBidirectionalState lState;
       
  3391 			TBidirectionalState rState;
       
  3392 
       
  3393 			//Check that newly created state objects match IsDefault
       
  3394 			aTest->TEST (lState.IsDefault());
       
  3395 			aTest->TEST (rState.IsDefault());
       
  3396 
       
  3397 			//Check that default state objects work with operator==
       
  3398 			aTest->TEST (lState == rState);
       
  3399 			aTest->TEST (rState == lState);
       
  3400 
       
  3401 			//Call ReorderLine to both populate lRunInfoArray and change 
       
  3402 			//the internal state of lState
       
  3403 			lState.ReorderLine(lRunInfoArray, KRuns, ETrue, ETrue, EParaLToR,
       
  3404 				TChar::EOtherNeutral, TChar::EOtherNeutral);
       
  3405 
       
  3406 			//Check that the state object is no longer in default state
       
  3407 			aTest->TEST (!lState.IsDefault());
       
  3408 
       
  3409 			//Check that operator== can detect that
       
  3410 			aTest->TEST (!(lState == rState));
       
  3411 
       
  3412 			//Call ReorderLine to both populate rRunInfoArray and change 
       
  3413 			//the internal state of RState
       
  3414 			rState.ReorderLine(rRunInfoArray, KRuns, ETrue, ETrue, EParaRToL,
       
  3415 				TChar::EOtherNeutral, TChar::EOtherNeutral);
       
  3416 
       
  3417 			//now rState should not be in default state
       
  3418 			aTest->TEST(!rState.IsDefault());
       
  3419 
       
  3420 			//Test that lSTate and rState are not the same.
       
  3421 			//Make sure that lState.operator== and rState.operator== give
       
  3422 			//the same answer.
       
  3423 
       
  3424 			aTest->TEST (!(lState == rState));
       
  3425 			aTest->TEST (!(rState == lState));
       
  3426 
       
  3427 
       
  3428 #ifdef PRINT_RUNS
       
  3429 			//Print the contents of kRunInfo in epocwind.out
       
  3430 			_LIT(KRunInfo1, "run             Category                 Embedding Level Direction       Index           Start           Length\r\n");
       
  3431 			_LIT(KRunInfo2, "       %d               %d                      %d             %d               %d              %d              %d\r\n");
       
  3432 
       
  3433 			//Temp - print contents of arrays
       
  3434 			aTest->INFO_PRINTF1(_L("Left-To-Right Paragraph\r\n"));
       
  3435 			aTest->INFO_PRINTF1(KRunInfo1);	
       
  3436 			for (run = 0 ; run < KRuns ; ++run)
       
  3437 				{
       
  3438 				aTest->Logger().LogExtra(((TText8*)__FILE__), __LINE__, ESevrInfo,
       
  3439 					KRunInfo2, run, lRunInfoArray[run].iCategory, 
       
  3440 					lRunInfoArray[run].iEmbeddingLevel, lRunInfoArray[run].iDirection, 
       
  3441 					lRunInfoArray[run].iIndex, lRunInfoArray[run].iStart, lRunInfoArray[run].iLength);	
       
  3442 				}
       
  3443 			aTest->INFO_PRINTF1(_L("Right-to-Left Paragraph\r\n"));
       
  3444 			aTest->INFO_PRINTF1(KRunInfo1);	
       
  3445 			for (run = 0 ; run < KRuns ; ++run)
       
  3446 				{
       
  3447 				aTest->Logger().LogExtra(((TText8*)__FILE__), __LINE__, ESevrInfo,
       
  3448 					KRunInfo2, run, rRunInfoArray[run].iCategory, 
       
  3449 					rRunInfoArray[run].iEmbeddingLevel, rRunInfoArray[run].iDirection, 
       
  3450 					rRunInfoArray[run].iIndex, rRunInfoArray[run].iStart, rRunInfoArray[run].iLength);	
       
  3451 				}
       
  3452 
       
  3453 #endif // PRINT_RUNS
       
  3454 
       
  3455 			//With the test data presented, there should be 64 runs in ascending order
       
  3456 			//when processed in a left-to-right context and in descending order when processed
       
  3457 			//as right-to-left, corresponding to each run being printed in entry order in
       
  3458 			//the former case and in reverse order in the latter case.
       
  3459 
       
  3460 			for (run = 0 ; run < KRuns ; ++run)
       
  3461 				{
       
  3462 				aTest->TEST(lRunInfoArray[run].iIndex == run);
       
  3463 				aTest->TEST(rRunInfoArray[KRuns - run - 1].iIndex == run);
       
  3464 				}
       
  3465 
       
  3466 		
       
  3467 			TestInternalizeL(lState,rState, aTest);			
       
  3468 			}
       
  3469 
       
  3470 
       
  3471 		CleanupStack::PopAndDestroy(rRunInfoArray);
       
  3472 		CleanupStack::PopAndDestroy(lRunInfoArray);
       
  3473 		CleanupStack::PopAndDestroy();
       
  3474 		}
       
  3475 
       
  3476 /**
       
  3477  *
       
  3478  * Tests that the Bidirectional Algorithm leaves left to right text alone.
       
  3479  *
       
  3480  *
       
  3481  * @param	  "TDes& aOldText"
       
  3482  *			  Descriptor that points to a buffer at least KBufferSize 16-bit characters long
       
  3483  *
       
  3484  * @param     "CTGraphicsBase* aTest"
       
  3485  *            Pointer to the test object 
       
  3486  *
       
  3487  */
       
  3488 	static void LeftToRightReorderTest(TDes& aOldText, CTGraphicsBase* aTest)
       
  3489 		{//LeftToRight test - are left-to-right character strings preserved?
       
  3490 		TText* lText = 0;
       
  3491 		TText* rText = 0;
       
  3492 		TInt lretval = KErrNone;
       
  3493 		TInt rretval = KErrNone;
       
  3494 
       
  3495 		TextIterator ltorIterator(KLeftToRight, KLeftToRightLength);
       
  3496 
       
  3497 		aTest->TEST(aOldText.Length() >= KBufferSize);
       
  3498 		while (!ltorIterator.Wrapped())
       
  3499 			{
       
  3500 			for (TInt i = 0 ; i < KBufferSize; )
       
  3501 				{
       
  3502 				if (!ltorIterator.NextCharInto(aOldText, i))
       
  3503 					break;
       
  3504 				}
       
  3505 
       
  3506 			lretval = TBidirectionalState::ReorderText(aOldText.Ptr(), KBufferSize, EParaLToR, lText);
       
  3507 			rretval = TBidirectionalState::ReorderText(aOldText.Ptr(), KBufferSize, EParaRToL, rText);
       
  3508 
       
  3509 			aTest->TEST(lretval == KErrNone); 
       
  3510 			aTest->TEST(rretval == KErrNone); 
       
  3511 
       
  3512 			//LtoR characters should remain unchanged in either paragraph direction
       
  3513 			aTest->TEST(TextInSameOrder(aOldText.Ptr(), lText, KBufferSize));
       
  3514 			aTest->TEST(TextInSameOrder(aOldText.Ptr(), rText, KBufferSize));
       
  3515 
       
  3516 			DeleteText(aOldText.Ptr(), lText, aTest);
       
  3517 			DeleteText(aOldText.Ptr(), rText, aTest);
       
  3518 
       
  3519 			}
       
  3520 		}
       
  3521 /**
       
  3522  *
       
  3523  * Tests that the Bidirectional Algorithm leaves european numbers alone
       
  3524  *
       
  3525  *
       
  3526  * @param	  "TDes& aOldText"
       
  3527  *			  Descriptor that points to a buffer at least KBufferSize 16-bit characters long
       
  3528  *
       
  3529  * @param     "CTGraphicsBase* aTest"
       
  3530  *            Pointer to the test object 
       
  3531  *
       
  3532  */
       
  3533 	static void SimpleEuropeanNumberTest(TDes& aOldText, CTGraphicsBase* aTest)
       
  3534 		{//European number test - are left-to-right character strings preserved?
       
  3535 
       
  3536 		TText* lText = 0;
       
  3537 		TText* rText = 0;
       
  3538 		TInt lretval = KErrNone;
       
  3539 		TInt rretval = KErrNone;
       
  3540 
       
  3541 		
       
  3542 		TextIterator numIterator(KEuropeanNumber, KEuropeanNumberLength);
       
  3543 		aTest->TEST(aOldText.Length() >= KBufferSize);
       
  3544 
       
  3545 		while (!numIterator.Wrapped())
       
  3546 			{
       
  3547 			for (TInt i = 0 ; i < KBufferSize; ++i)
       
  3548 				{
       
  3549 				aOldText[i] = numIterator.NextChar();
       
  3550 				}
       
  3551 
       
  3552 			lretval = TBidirectionalState::ReorderText(aOldText.Ptr(), KBufferSize, EParaLToR, lText);
       
  3553 			rretval = TBidirectionalState::ReorderText(aOldText.Ptr(), KBufferSize, EParaRToL, rText);
       
  3554 
       
  3555 			aTest->TEST(lretval == KErrNone); 
       
  3556 			aTest->TEST(rretval == KErrNone); 
       
  3557 
       
  3558 			aTest->TEST(TextInSameOrder(aOldText.Ptr(), lText, KBufferSize));
       
  3559 			aTest->TEST(TextInSameOrder(aOldText.Ptr(), rText, KBufferSize));
       
  3560 
       
  3561 			DeleteText(aOldText.Ptr(), lText, aTest);
       
  3562 			DeleteText(aOldText.Ptr(), rText, aTest);
       
  3563 			}
       
  3564 
       
  3565 		}
       
  3566 /**
       
  3567  *
       
  3568  * Tests that the Bidirectional Algorithm reverses right-to-left text.
       
  3569  *
       
  3570  * @param	  "TDes& aOldText"
       
  3571  *			  Descriptor that points to a buffer at least KBufferSize 16-bit characters long
       
  3572  *
       
  3573  * @param     "CTGraphicsBase* aTest"
       
  3574  *            Pointer to the test object 
       
  3575  *
       
  3576  */
       
  3577 	static void SimpleRightToLeftTest(TDes& aOldText, CTGraphicsBase* aTest)
       
  3578 		{// Basic Right-to-Left test
       
  3579 
       
  3580 		TText* lText = 0;
       
  3581 		TText* rText = 0;
       
  3582 		TInt lretval = KErrNone;
       
  3583 		TInt rretval = KErrNone;
       
  3584 		TInt oldTextLength = aOldText.Length();
       
  3585 
       
  3586 		TextIterator rtolIterator(KRightToLeft, KRightToLeftLength);
       
  3587 
       
  3588 		aTest->TEST(aOldText.Length() >= KBufferSize);
       
  3589 
       
  3590 		while (!rtolIterator.Wrapped())
       
  3591 			{
       
  3592 			TInt i = 0;
       
  3593 			rtolIterator.FillInto(aOldText, i, KBufferSize);
       
  3594 			aOldText.SetLength(i);
       
  3595 
       
  3596 			lretval = TBidirectionalState::ReorderText(aOldText.Ptr(), i, EParaLToR, lText);
       
  3597 			rretval = TBidirectionalState::ReorderText(aOldText.Ptr(), i, EParaRToL, rText);
       
  3598 		
       
  3599 			aTest->TEST(lretval == KErrNone); 
       
  3600 			aTest->TEST(rretval == KErrNone); 
       
  3601 
       
  3602 			//RightToLeft characters should be reversed in order
       
  3603 			aTest->TEST(TextInReverseOrder(aOldText.Ptr(), lText, i));
       
  3604 			aTest->TEST(TextInReverseOrder(aOldText.Ptr(), rText, i));
       
  3605 
       
  3606 			DeleteText(aOldText.Ptr(), lText, aTest);
       
  3607 			DeleteText(aOldText.Ptr(), rText, aTest);
       
  3608 			aOldText.SetLength(oldTextLength);
       
  3609 			}
       
  3610 		}		
       
  3611 
       
  3612 /**
       
  3613  *
       
  3614  * Tests that the Bidirectional Algorithm reverses right-to-left Arabic text.
       
  3615  *
       
  3616  * @param	  "TDes& aOldText"
       
  3617  *			  Descriptor that points to a buffer at least KBufferSize 16-bit characters long
       
  3618  *
       
  3619  * @param     "CTGraphicsBase* aTest"
       
  3620  *            Pointer to the test object 
       
  3621  *
       
  3622  */
       
  3623 	static void SimpleRightToLeftArabicTest(TDes& aOldText, CTGraphicsBase* aTest)
       
  3624 		{// Basic Right-to-Left Arabic test
       
  3625 
       
  3626 		TText* lText = 0;
       
  3627 		TText* rText = 0;
       
  3628 		TInt lretval = KErrNone;
       
  3629 		TInt rretval = KErrNone;
       
  3630 
       
  3631 		 // Basic Right-to-Left Arabic test
       
  3632 
       
  3633 		TextIterator rtolIterator(KRightToLeftArabic, KRightToLeftArabicLength);
       
  3634 
       
  3635 		aTest->TEST(aOldText.Length() >= KBufferSize);
       
  3636 
       
  3637 		while (!rtolIterator.Wrapped())
       
  3638 			{
       
  3639 			for (TInt i = 0 ; i < KBufferSize; ++i)
       
  3640 				{
       
  3641 				aOldText[i] = rtolIterator.NextChar();
       
  3642 				}
       
  3643 
       
  3644 			lretval = TBidirectionalState::ReorderText(aOldText.Ptr(), KBufferSize, EParaLToR, lText);
       
  3645 			rretval = TBidirectionalState::ReorderText(aOldText.Ptr(), KBufferSize, EParaRToL, rText);
       
  3646 
       
  3647 			aTest->TEST(lretval == KErrNone); 
       
  3648 			aTest->TEST(rretval == KErrNone); 
       
  3649 
       
  3650 			//RightToLeftArabic characters should be reversed
       
  3651 			aTest->TEST(TextInReverseOrder(aOldText.Ptr(), lText, KBufferSize));
       
  3652 			aTest->TEST(TextInReverseOrder(aOldText.Ptr(), rText, KBufferSize));
       
  3653 
       
  3654 			DeleteText(aOldText.Ptr(), lText, aTest);
       
  3655 			DeleteText(aOldText.Ptr(), rText, aTest);
       
  3656 
       
  3657 			
       
  3658 			}
       
  3659 		 }
       
  3660 
       
  3661 /**
       
  3662  *
       
  3663  * Tests that characters that have mirrors are replaced by their mirrors
       
  3664  * when right-to-left Arabic text is reversed.
       
  3665  *
       
  3666  * @param	  "TDes& aOldText"
       
  3667  *			  Descriptor that points to a buffer at least KBufferSize 16-bit characters long
       
  3668  *
       
  3669  * @param     "CTGraphicsBase* aTest"
       
  3670  *            Pointer to the test object 
       
  3671  *
       
  3672  */
       
  3673 	static void MirroredCharacterTest(TDes& aOldText, CTGraphicsBase* aTest)
       
  3674 		{
       
  3675 		TText* lText = 0;
       
  3676 		TText* rText = 0;
       
  3677 		TInt lretval = KErrNone;
       
  3678 		TInt rretval = KErrNone;
       
  3679 
       
  3680 		 // Mirrored Characters Test
       
  3681 
       
  3682 		 //Some Arabic test is interspersed with characters that have Mirror versions.
       
  3683 
       
  3684 		 //After reordering the text should be reversed and the mirror characters substituted
       
  3685 		 TextIterator rtolIterator(KRightToLeftArabic, KRightToLeftArabicLength);
       
  3686 		 TextIterator mirrorsIterator(KMirrors().Ptr(), KMirrors().Length());
       
  3687 		 TextIterator mirrordIterator(KMirrord().Ptr(), KMirrord().Length());
       
  3688 
       
  3689 		 while (!rtolIterator.Wrapped())
       
  3690 			{
       
  3691 			TInt i;
       
  3692 			TInt j;
       
  3693 			for (i = 0 ; i < (KBufferSize-3); i+=4)
       
  3694 				{
       
  3695 				aOldText[i] = rtolIterator.NextChar();
       
  3696 				aOldText[i+1] = mirrorsIterator.NextChar();
       
  3697 				aOldText[i+2] = mirrorsIterator.NextChar();
       
  3698 				aOldText[i+3] = rtolIterator.NextChar();
       
  3699 				}
       
  3700 
       
  3701 			lretval = TBidirectionalState::ReorderText(aOldText.Ptr(), KBufferSize, EParaLToR, lText);
       
  3702 			rretval = TBidirectionalState::ReorderText(aOldText.Ptr(), KBufferSize, EParaRToL, rText);
       
  3703 
       
  3704 			aTest->TEST(lretval == KErrNone); 
       
  3705 			aTest->TEST(rretval == KErrNone); 
       
  3706 #ifdef PRINT_DATA
       
  3707 			_LIT(KOTitleT, "Original (Top)");
       
  3708 			_LIT(KLTitleT, "Left-to-Right (Top)"); 
       
  3709 			_LIT(KRTitleT, "Right-to-Left (Top)");
       
  3710 			_LIT(KOTitleB, "Original (Bottom)");
       
  3711 			_LIT(KLTitleB, "Left-to-Right (Bottom)"); 
       
  3712 			_LIT(KRTitleB, "Right-to-Left (Bottom)");
       
  3713 			
       
  3714 
       
  3715 			PrintTestData(KOTitleT, aOldText.Ptr(), 32);
       
  3716 			PrintTestData(KOTitleB, aOldText.Ptr()+KBufferSize-32, 32);
       
  3717 
       
  3718 			PrintTestData(KLTitleT, lText, 32);
       
  3719 			PrintTestData(KLTitleB, lText+KBufferSize-32, 32);
       
  3720 
       
  3721 			PrintTestData(KRTitleT, rText, 32);
       
  3722 			PrintTestData(KRTitleB, rText+KBufferSize-32, 32);
       
  3723 
       
  3724 #endif
       
  3725 		
       
  3726 			for (i = 0 ; i < (KBufferSize-3) ; i+=4)
       
  3727 				{
       
  3728 				j = KBufferSize - i - 1;
       
  3729 				aTest->TEST(aOldText[i] == lText[j]);
       
  3730 				aTest->TEST(aOldText[i] == rText[j]);
       
  3731 				aTest->TEST(aOldText[i+3] == lText[j-3]);
       
  3732 				aTest->TEST(aOldText[i+3] == rText[j-3]);
       
  3733 
       
  3734 				TText16 nextMirror = mirrordIterator.NextChar();
       
  3735 
       
  3736 				aTest->TEST(nextMirror == lText[j-1]);
       
  3737 				aTest->TEST(nextMirror == rText[j-1]);
       
  3738 
       
  3739 				nextMirror = mirrordIterator.NextChar();
       
  3740 
       
  3741 				aTest->TEST(nextMirror == lText[j-2]);
       
  3742 				aTest->TEST(nextMirror == rText[j-2]);
       
  3743 				}
       
  3744 
       
  3745 
       
  3746 			DeleteText(aOldText.Ptr(), lText, aTest);
       
  3747 			DeleteText(aOldText.Ptr(), rText, aTest);
       
  3748 
       
  3749 	
       
  3750 			}
       
  3751 		}
       
  3752 /**
       
  3753  *
       
  3754  * Tests the effect of LeftToRightOverride on left-to-right text.
       
  3755  *
       
  3756  * @param	  "TDes& aOldText"
       
  3757  *			  Descriptor that points to a buffer at least KBufferSize 16-bit characters long
       
  3758  *
       
  3759  * @param     "CTGraphicsBase* aTest"
       
  3760  *            Pointer to the test object 
       
  3761  *
       
  3762  */
       
  3763 	static void LROLeftToRightTest(TDes& aOldText, CTGraphicsBase* aTest)
       
  3764 		{
       
  3765 		TText* newText = 0;
       
  3766 		TInt retval = KErrNone;
       
  3767 
       
  3768 		aTest->TEST(aOldText.Length() >= KBufferSize);
       
  3769 		//LRO test - are left-to-right character strings preserved?
       
  3770 	 
       
  3771 		TextIterator ltorIterator(KLeftToRight, KLeftToRightLength);
       
  3772 		while (ltorIterator.Wrapped())
       
  3773 			{
       
  3774 			aOldText[0] = KLeftToRightOverride[0];
       
  3775 			for (TInt i = 1 ; i < (KBufferSize-1); ++i)
       
  3776 				{
       
  3777 				aOldText[i] = ltorIterator.NextChar();
       
  3778 				}
       
  3779 
       
  3780 			aOldText[KBufferSize-1] = KPopDirectionalFormat[0];
       
  3781 			retval = TBidirectionalState::ReorderText(aOldText.Ptr(), KBufferSize, EParaLToR, newText);
       
  3782 
       
  3783 			aTest->TEST(retval == KErrNone); 
       
  3784 
       
  3785 			aTest->TEST(TextInSameOrder(aOldText.Ptr(), newText, KBufferSize));
       
  3786 		
       
  3787 			DeleteText(aOldText.Ptr(), newText, aTest);
       
  3788 
       
  3789 			}
       
  3790 		}
       
  3791 
       
  3792 /**
       
  3793  *
       
  3794  * Tests the effect of LeftToRightOverride on right-to-left text.
       
  3795  *
       
  3796  * @param	  "TDes& aOldText"
       
  3797  *			  Descriptor that points to a buffer at least KBufferSize 16-bit characters long
       
  3798  *
       
  3799  * @param     "CTGraphicsBase* aTest"
       
  3800  *            Pointer to the test object 
       
  3801  *
       
  3802  */
       
  3803 	static void LRORightToLeftTest(TDes& aOldText, CTGraphicsBase* aTest)
       
  3804 		{
       
  3805 		TText* newText = 0;
       
  3806 		TInt retval = KErrNone;
       
  3807 
       
  3808 
       
  3809 		//LRO test - are right-to-left character strings overidden?
       
  3810 		TextIterator rtolIterator(KRightToLeft, KRightToLeftLength);
       
  3811 
       
  3812 		aTest->TEST(aOldText.Length() >= KBufferSize);
       
  3813 		while (!rtolIterator.Wrapped())
       
  3814 			{
       
  3815 			aOldText[0] = KLeftToRightOverride[0];
       
  3816 			for (TInt i = 1 ; i < (KBufferSize-1); ++i)
       
  3817 				{
       
  3818 				aOldText[i] = rtolIterator.NextChar();
       
  3819 				}
       
  3820 			
       
  3821 			aOldText[KBufferSize-1] = KPopDirectionalFormat[0];
       
  3822 			retval = TBidirectionalState::ReorderText(aOldText.Ptr(), KBufferSize, EParaLToR, newText);
       
  3823 
       
  3824 			aTest->TEST(retval == KErrNone); 
       
  3825 
       
  3826 			aTest->TEST(TextInSameOrder(aOldText.Ptr(), newText, KBufferSize));
       
  3827 
       
  3828 			DeleteText(aOldText.Ptr(),newText, aTest);
       
  3829 			}
       
  3830 		}
       
  3831 
       
  3832 /**
       
  3833  *
       
  3834  * Tests the effect of RightToLeftOverride on right-to-left text.
       
  3835  *
       
  3836  * @param	  "TDes& aOldText"
       
  3837  *			  Descriptor that points to a buffer at least KBufferSize 16-bit characters long
       
  3838  *
       
  3839  * @param     "CTGraphicsBase* aTest"
       
  3840  *            Pointer to the test object 
       
  3841  *
       
  3842  */
       
  3843 	static void RLORightToLeftTest(TDes& aOldText, CTGraphicsBase* aTest)
       
  3844 		{
       
  3845 		TText* newText = 0;
       
  3846 		TInt retval = KErrNone;
       
  3847 		TInt oldTextLength = aOldText.Length();
       
  3848 
       
  3849 		 // RLO Test - are right-to-left characters unaffected?
       
  3850 		TextIterator rtolIterator(KRightToLeft, KRightToLeftLength);
       
  3851 		 
       
  3852 		aTest->TEST(aOldText.Length() >= KBufferSize);
       
  3853 
       
  3854 		while (!rtolIterator.Wrapped())
       
  3855 			{
       
  3856 			aOldText[0] = KRightToLeftOverride[0];
       
  3857 
       
  3858 			TInt i = 1;
       
  3859 			rtolIterator.FillInto(aOldText, i, KBufferSize-1);
       
  3860 			aOldText[i++] = KPopDirectionalFormat[0];
       
  3861 			aOldText.SetLength(i);
       
  3862 
       
  3863 			retval = TBidirectionalState::ReorderText(aOldText.Ptr(), i, EParaRToL, newText);
       
  3864 
       
  3865 			aTest->TEST(retval == KErrNone); 
       
  3866 
       
  3867 			aTest->TEST(TextInReverseOrder(aOldText.Ptr(), newText, i));
       
  3868 		
       
  3869 			DeleteText(aOldText.Ptr(), newText, aTest);
       
  3870 			aOldText.SetLength(oldTextLength);
       
  3871 			}
       
  3872 		}
       
  3873 
       
  3874 /**
       
  3875  *
       
  3876  * Tests the effect of RightToLeftOverride on right-to-left Arabic text.
       
  3877  *
       
  3878  * @param	  "TDes& aOldText"
       
  3879  *			  Descriptor that points to a buffer at least KBufferSize 16-bit characters long
       
  3880  *
       
  3881  * @param     "CTGraphicsBase* aTest"
       
  3882  *            Pointer to the test object 
       
  3883  *
       
  3884  */	
       
  3885 	static void RLORightToLeftArabicTest(TDes& aOldText, CTGraphicsBase* aTest)
       
  3886 		{
       
  3887 		TText* newText = 0;
       
  3888 		TInt retval = KErrNone;
       
  3889 
       
  3890 		// RLO Test - are right-to-left Arabic characters unaffected?
       
  3891 		TextIterator rtolIterator(KRightToLeftArabic, KRightToLeftArabicLength);
       
  3892 
       
  3893 		aTest->TEST(aOldText.Length() >= KBufferSize);
       
  3894 
       
  3895 		while (!rtolIterator.Wrapped())
       
  3896 			{
       
  3897 			aOldText[0] = KRightToLeftOverride[0];
       
  3898 
       
  3899 			for (TInt i = 1 ; i < (KBufferSize-1); ++i)
       
  3900 				{
       
  3901 				aOldText[i] = rtolIterator.NextChar();
       
  3902 				}
       
  3903 			
       
  3904 			aOldText[KBufferSize-1] = KPopDirectionalFormat[0];
       
  3905 		 
       
  3906 			retval = TBidirectionalState::ReorderText(aOldText.Ptr(), KBufferSize, EParaRToL, newText);
       
  3907 
       
  3908 			aTest->TEST(retval == KErrNone); 
       
  3909 
       
  3910 			aTest->TEST(TextInReverseOrder(aOldText.Ptr(), newText, KBufferSize));
       
  3911 
       
  3912 			DeleteText(aOldText.Ptr(), newText, aTest);
       
  3913 
       
  3914 			}
       
  3915 		}
       
  3916 
       
  3917 /**
       
  3918  *
       
  3919  * Tests the effect of RightToLeftOverride on left-to-right text.
       
  3920  *
       
  3921  * @param	  "TDes& aOldText"
       
  3922  *			  Descriptor that points to a buffer at least KBufferSize 16-bit characters long
       
  3923  *
       
  3924  * @param     "CTGraphicsBase* aTest"
       
  3925  *            Pointer to the test object 
       
  3926  *
       
  3927  */
       
  3928 	static void RLOLeftToRightTest(TDes& aOldText, CTGraphicsBase* aTest)
       
  3929 		{
       
  3930 		TText* newText = 0;
       
  3931 		TInt retval = KErrNone;
       
  3932 		TInt oldTextLength = aOldText.Length();
       
  3933 
       
  3934 		// RLO Test - are left-to-right characters overriden?
       
  3935 		 TextIterator ltorIterator(KLeftToRight, KLeftToRightLength);
       
  3936 
       
  3937 		 aTest->TEST(aOldText.Length() >= KBufferSize);
       
  3938 
       
  3939 		 while (!ltorIterator.Wrapped())
       
  3940 			{
       
  3941 			aOldText[0] = KRightToLeftOverride[0];
       
  3942 
       
  3943 			TInt i;
       
  3944 			for (i = 1 ; i < (KBufferSize-1); )
       
  3945 				{
       
  3946 				if (!ltorIterator.NextCharInto(aOldText, i, KBufferSize-1))
       
  3947 					break;
       
  3948 				}
       
  3949 
       
  3950 			aOldText[i] = KPopDirectionalFormat[0];
       
  3951 			TInt newLength = i + 1;
       
  3952 			aOldText.SetLength(newLength);
       
  3953 		 
       
  3954 			retval = TBidirectionalState::ReorderText(aOldText.Ptr(), newLength, EParaRToL, newText);
       
  3955 
       
  3956 			aTest->TEST(retval == KErrNone); 
       
  3957 
       
  3958 			aTest->TEST(TextInReverseOrder(aOldText.Ptr(), newText, newLength, aTest));
       
  3959 		
       
  3960 			DeleteText(aOldText.Ptr(), newText, aTest);
       
  3961 			aOldText.SetLength(oldTextLength);
       
  3962 			}
       
  3963 		}
       
  3964 
       
  3965 /**
       
  3966  *
       
  3967  * Tests the effect of putting Left To Right text by Right To Left text.
       
  3968  *
       
  3969  * @param	  "TDes& aOldText"
       
  3970  *			  Descriptor that points to a buffer at least KBufferSize 16-bit characters long
       
  3971  *
       
  3972  * @param     "CTGraphicsBase* aTest"
       
  3973  *            Pointer to the test object 
       
  3974  *
       
  3975  */
       
  3976 	static void LToRThenRToLTest(TDes& aOldText, CTGraphicsBase* aTest)
       
  3977 		{
       
  3978 		TText* lText = 0;
       
  3979 		TText* rText = 0;
       
  3980 		TInt lretval = KErrNone;
       
  3981 		TInt rretval = KErrNone;
       
  3982 		TInt oldTextLength = aOldText.Length();
       
  3983 
       
  3984 		// Mixing L-R & R-L without embed codes - L-R at start, R-L at end
       
  3985 		 TextIterator ltorIterator(KLeftToRight, KLeftToRightLength);
       
  3986 		 TextIterator rtolIterator(KRightToLeft, KRightToLeftLength);
       
  3987 
       
  3988 		 aTest->TEST(aOldText.Length() >= KBufferSize);
       
  3989 
       
  3990 		 while (!ltorIterator.Wrapped())
       
  3991 			{
       
  3992 			TInt i = 0;
       
  3993 			ltorIterator.FillInto(aOldText, i, KHalfBufferSize);
       
  3994 			TInt realSize1 = i;
       
  3995 
       
  3996 			rtolIterator.FillInto(aOldText, i, KBufferSize);
       
  3997 			TInt realSize2 = i - realSize1;
       
  3998 			aOldText.SetLength(i);
       
  3999 
       
  4000 			lretval = TBidirectionalState::ReorderText(aOldText.Ptr(), i, EParaLToR, lText);
       
  4001 			rretval = TBidirectionalState::ReorderText(aOldText.Ptr(), i, EParaLToR, rText);
       
  4002 
       
  4003 			aTest->TEST(lretval == KErrNone); 
       
  4004 			aTest->TEST(rretval == KErrNone); 
       
  4005 
       
  4006 			aTest->TEST(TextInSameOrder(aOldText.Ptr(), lText, realSize1));
       
  4007 			aTest->TEST(TextInReverseOrder(&aOldText.Ptr()[realSize1], &lText[realSize1], realSize2));
       
  4008 			aTest->TEST(TextInSameOrder(aOldText.Ptr(), rText, realSize1));
       
  4009 			aTest->TEST(TextInReverseOrder(&aOldText.Ptr()[realSize1], &rText[realSize1], realSize2));
       
  4010 
       
  4011 			DeleteText(aOldText.Ptr(), lText, aTest);
       
  4012 			DeleteText(aOldText.Ptr(), rText, aTest);
       
  4013 			aOldText.SetLength(oldTextLength);
       
  4014 			}
       
  4015 		}
       
  4016 
       
  4017 /**
       
  4018  *
       
  4019  * Tests the effect of putting Left To Right text by Right To Left Arabic text.
       
  4020  *
       
  4021  * @param	  "TDes& aOldText"
       
  4022  *			  Descriptor that points to a buffer at least KBufferSize 16-bit characters long
       
  4023  *
       
  4024  * @param     "CTGraphicsBase* aTest"
       
  4025  *            Pointer to the test object 
       
  4026  *
       
  4027  */
       
  4028 	static void LToRThenRToLATest(TDes& aOldText, CTGraphicsBase* aTest)
       
  4029 		{
       
  4030 		TText* lText = 0;
       
  4031 		TText* rText = 0;
       
  4032 		TInt lretval = KErrNone;
       
  4033 		TInt rretval = KErrNone;
       
  4034 		TInt oldTextLength = aOldText.Length();
       
  4035 
       
  4036 		 TextIterator ltorIterator(KLeftToRight, KLeftToRightLength);
       
  4037 		 TextIterator rtolIterator(KRightToLeftArabic, KRightToLeftArabicLength);
       
  4038 
       
  4039 		 aTest->TEST(aOldText.Length() >= KBufferSize);
       
  4040 		 while (!ltorIterator.Wrapped())
       
  4041 			{
       
  4042 			TInt i;
       
  4043 
       
  4044 			for (i = 0 ; i < KHalfBufferSize; )
       
  4045 				{
       
  4046 				if (!ltorIterator.NextCharInto(aOldText, i, KHalfBufferSize))
       
  4047 					break;
       
  4048 				}
       
  4049 			TInt realSize1 = i;
       
  4050 
       
  4051 			for (; i < KBufferSize; ++i)
       
  4052 				{
       
  4053 				aOldText[i] = rtolIterator.NextChar();
       
  4054 				}
       
  4055 			TInt realSize2 = i - realSize1;
       
  4056 			aOldText.SetLength(i);
       
  4057 
       
  4058  
       
  4059 			lretval = TBidirectionalState::ReorderText(aOldText.Ptr(), i, EParaLToR, lText);
       
  4060 			rretval = TBidirectionalState::ReorderText(aOldText.Ptr(), i, EParaLToR, rText);
       
  4061 
       
  4062 			aTest->TEST(lretval == KErrNone); 
       
  4063 			aTest->TEST(rretval == KErrNone); 
       
  4064 
       
  4065 			aTest->TEST(TextInSameOrder(aOldText.Ptr(), lText, realSize1));
       
  4066 			aTest->TEST(TextInReverseOrder(&aOldText.Ptr()[realSize1], &lText[realSize1], realSize2));
       
  4067 			aTest->TEST(TextInSameOrder(aOldText.Ptr(), rText, realSize1));
       
  4068 			aTest->TEST(TextInReverseOrder(&aOldText.Ptr()[realSize1], &rText[realSize1], realSize2));
       
  4069 
       
  4070 			DeleteText(aOldText.Ptr(), lText, aTest);
       
  4071 			DeleteText(aOldText.Ptr(), rText, aTest);
       
  4072 			aOldText.SetLength(oldTextLength);
       
  4073 			}
       
  4074 		}
       
  4075 /**
       
  4076  *
       
  4077  * Tests the effect of putting Right To Left Arabic by Left To Right text.
       
  4078  *
       
  4079  * @param	  "TDes& aOldText"
       
  4080  *			  Descriptor that points to a buffer at least KBufferSize 16-bit characters long
       
  4081  *
       
  4082  * @param     "CTGraphicsBase* aTest"
       
  4083  *            Pointer to the test object 
       
  4084  *
       
  4085  */
       
  4086 	static void RToLAThenLToRTest(TDes& aOldText, CTGraphicsBase* aTest)
       
  4087 		{
       
  4088 		TText* lText = 0;
       
  4089 		TText* rText = 0;
       
  4090 		TInt lretval = KErrNone;
       
  4091 		TInt rretval = KErrNone;
       
  4092 		TInt oldTextLength = aOldText.Length();
       
  4093 
       
  4094 		 // Mixing L-R & R-LA without embed codes - R-LA at start, L-R at end
       
  4095 		 TextIterator ltorIterator(KLeftToRight, KLeftToRightLength);
       
  4096 		 TextIterator rtolIterator(KRightToLeftArabic, KRightToLeftArabicLength);
       
  4097 
       
  4098 		 aTest->TEST(aOldText.Length() >= KBufferSize);
       
  4099 
       
  4100 		 while (!ltorIterator.Wrapped())
       
  4101 			{
       
  4102 			TInt i = 0;
       
  4103 
       
  4104 			rtolIterator.FillInto(aOldText, i, KHalfBufferSize);
       
  4105 			TInt realSize1 = i;
       
  4106 
       
  4107 			ltorIterator.FillInto(aOldText, i, KBufferSize);
       
  4108 			TInt realSize2 = i - realSize1;
       
  4109 			aOldText.SetLength(i);
       
  4110  
       
  4111 			lretval = TBidirectionalState::ReorderText(aOldText.Ptr(), i, EParaLToR, lText);
       
  4112 			rretval = TBidirectionalState::ReorderText(aOldText.Ptr(), i, EParaRToL, rText);
       
  4113 
       
  4114 			aTest->TEST(lretval == KErrNone); 
       
  4115 			aTest->TEST(rretval == KErrNone); 
       
  4116 
       
  4117 			aTest->TEST(TextInReverseOrder(aOldText.Ptr(), lText, realSize1));
       
  4118 			aTest->TEST(TextInSameOrder(&aOldText.Ptr()[realSize1], &lText[realSize1] , realSize2));
       
  4119 
       
  4120 			aTest->TEST(TextInReverseOrder(aOldText.Ptr(), &rText[realSize2], realSize1));
       
  4121 			aTest->TEST(TextInSameOrder(&aOldText.Ptr()[realSize1], rText, realSize2));
       
  4122 
       
  4123 			DeleteText(aOldText.Ptr(), lText, aTest);
       
  4124 			DeleteText(aOldText.Ptr(), rText, aTest);
       
  4125 			aOldText.SetLength(oldTextLength);
       
  4126 			}
       
  4127 		}
       
  4128 
       
  4129 /**
       
  4130  *
       
  4131  * Tests the effect of interspersing right to left and left to right text
       
  4132  *
       
  4133  * @param	  "TDes& aOldText"
       
  4134  *			  Descriptor that points to a buffer at least KBufferSize 16-bit characters long
       
  4135  *
       
  4136  * @param     "CTGraphicsBase* aTest"
       
  4137  *            Pointer to the test object 
       
  4138  *
       
  4139  */
       
  4140 	static void LToRThenRToLThenLToRThenRToLTest(TDes& aOldText, CTGraphicsBase* aTest)
       
  4141 		{
       
  4142 		TText* lText = 0;
       
  4143 		TText* rText = 0;
       
  4144 		TInt lretval = KErrNone;
       
  4145 		TInt rretval = KErrNone;
       
  4146 		TInt oldTextLength = aOldText.Length();
       
  4147 
       
  4148 		 // Mixing L-R & R-L without embed codes - quarter buffers L-R R-L L-R R-L 
       
  4149 		 TextIterator ltorIterator(KLeftToRight, KLeftToRightLength);
       
  4150 		 TextIterator rtolIterator(KRightToLeft, KRightToLeftLength);
       
  4151 
       
  4152 		 aTest->TEST(aOldText.Length() >= KBufferSize);
       
  4153 
       
  4154 		 while (!ltorIterator.Wrapped())
       
  4155 			{
       
  4156 			TInt i = 0;
       
  4157 
       
  4158 			ltorIterator.FillInto(aOldText, i, KQuarterBufferSize);
       
  4159 			TInt realSize1 = i;
       
  4160 			
       
  4161 			rtolIterator.FillInto(aOldText, i, KHalfBufferSize);
       
  4162 			TInt realSize2 = i - realSize1;
       
  4163 			TInt realSize12 = i;
       
  4164 			
       
  4165 			ltorIterator.FillInto(aOldText, i, KThreeQuarterBufferSize);
       
  4166 			TInt realSize3 = i - realSize12;
       
  4167 			TInt realSize123 = i;
       
  4168 			
       
  4169 			rtolIterator.FillInto(aOldText, i, KBufferSize);
       
  4170 			TInt realSize4 = i - realSize123;
       
  4171 			TInt realSize34 = i - realSize12;
       
  4172 			TInt realSize234 = i - realSize1;
       
  4173 
       
  4174 			lretval = TBidirectionalState::ReorderText(aOldText.Ptr(), i, EParaLToR, lText);
       
  4175 	    	rretval = TBidirectionalState::ReorderText(aOldText.Ptr(), i, EParaRToL, rText);
       
  4176 
       
  4177 			aTest->TEST(lretval == KErrNone); 
       
  4178 			aTest->TEST(rretval == KErrNone); 
       
  4179 
       
  4180 			// source:		L1 R2 L3 R4
       
  4181 			// l should be:	L1 L2 L3 L4
       
  4182 			// r should be: R4 R3 R2 R1
       
  4183 			aTest->TEST(TextInSameOrder(aOldText.Ptr(), lText, realSize1));
       
  4184 			aTest->TEST(TextInReverseOrder(&aOldText.Ptr()[realSize1], &lText[realSize1], realSize2));
       
  4185 			aTest->TEST(TextInSameOrder(&aOldText.Ptr()[realSize12], &lText[realSize12], realSize3));
       
  4186 			aTest->TEST(TextInReverseOrder(&aOldText.Ptr()[realSize123], &lText[realSize123], realSize4));
       
  4187 
       
  4188 			aTest->TEST(TextInReverseOrder(&aOldText.Ptr()[realSize123], rText, realSize4));
       
  4189 			aTest->TEST(TextInSameOrder(&aOldText.Ptr()[realSize12], &rText[realSize4], realSize3));
       
  4190 			aTest->TEST(TextInReverseOrder(&aOldText.Ptr()[realSize1], &rText[realSize34], realSize2));
       
  4191 			aTest->TEST(TextInSameOrder(aOldText.Ptr(), &rText[realSize234], realSize1));
       
  4192 		
       
  4193 			DeleteText(aOldText.Ptr(), lText, aTest);
       
  4194 			DeleteText(aOldText.Ptr(), rText, aTest);
       
  4195 			aOldText.SetLength(oldTextLength);
       
  4196 			}
       
  4197 		}
       
  4198 
       
  4199 /**
       
  4200  *
       
  4201  * Tests the effect of interspersing right to left and left to right text
       
  4202  *
       
  4203  * @param	  "TDes& aOldText"
       
  4204  *			  Descriptor that points to a buffer at least KBufferSize 16-bit characters long
       
  4205  *
       
  4206  * @param     "CTGraphicsBase* aTest"
       
  4207  *            Pointer to the test object 
       
  4208  *
       
  4209  */
       
  4210 	static void RToLThenLToRThenRToLThenLToRTest(TDes& aOldText, CTGraphicsBase* aTest)
       
  4211 		{
       
  4212 		TText* lText = 0;
       
  4213 		TText* rText = 0;
       
  4214 		TInt lretval = KErrNone;
       
  4215 		TInt rretval = KErrNone;
       
  4216 		TInt oldTextLength = aOldText.Length();
       
  4217 
       
  4218 		 // Mixing L-R & R-L without embed codes - quarter buffers R-L L-R R-L L-R
       
  4219 		 TextIterator ltorIterator(KLeftToRight, KLeftToRightLength);
       
  4220 		 TextIterator rtolIterator(KRightToLeft, KRightToLeftLength);
       
  4221 
       
  4222 		 aTest->TEST(aOldText.Length() >= KBufferSize);
       
  4223 
       
  4224 		 while (!ltorIterator.Wrapped())
       
  4225 			{
       
  4226 			TInt i = 0;
       
  4227 
       
  4228 	    	rtolIterator.FillInto(aOldText, i, KQuarterBufferSize);
       
  4229 			TInt realSize1 = i;
       
  4230 			
       
  4231 			ltorIterator.FillInto(aOldText, i, KHalfBufferSize);
       
  4232 			TInt realSize2 = i - realSize1;
       
  4233 			TInt realSize12 = i;
       
  4234 			
       
  4235 			rtolIterator.FillInto(aOldText, i, KThreeQuarterBufferSize);
       
  4236 			TInt realSize3 = i - realSize12;
       
  4237 			TInt realSize123 = i;
       
  4238 			
       
  4239 			ltorIterator.FillInto(aOldText, i, KBufferSize);
       
  4240 			TInt realSize4 = i - realSize123;
       
  4241 			TInt realSize34 = i - realSize12;
       
  4242 			TInt realSize234 = i - realSize1;
       
  4243 
       
  4244 			lretval = TBidirectionalState::ReorderText(aOldText.Ptr(), i, EParaLToR, lText);
       
  4245 	    	rretval = TBidirectionalState::ReorderText(aOldText.Ptr(), i, EParaRToL, rText);
       
  4246 
       
  4247 			aTest->TEST(lretval == KErrNone); 
       
  4248 			aTest->TEST(rretval == KErrNone); 
       
  4249 
       
  4250 			// source:		R1 L2 R3 L4
       
  4251 			// l should be:	L1 L2 L3 L4
       
  4252 			// r should be: L4 L3 L2 L1
       
  4253 			aTest->TEST(TextInReverseOrder(aOldText.Ptr(), lText, realSize1));
       
  4254 			aTest->TEST(TextInSameOrder(&aOldText.Ptr()[realSize1], &lText[realSize1], realSize2));
       
  4255 			aTest->TEST(TextInReverseOrder(&aOldText.Ptr()[realSize12], &lText[realSize12], realSize3));
       
  4256 			aTest->TEST(TextInSameOrder(&aOldText.Ptr()[realSize123], &lText[realSize123], realSize4));
       
  4257 		
       
  4258 			aTest->TEST( TextInSameOrder(&aOldText.Ptr()[realSize123], rText, realSize4));
       
  4259 			aTest->TEST(TextInReverseOrder(&aOldText.Ptr()[realSize12], &rText[realSize4], realSize3));
       
  4260 			aTest->TEST(TextInSameOrder(&aOldText.Ptr()[realSize1], &rText[realSize34], realSize2));
       
  4261 			aTest->TEST(TextInReverseOrder(aOldText.Ptr(), &rText[realSize234], realSize1));
       
  4262 		
       
  4263 			DeleteText(aOldText.Ptr(), lText, aTest);
       
  4264 			DeleteText(aOldText.Ptr(), rText, aTest);
       
  4265 			
       
  4266 			aOldText.SetLength(oldTextLength);
       
  4267 			}
       
  4268 		}
       
  4269 
       
  4270 /**
       
  4271  *
       
  4272  * Tests the effect of mixing blocks of right to left text, left to right text, 
       
  4273  * European numbers and Arabic numbers
       
  4274  *
       
  4275  * @param	  "TDes& aOldText"
       
  4276  *			  Descriptor that points to a buffer at least KBufferSize 16-bit characters long
       
  4277  *
       
  4278  * @param     "CTGraphicsBase* aTest"
       
  4279  *            Pointer to the test object 
       
  4280  *
       
  4281  */
       
  4282 	static void SimpleNumberTest(TDes& aOldText, CTGraphicsBase* aTest)
       
  4283 		{
       
  4284 		TText* lText = 0;
       
  4285 		TText* rText = 0;
       
  4286 		TInt lretval = KErrNone;
       
  4287 		TInt rretval = KErrNone;
       
  4288 		TInt oldTextLength = aOldText.Length();
       
  4289 
       
  4290 		// Now mix in some numbers
       
  4291 		 TextIterator ltorIterator(KLeftToRight, KLeftToRightLength);
       
  4292 		 TextIterator rtolIterator(KRightToLeft, KRightToLeftLength);
       
  4293 		 TextIterator euronIterator(KEuropeanNumber, KEuropeanNumberLength);
       
  4294 		 TextIterator arabnIterator(KArabicNumber, KArabicNumberLength);
       
  4295 
       
  4296 		 aTest->TEST(aOldText.Length() >= KBufferSize);
       
  4297 
       
  4298 		 while (!ltorIterator.Wrapped())
       
  4299 			{
       
  4300 			TInt i = 0;
       
  4301 	    	rtolIterator.FillInto(aOldText, i, KQuarterBufferSize);
       
  4302 			TInt realSize1 = i;
       
  4303 			
       
  4304 			ltorIterator.FillInto(aOldText, i, KHalfBufferSize);
       
  4305 			TInt realSize2 = i - realSize1;
       
  4306 			TInt realSize12 = i;
       
  4307 			
       
  4308 			euronIterator.FillInto(aOldText, i, KThreeQuarterBufferSize);
       
  4309 			TInt realSize3 = i - realSize12;
       
  4310 			TInt realSize123 = i;
       
  4311 			TInt realSize23 = realSize123 - realSize1;
       
  4312 			
       
  4313 			arabnIterator.FillInto(aOldText, i, KBufferSize);
       
  4314 			TInt realSize4 = i - realSize123;
       
  4315 			TInt realSize234 = i - realSize1;
       
  4316 
       
  4317 			rretval = TBidirectionalState::ReorderText(aOldText.Ptr(), i, EParaRToL, rText);
       
  4318 			lretval = TBidirectionalState::ReorderText(aOldText.Ptr(), i, EParaLToR, lText);
       
  4319 
       
  4320 			aTest->TEST(lretval == KErrNone); 
       
  4321 			aTest->TEST(rretval == KErrNone); 
       
  4322 
       
  4323 			// source:		 1  2  3  4
       
  4324 			// l should be:	 2  3  4 -1
       
  4325 			// r should be: -1  2  3  4
       
  4326 			aTest->TEST(TextInSameOrder(&aOldText.Ptr()[realSize1], rText, realSize2));
       
  4327 			aTest->TEST(TextInSameOrder(&aOldText.Ptr()[realSize12], &rText[realSize2], realSize3));
       
  4328 			aTest->TEST(TextInSameOrder(&aOldText.Ptr()[realSize123], &rText[realSize23], realSize4));
       
  4329 			aTest->TEST(TextInReverseOrder(aOldText.Ptr(), &rText[realSize234], realSize1));
       
  4330 
       
  4331 			aTest->TEST(TextInReverseOrder(aOldText.Ptr(), lText, realSize1));
       
  4332 			aTest->TEST(TextInSameOrder(&aOldText.Ptr()[realSize1], &lText[realSize1], realSize2));
       
  4333 			aTest->TEST(TextInSameOrder(&aOldText.Ptr()[realSize12], &lText[realSize12], realSize3));
       
  4334 			aTest->TEST(TextInSameOrder(&aOldText.Ptr()[realSize123], &lText[realSize123], realSize4));
       
  4335 		
       
  4336 			DeleteText(aOldText.Ptr(), lText, aTest);
       
  4337 			DeleteText(aOldText.Ptr(), rText, aTest);
       
  4338 			}
       
  4339 		}
       
  4340 
       
  4341 /**
       
  4342  *
       
  4343  * Tests what happens when Arabic and European numbers are surrounded by Arabic letters
       
  4344  *
       
  4345  * @param	  "TDes& aOldText"
       
  4346  *			  Descriptor that points to a buffer at least KBufferSize 16-bit characters long
       
  4347  *
       
  4348  * @param     "CTGraphicsBase* aTest"
       
  4349  *            Pointer to the test object 
       
  4350  *
       
  4351  */
       
  4352 	static void RToLAThenANThenENThenRToLATest(TDes& aOldText, CTGraphicsBase* aTest)
       
  4353 		{
       
  4354 		TText* lText = 0;
       
  4355 		TText* rText = 0;
       
  4356 		TInt lretval = KErrNone;
       
  4357 		TInt rretval = KErrNone;
       
  4358 		TInt oldTextLength = aOldText.Length();
       
  4359 		HBufC *lResult = HBufC::NewLC(KBufferSize);
       
  4360 		HBufC *rResult = HBufC::NewLC(KBufferSize);
       
  4361 
       
  4362 		// Now mix in some numbers
       
  4363 		 TextIterator rtolIterator(KRightToLeftArabic, KRightToLeftArabicLength);
       
  4364 		 TextIterator euronIterator(KEuropeanNumber, KEuropeanNumberLength);
       
  4365 		 TextIterator arabnIterator(KArabicNumber, KArabicNumberLength);
       
  4366 
       
  4367 		 while (!rtolIterator.Wrapped())
       
  4368 			{
       
  4369 			TInt i;
       
  4370 			TInt lasti = 0;
       
  4371 			TUint ch0, ch1, ch2, ch3;
       
  4372 			for (i = 0 ; i < KBufferSize-3; )
       
  4373 				{
       
  4374 				if (!rtolIterator.NextCharInto(aOldText, i, -1, ETrue, ETrue, &ch0))
       
  4375 					break;
       
  4376 				if (!arabnIterator.NextCharInto(aOldText, i, -1, ETrue, ETrue, &ch1))
       
  4377 					break;
       
  4378 				if (!euronIterator.NextCharInto(aOldText, i, -1, ETrue, ETrue, &ch2))
       
  4379 					break;
       
  4380 				if (!rtolIterator.NextCharInto(aOldText, i, -1, ETrue, ETrue, &ch3))
       
  4381 					break;
       
  4382 				
       
  4383 				lasti = i;
       
  4384 				AppendCharacter(lResult, ch0);
       
  4385 				AppendCharacter(lResult, ch2);
       
  4386 				AppendCharacter(lResult, ch1);
       
  4387 				AppendCharacter(lResult, ch3);
       
  4388 				
       
  4389 				AppendCharacter(rResult, ch0);
       
  4390 				AppendCharacter(rResult, ch2);
       
  4391 				AppendCharacter(rResult, ch1);
       
  4392 				AppendCharacter(rResult, ch3);
       
  4393 				}
       
  4394 			i = lasti;
       
  4395 			aOldText.SetLength(i);
       
  4396 			ASSERT(lResult->Des().Length() == i);
       
  4397 			ASSERT(rResult->Des().Length() == i);
       
  4398 
       
  4399 			rretval = TBidirectionalState::ReorderText(aOldText.Ptr(), i, EParaRToL, rText);
       
  4400 			lretval = TBidirectionalState::ReorderText(aOldText.Ptr(), i, EParaLToR, lText);
       
  4401 
       
  4402 			aTest->TEST(lretval == KErrNone); 
       
  4403 			aTest->TEST(rretval == KErrNone); 
       
  4404 #ifdef PRINT_DATA
       
  4405 
       
  4406 			_LIT(KOTitle, "Original");
       
  4407 			_LIT(KLTitle, "Left-to-Right"); 
       
  4408 			_LIT(KRTitle, "Right-to-Left");
       
  4409 			
       
  4410 
       
  4411 			PrintTestData(KOTitle, aOldText);
       
  4412 			PrintTestData(KLTitle, lText, KBufferSize);
       
  4413 			PrintTestData(KRTitle, rText, KBufferSize);
       
  4414 
       
  4415 #endif
       
  4416 			aTest->TEST(TextInReverseOrder(lResult->Ptr(), lText, i));
       
  4417 			aTest->TEST(TextInReverseOrder(rResult->Ptr(), rText, i, aTest));
       
  4418 
       
  4419 			DeleteText(aOldText.Ptr(), lText, aTest);
       
  4420 			DeleteText(aOldText.Ptr(), rText, aTest);
       
  4421 
       
  4422 			aOldText.SetLength(oldTextLength);
       
  4423 			lResult->Des().SetLength(0);
       
  4424 			rResult->Des().SetLength(0);
       
  4425 			}
       
  4426 		CleanupStack::PopAndDestroy(rResult);
       
  4427 		CleanupStack::PopAndDestroy(lResult);
       
  4428 		}
       
  4429 /**
       
  4430  *
       
  4431  * Tests what happens when Arabic and European numbers are surrounded by Arabic letters
       
  4432  *
       
  4433  * @param	  "TDes& aOldText"
       
  4434  *			  Descriptor that points to a buffer at least KBufferSize 16-bit characters long
       
  4435  *
       
  4436  * @param     "CTGraphicsBase* aTest"
       
  4437  *            Pointer to the test object 
       
  4438  *
       
  4439  */
       
  4440 	static void RToLAThenENThenANThenRToLATest(TDes& aOldText, CTGraphicsBase* aTest)
       
  4441 		{
       
  4442 		TText* lText = 0;
       
  4443 		TText* rText = 0;
       
  4444 		TInt lretval = KErrNone;
       
  4445 		TInt rretval = KErrNone;
       
  4446 		TInt oldTextLength = aOldText.Length();
       
  4447 		HBufC *lResult = HBufC::NewLC(KBufferSize);
       
  4448 		HBufC *rResult = HBufC::NewLC(KBufferSize);
       
  4449 
       
  4450 		// Now mix in some numbers
       
  4451 		 TextIterator rtolIterator(KRightToLeftArabic, KRightToLeftArabicLength);
       
  4452 		 TextIterator euronIterator(KEuropeanNumber, KEuropeanNumberLength);
       
  4453 		 TextIterator arabnIterator(KArabicNumber, KArabicNumberLength);
       
  4454 
       
  4455 		 while (!rtolIterator.Wrapped())
       
  4456 			{
       
  4457 			TInt i;
       
  4458 			TInt lasti = 0;
       
  4459 			TUint ch0, ch1, ch2, ch3;
       
  4460 			for (i = 0 ; i < KBufferSize-3; )
       
  4461 				{
       
  4462 				if (!rtolIterator.NextCharInto(aOldText, i, -1, ETrue, ETrue, &ch0))
       
  4463 					break;
       
  4464 				if (!euronIterator.NextCharInto(aOldText, i, -1, ETrue, ETrue, &ch1))
       
  4465 					break;
       
  4466 				if (!arabnIterator.NextCharInto(aOldText, i, -1, ETrue, ETrue, &ch2))
       
  4467 					break;
       
  4468 				if (!rtolIterator.NextCharInto(aOldText, i, -1, ETrue, ETrue, &ch3))
       
  4469 					break;
       
  4470 				
       
  4471 				lasti = i;
       
  4472 				AppendCharacter(lResult, ch0);
       
  4473 				AppendCharacter(lResult, ch2);
       
  4474 				AppendCharacter(lResult, ch1);
       
  4475 				AppendCharacter(lResult, ch3);
       
  4476 				
       
  4477 				AppendCharacter(rResult, ch0);
       
  4478 				AppendCharacter(rResult, ch2);
       
  4479 				AppendCharacter(rResult, ch1);
       
  4480 				AppendCharacter(rResult, ch3);
       
  4481 				}
       
  4482 			i = lasti;
       
  4483 			aOldText.SetLength(i);
       
  4484 			ASSERT(lResult->Des().Length() == i);
       
  4485 			ASSERT(rResult->Des().Length() == i);
       
  4486 
       
  4487 			rretval = TBidirectionalState::ReorderText(aOldText.Ptr(), i, EParaRToL, rText);
       
  4488 			lretval = TBidirectionalState::ReorderText(aOldText.Ptr(), i, EParaLToR, lText);
       
  4489 
       
  4490 			aTest->TEST(lretval == KErrNone); 
       
  4491 			aTest->TEST(rretval == KErrNone); 
       
  4492 #ifdef PRINT_DATA
       
  4493 
       
  4494 			_LIT(KOTitle, "Original");
       
  4495 			_LIT(KLTitle, "Left-to-Right"); 
       
  4496 			_LIT(KRTitle, "Right-to-Left");
       
  4497 			
       
  4498 
       
  4499 			PrintTestData(KOTitle, aOldText);
       
  4500 			PrintTestData(KLTitle, lText, KBufferSize);
       
  4501 			PrintTestData(KRTitle, rText, KBufferSize);
       
  4502 
       
  4503 #endif
       
  4504 			aTest->TEST(TextInReverseOrder(lResult->Ptr(), lText, i));
       
  4505 			aTest->TEST(TextInReverseOrder(rResult->Ptr(), rText, i, aTest));
       
  4506 
       
  4507 			DeleteText(aOldText.Ptr(), lText, aTest);
       
  4508 			DeleteText(aOldText.Ptr(), rText, aTest);
       
  4509 
       
  4510 			aOldText.SetLength(oldTextLength);
       
  4511 			lResult->Des().SetLength(0);
       
  4512 			rResult->Des().SetLength(0);
       
  4513 			}
       
  4514 		CleanupStack::PopAndDestroy(rResult);
       
  4515 		CleanupStack::PopAndDestroy(lResult);
       
  4516 		}
       
  4517 /**
       
  4518  *
       
  4519  * Tests what happens when Arabic and European numbers are surrounded by right-to-left letters
       
  4520  *
       
  4521  * @param	  "TDes& aOldText"
       
  4522  *			  Descriptor that points to a buffer at least KBufferSize 16-bit characters long
       
  4523  *
       
  4524  * @param     "CTGraphicsBase* aTest"
       
  4525  *            Pointer to the test object 
       
  4526  *
       
  4527  */
       
  4528 	static void RToLThenANThenENThenRToLTest(TDes& aOldText, CTGraphicsBase* aTest)
       
  4529 		{
       
  4530 		TText* lText = 0;
       
  4531 		TText* rText = 0;
       
  4532 		TInt oldTextLength = aOldText.Length();
       
  4533 		HBufC *lResult = HBufC::NewLC(KBufferSize);
       
  4534 		HBufC *rResult = HBufC::NewLC(KBufferSize);
       
  4535 
       
  4536 		// Now mix in some numbers
       
  4537 		 TextIterator rtolIterator(KRightToLeft, KRightToLeftLength);
       
  4538 		 TextIterator euronIterator(KEuropeanNumber, KEuropeanNumberLength);
       
  4539 		 TextIterator arabnIterator(KArabicNumber, KArabicNumberLength);
       
  4540 
       
  4541 		 while (!rtolIterator.Wrapped())
       
  4542 			{
       
  4543 			TInt i;
       
  4544 			TInt lasti = 0;
       
  4545 			TUint ch0, ch1, ch2, ch3;
       
  4546 			for (i = 0 ; i < KBufferSize-3; )
       
  4547 				{
       
  4548 				if (!rtolIterator.NextCharInto(aOldText, i, -1, ETrue, ETrue, &ch0))
       
  4549 					break;
       
  4550 				if (!arabnIterator.NextCharInto(aOldText, i, -1, ETrue, ETrue, &ch1))
       
  4551 					break;
       
  4552 				if (!euronIterator.NextCharInto(aOldText, i, -1, ETrue, ETrue, &ch2))
       
  4553 					break;
       
  4554 				if (!rtolIterator.NextCharInto(aOldText, i, -1, ETrue, ETrue, &ch3))
       
  4555 					break;
       
  4556 				
       
  4557 				lasti = i;
       
  4558 				AppendCharacter(lResult, ch0);
       
  4559 				AppendCharacter(lResult, ch2);
       
  4560 				AppendCharacter(lResult, ch1);
       
  4561 				AppendCharacter(lResult, ch3);
       
  4562 				
       
  4563 				AppendCharacter(rResult, ch0);
       
  4564 				AppendCharacter(rResult, ch2);
       
  4565 				AppendCharacter(rResult, ch1);
       
  4566 				AppendCharacter(rResult, ch3);
       
  4567 				}
       
  4568 			i = lasti;
       
  4569 			aOldText.SetLength(i);
       
  4570 			ASSERT(lResult->Des().Length() == i);
       
  4571 			ASSERT(rResult->Des().Length() == i);
       
  4572 
       
  4573 			TBidirectionalState::ReorderText(aOldText.Ptr(), i, EParaRToL, rText);
       
  4574 			TBidirectionalState::ReorderText(aOldText.Ptr(), i, EParaLToR, lText);
       
  4575 
       
  4576 #ifdef PRINT_DATA
       
  4577 
       
  4578 			_LIT(KOTitle, "Original");
       
  4579 			_LIT(KLTitle, "Left-to-Right"); 
       
  4580 			_LIT(KRTitle, "Right-to-Left");
       
  4581 			
       
  4582 
       
  4583 			PrintTestData(KOTitle, aOldText);
       
  4584 			PrintTestData(KLTitle, lText, KBufferSize);
       
  4585 			PrintTestData(KRTitle, rText, KBufferSize);
       
  4586 
       
  4587 #endif
       
  4588 			aTest->TEST(TextInReverseOrder(lResult->Ptr(), lText, i, aTest));
       
  4589 			aTest->TEST(TextInReverseOrder(rResult->Ptr(), rText, i, aTest));
       
  4590 
       
  4591 			DeleteText(aOldText.Ptr(), lText, aTest);
       
  4592 			DeleteText(aOldText.Ptr(), rText, aTest);
       
  4593 			aOldText.SetLength(oldTextLength);
       
  4594 			lResult->Des().SetLength(0);
       
  4595 			rResult->Des().SetLength(0);
       
  4596 			}
       
  4597 		CleanupStack::PopAndDestroy(rResult);
       
  4598 		CleanupStack::PopAndDestroy(lResult);
       
  4599 		}
       
  4600 
       
  4601 /**
       
  4602  *
       
  4603  * Tests what happens when Arabic and European numbers are surrounded by right-to-left letters
       
  4604  *
       
  4605  * @param	  "TDes& aOldText"
       
  4606  *			  Descriptor that points to a buffer at least KBufferSize 16-bit characters long
       
  4607  *
       
  4608  * @param     "CTGraphicsBase* aTest"
       
  4609  *            Pointer to the test object 
       
  4610  *
       
  4611  */
       
  4612 	static void RToLThenENThenANThenRToLTest(TDes& aOldText, CTGraphicsBase* aTest)
       
  4613 		{
       
  4614 		TText* lText = 0;
       
  4615 		TText* rText = 0;
       
  4616 		TInt lretval = KErrNone;
       
  4617 		TInt rretval = KErrNone;
       
  4618 		TInt oldTextLength = aOldText.Length();
       
  4619 		HBufC *lResult = HBufC::NewLC(KBufferSize);
       
  4620 		HBufC *rResult = HBufC::NewLC(KBufferSize);
       
  4621 
       
  4622 		// Now mix in some numbers
       
  4623 		 TextIterator rtolIterator(KRightToLeft, KRightToLeftLength);
       
  4624 		 TextIterator euronIterator(KEuropeanNumber, KEuropeanNumberLength);
       
  4625 		 TextIterator arabnIterator(KArabicNumber, KArabicNumberLength);
       
  4626 
       
  4627 		 while (!rtolIterator.Wrapped())
       
  4628 			{
       
  4629 			TInt i;
       
  4630 			TInt lasti = 0;
       
  4631 			TUint ch0, ch1, ch2, ch3;
       
  4632 			for (i = 0 ; i < KBufferSize-3; )
       
  4633 				{
       
  4634 				if (!rtolIterator.NextCharInto(aOldText, i, -1, ETrue, ETrue, &ch0))
       
  4635 					break;
       
  4636 				if (!euronIterator.NextCharInto(aOldText, i, -1, ETrue, ETrue, &ch1))
       
  4637 					break;
       
  4638 				if (!arabnIterator.NextCharInto(aOldText, i, -1, ETrue, ETrue, &ch2))
       
  4639 					break;
       
  4640 				if (!rtolIterator.NextCharInto(aOldText, i, -1, ETrue, ETrue, &ch3))
       
  4641 					break;
       
  4642 				
       
  4643 				lasti = i;
       
  4644 				AppendCharacter(lResult, ch0);
       
  4645 				AppendCharacter(lResult, ch2);
       
  4646 				AppendCharacter(lResult, ch1);
       
  4647 				AppendCharacter(lResult, ch3);
       
  4648 				
       
  4649 				AppendCharacter(rResult, ch0);
       
  4650 				AppendCharacter(rResult, ch2);
       
  4651 				AppendCharacter(rResult, ch1);
       
  4652 				AppendCharacter(rResult, ch3);
       
  4653 				}
       
  4654 			i = lasti;
       
  4655 			aOldText.SetLength(i);
       
  4656 			ASSERT(lResult->Des().Length() == i);
       
  4657 			ASSERT(rResult->Des().Length() == i);
       
  4658 
       
  4659 			rretval = TBidirectionalState::ReorderText(aOldText.Ptr(), i, EParaRToL, rText);
       
  4660 			lretval = TBidirectionalState::ReorderText(aOldText.Ptr(), i, EParaLToR, lText);
       
  4661 
       
  4662 			aTest->TEST(lretval == KErrNone); 
       
  4663 			aTest->TEST(rretval == KErrNone); 
       
  4664 #ifdef PRINT_DATA
       
  4665 
       
  4666 			_LIT(KOTitle, "Original");
       
  4667 			_LIT(KLTitle, "Left-to-Right"); 
       
  4668 			_LIT(KRTitle, "Right-to-Left");
       
  4669 			
       
  4670 
       
  4671 			PrintTestData(KOTitle, aOldText);
       
  4672 			PrintTestData(KLTitle, lText, KBufferSize);
       
  4673 			PrintTestData(KRTitle, rText, KBufferSize);
       
  4674 
       
  4675 #endif
       
  4676 
       
  4677 			aTest->TEST(TextInReverseOrder(lResult->Ptr(), lText, i, aTest));
       
  4678 			aTest->TEST(TextInReverseOrder(rResult->Ptr(), rText, i, aTest));
       
  4679 
       
  4680 			DeleteText(aOldText.Ptr(), lText, aTest);
       
  4681 			DeleteText(aOldText.Ptr(), rText, aTest);
       
  4682 
       
  4683 			aOldText.SetLength(oldTextLength);
       
  4684 			lResult->Des().SetLength(0);
       
  4685 			rResult->Des().SetLength(0);
       
  4686 			}
       
  4687 		CleanupStack::PopAndDestroy(rResult);
       
  4688 		CleanupStack::PopAndDestroy(lResult);
       
  4689 		}
       
  4690 /**
       
  4691  *
       
  4692  * Tests what happens when Arabic and European numbers are surrounded by Left to Right letters
       
  4693  *
       
  4694  * @param	  "TDes& aOldText"
       
  4695  *			  Descriptor that points to a buffer at least KBufferSize 16-bit characters long
       
  4696  *
       
  4697  * @param     "CTGraphicsBase* aTest"
       
  4698  *            Pointer to the test object 
       
  4699  *
       
  4700  */
       
  4701 	static void LToRThenANThenENThenLToRTest(TDes& aOldText, CTGraphicsBase* aTest)
       
  4702 		{
       
  4703 		TText* lText = 0;
       
  4704 		TText* rText = 0;
       
  4705 		TInt lretval = KErrNone;
       
  4706 		TInt rretval = KErrNone;
       
  4707 		TInt oldTextLength = aOldText.Length();
       
  4708 
       
  4709 		// Now mix in some numbers
       
  4710 		 TextIterator ltorIterator(KLeftToRight, KLeftToRightLength);
       
  4711 		 TextIterator euronIterator(KEuropeanNumber, KEuropeanNumberLength);
       
  4712 		 TextIterator arabnIterator(KArabicNumber, KArabicNumberLength);
       
  4713 
       
  4714 		 aTest->TEST(aOldText.Length() >= KBufferSize);
       
  4715 		 while (!ltorIterator.Wrapped())
       
  4716 			{
       
  4717 			TInt i;
       
  4718 
       
  4719 			for (i = 0 ; i < KBufferSize-3; )
       
  4720 				{
       
  4721 				if (!ltorIterator.NextCharInto(aOldText, i))
       
  4722 					break;
       
  4723 				if (!arabnIterator.NextCharInto(aOldText, i))
       
  4724 					break;
       
  4725 				if (!euronIterator.NextCharInto(aOldText, i))
       
  4726 					break;
       
  4727 				if (!ltorIterator.NextCharInto(aOldText, i))
       
  4728 					break;
       
  4729 				}
       
  4730 			aOldText.SetLength(i);
       
  4731 
       
  4732 			rretval = TBidirectionalState::ReorderText(aOldText.Ptr(), i, EParaRToL, rText);
       
  4733 			lretval = TBidirectionalState::ReorderText(aOldText.Ptr(), i, EParaLToR, lText);
       
  4734 
       
  4735 			aTest->TEST(lretval == KErrNone); 
       
  4736 			aTest->TEST(rretval == KErrNone); 
       
  4737 #ifdef PRINT_DATA
       
  4738 
       
  4739 			_LIT(KOTitle, "Original");
       
  4740 			_LIT(KLTitle, "Left-to-Right"); 
       
  4741 			_LIT(KRTitle, "Right-to-Left");
       
  4742 			
       
  4743 
       
  4744 			PrintTestData(KOTitle, aOldText);
       
  4745 			PrintTestData(KLTitle, lText, KBufferSize);
       
  4746 			PrintTestData(KRTitle, rText, KBufferSize);
       
  4747 
       
  4748 #endif
       
  4749 		
       
  4750 			aTest->TEST(TextInSameOrder(aOldText.Ptr(), lText, i));
       
  4751 			aTest->TEST(TextInSameOrder(aOldText.Ptr(), rText, i));
       
  4752 
       
  4753 
       
  4754 			DeleteText(aOldText.Ptr(), lText, aTest);
       
  4755 			DeleteText(aOldText.Ptr(), rText, aTest);
       
  4756 
       
  4757 			aOldText.SetLength(oldTextLength);
       
  4758 			}
       
  4759 		}
       
  4760 		
       
  4761 /**
       
  4762  *
       
  4763  * Tests what happens when Arabic and European numbers are surrounded by Left To Right letters
       
  4764  *
       
  4765  * @param	  "TDes& aOldText"
       
  4766  *			  Descriptor that points to a buffer at least KBufferSize 16-bit characters long
       
  4767  *
       
  4768  * @param     "CTGraphicsBase* aTest"
       
  4769  *            Pointer to the test object 
       
  4770  *
       
  4771  */
       
  4772 	static void LToRThenENThenANThenLToRTest(TDes& aOldText, CTGraphicsBase* aTest)
       
  4773 		{
       
  4774 		TText* lText = 0;
       
  4775 		TText* rText = 0;
       
  4776 		TInt lretval = KErrNone;
       
  4777 		TInt rretval = KErrNone;
       
  4778 		TInt oldTextLength = aOldText.Length();
       
  4779 
       
  4780 		// Now mix in some numbers
       
  4781 		 TextIterator ltorIterator(KLeftToRight, KLeftToRightLength);
       
  4782 		 TextIterator euronIterator(KEuropeanNumber, KEuropeanNumberLength);
       
  4783 		 TextIterator arabnIterator(KArabicNumber, KArabicNumberLength);
       
  4784 
       
  4785 		 aTest->TEST(aOldText.Length() >= KBufferSize);
       
  4786 
       
  4787 		 while (!ltorIterator.Wrapped())
       
  4788 			{
       
  4789 			TInt i;
       
  4790 
       
  4791 			for (i = 0 ; i < KBufferSize-3; )
       
  4792 				{
       
  4793 				if (!ltorIterator.NextCharInto(aOldText, i))
       
  4794 					break;
       
  4795 				if (!arabnIterator.NextCharInto(aOldText, i))
       
  4796 					break;
       
  4797 				if (!euronIterator.NextCharInto(aOldText, i))
       
  4798 					break;
       
  4799 				if (!ltorIterator.NextCharInto(aOldText, i))
       
  4800 					break;
       
  4801 				}
       
  4802 			aOldText.SetLength(i);
       
  4803 
       
  4804 
       
  4805 			rretval = TBidirectionalState::ReorderText(aOldText.Ptr(), i, EParaRToL, rText);
       
  4806 			lretval = TBidirectionalState::ReorderText(aOldText.Ptr(), i, EParaLToR, lText);
       
  4807 
       
  4808 
       
  4809 			aTest->TEST(lretval == KErrNone); 
       
  4810 			aTest->TEST(rretval == KErrNone); 
       
  4811 
       
  4812 #ifdef PRINT_DATA
       
  4813 
       
  4814 			_LIT(KOTitle, "Original");
       
  4815 			_LIT(KLTitle, "Left-to-Right"); 
       
  4816 			_LIT(KRTitle, "Right-to-Left");
       
  4817 			
       
  4818 
       
  4819 			PrintTestData(KOTitle, aOldText);
       
  4820 			PrintTestData(KLTitle, lText, KBufferSize);
       
  4821 			PrintTestData(KRTitle, rText, KBufferSize);
       
  4822 
       
  4823 #endif
       
  4824 			aTest->TEST(TextInSameOrder(aOldText.Ptr(), lText, i));
       
  4825 			aTest->TEST(TextInSameOrder(aOldText.Ptr(), rText, i));
       
  4826 
       
  4827 			DeleteText(aOldText.Ptr(), lText, aTest);
       
  4828 			DeleteText(aOldText.Ptr(), rText, aTest);
       
  4829 			
       
  4830 			aOldText.SetLength(oldTextLength);
       
  4831 			}
       
  4832 		}
       
  4833 
       
  4834 /**
       
  4835  *
       
  4836  * Tests what happens when Arabic and European numbers are preceded by Left To Right 
       
  4837  * and succeeded by Right To Left letters
       
  4838  *
       
  4839  * @param	  "TDes& aOldText"
       
  4840  *			  Descriptor that points to a buffer at least KBufferSize 16-bit characters long
       
  4841  *
       
  4842  * @param     "CTGraphicsBase* aTest"
       
  4843  *            Pointer to the test object 
       
  4844  *
       
  4845  */
       
  4846 	static void LToRThenANThenENThenRToLTest(TDes& aOldText, CTGraphicsBase* aTest)
       
  4847 		{
       
  4848 		TText* lText = 0;
       
  4849 		TText* rText = 0;
       
  4850 		TInt lretval = KErrNone;
       
  4851 		TInt rretval = KErrNone;
       
  4852 		TInt oldTextLength = aOldText.Length();
       
  4853 		HBufC *rResult = HBufC::NewLC(KBufferSize);
       
  4854 
       
  4855 		// Now mix in some numbers
       
  4856 		 TextIterator ltorIterator(KLeftToRight, KLeftToRightLength);
       
  4857 		 TextIterator euronIterator(KEuropeanNumber, KEuropeanNumberLength);
       
  4858 		 TextIterator arabnIterator(KArabicNumber, KArabicNumberLength);
       
  4859 		 TextIterator rtolIterator(KRightToLeft, KRightToLeftLength);
       
  4860 
       
  4861 		 aTest->TEST(aOldText.Length() >= KBufferSize);
       
  4862 
       
  4863 		 while (!ltorIterator.Wrapped())
       
  4864 			{
       
  4865 			TInt i;
       
  4866 			TInt lasti = 0;
       
  4867 			TUint ch0, ch1, ch2, ch3;
       
  4868 			for (i = 0 ; i < KBufferSize-3; )
       
  4869 				{
       
  4870 				if (!ltorIterator.NextCharInto(aOldText, i, -1, ETrue, ETrue, &ch0))
       
  4871 					break;
       
  4872 				if (!arabnIterator.NextCharInto(aOldText, i, -1, ETrue, ETrue, &ch1))
       
  4873 					break;
       
  4874 				if (!euronIterator.NextCharInto(aOldText, i, -1, ETrue, ETrue, &ch2))
       
  4875 					break;
       
  4876 				if (!rtolIterator.NextCharInto(aOldText, i, -1, ETrue, ETrue, &ch3))
       
  4877 					break;
       
  4878 				lasti = i;
       
  4879 				AppendCharacter(rResult, ch2);
       
  4880 				AppendCharacter(rResult, ch1);
       
  4881 				AppendCharacter(rResult, ch0);
       
  4882 				AppendCharacter(rResult, ch3);
       
  4883 				}
       
  4884 			i = lasti;
       
  4885 			aOldText.SetLength(i);
       
  4886 			ASSERT(rResult->Des().Length() == i);
       
  4887 
       
  4888 			rretval = TBidirectionalState::ReorderText(aOldText.Ptr(), i, EParaRToL, rText);
       
  4889 			lretval = TBidirectionalState::ReorderText(aOldText.Ptr(), i, EParaLToR, lText);
       
  4890 
       
  4891 			aTest->TEST(lretval == KErrNone); 
       
  4892 			aTest->TEST(rretval == KErrNone); 
       
  4893 
       
  4894 #ifdef PRINT_DATA
       
  4895 
       
  4896 			_LIT(KOTitle, "Original");
       
  4897 			_LIT(KLTitle, "Left-to-Right"); 
       
  4898 			_LIT(KRTitle, "Right-to-Left");
       
  4899 			
       
  4900 
       
  4901 			PrintTestData(KOTitle, aOldText);
       
  4902 			PrintTestData(KLTitle, lText, KBufferSize);
       
  4903 			PrintTestData(KRTitle, rText, KBufferSize);
       
  4904 
       
  4905 #endif
       
  4906 			aTest->TEST(TextInSameOrder(aOldText.Ptr(), lText, i));
       
  4907 			aTest->TEST(TextInReverseOrder(rResult->Ptr(), rText, i, aTest));
       
  4908 
       
  4909 			DeleteText(aOldText.Ptr(), lText, aTest);
       
  4910 			DeleteText(aOldText.Ptr(), rText, aTest);
       
  4911 			
       
  4912 			aOldText.SetLength(oldTextLength);
       
  4913 			rResult->Des().SetLength(0);
       
  4914 			}
       
  4915 		 CleanupStack::PopAndDestroy(rResult);
       
  4916 		}
       
  4917 
       
  4918 /**
       
  4919  *
       
  4920  * Tests what happens when Arabic and European numbers are preceded by Left To Right 
       
  4921  * and succeeded by Right To Left letters
       
  4922  *
       
  4923  * @param	  "TDes& aOldText"
       
  4924  *			  Descriptor that points to a buffer at least KBufferSize 16-bit characters long
       
  4925  *
       
  4926  * @param     "CTGraphicsBase* aTest"
       
  4927  *            Pointer to the test object 
       
  4928  *
       
  4929  */
       
  4930 	static void LToRThenENThenANThenRToLTest(TDes& aOldText, CTGraphicsBase* aTest)
       
  4931 		{
       
  4932 		TText* lText = 0;
       
  4933 		TText* rText = 0;
       
  4934 		TInt lretval = KErrNone;
       
  4935 		TInt rretval = KErrNone;
       
  4936 		TInt oldTextLength = aOldText.Length();
       
  4937 		HBufC *lResult = HBufC::NewLC(KBufferSize);
       
  4938 		HBufC *rResult = HBufC::NewLC(KBufferSize);
       
  4939 
       
  4940 		// Now mix in some numbers
       
  4941 		 TextIterator ltorIterator(KLeftToRight, KLeftToRightLength);
       
  4942 		 TextIterator euronIterator(KEuropeanNumber, KEuropeanNumberLength);
       
  4943 		 TextIterator arabnIterator(KArabicNumber, KArabicNumberLength);
       
  4944 		 TextIterator rtolIterator(KRightToLeft, KRightToLeftLength);
       
  4945 
       
  4946 		 while (!ltorIterator.Wrapped())
       
  4947 			{
       
  4948 			TInt i;
       
  4949 			TInt lasti = 0;
       
  4950 			TUint ch0, ch1, ch2, ch3;
       
  4951 			for (i = 0 ; i < KBufferSize-3; )
       
  4952 				{
       
  4953 				if (!ltorIterator.NextCharInto(aOldText, i, -1, ETrue, ETrue, &ch0))
       
  4954 					break;
       
  4955 				if (!euronIterator.NextCharInto(aOldText, i, -1, ETrue, ETrue, &ch1))
       
  4956 					break;
       
  4957 				if (!arabnIterator.NextCharInto(aOldText, i, -1, ETrue, ETrue, &ch2))
       
  4958 					break;
       
  4959 				if (!rtolIterator.NextCharInto(aOldText, i, -1, ETrue, ETrue, &ch3))
       
  4960 					break;
       
  4961 				
       
  4962 				lasti = i;
       
  4963 				AppendCharacter(lResult, ch0);
       
  4964 				AppendCharacter(lResult, ch1);
       
  4965 				AppendCharacter(lResult, ch3);
       
  4966 				AppendCharacter(lResult, ch2);
       
  4967 				
       
  4968 				AppendCharacter(rResult, ch2);
       
  4969 				AppendCharacter(rResult, ch1);
       
  4970 				AppendCharacter(rResult, ch0);
       
  4971 				AppendCharacter(rResult, ch3);
       
  4972 				}
       
  4973 			i = lasti;
       
  4974 			aOldText.SetLength(i);
       
  4975 			ASSERT(lResult->Des().Length() == i);
       
  4976 			ASSERT(rResult->Des().Length() == i);
       
  4977 
       
  4978 			rretval = TBidirectionalState::ReorderText(aOldText.Ptr(), i, EParaRToL, rText);
       
  4979 			lretval = TBidirectionalState::ReorderText(aOldText.Ptr(), i, EParaLToR, lText);
       
  4980 			aTest->TEST(lretval == KErrNone); 
       
  4981 			aTest->TEST(rretval == KErrNone); 
       
  4982 
       
  4983 #ifdef PRINT_DATA
       
  4984 
       
  4985 			_LIT(KOTitle, "Original");
       
  4986 			_LIT(KLTitle, "Left-to-Right"); 
       
  4987 			_LIT(KRTitle, "Right-to-Left");
       
  4988 			
       
  4989 
       
  4990 			PrintTestData(KOTitle, aOldText);
       
  4991 			PrintTestData(KLTitle, lText, KBufferSize);
       
  4992 			PrintTestData(KRTitle, rText, KBufferSize);
       
  4993 
       
  4994 #endif
       
  4995 			aTest->TEST(TextInSameOrder(lResult->Ptr(), lText, i));
       
  4996 			aTest->TEST(TextInReverseOrder(rResult->Ptr(), rText, i, aTest));
       
  4997 
       
  4998 			DeleteText(aOldText.Ptr(), lText, aTest);
       
  4999 			DeleteText(aOldText.Ptr(), rText, aTest);
       
  5000 			aOldText.SetLength(oldTextLength);
       
  5001 			lResult->Des().SetLength(0);
       
  5002 			rResult->Des().SetLength(0);
       
  5003 			}
       
  5004 		CleanupStack::PopAndDestroy(rResult);
       
  5005 		CleanupStack::PopAndDestroy(lResult);
       
  5006 		}
       
  5007 /**
       
  5008  *
       
  5009  * Tests what happens when Arabic and European numbers are preceded by Left To Right 
       
  5010  * and succeeded by Right To Left Arabic letters
       
  5011  *
       
  5012  * @param	  "TDes& aOldText"
       
  5013  *			  Descriptor that points to a buffer at least KBufferSize 16-bit characters long
       
  5014  *
       
  5015  * @param     "CTGraphicsBase* aTest"
       
  5016  *            Pointer to the test object 
       
  5017  *
       
  5018  */
       
  5019 	static void LToRThenANThenENThenRToLATest(TDes& aOldText, CTGraphicsBase* aTest)
       
  5020 		{
       
  5021 		TText* lText = 0;
       
  5022 		TText* rText = 0;
       
  5023 		TInt lretval = KErrNone;
       
  5024 		TInt rretval = KErrNone;
       
  5025 		TInt oldTextLength = aOldText.Length();
       
  5026 		HBufC *rResult = HBufC::NewLC(KBufferSize);
       
  5027 
       
  5028 		// Now mix in some numbers
       
  5029 		 TextIterator ltorIterator(KLeftToRight, KLeftToRightLength);
       
  5030 		 TextIterator euronIterator(KEuropeanNumber, KEuropeanNumberLength);
       
  5031 		 TextIterator arabnIterator(KArabicNumber, KArabicNumberLength);
       
  5032 		 TextIterator rtolIterator(KRightToLeftArabic, KRightToLeftArabicLength);
       
  5033 
       
  5034 		 aTest->TEST(aOldText.Length() >= KBufferSize);
       
  5035 
       
  5036 		 while (!ltorIterator.Wrapped())
       
  5037 			{
       
  5038 			TInt i;
       
  5039 			TInt lasti = 0;
       
  5040 			TUint ch0, ch1, ch2, ch3;
       
  5041 
       
  5042 			for (i = 0 ; i < KBufferSize-3; )
       
  5043 				{
       
  5044 				if (!ltorIterator.NextCharInto(aOldText, i, -1, ETrue, ETrue, &ch0))
       
  5045 					break;
       
  5046 				if (!arabnIterator.NextCharInto(aOldText, i, -1, ETrue, ETrue, &ch1))
       
  5047 					break;
       
  5048 				if (!euronIterator.NextCharInto(aOldText, i, -1, ETrue, ETrue, &ch2))
       
  5049 					break;
       
  5050 				if (!rtolIterator.NextCharInto(aOldText, i, -1, ETrue, ETrue, &ch3))
       
  5051 					break;
       
  5052 				
       
  5053 				lasti = i;
       
  5054 				AppendCharacter(rResult, ch2);
       
  5055 				AppendCharacter(rResult, ch1);
       
  5056 				AppendCharacter(rResult, ch0);
       
  5057 				AppendCharacter(rResult, ch3);
       
  5058 				}
       
  5059 			i = lasti;
       
  5060 			aOldText.SetLength(i);
       
  5061 			ASSERT(rResult->Des().Length() == i);
       
  5062 
       
  5063 
       
  5064 			rretval = TBidirectionalState::ReorderText(aOldText.Ptr(), i, EParaRToL, rText);
       
  5065 			lretval = TBidirectionalState::ReorderText(aOldText.Ptr(), i, EParaLToR, lText);
       
  5066 
       
  5067 			aTest->TEST(lretval == KErrNone); 
       
  5068 			aTest->TEST(rretval == KErrNone); 
       
  5069 
       
  5070 #ifdef PRINT_DATA
       
  5071 
       
  5072 			_LIT(KOTitleT, "Original (Top)");
       
  5073 			_LIT(KLTitleT, "Left-to-Right (Top)"); 
       
  5074 			_LIT(KRTitleT, "Right-to-Left (Top)");
       
  5075 			_LIT(KOTitleB, "Original (Bottom)");
       
  5076 			_LIT(KLTitleB, "Left-to-Right (Bottom)"); 
       
  5077 			_LIT(KRTitleB, "Right-to-Left (Bottom)");
       
  5078 			
       
  5079 
       
  5080 			PrintTestData(KOTitleT, aOldText.Ptr(), 32);
       
  5081 			PrintTestData(KOTitleB, aOldText.Ptr()+KBufferSize-32, 32);
       
  5082 
       
  5083 			PrintTestData(KLTitleT, lText, 32);
       
  5084 			PrintTestData(KLTitleB, lText+KBufferSize-32, 32);
       
  5085 
       
  5086 			PrintTestData(KRTitleT, rText, 32);
       
  5087 			PrintTestData(KRTitleB, rText+KBufferSize-32, 32);
       
  5088 
       
  5089 #endif
       
  5090 			aTest->TEST(TextInSameOrder(aOldText.Ptr(), lText, i));
       
  5091 			aTest->TEST(TextInReverseOrder(rResult->Ptr(), rText, i, aTest));
       
  5092 
       
  5093 			DeleteText(aOldText.Ptr(), lText, aTest);
       
  5094 			DeleteText(aOldText.Ptr(), rText, aTest);
       
  5095 		
       
  5096 			aOldText.SetLength(oldTextLength);
       
  5097 			rResult->Des().SetLength(0);
       
  5098 			}
       
  5099 		CleanupStack::PopAndDestroy(rResult);
       
  5100 		}
       
  5101 /**
       
  5102  *
       
  5103  * Tests what happens when Arabic and European numbers are preceded by Left To Right 
       
  5104  * and succeeded by Right To Left Arabic letters
       
  5105  *
       
  5106  * @param	  "TDes& aOldText"
       
  5107  *			  Descriptor that points to a buffer at least KBufferSize 16-bit characters long
       
  5108  *
       
  5109  * @param     "CTGraphicsBase* aTest"
       
  5110  *            Pointer to the test object 
       
  5111  *
       
  5112  */
       
  5113 	static void LToRThenENThenANThenRToLATest(TDes& aOldText, CTGraphicsBase* aTest)
       
  5114 		{
       
  5115 		TText* lText = 0;
       
  5116 		TText* rText = 0;
       
  5117 		TInt lretval = KErrNone;
       
  5118 		TInt rretval = KErrNone;
       
  5119 		TInt oldTextLength = aOldText.Length();
       
  5120 		HBufC *lResult = HBufC::NewLC(KBufferSize);
       
  5121 		HBufC *rResult = HBufC::NewLC(KBufferSize);
       
  5122 
       
  5123 		// Now mix in some numbers
       
  5124 		 TextIterator ltorIterator(KLeftToRight, KLeftToRightLength);
       
  5125 		 TextIterator euronIterator(KEuropeanNumber, KEuropeanNumberLength);
       
  5126 		 TextIterator arabnIterator(KArabicNumber, KArabicNumberLength);
       
  5127 		 TextIterator rtolIterator(KRightToLeftArabic, KRightToLeftArabicLength);
       
  5128 
       
  5129 		 while (!ltorIterator.Wrapped())
       
  5130 			{
       
  5131 			TInt i;
       
  5132 			TInt lasti = 0;
       
  5133 			TUint ch0, ch1, ch2, ch3;
       
  5134 			for (i = 0 ; i < KBufferSize-3; )
       
  5135 				{
       
  5136 				if (!ltorIterator.NextCharInto(aOldText, i, -1, ETrue, ETrue, &ch0))
       
  5137 					break;
       
  5138 				if (!euronIterator.NextCharInto(aOldText, i, -1, ETrue, ETrue, &ch1))
       
  5139 					break;
       
  5140 				if (!arabnIterator.NextCharInto(aOldText, i, -1, ETrue, ETrue, &ch2))
       
  5141 					break;
       
  5142 				if (!rtolIterator.NextCharInto(aOldText, i, -1, ETrue, ETrue, &ch3))
       
  5143 					break;
       
  5144 				
       
  5145 				lasti = i;
       
  5146 				AppendCharacter(lResult, ch0);
       
  5147 				AppendCharacter(lResult, ch1);
       
  5148 				AppendCharacter(lResult, ch3);
       
  5149 				AppendCharacter(lResult, ch2);
       
  5150 				
       
  5151 				AppendCharacter(rResult, ch2);
       
  5152 				AppendCharacter(rResult, ch1);
       
  5153 				AppendCharacter(rResult, ch0);
       
  5154 				AppendCharacter(rResult, ch3);
       
  5155 				}
       
  5156 			i = lasti;
       
  5157 			aOldText.SetLength(i);
       
  5158 			ASSERT(lResult->Des().Length() == i);
       
  5159 			ASSERT(rResult->Des().Length() == i);
       
  5160 
       
  5161 			rretval = TBidirectionalState::ReorderText(aOldText.Ptr(), i, EParaRToL, rText);
       
  5162 			lretval = TBidirectionalState::ReorderText(aOldText.Ptr(), i, EParaLToR, lText);
       
  5163 
       
  5164 			aTest->TEST(lretval == KErrNone); 
       
  5165 			aTest->TEST(rretval == KErrNone); 
       
  5166 
       
  5167 #ifdef PRINT_DATA
       
  5168 			_LIT(KOTitleT, "Original (Top)");
       
  5169 			_LIT(KLTitleT, "Left-to-Right (Top)"); 
       
  5170 			_LIT(KRTitleT, "Right-to-Left (Top)");
       
  5171 			_LIT(KOTitleB, "Original (Bottom)");
       
  5172 			_LIT(KLTitleB, "Left-to-Right (Bottom)"); 
       
  5173 			_LIT(KRTitleB, "Right-to-Left (Bottom)");
       
  5174 			
       
  5175 
       
  5176 			PrintTestData(KOTitleT, aOldText.Ptr(), 32);
       
  5177 			PrintTestData(KOTitleB, aOldText.Ptr()+KBufferSize-32, 32);
       
  5178 
       
  5179 			PrintTestData(KLTitleT, lText, 32);
       
  5180 			PrintTestData(KLTitleB, lText+KBufferSize-32, 32);
       
  5181 
       
  5182 			PrintTestData(KRTitleT, rText, 32);
       
  5183 			PrintTestData(KRTitleB, rText+KBufferSize-32, 32);
       
  5184 
       
  5185 #endif
       
  5186 			aTest->TEST(TextInSameOrder(lResult->Ptr(), lText, i));
       
  5187 			aTest->TEST(TextInReverseOrder(rResult->Ptr(), rText, i, aTest));
       
  5188 
       
  5189 			DeleteText(aOldText.Ptr(), lText, aTest);
       
  5190 			DeleteText(aOldText.Ptr(), rText, aTest);
       
  5191 			
       
  5192 			aOldText.SetLength(oldTextLength);
       
  5193 			lResult->Des().SetLength(0);
       
  5194 			rResult->Des().SetLength(0);
       
  5195 			}
       
  5196 		CleanupStack::PopAndDestroy(rResult);
       
  5197 		CleanupStack::PopAndDestroy(lResult);
       
  5198 		}
       
  5199 /**
       
  5200  *
       
  5201  * Tests what happens when Arabic and European numbers are preceded by Right to Left
       
  5202  * and succeeded by Left To Right letters
       
  5203  *
       
  5204  * @param	  "TDes& aOldText"
       
  5205  *			  Descriptor that points to a buffer at least KBufferSize 16-bit characters long
       
  5206  *
       
  5207  * @param     "CTGraphicsBase* aTest"
       
  5208  *            Pointer to the test object 
       
  5209  *
       
  5210  */
       
  5211 	static void RToLThenANThenENThenLToRTest(TDes& aOldText, CTGraphicsBase* aTest)
       
  5212 		{
       
  5213 		TText* lText = 0;
       
  5214 		TText* rText = 0;
       
  5215 		TInt lretval = KErrNone;
       
  5216 		TInt rretval = KErrNone;
       
  5217 		TInt oldTextLength = aOldText.Length();
       
  5218 		HBufC *lResult = HBufC::NewLC(KBufferSize);
       
  5219 		HBufC *rResult = HBufC::NewLC(KBufferSize);
       
  5220 
       
  5221 		aTest->INFO_PRINTF1(_L("TBidirectionalState test - R-L AN EN L-R test\r\n"));
       
  5222 		
       
  5223 		// Now mix in some numbers
       
  5224 		 TextIterator rtolIterator(KRightToLeft, KRightToLeftLength);
       
  5225 		 TextIterator euronIterator(KEuropeanNumber, KEuropeanNumberLength);
       
  5226 		 TextIterator arabnIterator(KArabicNumber, KArabicNumberLength);
       
  5227 		 TextIterator ltorIterator(KLeftToRight, KLeftToRightLength);
       
  5228 
       
  5229 		 while (!ltorIterator.Wrapped())
       
  5230 			{
       
  5231 			TInt i;
       
  5232 			TInt lasti = 0;
       
  5233 			TUint ch0, ch1, ch2, ch3;
       
  5234 			for (i = 0 ; i < KBufferSize-3; )
       
  5235 				{
       
  5236 				if (!rtolIterator.NextCharInto(aOldText, i, -1, ETrue, ETrue, &ch0))
       
  5237 					break;
       
  5238 				if (!arabnIterator.NextCharInto(aOldText, i, -1, ETrue, ETrue, &ch1))
       
  5239 					break;
       
  5240 				if (!euronIterator.NextCharInto(aOldText, i, -1, ETrue, ETrue, &ch2))
       
  5241 					break;
       
  5242 				if (!ltorIterator.NextCharInto(aOldText, i, -1, ETrue, ETrue, &ch3))
       
  5243 					break;
       
  5244 				
       
  5245 				lasti = i;
       
  5246 				AppendCharacter(lResult, ch1);
       
  5247 				AppendCharacter(lResult, ch2);
       
  5248 				AppendCharacter(lResult, ch0);
       
  5249 				AppendCharacter(lResult, ch3);
       
  5250 				
       
  5251 				AppendCharacter(rResult, ch0);
       
  5252 				AppendCharacter(rResult, ch3);
       
  5253 				AppendCharacter(rResult, ch2);
       
  5254 				AppendCharacter(rResult, ch1);
       
  5255 				}
       
  5256 			i = lasti;
       
  5257 			aOldText.SetLength(i);
       
  5258 			ASSERT(lResult->Des().Length() == i);
       
  5259 			ASSERT(rResult->Des().Length() == i);
       
  5260 
       
  5261 			rretval = TBidirectionalState::ReorderText(aOldText.Ptr(), i, EParaRToL, rText);
       
  5262 			lretval = TBidirectionalState::ReorderText(aOldText.Ptr(), i, EParaLToR, lText);
       
  5263 			aTest->TEST(lretval == KErrNone); 
       
  5264 			aTest->TEST(rretval == KErrNone); 
       
  5265 #ifdef PRINT_DATA
       
  5266 			_LIT(KOTitleT, "Original (Top)");
       
  5267 			_LIT(KLTitleT, "Left-to-Right (Top)"); 
       
  5268 			_LIT(KRTitleT, "Right-to-Left (Top)");
       
  5269 			_LIT(KOTitleB, "Original (Bottom)");
       
  5270 			_LIT(KLTitleB, "Left-to-Right (Bottom)"); 
       
  5271 			_LIT(KRTitleB, "Right-to-Left (Bottom)");
       
  5272 			
       
  5273 
       
  5274 			PrintTestData(KOTitleT, aOldText.Ptr(), 32);
       
  5275 			PrintTestData(KOTitleB, aOldText.Ptr()+KBufferSize-32, 32);
       
  5276 
       
  5277 			PrintTestData(KLTitleT, lText, 32);
       
  5278 			PrintTestData(KLTitleB, lText+KBufferSize-32, 32);
       
  5279 
       
  5280 			PrintTestData(KRTitleT, rText, 32);
       
  5281 			PrintTestData(KRTitleB, rText+KBufferSize-32, 32);
       
  5282 
       
  5283 #endif
       
  5284 		
       
  5285 			aTest->TEST(TextInSameOrder(lResult->Ptr(), lText, i));
       
  5286 			aTest->TEST(TextInReverseOrder(rResult->Ptr(), rText, i, aTest));
       
  5287 
       
  5288 			DeleteText(aOldText.Ptr(), lText, aTest);
       
  5289 			DeleteText(aOldText.Ptr(), rText, aTest);
       
  5290 
       
  5291 			aOldText.SetLength(oldTextLength);
       
  5292 			lResult->Des().SetLength(0);
       
  5293 			rResult->Des().SetLength(0);
       
  5294 			}
       
  5295 		CleanupStack::PopAndDestroy(rResult);
       
  5296 		CleanupStack::PopAndDestroy(lResult);
       
  5297 		}
       
  5298 
       
  5299 /**
       
  5300  *
       
  5301  * Tests what happens when Arabic and European numbers are preceded by Right to Left
       
  5302  * and succeeded by Left To Right letters
       
  5303  *
       
  5304  * @param	  "TDes& aOldText"
       
  5305  *			  Descriptor that points to a buffer at least KBufferSize 16-bit characters long
       
  5306  *
       
  5307  * @param     "CTGraphicsBase* aTest"
       
  5308  *            Pointer to the test object 
       
  5309  *
       
  5310  */
       
  5311 	static void RToLThenENThenANThenLToRTest(TDes& aOldText, CTGraphicsBase* aTest)
       
  5312 		{
       
  5313 		TText* lText = 0;
       
  5314 		TText* rText = 0;
       
  5315 		TInt lretval = KErrNone;
       
  5316 		TInt rretval = KErrNone;
       
  5317 		TInt oldTextLength = aOldText.Length();
       
  5318 		HBufC *lResult = HBufC::NewLC(KBufferSize);
       
  5319 		HBufC *rResult = HBufC::NewLC(KBufferSize);
       
  5320 
       
  5321 		aTest->INFO_PRINTF1(_L("TBidirectionalState test - R-L EN AN L-R test\r\n"));
       
  5322 		
       
  5323 		// Now mix in some numbers
       
  5324 		 TextIterator rtolIterator(KRightToLeft, KRightToLeftLength);
       
  5325 		 TextIterator euronIterator(KEuropeanNumber, KEuropeanNumberLength);
       
  5326 		 TextIterator arabnIterator(KArabicNumber, KArabicNumberLength);
       
  5327 		 TextIterator ltorIterator(KLeftToRight, KLeftToRightLength);
       
  5328 
       
  5329 		 while (!ltorIterator.Wrapped())
       
  5330 			{
       
  5331 			TInt i;
       
  5332 			TInt lasti = 0;
       
  5333 			TUint ch0, ch1, ch2, ch3;
       
  5334 			for (i = 0 ; i < KBufferSize-3; )
       
  5335 				{
       
  5336 				if (!rtolIterator.NextCharInto(aOldText, i, -1, ETrue, ETrue, &ch0))
       
  5337 					break;
       
  5338 				if (!euronIterator.NextCharInto(aOldText, i, -1, ETrue, ETrue, &ch1))
       
  5339 					break;
       
  5340 				if (!arabnIterator.NextCharInto(aOldText, i, -1, ETrue, ETrue, &ch2))
       
  5341 					break;
       
  5342 				if (!ltorIterator.NextCharInto(aOldText, i, -1, ETrue, ETrue, &ch3))
       
  5343 					break;
       
  5344 				
       
  5345 				lasti = i;
       
  5346 				AppendCharacter(lResult, ch1);
       
  5347 				AppendCharacter(lResult, ch2);
       
  5348 				AppendCharacter(lResult, ch0);
       
  5349 				AppendCharacter(lResult, ch3);
       
  5350 				
       
  5351 				AppendCharacter(rResult, ch0);
       
  5352 				AppendCharacter(rResult, ch3);
       
  5353 				AppendCharacter(rResult, ch2);
       
  5354 				AppendCharacter(rResult, ch1);
       
  5355 				}
       
  5356 			i = lasti;
       
  5357 			aOldText.SetLength(i);
       
  5358 			ASSERT(lResult->Des().Length() == i);
       
  5359 			ASSERT(rResult->Des().Length() == i);
       
  5360 
       
  5361 
       
  5362 			rretval = TBidirectionalState::ReorderText(aOldText.Ptr(), i, EParaRToL, rText);
       
  5363 			lretval = TBidirectionalState::ReorderText(aOldText.Ptr(), i, EParaLToR, lText);
       
  5364 
       
  5365 			aTest->TEST(lretval == KErrNone); 
       
  5366 			aTest->TEST(rretval == KErrNone); 
       
  5367 #ifdef PRINT_DATA
       
  5368 			_LIT(KOTitleT, "Original (Top)");
       
  5369 			_LIT(KLTitleT, "Left-to-Right (Top)"); 
       
  5370 			_LIT(KRTitleT, "Right-to-Left (Top)");
       
  5371 			_LIT(KOTitleB, "Original (Bottom)");
       
  5372 			_LIT(KLTitleB, "Left-to-Right (Bottom)"); 
       
  5373 			_LIT(KRTitleB, "Right-to-Left (Bottom)");
       
  5374 			
       
  5375 
       
  5376 			PrintTestData(KOTitleT, aOldText.Ptr(), 32);
       
  5377 			PrintTestData(KOTitleB, aOldText.Ptr()+KBufferSize-32, 32);
       
  5378 
       
  5379 			PrintTestData(KLTitleT, lText, 32);
       
  5380 			PrintTestData(KLTitleB, lText+KBufferSize-32, 32);
       
  5381 
       
  5382 			PrintTestData(KRTitleT, rText, 32);
       
  5383 			PrintTestData(KRTitleB, rText+KBufferSize-32, 32);
       
  5384 
       
  5385 #endif
       
  5386 		
       
  5387 			aTest->TEST(TextInSameOrder(lResult->Ptr(), lText, i));
       
  5388 			aTest->TEST(TextInReverseOrder(rResult->Ptr(), rText, i, aTest));
       
  5389 
       
  5390 			DeleteText(aOldText.Ptr(), lText, aTest);
       
  5391 			DeleteText(aOldText.Ptr(), rText, aTest);
       
  5392 
       
  5393 			aOldText.SetLength(oldTextLength);
       
  5394 			lResult->Des().SetLength(0);
       
  5395 			rResult->Des().SetLength(0);
       
  5396 			}
       
  5397 		CleanupStack::PopAndDestroy(rResult);
       
  5398 		CleanupStack::PopAndDestroy(lResult);
       
  5399 		}
       
  5400 /**
       
  5401  *
       
  5402  * Tests what happens when Arabic and European numbers are preceded by Right to Left Arabic
       
  5403  * and succeeded by Left To Right letters
       
  5404  *
       
  5405  * @param	  "TDes& aOldText"
       
  5406  *			  Descriptor that points to a buffer at least KBufferSize 16-bit characters long
       
  5407  *
       
  5408  * @param     "CTGraphicsBase* aTest"
       
  5409  *            Pointer to the test object 
       
  5410  *
       
  5411  */
       
  5412 	static void RToLAThenANThenENThenLToRTest(TDes& aOldText, CTGraphicsBase* aTest)
       
  5413 		{
       
  5414 		TText* lText = 0;
       
  5415 		TText* rText = 0;
       
  5416 		TInt lretval = KErrNone;
       
  5417 		TInt rretval = KErrNone;
       
  5418 		TInt oldTextLength = aOldText.Length();
       
  5419 		HBufC *lResult = HBufC::NewLC(KBufferSize);
       
  5420 		HBufC *rResult = HBufC::NewLC(KBufferSize);
       
  5421 
       
  5422 		aTest->INFO_PRINTF1(_L("TBidirectionalState test - R-LA AN EN L-R test\r\n"));
       
  5423 		
       
  5424 		// Now mix in some numbers
       
  5425 		 TextIterator rtolIterator(KRightToLeftArabic, KRightToLeftArabicLength);
       
  5426 		 TextIterator euronIterator(KEuropeanNumber, KEuropeanNumberLength);
       
  5427 		 TextIterator arabnIterator(KArabicNumber, KArabicNumberLength);
       
  5428 		 TextIterator ltorIterator(KLeftToRight, KLeftToRightLength);
       
  5429 
       
  5430 		 while (!ltorIterator.Wrapped())
       
  5431 			{
       
  5432 			TInt i;
       
  5433 			TInt lasti = 0;
       
  5434 			TUint ch0, ch1, ch2, ch3;
       
  5435 			for (i = 0 ; i < KBufferSize-3; )
       
  5436 				{
       
  5437 				if (!rtolIterator.NextCharInto(aOldText, i, -1, ETrue, ETrue, &ch0))
       
  5438 					break;
       
  5439 				if (!arabnIterator.NextCharInto(aOldText, i, -1, ETrue, ETrue, &ch1))
       
  5440 					break;
       
  5441 				if (!euronIterator.NextCharInto(aOldText, i, -1, ETrue, ETrue, &ch2))
       
  5442 					break;
       
  5443 				if (!ltorIterator.NextCharInto(aOldText, i, -1, ETrue, ETrue, &ch3))
       
  5444 					break;
       
  5445 				
       
  5446 				lasti = i;
       
  5447 				AppendCharacter(lResult, ch1);
       
  5448 				AppendCharacter(lResult, ch2);
       
  5449 				AppendCharacter(lResult, ch0);
       
  5450 				AppendCharacter(lResult, ch3);
       
  5451 				
       
  5452 				AppendCharacter(rResult, ch0);
       
  5453 				AppendCharacter(rResult, ch3);
       
  5454 				AppendCharacter(rResult, ch2);
       
  5455 				AppendCharacter(rResult, ch1);
       
  5456 				}
       
  5457 			i = lasti;
       
  5458 			aOldText.SetLength(i);
       
  5459 			ASSERT(lResult->Des().Length() == i);
       
  5460 			ASSERT(rResult->Des().Length() == i);
       
  5461 
       
  5462 			rretval = TBidirectionalState::ReorderText(aOldText.Ptr(), i, EParaRToL, rText);
       
  5463 			lretval = TBidirectionalState::ReorderText(aOldText.Ptr(), i, EParaLToR, lText);
       
  5464 
       
  5465 			aTest->TEST(lretval == KErrNone); 
       
  5466 			aTest->TEST(rretval == KErrNone); 
       
  5467 #ifdef PRINT_DATA
       
  5468 			_LIT(KOTitleT, "Original (Top)");
       
  5469 			_LIT(KLTitleT, "Left-to-Right (Top)"); 
       
  5470 			_LIT(KRTitleT, "Right-to-Left (Top)");
       
  5471 			_LIT(KOTitleB, "Original (Bottom)");
       
  5472 			_LIT(KLTitleB, "Left-to-Right (Bottom)"); 
       
  5473 			_LIT(KRTitleB, "Right-to-Left (Bottom)");
       
  5474 			
       
  5475 
       
  5476 			PrintTestData(KOTitleT, aOldText.Ptr(), 32);
       
  5477 			PrintTestData(KOTitleB, aOldText.Ptr()+KBufferSize-32, 32);
       
  5478 
       
  5479 			PrintTestData(KLTitleT, lText, 32);
       
  5480 			PrintTestData(KLTitleB, lText+KBufferSize-32, 32);
       
  5481 
       
  5482 			PrintTestData(KRTitleT, rText, 32);
       
  5483 			PrintTestData(KRTitleB, rText+KBufferSize-32, 32);
       
  5484 
       
  5485 #endif
       
  5486 		
       
  5487 			aTest->TEST(TextInSameOrder(lResult->Ptr(), lText, i));
       
  5488 			aTest->TEST(TextInReverseOrder(rResult->Ptr(), rText, i, aTest));
       
  5489 
       
  5490 			DeleteText(aOldText.Ptr(), lText, aTest);
       
  5491 			DeleteText(aOldText.Ptr(), rText, aTest);
       
  5492 
       
  5493 			aOldText.SetLength(oldTextLength);
       
  5494 			lResult->Des().SetLength(0);
       
  5495 			rResult->Des().SetLength(0);
       
  5496 			}
       
  5497 		CleanupStack::PopAndDestroy(rResult);
       
  5498 		CleanupStack::PopAndDestroy(lResult);
       
  5499 		}
       
  5500 
       
  5501 /**
       
  5502  *
       
  5503  * Tests what happens when Arabic and European numbers are preceded by Right to Left Arabic
       
  5504  * and succeeded by Left To Right letters
       
  5505  *
       
  5506  * @param	  "TDes& aOldText"
       
  5507  *			  Descriptor that points to a buffer at least KBufferSize 16-bit characters long
       
  5508  *
       
  5509  * @param     "CTGraphicsBase* aTest"
       
  5510  *            Pointer to the test object 
       
  5511  *
       
  5512  */
       
  5513 	static void RToLAThenENThenANThenLToRTest(TDes& aOldText, CTGraphicsBase* aTest)
       
  5514 		{
       
  5515 		TText* lText = 0;
       
  5516 		TText* rText = 0;
       
  5517 		TInt lretval = KErrNone;
       
  5518 		TInt rretval = KErrNone;
       
  5519 		TInt oldTextLength = aOldText.Length();
       
  5520 		HBufC *lResult = HBufC::NewLC(KBufferSize);
       
  5521 		HBufC *rResult = HBufC::NewLC(KBufferSize);
       
  5522 
       
  5523 		aTest->INFO_PRINTF1(_L("TBidirectionalState test - R-LA EN AN L-R test\r\n"));
       
  5524 		
       
  5525 		// Now mix in some numbers
       
  5526 		 TextIterator rtolIterator(KRightToLeftArabic, KRightToLeftArabicLength);
       
  5527 		 TextIterator euronIterator(KEuropeanNumber, KEuropeanNumberLength);
       
  5528 		 TextIterator arabnIterator(KArabicNumber, KArabicNumberLength);
       
  5529 		 TextIterator ltorIterator(KLeftToRight, KLeftToRightLength);
       
  5530 
       
  5531 		 while (!ltorIterator.Wrapped())
       
  5532 			{
       
  5533 			TInt i;
       
  5534 			TInt lasti = 0;
       
  5535 			TUint ch0, ch1, ch2, ch3;
       
  5536 			for (i = 0 ; i < KBufferSize-3; )
       
  5537 				{
       
  5538 				if (!rtolIterator.NextCharInto(aOldText, i, -1, ETrue, ETrue, &ch0))
       
  5539 					break;
       
  5540 				if (!euronIterator.NextCharInto(aOldText, i, -1, ETrue, ETrue, &ch1))
       
  5541 					break;
       
  5542 				if (!arabnIterator.NextCharInto(aOldText, i, -1, ETrue, ETrue, &ch2))
       
  5543 					break;
       
  5544 				if (!ltorIterator.NextCharInto(aOldText, i, -1, ETrue, ETrue, &ch3))
       
  5545 					break;
       
  5546 				
       
  5547 				lasti = i;
       
  5548 				AppendCharacter(lResult, ch1);
       
  5549 				AppendCharacter(lResult, ch2);
       
  5550 				AppendCharacter(lResult, ch0);
       
  5551 				AppendCharacter(lResult, ch3);
       
  5552 				
       
  5553 				AppendCharacter(rResult, ch0);
       
  5554 				AppendCharacter(rResult, ch3);
       
  5555 				AppendCharacter(rResult, ch2);
       
  5556 				AppendCharacter(rResult, ch1);
       
  5557 				}
       
  5558 			i = lasti;
       
  5559 			aOldText.SetLength(i);
       
  5560 			ASSERT(lResult->Des().Length() == i);
       
  5561 			ASSERT(rResult->Des().Length() == i);
       
  5562 
       
  5563 			rretval = TBidirectionalState::ReorderText(aOldText.Ptr(), i, EParaRToL, rText);
       
  5564 			lretval = TBidirectionalState::ReorderText(aOldText.Ptr(), i, EParaLToR, lText);
       
  5565 
       
  5566 			aTest->TEST(lretval == KErrNone); 
       
  5567 			aTest->TEST(rretval == KErrNone); 
       
  5568 #ifdef PRINT_DATA
       
  5569 			_LIT(KOTitleT, "Original (Top)");
       
  5570 			_LIT(KLTitleT, "Left-to-Right (Top)"); 
       
  5571 			_LIT(KRTitleT, "Right-to-Left (Top)");
       
  5572 			_LIT(KOTitleB, "Original (Bottom)");
       
  5573 			_LIT(KLTitleB, "Left-to-Right (Bottom)"); 
       
  5574 			_LIT(KRTitleB, "Right-to-Left (Bottom)");
       
  5575 			
       
  5576 
       
  5577 			PrintTestData(KOTitleT, aOldText.Ptr(), 32);
       
  5578 			PrintTestData(KOTitleB, aOldText.Ptr()+KBufferSize-32, 32);
       
  5579 
       
  5580 			PrintTestData(KLTitleT, lText, 32);
       
  5581 			PrintTestData(KLTitleB, lText+KBufferSize-32, 32);
       
  5582 
       
  5583 			PrintTestData(KRTitleT, rText, 32);
       
  5584 			PrintTestData(KRTitleB, rText+KBufferSize-32, 32);
       
  5585 
       
  5586 #endif
       
  5587 		
       
  5588 			aTest->TEST(TextInSameOrder(lResult->Ptr(), lText, i));
       
  5589 			aTest->TEST(TextInReverseOrder(rResult->Ptr(), rText, i, aTest));
       
  5590 
       
  5591 			DeleteText(aOldText.Ptr(), lText, aTest);
       
  5592 			DeleteText(aOldText.Ptr(), rText, aTest);
       
  5593 
       
  5594 			aOldText.SetLength(oldTextLength);
       
  5595 			lResult->Des().SetLength(0);
       
  5596 			rResult->Des().SetLength(0);
       
  5597 			}
       
  5598 		CleanupStack::PopAndDestroy(rResult);
       
  5599 		CleanupStack::PopAndDestroy(lResult);
       
  5600 		}
       
  5601 
       
  5602 /**
       
  5603  *
       
  5604  * Tests what happens to European Terminators in a pair of European Numbers 
       
  5605  * when the first character is a Right To Left letter
       
  5606  *
       
  5607  * @param	  "TDes& aOldText"
       
  5608  *			  Descriptor that points to a buffer at least KBufferSize 16-bit characters long
       
  5609  *
       
  5610  * @param     "CTGraphicsBase* aTest"
       
  5611  *            Pointer to the test object 
       
  5612  *
       
  5613  */
       
  5614 	static void RToLThenENThenETThenENTest(TDes& aOldText, CTGraphicsBase* aTest)
       
  5615 		{
       
  5616 		TText* lText = 0;
       
  5617 		TText* rText = 0;
       
  5618 		TInt lretval = KErrNone;
       
  5619 		TInt rretval = KErrNone;
       
  5620 		TInt oldTextLength = aOldText.Length();
       
  5621 		HBufC *lResult = HBufC::NewLC(KBufferSize);
       
  5622 		HBufC *rResult = HBufC::NewLC(KBufferSize);
       
  5623 
       
  5624 		aTest->INFO_PRINTF1(_L("TBidirectionalState test - R-L EN ET EN test\r\n"));
       
  5625 		
       
  5626 		// Now mix in some numbers
       
  5627 		 TextIterator rtolIterator(KRightToLeft, KRightToLeftLength);
       
  5628 		 TextIterator euronIterator(KEuropeanNumber, KEuropeanNumberLength);
       
  5629 		 TextIterator eurotIterator(KEuropeanNumberTerminator, KEuropeanNumberTerminatorLength);
       
  5630 
       
  5631 		 while(!rtolIterator.Wrapped())
       
  5632 			{
       
  5633 			TInt i;
       
  5634 			TInt lasti = 0;
       
  5635 			TUint ch0, ch1, ch2, ch3;
       
  5636 			for (i = 0 ; i < KBufferSize-3; )
       
  5637 				{
       
  5638 				if (!rtolIterator.NextCharInto(aOldText, i, -1, ETrue, ETrue, &ch0))
       
  5639 					break;
       
  5640 				if (!euronIterator.NextCharInto(aOldText, i, -1, ETrue, ETrue, &ch1))
       
  5641 					break;
       
  5642 				if (!eurotIterator.NextCharInto(aOldText, i, -1, ETrue, ETrue, &ch2))
       
  5643 					break;
       
  5644 				if (!euronIterator.NextCharInto(aOldText, i, -1, ETrue, ETrue, &ch3))
       
  5645 					break;
       
  5646 				
       
  5647 				lasti = i;
       
  5648 				AppendCharacter(lResult, ch0);
       
  5649 				AppendCharacter(lResult, ch3);
       
  5650 				AppendCharacter(lResult, ch2);
       
  5651 				AppendCharacter(lResult, ch1);
       
  5652 				
       
  5653 				AppendCharacter(rResult, ch0);
       
  5654 				AppendCharacter(rResult, ch3);
       
  5655 				AppendCharacter(rResult, ch2);
       
  5656 				AppendCharacter(rResult, ch1);
       
  5657 				}
       
  5658 			i = lasti;
       
  5659 			aOldText.SetLength(i);
       
  5660 			ASSERT(lResult->Des().Length() == i);
       
  5661 			ASSERT(rResult->Des().Length() == i);
       
  5662 
       
  5663 			rretval = TBidirectionalState::ReorderText(aOldText.Ptr(), i, EParaRToL, rText);
       
  5664 			lretval = TBidirectionalState::ReorderText(aOldText.Ptr(), i, EParaLToR, lText);
       
  5665 
       
  5666 			aTest->TEST(lretval == KErrNone); 
       
  5667 			aTest->TEST(rretval == KErrNone); 
       
  5668 #ifdef PRINT_DATA
       
  5669 			_LIT(KOTitleT, "Original (Top)");
       
  5670 			_LIT(KLTitleT, "Left-to-Right (Top)"); 
       
  5671 			_LIT(KRTitleT, "Right-to-Left (Top)");
       
  5672 			_LIT(KOTitleB, "Original (Bottom)");
       
  5673 			_LIT(KLTitleB, "Left-to-Right (Bottom)"); 
       
  5674 			_LIT(KRTitleB, "Right-to-Left (Bottom)");
       
  5675 			
       
  5676 
       
  5677 			PrintTestData(KOTitleT, aOldText.Ptr(), 32);
       
  5678 			PrintTestData(KOTitleB, aOldText.Ptr()+KBufferSize-32, 32);
       
  5679 
       
  5680 			PrintTestData(KLTitleT, lText, 32);
       
  5681 			PrintTestData(KLTitleB, lText+KBufferSize-32, 32);
       
  5682 
       
  5683 			PrintTestData(KRTitleT, rText, 32);
       
  5684 			PrintTestData(KRTitleB, rText+KBufferSize-32, 32);
       
  5685 
       
  5686 #endif
       
  5687 			aTest->TEST(TextInReverseOrder(lResult->Ptr(), lText, i));
       
  5688 			aTest->TEST(TextInReverseOrder(rResult->Ptr(), rText, i, aTest));
       
  5689 
       
  5690 			DeleteText(aOldText.Ptr(), lText, aTest);
       
  5691 			DeleteText(aOldText.Ptr(), rText, aTest);
       
  5692 
       
  5693 			aOldText.SetLength(oldTextLength);
       
  5694 			lResult->Des().SetLength(0);
       
  5695 			rResult->Des().SetLength(0);
       
  5696 			}
       
  5697 		CleanupStack::PopAndDestroy(rResult);
       
  5698 		CleanupStack::PopAndDestroy(lResult);
       
  5699 		}
       
  5700 /**
       
  5701  *
       
  5702  * Tests what happens to European Terminators in a pair of Arabic Numbers 
       
  5703  * when the first character is a Right To Left letter
       
  5704  *
       
  5705  * @param	  "TDes& aOldText"
       
  5706  *			  Descriptor that points to a buffer at least KBufferSize 16-bit characters long
       
  5707  *
       
  5708  * @param     "CTGraphicsBase* aTest"
       
  5709  *            Pointer to the test object 
       
  5710  *
       
  5711  */
       
  5712 	static void RToLThenANThenETThenANTest(TDes& aOldText, CTGraphicsBase *aTest)
       
  5713 		{
       
  5714 		TText* lText = 0;
       
  5715 		TText* rText = 0;
       
  5716 		TInt lretval = KErrNone;
       
  5717 		TInt rretval = KErrNone;
       
  5718 		TInt oldTextLength = aOldText.Length();
       
  5719 
       
  5720 		aTest->INFO_PRINTF1(_L("TBidirectionalState test - R-L AN ET AN test\r\n"));
       
  5721 		
       
  5722 		// Now mix in some numbers
       
  5723 		 TextIterator rtolIterator(KRightToLeft, KRightToLeftLength);
       
  5724 		 TextIterator arabnIterator(KArabicNumber, KArabicNumberLength);
       
  5725 		 TextIterator eurotIterator(KEuropeanNumberTerminator, KEuropeanNumberTerminatorLength);
       
  5726 
       
  5727 		 aTest->TEST(aOldText.Length() >= KBufferSize);
       
  5728 
       
  5729 		 while(!rtolIterator.Wrapped())
       
  5730 			{
       
  5731 			TInt i;
       
  5732 			for (i = 0 ; i < KBufferSize-3; )
       
  5733 				{
       
  5734 				if (!rtolIterator.NextCharInto(aOldText, i))
       
  5735 					break;
       
  5736 				if (!arabnIterator.NextCharInto(aOldText, i))
       
  5737 					break;
       
  5738 				if (!eurotIterator.NextCharInto(aOldText, i))
       
  5739 					break;
       
  5740 				if (!arabnIterator.NextCharInto(aOldText, i))
       
  5741 					break;
       
  5742 				}
       
  5743 			aOldText.SetLength(i);
       
  5744 
       
  5745 			rretval = TBidirectionalState::ReorderText(aOldText.Ptr(), i, EParaRToL, rText);
       
  5746 			lretval = TBidirectionalState::ReorderText(aOldText.Ptr(), i, EParaLToR, lText);
       
  5747 
       
  5748 			aTest->TEST(lretval == KErrNone); 
       
  5749 			aTest->TEST(rretval == KErrNone); 
       
  5750 #ifdef PRINT_DATA
       
  5751 			_LIT(KOTitleT, "Original (Top)");
       
  5752 			_LIT(KLTitleT, "Left-to-Right (Top)"); 
       
  5753 			_LIT(KRTitleT, "Right-to-Left (Top)");
       
  5754 			_LIT(KOTitleB, "Original (Bottom)");
       
  5755 			_LIT(KLTitleB, "Left-to-Right (Bottom)"); 
       
  5756 			_LIT(KRTitleB, "Right-to-Left (Bottom)");
       
  5757 			
       
  5758 
       
  5759 			PrintTestData(KOTitleT, aOldText.Ptr(), 32);
       
  5760 			PrintTestData(KOTitleB, aOldText.Ptr()+KBufferSize-32, 32);
       
  5761 
       
  5762 			PrintTestData(KLTitleT, lText, 32);
       
  5763 			PrintTestData(KLTitleB, lText+KBufferSize-32, 32);
       
  5764 
       
  5765 			PrintTestData(KRTitleT, rText, 32);
       
  5766 			PrintTestData(KRTitleB, rText+KBufferSize-32, 32);
       
  5767 
       
  5768 #endif
       
  5769 			aTest->TEST(TextInReverseOrder(aOldText.Ptr(), lText, i));
       
  5770 			aTest->TEST(TextInReverseOrder(aOldText.Ptr(), rText, i));
       
  5771 		
       
  5772 
       
  5773 			DeleteText(aOldText.Ptr(), lText, aTest);
       
  5774 			DeleteText(aOldText.Ptr(), rText, aTest);
       
  5775 
       
  5776 			aOldText.SetLength(oldTextLength);
       
  5777 			}
       
  5778 		}
       
  5779 /**
       
  5780  *
       
  5781  * Tests what happens to European Terminators in a pair of European Numbers 
       
  5782  * when the first character is a Right To Left Arabic letter
       
  5783  *
       
  5784  * @param	  "TDes& aOldText"
       
  5785  *			  Descriptor that points to a buffer at least KBufferSize 16-bit characters long
       
  5786  *
       
  5787  * @param     "CTGraphicsBase* aTest"
       
  5788  *            Pointer to the test object 
       
  5789  *
       
  5790  */
       
  5791 	static void RToLAThenENThenETThenENTest(TDes& aOldText, CTGraphicsBase* aTest)
       
  5792 		{
       
  5793 		TText* lText = 0;
       
  5794 		TText* rText = 0;
       
  5795 		TInt lretval = KErrNone;
       
  5796 		TInt rretval = KErrNone;
       
  5797 		TInt oldTextLength = aOldText.Length();
       
  5798 
       
  5799 		aTest->INFO_PRINTF1(_L("TBidirectionalState test - R-LA EN ET EN test\r\n"));
       
  5800 		
       
  5801 		// Now mix in some numbers
       
  5802 		 TextIterator rtolIterator(KRightToLeftArabic, KRightToLeftArabicLength);
       
  5803 		 TextIterator euronIterator(KEuropeanNumber, KEuropeanNumberLength);
       
  5804 		 TextIterator eurotIterator(KEuropeanNumberTerminator, KEuropeanNumberTerminatorLength);
       
  5805 
       
  5806 		 aTest->TEST(aOldText.Length() >= KBufferSize);
       
  5807 
       
  5808 		 while(!rtolIterator.Wrapped())
       
  5809 			{
       
  5810 			TInt i;
       
  5811 
       
  5812 			TInt lasti = 0;
       
  5813 			for (i = 0 ; i < KBufferSize-3; )
       
  5814 				{
       
  5815 				if (!rtolIterator.NextCharInto(aOldText, i))
       
  5816 					break;
       
  5817 				if (!euronIterator.NextCharInto(aOldText, i))
       
  5818 					break;
       
  5819 				if (!eurotIterator.NextCharInto(aOldText, i))
       
  5820 					break;
       
  5821 				if (!euronIterator.NextCharInto(aOldText, i))
       
  5822 					break;
       
  5823 				lasti = i;
       
  5824 				}
       
  5825 			i = lasti;
       
  5826 			aOldText.SetLength(i);
       
  5827 
       
  5828 			rretval = TBidirectionalState::ReorderText(aOldText.Ptr(), i, EParaRToL, rText);
       
  5829 			lretval = TBidirectionalState::ReorderText(aOldText.Ptr(), i, EParaLToR, lText);
       
  5830 
       
  5831 			aTest->TEST(lretval == KErrNone); 
       
  5832 			aTest->TEST(rretval == KErrNone); 
       
  5833 #ifdef PRINT_DATA
       
  5834 			_LIT(KOTitleT, "Original (Top)");
       
  5835 			_LIT(KLTitleT, "Left-to-Right (Top)"); 
       
  5836 			_LIT(KRTitleT, "Right-to-Left (Top)");
       
  5837 			_LIT(KOTitleB, "Original (Bottom)");
       
  5838 			_LIT(KLTitleB, "Left-to-Right (Bottom)"); 
       
  5839 			_LIT(KRTitleB, "Right-to-Left (Bottom)");
       
  5840 			
       
  5841 
       
  5842 			PrintTestData(KOTitleT, aOldText.Ptr(), 32);
       
  5843 			PrintTestData(KOTitleB, aOldText.Ptr()+KBufferSize-32, 32);
       
  5844 
       
  5845 			PrintTestData(KLTitleT, lText, 32);
       
  5846 			PrintTestData(KLTitleB, lText+KBufferSize-32, 32);
       
  5847 
       
  5848 			PrintTestData(KRTitleT, rText, 32);
       
  5849 			PrintTestData(KRTitleB, rText+KBufferSize-32, 32);
       
  5850 
       
  5851 #endif
       
  5852 		
       
  5853 			aTest->TEST(TextInReverseOrder(aOldText.Ptr(), lText, i));
       
  5854 			aTest->TEST(TextInReverseOrder(aOldText.Ptr(), rText, i));
       
  5855 
       
  5856 			DeleteText(aOldText.Ptr(), lText, aTest);
       
  5857 			DeleteText(aOldText.Ptr(), rText, aTest);
       
  5858 
       
  5859 			aOldText.SetLength(oldTextLength);
       
  5860 			}
       
  5861 		}
       
  5862 /**
       
  5863  *
       
  5864  * Tests what happens to European Terminators in a pair of Arabic Numbers 
       
  5865  * when the first character is a Right To Left Arabic letter
       
  5866  *
       
  5867  * @param	  "TDes& aOldText"
       
  5868  *			  Descriptor that points to a buffer at least KBufferSize 16-bit characters long
       
  5869  *
       
  5870  * @param     "CTGraphicsBase* aTest"
       
  5871  *            Pointer to the test object 
       
  5872  *
       
  5873  */
       
  5874 	static void RToLAThenANThenETThenANTest(TDes& aOldText, CTGraphicsBase* aTest)
       
  5875 		{
       
  5876 		TText* lText = 0;
       
  5877 		TText* rText = 0;
       
  5878 		TInt lretval = KErrNone;
       
  5879 		TInt rretval = KErrNone;
       
  5880 
       
  5881 		aTest->INFO_PRINTF1(_L("TBidirectionalState test - R-LA AN ET AN test\r\n"));
       
  5882 		
       
  5883 		// Now mix in some numbers
       
  5884 		 TextIterator rtolIterator(KRightToLeftArabic, KRightToLeftArabicLength);
       
  5885 		 TextIterator arabnIterator(KArabicNumber, KArabicNumberLength);
       
  5886 		 TextIterator eurotIterator(KEuropeanNumberTerminator, KEuropeanNumberTerminatorLength);
       
  5887 
       
  5888 		 aTest->TEST(aOldText.Length() >= KBufferSize);
       
  5889 
       
  5890 		 while(!rtolIterator.Wrapped())
       
  5891 			{
       
  5892 			TInt i;
       
  5893 
       
  5894 			for (i = 0 ; i < (KBufferSize-3) ; i+=4)
       
  5895 				{
       
  5896 				aOldText[i] = rtolIterator.NextChar();
       
  5897 				aOldText[i+1] = arabnIterator.NextChar();
       
  5898 				aOldText[i+2] = eurotIterator.NextChar();
       
  5899 				aOldText[i+3] = arabnIterator.NextChar();
       
  5900 				}
       
  5901 			rretval = TBidirectionalState::ReorderText(aOldText.Ptr(), KBufferSize, EParaRToL, rText);
       
  5902 			lretval = TBidirectionalState::ReorderText(aOldText.Ptr(), KBufferSize, EParaLToR, lText);
       
  5903 
       
  5904 			aTest->TEST(lretval == KErrNone); 
       
  5905 			aTest->TEST(rretval == KErrNone); 
       
  5906 #ifdef PRINT_DATA
       
  5907 			_LIT(KOTitleT, "Original (Top)");
       
  5908 			_LIT(KLTitleT, "Left-to-Right (Top)"); 
       
  5909 			_LIT(KRTitleT, "Right-to-Left (Top)");
       
  5910 			_LIT(KOTitleB, "Original (Bottom)");
       
  5911 			_LIT(KLTitleB, "Left-to-Right (Bottom)"); 
       
  5912 			_LIT(KRTitleB, "Right-to-Left (Bottom)");
       
  5913 			
       
  5914 
       
  5915 			PrintTestData(KOTitleT, aOldText.Ptr(), 32);
       
  5916 			PrintTestData(KOTitleB, aOldText.Ptr()+KBufferSize-32, 32);
       
  5917 
       
  5918 			PrintTestData(KLTitleT, lText, 32);
       
  5919 			PrintTestData(KLTitleB, lText+KBufferSize-32, 32);
       
  5920 
       
  5921 			PrintTestData(KRTitleT, rText, 32);
       
  5922 			PrintTestData(KRTitleB, rText+KBufferSize-32, 32);
       
  5923 
       
  5924 #endif
       
  5925 		
       
  5926 			aTest->TEST(TextInReverseOrder(aOldText.Ptr(), lText, KBufferSize));
       
  5927 			aTest->TEST(TextInReverseOrder(aOldText.Ptr(), rText, KBufferSize));
       
  5928 		
       
  5929 			DeleteText(aOldText.Ptr(), lText, aTest);
       
  5930 			DeleteText(aOldText.Ptr(), rText, aTest);
       
  5931 
       
  5932 			
       
  5933 			}
       
  5934 		}
       
  5935 
       
  5936 
       
  5937 /**
       
  5938  *
       
  5939  * Tests what happens to Other Neutrals when mixed into Left To Right and Right To Left text
       
  5940  *
       
  5941  * @param	  "TDes& aOldText"
       
  5942  *			  Descriptor that points to a buffer at least KBufferSize 16-bit characters long
       
  5943  *
       
  5944  * @param     "CTGraphicsBase* aTest"
       
  5945  *            Pointer to the test object 
       
  5946  *
       
  5947  */
       
  5948 	static void InterspersedNeutralsTest(TDes& aOldText, CTGraphicsBase* aTest)
       
  5949 		{
       
  5950 		TText* lText = 0;
       
  5951 		TText* rText = 0;
       
  5952 		TInt lretval = KErrNone;
       
  5953 		TInt rretval = KErrNone;
       
  5954 		aTest->INFO_PRINTF1(_L("TBidirectionalState test - L-R R-L with interspersed Neutrals test\r\n"));
       
  5955 		TInt oldTextLength = aOldText.Length();
       
  5956 
       
  5957 		// Neutrals Test
       
  5958 
       
  5959 		 // These should go left-to-right when with left-to-right text
       
  5960 		 // and right-to-left with right-to-left text.
       
  5961 
       
  5962 		 TextIterator ltorIterator(KLeftToRight, KLeftToRightLength);
       
  5963 		 TextIterator rtolIterator(KRightToLeft, KRightToLeftLength);
       
  5964 		 TextIterator neutIterator(KOtherNeutrals, KOtherNeutralsLength);
       
  5965 		 TUint16 neut;
       
  5966 
       
  5967 		 aTest->TEST(aOldText.Length() >= KBufferSize);
       
  5968 
       
  5969 		 while (!ltorIterator.Wrapped())
       
  5970 			{
       
  5971 			TInt i;
       
  5972 			for (i = 0 ; i < KHalfBufferSize; i+=2)
       
  5973 				{
       
  5974 				aOldText[i] = ltorIterator.NextChar();
       
  5975 				//Skip any characters that are mirrored for simplicity of checking
       
  5976 				while(KMirrors().Locate(neut = neutIterator.NextChar()) != KErrNotFound)
       
  5977 					{
       
  5978 					}
       
  5979 				
       
  5980 				aOldText[i+1] = neut;
       
  5981 				}	
       
  5982 
       
  5983 			for (i = KHalfBufferSize ; i < KBufferSize; i+=2)
       
  5984 				{
       
  5985 				aOldText[i] = rtolIterator.NextChar();
       
  5986 				//Skip any characters that are mirrored for simplicity of checking
       
  5987 				while(KMirrors().Locate(neut = neutIterator.NextChar()) != KErrNotFound)
       
  5988 					{
       
  5989 					}
       
  5990 				aOldText[i+1] = neut;
       
  5991 				}
       
  5992 			lretval = TBidirectionalState::ReorderText(aOldText.Ptr(), KBufferSize, EParaLToR, lText);
       
  5993 			rretval = TBidirectionalState::ReorderText(aOldText.Ptr(), KBufferSize, EParaRToL, rText);
       
  5994 		
       
  5995 			aTest->TEST(lretval == KErrNone); 
       
  5996 			aTest->TEST(rretval == KErrNone); 
       
  5997 
       
  5998 			/*
       
  5999 				Note - the tests are made more complex because of the behaviour of the last
       
  6000 				neutral in the first half of the buffer.
       
  6001 
       
  6002 				Because the sequence goes <LtoR> <Neutral> <RtoL>, the way that last
       
  6003 				neutral is interpreted depends upon the paragraph direction instead of
       
  6004 				the direction of the adjacent text.
       
  6005 
       
  6006 			*/
       
  6007 
       
  6008 			aTest->TEST(TextInSameOrder(aOldText.Ptr(), lText, KHalfBufferSize));
       
  6009 			aTest->TEST(TextInReverseOrder(&aOldText.Ptr()[KHalfBufferSize], &lText[KHalfBufferSize], KHalfBufferSize-1));
       
  6010 			aTest->TEST((aOldText.Ptr()[KBufferSize-1] == lText[KBufferSize-1])); //Last neutral obeys L-R hence stays where it was
       
  6011 			aTest->TEST(TextInReverseOrder(&aOldText.Ptr()[KHalfBufferSize], rText, KHalfBufferSize));
       
  6012 			aTest->TEST((aOldText.Ptr()[KHalfBufferSize-1] == rText[KHalfBufferSize])); //First neutral stays RtoL and stays at the front
       
  6013 			aTest->TEST(TextInSameOrder(aOldText.Ptr(), &rText[KHalfBufferSize+1], KHalfBufferSize-1));
       
  6014 
       
  6015 
       
  6016 			DeleteText(aOldText.Ptr(), lText, aTest);
       
  6017 			DeleteText(aOldText.Ptr(), rText, aTest);
       
  6018 			}
       
  6019 		}
       
  6020 
       
  6021 /**
       
  6022  *
       
  6023  * Tests that the behaviour shown in small numbers of runs also occurs when lots of 
       
  6024  * left to right and right to left text is intermixed.
       
  6025  *
       
  6026  * @param	  "TDes& aOldText"
       
  6027  *			  Descriptor that points to a buffer at least KBufferSize 16-bit characters long
       
  6028  *
       
  6029  * @param     "CTGraphicsBase* aTest"
       
  6030  *            Pointer to the test object 
       
  6031  *
       
  6032  */
       
  6033 static void ComplexTextTest(TDes& aOldText, CTGraphicsBase *aTest)
       
  6034 		{
       
  6035 		TText* lText = 0;
       
  6036 		TText* rText = 0;
       
  6037 		TInt lretval = KErrNone;
       
  6038 		TInt rretval = KErrNone;
       
  6039 		TInt oldTextLength = aOldText.Length();
       
  6040 
       
  6041 #ifdef PRINT_RUNS
       
  6042 		_LIT(KRunTitle, "Populating aOldText buffer with embedded runs of characters as follows:\r\n");
       
  6043 		_LIT(KRunFormat, "Run %d begins with %04x\r\n");
       
  6044 		_LIT(KEndRunFormat, "End of Run %d begins with %04x\r\n");
       
  6045 		
       
  6046 #endif // PRINT_RUNS
       
  6047 	
       
  6048 		
       
  6049 		aTest->INFO_PRINTF1(_L("TBidirectionalState test - Complex text test\r\n"));
       
  6050 
       
  6051 		aTest->TEST(aOldText.Length() >= KBufferSize);
       
  6052 
       
  6053 
       
  6054 		 //Build up a lot of levels of L-R and R-L text
       
  6055 
       
  6056 		 TextIterator ltorIterator(KLeftToRight, KLeftToRightLength);
       
  6057 		 TextIterator rtolIterator(KRightToLeft, KRightToLeftLength);
       
  6058 		 const TInt KRuns = 64;
       
  6059 		 const TInt KRunSize = ((KBufferSize/KRuns)/2 ); 
       
  6060 		 TInt runStart[KRuns];
       
  6061 		 TInt runEnd[KRuns];
       
  6062 		 TInt runStartSize[KRuns];
       
  6063 		 TInt runEndSize[KRuns];
       
  6064 		 while (!ltorIterator.Wrapped())
       
  6065 			{
       
  6066 			//Build up start of runs
       
  6067 			 TInt index = 0;
       
  6068 			 TInt run;
       
  6069 #ifdef PRINT_RUNS
       
  6070 			 aTest->INFO_PRINTF1(KRunTitle);
       
  6071 #endif // PRINT_RUNS 
       
  6072 			 for (run = 0 ; run < KRuns ; run++) 
       
  6073 				{
       
  6074 				runStart[run]=index;
       
  6075 				if ((run & 1) == 0)
       
  6076 					{
       
  6077 					ltorIterator.FillInto(aOldText, index, KRunSize*(run+1));
       
  6078 					}
       
  6079 				else
       
  6080 					{
       
  6081 					rtolIterator.FillInto(aOldText, index, KRunSize*(run+1));
       
  6082 					}
       
  6083 				runStartSize[run] = index - runStart[run];
       
  6084 				}
       
  6085 			//Now fill in the ends
       
  6086 			for (TInt brun = KRuns ; brun > 0 ; --brun) 
       
  6087 				{
       
  6088 				run = brun - 1;
       
  6089 				runEnd[run] = index;
       
  6090 				if ((run & 1) == 0)
       
  6091 					{
       
  6092 					ltorIterator.FillInto(aOldText, index, KRunSize*(KRuns*2-run));
       
  6093 					}
       
  6094 				else
       
  6095 					{
       
  6096 					rtolIterator.FillInto(aOldText, index, KRunSize*(KRuns*2-run));
       
  6097 					}
       
  6098 				runEndSize[run] = index - runEnd[run];
       
  6099 				}
       
  6100 			aOldText.SetLength(index);
       
  6101 
       
  6102 			lretval = TBidirectionalState::ReorderText(aOldText.Ptr(), index, EParaLToR, lText);
       
  6103 			rretval = TBidirectionalState::ReorderText(aOldText.Ptr(), index, EParaRToL, rText);
       
  6104 
       
  6105 			aTest->TEST(lretval == KErrNone); 
       
  6106 			aTest->TEST(rretval == KErrNone); 
       
  6107 			
       
  6108 		
       
  6109 #ifdef PRINT_ARRAYS
       
  6110 			_LIT(KHexTitleo, "Contents of aOldText");
       
  6111 			_LIT(KHexTitlel, "Contents of lText");
       
  6112 			_LIT(KHexTitler, "Contents of rText");
       
  6113 
       
  6114 			PrintTestData(KHexTitleo, aOldText);
       
  6115 			PrintTestData(KHexTitlel, lText, KBufferSize);
       
  6116 			PrintTestData(KHexTitler, rText, KBufferSize);
       
  6117 
       
  6118 #endif // PRINT_ARRAYS
       
  6119 			//LeftToRight Paragraph test - all but last run should be in-place,
       
  6120 			//but the right-to-left text is reversed.
       
  6121 
       
  6122 			for (run = 0 ; run < (KRuns-1) ; ++run)
       
  6123 				{
       
  6124 
       
  6125 				aTest->TEST( (KRunSize <= aOldText.Length() - runStart[run]) && (KRunSize <= KBufferSize - runStart[run]));
       
  6126 				aTest->TEST( (KRunSize <= aOldText.Length() - runEnd[run]) && (KRunSize <= KBufferSize - runEnd[run]));
       
  6127 				if ((run & 1) == 0)
       
  6128 					{
       
  6129 					aTest->TEST(TextInSameOrder (&aOldText.Ptr()[runStart[run]], &lText[runStart[run]], runStartSize[run]));
       
  6130 					aTest->TEST(TextInSameOrder (&aOldText.Ptr()[runEnd[run]], &lText[runEnd[run]], runEndSize[run]));
       
  6131 					}
       
  6132 				else
       
  6133 					{
       
  6134 					aTest->TEST(TextInReverseOrder (&aOldText.Ptr()[runStart[run]], &lText[runStart[run]], runStartSize[run]));
       
  6135 					aTest->TEST(TextInReverseOrder (&aOldText.Ptr()[runEnd[run]], &lText[runEnd[run]], runEndSize[run]));
       
  6136 					}
       
  6137 				}
       
  6138 
       
  6139 			run = KRuns-1; //now do last run, which is double-sized 
       
  6140 
       
  6141 			aTest->TEST( (KRunSize*2 <= aOldText.Length() - runStart[run]) && (KRunSize*2 <= KBufferSize - runStart[run]));
       
  6142 			if ((run & 1) == 0)
       
  6143 				{
       
  6144 				aTest->TEST(TextInSameOrder (&aOldText.Ptr()[runStart[run]], &lText[runStart[run]], runStartSize[run]+runEndSize[run]));
       
  6145 				}
       
  6146 			else
       
  6147 				{
       
  6148 				aTest->TEST(TextInReverseOrder (&aOldText.Ptr()[runStart[run]], &lText[runStart[run]], runStartSize[run]+runEndSize[run]));
       
  6149 				}
       
  6150 
       
  6151 			//Right-To-Left Paragraph test - all runs are exchanged about the centre,
       
  6152 			//so the last end run is swapped with the first run and so on
       
  6153 			//and the right-to-left text is reversed.
       
  6154 			for (run = 0 ; run < (KRuns-1) ; ++run)
       
  6155 				{
       
  6156 
       
  6157 				aTest->TEST( (KRunSize <= aOldText.Length() - runStart[run]) && (KRunSize <= KBufferSize - runEnd[run]));
       
  6158 				aTest->TEST( (KRunSize <= aOldText.Length() - runEnd[run]) && (KRunSize <= KBufferSize - runStart[run]));
       
  6159 				if ((run & 1) == 0)
       
  6160 					{
       
  6161 					aTest->TEST(TextInSameOrder (&aOldText.Ptr()[runStart[run]], &rText[index-runStart[run+1]], runStartSize[run]));
       
  6162 					aTest->TEST(TextInSameOrder (&aOldText.Ptr()[runEnd[run]], &rText[index-runEnd[run]-runEndSize[run]], runEndSize[run]));
       
  6163 					}
       
  6164 				else
       
  6165 					{
       
  6166 					aTest->TEST(TextInReverseOrder (&aOldText.Ptr()[runStart[run]], &rText[index-runStart[run+1]], runStartSize[run]));
       
  6167 					aTest->TEST(TextInReverseOrder (&aOldText.Ptr()[runEnd[run]], &rText[index-runEnd[run]-runEndSize[run]], runEndSize[run]));
       
  6168 					}
       
  6169 				}
       
  6170 
       
  6171 			run = KRuns-1; //now do last run, which is double-sized 
       
  6172 
       
  6173 			aTest->TEST( (KRunSize*2 <= aOldText.Length() - runStart[run]) && (KRunSize*2 <= KBufferSize - runStart[run]));
       
  6174 
       
  6175 			if ((run & 1) == 0)
       
  6176 				{
       
  6177 
       
  6178 				aTest->TEST(TextInSameOrder (&aOldText.Ptr()[runStart[run]], &rText[index-runEnd[run-1]], runStartSize[run]+runEndSize[run]));
       
  6179 				}
       
  6180 			else
       
  6181 				{
       
  6182 				aTest->TEST(TextInReverseOrder (&aOldText.Ptr()[runStart[run]], &rText[index-runEnd[run-1]], runStartSize[run]+runEndSize[run]));
       
  6183 				}
       
  6184 			DeleteText(aOldText.Ptr(), lText, aTest);
       
  6185 			DeleteText(aOldText.Ptr(), rText, aTest);
       
  6186 			aOldText.SetLength(oldTextLength);
       
  6187 			}
       
  6188 		}
       
  6189 
       
  6190 /**
       
  6191    @SYMTestCaseID          	GRAPHICS-GDI-BiDi-0003
       
  6192 
       
  6193    @SYMDEF					DEF105603
       
  6194 
       
  6195    @SYMTestCaseDesc			Test TBidirectionalState functionality (Unicode Bidirectional Algorithm impmentation withing SymbianOS)
       
  6196 
       
  6197    @SYMTestPriority			High
       
  6198 
       
  6199    @SYMTestStatus       	Implemented
       
  6200 
       
  6201    @SYMTestActions      	Test reordering text based on various combinations of formatting codes & characters
       
  6202 
       
  6203    @SYMTestExpectedResults	Confirmation the implementation conforms to the Unicode Birdirection Algorithm standard
       
  6204 */
       
  6205 static void TestReorderTextL(CTGraphicsBase* aTest)
       
  6206 		{
       
  6207 		//Create buffer to hold test data
       
  6208 
       
  6209 		HBufC* oldTextBufPtr = HBufC::NewLC(KBufferSize);
       
  6210 
       
  6211 		//Force buffer to desired aSize
       
  6212 		for (int i = 0 ; i < KBufferSize ; ++i)
       
  6213 			{
       
  6214 			oldTextBufPtr->Des().Append(0);
       
  6215 			}
       
  6216 
       
  6217 		TPtr oldText(oldTextBufPtr->Des()); 
       
  6218 		
       
  6219 		aTest->INFO_PRINTF1(_L("TBidirectionalState::ReorderText"));
       
  6220 
       
  6221 		LeftToRightReorderTest(oldText, aTest);
       
  6222 		SimpleEuropeanNumberTest(oldText, aTest);
       
  6223 		SimpleRightToLeftTest(oldText, aTest);
       
  6224 		SimpleRightToLeftArabicTest(oldText, aTest);
       
  6225 
       
  6226 		MirroredCharacterTest(oldText, aTest);
       
  6227 
       
  6228 		LROLeftToRightTest(oldText, aTest);
       
  6229 		LRORightToLeftTest(oldText, aTest);
       
  6230 		RLORightToLeftTest(oldText, aTest);
       
  6231 		RLORightToLeftArabicTest(oldText, aTest);
       
  6232 		RLOLeftToRightTest(oldText, aTest);
       
  6233 
       
  6234 		LToRThenRToLTest(oldText, aTest);
       
  6235 		LToRThenRToLATest(oldText, aTest);
       
  6236 		RToLAThenLToRTest(oldText, aTest);
       
  6237 
       
  6238 		LToRThenRToLThenLToRThenRToLTest(oldText, aTest);
       
  6239 		RToLThenLToRThenRToLThenLToRTest(oldText, aTest);
       
  6240 
       
  6241 		SimpleNumberTest(oldText, aTest);
       
  6242 
       
  6243 		RToLAThenANThenENThenRToLATest(oldText, aTest);
       
  6244 		RToLAThenENThenANThenRToLATest(oldText, aTest);
       
  6245 		RToLThenANThenENThenRToLTest(oldText, aTest);
       
  6246 		RToLThenENThenANThenRToLTest(oldText, aTest);
       
  6247 		LToRThenANThenENThenLToRTest(oldText, aTest);
       
  6248 		LToRThenENThenANThenLToRTest(oldText, aTest);
       
  6249 		LToRThenANThenENThenRToLTest(oldText, aTest);
       
  6250 		LToRThenENThenANThenRToLTest(oldText, aTest);
       
  6251 		LToRThenANThenENThenRToLATest(oldText, aTest);
       
  6252 		LToRThenENThenANThenRToLATest(oldText, aTest);
       
  6253 		RToLThenANThenENThenLToRTest(oldText, aTest);
       
  6254 		RToLThenENThenANThenLToRTest(oldText, aTest);
       
  6255 		RToLAThenANThenENThenLToRTest(oldText, aTest);
       
  6256 		RToLAThenENThenANThenLToRTest(oldText, aTest);
       
  6257 		RToLThenENThenETThenENTest(oldText, aTest);
       
  6258 		RToLThenANThenETThenANTest(oldText, aTest);
       
  6259 		RToLAThenENThenETThenENTest(oldText, aTest);
       
  6260 		RToLAThenANThenETThenANTest(oldText, aTest);
       
  6261 
       
  6262 		ComplexTextTest(oldText, aTest);
       
  6263 
       
  6264 		aTest->INFO_PRINTF1(_L("TBidirectionalState::ReorderText tests complete\r\n"));
       
  6265 
       
  6266 		CleanupStack::PopAndDestroy();
       
  6267 		}
       
  6268 	};
       
  6269 
       
  6270 /**
       
  6271  * Test behaviour of text reordering under normal & OOM conditions
       
  6272  *
       
  6273  * @param	"MOOMTest& aOOMTest" 
       
  6274  *			Reference to the BD test object 
       
  6275 */
       
  6276 void CTBiDi::TestOOML(MOOMTest& aOOMTest)
       
  6277 	{
       
  6278 	aOOMTest.SetUpL();
       
  6279 	aOOMTest.ManipulateL();
       
  6280 	aOOMTest.TearDown();
       
  6281 	TInt successesRequired = aOOMTest.ConsecutivePassesRequired();
       
  6282 	__ASSERT_DEBUG(0 < successesRequired, User::Panic(_L("TBiDi"), KErrGeneral));
       
  6283 	TInt consecutiveSuccesses = 0;
       
  6284 	for (TInt i = 1; consecutiveSuccesses != successesRequired; ++i)
       
  6285 		{
       
  6286 		TInt pHCountStart;
       
  6287 		TInt tHCountStart;
       
  6288 		RThread().HandleCount(pHCountStart,tHCountStart);
       
  6289 		__UHEAP_MARK;
       
  6290 
       
  6291 		aOOMTest.SetUpL();
       
  6292 		__UHEAP_SETFAIL(RHeap::EDeterministic, i);
       
  6293 		TRAPD(err, aOOMTest.ManipulateL());
       
  6294 		if (err == KErrNone)
       
  6295 			{
       
  6296 			aOOMTest.TestIfPassedL(this);
       
  6297 			++consecutiveSuccesses;
       
  6298 			}
       
  6299 		else
       
  6300 			{
       
  6301 			aOOMTest.TestLeftCleanlyL(this);
       
  6302 			consecutiveSuccesses = 0;
       
  6303 			}
       
  6304 		aOOMTest.TearDown();
       
  6305 		__UHEAP_SETFAIL(RHeap::ENone, 0);
       
  6306 
       
  6307 		// test no memory or handles leaked
       
  6308 		__UHEAP_MARKENDC(0);
       
  6309 		TInt pHCountEnd;
       
  6310 		TInt tHCountEnd;
       
  6311 		RThread().HandleCount(pHCountEnd,tHCountEnd);
       
  6312 		TEST(pHCountStart == pHCountEnd);
       
  6313 		TEST(tHCountStart == tHCountEnd);
       
  6314   		}
       
  6315 	}
       
  6316 
       
  6317 class TReorderTextOOMTest : public MOOMTest
       
  6318 	{
       
  6319 	const TDesC* iText;
       
  6320 	TBool iRightToLeft;
       
  6321 	const TDesC* iReorderedText;
       
  6322 	TText* iBuffer;
       
  6323 	TInt iReturnValue;
       
  6324 public:
       
  6325 	TReorderTextOOMTest(const TDesC& aText, TBool aRightToLeft,	const TDesC& aReorderedText) 
       
  6326 		: iText(&aText), iRightToLeft(aRightToLeft), iReorderedText(&aReorderedText),
       
  6327 		iBuffer(0), iReturnValue(0) 
       
  6328 		{}
       
  6329 	virtual ~TReorderTextOOMTest() { TearDown(); }
       
  6330 	void Initialize(const TDesC& aText, TBool aRightToLeft,
       
  6331 		const TDesC& aReorderedText)
       
  6332 		{
       
  6333 		TearDown();
       
  6334 		iText = &aText;
       
  6335 		iRightToLeft = aRightToLeft;
       
  6336 		iReorderedText = &aReorderedText;
       
  6337 		}
       
  6338 	void SetUpL()
       
  6339 		{
       
  6340 		iBuffer = 0;
       
  6341 		iReturnValue = 0;
       
  6342 		}
       
  6343 	void ManipulateL()
       
  6344 		{
       
  6345 		iReturnValue = TBidirectionalState::ReorderText(iText->Ptr(),
       
  6346 			iText->Length(), iRightToLeft, iBuffer);
       
  6347 		User::LeaveIfError(iReturnValue);
       
  6348 		}
       
  6349 	static TBool IsIgnorable(TText a)
       
  6350 		{
       
  6351 		if (a == 0xFFFF)
       
  6352 			return ETrue;
       
  6353 		if (a < 0x202A || 0x202E < a)
       
  6354 			return EFalse;
       
  6355 		return ETrue;
       
  6356 		}
       
  6357 	static TBool StringsMatch(const TText* a1, TInt a1Len,
       
  6358 		const TText* a2, TInt a2Len)
       
  6359 		{
       
  6360 		const TText* a1End = a1 + a1Len;
       
  6361 		const TText* a2End = a2 + a2Len;
       
  6362 		for (;;)
       
  6363 			{
       
  6364 			while (a1 != a1End && IsIgnorable(*a1))
       
  6365 				++a1;
       
  6366 			while (a2 != a2End && IsIgnorable(*a2))
       
  6367 				++a2;
       
  6368 			if (a1 == a1End)
       
  6369 				return a2 == a2End;
       
  6370 			else if (a2 == a2End)
       
  6371 				return EFalse;
       
  6372 			if (*a1 != *a2)
       
  6373 				return EFalse;
       
  6374 			++a1;
       
  6375 			++a2;
       
  6376 			}
       
  6377 		}
       
  6378 
       
  6379 	void TestIfPassedL(CTGraphicsBase* aTest)
       
  6380 		{
       
  6381 		// test the reordered text was returned in iBuffer (as per SDK documentation for TBidirectionalState::ReorderText)
       
  6382 		aTest->TEST(iBuffer != 0);
       
  6383 		aTest->TEST( StringsMatch(iBuffer, iText->Length(), iReorderedText->Ptr(), iReorderedText->Length()) );
       
  6384 		}
       
  6385 
       
  6386 	void TestLeftCleanlyL(CTGraphicsBase* aTest)
       
  6387 		{
       
  6388 		// test the original text was returned in iBuffer (as per SDK documentation for TBidirectionalState::ReorderText)
       
  6389 		aTest->TEST(iBuffer != 0);
       
  6390 		aTest->TEST( StringsMatch(iBuffer, iText->Length(), iText->Ptr(), iText->Length()) );
       
  6391 		}
       
  6392 
       
  6393 	void TearDown()
       
  6394 		{
       
  6395 		if (iBuffer != iText->Ptr())
       
  6396 			delete[] iBuffer;
       
  6397 		iBuffer = 0;
       
  6398 		}
       
  6399 	};
       
  6400 
       
  6401 /**
       
  6402  *
       
  6403  * Prints some details about an array of TBidirectionalState::TRunInfo objects to the test console.
       
  6404  * This function prints each character of text with category code and Bidirectional category
       
  6405  *
       
  6406  *
       
  6407  *  @param		"const TBidirectionalState::TRunInfo* aRunArray"
       
  6408  *				Points to the array of run info objects
       
  6409  *
       
  6410  *  @param		"const TInt aRuns"
       
  6411  *				Number of objects in the array
       
  6412  *
       
  6413  *  @param		"const TText* aText"
       
  6414  *              The text which after being analysed by the Bidirectional Algorithm resulted in
       
  6415  *				the array of run info objects.
       
  6416  * 
       
  6417  *  @param		"const TBool aInternal"
       
  6418  *              The iCategory element of a run info object may be encoded in two ways, either
       
  6419  *              the codes used by TChar or those used by TBidirectionalState. If this flag is ETrue
       
  6420  *				the value is interpreted as a TBidirectionalState code.
       
  6421  *
       
  6422  */
       
  6423 void CTBiDi::PrintRunCategories(const TBidirectionalState::TRunInfo* aRunArray, const TInt aRuns, const TText* aText, const TBool aInternal)
       
  6424 	{
       
  6425 		TBuf16<100> line2;
       
  6426 		TBuf16<100> line3;
       
  6427 		TBuf16<100> line4;
       
  6428 		TBuf16<100> line5;
       
  6429 		line2.Fill(' ',100);
       
  6430 		line3.Fill(' ',100);
       
  6431 		line4.Fill(' ',100);
       
  6432 		line5.Fill(' ',100);
       
  6433 		for (int ii = 0 ; ii < aRuns ; ++ii)
       
  6434 			{
       
  6435 			TUint cat = aRunArray[ii].iCategory;
       
  6436 			if (aInternal)
       
  6437 				{
       
  6438 				cat = 1 << cat; //translate from the form used by TChar to that used internally
       
  6439 								//in TBidirectionalText.
       
  6440 				}
       
  6441 			for (int jj = aRunArray[ii].iStart ;
       
  6442 					(jj < aRunArray[ii].iStart+aRunArray[ii].iLength) ; ++jj)
       
  6443 				{
       
  6444 				line2[jj] = aText[jj];
       
  6445 				switch(cat)
       
  6446 					{
       
  6447 					
       
  6448 					case ELeftToRight:
       
  6449 						line3[jj] = 'L';
       
  6450 						line4[jj] = ' ';
       
  6451 						line5[jj] = ' ';
       
  6452 						break;
       
  6453 					case ELeftToRightEmbedding:
       
  6454 						line3[jj] = 'L';
       
  6455 						line4[jj] = 'R';
       
  6456 						line5[jj] = 'E';
       
  6457 						break;
       
  6458 					case ELeftToRightOverride:
       
  6459 						line3[jj] = 'L';
       
  6460 						line4[jj] = 'R';
       
  6461 						line5[jj] = 'O';
       
  6462 						break;
       
  6463 					case ERightToLeft:
       
  6464 						line3[jj] = 'R';
       
  6465 						line4[jj] = ' ';
       
  6466 						line5[jj] = ' ';
       
  6467 						break;
       
  6468 					case ERightToLeftArabic:
       
  6469 						line3[jj] = 'A';
       
  6470 						line4[jj] = 'L';
       
  6471 						line5[jj] = ' ';
       
  6472 						break;
       
  6473 					case ERightToLeftEmbedding:
       
  6474 						line3[jj] = 'R';
       
  6475 						line4[jj] = 'L';
       
  6476 						line5[jj] = 'E';
       
  6477 						break;
       
  6478 					case ERightToLeftOverride:
       
  6479 						line3[jj] = 'R';
       
  6480 						line4[jj] = 'L';
       
  6481 						line5[jj] = 'O';
       
  6482 						break;
       
  6483 					case EPopDirectionalFormat:
       
  6484 						line3[jj] = 'P';
       
  6485 						line4[jj] = 'D';
       
  6486 						line5[jj] = 'F';
       
  6487 						break;
       
  6488 					case EEuropeanNumber:
       
  6489 						line3[jj] = 'E';
       
  6490 						line4[jj] = 'N';
       
  6491 						line5[jj] = ' ';
       
  6492 						break;
       
  6493 					case EEuropeanNumberSeparator:
       
  6494 						line3[jj] = 'E';
       
  6495 						line4[jj] = 'S';
       
  6496 						line5[jj] = ' ';
       
  6497 						break;
       
  6498 					case EEuropeanNumberTerminator:
       
  6499 						line3[jj] = 'E';
       
  6500 						line4[jj] = 'T';
       
  6501 						line5[jj] = ' ';
       
  6502 						break;
       
  6503 					case EArabicNumber:
       
  6504 						line3[jj] = 'A';
       
  6505 						line4[jj] = 'N';
       
  6506 						line5[jj] = ' ';
       
  6507 						break;
       
  6508 					case ECommonNumberSeparator:
       
  6509 						line3[jj] = 'C';
       
  6510 						line4[jj] = 'S';
       
  6511 						line5[jj] = ' ';
       
  6512 						break;
       
  6513 					case ENonSpacingMark:
       
  6514 						line3[jj] = 'N';
       
  6515 						line4[jj] = 'S';
       
  6516 						line5[jj] = 'M';
       
  6517 						break;
       
  6518 					case EBoundaryNeutral:
       
  6519 						line3[jj] = 'B';
       
  6520 						line4[jj] = 'N';
       
  6521 						line5[jj] = ' ';
       
  6522 						break;
       
  6523 					case EParagraphSeparator:
       
  6524 						line3[jj] = 'B';
       
  6525 						line4[jj] = ' ';
       
  6526 						line5[jj] = ' ';
       
  6527 						break;
       
  6528 					case ESegmentSeparator:
       
  6529 						line3[jj] = 'S';
       
  6530 						line4[jj] = ' ';
       
  6531 						line5[jj] = ' ';
       
  6532 						break;
       
  6533 					case EWhitespace:
       
  6534 						line3[jj] = 'W';
       
  6535 						line4[jj] = 'S';
       
  6536 						line5[jj] = ' ';
       
  6537 						break;
       
  6538 					case EOtherNeutral:
       
  6539 						line3[jj] = 'O';
       
  6540 						line4[jj] = 'N';
       
  6541 						line5[jj] = ' ';
       
  6542 						break;
       
  6543 					case EStartOfParagraph:
       
  6544 						line3[jj] = 'S';
       
  6545 						line4[jj] = 'O';
       
  6546 						line5[jj] = 'P';
       
  6547 						break;
       
  6548 					case EEndOfParagraph:
       
  6549 						line3[jj] = 'E';
       
  6550 						line4[jj] = 'O';
       
  6551 						line5[jj] = 'P';
       
  6552 						break;
       
  6553 					default:
       
  6554 						line3[jj] = '?';
       
  6555 						line4[jj] = ' ';
       
  6556 						line5[jj] = ' ';
       
  6557 						break;
       
  6558 				}
       
  6559 			}
       
  6560 		}
       
  6561 		line2.TrimRight();
       
  6562 		line3.TrimRight();
       
  6563 		line4.TrimRight();
       
  6564 		line5.TrimRight();
       
  6565 		line2.ZeroTerminate();
       
  6566 		line3.ZeroTerminate();
       
  6567 		line4.ZeroTerminate();
       
  6568 		line5.ZeroTerminate();
       
  6569 		INFO_PRINTF2(KSingleString, line2.Ptr());
       
  6570 		INFO_PRINTF2(KSingleString, line3.Ptr());
       
  6571 		INFO_PRINTF2(KSingleString, line4.Ptr());
       
  6572 		INFO_PRINTF2(KSingleString, line5.Ptr());
       
  6573 	}
       
  6574 
       
  6575 /**
       
  6576  *
       
  6577  * Prints some details about an array of TBidirectionalState::TRunInfo objects to the test console.
       
  6578  * This function prints each character of text with the embedding level and Bidirectional category
       
  6579  *
       
  6580  *
       
  6581  *  @param		"const TBidirectionalState::TRunInfo* aRunArray"
       
  6582  *				Points to the array of run info objects
       
  6583  *
       
  6584  *  @param		"const TInt aRuns"
       
  6585  *				Number of objects in the array
       
  6586  *
       
  6587  *  @param		"const TText* aText"
       
  6588  *              The text which after being analysed by the Bidirectional Algorithm resulted in
       
  6589  *				the array of run info objects.
       
  6590  * 
       
  6591 *
       
  6592  */
       
  6593 void CTBiDi::PrintRunArray(const TBidirectionalState::TRunInfo* aRunArray, const TInt aRuns, const TText*  aText)
       
  6594 	{
       
  6595 	if (aRunArray)
       
  6596 		{
       
  6597 #ifdef PRINT_RUN_DETAILS
       
  6598 		_LIT(KRunFmt, "Run %d - Category %d Level %d Direction %d Index %d Start %d Length %d");
       
  6599 #endif // PRINT_RUN_DETAILS
       
  6600 
       
  6601 		TBuf16<100> line1;
       
  6602 		TBuf16<100> line2;
       
  6603 		TBuf16<100> line3;
       
  6604 		TBuf16<100> line4;
       
  6605 		TBuf16<100> line5;
       
  6606 		line1.Zero();
       
  6607 		line2.Zero();
       
  6608 		line3.Zero();
       
  6609 		line4.Zero();
       
  6610 		line5.Zero();
       
  6611 		for (int ii = 0 ; ii < aRuns ; ++ii)
       
  6612 			{
       
  6613 #ifdef PRINT_RUN_DETAILS
       
  6614 			aTest->INFO_PRINTF1(KRunFmt, ii, aRunArray[ii].iCategory,
       
  6615 				aRunArray[ii].iEmbeddingLevel,
       
  6616 				aRunArray[ii].iDirection,
       
  6617 				aRunArray[ii].iIndex,
       
  6618 				aRunArray[ii].iStart,
       
  6619 				aRunArray[ii].iLength);
       
  6620 #endif // PRINT_RUN_DETAILS
       
  6621 			//mark up each character slot with embedding level.
       
  6622 			//Only works well for small values of the embedding level!
       
  6623 			for (int jj = aRunArray[ii].iStart ;
       
  6624 					(jj < aRunArray[ii].iStart+aRunArray[ii].iLength) ; ++jj)
       
  6625 				{
       
  6626 				line1.Append(aText[jj]);
       
  6627 				line2.Append(static_cast<TUint16>(aRunArray[ii].iEmbeddingLevel + '0'));
       
  6628 				switch(aRunArray[ii].iCategory)
       
  6629 					{
       
  6630 					
       
  6631 					case ELeftToRight:
       
  6632 						line3.Append('L');
       
  6633 						line4.Append(' ');
       
  6634 						line5.Append(' ');
       
  6635 						break;
       
  6636 					case ELeftToRightEmbedding:
       
  6637 						line3.Append('L');
       
  6638 						line4.Append('R');
       
  6639 						line5.Append('E');
       
  6640 						break;
       
  6641 					case ELeftToRightOverride:
       
  6642 						line3.Append('L');
       
  6643 						line4.Append('R');
       
  6644 						line5.Append('O');
       
  6645 						break;
       
  6646 					case ERightToLeft:
       
  6647 						line3.Append('R');
       
  6648 						line4.Append(' ');
       
  6649 						line5.Append(' ');
       
  6650 						break;
       
  6651 					case ERightToLeftArabic:
       
  6652 						line3.Append('A');
       
  6653 						line4.Append('L');
       
  6654 						line5.Append(' ');
       
  6655 						break;
       
  6656 					case ERightToLeftEmbedding:
       
  6657 						line3.Append('R');
       
  6658 						line4.Append('L');
       
  6659 						line5.Append('E');
       
  6660 						break;
       
  6661 					case ERightToLeftOverride:
       
  6662 						line3.Append('R');
       
  6663 						line4.Append('L');
       
  6664 						line5.Append('O');
       
  6665 						break;
       
  6666 					case EPopDirectionalFormat:
       
  6667 						line3.Append('P');
       
  6668 						line4.Append('D');
       
  6669 						line5.Append('F');
       
  6670 						break;
       
  6671 					case EEuropeanNumber:
       
  6672 						line3.Append('E');
       
  6673 						line4.Append('N');
       
  6674 						line5.Append(' ');
       
  6675 						break;
       
  6676 					case EEuropeanNumberSeparator:
       
  6677 						line3.Append('E');
       
  6678 						line4.Append('S');
       
  6679 						line5.Append(' ');
       
  6680 						break;
       
  6681 					case EEuropeanNumberTerminator:
       
  6682 						line3.Append('E');
       
  6683 						line4.Append('T');
       
  6684 						line5.Append(' ');
       
  6685 						break;
       
  6686 					case EArabicNumber:
       
  6687 						line3.Append('A');
       
  6688 						line4.Append('N');
       
  6689 						line5.Append(' ');
       
  6690 						break;
       
  6691 					case ECommonNumberSeparator:
       
  6692 						line3.Append('C');
       
  6693 						line4.Append('S');
       
  6694 						line5.Append(' ');
       
  6695 						break;
       
  6696 					case ENonSpacingMark:
       
  6697 						line3.Append('N');
       
  6698 						line4.Append('S');
       
  6699 						line5.Append('M');
       
  6700 						break;
       
  6701 					case EBoundaryNeutral:
       
  6702 						line3.Append('B');
       
  6703 						line4.Append('N');
       
  6704 						line5.Append(' ');
       
  6705 						break;
       
  6706 					case EParagraphSeparator:
       
  6707 						line3.Append('B');
       
  6708 						line4.Append(' ');
       
  6709 						line5.Append(' ');
       
  6710 						break;
       
  6711 					case ESegmentSeparator:
       
  6712 						line3.Append('S');
       
  6713 						line4.Append(' ');
       
  6714 						line5.Append(' ');
       
  6715 						break;
       
  6716 					case EWhitespace:
       
  6717 						line3.Append('W');
       
  6718 						line4.Append('S');
       
  6719 						line5.Append(' ');
       
  6720 						break;
       
  6721 					case EOtherNeutral:
       
  6722 						line3.Append('O');
       
  6723 						line4.Append('N');
       
  6724 						line5.Append(' ');
       
  6725 						break;
       
  6726 					case EStartOfParagraph:
       
  6727 						line3.Append('S');
       
  6728 						line4.Append('O');
       
  6729 						line5.Append('P');
       
  6730 						break;
       
  6731 					case EEndOfParagraph:
       
  6732 						line3.Append('E');
       
  6733 						line4.Append('O');
       
  6734 						line5.Append('P');
       
  6735 						break;
       
  6736 					default:
       
  6737 						line3.Append('?');
       
  6738 						line4.Append(' ');
       
  6739 						line5.Append(' ');
       
  6740 						break;
       
  6741 				} 
       
  6742 			}
       
  6743 		}
       
  6744 
       
  6745 		line1.ZeroTerminate();
       
  6746 		line2.ZeroTerminate();
       
  6747 		line3.ZeroTerminate();
       
  6748 		line4.ZeroTerminate();
       
  6749 		line5.ZeroTerminate();
       
  6750 		INFO_PRINTF2(KSingleString, line1.Ptr());
       
  6751 		INFO_PRINTF2(KSingleString, line2.Ptr()); 
       
  6752 		INFO_PRINTF2(KSingleString, line3.Ptr());
       
  6753 		INFO_PRINTF2(KSingleString, line4.Ptr());
       
  6754 		INFO_PRINTF2(KSingleString, line5.Ptr());
       
  6755 	} 
       
  6756 
       
  6757 }
       
  6758 
       
  6759 
       
  6760 #define TEST_BUF_LEN 80
       
  6761 
       
  6762 /**
       
  6763 The Unicode Example test class
       
  6764 
       
  6765 This class contains functions that support tests based on the examples given by 
       
  6766 Unicode Standard Annexe 9
       
  6767 
       
  6768 Those examples use UPPER CASE latin letters to represent Arabic letters and quotes
       
  6769 to represent embedding levels.
       
  6770 
       
  6771 The functions of this class allow the example to be transcoded using real Arabic letters and
       
  6772 LRE and RLE embedding codes before applying the bidirectional algorithm.
       
  6773 
       
  6774 */
       
  6775 class TUnicodeExampleOOMTest : public MOOMTest
       
  6776 	{
       
  6777 	TBuf<TEST_BUF_LEN> iText;
       
  6778 	TBuf<TEST_BUF_LEN> iOriginalText;
       
  6779 	TBuf<TEST_BUF_LEN> iPrintData;
       
  6780 	TBool iRightToLeft;
       
  6781 	TBuf<TEST_BUF_LEN> iReorderedText;
       
  6782 	TText* iBuffer;
       
  6783 	TInt iReturnValue;
       
  6784 	TInt iAlef; 
       
  6785 	TPtrC iArabicChars;
       
  6786 	TBool iFirst;
       
  6787 	enum {
       
  6788 		EAlef = 0x627
       
  6789 		};
       
  6790 
       
  6791 public:
       
  6792 	TUnicodeExampleOOMTest(const TDesC& aText, TBool aRightToLeft,
       
  6793 		const TDesC& aReorderedText, CTGraphicsBase* aTest)
       
  6794 		: iOriginalText(aText),
       
  6795 		iRightToLeft(aRightToLeft),
       
  6796 		iBuffer(0),
       
  6797 		iReturnValue(0),
       
  6798 		iArabicChars(KRightToLeftArabic, KRightToLeftArabicLength)
       
  6799 		{
       
  6800 		//Find position of arabic letters in table
       
  6801 		iAlef = iArabicChars.Locate(EAlef);
       
  6802 		iText.SetLength(iText.MaxLength()); //set buffer to max size to begin with ensuring first copy fills whole buffer
       
  6803 		iReorderedText.SetLength(iReorderedText.MaxLength());  //set buffer to max size to begin with
       
  6804 		CopyAndMapToArabic(iText, aText, aTest);
       
  6805 		CopyAndMapToArabic(iReorderedText, aReorderedText, aTest);
       
  6806 		}
       
  6807 	virtual ~TUnicodeExampleOOMTest() { TearDown(); }
       
  6808 	void Initialize(const TDesC& aText, TBool aRightToLeft,
       
  6809 		const TDesC& aReorderedText, CTGraphicsBase* aTest)
       
  6810 		{
       
  6811 		TearDown();
       
  6812 		iOriginalText = aText;
       
  6813 		CopyAndMapToArabic(iText, aText, aTest);
       
  6814 		iRightToLeft = aRightToLeft;
       
  6815 		CopyAndMapToArabic(iReorderedText, aReorderedText, aTest);
       
  6816 		}
       
  6817 	void SetUpL()
       
  6818 		{
       
  6819 		iBuffer = 0;
       
  6820 		iReturnValue = 0;
       
  6821 		}
       
  6822 	void ManipulateL()
       
  6823 		{
       
  6824 		iReturnValue = TBidirectionalState::ReorderText(iText.Ptr(),
       
  6825 			iText.Length(), iRightToLeft, iBuffer);
       
  6826 		User::LeaveIfError(iReturnValue);
       
  6827 		}
       
  6828 
       
  6829 	TUint MapToArabic(TUint aChar)
       
  6830 		{
       
  6831 		TUint newChar = aChar;
       
  6832 		if (TChar(aChar).IsUpper())
       
  6833 			{
       
  6834 			newChar = KRightToLeftArabic[aChar-'A'+iAlef]; //Note this isn't a linguistic transliteration.
       
  6835 			};
       
  6836 		return newChar;
       
  6837 		}
       
  6838 	TUint MapFromArabic(TUint aChar)
       
  6839 		{
       
  6840 		TInt pos = iArabicChars.Locate(aChar) - iAlef;
       
  6841 		TUint newChar = aChar;
       
  6842 		if ((pos >= 0) && (pos < 26))
       
  6843 			{
       
  6844 			newChar = 'A'+pos;
       
  6845 			};
       
  6846 		return newChar;
       
  6847 
       
  6848 		}
       
  6849 
       
  6850 	void CopyAndMapToArabic(TDes& aBuffer, const TDesC& aDes, CTGraphicsBase* aTest)
       
  6851 		{
       
  6852 		TInt quoteLevel = 0;
       
  6853 		TChar lastQuote = 0;
       
  6854 		aTest->TEST(aDes.Length() <= aBuffer.MaxLength());
       
  6855 
       
  6856 		aBuffer.Fill(0xFFFF); //fill old contents to help debugging if new string is shorter
       
  6857 
       
  6858 		aBuffer.Zero();
       
  6859 
       
  6860 		for (TInt i = 0 ; i < aDes.Length() ; ++i)
       
  6861 			{
       
  6862 			TUint newChar = MapToArabic(aDes[i]);
       
  6863 			if ((newChar == '\'') || (newChar == '"'))
       
  6864 				{
       
  6865 				//Quote handling
       
  6866 				if (newChar == lastQuote)
       
  6867 					{
       
  6868 					//match so drop a level if there is a level to drop
       
  6869 					if (quoteLevel > 0)
       
  6870 						{
       
  6871 						aBuffer.Append(0x202c); //emit a PLD
       
  6872 						aBuffer.Append(newChar);
       
  6873 						--quoteLevel;
       
  6874 						lastQuote = ((lastQuote == '"') ? '\'' : '"' );
       
  6875 						}
       
  6876 					}
       
  6877 				else
       
  6878 					{
       
  6879 					//start new level
       
  6880 					aBuffer.Append(newChar);
       
  6881 					if (newChar == '\'')
       
  6882 						{
       
  6883 						aBuffer.Append(0x202a); //emit LRE
       
  6884 						}
       
  6885 					else
       
  6886 						{
       
  6887 						aBuffer.Append(0x202b); //emit RLE
       
  6888 						}
       
  6889 					++quoteLevel;
       
  6890 					lastQuote = newChar;
       
  6891 					}
       
  6892 				}
       
  6893 			else
       
  6894 				{
       
  6895 				aBuffer.Append(newChar);
       
  6896 				}
       
  6897 			}
       
  6898 		
       
  6899 		}
       
  6900 	void PrintMappedData(const TDesC& aTitle, const TDesC& aBuffer, CTGraphicsBase* aTest)
       
  6901 		{
       
  6902 		iPrintData.Zero();
       
  6903 		for (TInt i = 0 ; i < aBuffer.Length() ; ++i)
       
  6904 			{
       
  6905 			TText a = aBuffer[i];
       
  6906 
       
  6907 			if (!IsIgnorable(a))
       
  6908 				{
       
  6909 				iPrintData.Append(MapFromArabic(a));
       
  6910 				}
       
  6911 			}
       
  6912 		iPrintData.ZeroTerminate();
       
  6913 		aTest->INFO_PRINTF3(KDoubleString, aTitle.Ptr(), iPrintData.Ptr());
       
  6914 		}
       
  6915 	static TBool IsIgnorable(TText a)
       
  6916 		{
       
  6917 		TBool ignorable = EFalse;
       
  6918 		switch(a) {
       
  6919 			case KUnicodeNoSuchCharacter:
       
  6920 			case KUnicodeLeftToRightMark:
       
  6921 			case KUnicodeRightToLeftMark:
       
  6922 			case KUnicodeLeftToRightEmbedding:
       
  6923 			case KUnicodeRightToLeftEmbedding:
       
  6924 			case KUnicodePopDirectionFormat:
       
  6925 			case KUnicodeLeftToRightOverride:
       
  6926 			case KUnicodeRightToLeftOverride:
       
  6927 				ignorable = ETrue;
       
  6928 				break;
       
  6929 			default:
       
  6930 				break;
       
  6931 			}
       
  6932 		return ignorable;
       
  6933 		}
       
  6934 	static TBool StringsMatch(const TText* a1, TInt a1Len,
       
  6935 		const TText* a2, TInt a2Len)
       
  6936 		{
       
  6937 		const TText* a1End = a1 + a1Len;
       
  6938 		const TText* a2End = a2 + a2Len;
       
  6939 		for (;;)
       
  6940 			{
       
  6941 			while (a1 != a1End && IsIgnorable(*a1))
       
  6942 				++a1;
       
  6943 			while (a2 != a2End && IsIgnorable(*a2))
       
  6944 				++a2;
       
  6945 			if (a1 == a1End)
       
  6946 				return a2 == a2End;
       
  6947 			else if (a2 == a2End)
       
  6948 				return EFalse;
       
  6949 			if (*a1 != *a2)
       
  6950 				return EFalse;
       
  6951 			++a1;
       
  6952 			++a2;
       
  6953 			}
       
  6954 		}
       
  6955 	void TestIfPassedL(CTGraphicsBase* aTest)
       
  6956 		{
       
  6957 #ifdef PRINT_EXAMPLE
       
  6958 		_LIT(KTestPassR, "Test Passed - result");
       
  6959 		_LIT(KTestFailE, "Test Failed - expected");
       
  6960 		_LIT(KTestFailR, "Test Failed - result");
       
  6961 #endif // PRINT_EXAMPLE
       
  6962 		aTest->TEST(iBuffer != 0);
       
  6963 		TBool match = StringsMatch(iBuffer, iText.Length(), iReorderedText.Ptr(), iReorderedText.Length());
       
  6964 
       
  6965 		if (match)
       
  6966 			{
       
  6967 #ifdef PRINT_EXAMPLE
       
  6968 			PrintMappedData(KTestPassR, TPtrC(iBuffer, iText.Length()));
       
  6969 #endif // PRINT_EXAMPLE
       
  6970 			}
       
  6971 		else
       
  6972 			{
       
  6973 #ifdef PRINT_EXAMPLE
       
  6974 			PrintMappedData(KTestFailE, iReorderedText);
       
  6975 			PrintMappedData(KTestFailR, TPtrC(iBuffer, iText.Length()));
       
  6976 #endif // PRINT_EXAMPLE
       
  6977 			aTest->TEST(EFalse);
       
  6978 			}
       
  6979 
       
  6980 		}
       
  6981 	void TearDown()
       
  6982 		{
       
  6983 		if (iBuffer != iText.Ptr())
       
  6984 			delete[] iBuffer;
       
  6985 		iBuffer = 0;
       
  6986 		}
       
  6987 	};
       
  6988 
       
  6989 
       
  6990 
       
  6991 //Unicode Spec sample data
       
  6992 // This uses UPPER CASE english to represent right to left Arabic characters
       
  6993 // A straight mapping to tabularly equivalent Arabic letters is done during the 
       
  6994 // tests using this data. KxxS is the "Storage" value, KxxD is the "Display" value.
       
  6995 // Also all the values like <RLE> are ignored in the comparison, so aren't included in the D value 
       
  6996 // Embedding codes:
       
  6997 // <RLE> \x202b <LRE> \0x202a <PDF> \0x202c <RLO> \x202e <LRO> \x202d <RLM> \0x200f <LRM> \0x200e
       
  6998 
       
  6999 _LIT(KU1S, "he said \"THE VALUES ARE 123, 456, 789, OK\".");
       
  7000 _LIT(KU1D, "he said \"KO ,789 ,456 ,123 ERA SEULAV EHT\".");
       
  7001 _LIT(KU2S, "he said \"IT IS A bmw 500, OK.\"");
       
  7002 _LIT(KU2D, "he said \".KO ,bmw 500 A SI TI\"");
       
  7003 _LIT(KU3S, "car means CAR.");
       
  7004 _LIT(KU3D, "car means RAC.");
       
  7005 _LIT(KU4S, "car MEANS CAR.");
       
  7006 _LIT(KU4D, ".RAC SNAEM car");
       
  7007 //_LIT(KU5S, "he said \"car MEANS CAR.\"");
       
  7008 //_LIT(KU5D, "he said \"RAC SNAEM car.\"");
       
  7009 _LIT(KU6S, "DID YOU SAY 'he said \"car MEANS CAR\"'?");
       
  7010 _LIT(KU6D, "?'he said \"RAC SNAEM car\"' YAS UOY DID");
       
  7011 _LIT(KU7S, "he said `I NEED WATER!`, and expired.");
       
  7012 _LIT(KU7D, "he said `RETAW DEEN I!`, and expired.");
       
  7013 _LIT(KU8S, "he said `\x202bI NEED WATER!\x202c`, and expired.");
       
  7014 _LIT(KU8D, "he said `!RETAW DEEN I`, and expired.");
       
  7015 _LIT(KU9S, "he said `I NEED WATER!\x200f`, and expired.");
       
  7016 _LIT(KU9D, "he said `!RETAW DEEN I`, and expired.");
       
  7017 _LIT(KU10S,"DID YOU SAY '\x202ahe said \"I NEED WATER!\x200f\", and expired.\x202c'?");
       
  7018 _LIT(KU10D,"?'he said \"!RETAW DEEN I\", and expired.' YAS UOY DID");
       
  7019 
       
  7020 /**
       
  7021    @SYMTestCaseID          	GRAPHICS-GDI-BiDi-0005
       
  7022 
       
  7023    @SYMDEF					DEF105603
       
  7024 
       
  7025    @SYMTestCaseDesc			Test TBidirectionalState functionality (Unicode Bidirectional Algorithm impmentation withing SymbianOS)
       
  7026 
       
  7027    @SYMTestPriority			High
       
  7028 
       
  7029    @SYMTestStatus       	Implemented
       
  7030 
       
  7031    @SYMTestActions      	Test behaviour of text-reordering under normal & OOM conditions using examples derived from Unicode Standard Annex 9
       
  7032 
       
  7033    @SYMTestExpectedResults	Confirmation the implementation conforms to the Unicode Birdirection Algorithm standard
       
  7034 */
       
  7035 void CTBiDi::TUnicodeExampleTestL()
       
  7036 	{
       
  7037 	TUnicodeExampleOOMTest toom(KU1S, EFalse, KU1D, this);
       
  7038 	TestOOML(toom);
       
  7039 	toom.Initialize(KU2S, EFalse, KU2D, this);
       
  7040 	TestOOML(toom);
       
  7041 	toom.Initialize(KU3S, EFalse, KU3D, this);
       
  7042 	TestOOML(toom);
       
  7043 	toom.Initialize(KU4S, ETrue, KU4D, this);
       
  7044 	TestOOML(toom);
       
  7045 //  This test commented out because there seems to be no way to persuade a computer 
       
  7046 //  to reproduce this example, it only makes sense to human beings.
       
  7047 //	toom.Initialize(KU5S, EFalse, KU5D);
       
  7048 //	TestOOML(toom);
       
  7049 	toom.Initialize(KU6S, ETrue, KU6D, this);
       
  7050 	TestOOML(toom);
       
  7051 	toom.Initialize(KU7S, EFalse, KU7D, this);
       
  7052 	TestOOML(toom);
       
  7053 	toom.Initialize(KU8S, EFalse, KU8D, this);
       
  7054 	TestOOML(toom);
       
  7055 	toom.Initialize(KU9S, EFalse, KU9D, this);
       
  7056 	TestOOML(toom);
       
  7057 	toom.Initialize(KU10S, ETrue, KU10D, this);
       
  7058 	TestOOML(toom);
       
  7059 
       
  7060 	}
       
  7061 
       
  7062 
       
  7063 _LIT(KHalalL, "\x62D\x644\x627\x644");
       
  7064 _LIT(KHalalD, "\x644\x627\x644\x62D");
       
  7065 _LIT(KHello, "Hello");
       
  7066 _LIT(KHttL, "\x62D\x644\x627\x644 12:30 \x644\x633");
       
  7067 _LIT(KHttD, "\x633\x644 12:30 \x644\x627\x644\x62D");
       
  7068 _LIT(KHttsL, "\x62D\x644\x627\x644 12, 30 \x644\x633");
       
  7069 _LIT(KHttsD, "\x633\x644 30 ,12 \x644\x627\x644\x62D");
       
  7070 _LIT(KEmbedL,"he said \x202B\x644 some text 12 nos \x627 \x202A=Hah is \x62D\x202C \x633\x202C perhaps");
       
  7071 _LIT(KEmbedD,"he said \x633 =Hah is \x62D \x627 some text 12 nos \x644 perhaps");
       
  7072 _LIT(KMixedL, "\x644\x627 ab");
       
  7073 _LIT(KMixedD, "ab \x627\x644");
       
  7074 _LIT(KMixedDL, "\x627\x644 ab");
       
  7075 _LIT(KRLOverrideL, "\x202Ewxyz\x202Cijkl");
       
  7076 _LIT(KRLOverrideD, "zyxwijkl");
       
  7077 
       
  7078 /**
       
  7079    @SYMTestCaseID          	GRAPHICS-GDI-BiDi-0004
       
  7080 
       
  7081    @SYMDEF					DEF105603
       
  7082 
       
  7083    @SYMTestCaseDesc			Test TBidirectionalState functionality (Unicode Bidirectional Algorithm impmentation withing SymbianOS)
       
  7084 
       
  7085    @SYMTestPriority			High
       
  7086 
       
  7087    @SYMTestStatus       	Implemented
       
  7088 
       
  7089    @SYMTestActions      	Test reordering under normal & OOM conditions, using custom strings mixing text with formatting codes
       
  7090 
       
  7091    @SYMTestExpectedResults	Confirmation the implementation conforms to the Unicode Birdirection Algorithm standard
       
  7092 */
       
  7093 void CTBiDi::TestReorderTextL()
       
  7094 	{
       
  7095 	TReorderTextOOMTest toom(KHalalL, EFalse, KHalalD);
       
  7096 	TestOOML(toom);
       
  7097 	toom.Initialize(KHalalL, ETrue, KHalalD);
       
  7098 	TestOOML(toom);
       
  7099 	toom.Initialize(KHello, ETrue, KHello);
       
  7100 	TestOOML(toom);
       
  7101 	toom.Initialize(KHello, EFalse, KHello);
       
  7102 	TestOOML(toom);
       
  7103 	toom.Initialize(KHttL, ETrue, KHttD);
       
  7104 	TestOOML(toom);
       
  7105 	toom.Initialize(KHttL, EFalse, KHttD);
       
  7106 	TestOOML(toom);
       
  7107 	toom.Initialize(KHttsL, ETrue, KHttsD);
       
  7108 	TestOOML(toom);
       
  7109 	toom.Initialize(KHttsL, EFalse, KHttsD);
       
  7110 	TestOOML(toom);
       
  7111 	toom.Initialize(KMixedL, ETrue, KMixedD);
       
  7112 	TestOOML(toom);
       
  7113 	toom.Initialize(KMixedL, EFalse, KMixedDL);
       
  7114 	TestOOML(toom);
       
  7115 	toom.Initialize(KRLOverrideL, EFalse, KRLOverrideD);
       
  7116 	TestOOML(toom);
       
  7117 	toom.Initialize(KEmbedL, EFalse, KEmbedD);
       
  7118 //	TestOOML(toom);
       
  7119 	}
       
  7120 
       
  7121 /**
       
  7122 TBidiTextOOMTest
       
  7123 
       
  7124 This class contains functions that support tests based on the examples given by 
       
  7125 Unicode Standard Annexe 9
       
  7126 
       
  7127 The class contains methods for creating text with different directionality (left-to-right, right-to-left)
       
  7128 and test functions to determine directionality
       
  7129 */
       
  7130 class TBidiTextOOMTest : public MOOMTest
       
  7131 	{
       
  7132 public:
       
  7133 /** Overall directionality of the text. */
       
  7134 /** Text reading begins on the left. */
       
  7135 /** Text reading begins on the right. */
       
  7136 	enum TDirectionality { ELeftToRight, ERightToLeft, EAutomatic };
       
  7137 	TBidiTextOOMTest(CTGraphicsBase *aTest) : iInputText(0), iBidi(0), iTest(aTest) {}
       
  7138 	void Initialize(const TDesC& aInput,
       
  7139 		TDirectionality aDirectionality, TInt aMaxLines)
       
  7140 		{
       
  7141 		iInputText = &aInput;
       
  7142 		iDirectionality = aDirectionality;
       
  7143 		iMaxLines = aMaxLines;
       
  7144 		delete iBidi;
       
  7145 		iBidi = 0;
       
  7146 		}
       
  7147 
       
  7148 	void SetUpL() {}
       
  7149 
       
  7150 	void ManipulateL()
       
  7151 		{
       
  7152 		switch(iDirectionality) {
       
  7153 			case EAutomatic:
       
  7154 				iBidi = TBidiText::NewL(*iInputText, iMaxLines);
       
  7155 				break;
       
  7156 			case ELeftToRight:
       
  7157 				iBidi = TBidiText::NewL(*iInputText, iMaxLines, TBidiText::ELeftToRight);
       
  7158 				break;
       
  7159 			case ERightToLeft:
       
  7160 				iBidi = TBidiText::NewL(*iInputText, iMaxLines, TBidiText::ERightToLeft);
       
  7161 				break;
       
  7162 			default:
       
  7163 				iTest->TEST(EFalse); //Invalid value for iDirectionality
       
  7164 			}
       
  7165 		}
       
  7166 
       
  7167 	void TearDown()
       
  7168 		{
       
  7169 		delete iBidi;
       
  7170 		iBidi = 0;
       
  7171 		}
       
  7172 
       
  7173 	void TestIfPassedL(CTGraphicsBase* aTest)
       
  7174 		{
       
  7175 		aTest->TEST(iBidi != NULL);
       
  7176 		const TFileName a(iBidi->Text());
       
  7177 		aTest->TEST(a == *iInputText); 
       
  7178 		// tests on the actual display text are run in a separate test case
       
  7179 		}
       
  7180 
       
  7181 	void TestLeftCleanlyL(CTGraphicsBase* aTest)
       
  7182 		{
       
  7183 		aTest->TEST(iBidi == NULL);
       
  7184 		}
       
  7185 private:
       
  7186 	const TDesC* iInputText;
       
  7187 	TDirectionality iDirectionality;
       
  7188 	TInt iMaxLines;
       
  7189 	TBidiText* iBidi;
       
  7190 	CTGraphicsBase *iTest;
       
  7191 	};
       
  7192 
       
  7193 /**
       
  7194    @SYMTestCaseID			GRAPHICS-GDI-BiDi-0006
       
  7195 
       
  7196    @SYMDEF					DEF105603
       
  7197 
       
  7198    @SYMTestCaseDesc			Test TBidirectionalState functionality (Unicode Bidirectional Algorithm impmentation withing SymbianOS)
       
  7199 
       
  7200    @SYMTestPriority			High
       
  7201 
       
  7202    @SYMTestStatus       	Implemented
       
  7203 
       
  7204    @SYMTestActions      	Test detection of 'overall' directionality of a given language/script
       
  7205 
       
  7206    @SYMTestExpectedResults	Confirmation the implementation conforms to the Unicode Birdirection Algorithm standard
       
  7207 */
       
  7208 void CTBiDi::TestScriptDirectionality()
       
  7209 	{
       
  7210 	for (TInt i = 0; i != 100; ++i)
       
  7211 		{
       
  7212 		TBidiText::TDirectionality dir = TBidiText::ScriptDirectionality(
       
  7213 			static_cast<TLanguage>(i));
       
  7214 		TEST(i == ELangArabic || i == ELangHebrew || i == ELangFarsi || i == ELangUrdu?
       
  7215 			dir==TBidiText::ERightToLeft : dir == TBidiText::ELeftToRight);
       
  7216 		}
       
  7217 	}
       
  7218 
       
  7219 _LIT(KMultiLine, "Many\x644\x633 runs\xD\xAwith\xDmany\xAtypes\x2028of\x2029\x633\x633 Linebreaks");
       
  7220 _LIT(KLineSep, "\x2028");
       
  7221 
       
  7222 /**
       
  7223  *
       
  7224  * void CTBiDi::NoLineBreakDrawTestL
       
  7225  *
       
  7226  * Test for TBidiText::DrawText
       
  7227  * 
       
  7228  * Some Arabic text is drawn without any line break opportunities.
       
  7229  *
       
  7230  * The result should still be broken into screenwidths and drawn.
       
  7231  *
       
  7232  *
       
  7233  */
       
  7234 void CTBiDi::NoLineBreakDrawTestL()
       
  7235 	{
       
  7236 	INFO_PRINTF1(_L("TBidiText test - RightToLeftArabic draw test without line break opportunities\r\n"));
       
  7237 
       
  7238 	TSize windowSize(400,200);
       
  7239 
       
  7240 	RArray<TTestDataRun> runsArray(16);
       
  7241 	CleanupClosePushL(runsArray);
       
  7242 	
       
  7243 	CFont* testFont = new(ELeave) CTestFont;
       
  7244 	CleanupStack::PushL(testFont);
       
  7245 
       
  7246 
       
  7247 	CTestGraphicsDevice* testDevice = CTestGraphicsDevice::NewL(windowSize);
       
  7248 
       
  7249 	CleanupStack::PushL(testDevice);
       
  7250 
       
  7251 	CGraphicsContext* tContext = NULL;
       
  7252 	
       
  7253 	TEST(testDevice->CreateContext(tContext) == KErrNone);
       
  7254 	//note - no cleanupstack entry as the context is owned by the device
       
  7255 
       
  7256 	CTestGraphicsContext* testContext = static_cast<CTestGraphicsContext*>(tContext);
       
  7257 
       
  7258 
       
  7259 	//Create buffer to hold test data
       
  7260 	HBufC* oldTextBufPtr = HBufC::NewLC(KBufferSize);
       
  7261 
       
  7262 	TPtrC original;
       
  7263 	TPtrC wrapped;
       
  7264 
       
  7265 	TextIterator rIterator(KRightToLeftArabic, KRightToLeftArabicLength);
       
  7266 
       
  7267 	TInt i;
       
  7268 	TInt length;
       
  7269 	TInt end;
       
  7270 	MLineBreaker breaker;
       
  7271 
       
  7272 	//Fill buffer with data
       
  7273 	for (i = 0 ; i < KBufferSize ; ++i)
       
  7274 		{
       
  7275 		TUint s, e;
       
  7276 		TText16 ch = rIterator.NextChar();
       
  7277 		if (breaker.LineBreakClass(ch, s, e) == MLineBreaker::EAlLineBreakClass)
       
  7278 			oldTextBufPtr->Des().Append(ch);
       
  7279 		}
       
  7280 
       
  7281 	TPtr oldText(oldTextBufPtr->Des());
       
  7282 
       
  7283 	TBidiText* bidi = TBidiText::NewL(oldText, 50);
       
  7284 
       
  7285 	CleanupStack::PushL(bidi);
       
  7286 
       
  7287 	TInt comparedLength = (oldText.Length() < KBufferSize )? oldText.Length(): KBufferSize;
       
  7288 
       
  7289 	TEST(oldText.Length() == bidi->Text().Length());
       
  7290 
       
  7291 	TEST(TestTBidirectionalState::TextInSameOrder(oldText.Ptr(), bidi->Text().Ptr(), comparedLength));
       
  7292 
       
  7293 	bidi->WrapText(400 , *testFont, 0);
       
  7294 
       
  7295 	TEST(bidi->WrappingWidth() == 400);
       
  7296 
       
  7297 	original.Set(bidi->Text());
       
  7298 
       
  7299 	wrapped.Set(bidi->DisplayText());
       
  7300 
       
  7301 #ifdef PRINT_ARRAYS
       
  7302 	_LIT(KOriginalTitle, "Original: \r\n"); 
       
  7303 	_LIT(KDisplayTitle, "Display: \r\n"); 
       
  7304 
       
  7305 	PrintTestData(KOriginalTitle, original);
       
  7306 	PrintTestData(KDisplayTitle, wrapped);
       
  7307 
       
  7308 #endif // PRINT_ARRAYS
       
  7309 	
       
  7310 	//Using a font where every character is 10 pixels wide and wrapping to 400 pixels width,
       
  7311 	//every 40 characters should be a Linebreak character, and each of those lines should be reversed.
       
  7312 
       
  7313 	length = oldText.Length();
       
  7314 	end = wrapped.Length();
       
  7315 
       
  7316 	TEST(original.Length() == length);
       
  7317 	TEST(end  >= length);
       
  7318 
       
  7319 	const TText* currentWrapped = wrapped.Ptr();
       
  7320 	const TText* wrappedEnd = currentWrapped + wrapped.Length();
       
  7321 	for (i = 0; i < length ; i += 40)
       
  7322 		{
       
  7323 		end = ((length-i) >= 40) ? i+40 : length;
       
  7324 
       
  7325 		TTestDataRun runData;
       
  7326 
       
  7327 		runData.iStart = i;
       
  7328 		runData.iLength = end-i;
       
  7329 
       
  7330 		runsArray.Append(runData); 
       
  7331 
       
  7332 		TEST( ( end-i <= oldText.Length() - i) && ( end-i <= wrappedEnd - currentWrapped));
       
  7333 		const TText* endLine = TestTBidirectionalState::TextInReverseOrderIgnoringJoiners(
       
  7334 			oldText.Ptr() + i, currentWrapped, end-i);
       
  7335 		if (!endLine)
       
  7336 			{
       
  7337 			INFO_PRINTF3(_L("TBidiText test - wrapped - reverse order check failed for index %d out-index %d"),
       
  7338 				i, currentWrapped - wrapped.Ptr());
       
  7339 			TEST(EFalse);
       
  7340 			}
       
  7341 		
       
  7342 		if (wrappedEnd <= endLine)
       
  7343 			break;
       
  7344 
       
  7345 		if (*endLine != 0x02028)
       
  7346 			{
       
  7347 			INFO_PRINTF3(_L("TBidiText test - wrapped - line terminator check failed for index %d out-index %d"),
       
  7348 				i, currentWrapped - wrapped.Ptr());
       
  7349 			TEST(EFalse);
       
  7350 			}
       
  7351 		currentWrapped = endLine + 1;
       
  7352 		}
       
  7353 
       
  7354 	TPoint origin(0,0);
       
  7355 	TInt baseline_offset = testFont->BaselineOffsetInPixels();
       
  7356 	bidi->DrawText(*testContext, origin, baseline_offset);
       
  7357 
       
  7358 	//now check that DrawText passed the right data
       
  7359 	for (i = 0 ; i < runsArray.Count() ; i++)
       
  7360 		{
       
  7361 		TPtrC spec(testContext->DisplayLine(i).LineData());
       
  7362 		TEST( ( runsArray[i].iLength <= oldText.Length() - runsArray[i].iStart) && ( runsArray[i].iLength <= spec.Length()));
       
  7363 		TEST(0 != TestTBidirectionalState::TextInReverseOrderIgnoringJoiners(
       
  7364 			oldText.Ptr() + runsArray[i].iStart , spec.Ptr(), runsArray[i].iLength));
       
  7365 		};
       
  7366 
       
  7367 	INFO_PRINTF1(_L("TBidiText test - wrapped - display text test passed\r\n"));
       
  7368 
       
  7369 	CleanupStack::PopAndDestroy(bidi);
       
  7370 	CleanupStack::PopAndDestroy(oldTextBufPtr); //whatever is pushed by HBufC::NewLC
       
  7371 	delete testContext;
       
  7372 	CleanupStack::PopAndDestroy(testDevice);
       
  7373 
       
  7374 	CleanupStack::PopAndDestroy(testFont);
       
  7375 	CleanupStack::PopAndDestroy();  //closes runsArray
       
  7376 	}
       
  7377 
       
  7378 /**
       
  7379  *
       
  7380  * void CTBiDi::RightToLeftArabicDrawTestL()
       
  7381  * 
       
  7382  * Test for TBidiText::DrawText
       
  7383  * 
       
  7384  * Some Arabic text is drawn with line break opportunities, but the resulting lines
       
  7385  * are still longer than the declared screen width. So every line becomes two lines.
       
  7386  *
       
  7387  */
       
  7388 void CTBiDi::RightToLeftArabicDrawTestL()
       
  7389 	{
       
  7390 	INFO_PRINTF1(_L("TBidiText test - RightToLeftArabic draw test with linebreak opportunities\r\n"));
       
  7391 
       
  7392 	TSize windowSize(400,200);
       
  7393 
       
  7394 	RArray<TTestDataRun> runsArray(16);
       
  7395 	CleanupClosePushL(runsArray);
       
  7396 	
       
  7397 	CFont* testFont = new(ELeave) CTestFont;
       
  7398 	CleanupStack::PushL(testFont);
       
  7399 
       
  7400 	CTestGraphicsDevice* testDevice = CTestGraphicsDevice::NewL(windowSize);
       
  7401 
       
  7402 	CleanupStack::PushL(testDevice);
       
  7403 
       
  7404 	CGraphicsContext* tContext;
       
  7405 	
       
  7406 	TEST(testDevice->CreateContext(tContext) == KErrNone);
       
  7407 	//note - no cleanupstack entry as the context is owned by the device
       
  7408 
       
  7409 	CTestGraphicsContext* testContext = static_cast<CTestGraphicsContext*>(tContext);
       
  7410 
       
  7411 
       
  7412 	//Create buffer to hold test data
       
  7413 	HBufC* oldTextBufPtr = HBufC::NewLC(KBufferSize);
       
  7414 
       
  7415 	TPtrC original;
       
  7416 	TPtrC wrapped;
       
  7417 
       
  7418 	TextIterator rIterator(KRightToLeftArabic, KRightToLeftArabicLength);
       
  7419 
       
  7420 	TInt i;
       
  7421 	TInt length;
       
  7422 	TInt end;
       
  7423 
       
  7424 	//Fill buffer with groups of 16 characters separated by single spaces
       
  7425 	//Avoid a trailing space
       
  7426 	for (i = 0 ; i < (KBufferSize-1) ; ++i)
       
  7427 		{
       
  7428 			if ( (i & 15) == 15) 
       
  7429 				{
       
  7430 					oldTextBufPtr->Des().Append(0x020);
       
  7431 				}
       
  7432 			else
       
  7433 				{
       
  7434 					oldTextBufPtr->Des().Append(rIterator.NextChar());
       
  7435 				}
       
  7436 		}
       
  7437 
       
  7438 	oldTextBufPtr->Des().Append(rIterator.NextChar()); //final character in buffer should not be a space
       
  7439 
       
  7440 
       
  7441 	TPtr oldText(oldTextBufPtr->Des());
       
  7442 
       
  7443 	TBidiText* bidi = TBidiText::NewL(oldText, 50);
       
  7444 
       
  7445 	CleanupStack::PushL(bidi);
       
  7446 
       
  7447 	TEST( (oldText.Length() == bidi->Text().Length() ) && (oldText.Length() == KBufferSize) );
       
  7448 	TEST(TestTBidirectionalState::TextInSameOrder(oldText.Ptr(), bidi->Text().Ptr(), KBufferSize));
       
  7449 
       
  7450 	bidi->WrapText(400 , *testFont, 0);
       
  7451 
       
  7452 	TEST(bidi->WrappingWidth() == 400);
       
  7453 
       
  7454 	original.Set(bidi->Text());
       
  7455 
       
  7456 	wrapped.Set(bidi->DisplayText());
       
  7457 
       
  7458 #ifdef PRINT_ARRAYS
       
  7459 	_LIT(KOriginalTitle, "Original: \r\n"); 
       
  7460 	_LIT(KDisplayTitle, "Display: \r\n"); 
       
  7461 
       
  7462 	PrintTestData(KOriginalTitle, original);
       
  7463 	PrintTestData(KDisplayTitle, wrapped);
       
  7464 
       
  7465 #endif // PRINT_ARRAYS
       
  7466 	
       
  7467 	//Using a font where every character is 10 pixels wide and wrapping to 400 pixels width,
       
  7468 	// The space every 32 characters should be replaced by a linebreak character
       
  7469 
       
  7470 	length = oldText.Length();
       
  7471 	end = wrapped.Length();
       
  7472 
       
  7473 	TEST(original.Length() == length);
       
  7474 
       
  7475 	for (i = 0; i < length ; i += 32)
       
  7476 		{
       
  7477 		TInt left = length-i;
       
  7478 		TTestDataRun runData;
       
  7479 		runData.iStart = i;
       
  7480 
       
  7481 		if (left <= 33)
       
  7482 			{
       
  7483 			end = length;
       
  7484 			runData.iLength = end - i;
       
  7485 			}
       
  7486 		else
       
  7487 			{
       
  7488 			end = i+32;
       
  7489 			runData.iLength = 31;
       
  7490 			};
       
  7491 
       
  7492 		runsArray.Append(runData); 
       
  7493 
       
  7494 		TEST( (runData.iLength <= oldText.Length() - runData.iStart) && (runData.iLength <= wrapped.Length() - runData.iStart) );
       
  7495 
       
  7496 		if (!TestTBidirectionalState::TextInReverseOrder(oldText.Ptr() + runData.iStart , wrapped.Ptr() + runData.iStart, runData.iLength))
       
  7497 			{
       
  7498 			INFO_PRINTF2(_L("TBidiText test - wrapped - reverse order check failed for index %d\r\n"), i);
       
  7499 			TEST(EFalse);
       
  7500 			}
       
  7501 
       
  7502 		if (length-end < 32)
       
  7503 			{
       
  7504 			break; //don't expect an end of line on the last line
       
  7505 			}
       
  7506 
       
  7507 		if (wrapped[i+31] != 0x02028)
       
  7508 			{
       
  7509 			INFO_PRINTF2(_L("TBidiText test - wrapped - line terminator check failed for index %d\r\n"), i);
       
  7510 			TEST(EFalse);
       
  7511 			}
       
  7512 			
       
  7513 		}
       
  7514 
       
  7515 	TPoint origin(0,0);
       
  7516 	TInt baseline_offset = testFont->BaselineOffsetInPixels();
       
  7517 	bidi->DrawText(*testContext, origin, baseline_offset);
       
  7518 
       
  7519 	//now check that DrawText passed the right data
       
  7520 	for (i = 0 ; i < runsArray.Count() ; i++)
       
  7521 		{
       
  7522 		TPtrC16 spec(testContext->DisplayLine(i).LineData());
       
  7523 		TEST(spec.Length() == runsArray[i].iLength);
       
  7524 		TEST( spec.Length() <= (oldText.Length() - runsArray[i].iStart) );
       
  7525 		TEST(TestTBidirectionalState::TextInReverseOrder(oldText.Ptr() + runsArray[i].iStart , spec.Ptr(), spec.Length()));
       
  7526 		};
       
  7527 
       
  7528 	INFO_PRINTF1(_L("TBidiText test - wrapped - display text test passed\r\n"));
       
  7529 
       
  7530 	CleanupStack::PopAndDestroy(bidi);
       
  7531 	CleanupStack::PopAndDestroy(); //whatever is pushed by HBufC::NewLC
       
  7532 	delete testContext;
       
  7533 	CleanupStack::PopAndDestroy(testDevice);
       
  7534 	CleanupStack::PopAndDestroy(testFont);
       
  7535 	CleanupStack::PopAndDestroy(); //closes runsArray
       
  7536 
       
  7537 	}
       
  7538 
       
  7539 /**
       
  7540  *
       
  7541  * void CTBiDi::LeftToRightDrawTestL()
       
  7542  *
       
  7543  * Test for TBidiText::DrawText
       
  7544  * 
       
  7545  * Some Latin text is drawn with line breaks
       
  7546  *
       
  7547  */
       
  7548 void CTBiDi::LeftToRightDrawTestL()
       
  7549 	{//as well as left to right text, this uses a variety of break opportunities.
       
  7550 	INFO_PRINTF1(_L("TBidiText test - LeftToRight draw test\r\n"));
       
  7551 
       
  7552 	TSize windowSize(100,400);
       
  7553 
       
  7554 	RArray<TTestDataRun> runsArray(16);
       
  7555 	CleanupClosePushL(runsArray);
       
  7556 	
       
  7557 	CFont* testFont = new(ELeave) CTestFont;
       
  7558 	CleanupStack::PushL(testFont);
       
  7559 
       
  7560 
       
  7561 	CTestGraphicsDevice* testDevice = CTestGraphicsDevice::NewL(windowSize);
       
  7562 
       
  7563 	CleanupStack::PushL(testDevice);
       
  7564 
       
  7565 	CGraphicsContext* tContext;
       
  7566 	
       
  7567 	TEST(testDevice->CreateContext(tContext) == KErrNone);
       
  7568 	//note - no cleanupstack entry as the context is owned by the device
       
  7569 
       
  7570 	CTestGraphicsContext* testContext = static_cast<CTestGraphicsContext*>(tContext);
       
  7571 
       
  7572 
       
  7573 	//Create buffer to hold test data
       
  7574 	HBufC* oldTextBufPtr = HBufC::NewLC(KBufferSize);
       
  7575 
       
  7576 	TPtrC original;
       
  7577 	TPtrC wrapped;
       
  7578 
       
  7579 	TextIterator lIterator(KLeftToRight, KLeftToRightLength);
       
  7580 
       
  7581 	TInt i;
       
  7582 	TInt j;
       
  7583 	TInt length;
       
  7584 	TInt endOfWrapped;
       
  7585 
       
  7586 	//Fill buffer with groups of 16 characters separated by single spaces
       
  7587 	for (i = 0 ; i < KBufferSize ; ++i)
       
  7588 		{
       
  7589 		if ( (i & 15) == 15) 
       
  7590 			{
       
  7591 			oldTextBufPtr->Des().Append(0x020);
       
  7592 			}
       
  7593 		else
       
  7594 			{
       
  7595 			oldTextBufPtr->Des().Append(lIterator.NextChar());
       
  7596 			}
       
  7597 		}
       
  7598 
       
  7599 	TPtr oldText(oldTextBufPtr->Des());
       
  7600 
       
  7601 	TBidiText* bidi = TBidiText::NewL(oldText, 200);
       
  7602 
       
  7603 	CleanupStack::PushL(bidi);
       
  7604 
       
  7605 	TEST( (oldText.Length() == bidi->Text().Length() ) && (oldText.Length() == KBufferSize) );
       
  7606 
       
  7607 	TEST(TestTBidirectionalState::TextInSameOrder(oldText.Ptr(), bidi->Text().Ptr(), KBufferSize));
       
  7608 
       
  7609 	bidi->WrapText(100 , *testFont, 0);
       
  7610 
       
  7611 	TEST(bidi->WrappingWidth() == 100);
       
  7612 
       
  7613 	original.Set(bidi->Text());
       
  7614 
       
  7615 	wrapped.Set(bidi->DisplayText());
       
  7616 
       
  7617 #ifdef PRINT_ARRAYS
       
  7618 	_LIT(KOriginalTitle, "Original: \r\n"); 
       
  7619 	_LIT(KDisplayTitle, "Display: \r\n"); 
       
  7620 
       
  7621 	PrintTestData(KOriginalTitle, original);
       
  7622 	PrintTestData(KDisplayTitle, wrapped);
       
  7623 
       
  7624 #endif // PRINT_ARRAYS
       
  7625 	
       
  7626 	//Using a font where every character is 10 pixels wide and wrapping to 100 pixels width,
       
  7627 	//after 10 characters should be a linebreak, then the next space is replaced by another linebreak and so on.
       
  7628 
       
  7629 	length = oldText.Length();
       
  7630 	endOfWrapped = wrapped.Length();
       
  7631 
       
  7632 	TEST(original.Length() == length);
       
  7633 	TEST(endOfWrapped  >= length);
       
  7634 
       
  7635 	TInt increment = 10;
       
  7636 
       
  7637 	i = 0;
       
  7638 	j = 0;
       
  7639 
       
  7640 	for(i=0,j=0; i < length; i += increment, (increment = (increment == 5) ? 10 : 5))
       
  7641 		{ 
       
  7642 		
       
  7643 		TTestDataRun runData;
       
  7644 
       
  7645 		TInt endOfRun = ((length-i) > increment) ? i+increment : length;
       
  7646 
       
  7647 		runData.iStart = i;
       
  7648 		runData.iLength = endOfRun-i;
       
  7649 
       
  7650 		runsArray.Append(runData); 
       
  7651 
       
  7652 		//make sure the array is not overread
       
  7653 		TEST( (runData.iLength <= oldText.Length() - i) && (runData.iLength <= wrapped.Length() - j) );
       
  7654 
       
  7655 		if (!TestTBidirectionalState::TextInSameOrder(oldText.Ptr() + i , wrapped.Ptr() + j, runData.iLength))
       
  7656 			{
       
  7657 			INFO_PRINTF3(_L("TBidiText test - wrapped - same order check failed for index %d out-index %d\r\n"), i, j);
       
  7658 			TEST(EFalse);
       
  7659 			}
       
  7660 
       
  7661 		j += increment;
       
  7662 
       
  7663 		if (j >= (endOfWrapped-1))
       
  7664 			{
       
  7665 			break;
       
  7666 			}
       
  7667 		
       
  7668 		if (wrapped[j++] != 0x02028)
       
  7669 			{
       
  7670 			INFO_PRINTF3(_L("TBidiText test - wrapped - line terminator check failed for index %d out-index %d\r\n"), i, j-1);
       
  7671 			TEST(EFalse);
       
  7672 			}
       
  7673 		if (increment == 5) 
       
  7674 			{
       
  7675 			i++; //skip space at end of every 15 characters
       
  7676 			};
       
  7677 		
       
  7678 
       
  7679 		}
       
  7680 
       
  7681 	TPoint origin(0,0);
       
  7682 	TInt baseline_offset = testFont->BaselineOffsetInPixels();
       
  7683 	bidi->DrawText(*testContext, origin, baseline_offset);
       
  7684 
       
  7685 	//now check that DrawText passed the right data
       
  7686 	for (i = 0 ; i < (runsArray.Count()-1) ; i++)
       
  7687 		{
       
  7688 		TPoint line_origin(testContext->DisplayLine(i).Position());
       
  7689 		TEST (line_origin.iY == (origin.iY + (i * baseline_offset)));
       
  7690 		TPtrC16 spec(testContext->DisplayLine(i).LineData());
       
  7691 		TTestDataRun run = runsArray[i];
       
  7692 		TEST(spec.Length() == run.iLength);
       
  7693 		//make sure the array is not overread
       
  7694 		TEST(spec.Length() <= oldText.Length() - run.iStart);
       
  7695 		TEST(TestTBidirectionalState::TextInSameOrder(oldText.Ptr() + run.iStart , spec.Ptr(), spec.Length()));
       
  7696 		};
       
  7697 
       
  7698 	INFO_PRINTF1(_L("TBidiText test - wrapped - display text test passed\r\n"));
       
  7699 
       
  7700 	CleanupStack::PopAndDestroy(bidi);
       
  7701 	CleanupStack::PopAndDestroy(); //whatever is pushed by HBufC::NewLC
       
  7702 	delete testContext;
       
  7703 	CleanupStack::PopAndDestroy(testDevice);
       
  7704 	CleanupStack::PopAndDestroy(testFont);
       
  7705 	CleanupStack::PopAndDestroy(); //closes runsArray
       
  7706 
       
  7707 	}
       
  7708 
       
  7709 /**
       
  7710  *
       
  7711  * TBool CTBiDi::GlyphTestL
       
  7712  *
       
  7713  * Test function for glyph substitution
       
  7714  *
       
  7715  * @param     "const TDesC16& aTitle"
       
  7716  *            Reference to literal string used for logging. Id's the particular test
       
  7717  *
       
  7718  * @param     "const TDesC16& aOriginal"
       
  7719  *            Reference text
       
  7720  *
       
  7721  * @param     "const TDesC16& aDesired"
       
  7722  *            Reference to expected result following call to DisplayText
       
  7723  *
       
  7724  * @param     "const TInt aWrapWidth"
       
  7725  *            The maximum width of the text (in pixels)
       
  7726  *
       
  7727  */
       
  7728 TBool CTBiDi::GlyphTestL(const TDesC16& aTitle, const TDesC16& aOriginal, const TDesC16& aDesired, const TInt aWrapWidth)
       
  7729 	{
       
  7730 	TBool pass = ETrue;
       
  7731 	INFO_PRINTF1(aTitle);
       
  7732 
       
  7733 	TSize windowSize(400,200);
       
  7734 
       
  7735 	CTestGraphicsDevice* testDevice = CTestGraphicsDevice::NewL(windowSize);
       
  7736 	CleanupStack::PushL(testDevice);
       
  7737 
       
  7738 	CFont* testFont;
       
  7739 	CGraphicsContext* tContext;
       
  7740 	
       
  7741 	User::LeaveIfError(testDevice->CreateContext(tContext));
       
  7742 	CleanupStack::PushL(tContext);
       
  7743 
       
  7744 	User::LeaveIfError(testDevice->GetNearestFontToDesignHeightInPixels(testFont,TFontSpec(KArabicFontName,16)));
       
  7745 
       
  7746 	TPtrC original;
       
  7747 	TPtrC wrapped;
       
  7748 	TPtrC desired(aDesired);
       
  7749 	TInt desiredIndex = 0;
       
  7750 	TInt desiredLength = desired.Length();
       
  7751 
       
  7752 	TBidiText* bidi = TBidiText::NewL(aOriginal, 50);
       
  7753 
       
  7754 	CleanupStack::PushL(bidi);
       
  7755 
       
  7756 	bidi->WrapText(aWrapWidth , *testFont, 0);
       
  7757 
       
  7758 	TEST(bidi->WrappingWidth() == aWrapWidth);
       
  7759 
       
  7760 	original.Set(bidi->Text());
       
  7761 
       
  7762 	wrapped.Set(bidi->DisplayText());
       
  7763 
       
  7764 	
       
  7765 	CFont::TPositionParam param;
       
  7766 	param.iDirection = CFont::EHorizontal;
       
  7767 	param.iText.Set(bidi->DisplayText());
       
  7768 
       
  7769 	param.iPosInText = 0;
       
  7770 	TInt end_char = wrapped.Length();
       
  7771 
       
  7772 	pass = ETrue;
       
  7773 
       
  7774 	while (param.iPosInText < end_char)
       
  7775 		{
       
  7776 		if (testFont->GetCharacterPosition(param)) //turn character(s) into glyphs
       
  7777 			{
       
  7778 			//some glyphs have been output
       
  7779 			TInt i;
       
  7780 			for (i = 0 ; i < param.iOutputGlyphs ; ++i)
       
  7781 				{
       
  7782 				pass = pass && (desiredIndex < desiredLength); //see if more glyphs generated than expected
       
  7783 
       
  7784 				while (desired[desiredIndex] == KUnicodeNoSuchCharacter)
       
  7785 					{
       
  7786 					++desiredIndex; //skip any padding
       
  7787 					}
       
  7788 
       
  7789 				pass = pass && (desired[desiredIndex] == param.iOutput[i].iCode);
       
  7790 
       
  7791 				++desiredIndex;
       
  7792 				}
       
  7793 			}
       
  7794 		}
       
  7795 	_LIT(KPassed, " passed\r\n");
       
  7796 	_LIT(KFailed, " FAILED\r\n");
       
  7797 
       
  7798 	if (pass)
       
  7799 		{
       
  7800 		INFO_PRINTF1(KPassed);
       
  7801 		}
       
  7802 	else
       
  7803 		{
       
  7804 		INFO_PRINTF1(KFailed);
       
  7805 		_LIT(KOriginalTitle, "Original: \r\n"); 
       
  7806 		_LIT(KDisplayTitle, "Display: \r\n"); 
       
  7807 		_LIT(KDesiredTitle, "Desired: \r\n");
       
  7808 		PrintTestData(KOriginalTitle, original);
       
  7809 		PrintTestData(KDisplayTitle, wrapped);
       
  7810 		PrintTestData(KDesiredTitle, desired);
       
  7811 
       
  7812 		}
       
  7813 
       
  7814 	CleanupStack::PopAndDestroy(bidi);
       
  7815 	CleanupStack::PopAndDestroy(tContext);
       
  7816 	CleanupStack::PopAndDestroy(testDevice);
       
  7817 	delete 	((CTestFont*)testFont); //this is to avoid compilation warnings as CFont desructor is private
       
  7818 
       
  7819 	return pass;
       
  7820 	}
       
  7821 
       
  7822 _LIT(KLamAlefIsolateTitle, "Lam-Alef Ligature Test (Alef-Lam in logical order) ");
       
  7823 _LIT(KLamAlefIsolate, " \x644\x627 ");
       
  7824 _LIT(KLamAlefIsolateDesired, " \xfefb "); 
       
  7825 _LIT(KLamAlefTahTtitle, "Lam-Alef Tah Ligature Test (Tah Alef Lam in logical order) ");
       
  7826 _LIT(KLamAlefTah, " \x637\x644\x627 ");
       
  7827 _LIT(KLamAlefTahDesired, " \xfefc\xfec3 "); 
       
  7828 _LIT(KTaaTaaTaaTitle, "Taa Taa Taa Shaping test  ");
       
  7829 _LIT(KTaaTaaTaa, " \x637\x637\x637 ");
       
  7830 _LIT(KTaaTaaTaaDesired, " \xfec2\xfec4\xfec3 ");  
       
  7831 
       
  7832 
       
  7833 /**
       
  7834  *
       
  7835  * TBool CTBiDi::LigatureTextsL
       
  7836  *
       
  7837  * Test function of glyphs using ligatures
       
  7838  *
       
  7839  */
       
  7840 void CTBiDi::LigatureTestsL()
       
  7841 	{
       
  7842 	TInt passed = 0;
       
  7843 	TInt wrapWidth = 400;
       
  7844 	//set the wrapping width very large - we don't want these tests to linewrap.
       
  7845 
       
  7846 	if (GlyphTestL(KLamAlefIsolateTitle, KLamAlefIsolate, KLamAlefIsolateDesired, wrapWidth))
       
  7847 		{
       
  7848 		++passed;
       
  7849 		}
       
  7850 	if (GlyphTestL(KLamAlefTahTtitle, KLamAlefTah, KLamAlefTahDesired, wrapWidth))
       
  7851 		{
       
  7852 		++passed;
       
  7853 		}
       
  7854 	if (GlyphTestL(KTaaTaaTaaTitle, KTaaTaaTaa, KTaaTaaTaaDesired, wrapWidth))
       
  7855 		{
       
  7856 		++passed;
       
  7857 		}
       
  7858 	TEST(passed == 3);
       
  7859 	}
       
  7860 
       
  7861 _LIT(KIllegalBreakTitle, "Arabic Illegal Linebreak Test");
       
  7862 
       
  7863 /**
       
  7864 *
       
  7865 * void CTBiDi::ArabicIllegalLinebreakTestsL
       
  7866 *
       
  7867 * Tests that when rendering a long Arabic "word" that needs to be broken up part-way
       
  7868 * due to screen width, that the characters inside the word are still rendered as their 
       
  7869 * medial form rather than incorrectly making them initial final or isolated.
       
  7870 */
       
  7871 void CTBiDi::ArabicIllegalLinebreakTestsL()
       
  7872 	{
       
  7873 	static const TInt KWrappingWidth = 100; //in pixels
       
  7874 	static const TInt KLineWidth = 10;       //not including linebreak
       
  7875 	static const TInt KInputLength = 150;
       
  7876 	static const TInt KOutputLength = ((KInputLength/(KLineWidth-1))+1)*KLineWidth; //allow for linebreak characters
       
  7877 
       
  7878 	TBuf<KInputLength> iBuffer;        //holds input data
       
  7879 	TBuf<KOutputLength> oBuffer;        //holds expected glyphs that the input will be turned into
       
  7880 
       
  7881 	TextIterator iterator(KArabicDualJoiningLettersData, KArabicDualJoiningLettersLength);
       
  7882 
       
  7883 	while (!iterator.Wrapped())
       
  7884 		{
       
  7885 		TInt i;
       
  7886 		TInt j;
       
  7887 		TInt startOfLine;
       
  7888 		iBuffer.Zero();
       
  7889 		oBuffer.FillZ(oBuffer.MaxLength());
       
  7890 		TUint16 ch = iterator.NextChar();
       
  7891 		TUint16 medial_ch;
       
  7892 
       
  7893 		startOfLine = 0;
       
  7894 		j = KLineWidth; 
       
  7895 		iBuffer.Append(KUnicodeSpace);
       
  7896 		oBuffer[j--] = KUnicodeLinebreak;
       
  7897 		oBuffer[j--] = KUnicodeSpace;
       
  7898 		iBuffer.Append(ch);
       
  7899 		oBuffer[j--] = GetInitialForm(ch);
       
  7900 
       
  7901 		//Now compose a very long nonsense word in Arabic.
       
  7902 		//At the same time insert the corresponding 
       
  7903 		for (i = 1; i < (iBuffer.MaxLength()-3) ; ++i)
       
  7904 			{
       
  7905 			do 
       
  7906 				{
       
  7907 				ch = iterator.NextChar();
       
  7908 				medial_ch = GetMedialForm(ch);
       
  7909 				}
       
  7910 			while (medial_ch == ch); //skip characters without medial form
       
  7911 			iBuffer.Append(ch);
       
  7912 			oBuffer[j--] = medial_ch;;
       
  7913 			if (j < startOfLine)
       
  7914 				{
       
  7915 				startOfLine += KLineWidth+1;
       
  7916 				j = startOfLine + KLineWidth;
       
  7917 				oBuffer[j--] = KUnicodeLinebreak;
       
  7918 				}
       
  7919 			}
       
  7920 		ch = iterator.NextChar();
       
  7921 		iBuffer.Append(ch);
       
  7922 		oBuffer[j--] = GetFinalForm(ch);
       
  7923 		iBuffer.Append(KUnicodeSpace);	
       
  7924 		oBuffer[j--] = KUnicodeSpace;	//Trailing spaces are not supressed, hence add space to test output
       
  7925 		for (; j >= startOfLine ; --j)
       
  7926 			{
       
  7927 				oBuffer[j] = KUnicodeNoSuchCharacter;
       
  7928 			}
       
  7929 
       
  7930 		//You might be expecting to see some zero-width joiners in the output.
       
  7931 		//In fact these are suppressed by the font object used by GlyphTestL 
       
  7932 		//so we never see them on the outside.
       
  7933 
       
  7934 		TBool passed = GlyphTestL(KIllegalBreakTitle, iBuffer, oBuffer, KWrappingWidth);
       
  7935 		if (!passed) 
       
  7936 			{
       
  7937 			TEST(EFalse);
       
  7938 			}
       
  7939 		}
       
  7940 	}
       
  7941 
       
  7942 /**
       
  7943  *
       
  7944  * void CTBiDi::DoTestTextDrawPanic() 
       
  7945  *
       
  7946  * Panic Test for TBidiText::DrawText
       
  7947  * 
       
  7948  * This attempts to call DrawText without first calling WrapText and consequently is expected to panic.
       
  7949  *
       
  7950  */
       
  7951 void CTBiDi::DoTestTextDrawPanic() 
       
  7952 	{
       
  7953 	TSize windowSize(100,100);
       
  7954 
       
  7955 	CTestGraphicsDevice* testDevice = CTestGraphicsDevice::NewL(windowSize);
       
  7956 
       
  7957 	CleanupStack::PushL(testDevice);
       
  7958 
       
  7959 	CGraphicsContext* testContext;
       
  7960 	
       
  7961 	TEST(testDevice->CreateContext(testContext) == KErrNone);
       
  7962 	//note - no cleanupstack entry as the context is owned by the device
       
  7963 
       
  7964 	_LIT(KBidiText, "This is just a random lump of text");
       
  7965 
       
  7966 	TBidiText* bidi = TBidiText::NewL(KBidiText, 50);
       
  7967 
       
  7968 	CleanupStack::PushL(bidi);
       
  7969 
       
  7970 	TPoint centre(50,50);
       
  7971 
       
  7972 	bidi->DrawText(*testContext, centre);
       
  7973 
       
  7974 	CleanupStack::PopAndDestroy(bidi);
       
  7975 	CleanupStack::PopAndDestroy(testDevice);
       
  7976 	}
       
  7977 
       
  7978 /**
       
  7979  *
       
  7980  * static TInt TestDrawTextPanicThread
       
  7981  *
       
  7982  * Panic Test for TBidiText::DrawText
       
  7983  * 
       
  7984  * This calls DoTestDrawTextPanic within its own cleanup stack and TRAPD as it is in 
       
  7985  * a separate thread.
       
  7986  *
       
  7987  */
       
  7988 static TInt TestDrawTextPanicThread(TAny* aData)
       
  7989 	{
       
  7990 	//Tests that BidiText::DrawText panics if called without first calling
       
  7991 	//BidiText::WrapText.
       
  7992 	
       
  7993 	CTBiDi* theTest = static_cast<CTBiDi*> (aData);
       
  7994 	CTrapCleanup* tc = CTrapCleanup::New();
       
  7995 	if (!tc)
       
  7996 		return KErrNoMemory;
       
  7997 
       
  7998 	TRAPD(err, theTest->DoTestTextDrawPanic());
       
  7999 
       
  8000 	delete tc;
       
  8001 
       
  8002 	return err;
       
  8003 	}
       
  8004 
       
  8005 /**
       
  8006  *
       
  8007  * TInt CTBiDi::TestPanic
       
  8008  *
       
  8009  * Panic Test for TBidiText
       
  8010  * 
       
  8011  * This creates a separate thread to run the test in as normally a panic
       
  8012  * will stop the test process.
       
  8013  *
       
  8014  */
       
  8015 TInt CTBiDi::TestPanic(TThreadFunction aFunction)
       
  8016 		{
       
  8017 		// Increment the test thread counter to create threads with different names and thus avoid conflict of kernel resources
       
  8018 		++iTestThreadCounter;
       
  8019 		_LIT(KThreadNameFormat, "DeliberatePanicPleaseIgnore%d");
       
  8020 		TBuf<256> threadNameBuf;
       
  8021 		threadNameBuf.Format(KThreadNameFormat, iTestThreadCounter);
       
  8022 	
       
  8023 		TInt KHeapSize = 8192;
       
  8024 		RThread thread;
       
  8025 		TRequestStatus threadstat;
       
  8026 		TBool jit = User::JustInTime();
       
  8027 		User::SetJustInTime(EFalse);
       
  8028 		TInt ret = thread.Create(threadNameBuf, aFunction, KDefaultStackSize, KHeapSize, KHeapSize, this);
       
  8029 		TEST(KErrNone == ret);
       
  8030 		thread.Logon(threadstat);
       
  8031 		thread.Resume();
       
  8032 		User::WaitForRequest(threadstat);
       
  8033 		TEST (thread.ExitType() == EExitPanic);
       
  8034 		TInt reason = thread.ExitReason();
       
  8035 		thread.Close();
       
  8036 		User::SetJustInTime(jit);
       
  8037 		return reason;
       
  8038 		}
       
  8039 
       
  8040 /**
       
  8041  *
       
  8042  * void CTBiDi::TRunInfoCompactReorderTest
       
  8043  *
       
  8044  * Tests functionality contained within TRunInfoCompact
       
  8045  *
       
  8046  */
       
  8047 void CTBiDi::TRunInfoCompactReorderTest()
       
  8048 	{
       
  8049 	_LIT(KLetters, "XYZjklmnPQR");
       
  8050 	static const struct {
       
  8051 		TBool iJoinsAtStart;
       
  8052 		TBool iJoinsAtEnd;
       
  8053 		TBool iTruncated;
       
  8054 		TInt iStart;
       
  8055 		TInt iEnd;
       
  8056 		const TText* iExpected;} testData[] =
       
  8057 		{
       
  8058 			{EFalse, EFalse, EFalse, 4, 7, _S("klm")},
       
  8059 			{EFalse, EFalse, EFalse, 3, 7, _S("jklm")},
       
  8060 			{EFalse, EFalse, EFalse, 4, 8, _S("klmn")},
       
  8061 			{EFalse, EFalse, EFalse, 2, 9, _S("jklmn")},
       
  8062 			{ETrue, ETrue, EFalse, 2, 9, _S("\x200Djklmn\x200D")},
       
  8063 			{EFalse, ETrue, EFalse, 2, 9, _S("jklmn\x200D")},
       
  8064 			{ETrue, EFalse, EFalse, 2, 9, _S("\x200Djklmn")},
       
  8065 			{EFalse, EFalse, ETrue, 4, 8, _S("klmn")},
       
  8066 			{EFalse, EFalse, ETrue, 2, 9, _S("jklmn\x2029")},
       
  8067 			{ETrue, ETrue, ETrue, 2, 9, _S("\x200Djklmn\x200D\x2029")},
       
  8068 			{EFalse, ETrue, ETrue, 2, 9, _S("jklmn\x200D\x2029")},
       
  8069 			{ETrue, EFalse, ETrue, 2, 9, _S("\x200Djklmn\x2029")},
       
  8070 			{ETrue, ETrue, ETrue, 8, 9, _S("\x200D\x2029")},
       
  8071 			{ETrue, ETrue, ETrue, 8, 8, _S("")},
       
  8072 			{ETrue, ETrue, ETrue, 9, 9, _S("")},
       
  8073 			{ETrue, ETrue, ETrue, 4, 4, _S("")},
       
  8074 			{ETrue, ETrue, ETrue, 4, 5, _S("k")},
       
  8075 			{EFalse, EFalse, EFalse, 7, 4, _S("mlk")},
       
  8076 			{EFalse, EFalse, EFalse, 7, 3, _S("mlkj")},
       
  8077 			{EFalse, EFalse, EFalse, 8, 4, _S("nmlk")},
       
  8078 			{EFalse, EFalse, EFalse, 9, 2, _S("nmlkj")},
       
  8079 			{ETrue, ETrue, EFalse, 9, 2, _S("\x200Dnmlkj\x200D")},
       
  8080 			{EFalse, ETrue, EFalse, 9, 2, _S("\x200Dnmlkj")},
       
  8081 			{ETrue, EFalse, EFalse, 9, 2, _S("nmlkj\x200D")},
       
  8082 			{EFalse, EFalse, ETrue, 8, 4, _S("nmlk")},
       
  8083 			{EFalse, EFalse, ETrue, 9, 2, _S("\x2029nmlkj")},
       
  8084 			{ETrue, ETrue, ETrue, 9, 2, _S("\x2029\x200Dnmlkj\x200D")},
       
  8085 			{EFalse, ETrue, ETrue, 9, 2, _S("\x2029\x200Dnmlkj")},
       
  8086 			{ETrue, EFalse, ETrue, 9, 2, _S("\x2029nmlkj\x200D")},
       
  8087 			{ETrue, ETrue, ETrue, 9, 8, _S("\x2029\x200D")},
       
  8088 			{ETrue, ETrue, ETrue, 5, 4, _S("k")},
       
  8089 		};
       
  8090 	INFO_PRINTF1(_L("TRunInfoCompact::Reorder test\r\n"));
       
  8091 	TRunInfoCompact::TReorderingContext context;
       
  8092 	context.iSource = KLetters().Ptr();
       
  8093 	context.iStart = 3;
       
  8094 	context.iEnd = 8;
       
  8095 	TText buffer[20];
       
  8096 	TInt numTestCases = sizeof(testData)/sizeof(testData[0]);
       
  8097 	TBool allTestsPassed = ETrue;
       
  8098 	for (TInt i = 0; i != numTestCases; ++i)
       
  8099 		{
       
  8100 		TInt start = testData[i].iStart;
       
  8101 		TInt end = testData[i].iEnd;
       
  8102 		TBool reverse = EFalse;
       
  8103 		if (end < start)
       
  8104 			{
       
  8105 			reverse = ETrue;
       
  8106 			start = testData[i].iEnd;
       
  8107 			end = testData[i].iStart;
       
  8108 			}
       
  8109 		TInt length = end - start;
       
  8110 		TRunInfoCompact run(start, length, reverse);
       
  8111 		context.iJoinsAtStart = testData[i].iJoinsAtStart;
       
  8112 		context.iJoinsAtEnd = testData[i].iJoinsAtEnd;
       
  8113 		context.iTruncation = testData[i].iTruncated ? 0x2029 : 0xFFFF;
       
  8114 		TText* resultEnd = buffer;
       
  8115 		TRAPD(err, resultEnd = run.Reorder(buffer, context));
       
  8116 		TEST(err == KErrNone);
       
  8117 		TPtrC result(buffer, resultEnd - buffer);
       
  8118 		TPtrC expected(testData[i].iExpected);
       
  8119 		if(result.Compare(expected) != 0)
       
  8120 			{
       
  8121 			INFO_PRINTF2(_L("TRunInfoCompactReorderTest %d Failed\r\n"), i+1);
       
  8122 			PrintTestData(_L("Result "), result);
       
  8123 			PrintTestData(_L("Expected "), expected);
       
  8124 			allTestsPassed = EFalse;
       
  8125 			};
       
  8126 			
       
  8127 		}
       
  8128 		TEST(allTestsPassed);
       
  8129 	}
       
  8130 
       
  8131 /**
       
  8132  *
       
  8133  * void CTBiDi::TBidiLogicalToVisualGetVisualLineTest
       
  8134  *
       
  8135  * Tests functionality contained within TBidiLogicalToVisual
       
  8136  *
       
  8137  */
       
  8138 void CTBiDi::TBidiLogicalToVisualGetVisualLineTest()
       
  8139 	{
       
  8140 	TBidirectionalState::TRunInfo runArray[4];
       
  8141 	// only iStart, iLength and iDirection are important
       
  8142 	// logical: 0>0>0>0>0>3<3<3<1<1<1<1<2>2>2>2>2>2>
       
  8143 	// visual: 01234BA98CDEFGH765
       
  8144 	// This text would never really be re-ordered in this way.
       
  8145 	// Joiners are between 5 and 6, and 9 and 10.
       
  8146 	_LIT(KBidi, "GHIJK\x0643\x0631\x0644\x0621\x0645\x0627\x0639LMNOPQ");
       
  8147 	runArray[0].iStart = 0;
       
  8148 	runArray[0].iLength = 5;
       
  8149 	runArray[0].iDirection = 0;
       
  8150 	runArray[1].iStart = 8;
       
  8151 	runArray[1].iLength = 4;
       
  8152 	runArray[1].iDirection = 1;
       
  8153 	runArray[2].iStart = 12;
       
  8154 	runArray[2].iLength = 6;
       
  8155 	runArray[2].iDirection = 0;
       
  8156 	runArray[3].iStart = 5;
       
  8157 	runArray[3].iLength = 3;
       
  8158 	runArray[3].iDirection = 1;
       
  8159 
       
  8160 	TBidiLogicalToVisual conv(KBidi, EFalse, runArray, 4);
       
  8161 	// We won't call TBidiLogicalToVisual::Reorder(), because we are using the
       
  8162 	// data as-is as test data.
       
  8163 	static const struct {
       
  8164 		TInt iStart;
       
  8165 		TInt iEnd;
       
  8166 		TBool iTruncated;
       
  8167 		const TText* iExpected;
       
  8168 		}
       
  8169 		testData[] =
       
  8170 		{
       
  8171 			{0, 18, EFalse, _S("GHIJK\x0639\x0627\x0645\x0621LMNOPQ\x0644\x0631\x0643")},
       
  8172 			{0, 17, ETrue, _S("GHIJK\x0639\x0627\x0645\x0621LMNOP\x2026\x0644\x0631\x0643")},
       
  8173 			{0, 13, ETrue, _S("GHIJK\x0639\x0627\x0645\x0621L\x2026\x0644\x0631\x0643")},
       
  8174 			{0, 12, ETrue, _S("GHIJK\x0639\x0627\x0645\x0621\x2026\x0644\x0631\x0643")},
       
  8175 			{0, 11, ETrue, _S("GHIJK\x2026\x0627\x0645\x0621\x0644\x0631\x0643")},
       
  8176 			{0, 10, ETrue, _S("GHIJK\x2026\x200D\x0645\x0621\x0644\x0631\x0643")},
       
  8177 			{4, 10, EFalse, _S("K\x200D\x0645\x0621\x0644\x0631\x0643")},
       
  8178 			{5, 10, ETrue, _S("\x2026\x200D\x0645\x0621\x0644\x0631\x0643")},
       
  8179 			{6, 10, ETrue, _S("\x2026\x200D\x0645\x0621\x0644\x0631\x200D")},
       
  8180 			{7, 10, ETrue, _S("\x2026\x200D\x0645\x0621\x0644")},
       
  8181 			{8, 10, ETrue, _S("\x2026\x200D\x0645\x0621")},
       
  8182 			{8, 9, ETrue, _S("\x2026\x0621")},
       
  8183 			{8, 9, EFalse, _S("\x0621")},
       
  8184 			{9, 9, ETrue, _S("\x2026")},
       
  8185 		};
       
  8186 
       
  8187 	TBuf<100> result;
       
  8188 	TInt numTestCases = sizeof(testData)/sizeof(testData[0]);
       
  8189 	for (TInt i = 0; i != numTestCases; ++i)
       
  8190 		{
       
  8191 		conv.GetVisualLine(result,
       
  8192 			testData[i].iStart, testData[i].iEnd,
       
  8193 			testData[i].iTruncated? 0x2026 : 0xFFFF);
       
  8194 		TPtrC expected(testData[i].iExpected);
       
  8195 		TEST(0 == result.Compare(expected));
       
  8196 		}
       
  8197 	}
       
  8198 
       
  8199 /**
       
  8200 TBidiLogicalToVisualOOMTest
       
  8201 
       
  8202 This class contains functions that support tests based on the examples given by 
       
  8203 Unicode Standard Annexe 9
       
  8204 
       
  8205 The class contains methods for comparing an example text's logical order with it's display order
       
  8206 
       
  8207 */
       
  8208 class TBidiLogicalToVisualOOMTest : public MOOMTest
       
  8209 	{
       
  8210 	const TDesC* iText;
       
  8211 	TInt iStart;
       
  8212 	TInt iEnd;
       
  8213 	TBool iRightToLeft;
       
  8214 	const TDesC* iReorderedText;
       
  8215 	TInt iReturnValue;
       
  8216 	TBidirectionalState::TRunInfo* iRunInfoArray;
       
  8217 	TInt iRunInfoLength;
       
  8218 	TBuf<80> iLine;
       
  8219 	CTBiDi* iTest;
       
  8220 public:
       
  8221 	TBidiLogicalToVisualOOMTest(
       
  8222 		const TDesC& aText, 
       
  8223 		const TInt aStart,
       
  8224 		const TInt aEnd,
       
  8225 		const TBool aRightToLeft,
       
  8226 		const TDesC& aReorderedText,
       
  8227 		TBidirectionalState::TRunInfo* aRunInfoArray, 
       
  8228 		TInt aRunInfoLength,
       
  8229 		CTBiDi* aTest )
       
  8230 		:	iText(&aText), 
       
  8231 			iStart(aStart),
       
  8232 			iEnd(aEnd),
       
  8233 			iRightToLeft(aRightToLeft), 
       
  8234 			iReorderedText(&aReorderedText),
       
  8235 			iReturnValue(0) , 
       
  8236 			iRunInfoArray(aRunInfoArray),
       
  8237 			iRunInfoLength(aRunInfoLength),
       
  8238 			iTest(aTest)
       
  8239 		{
       
  8240 		}
       
  8241 	virtual ~TBidiLogicalToVisualOOMTest() { TearDown(); }
       
  8242 	void Initialize(const TDesC& aText, TInt aStart, TInt aEnd, TBool aRightToLeft,
       
  8243 		const TDesC& aReorderedText)
       
  8244 		{
       
  8245 		TearDown();
       
  8246 		iText = &aText;
       
  8247 		iStart = aStart;
       
  8248 		iEnd = aEnd;
       
  8249 		iRightToLeft = aRightToLeft;
       
  8250 		iReorderedText = &aReorderedText;
       
  8251 		}
       
  8252 	void SetUpL()
       
  8253 		{
       
  8254 		iLine.Zero();
       
  8255 		iReturnValue = 0;
       
  8256 		}
       
  8257 	void ManipulateL()
       
  8258 		{
       
  8259 		TBidiLogicalToVisual ltv(*iText, iRightToLeft, iRunInfoArray, iRunInfoLength);
       
  8260 		ltv.Reorder();	//map text to visual order
       
  8261 		ltv.GetVisualLine(iLine, iStart, iEnd, 0xFFFF);
       
  8262 		iTest->TEST(StringsMatch(iReorderedText->Ptr(), iReorderedText->Length(), iLine.Ptr(), iReorderedText->Length()));
       
  8263 		//Because this is an OOM test the contents of Line are the results of repeated calls, so the
       
  8264 		//length of iLine is greater than that of iReorderedText. However comparing the first copy suffices.
       
  8265 		//This won't detect the algorithm supplying more characters than expected, but other tests in the suite
       
  8266 		//will detect that.
       
  8267 		User::LeaveIfError(iReturnValue);
       
  8268 		}
       
  8269 	static TBool IsIgnorable(TText a)
       
  8270 		{
       
  8271 		TBool ignorable = EFalse;
       
  8272 		switch(a) {
       
  8273 			case KUnicodeNoSuchCharacter:
       
  8274 			case KUnicodeLeftToRightMark:
       
  8275 			case KUnicodeRightToLeftMark:
       
  8276 			case KUnicodeLeftToRightEmbedding:
       
  8277 			case KUnicodeRightToLeftEmbedding:
       
  8278 			case KUnicodePopDirectionFormat:
       
  8279 			case KUnicodeLeftToRightOverride:
       
  8280 			case KUnicodeRightToLeftOverride:
       
  8281 				ignorable = ETrue;
       
  8282 				break;
       
  8283 			default:
       
  8284 				break;
       
  8285 			}
       
  8286 		return ignorable;
       
  8287 		}
       
  8288 	static TBool StringsMatch(const TText* a1, TInt a1Len,
       
  8289 		const TText* a2, TInt a2Len)
       
  8290 		{
       
  8291 		const TText* a1End = a1 + a1Len;
       
  8292 		const TText* a2End = a2 + a2Len;
       
  8293 		for (;;)
       
  8294 			{
       
  8295 			while (a1 != a1End && IsIgnorable(*a1))
       
  8296 				++a1;
       
  8297 			while (a2 != a2End && IsIgnorable(*a2))
       
  8298 				++a2;
       
  8299 			if (a1 == a1End)
       
  8300 				return a2 == a2End;
       
  8301 			else if (a2 == a2End)
       
  8302 				return EFalse;
       
  8303 			if (*a1 != *a2)
       
  8304 				return EFalse;
       
  8305 			++a1;
       
  8306 			++a2;
       
  8307 			}
       
  8308 		}
       
  8309 	void TearDown()
       
  8310 		{
       
  8311 		iLine.Zero();
       
  8312 		}
       
  8313 	};
       
  8314 
       
  8315 void CTBiDi::DEF043323L()
       
  8316 	{
       
  8317 	const TUint16 KArabicPhrase[] =
       
  8318 		{
       
  8319 		KKaf, KAlef, KFeh, KYeh, KTeh, KYeh, KReh, KYeh, KAlef, KUnicodeSpace,
       
  8320 		KNoon, KAlef, KNoon, KAlef
       
  8321 		};
       
  8322 	const TUint16 KReversedArabicPhrase[] =
       
  8323 		{
       
  8324 		KAlef, KNoon, KAlef, KNoon,
       
  8325 		KUnicodeSpace, KAlef, KYeh, KReh, KYeh, KTeh, KYeh, KFeh, KAlef, KKaf,
       
  8326 		KEllipsis
       
  8327 		};
       
  8328 	TPtrC16 phrase(KArabicPhrase, sizeof(KArabicPhrase)/sizeof(KArabicPhrase[0]));
       
  8329 	TBidiText* text = TBidiText::NewL(phrase, 3);
       
  8330 	CleanupStack::PushL(text);
       
  8331 	CFont* font = new (ELeave) CTestFont;
       
  8332 	CleanupStack::PushL(font);
       
  8333 	// wrap to 3 lines, lengths 50/40/40, no truncation character
       
  8334 	text->WrapText(50, *font, 0);
       
  8335 	TEST(text->NumberOfLinesInDisplayText() == 3);
       
  8336 	TInt width;
       
  8337 	TPtrC16 line = text->LineOfDisplayText(0, width);
       
  8338 	TPtrC16 expectedLine(KReversedArabicPhrase + 9, 5);
       
  8339 	TEST(line.Find(expectedLine) != KErrNotFound);
       
  8340 	TEST(width == 50);
       
  8341 	line.Set( text->LineOfDisplayText(1, width));
       
  8342 	expectedLine.Set(KReversedArabicPhrase + 5, 4);
       
  8343 	TEST(line.Find(expectedLine) != KErrNotFound);
       
  8344 	TEST(width == 40);
       
  8345 	line.Set(text->LineOfDisplayText(2, width));
       
  8346 	expectedLine.Set(KReversedArabicPhrase, 4);
       
  8347 	TEST(line.Find(expectedLine) != KErrNotFound);
       
  8348 	TEST(width == 40);
       
  8349 	// wrap to 2 lines, lengths 90/40, no truncation character
       
  8350 	text->WrapText(90, *font, 0, 2);
       
  8351 	TEST(text->NumberOfLinesInDisplayText() == 2);
       
  8352 	text->WrapText(90, *font, 0, 3);
       
  8353 	TEST(text->NumberOfLinesInDisplayText() == 2);
       
  8354 	line.Set(text->LineOfDisplayText(0, width));
       
  8355 	expectedLine.Set(KReversedArabicPhrase + 5, 9);
       
  8356 	TEST(line.Find(expectedLine) != KErrNotFound);
       
  8357 	TEST(width == 90);
       
  8358 	line.Set(text->LineOfDisplayText(1, width));
       
  8359 	expectedLine.Set(KReversedArabicPhrase, 4);
       
  8360 	TEST(line.Find(expectedLine) != KErrNotFound);
       
  8361 	TEST(width == 40);
       
  8362 	// wrap to 2 lines, lengths 20/20, truncation character
       
  8363 	text->WrapText(20, *font, 0, 2);
       
  8364 	TEST(text->NumberOfLinesInDisplayText() == 2);
       
  8365 	line.Set(text->LineOfDisplayText(0, width));
       
  8366 	expectedLine.Set(KReversedArabicPhrase + 12, 2);
       
  8367 	TEST(line.Find(expectedLine) != KErrNotFound);
       
  8368 	TEST(width == 20);
       
  8369 	line.Set(text->LineOfDisplayText(1, width));
       
  8370 	TEST(width == 20);
       
  8371 	expectedLine.Set(KReversedArabicPhrase + 11, 1);
       
  8372 	TEST(line.Find(expectedLine) != KErrNotFound);
       
  8373 	expectedLine.Set(KReversedArabicPhrase + 14, 1);
       
  8374 	TEST(line.Find(expectedLine) != KErrNotFound);
       
  8375 	// lengths 30/30, truncation character
       
  8376 	text->WrapText(30, *font, 0, 2);
       
  8377 	TEST(text->NumberOfLinesInDisplayText() == 2);
       
  8378 	line.Set(text->LineOfDisplayText(0, width));
       
  8379 	expectedLine.Set(KReversedArabicPhrase + 11, 3);
       
  8380 	TEST(line.Find(expectedLine) != KErrNotFound);
       
  8381 	TEST(width == 30);
       
  8382 	line.Set(text->LineOfDisplayText(1, width));
       
  8383 	TEST(width == 30);
       
  8384 	expectedLine.Set(KReversedArabicPhrase + 9, 2);
       
  8385 	TEST(line.Find(expectedLine) != KErrNotFound);
       
  8386 	expectedLine.Set(KReversedArabicPhrase + 14, 1);
       
  8387 	TEST(line.Find(expectedLine) != KErrNotFound);
       
  8388 	// lengths 40/40, truncation character
       
  8389 	text->WrapText(40, *font, 0, 2);
       
  8390 	TEST(text->NumberOfLinesInDisplayText() == 2);
       
  8391 	line.Set(text->LineOfDisplayText(0, width));
       
  8392 	expectedLine.Set(KReversedArabicPhrase + 10, 4);
       
  8393 	TEST(line.Find(expectedLine) != KErrNotFound);
       
  8394 	TEST(width == 40);
       
  8395 	line.Set(text->LineOfDisplayText(1, width));
       
  8396 	TEST(width == 40);
       
  8397 	expectedLine.Set(KReversedArabicPhrase + 7, 3);
       
  8398 	TEST(line.Find(expectedLine) != KErrNotFound);
       
  8399 	expectedLine.Set(KReversedArabicPhrase + 14, 1);
       
  8400 	TEST(line.Find(expectedLine) != KErrNotFound);
       
  8401 	// lengths 50/50, truncation character
       
  8402 	text->WrapText(50, *font, 0, 2);
       
  8403 	TEST(text->NumberOfLinesInDisplayText() == 2);
       
  8404 	line.Set(text->LineOfDisplayText(0, width));
       
  8405 	expectedLine.Set(KReversedArabicPhrase + 9, 5);
       
  8406 	TEST(line.Find(expectedLine) != KErrNotFound);
       
  8407 	TEST(width == 50);
       
  8408 	line.Set(text->LineOfDisplayText(1, width));
       
  8409 	TEST(width == 50);
       
  8410 	expectedLine.Set(KReversedArabicPhrase + 5, 4);
       
  8411 	TEST(line.Find(expectedLine) != KErrNotFound);
       
  8412 	expectedLine.Set(KReversedArabicPhrase + 14, 1);
       
  8413 	TEST(line.Find(expectedLine) != KErrNotFound);
       
  8414 	// length 100, truncation character
       
  8415 	text->WrapText(100, *font, 0, 1);
       
  8416 	TEST(text->NumberOfLinesInDisplayText() == 1);
       
  8417 	line.Set(text->LineOfDisplayText(0, width));
       
  8418 	expectedLine.Set(KReversedArabicPhrase + 5, 9);
       
  8419 	TEST(line.Find(expectedLine) != KErrNotFound);
       
  8420 	TEST(width == 100);
       
  8421 	expectedLine.Set(KReversedArabicPhrase + 14, 1);
       
  8422 	TEST(line.Find(expectedLine) != KErrNotFound);
       
  8423 	// length 120, truncation character: this caught the defect
       
  8424 	text->WrapText(110, *font, 0, 1);
       
  8425 	TEST(text->NumberOfLinesInDisplayText() == 1);
       
  8426 	line.Set(text->LineOfDisplayText(0, width));
       
  8427 	// the space should not be present, so only 100 width
       
  8428 	expectedLine.Set(KReversedArabicPhrase + 5, 9);
       
  8429 	TEST(line.Find(expectedLine) != KErrNotFound);
       
  8430 	TEST(width == 100);
       
  8431 	expectedLine.Set(KReversedArabicPhrase + 14, 1);
       
  8432 	TEST(line.Find(expectedLine) != KErrNotFound);
       
  8433 	// length 120, truncation character
       
  8434 	text->WrapText(120, *font, 0, 1);
       
  8435 	TEST(text->NumberOfLinesInDisplayText() == 1);
       
  8436 	line.Set(text->LineOfDisplayText(0, width));
       
  8437 	expectedLine.Set(KReversedArabicPhrase + 3, 11);
       
  8438 	TEST(line.Find(expectedLine) != KErrNotFound);
       
  8439 	TEST(width == 120);
       
  8440 	expectedLine.Set(KReversedArabicPhrase + 14, 1);
       
  8441 	TEST(line.Find(expectedLine) != KErrNotFound);
       
  8442 	CleanupStack::PopAndDestroy(font);
       
  8443 	CleanupStack::PopAndDestroy(text);
       
  8444 	}
       
  8445 	
       
  8446 void CTBiDi::DEF052191L()
       
  8447 	{
       
  8448 	_LIT(KTwoLines, "First line.\nSecond line.");
       
  8449 	CFont* font = new (ELeave) CTestFont;
       
  8450 	CleanupStack::PushL(font);
       
  8451 	TBidiText* text = TBidiText::NewL(KTwoLines, 16);
       
  8452 	CleanupStack::PushL(text);
       
  8453 	text->WrapText(240, *font, NULL);
       
  8454 	TEST(text->NumberOfLinesInDisplayText() == 2);	//before the fix this used to return 3
       
  8455 	CleanupStack::PopAndDestroy(2); //font and text
       
  8456 	}
       
  8457 
       
  8458 /**
       
  8459    @SYMTestCaseID			GRAPHICS-GDI-BiDi-0007
       
  8460 
       
  8461    @SYMDEF					DEF105603
       
  8462 
       
  8463    @SYMTestCaseDesc			Test TBidirectionalState functionality (Unicode Bidirectional Algorithm impmentation withing SymbianOS)
       
  8464 
       
  8465    @SYMTestPriority			High
       
  8466 
       
  8467    @SYMTestStatus       	Implemented
       
  8468 
       
  8469    @SYMTestActions      	Test detection of 'overall' directionality of a given language/script under normal & OOM conditions
       
  8470 
       
  8471    @SYMTestExpectedResults	Confirmation the implementation conforms to the Unicode Birdirection Algorithm standard
       
  8472 */
       
  8473 void CTBiDi::TestBidiTextClassL()
       
  8474 	{
       
  8475 	INFO_PRINTF1(_L("Out of Memory Tests"));
       
  8476 	TBidiTextOOMTest toom(this);
       
  8477 	toom.Initialize(KHttsD, TBidiTextOOMTest::ELeftToRight, 1);
       
  8478 	TestOOML(toom);
       
  8479 	toom.Initialize(KHttsD, TBidiTextOOMTest::ERightToLeft, 1);
       
  8480 	TestOOML(toom);
       
  8481 	toom.Initialize(KHttsD, TBidiTextOOMTest::EAutomatic, 1);
       
  8482 	TestOOML(toom);
       
  8483 	toom.Initialize(KHttsD, TBidiTextOOMTest::ELeftToRight, 100);
       
  8484 	TestOOML(toom);
       
  8485 	toom.Initialize(KHttsD, TBidiTextOOMTest::ERightToLeft, 100);
       
  8486 	TestOOML(toom);
       
  8487 	toom.Initialize(KHttsD, TBidiTextOOMTest::EAutomatic, 100);
       
  8488 	TestOOML(toom);
       
  8489 	toom.Initialize(KMultiLine, TBidiTextOOMTest::ELeftToRight, 1);
       
  8490 	TestOOML(toom);
       
  8491 	toom.Initialize(KLineSep, TBidiTextOOMTest::ERightToLeft, 1);
       
  8492 	TestOOML(toom);
       
  8493 
       
  8494 	INFO_PRINTF1(_L("Panic"));
       
  8495 	INFO_PRINTF1(_L("Testing DrawText panic\r\n"));
       
  8496 	TEST (EBidiPanic_InvalidVisualOrderedTextLength == TestPanic(TestDrawTextPanicThread));
       
  8497 	INFO_PRINTF1(_L("Arabic with no line break opportunities"));
       
  8498 	NoLineBreakDrawTestL();
       
  8499 	INFO_PRINTF1(_L("Arabic with rare line break opportunities"));
       
  8500 	RightToLeftArabicDrawTestL();
       
  8501 	INFO_PRINTF1(_L("Latin"));
       
  8502 	LeftToRightDrawTestL();
       
  8503 	INFO_PRINTF1(_L("Glyph tests"));
       
  8504 	LigatureTestsL();
       
  8505 
       
  8506 	INFO_PRINTF1(_L("TRunInfoCompactReorder"));
       
  8507 	TRunInfoCompactReorderTest();
       
  8508 	// Need to test the rest of the TRunInfoCompact API as well.
       
  8509 
       
  8510 	INFO_PRINTF1(_L("Arabic Illegal Line breaks"));
       
  8511 	ArabicIllegalLinebreakTestsL();
       
  8512 
       
  8513 	INFO_PRINTF1(_L("DEF043323 - Alignment of TBidiText::DrawText() doesn't take the truncation char into account"));
       
  8514 	DEF043323L();
       
  8515 	INFO_PRINTF1(_L("DEF042191 - Problems with wraping in TBidiText"));
       
  8516 	DEF052191L();
       
  8517 	}
       
  8518 
       
  8519 /**
       
  8520    @SYMTestCaseID			GRAPHICS-GDI-BiDi-0008
       
  8521 
       
  8522    @SYMDEF					DEF105603
       
  8523 
       
  8524    @SYMTestCaseDesc			Test TBidirectionalState functionality (Unicode Bidirectional Algorithm impmentation withing SymbianOS)
       
  8525 
       
  8526    @SYMTestPriority			High
       
  8527 
       
  8528    @SYMTestStatus       	Implemented
       
  8529 
       
  8530    @SYMTestActions      	Test detection of 'overall' directionality of a given language/script
       
  8531 
       
  8532    @SYMTestExpectedResults	Confirmation the implementation conforms to the Unicode Birdirection Algorithm standard
       
  8533 */
       
  8534 void CTBiDi::TestBidiLogicalToVisualClassL()
       
  8535 	{
       
  8536 	static const TInt KRunInfoLength = 50;
       
  8537 	TBidirectionalState::TRunInfo runInfo[KRunInfoLength];
       
  8538 	INFO_PRINTF1(_L("TBidiVisual test - Out of Memory Tests\r\n"));
       
  8539 	TBidiLogicalToVisualOOMTest toom(KHttsL, 0, 14, ETrue, KHttsD, runInfo, KRunInfoLength, this);
       
  8540 	TestOOML(toom);
       
  8541 	toom.Initialize(KHttL, 0, 13, ETrue, KHttD);
       
  8542 	TestOOML(toom);
       
  8543 	toom.Initialize(KHttL, 0, 13, EFalse, KHttD);
       
  8544 	TestOOML(toom);
       
  8545 	toom.Initialize(KMixedL, 0, 5, ETrue, KMixedD);
       
  8546 	TestOOML(toom);
       
  8547 	toom.Initialize(KMixedL, 0, 5, EFalse, KMixedDL);
       
  8548 	TestOOML(toom);
       
  8549 	toom.Initialize(KHello, 0, 5, ETrue, KHello);
       
  8550 	TestOOML(toom);
       
  8551 	toom.Initialize(KHello, 0, 5, EFalse, KHello);
       
  8552 	TestOOML(toom);
       
  8553 	toom.Initialize(KHalalL, 0, 4, EFalse, KHalalD);
       
  8554 	TestOOML(toom);
       
  8555 	toom.Initialize(KHalalL, 0, 4, ETrue, KHalalD);
       
  8556 	TestOOML(toom);
       
  8557 
       
  8558 	TBidiLogicalToVisualGetVisualLineTest();
       
  8559 	}
       
  8560 
       
  8561 /**
       
  8562  *
       
  8563  * void CTBiDi::TestCatToNumber
       
  8564  * 
       
  8565  * Convert TBidirectionalState::TCategory into it's equivalent TChar::TBdCategory
       
  8566  *
       
  8567  */
       
  8568  void CTBiDi::TestCatToNumber(TInt aIn, TInt aOut)
       
  8569 	{
       
  8570 	TEST(TBidirectionalState::CatToNumber(aIn) == aOut);
       
  8571 	}
       
  8572 
       
  8573 
       
  8574 #define FILL_RUN_ARRAY(aTestArray, aRunArray, aContext) \
       
  8575 	CTBiDi::FillRunArray((aTestArray), (aRunArray), \
       
  8576 	sizeof((aTestArray))/sizeof((aTestArray)[0]), (aContext))
       
  8577 
       
  8578 void CTBiDi::FillRunArray(const TBdLevelTest* aTests, TBidirectionalState::TRunInfo* aRuns,
       
  8579 	TInt aArraySize, TBidirectionalState::TReorderContext& aContext)
       
  8580 	{
       
  8581 	aContext.iCategories = 0;
       
  8582 	aContext.iRuns = aArraySize;
       
  8583 	for (TInt i = 0; i != aArraySize; ++i)
       
  8584 		{
       
  8585 		TUint category = 1 << static_cast<TUint>(aTests[i].iCat);
       
  8586 		aContext.iCategories |= category;
       
  8587 		aRuns[i].iCategory = category;
       
  8588 		aRuns[i].iIndex = i;
       
  8589 		}
       
  8590 	}
       
  8591 
       
  8592 #define CHECK_RUN_RESULTS(aTestArray, aRunArray) \
       
  8593 	CheckRunResults((aTestArray), (aRunArray), \
       
  8594 	sizeof((aTestArray))/sizeof((aTestArray)[0]))
       
  8595 
       
  8596 void CTBiDi::CheckRunResults(const TBdLevelTest* aTests, TBidirectionalState::TRunInfo* aRuns,
       
  8597 	TInt aArraySize)
       
  8598 	{
       
  8599 	for (TInt i = 0; i != aArraySize; ++i)
       
  8600 		{
       
  8601 		const TBdLevelTest* currentTestData = aTests + i;
       
  8602 		TBidirectionalState::TRunInfo* currentRun = aRuns + i;
       
  8603 		if (currentTestData->iLevel != -1)
       
  8604 			{
       
  8605 			TUint category = 1 << static_cast<TUint>(currentTestData->iChangedCat);
       
  8606 			TEST(currentTestData->iLevel == currentRun->iEmbeddingLevel);
       
  8607 			TEST(category == currentRun->iCategory);
       
  8608 			}
       
  8609 		}
       
  8610 	}
       
  8611 
       
  8612 void CTBiDi::SetContext(TBidirectionalState::TReorderContext& aContext,
       
  8613 	TChar::TBdCategory aCat)
       
  8614 	{
       
  8615 	TInt cat = 1 << static_cast<TInt>(aCat);
       
  8616 	// big axe
       
  8617 	TInt* p = reinterpret_cast<TInt*> (&(aContext.iNextStrongCategory));
       
  8618 	*p = cat;
       
  8619 	p = reinterpret_cast<TInt*> (&(aContext.iNextCategory));
       
  8620 	*p = cat;
       
  8621 	}
       
  8622 
       
  8623 //test data for TestTBidirectionalStateInternalsL
       
  8624 
       
  8625 // test X1, X2, X3, X4, X5, X6, X7
       
  8626 // (X8 does not apply to ReorderLine: should not contain multiple paragraphs)
       
  8627 // (X9 and X10 should not be tested explicitly at this level)
       
  8628 static const TBdLevelTest KXTests[] =
       
  8629 	{
       
  8630 
       
  8631 	{TChar::ERightToLeftEmbedding, -1, TChar::EOtherNeutral},
       
  8632 	{TChar::EOtherNeutral, 1, TChar::EOtherNeutral},
       
  8633 	{TChar::ELeftToRightEmbedding, -1, TChar::EOtherNeutral},
       
  8634 	{TChar::EOtherNeutral, 2, TChar::EOtherNeutral},
       
  8635 	{TChar::ELeftToRightEmbedding, -1, TChar::EOtherNeutral},
       
  8636 	{TChar::EOtherNeutral, 4, TChar::EOtherNeutral},
       
  8637 	{TChar::ELeftToRightOverride, -1, TChar::EOtherNeutral},
       
  8638 	{TChar::EOtherNeutral, 6, TChar::ELeftToRight},
       
  8639 	{TChar::ERightToLeftOverride, -1, TChar::EOtherNeutral},
       
  8640 	{TChar::EOtherNeutral, 7, TChar::ERightToLeft},
       
  8641 	{TChar::ERightToLeftOverride, -1, TChar::EOtherNeutral},
       
  8642 	{TChar::EOtherNeutral, 9, TChar::ERightToLeft},
       
  8643 	{TChar::ELeftToRightOverride, -1, TChar::EOtherNeutral},
       
  8644 	{TChar::EOtherNeutral, 10, TChar::ELeftToRight},
       
  8645 	{TChar::ELeftToRightOverride, -1, TChar::EOtherNeutral},
       
  8646 	{TChar::EOtherNeutral, 12, TChar::ELeftToRight},
       
  8647 	{TChar::ERightToLeftEmbedding, -1, TChar::EOtherNeutral},
       
  8648 	{TChar::EOtherNeutral, 13, TChar::EOtherNeutral},
       
  8649 	{TChar::ERightToLeftOverride, -1, TChar::EOtherNeutral},
       
  8650 	{TChar::EPopDirectionalFormat, -1, TChar::EOtherNeutral},
       
  8651 	{TChar::EOtherNeutral, 13, TChar::EOtherNeutral},
       
  8652 	{TChar::ERightToLeftEmbedding, -1, TChar::EOtherNeutral},
       
  8653 	{TChar::EOtherNeutral, 15, TChar::EOtherNeutral},
       
  8654 	{TChar::ERightToLeftOverride, -1, TChar::EOtherNeutral},
       
  8655 	{TChar::ERightToLeftOverride, -1, TChar::EOtherNeutral},
       
  8656 	{TChar::ERightToLeftOverride, -1, TChar::EOtherNeutral},
       
  8657 	{TChar::ERightToLeftOverride, -1, TChar::EOtherNeutral},
       
  8658 	{TChar::ERightToLeftOverride, -1, TChar::EOtherNeutral},
       
  8659 	{TChar::ERightToLeftOverride, -1, TChar::EOtherNeutral},
       
  8660 	{TChar::ERightToLeftOverride, -1, TChar::EOtherNeutral},
       
  8661 	{TChar::ERightToLeftOverride, -1, TChar::EOtherNeutral},
       
  8662 	{TChar::ERightToLeftOverride, -1, TChar::EOtherNeutral},
       
  8663 	{TChar::ERightToLeftOverride, -1, TChar::EOtherNeutral},
       
  8664 	{TChar::EOtherNeutral, 35, TChar::ERightToLeft},
       
  8665 	{TChar::ERightToLeftOverride, -1, TChar::EOtherNeutral},
       
  8666 	{TChar::ERightToLeftOverride, -1, TChar::EOtherNeutral},
       
  8667 	{TChar::ERightToLeftOverride, -1, TChar::EOtherNeutral},
       
  8668 	{TChar::ERightToLeftOverride, -1, TChar::EOtherNeutral},
       
  8669 	{TChar::ERightToLeftOverride, -1, TChar::EOtherNeutral},
       
  8670 	{TChar::ERightToLeftOverride, -1, TChar::EOtherNeutral},
       
  8671 	{TChar::ERightToLeftOverride, -1, TChar::EOtherNeutral},
       
  8672 	{TChar::ERightToLeftOverride, -1, TChar::EOtherNeutral},
       
  8673 	{TChar::ERightToLeftOverride, -1, TChar::EOtherNeutral},
       
  8674 	{TChar::ERightToLeftOverride, -1, TChar::EOtherNeutral},
       
  8675 	{TChar::EOtherNeutral, 55, TChar::ERightToLeft},
       
  8676 	{TChar::ERightToLeftOverride, -1, TChar::EOtherNeutral},
       
  8677 	{TChar::ERightToLeftOverride, -1, TChar::EOtherNeutral},
       
  8678 	{TChar::ELeftToRightOverride, -1, TChar::EOtherNeutral},
       
  8679 	{TChar::EOtherNeutral, 60, TChar::ELeftToRight},
       
  8680 	{TChar::ELeftToRightOverride, -1, TChar::EOtherNeutral},	// should not alter directionality
       
  8681 	{TChar::ELeftToRightOverride, -1, TChar::EOtherNeutral},	// should not alter directionality
       
  8682 	{TChar::ELeftToRightOverride, -1, TChar::EOtherNeutral},	// should not alter directionality
       
  8683 	{TChar::EOtherNeutral, 60, TChar::ELeftToRight},
       
  8684 	{TChar::ERightToLeftEmbedding, -1, TChar::EOtherNeutral},
       
  8685 	{TChar::EOtherNeutral, 61, TChar::EOtherNeutral},
       
  8686 	{TChar::ELeftToRightOverride, -1, TChar::EOtherNeutral},	// should not alter directionality
       
  8687 	{TChar::ELeftToRightOverride, -1, TChar::EOtherNeutral},	// should not alter directionality
       
  8688 	{TChar::EOtherNeutral, 61, TChar::EOtherNeutral},
       
  8689 	{TChar::EPopDirectionalFormat, -1, TChar::EOtherNeutral},	// matches ignored code
       
  8690 	{TChar::EOtherNeutral, 61, TChar::EOtherNeutral},
       
  8691 	{TChar::EPopDirectionalFormat, -1, TChar::EOtherNeutral},	// matches ignored code
       
  8692 	{TChar::EOtherNeutral, 61, TChar::EOtherNeutral},
       
  8693 	{TChar::EPopDirectionalFormat, -1, TChar::EOtherNeutral},
       
  8694 	{TChar::EOtherNeutral, 60, TChar::ELeftToRight},
       
  8695 	{TChar::EPopDirectionalFormat, -1, TChar::EOtherNeutral},	// matches ignored code
       
  8696 	{TChar::EOtherNeutral, 60, TChar::ELeftToRight},
       
  8697 	{TChar::EPopDirectionalFormat, -1, TChar::EOtherNeutral},	// matches ignored code
       
  8698 	{TChar::EOtherNeutral, 60, TChar::ELeftToRight},
       
  8699 	{TChar::EPopDirectionalFormat, -1, TChar::EOtherNeutral},	// matches ignored code
       
  8700 	{TChar::EOtherNeutral, 60, TChar::ELeftToRight},
       
  8701 	{TChar::EPopDirectionalFormat, -1, TChar::EOtherNeutral},
       
  8702 	{TChar::EPopDirectionalFormat, -1, TChar::EOtherNeutral},
       
  8703 	{TChar::EPopDirectionalFormat, -1, TChar::EOtherNeutral},
       
  8704 	{TChar::EOtherNeutral, 55, TChar::ERightToLeft},
       
  8705 	{TChar::EPopDirectionalFormat, -1, TChar::EOtherNeutral},
       
  8706 	{TChar::EPopDirectionalFormat, -1, TChar::EOtherNeutral},
       
  8707 	{TChar::EPopDirectionalFormat, -1, TChar::EOtherNeutral},
       
  8708 	{TChar::EPopDirectionalFormat, -1, TChar::EOtherNeutral},
       
  8709 	{TChar::EPopDirectionalFormat, -1, TChar::EOtherNeutral},
       
  8710 	{TChar::EPopDirectionalFormat, -1, TChar::EOtherNeutral},
       
  8711 	{TChar::EPopDirectionalFormat, -1, TChar::EOtherNeutral},
       
  8712 	{TChar::EPopDirectionalFormat, -1, TChar::EOtherNeutral},
       
  8713 	{TChar::EPopDirectionalFormat, -1, TChar::EOtherNeutral},
       
  8714 	{TChar::EPopDirectionalFormat, -1, TChar::EOtherNeutral},
       
  8715 	{TChar::EOtherNeutral, 35, TChar::ERightToLeft},
       
  8716 	{TChar::EPopDirectionalFormat, -1, TChar::EOtherNeutral},
       
  8717 	{TChar::EPopDirectionalFormat, -1, TChar::EOtherNeutral},
       
  8718 	{TChar::EPopDirectionalFormat, -1, TChar::EOtherNeutral},
       
  8719 	{TChar::EPopDirectionalFormat, -1, TChar::EOtherNeutral},
       
  8720 	{TChar::EPopDirectionalFormat, -1, TChar::EOtherNeutral},
       
  8721 	{TChar::EPopDirectionalFormat, -1, TChar::EOtherNeutral},
       
  8722 	{TChar::EPopDirectionalFormat, -1, TChar::EOtherNeutral},
       
  8723 	{TChar::EPopDirectionalFormat, -1, TChar::EOtherNeutral},
       
  8724 	{TChar::EPopDirectionalFormat, -1, TChar::EOtherNeutral},
       
  8725 	{TChar::EPopDirectionalFormat, -1, TChar::EOtherNeutral},
       
  8726 	{TChar::EOtherNeutral, 15, TChar::EOtherNeutral},
       
  8727 	{TChar::EPopDirectionalFormat, -1, TChar::EOtherNeutral},
       
  8728 	{TChar::EOtherNeutral, 13, TChar::EOtherNeutral},
       
  8729 	{TChar::EPopDirectionalFormat, -1, TChar::EOtherNeutral},
       
  8730 	{TChar::EOtherNeutral, 12, TChar::ELeftToRight},
       
  8731 	{TChar::EPopDirectionalFormat, -1, TChar::EOtherNeutral},
       
  8732 	{TChar::EOtherNeutral, 10, TChar::ELeftToRight},
       
  8733 	{TChar::EPopDirectionalFormat, -1, TChar::EOtherNeutral},
       
  8734 	{TChar::EOtherNeutral, 9, TChar::ERightToLeft},
       
  8735 	{TChar::EPopDirectionalFormat, -1, TChar::EOtherNeutral},
       
  8736 	{TChar::EOtherNeutral, 7, TChar::ERightToLeft},
       
  8737 	{TChar::EPopDirectionalFormat, -1, TChar::EOtherNeutral},
       
  8738 	{TChar::EOtherNeutral, 6, TChar::ELeftToRight},
       
  8739 	{TChar::EPopDirectionalFormat, -1, TChar::EOtherNeutral},
       
  8740 	{TChar::EOtherNeutral, 4, TChar::EOtherNeutral},
       
  8741 	{TChar::EPopDirectionalFormat, -1, TChar::EOtherNeutral},
       
  8742 	{TChar::EOtherNeutral, 2, TChar::EOtherNeutral},
       
  8743 	{TChar::EPopDirectionalFormat, -1, TChar::EOtherNeutral},
       
  8744 	{TChar::EOtherNeutral, 1, TChar::EOtherNeutral},
       
  8745 	{TChar::EPopDirectionalFormat, -1, TChar::EOtherNeutral},
       
  8746 	{TChar::EOtherNeutral, 0, TChar::EOtherNeutral}
       
  8747 	};
       
  8748 
       
  8749 static const TBdLevelTest KW123TestsL[] =
       
  8750 	{
       
  8751 	{TChar::ENonSpacingMark, 0, TChar::ELeftToRight},
       
  8752 	{TChar::EEuropeanNumber, 0, TChar::EEuropeanNumber},
       
  8753 	{TChar::ERightToLeftEmbedding, -1, TChar::EOtherNeutral},
       
  8754 	{TChar::ENonSpacingMark, 1, TChar::ERightToLeft},
       
  8755 	{TChar::ELeftToRight, -1, TChar::EOtherNeutral},
       
  8756 	{TChar::ENonSpacingMark, 1, TChar::ELeftToRight},
       
  8757 	{TChar::EEuropeanNumber, 1, TChar::EEuropeanNumber},
       
  8758 	{TChar::ERightToLeftArabic, 1, TChar::ERightToLeft},
       
  8759 	{TChar::ENonSpacingMark, 1, TChar::ERightToLeft},
       
  8760 	{TChar::EOtherNeutral, -1, TChar::EOtherNeutral},
       
  8761 	{TChar::ENonSpacingMark, 1, TChar::EOtherNeutral},
       
  8762 	{TChar::EEuropeanNumber, 1, TChar::EArabicNumber}
       
  8763 	};
       
  8764 
       
  8765 static const TBdLevelTest KW123TestsR[] =
       
  8766 	{
       
  8767 	{TChar::ENonSpacingMark, 1, TChar::ERightToLeft},
       
  8768 	{TChar::EEuropeanNumber, 1, TChar::EEuropeanNumber},
       
  8769 	{TChar::ENonSpacingMark, 1, TChar::EEuropeanNumber},
       
  8770 	{TChar::ELeftToRightEmbedding, -1, TChar::EOtherNeutral},
       
  8771 	{TChar::ENonSpacingMark, 2, TChar::ELeftToRight},
       
  8772 	{TChar::ELeftToRight, -1, TChar::EOtherNeutral},
       
  8773 	{TChar::ENonSpacingMark, 2, TChar::ELeftToRight},
       
  8774 	{TChar::EWhitespace, -1, TChar::EOtherNeutral},
       
  8775 	{TChar::ENonSpacingMark, 2, TChar::EWhitespace},
       
  8776 	{TChar::EOtherNeutral, -1, TChar::EOtherNeutral},
       
  8777 	{TChar::ENonSpacingMark, 2, TChar::EOtherNeutral}
       
  8778 	};
       
  8779 
       
  8780 
       
  8781 static const TBdLevelTest KW456Tests[] =
       
  8782 	{
       
  8783 	{TChar::EEuropeanNumber, 0, TChar::EEuropeanNumber},
       
  8784 	{TChar::EEuropeanNumberSeparator, 0, TChar::EEuropeanNumber},	// W4
       
  8785 	{TChar::EEuropeanNumber, 0, TChar::EEuropeanNumber},
       
  8786 	{TChar::EEuropeanNumber, 0, TChar::EEuropeanNumber},
       
  8787 	{TChar::ECommonNumberSeparator, 0, TChar::EEuropeanNumber},	// W4
       
  8788 	{TChar::EEuropeanNumber, 0, TChar::EEuropeanNumber},
       
  8789 	{TChar::EArabicNumber, 0, TChar::EArabicNumber},
       
  8790 	{TChar::ECommonNumberSeparator, 0, TChar::EArabicNumber},	// W4
       
  8791 	{TChar::EArabicNumber, 0, TChar::EArabicNumber},
       
  8792 	{TChar::EOtherNeutral, 0, TChar::EOtherNeutral},
       
  8793 	{TChar::EEuropeanNumberTerminator, 0, TChar::EEuropeanNumber},	// W5
       
  8794 	{TChar::EEuropeanNumberTerminator, 0, TChar::EEuropeanNumber},	// W5
       
  8795 	{TChar::EEuropeanNumber, 0, TChar::EEuropeanNumber},
       
  8796 	{TChar::EEuropeanNumberTerminator, 0, TChar::EEuropeanNumber},	// W5
       
  8797 	{TChar::EEuropeanNumberTerminator, 0, TChar::EEuropeanNumber},	// W5
       
  8798 	{TChar::EOtherNeutral, 0, TChar::EOtherNeutral},
       
  8799 	{TChar::EArabicNumber, 0, TChar::EArabicNumber},
       
  8800 	{TChar::EEuropeanNumberTerminator, 0, TChar::EEuropeanNumber},	// W5
       
  8801 	{TChar::EEuropeanNumber, 0, TChar::EEuropeanNumber},
       
  8802 	{TChar::EOtherNeutral, 0, TChar::EOtherNeutral},
       
  8803 	{TChar::EEuropeanNumber, 0, TChar::EEuropeanNumber},
       
  8804 	{TChar::EEuropeanNumberSeparator, 0, TChar::EOtherNeutral},	// W6
       
  8805 	{TChar::EEuropeanNumberSeparator, 0, TChar::EOtherNeutral},	// W6
       
  8806 	{TChar::EEuropeanNumber, 0, TChar::EEuropeanNumber},
       
  8807 	{TChar::EArabicNumber, 0, TChar::EArabicNumber},
       
  8808 	{TChar::EEuropeanNumberTerminator, 0, TChar::EOtherNeutral},	// W6
       
  8809 	{TChar::EOtherNeutral, 0, TChar::EOtherNeutral},
       
  8810 	{TChar::ELeftToRight, 0, TChar::ELeftToRight},
       
  8811 	{TChar::EEuropeanNumberSeparator, 0, TChar::EOtherNeutral},	// W6
       
  8812 	{TChar::EEuropeanNumber, 0, TChar::EEuropeanNumber},
       
  8813 	{TChar::ELeftToRight, 0, TChar::ELeftToRight},
       
  8814 	{TChar::EEuropeanNumberSeparator, 0, TChar::EOtherNeutral},	// W6
       
  8815 	{TChar::EEuropeanNumberSeparator, 0, TChar::EOtherNeutral},	// W6
       
  8816 	{TChar::EEuropeanNumberSeparator, 0, TChar::EOtherNeutral},	// W6
       
  8817 	{TChar::EEuropeanNumber, 0, TChar::EEuropeanNumber},
       
  8818 	{TChar::EEuropeanNumberSeparator, 0, TChar::EOtherNeutral},	// W6
       
  8819 	{TChar::EArabicNumber, 0, TChar::EArabicNumber},
       
  8820 	{TChar::EEuropeanNumberTerminator, 0, TChar::EOtherNeutral},	// W6
       
  8821 	{TChar::EArabicNumber, 0, TChar::EArabicNumber},
       
  8822 	};
       
  8823 
       
  8824 
       
  8825 static const TBdLevelTest KW7TestsL[] =
       
  8826 	{
       
  8827 	{TChar::EEuropeanNumber, 0, TChar::ELeftToRight},
       
  8828 	{TChar::EOtherNeutral, 0, TChar::EOtherNeutral},
       
  8829 	{TChar::ELeftToRight, 0, TChar::ELeftToRight},
       
  8830 	{TChar::EOtherNeutral, 0, TChar::EOtherNeutral},
       
  8831 	{TChar::EOtherNeutral, 0, TChar::EOtherNeutral},
       
  8832 	{TChar::EOtherNeutral, 0, TChar::EOtherNeutral},
       
  8833 	{TChar::EOtherNeutral, 0, TChar::EOtherNeutral},
       
  8834 	{TChar::EOtherNeutral, 0, TChar::EOtherNeutral},
       
  8835 	{TChar::EEuropeanNumber, 0, TChar::ELeftToRight},
       
  8836 	{TChar::ERightToLeft, 0, TChar::ERightToLeft},
       
  8837 	{TChar::EOtherNeutral, 0, TChar::EOtherNeutral},
       
  8838 	{TChar::EOtherNeutral, 0, TChar::EOtherNeutral},
       
  8839 	{TChar::EOtherNeutral, 0, TChar::EOtherNeutral},
       
  8840 	{TChar::EOtherNeutral, 0, TChar::EOtherNeutral},
       
  8841 	{TChar::EOtherNeutral, 0, TChar::EOtherNeutral},
       
  8842 	{TChar::EEuropeanNumber, 0, TChar::EEuropeanNumber},
       
  8843 	{TChar::EOtherNeutral, 0, TChar::EOtherNeutral},
       
  8844 	{TChar::ERightToLeftEmbedding, -1, TChar::EOtherNeutral},
       
  8845 	{TChar::EEuropeanNumber, 1, TChar::EEuropeanNumber},
       
  8846 	{TChar::ELeftToRightEmbedding, -1, TChar::EOtherNeutral},
       
  8847 	{TChar::EEuropeanNumber, 2, TChar::ELeftToRight},
       
  8848 	{TChar::EPopDirectionalFormat, -1, TChar::EOtherNeutral},
       
  8849 	{TChar::EEuropeanNumber, 1, TChar::ELeftToRight},
       
  8850 	{TChar::EPopDirectionalFormat, -1, TChar::EOtherNeutral},
       
  8851 	{TChar::EEuropeanNumber, 0, TChar::EEuropeanNumber},
       
  8852 	};
       
  8853 
       
  8854 static const TBdLevelTest KW7TestsR[] =
       
  8855 	{
       
  8856 	{TChar::EEuropeanNumber, 0, TChar::EEuropeanNumber},
       
  8857 	};
       
  8858 
       
  8859 static const TBdLevelTest KN12TestsL[] =
       
  8860 	{
       
  8861 	{TChar::EOtherNeutral, 0, TChar::ELeftToRight},
       
  8862 	{TChar::ELeftToRight, 0, TChar::ELeftToRight},
       
  8863 	{TChar::EOtherNeutral, 0, TChar::ELeftToRight},
       
  8864 	{TChar::EOtherNeutral, 0, TChar::ELeftToRight},
       
  8865 	{TChar::EOtherNeutral, 0, TChar::ELeftToRight},
       
  8866 	{TChar::ELeftToRight, 0, TChar::ELeftToRight},
       
  8867 	{TChar::ERightToLeft, 0, TChar::ERightToLeft},
       
  8868 	{TChar::EOtherNeutral, 0, TChar::ERightToLeft},
       
  8869 	{TChar::EOtherNeutral, 0, TChar::ERightToLeft},
       
  8870 	{TChar::EOtherNeutral, 0, TChar::ERightToLeft},
       
  8871 	{TChar::ERightToLeft, 0, TChar::ERightToLeft},
       
  8872 	{TChar::EOtherNeutral, 0, TChar::ERightToLeft},
       
  8873 	{TChar::EOtherNeutral, 0, TChar::ERightToLeft},
       
  8874 	{TChar::EArabicNumber, 0, TChar::EArabicNumber},
       
  8875 	{TChar::EOtherNeutral, 0, TChar::ERightToLeft},
       
  8876 	{TChar::ERightToLeft, 0, TChar::ERightToLeft},
       
  8877 	{TChar::ERightToLeft, 0, TChar::ERightToLeft},
       
  8878 	{TChar::EOtherNeutral, 0, TChar::ERightToLeft},
       
  8879 	{TChar::EEuropeanNumber, 0, TChar::EEuropeanNumber},
       
  8880 	{TChar::EOtherNeutral, 0, TChar::ERightToLeft},
       
  8881 	{TChar::ERightToLeft, 0, TChar::ERightToLeft},
       
  8882 	{TChar::EEuropeanNumber, 0, TChar::EEuropeanNumber},
       
  8883 	{TChar::EOtherNeutral, 0, TChar::ERightToLeft},
       
  8884 	{TChar::EOtherNeutral, 0, TChar::ERightToLeft},
       
  8885 	{TChar::EArabicNumber, 0, TChar::EArabicNumber},
       
  8886 	{TChar::EOtherNeutral, 0, TChar::ERightToLeft},
       
  8887 	{TChar::EArabicNumber, 0, TChar::EArabicNumber},
       
  8888 	{TChar::EOtherNeutral, 0, TChar::ELeftToRight},
       
  8889 	{TChar::ELeftToRight, 0, TChar::ELeftToRight},
       
  8890 	{TChar::EOtherNeutral, 0, TChar::ELeftToRight},
       
  8891 	{TChar::EOtherNeutral, 0, TChar::ELeftToRight},
       
  8892 	{TChar::EOtherNeutral, 0, TChar::ELeftToRight},
       
  8893 	{TChar::ERightToLeft, 0, TChar::ERightToLeft},
       
  8894 	{TChar::EOtherNeutral, 0, TChar::ELeftToRight},
       
  8895 	{TChar::ELeftToRight, 0, TChar::ELeftToRight},
       
  8896 	{TChar::EOtherNeutral, 0, TChar::ELeftToRight},
       
  8897 	{TChar::EArabicNumber, 0, TChar::EArabicNumber},
       
  8898 	{TChar::EOtherNeutral, 0, TChar::ERightToLeft},
       
  8899 	{TChar::EArabicNumber, 0, TChar::EArabicNumber},
       
  8900 	{TChar::ELeftToRight, 0, TChar::ELeftToRight},
       
  8901 	{TChar::EOtherNeutral, 0, TChar::ELeftToRight},
       
  8902 	};
       
  8903 
       
  8904 static const TBdLevelTest KN12TestsR[] =
       
  8905 	{
       
  8906 	{TChar::EOtherNeutral, 1, TChar::ERightToLeft},
       
  8907 	{TChar::ELeftToRight, 1, TChar::ELeftToRight},
       
  8908 	{TChar::EOtherNeutral, 1, TChar::ELeftToRight},
       
  8909 	{TChar::EOtherNeutral, 1, TChar::ELeftToRight},
       
  8910 	{TChar::EOtherNeutral, 1, TChar::ELeftToRight},
       
  8911 	{TChar::ELeftToRight, 1, TChar::ELeftToRight},
       
  8912 	{TChar::ERightToLeft, 1, TChar::ERightToLeft},
       
  8913 	{TChar::EOtherNeutral, 1, TChar::ERightToLeft},
       
  8914 	{TChar::EOtherNeutral, 1, TChar::ERightToLeft},
       
  8915 	{TChar::EOtherNeutral, 1, TChar::ERightToLeft},
       
  8916 	{TChar::ERightToLeft, 1, TChar::ERightToLeft},
       
  8917 	{TChar::EOtherNeutral, 1, TChar::ERightToLeft},
       
  8918 	{TChar::EOtherNeutral, 1, TChar::ERightToLeft},
       
  8919 	{TChar::EArabicNumber, 1, TChar::EArabicNumber},
       
  8920 	{TChar::EOtherNeutral, 1, TChar::ERightToLeft},
       
  8921 	{TChar::ERightToLeft, 1, TChar::ERightToLeft},
       
  8922 	{TChar::ERightToLeft, 1, TChar::ERightToLeft},
       
  8923 	{TChar::EOtherNeutral, 1, TChar::ERightToLeft},
       
  8924 	{TChar::EEuropeanNumber, 1, TChar::EEuropeanNumber},
       
  8925 	{TChar::EOtherNeutral, 1, TChar::ERightToLeft},
       
  8926 	{TChar::ERightToLeft, 1, TChar::ERightToLeft},
       
  8927 	{TChar::EEuropeanNumber, 1, TChar::EEuropeanNumber},
       
  8928 	{TChar::EOtherNeutral, 1, TChar::ERightToLeft},
       
  8929 	{TChar::EOtherNeutral, 1, TChar::ERightToLeft},
       
  8930 	{TChar::EArabicNumber, 1, TChar::EArabicNumber},
       
  8931 	{TChar::EOtherNeutral, 1, TChar::ERightToLeft},
       
  8932 	{TChar::EArabicNumber, 1, TChar::EArabicNumber},
       
  8933 	{TChar::EOtherNeutral, 1, TChar::ERightToLeft},
       
  8934 	{TChar::ELeftToRight, 1, TChar::ELeftToRight},
       
  8935 	{TChar::EOtherNeutral, 1, TChar::ERightToLeft},
       
  8936 	{TChar::EOtherNeutral, 1, TChar::ERightToLeft},
       
  8937 	{TChar::EOtherNeutral, 1, TChar::ERightToLeft},
       
  8938 	{TChar::ERightToLeft, 1, TChar::ERightToLeft},
       
  8939 	{TChar::EOtherNeutral, 1, TChar::ERightToLeft},
       
  8940 	{TChar::ELeftToRight, 1, TChar::ELeftToRight},
       
  8941 	{TChar::ERightToLeft, 1, TChar::ERightToLeft},
       
  8942 	{TChar::EOtherNeutral, 1, TChar::ERightToLeft},
       
  8943 	};
       
  8944 
       
  8945 static const TBdLevelTest KN12TestsRRL[] =
       
  8946 	{
       
  8947 	{TChar::EOtherNeutral, 1, TChar::ERightToLeft},
       
  8948 	{TChar::ERightToLeft, 1, TChar::ERightToLeft},
       
  8949 	{TChar::EOtherNeutral, 1, TChar::ERightToLeft},
       
  8950 	{TChar::ELeftToRight, 1, TChar::ELeftToRight},
       
  8951 	{TChar::EOtherNeutral, 1, TChar::ELeftToRight}
       
  8952 	};
       
  8953 
       
  8954 static const TBdLevelTest KN12TestsLRR[] =
       
  8955 	{
       
  8956 	{TChar::EOtherNeutral, 1, TChar::ELeftToRight},
       
  8957 	{TChar::ELeftToRight, 1, TChar::ELeftToRight},
       
  8958 	{TChar::EOtherNeutral, 1, TChar::ERightToLeft},
       
  8959 	{TChar::ERightToLeft, 1, TChar::ERightToLeft},
       
  8960 	{TChar::EOtherNeutral, 1, TChar::ERightToLeft}
       
  8961 	};
       
  8962 
       
  8963 // Test that pop directional format as the final context does the
       
  8964 // right thing, and that embedded directionalities are taken
       
  8965 // into account.
       
  8966 static const TBdLevelTest KN12TestsLRP[] =
       
  8967 	{
       
  8968 	{TChar::EOtherNeutral, 1, TChar::ELeftToRight},
       
  8969 	{TChar::ELeftToRightEmbedding, -1, TChar::EOtherNeutral},
       
  8970 	{TChar::ERightToLeft, 2, TChar::ERightToLeft},
       
  8971 	{TChar::EOtherNeutral, 2, TChar::ELeftToRight},
       
  8972 	{TChar::ELeftToRight, 2, TChar::ELeftToRight},
       
  8973 	{TChar::EOtherNeutral, 2, TChar::ELeftToRight}
       
  8974 	};
       
  8975 
       
  8976 static const TBdLevelTest KN12TestsRLP[] =
       
  8977 	{
       
  8978 	{TChar::EOtherNeutral, 0, TChar::ERightToLeft},
       
  8979 	{TChar::ERightToLeftEmbedding, -1, TChar::EOtherNeutral},
       
  8980 	{TChar::ELeftToRight, 1, TChar::ELeftToRight},
       
  8981 	{TChar::EOtherNeutral, 1, TChar::ERightToLeft},
       
  8982 	{TChar::ERightToLeft, 1, TChar::ERightToLeft},
       
  8983 	{TChar::EOtherNeutral, 1, TChar::ERightToLeft}
       
  8984 	};
       
  8985 
       
  8986 static const TBdLevelTest KPreviousCarryOver1Line1[] =
       
  8987 	{
       
  8988 	{TChar::ERightToLeftArabic, 1, TChar::ERightToLeft},
       
  8989 	};
       
  8990 static const TBdLevelTest KPreviousCarryOver1Line2[] =
       
  8991 	{
       
  8992 	{TChar::EEuropeanNumber, 2, TChar::EArabicNumber},
       
  8993 	{TChar::EOtherNeutral, 1, TChar::ERightToLeft},
       
  8994 	{TChar::EEuropeanNumber, 2, TChar::EArabicNumber},
       
  8995 	};
       
  8996 
       
  8997 void CTBiDi::DoXTests(TBidirectionalState& aState,
       
  8998 	TBidirectionalState::TReorderContext& aContext,
       
  8999 	TBidirectionalState::TRunInfo* aRuns) 
       
  9000 	{
       
  9001 	FILL_RUN_ARRAY(KXTests, aRuns, aContext);
       
  9002 	aState.HandleBdControls(aContext);
       
  9003 	CHECK_RUN_RESULTS(KXTests, aRuns);
       
  9004 	}
       
  9005 
       
  9006 void CTBiDi::DoKW123TestsLeft(TBidirectionalState& aState,
       
  9007 	TBidirectionalState::TReorderContext& aContext,
       
  9008 	TBidirectionalState::TRunInfo* aRuns) 
       
  9009 	{
       
  9010 	aState = TBidirectionalState(TChar::ELeftToRight, TChar::ELeftToRight, EFalse);
       
  9011 	FILL_RUN_ARRAY(KW123TestsL, aRuns, aContext);
       
  9012 	aState.HandleBdControls(aContext);
       
  9013 	aState.ResolveWeakTypesW1W2W3(aContext);
       
  9014 	CHECK_RUN_RESULTS(KW123TestsL, aRuns);
       
  9015 	}
       
  9016 
       
  9017 void CTBiDi::DoKW123TestsRight(TBidirectionalState& aState,
       
  9018 	TBidirectionalState::TReorderContext& aContext,
       
  9019 	TBidirectionalState::TRunInfo* aRuns) 
       
  9020 	{
       
  9021 	aState = TBidirectionalState(TChar::ERightToLeft, TChar::ERightToLeft, ETrue);
       
  9022 	FILL_RUN_ARRAY(KW123TestsR, aRuns, aContext);
       
  9023 	aState.HandleBdControls(aContext);
       
  9024 	aState.ResolveWeakTypesW1W2W3(aContext);
       
  9025 	CHECK_RUN_RESULTS(KW123TestsR, aRuns);
       
  9026 	}
       
  9027 
       
  9028 void CTBiDi::DoKW456Tests(TBidirectionalState& aState,
       
  9029 	TBidirectionalState::TReorderContext& aContext,
       
  9030 	TBidirectionalState::TRunInfo* aRuns) 
       
  9031 	{
       
  9032 	aState = TBidirectionalState(TChar::ELeftToRight, TChar::ELeftToRight, EFalse);
       
  9033 	FILL_RUN_ARRAY(KW456Tests, aRuns, aContext);
       
  9034 	aState.HandleBdControls(aContext);
       
  9035 	aState.ResolveWeakTypesW1W2W3(aContext);
       
  9036 	aState.ResolveWeakTypesW4W5W6(aContext);
       
  9037 	CHECK_RUN_RESULTS(KW456Tests, aRuns);
       
  9038 
       
  9039 	}
       
  9040 
       
  9041 
       
  9042 void CTBiDi::DoKW7TestsLeft(TBidirectionalState& aState,
       
  9043 	TBidirectionalState::TReorderContext& aContext,
       
  9044 	TBidirectionalState::TRunInfo* aRuns) 
       
  9045 	{
       
  9046 
       
  9047 	aState = TBidirectionalState(TChar::ELeftToRight, TChar::ELeftToRight, EFalse);
       
  9048 	FILL_RUN_ARRAY(KW7TestsL, aRuns, aContext);
       
  9049 	aState.HandleBdControls(aContext);
       
  9050 	aState.ResolveWeakTypesW1W2W3(aContext);
       
  9051 	aState.ResolveWeakTypesW4W5W6(aContext);
       
  9052 	aState.ResolveWeakTypesW7(aContext);
       
  9053 	CHECK_RUN_RESULTS(KW7TestsL, aRuns);
       
  9054 
       
  9055 	}
       
  9056 
       
  9057 void CTBiDi::DoKW7TestsRight(TBidirectionalState& aState,
       
  9058 	TBidirectionalState::TReorderContext& aContext,
       
  9059 	TBidirectionalState::TRunInfo* aRuns) 
       
  9060 	{
       
  9061 	aState = TBidirectionalState(TChar::ERightToLeft, TChar::ERightToLeft, EFalse);
       
  9062 	FILL_RUN_ARRAY(KW7TestsR, aRuns, aContext);
       
  9063 	aState.HandleBdControls(aContext);
       
  9064 	aState.ResolveWeakTypesW1W2W3(aContext);
       
  9065 	aState.ResolveWeakTypesW4W5W6(aContext);
       
  9066 	aState.ResolveWeakTypesW7(aContext);
       
  9067 	CHECK_RUN_RESULTS(KW7TestsR, aRuns);
       
  9068 	}
       
  9069 
       
  9070 void CTBiDi::DoKN12TestsLeft(TBidirectionalState& aState,
       
  9071 	TBidirectionalState::TReorderContext& aContext,
       
  9072 	TBidirectionalState::TRunInfo* aRuns) 
       
  9073 	{
       
  9074 	aState = TBidirectionalState(TChar::ERightToLeft, TChar::ERightToLeft, EFalse);
       
  9075 	SetContext(aContext, TChar::ERightToLeft);
       
  9076 	FILL_RUN_ARRAY(KN12TestsL, aRuns, aContext);
       
  9077 	aState.HandleBdControls(aContext);
       
  9078 	aState.ResolveWeakTypesW1W2W3(aContext);
       
  9079 	aState.ResolveWeakTypesW4W5W6(aContext);
       
  9080 	aState.ResolveWeakTypesW7(aContext);
       
  9081 	aState.ResolveNeutralTypes(aContext);
       
  9082 	CHECK_RUN_RESULTS(KN12TestsL, aRuns);
       
  9083 
       
  9084 	}
       
  9085 
       
  9086 void CTBiDi::DoKN12TestsRight(TBidirectionalState& aState,
       
  9087 	TBidirectionalState::TReorderContext& aContext,
       
  9088 	TBidirectionalState::TRunInfo* aRuns) 
       
  9089 	{
       
  9090 	aState = TBidirectionalState(TChar::ERightToLeft, TChar::ERightToLeft, ETrue);
       
  9091 	SetContext(aContext, TChar::ERightToLeft);
       
  9092 	FILL_RUN_ARRAY(KN12TestsR, aRuns, aContext);
       
  9093 	aState.HandleBdControls(aContext);
       
  9094 	aState.ResolveWeakTypesW1W2W3(aContext);
       
  9095 	aState.ResolveWeakTypesW4W5W6(aContext);
       
  9096 	aState.ResolveWeakTypesW7(aContext);
       
  9097 	aState.ResolveNeutralTypes(aContext);
       
  9098 	CHECK_RUN_RESULTS(KN12TestsR, aRuns);
       
  9099 	}
       
  9100 
       
  9101 void CTBiDi::DoKN12TestsRRL(TBidirectionalState& aState,
       
  9102 	TBidirectionalState::TReorderContext& aContext,
       
  9103 	TBidirectionalState::TRunInfo* aRuns) 
       
  9104 	{
       
  9105 	aState = TBidirectionalState(TChar::ERightToLeft, TChar::ERightToLeft, ETrue);
       
  9106 	SetContext(aContext, TChar::ELeftToRight);
       
  9107 	FILL_RUN_ARRAY(KN12TestsRRL, aRuns, aContext);
       
  9108 	aState.HandleBdControls(aContext);
       
  9109 	aState.ResolveWeakTypesW1W2W3(aContext);
       
  9110 	aState.ResolveWeakTypesW4W5W6(aContext);
       
  9111 	aState.ResolveWeakTypesW7(aContext);
       
  9112 	aState.ResolveNeutralTypes(aContext);
       
  9113 	CHECK_RUN_RESULTS(KN12TestsRRL, aRuns);
       
  9114 	}
       
  9115 
       
  9116 void CTBiDi::DoKN12TestsLRR(TBidirectionalState& aState,
       
  9117 	TBidirectionalState::TReorderContext& aContext,
       
  9118 	TBidirectionalState::TRunInfo* aRuns) 
       
  9119 	{
       
  9120 	aState = TBidirectionalState(TChar::ELeftToRight, TChar::ELeftToRight, ETrue);
       
  9121 	SetContext(aContext, TChar::ERightToLeft);
       
  9122 	FILL_RUN_ARRAY(KN12TestsLRR, aRuns, aContext);
       
  9123 	aState.HandleBdControls(aContext);
       
  9124 	aState.ResolveWeakTypesW1W2W3(aContext);
       
  9125 	aState.ResolveWeakTypesW4W5W6(aContext);
       
  9126 	aState.ResolveWeakTypesW7(aContext);
       
  9127 	aState.ResolveNeutralTypes(aContext);
       
  9128 	CHECK_RUN_RESULTS(KN12TestsLRR, aRuns);
       
  9129 	}
       
  9130 
       
  9131 void CTBiDi::DoKN12TestsLRP(TBidirectionalState& aState,
       
  9132 	TBidirectionalState::TReorderContext& aContext,
       
  9133 	TBidirectionalState::TRunInfo* aRuns) 
       
  9134 	{
       
  9135 	aState = TBidirectionalState(TChar::ELeftToRight, TChar::ELeftToRight, ETrue);
       
  9136 	SetContext(aContext, TChar::EPopDirectionalFormat);
       
  9137 	FILL_RUN_ARRAY(KN12TestsLRP, aRuns, aContext);
       
  9138 	aState.HandleBdControls(aContext);
       
  9139 	aState.ResolveWeakTypesW1W2W3(aContext);
       
  9140 	aState.ResolveWeakTypesW4W5W6(aContext);
       
  9141 	aState.ResolveWeakTypesW7(aContext);
       
  9142 	aState.ResolveNeutralTypes(aContext);
       
  9143 	CHECK_RUN_RESULTS(KN12TestsLRP, aRuns);
       
  9144 	}
       
  9145 
       
  9146 void CTBiDi::DoKN12TestsRLP(TBidirectionalState& aState,
       
  9147 	TBidirectionalState::TReorderContext& aContext,
       
  9148 	TBidirectionalState::TRunInfo* aRuns) 
       
  9149 	{
       
  9150 	aState = TBidirectionalState(TChar::ERightToLeft, TChar::ERightToLeft, EFalse);
       
  9151 	SetContext(aContext, TChar::EPopDirectionalFormat);
       
  9152 	FILL_RUN_ARRAY(KN12TestsRLP, aRuns, aContext);
       
  9153 	aState.HandleBdControls(aContext);
       
  9154 	aState.ResolveWeakTypesW1W2W3(aContext);
       
  9155 	aState.ResolveWeakTypesW4W5W6(aContext);
       
  9156 	aState.ResolveWeakTypesW7(aContext);
       
  9157 	aState.ResolveNeutralTypes(aContext);
       
  9158 	CHECK_RUN_RESULTS(KN12TestsRLP, aRuns);
       
  9159 	}
       
  9160 
       
  9161 void CTBiDi::DoCarryOverTest1(TBidirectionalState& aState,
       
  9162 	TBidirectionalState::TReorderContext& aContext,
       
  9163 	TBidirectionalState::TRunInfo* aRuns)
       
  9164 	{
       
  9165 	aState = TBidirectionalState(TChar::ERightToLeft, TChar::ERightToLeft, EFalse);
       
  9166 	SetContext(aContext, TChar::EOtherNeutral);
       
  9167 	FILL_RUN_ARRAY(KPreviousCarryOver1Line1, aRuns, aContext);
       
  9168 	aState.HandleBdControls(aContext);
       
  9169 	aState.ResolveWeakTypesW1W2W3(aContext);
       
  9170 	aState.ResolveWeakTypesW4W5W6(aContext);
       
  9171 	aState.ResolveWeakTypesW7(aContext);
       
  9172 	aState.ResolveNeutralTypes(aContext);
       
  9173 	aState.ResolveImplicitLevels(aContext);
       
  9174 	aState.PrepareForNextLine(aContext);
       
  9175 	CHECK_RUN_RESULTS(KPreviousCarryOver1Line1, aRuns);
       
  9176 	FILL_RUN_ARRAY(KPreviousCarryOver1Line2, aRuns, aContext);
       
  9177 	aState.HandleBdControls(aContext);
       
  9178 	aState.ResolveWeakTypesW1W2W3(aContext);
       
  9179 	aState.ResolveWeakTypesW4W5W6(aContext);
       
  9180 	aState.ResolveWeakTypesW7(aContext);
       
  9181 	aState.ResolveNeutralTypes(aContext);
       
  9182 	aState.ResolveImplicitLevels(aContext);
       
  9183 	aState.PrepareForNextLine(aContext);
       
  9184 	CHECK_RUN_RESULTS(KPreviousCarryOver1Line2, aRuns);
       
  9185 	}
       
  9186 
       
  9187 /**
       
  9188    @SYMTestCaseID			GRAPHICS-GDI-BiDi-0001
       
  9189 
       
  9190    @SYMDEF					DEF105603
       
  9191 
       
  9192    @SYMTestCaseDesc			Test TBidirectionalState functionality (Unicode Bidirectional Algorithm impmentation withing SymbianOS)
       
  9193 
       
  9194    @SYMTestPriority			High
       
  9195 
       
  9196    @SYMTestStatus       	Implemented
       
  9197 
       
  9198    @SYMTestActions      	Test conversion of a TBidirectional::TCategory value into it's equivalent TChar::TBdCategory
       
  9199 							Test the various phases of the Bidirectional Algorithm implementation (Resolving explicit levels and directions, weak types & neutral types) 
       
  9200 
       
  9201    @SYMTestExpectedResults	Confirmation the implementation conforms to the Unicode Birdirection Algorithm standard
       
  9202 */
       
  9203 void CTBiDi::TestTBidirectionalStateInternalsL()
       
  9204 	{
       
  9205 	INFO_PRINTF1(_L("TBidirectionalState internals"));
       
  9206 	TestCatToNumber(1, 0);
       
  9207 	TestCatToNumber(2, 1);
       
  9208 	TestCatToNumber(3, 1);
       
  9209 	TestCatToNumber(4, 2);
       
  9210 	TestCatToNumber(6, 2);
       
  9211 	TestCatToNumber(8, 3);
       
  9212 	TestCatToNumber(9, 3);
       
  9213 	TestCatToNumber(0x10, 4);
       
  9214 	TestCatToNumber(0x20, 5);
       
  9215 	TestCatToNumber(0x40, 6);
       
  9216 	TestCatToNumber(0x7F, 6);
       
  9217 	TestCatToNumber(0x80, 7);
       
  9218 	TestCatToNumber(0x100, 8);
       
  9219 	TestCatToNumber(0x200, 9);
       
  9220 	TestCatToNumber(0x400, 10);
       
  9221 	TestCatToNumber(0x800, 11);
       
  9222 	TestCatToNumber(0x1000, 12);
       
  9223 	TestCatToNumber(0x2000, 13);
       
  9224 	TestCatToNumber(0x4000, 14);
       
  9225 	TestCatToNumber(0x8000, 15);
       
  9226 	TestCatToNumber(0xFFFF, 15);
       
  9227 	TestCatToNumber(0x10000, 16);
       
  9228 	TestCatToNumber(0x20000, 17);
       
  9229 	TestCatToNumber(0x40000, 18);
       
  9230 	TestCatToNumber(0x80000, 19);
       
  9231 	TestCatToNumber(0x100000, 20);
       
  9232 	TestCatToNumber(0x200000, 21);
       
  9233 	TestCatToNumber(0x400000, 22);
       
  9234 	TestCatToNumber(0x800000, 23);
       
  9235 	TestCatToNumber(0x1000000, 24);
       
  9236 	TestCatToNumber(0x2000000, 25);
       
  9237 	TestCatToNumber(0x4000000, 26);
       
  9238 	TestCatToNumber(0x8000000, 27);
       
  9239 	TestCatToNumber(0x10000000, 28);
       
  9240 	TestCatToNumber(0x20000000, 29);
       
  9241 	TestCatToNumber(0x40000000, 30);
       
  9242 	TestCatToNumber(0x7FFFFFFF, 30);
       
  9243 
       
  9244 	TBidirectionalState::TRunInfo* runs = new(ELeave) TBidirectionalState::TRunInfo[200];
       
  9245 	CleanupArrayDeletePushL(runs);
       
  9246 	TBidirectionalState state(TChar::EOtherNeutral, TChar::EOtherNeutral, EFalse);
       
  9247 	TBidirectionalState::TReorderContext context;
       
  9248 	context.iRunInfo = runs;
       
  9249 	DoXTests(state, context, runs);
       
  9250 	DoKW123TestsLeft(state, context, runs);
       
  9251 	DoKW123TestsRight(state, context, runs);
       
  9252 	DoKW456Tests(state, context, runs);
       
  9253 	DoKW7TestsLeft(state, context, runs);
       
  9254 	DoKW7TestsRight(state, context, runs);
       
  9255 	DoKN12TestsLeft(state, context, runs);
       
  9256 	DoKN12TestsRight(state, context, runs);
       
  9257 	DoKN12TestsRRL(state, context, runs);
       
  9258 	DoKN12TestsLRR(state, context, runs);
       
  9259 	DoKN12TestsLRP(state, context, runs);
       
  9260 	DoKN12TestsRLP(state, context, runs);
       
  9261 
       
  9262 	// Should test "Resolve implicit levels" as well.
       
  9263 	//...
       
  9264 
       
  9265 	DoCarryOverTest1(state, context, runs);
       
  9266 
       
  9267 	CleanupStack::PopAndDestroy(runs);
       
  9268 	}
       
  9269 
       
  9270 
       
  9271 /**
       
  9272  * @SYMTestCaseID			GRAPHICS-SYSLIB-GDI-CT-0217
       
  9273  * @SYMTestCaseDesc			Test the operation of the run array scratch area
       
  9274  * @SYMTestPriority			low
       
  9275  * @SYMTestActions			Step 1: Verify that the scratch area is created and destroyed correctly
       
  9276  *									and that no memory is leaked.
       
  9277  *                			Step 2: Verify that the reference counting mechanism operates correctly
       
  9278  *                			Step 3: Verify that a call to OpenL() will leave correctly if there is 
       
  9279  * 									not enough memory available.
       
  9280  * @SYMTestExpectedResults	The test must pass
       
  9281  * @SYMREQ					APOS-69QD7N - Change TBidiText to make it useable and easier to port 
       
  9282  *							code to it
       
  9283  * @SYMDevelopedForRelease	Mike
       
  9284  * @SYMTestType				CT
       
  9285  * 
       
  9286  */
       
  9287 void CTBiDi::DoTestRRunInfoArrayInternalsL()
       
  9288 	{
       
  9289 	INFO_PRINTF1(_L("RRunInfoArray Internals..."));
       
  9290 	
       
  9291 
       
  9292 #ifdef _DEBUG
       
  9293 	const TInt KExpectedHeapCells = 2;
       
  9294 #endif
       
  9295 
       
  9296 
       
  9297 	// Step 1: Verify that the scratch area is created and
       
  9298 	//         destroyed correctly
       
  9299 		{
       
  9300 		INFO_PRINTF1(_L("    Create/destroy run info scratch area..."));
       
  9301 		
       
  9302 		__UHEAP_MARK;
       
  9303 		RRunInfoArray runInfoArray;
       
  9304 		runInfoArray.OpenL();
       
  9305 		__UHEAP_CHECK(KExpectedHeapCells);
       
  9306 		runInfoArray.Close();
       
  9307 		__UHEAP_MARKEND;
       
  9308 		}
       
  9309 
       
  9310 
       
  9311 	// Step 2: Multiple calls to OpenL() and Close()
       
  9312 	//
       
  9313 		{
       
  9314 		INFO_PRINTF1(_L("    Multiple calls to RRunInfoArray::OpenL()..."));
       
  9315 		
       
  9316 		__UHEAP_MARK;
       
  9317 		RRunInfoArray runInfoArray;
       
  9318 		runInfoArray.OpenL();
       
  9319 		__UHEAP_CHECK(KExpectedHeapCells);
       
  9320 
       
  9321 		// Second call on the same object gets ignored.
       
  9322 		runInfoArray.OpenL();
       
  9323 		__UHEAP_CHECK(KExpectedHeapCells);
       
  9324 
       
  9325 
       
  9326 		// Creating another one reuses the singleton we created
       
  9327 		// earlier. No additional storage gets allocated
       
  9328 		RRunInfoArray runInfoArray2;
       
  9329 		runInfoArray2.OpenL();
       
  9330 		__UHEAP_CHECK(KExpectedHeapCells);
       
  9331 
       
  9332 
       
  9333 		// Shut down can be done in any order -  It is the last one 
       
  9334 		// that should actually free the memory
       
  9335 		INFO_PRINTF1(_L("    Multiple calls to RRunInfoArray::Close()..."));
       
  9336 		runInfoArray.Close();
       
  9337 		__UHEAP_CHECK(KExpectedHeapCells);
       
  9338 		runInfoArray2.Close();
       
  9339 		__UHEAP_CHECK(0);
       
  9340 		
       
  9341 		
       
  9342 		// Try to break it by calling Close() again
       
  9343 		runInfoArray.Close();
       
  9344 		__UHEAP_CHECK(0);
       
  9345 
       
  9346 		
       
  9347 		__UHEAP_MARKEND;
       
  9348 		}
       
  9349 		
       
  9350 	
       
  9351 	// Step 3: Check that OpenL() really does leave if not enough
       
  9352 	//         memory - only valid for debug builds
       
  9353 #ifdef _DEBUG
       
  9354 		{
       
  9355 		INFO_PRINTF1(_L("    RRunInfoArray::OpenL() fails for OOM..."));
       
  9356 		RRunInfoArray runInfoArray;
       
  9357 
       
  9358 		// OOM loop - must successfully allocate for 10 consecutive alloc sizes
       
  9359 		TInt allocSuccess = 0;
       
  9360 		TInt failAlloc = 1;
       
  9361 		do 
       
  9362 			{
       
  9363 			__UHEAP_FAILNEXT(failAlloc);
       
  9364 			TRAPD(err, runInfoArray.OpenL());
       
  9365 			__UHEAP_RESET;
       
  9366 
       
  9367 			if (err == KErrNone)
       
  9368 				{
       
  9369 				++allocSuccess;
       
  9370 				runInfoArray.Close();
       
  9371 				}
       
  9372 			else
       
  9373 				{
       
  9374 				TEST(KErrNoMemory == err);
       
  9375 				allocSuccess = 0;
       
  9376 				}
       
  9377 			++failAlloc;
       
  9378 			}
       
  9379 			while (allocSuccess < 10);
       
  9380 		}
       
  9381 #endif
       
  9382 	}
       
  9383 
       
  9384 
       
  9385 /**
       
  9386  *
       
  9387  * Check that TBidiText will panic if the NewL call contains
       
  9388  * an invalid max length value.
       
  9389  *
       
  9390  * Note: This function will generate a panic and should therefore
       
  9391  * be called from within a separate worker thread.
       
  9392  *
       
  9393  */
       
  9394 static TInt TestPanicMaxLengthInvalidL(TAny*)
       
  9395 	{
       
  9396 	// A max length of 0 or less is invalid. Should cause a panic.
       
  9397 	TBidiText* bidi = TBidiText::NewL(-1, 3);
       
  9398 
       
  9399 
       
  9400 	return (KErrNone);
       
  9401 	}
       
  9402 
       
  9403 
       
  9404 /**
       
  9405  *
       
  9406  * Check that TBidiText will panic if the NewL call contains
       
  9407  * an invalid max lines value
       
  9408  *
       
  9409  * Note: This function will generate a panic and should therefore
       
  9410  * be called from within a separate worker thread.
       
  9411  *
       
  9412  */
       
  9413 static TInt TestPanicMaxLinesInvalidL(TAny*)
       
  9414 	{
       
  9415 	// The max number of lines should be 1 or more. Should cause a
       
  9416 	// panic.
       
  9417 	TBidiText* bidi = TBidiText::NewL(100, -1);
       
  9418 	
       
  9419 	
       
  9420 	return (KErrNone);
       
  9421 	}
       
  9422 
       
  9423 
       
  9424 /**
       
  9425  *
       
  9426  * @SYMTestCaseID			GRAPHICS-SYSLIB-GDI-CT-0218
       
  9427  * @SYMTestCaseDesc			Test the creation of an empty TBidiText object
       
  9428  * @SYMTestPriority			low
       
  9429  * @SYMTestActions			Step 1: Verify object creation
       
  9430  *                			Step 2: Verify that object destruction does not leak memory
       
  9431  *                			Step 3: Verify that the correct panics are generated if an
       
  9432  *									invalid parameter is specified
       
  9433  * @SYMTestExpectedResults	The test must pass
       
  9434  * @SYMREQ					APOS-69QD7N - Change TBidiText to make it useable and easier to port 
       
  9435  *							code to it
       
  9436  * @SYMDevelopedForRelease	Mike
       
  9437  * @SYMTestType				CT
       
  9438  *
       
  9439  */
       
  9440 void CTBiDi::DoTestTBidiTextNewL()
       
  9441 	{
       
  9442 	INFO_PRINTF1(_L("TBidiText::NewL()..."));
       
  9443 	const TInt KMaxLength         = 100;
       
  9444 	const TInt KMaxLines          =   3;
       
  9445 #ifdef _DEBUG
       
  9446 	const TInt KExpectedHeapCells =   1;
       
  9447 #endif
       
  9448 			
       
  9449 	TBidiText* bidiText = 0;
       
  9450 
       
  9451 	// First we're going to test the successful creation. This
       
  9452 	// should (hopefully) be how the client app will use the class)
       
  9453 	INFO_PRINTF1(_L("    Create an empty object..."));
       
  9454 	__UHEAP_MARK;
       
  9455 	TRAPD(err, bidiText = TBidiText::NewL(KMaxLength, KMaxLines));
       
  9456 	TEST(KErrNone == err);
       
  9457 	__UHEAP_CHECK(KExpectedHeapCells);
       
  9458 	
       
  9459 		
       
  9460 	// Free up the memory and make sure we haven't leaked anything
       
  9461 	INFO_PRINTF1(_L("    Delete object..."));
       
  9462 	delete bidiText;
       
  9463 	bidiText = 0;
       
  9464 	__UHEAP_CHECK(0);
       
  9465 	__UHEAP_MARKEND;
       
  9466 			
       
  9467 
       
  9468 	// Now for the invalid parameters. These will generate a panic
       
  9469 	// so must be tested in a separate thread.
       
  9470 	INFO_PRINTF1(_L("    Invalid max length (will panic!)"));
       
  9471 	TEST(EBidiPanic_InvalidReservedMaxLength == TestPanic(TestPanicMaxLengthInvalidL));
       
  9472 	INFO_PRINTF1(_L("    Invalid max lines (will panic!)"));
       
  9473 	TEST(EBidiPanic_InvalidMaxline == TestPanic(TestPanicMaxLinesInvalidL));
       
  9474 	}
       
  9475 
       
  9476 
       
  9477 /**
       
  9478  *
       
  9479  * Check that TBidiText will panic if the SetText call is made
       
  9480  * before RRunInfoArray::OpenL();
       
  9481  *
       
  9482  * Note: This function will generate a panic and should therefore
       
  9483  * be called from within a separate worker thread.
       
  9484  *
       
  9485  */
       
  9486 TInt CTBiDi::DoTestPanicSetTextL()
       
  9487 	{
       
  9488 	const TInt KMaxLength = 100;
       
  9489 	const TInt KMaxLines  =   3;
       
  9490 	_LIT(KHello, "Hello World");
       
  9491 	
       
  9492 	TBidiText* bidiText   = TBidiText::NewL(KMaxLength, KMaxLines);
       
  9493 	CleanupStack::PushL(bidiText);
       
  9494 
       
  9495 	
       
  9496 	// Will cause a KErrDisconnected panic because we have not
       
  9497 	// called RRunInfoArray::OpenL()
       
  9498 	RRunInfoArray runArray;
       
  9499 	bidiText->SetText(KHello, runArray);
       
  9500 
       
  9501 
       
  9502 	CleanupStack::PopAndDestroy(bidiText);
       
  9503 	return KErrNone;
       
  9504 	}
       
  9505 	
       
  9506 
       
  9507 /**
       
  9508  *
       
  9509  * Entry point for the DoTestPanicSetTextL test's worker thread
       
  9510  *
       
  9511  * Provides cleanup stack for the test function
       
  9512  *
       
  9513  */
       
  9514 TInt TestPanicSetTextL(TAny* aData)
       
  9515 	{
       
  9516 	CTBiDi* theTest = static_cast<CTBiDi*> (aData);
       
  9517 	CTrapCleanup* trap = CTrapCleanup::New();
       
  9518 	if (!trap)
       
  9519 		return KErrNoMemory;
       
  9520 	
       
  9521 	
       
  9522 	TRAP_IGNORE(theTest->DoTestPanicSetTextL());	
       
  9523 
       
  9524 
       
  9525 	delete trap;
       
  9526 	return KErrNone;
       
  9527 	}
       
  9528 
       
  9529 
       
  9530 /**
       
  9531  *
       
  9532  * @SYMTestCaseID			GRAPHICS-SYSLIB-GDI-CT-0219
       
  9533  * @SYMTestCaseDesc			Test the operation of TBidiText::SetText()
       
  9534  * @SYMTestPriority			low
       
  9535  * @SYMTestActions			Step 1: Verify that RRunInfoArray will panic if OpenL() 
       
  9536  *									has not been called
       
  9537  *                			Step 2: Verify that SetText() does change the text and
       
  9538  *									string length
       
  9539  *                			Step 3: Verify that SetText() will return the number of
       
  9540  *									characters truncated if the string is too big for
       
  9541  *									the object.
       
  9542  *                 			Step 4: Also checks that the text is changed and the
       
  9543  *									length is updated.
       
  9544  *                			Step 5: Verify that RRunInfoArray will panic if it's
       
  9545  *									buffer overflows
       
  9546  * @SYMTestExpectedResults	The test must pass
       
  9547  * @SYMREQ					APOS-69QD7N - Change TBidiText to make it useable and easier to port 
       
  9548  *							code to it
       
  9549  * @SYMDevelopedForRelease	Mike
       
  9550  * @SYMTestType				CT
       
  9551  *
       
  9552  */
       
  9553 void CTBiDi::DoTestTBidiTextSetTextL()
       
  9554 	{
       
  9555 	INFO_PRINTF1(_L("TBidiText::SetText()..."));
       
  9556 
       
  9557 
       
  9558 	INFO_PRINTF1(_L("    Run Array not initialised (will panic!)"));
       
  9559 	TEST(EBidiPanic_RunArrayNull == TestPanic(TestPanicSetTextL));
       
  9560 	
       
  9561 	
       
  9562 	// Rest of the tests will make use of these resources
       
  9563 	_LIT(KLine1,    "Mary had a little lamb");
       
  9564 	_LIT(KLine2,    "and she had a bear");
       
  9565 	_LIT(KLine3,    "I've often seen her little lamb");
       
  9566 	const TInt KExpectedDiff = KLine3.iTypeLength - KLine1.iTypeLength;
       
  9567 
       
  9568 
       
  9569 	RRunInfoArray runArray;
       
  9570 	runArray.OpenL();
       
  9571 	
       
  9572 
       
  9573 	INFO_PRINTF1(_L("    Change text..."));
       
  9574 	TBidiText* bidiText = TBidiText::NewL(KLine1, 1);
       
  9575 	CleanupStack::PushL(bidiText);
       
  9576 	TEST(KLine1.iTypeLength == bidiText->Text().Length());
       
  9577 	
       
  9578 
       
  9579 	// Will fit. Expect an overflow of 0 characters.	
       
  9580 	TInt overFlow = bidiText->SetText(KLine2, runArray);
       
  9581 	TEST(0 == overFlow);
       
  9582 	TEST(KLine2.iTypeLength == bidiText->Text().Length());
       
  9583 	TEST(!bidiText->Text().Compare(KLine2));
       
  9584 	
       
  9585 	
       
  9586 	// Too long. Expect an overflow for this string. The number of
       
  9587 	// characters we have exceeded the buffer by is determined from
       
  9588 	// the lengths of the two strings: KLine1 (used to set the initial
       
  9589 	// length of the buffer) and KLine3 (used to change the text in the 
       
  9590 	// buffer
       
  9591 	INFO_PRINTF1(_L("    Text overflow..."));
       
  9592 	overFlow = bidiText->SetText(KLine3, runArray);
       
  9593 	TEST(KExpectedDiff == overFlow);
       
  9594 	TEST(KLine1.iTypeLength == bidiText->Text().Length());
       
  9595 	TPtrC line3(KLine3);
       
  9596 	TEST(!bidiText->Text().Compare(line3.Left(KLine1.iTypeLength)));
       
  9597 	
       
  9598 	
       
  9599 	// If the Run Info Array is too small, the text will be truncated
       
  9600 	// and the excess characters returned to the client application as
       
  9601 	// a negative integer. (i.e. can be distinguished from simple
       
  9602 	// truncation)
       
  9603 	TBidiText* bidiText2 = TBidiText::NewL(512, 1);
       
  9604 	CleanupStack::PushL(bidiText2);
       
  9605 	
       
  9606 	// KManyRuns is too long for RRunArray
       
  9607 	_LIT(KManyRuns, "1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a");
       
  9608 	TInt excessChars = bidiText2->SetText(KManyRuns, runArray);
       
  9609 	TEST (52 == excessChars);
       
  9610 	
       
  9611 
       
  9612 	// Tidy up
       
  9613 	CleanupStack::PopAndDestroy(bidiText2);
       
  9614 	CleanupStack::PopAndDestroy(bidiText);
       
  9615 	runArray.Close();
       
  9616 	}
       
  9617 	
       
  9618 
       
  9619 /**
       
  9620  *
       
  9621  * @SYMTestCaseID			GRAPHICS-SYSLIB-GDI-CT-0220
       
  9622  * @SYMTestCaseDesc			Test the operation of TBidiText::MinimumSize()
       
  9623  * @SYMTestPriority			low
       
  9624  * @SYMTestActions			Step 1: Verify that MinimumSize() returns the correct
       
  9625  *									size in pixels both with and without the aMaxLines
       
  9626  *									parameter specified
       
  9627  *                          Step 2: Verify that MinimumSize() will panic if an invalid
       
  9628  *									parameter is specified.
       
  9629  * @SYMTestExpectedResults	The test must pass
       
  9630  * @SYMREQ					APOS-69QD7N - Change TBidiText to make it useable and easier to port 
       
  9631  *							code to it
       
  9632  * @SYMDevelopedForRelease	Mike
       
  9633  * @SYMTestType				CT
       
  9634  *
       
  9635  */
       
  9636 void CTBiDi::DoTestTBidiTextMinimumSizeL()
       
  9637 	{
       
  9638 	INFO_PRINTF1(_L("TBidiText::MinimumSize()..."));
       
  9639 	
       
  9640 	
       
  9641 	CFont* testFont = new (ELeave) CTestFont;
       
  9642 	CleanupStack::PushL(testFont);
       
  9643 	
       
  9644 
       
  9645 	// Create and populate the buffer that holds the test data
       
  9646 	// for this test. 
       
  9647 	HBufC* oldTextBufPtr = HBufC::NewLC(KBufferSize);
       
  9648 	TextIterator rIterator(KRightToLeftArabic, KRightToLeftArabicLength);
       
  9649 	MLineBreaker breaker;
       
  9650 	for (TInt i = 0; i < KBufferSize; ++i)
       
  9651 		{
       
  9652 		TUint s, e;
       
  9653 		TText16 ch = rIterator.NextChar();
       
  9654 		if (breaker.LineBreakClass(ch, s, e) == MLineBreaker::EAlLineBreakClass)
       
  9655 			oldTextBufPtr->Des().Append(ch);
       
  9656 		}
       
  9657 	TPtr oldText(oldTextBufPtr->Des());
       
  9658 	
       
  9659 	
       
  9660 	TBidiText* bidiText = TBidiText::NewL(oldText, 50);
       
  9661 	CleanupStack::PushL(bidiText);
       
  9662 	
       
  9663 
       
  9664 	const TUint KWrapWidth      = 400;
       
  9665 	const TUint KLineGap        =   2;
       
  9666 	TSize result = bidiText->MinimumSize(KWrapWidth, *testFont, KLineGap);
       
  9667 
       
  9668 
       
  9669 	// For a fixed width font where each character is 10 pixels wide, we
       
  9670 	// should expect that we will have 40 characters per line for a wrapping
       
  9671 	// width of 400. 
       
  9672 	const TUint KExpectedWidth = KWrapWidth;
       
  9673 	const TUint KExpectedCharsPerLine = KWrapWidth/testFont->CharWidthInPixels('a');
       
  9674 	const TUint KExpectedLines = (oldText.Length() + KExpectedCharsPerLine - 1)/KExpectedCharsPerLine;
       
  9675 	const TUint KExpectedHeight = (testFont->HeightInPixels() + KLineGap) * KExpectedLines - KLineGap;
       
  9676 	TEST(KExpectedWidth == result.iWidth);
       
  9677 	TEST(KExpectedHeight == result.iHeight);
       
  9678 	
       
  9679 
       
  9680 	// Repeat the above, but this time specify the maximum number of lines
       
  9681 	// we're interested in.
       
  9682 	const TUint KMaxLines =  14;
       
  9683 	result = bidiText->MinimumSize(KWrapWidth, *testFont, KLineGap, KMaxLines);
       
  9684 	const TUint KExpectedHeight2      = (testFont->HeightInPixels() + KLineGap) * KMaxLines - KLineGap;;
       
  9685 	TEST(KExpectedWidth   == result.iWidth);
       
  9686 	TEST(KExpectedHeight2 == result.iHeight);
       
  9687 
       
  9688 
       
  9689 	CleanupStack::PopAndDestroy(bidiText);
       
  9690 	CleanupStack::PopAndDestroy(oldTextBufPtr);
       
  9691 	CleanupStack::PopAndDestroy(testFont);
       
  9692 	}
       
  9693 
       
  9694 
       
  9695 /**
       
  9696  *
       
  9697  * Check that TBidiText will panic if MinimumSize is called
       
  9698  * with an invalid wrapping width
       
  9699  *
       
  9700  * Note: This function will generate a panic and should therefore
       
  9701  * be called from within a separate worker thread.
       
  9702  *
       
  9703  */
       
  9704 TInt CTBiDi::DoTestPanicMinimumSizeWidth()
       
  9705 	{
       
  9706 	CFont* testFont = new (ELeave) CTestFont;
       
  9707 	CleanupStack::PushL(testFont);
       
  9708 
       
  9709 	_LIT(KDummyText, "Hello World");
       
  9710 	const TInt KMaxLines  = 50;
       
  9711 	TBidiText* bidiText   = TBidiText::NewL(KDummyText, KMaxLines);
       
  9712 	CleanupStack::PushL(bidiText);
       
  9713 	
       
  9714 	
       
  9715 	RRunInfoArray runArray;
       
  9716 	runArray.OpenL();
       
  9717 
       
  9718 
       
  9719 	// Should panic - KWrappingWidth is negative
       
  9720 	const TInt  KWrappingWidth = -1;
       
  9721 	const TUint KLineGap       =  1;
       
  9722 	bidiText->MinimumSize(KWrappingWidth, *testFont, KLineGap);
       
  9723 
       
  9724 
       
  9725 	CleanupStack::PopAndDestroy(bidiText);
       
  9726 	CleanupStack::PopAndDestroy(testFont);
       
  9727 	
       
  9728 	
       
  9729 	return KErrNone;
       
  9730 	}
       
  9731 
       
  9732 
       
  9733 /**
       
  9734  *
       
  9735  * Entry point for the DoTestPanicMinimumSizeWidth test's worker 
       
  9736  * thread
       
  9737  *
       
  9738  * Provides cleanup stack for the test function
       
  9739  *
       
  9740  */
       
  9741 static TInt TestPanicMinimumSizeWidth(TAny* aData)
       
  9742 	{
       
  9743 	CTBiDi* theTest = static_cast<CTBiDi*> (aData);
       
  9744 	CTrapCleanup* trap = CTrapCleanup::New();
       
  9745 	if (!trap)
       
  9746 		return KErrNoMemory;
       
  9747 	
       
  9748 	TInt result = KErrNone;
       
  9749 	TRAP_IGNORE(result = theTest->DoTestPanicMinimumSizeWidth());
       
  9750 	
       
  9751 	delete trap;
       
  9752 	return result;
       
  9753 	}
       
  9754 
       
  9755 
       
  9756 /**
       
  9757  *
       
  9758  * Check that TBidiText will panic if MinimumSize is called
       
  9759  * with an invalid line gap
       
  9760  *
       
  9761  * Note: This function will generate a panic and should therefore
       
  9762  * be called from within a separate worker thread.
       
  9763  *
       
  9764  */
       
  9765 TInt CTBiDi::DoTestPanicMinimumSizeLineGap()
       
  9766 	{
       
  9767 	CFont* testFont = new (ELeave) CTestFont;
       
  9768 	CleanupStack::PushL(testFont);
       
  9769 
       
  9770 	_LIT(KDummyText, "Hello World");
       
  9771 	const TInt KMaxLines  = 50;
       
  9772 	TBidiText* bidiText   = TBidiText::NewL(KDummyText, KMaxLines);
       
  9773 	CleanupStack::PushL(bidiText);
       
  9774 	
       
  9775 	
       
  9776 	RRunInfoArray runArray;
       
  9777 	runArray.OpenL();
       
  9778 
       
  9779 
       
  9780 	// Should panic - KLineGap is negative
       
  9781 	const TUint KWrappingWidth = 400;
       
  9782 	const TInt  KLineGap       =  -1;
       
  9783 	bidiText->MinimumSize(KWrappingWidth, *testFont, KLineGap);
       
  9784 
       
  9785 
       
  9786 	CleanupStack::PopAndDestroy(bidiText);
       
  9787 	CleanupStack::PopAndDestroy(testFont);
       
  9788 	
       
  9789 	
       
  9790 	return KErrNone;
       
  9791 	}
       
  9792 
       
  9793 
       
  9794 /**
       
  9795  *
       
  9796  * Entry point for the DoTestPanicMinimumSizeLineGap test's worker 
       
  9797  * thread
       
  9798  *
       
  9799  * Provides cleanup stack for the test function
       
  9800  *
       
  9801  */
       
  9802 static TInt TestPanicMinimumSizeLineGap(TAny* aData)
       
  9803 	{
       
  9804 	CTBiDi* theTest = static_cast <CTBiDi*> (aData);
       
  9805 	CTrapCleanup* trap = CTrapCleanup::New();
       
  9806 	if (!trap)
       
  9807 		return KErrNoMemory;
       
  9808 	
       
  9809 	TInt result = KErrNone;;
       
  9810 	TRAP_IGNORE(result = theTest->DoTestPanicMinimumSizeLineGap());
       
  9811 	
       
  9812 	delete trap;
       
  9813 	return result;
       
  9814 	}
       
  9815 
       
  9816 
       
  9817 /**
       
  9818  *
       
  9819  * Check that TBidiText will panic if MinimumSize is called
       
  9820  * with an invalid maximum number of lines
       
  9821  *
       
  9822  * Note: This function will generate a panic and should therefore
       
  9823  * be called from within a separate worker thread.
       
  9824  *
       
  9825  */
       
  9826 TInt CTBiDi::DoTestPanicMinimumSizeMaxLines()
       
  9827 	{
       
  9828 	CFont* testFont = new (ELeave) CTestFont;
       
  9829 	CleanupStack::PushL(testFont);
       
  9830 
       
  9831 	_LIT(KDummyText, "Hello World");
       
  9832 	TBidiText* bidiText   = TBidiText::NewL(KDummyText, 50);
       
  9833 	CleanupStack::PushL(bidiText);
       
  9834 	
       
  9835 	
       
  9836 	RRunInfoArray runArray;
       
  9837 	runArray.OpenL();
       
  9838 
       
  9839 
       
  9840 	// Should panic - KMaxLines is invalid
       
  9841 	const TUint KWrappingWidth = 400;
       
  9842 	const TUint KLineGap       =   1;
       
  9843 	const TInt  KMaxLines      =  -2;
       
  9844 	bidiText->MinimumSize(KWrappingWidth, *testFont, KLineGap, KMaxLines);
       
  9845 
       
  9846 
       
  9847 	CleanupStack::PopAndDestroy(bidiText);
       
  9848 	CleanupStack::PopAndDestroy(testFont);
       
  9849 	
       
  9850 	
       
  9851 	return KErrNone;
       
  9852 	}
       
  9853 
       
  9854 
       
  9855 /**
       
  9856  *
       
  9857  * Entry point for the DoTestPanicMinimumSizeMaxLines test's worker 
       
  9858  * thread
       
  9859  *
       
  9860  * Provides cleanup stack for the test function
       
  9861  *
       
  9862  */
       
  9863 static TInt TestPanicMinimumSizeMaxLines(TAny* aData)
       
  9864 	{
       
  9865 	CTBiDi* theTest = static_cast <CTBiDi*> (aData);
       
  9866 	CTrapCleanup* trap = CTrapCleanup::New();
       
  9867 	if (!trap)
       
  9868 		return KErrNoMemory;
       
  9869 	
       
  9870 	TInt result = KErrNone;;
       
  9871 	TRAP_IGNORE(result = theTest->DoTestPanicMinimumSizeMaxLines());
       
  9872 	
       
  9873 	delete trap;
       
  9874 	return result;
       
  9875 	}
       
  9876 
       
  9877 
       
  9878 /**
       
  9879  *
       
  9880  * Check that TBidiText will panic if LineOfDisplayText is called
       
  9881  * with an invalid number of lines.
       
  9882  *
       
  9883  * Note: This function will generate a panic and should therefore
       
  9884  * be called from within a separate worker thread.
       
  9885  *
       
  9886  */
       
  9887 TInt CTBiDi::DoTestPanicMinimumNumberOfLinesL()
       
  9888 	{
       
  9889 	CFont* testFont = new (ELeave) CTestFont;
       
  9890 	CleanupStack::PushL(testFont);
       
  9891 
       
  9892 	_LIT(KDummyText, "Hello World");
       
  9893 	TBidiText* bidiText   = TBidiText::NewL(KDummyText, 50);
       
  9894 	CleanupStack::PushL(bidiText);
       
  9895 	
       
  9896 	TInt width = 400;
       
  9897 	bidiText->LineOfDisplayText(-2, width);
       
  9898 
       
  9899 	CleanupStack::PopAndDestroy(2,testFont);
       
  9900 	
       
  9901 	return KErrNone;
       
  9902 	}
       
  9903 /**
       
  9904  *
       
  9905  * Entry point for the DoTestPanicMinimumNumberOfLinesL test's worker 
       
  9906  * thread
       
  9907  *
       
  9908  * Provides cleanup stack for the test function
       
  9909  *
       
  9910  */
       
  9911 static TInt TestPanicMinimumNumberOfLines(TAny* aData)
       
  9912 	{
       
  9913 	CTBiDi* theTest = static_cast <CTBiDi*> (aData);
       
  9914 	CTrapCleanup* trap = CTrapCleanup::New();
       
  9915 	if (!trap)
       
  9916 		{
       
  9917 		return KErrNoMemory;
       
  9918 		}
       
  9919 	TRAP_IGNORE(theTest->DoTestPanicMinimumNumberOfLinesL());
       
  9920 	
       
  9921 	delete trap;
       
  9922 	return KErrNone;
       
  9923 	}
       
  9924 
       
  9925 /**
       
  9926  *
       
  9927  * Test that TBidiText::MinimumSize() will panic in the following
       
  9928  * circumstances:
       
  9929  *
       
  9930  *    o Wrapping width is invalid (i.e. <= 0)
       
  9931  *    o Line gap is invalid (i.e. < 0)
       
  9932  *    o Max. lines is invalid (i.e. < -1)
       
  9933  *
       
  9934  */
       
  9935 void CTBiDi::DoTestTBidiTextMinimumSizePanics()
       
  9936 	{
       
  9937 	INFO_PRINTF1(_L("    Invalid wrapping width (will panic!)"));
       
  9938 	TEST(EBidiPanic_InvalidWrappingWidth == TestPanic(TestPanicMinimumSizeWidth));
       
  9939 
       
  9940 	INFO_PRINTF1(_L("    Invalid line gap (will panic!)"));
       
  9941 	TEST(EBidiPanic_InvalidLineGap == TestPanic(TestPanicMinimumSizeLineGap));
       
  9942 
       
  9943 	INFO_PRINTF1(_L("    Invalid max lines (will panic!)"));
       
  9944 	TEST(EBidiPanic_InvalidMaxline == TestPanic(TestPanicMinimumSizeMaxLines));
       
  9945 	
       
  9946 	INFO_PRINTF1(_L("    Invalid minimum number of lines (will panic!)"));
       
  9947 	TEST(EBidiPanic_InvalidVisualOrderedTextLength == TestPanic(TestPanicMinimumNumberOfLines));
       
  9948 	}
       
  9949 	
       
  9950 	
       
  9951 /**
       
  9952    @SYMTestCaseID			GRAPHICS-GDI-BiDi-0009
       
  9953 
       
  9954    @SYMDEF					Change Request APOS-69QD7N
       
  9955 
       
  9956    @SYMTestCaseDesc			Test TBidirectionalState functionality (Unicode Bidirectional Algorithm impmentation withing SymbianOS)
       
  9957 
       
  9958    @SYMTestPriority			High
       
  9959 
       
  9960    @SYMTestStatus       	Implemented
       
  9961 
       
  9962    @SYMTestActions      	Test detection of 'overall' directionality of a given language/script
       
  9963 
       
  9964    @SYMTestExpectedResults	Confirmation the implementation conforms to the Unicode Birdirection Algorithm standard
       
  9965 */
       
  9966 void CTBiDi::TestCrApos69qd7nL()
       
  9967 	{
       
  9968 	INFO_PRINTF1(_L("CR APOS-69QD7N - TBidiText"));
       
  9969 	((CTBiDiStep*)iStep)->SetTestStepID(_L("GRAPHICS-SYSLIB-GDI-CT-0217"));
       
  9970 	DoTestRRunInfoArrayInternalsL();
       
  9971 	((CTBiDiStep*)iStep)->RecordTestResultL();
       
  9972 	((CTBiDiStep*)iStep)->SetTestStepID(_L("GRAPHICS-SYSLIB-GDI-CT-0218"));
       
  9973 	DoTestTBidiTextNewL();
       
  9974 	((CTBiDiStep*)iStep)->RecordTestResultL();
       
  9975 	((CTBiDiStep*)iStep)->SetTestStepID(_L("GRAPHICS-SYSLIB-GDI-CT-0219"));
       
  9976 	DoTestTBidiTextSetTextL();
       
  9977 	((CTBiDiStep*)iStep)->RecordTestResultL();
       
  9978 	((CTBiDiStep*)iStep)->SetTestStepID(_L("GRAPHICS-SYSLIB-GDI-CT-0220"));
       
  9979 	DoTestTBidiTextMinimumSizeL();
       
  9980 	((CTBiDiStep*)iStep)->RecordTestResultL();
       
  9981 	((CTBiDiStep*)iStep)->SetTestStepID(_L("GRAPHICS-GDI-BiDi-0009"));
       
  9982 	DoTestTBidiTextMinimumSizePanics();
       
  9983 	}
       
  9984 	
       
  9985 /**
       
  9986  *
       
  9987  * Test for English Strings inserted into Arabic text with brackets interspersed.
       
  9988  *
       
  9989  */
       
  9990  
       
  9991 void CTBiDi::INC086135TestL()
       
  9992 	{	
       
  9993 	// originalText: "<ALEF><LAM> ([h]o{m}e(r)):"
       
  9994 	const TText* originalText = _S("\x627\x644 ([h]o{m}e(r)):");
       
  9995 	// expected text: ":((h]o{m}e(r]) <LAM><ALEF>
       
  9996 	const TText* expectedText = _S(":((h]o{m}e(r]) \x644\x627");
       
  9997 	
       
  9998 	TPtrC ptrOriginal(originalText);
       
  9999 	TPtrC ptrExpected(expectedText);
       
 10000 
       
 10001 	// Construct the bidirectional text
       
 10002 	TBidiText* bidiText = TBidiText::NewL(ptrOriginal, 16);
       
 10003 	CleanupStack::PushL(bidiText);
       
 10004 	
       
 10005 	// Call wrap text to prepare the text
       
 10006 	CFont* testFont = new(ELeave) CTestFont;
       
 10007 	CleanupStack::PushL(testFont);
       
 10008 	const TInt KLineLength = 192;
       
 10009 	const TInt KNumLines = 1;
       
 10010 	bidiText->WrapText(KLineLength , *testFont, NULL, KNumLines);
       
 10011 	
       
 10012 	// Return the text that would be displayed
       
 10013 	TPtrC displayText = bidiText->DisplayText();
       
 10014 	
       
 10015 	// Check the result
       
 10016 	if(displayText.Compare(ptrExpected) != 0)
       
 10017 		{
       
 10018 		INFO_PRINTF1(_L("INC086135Test Failed\r\n"));
       
 10019 		PrintTestData(_L("Result "), displayText);
       
 10020 		PrintTestData(_L("Expected "), ptrExpected);
       
 10021 		TEST(EFalse);
       
 10022 		}
       
 10023 	else
       
 10024 		{
       
 10025 		INFO_PRINTF1(_L("INC086135Test Passed\r\n"));
       
 10026 		}
       
 10027 	CleanupStack::PopAndDestroy(2, bidiText);
       
 10028 	}
       
 10029 
       
 10030 
       
 10031 CTBiDi::CTBiDi(CTestStep* aStep) :
       
 10032 	CTGraphicsBase(aStep)
       
 10033 	{
       
 10034 	 iTestThreadCounter = 0;
       
 10035 	INFO_PRINTF1(_L("TBidirectionalState::ReorderText"));
       
 10036 	}
       
 10037 
       
 10038 
       
 10039 void CTBiDi::RunTestCaseL(TInt aCurTestCase)
       
 10040 	{
       
 10041 	((CTBiDiStep*)iStep)->SetTestStepID(KUnknownSYMTestCaseIDName);
       
 10042 	switch(aCurTestCase)
       
 10043 		{
       
 10044 	case 1:
       
 10045 		((CTBiDiStep*)iStep)->SetTestStepID(_L("GRAPHICS-GDI-BiDi-0001"));
       
 10046 		TRAPD(err, TestTBidirectionalStateInternalsL());
       
 10047 		TEST(err == KErrNone);
       
 10048 		break;
       
 10049 	case 2:
       
 10050 /**
       
 10051 @SYMTestCaseID GRAPHICS-GDI-BiDi-0002
       
 10052 */
       
 10053         	((CTBiDiStep*)iStep)->SetTestStepID(_L("GRAPHICS-GDI-BiDi-0002"));
       
 10054 		TRAP(err, TestTBidirectionalState::TestAPIL(this));
       
 10055 		TEST(err == KErrNone);
       
 10056 		break;
       
 10057 	case 3:
       
 10058 		((CTBiDiStep*)iStep)->SetTestStepID(_L("GRAPHICS-GDI-BiDi-0003"));
       
 10059 		TRAP(err, TestTBidirectionalState::TestReorderTextL(this));
       
 10060 		TEST(err == KErrNone);
       
 10061 		break;
       
 10062 	case 4:
       
 10063 		((CTBiDiStep*)iStep)->SetTestStepID(_L("GRAPHICS-GDI-BiDi-0004"));
       
 10064 		TRAP(err, TestReorderTextL());
       
 10065 		TEST(err == KErrNone);
       
 10066 		break;
       
 10067 	case 5:
       
 10068 		((CTBiDiStep*)iStep)->SetTestStepID(_L("GRAPHICS-GDI-BiDi-0005"));
       
 10069 		TRAP(err, TUnicodeExampleTestL());
       
 10070 		TEST(err == KErrNone);
       
 10071 		break;
       
 10072 	case 6:
       
 10073 		((CTBiDiStep*)iStep)->SetTestStepID(_L("GRAPHICS-GDI-BiDi-0006"));
       
 10074 		INFO_PRINTF1(_L("Script directionality"));
       
 10075 		TestScriptDirectionality();
       
 10076 		break;
       
 10077 	case 7:
       
 10078 		{
       
 10079 		((CTBiDiStep*)iStep)->SetTestStepID(_L("GRAPHICS-GDI-BiDi-0007"));
       
 10080 		INFO_PRINTF1(_L("TBidiText"));
       
 10081 		TRAPD(err, TestBidiTextClassL());
       
 10082 		TEST(err == KErrNone);
       
 10083 		}
       
 10084 		break;
       
 10085 	case 8:
       
 10086 		{
       
 10087 		((CTBiDiStep*)iStep)->SetTestStepID(_L("GRAPHICS-GDI-BiDi-0008"));
       
 10088 		INFO_PRINTF1(_L("TBidiLogicalToVisual"));
       
 10089 		TRAPD(err, TestBidiLogicalToVisualClassL());
       
 10090 		TEST(err == KErrNone);
       
 10091 		}
       
 10092 		break;
       
 10093 	case 9:
       
 10094 		{
       
 10095 	__UHEAP_MARK;
       
 10096 		((CTBiDiStep*)iStep)->SetTestStepID(_L("GRAPHICS-GDI-BiDi-0009"));
       
 10097 		TRAPD(err, TestCrApos69qd7nL());
       
 10098 		TEST(err == KErrNone);
       
 10099 		((CTBiDiStep*)iStep)->CloseTMSGraphicsStep();	
       
 10100 	__UHEAP_MARKEND;
       
 10101 		}
       
 10102 		break;
       
 10103 	case 10:
       
 10104 		{
       
 10105 /**
       
 10106 @SYMTestCaseID GRAPHICS-GDI-BiDi-0010
       
 10107 */
       
 10108         	((CTBiDiStep*)iStep)->SetTestStepID(_L("GRAPHICS-GDI-BiDi-0010"));
       
 10109 		INFO_PRINTF1(_L("INC086135Test"));
       
 10110 		TRAPD(err, INC086135TestL());
       
 10111 		TEST(err == KErrNone);
       
 10112 		break;	
       
 10113 		}
       
 10114 	case 11:
       
 10115         	((CTBiDiStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName);
       
 10116 		((CTBiDiStep*)iStep)->CloseTMSGraphicsStep();
       
 10117 		TestComplete();
       
 10118 		break;
       
 10119 		}
       
 10120 	((CTBiDiStep*)iStep)->RecordTestResultL();
       
 10121 	}
       
 10122 
       
 10123 //--------------
       
 10124 __CONSTRUCT_STEP__(BiDi)