1 /*

     2 * Copyright (c) 2009 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 */

    17 

    18 

    19 //  INTERNAL INCLUDES

    20 #include "ut_musenguriparser.h"

    21 #include "musenguriparser.h"

    22 #include "musengtestdefs.h"

    23 #include "mussettingskeys.h"

    24 #include "mussettings.h"

    25 

    26 //  SYSTEM INCLUDES

    27 #include <digia/eunit/eunitmacros.h>

    28 #include <e32property.h>

    29 

    30 

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

    32 //

    33 // -----------------------------------------------------------------------------

    34 //

    35 UT_TMusEngUriParser* UT_TMusEngUriParser::NewL()

    36     {

    37     UT_TMusEngUriParser* self = UT_TMusEngUriParser::NewLC();

    38     CleanupStack::Pop( self );

    39     return self;

    40     }

    41 

    42 

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

    44 //

    45 // -----------------------------------------------------------------------------

    46 //

    47 UT_TMusEngUriParser* UT_TMusEngUriParser::NewLC()

    48     {

    49     UT_TMusEngUriParser* self = new( ELeave ) UT_TMusEngUriParser();

    50     CleanupStack::PushL( self );

    51     self->ConstructL();

    52     return self;

    53     }

    54 

    55 

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

    57 //

    58 // -----------------------------------------------------------------------------

    59 //

    60 UT_TMusEngUriParser::~UT_TMusEngUriParser()

    61     {

    62     // NOP

    63     }

    64 

    65 

    66 // -----------------------------------------------------------------------------

    67 // Default constructor

    68 // -----------------------------------------------------------------------------

    69 //

    70 UT_TMusEngUriParser::UT_TMusEngUriParser()

    71     {

    72     // NOP

    73     }

    74 

    75 

    76 // -----------------------------------------------------------------------------

    77 // Second phase construct

    78 // -----------------------------------------------------------------------------

    79 //

    80 void UT_TMusEngUriParser::ConstructL()

    81     {

    82     // The ConstructL from the base class CEUnitTestSuiteClass must be called.

    83     // It generates the test case table.

    84     CEUnitTestSuiteClass::ConstructL();

    85     }

    86     

    87 

    88 // -----------------------------------------------------------------------------

    89 //

    90 // -----------------------------------------------------------------------------

    91 //

    92 void UT_TMusEngUriParser::SetupL()

    93     {

    94     

    95     }

    96 

    97 

    98 // -----------------------------------------------------------------------------

    99 //

   100 // -----------------------------------------------------------------------------

   101 //

   102 void UT_TMusEngUriParser::Teardown()

   103     {

   104     MultimediaSharingSettings::SetOperatorVariantSettingL(

   105                              MusSettingsKeys::EStandard );

   106     PropertyHelper::Close();

   107     }

   108 

   109 

   110 

   111 // TEST CASES

   112 

   113 // -----------------------------------------------------------------------------

   114 //

   115 // -----------------------------------------------------------------------------

   116 //

   117 void UT_TMusEngUriParser::UT_TMusEngUriParser_TMusEngUriParserL()

   118     {

   119     TMusEngUriParser parser( KTestRecipientSipUri() );

   120     EUNIT_ASSERT( parser.iUri == KTestRecipientSipUri8()  )

   121     

   122     // Too long

   123     TBuf<520> longBuf;

   124     longBuf.Fill('a', 520);

   125     

   126     TMusEngUriParser parser2( longBuf );

   127     EUNIT_ASSERT( parser2.iUri == KNullDesC8() )

   128                      

   129     }

   130 

   131 

   132 #include <uri8.h>

   133 

   134 // -----------------------------------------------------------------------------

   135 //

   136 // -----------------------------------------------------------------------------

   137 //

   138 void UT_TMusEngUriParser::UT_TMusEngUriParser_GetUri8LL()

   139     {

   140     TMusEngUriParser parser( KTestRecipientSipUriNoSipPrefix() );

   141     

   142     // No parsing done, fails

   143     TRAPD( error, parser.GetUri8L() );

   144     MUS_TEST_FORWARD_ALLOC_FAILURE( error );

   145     EUNIT_ASSERT( error == KErrNotReady );

   146     

   147     // Parse and test

   148     parser.ParseUriL();

   149     

   150     HBufC8* uri = parser.GetUri8L(); 

   151                               

   152     CleanupStack::PushL( uri );

   153     EUNIT_ASSERT( *uri == KTestRecipientSipUri8() );

   154     CleanupStack::PopAndDestroy( uri );   

   155     

   156     }

   157     

   158 

   159 // -----------------------------------------------------------------------------

   160 //

   161 // -----------------------------------------------------------------------------

   162 //

   163 void UT_TMusEngUriParser::UT_TMusEngUriParser_GetUri16LL()

   164     {

   165     TMusEngUriParser parser( KTestRecipientSipUriNoSipPrefix() );

   166     

   167     // No parsing done, fails

   168     TRAPD( error, parser.GetUri16L( ETrue ) );

   169     MUS_TEST_FORWARD_ALLOC_FAILURE( error );

   170     EUNIT_ASSERT( error == KErrNotReady );

   171     

   172     // Parse and test

   173     parser.ParseUriL();

   174     

   175     HBufC16* uri = parser.GetUri16L( ETrue ); 

   176                               

   177     CleanupStack::PushL( uri );

   178     EUNIT_ASSERT( *uri == KTestRecipientSipUri() );

   179     CleanupStack::PopAndDestroy( uri );

   180     

   181     uri = parser.GetUri16L( EFalse ); 

   182                               

   183     CleanupStack::PushL( uri );

   184     EUNIT_ASSERT( *uri == KTestRecipientSipUriNoSipPrefix() );

   185     CleanupStack::PopAndDestroy( uri );

   186       

   187     }

   188 

   189 

   190 // -----------------------------------------------------------------------------

   191 //

   192 // -----------------------------------------------------------------------------

   193 //

   194 void UT_TMusEngUriParser::UT_TMusEngUriParser_ParseUriLL()

   195     {

   196     TMusEngUriParser parser( KTestRecipientSipUri() );

   197     

   198     // Succesful case, sip uri

   199     parser.ParseUriL();

   200     EUNIT_ASSERT_EQUALS( parser.iUri, KTestRecipientSipUri8() );

   201     

   202     // Succesful case, sip uri with uppercase prefix

   203     parser.iUri = KTestRecipientSipUriPrefixUpperCase8();

   204     parser.ParseUriL();

   205     EUNIT_ASSERT_EQUALS( parser.iUri, KTestRecipientSipUri8() );

   206     

   207     // Succesful case, secure sip uri

   208     _LIT8( KTestRecipientSipsUriPrefix8, "sips:testrecipient@host.domain" );

   209     parser.iUri = KTestRecipientSipsUriPrefix8();

   210     parser.ParseUriL();

   211     EUNIT_ASSERT_EQUALS( parser.iUri, KTestRecipientSipsUriPrefix8() );

   212     

   213     // Succesful case, secure sip uri with uppercase prefix

   214     _LIT8( KTestRecipientSipsUriPrefixUpperCase8, "SIPS:testrecipient@host.domain" );

   215     parser.iUri = KTestRecipientSipsUriPrefixUpperCase8();

   216     parser.ParseUriL();

   217     EUNIT_ASSERT_EQUALS( parser.iUri, KTestRecipientSipsUriPrefix8() );

   218     

   219     // Succesful case, tel uri

   220     parser.iUri = KTestRecipientTelUri8();

   221     parser.ParseUriL();

   222     EUNIT_ASSERT_EQUALS( parser.iUri, KTestRecipientTelUri8() );

   223     

   224     // Succesful case, sip uri added

   225     parser.iUri = KTestRecipientSipUriNoSipPrefix8();

   226     parser.ParseUriL();

   227     EUNIT_ASSERT_EQUALS( parser.iUri, KTestRecipientSipUri8() );

   228     

   229     // Succesful case, tel uri added

   230     parser.iUri = KTestRecipientTelUriNoTelPrefix8();

   231     parser.ParseUriL();

   232     EUNIT_ASSERT_EQUALS( parser.iUri, KTestRecipientTelUri8() );

   233     

   234     // Succesfull case, valid number with separators

   235     _LIT8( KTestTelUriWithSomeWildChars, " +358 (1) [11-]{1}111 " );

   236     _LIT8( KTestTelUriWithPrefixAndSomeWildChars, "tel:+358 (1) [11-]{1}111" );

   237     

   238     parser.iUri = KTestTelUriWithSomeWildChars();

   239     parser.ParseUriL();

   240     EUNIT_ASSERT_EQUALS( parser.iUri, KTestRecipientTelUri8() );

   241     

   242     parser.iUri = KTestTelUriWithPrefixAndSomeWildChars();

   243     parser.ParseUriL();

   244     EUNIT_ASSERT_EQUALS( parser.iUri, KTestRecipientTelUri8() );

   245         

   246     // Unsuccessful case, random string

   247     parser.iUri = KTestRecipientRandomText8();

   248     TRAPD( error, parser.ParseUriL() );

   249     MUS_TEST_FORWARD_ALLOC_FAILURE( error );

   250     EUNIT_ASSERT_EQUALS( error, KErrArgument );

   251     

   252     // Unsuccessful case, tel prefix and at sign present

   253     parser.iUri = KTestRecipientTelUriWithAtSign8();

   254     TRAP( error, parser.ParseUriL() );

   255     MUS_TEST_FORWARD_ALLOC_FAILURE( error );

   256     EUNIT_ASSERT_EQUALS( error, KErrCorrupt );

   257     

   258     // Unsuccessful case, plus sign and non-numeric characters

   259     parser.iUri = KTestRecipientTelUriWithXCharAtEnd8();

   260     TRAP( error, parser.ParseUriL() );

   261     MUS_TEST_FORWARD_ALLOC_FAILURE( error );

   262     EUNIT_ASSERT_EQUALS( error, KErrCorrupt );

   263     

   264     parser.iUri = KTestRecipientTelUriWithXCharAtStart8();

   265     TRAP( error, parser.ParseUriL() );

   266     MUS_TEST_FORWARD_ALLOC_FAILURE( error );

   267     EUNIT_ASSERT_EQUALS( error, KErrCorrupt );

   268     

   269     // Unsuccesful case, name too long to be able to add sip prefix

   270     parser.iUri.Fill('a', 510);

   271     parser.iUri.Replace( 0, 

   272                          KTestRecipientSipUriNoSipPrefix8().Length(),

   273                          KTestRecipientSipUriNoSipPrefix8() );

   274     

   275     TRAP( error, parser.ParseUriL() );

   276     MUS_TEST_FORWARD_ALLOC_FAILURE( error );

   277     EUNIT_ASSERT_EQUALS( error, KErrCorrupt );

   278     

   279     // Unsuccesful case, name too long to be able to add tel prefix

   280     parser.iUri.Fill('1', 510);

   281     parser.iUri.Replace( 0, 

   282                          KTestRecipientTelUriNoTelPrefix8().Length(),

   283                          KTestRecipientTelUriNoTelPrefix8() );

   284     

   285     TRAP( error, parser.ParseUriL() );

   286     MUS_TEST_FORWARD_ALLOC_FAILURE( error );

   287     EUNIT_ASSERT_EQUALS( error, KErrCorrupt );

   288  

   289   // test cases for operator variant

   290     // set operator variant

   291     MultimediaSharingSettings::SetOperatorVariantSettingL(

   292                      MusSettingsKeys::EOperatorSpecific );

   293     

   294     EUNIT_ASSERT_EQUALS( MusSettingsKeys::EOperatorSpecific, 

   295                    MultimediaSharingSettings::OperatorVariantSettingL() );

   296 

   297     //local number cases without tel prefix 

   298      // Successful case

   299     parser.iUri = KTestRecipientLocalTelUriNoTelPrefix8();

   300     parser.ParseUriL();

   301     EUNIT_ASSERT_EQUALS( parser.iUri, KTestRecipientLocalTelUri8() );

   302 

   303     // Unsuccesful case, uri too long to be able to add tel prefix

   304     parser.iUri = KTestRecipientLocalTelUriNoTelPrefix8();

   305     parser.iUri.Fill('1', 510);

   306     

   307     TRAP( error, parser.ParseUriL() );

   308     MUS_TEST_FORWARD_ALLOC_FAILURE( error );

   309     EUNIT_ASSERT_EQUALS( error, KErrCorrupt );

   310     

   311     // Unsuccessful case, crap uri

   312     parser.iUri = KTestRecipientLocalTelUriNoTelPrefixWithXCharAtEnd8();

   313     TRAP( error, parser.ParseUriL() );

   314     MUS_TEST_FORWARD_ALLOC_FAILURE( error );

   315     EUNIT_ASSERT_EQUALS( error, KErrCorrupt );

   316 

   317     // Unsuccessful case, crap uri

   318     parser.iUri = KTestRecipientLocalTelUriNoTelPrefixWithXCharAtStart8();

   319     TRAP( error, parser.ParseUriL() );

   320     MUS_TEST_FORWARD_ALLOC_FAILURE( error );

   321     EUNIT_ASSERT_EQUALS( error, KErrCorrupt );

   322 

   323     // Unsuccessful case, crap uri

   324     parser.iUri = KTestRecipientLocalTelUriNoTelPrefixWithXCharAtMiddle8();

   325     TRAP( error, parser.ParseUriL() );

   326     MUS_TEST_FORWARD_ALLOC_FAILURE( error );

   327     EUNIT_ASSERT_EQUALS( error, KErrCorrupt );

   328 

   329     //local number cases with tel prefix

   330     // Successful case

   331     parser.iUri = KTestRecipientLocalTelUri8();

   332     parser.ParseUriL();

   333     EUNIT_ASSERT_EQUALS( parser.iUri, KTestRecipientLocalTelUri8() );

   334 

   335     // Successful case, prefix uppercase

   336     parser.iUri = KTestRecipientLocalTelUriPrefixUpperCase8();

   337     parser.ParseUriL();

   338     EUNIT_ASSERT_EQUALS( parser.iUri, KTestRecipientLocalTelUri8() );

   339 

   340     // Unsuccessful case, crap uri

   341     parser.iUri = KTestRecipientLocalTelUriWithXCharAtEnd8();

   342     TRAP( error, parser.ParseUriL() );

   343     MUS_TEST_FORWARD_ALLOC_FAILURE( error );

   344     EUNIT_ASSERT_EQUALS( error, KErrCorrupt );

   345 

   346     // Unsuccessful case, crap uri

   347     parser.iUri = KTestRecipientLocalTelUriWithXCharAtStart8();

   348     TRAP( error, parser.ParseUriL() );

   349     MUS_TEST_FORWARD_ALLOC_FAILURE( error );

   350     EUNIT_ASSERT_EQUALS( error, KErrCorrupt );

   351 

   352     // Unsuccessful case, crap uri

   353     parser.iUri = KTestRecipientLocalTelUriWithXCharAtMiddle8();

   354     TRAP( error, parser.ParseUriL() );

   355     MUS_TEST_FORWARD_ALLOC_FAILURE( error );

   356     EUNIT_ASSERT_EQUALS( error, KErrCorrupt );

   357 

   358     // Unsuccessful case, crap uri

   359     parser.iUri = KTestRecipientLocalTelUriTelPrefixAtMiddle8();

   360     TRAP( error, parser.ParseUriL() );

   361     MUS_TEST_FORWARD_ALLOC_FAILURE( error );

   362     EUNIT_ASSERT_EQUALS( error, KErrCorrupt );

   363     }

   364 

   365 

   366 //  TEST TABLE

   367 

   368 EUNIT_BEGIN_TEST_TABLE(

   369     UT_TMusEngUriParser,

   370     "UT_TMusEngUriParser",

   371     "UNIT" )

   372 

   373 EUNIT_TEST(

   374     "TMusEngUriParser - test ",

   375     "TMusEngUriParser",

   376     "TMusEngUriParser",

   377     "FUNCTIONALITY",

   378     SetupL, UT_TMusEngUriParser_TMusEngUriParserL, Teardown)

   379 

   380 EUNIT_TEST(

   381     "GetUri8L - test ",

   382     "TMusEngUriParser",

   383     "GetUri8L",

   384     "FUNCTIONALITY",

   385     SetupL, UT_TMusEngUriParser_GetUri8LL, Teardown)

   386 

   387 EUNIT_TEST(

   388     "GetUri16L - test ",

   389     "TMusEngUriParser",

   390     "GetUri16L",

   391     "FUNCTIONALITY",

   392     SetupL, UT_TMusEngUriParser_GetUri16LL, Teardown)

   393 

   394 EUNIT_TEST(

   395     "ParseUriL - test ",

   396     "TMusEngUriParser",

   397     "ParseUriL",

   398     "FUNCTIONALITY",

   399     SetupL, UT_TMusEngUriParser_ParseUriLL, Teardown)

   400 

   401 

   402 

   403 EUNIT_END_TEST_TABLE

   404 

   405 //  END OF FILE

   406 

   407