1 /*

     2 * Copyright (c) 2002 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:    test CONVUTILS.H

    15 *

    16 */

    17 

    18 

    19 

    20 

    21 

    22 // [INCLUDE FILES]

    23 #include <e32svr.h>

    24 #include <StifParser.h>

    25 #include <StifTestInterface.h>

    26 #include <convutils.h>

    27 

    28 #include "testsdkcharacterconversionpp.h"

    29 

    30 const TInt KLength = 20;

    31 // -----------------------------------------------------------------------------

    32 // Fuction ConvertFromIntermediateBufferInPlace() for 

    33 // initialize sturct SCharacterSet

    34 // -----------------------------------------------------------------------------

    35 //

    36 void ConvertFromIntermediateBufferInPlace( TInt /*aStartPositionInDescriptor*/, 

    37                                            TDes8& /*aDescriptor*/, 

    38                                            TInt& /*aNumberOfCharactersThatDroppedOut*/ )

    39     {

    40     

    41     }

    42 

    43 // -----------------------------------------------------------------------------

    44 // Fuction ConvertToIntermediateBufferInPlace() for 

    45 // initialize sturct SMethod

    46 // -----------------------------------------------------------------------------

    47 //

    48 void ConvertToIntermediateBufferInPlace( TDes8& /*aDescriptor*/ )

    49     {

    50     

    51     }

    52 

    53 // -----------------------------------------------------------------------------

    54 // Fuction NumberOfBytesAbleToConvert() for 

    55 // initialize sturct SMethod

    56 // -----------------------------------------------------------------------------

    57 //

    58 TInt NumberOfBytesAbleToConvert(const TDesC8& aDescriptor)

    59     {

    60     if( aDescriptor.Length() == 0 )

    61         {

    62         return 0;

    63         }

    64     else

    65         {

    66         return 1;

    67         }

    68     }

    69 

    70 // ============================ MEMBER FUNCTIONS ===============================

    71 

    72 // -----------------------------------------------------------------------------

    73 // CTestSDKCharacterConversionPP::RunMethodL

    74 // Run specified method. Contains also table of test mothods and their names.

    75 // -----------------------------------------------------------------------------

    76 //

    77 TInt CTestSDKCharacterConversionPP::RunMethodL( CStifItemParser& aItem ) 

    78     {

    79 

    80     static TStifFunctionInfo const KFunctions[] =

    81         {  

    82 

    83         ENTRY( "TestCCPPConvertFromUnicodeL", 

    84                 CTestSDKCharacterConversionPP::TestCCPPConvertFromUnicodeL ),

    85         ENTRY( "TestCCPPConvertFromUnicodeFlagL", 

    86                 CTestSDKCharacterConversionPP::TestCCPPConvertFromUnicodeFlagL ),

    87         ENTRY( "TestCCPPConvertFromIntermediateBufferInPlace", 

    88                 CTestSDKCharacterConversionPP::TestCCPPConvertFromIntermediateBufferInPlace ),

    89         ENTRY( "TestCCPPConvertToUnicodeFromModalForeignL", 

    90                 CTestSDKCharacterConversionPP::TestCCPPConvertToUnicodeFromModalForeignL ),

    91         ENTRY( "TestCCPPConvertToUnicodeFromModalForeignFlagL", 

    92                 CTestSDKCharacterConversionPP::TestCCPPConvertToUnicodeFromModalForeignFlagL ),

    93         ENTRY( "TestCCPPConvertToUnicodeFromHeterogeneousForeignL", 

    94                 CTestSDKCharacterConversionPP::TestCCPPConvertToUnicodeFromHeterogeneousForeignL ),

    95         ENTRY( "TestCCPPConvertToUnicodeFromHeterogeneousForeignFlagL", 

    96                 CTestSDKCharacterConversionPP::TestCCPPConvertToUnicodeFromHeterogeneousForeignFlagL ),

    97 

    98         };

    99 

   100     const TInt count = sizeof( KFunctions ) / sizeof( TStifFunctionInfo );

   101 

   102     return RunInternalL( KFunctions, count, aItem );

   103 

   104     }

   105 

   106 // ============================ MEMBER FUNCTIONS ===============================

   107 // =========================== CLASS CnvUtilities===============================

   108 // -----------------------------------------------------------------------------

   109 // CTestSDKCharacterConversionPP::TestCCPPConvertFromUnicodeL 

   110 // -----------------------------------------------------------------------------

   111 TInt CTestSDKCharacterConversionPP::TestCCPPConvertFromUnicodeL( CStifItemParser& /*aItem*/ )

   112     {

   113     CnvUtilities::SCharacterSet characterSet;

   114     characterSet.iConversionData = &( CCnvCharacterSetConverter::AsciiConversionData() );

   115     characterSet.iConvertFromIntermediateBufferInPlace = ConvertFromIntermediateBufferInPlace;

   116     CArrayFix<CnvUtilities::SCharacterSet>* array = new(ELeave) CArrayFixFlat<CnvUtilities::SCharacterSet>( 1 );

   117     CleanupStack::PushL( array );

   118     array->AppendL( characterSet );

   119     

   120     _LIT8( KForeign, "converter" );

   121     _LIT( KUnicode, "converter" );

   122     TBuf8<KLength> foreign;

   123     TBuf<KLength> unicode( KUnicode );

   124 

   125     TBuf8<KLength> replace( KForeign );

   126     CCnvCharacterSetConverter::TArrayOfAscendingIndices indice;

   127     

   128     TInt num = CnvUtilities::ConvertFromUnicode( CCnvCharacterSetConverter::ELittleEndian, replace, foreign, unicode, indice, array->Array() );

   129     STIF_ASSERT_TRUE( 0 == num );

   130     STIF_ASSERT_TRUE( 0 == foreign.Compare( KForeign ) );

   131     

   132     CleanupStack::PopAndDestroy( array );

   133     

   134     return KErrNone;

   135     

   136     }

   137 

   138 // -----------------------------------------------------------------------------

   139 // CTestSDKCharacterConversionPP::TestCCPPConvertFromUnicodeFlagL 

   140 // -----------------------------------------------------------------------------

   141 TInt CTestSDKCharacterConversionPP::TestCCPPConvertFromUnicodeFlagL( CStifItemParser& /*aItem*/ )

   142     {

   143     CnvUtilities::SCharacterSet characterSet;

   144     characterSet.iConversionData = &( CCnvCharacterSetConverter::AsciiConversionData() );

   145     characterSet.iConvertFromIntermediateBufferInPlace = ConvertFromIntermediateBufferInPlace;

   146     CArrayFix<CnvUtilities::SCharacterSet>* array = new(ELeave) CArrayFixFlat<CnvUtilities::SCharacterSet>( 1 );

   147     CleanupStack::PushL( array );

   148     array->AppendL( characterSet );

   149     

   150     _LIT8( KForeign, "converter" );

   151     _LIT( KUnicode, "converter" );

   152     TBuf8<KLength> foreign;

   153     TBuf<KLength> unicode( KUnicode );

   154 

   155     TBuf8<KLength> replace( KForeign );

   156     CCnvCharacterSetConverter::TArrayOfAscendingIndices indice;

   157     TUint inputFlag = CCnvCharacterSetConverter::EInputConversionFlagAppend;

   158     TUint outputFlag;

   159     

   160     TInt num = CnvUtilities::ConvertFromUnicode( CCnvCharacterSetConverter::ELittleEndian, replace, foreign, 

   161                                                  unicode, indice, array->Array(), outputFlag, inputFlag );

   162     STIF_ASSERT_TRUE( 0 == num );

   163     STIF_ASSERT_TRUE( 0 == foreign.Compare( KForeign ) );

   164     

   165     CleanupStack::PopAndDestroy( array );

   166     

   167     return KErrNone;

   168     

   169     }

   170 

   171 // -----------------------------------------------------------------------------

   172 // CTestSDKCharacterConversionPP::TestCCPPConvertFromIntermediateBufferInPlace 

   173 // -----------------------------------------------------------------------------

   174 TInt CTestSDKCharacterConversionPP::TestCCPPConvertFromIntermediateBufferInPlace( CStifItemParser& /*aItem*/ )

   175     {

   176     

   177     _LIT8( KForeign, "converter" );

   178     _LIT( KUnicode, "converter" );

   179     TBuf8<KLength> foreign( KForeign );

   180     TBuf<KLength> unicode( KUnicode );

   181 

   182     TBuf8<KLength> replace( KForeign );

   183     TInt dropOut;

   184     

   185     CnvUtilities::ConvertFromIntermediateBufferInPlace( 0, foreign, dropOut, replace, foreign.Length() );

   186     

   187     return KErrNone;

   188     

   189     }

   190 

   191 // -----------------------------------------------------------------------------

   192 // CTestSDKCharacterConversionPP::TestCCPPConvertToUnicodeFromModalForeignL 

   193 // -----------------------------------------------------------------------------

   194 TInt CTestSDKCharacterConversionPP::TestCCPPConvertToUnicodeFromModalForeignL( CStifItemParser& /*aItem*/ )

   195     {

   196     CnvUtilities::SState sstate;

   197     sstate.iConversionData = &( CCnvCharacterSetConverter::AsciiConversionData() );

   198     TBuf8<KLength> sequence;

   199     const TUint KControlCharacterEscape=0x1b;

   200     sequence.Append( KControlCharacterEscape );

   201     sstate.iEscapeSequence = &sequence;

   202     CArrayFix<CnvUtilities::SState>* array = new(ELeave) CArrayFixFlat<CnvUtilities::SState>( 1 );

   203     CleanupStack::PushL( array );

   204     array->AppendL( sstate );

   205     

   206     _LIT8( KForeign, "converter" );

   207     _LIT( KUnicode, "converter" );

   208     TBuf8<KLength> foreign( KForeign );

   209     TBuf<KLength> unicode;

   210 

   211     TInt state = 0;

   212     TInt unconversion;

   213     TInt index;

   214     

   215     TInt num = CnvUtilities::ConvertToUnicodeFromModalForeign( CCnvCharacterSetConverter::ELittleEndian, unicode, 

   216                                                                foreign, state, unconversion, index, array->Array() );

   217     STIF_ASSERT_TRUE( 0 == num );

   218     STIF_ASSERT_TRUE( 0 == unicode.Compare( KUnicode ) );

   219     

   220     CleanupStack::PopAndDestroy( array );

   221     

   222     return KErrNone;

   223     

   224     }

   225 

   226 // -----------------------------------------------------------------------------

   227 // CTestSDKCharacterConversionPP::TestCCPPConvertToUnicodeFromModalForeignFlagL 

   228 // -----------------------------------------------------------------------------

   229 TInt CTestSDKCharacterConversionPP::TestCCPPConvertToUnicodeFromModalForeignFlagL( CStifItemParser& /*aItem*/ )

   230     {

   231     CnvUtilities::SState sstate;

   232     sstate.iConversionData = &( CCnvCharacterSetConverter::AsciiConversionData() );

   233     TBuf8<KLength> sequence;

   234     const TUint KControlCharacterEscape=0x1b;

   235     sequence.Append( KControlCharacterEscape );

   236     sstate.iEscapeSequence = &sequence;

   237     CArrayFix<CnvUtilities::SState>* array = new(ELeave) CArrayFixFlat<CnvUtilities::SState>( 1 );

   238     CleanupStack::PushL( array );

   239     array->AppendL( sstate );

   240     

   241     _LIT8( KForeign, "converter" );

   242     _LIT( KUnicode, "converter" );

   243     TBuf8<KLength> foreign( KForeign );

   244     TBuf<KLength> unicode;

   245 

   246     TUint inputFlag = CCnvCharacterSetConverter::EInputConversionFlagAppend;

   247     TUint outputFlag;

   248     TInt state = 0;

   249     TInt unconversion;

   250     TInt index;

   251     

   252     TInt num = CnvUtilities::ConvertToUnicodeFromModalForeign( CCnvCharacterSetConverter::ELittleEndian, unicode, 

   253                                                                foreign, state, unconversion, index, array->Array(), 

   254                                                                outputFlag, inputFlag );

   255     STIF_ASSERT_TRUE( 0 == num );

   256     STIF_ASSERT_TRUE( 0 == unicode.Compare( KUnicode ) );

   257     

   258     CleanupStack::PopAndDestroy( array );

   259     

   260     return KErrNone;

   261     

   262     }

   263 

   264 // -----------------------------------------------------------------------------

   265 // CTestSDKCharacterConversionPP::TestCCPPConvertToUnicodeFromHeterogeneousForeignL 

   266 // -----------------------------------------------------------------------------

   267 TInt CTestSDKCharacterConversionPP::TestCCPPConvertToUnicodeFromHeterogeneousForeignL( CStifItemParser& /*aItem*/ )

   268     {

   269     CArrayFix<CnvUtilities::SMethod>* array = new(ELeave) CArrayFixFlat<CnvUtilities::SMethod>( 1 );

   270     CleanupStack::PushL( array );

   271     

   272     CnvUtilities::SMethod method;

   273     method.iConversionData = &( CCnvCharacterSetConverter::AsciiConversionData() );

   274     method.iNumberOfBytesPerCharacter = 1;

   275     method.iNumberOfCoreBytesPerCharacter = 1;

   276     method.iConvertToIntermediateBufferInPlace = ConvertToIntermediateBufferInPlace;

   277     method.iNumberOfBytesAbleToConvert = NumberOfBytesAbleToConvert;

   278     

   279     array->AppendL( method );

   280     

   281     _LIT8( KForeign, "c" );

   282     _LIT( KUnicode, "c" );

   283     TBuf8<KLength> foreign( KForeign );

   284     TBuf<KLength> unicode;

   285 

   286     TInt unconversion;

   287     TInt index;

   288     

   289     TInt num = CnvUtilities::ConvertToUnicodeFromHeterogeneousForeign( CCnvCharacterSetConverter::ELittleEndian, unicode, 

   290                                                                        foreign, unconversion, index, array->Array() );

   291     STIF_ASSERT_TRUE( 0 == num );

   292     STIF_ASSERT_TRUE( 0 == unicode.Compare( KUnicode ) );

   293     

   294     CleanupStack::PopAndDestroy( array );

   295     

   296     return KErrNone;

   297     

   298     }

   299 

   300 // -----------------------------------------------------------------------------

   301 // CTestSDKCharacterConversionPP::TestCCPPConvertToUnicodeFromHeterogeneousForeignFlagL 

   302 // -----------------------------------------------------------------------------

   303 TInt CTestSDKCharacterConversionPP::TestCCPPConvertToUnicodeFromHeterogeneousForeignFlagL( CStifItemParser& /*aItem*/ )

   304     {

   305     CArrayFix<CnvUtilities::SMethod>* array = new(ELeave) CArrayFixFlat<CnvUtilities::SMethod>( 1 );

   306     CleanupStack::PushL( array );

   307     

   308     CnvUtilities::SMethod method;

   309     method.iConversionData = &( CCnvCharacterSetConverter::AsciiConversionData() );

   310     method.iNumberOfBytesPerCharacter = 1;

   311     method.iNumberOfCoreBytesPerCharacter = 1;

   312     method.iConvertToIntermediateBufferInPlace = ConvertToIntermediateBufferInPlace;

   313     method.iNumberOfBytesAbleToConvert = NumberOfBytesAbleToConvert;

   314     

   315     array->AppendL( method );

   316     

   317     _LIT8( KForeign, "converte" );

   318     _LIT( KUnicode, "converte" );

   319     TBuf8<KLength> foreign( KForeign );

   320     TBuf<KLength> unicode;

   321 

   322     TUint inputFlag = CCnvCharacterSetConverter::EInputConversionFlagAppend;

   323     TUint outputFlag;

   324     TInt unconversion;

   325     TInt index;

   326     

   327     TInt num = CnvUtilities::ConvertToUnicodeFromHeterogeneousForeign( CCnvCharacterSetConverter::ELittleEndian, unicode, 

   328                                                                        foreign, unconversion, index, array->Array(), 

   329                                                                        outputFlag, inputFlag );

   330     STIF_ASSERT_TRUE( 0 == num );

   331     STIF_ASSERT_TRUE( 0 == unicode.Compare( KUnicode ) );

   332     

   333     CleanupStack::PopAndDestroy( array );

   334     

   335     return KErrNone;

   336     

   337     }

   338 

   339 //  [End of File]