sl@0: /*
sl@0: * Copyright (c) 2005-2010 Nokia Corporation and/or its subsidiary(-ies).
sl@0: * All rights reserved.
sl@0: * This component and the accompanying materials are made available
sl@0: * under the terms of "Eclipse Public License v1.0"
sl@0: * which accompanies this distribution, and is available
sl@0: * at the URL "http://www.eclipse.org/legal/epl-v10.html".
sl@0: *
sl@0: * Initial Contributors:
sl@0: * Nokia Corporation - initial contribution.
sl@0: *
sl@0: * Contributors:
sl@0: *
sl@0: * Description: 
sl@0: *
sl@0: */
sl@0: 
sl@0: 
sl@0: #include <e32std.h>
sl@0: #include <e32base.h>
sl@0: #include <f32file.h>
sl@0: #include <charconv.h>
sl@0: #include "t_ucs2.h"
sl@0: 
sl@0: #define test(cond)                                  \
sl@0:     {                                               \
sl@0:     TBool __bb = (cond);                            \
sl@0:     TEST(__bb);                                     \
sl@0:     if (!__bb)                                      \
sl@0:         {                                           \
sl@0:         ERR_PRINTF1(_L("ERROR: Test Failed"));      \
sl@0:         User::Leave(1);                             \
sl@0:         }                                           \
sl@0:     }
sl@0: 
sl@0: const TInt KMibValue = 1000;
sl@0: 
sl@0: const TInt KBufferLength1=1;
sl@0: const TInt KBufferLength6=6;
sl@0: const TInt KBufferLength8=8;
sl@0: const TInt KBufferLength40=40;
sl@0: 
sl@0: const TPtrC8 KForeignBufferEven12LE(_S8("\xff\xfe\x41\x42\x43\x44\x45\x46\x47\x48\x49\x4a"));
sl@0: const TPtrC8 KForeignBufferOdd13LE(_S8("\xff\xfe\x41\x42\x43\x44\x45\x46\x47\x48\x49\x4a\x4b"));
sl@0: const TPtrC8 KForeignBufferEven12BE(_S8("\xfe\xff\x42\x41\x44\x43\x46\x45\x48\x47\x4a\x49"));
sl@0: const TPtrC8 KForeignBufferOdd13BE(_S8("\xfe\xff\x42\x41\x44\x43\x46\x45\x48\x47\x4a\x49\x4b"));
sl@0: 
sl@0: const TPtrC8 KForeignBufferEvenWithoutBOM10LE(_S8("\x41\x42\x43\x44\x45\x46\x47\x48\x49\x4a"));
sl@0: const TPtrC8 KForeignBufferOddWithoutBOM11LE(_S8("\x41\x42\x43\x44\x45\x46\x47\x48\x49\x4a\x4b"));
sl@0: const TPtrC8 KForeignBufferEvenWithoutBOM10BE(_S8("\x42\x41\x44\x43\x46\x45\x48\x47\x4a\x49"));
sl@0: const TPtrC8 KForeignBufferOddWithoutBOM11BE(_S8("\x42\x41\x44\x43\x46\x45\x48\x47\x4a\x49\x4b"));
sl@0: 
sl@0: 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"));
sl@0: 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"));
sl@0: 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"));
sl@0: 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"));
sl@0: 
sl@0: 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"));
sl@0: 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"));
sl@0: 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"));
sl@0: 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"));
sl@0: 
sl@0: const TPtrC16 KUnicodeBufferEven14BE(_S16("\xfeff\x4142\x4344\x4546\x4748\x494a\x4b4c\x4d4e\x4f50\x5152\x5354\x5556\x5758\x595a"));
sl@0: const TPtrC16 KUnicodeBufferOdd15BE(_S16("\xfeff\x4142\x4344\x4546\x4748\x494a\x4b4c\x4d4e\x4f50\x5152\x5354\x5556\x5758\x595a\x5b5c"));
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID          SYSLIB-CHARCONV-CT-0553
sl@0: @SYMTestCaseDesc        8 bit to UCS2 Little Endian Conversion - Single pass test
sl@0: @SYMTestPriority        Medium
sl@0: @SYMTestActions         Tests a 8 bit string to 16 bit UCS2 conversion.
sl@0:                         Test with and without Byte Order Mark. Byte Order Mark is set to Little Endian.
sl@0:                         Output buffer is large enough to contain the complete input string
sl@0:                         on a single pass
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMREQ                 REQ0000
sl@0: */
sl@0: void CT_UCS2::LEConversionSinglePassBOM(CCnvCharacterSetConverter& aCharacterSetConverter)
sl@0: {
sl@0:     INFO_PRINTF1(_L(" @SYMTestCaseID:SYSLIB-CHARCONV-CT-0553 "));
sl@0:     TBuf16<KBufferLength40> generatedUnicode;
sl@0:     TInt state=CCnvCharacterSetConverter::KStateDefault;
sl@0:     TInt numberOfUnconvertibleCharacters=0;
sl@0:     TInt indexOfFirstByteOfFirstUnconvertibleCharacter=0;
sl@0:     TInt numberLeft =0;
sl@0: 
sl@0:     // set the default endianness to little Endian
sl@0:     aCharacterSetConverter.SetDefaultEndiannessOfForeignCharacters(CCnvCharacterSetConverter::ELittleEndian);
sl@0: 
sl@0:     // test even number of foreign bytes
sl@0:     aCharacterSetConverter.ConvertToUnicode(generatedUnicode, KForeignBufferEven12LE, state, numberOfUnconvertibleCharacters, indexOfFirstByteOfFirstUnconvertibleCharacter);
sl@0:     test(generatedUnicode==_L16("\x4241\x4443\x4645\x4847\x4a49"));
sl@0:     test(numberOfUnconvertibleCharacters==0);
sl@0:     test(indexOfFirstByteOfFirstUnconvertibleCharacter==-1);
sl@0:     INFO_PRINTF1(_L("\nLittleEndianConversionSinglePassEvenBOM - OK"));
sl@0: 
sl@0:     // test even number of foreign bytes without BOM
sl@0:     aCharacterSetConverter.ConvertToUnicode(generatedUnicode, KForeignBufferEvenWithoutBOM10LE, state, numberOfUnconvertibleCharacters, indexOfFirstByteOfFirstUnconvertibleCharacter);
sl@0:     test(generatedUnicode==_L16("\x4241\x4443\x4645\x4847\x4a49"));
sl@0:     test(numberOfUnconvertibleCharacters==0);
sl@0:     test(indexOfFirstByteOfFirstUnconvertibleCharacter==-1);
sl@0:     INFO_PRINTF1(_L("\nLittleEndianConversionSinglePassEvenBOM - OK"));
sl@0: 
sl@0:     // test odd number of foreign bytes
sl@0:     state=CCnvCharacterSetConverter::KStateDefault;
sl@0:     numberLeft = aCharacterSetConverter.ConvertToUnicode(generatedUnicode, KForeignBufferOdd13LE, state, numberOfUnconvertibleCharacters, indexOfFirstByteOfFirstUnconvertibleCharacter);
sl@0:     test(numberLeft==1);
sl@0:     test(generatedUnicode==_L16("\x4241\x4443\x4645\x4847\x4a49"));
sl@0:     test(numberOfUnconvertibleCharacters==0);
sl@0:     test(indexOfFirstByteOfFirstUnconvertibleCharacter==-1);
sl@0: 
sl@0:     // test odd number of foreign bytes without BOM
sl@0:     numberLeft = aCharacterSetConverter.ConvertToUnicode(generatedUnicode, KForeignBufferOddWithoutBOM11LE, state, numberOfUnconvertibleCharacters, indexOfFirstByteOfFirstUnconvertibleCharacter);
sl@0:     test(generatedUnicode==_L16("\x4241\x4443\x4645\x4847\x4a49"));
sl@0:     test(numberLeft==1);
sl@0:     test(numberOfUnconvertibleCharacters==0);
sl@0:     test(indexOfFirstByteOfFirstUnconvertibleCharacter==-1);
sl@0: 
sl@0:     INFO_PRINTF1(_L("\nLittleEndianConversionSinglePassOddBOM - OK"));
sl@0: }
sl@0: /**
sl@0: @SYMTestCaseID          SYSLIB-CHARCONV-CT-0554
sl@0: @SYMTestCaseDesc        8 bit to UCS2 Little Endian Conversion - Multiple pass test
sl@0: @SYMTestPriority        Medium
sl@0: @SYMTestActions         Tests a 8 bit string to 16 bit UCS2 conversion.
sl@0:                         With and without Byte Order Mark. Byte Order Mark is set to Little Endian.
sl@0:                         Output buffer is NOT large enough to contain the complete input string
sl@0:                         on a single pass. Multiple calls are made to complete translation.
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMREQ                 REQ0000
sl@0: */
sl@0: void CT_UCS2::LEConversionMultiplePassBOM(CCnvCharacterSetConverter& aCharacterSetConverter)
sl@0: {
sl@0:     INFO_PRINTF1(_L(" @SYMTestCaseID:SYSLIB-CHARCONV-CT-0554 "));
sl@0:     TBuf16<KBufferLength6> generatedUnicode;
sl@0:     TInt state=CCnvCharacterSetConverter::KStateDefault;
sl@0:     TInt numberOfUnconvertibleCharacters=0;
sl@0:     TInt indexOfFirstByteOfFirstUnconvertibleCharacter=0;
sl@0: 
sl@0:     // set the default endianness to little Endian
sl@0:     aCharacterSetConverter.SetDefaultEndiannessOfForeignCharacters(CCnvCharacterSetConverter::ELittleEndian);
sl@0: 
sl@0:     // test even number of foreign bytes
sl@0:     // first pass
sl@0:     TInt numberUnconverted;
sl@0:     numberUnconverted = aCharacterSetConverter.ConvertToUnicode(generatedUnicode, KForeignBufferEven24LE, state, numberOfUnconvertibleCharacters, indexOfFirstByteOfFirstUnconvertibleCharacter);
sl@0:     test(generatedUnicode==_L16("\x4241\x4443\x4645\x4847\x4a49\x4c4b"));
sl@0:     test(numberUnconverted==10);
sl@0:     test(numberOfUnconvertibleCharacters==0);
sl@0:     test(indexOfFirstByteOfFirstUnconvertibleCharacter==-1);
sl@0: 
sl@0:     // test even number of foreign bytes without BOM
sl@0:     numberUnconverted = aCharacterSetConverter.ConvertToUnicode(generatedUnicode, KForeignBufferEvenWithoutBOM22LE, state, numberOfUnconvertibleCharacters, indexOfFirstByteOfFirstUnconvertibleCharacter);
sl@0:     test(generatedUnicode==_L16("\x4241\x4443\x4645\x4847\x4a49\x4c4b"));
sl@0:     test(numberUnconverted==10);
sl@0:     test(numberOfUnconvertibleCharacters==0);
sl@0:     test(indexOfFirstByteOfFirstUnconvertibleCharacter==-1);
sl@0: 
sl@0:     // second pass
sl@0:     numberUnconverted = aCharacterSetConverter.ConvertToUnicode(generatedUnicode, KForeignBufferEven24LE.Right(numberUnconverted), state, numberOfUnconvertibleCharacters, indexOfFirstByteOfFirstUnconvertibleCharacter);
sl@0:     test(numberUnconverted==0);
sl@0:     test(generatedUnicode==_L16("\x4e4d\x504f\x5251\x5453\x5655"));
sl@0:     test(numberOfUnconvertibleCharacters==0);
sl@0:     test(indexOfFirstByteOfFirstUnconvertibleCharacter==-1);
sl@0:     INFO_PRINTF1(_L("\nLittleEndianConversionMultiplePassOddEven - OK"));
sl@0: 
sl@0:     // without BOM
sl@0:     numberOfUnconvertibleCharacters=10;
sl@0:     aCharacterSetConverter.ConvertToUnicode(generatedUnicode, KForeignBufferEvenWithoutBOM22LE.Right(numberOfUnconvertibleCharacters), state, numberOfUnconvertibleCharacters, indexOfFirstByteOfFirstUnconvertibleCharacter);
sl@0:     test(generatedUnicode==_L16("\x4e4d\x504f\x5251\x5453\x5655"));
sl@0:     test(numberOfUnconvertibleCharacters==0);
sl@0:     test(indexOfFirstByteOfFirstUnconvertibleCharacter==-1);
sl@0:     INFO_PRINTF1(_L("\nLittleEndianConversionMultiplePassOddEven - OK"));
sl@0: 
sl@0: 
sl@0:     // test odd number of foreign bytes
sl@0:     // first pass
sl@0:     state=CCnvCharacterSetConverter::KStateDefault;
sl@0:     numberUnconverted = aCharacterSetConverter.ConvertToUnicode(generatedUnicode, KForeignBufferOdd25LE, state, numberOfUnconvertibleCharacters, indexOfFirstByteOfFirstUnconvertibleCharacter);
sl@0:     test(numberUnconverted==11);
sl@0:     test(indexOfFirstByteOfFirstUnconvertibleCharacter==-1);
sl@0:     test(generatedUnicode==_L16("\x4241\x4443\x4645\x4847\x4a49\x4c4b"));
sl@0: 
sl@0:     // without BOM
sl@0:     numberUnconverted = aCharacterSetConverter.ConvertToUnicode(generatedUnicode, KForeignBufferOddWithoutBOM23LE, state, numberOfUnconvertibleCharacters, indexOfFirstByteOfFirstUnconvertibleCharacter);
sl@0:     test(numberUnconverted==11);
sl@0:     test(indexOfFirstByteOfFirstUnconvertibleCharacter==-1);
sl@0:     test(generatedUnicode==_L16("\x4241\x4443\x4645\x4847\x4a49\x4c4b"));
sl@0: 
sl@0:     // second pass
sl@0:     numberUnconverted = aCharacterSetConverter.ConvertToUnicode(generatedUnicode, KForeignBufferOdd25LE.Right(numberUnconverted), state, numberOfUnconvertibleCharacters, indexOfFirstByteOfFirstUnconvertibleCharacter);
sl@0:     test(generatedUnicode==_L16("\x4e4d\x504f\x5251\x5453\x5655"));
sl@0:     test(numberUnconverted==1);
sl@0:     test(numberOfUnconvertibleCharacters==0);
sl@0:     test(indexOfFirstByteOfFirstUnconvertibleCharacter==-1);
sl@0: 
sl@0:     // without BOM
sl@0:     numberUnconverted = 11;
sl@0:     numberUnconverted = aCharacterSetConverter.ConvertToUnicode(generatedUnicode, KForeignBufferOddWithoutBOM23LE.Right(numberUnconverted), state, numberOfUnconvertibleCharacters, indexOfFirstByteOfFirstUnconvertibleCharacter);
sl@0:     test(numberUnconverted==1);
sl@0:     test(numberOfUnconvertibleCharacters==0);
sl@0:     test(indexOfFirstByteOfFirstUnconvertibleCharacter==-1);
sl@0:     test(generatedUnicode==_L16("\x4e4d\x504f\x5251\x5453\x5655"));
sl@0: 
sl@0: 
sl@0:     INFO_PRINTF1(_L("\nLittleEndianConversionMultiplePassOddBOM - OK"));
sl@0: }
sl@0: /**
sl@0: @SYMTestCaseID          SYSLIB-CHARCONV-CT-0555
sl@0: @SYMTestCaseDesc        8 bit to UCS2 Big Endian Conversion - Single pass
sl@0: @SYMTestPriority        Medium
sl@0: @SYMTestActions         Tests a 8 bit string to 16 bit UCS2 conversion.
sl@0:                         With and without Byte Order Mark. Byte Order Mark is set to Big Endian.
sl@0:                         Output buffer is large enough to contain the complete input string
sl@0:                         on a single pass
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMREQ                 REQ0000
sl@0: */
sl@0: void CT_UCS2::BEConversionSinglePassBOM(CCnvCharacterSetConverter& aCharacterSetConverter)
sl@0: {
sl@0:     INFO_PRINTF1(_L(" @SYMTestCaseID:SYSLIB-CHARCONV-CT-0555 "));
sl@0:     TBuf16<KBufferLength40> generatedUnicode;
sl@0:     TInt state=CCnvCharacterSetConverter::KStateDefault;
sl@0:     TInt numberOfUnconvertibleCharacters=0;
sl@0:     TInt indexOfFirstByteOfFirstUnconvertibleCharacter=0;
sl@0:     TInt numberLeft=0;
sl@0: 
sl@0:     // set the default endianness to Big Endian
sl@0:     aCharacterSetConverter.SetDefaultEndiannessOfForeignCharacters(CCnvCharacterSetConverter::EBigEndian);
sl@0: 
sl@0:     // test even number of foreign bytes
sl@0:     aCharacterSetConverter.ConvertToUnicode(generatedUnicode, KForeignBufferEven12BE, state, numberOfUnconvertibleCharacters, indexOfFirstByteOfFirstUnconvertibleCharacter);
sl@0:     test(generatedUnicode==_L16("\x4241\x4443\x4645\x4847\x4a49"));
sl@0:     test(numberOfUnconvertibleCharacters==0);
sl@0:     test(indexOfFirstByteOfFirstUnconvertibleCharacter==-1);
sl@0:     INFO_PRINTF1(_L("\nBigEndianConversionSinglePassEvenBOM - OK"));
sl@0: 
sl@0:     // test even number of foreign bytes without BOM
sl@0:     aCharacterSetConverter.ConvertToUnicode(generatedUnicode, KForeignBufferEvenWithoutBOM10BE, state, numberOfUnconvertibleCharacters, indexOfFirstByteOfFirstUnconvertibleCharacter);
sl@0:     test(generatedUnicode==_L16("\x4241\x4443\x4645\x4847\x4a49"));
sl@0:     test(numberOfUnconvertibleCharacters==0);
sl@0:     test(indexOfFirstByteOfFirstUnconvertibleCharacter==-1);
sl@0:     INFO_PRINTF1(_L("\nBigEndianConversionSinglePassEvenBOM - OK"));
sl@0: 
sl@0: 
sl@0:     // test odd number of foreign bytes
sl@0:     state=CCnvCharacterSetConverter::KStateDefault;
sl@0:     numberLeft = aCharacterSetConverter.ConvertToUnicode(generatedUnicode, KForeignBufferOdd13BE, state, numberOfUnconvertibleCharacters, indexOfFirstByteOfFirstUnconvertibleCharacter);
sl@0:     test(generatedUnicode==_L16("\x4241\x4443\x4645\x4847\x4a49"));
sl@0:     test(numberLeft==1);
sl@0:     test(numberOfUnconvertibleCharacters==0);
sl@0:     test(indexOfFirstByteOfFirstUnconvertibleCharacter==-1);
sl@0: 
sl@0:     // test odd number of foreign bytes without BOM
sl@0:     numberLeft = aCharacterSetConverter.ConvertToUnicode(generatedUnicode, KForeignBufferOddWithoutBOM11BE, state, numberOfUnconvertibleCharacters, indexOfFirstByteOfFirstUnconvertibleCharacter);
sl@0:     test(generatedUnicode==_L16("\x4241\x4443\x4645\x4847\x4a49"));
sl@0:     test(numberLeft==1);
sl@0:     test(numberOfUnconvertibleCharacters==0);
sl@0:     test(indexOfFirstByteOfFirstUnconvertibleCharacter==-1);
sl@0: 
sl@0:     INFO_PRINTF1(_L("\nBigEndianConversionSinglePassOddBOM - OK"));
sl@0: }
sl@0: /**
sl@0: @SYMTestCaseID          SYSLIB-CHARCONV-CT-0556
sl@0: @SYMTestCaseDesc        8 bit to UCS2 Big Endian Conversion - Multiple pass test
sl@0: @SYMTestPriority        Medium
sl@0: @SYMTestActions         Tests a 8 bit string to 16 bit UCS2 conversion.
sl@0:                         With and without Byte Order Mark. Byte Order Mark is set to Big Endian.
sl@0:                         Output buffer is NOT large enough to contain the complete input string
sl@0:                         on a single pass. Multiple calls are made to complete translation.
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMREQ                 REQ0000
sl@0: */
sl@0: void CT_UCS2::BEConversionMultiplePassBOM(CCnvCharacterSetConverter& aCharacterSetConverter)
sl@0: {
sl@0:     INFO_PRINTF1(_L(" @SYMTestCaseID:SYSLIB-CHARCONV-CT-0556 "));
sl@0:     TBuf16<KBufferLength6> generatedUnicode;
sl@0:     TInt state=CCnvCharacterSetConverter::KStateDefault;
sl@0:     TInt numberOfUnconvertibleCharacters=0;
sl@0:     TInt indexOfFirstByteOfFirstUnconvertibleCharacter=0;
sl@0:     TInt numberUnconverted=0;
sl@0: 
sl@0:     // set the default endianness to Big Endian
sl@0:     aCharacterSetConverter.SetDefaultEndiannessOfForeignCharacters(CCnvCharacterSetConverter::EBigEndian);
sl@0: 
sl@0:     // test even number of foreign bytes
sl@0:     // first pass
sl@0:     numberUnconverted=aCharacterSetConverter.ConvertToUnicode(generatedUnicode, KForeignBufferEven24BE, state, numberOfUnconvertibleCharacters, indexOfFirstByteOfFirstUnconvertibleCharacter);
sl@0:     test(generatedUnicode==_L16("\x4241\x4443\x4645\x4847\x4a49\x4c4b"));
sl@0:     test(numberUnconverted==10);
sl@0:     test(numberOfUnconvertibleCharacters==0);
sl@0:     test(indexOfFirstByteOfFirstUnconvertibleCharacter==-1);
sl@0: 
sl@0:     // without BOM
sl@0:     numberUnconverted=aCharacterSetConverter.ConvertToUnicode(generatedUnicode, KForeignBufferEvenWithoutBOM22BE, state, numberOfUnconvertibleCharacters, indexOfFirstByteOfFirstUnconvertibleCharacter);
sl@0:     test(generatedUnicode==_L16("\x4241\x4443\x4645\x4847\x4a49\x4c4b"));
sl@0:     test(numberUnconverted==10);
sl@0:     test(numberOfUnconvertibleCharacters==0);
sl@0:     test(indexOfFirstByteOfFirstUnconvertibleCharacter==-1);
sl@0: 
sl@0:     // second pass
sl@0:     numberUnconverted=aCharacterSetConverter.ConvertToUnicode(generatedUnicode, KForeignBufferEven24BE.Right(numberUnconverted), state, numberOfUnconvertibleCharacters, indexOfFirstByteOfFirstUnconvertibleCharacter);
sl@0:     test(generatedUnicode==_L16("\x4e4d\x504f\x5251\x5453\x5655"));
sl@0:     test(numberUnconverted==0);
sl@0:     test(numberOfUnconvertibleCharacters==0);
sl@0:     test(indexOfFirstByteOfFirstUnconvertibleCharacter==-1);
sl@0:     INFO_PRINTF1(_L("\nBigEndianConversionMultiplePassOddEven - OK"));
sl@0: 
sl@0:     // without BOM
sl@0:     numberOfUnconvertibleCharacters=10;
sl@0:     numberUnconverted=aCharacterSetConverter.ConvertToUnicode(generatedUnicode, KForeignBufferEvenWithoutBOM22BE.Right(numberOfUnconvertibleCharacters), state, numberOfUnconvertibleCharacters, indexOfFirstByteOfFirstUnconvertibleCharacter);
sl@0:     test(generatedUnicode==_L16("\x4e4d\x504f\x5251\x5453\x5655"));
sl@0:     test(numberOfUnconvertibleCharacters==0);
sl@0:     test(indexOfFirstByteOfFirstUnconvertibleCharacter==-1);
sl@0:     INFO_PRINTF1(_L("\nBigEndianConversionMultiplePassOddEven - OK"));
sl@0: 
sl@0:     // test odd number of foreign bytes
sl@0:     // first pass
sl@0:     state=CCnvCharacterSetConverter::KStateDefault;
sl@0:     numberUnconverted=aCharacterSetConverter.ConvertToUnicode(generatedUnicode, KForeignBufferOdd25BE, state, numberOfUnconvertibleCharacters, indexOfFirstByteOfFirstUnconvertibleCharacter);
sl@0:     test(numberUnconverted==11);
sl@0:     test(numberOfUnconvertibleCharacters==0);
sl@0:     test(indexOfFirstByteOfFirstUnconvertibleCharacter==-1);
sl@0:     test(generatedUnicode==_L16("\x4241\x4443\x4645\x4847\x4a49\x4c4b"));
sl@0: 
sl@0:     // without BOM
sl@0:     numberUnconverted=aCharacterSetConverter.ConvertToUnicode(generatedUnicode, KForeignBufferOddWithoutBOM23BE, state, numberOfUnconvertibleCharacters, indexOfFirstByteOfFirstUnconvertibleCharacter);
sl@0:     test(numberUnconverted==11);
sl@0:     test(numberOfUnconvertibleCharacters==0);
sl@0:     test(indexOfFirstByteOfFirstUnconvertibleCharacter==-1);
sl@0:     test(generatedUnicode==_L16("\x4241\x4443\x4645\x4847\x4a49\x4c4b"));
sl@0: 
sl@0:     // second pass
sl@0:     numberUnconverted=aCharacterSetConverter.ConvertToUnicode(generatedUnicode, KForeignBufferOdd25BE.Right(numberUnconverted), state, numberOfUnconvertibleCharacters, indexOfFirstByteOfFirstUnconvertibleCharacter);
sl@0:     test(generatedUnicode==_L16("\x4e4d\x504f\x5251\x5453\x5655"));
sl@0:     test(numberUnconverted==1);
sl@0:     test(numberOfUnconvertibleCharacters==0);
sl@0:     test(indexOfFirstByteOfFirstUnconvertibleCharacter==-1);
sl@0: 
sl@0:     // without BOM
sl@0:     numberOfUnconvertibleCharacters=11;
sl@0:     numberUnconverted=aCharacterSetConverter.ConvertToUnicode(generatedUnicode, KForeignBufferOddWithoutBOM23BE.Right(numberOfUnconvertibleCharacters), state, numberOfUnconvertibleCharacters, indexOfFirstByteOfFirstUnconvertibleCharacter);
sl@0:     test(generatedUnicode==_L16("\x4e4d\x504f\x5251\x5453\x5655"));
sl@0:     test(numberUnconverted==1);
sl@0:     test(numberOfUnconvertibleCharacters==0);
sl@0:     test(indexOfFirstByteOfFirstUnconvertibleCharacter==-1);
sl@0: 
sl@0: 
sl@0:     INFO_PRINTF1(_L("\nBigEndianConversionMultiplePassOddBOM - OK"));
sl@0: }
sl@0: /**
sl@0: @SYMTestCaseID          SYSLIB-CHARCONV-CT-0557
sl@0: @SYMTestCaseDesc        UCS2 to 8 bit Big Endian Conversion - Single pass test
sl@0: @SYMTestPriority        Medium
sl@0: @SYMTestActions         Tests a 16 bit UCS2 to 8 bit descriptor conversion.
sl@0:                         Byte Order Mark is present and is set to Big Endian.
sl@0:                         Output buffer is large enough to contain the complete input string
sl@0:                         on a single pass
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMREQ                 REQ0000
sl@0: */
sl@0: void CT_UCS2::UCS2BEConversionSinglePassBOM(CCnvCharacterSetConverter& aCharacterSetConverter)
sl@0: {
sl@0:     INFO_PRINTF1(_L(" @SYMTestCaseID:SYSLIB-CHARCONV-CT-0557 "));
sl@0:     TBuf8<KBufferLength40> generatedForeign;
sl@0:     CCnvCharacterSetConverter::TArrayOfAscendingIndices indicesOfUnconvertibleCharacters;
sl@0: 
sl@0:     // set the default endianness to Big Endian
sl@0:     aCharacterSetConverter.SetDefaultEndiannessOfForeignCharacters(CCnvCharacterSetConverter::EBigEndian);
sl@0: 
sl@0:     // test even number of foreign bytes
sl@0:     aCharacterSetConverter.ConvertFromUnicode( generatedForeign,
sl@0:                                                         KUnicodeBufferEven14BE,
sl@0:                                                         indicesOfUnconvertibleCharacters );
sl@0: 
sl@0:     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"));
sl@0:     INFO_PRINTF1(_L("\nUCS2BEConversionSinglePassEvenBOM - OK"));
sl@0: 
sl@0:     // test odd number of foreign bytes
sl@0:     aCharacterSetConverter.ConvertFromUnicode( generatedForeign,
sl@0:                                                         KUnicodeBufferOdd15BE,
sl@0:                                                         indicesOfUnconvertibleCharacters );
sl@0: 
sl@0:     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"));
sl@0:     INFO_PRINTF1(_L("\nUCS2BEConversionSinglePassOddBOM - OK"));
sl@0: }
sl@0: /**
sl@0: @SYMTestCaseID          SYSLIB-CHARCONV-CT-0558
sl@0: @SYMTestCaseDesc        UCS2 to 8 bit Big Endian Conversion - Multiple pass test
sl@0: @SYMTestPriority        Medium
sl@0: @SYMTestActions         Tests a 16 bit UCS2 to 8 bit descriptor conversion.
sl@0:                         Byte Order Mark is present and is set to Big Endian.
sl@0:                         Output buffer is NOT large enough to contain the complete input string
sl@0:                         on a single pass
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMREQ                 REQ0000
sl@0: */
sl@0: void CT_UCS2::UCS2BEConversionMultiplePassBOM (CCnvCharacterSetConverter& aCharacterSetConverter)
sl@0: {
sl@0:     INFO_PRINTF1(_L(" @SYMTestCaseID:SYSLIB-CHARCONV-CT-0558 "));
sl@0:     TBuf8<KBufferLength6> generatedForeign;
sl@0:     TBuf8<KBufferLength8> generatedForeign2;
sl@0:     TInt result=0;
sl@0:     CCnvCharacterSetConverter::TArrayOfAscendingIndices indicesOfUnconvertibleCharacters;
sl@0: 
sl@0:     // set the default endianness to Big Endian
sl@0:     aCharacterSetConverter.SetDefaultEndiannessOfForeignCharacters(CCnvCharacterSetConverter::EBigEndian);
sl@0: 
sl@0:     // *** Test even number of bytes ***
sl@0:     // test even number of foreign bytes - pass 1
sl@0:     result = aCharacterSetConverter.ConvertFromUnicode( generatedForeign,
sl@0:                                                         KUnicodeBufferEven14BE,
sl@0:                                                         indicesOfUnconvertibleCharacters );
sl@0:     test(generatedForeign==_L8("\xfe\xff\x41\x42\x43\x44"));
sl@0:     test(result==11);
sl@0: 
sl@0:     // test even number of foreign bytes - pass 2
sl@0:     result = aCharacterSetConverter.ConvertFromUnicode( generatedForeign,
sl@0:                                                         KUnicodeBufferEven14BE.Right(result),
sl@0:                                                         indicesOfUnconvertibleCharacters );
sl@0:     test(result==8);
sl@0:     test(generatedForeign==_L8("\x45\x46\x47\x48\x49\x4A"));
sl@0: 
sl@0:     // test even number of foreign bytes - pass 3
sl@0:     result = aCharacterSetConverter.ConvertFromUnicode( generatedForeign,
sl@0:                                                         KUnicodeBufferEven14BE.Right(result),
sl@0:                                                         indicesOfUnconvertibleCharacters );
sl@0:     test(result==5);
sl@0:     test(generatedForeign==_L8("\x4b\x4c\x4d\x4e\x4f\x50"));
sl@0: 
sl@0: 
sl@0:     // test even number of foreign bytes - pass 4
sl@0:     result = aCharacterSetConverter.ConvertFromUnicode( generatedForeign,
sl@0:                                                         KUnicodeBufferEven14BE.Right(result),
sl@0:                                                         indicesOfUnconvertibleCharacters );
sl@0:     test(result==2);
sl@0:     test(generatedForeign==_L8("\x51\x52\x53\x54\x55\x56"));
sl@0: 
sl@0:     // test even number of foreign bytes - pass 5
sl@0:     result = aCharacterSetConverter.ConvertFromUnicode( generatedForeign2,
sl@0:                                                         KUnicodeBufferEven14BE.Right(result),
sl@0:                                                         indicesOfUnconvertibleCharacters );
sl@0:     test(generatedForeign2==_L8("\x57\x58\x59\x5a"));
sl@0:     test(result==0);
sl@0: 
sl@0:     INFO_PRINTF1(_L("\nUCS2LEConversionMultiplePassEvenBOM - OK"));
sl@0: 
sl@0:     // *** Test odd numer of bytes ***
sl@0:     result = aCharacterSetConverter.ConvertFromUnicode( generatedForeign,
sl@0:                                                         KUnicodeBufferOdd15BE,
sl@0:                                                         indicesOfUnconvertibleCharacters );
sl@0:     test(generatedForeign==_L8("\xfe\xff\x41\x42\x43\x44"));
sl@0: 
sl@0:         // test even number of foreign bytes - pass 2
sl@0:     result = aCharacterSetConverter.ConvertFromUnicode( generatedForeign,
sl@0:                                                         KUnicodeBufferOdd15BE.Right(result),
sl@0:                                                         indicesOfUnconvertibleCharacters );
sl@0:     test(generatedForeign==_L8("\x45\x46\x47\x48\x49\x4a"));
sl@0: 
sl@0:     // test even number of foreign bytes - pass 3
sl@0:     result = aCharacterSetConverter.ConvertFromUnicode( generatedForeign,
sl@0:                                                         KUnicodeBufferOdd15BE.Right(result),
sl@0:                                                         indicesOfUnconvertibleCharacters );
sl@0:     test(generatedForeign==_L8("\x4b\x4c\x4d\x4e\x4f\x50"));
sl@0: 
sl@0:     // test even number of foreign bytes - pass 4
sl@0:     result = aCharacterSetConverter.ConvertFromUnicode( generatedForeign,
sl@0:                                                         KUnicodeBufferOdd15BE.Right(result),
sl@0:                                                         indicesOfUnconvertibleCharacters );
sl@0:     test(generatedForeign==_L8("\x51\x52\x53\x54\x55\x56"));
sl@0: 
sl@0: 
sl@0:     // test even number of foreign bytes - pass 5
sl@0:     result = aCharacterSetConverter.ConvertFromUnicode( generatedForeign,
sl@0:                                                         KUnicodeBufferOdd15BE.Right(result),
sl@0:                                                         indicesOfUnconvertibleCharacters );
sl@0:     test(generatedForeign==_L8("\x57\x58\x59\x5a\x5b\x5c"));
sl@0:     test(result==0);
sl@0: 
sl@0:     INFO_PRINTF1(_L("\nUCS2LEConversionMultiplePassOddBOM - OK"));
sl@0: }
sl@0: /**
sl@0: @SYMTestCaseID          SYSLIB-CHARCONV-CT-0559
sl@0: @SYMTestCaseDesc        Tests a 16 bit UCS2 to 8 bit & 16 bit UCS2 to 8 bit conversion with empty buffers.
sl@0: @SYMTestPriority        Medium
sl@0: @SYMTestActions         Attempt for conversion when input and output buffers are small
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMREQ                 REQ0000
sl@0: */
sl@0: void CT_UCS2::TooSmallBufferConversion (CCnvCharacterSetConverter& aCharacterSetConverter)
sl@0:     {
sl@0:     INFO_PRINTF1(_L(" @SYMTestCaseID:SYSLIB-CHARCONV-CT-0559 "));
sl@0:     TBuf16<KBufferLength1> generatedUnicode1;
sl@0:     TBuf8<KBufferLength1> generatedForeign1;
sl@0: 
sl@0:     TInt state=CCnvCharacterSetConverter::KStateDefault;
sl@0:     TInt numberOfUnconvertibleCharacters=0;
sl@0:     TInt indexOfFirstByteOfFirstUnconvertibleCharacter=0;
sl@0: 
sl@0:     CCnvCharacterSetConverter::TArrayOfAscendingIndices indicesOfUnconvertibleCharacters;
sl@0: 
sl@0:         // set the default endianness to little Endian
sl@0:     aCharacterSetConverter.SetDefaultEndiannessOfForeignCharacters(CCnvCharacterSetConverter::ELittleEndian);
sl@0: 
sl@0:     // convert to UCS2 using an output buffer that is too small
sl@0:     TInt result = aCharacterSetConverter.ConvertToUnicode(generatedUnicode1, KForeignBufferEven12LE, state, numberOfUnconvertibleCharacters, indexOfFirstByteOfFirstUnconvertibleCharacter);
sl@0:     test(generatedUnicode1==_L16("\x4241"));
sl@0:     test(result==8);
sl@0:     test(numberOfUnconvertibleCharacters==0);
sl@0:     test(indexOfFirstByteOfFirstUnconvertibleCharacter==-1);
sl@0:     INFO_PRINTF1(_L("\n8bit->UCS2 output buffer size 1 - OK"));
sl@0: 
sl@0:     INFO_PRINTF1(_L("\nConversionTooSmallBuffer - OK"));
sl@0:     }
sl@0: /**
sl@0: @SYMTestCaseID          SYSLIB-CHARCONV-CT-0560
sl@0: @SYMTestCaseDesc        Conversion tests from UCS2 GUID to MIB
sl@0: @SYMTestPriority        Medium
sl@0: @SYMTestActions         Tests retreiving the MIB value from the UCS2 GUID
sl@0:                         Tests retreiving the UCS2 GUID from the MIB value
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMREQ                 REQ0000
sl@0: */
sl@0: void CT_UCS2::CharacterSetValueAndMIBTests(CCnvCharacterSetConverter& aCharacterSetConverter, RFs& aFileServerSession)
sl@0: {
sl@0:     INFO_PRINTF1(_L(" @SYMTestCaseID:SYSLIB-CHARCONV-CT-0560 "));
sl@0:     // check that the character set value of '1000' is converted to the UCS2 GUID (0x101ff492)
sl@0:     test(aCharacterSetConverter.ConvertMibEnumOfCharacterSetToIdentifierL(KMibValue,aFileServerSession)==KCharacterSetIdentifierUcs2);
sl@0:     INFO_PRINTF1(_L("\nMIB->Char Set GUID - OK"));
sl@0: 
sl@0:     // check that the UCS2 GUID (0x101ff492) is converted to the character set value of '1000'
sl@0:     test(aCharacterSetConverter.ConvertCharacterSetIdentifierToMibEnumL(KCharacterSetIdentifierUcs2,aFileServerSession)==KMibValue);
sl@0:     INFO_PRINTF1(_L("\nChar Set GUID->MIB - OK"));
sl@0: }
sl@0: 
sl@0: 
sl@0: void CT_UCS2::DoE32MainL()
sl@0:     {
sl@0:     RFs fileServerSession;
sl@0:     CleanupClosePushL(fileServerSession);
sl@0:     User::LeaveIfError(fileServerSession.Connect());
sl@0:     CCnvCharacterSetConverter* characterSetConverter=CCnvCharacterSetConverter::NewLC();
sl@0:     CArrayFix<CCnvCharacterSetConverter::SCharacterSet>* arrayOfCharacterSetsAvailable=CCnvCharacterSetConverter::CreateArrayOfCharacterSetsAvailableLC(fileServerSession);
sl@0:     TInt i;
sl@0:     for (i=arrayOfCharacterSetsAvailable->Count()-1; i>=0; --i)
sl@0:         {
sl@0:         const CCnvCharacterSetConverter::SCharacterSet& charactersSet=(*arrayOfCharacterSetsAvailable)[i];
sl@0:         characterSetConverter->PrepareToConvertToOrFromL(charactersSet.Identifier(), *arrayOfCharacterSetsAvailable, fileServerSession);
sl@0:         TPtrC charactersSetName(charactersSet.Name());
sl@0:         if (charactersSet.NameIsFileName())
sl@0:             {
sl@0:             charactersSetName.Set(TParsePtrC(charactersSetName).Name());
sl@0:             }
sl@0:         INFO_PRINTF2(_L("    %S\n"), &charactersSetName);
sl@0:         }
sl@0: 
sl@0:     // test MIB to Character Set ID (and visa versa) conversion
sl@0:     CharacterSetValueAndMIBTests(*characterSetConverter, fileServerSession);
sl@0: 
sl@0:     // prepare for conversion
sl@0:     INFO_PRINTF1(_L("\nTesting 8 bit -> UCS2 conversion"));
sl@0:     TRAPD( error, characterSetConverter->PrepareToConvertToOrFromL(KCharacterSetIdentifierUcs2, *arrayOfCharacterSetsAvailable, fileServerSession));
sl@0:     if ( error != KErrNone )
sl@0:         {
sl@0:         RDebug::Print(_L("PrepareToConvertToOrFromL failed code:%d\n"),error);
sl@0:         RDebug::Print(_L("KCharacterSetIdentifierUcs2 is not available so tests failed\n"));
sl@0:         User::LeaveIfError(error);
sl@0:         }
sl@0: 
sl@0: 
sl@0:     // *** 8 bit to UCS2 conversion ***
sl@0:     INFO_PRINTF1(_L("\n8->UCS2 Little Endian Conversion - Single pass"));
sl@0:     LEConversionSinglePassBOM(*characterSetConverter);
sl@0: 
sl@0:     INFO_PRINTF1(_L("\n8->UCS2 Little Endian Conversion - Multiple pass"));
sl@0:     LEConversionMultiplePassBOM(*characterSetConverter);
sl@0: 
sl@0:     INFO_PRINTF1(_L("\n8->UCS2 Big Endian Conversion - Single pass"));
sl@0:     BEConversionSinglePassBOM(*characterSetConverter);
sl@0: 
sl@0:     INFO_PRINTF1(_L("\n8->UCS2 Big Endian Conversion - Multiple pass"));
sl@0:     BEConversionMultiplePassBOM(*characterSetConverter);
sl@0: 
sl@0: 
sl@0:     // *** UCS2 to 8 bit conversion ***
sl@0:     INFO_PRINTF1(_L("\nUCS2->8 Big Endian Conversion - Single pass"));
sl@0:     UCS2BEConversionSinglePassBOM(*characterSetConverter);
sl@0: 
sl@0:     INFO_PRINTF1(_L("\nUCS2->8 Big Endian Conversion - Multiple pass"));
sl@0:     UCS2BEConversionMultiplePassBOM(*characterSetConverter);
sl@0: 
sl@0:     // *** attempted conversion when input/output buffers are too small
sl@0:     INFO_PRINTF1(_L("\nTooSmallBufferConversion"));
sl@0:     TooSmallBufferConversion(*characterSetConverter);
sl@0: 
sl@0:     INFO_PRINTF1(_L("\n"));
sl@0:     CleanupStack::PopAndDestroy(3);// arrayOfCharacterSetsAvailable and characterSetConverter and fileServerSession
sl@0:     }
sl@0: 
sl@0: CT_UCS2::CT_UCS2()
sl@0:     {
sl@0:     SetTestStepName(KTestStep_T_UCS2);
sl@0:     }
sl@0: 
sl@0: TVerdict CT_UCS2::doTestStepL()
sl@0:     {
sl@0:     SetTestStepResult(EFail);
sl@0: 
sl@0:     __UHEAP_MARK;
sl@0:     TRAPD(error1, DoE32MainL());
sl@0:     __UHEAP_MARKEND;
sl@0: 
sl@0:     if(error1 == KErrNone)
sl@0:         {
sl@0:         SetTestStepResult(EPass);
sl@0:         }
sl@0: 
sl@0:     return TestStepResult();
sl@0:     }