Symaptic: os/textandloc/charconvfw/charconvplugins/test/rtest/tsrc/main/t

     1 /*

     2 * Copyright (c) 2005-2010 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:

    15 *

    16 */

    19 #include <e32std.h>

    20 #include <e32base.h>

    21 #include <f32file.h>

    22 #include <charconv.h>

    23 #include "t_ucs2.h"

    25 #define test(cond)                                  \

    26     {                                               \

    27     TBool __bb = (cond);                            \

    28     TEST(__bb);                                     \

    29     if (!__bb)                                      \

    30         {                                           \

    31         ERR_PRINTF1(_L("ERROR: Test Failed"));      \

    32         User::Leave(1);                             \

    33         }                                           \

    34     }

    36 const TInt KMibValue = 1000;

    38 const TInt KBufferLength1=1;

    39 const TInt KBufferLength6=6;

    40 const TInt KBufferLength8=8;

    41 const TInt KBufferLength40=40;

    43 const TPtrC8 KForeignBufferEven12LE(_S8("\xff\xfe\x41\x42\x43\x44\x45\x46\x47\x48\x49\x4a"));

    44 const TPtrC8 KForeignBufferOdd13LE(_S8("\xff\xfe\x41\x42\x43\x44\x45\x46\x47\x48\x49\x4a\x4b"));

    45 const TPtrC8 KForeignBufferEven12BE(_S8("\xfe\xff\x42\x41\x44\x43\x46\x45\x48\x47\x4a\x49"));

    46 const TPtrC8 KForeignBufferOdd13BE(_S8("\xfe\xff\x42\x41\x44\x43\x46\x45\x48\x47\x4a\x49\x4b"));

    48 const TPtrC8 KForeignBufferEvenWithoutBOM10LE(_S8("\x41\x42\x43\x44\x45\x46\x47\x48\x49\x4a"));

    49 const TPtrC8 KForeignBufferOddWithoutBOM11LE(_S8("\x41\x42\x43\x44\x45\x46\x47\x48\x49\x4a\x4b"));

    50 const TPtrC8 KForeignBufferEvenWithoutBOM10BE(_S8("\x42\x41\x44\x43\x46\x45\x48\x47\x4a\x49"));

    51 const TPtrC8 KForeignBufferOddWithoutBOM11BE(_S8("\x42\x41\x44\x43\x46\x45\x48\x47\x4a\x49\x4b"));

    53 const TPtrC8 KForeignBufferEven24LE(_S8("\xff\xfe\x41\x42\x43\x44\x45\x46\x47\x48\x49\x4a\x4b\x4c\x4d\x4e\x4f\x50\x51\x52\x53\x54\x55\x56"));

    54 const TPtrC8 KForeignBufferOdd25LE(_S8("\xff\xfe\x41\x42\x43\x44\x45\x46\x47\x48\x49\x4a\x4b\x4c\x4d\x4e\x4f\x50\x51\x52\x53\x54\x55\x56\x57"));

    55 const TPtrC8 KForeignBufferEven24BE(_S8("\xfe\xff\x42\x41\x44\x43\x46\x45\x48\x47\x4a\x49\x4c\x4b\x4e\x4d\x50\x4f\x52\x51\x54\x53\x56\x55"));

    56 const TPtrC8 KForeignBufferOdd25BE(_S8("\xfe\xff\x42\x41\x44\x43\x46\x45\x48\x47\x4a\x49\x4c\x4b\x4e\x4d\x50\x4f\x52\x51\x54\x53\x56\x55\x57"));

    58 const TPtrC8 KForeignBufferEvenWithoutBOM22LE(_S8("\x41\x42\x43\x44\x45\x46\x47\x48\x49\x4a\x4b\x4c\x4d\x4e\x4f\x50\x51\x52\x53\x54\x55\x56"));

    59 const TPtrC8 KForeignBufferOddWithoutBOM23LE(_S8("\x41\x42\x43\x44\x45\x46\x47\x48\x49\x4a\x4b\x4c\x4d\x4e\x4f\x50\x51\x52\x53\x54\x55\x56\x57"));

    60 const TPtrC8 KForeignBufferEvenWithoutBOM22BE(_S8("\x42\x41\x44\x43\x46\x45\x48\x47\x4a\x49\x4c\x4b\x4e\x4d\x50\x4f\x52\x51\x54\x53\x56\x55"));

    61 const TPtrC8 KForeignBufferOddWithoutBOM23BE(_S8("\x42\x41\x44\x43\x46\x45\x48\x47\x4a\x49\x4c\x4b\x4e\x4d\x50\x4f\x52\x51\x54\x53\x56\x55\x57"));

    63 const TPtrC16 KUnicodeBufferEven14BE(_S16("\xfeff\x4142\x4344\x4546\x4748\x494a\x4b4c\x4d4e\x4f50\x5152\x5354\x5556\x5758\x595a"));

    64 const TPtrC16 KUnicodeBufferOdd15BE(_S16("\xfeff\x4142\x4344\x4546\x4748\x494a\x4b4c\x4d4e\x4f50\x5152\x5354\x5556\x5758\x595a\x5b5c"));

    66 /**

    67 @SYMTestCaseID          SYSLIB-CHARCONV-CT-0553

    68 @SYMTestCaseDesc        8 bit to UCS2 Little Endian Conversion - Single pass test

    69 @SYMTestPriority        Medium

    70 @SYMTestActions         Tests a 8 bit string to 16 bit UCS2 conversion.

    71                         Test with and without Byte Order Mark. Byte Order Mark is set to Little Endian.

    72                         Output buffer is large enough to contain the complete input string

    73                         on a single pass

    74 @SYMTestExpectedResults Test must not fail

    75 @SYMREQ                 REQ0000

    76 */

    77 void CT_UCS2::LEConversionSinglePassBOM(CCnvCharacterSetConverter& aCharacterSetConverter)

    78 {

    79     INFO_PRINTF1(_L(" @SYMTestCaseID:SYSLIB-CHARCONV-CT-0553 "));

    80     TBuf16<KBufferLength40> generatedUnicode;

    81     TInt state=CCnvCharacterSetConverter::KStateDefault;

    82     TInt numberOfUnconvertibleCharacters=0;

    83     TInt indexOfFirstByteOfFirstUnconvertibleCharacter=0;

    84     TInt numberLeft =0;

    86     // set the default endianness to little Endian

    87     aCharacterSetConverter.SetDefaultEndiannessOfForeignCharacters(CCnvCharacterSetConverter::ELittleEndian);

    89     // test even number of foreign bytes

    90     aCharacterSetConverter.ConvertToUnicode(generatedUnicode, KForeignBufferEven12LE, state, numberOfUnconvertibleCharacters, indexOfFirstByteOfFirstUnconvertibleCharacter);

    91     test(generatedUnicode==_L16("\x4241\x4443\x4645\x4847\x4a49"));

    92     test(numberOfUnconvertibleCharacters==0);

    93     test(indexOfFirstByteOfFirstUnconvertibleCharacter==-1);

    94     INFO_PRINTF1(_L("\nLittleEndianConversionSinglePassEvenBOM - OK"));

    96     // test even number of foreign bytes without BOM

    97     aCharacterSetConverter.ConvertToUnicode(generatedUnicode, KForeignBufferEvenWithoutBOM10LE, state, numberOfUnconvertibleCharacters, indexOfFirstByteOfFirstUnconvertibleCharacter);

    98     test(generatedUnicode==_L16("\x4241\x4443\x4645\x4847\x4a49"));

    99     test(numberOfUnconvertibleCharacters==0);

   100     test(indexOfFirstByteOfFirstUnconvertibleCharacter==-1);

   101     INFO_PRINTF1(_L("\nLittleEndianConversionSinglePassEvenBOM - OK"));

   103     // test odd number of foreign bytes

   104     state=CCnvCharacterSetConverter::KStateDefault;

   105     numberLeft = aCharacterSetConverter.ConvertToUnicode(generatedUnicode, KForeignBufferOdd13LE, state, numberOfUnconvertibleCharacters, indexOfFirstByteOfFirstUnconvertibleCharacter);

   106     test(numberLeft==1);

   107     test(generatedUnicode==_L16("\x4241\x4443\x4645\x4847\x4a49"));

   108     test(numberOfUnconvertibleCharacters==0);

   109     test(indexOfFirstByteOfFirstUnconvertibleCharacter==-1);

   111     // test odd number of foreign bytes without BOM

   112     numberLeft = aCharacterSetConverter.ConvertToUnicode(generatedUnicode, KForeignBufferOddWithoutBOM11LE, state, numberOfUnconvertibleCharacters, indexOfFirstByteOfFirstUnconvertibleCharacter);

   113     test(generatedUnicode==_L16("\x4241\x4443\x4645\x4847\x4a49"));

   114     test(numberLeft==1);

   115     test(numberOfUnconvertibleCharacters==0);

   116     test(indexOfFirstByteOfFirstUnconvertibleCharacter==-1);

   118     INFO_PRINTF1(_L("\nLittleEndianConversionSinglePassOddBOM - OK"));

   119 }

   120 /**

   121 @SYMTestCaseID          SYSLIB-CHARCONV-CT-0554

   122 @SYMTestCaseDesc        8 bit to UCS2 Little Endian Conversion - Multiple pass test

   123 @SYMTestPriority        Medium

   124 @SYMTestActions         Tests a 8 bit string to 16 bit UCS2 conversion.

   125                         With and without Byte Order Mark. Byte Order Mark is set to Little Endian.

   126                         Output buffer is NOT large enough to contain the complete input string

   127                         on a single pass. Multiple calls are made to complete translation.

   128 @SYMTestExpectedResults Test must not fail

   129 @SYMREQ                 REQ0000

   130 */

   131 void CT_UCS2::LEConversionMultiplePassBOM(CCnvCharacterSetConverter& aCharacterSetConverter)

   132 {

   133     INFO_PRINTF1(_L(" @SYMTestCaseID:SYSLIB-CHARCONV-CT-0554 "));

   134     TBuf16<KBufferLength6> generatedUnicode;

   135     TInt state=CCnvCharacterSetConverter::KStateDefault;

   136     TInt numberOfUnconvertibleCharacters=0;

   137     TInt indexOfFirstByteOfFirstUnconvertibleCharacter=0;

   139     // set the default endianness to little Endian

   140     aCharacterSetConverter.SetDefaultEndiannessOfForeignCharacters(CCnvCharacterSetConverter::ELittleEndian);

   142     // test even number of foreign bytes

   143     // first pass

   144     TInt numberUnconverted;

   145     numberUnconverted = aCharacterSetConverter.ConvertToUnicode(generatedUnicode, KForeignBufferEven24LE, state, numberOfUnconvertibleCharacters, indexOfFirstByteOfFirstUnconvertibleCharacter);

   146     test(generatedUnicode==_L16("\x4241\x4443\x4645\x4847\x4a49\x4c4b"));

   147     test(numberUnconverted==10);

   148     test(numberOfUnconvertibleCharacters==0);

   149     test(indexOfFirstByteOfFirstUnconvertibleCharacter==-1);

   151     // test even number of foreign bytes without BOM

   152     numberUnconverted = aCharacterSetConverter.ConvertToUnicode(generatedUnicode, KForeignBufferEvenWithoutBOM22LE, state, numberOfUnconvertibleCharacters, indexOfFirstByteOfFirstUnconvertibleCharacter);

   153     test(generatedUnicode==_L16("\x4241\x4443\x4645\x4847\x4a49\x4c4b"));

   154     test(numberUnconverted==10);

   155     test(numberOfUnconvertibleCharacters==0);

   156     test(indexOfFirstByteOfFirstUnconvertibleCharacter==-1);

   158     // second pass

   159     numberUnconverted = aCharacterSetConverter.ConvertToUnicode(generatedUnicode, KForeignBufferEven24LE.Right(numberUnconverted), state, numberOfUnconvertibleCharacters, indexOfFirstByteOfFirstUnconvertibleCharacter);

   160     test(numberUnconverted==0);

   161     test(generatedUnicode==_L16("\x4e4d\x504f\x5251\x5453\x5655"));

   162     test(numberOfUnconvertibleCharacters==0);

   163     test(indexOfFirstByteOfFirstUnconvertibleCharacter==-1);

   164     INFO_PRINTF1(_L("\nLittleEndianConversionMultiplePassOddEven - OK"));

   166     // without BOM

   167     numberOfUnconvertibleCharacters=10;

   168     aCharacterSetConverter.ConvertToUnicode(generatedUnicode, KForeignBufferEvenWithoutBOM22LE.Right(numberOfUnconvertibleCharacters), state, numberOfUnconvertibleCharacters, indexOfFirstByteOfFirstUnconvertibleCharacter);

   169     test(generatedUnicode==_L16("\x4e4d\x504f\x5251\x5453\x5655"));

   170     test(numberOfUnconvertibleCharacters==0);

   171     test(indexOfFirstByteOfFirstUnconvertibleCharacter==-1);

   172     INFO_PRINTF1(_L("\nLittleEndianConversionMultiplePassOddEven - OK"));

   175     // test odd number of foreign bytes

   176     // first pass

   177     state=CCnvCharacterSetConverter::KStateDefault;

   178     numberUnconverted = aCharacterSetConverter.ConvertToUnicode(generatedUnicode, KForeignBufferOdd25LE, state, numberOfUnconvertibleCharacters, indexOfFirstByteOfFirstUnconvertibleCharacter);

   179     test(numberUnconverted==11);

   180     test(indexOfFirstByteOfFirstUnconvertibleCharacter==-1);

   181     test(generatedUnicode==_L16("\x4241\x4443\x4645\x4847\x4a49\x4c4b"));

   183     // without BOM

   184     numberUnconverted = aCharacterSetConverter.ConvertToUnicode(generatedUnicode, KForeignBufferOddWithoutBOM23LE, state, numberOfUnconvertibleCharacters, indexOfFirstByteOfFirstUnconvertibleCharacter);

   185     test(numberUnconverted==11);

   186     test(indexOfFirstByteOfFirstUnconvertibleCharacter==-1);

   187     test(generatedUnicode==_L16("\x4241\x4443\x4645\x4847\x4a49\x4c4b"));

   189     // second pass

   190     numberUnconverted = aCharacterSetConverter.ConvertToUnicode(generatedUnicode, KForeignBufferOdd25LE.Right(numberUnconverted), state, numberOfUnconvertibleCharacters, indexOfFirstByteOfFirstUnconvertibleCharacter);

   191     test(generatedUnicode==_L16("\x4e4d\x504f\x5251\x5453\x5655"));

   192     test(numberUnconverted==1);

   193     test(numberOfUnconvertibleCharacters==0);

   194     test(indexOfFirstByteOfFirstUnconvertibleCharacter==-1);

   196     // without BOM

   197     numberUnconverted = 11;

   198     numberUnconverted = aCharacterSetConverter.ConvertToUnicode(generatedUnicode, KForeignBufferOddWithoutBOM23LE.Right(numberUnconverted), state, numberOfUnconvertibleCharacters, indexOfFirstByteOfFirstUnconvertibleCharacter);

   199     test(numberUnconverted==1);

   200     test(numberOfUnconvertibleCharacters==0);

   201     test(indexOfFirstByteOfFirstUnconvertibleCharacter==-1);

   202     test(generatedUnicode==_L16("\x4e4d\x504f\x5251\x5453\x5655"));

   205     INFO_PRINTF1(_L("\nLittleEndianConversionMultiplePassOddBOM - OK"));

   206 }

   207 /**

   208 @SYMTestCaseID          SYSLIB-CHARCONV-CT-0555

   209 @SYMTestCaseDesc        8 bit to UCS2 Big Endian Conversion - Single pass

   210 @SYMTestPriority        Medium

   211 @SYMTestActions         Tests a 8 bit string to 16 bit UCS2 conversion.

   212                         With and without Byte Order Mark. Byte Order Mark is set to Big Endian.

   213                         Output buffer is large enough to contain the complete input string

   214                         on a single pass

   215 @SYMTestExpectedResults Test must not fail

   216 @SYMREQ                 REQ0000

   217 */

   218 void CT_UCS2::BEConversionSinglePassBOM(CCnvCharacterSetConverter& aCharacterSetConverter)

   219 {

   220     INFO_PRINTF1(_L(" @SYMTestCaseID:SYSLIB-CHARCONV-CT-0555 "));

   221     TBuf16<KBufferLength40> generatedUnicode;

   222     TInt state=CCnvCharacterSetConverter::KStateDefault;

   223     TInt numberOfUnconvertibleCharacters=0;

   224     TInt indexOfFirstByteOfFirstUnconvertibleCharacter=0;

   225     TInt numberLeft=0;

   227     // set the default endianness to Big Endian

   228     aCharacterSetConverter.SetDefaultEndiannessOfForeignCharacters(CCnvCharacterSetConverter::EBigEndian);

   230     // test even number of foreign bytes

   231     aCharacterSetConverter.ConvertToUnicode(generatedUnicode, KForeignBufferEven12BE, state, numberOfUnconvertibleCharacters, indexOfFirstByteOfFirstUnconvertibleCharacter);

   232     test(generatedUnicode==_L16("\x4241\x4443\x4645\x4847\x4a49"));

   233     test(numberOfUnconvertibleCharacters==0);

   234     test(indexOfFirstByteOfFirstUnconvertibleCharacter==-1);

   235     INFO_PRINTF1(_L("\nBigEndianConversionSinglePassEvenBOM - OK"));

   237     // test even number of foreign bytes without BOM

   238     aCharacterSetConverter.ConvertToUnicode(generatedUnicode, KForeignBufferEvenWithoutBOM10BE, state, numberOfUnconvertibleCharacters, indexOfFirstByteOfFirstUnconvertibleCharacter);

   239     test(generatedUnicode==_L16("\x4241\x4443\x4645\x4847\x4a49"));

   240     test(numberOfUnconvertibleCharacters==0);

   241     test(indexOfFirstByteOfFirstUnconvertibleCharacter==-1);

   242     INFO_PRINTF1(_L("\nBigEndianConversionSinglePassEvenBOM - OK"));

   245     // test odd number of foreign bytes

   246     state=CCnvCharacterSetConverter::KStateDefault;

   247     numberLeft = aCharacterSetConverter.ConvertToUnicode(generatedUnicode, KForeignBufferOdd13BE, state, numberOfUnconvertibleCharacters, indexOfFirstByteOfFirstUnconvertibleCharacter);

   248     test(generatedUnicode==_L16("\x4241\x4443\x4645\x4847\x4a49"));

   249     test(numberLeft==1);

   250     test(numberOfUnconvertibleCharacters==0);

   251     test(indexOfFirstByteOfFirstUnconvertibleCharacter==-1);

   253     // test odd number of foreign bytes without BOM

   254     numberLeft = aCharacterSetConverter.ConvertToUnicode(generatedUnicode, KForeignBufferOddWithoutBOM11BE, state, numberOfUnconvertibleCharacters, indexOfFirstByteOfFirstUnconvertibleCharacter);

   255     test(generatedUnicode==_L16("\x4241\x4443\x4645\x4847\x4a49"));

   256     test(numberLeft==1);

   257     test(numberOfUnconvertibleCharacters==0);

   258     test(indexOfFirstByteOfFirstUnconvertibleCharacter==-1);

   260     INFO_PRINTF1(_L("\nBigEndianConversionSinglePassOddBOM - OK"));

   261 }

   262 /**

   263 @SYMTestCaseID          SYSLIB-CHARCONV-CT-0556

   264 @SYMTestCaseDesc        8 bit to UCS2 Big Endian Conversion - Multiple pass test

   265 @SYMTestPriority        Medium

   266 @SYMTestActions         Tests a 8 bit string to 16 bit UCS2 conversion.

   267                         With and without Byte Order Mark. Byte Order Mark is set to Big Endian.

   268                         Output buffer is NOT large enough to contain the complete input string

   269                         on a single pass. Multiple calls are made to complete translation.

   270 @SYMTestExpectedResults Test must not fail

   271 @SYMREQ                 REQ0000

   272 */

   273 void CT_UCS2::BEConversionMultiplePassBOM(CCnvCharacterSetConverter& aCharacterSetConverter)

   274 {

   275     INFO_PRINTF1(_L(" @SYMTestCaseID:SYSLIB-CHARCONV-CT-0556 "));

   276     TBuf16<KBufferLength6> generatedUnicode;

   277     TInt state=CCnvCharacterSetConverter::KStateDefault;

   278     TInt numberOfUnconvertibleCharacters=0;

   279     TInt indexOfFirstByteOfFirstUnconvertibleCharacter=0;

   280     TInt numberUnconverted=0;

   282     // set the default endianness to Big Endian

   283     aCharacterSetConverter.SetDefaultEndiannessOfForeignCharacters(CCnvCharacterSetConverter::EBigEndian);

   285     // test even number of foreign bytes

   286     // first pass

   287     numberUnconverted=aCharacterSetConverter.ConvertToUnicode(generatedUnicode, KForeignBufferEven24BE, state, numberOfUnconvertibleCharacters, indexOfFirstByteOfFirstUnconvertibleCharacter);

   288     test(generatedUnicode==_L16("\x4241\x4443\x4645\x4847\x4a49\x4c4b"));

   289     test(numberUnconverted==10);

   290     test(numberOfUnconvertibleCharacters==0);

   291     test(indexOfFirstByteOfFirstUnconvertibleCharacter==-1);

   293     // without BOM

   294     numberUnconverted=aCharacterSetConverter.ConvertToUnicode(generatedUnicode, KForeignBufferEvenWithoutBOM22BE, state, numberOfUnconvertibleCharacters, indexOfFirstByteOfFirstUnconvertibleCharacter);

   295     test(generatedUnicode==_L16("\x4241\x4443\x4645\x4847\x4a49\x4c4b"));

   296     test(numberUnconverted==10);

   297     test(numberOfUnconvertibleCharacters==0);

   298     test(indexOfFirstByteOfFirstUnconvertibleCharacter==-1);

   300     // second pass

   301     numberUnconverted=aCharacterSetConverter.ConvertToUnicode(generatedUnicode, KForeignBufferEven24BE.Right(numberUnconverted), state, numberOfUnconvertibleCharacters, indexOfFirstByteOfFirstUnconvertibleCharacter);

   302     test(generatedUnicode==_L16("\x4e4d\x504f\x5251\x5453\x5655"));

   303     test(numberUnconverted==0);

   304     test(numberOfUnconvertibleCharacters==0);

   305     test(indexOfFirstByteOfFirstUnconvertibleCharacter==-1);

   306     INFO_PRINTF1(_L("\nBigEndianConversionMultiplePassOddEven - OK"));

   308     // without BOM

   309     numberOfUnconvertibleCharacters=10;

   310     numberUnconverted=aCharacterSetConverter.ConvertToUnicode(generatedUnicode, KForeignBufferEvenWithoutBOM22BE.Right(numberOfUnconvertibleCharacters), state, numberOfUnconvertibleCharacters, indexOfFirstByteOfFirstUnconvertibleCharacter);

   311     test(generatedUnicode==_L16("\x4e4d\x504f\x5251\x5453\x5655"));

   312     test(numberOfUnconvertibleCharacters==0);

   313     test(indexOfFirstByteOfFirstUnconvertibleCharacter==-1);

   314     INFO_PRINTF1(_L("\nBigEndianConversionMultiplePassOddEven - OK"));

   316     // test odd number of foreign bytes

   317     // first pass

   318     state=CCnvCharacterSetConverter::KStateDefault;

   319     numberUnconverted=aCharacterSetConverter.ConvertToUnicode(generatedUnicode, KForeignBufferOdd25BE, state, numberOfUnconvertibleCharacters, indexOfFirstByteOfFirstUnconvertibleCharacter);

   320     test(numberUnconverted==11);

   321     test(numberOfUnconvertibleCharacters==0);

   322     test(indexOfFirstByteOfFirstUnconvertibleCharacter==-1);

   323     test(generatedUnicode==_L16("\x4241\x4443\x4645\x4847\x4a49\x4c4b"));

   325     // without BOM

   326     numberUnconverted=aCharacterSetConverter.ConvertToUnicode(generatedUnicode, KForeignBufferOddWithoutBOM23BE, state, numberOfUnconvertibleCharacters, indexOfFirstByteOfFirstUnconvertibleCharacter);

   327     test(numberUnconverted==11);

   328     test(numberOfUnconvertibleCharacters==0);

   329     test(indexOfFirstByteOfFirstUnconvertibleCharacter==-1);

   330     test(generatedUnicode==_L16("\x4241\x4443\x4645\x4847\x4a49\x4c4b"));

   332     // second pass

   333     numberUnconverted=aCharacterSetConverter.ConvertToUnicode(generatedUnicode, KForeignBufferOdd25BE.Right(numberUnconverted), state, numberOfUnconvertibleCharacters, indexOfFirstByteOfFirstUnconvertibleCharacter);

   334     test(generatedUnicode==_L16("\x4e4d\x504f\x5251\x5453\x5655"));

   335     test(numberUnconverted==1);

   336     test(numberOfUnconvertibleCharacters==0);

   337     test(indexOfFirstByteOfFirstUnconvertibleCharacter==-1);

   339     // without BOM

   340     numberOfUnconvertibleCharacters=11;

   341     numberUnconverted=aCharacterSetConverter.ConvertToUnicode(generatedUnicode, KForeignBufferOddWithoutBOM23BE.Right(numberOfUnconvertibleCharacters), state, numberOfUnconvertibleCharacters, indexOfFirstByteOfFirstUnconvertibleCharacter);

   342     test(generatedUnicode==_L16("\x4e4d\x504f\x5251\x5453\x5655"));

   343     test(numberUnconverted==1);

   344     test(numberOfUnconvertibleCharacters==0);

   345     test(indexOfFirstByteOfFirstUnconvertibleCharacter==-1);

   348     INFO_PRINTF1(_L("\nBigEndianConversionMultiplePassOddBOM - OK"));

   349 }

   350 /**

   351 @SYMTestCaseID          SYSLIB-CHARCONV-CT-0557

   352 @SYMTestCaseDesc        UCS2 to 8 bit Big Endian Conversion - Single pass test

   353 @SYMTestPriority        Medium

   354 @SYMTestActions         Tests a 16 bit UCS2 to 8 bit descriptor conversion.

   355                         Byte Order Mark is present and is set to Big Endian.

   356                         Output buffer is large enough to contain the complete input string

   357                         on a single pass

   358 @SYMTestExpectedResults Test must not fail

   359 @SYMREQ                 REQ0000

   360 */

   361 void CT_UCS2::UCS2BEConversionSinglePassBOM(CCnvCharacterSetConverter& aCharacterSetConverter)

   362 {

   363     INFO_PRINTF1(_L(" @SYMTestCaseID:SYSLIB-CHARCONV-CT-0557 "));

   364     TBuf8<KBufferLength40> generatedForeign;

   365     CCnvCharacterSetConverter::TArrayOfAscendingIndices indicesOfUnconvertibleCharacters;

   367     // set the default endianness to Big Endian

   368     aCharacterSetConverter.SetDefaultEndiannessOfForeignCharacters(CCnvCharacterSetConverter::EBigEndian);

   370     // test even number of foreign bytes

   371     aCharacterSetConverter.ConvertFromUnicode( generatedForeign,

   372                                                         KUnicodeBufferEven14BE,

   373                                                         indicesOfUnconvertibleCharacters );

   375     test(generatedForeign==_L8("\xfe\xff\x41\x42\x43\x44\x45\x46\x47\x48\x49\x4a\x4b\x4c\x4d\x4e\x4f\x50\x51\x52\x53\x54\x55\x56\x57\x58\x59\x5a"));

   376     INFO_PRINTF1(_L("\nUCS2BEConversionSinglePassEvenBOM - OK"));

   378     // test odd number of foreign bytes

   379     aCharacterSetConverter.ConvertFromUnicode( generatedForeign,

   380                                                         KUnicodeBufferOdd15BE,

   381                                                         indicesOfUnconvertibleCharacters );

   383     test(generatedForeign==_L8("\xfe\xff\x41\x42\x43\x44\x45\x46\x47\x48\x49\x4a\x4b\x4c\x4d\x4e\x4f\x50\x51\x52\x53\x54\x55\x56\x57\x58\x59\x5a\x5b\x5c"));

   384     INFO_PRINTF1(_L("\nUCS2BEConversionSinglePassOddBOM - OK"));

   385 }

   386 /**

   387 @SYMTestCaseID          SYSLIB-CHARCONV-CT-0558

   388 @SYMTestCaseDesc        UCS2 to 8 bit Big Endian Conversion - Multiple pass test

   389 @SYMTestPriority        Medium

   390 @SYMTestActions         Tests a 16 bit UCS2 to 8 bit descriptor conversion.

   391                         Byte Order Mark is present and is set to Big Endian.

   392                         Output buffer is NOT large enough to contain the complete input string

   393                         on a single pass

   394 @SYMTestExpectedResults Test must not fail

   395 @SYMREQ                 REQ0000

   396 */

   397 void CT_UCS2::UCS2BEConversionMultiplePassBOM (CCnvCharacterSetConverter& aCharacterSetConverter)

   398 {

   399     INFO_PRINTF1(_L(" @SYMTestCaseID:SYSLIB-CHARCONV-CT-0558 "));

   400     TBuf8<KBufferLength6> generatedForeign;

   401     TBuf8<KBufferLength8> generatedForeign2;

   402     TInt result=0;

   403     CCnvCharacterSetConverter::TArrayOfAscendingIndices indicesOfUnconvertibleCharacters;

   405     // set the default endianness to Big Endian

   406     aCharacterSetConverter.SetDefaultEndiannessOfForeignCharacters(CCnvCharacterSetConverter::EBigEndian);

   408     // *** Test even number of bytes ***

   409     // test even number of foreign bytes - pass 1

   410     result = aCharacterSetConverter.ConvertFromUnicode( generatedForeign,

   411                                                         KUnicodeBufferEven14BE,

   412                                                         indicesOfUnconvertibleCharacters );

   413     test(generatedForeign==_L8("\xfe\xff\x41\x42\x43\x44"));

   414     test(result==11);

   416     // test even number of foreign bytes - pass 2

   417     result = aCharacterSetConverter.ConvertFromUnicode( generatedForeign,

   418                                                         KUnicodeBufferEven14BE.Right(result),

   419                                                         indicesOfUnconvertibleCharacters );

   420     test(result==8);

   421     test(generatedForeign==_L8("\x45\x46\x47\x48\x49\x4A"));

   423     // test even number of foreign bytes - pass 3

   424     result = aCharacterSetConverter.ConvertFromUnicode( generatedForeign,

   425                                                         KUnicodeBufferEven14BE.Right(result),

   426                                                         indicesOfUnconvertibleCharacters );

   427     test(result==5);

   428     test(generatedForeign==_L8("\x4b\x4c\x4d\x4e\x4f\x50"));

   431     // test even number of foreign bytes - pass 4

   432     result = aCharacterSetConverter.ConvertFromUnicode( generatedForeign,

   433                                                         KUnicodeBufferEven14BE.Right(result),

   434                                                         indicesOfUnconvertibleCharacters );

   435     test(result==2);

   436     test(generatedForeign==_L8("\x51\x52\x53\x54\x55\x56"));

   438     // test even number of foreign bytes - pass 5

   439     result = aCharacterSetConverter.ConvertFromUnicode( generatedForeign2,

   440                                                         KUnicodeBufferEven14BE.Right(result),

   441                                                         indicesOfUnconvertibleCharacters );

   442     test(generatedForeign2==_L8("\x57\x58\x59\x5a"));

   443     test(result==0);

   445     INFO_PRINTF1(_L("\nUCS2LEConversionMultiplePassEvenBOM - OK"));

   447     // *** Test odd numer of bytes ***

   448     result = aCharacterSetConverter.ConvertFromUnicode( generatedForeign,

   449                                                         KUnicodeBufferOdd15BE,

   450                                                         indicesOfUnconvertibleCharacters );

   451     test(generatedForeign==_L8("\xfe\xff\x41\x42\x43\x44"));

   453         // test even number of foreign bytes - pass 2

   454     result = aCharacterSetConverter.ConvertFromUnicode( generatedForeign,

   455                                                         KUnicodeBufferOdd15BE.Right(result),

   456                                                         indicesOfUnconvertibleCharacters );

   457     test(generatedForeign==_L8("\x45\x46\x47\x48\x49\x4a"));

   459     // test even number of foreign bytes - pass 3

   460     result = aCharacterSetConverter.ConvertFromUnicode( generatedForeign,

   461                                                         KUnicodeBufferOdd15BE.Right(result),

   462                                                         indicesOfUnconvertibleCharacters );

   463     test(generatedForeign==_L8("\x4b\x4c\x4d\x4e\x4f\x50"));

   465     // test even number of foreign bytes - pass 4

   466     result = aCharacterSetConverter.ConvertFromUnicode( generatedForeign,

   467                                                         KUnicodeBufferOdd15BE.Right(result),

   468                                                         indicesOfUnconvertibleCharacters );

   469     test(generatedForeign==_L8("\x51\x52\x53\x54\x55\x56"));

   472     // test even number of foreign bytes - pass 5

   473     result = aCharacterSetConverter.ConvertFromUnicode( generatedForeign,

   474                                                         KUnicodeBufferOdd15BE.Right(result),

   475                                                         indicesOfUnconvertibleCharacters );

   476     test(generatedForeign==_L8("\x57\x58\x59\x5a\x5b\x5c"));

   477     test(result==0);

   479     INFO_PRINTF1(_L("\nUCS2LEConversionMultiplePassOddBOM - OK"));

   480 }

   481 /**

   482 @SYMTestCaseID          SYSLIB-CHARCONV-CT-0559

   483 @SYMTestCaseDesc        Tests a 16 bit UCS2 to 8 bit & 16 bit UCS2 to 8 bit conversion with empty buffers.

   484 @SYMTestPriority        Medium

   485 @SYMTestActions         Attempt for conversion when input and output buffers are small

   486 @SYMTestExpectedResults Test must not fail

   487 @SYMREQ                 REQ0000

   488 */

   489 void CT_UCS2::TooSmallBufferConversion (CCnvCharacterSetConverter& aCharacterSetConverter)

   490     {

   491     INFO_PRINTF1(_L(" @SYMTestCaseID:SYSLIB-CHARCONV-CT-0559 "));

   492     TBuf16<KBufferLength1> generatedUnicode1;

   493     TBuf8<KBufferLength1> generatedForeign1;

   495     TInt state=CCnvCharacterSetConverter::KStateDefault;

   496     TInt numberOfUnconvertibleCharacters=0;

   497     TInt indexOfFirstByteOfFirstUnconvertibleCharacter=0;

   499     CCnvCharacterSetConverter::TArrayOfAscendingIndices indicesOfUnconvertibleCharacters;

   501         // set the default endianness to little Endian

   502     aCharacterSetConverter.SetDefaultEndiannessOfForeignCharacters(CCnvCharacterSetConverter::ELittleEndian);

   504     // convert to UCS2 using an output buffer that is too small

   505     TInt result = aCharacterSetConverter.ConvertToUnicode(generatedUnicode1, KForeignBufferEven12LE, state, numberOfUnconvertibleCharacters, indexOfFirstByteOfFirstUnconvertibleCharacter);

   506     test(generatedUnicode1==_L16("\x4241"));

   507     test(result==8);

   508     test(numberOfUnconvertibleCharacters==0);

   509     test(indexOfFirstByteOfFirstUnconvertibleCharacter==-1);

   510     INFO_PRINTF1(_L("\n8bit->UCS2 output buffer size 1 - OK"));

   512     INFO_PRINTF1(_L("\nConversionTooSmallBuffer - OK"));

   513     }

   514 /**

   515 @SYMTestCaseID          SYSLIB-CHARCONV-CT-0560

   516 @SYMTestCaseDesc        Conversion tests from UCS2 GUID to MIB

   517 @SYMTestPriority        Medium

   518 @SYMTestActions         Tests retreiving the MIB value from the UCS2 GUID

   519                         Tests retreiving the UCS2 GUID from the MIB value

   520 @SYMTestExpectedResults Test must not fail

   521 @SYMREQ                 REQ0000

   522 */

   523 void CT_UCS2::CharacterSetValueAndMIBTests(CCnvCharacterSetConverter& aCharacterSetConverter, RFs& aFileServerSession)

   524 {

   525     INFO_PRINTF1(_L(" @SYMTestCaseID:SYSLIB-CHARCONV-CT-0560 "));

   526     // check that the character set value of '1000' is converted to the UCS2 GUID (0x101ff492)

   527     test(aCharacterSetConverter.ConvertMibEnumOfCharacterSetToIdentifierL(KMibValue,aFileServerSession)==KCharacterSetIdentifierUcs2);

   528     INFO_PRINTF1(_L("\nMIB->Char Set GUID - OK"));

   530     // check that the UCS2 GUID (0x101ff492) is converted to the character set value of '1000'

   531     test(aCharacterSetConverter.ConvertCharacterSetIdentifierToMibEnumL(KCharacterSetIdentifierUcs2,aFileServerSession)==KMibValue);

   532     INFO_PRINTF1(_L("\nChar Set GUID->MIB - OK"));

   533 }

   536 void CT_UCS2::DoE32MainL()

   537     {

   538     RFs fileServerSession;

   539     CleanupClosePushL(fileServerSession);

   540     User::LeaveIfError(fileServerSession.Connect());

   541     CCnvCharacterSetConverter* characterSetConverter=CCnvCharacterSetConverter::NewLC();

   542     CArrayFix<CCnvCharacterSetConverter::SCharacterSet>* arrayOfCharacterSetsAvailable=CCnvCharacterSetConverter::CreateArrayOfCharacterSetsAvailableLC(fileServerSession);

   543     TInt i;

   544     for (i=arrayOfCharacterSetsAvailable->Count()-1; i>=0; --i)

   545         {

   546         const CCnvCharacterSetConverter::SCharacterSet& charactersSet=(*arrayOfCharacterSetsAvailable)[i];

   547         characterSetConverter->PrepareToConvertToOrFromL(charactersSet.Identifier(), *arrayOfCharacterSetsAvailable, fileServerSession);

   548         TPtrC charactersSetName(charactersSet.Name());

   549         if (charactersSet.NameIsFileName())

   550             {

   551             charactersSetName.Set(TParsePtrC(charactersSetName).Name());

   552             }

   553         INFO_PRINTF2(_L("    %S\n"), &charactersSetName);

   554         }

   556     // test MIB to Character Set ID (and visa versa) conversion

   557     CharacterSetValueAndMIBTests(*characterSetConverter, fileServerSession);

   559     // prepare for conversion

   560     INFO_PRINTF1(_L("\nTesting 8 bit -> UCS2 conversion"));

   561     TRAPD( error, characterSetConverter->PrepareToConvertToOrFromL(KCharacterSetIdentifierUcs2, *arrayOfCharacterSetsAvailable, fileServerSession));

   562     if ( error != KErrNone )

   563         {

   564         RDebug::Print(_L("PrepareToConvertToOrFromL failed code:%d\n"),error);

   565         RDebug::Print(_L("KCharacterSetIdentifierUcs2 is not available so tests failed\n"));

   566         User::LeaveIfError(error);

   567         }

   570     // *** 8 bit to UCS2 conversion ***

   571     INFO_PRINTF1(_L("\n8->UCS2 Little Endian Conversion - Single pass"));

   572     LEConversionSinglePassBOM(*characterSetConverter);

   574     INFO_PRINTF1(_L("\n8->UCS2 Little Endian Conversion - Multiple pass"));

   575     LEConversionMultiplePassBOM(*characterSetConverter);

   577     INFO_PRINTF1(_L("\n8->UCS2 Big Endian Conversion - Single pass"));

   578     BEConversionSinglePassBOM(*characterSetConverter);

   580     INFO_PRINTF1(_L("\n8->UCS2 Big Endian Conversion - Multiple pass"));

   581     BEConversionMultiplePassBOM(*characterSetConverter);

   584     // *** UCS2 to 8 bit conversion ***

   585     INFO_PRINTF1(_L("\nUCS2->8 Big Endian Conversion - Single pass"));

   586     UCS2BEConversionSinglePassBOM(*characterSetConverter);

   588     INFO_PRINTF1(_L("\nUCS2->8 Big Endian Conversion - Multiple pass"));

   589     UCS2BEConversionMultiplePassBOM(*characterSetConverter);

   591     // *** attempted conversion when input/output buffers are too small

   592     INFO_PRINTF1(_L("\nTooSmallBufferConversion"));

   593     TooSmallBufferConversion(*characterSetConverter);

   595     INFO_PRINTF1(_L("\n"));

   596     CleanupStack::PopAndDestroy(3);// arrayOfCharacterSetsAvailable and characterSetConverter and fileServerSession

   597     }

   599 CT_UCS2::CT_UCS2()

   600     {

   601     SetTestStepName(KTestStep_T_UCS2);

   602     }

   604 TVerdict CT_UCS2::doTestStepL()

   605     {

   606     SetTestStepResult(EFail);

   608     __UHEAP_MARK;

   609     TRAPD(error1, DoE32MainL());

   610     __UHEAP_MARKEND;

   612     if(error1 == KErrNone)

   613         {

   614         SetTestStepResult(EPass);

   615         }

   617     return TestStepResult();

   618     }

author	sl
	Tue, 10 Jun 2014 14:32:02 +0200
changeset 1	260cb5ec6c19
permissions	-rw-r--r--