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 

    20 

    21 

    22 

    23 

    24 #include <e32std.h>

    25 #include <f32file.h>

    26 #include "testinternalwspolicy.h"

    27 

    28 CTestInternalWSPolicy* CTestInternalWSPolicy::NewL()

    29 {

    30 	return((CTestInternalWSPolicy*)CSenInternalWsPolicy::NewL());

    31 }

    32 

    33 CTestInternalWSPolicy* CTestInternalWSPolicy::NewLC()

    34 {

    35 	return((CTestInternalWSPolicy*)CSenInternalWsPolicy::NewLC());

    36 }

    37 

    38 CTestInternalWSPolicy* CTestInternalWSPolicy::NewL(const TDesC8& aNsUri,

    39                                             const TDesC8& aLocalName,

    40                                             const TDesC8& aQName,

    41                                             const RAttributeArray& aAttributes)

    42 {

    43 	return((CTestInternalWSPolicy*)CSenInternalWsPolicy::NewL(aNsUri,aLocalName,aQName,aAttributes));

    44 }

    45 

    46 CTestInternalWSPolicy* CTestInternalWSPolicy::NewLC(const TDesC8& aNsUri,

    47                                             const TDesC8& aLocalName,

    48                                             const TDesC8& aQName,

    49                                             const RAttributeArray& aAttributes)

    50 {

    51 	return((CTestInternalWSPolicy*)CSenInternalWsPolicy::NewLC(aNsUri,aLocalName,aQName,aAttributes));

    52 }

    53 

    54 CTestInternalWSPolicy* CTestInternalWSPolicy::NewL(const TDesC8& aNsUri,

    55                                                            const TDesC8& aLocalName,

    56                                                            const TDesC8& aQName,

    57                                                            const RAttributeArray& aAttributes,

    58                                                            CSenElement& aParent)

    59 {

    60 	return((CTestInternalWSPolicy*)CSenInternalWsPolicy::NewL(aNsUri,aLocalName,aQName,aAttributes,aParent));

    61 }                                                           

    62 

    63 CTestInternalWSPolicy* CTestInternalWSPolicy::NewLC(const TDesC8& aNsUri,

    64                                                            const TDesC8& aLocalName,

    65                                                            const TDesC8& aQName,

    66                                                            const RAttributeArray& aAttributes,

    67                                                            CSenElement& aParent)

    68 {

    69 	return((CTestInternalWSPolicy*)CSenInternalWsPolicy::NewLC(aNsUri,aLocalName,aQName,aAttributes,aParent));

    70 }

    71     

    72 CTestInternalWSPolicy::~CTestInternalWSPolicy()

    73 {

    74 	

    75 }

    76 

    77 TBool CTestInternalWSPolicy::IsApplicableL(const TDesC8& aPolicyEndpoint)

    78 {

    79 	return(CSenInternalWsPolicy::IsApplicableL(aPolicyEndpoint));

    80 }

    81 

    82 TBool CTestInternalWSPolicy::IsApplicableL(CSenInternalWsPolicy* aInternalPolicy)

    83 {

    84 	return(CSenInternalWsPolicy::IsApplicableL(aInternalPolicy));

    85 }

    86 

    87 TBool CTestInternalWSPolicy::IsApplicableL(CSenWSDescription& aPattern)

    88 {

    89 	return(CSenInternalWsPolicy::IsApplicableL(aPattern));

    90 }

    91 

    92 TBool CTestInternalWSPolicy::UpdateMetadataEndpointL(CSenInternalWsPolicy* aInternalPolicy, TInt& aExist)

    93 {

    94 	return(CSenInternalWsPolicy::UpdateMetadataEndpointL(aInternalPolicy,aExist));

    95 }

    96 

    97 TInt CTestInternalWSPolicy::AddMetadataPolicyL(CSenElement* aElement)

    98 {

    99 	return(CSenInternalWsPolicy::AddMetadataPolicyL(aElement));

   100 }

   101 TInt CTestInternalWSPolicy::RemoveMetadataPolicyL(const TDesC8& aUri)

   102 {

   103 	return(CSenInternalWsPolicy::RemoveMetadataPolicyL(aUri));

   104 }

   105 CSenElement* CTestInternalWSPolicy::WsPolicyByUriL(const TDesC8& aUri)

   106 {

   107 	return(CSenInternalWsPolicy::WsPolicyByUriL(aUri));

   108 }

   109 CSenElement* CTestInternalWSPolicy::WsPolicyByName(const TDesC8& aName)

   110 {

   111 	return(CSenInternalWsPolicy::WsPolicyByName(aName));

   112 }

   113 TTime CTestInternalWSPolicy::ValidUntilL(const TDesC8& aUri)

   114 {

   115 	return(CSenInternalWsPolicy::ValidUntilL(aUri));

   116 }

   117     

   118 

   119 ////////////////////////////////////////////////////////////////////////

   120 /////////////////////CTestWSPolicyIdentifier///////////////////////////

   121 //////////////////////////////////////////////////////////////////////

   122 

   123 

   124 CTestWSPolicyIdentifier* CTestWSPolicyIdentifier::NewL()

   125 {

   126 	return ((CTestWSPolicyIdentifier*)CSenWSPolicyIdentifier::NewL());

   127 }

   128 

   129 CTestWSPolicyIdentifier* CTestWSPolicyIdentifier::NewLC()

   130 {

   131 	return ((CTestWSPolicyIdentifier*)CSenWSPolicyIdentifier::NewLC());

   132 }

   133 	

   134 CTestWSPolicyIdentifier* CTestWSPolicyIdentifier::NewL(const TDesC8& aNsUri,

   135                                          				const TDesC8& aLocalName,

   136                                          				const TDesC8& aQName,

   137                                          				const RAttributeArray& aAttributes)

   138 {

   139 	return ((CTestWSPolicyIdentifier*)CSenWSPolicyIdentifier::NewL(aNsUri,aLocalName,aQName,aAttributes));

   140 }

   141 

   142 CTestWSPolicyIdentifier* CTestWSPolicyIdentifier::NewLC(const TDesC8& aNsUri,

   143                                          				const TDesC8& aLocalName,

   144                                          				const TDesC8& aQName,

   145                                          				const RAttributeArray& aAttributes)

   146 {

   147 	return ((CTestWSPolicyIdentifier*)CSenWSPolicyIdentifier::NewLC(aNsUri,aLocalName,aQName,aAttributes));

   148 }

   149 	

   150 CTestWSPolicyIdentifier* CTestWSPolicyIdentifier::NewL(const TDesC8& aNsUri,

   151                                          				const TDesC8& aLocalName,

   152                                          				const TDesC8& aQName,

   153                                          				const RAttributeArray& aAttributes,

   154                                          				CSenElement& aParent)

   155 {

   156 	return ((CTestWSPolicyIdentifier*)CSenWSPolicyIdentifier::NewL(aNsUri,aLocalName,aQName,aAttributes,aParent));

   157 }

   158 

   159 CTestWSPolicyIdentifier* CTestWSPolicyIdentifier::NewLC(const TDesC8& aNsUri,

   160                                          				const TDesC8& aLocalName,

   161                                          				const TDesC8& aQName,

   162                                          				const RAttributeArray& aAttributes,

   163                                          				CSenElement& aParent)

   164 {

   165 	return ((CTestWSPolicyIdentifier*)CSenWSPolicyIdentifier::NewLC(aNsUri,aLocalName,aQName,aAttributes,aParent));

   166 }

   167 

   168 TInt CTestWSPolicyIdentifier::SetPropertyL(const TDesC8& aName,const TDesC8& aValue)

   169 {

   170 	return(CSenWSPolicyProperties::SetPropertyL(aName,aValue));

   171 }

   172                                                          

   173 TInt CTestWSPolicyIdentifier::PropertyL(const TDesC8& aName, TPtrC8& aValue)

   174 {

   175 	return(CSenWSPolicyProperties::PropertyL(aName,aValue));

   176 }

   177 void CTestWSPolicyIdentifier::SetIdL(TInt aId)

   178 {

   179 	return(CSenWSPolicyIdentifier::SetIdL(aId));

   180 }

   181 TInt CTestWSPolicyIdentifier::IdL()

   182 {

   183 	return(CSenWSPolicyIdentifier::IdL());

   184 }

   185 

   186 TInt CTestWSPolicyIdentifier::AddMetadataEndpointL(CSenElement* aElement)

   187 {

   188 	return(CSenWSPolicyIdentifier::AddMetadataEndpointL(aElement));

   189 }

   190 

   191 TPtrC8 CTestWSPolicyIdentifier::MetadataEndpointL()

   192 {

   193 	return(CSenWSPolicyIdentifier::MetadataEndpointL());

   194 }

   195 

   196 CSenElement* CTestWSPolicyIdentifier::MetadataEndpointElementL()

   197 {

   198 	return(CSenWSPolicyIdentifier::MetadataEndpointElementL());

   199 }

   200 

   201 TPtrC8 CTestWSPolicyIdentifier::ElementAttribValueL(CSenElement* aElement, const TDesC8& aName)

   202 {

   203 	return(CSenWSPolicyIdentifier::ElementAttribValueL(aElement,aName));

   204 }

   205 

   206 TBool CTestWSPolicyIdentifier::HasAttributeL(CSenElement* aElement, const TDesC8& aName)

   207 {

   208 	return(CSenWSPolicyIdentifier::HasAttributeL(aElement,aName));

   209 }

   210 

   211 /////////////////////////////////////////////////////////////////////////////////

   212 /////////////////////////////CTestPolicyWriter///////////////////////////////////////////////////

   213 ////////////////////////////////////////////////////////////////////////////////

   214 

   215 CTestPolicyWriter* CTestPolicyWriter::NewL()

   216 {

   217 	return ((CTestPolicyWriter*)CWSPolicyWriter::NewL());

   218 }

   219 

   220 CTestPolicyWriter* CTestPolicyWriter::NewLC()

   221 {

   222 	return ((CTestPolicyWriter*)CWSPolicyWriter::NewLC());

   223 }

   224 void CTestPolicyWriter::WriteToFileAllL(CSenElement* aXml)

   225 {

   226 	return (CWSPolicyWriter::WriteToFileAllL(aXml));

   227 }

   228 void CTestPolicyWriter::WriteToFileAllL(TDesC8& aXml)

   229 {

   230 	return (CWSPolicyWriter::WriteToFileAllL(aXml));

   231 }

   232 HBufC8* CTestPolicyWriter::WriteAllAsXmlL(CPolicyAssertion* aPolicy)

   233 {

   234 //	return (CWSPolicyWriter::WriteAllAsXmlL(aPolicy));

   235 }

   236 /////////////////////////////////////////////////////////////////////////////////

   237 ///////////////////////////////CTestPolicyReader/////////////////////////////////////////////////

   238 ////////////////////////////////////////////////////////////////////////////////

   239 

   240 CTestPolicyReader* CTestPolicyReader::NewL()

   241 {

   242 	return ((CTestPolicyReader*)CWSPolicyReader::NewL());

   243 }

   244 

   245 CTestPolicyReader* CTestPolicyReader::NewLC()

   246 {

   247 	return ((CTestPolicyReader*)CWSPolicyReader::NewLC());

   248 }

   249 CPolicyAssertion* CTestPolicyReader::GetPolicyL(CSenElement* aPolicy)

   250 {

   251 	return (CWSPolicyReader::GetPolicyL(aPolicy));

   252 }

   253 

   254 /////////////////////////////////////////////////////////////////////////////////

   255 /////////////////////////////////CTestPolicyAssertion///////////////////////////////////////////////

   256 ////////////////////////////////////////////////////////////////////////////////

   257 

   258 CPolicyAssertion* CTestPolicyAssertion::NewL()

   259 {

   260 	return (CPolicyAssertion::NewL());

   261 }

   262 

   263 CTestPolicyAssertion* CTestPolicyAssertion::NewLC()

   264 {

   265 	return ((CTestPolicyAssertion*)CPolicyAssertion::NewLC());

   266 }