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:        ?Description

    15 *

    16 */

    17 

    18 

    19 

    20 

    21 

    22 

    23 

    24 

    25 //  CLASS HEADER

    26 #include "myxml.h"

    27 //  EXTERNAL INCLUDES

    28 #include <wspolicyregistry.h>

    29 #include <wspolicy.h>

    30 #include <wspolicyutils.h>

    31 #include <TestInternalWSPolicy.h>

    32 #include <stringpool.h>

    33 #include <senwsdescription.h>

    34 

    35 // [INCLUDE FILES] - do not remove

    36 #include <e32svr.h>

    37 #include <StifParser.h>

    38 #include <StifTestInterface.h>

    39 #include "wsPolicyTester.h"

    40 #include <StifTestModule.h>

    41 // EXTERNAL DATA STRUCTURES

    42 //extern  ?external_data;

    43 

    44 // EXTERNAL FUNCTION PROTOTYPES  

    45 //extern ?external_function( ?arg_type,?arg_type );

    46 

    47 // CONSTANTS

    48 namespace

    49 {

    50 

    51 _LIT8( KWsPolicyNsUri , "http://schemas.xmlsoap.org/ws/2004/09/policy"); // Namespace of WS-Policy

    52 _LIT8( KWsPolicy , "Policy");                       // Tag name of Policy

    53 _LIT8( KWsPolicyPrefix , "wsp");                    // Prefix of WS-Policy namespace

    54 _LIT8( KWsPolicyQName , "wsp:Policy");                    // Prefix of WS-Policy namespace

    55 

    56 //registry resources

    57 _LIT(KReg1, "c:\\testing\\data\\registry1.xml");

    58 _LIT(KReg2, "c:\\testing\\data\\registry2.xml");

    59 _LIT(KReg3, "c:\\testing\\data\\registry3.xml");

    60 _LIT8(KID1, "ID1");

    61 _LIT8(KID2, "ID2");

    62 _LIT8(KID3, "ID3");

    63 _LIT8(KP1, "P1");

    64 _LIT8(KP2, "P2");

    65 _LIT8(KP3, "P3");

    66 _LIT8(KURI1, "URI1");

    67 _LIT8(KURI2, "URI2");

    68 _LIT8(KURI3, "URI3");

    69 

    70 //WSPolicy resource

    71 _LIT(KPolicy1, "c:\\testing\\data\\policy1.xml");

    72 _LIT(KPolicy2, "c:\\testing\\data\\policy2.xml"); //

    73 _LIT(KExpPolicy1, "c:\\testing\\data\\expiry1.xml"); //for expiry tag validation

    74 _LIT(KPolicy3, "c:\\testing\\data\\policy3.xml"); //for optional element = true

    75 _LIT(KPolicy3Ref, "c:\\testing\\data\\policy3Ref.xml");

    76 _LIT(KPolicy4, "c:\\testing\\data\\policy4.xml"); //for nesting

    77 _LIT(KPolicy4Ref,"c:\\testing\\data\\policy4Ref.xml");

    78 _LIT(KPolicy5, "c:\\testing\\data\\policy5.xml"); //for multiple nesting

    79 _LIT(KPolicy5Ref,"c:\\testing\\data\\policy5Ref.xml");

    80 

    81 // Policy, name and its normalized reference    

    82 _LIT8(KPolicyName, "P1");

    83 _LIT8(KPolicy,   "<wsp:Policy xmlns:wsp=\"http://schemas.xmlsoap.org/ws/2004/09/policy\" xmlns:wsu=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd\" Name=\"P1\" wsu:Id=\"ID1\" MetadataEndpoint=\"URI1\"><wsp:ExactlyOne><wsp:All/></wsp:ExactlyOne></wsp:Policy>");

    84 _LIT8(KPolicyRef,"<wsp:Policy xmlns:wsp=\"http://schemas.xmlsoap.org/ws/2004/09/policy\" xmlns:wsu=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd\" Name=\"P1\" wsu:Id=\"ID1\" MetadataEndpoint=\"URI1\"><wsp:ExactlyOne><wsp:All/></wsp:ExactlyOne></wsp:Policy>");

    85 const TInt KRefLength = 267;

    86 

    87 }

    88 

    89 

    90 // MACROS

    91 #define LOCAL_ASSERT(expression)  {if(!(expression)){return KErrArgument;}}

    92 #define LOCAL_VOID_ASSERT(expression)	{if(!(expression)){return ;}}

    93 #define STIFF_ASSERT_NOT_EQUALS_DESC(expression1, expression2, desc){TL((expression1) != (expression2)){RDebug::Print(_L(desc)) ;}}

    94 #define STIFF_ASSERT_DESC(expression, desc)	{if(!(expression)){RDebug::Print(_L(desc)) ;return KErrArgument;}}

    95 

    96 // LOCAL CONSTANTS AND MACROS

    97 //const ?type ?constant_var = ?constant;

    98 //#define ?macro_name ?macro_def

    99 

   100 // MODULE DATA STRUCTURES

   101 //enum ?declaration

   102 //typedef ?declaration

   103 

   104 // LOCAL FUNCTION PROTOTYPES

   105 //?type ?function_name( ?arg_type, ?arg_type );

   106 

   107 // FORWARD DECLARATIONS

   108 //class ?FORWARD_CLASSNAME;

   109 

   110 // ============================= LOCAL FUNCTIONS ===============================

   111 

   112 // -----------------------------------------------------------------------------

   113 // ?function_name ?description.

   114 // ?description

   115 // Returns: ?value_1: ?description

   116 //          ?value_n: ?description_line1

   117 //                    ?description_line2

   118 // -----------------------------------------------------------------------------

   119 //

   120 /*

   121 ?type ?function_name(

   122     ?arg_type arg,  // ?description

   123     ?arg_type arg)  // ?description

   124     {

   125 

   126     ?code  // ?comment

   127 

   128     // ?comment

   129     ?code

   130     }

   131 */

   132 

   133 // ============================ MEMBER FUNCTIONS ===============================

   134 

   135 // -----------------------------------------------------------------------------

   136 // CwsPolicyTester::Delete

   137 // Delete here all resources allocated and opened from test methods. 

   138 // Called from destructor. 

   139 // -----------------------------------------------------------------------------

   140 //

   141 void CwsPolicyTester::Delete() 

   142     {

   143 

   144     }

   145 

   146 // -----------------------------------------------------------------------------

   147 // CwsPolicyTester::RunMethodL

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

   149 // -----------------------------------------------------------------------------

   150 //

   151 TInt CwsPolicyTester::RunMethodL( 

   152     CStifItemParser& aItem ) 

   153     {

   154 

   155     static TStifFunctionInfo const KFunctions[] =

   156         {  

   157         // Copy this line for every implemented function.

   158         // First string is the function name used in TestScripter script file.

   159         // Second is the actual implementation member function. 

   160   

   161         ENTRY("NewL-test_CWSPolicyUtils_PolicyIdL", CwsPolicyTester::MT_CWSPolicyUtils_PolicyIdLL),

   162         ENTRY("NewL-test_CWSPolicyUtils_PolicyNameL", CwsPolicyTester::MT_CWSPolicyUtils_PolicyNameLL),

   163         ENTRY("NewL-test_CWSPolicyUtils_IsExpiredPolicyL", CwsPolicyTester::MT_CWSPolicyUtils_PolicyUriLL),

   164         ENTRY("NewL-test_CWSPolicyUtils_IsExpiredPolicyL", CwsPolicyTester::MT_CWSPolicyUtils_IsExpiredPolicyLL),

   165         ENTRY("NewL-test_CPolicyRegistry_NewL", CwsPolicyTester::MT_CPolicyRegistry_NewLL),

   166         ENTRY("NewLC-test_CPolicyRegistry_NewLC", CwsPolicyTester::MT_CPolicyRegistry_NewLCL),

   167         ENTRY("LookupPolicy-test_CPolicyRegistry_LookupPolicy", CwsPolicyTester::MT_CPolicyRegistry_LookupPolicyL),

   168         ENTRY("LookupPolicyByName-test_CPolicyRegistry_LookupPolicyByName", CwsPolicyTester::MT_CPolicyRegistry_LookupPolicyByNameL),

   169         ENTRY("RegisterPolicy-test_CPolicyRegistry_RegisterPolicy", CwsPolicyTester::MT_CPolicyRegistry_RegisterPolicyL),

   170         ENTRY("UnregisterPolicy-test_CPolicyRegistry_UnregisterPolicy", CwsPolicyTester::MT_CPolicyRegistry_UnregisterPolicyL),

   171         ENTRY("PopulateRegistry-test_CPolicyRegistry_PopulateRegistry", CwsPolicyTester::MT_CPolicyRegistry_PopulateRegistryL),

   172         ENTRY("ResetRegistry-test_CPolicyRegistry_ResetRegistry", CwsPolicyTester::MT_CPolicyRegistry_ResetRegistryL),

   173         ENTRY("NewL-test_CWSPolicy_NewL", CwsPolicyTester::MT_CWSPolicy_NewLL),

   174         ENTRY("NewLC-test_CWSPolicy_NewLC", CwsPolicyTester::MT_CWSPolicy_NewLCL),

   175         ENTRY("NewL-test_CWSPolicy_NewL", CwsPolicyTester::MT_CWSPolicy_NewL_1L),

   176         ENTRY("NewLC-test_CWSPolicy_NewLC", CwsPolicyTester::MT_CWSPolicy_NewLC_1L),

   177         ENTRY("NormalizePolicyL-test_CWSPolicy_NormalizePolicyL", CwsPolicyTester::MT_CWSPolicy_NormalizePolicyLL),

   178         ENTRY("IntersectPolicyL-test_CWSPolicy_IntersectPolicyL", CwsPolicyTester::MT_CWSPolicy_IntersectPolicyLL),

   179         ENTRY("MergePolicyL-test_CWSPolicy_MergePolicyL", CwsPolicyTester::MT_CWSPolicy_MergePolicyLL),

   180         ENTRY("Normalized-test_CWSPolicy_Normalized", CwsPolicyTester::MT_CWSPolicy_NormalizedL),

   181         ENTRY("Policy-test_CWSPolicy_Policy", CwsPolicyTester::MT_CWSPolicy_Policy),

   182         ENTRY("AsXmlL-test_CWSPolicy_AsXmlL", CwsPolicyTester::MT_CWSPolicy_NormalizedAsXmlLL),

   183         ENTRY("NormalizedPolicy-test_CWSPolicy_NormalizedPolicy", CwsPolicyTester::MT_CWSPolicy_NormalizedPolicy),

   184         ENTRY("IsExpiredPolicy-test_CWSPolicy_IsExpiredPolicy", CwsPolicyTester::MT_CWSPolicy_IsExpiredPolicyL),

   185         ENTRY("NewL-test_CSenInternalWsPolicy_NewL", CwsPolicyTester::MT_CSenInternalWsPolicy_NewLL),

   186         ENTRY("NewLC-test_CSenInternalWsPolicy_NewLC", CwsPolicyTester::MT_CSenInternalWsPolicy_NewLCL),

   187         ENTRY("NewL-test_CSenInternalWsPolicy_NewL", CwsPolicyTester::MT_CSenInternalWsPolicy_NewL_1L),

   188         ENTRY("NewLC-test_CSenInternalWsPolicy_NewLC", CwsPolicyTester::MT_CSenInternalWsPolicy_NewLC_1L),

   189         ENTRY("NewLC-test_CSenInternalWsPolicy_NewLC", CwsPolicyTester::MT_CSenInternalWsPolicy_NewL_2L),

   190         ENTRY("NewLC-test_CSenInternalWsPolicy_NewLC", CwsPolicyTester::MT_CSenInternalWsPolicy_NewLC_2L),

   191         ENTRY("IsApplicableL-test_CSenInternalWsPolicy_IsApplicableL", CwsPolicyTester::MT_CSenInternalWsPolicy_IsApplicableLL),

   192         ENTRY("IsApplicableL-test_CSenInternalWsPolicy_IsApplicableL", CwsPolicyTester::MT_CSenInternalWsPolicy_IsApplicableL_1L),

   193         ENTRY("IsApplicableL-test_CSenInternalWsPolicy_IsApplicableL", CwsPolicyTester::MT_CSenInternalWsPolicy_IsApplicableL_2L),

   194         ENTRY("UpdateMetadataEndpointL-test_CSenInternalWsPolicy_UpdateMetadataEndpointL", CwsPolicyTester::MT_CSenInternalWsPolicy_UpdateMetadataEndpointLL),

   195         ENTRY("UpdateMetadataEndpointL-test_CSenInternalWsPolicy_AddMetadataPolicyL", CwsPolicyTester::MT_CSenInternalWsPolicy_AddMetadataPolicyLL),

   196         ENTRY("UpdateMetadataEndpointL-test_CSenInternalWsPolicy_RemoveMetadataPolicyL", CwsPolicyTester::MT_CSenInternalWsPolicy_RemoveMetadataPolicyLL),

   197         ENTRY("WsPolicyByUriL-test_CSenInternalWsPolicy_WsPolicyByUriL", CwsPolicyTester::MT_CSenInternalWsPolicy_WsPolicyByUriLL),

   198         ENTRY("WsPolicyByName-test_CSenInternalWsPolicy_WsPolicyByName", CwsPolicyTester::MT_CSenInternalWsPolicy_WsPolicyByNameL),

   199         ENTRY("ValidUntilL-test_CSenInternalWsPolicy_ValidUntilL", CwsPolicyTester::MT_CSenInternalWsPolicy_ValidUntilLL),

   200         ENTRY("NewL-test_CSenWSPolicyIdentifier_NewL", CwsPolicyTester::MT_CSenWSPolicyIdentifier_NewLL),

   201         ENTRY("NewLC-test_CSenWSPolicyIdentifier_NewLC", CwsPolicyTester::MT_CSenWSPolicyIdentifier_NewLCL),

   202         ENTRY("NewL-test_CSenWSPolicyIdentifier_NewL", CwsPolicyTester::MT_CSenWSPolicyIdentifier_NewL_1L),

   203         ENTRY("NewLC-test_CSenWSPolicyIdentifier_NewLC", CwsPolicyTester::MT_CSenWSPolicyIdentifier_NewLC_1L),

   204         ENTRY("NewL-test_CSenWSPolicyIdentifier_NewL", CwsPolicyTester::MT_CSenWSPolicyIdentifier_NewL_2L),

   205         ENTRY("NewLC-test_CSenWSPolicyIdentifier_NewLC", CwsPolicyTester::MT_CSenWSPolicyIdentifier_NewLC_2L),

   206         ENTRY("SetPropertyL-test_CSenWSPolicyIdentifier_SetPropertyL", CwsPolicyTester::MT_CSenWSPolicyIdentifier_SetPropertyLL),

   207         ENTRY("PropertyL-test_CSenWSPolicyIdentifier_PropertyL", CwsPolicyTester::MT_CSenWSPolicyIdentifier_PropertyLL),

   208         ENTRY("SetIdL-test_CSenWSPolicyIdentifier_SetIdL", CwsPolicyTester::MT_CSenWSPolicyIdentifier_SetIdLL),

   209         ENTRY("IdL-test_CSenWSPolicyIdentifier_IdL", CwsPolicyTester::MT_CSenWSPolicyIdentifier_IdLL),

   210         ENTRY("AddMetadataEndpointL-test_CSenWSPolicyIdentifier_AddMetadataEndpointL", CwsPolicyTester::MT_CSenWSPolicyIdentifier_AddMetadataEndpointLL),

   211         ENTRY("MetadataEndpointL-test_CSenWSPolicyIdentifier_MetadataEndpointL", CwsPolicyTester::MT_CSenWSPolicyIdentifier_MetadataEndpointLL),

   212         ENTRY("MetadataEndpointElementL-test_CSenWSPolicyIdentifier_MetadataEndpointElementL", CwsPolicyTester::MT_CSenWSPolicyIdentifier_MetadataEndpointElementLL),

   213         ENTRY("ElementAttribValueL-test_CSenWSPolicyIdentifier_ElementAttribValueL", CwsPolicyTester::MT_CSenWSPolicyIdentifier_ElementAttribValueLL),

   214         ENTRY("HasAttributeL-test_CSenWSPolicyIdentifier_HasAttributeL", CwsPolicyTester::MT_CSenWSPolicyIdentifier_HasAttributeLL),

   215         ENTRY("NewL-test_CWSPolicyWriter_NewL", CwsPolicyTester::MT_CWSPolicyWriter_NewLL),

   216         ENTRY("NewLC-test_CWSPolicyWriter_NewLC", CwsPolicyTester::MT_CWSPolicyWriter_NewLCL),

   217         ENTRY("NewL-test_CWSPolicyReader_NewL", CwsPolicyTester::MT_CWSPolicyReader_NewLL),

   218         ENTRY("NewLC-test_CWSPolicyReader_NewLC", CwsPolicyTester::MT_CWSPolicyReader_NewLCL),

   219         ENTRY("GetPolicyL-test_CWSPolicyReader_GetPolicyL", CwsPolicyTester::MT_CWSPolicyReader_GetPolicyLL),

   220         ENTRY("WriteToFileAllL-test_CWSPolicyWriter_WriteToFileAllL", CwsPolicyTester::MT_CWSPolicyWriter_WriteToFileAllLL),

   221         ENTRY("WriteToFileAllL-test_CWSPolicyWriter_WriteToFileAllL", CwsPolicyTester::MT_CWSPolicyWriter_WriteToFileAllL_1L),

   222         ENTRY("WriteAllAsXmlL-test_CWSPolicyWriter_WriteAllAsXmlL", CwsPolicyTester::MT_CWSPolicyWriter_WriteAllAsXmlLL),

   223 

   224         //ADD NEW ENTRY HERE

   225         // [test cases entries] - Do not remove

   226 

   227         };

   228 

   229     const TInt count = sizeof( KFunctions ) / 

   230                         sizeof( TStifFunctionInfo );

   231 

   232     return RunInternalL( KFunctions, count, aItem );

   233 

   234     }

   235 

   236 void CwsPolicyTester::SetupL(  )

   237     {

   238 //    _LIT(KDir,"XML_App");

   239 //    TBufC<30> aDirBuf(KDir);

   240 //    _LIT(KFile,"WSPolicy_Test.txt");

   241 //    TBufC<30> aNameBuf(KFile);

   242 //    TInt connectRes=fL.Connect();

   243 //    TRAPD(createRes,fL.CreateLog(aDirBuf,aNameBuf,EFileLoggingModeOverwrite));

   244 

   245     }

   246 

   247 void CwsPolicyTester::Teardown(  )

   248     {

   249 //      fL.CloseLog();

   250 //    fL.Close();

   251 

   252     }

   253 

   254 TInt CwsPolicyTester::MT_CWSPolicyUtils_PolicyIdLL(CStifItemParser& aItem)

   255 {  

   256      TPtrC8 p1(KID1);

   257      TPtrC8 p2(KID2);

   258      TPtrC8 p3(KID3);

   259 

   260     CMyXmlEle* doc1 = CMyXmlEle::NewL();

   261     TFileName name1(KPolicy1);

   262     doc1->ReadFileL(name1);

   263     CSenElement* policy1 = doc1->XMLDocL();

   264     TL(policy1 != (CSenElement*)NULL);

   265     TPtrC8 id1(CWSPolicyUtils::PolicyIdL(policy1));

   266     TL(id1 == p1);

   267     

   268     CMyXmlEle* doc2 = CMyXmlEle::NewL();

   269     TFileName name2(KPolicy2);

   270     doc2->ReadFileL(name2);

   271     CSenElement* policy2 = doc2->XMLDocL();

   272     TL(policy2 != (CSenElement*)NULL);

   273     TPtrC8 id2(CWSPolicyUtils::PolicyIdL(policy2));

   274     TL(id2 == p2);

   275     

   276      delete doc1;

   277      delete doc2;

   278     return KErrNone;

   279 }

   280 

   281 TInt CwsPolicyTester::MT_CWSPolicyUtils_PolicyNameLL(CStifItemParser& aItem )

   282 {

   283      TPtrC8 p1(KP1);

   284      TPtrC8 p2(KP2);

   285      TPtrC8 p3(KP3);

   286 

   287     CMyXmlEle* doc1 = CMyXmlEle::NewL();

   288     TFileName name1(KPolicy1);

   289     doc1->ReadFileL(name1);

   290     CSenElement* policy1 = doc1->XMLDocL();

   291     TL(policy1 != (CSenElement*)NULL);

   292     TPtrC8 id1(CWSPolicyUtils::PolicyNameL(policy1));

   293     TL(id1 == p1);

   294     

   295     CMyXmlEle* doc2 = CMyXmlEle::NewL();

   296     TFileName name2(KPolicy2);

   297     doc2->ReadFileL(name2);

   298     CSenElement* policy2 = doc2->XMLDocL();

   299     TL(policy2 != (CSenElement*)NULL);

   300     TPtrC8 id2(CWSPolicyUtils::PolicyNameL(policy2));

   301     TL(id2 == p2);

   302     

   303     delete doc1;

   304     delete doc2;

   305     return KErrNone;

   306 }

   307 

   308 TInt CwsPolicyTester::MT_CWSPolicyUtils_PolicyUriLL(CStifItemParser& aItem)

   309 {

   310      TPtrC8 p1(KURI1);

   311      TPtrC8 p2(KURI2);

   312      TPtrC8 p3(KURI3);

   313 

   314     CMyXmlEle* doc1 = CMyXmlEle::NewL();

   315     TFileName name1(KPolicy1);

   316     doc1->ReadFileL(name1);

   317     CSenElement* policy1 = doc1->XMLDocL();

   318     TL(policy1 != (CSenElement*)NULL);

   319     TPtrC8 uri1(CWSPolicyUtils::PolicyUriL(policy1));

   320     TL(uri1 == p1);

   321     

   322     CMyXmlEle* doc2 = CMyXmlEle::NewL();

   323     TFileName name2(KPolicy2);

   324     doc2->ReadFileL(name2);

   325     CSenElement* policy2 = doc2->XMLDocL();

   326     TL(policy2 != (CSenElement*)NULL);

   327     TPtrC8 uri2(CWSPolicyUtils::PolicyUriL(policy2));

   328     TL(uri2 == p2);

   329     

   330     delete doc1;

   331     delete doc2;

   332     return KErrNone;

   333 }

   334 TInt CwsPolicyTester::MT_CWSPolicyUtils_IsExpiredPolicyLL(CStifItemParser& aItem)

   335 {

   336     CMyXmlEle* doc1 = CMyXmlEle::NewL();

   337     TFileName name1(KExpPolicy1);

   338     doc1->ReadFileL(name1);

   339     CSenElement* policy1 = doc1->XMLDocL();

   340     TBool result = EFalse;

   341     result = CWSPolicyUtils::IsExpiredPolicyL(policy1);

   342     TL(result == EFalse);

   343 

   344     delete doc1;

   345     return KErrNone;

   346 }

   347 

   348 TInt CwsPolicyTester::MT_CPolicyRegistry_NewLL( CStifItemParser& aItem  )

   349     {

   350      CPolicyRegistry* registry = CPolicyRegistry::NewL();

   351      TL(registry != (CPolicyRegistry*)NULL);

   352 

   353      __ASSERT_ALWAYS_NO_LEAVE(delete registry);

   354      registry = NULL;

   355      return KErrNone;

   356     }

   357 

   358 TInt CwsPolicyTester::MT_CPolicyRegistry_NewLCL( CStifItemParser& aItem  )

   359     {

   360      CPolicyRegistry* registry = CPolicyRegistry::NewLC();

   361      TL(registry != (CPolicyRegistry*)NULL);

   362      

   363      CleanupStack::Pop();

   364      __ASSERT_ALWAYS_NO_LEAVE(delete registry);

   365      registry = NULL;

   366      return KErrNone;

   367     }

   368 

   369 TInt CwsPolicyTester::MT_CPolicyRegistry_LookupPolicyL( CStifItemParser& aItem  )

   370     {

   371     CPolicyRegistry* registry = CPolicyRegistry::NewL();

   372     TL(registry != (CPolicyRegistry*)NULL);

   373          

   374     CMyXmlEle* doc1 = CMyXmlEle::NewL();

   375     TFileName name(KReg1);

   376     doc1->ReadFileL(name);

   377     CSenElement* policy = doc1->XMLDocL();

   378     

   379     registry->PopulateRegistryL(policy);  //codescannerwarnings

   380      

   381      TPtrC8 p1(KID1);

   382      TPtrC8 p2(KID2);

   383      TPtrC8 p3(KID3);

   384      

   385      CSenElement* ele1 = registry->LookupPolicy(p1);

   386      TPtrC8 policyId1(CWSPolicyUtils::PolicyIdL(ele1));

   387      TL(policyId1 == p1);

   388 

   389      CSenElement* ele2 = registry->LookupPolicy(p2);

   390      TPtrC8 policyId2(CWSPolicyUtils::PolicyIdL(ele2));

   391      TL(policyId2 == p2);

   392           

   393      __ASSERT_ALWAYS_NO_LEAVE(delete registry);

   394      registry = NULL;

   395      delete doc1;

   396      return KErrNone;

   397     }

   398 

   399 TInt CwsPolicyTester::MT_CPolicyRegistry_LookupPolicyByNameL( CStifItemParser& aItem  )

   400     {

   401     CPolicyRegistry* registry = CPolicyRegistry::NewL();

   402     TL(registry != (CPolicyRegistry*)NULL);

   403          

   404     CMyXmlEle* doc1 = CMyXmlEle::NewL();

   405     TFileName name(KReg1);

   406     doc1->ReadFileL(name);

   407     CSenElement* policy = doc1->XMLDocL();

   408     

   409     registry->PopulateRegistryL(policy);  //codescannerwarnings

   410      

   411      TPtrC8 p1Name(KP1);

   412      TPtrC8 p2Name(KP2);

   413      TPtrC8 p3Name(KP3);

   414      

   415      CSenElement* ele1 = registry->LookupPolicyByNameL(p1Name); //codescannerwarnings

   416      TL(ele1 != (CSenElement*)NULL);

   417 

   418      CSenElement* ele2 = registry->LookupPolicyByNameL(p2Name); //codescannerwarnings

   419      TL(ele2  != (CSenElement*)NULL);

   420 

   421      CSenElement* ele3 = registry->LookupPolicyByNameL(p3Name); //codescannerwarnings

   422      TL(ele3 == (CSenElement*)NULL);

   423           

   424      __ASSERT_ALWAYS_NO_LEAVE(delete registry);

   425      registry = NULL;

   426      delete doc1;

   427      return KErrNone;

   428     }

   429 

   430 TInt CwsPolicyTester::MT_CPolicyRegistry_RegisterPolicyL( CStifItemParser& aItem  )

   431     {

   432     CPolicyRegistry* registry = CPolicyRegistry::NewL();

   433     TL(registry != (CPolicyRegistry*)NULL);

   434     

   435   

   436     CMyXmlEle* doc2 = CMyXmlEle::NewL();

   437     TFileName name2(KReg1);

   438     doc2->ReadFileL(name2);

   439     CSenElement* policy2 = doc2->XMLDocL();

   440 

   441     CMyXmlEle* doc3 = CMyXmlEle::NewL();

   442     TFileName name3(KReg3);

   443     doc3->ReadFileL(name3);

   444     CSenElement* policy3 = doc3->XMLDocL();

   445     

   446      TPtrC8 p1(KID1);

   447      TPtrC8 p2(KID2);

   448      TPtrC8 p3(KID3);

   449     

   450     registry->RegisterPolicy(p1,policy2);

   451 

   452     

   453      CSenElement* ele2 = registry->LookupPolicy(p1);

   454      TL(ele2 != (CSenElement*)NULL);

   455      CSenElement* ele3 = registry->LookupPolicy(p2);

   456      TL(ele3 == (CSenElement*)NULL);

   457 

   458     registry->RegisterPolicy(p2,policy3);

   459 

   460      CSenElement* ele2_1 = registry->LookupPolicy(p1);

   461      TL(ele2_1 != (CSenElement*)NULL);

   462      CSenElement* ele3_1 = registry->LookupPolicy(p2);

   463      TL(ele3_1 != (CSenElement*)NULL);

   464      

   465           

   466      __ASSERT_ALWAYS_NO_LEAVE(delete registry);

   467      registry = NULL;

   468      delete doc2;

   469      delete doc3;

   470      return KErrNone;

   471     }

   472 

   473 TInt CwsPolicyTester::MT_CPolicyRegistry_UnregisterPolicyL( CStifItemParser& aItem  )

   474     {

   475    CPolicyRegistry* registry = CPolicyRegistry::NewL();

   476     TL(registry != (CPolicyRegistry*)NULL);

   477          

   478     CMyXmlEle* doc1 = CMyXmlEle::NewL();

   479     TFileName name(KReg1);

   480     doc1->ReadFileL(name);

   481     CSenElement* policy = doc1->XMLDocL();

   482     

   483     registry->PopulateRegistryL(policy);  //codescannerwarnings

   484      

   485      TPtrC8 p1(KID1);

   486      TPtrC8 p2(KID2);

   487      TPtrC8 p3(KID3);

   488      

   489      CSenElement* ele1 = registry->LookupPolicy(p1);

   490      TL(ele1 != (CSenElement*)NULL);

   491      CSenElement* ele2 = registry->LookupPolicy(p2);

   492      TL(ele2 != (CSenElement*)NULL);

   493      registry->UnregisterPolicy(p2);

   494      ele1 = NULL;

   495      ele2 = NULL;

   496 

   497      ele1 = registry->LookupPolicy(p1);

   498      TL(ele1 != (CSenElement*)NULL);

   499      ele2 = registry->LookupPolicy(p2);

   500      TL(ele2 == (CSenElement*)NULL);

   501      registry->UnregisterPolicy(p1);

   502      

   503      ele1 = NULL;

   504      ele2 = NULL;

   505      ele1 = registry->LookupPolicy(p1);

   506      TL(ele1 == (CSenElement*)NULL);

   507      ele2 = registry->LookupPolicy(p2);

   508      TL(ele2 == (CSenElement*)NULL);

   509 

   510           

   511      __ASSERT_ALWAYS_NO_LEAVE(delete registry);

   512      registry = NULL;

   513      delete doc1;

   514      return KErrNone;

   515     }

   516 

   517 TInt CwsPolicyTester::MT_CPolicyRegistry_PopulateRegistryL( CStifItemParser& aItem  )

   518     {

   519     

   520     CPolicyRegistry* registry = CPolicyRegistry::NewL();

   521     TL(registry != (CPolicyRegistry*)NULL);

   522          

   523     CMyXmlEle* doc1 = CMyXmlEle::NewL();

   524     TFileName name(KReg1);

   525     doc1->ReadFileL(name);

   526     CSenElement* policy = doc1->XMLDocL();

   527     

   528     registry->PopulateRegistryL(policy);  //codescannerwarnings

   529      

   530      TPtrC8 p1(KID1);

   531      TPtrC8 p2(KID2);

   532      TPtrC8 p3(KID3);

   533      

   534      CSenElement* ele1 = registry->LookupPolicy(p1);

   535      TL(ele1 != (CSenElement*)NULL);

   536      CSenElement* ele2 = registry->LookupPolicy(p2);

   537      TL(ele2 != (CSenElement*)NULL);

   538      CSenElement* ele3 = registry->LookupPolicy(p3);

   539      TL(ele3 == (CSenElement*)NULL);

   540           

   541      __ASSERT_ALWAYS_NO_LEAVE(delete registry);

   542      registry = NULL;

   543      delete doc1;

   544      return KErrNone;

   545     }

   546 

   547 TInt CwsPolicyTester::MT_CPolicyRegistry_ResetRegistryL( CStifItemParser& aItem  )

   548     {

   549     

   550     CPolicyRegistry* registry = CPolicyRegistry::NewL();

   551     TL(registry != (CPolicyRegistry*)NULL);

   552     

   553     CMyXmlEle* doc1 = CMyXmlEle::NewL();

   554     TFileName name(KReg1);

   555     doc1->ReadFileL(name);

   556     CSenElement* policy = doc1->XMLDocL();

   557     

   558     registry->PopulateRegistryL(policy);  //codescannerwarnings

   559      

   560      TPtrC8 p1(KID1);

   561      TPtrC8 p2(KID2);

   562           

   563      CSenElement* ele1 = registry->LookupPolicy(p1);

   564      TL(ele1 != (CSenElement*)NULL);

   565      CSenElement* ele2 = registry->LookupPolicy(p2);

   566      TL(ele2 != (CSenElement*)NULL);

   567      

   568      registry->ResetRegistry();

   569      

   570      CSenElement* ele3 = registry->LookupPolicy(p1);

   571      TL(ele3 == (CSenElement*)NULL);

   572      CSenElement* ele4 = registry->LookupPolicy(p2);

   573      TL(ele4 == (CSenElement*)NULL);

   574           

   575      __ASSERT_ALWAYS_NO_LEAVE(delete registry);

   576      registry = NULL;

   577      delete doc1;

   578      return KErrNone;

   579     }

   580 

   581 TInt CwsPolicyTester::MT_CWSPolicy_NewLL( CStifItemParser& aItem  )

   582     {

   583     CWSPolicy* xmlPolicy = CWSPolicy::NewL();

   584     LOCAL_ASSERT(xmlPolicy);

   585 

   586     __ASSERT_ALWAYS_NO_LEAVE(delete xmlPolicy);

   587     xmlPolicy = NULL;

   588     return KErrNone;

   589     }

   590 

   591 TInt CwsPolicyTester::MT_CWSPolicy_NewLCL( CStifItemParser& aItem  )

   592     {

   593     CWSPolicy* xmlPolicy = CWSPolicy::NewLC(); 

   594     LOCAL_ASSERT(xmlPolicy);

   595     CleanupStack::Pop();

   596     __ASSERT_ALWAYS_NO_LEAVE(delete xmlPolicy);

   597     xmlPolicy = NULL;

   598     return KErrNone;

   599     }

   600 

   601 TInt CwsPolicyTester::MT_CWSPolicy_NewL_1L( CStifItemParser& aItem  )

   602     {

   603     TPtrC8 name(KPolicyName);

   604     TPtrC8 policy(KPolicy);

   605     CWSPolicy* xmlPolicy = CWSPolicy::NewL(name, policy);

   606     LOCAL_ASSERT(xmlPolicy);

   607 

   608     __ASSERT_ALWAYS_NO_LEAVE(delete xmlPolicy);

   609     xmlPolicy = NULL;

   610     return KErrNone;

   611     }

   612 

   613 TInt CwsPolicyTester::MT_CWSPolicy_NewLC_1L( CStifItemParser& aItem  )

   614     {

   615     TPtrC8 name(KPolicyName);

   616     TPtrC8 policy(KPolicy);

   617     CWSPolicy* xmlPolicy = CWSPolicy::NewLC(name, policy); //KText

   618     LOCAL_ASSERT(xmlPolicy);

   619     CleanupStack::Pop();

   620     __ASSERT_ALWAYS_NO_LEAVE(delete xmlPolicy);

   621     xmlPolicy = NULL;

   622     return KErrNone;

   623     }

   624 

   625 void CwsPolicyTester::DoNormalizePolicyL(TFileName aFile, TInt count)

   626 {

   627     CMyXmlEle* doc1 = CMyXmlEle::NewL();

   628     TFileName name1(aFile);

   629     doc1->ReadFileL(name1);

   630     CSenElement* policy1 = doc1->XMLDocL();

   631     

   632     HBufC8* policyBuf = policy1->AsXmlL();

   633     

   634     TPtrC8 name(CWSPolicyUtils::PolicyNameL(policy1));

   635     TPtrC8 policy(policyBuf->Des());

   636     

   637     CWSPolicy* xmlPolicy = CWSPolicy::NewL(name, policy); //KText

   638     

   639     //LOCAL_ASSERT(xmlPolicy->NormalizePolicyL(NULL) == TRUE);

   640     HBufC8* xmlBuffer = xmlPolicy->PolicyAsXmlL();

   641     

   642     CleanupStack::PushL( xmlBuffer );

   643     TPtr8 ptr = xmlBuffer->Des();

   644     

   645     if (ptr.Length() > 0)

   646         RDebug::Print( _L( " xmlBuffer [%S]"),&ptr);

   647     else

   648         RDebug::Print( _L( " xmlBuffer empty"));

   649     

   650     switch (count)

   651     {

   652         case (3):

   653         {

   654             CMyXmlEle* doc3 = CMyXmlEle::NewL();

   655             TFileName name3(KPolicy3Ref);

   656             doc3->ReadFileL(name3);

   657             CSenElement* policy3 = doc3->XMLDocL();

   658             HBufC8* policyBuf3 = policy3->AsXmlL();

   659             TPtr8 policy3Ptr = policyBuf3->Des();

   660             TL(ptr == policy3Ptr);

   661             delete policyBuf3;

   662             delete doc3;

   663             break;            

   664         }

   665         case 4:

   666         {

   667             CMyXmlEle* doc4 = CMyXmlEle::NewL();

   668             TFileName name4(KPolicy4Ref);

   669             doc4->ReadFileL(name4);

   670             CSenElement* policy4 = doc4->XMLDocL();

   671             HBufC8* policyBuf4 = policy4->AsXmlL();

   672             TPtr8 policy4Ptr = policyBuf4->Des();

   673             TL(ptr == policy4Ptr);

   674             delete policyBuf4;

   675             delete doc4;

   676             break;            

   677         }

   678         case 5:

   679         {

   680             CMyXmlEle* doc5 = CMyXmlEle::NewL();

   681             TFileName name5(KPolicy5Ref);

   682             doc5->ReadFileL(name5);

   683             CSenElement* policy5 = doc5->XMLDocL();

   684             HBufC8* policyBuf5 = policy5->AsXmlL();

   685             TPtr8 policy5Ptr = policyBuf5->Des();

   686             TL(ptr == policy5Ptr);

   687             delete policyBuf5;

   688             delete doc5;

   689             break;            

   690         }

   691 

   692     }

   693 

   694     CleanupStack::PopAndDestroy();

   695     

   696     __ASSERT_ALWAYS_NO_LEAVE(delete xmlPolicy);

   697     xmlPolicy = NULL;

   698     delete policyBuf;

   699     delete doc1;

   700     

   701 }

   702 TInt CwsPolicyTester::MT_CWSPolicy_NormalizePolicyLL( CStifItemParser& aItem  )

   703     {

   704     

   705     TBuf<255> file;

   706     _LIT( KFileName, "c:\\testing\\data\\Policy%d.xml");

   707     for(TInt i = 3; i< 6 ; i++)

   708     {

   709         file.Format(KFileName, i);

   710         RDebug::Print( _L( "NormalizePolicyL: File [%S]"),&file);

   711         DoNormalizePolicyL(file, i);

   712     }

   713     return KErrNone;

   714 

   715     }

   716     

   717 void CwsPolicyTester::TestIntersectPolicyL(TInt i, TInt j)

   718 {

   719 

   720     _LIT(KFile, "c:\\testing\\data\\Policy%d.xml"); //BigSecurityPolicy3.xml");

   721     _LIT( KresultFile, "c:\\testing\\data\\inter%d-%d.xml");

   722     TBuf<50> file1;

   723     file1.Format(KFile, i);

   724     TBuf<50> file2;

   725     file2.Format(KFile, j);

   726 //Read first file

   727     CMyXmlEle* doc1 = CMyXmlEle::NewL();

   728     TFileName name1(file1);

   729     doc1->ReadFileL(name1);

   730     CSenElement* policy1 = doc1->XMLDocL();

   731     HBufC8* policyBuf1 = policy1->AsXmlL();

   732     TPtrC8 uri1(CWSPolicyUtils::PolicyUriL(policy1));

   733     TPtrC8 policyPtr1(policyBuf1->Des());

   734     

   735     CWSPolicy* xmlPolicy1 = CWSPolicy::NewL(uri1, policyPtr1); //KText

   736     xmlPolicy1->NormalizePolicyL(NULL);

   737     CSenElement* normPolicy1 = xmlPolicy1->PolicyL(); //codescannerwarnings

   738     delete policyBuf1;

   739     delete doc1;

   740 

   741 //Read second file  

   742     CMyXmlEle* doc2 = CMyXmlEle::NewL();

   743     TFileName name2(file2);

   744     doc2->ReadFileL(name2);

   745     CSenElement* policy2 = doc2->XMLDocL();

   746     HBufC8* policyBuf2 = policy2->AsXmlL();

   747     TPtrC8 uri2(CWSPolicyUtils::PolicyUriL(policy2));

   748     TPtrC8 policyPtr2(policyBuf2->Des());

   749     

   750     CWSPolicy* xmlPolicy2 = CWSPolicy::NewL(uri2, policyPtr2); //KText

   751     xmlPolicy2->NormalizePolicyL(NULL);

   752     CSenElement* normPolicy2 = xmlPolicy2->PolicyL(); //codescannerwarnings

   753     delete policyBuf2;

   754     delete doc2;

   755 

   756 ////Intersecting

   757 

   758     CWSPolicy* mergedPolicy = xmlPolicy2->IntersectPolicyL(xmlPolicy1);

   759     if(mergedPolicy)

   760     {

   761 

   762         TBuf<50> resfile;

   763         resfile.Format(KresultFile, i, j);

   764 

   765         CSenElement* intpolicy = mergedPolicy->PolicyL(); //codescannerwarnings

   766         HBufC8* xmlBuffer = intpolicy->AsXmlL();       

   767         CleanupStack::PushL( xmlBuffer );

   768         TPtr8 ptr = xmlBuffer->Des();

   769 

   770         CMyXmlEle* doc3 = CMyXmlEle::NewL();

   771         TFileName name3(resfile);

   772         doc3->ReadFileL(name3);

   773         CSenElement* policy3 = doc3->XMLDocL();

   774         HBufC8* policyBuf3 = policy3->AsXmlL();

   775         TPtr8 policy3Ptr = policyBuf3->Des();

   776         TL(ptr.Length() == policy3Ptr.Length());

   777         delete policyBuf3;

   778         delete doc3;

   779         

   780         CleanupStack::PopAndDestroy(xmlBuffer);

   781     }

   782     delete mergedPolicy;

   783     delete xmlPolicy2;  

   784     delete xmlPolicy1;    

   785 }

   786 TInt CwsPolicyTester::MT_CWSPolicy_IntersectPolicyLL( CStifItemParser& aItem  )

   787     {

   788     

   789     TInt start = 3;

   790     TInt last = 5;

   791 

   792     for (TInt i = start; i < last+1; i++)

   793     {

   794         for (TInt j = start; j < last+1; j++)

   795         {

   796              TestIntersectPolicyL(i , j) ;  

   797         }

   798         

   799     }

   800     return KErrNone;

   801     }

   802 

   803 void TestMergePolicyL(TInt i, TInt j)

   804 {

   805 

   806     _LIT(KFile, "c:\\testing\\data\\Policy%d.xml"); //BigSecurityPolicy3.xml");

   807     _LIT( KresultFile, "c:\\testing\\data\\merge%d-%d.xml");

   808     TBuf<50> file1;

   809     file1.Format(KFile, i);

   810     TBuf<50> file2;

   811     file2.Format(KFile, j);

   812 //Read first file

   813     CMyXmlEle* doc1 = CMyXmlEle::NewL();

   814     TFileName name1(file1);

   815     doc1->ReadFileL(name1);

   816     CSenElement* policy1 = doc1->XMLDocL();

   817     HBufC8* policyBuf1 = policy1->AsXmlL();

   818     TPtrC8 uri1(CWSPolicyUtils::PolicyUriL(policy1));

   819     TPtrC8 policyPtr1(policyBuf1->Des());

   820     

   821     CWSPolicy* xmlPolicy1 = CWSPolicy::NewL(uri1, policyPtr1); //KText

   822     xmlPolicy1->NormalizePolicyL(NULL);

   823     CSenElement* normPolicy1 = xmlPolicy1->PolicyL(); //codescannerwarnings

   824     delete policyBuf1;

   825     delete doc1;

   826 

   827 //Read second file  

   828     CMyXmlEle* doc2 = CMyXmlEle::NewL();

   829     TFileName name2(file2);

   830     doc2->ReadFileL(name2);

   831     CSenElement* policy2 = doc2->XMLDocL();

   832     HBufC8* policyBuf2 = policy2->AsXmlL();

   833     TPtrC8 uri2(CWSPolicyUtils::PolicyUriL(policy2));

   834     TPtrC8 policyPtr2(policyBuf2->Des());

   835     

   836     CWSPolicy* xmlPolicy2 = CWSPolicy::NewL(uri2, policyPtr2); //KText

   837     xmlPolicy2->NormalizePolicyL(NULL);

   838     CSenElement* normPolicy2 = xmlPolicy2->PolicyL(); //codescannerwarnings

   839     delete policyBuf2;

   840     delete doc2;

   841 

   842 ////Intersecting

   843 

   844     CWSPolicy* mergedPolicy = xmlPolicy2->MergePolicyL(xmlPolicy1);

   845     if(mergedPolicy)

   846     {

   847 

   848         TBuf<50> resfile;

   849         resfile.Format(KresultFile, i, j);

   850 

   851         CSenElement* intpolicy = mergedPolicy->PolicyL(); //codescannerwarnings

   852         HBufC8* xmlBuffer = intpolicy->AsXmlL();       

   853         CleanupStack::PushL( xmlBuffer );

   854         TPtr8 ptr = xmlBuffer->Des();

   855 

   856         CMyXmlEle* doc3 = CMyXmlEle::NewL();

   857         TFileName name3(resfile);

   858         doc3->ReadFileL(name3);

   859         CSenElement* policy3 = doc3->XMLDocL();

   860         HBufC8* policyBuf3 = policy3->AsXmlL();

   861         TPtr8 policy3Ptr = policyBuf3->Des();

   862      //   TL(ptr.Length() == policy3Ptr.Length());

   863         delete policyBuf3;

   864         delete doc3;

   865         

   866         CleanupStack::PopAndDestroy(xmlBuffer);

   867     }

   868     delete mergedPolicy;

   869     delete xmlPolicy2;  

   870     delete xmlPolicy1;    

   871     

   872 }

   873 TInt CwsPolicyTester::MT_CWSPolicy_MergePolicyLL( CStifItemParser& aItem  )

   874     {

   875     TInt start = 3;

   876     TInt last = 5;

   877 

   878     for (TInt i = start; i < last+1; i++)

   879     {

   880         for (TInt j = start; j < last+1; j++)

   881         {

   882              TestMergePolicyL(i , j) ;  

   883         }

   884         

   885     }

   886     return KErrNone;

   887     }

   888 

   889 TInt CwsPolicyTester::MT_CWSPolicy_NormalizedL( CStifItemParser& aItem  )

   890     {

   891     

   892     TPtrC8 name(KPolicyName);

   893     TPtrC8 policy(KPolicy);

   894     CWSPolicy* xmlPolicy = CWSPolicy::NewL(name, policy); //KText

   895    

   896     TL( xmlPolicy->Normalized() == FALSE);

   897     LOCAL_ASSERT(xmlPolicy->NormalizePolicyL(NULL) == TRUE);

   898     TL( xmlPolicy->Normalized() == TRUE);     

   899     

   900     __ASSERT_ALWAYS_NO_LEAVE(delete xmlPolicy);

   901     xmlPolicy = NULL;

   902     return KErrNone;

   903     }

   904 

   905 TInt CwsPolicyTester::MT_CWSPolicy_Policy( CStifItemParser& aItem )

   906     {

   907     TPtrC8 name(KPolicyName);

   908     TPtrC8 policy(KPolicy);

   909     CWSPolicy* xmlPolicy = CWSPolicy::NewL(name, policy); //KText

   910 

   911     CSenElement* origPolicy = xmlPolicy->PolicyL();     //codescannerwarnings

   912     TL( origPolicy != (CSenElement*)NULL);     

   913 

   914     __ASSERT_ALWAYS_NO_LEAVE(delete xmlPolicy);

   915     xmlPolicy = NULL;

   916     return KErrNone;

   917     }

   918 

   919 TInt CwsPolicyTester::MT_CWSPolicy_NormalizedAsXmlLL( CStifItemParser& aItem  )

   920     {

   921     TPtrC8 name(KPolicyName);

   922     TPtrC8 policy(KPolicy);

   923     

   924     CWSPolicy* xmlPolicy = CWSPolicy::NewL(name, policy); //KText

   925     

   926     LOCAL_ASSERT(xmlPolicy->NormalizePolicyL(NULL) == TRUE);

   927     

   928     CSenElement* normPolicy = xmlPolicy->PolicyL();         //codescannerwarnings

   929     HBufC8* xmlBuffer = normPolicy->AsXmlL();    

   930     CleanupStack::PushL( xmlBuffer );

   931     

   932     TInt data = xmlBuffer->Length();

   933     TInt ref_data(KRefLength);

   934     

   935     TPtr8 ptr = xmlBuffer->Des();

   936     if (ptr.Length() > 0)

   937         RDebug::Print( _L( "xmlBuffer [%S]"),&ptr);

   938     else

   939         RDebug::Print( _L( "xmlBuffer empty"));

   940     

   941   

   942     TL(data == ref_data);

   943     

   944     CleanupStack::PopAndDestroy(xmlBuffer);

   945 

   946     

   947     __ASSERT_ALWAYS_NO_LEAVE(delete xmlPolicy);

   948     

   949     xmlPolicy = NULL;

   950     return KErrNone;

   951     }

   952 

   953 TInt CwsPolicyTester::MT_CWSPolicy_NormalizedPolicy( CStifItemParser& aItem  )

   954     {

   955     TPtrC8 name(KPolicyName);

   956     TPtrC8 policy(KPolicy);

   957     CWSPolicy* xmlPolicy = CWSPolicy::NewL(name, policy); //KText

   958 

   959     TL( xmlPolicy->PolicyL() != (CSenElement*)NULL);      //codescannerwarnings

   960     LOCAL_ASSERT(xmlPolicy->NormalizePolicyL(NULL) == TRUE);

   961     TL( xmlPolicy->PolicyL() != (CSenElement*)NULL);     //codescannerwarnings

   962 

   963     __ASSERT_ALWAYS_NO_LEAVE(delete xmlPolicy);

   964     xmlPolicy = NULL;

   965     return KErrNone;

   966     }

   967 

   968 TInt CwsPolicyTester::MT_CWSPolicy_IsExpiredPolicyL( CStifItemParser& aItem  )

   969     {

   970 

   971     CMyXmlEle* doc1 = CMyXmlEle::NewL();

   972     TFileName name1(KExpPolicy1);

   973     doc1->ReadFileL(name1);

   974     

   975     CSenElement* policy1 = doc1->XMLDocL();

   976     TPtrC8 name(CWSPolicyUtils::PolicyNameL(policy1));

   977 

   978     HBufC8* policyBuf = policy1->AsXmlL();

   979     CleanupStack::PushL( policyBuf );

   980     TPtrC8 policy(policyBuf->Des());

   981     

   982     CWSPolicy* xmlPolicy = CWSPolicy::NewL(name, policy);

   983     

   984     CleanupStack::PopAndDestroy();

   985     LOCAL_ASSERT(xmlPolicy);

   986     TBool result = EFalse;

   987     result = xmlPolicy->IsExpiredPolicyL(); //codescannerwarnings

   988     TL(result == EFalse);

   989     __ASSERT_ALWAYS_NO_LEAVE(delete xmlPolicy);

   990     xmlPolicy = NULL;

   991     delete doc1;

   992     return KErrNone;

   993     }

   994 

   995 TInt CwsPolicyTester::MT_CSenInternalWsPolicy_NewLL( CStifItemParser& aItem )

   996 {

   997     CTestInternalWSPolicy* pInternalPolicy = CTestInternalWSPolicy::NewL();

   998     LOCAL_ASSERT( pInternalPolicy );

   999     delete pInternalPolicy ;

  1000     pInternalPolicy = NULL;

  1001     return KErrNone;

  1002 }

  1003 

  1004 TInt CwsPolicyTester::MT_CSenInternalWsPolicy_NewLCL( CStifItemParser& aItem )

  1005 {

  1006     CTestInternalWSPolicy* pInternalPolicy = CTestInternalWSPolicy::NewLC();

  1007     LOCAL_ASSERT( pInternalPolicy );

  1008     CleanupStack::Pop(pInternalPolicy);

  1009     delete pInternalPolicy ;

  1010     pInternalPolicy = NULL;

  1011     return KErrNone;

  1012 }

  1013 

  1014 TInt CwsPolicyTester::MT_CSenInternalWsPolicy_NewL_1L( CStifItemParser& aItem )

  1015 {

  1016   RStringPool stringPool;

  1017     stringPool.OpenL();

  1018     CleanupClosePushL(stringPool);

  1019     

  1020     RString nsUriRString        = stringPool.OpenStringL(_L8("nsuri"));

  1021     CleanupClosePushL(nsUriRString);

  1022     RString nsPrefixRString     = stringPool.OpenStringL(_L8("pr"));

  1023     CleanupClosePushL(nsPrefixRString);

  1024     RString localNameRString    = stringPool.OpenStringL(_L8("LocalName"));

  1025     CleanupClosePushL(localNameRString);

  1026     RString valueRString        = stringPool.OpenStringL(_L8("Value"));

  1027     CleanupClosePushL(valueRString);

  1028     

  1029     RAttribute attribute;

  1030     attribute.Open(nsUriRString, nsPrefixRString, localNameRString, 

  1031                    valueRString);

  1032     CleanupStack::Pop(4); 

  1033     CleanupClosePushL(attribute);

  1034 

  1035     RAttributeArray attrArray;

  1036     attrArray.AppendL(attribute);

  1037     CleanupClosePushL(attrArray); 

  1038   

  1039     CTestInternalWSPolicy* pInternalPolicy = CTestInternalWSPolicy::NewL(_L8("ansuri"),_L8("Nokia"),_L8("a:Nokia"),attrArray);

  1040     LOCAL_ASSERT( pInternalPolicy );

  1041     CleanupStack::PopAndDestroy(&attrArray);

  1042     CleanupStack::PopAndDestroy(&attribute);

  1043     CleanupStack::PopAndDestroy(&stringPool);

  1044     delete pInternalPolicy ;

  1045     pInternalPolicy = NULL;

  1046     return KErrNone;

  1047 }

  1048 

  1049 TInt CwsPolicyTester::MT_CSenInternalWsPolicy_NewLC_1L( CStifItemParser& aItem )

  1050 {

  1051     RStringPool stringPool;

  1052     stringPool.OpenL();

  1053     CleanupClosePushL(stringPool);

  1054     

  1055     RString nsUriRString        = stringPool.OpenStringL(_L8("nsuri"));

  1056     CleanupClosePushL(nsUriRString);

  1057     RString nsPrefixRString     = stringPool.OpenStringL(_L8("pr"));

  1058     CleanupClosePushL(nsPrefixRString);

  1059     RString localNameRString    = stringPool.OpenStringL(_L8("LocalName"));

  1060     CleanupClosePushL(localNameRString);

  1061     RString valueRString        = stringPool.OpenStringL(_L8("Value"));

  1062     CleanupClosePushL(valueRString);

  1063     

  1064     RAttribute attribute;

  1065     attribute.Open(nsUriRString, nsPrefixRString, localNameRString, 

  1066                    valueRString);

  1067     CleanupStack::Pop(4); 

  1068     CleanupClosePushL(attribute);

  1069 

  1070     RAttributeArray attrArray;

  1071     attrArray.AppendL(attribute);

  1072     CleanupClosePushL(attrArray); 

  1073   

  1074     CTestInternalWSPolicy* pInternalPolicy = CTestInternalWSPolicy::NewLC(_L8("ansuri"),_L8("Nokia"),_L8("a:Nokia"),attrArray);

  1075     LOCAL_ASSERT( pInternalPolicy );

  1076     CleanupStack::Pop(pInternalPolicy);

  1077     CleanupStack::PopAndDestroy(&attrArray);

  1078     CleanupStack::PopAndDestroy(&attribute);

  1079     CleanupStack::PopAndDestroy(&stringPool);

  1080     delete pInternalPolicy ;

  1081     pInternalPolicy = NULL;

  1082     return KErrNone;

  1083 }

  1084 

  1085 TInt CwsPolicyTester::MT_CSenInternalWsPolicy_NewL_2L( CStifItemParser& aItem )

  1086 {

  1087     RStringPool stringPool;

  1088     stringPool.OpenL();

  1089     CleanupClosePushL(stringPool);

  1090     

  1091     RString nsUriRString        = stringPool.OpenStringL(_L8("nsuri"));

  1092     CleanupClosePushL(nsUriRString);

  1093     RString nsPrefixRString     = stringPool.OpenStringL(_L8("pr"));

  1094     CleanupClosePushL(nsPrefixRString);

  1095     RString localNameRString    = stringPool.OpenStringL(_L8("LocalName"));

  1096     CleanupClosePushL(localNameRString);

  1097     RString valueRString        = stringPool.OpenStringL(_L8("Value"));

  1098     CleanupClosePushL(valueRString);

  1099     

  1100     RAttribute attribute;

  1101     attribute.Open(nsUriRString, nsPrefixRString, localNameRString, 

  1102                    valueRString);

  1103     CleanupStack::Pop(4); 

  1104     CleanupClosePushL(attribute);

  1105 

  1106     RAttributeArray attrArray;

  1107     attrArray.AppendL(attribute);

  1108     CleanupClosePushL(attrArray); 

  1109     

  1110     CSenElement* pParentElement = CSenBaseElement::NewL(_L8("Parent"));

  1111     CleanupStack::PushL(pParentElement);

  1112     CTestInternalWSPolicy* pInternalPolicy = CTestInternalWSPolicy::NewL(_L8("ansuri"),_L8("Nokia"),_L8("a:Nokia"),attrArray,*pParentElement);

  1113     LOCAL_ASSERT( pInternalPolicy );

  1114     CleanupStack::PopAndDestroy(pParentElement);

  1115     CleanupStack::PopAndDestroy(&attrArray);

  1116     CleanupStack::PopAndDestroy(&attribute);

  1117     CleanupStack::PopAndDestroy(&stringPool);

  1118     delete pInternalPolicy ;

  1119     pInternalPolicy = NULL;

  1120     return KErrNone;

  1121 }

  1122 

  1123 TInt CwsPolicyTester::MT_CSenInternalWsPolicy_NewLC_2L( CStifItemParser& aItem )

  1124 {

  1125     RStringPool stringPool;

  1126     stringPool.OpenL();

  1127     CleanupClosePushL(stringPool);

  1128     

  1129     RString nsUriRString        = stringPool.OpenStringL(_L8("nsuri"));

  1130     CleanupClosePushL(nsUriRString);

  1131     RString nsPrefixRString     = stringPool.OpenStringL(_L8("pr"));

  1132     CleanupClosePushL(nsPrefixRString);

  1133     RString localNameRString    = stringPool.OpenStringL(_L8("LocalName"));

  1134     CleanupClosePushL(localNameRString);

  1135     RString valueRString        = stringPool.OpenStringL(_L8("Value"));