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 

    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     

   105     }

   106 

   107 

   108 

   109 // TEST CASES

   110 

   111 // -----------------------------------------------------------------------------

   112 //

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

   114 //

   115 void UT_TMusEngUriParser::UT_TMusEngUriParser_TMusEngUriParserL()

   116     {

   117     TMusEngUriParser parser( KTestRecipientSipUri() );

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

   119     

   120     // Too long

   121     TBuf<520> longBuf;

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

   123     

   124     TMusEngUriParser parser2( longBuf );

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

   126                      

   127     }

   128 

   129 

   130 #include <uri8.h>

   131 

   132 // -----------------------------------------------------------------------------

   133 //

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

   135 //

   136 void UT_TMusEngUriParser::UT_TMusEngUriParser_GetUri8LL()

   137     {

   138     TMusEngUriParser parser( KTestRecipientSipUriNoSipPrefix() );

   139     

   140     // No parsing done, fails

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

   142     MUS_TEST_FORWARD_ALLOC_FAILURE( error );

   143     EUNIT_ASSERT( error == KErrNotReady );

   144     

   145     // Parse and test

   146     parser.ParseUriL();

   147     

   148     HBufC8* uri = parser.GetUri8L(); 

   149                               

   150     CleanupStack::PushL( uri );

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

   152     CleanupStack::PopAndDestroy( uri );   

   153     

   154     }

   155     

   156 

   157 // -----------------------------------------------------------------------------

   158 //

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

   160 //

   161 void UT_TMusEngUriParser::UT_TMusEngUriParser_GetUri16LL()

   162     {

   163     TMusEngUriParser parser( KTestRecipientSipUriNoSipPrefix() );

   164     

   165     // No parsing done, fails

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

   167     MUS_TEST_FORWARD_ALLOC_FAILURE( error );

   168     EUNIT_ASSERT( error == KErrNotReady );

   169     

   170     // Parse and test

   171     parser.ParseUriL();

   172     

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

   174                               

   175     CleanupStack::PushL( uri );

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

   177     CleanupStack::PopAndDestroy( uri );

   178     

   179     uri = parser.GetUri16L( EFalse ); 

   180                               

   181     CleanupStack::PushL( uri );

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

   183     CleanupStack::PopAndDestroy( uri );

   184       

   185     }

   186 

   187 

   188 // -----------------------------------------------------------------------------

   189 //

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

   191 //

   192 void UT_TMusEngUriParser::UT_TMusEngUriParser_ParseUriLL()

   193     {

   194     TMusEngUriParser parser( KTestRecipientSipUri() );

   195     

   196     // Succesful case, sip uri

   197     parser.ParseUriL();

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

   199     

   200     // Succesful case, sip uri with uppercase prefix

   201     parser.iUri = KTestRecipientSipUriPrefixUpperCase8();

   202     parser.ParseUriL();

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

   204     

   205     // Succesful case, secure sip uri

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

   207     parser.iUri = KTestRecipientSipsUriPrefix8();

   208     parser.ParseUriL();

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

   210     

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

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

   213     parser.iUri = KTestRecipientSipsUriPrefixUpperCase8();

   214     parser.ParseUriL();

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

   216     

   217     // Succesful case, tel uri

   218     parser.iUri = KTestRecipientTelUri8();

   219     parser.ParseUriL();

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

   221     

   222     // Succesful case, sip uri added

   223     parser.iUri = KTestRecipientSipUriNoSipPrefix8();

   224     parser.ParseUriL();

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

   226     

   227     // Succesful case, tel uri added

   228     parser.iUri = KTestRecipientTelUriNoTelPrefix8();

   229     parser.ParseUriL();

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

   231     

   232     // Succesfull case, valid number with separators

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

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

   235     

   236     parser.iUri = KTestTelUriWithSomeWildChars();

   237     parser.ParseUriL();

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

   239     

   240     parser.iUri = KTestTelUriWithPrefixAndSomeWildChars();

   241     parser.ParseUriL();

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

   243         

   244     // Unsuccessful case, random string

   245     parser.iUri = KTestRecipientRandomText8();

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

   247     MUS_TEST_FORWARD_ALLOC_FAILURE( error );

   248     EUNIT_ASSERT_EQUALS( error, KErrCorrupt );

   249     

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

   251     parser.iUri = KTestRecipientTelUriWithAtSign8();

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

   253     MUS_TEST_FORWARD_ALLOC_FAILURE( error );

   254     EUNIT_ASSERT_EQUALS( error, KErrCorrupt );

   255     

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

   257     parser.iUri = KTestRecipientTelUriWithXCharAtEnd8();

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

   259     MUS_TEST_FORWARD_ALLOC_FAILURE( error );

   260     EUNIT_ASSERT_EQUALS( error, KErrCorrupt );

   261     

   262     parser.iUri = KTestRecipientTelUriWithXCharAtStart8();

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

   264     MUS_TEST_FORWARD_ALLOC_FAILURE( error );

   265     EUNIT_ASSERT_EQUALS( error, KErrCorrupt );

   266     

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

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

   269     parser.iUri.Replace( 0, 

   270                          KTestRecipientSipUriNoSipPrefix8().Length(),

   271                          KTestRecipientSipUriNoSipPrefix8() );

   272     

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

   274     MUS_TEST_FORWARD_ALLOC_FAILURE( error );

   275     EUNIT_ASSERT_EQUALS( error, KErrCorrupt );

   276     

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

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

   279     parser.iUri.Replace( 0, 

   280                          KTestRecipientTelUriNoTelPrefix8().Length(),

   281                          KTestRecipientTelUriNoTelPrefix8() );

   282     

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

   284     MUS_TEST_FORWARD_ALLOC_FAILURE( error );

   285     EUNIT_ASSERT_EQUALS( error, KErrCorrupt );

   286  

   287   // test cases for operator variant

   288     // set operator variant

   289     MultimediaSharingSettings::SetOperatorVariantSettingL(

   290                      MusSettingsKeys::EOperatorSpecific );

   291     

   292     EUNIT_ASSERT_EQUALS( MusSettingsKeys::EOperatorSpecific, 

   293                    MultimediaSharingSettings::OperatorVariantSettingL() );

   294 

   295     //local number cases without tel prefix 

   296      // Successful case

   297     parser.iUri = KTestRecipientLocalTelUriNoTelPrefix8();

   298     parser.ParseUriL();

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

   300 

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

   302     parser.iUri = KTestRecipientLocalTelUriNoTelPrefix8();

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

   304     

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

   306     MUS_TEST_FORWARD_ALLOC_FAILURE( error );

   307     EUNIT_ASSERT_EQUALS( error, KErrCorrupt );

   308     

   309     // Unsuccessful case, crap uri

   310     parser.iUri = KTestRecipientLocalTelUriNoTelPrefixWithXCharAtEnd8();

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

   312     MUS_TEST_FORWARD_ALLOC_FAILURE( error );

   313     EUNIT_ASSERT_EQUALS( error, KErrCorrupt );

   314 

   315     // Unsuccessful case, crap uri

   316     parser.iUri = KTestRecipientLocalTelUriNoTelPrefixWithXCharAtStart8();

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

   318     MUS_TEST_FORWARD_ALLOC_FAILURE( error );

   319     EUNIT_ASSERT_EQUALS( error, KErrCorrupt );

   320 

   321     // Unsuccessful case, crap uri

   322     parser.iUri = KTestRecipientLocalTelUriNoTelPrefixWithXCharAtMiddle8();

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

   324     MUS_TEST_FORWARD_ALLOC_FAILURE( error );

   325     EUNIT_ASSERT_EQUALS( error, KErrCorrupt );

   326 

   327     //local number cases with tel prefix

   328     // Successful case

   329     parser.iUri = KTestRecipientLocalTelUri8();

   330     parser.ParseUriL();

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

   332 

   333     // Successful case, prefix uppercase

   334     parser.iUri = KTestRecipientLocalTelUriPrefixUpperCase8();

   335     parser.ParseUriL();

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

   337 

   338     // Unsuccessful case, crap uri

   339     parser.iUri = KTestRecipientLocalTelUriWithXCharAtEnd8();

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

   341     MUS_TEST_FORWARD_ALLOC_FAILURE( error );

   342     EUNIT_ASSERT_EQUALS( error, KErrCorrupt );

   343 

   344     // Unsuccessful case, crap uri

   345     parser.iUri = KTestRecipientLocalTelUriWithXCharAtStart8();

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

   347     MUS_TEST_FORWARD_ALLOC_FAILURE( error );

   348     EUNIT_ASSERT_EQUALS( error, KErrCorrupt );

   349 

   350     // Unsuccessful case, crap uri

   351     parser.iUri = KTestRecipientLocalTelUriWithXCharAtMiddle8();

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

   353     MUS_TEST_FORWARD_ALLOC_FAILURE( error );

   354     EUNIT_ASSERT_EQUALS( error, KErrCorrupt );

   355 

   356     // Unsuccessful case, crap uri

   357     parser.iUri = KTestRecipientLocalTelUriTelPrefixAtMiddle8();

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

   359     MUS_TEST_FORWARD_ALLOC_FAILURE( error );

   360     EUNIT_ASSERT_EQUALS( error, KErrCorrupt );

   361     }

   362 

   363 

   364 //  TEST TABLE

   365 

   366 EUNIT_BEGIN_TEST_TABLE(

   367     UT_TMusEngUriParser,

   368     "UT_TMusEngUriParser",

   369     "UNIT" )

   370 

   371 EUNIT_TEST(

   372     "TMusEngUriParser - test ",

   373     "TMusEngUriParser",

   374     "TMusEngUriParser",

   375     "FUNCTIONALITY",

   376     SetupL, UT_TMusEngUriParser_TMusEngUriParserL, Teardown)

   377 

   378 EUNIT_TEST(

   379     "GetUri8L - test ",

   380     "TMusEngUriParser",

   381     "GetUri8L",

   382     "FUNCTIONALITY",

   383     SetupL, UT_TMusEngUriParser_GetUri8LL, Teardown)

   384 

   385 EUNIT_TEST(

   386     "GetUri16L - test ",

   387     "TMusEngUriParser",

   388     "GetUri16L",

   389     "FUNCTIONALITY",

   390     SetupL, UT_TMusEngUriParser_GetUri16LL, Teardown)

   391 

   392 EUNIT_TEST(

   393     "ParseUriL - test ",

   394     "TMusEngUriParser",

   395     "ParseUriL",

   396     "FUNCTIONALITY",

   397     SetupL, UT_TMusEngUriParser_ParseUriLL, Teardown)

   398 

   399 

   400 

   401 EUNIT_END_TEST_TABLE

   402 

   403 //  END OF FILE

   404 

   405