|
1 /* |
|
2 * Copyright (c) 2002-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: ?Description |
|
15 * |
|
16 */ |
|
17 |
|
18 |
|
19 // INCLUDE FILES |
|
20 #include <e32math.h> |
|
21 #include "SenServDescBCTest.h" |
|
22 #include <senxmlelement.h> |
|
23 |
|
24 // EXTERNAL DATA STRUCTURES |
|
25 //extern ?external_data; |
|
26 |
|
27 // EXTERNAL FUNCTION PROTOTYPES |
|
28 //extern ?external_function( ?arg_type,?arg_type ); |
|
29 |
|
30 // CONSTANTS |
|
31 //const ?type ?constant_var = ?constant; |
|
32 |
|
33 // MACROS |
|
34 #define LOCAL_ASSERT(expression) {if(!(expression)){return KErrArgument;}} |
|
35 |
|
36 //#define ?macro ?macro_def |
|
37 |
|
38 // LOCAL CONSTANTS AND MACROS |
|
39 //const ?type ?constant_var = ?constant; |
|
40 //#define ?macro_name ?macro_def |
|
41 |
|
42 // MODULE DATA STRUCTURES |
|
43 //enum ?declaration |
|
44 //typedef ?declaration |
|
45 |
|
46 // LOCAL FUNCTION PROTOTYPES |
|
47 //?type ?function_name( ?arg_type, ?arg_type ); |
|
48 |
|
49 // FORWARD DECLARATIONS |
|
50 //class ?FORWARD_CLASSNAME; |
|
51 |
|
52 // ============================= LOCAL FUNCTIONS =============================== |
|
53 |
|
54 // ----------------------------------------------------------------------------- |
|
55 // ?function_name ?description. |
|
56 // ?description |
|
57 // Returns: ?value_1: ?description |
|
58 // ?value_n: ?description_line1 |
|
59 // ?description_line2 |
|
60 // ----------------------------------------------------------------------------- |
|
61 // |
|
62 /* |
|
63 ?type ?function_name( |
|
64 ?arg_type arg, // ?description |
|
65 ?arg_type arg) // ?description |
|
66 { |
|
67 |
|
68 ?code // ?comment |
|
69 |
|
70 // ?comment |
|
71 ?code |
|
72 } |
|
73 */ |
|
74 |
|
75 // ============================ MEMBER FUNCTIONS =============================== |
|
76 |
|
77 // ----------------------------------------------------------------------------- |
|
78 // CSenServDesc::Case |
|
79 // Returns a test case by number. |
|
80 // |
|
81 // This function contains an array of all available test cases |
|
82 // i.e pair of case name and test function. If case specified by parameter |
|
83 // aCaseNumber is found from array, then that item is returned. |
|
84 // |
|
85 // The reason for this rather complicated function is to specify all the |
|
86 // test cases only in one place. It is not necessary to understand how |
|
87 // function pointers to class member functions works when adding new test |
|
88 // cases. See function body for instructions how to add new test case. |
|
89 // ----------------------------------------------------------------------------- |
|
90 // |
|
91 const TCaseInfo CSenServDesc::Case ( |
|
92 const TInt aCaseNumber ) const |
|
93 { |
|
94 |
|
95 /** |
|
96 * To add new test cases, implement new test case function and add new |
|
97 * line to KCases array specify the name of the case and the function |
|
98 * doing the test case |
|
99 * In practice, do following |
|
100 * 1) Make copy of existing test case function and change its name |
|
101 * and functionality. Note that the function must be added to |
|
102 * SenServDesc.cpp file and to SenServDesc.h |
|
103 * header file. |
|
104 * |
|
105 * 2) Add entry to following KCases array either by using: |
|
106 * |
|
107 * 2.1: FUNCENTRY or ENTRY macro |
|
108 * ENTRY macro takes two parameters: test case name and test case |
|
109 * function name. |
|
110 * |
|
111 * FUNCENTRY macro takes only test case function name as a parameter and |
|
112 * uses that as a test case name and test case function name. |
|
113 * |
|
114 * Or |
|
115 * |
|
116 * 2.2: OOM_FUNCENTRY or OOM_ENTRY macro. Note that these macros are used |
|
117 * only with OOM (Out-Of-Memory) testing! |
|
118 * |
|
119 * OOM_ENTRY macro takes five parameters: test case name, test case |
|
120 * function name, TBool which specifies is method supposed to be run using |
|
121 * OOM conditions, TInt value for first heap memory allocation failure and |
|
122 * TInt value for last heap memory allocation failure. |
|
123 * |
|
124 * OOM_FUNCENTRY macro takes test case function name as a parameter and uses |
|
125 * that as a test case name, TBool which specifies is method supposed to be |
|
126 * run using OOM conditions, TInt value for first heap memory allocation |
|
127 * failure and TInt value for last heap memory allocation failure. |
|
128 */ |
|
129 |
|
130 static TCaseInfoInternal const KCases[] = |
|
131 { |
|
132 // To add new test cases, add new items to this array |
|
133 |
|
134 // NOTE: When compiled to GCCE, there must be Classname:: |
|
135 // declaration in front of the method name, e.g. |
|
136 // CSenServDesc::PrintTest. Otherwise the compiler |
|
137 // gives errors. |
|
138 |
|
139 // FUNCENTRY( CSenServDesc::PrintTest ), |
|
140 // ENTRY( "Loop test", CSenServDesc::LoopTest ), |
|
141 ENTRY("NewL - CSenCredential", CSenServDesc::MT_CSenCredential_NewLL), |
|
142 ENTRY("NewLC - CSenCredential", CSenServDesc::MT_CSenCredential_NewLCL), |
|
143 ENTRY("NewL - CSenCredential baseElement", CSenServDesc::MT_CSenCredential_NewL_1L), |
|
144 ENTRY("NewLC - CSenCredential baseElement", CSenServDesc::MT_CSenCredential_NewLC_1L), |
|
145 ENTRY("NewL - CSenCredential copy", CSenServDesc::MT_CSenCredential_NewL_2L), |
|
146 ENTRY("NewLC - CSenCredential copy", CSenServDesc::MT_CSenCredential_NewLC_2L), |
|
147 ENTRY("ValidUntil - CSenCredential ValidUntil", CSenServDesc::MT_CSenCredential_ValidUntilL), |
|
148 ENTRY("SetValidUntil - CSenCredential SetValidUntil", CSenServDesc::MT_CSenCredential_SetValidUntilL), |
|
149 //ENTRY("NewLC - CSenCredential Id", CSenServDesc::MT_CSenCredential_IdL), |
|
150 ENTRY("StartElement - CSenCredential StartElement", CSenServDesc::MT_CSenCredential_StartElementLL), |
|
151 |
|
152 ENTRY("NewL - CSenCredential2", CSenServDesc::MT_CSenCredential2_NewLL), |
|
153 ENTRY("NewLC - CSenCredential2", CSenServDesc::MT_CSenCredential2_NewLCL), |
|
154 ENTRY("NewL - CSenCredential2 baseElement", CSenServDesc::MT_CSenCredential2_NewL_1L), |
|
155 ENTRY("NewLC - CSenCredential2 baseElement", CSenServDesc::MT_CSenCredential2_NewLC_1L), |
|
156 ENTRY("NewL - CSenCredential2 ", CSenServDesc::MT_CSenCredential2_NewL_2L), |
|
157 ENTRY("NewLC - CSenCredential2 ", CSenServDesc::MT_CSenCredential2_NewLC_2L), |
|
158 ENTRY("NewL - CSenCredential2 copy", CSenServDesc::MT_CSenCredential2_NewL_3L), |
|
159 ENTRY("NewLC - CSenCredential2 copy", CSenServDesc::MT_CSenCredential2_NewLC_3L), |
|
160 ENTRY("NewL - CSenCredential2 document", CSenServDesc::MT_CSenCredential2_NewL_4L), |
|
161 ENTRY("NewLC - CSenCredential2 document", CSenServDesc::MT_CSenCredential2_NewLC_4L), |
|
162 ENTRY("Id - CSenCredential2 Id", CSenServDesc::MT_CSenCredential2_IdL), |
|
163 ENTRY("ValidUntil - CSenCredential2 ValidUntil", CSenServDesc::MT_CSenCredential2_ValidUntilL), |
|
164 ENTRY("SetValidUntil - CSenCredential2 SetValidUntil", CSenServDesc::MT_CSenCredential2_SetValidUntilL), |
|
165 ENTRY("NewL - CSenFacet", CSenServDesc::MT_CSenFacet_NewLL), |
|
166 ENTRY("NewL - CSenFacet copy", CSenServDesc::MT_CSenFacet_NewL_1L), |
|
167 ENTRY("NewL - CSenFacet attribute", CSenServDesc::MT_CSenFacet_NewL_2L), |
|
168 ENTRY("SetNameL - CSenFacet", CSenServDesc::MT_CSenFacet_SetNameLL), |
|
169 ENTRY("SetTypeL - CSenFacet", CSenServDesc::MT_CSenFacet_SetTypeLL), |
|
170 ENTRY("SetValueL - CSenFacet", CSenServDesc::MT_CSenFacet_SetValueLL), |
|
171 ENTRY("Name - CSenFacet", CSenServDesc::MT_CSenFacet_NameL), |
|
172 ENTRY("Type - CSenFacet", CSenServDesc::MT_CSenFacet_TypeL), |
|
173 ENTRY("Value - CSenFacet", CSenServDesc::MT_CSenFacet_ValueL), |
|
174 ENTRY("NewL - Endpoint", CSenServDesc::MT_CSenIdentityProvider_NewL_L), |
|
175 ENTRY("NewLC - Endpoint", CSenServDesc::MT_CSenIdentityProvider_NewLCL), |
|
176 ENTRY("NewL - Enpoint + Contract", CSenServDesc::MT_CSenIdentityProvider_NewL_1L), |
|
177 ENTRY("NewLC - Enpoint + Contract", CSenServDesc::MT_CSenIdentityProvider_NewLC_1L), |
|
178 ENTRY("NewL - Provider + Contract+ Endpoint", CSenServDesc::MT_CSenIdentityProvider_NewL_2L), |
|
179 ENTRY("NewLC - Provider + Contract+ Endpoint", CSenServDesc::MT_CSenIdentityProvider_NewLC_2L), |
|
180 ENTRY("NewL - ServiceID + Provider + Contract+ Endpoint", CSenServDesc::MT_CSenIdentityProvider_NewL_3L), |
|
181 ENTRY("NewLC - ServiceID + Provider + Contract+ Endpoint", CSenServDesc::MT_CSenIdentityProvider_NewLC_3L), |
|
182 ENTRY("AuthzID - IdentityProvider", CSenServDesc::MT_CSenIdentityProvider_AuthzIDL), |
|
183 ENTRY("AdvisoryAuthnID - IdentityProvider", CSenServDesc::MT_CSenIdentityProvider_AdvisoryAuthnIDL), |
|
184 ENTRY("ProviderID - IdentityProvider", CSenServDesc::MT_CSenIdentityProvider_ProviderIDL), |
|
185 ENTRY("Password - IdentityProvider", CSenServDesc::MT_CSenIdentityProvider_PasswordL), |
|
186 ENTRY("IMEI - IdentityProvider", CSenServDesc::MT_CSenIdentityProvider_IMEIL), |
|
187 ENTRY("UserName - IdentityProvider", CSenServDesc::MT_CSenIdentityProvider_UserNameL), |
|
188 ENTRY("SetProviderID - IdentityProvider", CSenServDesc::MT_CSenIdentityProvider_SetProviderIDL), |
|
189 ENTRY("SetServiceID - IdentityProvider", CSenServDesc::MT_CSenIdentityProvider_SetServiceIDL), |
|
190 ENTRY("IsTrustedByL - IdentityProvider", CSenServDesc::MT_CSenIdentityProvider_IsTrustedByLL), |
|
191 ENTRY("IsTrustedByL1 - IdentityProvider", CSenServDesc::MT_CSenIdentityProvider_IsTrustedByL1L), |
|
192 ENTRY("HttpCredentialsL - IdentityProvider", CSenServDesc::MT_CSenIdentityProvider_HttpCredentialsLL), |
|
193 ENTRY("IsDefault - IdentityProvider", CSenServDesc::MT_CSenIdentityProvider_IsDefaultL), |
|
194 |
|
195 ENTRY("NewElementName - IdentityProvider", CSenServDesc::MT_CSenIdentityProvider_NewElementNameL), |
|
196 ENTRY("NewL - CSenIdentityProviderIdArray8", CSenServDesc::MT_CSenIdentityProviderIdArray8_NewLL), |
|
197 ENTRY("NewLC - CSenIdentityProviderIdArray8", CSenServDesc::MT_CSenIdentityProviderIdArray8_NewLCL), |
|
198 ENTRY("NewL - CSenIdentityProviderIdArray8", CSenServDesc::MT_CSenIdentityProviderIdArray8_NewL_1L), |
|
199 ENTRY("NewLC - CSenIdentityProviderIdArray8", CSenServDesc::MT_CSenIdentityProviderIdArray8_NewLC_1L), |
|
200 ENTRY("IsStrict - CSenIdentityProviderIdArray8", CSenServDesc::MT_CSenIdentityProviderIdArray8_IsStrictL), |
|
201 ENTRY("SetStrict - CSenIdentityProviderIdArray8", CSenServDesc::MT_CSenIdentityProviderIdArray8_SetStrictL), |
|
202 ENTRY("NewL - CSenServicePattern", CSenServDesc::MT_CSenServicePattern_NewLL), |
|
203 ENTRY("NewLC - CSenServicePattern", CSenServDesc::MT_CSenServicePattern_NewLCL), |
|
204 ENTRY("NewL - CSenServicePattern", CSenServDesc::MT_CSenServicePattern_NewL_1L), |
|
205 ENTRY("NewLC - CSenServicePattern", CSenServDesc::MT_CSenServicePattern_NewLC_1L), |
|
206 ENTRY("NewL - CSenServicePattern", CSenServDesc::MT_CSenServicePattern_NewL_2L), |
|
207 ENTRY("NewLC - CSenServicePattern", CSenServDesc::MT_CSenServicePattern_NewLC_2L), |
|
208 ENTRY("MatchesL - CSenServicePattern", CSenServDesc::MT_CSenServicePattern_MatchesL), |
|
209 ENTRY("SetConsumerIapIdL - CSenServicePattern", CSenServDesc::MT_CSenServicePattern_SetConsumerIapIdLL), |
|
210 ENTRY("ConsumerIapId - CSenServicePattern", CSenServDesc::MT_CSenServicePattern_ConsumerIapIdL), |
|
211 ENTRY("SetConsumerSnapId - CSenServicePattern", CSenServDesc::MT_CSenServicePattern_SetConsumerSnapIdLL), |
|
212 ENTRY("ConsumerSnapId - CSenServicePattern", CSenServDesc::MT_CSenServicePattern_ConsumerSnapIdL), |
|
213 ENTRY("SetConsumerIdentityProviderIdsL - CSenServicePattern", CSenServDesc::MT_CSenServicePattern_SetConsumerIdentityProviderIdsLL), |
|
214 ENTRY("ConsumerPolicyAsXmlL - CSenServicePattern", CSenServDesc::MT_CSenServicePattern_ConsumerPolicyAsXmlLL), |
|
215 ENTRY("StartElementL - CSenServicePattern", CSenServDesc::MT_CSenServicePattern_StartElementLL), |
|
216 |
|
217 |
|
218 ENTRY("AddConsumerIdentityProviderIdL - CSenServicePattern", CSenServDesc::MT_CSenServicePattern_AddConsumerIdentityProviderIdLL), |
|
219 ENTRY("ConsumerIdentityProviderIds8L - CSenServicePattern", CSenServDesc::MT_CSenServicePattern_ConsumerIdentityProviderIds8LL), |
|
220 ENTRY("AcceptsConsumerPolicy - CSenServicePattern", CSenServDesc::MT_CSenServicePattern_AcceptsConsumerPolicyL), |
|
221 ENTRY("RebuildFromConsumerPolicy - CSenServicePattern", CSenServDesc::MT_CSenServicePattern_RebuildFromConsumerPolicyL), |
|
222 ENTRY("NewL - CSenXmlServiceDescription", CSenServDesc::MT_CSenXmlServiceDescription_NewLL), |
|
223 ENTRY("NewLC - CSenXmlServiceDescription", CSenServDesc::MT_CSenXmlServiceDescription_NewLCL), |
|
224 ENTRY("NewL - CSenXmlServiceDescription", CSenServDesc::MT_CSenXmlServiceDescription_NewL_1L), |
|
225 ENTRY("NewLC - CSenXmlServiceDescription", CSenServDesc::MT_CSenXmlServiceDescription_NewLC_1L), |
|
226 ENTRY("NewL - CSenXmlServiceDescription", CSenServDesc::MT_CSenXmlServiceDescription_NewL_2L), |
|
227 ENTRY("NewLC - CSenXmlServiceDescription", CSenServDesc::MT_CSenXmlServiceDescription_NewLC_2L), |
|
228 ENTRY("SetFrameworkIdL - CSenXmlServiceDescription", CSenServDesc::MT_CSenXmlServiceDescription_SetFrameworkIdLL), |
|
229 ENTRY("NewElementName - CSenXmlServiceDescription", CSenServDesc::MT_CSenXmlServiceDescription_NewElementNameL), |
|
230 ENTRY("SetIapIdL - CSenXmlServiceDescription", CSenServDesc::MT_CSenXmlServiceDescription_SetIapIdLL), |
|
231 ENTRY("IapId - CSenXmlServiceDescription", CSenServDesc::MT_CSenXmlServiceDescription_IapIdL), |
|
232 ENTRY("SetSnapIdL - CSenXmlServiceDescription", CSenServDesc::MT_CSenXmlServiceDescription_SetSnapIdLL), |
|
233 ENTRY("SnapId - CSenXmlServiceDescription", CSenServDesc::MT_CSenXmlServiceDescription_SnapIdL), |
|
234 ENTRY("SetIdentityProviderIdsL - CSenXmlServiceDescription", CSenServDesc::MT_CSenXmlServiceDescription_SetIdentityProviderIdsLL), |
|
235 ENTRY("AddIdentityProviderIdL - CSenXmlServiceDescription", CSenServDesc::MT_CSenXmlServiceDescription_AddIdentityProviderIdLL), |
|
236 ENTRY("RebuildFrom - CSenXmlServiceDescription", CSenServDesc::MT_CSenXmlServiceDescription_RebuildFromL), |
|
237 ENTRY("IdentityProviderIds8L - CSenXmlServiceDescription", CSenServDesc::MT_CSenXmlServiceDescription_IdentityProviderIds8LL), |
|
238 ENTRY("Accepts - CSenXmlServiceDescription", CSenServDesc::MT_CSenXmlServiceDescription_AcceptsL), |
|
239 ENTRY("DescriptionClassType - CSenXmlServiceDescription", CSenServDesc::MT_CSenXmlServiceDescription_DescriptionClassTypeL), |
|
240 ENTRY("MatchesL - CSenXmlServiceDescription", CSenServDesc::MT_CSenXmlServiceDescription_MatchesL), |
|
241 ENTRY("SetProviderIDL - CSenXmlServiceDescription", CSenServDesc::MT_CSenXmlServiceDescription_SetProviderIDL), |
|
242 ENTRY("SetPolicyLL - CSenXmlServiceDescription", CSenServDesc::MT_CSenXmlServiceDescription_SetPolicyLL), |
|
243 ENTRY("SetPolicyL_1L - CSenXmlServiceDescription", CSenServDesc::MT_CSenXmlServiceDescription_SetPolicyL_1L), |
|
244 ENTRY("SetPolicyL_2L - CSenXmlServiceDescription", CSenServDesc::MT_CSenXmlServiceDescription_SetPolicyL_2L), |
|
245 ENTRY("Contract - CSenXmlServiceDescription", CSenServDesc::MT_CSenXmlServiceDescription_ContractL), |
|
246 ENTRY("HasFacetL - CSenXmlServiceDescription", CSenServDesc::MT_CSenXmlServiceDescription_HasFacetLL), |
|
247 ENTRY("FacetValue - CSenXmlServiceDescription", CSenServDesc::MT_CSenXmlServiceDescription_FacetValueL), |
|
248 ENTRY("AddFacetL - CSenXmlServiceDescription", CSenServDesc::MT_CSenXmlServiceDescription_AddFacetLL), |
|
249 ENTRY("SetFacetL - CSenXmlServiceDescription", CSenServDesc::MT_CSenXmlServiceDescription_SetFacetLL), |
|
250 ENTRY("RemoveFacet - CSenXmlServiceDescription", CSenServDesc::MT_CSenXmlServiceDescription_RemoveFacetL), |
|
251 ENTRY("FacetsL - CSenXmlServiceDescription", CSenServDesc::MT_CSenXmlServiceDescription_FacetsLL), |
|
252 ENTRY("ScoreMatchL - CSenXmlServiceDescription", CSenServDesc::MT_CSenXmlServiceDescription_ScoreMatchLL), |
|
253 ENTRY("Endpoint - CSenXmlServiceDescription", CSenServDesc::MT_CSenXmlServiceDescription_EndpointL), |
|
254 ENTRY("FrameworkId - CSenXmlServiceDescription", CSenServDesc::MT_CSenXmlServiceDescription_FrameworkIdL), |
|
255 ENTRY("FrameworkVersion - CSenXmlServiceDescription", CSenServDesc::MT_CSenXmlServiceDescription_FrameworkVersionL), |
|
256 ENTRY("SetContractL - CSenXmlServiceDescription", CSenServDesc::MT_CSenXmlServiceDescription_SetContractLL), |
|
257 ENTRY("SetEndPointL - CSenXmlServiceDescription", CSenServDesc::MT_CSenXmlServiceDescription_SetEndPointLL), |
|
258 ENTRY("SetAttributesL - CSenXmlServiceDescription", CSenServDesc::MT_CSenXmlServiceDescription_SetAttributesLL), |
|
259 ENTRY("AsXmlL - CSenXmlServiceDescription ", CSenServDesc::MT_CSenXmlServiceDescription_AsXmlLL), |
|
260 ENTRY("WriteAsXMLToL - CSenXmlServiceDescription ", CSenServDesc::MT_CSenXmlServiceDescription_WriteAsXMLToLL), |
|
261 ENTRY("AsXmlUnicodeL - CSenXmlServiceDescription ", CSenServDesc::MT_CSenXmlServiceDescription_AsXmlUnicodeLL), |
|
262 ENTRY("Credentials - CSenXmlServiceDescription ", CSenServDesc::MT_CSenXmlServiceDescription_CredentialsL), |
|
263 |
|
264 ENTRY("HasEqualPrimaryKeysL - CSenXmlServiceDescription ", CSenServDesc::MT_CSenXmlServiceDescription_HasEqualPrimaryKeysLL), |
|
265 ENTRY("IsLocalL - CSenXmlServiceDescription ", CSenServDesc::MT_CSenXmlServiceDescription_IsLocalLL), |
|
266 ENTRY("SetTransportCueL - CSenXmlServiceDescription ", CSenServDesc::MT_CSenXmlServiceDescription_SetTransportCueLL), |
|
267 ENTRY("TransportCue - CSenXmlServiceDescription ", CSenServDesc::MT_CSenXmlServiceDescription_TransportCueL), |
|
268 //ENTRY("ServicePolicy - CSenXmlServiceDescription ", CSenServDesc::MT_CSenXmlServiceDescription_ServicePolicyL), |
|
269 ENTRY("ProviderId - CSenXmlServiceDescription ", CSenServDesc::MT_CSenXmlServiceDescription_ProviderIdL), |
|
270 ENTRY("SetPromptUserInfoL - CSenXmlServiceDescription ", CSenServDesc::MT_CSenXmlServiceDescription_SetPromptUserInfoLL), |
|
271 ENTRY("PromptUserInfo - CSenXmlServiceDescription ", CSenServDesc::MT_CSenXmlServiceDescription_PromptUserInfoL), |
|
272 ENTRY("StartElementL - CSenXmlServiceDescription ", CSenServDesc::MT_CSenXmlServiceDescription_StartEndElementLL), |
|
273 ENTRY("CopyFromLL - CSenXmlServiceDescription ", CSenServDesc::MT_CSenXmlServiceDescription_CopyFromLL), |
|
274 |
|
275 // Example how to use OOM functionality |
|
276 //OOM_ENTRY( "Loop test with OOM", CSenServDesc::LoopTest, ETrue, 2, 3), |
|
277 //OOM_FUNCENTRY( CSenServDesc::PrintTest, ETrue, 1, 3 ), |
|
278 }; |
|
279 |
|
280 // Verify that case number is valid |
|
281 if( (TUint) aCaseNumber >= sizeof( KCases ) / |
|
282 sizeof( TCaseInfoInternal ) ) |
|
283 { |
|
284 // Invalid case, construct empty object |
|
285 TCaseInfo null( (const TText*) L"" ); |
|
286 null.iMethod = NULL; |
|
287 null.iIsOOMTest = EFalse; |
|
288 null.iFirstMemoryAllocation = 0; |
|
289 null.iLastMemoryAllocation = 0; |
|
290 return null; |
|
291 } |
|
292 |
|
293 // Construct TCaseInfo object and return it |
|
294 TCaseInfo tmp ( KCases[ aCaseNumber ].iCaseName ); |
|
295 tmp.iMethod = KCases[ aCaseNumber ].iMethod; |
|
296 tmp.iIsOOMTest = KCases[ aCaseNumber ].iIsOOMTest; |
|
297 tmp.iFirstMemoryAllocation = KCases[ aCaseNumber ].iFirstMemoryAllocation; |
|
298 tmp.iLastMemoryAllocation = KCases[ aCaseNumber ].iLastMemoryAllocation; |
|
299 return tmp; |
|
300 |
|
301 } |
|
302 |
|
303 // METHODS |
|
304 |
|
305 |
|
306 |
|
307 void CSenServDesc::SetupL( ) |
|
308 { |
|
309 |
|
310 } |
|
311 |
|
312 void CSenServDesc::Teardown( ) |
|
313 { |
|
314 |
|
315 } |
|
316 TPtr16 CSenServDesc::ConvertToPtr16LC(CSenBaseFragment &fragment){ |
|
317 HBufC16* xmlBuffer = fragment.AsElement().AsXmlUnicodeL();//Parent()-> |
|
318 CleanupStack::PushL( xmlBuffer ); |
|
319 TPtr16 ptr = xmlBuffer->Des(); |
|
320 if (ptr.Length() > 0){ |
|
321 RDebug::Print( _L( "WSModTester: xmlBuffer [%S]"),&ptr); |
|
322 } |
|
323 else |
|
324 RDebug::Print( _L( "WSModTester: xmlBuffer empty")); |
|
325 return ptr; |
|
326 } |
|
327 TPtr16 CSenServDesc::ConvertToPtr16LC(CSenBaseElement &element){ |
|
328 HBufC16* xmlBuffer = element.AsXmlUnicodeL();//Parent()-> |
|
329 CleanupStack::PushL( xmlBuffer ); |
|
330 TPtr16 ptr = xmlBuffer->Des(); |
|
331 if (ptr.Length() > 0){ |
|
332 RDebug::Print( _L( "WSModTester: xmlBuffer [%S]"),&ptr); |
|
333 } |
|
334 else |
|
335 RDebug::Print( _L( "WSModTester: xmlBuffer empty")); |
|
336 return ptr; |
|
337 } |
|
338 |
|
339 TInt CSenServDesc::MT_CSenCredential_NewLL( TTestResult& aResult ) |
|
340 { |
|
341 SetupL(); |
|
342 |
|
343 RAttributeArray attributeArray; |
|
344 CSenCredential* senCredential = CSenCredential::NewL(KText, KText, KText, attributeArray); |
|
345 TL(senCredential != (CSenCredential*)NULL); |
|
346 |
|
347 _LIT16(KRef, "<text xmlns=\"text\"/>"); |
|
348 //checking xml |
|
349 TL(ConvertToPtr16LC(*senCredential) == KRef); |
|
350 |
|
351 CleanupStack::PopAndDestroy();//Ptr |
|
352 |
|
353 __ASSERT_ALWAYS_NO_LEAVE(delete senCredential); |
|
354 |
|
355 senCredential = NULL; |
|
356 |
|
357 {TRAPD(err, CSenCredential::NewL(KText, KNullDesC8, KText, attributeArray));if(err != (KErrSenZeroLengthDescriptor))return err;} |
|
358 |
|
359 {TRAPD(err, CSenCredential::NewL(KText, KText, KNullDesC8, attributeArray));if(err != (KErrSenZeroLengthDescriptor))return err;} |
|
360 |
|
361 {TRAPD(err, CSenCredential::NewL(KText, KNullDesC8, KNullDesC8, attributeArray));if(err != (KErrSenZeroLengthDescriptor))return err;} |
|
362 |
|
363 {TRAPD(err, CSenCredential::NewL(KText, KXmlSpecific, KText, attributeArray));if(err != (KErrSenInvalidCharacters))return err;} |
|
364 |
|
365 {TRAPD(err, CSenCredential::NewL(KText, KText, KXmlSpecific, attributeArray));if(err != (KErrSenInvalidCharacters))return err;} |
|
366 |
|
367 {TRAPD(err, CSenCredential::NewL(KText, KXmlSpecific, KXmlSpecific, attributeArray));if(err != (KErrSenInvalidCharacters))return err;} |
|
368 |
|
369 attributeArray.Reset(); |
|
370 attributeArray.Close(); |
|
371 |
|
372 Teardown(); |
|
373 return KErrNone; |
|
374 } |
|
375 |
|
376 |
|
377 |
|
378 |
|
379 TInt CSenServDesc::MT_CSenCredential_NewLCL( TTestResult& aResult ) |
|
380 { |
|
381 SetupL(); |
|
382 |
|
383 RAttributeArray attributeArray; |
|
384 CSenCredential* senCredential = CSenCredential::NewLC(KText, KText, KText, attributeArray); |
|
385 TL(senCredential != (CSenCredential*)NULL); |
|
386 |
|
387 //checking xml |
|
388 _LIT16(KRef, "<text xmlns=\"text\"/>"); |
|
389 TL(ConvertToPtr16LC(*senCredential) == KRef); |
|
390 CleanupStack::PopAndDestroy();//Ptr |
|
391 |
|
392 CleanupStack::Pop(); |
|
393 __ASSERT_ALWAYS_NO_LEAVE(delete senCredential); |
|
394 senCredential = NULL; |
|
395 |
|
396 {TRAPD(err, CSenCredential::NewLC(KText, KNullDesC8, KText, attributeArray));if(err != (KErrSenZeroLengthDescriptor))return err;} |
|
397 |
|
398 {TRAPD(err, CSenCredential::NewLC(KText, KText, KNullDesC8, attributeArray));if(err != (KErrSenZeroLengthDescriptor))return err;} |
|
399 |
|
400 {TRAPD(err, CSenCredential::NewLC(KText, KNullDesC8, KNullDesC8, attributeArray));if(err != (KErrSenZeroLengthDescriptor))return err;} |
|
401 |
|
402 {TRAPD(err, CSenCredential::NewLC(KText, KXmlSpecific, KText, attributeArray));if(err != (KErrSenInvalidCharacters))return err;} |
|
403 |
|
404 {TRAPD(err, CSenCredential::NewLC(KText, KText, KXmlSpecific, attributeArray));if(err != (KErrSenInvalidCharacters))return err;} |
|
405 |
|
406 {TRAPD(err, CSenCredential::NewLC(KText, KXmlSpecific, KXmlSpecific, attributeArray));if(err != (KErrSenInvalidCharacters))return err;} |
|
407 |
|
408 attributeArray.Reset(); |
|
409 attributeArray.Close(); |
|
410 Teardown(); |
|
411 return KErrNone; |
|
412 } |
|
413 |
|
414 |
|
415 TInt CSenServDesc::MT_CSenCredential_NewL_1L( TTestResult& aResult ) |
|
416 { |
|
417 SetupL(); |
|
418 |
|
419 RAttributeArray attributeArray; |
|
420 CSenBaseElement* senBaseElement = CSenBaseElement::NewL(KText); |
|
421 CSenCredential* senCredential = CSenCredential::NewL(KText, KText, KText, attributeArray, *senBaseElement); |
|
422 TL(senCredential != (CSenCredential*)NULL); |
|
423 |
|
424 //checking xml, parent we will not see so ref the same as previous NewL ctr |
|
425 _LIT16(KRef, "<text xmlns=\"text\"/>"); |
|
426 TL(ConvertToPtr16LC(*senCredential) == KRef); |
|
427 |
|
428 CleanupStack::PopAndDestroy();//Ptr |
|
429 |
|
430 __ASSERT_ALWAYS_NO_LEAVE(delete senCredential); |
|
431 senCredential = NULL; |
|
432 delete senBaseElement; |
|
433 senBaseElement = NULL; |
|
434 |
|
435 senBaseElement = CSenBaseElement::NewL(KText); |
|
436 {TRAPD(err, CSenCredential::NewL(KText, KNullDesC8, KText, attributeArray, *senBaseElement));if(err != (KErrSenZeroLengthDescriptor))return err;} |
|
437 |
|
438 {TRAPD(err, CSenCredential::NewL(KText, KText, KNullDesC8, attributeArray, *senBaseElement));if(err != (KErrSenZeroLengthDescriptor))return err;} |
|
439 |
|
440 {TRAPD(err, CSenCredential::NewL(KText, KNullDesC8, KNullDesC8, attributeArray, *senBaseElement));if(err != (KErrSenZeroLengthDescriptor))return err;} |
|
441 |
|
442 {TRAPD(err, CSenCredential::NewL(KText, KXmlSpecific, KText, attributeArray, *senBaseElement));if(err != (KErrSenInvalidCharacters))return err;} |
|
443 |
|
444 {TRAPD(err, CSenCredential::NewL(KText, KText, KXmlSpecific, attributeArray, *senBaseElement));if(err != (KErrSenInvalidCharacters))return err;} |
|
445 |
|
446 {TRAPD(err, CSenCredential::NewL(KText, KXmlSpecific, KXmlSpecific, attributeArray, *senBaseElement));if(err != (KErrSenInvalidCharacters))return err;} |
|
447 |
|
448 delete senBaseElement; |
|
449 senBaseElement = NULL; |
|
450 attributeArray.Reset(); |
|
451 attributeArray.Close(); |
|
452 Teardown(); |
|
453 return KErrNone; |
|
454 } |
|
455 |
|
456 TInt CSenServDesc::MT_CSenCredential_NewLC_1L( TTestResult& aResult ) |
|
457 { |
|
458 SetupL(); |
|
459 |
|
460 RAttributeArray attributeArray; |
|
461 CSenBaseElement* senBaseElement = CSenBaseElement::NewL(KText); |
|
462 CSenCredential* senCredential = CSenCredential::NewLC(KText, KText, KText, attributeArray, *senBaseElement); |
|
463 TL(senCredential != (CSenCredential*)NULL); |
|
464 |
|
465 //checking xml, parent we will not see so ref the same as previous Newl ctr |
|
466 _LIT16(KRef, "<text xmlns=\"text\"/>"); |
|
467 TL(ConvertToPtr16LC(*senCredential)== KRef); |
|
468 |
|
469 CleanupStack::PopAndDestroy();//Ptr |
|
470 |
|
471 CleanupStack::Pop(); |
|
472 __ASSERT_ALWAYS_NO_LEAVE(delete senCredential); |
|
473 senCredential = NULL; |
|
474 delete senBaseElement; |
|
475 senBaseElement = NULL; |
|
476 |
|
477 senBaseElement = CSenBaseElement::NewL(KText); |
|
478 {TRAPD(err, CSenCredential::NewLC(KText, KNullDesC8, KText, attributeArray, *senBaseElement));if(err != (KErrSenZeroLengthDescriptor))return err;} |
|
479 |
|
480 {TRAPD(err, CSenCredential::NewLC(KText, KText, KNullDesC8, attributeArray, *senBaseElement));if(err != (KErrSenZeroLengthDescriptor))return err;} |
|
481 |
|
482 {TRAPD(err, CSenCredential::NewLC(KText, KNullDesC8, KNullDesC8, attributeArray, *senBaseElement));if(err != (KErrSenZeroLengthDescriptor))return err;} |
|
483 |
|
484 {TRAPD(err, CSenCredential::NewLC(KText, KXmlSpecific, KText, attributeArray, *senBaseElement));if(err != (KErrSenInvalidCharacters))return err;} |
|
485 |
|
486 {TRAPD(err, CSenCredential::NewLC(KText, KText, KXmlSpecific, attributeArray, *senBaseElement));if(err != (KErrSenInvalidCharacters))return err;} |
|
487 |
|
488 {TRAPD(err, CSenCredential::NewLC(KText, KXmlSpecific, KXmlSpecific, attributeArray, *senBaseElement));if(err != (KErrSenInvalidCharacters))return err;} |
|
489 |
|
490 delete senBaseElement; |
|
491 senBaseElement = NULL; |
|
492 attributeArray.Reset(); |
|
493 attributeArray.Close(); |
|
494 Teardown(); |
|
495 return KErrNone; |
|
496 } |
|
497 |
|
498 TInt CSenServDesc::MT_CSenCredential_NewL_2L( TTestResult& aResult ) |
|
499 { |
|
500 SetupL(); |
|
501 |
|
502 RAttributeArray attributeArray; |
|
503 CSenCredential* senCredential, *orgSenCredential = CSenCredential::NewL(KText, KText, KText, attributeArray); |
|
504 |
|
505 senCredential = CSenCredential::NewL(*orgSenCredential); |
|
506 |
|
507 //checking xml |
|
508 _LIT16(KRef, "<text xmlns=\"text\"/>"); |
|
509 TL(ConvertToPtr16LC(*senCredential) == KRef); |
|
510 CleanupStack::PopAndDestroy();//Ptr |
|
511 |
|
512 TL(senCredential != (CSenCredential*)NULL); |
|
513 |
|
514 __ASSERT_ALWAYS_NO_LEAVE(delete senCredential); |
|
515 senCredential = NULL; |
|
516 delete orgSenCredential; |
|
517 orgSenCredential = NULL; |
|
518 attributeArray.Reset(); |
|
519 attributeArray.Close(); |
|
520 Teardown(); |
|
521 return KErrNone; |
|
522 } |
|
523 |
|
524 TInt CSenServDesc::MT_CSenCredential_NewLC_2L( TTestResult& aResult ) |
|
525 { |
|
526 SetupL(); |
|
527 |
|
528 RAttributeArray attributeArray; |
|
529 CSenCredential* senCredential, *orgSenCredential = CSenCredential::NewL(KText, KText, KText, attributeArray); |
|
530 |
|
531 senCredential = CSenCredential::NewLC(*orgSenCredential); |
|
532 TL(senCredential != (CSenCredential*)NULL); |
|
533 |
|
534 //checking xml |
|
535 _LIT16(KRef, "<text xmlns=\"text\"/>"); |
|
536 TL(ConvertToPtr16LC(*senCredential) == KRef); |
|
537 |
|
538 CleanupStack::PopAndDestroy();//Ptr |
|
539 |
|
540 CleanupStack::Pop(); |
|
541 __ASSERT_ALWAYS_NO_LEAVE(delete senCredential); |
|
542 senCredential = NULL; |
|
543 delete orgSenCredential; |
|
544 orgSenCredential = NULL; |
|
545 attributeArray.Reset(); |
|
546 attributeArray.Close(); |
|
547 Teardown(); |
|
548 return KErrNone; |
|
549 } |
|
550 |
|
551 TInt CSenServDesc::MT_CSenCredential_ValidUntilL( TTestResult& aResult ) |
|
552 { |
|
553 SetupL(); |
|
554 RAttributeArray attributes; |
|
555 CSenCredential* senCredential = CSenCredential::NewL(KText, KText, KText, attributes); |
|
556 TTime time; |
|
557 _LIT(KTimeString1,"23:34.56"); |
|
558 time.Parse(KTimeString1); |
|
559 /*__ASSERT_ALWAYS_NO_LEAVE(senCredential->SetValidUntil(time));*/ |
|
560 __ASSERT_ALWAYS_NO_LEAVE(senCredential->SetValidUntil(time)); |
|
561 LOCAL_ASSERT(senCredential->ValidUntil() == time); |
|
562 |
|
563 /*__ASSERT_ALWAYS_NO_LEAVE(senCredential->ValidUntil()); */ |
|
564 __ASSERT_ALWAYS_NO_LEAVE(senCredential->ValidUntil()); |
|
565 |
|
566 //checking xml |
|
567 //_LIT16(KRef, "<text xmlns=\"text\" some valid stuff/>"); |
|
568 //_LIT16(KRef, "<text xmlns=\"text\" >"); |
|
569 _LIT16(KRef, "<text xmlns=\"text\"/>"); |
|
570 /*EUNIT_ASSERT_EQUALS(ConvertToPtr16LC(*senCredential), KRef);*/ |
|
571 TL(ConvertToPtr16LC(*senCredential) == KRef); |
|
572 CleanupStack::PopAndDestroy();//Ptr |
|
573 |
|
574 delete senCredential; |
|
575 senCredential = NULL; |
|
576 attributes.Reset(); |
|
577 attributes.Close(); |
|
578 Teardown(); |
|
579 return KErrNone; |
|
580 } |
|
581 |
|
582 TInt CSenServDesc::MT_CSenCredential_SetValidUntilL( TTestResult& aResult ) |
|
583 { |
|
584 return MT_CSenCredential_ValidUntilL(aResult); |
|
585 } |
|
586 TInt CSenServDesc::MT_CSenCredential_StartElementLL(TTestResult& aResult) |
|
587 { |
|
588 /* |
|
589 _LIT8(KCredential, "<Credentials CredentialsMaxID=\"1\"> |
|
590 <CredentialContainer> |
|
591 <Identifier><garbage>1</garbage><Endpoint>http://10.21.32.20/WSStar/CredMan/WSService.aspx</Endpoint><ProviderID>provider01</ProviderID></Identifier> |
|
592 <Properties> |
|
593 <ServiceInterval>-60540625</ServiceInterval><ValidUntil>2020-06-19T10:28:31.000000Z</ValidUntil> |
|
594 <Created>2007-06-18T10:23:52Z</Created><PhoneTimeWhenMTResolved>2007-06-18T10:24:52.504375Z</PhoneTimeWhenMTResolved> |
|
595 <POP>cnqlXcxDmY4h4tjbgNssLMwhCkOnc+4c</POP> |
|
596 <TokenType>http://docs.oasis-open.org/wss/oasis-wss-saml-token-profile-1.1#SAMLV1.1</TokenType>\ |
|
597 <BinaryType>simmetric</BinaryType> |
|
598 </Properties></CredentialContainer></Credentials>"); |
|
599 */ |
|
600 |
|
601 _LIT8(KCredential, "<Credentials CredentialsMaxID=\"1\">\ |
|
602 </Credentials>"); |
|
603 |
|
604 RAttributeArray attributes; |
|
605 CSenCredential* pCredential = CSenCredential::NewL(_L8(""),_L8("Credentials"),_L8("Credentials"),attributes); |
|
606 CleanupStack::PushL(pCredential); |
|
607 CSenXmlReader *pXmlReader = CSenXmlReader::NewL(); |
|
608 CleanupStack::PushL(pXmlReader); |
|
609 pCredential->SetReader(*pXmlReader ); |
|
610 TRAPD(retVal,pCredential->ParseL(KCredential)); |
|
611 CleanupStack::PopAndDestroy(pXmlReader); |
|
612 CleanupStack::PopAndDestroy(pCredential); |
|
613 return retVal; |
|
614 } |
|
615 |
|
616 |
|
617 TInt CSenServDesc::MT_CSenCredential2_NewLL( TTestResult& aResult ) |
|
618 { |
|
619 SetupL(); |
|
620 |
|
621 CSenCredential2* senCredential = CSenCredential2::NewL(); |
|
622 TL(senCredential != (CSenCredential2*)NULL); |
|
623 |
|
624 __ASSERT_ALWAYS_NO_LEAVE(delete senCredential); |
|
625 |
|
626 senCredential = NULL; |
|
627 |
|
628 |
|
629 Teardown(); |
|
630 return KErrNone; |
|
631 } |
|
632 |
|
633 |
|
634 |
|
635 |
|
636 TInt CSenServDesc::MT_CSenCredential2_NewLCL( TTestResult& aResult ) |
|
637 { |
|
638 SetupL(); |
|
639 |
|
640 CSenCredential2* senCredential = CSenCredential2::NewLC(); |
|
641 TL(senCredential != (CSenCredential2*)NULL); |
|
642 CleanupStack::Pop(); |
|
643 __ASSERT_ALWAYS_NO_LEAVE(delete senCredential); |
|
644 |
|
645 senCredential = NULL; |
|
646 |
|
647 //CleanupStack::PopAndDestroy(); |
|
648 Teardown(); |
|
649 return KErrNone; |
|
650 } |
|
651 |
|
652 |
|
653 TInt CSenServDesc::MT_CSenCredential2_NewL_1L( TTestResult& aResult ) |
|
654 { |
|
655 SetupL(); |
|
656 |
|
657 RAttributeArray attributeArray; |
|
658 CSenCredential2* senCredential = CSenCredential2::NewL(KText, KText, KText, attributeArray); |
|
659 TL(senCredential != (CSenCredential2*)NULL); |
|
660 |
|
661 |
|
662 __ASSERT_ALWAYS_NO_LEAVE(delete senCredential); |
|
663 senCredential = NULL; |
|
664 Teardown(); |
|
665 return KErrNone; |
|
666 } |
|
667 |
|
668 TInt CSenServDesc::MT_CSenCredential2_NewLC_1L( TTestResult& aResult ) |
|
669 { |
|
670 SetupL(); |
|
671 |
|
672 RAttributeArray attributeArray; |
|
673 CSenCredential2* senCredential = CSenCredential2::NewLC(KText, KText, KText, attributeArray); |
|
674 TL(senCredential != (CSenCredential2*)NULL); |
|
675 |
|
676 CleanupStack::Pop(); |
|
677 __ASSERT_ALWAYS_NO_LEAVE(delete senCredential); |
|
678 senCredential = NULL; |
|
679 //CleanupStack::PopAndDestroy(); |
|
680 |
|
681 Teardown(); |
|
682 return KErrNone; |
|
683 } |
|
684 |
|
685 |
|
686 TInt CSenServDesc::MT_CSenCredential2_NewL_2L( TTestResult& aResult ) |
|
687 { |
|
688 SetupL(); |
|
689 _LIT8(KBodyElementName, "BodyElement"); |
|
690 RAttributeArray attributeArray; |
|
691 RSenDocument document = RSenDocument::NewLC(); |
|
692 TXmlEngElement bodyElement = document.CreateDocumentElementL(KBodyElementName()); |
|
693 CSenCredential2* senCredential = CSenCredential2::NewL(KText, KText, KText, attributeArray, bodyElement); |
|
694 TL(senCredential != (CSenCredential2*)NULL); |
|
695 __ASSERT_ALWAYS_NO_LEAVE(delete senCredential); |
|
696 senCredential = NULL; |
|
697 CleanupStack::PopAndDestroy(1); |
|
698 |
|
699 Teardown(); |
|
700 return KErrNone; |
|
701 } |
|
702 |
|
703 TInt CSenServDesc::MT_CSenCredential2_NewLC_2L( TTestResult& aResult ) |
|
704 { |
|
705 SetupL(); |
|
706 _LIT8(KBodyElementName, "BodyElement"); |
|
707 RAttributeArray attributeArray; |
|
708 RSenDocument document = RSenDocument::NewLC(); |
|
709 TXmlEngElement bodyElement = document.CreateDocumentElementL(KBodyElementName()); |
|
710 CSenCredential2* senCredential = CSenCredential2::NewLC(KText, KText, KText, attributeArray, bodyElement); |
|
711 TL(senCredential != (CSenCredential2*)NULL); |
|
712 CleanupStack::Pop(); |
|
713 __ASSERT_ALWAYS_NO_LEAVE(delete senCredential); |
|
714 senCredential = NULL; |
|
715 CleanupStack::PopAndDestroy(1); |
|
716 Teardown(); |
|
717 return KErrNone; |
|
718 } |
|
719 |
|
720 TInt CSenServDesc::MT_CSenCredential2_NewL_3L( TTestResult& aResult ) |
|
721 { |
|
722 SetupL(); |
|
723 |
|
724 RAttributeArray attributeArray; |
|
725 CSenCredential2 *senCredential; |
|
726 CSenCredential2 *orgSenCredential = CSenCredential2::NewL(KText, KText, KText, attributeArray); |
|
727 senCredential = CSenCredential2::NewL(*orgSenCredential); |
|
728 |
|
729 |
|
730 __ASSERT_ALWAYS_NO_LEAVE(delete senCredential); |
|
731 senCredential = NULL; |
|
732 delete orgSenCredential; |
|
733 orgSenCredential = NULL; |
|
734 Teardown(); |
|
735 return KErrNone; |
|
736 } |
|
737 |
|
738 TInt CSenServDesc::MT_CSenCredential2_NewLC_3L( TTestResult& aResult ) |
|
739 { |
|
740 SetupL(); |
|
741 |
|
742 RAttributeArray attributeArray; |
|
743 CSenCredential2 *senCredential; |
|
744 CSenCredential2 *orgSenCredential = CSenCredential2::NewL(KText, KText, KText, attributeArray); |
|
745 senCredential = CSenCredential2::NewLC(*orgSenCredential); |
|
746 TL(senCredential != (CSenCredential2*)NULL); |
|
747 |
|
748 |
|
749 CleanupStack::Pop(); |
|
750 __ASSERT_ALWAYS_NO_LEAVE(delete senCredential); |
|
751 senCredential = NULL; |
|
752 delete orgSenCredential; |
|
753 orgSenCredential = NULL; |
|
754 attributeArray.Reset(); |
|
755 attributeArray.Close(); |
|
756 Teardown(); |
|
757 return KErrNone; |
|
758 } |
|
759 |
|
760 |
|
761 TInt CSenServDesc::MT_CSenCredential2_NewL_4L( TTestResult& aResult ) |
|
762 { |
|
763 SetupL(); |
|
764 _LIT8(KBodyElementName, "BodyElement"); |
|
765 RAttributeArray attributeArray; |
|
766 RSenDocument document = RSenDocument::NewLC(); |
|
767 TXmlEngElement bodyElement = document.CreateDocumentElementL(KBodyElementName()); |
|
768 CSenCredential2* senCredential = CSenCredential2::NewL(KText, KText, KText, attributeArray, bodyElement, document); |
|
769 TL(senCredential != (CSenCredential2*)NULL); |
|
770 __ASSERT_ALWAYS_NO_LEAVE(delete senCredential); |
|
771 senCredential = NULL; |
|
772 CleanupStack::PopAndDestroy(1); |
|
773 |
|
774 Teardown(); |
|
775 return KErrNone; |
|
776 } |
|
777 |
|
778 TInt CSenServDesc::MT_CSenCredential2_NewLC_4L( TTestResult& aResult ) |
|
779 { |
|
780 SetupL(); |
|
781 _LIT8(KBodyElementName, "BodyElement"); |
|
782 RAttributeArray attributeArray; |
|
783 RSenDocument document = RSenDocument::NewLC(); |
|
784 TXmlEngElement bodyElement = document.CreateDocumentElementL(KBodyElementName()); |
|
785 CSenCredential2* senCredential = CSenCredential2::NewLC(KText, KText, KText, attributeArray, bodyElement, document); |
|
786 TL(senCredential != (CSenCredential2*)NULL); |
|
787 CleanupStack::Pop(); |
|
788 __ASSERT_ALWAYS_NO_LEAVE(delete senCredential); |
|
789 senCredential = NULL; |
|
790 CleanupStack::PopAndDestroy(1); |
|
791 Teardown(); |
|
792 return KErrNone; |
|
793 } |
|
794 |
|
795 |
|
796 TInt CSenServDesc::MT_CSenCredential2_IdL( TTestResult& aResult ) |
|
797 { |
|
798 SetupL(); |
|
799 |
|
800 RAttributeArray attributeArray; |
|
801 CSenCredential2 *senCredential; |
|
802 CSenCredential2 *orgSenCredential = CSenCredential2::NewL(KText, KText, KText, attributeArray); |
|
803 senCredential = CSenCredential2::NewL(*orgSenCredential); |
|
804 senCredential->Id(); |
|
805 TL(senCredential != (CSenCredential2*)NULL); |
|
806 |
|
807 |
|
808 __ASSERT_ALWAYS_NO_LEAVE(delete senCredential); |
|
809 senCredential = NULL; |
|
810 delete orgSenCredential; |
|
811 orgSenCredential = NULL; |
|
812 attributeArray.Reset(); |
|
813 attributeArray.Close(); |
|
814 Teardown(); |
|
815 return KErrNone; |
|
816 } |
|
817 |
|
818 |
|
819 TInt CSenServDesc::MT_CSenCredential2_ValidUntilL( TTestResult& aResult ) |
|
820 { |
|
821 SetupL(); |
|
822 RAttributeArray attributes; |
|
823 CSenCredential2* senCredential = CSenCredential2::NewL(KText, KText, KText, attributes); |
|
824 TTime time; |
|
825 _LIT(KTimeString1,"23:34.56"); |
|
826 time.Parse(KTimeString1); |
|
827 /*__ASSERT_ALWAYS_NO_LEAVE(senCredential->SetValidUntil(time));*/ |
|
828 __ASSERT_ALWAYS_NO_LEAVE(senCredential->SetValidUntil(time)); |
|
829 LOCAL_ASSERT(senCredential->ValidUntil() == time); |
|
830 |
|
831 /*__ASSERT_ALWAYS_NO_LEAVE(senCredential->ValidUntil()); */ |
|
832 __ASSERT_ALWAYS_NO_LEAVE(senCredential->ValidUntil()); |
|
833 |
|
834 //checking xml |
|
835 //_LIT16(KRef, "<text xmlns=\"text\" some valid stuff/>"); |
|
836 //_LIT16(KRef, "<text xmlns=\"text\" >"); |
|
837 //_LIT16(KRef, "<text xmlns=\"text\"/>"); |
|
838 /*EUNIT_ASSERT_EQUALS(ConvertToPtr16LC(*senCredential), KRef);*/ |
|
839 //TL(ConvertToPtr16LC(*senCredential) == KRef); |
|
840 //CleanupStack::PopAndDestroy();//Ptr |
|
841 |
|
842 delete senCredential; |
|
843 senCredential = NULL; |
|
844 attributes.Reset(); |
|
845 attributes.Close(); |
|
846 Teardown(); |
|
847 return KErrNone; |
|
848 } |
|
849 |
|
850 TInt CSenServDesc::MT_CSenCredential2_SetValidUntilL( TTestResult& aResult ) |
|
851 { |
|
852 return MT_CSenCredential2_ValidUntilL(aResult); |
|
853 } |
|
854 |
|
855 |
|
856 TInt CSenServDesc::MT_CSenFacet_NewLL( TTestResult& aResult ) |
|
857 { |
|
858 SetupL(); |
|
859 |
|
860 RAttributeArray attributeArray; |
|
861 CSenFacet* senFacet = CSenFacet::NewL(); |
|
862 TL(senFacet != (CSenFacet*)NULL); |
|
863 |
|
864 //checking xml |
|
865 _LIT16(KRef, "<Facet/>"); |
|
866 TL(ConvertToPtr16LC(*senFacet) == KRef); |
|
867 |
|
868 CleanupStack::PopAndDestroy();//Ptr |
|
869 |
|
870 __ASSERT_ALWAYS_NO_LEAVE(delete senFacet); |
|
871 senFacet = NULL; |
|
872 attributeArray.Reset(); |
|
873 attributeArray.Close(); |
|
874 Teardown(); |
|
875 return KErrNone; |
|
876 } |
|
877 |
|
878 TInt CSenServDesc::MT_CSenFacet_NewL_1L(TTestResult& aResult) |
|
879 { |
|
880 SetupL(); |
|
881 |
|
882 CSenFacet *senFacet; |
|
883 CSenFacet *senFacetOrg = CSenFacet::NewL(); |
|
884 |
|
885 senFacet = CSenFacet::NewL(*senFacetOrg); |
|
886 TL(senFacet != (CSenFacet*)NULL); |
|
887 |
|
888 //checking xml |
|
889 _LIT16(KRef, "<Facet/>"); |
|
890 TL(ConvertToPtr16LC(*senFacet) == KRef); |
|
891 |
|
892 CleanupStack::PopAndDestroy();//Ptr |
|
893 |
|
894 __ASSERT_ALWAYS_NO_LEAVE(delete senFacet); |
|
895 senFacet = NULL; |
|
896 delete senFacetOrg; |
|
897 senFacetOrg = NULL; |
|
898 Teardown(); |
|
899 return KErrNone; |
|
900 } |
|
901 |
|
902 TInt CSenServDesc::MT_CSenFacet_NewL_2L( TTestResult& aResult ) |
|
903 { |
|
904 SetupL(); |
|
905 |
|
906 RAttributeArray attributeArray; |
|
907 CSenFacet* senFacet = CSenFacet::NewL(KText, KText, KText, attributeArray); |
|
908 TL(senFacet != (CSenFacet*)NULL); |
|
909 |
|
910 //checking xml |
|
911 _LIT16(KRef, "<text xmlns=\"text\"/>"); |
|
912 TL(ConvertToPtr16LC(*senFacet) == KRef); |
|
913 |
|
914 CleanupStack::PopAndDestroy();//Ptr |
|
915 |
|
916 __ASSERT_ALWAYS_NO_LEAVE(delete senFacet); |
|
917 senFacet = NULL; |
|
918 |
|
919 {TRAPD(err, CSenFacet::NewL(KText, KNullDesC8, KText, attributeArray));if(err != (KErrSenZeroLengthDescriptor))return err;} |
|
920 |
|
921 {TRAPD(err, CSenFacet::NewL(KText, KText, KNullDesC8, attributeArray));if(err != (KErrSenZeroLengthDescriptor))return err;} |
|
922 |
|
923 {TRAPD(err, CSenFacet::NewL(KText, KNullDesC8, KNullDesC8, attributeArray));if(err != (KErrSenZeroLengthDescriptor))return err;} |
|
924 |
|
925 {TRAPD(err, CSenFacet::NewL(KText, KXmlSpecific, KText, attributeArray));if(err != (KErrSenInvalidCharacters))return err;} |
|
926 |
|
927 {TRAPD(err, CSenFacet::NewL(KText, KText, KXmlSpecific, attributeArray));if(err != (KErrSenInvalidCharacters))return err;} |
|
928 |
|
929 {TRAPD(err, CSenFacet::NewL(KText, KXmlSpecific, KXmlSpecific, attributeArray));if(err != (KErrSenInvalidCharacters))return err;} |
|
930 |
|
931 attributeArray.Reset(); |
|
932 attributeArray.Close(); |
|
933 Teardown(); |
|
934 return KErrNone; |
|
935 } |
|
936 |
|
937 TInt CSenServDesc::MT_CSenFacet_SetNameLL( TTestResult& aResult ) |
|
938 { |
|
939 SetupL(); |
|
940 |
|
941 CSenFacet* senFacet = CSenFacet::NewL(); |
|
942 if(!(senFacet->Name() == KNullDesC8))return KErrArgument; |
|
943 |
|
944 senFacet->SetNameL(KText); |
|
945 if(!(senFacet->Name() == KText))return KErrArgument; |
|
946 |
|
947 //checking xml |
|
948 _LIT16(KRef, "<Facet name=\"text\"/>"); |
|
949 TL(ConvertToPtr16LC(*senFacet) == KRef); |
|
950 |
|
951 CleanupStack::PopAndDestroy();//Ptr |
|
952 |
|
953 if(!(senFacet->Name() == KText))return KErrArgument; |
|
954 |
|
955 __ASSERT_ALWAYS_NO_LEAVE(delete senFacet); |
|
956 senFacet = NULL; |
|
957 Teardown(); |
|
958 return KErrNone; |
|
959 } |
|
960 |
|
961 TInt CSenServDesc::MT_CSenFacet_SetTypeLL( TTestResult& aResult ) |
|
962 { |
|
963 SetupL(); |
|
964 |
|
965 CSenFacet* senFacet = CSenFacet::NewL(); |
|
966 if(!(senFacet->Type() == KNullDesC8))return KErrArgument; |
|
967 |
|
968 senFacet->SetTypeL(KText); |
|
969 if(!(senFacet->Type() == KText))return KErrArgument; |
|
970 |
|
971 //checking xml |
|
972 _LIT16(KRef, "<Facet type=\"text\"/>"); |
|
973 TL(ConvertToPtr16LC(*senFacet) == KRef); |
|
974 |
|
975 CleanupStack::PopAndDestroy();//Ptr |
|
976 |
|
977 if(!(senFacet->Type() == KText))return KErrArgument; |
|
978 |
|
979 delete senFacet; |
|
980 senFacet = NULL; |
|
981 Teardown(); |
|
982 return KErrNone; |
|
983 } |
|
984 |
|
985 TInt CSenServDesc::MT_CSenFacet_SetValueLL( TTestResult& aResult ) |
|
986 { |
|
987 SetupL(); |
|
988 |
|
989 CSenFacet* senFacet = CSenFacet::NewL(); |
|
990 if(!(senFacet->Value() == KNullDesC8))return KErrArgument; |
|
991 |
|
992 senFacet->SetValueL(KText); |
|
993 if(!(senFacet->Value() == KText))return KErrArgument; |
|
994 |
|
995 |
|
996 //checking xml |
|
997 _LIT16(KRef, "<Facet>text</Facet>"); |
|
998 TL(ConvertToPtr16LC(*senFacet) == KRef); |
|
999 |
|
1000 CleanupStack::PopAndDestroy();//Ptr |
|
1001 |
|
1002 if(!(senFacet->Value() == KText))return KErrArgument; |
|
1003 |
|
1004 delete senFacet; |
|
1005 senFacet = NULL; |
|
1006 Teardown(); |
|
1007 return KErrNone; |
|
1008 } |
|
1009 |
|
1010 TInt CSenServDesc::MT_CSenFacet_NameL( TTestResult& aResult ) |
|
1011 { |
|
1012 return MT_CSenFacet_SetNameLL(aResult); |
|
1013 } |
|
1014 |
|
1015 TInt CSenServDesc::MT_CSenFacet_TypeL( TTestResult& aResult ) |
|
1016 { |
|
1017 return MT_CSenFacet_SetTypeLL(aResult); |
|
1018 } |
|
1019 |
|
1020 TInt CSenServDesc::MT_CSenFacet_ValueL( TTestResult& aResult ) |
|
1021 { |
|
1022 return MT_CSenFacet_SetValueLL(aResult); |
|
1023 } |
|
1024 TInt CSenServDesc::MT_CSenIdentityProvider_NewL_L( TTestResult& aResult ) |
|
1025 { |
|
1026 SetupL(); |
|
1027 |
|
1028 CSenIdentityProvider* idProvider = CSenIdentityProvider::NewL(KText); |
|
1029 /*EUNIT_ASSERT_NOT_EQUALS(idProvider, (CSenIdentityProvider*)NULL);*/ |
|
1030 TL(idProvider != (CSenIdentityProvider*)NULL); |
|
1031 |
|
1032 //checking xml |
|
1033 _LIT16(KRef, "<IdentityProvider framework=\"ID-WSF\"><Endpoint>text</Endpoint><Contract>urn:liberty:as:2004-04</Contract><ProviderPolicy/><ServicePolicy/></IdentityProvider>"); |
|
1034 /*EUNIT_ASSERT_EQUALS(ConvertToPtr16LC(*idProvider), KRef);*/ |
|
1035 TL(ConvertToPtr16LC(*idProvider) == KRef); |
|
1036 CleanupStack::PopAndDestroy();//Ptr |
|
1037 |
|
1038 |
|
1039 /*__ASSERT_ALWAYS_NO_LEAVE(delete idProvider);*/ |
|
1040 __ASSERT_ALWAYS_NO_LEAVE(delete idProvider); |
|
1041 idProvider = NULL; |
|
1042 Teardown(); |
|
1043 return KErrNone; |
|
1044 |
|
1045 } |
|
1046 |
|
1047 |
|
1048 TInt CSenServDesc::MT_CSenIdentityProvider_NewLCL( TTestResult& aResult ) |
|
1049 { |
|
1050 SetupL(); |
|
1051 |
|
1052 CSenIdentityProvider* idProvider = CSenIdentityProvider::NewLC(KText); |
|
1053 TL(idProvider != (CSenIdentityProvider*)NULL); |
|
1054 |
|
1055 //checking xml |
|
1056 //_LIT16(KRef, "<IdentityProvider framework=\"ID-WSF\"><Endpoint>text</Endpoint><Contract>urn:liberty:as:2004-04</Contract><ProviderPolicy/><ServicePolicy/></IdentityProvider>"); |
|
1057 |
|
1058 //TL(ConvertToPtr16LC(*idProvider) == KRef); |
|
1059 |
|
1060 //CleanupStack::PopAndDestroy();//Ptr |
|
1061 |
|
1062 CleanupStack::Pop(); |
|
1063 __ASSERT_ALWAYS_NO_LEAVE(delete idProvider); |
|
1064 idProvider = NULL; |
|
1065 Teardown(); |
|
1066 return KErrNone; |
|
1067 } |
|
1068 |
|
1069 TInt CSenServDesc::MT_CSenIdentityProvider_NewL_1L( TTestResult& aResult ) |
|
1070 { |
|
1071 SetupL(); |
|
1072 |
|
1073 CSenIdentityProvider* idProvider = CSenIdentityProvider::NewL(KText, KText); |
|
1074 TL(idProvider != (CSenIdentityProvider*)NULL); |
|
1075 |
|
1076 //checking xml |
|
1077 //_LIT16(KRef, "<IdentityProvider><Endpoint>text</Endpoint><Contract>text</Contract><ProviderPolicy/><ServicePolicy/></IdentityProvider>"); |
|
1078 //TL(ConvertToPtr16LC(*idProvider) == KRef); |
|
1079 |
|
1080 //CleanupStack::PopAndDestroy();//Ptr |
|
1081 |
|
1082 __ASSERT_ALWAYS_NO_LEAVE(delete idProvider); |
|
1083 idProvider = NULL; |
|
1084 Teardown(); |
|
1085 return KErrNone; |
|
1086 } |
|
1087 |
|
1088 TInt CSenServDesc::MT_CSenIdentityProvider_NewLC_1L( TTestResult& aResult ) |
|
1089 { |
|
1090 SetupL(); |
|
1091 |
|
1092 CSenIdentityProvider* idProvider = CSenIdentityProvider::NewLC(KText, KText); |
|
1093 TL(idProvider != (CSenIdentityProvider*)NULL); |
|
1094 |
|
1095 //checking xml |
|
1096 //_LIT16(KRef, "<IdentityProvider><Endpoint>text</Endpoint><Contract>text</Contract><ProviderPolicy/><ServicePolicy/></IdentityProvider>"); |
|
1097 //TL(ConvertToPtr16LC(*idProvider) == KRef); |
|
1098 |
|
1099 //CleanupStack::PopAndDestroy();//Ptr |
|
1100 CleanupStack::Pop(); |
|
1101 __ASSERT_ALWAYS_NO_LEAVE(delete idProvider); |
|
1102 idProvider = NULL; |
|
1103 Teardown(); |
|
1104 return KErrNone; |
|
1105 } |
|
1106 |
|
1107 TInt CSenServDesc::MT_CSenIdentityProvider_NewL_2L( TTestResult& aResult ) |
|
1108 { |
|
1109 SetupL(); |
|
1110 |
|
1111 CSenIdentityProvider* idProvider = CSenIdentityProvider::NewL(KText, KText, KText); |
|
1112 TL(idProvider != (CSenIdentityProvider*)NULL); |
|
1113 |
|
1114 //checking xml |
|
1115 //_LIT16(KRef, "<IdentityProvider><Endpoint>text</Endpoint><Contract>text</Contract><ProviderPolicy/><ServicePolicy/><ProviderID>text</ProviderID></IdentityProvider>"); |
|
1116 //TL(ConvertToPtr16LC(*idProvider) == KRef); |
|
1117 |
|
1118 //CleanupStack::PopAndDestroy();//Ptr |
|
1119 __ASSERT_ALWAYS_NO_LEAVE(delete idProvider); |
|
1120 idProvider = NULL; |
|
1121 Teardown(); |
|
1122 return KErrNone; |
|
1123 } |
|
1124 |
|
1125 TInt CSenServDesc::MT_CSenIdentityProvider_NewLC_2L( TTestResult& aResult ) |
|
1126 { |
|
1127 SetupL(); |
|
1128 |
|
1129 CSenIdentityProvider* idProvider = CSenIdentityProvider::NewLC(KText, KText, KText); |
|
1130 TL(idProvider != (CSenIdentityProvider*)NULL); |
|
1131 |
|
1132 //checking xml |
|
1133 //_LIT16(KRef, "<IdentityProvider><Endpoint>text</Endpoint><Contract>text</Contract><ProviderPolicy/><ServicePolicy/><ProviderID>text</ProviderID></IdentityProvider>"); |
|
1134 //TL(ConvertToPtr16LC(*idProvider) == KRef); |
|
1135 |
|
1136 //CleanupStack::PopAndDestroy();//Ptr |
|
1137 CleanupStack::Pop(); |
|
1138 __ASSERT_ALWAYS_NO_LEAVE(delete idProvider); |
|
1139 idProvider = NULL; |
|
1140 Teardown(); |
|
1141 return KErrNone; |
|
1142 } |
|
1143 |
|
1144 TInt CSenServDesc::MT_CSenIdentityProvider_NewL_3L( TTestResult& aResult ) |
|
1145 { |
|
1146 SetupL(); |
|
1147 |
|
1148 CSenIdentityProvider* idProvider = CSenIdentityProvider::NewL(KText, KText, KText, KText); |
|
1149 TL(idProvider != (CSenIdentityProvider*)NULL); |
|
1150 |
|
1151 //checking xml |
|
1152 //_LIT16(KRef, "<IdentityProvider><Endpoint>text</Endpoint><Contract>text</Contract><ProviderPolicy/><ServicePolicy/><ProviderID>text</ProviderID><ServiceID>text</ServiceID></IdentityProvider>"); |
|
1153 //TL(ConvertToPtr16LC(*idProvider) == KRef); |
|
1154 |
|
1155 //CleanupStack::PopAndDestroy();//Ptr |
|
1156 __ASSERT_ALWAYS_NO_LEAVE(delete idProvider); |
|
1157 idProvider = NULL; |
|
1158 Teardown(); |
|
1159 return KErrNone; |
|
1160 } |
|
1161 |
|
1162 TInt CSenServDesc::MT_CSenIdentityProvider_NewLC_3L( TTestResult& aResult ) |
|
1163 { |
|
1164 SetupL(); |
|
1165 |
|
1166 CSenIdentityProvider* idProvider = CSenIdentityProvider::NewLC(KText, KText, KText, KText); |
|
1167 TL(idProvider != (CSenIdentityProvider*)NULL); |
|
1168 |
|
1169 //checking xml |
|
1170 //_LIT16(KRef, "<IdentityProvider><Endpoint>text</Endpoint><Contract>text</Contract><ProviderPolicy/><ServicePolicy/><ProviderID>text</ProviderID><ServiceID>text</ServiceID></IdentityProvider>"); |
|
1171 //TL(ConvertToPtr16LC(*idProvider) == KRef); |
|
1172 |
|
1173 //CleanupStack::PopAndDestroy();//Ptr |
|
1174 CleanupStack::Pop(); |
|
1175 __ASSERT_ALWAYS_NO_LEAVE(delete idProvider); |
|
1176 idProvider = NULL; |
|
1177 Teardown(); |
|
1178 return KErrNone; |
|
1179 } |
|
1180 |
|
1181 TInt CSenServDesc::MT_CSenIdentityProvider_AuthzIDL( TTestResult& aResult ) |
|
1182 { |
|
1183 SetupL(); |
|
1184 |
|
1185 CSenIdentityProvider* idProvider = CSenIdentityProvider::NewL(KText); |
|
1186 TL(idProvider->AuthzID() == KNullDesC8); |
|
1187 |
|
1188 __ASSERT_ALWAYS_NO_LEAVE(idProvider->AuthzID()); |
|
1189 idProvider->SetUserInfoL(KText2, KNullDesC8, KNullDesC8); |
|
1190 idProvider->SetUserInfoL(KText, KNullDesC8, KNullDesC8); |
|
1191 |
|
1192 //checking xml |
|
1193 _LIT16(KRef, "<IdentityProvider framework=\"ID-WSF\"><Endpoint>text</Endpoint><Contract>urn:liberty:as:2004-04</Contract><ProviderPolicy/><ServicePolicy/><AuthzID>text</AuthzID></IdentityProvider>"); |
|
1194 |
|
1195 TPtr16 ptr = ConvertToPtr16LC(*idProvider); |
|
1196 TInt posId(-1); |
|
1197 TPtrC16 messageToParse; |
|
1198 messageToParse.Set(ptr); |
|
1199 posId = messageToParse.Find(_L("<AuthzID>")); |
|
1200 TL(posId != -1); |
|
1201 CleanupStack::PopAndDestroy();//Ptr |
|
1202 |
|
1203 TL(idProvider->AuthzID() == KText); |
|
1204 |
|
1205 |
|
1206 __ASSERT_ALWAYS_NO_LEAVE(delete idProvider); |
|
1207 idProvider = NULL; |
|
1208 Teardown(); |
|
1209 return KErrNone; |
|
1210 } |
|
1211 |
|
1212 TInt CSenServDesc::MT_CSenIdentityProvider_AdvisoryAuthnIDL( TTestResult& aResult ) |
|
1213 { |
|
1214 SetupL(); |
|
1215 |
|
1216 CSenIdentityProvider* idProvider = CSenIdentityProvider::NewL(KText); |
|
1217 TL(idProvider->AdvisoryAuthnID() == KNullDesC8); |
|
1218 |
|
1219 __ASSERT_ALWAYS_NO_LEAVE(idProvider->AdvisoryAuthnID()); |
|
1220 idProvider->SetUserInfoL(KNullDesC8, KText2, KNullDesC8); |
|
1221 idProvider->SetUserInfoL(KNullDesC8, KText, KNullDesC8); |
|
1222 |
|
1223 //checking xml |
|
1224 _LIT16(KRef, "<IdentityProvider framework=\"ID-WSF\"><Endpoint>text</Endpoint><Contract>urn:liberty:as:2004-04</Contract><ProviderPolicy/><ServicePolicy/><AdvisoryAuthnID>text</AdvisoryAuthnID></IdentityProvider>"); |
|
1225 |
|
1226 // TL(ConvertToPtr16LC(*idProvider) == KRef); |
|
1227 |
|
1228 //CleanupStack::PopAndDestroy();//Ptr |
|
1229 |
|
1230 TPtr16 ptr = ConvertToPtr16LC(*idProvider); |
|
1231 TInt posId(-1); |
|
1232 TPtrC16 messageToParse; |
|
1233 messageToParse.Set(ptr); |
|
1234 posId = messageToParse.Find(_L("<AdvisoryAuthnID>")); |
|
1235 TL(posId != -1); |
|
1236 CleanupStack::PopAndDestroy();//Ptr |
|
1237 |
|
1238 TL(idProvider->AdvisoryAuthnID() == KText); |
|
1239 |
|
1240 |
|
1241 __ASSERT_ALWAYS_NO_LEAVE(delete idProvider); |
|
1242 idProvider = NULL; |
|
1243 Teardown(); |
|
1244 return KErrNone; |
|
1245 } |
|
1246 |
|
1247 TInt CSenServDesc::MT_CSenIdentityProvider_ProviderIDL( TTestResult& aResult ) |
|
1248 { |
|
1249 SetupL(); |
|
1250 |
|
1251 CSenIdentityProvider* idProvider = CSenIdentityProvider::NewL(KText, KText, KText2); |
|
1252 __ASSERT_ALWAYS_NO_LEAVE(idProvider->ProviderID()); |
|
1253 TL(idProvider->ProviderID() == KText2); |
|
1254 |
|
1255 delete idProvider; |
|
1256 idProvider = NULL; |
|
1257 Teardown(); |
|
1258 return KErrNone; |
|
1259 } |
|
1260 |
|
1261 TInt CSenServDesc::MT_CSenIdentityProvider_PasswordL( TTestResult& aResult ) |
|
1262 { |
|
1263 SetupL(); |
|
1264 |
|
1265 CSenIdentityProvider* idProvider = CSenIdentityProvider::NewL(KText); |
|
1266 __ASSERT_ALWAYS_NO_LEAVE(idProvider->Password()); |
|
1267 TL(idProvider->Password() == KNullDesC8); |
|
1268 |
|
1269 idProvider->SetUserInfoL(KNullDesC8, KNullDesC8, KText2); |
|
1270 idProvider->SetUserInfoL(KNullDesC8, KNullDesC8, KText); |
|
1271 //checking xml |
|
1272 _LIT16(KRef, "<IdentityProvider framework=\"ID-WSF\"><Endpoint>text</Endpoint><Contract>urn:liberty:as:2004-04</Contract><ProviderPolicy/><ServicePolicy/><Password>text</Password></IdentityProvider>"); |
|
1273 //TL(ConvertToPtr16LC(*idProvider) == KRef); |
|
1274 |
|
1275 //CleanupStack::PopAndDestroy();//Ptr |
|
1276 TPtr16 ptr = ConvertToPtr16LC(*idProvider); |
|
1277 TInt posId(-1); |
|
1278 TPtrC16 messageToParse; |
|
1279 messageToParse.Set(ptr); |
|
1280 posId = messageToParse.Find(_L("<Password>")); |
|
1281 TL(posId != -1); |
|
1282 CleanupStack::PopAndDestroy();//Ptr |
|
1283 |
|
1284 TL(idProvider->Password() == KText); |
|
1285 |
|
1286 |
|
1287 __ASSERT_ALWAYS_NO_LEAVE(delete idProvider); |
|
1288 idProvider = NULL; |
|
1289 Teardown(); |
|
1290 return KErrNone; |
|
1291 } |
|
1292 |
|
1293 TInt CSenServDesc::MT_CSenIdentityProvider_IMEIL( TTestResult& aResult ) |
|
1294 { |
|
1295 SetupL(); |
|
1296 |
|
1297 CSenIdentityProvider* idProvider = CSenIdentityProvider::NewL(KText); |
|
1298 __ASSERT_ALWAYS_NO_LEAVE(idProvider->IMEI()); |
|
1299 idProvider->IMEI(); |
|
1300 |
|
1301 __ASSERT_ALWAYS_NO_LEAVE(delete idProvider); |
|
1302 idProvider = NULL; |
|
1303 Teardown(); |
|
1304 return KErrNone; |
|
1305 } |
|
1306 |
|
1307 TInt CSenServDesc::MT_CSenIdentityProvider_UserNameL( TTestResult& aResult ) |
|
1308 { |
|
1309 SetupL(); |
|
1310 |
|
1311 CSenIdentityProvider* idProvider = CSenIdentityProvider::NewL(KText); |
|
1312 __ASSERT_ALWAYS_NO_LEAVE(idProvider->UserName()); |
|
1313 TL(idProvider->UserName() == KNullDesC8); |
|
1314 |
|
1315 idProvider->SetUserInfoL(KNullDesC8, KText, KNullDesC8); |
|
1316 TL(idProvider->UserName()== KText); |
|
1317 |
|
1318 idProvider->SetUserInfoL(KText, KNullDesC8, KNullDesC8); |
|
1319 TL(idProvider->UserName() == KText); |
|
1320 |
|
1321 idProvider->SetUserInfoL(KNullDesC8, KNullDesC8, KText); |
|
1322 |
|
1323 __ASSERT_ALWAYS_NO_LEAVE(delete idProvider); |
|
1324 idProvider = NULL; |
|
1325 Teardown(); |
|
1326 return KErrNone; |
|
1327 } |
|
1328 |
|
1329 TInt CSenServDesc::MT_CSenIdentityProvider_SetProviderIDL( TTestResult& aResult ) |
|
1330 { |
|
1331 SetupL(); |
|
1332 |
|
1333 CSenIdentityProvider* idProvider = CSenIdentityProvider::NewL(KText); |
|
1334 __ASSERT_ALWAYS_NO_LEAVE(idProvider->SetProviderID(KText2)); |
|
1335 __ASSERT_ALWAYS_NO_LEAVE(idProvider->SetProviderID(KText)); |
|
1336 //checking xml |
|
1337 _LIT16(KRef, "<IdentityProvider framework=\"ID-WSF\"><Endpoint>text</Endpoint><Contract>urn:liberty:as:2004-04</Contract><ProviderPolicy/><ServicePolicy/><ProviderID>text</ProviderID></IdentityProvider>"); |
|
1338 //TL(ConvertToPtr16LC(*idProvider) == KRef); |
|
1339 TPtr16 ptr = ConvertToPtr16LC(*idProvider); |
|
1340 TInt posId(-1); |
|
1341 TPtrC16 messageToParse; |
|
1342 messageToParse.Set(ptr); |
|
1343 posId = messageToParse.Find(_L("<ProviderID>")); |
|
1344 TL(posId != -1); |
|
1345 CleanupStack::PopAndDestroy();//Ptr |
|
1346 __ASSERT_ALWAYS_NO_LEAVE(delete idProvider); |
|
1347 idProvider = NULL; |
|
1348 Teardown(); |
|
1349 return KErrNone; |
|
1350 } |
|
1351 |
|
1352 TInt CSenServDesc::MT_CSenIdentityProvider_SetServiceIDL( TTestResult& aResult ) |
|
1353 { |
|
1354 SetupL(); |
|
1355 |
|
1356 CSenIdentityProvider* idProvider = CSenIdentityProvider::NewL(KText); |
|
1357 __ASSERT_ALWAYS_NO_LEAVE(idProvider->SetServiceID(KText2)); |
|
1358 __ASSERT_ALWAYS_NO_LEAVE(idProvider->SetServiceID(KText)); |
|
1359 //checking xml |
|
1360 _LIT16(KRef, "<IdentityProvider framework=\"ID-WSF\"><Endpoint>text</Endpoint><Contract>urn:liberty:as:2004-04</Contract><ProviderPolicy/><ServicePolicy/><ServiceID>text</ServiceID></IdentityProvider>"); |
|
1361 //TL(ConvertToPtr16LC(*idProvider) == KRef); |
|
1362 |
|
1363 TPtr16 ptr = ConvertToPtr16LC(*idProvider); |
|
1364 TInt posId(-1); |
|
1365 TPtrC16 messageToParse; |
|
1366 messageToParse.Set(ptr); |
|
1367 posId = messageToParse.Find(_L("<ServiceID>")); |
|
1368 TL(posId != -1); |
|
1369 CleanupStack::PopAndDestroy();//Ptr |
|
1370 |
|
1371 __ASSERT_ALWAYS_NO_LEAVE(delete idProvider); |
|
1372 idProvider = NULL; |
|
1373 Teardown(); |
|
1374 return KErrNone; |
|
1375 } |
|
1376 |
|
1377 TInt CSenServDesc::MT_CSenIdentityProvider_IsTrustedByLL( TTestResult& aResult ) |
|
1378 { |
|
1379 SetupL(); |
|
1380 TBool retVal; |
|
1381 CSenXmlServiceDescription* serviceDesc = CSenXmlServiceDescription::NewL(KText, KText2) ; |
|
1382 CSenIdentityProvider* idProvider = CSenIdentityProvider::NewL(_L8("endpoint"), _L8("contract"), KText, KText2); |
|
1383 retVal = idProvider->IsTrustedByL(*serviceDesc); |
|
1384 |
|
1385 if(retVal); |
|
1386 |
|
1387 __ASSERT_ALWAYS_NO_LEAVE(delete idProvider); |
|
1388 idProvider = NULL; |
|
1389 __ASSERT_ALWAYS_NO_LEAVE(delete serviceDesc); |
|
1390 serviceDesc = NULL; |
|
1391 Teardown(); |
|
1392 return KErrNone; |
|
1393 } |
|
1394 |
|
1395 TInt CSenServDesc::MT_CSenIdentityProvider_IsTrustedByL1L( TTestResult& aResult ) |
|
1396 { |
|
1397 SetupL(); |
|
1398 TBool retVal; |
|
1399 CSenIdentityProvider* idProvider = CSenIdentityProvider::NewL(_L8("endpoint"), _L8("contract"), KText, KText2); |
|
1400 retVal = idProvider->IsTrustedByL(KText); |
|
1401 |
|
1402 if(retVal); |
|
1403 __ASSERT_ALWAYS_NO_LEAVE(delete idProvider); |
|
1404 idProvider = NULL; |
|
1405 Teardown(); |
|
1406 return KErrNone; |
|
1407 } |
|
1408 |
|
1409 |
|
1410 TInt CSenServDesc::MT_CSenIdentityProvider_IsDefaultL( TTestResult& aResult ) |
|
1411 { |
|
1412 SetupL(); |
|
1413 TBool retVal; |
|
1414 CSenIdentityProvider* idProvider = CSenIdentityProvider::NewL(KText); |
|
1415 retVal = idProvider->IsDefault(); |
|
1416 |
|
1417 if(retVal); |
|
1418 |
|
1419 __ASSERT_ALWAYS_NO_LEAVE(delete idProvider); |
|
1420 idProvider = NULL; |
|
1421 Teardown(); |
|
1422 return KErrNone; |
|
1423 } |
|
1424 |
|
1425 |
|
1426 |
|
1427 TInt CSenServDesc::MT_CSenIdentityProvider_HttpCredentialsLL( TTestResult& aResult ) |
|
1428 { |
|
1429 SetupL(); |
|
1430 |
|
1431 CSenIdentityProvider* idProvider = CSenIdentityProvider::NewL(KText); |
|
1432 //retVal = idProvider->HttpCredentialsL(); |
|
1433 |
|
1434 |
|
1435 __ASSERT_ALWAYS_NO_LEAVE(delete idProvider); |
|
1436 idProvider = NULL; |
|
1437 Teardown(); |
|
1438 return KErrNone; |
|
1439 } |
|
1440 |
|
1441 TInt CSenServDesc::MT_CSenIdentityProvider_NewElementNameL( TTestResult& aResult ) |
|
1442 { |
|
1443 SetupL(); |
|
1444 |
|
1445 CSenIdentityProvider* idProvider = CSenIdentityProvider::NewL(KText); |
|
1446 TL(idProvider->NewElementName() == _L8("IdentityProvider")); |
|
1447 |
|
1448 __ASSERT_ALWAYS_NO_LEAVE(idProvider->NewElementName()); |
|
1449 __ASSERT_ALWAYS_NO_LEAVE(delete idProvider); |
|
1450 idProvider = NULL; |
|
1451 Teardown(); |
|
1452 return KErrNone; |
|
1453 } |
|
1454 |
|
1455 TInt CSenServDesc::MT_CSenIdentityProviderIdArray8_NewLL( TTestResult& aResult ) |
|
1456 { |
|
1457 SetupL(); |
|
1458 |
|
1459 CSenIdentityProviderIdArray8* array = CSenIdentityProviderIdArray8::NewL(); |
|
1460 TL(array->IsStrict() == FALSE); |
|
1461 |
|
1462 __ASSERT_ALWAYS_NO_LEAVE(delete array); |
|
1463 array = NULL; |
|
1464 Teardown(); |
|
1465 return KErrNone; |
|
1466 } |
|
1467 |
|
1468 TInt CSenServDesc::MT_CSenIdentityProviderIdArray8_NewLCL( TTestResult& aResult ) |
|
1469 { |
|
1470 SetupL(); |
|
1471 |
|
1472 CSenIdentityProviderIdArray8* array = CSenIdentityProviderIdArray8::NewLC(); |
|
1473 TL(array->IsStrict() == FALSE); |
|
1474 |
|
1475 __ASSERT_ALWAYS_NO_LEAVE(delete array); |
|
1476 CleanupStack::Pop(); |
|
1477 array = NULL; |
|
1478 Teardown(); |
|
1479 return KErrNone; |
|
1480 } |
|
1481 |
|
1482 TInt CSenServDesc::MT_CSenIdentityProviderIdArray8_NewL_1L( TTestResult& aResult ) |
|
1483 { |
|
1484 SetupL(); |
|
1485 |
|
1486 CSenIdentityProviderIdArray8* array = CSenIdentityProviderIdArray8::NewL(FALSE); |
|
1487 TL(array->IsStrict() == FALSE); |
|
1488 |
|
1489 __ASSERT_ALWAYS_NO_LEAVE(delete array); |
|
1490 array = NULL; |
|
1491 |
|
1492 array = CSenIdentityProviderIdArray8::NewL(TRUE); |
|
1493 TL(array->IsStrict() == TRUE); |
|
1494 |
|
1495 __ASSERT_ALWAYS_NO_LEAVE(delete array); |
|
1496 array = NULL; |
|
1497 |
|
1498 Teardown(); |
|
1499 return KErrNone; |
|
1500 } |
|
1501 |
|
1502 TInt CSenServDesc::MT_CSenIdentityProviderIdArray8_NewLC_1L( TTestResult& aResult ) |
|
1503 { |
|
1504 SetupL(); |
|
1505 |
|
1506 CSenIdentityProviderIdArray8* array = CSenIdentityProviderIdArray8::NewLC(FALSE); |
|
1507 TL(array->IsStrict() == FALSE); |
|
1508 |
|
1509 __ASSERT_ALWAYS_NO_LEAVE(delete array); |
|
1510 CleanupStack::Pop(); |
|
1511 array = NULL; |
|
1512 |
|
1513 array = CSenIdentityProviderIdArray8::NewLC(TRUE); |
|
1514 TL(array->IsStrict() == TRUE); |
|
1515 |
|
1516 __ASSERT_ALWAYS_NO_LEAVE(delete array); |
|
1517 CleanupStack::Pop(); |
|
1518 array = NULL; |
|
1519 Teardown(); |
|
1520 return KErrNone; |
|
1521 } |
|
1522 |
|
1523 TInt CSenServDesc::MT_CSenIdentityProviderIdArray8_IsStrictL( TTestResult& aResult ) |
|
1524 { |
|
1525 SetupL(); |
|
1526 |
|
1527 CSenIdentityProviderIdArray8* array = CSenIdentityProviderIdArray8::NewL(); |
|
1528 __ASSERT_ALWAYS_NO_LEAVE(array->SetStrict(TRUE)); |
|
1529 TL(array->IsStrict() == TRUE); |
|
1530 |
|
1531 __ASSERT_ALWAYS_NO_LEAVE(array->SetStrict(FALSE)); |
|
1532 TL(array->IsStrict() == FALSE); |
|
1533 |
|
1534 __ASSERT_ALWAYS_NO_LEAVE(delete array); |
|
1535 array = NULL; |
|
1536 Teardown(); |
|
1537 return KErrNone; |
|
1538 } |
|
1539 |
|
1540 TInt CSenServDesc::MT_CSenIdentityProviderIdArray8_SetStrictL( TTestResult& aResult ) |
|
1541 { |
|
1542 return MT_CSenIdentityProviderIdArray8_IsStrictL(aResult); |
|
1543 } |
|
1544 |
|
1545 TInt CSenServDesc::MT_CSenServicePattern_NewLL( TTestResult& aResult ) |
|
1546 { |
|
1547 SetupL(); |
|
1548 |
|
1549 CSenServicePattern* pattern = CSenServicePattern::NewL(); |
|
1550 //checking xml |
|
1551 //_LIT16(KRef, "<ServiceDescription><ProviderPolicy/><ServicePolicy/></ServiceDescription>"); |
|
1552 //TL(ConvertToPtr16LC(*pattern) == KRef); |
|
1553 |
|
1554 //CleanupStack::PopAndDestroy();//Ptr |
|
1555 __ASSERT_ALWAYS_NO_LEAVE(delete pattern); |
|
1556 pattern = NULL; |
|
1557 Teardown(); |
|
1558 return KErrNone; |
|
1559 } |
|
1560 |
|
1561 TInt CSenServDesc::MT_CSenServicePattern_NewLCL( TTestResult& aResult ) |
|
1562 { |
|
1563 SetupL(); |
|
1564 |
|
1565 CSenServicePattern* pattern = CSenServicePattern::NewLC(); |
|
1566 //checking xml |
|
1567 //_LIT16(KRef, "<ServiceDescription><ProviderPolicy/><ServicePolicy/></ServiceDescription>"); |
|
1568 //TL(ConvertToPtr16LC(*pattern) == KRef); |
|
1569 |
|
1570 //CleanupStack::PopAndDestroy();//Ptr |
|
1571 CleanupStack::Pop(); |
|
1572 __ASSERT_ALWAYS_NO_LEAVE(delete pattern); |
|
1573 pattern = NULL; |
|
1574 Teardown(); |
|
1575 return KErrNone; |
|
1576 } |
|
1577 |
|
1578 TInt CSenServDesc::MT_CSenServicePattern_NewL_1L( TTestResult& aResult ) |
|
1579 { |
|
1580 SetupL(); |
|
1581 |
|
1582 CSenServicePattern* pattern = CSenServicePattern::NewL(KText); |
|
1583 //checking xml |
|
1584 //_LIT16(KRef, "<ServiceDescription xmlns=\"text\"><ProviderPolicy/><ServicePolicy/></ServiceDescription>"); |
|
1585 //TL(ConvertToPtr16LC(*pattern) == KRef); |
|
1586 |
|
1587 //CleanupStack::PopAndDestroy();//Ptr |
|
1588 __ASSERT_ALWAYS_NO_LEAVE(delete pattern); |
|
1589 pattern = NULL; |
|
1590 Teardown(); |
|
1591 return KErrNone; |
|
1592 } |
|
1593 |
|
1594 TInt CSenServDesc::MT_CSenServicePattern_NewLC_1L( TTestResult& aResult ) |
|
1595 { |
|
1596 SetupL(); |
|
1597 |
|
1598 CSenServicePattern* pattern = CSenServicePattern::NewLC(KText); |
|
1599 //checking xml |
|
1600 //_LIT16(KRef, "<ServiceDescription xmlns=\"text\"><ProviderPolicy/><ServicePolicy/></ServiceDescription>"); |
|
1601 //TL(ConvertToPtr16LC(*pattern) == KRef); |
|
1602 |
|
1603 //CleanupStack::PopAndDestroy();//Ptr |
|
1604 CleanupStack::Pop(); |
|
1605 __ASSERT_ALWAYS_NO_LEAVE(delete pattern); |
|
1606 pattern = NULL; |
|
1607 Teardown(); |
|
1608 return KErrNone; |
|
1609 } |
|
1610 |
|
1611 TInt CSenServDesc::MT_CSenServicePattern_NewL_2L( TTestResult& aResult ) |
|
1612 { |
|
1613 SetupL(); |
|
1614 |
|
1615 CSenServicePattern* pattern = CSenServicePattern::NewL(KText, KText); |
|
1616 |
|
1617 //_LIT16(KRef, "<ServiceDescription><Endpoint>text</Endpoint><Contract>text</Contract><ProviderPolicy/><ServicePolicy/></ServiceDescription>"); |
|
1618 //TL(ConvertToPtr16LC(*pattern) == KRef); |
|
1619 |
|
1620 //CleanupStack::PopAndDestroy();//Ptr |
|
1621 __ASSERT_ALWAYS_NO_LEAVE(delete pattern); |
|
1622 pattern = NULL; |
|
1623 Teardown(); |
|
1624 return KErrNone; |
|
1625 } |
|
1626 |
|
1627 TInt CSenServDesc::MT_CSenServicePattern_NewLC_2L( TTestResult& aResult ) |
|
1628 { |
|
1629 SetupL(); |
|
1630 |
|
1631 CSenServicePattern* pattern = CSenServicePattern::NewLC(KText, KText); |
|
1632 |
|
1633 //_LIT16(KRef, "<ServiceDescription><Endpoint>text</Endpoint><Contract>text</Contract><ProviderPolicy/><ServicePolicy/></ServiceDescription>"); |
|
1634 //TL(ConvertToPtr16LC(*pattern) == KRef); |
|
1635 |
|
1636 //CleanupStack::PopAndDestroy();//Ptr |
|
1637 CleanupStack::Pop(); |
|
1638 __ASSERT_ALWAYS_NO_LEAVE(delete pattern); |
|
1639 pattern = NULL; |
|
1640 Teardown(); |
|
1641 return KErrNone; |
|
1642 } |
|
1643 |
|
1644 TInt CSenServDesc::MT_CSenServicePattern_MatchesL( TTestResult& aResult ) |
|
1645 { |
|
1646 SetupL(); |
|
1647 CSenServicePattern *pattern2; |
|
1648 CSenServicePattern *pattern; |
|
1649 |
|
1650 pattern = CSenServicePattern::NewL(); |
|
1651 //EUNIT_ASSERT_EQUALS(pattern->Matches(*pattern2), FALSE); |
|
1652 |
|
1653 pattern2 = CSenServicePattern::NewL(); |
|
1654 //checking xml |
|
1655 TL(pattern->Matches(*pattern2) == TRUE); |
|
1656 __ASSERT_ALWAYS_NO_LEAVE(delete pattern2); |
|
1657 pattern2 = NULL; |
|
1658 |
|
1659 CSenXmlServiceDescription* xmlDescr = CSenXmlServiceDescription::NewL(); |
|
1660 TL(pattern->Matches(*xmlDescr) == FALSE); |
|
1661 |
|
1662 __ASSERT_ALWAYS_NO_LEAVE(delete xmlDescr); |
|
1663 xmlDescr = NULL; |
|
1664 __ASSERT_ALWAYS_NO_LEAVE(delete pattern); |
|
1665 pattern = NULL; |
|
1666 Teardown(); |
|
1667 return KErrNone; |
|
1668 } |
|
1669 |
|
1670 TInt CSenServDesc::MT_CSenServicePattern_SetConsumerIapIdLL( TTestResult& aResult ) |
|
1671 { |
|
1672 SetupL(); |
|
1673 |
|
1674 CSenServicePattern* pattern = CSenServicePattern::NewL(); |
|
1675 //checking xml |
|
1676 |
|
1677 TUint32 iap(0); |
|
1678 TL(pattern->ConsumerIapId(iap) == KErrNotFound); |
|
1679 |
|
1680 |
|
1681 pattern->SetConsumerIapIdL(1); |
|
1682 __ASSERT_ALWAYS_NO_LEAVE(pattern->ConsumerIapId(iap)); |
|
1683 TL(pattern->ConsumerIapId(iap) == KErrNone); |
|
1684 |
|
1685 TL(iap == 1); |
|
1686 pattern->SetConsumerIapIdL(2); |
|
1687 __ASSERT_ALWAYS_NO_LEAVE(pattern->ConsumerIapId(iap)); |
|
1688 TL(pattern->ConsumerIapId(iap) == KErrNone); |
|
1689 |
|
1690 TL(iap == 2); |
|
1691 |
|
1692 __ASSERT_ALWAYS_NO_LEAVE(delete pattern); |
|
1693 pattern = NULL; |
|
1694 Teardown(); |
|
1695 return KErrNone; |
|
1696 } |
|
1697 |
|
1698 TInt CSenServDesc::MT_CSenServicePattern_ConsumerIapIdL( TTestResult& aResult ) |
|
1699 { |
|
1700 SetupL(); |
|
1701 |
|
1702 MT_CSenServicePattern_SetConsumerIapIdLL(aResult); |
|
1703 Teardown(); |
|
1704 return KErrNone; |
|
1705 } |
|
1706 TInt CSenServDesc::MT_CSenServicePattern_SetConsumerSnapIdLL( TTestResult& aResult ) |
|
1707 { |
|
1708 SetupL(); |
|
1709 |
|
1710 CSenServicePattern* pattern = CSenServicePattern::NewL(); |
|
1711 //checking xml |
|
1712 |
|
1713 TUint32 iap(0); |
|
1714 TL(pattern->ConsumerSnapId(iap) == KErrNotFound); |
|
1715 |
|
1716 |
|
1717 pattern->SetConsumerSnapIdL(1); |
|
1718 __ASSERT_ALWAYS_NO_LEAVE(pattern->ConsumerSnapId(iap)); |
|
1719 TL(pattern->ConsumerSnapId(iap) == KErrNone); |
|
1720 |
|
1721 TL(iap == 1); |
|
1722 |
|
1723 pattern->SetConsumerSnapIdL(0); |
|
1724 __ASSERT_ALWAYS_NO_LEAVE(pattern->ConsumerSnapId(iap)); |
|
1725 TL(pattern->ConsumerSnapId(iap) == KErrNotFound); |
|
1726 |
|
1727 // TL(iap == 0); |
|
1728 |
|
1729 __ASSERT_ALWAYS_NO_LEAVE(delete pattern); |
|
1730 pattern = NULL; |
|
1731 Teardown(); |
|
1732 |
|
1733 return KErrNone; |
|
1734 } |
|
1735 |
|
1736 TInt CSenServDesc::MT_CSenServicePattern_ConsumerSnapIdL( TTestResult& aResult ) |
|
1737 { |
|
1738 |
|
1739 SetupL(); |
|
1740 |
|
1741 MT_CSenServicePattern_SetConsumerSnapIdLL(aResult); |
|
1742 Teardown(); |
|
1743 |
|
1744 return KErrNone; |
|
1745 } |
|
1746 |
|
1747 |
|
1748 TInt CSenServDesc::MT_CSenServicePattern_SetConsumerIdentityProviderIdsLL( TTestResult& aResult ) |
|
1749 { |
|
1750 SetupL(); |
|
1751 |
|
1752 CSenServicePattern* pattern = CSenServicePattern::NewL(); |
|
1753 CSenIdentityProviderIdArray8* array = CSenIdentityProviderIdArray8::NewL(); |
|
1754 |
|
1755 |
|
1756 __ASSERT_ALWAYS_NO_LEAVE(pattern->SetConsumerIdentityProviderIdsL(*array)); |
|
1757 pattern->AddConsumerIdentityProviderIdL(KText); |
|
1758 __ASSERT_ALWAYS_NO_LEAVE(pattern->SetConsumerIdentityProviderIdsL(*array)); |
|
1759 array->AppendL(KText); |
|
1760 __ASSERT_ALWAYS_NO_LEAVE(pattern->SetConsumerIdentityProviderIdsL(*array)); |
|
1761 array->AppendL(KText2); |
|
1762 __ASSERT_ALWAYS_NO_LEAVE(pattern->SetConsumerIdentityProviderIdsL(*array)); |
|
1763 |
|
1764 TL((pattern->ConsumerIdentityProviderIds8L()).Count() == 2); |
|
1765 |
|
1766 TInt pos(0); |
|
1767 if(!((pattern->ConsumerIdentityProviderIds8L()).Find(KText, pos)==KErrNone))return KErrArgument; |
|
1768 |
|
1769 if(!((pattern->ConsumerIdentityProviderIds8L()).Find(KText2, pos)==KErrNone))return KErrArgument; |
|
1770 |
|
1771 __ASSERT_ALWAYS_NO_LEAVE(delete array); |
|
1772 array = NULL; |
|
1773 __ASSERT_ALWAYS_NO_LEAVE(delete pattern); |
|
1774 pattern = NULL; |
|
1775 Teardown(); |
|
1776 return KErrNone; |
|
1777 } |
|
1778 |
|
1779 TInt CSenServDesc::MT_CSenServicePattern_AddConsumerIdentityProviderIdLL( TTestResult& aResult ) |
|
1780 { |
|
1781 SetupL(); |
|
1782 |
|
1783 CSenServicePattern* pattern = CSenServicePattern::NewL(); |
|
1784 |
|
1785 |
|
1786 if(!(pattern->AddConsumerIdentityProviderIdL(KNullDesC8) == KErrArgument))return KErrArgument; |
|
1787 |
|
1788 if(!(pattern->AddConsumerIdentityProviderIdL(KText) == KErrNone))return KErrArgument; |
|
1789 |
|
1790 if(!(pattern->AddConsumerIdentityProviderIdL(KText) == KErrAlreadyExists))return KErrArgument; |
|
1791 |
|
1792 if(!(pattern->AddConsumerIdentityProviderIdL(KText2) == KErrNone))return KErrArgument; |
|
1793 |
|
1794 _LIT16(KRef, "<ServiceDescription><ProviderPolicy/><ServicePolicy/></ServiceDescription>"); |
|
1795 //TL(ConvertToPtr16LC(*pattern) == KRef); |
|
1796 |
|
1797 //CleanupStack::PopAndDestroy();//Ptr |
|
1798 |
|
1799 __ASSERT_ALWAYS_NO_LEAVE(delete pattern); |
|
1800 pattern = NULL; |
|
1801 Teardown(); |
|
1802 return KErrNone; |
|
1803 } |
|
1804 |
|
1805 TInt CSenServDesc::MT_CSenServicePattern_ConsumerIdentityProviderIds8LL( TTestResult& aResult ) |
|
1806 { |
|
1807 return MT_CSenServicePattern_SetConsumerIdentityProviderIdsLL(aResult); |
|
1808 } |
|
1809 |
|
1810 TInt CSenServDesc::MT_CSenServicePattern_AcceptsConsumerPolicyL( TTestResult& aResult ) |
|
1811 { |
|
1812 SetupL(); |
|
1813 |
|
1814 CSenServicePattern* pattern = CSenServicePattern::NewL(); |
|
1815 CSenIdentityProviderIdArray8* array = CSenIdentityProviderIdArray8::NewL(); |
|
1816 |
|
1817 pattern->SetConsumerIapIdL(1); |
|
1818 array->AppendL(KText); |
|
1819 |
|
1820 CSenServicePattern* pattern2 = CSenServicePattern::NewL(); |
|
1821 if(!(pattern2->RebuildFromConsumerPolicy(*pattern)==KErrNone))return KErrArgument; |
|
1822 |
|
1823 if(!(pattern2->AcceptsConsumerPolicy(*pattern)==TRUE))return KErrArgument; |
|
1824 |
|
1825 __ASSERT_ALWAYS_NO_LEAVE(delete array); |
|
1826 __ASSERT_ALWAYS_NO_LEAVE(delete pattern2); |
|
1827 array = NULL; |
|
1828 pattern2 = NULL; |
|
1829 //false |
|
1830 pattern2 = CSenServicePattern::NewL(); |
|
1831 pattern2->SetConsumerIapIdL(2); |
|
1832 if(!(pattern2->AcceptsConsumerPolicy(*pattern)==FALSE))return KErrArgument; |
|
1833 |
|
1834 __ASSERT_ALWAYS_NO_LEAVE(delete pattern2); |
|
1835 __ASSERT_ALWAYS_NO_LEAVE(delete pattern); |
|
1836 pattern2 = NULL; |
|
1837 pattern = NULL; |
|
1838 Teardown(); |
|
1839 return KErrNone; |
|
1840 } |
|
1841 |
|
1842 TInt CSenServDesc::MT_CSenServicePattern_RebuildFromConsumerPolicyL( TTestResult& aResult ) |
|
1843 { |
|
1844 return MT_CSenServicePattern_AcceptsConsumerPolicyL(aResult); |
|
1845 } |
|
1846 |
|
1847 TInt CSenServDesc::MT_CSenServicePattern_ConsumerPolicyAsXmlLL( TTestResult& aResult ) |
|
1848 { |
|
1849 SetupL(); |
|
1850 HBufC8* retVal; |
|
1851 CSenServicePattern* pattern = CSenServicePattern::NewL(); |
|
1852 |
|
1853 retVal = pattern->ConsumerPolicyAsXmlL(); |
|
1854 |
|
1855 if(retVal); |
|
1856 __ASSERT_ALWAYS_NO_LEAVE(delete pattern); |
|
1857 pattern = NULL; |
|
1858 Teardown(); |
|
1859 return KErrNone; |
|
1860 } |
|
1861 |
|
1862 TInt CSenServDesc::MT_CSenServicePattern_StartElementLL( TTestResult& aResult ) |
|
1863 { |
|
1864 SetupL(); |
|
1865 //HBufC8* retVal; |
|
1866 _LIT8(KText, "text"); |
|
1867 CSenServicePattern* pattern = CSenServicePattern::NewL(); |
|
1868 RAttributeArray array; |
|
1869 pattern->StartElementL(KText, KText, KText, array); |
|
1870 __ASSERT_ALWAYS_NO_LEAVE(delete pattern); |
|
1871 pattern = NULL; |
|
1872 Teardown(); |
|
1873 return KErrNone; |
|
1874 } |
|
1875 |
|
1876 |
|
1877 TInt CSenServDesc::MT_CSenXmlServiceDescription_NewLL( TTestResult& aResult ) |
|
1878 { |
|
1879 SetupL(); |
|
1880 |
|
1881 CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL(); |
|
1882 if(xmlService == NULL) |
|
1883 return KErrNoMemory; |
|
1884 //checking xml |
|
1885 //_LIT16(KRef, "<ServiceDescription><ProviderPolicy/><ServicePolicy/></ServiceDescription>"); |
|
1886 //TL(ConvertToPtr16LC(*xmlService) == KRef); |
|
1887 |
|
1888 //CleanupStack::PopAndDestroy();//Ptr |
|
1889 __ASSERT_ALWAYS_NO_LEAVE(delete xmlService); |
|
1890 xmlService = NULL; |
|
1891 Teardown(); |
|
1892 return KErrNone; |
|
1893 } |
|
1894 |
|
1895 TInt CSenServDesc::MT_CSenXmlServiceDescription_NewLCL( TTestResult& aResult ) |
|
1896 { |
|
1897 SetupL(); |
|
1898 |
|
1899 CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewLC(); |
|
1900 if(xmlService == NULL) |
|
1901 return KErrNoMemory; |
|
1902 //checking xml |
|
1903 //_LIT16(KRef, "<ServiceDescription><ProviderPolicy/><ServicePolicy/></ServiceDescription>"); |
|
1904 //TL(ConvertToPtr16LC(*xmlService) == KRef); |
|
1905 |
|
1906 //CleanupStack::PopAndDestroy();//Ptr |
|
1907 CleanupStack::Pop(); |
|
1908 __ASSERT_ALWAYS_NO_LEAVE(delete xmlService); |
|
1909 xmlService = NULL; |
|
1910 Teardown(); |
|
1911 return KErrNone; |
|
1912 } |
|
1913 |
|
1914 TInt CSenServDesc::MT_CSenXmlServiceDescription_NewL_1L( TTestResult& aResult ) |
|
1915 { |
|
1916 SetupL(); |
|
1917 |
|
1918 CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL(KText); |
|
1919 if(xmlService == NULL) |
|
1920 return KErrNoMemory; |
|
1921 //checking xml |
|
1922 //_LIT16(KRef, "<ServiceDescription xmlns=\"text\"><ProviderPolicy/><ServicePolicy/></ServiceDescription>"); |
|
1923 //TL(ConvertToPtr16LC(*xmlService) == KRef); |
|
1924 |
|
1925 //CleanupStack::PopAndDestroy();//Ptr |
|
1926 __ASSERT_ALWAYS_NO_LEAVE(delete xmlService); |
|
1927 xmlService = NULL; |
|
1928 Teardown(); |
|
1929 return KErrNone; |
|
1930 } |
|
1931 |
|
1932 TInt CSenServDesc::MT_CSenXmlServiceDescription_NewLC_1L( TTestResult& aResult ) |
|
1933 { |
|
1934 SetupL(); |
|
1935 |
|
1936 CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewLC(KText); |
|
1937 if(xmlService == NULL) |
|
1938 return KErrNoMemory; |
|
1939 //checking xml |
|
1940 //_LIT16(KRef, "<ServiceDescription xmlns=\"text\"><ProviderPolicy/><ServicePolicy/></ServiceDescription>"); |
|
1941 //TL(ConvertToPtr16LC(*xmlService) == KRef); |
|
1942 |
|
1943 //CleanupStack::PopAndDestroy();//Ptr |
|
1944 CleanupStack::Pop(); |
|
1945 __ASSERT_ALWAYS_NO_LEAVE(delete xmlService); |
|
1946 xmlService = NULL; |
|
1947 Teardown(); |
|
1948 return KErrNone; |
|
1949 } |
|
1950 |
|
1951 TInt CSenServDesc::MT_CSenXmlServiceDescription_NewL_2L( TTestResult& aResult ) |
|
1952 { |
|
1953 SetupL(); |
|
1954 |
|
1955 CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL(KText, KText); |
|
1956 if(xmlService == NULL) |
|
1957 return KErrNoMemory; |
|
1958 //checking xml |
|
1959 //_LIT16(KRef, "<ServiceDescription><Endpoint>text</Endpoint><Contract>text</Contract><ProviderPolicy/><ServicePolicy/></ServiceDescription>"); |
|
1960 //TL(ConvertToPtr16LC(*xmlService) == KRef); |
|
1961 |
|
1962 //CleanupStack::PopAndDestroy();//Ptr |
|
1963 __ASSERT_ALWAYS_NO_LEAVE(delete xmlService); |
|
1964 xmlService = NULL; |
|
1965 Teardown(); |
|
1966 return KErrNone; |
|
1967 } |
|
1968 |
|
1969 TInt CSenServDesc::MT_CSenXmlServiceDescription_NewLC_2L( TTestResult& aResult ) |
|
1970 { |
|
1971 SetupL(); |
|
1972 |
|
1973 CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewLC(KText, KText); |
|
1974 if(xmlService == NULL) |
|
1975 return KErrNoMemory; |
|
1976 //checking xml |
|
1977 //_LIT16(KRef, "<ServiceDescription><Endpoint>text</Endpoint><Contract>text</Contract><ProviderPolicy/><ServicePolicy/></ServiceDescription>"); |
|
1978 //TL(ConvertToPtr16LC(*xmlService) == KRef); |
|
1979 |
|
1980 //CleanupStack::PopAndDestroy();//Ptr |
|
1981 CleanupStack::Pop(); |
|
1982 __ASSERT_ALWAYS_NO_LEAVE(delete xmlService); |
|
1983 xmlService = NULL; |
|
1984 Teardown(); |
|
1985 return KErrNone; |
|
1986 } |
|
1987 |
|
1988 TInt CSenServDesc::MT_CSenXmlServiceDescription_SetFrameworkIdLL( TTestResult& aResult ) |
|
1989 { |
|
1990 SetupL(); |
|
1991 |
|
1992 CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL(); |
|
1993 |
|
1994 TL(xmlService->FrameworkId() == KNullDesC8); |
|
1995 |
|
1996 _LIT8(KFr, "ID-WSF"); |
|
1997 xmlService->SetFrameworkIdL(KFr); |
|
1998 //checking xml |
|
1999 _LIT16(KRef1, "<ServiceDescription framework=\"ID-WSF\"><ProviderPolicy/><ServicePolicy/></ServiceDescription>"); |
|
2000 //TL(ConvertToPtr16LC(*xmlService) == KRef1); |
|
2001 |
|
2002 TPtr16 ptr = ConvertToPtr16LC(*xmlService); |
|
2003 TInt posId(-1); |
|
2004 TPtrC16 messageToParse; |
|
2005 messageToParse.Set(ptr); |
|
2006 posId = messageToParse.Find(_L("framework=\"ID-WSF\"")); |
|
2007 TL(posId != -1); |
|
2008 CleanupStack::PopAndDestroy();//Ptr |
|
2009 TL(xmlService->FrameworkId() == KFr); |
|
2010 |
|
2011 //again |
|
2012 xmlService->SetFrameworkIdL(KFr); |
|
2013 //checking xml |
|
2014 //_LIT16(KRef2, "<ServiceDescription framework=\"ID-WSF\"><ProviderPolicy/><ServicePolicy/></ServiceDescription>"); |
|
2015 //TL(ConvertToPtr16LC(*xmlService) == KRef2); |
|
2016 |
|
2017 TPtr16 ptr1 = ConvertToPtr16LC(*xmlService); |
|
2018 posId = -1; |
|
2019 messageToParse.Set(ptr1); |
|
2020 posId = messageToParse.Find(_L("framework=\"ID-WSF\"")); |
|
2021 TL(posId != -1); |
|
2022 CleanupStack::PopAndDestroy();//Ptr1 |
|
2023 TL(xmlService->FrameworkId() == KFr); |
|
2024 |
|
2025 //again |
|
2026 xmlService->SetFrameworkIdL(KText); |
|
2027 //checking xml |
|
2028 //_LIT16(KRef3, "<ServiceDescription framework=\"text\"><ProviderPolicy/><ServicePolicy/></ServiceDescription>"); |
|
2029 //TL(ConvertToPtr16LC(*xmlService) == KRef3); |
|
2030 TPtr16 ptr2 = ConvertToPtr16LC(*xmlService); |
|
2031 posId =-1; |
|
2032 messageToParse.Set(ptr2); |
|
2033 posId = messageToParse.Find(_L("framework=\"text\"")); |
|
2034 TL(posId != -1); |
|
2035 CleanupStack::PopAndDestroy();//Ptr2 |
|
2036 TL(xmlService->FrameworkId() == KText); |
|
2037 |
|
2038 //clear |
|
2039 xmlService->SetFrameworkIdL(KNullDesC8); |
|
2040 //checking xml |
|
2041 //_LIT16(KRef4, "<ServiceDescription><ProviderPolicy/><ServicePolicy/></ServiceDescription>"); |
|
2042 //TL(ConvertToPtr16LC(*xmlService) == KRef4); |
|
2043 TPtr16 ptr3 = ConvertToPtr16LC(*xmlService); |
|
2044 posId = -1; |
|
2045 messageToParse.Set(ptr3); |
|
2046 posId = messageToParse.Find(_L("ServiceDescription")); |
|
2047 TL(posId != -1); |
|
2048 CleanupStack::PopAndDestroy();//Ptr3 |
|
2049 TL(xmlService->FrameworkId() == KNullDesC8); |
|
2050 |
|
2051 __ASSERT_ALWAYS_NO_LEAVE(delete xmlService); |
|
2052 xmlService = NULL; |
|
2053 Teardown(); |
|
2054 return KErrNone; |
|
2055 } |
|
2056 |
|
2057 TInt CSenServDesc::MT_CSenXmlServiceDescription_NewElementNameL( TTestResult& aResult ) |
|
2058 { |
|
2059 SetupL(); |
|
2060 |
|
2061 CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL(); |
|
2062 _LIT8(KRef, "ServiceDescription"); |
|
2063 if(!(xmlService ->NewElementName() == KRef))return KErrArgument; |
|
2064 |
|
2065 __ASSERT_ALWAYS_NO_LEAVE(delete xmlService); |
|
2066 xmlService = NULL; |
|
2067 Teardown(); |
|
2068 return KErrNone; |
|
2069 } |
|
2070 |
|
2071 TInt CSenServDesc::MT_CSenXmlServiceDescription_SetIapIdLL( TTestResult& aResult ) |
|
2072 { |
|
2073 SetupL(); |
|
2074 |
|
2075 CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL(); |
|
2076 TUint32 iap(0); |
|
2077 if(!((xmlService ->IapId(iap)) == KErrNotFound))return KErrArgument; |
|
2078 |
|
2079 xmlService ->SetIapIdL(1); |
|
2080 if(!(xmlService ->IapId(iap) == KErrNone))return KErrArgument; |
|
2081 |
|
2082 if(!(1))return KErrArgument; |
|
2083 |
|
2084 xmlService ->SetIapIdL(2); |
|
2085 if(!(xmlService ->IapId(iap) == KErrNone))return KErrArgument; |
|
2086 |
|
2087 if(!(2))return KErrArgument; |
|
2088 |
|
2089 __ASSERT_ALWAYS_NO_LEAVE(delete xmlService); |
|
2090 xmlService = NULL; |
|
2091 Teardown(); |
|
2092 return KErrNone; |
|
2093 } |
|
2094 |
|
2095 TInt CSenServDesc::MT_CSenXmlServiceDescription_IapIdL( TTestResult& aResult ) |
|
2096 { |
|
2097 return MT_CSenXmlServiceDescription_SetIapIdLL(aResult); |
|
2098 } |
|
2099 |
|
2100 TInt CSenServDesc::MT_CSenXmlServiceDescription_SetSnapIdLL( TTestResult& aResult ) |
|
2101 { |
|
2102 SetupL(); |
|
2103 |
|
2104 CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL(); |
|
2105 TUint32 iap(0); |
|
2106 if(!((xmlService ->SnapId(iap)) == KErrNotFound))return KErrArgument; |
|
2107 |
|
2108 xmlService ->SetSnapIdL(1); |
|
2109 if(!(xmlService ->SnapId(iap) == KErrNone))return KErrArgument; |
|
2110 |
|
2111 if(!(1))return KErrArgument; |
|
2112 |
|
2113 xmlService ->SetSnapIdL(2); |
|
2114 if(!(xmlService ->SnapId(iap) == KErrNone))return KErrArgument; |
|
2115 |
|
2116 if(!(2))return KErrArgument; |
|
2117 |
|
2118 __ASSERT_ALWAYS_NO_LEAVE(delete xmlService); |
|
2119 xmlService = NULL; |
|
2120 Teardown(); |
|
2121 return KErrNone; |
|
2122 } |
|
2123 |
|
2124 TInt CSenServDesc::MT_CSenXmlServiceDescription_SnapIdL( TTestResult& aResult ) |
|
2125 { |
|
2126 return MT_CSenXmlServiceDescription_SetSnapIdLL(aResult); |
|
2127 } |
|
2128 |
|
2129 TInt CSenServDesc::MT_CSenXmlServiceDescription_SetIdentityProviderIdsLL( TTestResult& aResult ) |
|
2130 { |
|
2131 SetupL(); |
|
2132 |
|
2133 CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL(); |
|
2134 CSenIdentityProviderIdArray8* array = CSenIdentityProviderIdArray8::NewL(); |
|
2135 |
|
2136 |
|
2137 __ASSERT_ALWAYS_NO_LEAVE(xmlService->SetIdentityProviderIdsL(*array)); |
|
2138 |
|
2139 TPtrC8 ptrText = KText(); |
|
2140 xmlService->AddIdentityProviderIdL(ptrText); |
|
2141 |
|
2142 __ASSERT_ALWAYS_NO_LEAVE(xmlService->SetIdentityProviderIdsL(*array)); |
|
2143 array->AppendL(KText); |
|
2144 __ASSERT_ALWAYS_NO_LEAVE(xmlService->SetIdentityProviderIdsL(*array)); |
|
2145 array->AppendL(KText2); |
|
2146 __ASSERT_ALWAYS_NO_LEAVE(xmlService->SetIdentityProviderIdsL(*array)); |
|
2147 |
|
2148 TL((xmlService->IdentityProviderIds8L()).Count() == 2); |
|
2149 |
|
2150 TInt pos(0); |
|
2151 if(!((xmlService->IdentityProviderIds8L()).Find(KText, pos)==KErrNone))return KErrArgument; |
|
2152 |
|
2153 if(!((xmlService->IdentityProviderIds8L()).Find(KText2, pos)==KErrNone))return KErrArgument; |
|
2154 |
|
2155 __ASSERT_ALWAYS_NO_LEAVE(delete array); |
|
2156 array = NULL; |
|
2157 __ASSERT_ALWAYS_NO_LEAVE(delete xmlService); |
|
2158 xmlService = NULL; |
|
2159 Teardown(); |
|
2160 return KErrNone; |
|
2161 } |
|
2162 |
|
2163 TInt CSenServDesc::MT_CSenXmlServiceDescription_AddIdentityProviderIdLL( TTestResult& aResult ) |
|
2164 { |
|
2165 SetupL(); |
|
2166 |
|
2167 CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL(); |
|
2168 TPtrC8 ptr = KNullDesC8(); |
|
2169 if(!(xmlService->AddIdentityProviderIdL(ptr) == KErrArgument))return KErrArgument; |
|
2170 |
|
2171 ptr.Set(KText); |
|
2172 if(!(xmlService->AddIdentityProviderIdL(ptr) == KErrNone))return KErrArgument; |
|
2173 |
|
2174 if(!(xmlService->AddIdentityProviderIdL(ptr) == KErrAlreadyExists))return KErrArgument; |
|
2175 |
|
2176 ptr.Set(KText2); |
|
2177 if(!(xmlService->AddIdentityProviderIdL(ptr) == KErrNone))return KErrArgument; |
|
2178 |
|
2179 |
|
2180 _LIT16(KRef, "<ServiceDescription><ProviderPolicy><IdentityProviderIDs><IdentityProviderID>text</IdentityProviderID><IdentityProviderID>text2</IdentityProviderID></IdentityProviderIDs></ProviderPolicy><ServicePolicy/></ServiceDescription>"); |
|
2181 //TL(ConvertToPtr16LC(*xmlService) == KRef); |
|
2182 |
|
2183 //CleanupStack::PopAndDestroy();//Ptr |
|
2184 |
|
2185 __ASSERT_ALWAYS_NO_LEAVE(delete xmlService); |
|
2186 xmlService = NULL; |
|
2187 Teardown(); |
|
2188 return KErrNone; |
|
2189 } |
|
2190 |
|
2191 TInt CSenServDesc::MT_CSenXmlServiceDescription_RebuildFromL( TTestResult& aResult ) |
|
2192 { |
|
2193 SetupL(); |
|
2194 |
|
2195 CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL(); |
|
2196 CSenIdentityProviderIdArray8* array = CSenIdentityProviderIdArray8::NewL(); |
|
2197 |
|
2198 xmlService->SetIapIdL(1); |
|
2199 array->AppendL(KText); |
|
2200 |
|
2201 CSenXmlServiceDescription* xmlService2 = CSenXmlServiceDescription::NewL(); |
|
2202 if(!(xmlService2->RebuildFrom(*xmlService)==KErrNone))return KErrArgument; |
|
2203 |
|
2204 if(!(xmlService2->Accepts(*xmlService)==TRUE))return KErrArgument; |
|
2205 |
|
2206 __ASSERT_ALWAYS_NO_LEAVE(delete array); |
|
2207 __ASSERT_ALWAYS_NO_LEAVE(delete xmlService2); |
|
2208 array = NULL; |
|
2209 xmlService2 = NULL; |
|
2210 //false |
|
2211 xmlService2 = CSenServicePattern::NewL(); |
|
2212 xmlService2->SetIapIdL(2); |
|
2213 if(!(xmlService2->Accepts(*xmlService)==FALSE))return KErrArgument; |
|
2214 |
|
2215 __ASSERT_ALWAYS_NO_LEAVE(delete xmlService2); |
|
2216 __ASSERT_ALWAYS_NO_LEAVE(delete xmlService); |
|
2217 xmlService2 = NULL; |
|
2218 xmlService = NULL; |
|
2219 Teardown(); |
|
2220 return KErrNone; |
|
2221 } |
|
2222 |
|
2223 TInt CSenServDesc::MT_CSenXmlServiceDescription_IdentityProviderIds8LL( TTestResult& aResult ) |
|
2224 { |
|
2225 return MT_CSenXmlServiceDescription_SetIdentityProviderIdsLL(aResult); |
|
2226 } |
|
2227 |
|
2228 TInt CSenServDesc::MT_CSenXmlServiceDescription_AcceptsL( TTestResult& aResult ) |
|
2229 { |
|
2230 return MT_CSenXmlServiceDescription_RebuildFromL(aResult); |
|
2231 } |
|
2232 |
|
2233 TInt CSenServDesc::MT_CSenXmlServiceDescription_DescriptionClassTypeL( TTestResult& aResult ) |
|
2234 { |
|
2235 SetupL(); |
|
2236 |
|
2237 CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL(); |
|
2238 if(!(xmlService ->DescriptionClassType() == MSenServiceDescription::EXmlServiceDescription))return KErrArgument; |
|
2239 |
|
2240 __ASSERT_ALWAYS_NO_LEAVE(delete xmlService); |
|
2241 xmlService = NULL; |
|
2242 Teardown(); |
|
2243 return KErrNone; |
|
2244 } |
|
2245 |
|
2246 TInt CSenServDesc::MT_CSenXmlServiceDescription_MatchesL( TTestResult& aResult ) |
|
2247 { |
|
2248 SetupL(); |
|
2249 |
|
2250 CSenXmlServiceDescription *xmlService; |
|
2251 CSenXmlServiceDescription *xmlService2(NULL); |
|
2252 |
|
2253 xmlService = CSenXmlServiceDescription::NewL(); |
|
2254 //EUNIT_ASSERT_EQUALS(xmlService->Matches(*xmlService2), FALSE); |
|
2255 |
|
2256 xmlService2 = CSenXmlServiceDescription::NewL(); |
|
2257 //checking xml |
|
2258 TL(xmlService ->Matches(*xmlService2) == TRUE); |
|
2259 __ASSERT_ALWAYS_NO_LEAVE(delete xmlService2); |
|
2260 xmlService2 = NULL; |
|
2261 |
|
2262 CSenServicePattern* pattern = CSenServicePattern::NewL(); |
|
2263 //EUNIT_ASSERT_EQUALS(xmlService->Matches(*pattern), FALSE); |
|
2264 TL(xmlService->Matches(*pattern) == TRUE); |
|
2265 |
|
2266 __ASSERT_ALWAYS_NO_LEAVE(delete xmlService); |
|
2267 xmlService = NULL; |
|
2268 __ASSERT_ALWAYS_NO_LEAVE(delete pattern); |
|
2269 pattern = NULL; |
|
2270 Teardown(); |
|
2271 return KErrNone; |
|
2272 |
|
2273 } |
|
2274 |
|
2275 TInt CSenServDesc::MT_CSenXmlServiceDescription_SetProviderIDL( TTestResult& aResult ) |
|
2276 { |
|
2277 SetupL(); |
|
2278 |
|
2279 CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL(); |
|
2280 |
|
2281 __ASSERT_ALWAYS_NO_LEAVE(xmlService->SetProviderIdL(KText2)); |
|
2282 __ASSERT_ALWAYS_NO_LEAVE(xmlService->SetProviderIdL(KText)); |
|
2283 |
|
2284 //checking xml |
|
2285 _LIT16(KRef, "<ServiceDescription><ProviderPolicy/><ServicePolicy/><ProviderID>text</ProviderID></ServiceDescription>"); |
|
2286 TL(ConvertToPtr16LC(*xmlService)== KRef); |
|
2287 CleanupStack::PopAndDestroy();//Ptr |
|
2288 __ASSERT_ALWAYS_NO_LEAVE(delete xmlService); |
|
2289 xmlService = NULL; |
|
2290 Teardown(); |
|
2291 return KErrNone; |
|
2292 |
|
2293 } |
|
2294 |
|
2295 TInt CSenServDesc::MT_CSenXmlServiceDescription_SetPolicyLL( TTestResult& aResult ) |
|
2296 { |
|
2297 SetupL(); |
|
2298 |
|
2299 CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL(); |
|
2300 LOCAL_ASSERT(xmlService->SetPolicyL(KText) == KErrNone); |
|
2301 LOCAL_ASSERT(xmlService->SetPolicyL(_L8("")) == KErrArgument); |
|
2302 |
|
2303 _LIT16(KRef, "<ServiceDescription><ProviderPolicy/><ServicePolicy><ClientPolicy><text/></ClientPolicy></ServicePolicy></ServiceDescription>"); |
|
2304 TL(ConvertToPtr16LC(*xmlService)== KRef); |
|
2305 CleanupStack::PopAndDestroy();//Ptr |
|
2306 |
|
2307 __ASSERT_ALWAYS_NO_LEAVE(delete xmlService); |
|
2308 xmlService = NULL; |
|
2309 Teardown(); |
|
2310 return KErrNone; |
|
2311 |
|
2312 } |
|
2313 |
|
2314 TInt CSenServDesc::MT_CSenXmlServiceDescription_SetPolicyL_1L( TTestResult& aResult ) |
|
2315 { |
|
2316 SetupL(); |
|
2317 |
|
2318 CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL(); |
|
2319 LOCAL_ASSERT(xmlService->SetPolicyL(KText, KText) == KErrNone); |
|
2320 LOCAL_ASSERT(xmlService->SetPolicyL(_L8(""), KText) == KErrArgument); |
|
2321 |
|
2322 _LIT16(KRef, "<ServiceDescription><ProviderPolicy/><ServicePolicy><ClientPolicy><text>text</text></ClientPolicy></ServicePolicy></ServiceDescription>"); |
|
2323 TL(ConvertToPtr16LC(*xmlService)== KRef); |
|
2324 CleanupStack::PopAndDestroy();//Ptr |
|
2325 |
|
2326 __ASSERT_ALWAYS_NO_LEAVE(delete xmlService); |
|
2327 xmlService = NULL; |
|
2328 Teardown(); |
|
2329 return KErrNone; |
|
2330 |
|
2331 } |
|
2332 |
|
2333 TInt CSenServDesc::MT_CSenXmlServiceDescription_SetPolicyL_2L( TTestResult& aResult ) |
|
2334 { |
|
2335 SetupL(); |
|
2336 |
|
2337 CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL(); |
|
2338 LOCAL_ASSERT(xmlService->SetPolicyL(KText, KText, KText, KText) == KErrNone); |
|
2339 LOCAL_ASSERT(xmlService->SetPolicyL(_L8(""), _L8(""), KText, KText) == KErrArgument); |
|
2340 |
|
2341 _LIT16(KRef, "<ServiceDescription><ProviderPolicy/><ServicePolicy><ClientPolicy><text text=\"text\">text</text></ClientPolicy></ServicePolicy></ServiceDescription>"); |
|
2342 TL(ConvertToPtr16LC(*xmlService)== KRef); |
|
2343 CleanupStack::PopAndDestroy();//Ptr |
|
2344 |
|
2345 __ASSERT_ALWAYS_NO_LEAVE(delete xmlService); |
|
2346 xmlService = NULL; |
|
2347 Teardown(); |
|
2348 return KErrNone; |
|
2349 |
|
2350 } |
|
2351 |
|
2352 TInt CSenServDesc::MT_CSenXmlServiceDescription_ContractL( TTestResult& aResult ) |
|
2353 { |
|
2354 SetupL(); |
|
2355 |
|
2356 CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL(); |
|
2357 xmlService ->SetContractL(KText); |
|
2358 //checking xml |
|
2359 _LIT16(KRef, "<ServiceDescription><ProviderPolicy/><ServicePolicy/><Contract>text</Contract></ServiceDescription>"); |
|
2360 |
|
2361 //TL(ConvertToPtr16LC(*xmlService) == KRef); |
|
2362 TPtr16 ptr = ConvertToPtr16LC(*xmlService); |
|
2363 TInt posId(-1); |
|
2364 TPtrC16 messageToParse; |
|
2365 messageToParse.Set(ptr); |
|
2366 posId = messageToParse.Find(_L("<Contract>")); |
|
2367 TL(posId != -1); |
|
2368 CleanupStack::PopAndDestroy();//Ptr |
|
2369 TL(xmlService->Contract() == KText); |
|
2370 |
|
2371 //CleanupStack::PopAndDestroy();//Ptr |
|
2372 |
|
2373 //2nd time |
|
2374 xmlService ->SetContractL(KText); |
|
2375 //checking xml |
|
2376 //TL(ConvertToPtr16LC(*xmlService) == KRef); |
|
2377 ptr = ConvertToPtr16LC(*xmlService); |
|
2378 posId = -1; |
|
2379 messageToParse.Set(ptr); |
|
2380 posId = messageToParse.Find(_L("<Contract>")); |
|
2381 TL(posId != -1); |
|
2382 CleanupStack::PopAndDestroy();//Ptr |
|
2383 TL(xmlService->Contract() == KText); |
|
2384 |
|
2385 //CleanupStack::PopAndDestroy();//Ptr |
|
2386 |
|
2387 xmlService ->SetContractL(KText2); |
|
2388 //checking xml |
|
2389 _LIT16(KRef2, "<ServiceDescription><ProviderPolicy/><ServicePolicy/><Contract>text2</Contract></ServiceDescription>"); |
|
2390 //TL(ConvertToPtr16LC(*xmlService) == KRef2); |
|
2391 |
|
2392 TL(xmlService->Contract() == KText2); |
|
2393 |
|
2394 //CleanupStack::PopAndDestroy();//Ptr |
|
2395 |
|
2396 __ASSERT_ALWAYS_NO_LEAVE(delete xmlService); |
|
2397 xmlService = NULL; |
|
2398 Teardown(); |
|
2399 return KErrNone; |
|
2400 } |
|
2401 //================Facets |
|
2402 TInt CSenServDesc::MT_CSenXmlServiceDescription_HasFacetLL( TTestResult& aResult ) |
|
2403 { |
|
2404 return MT_CSenXmlServiceDescription_RemoveFacetL(aResult); |
|
2405 } |
|
2406 |
|
2407 TInt CSenServDesc::MT_CSenXmlServiceDescription_FacetValueL( TTestResult& aResult ) |
|
2408 { |
|
2409 SetupL(); |
|
2410 |
|
2411 CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL(); |
|
2412 CSenFacet* senFacet; |
|
2413 senFacet = CSenFacet::NewL(); |
|
2414 senFacet->SetNameL(KText); |
|
2415 senFacet->SetValueL(KText2); |
|
2416 |
|
2417 |
|
2418 xmlService->AddFacetL(*senFacet); |
|
2419 TPtrC8 ptr=KText(); |
|
2420 HBufC8* valueTo = NULL; |
|
2421 |
|
2422 if(!(xmlService->FacetValue(ptr, valueTo)==KErrNone))return KErrArgument; |
|
2423 |
|
2424 TL(*valueTo == KText2); |
|
2425 |
|
2426 __ASSERT_ALWAYS_NO_LEAVE(delete valueTo ); |
|
2427 valueTo = NULL; |
|
2428 |
|
2429 if(!(xmlService->FacetValue(ptr, valueTo)==KErrNone))return KErrArgument; |
|
2430 |
|
2431 TL(*valueTo == KText2); |
|
2432 |
|
2433 __ASSERT_ALWAYS_NO_LEAVE(delete valueTo ); |
|
2434 valueTo = NULL; |
|
2435 |
|
2436 ptr.Set(KText2); |
|
2437 if(!(xmlService->FacetValue(ptr, valueTo)==KErrNotFound))return KErrArgument; |
|
2438 |
|
2439 __ASSERT_ALWAYS_NO_LEAVE(delete senFacet); |
|
2440 senFacet = NULL; |
|
2441 __ASSERT_ALWAYS_NO_LEAVE(delete xmlService); |
|
2442 xmlService = NULL; |
|
2443 Teardown(); |
|
2444 return KErrNone; |
|
2445 } |
|
2446 |
|
2447 TInt CSenServDesc::MT_CSenXmlServiceDescription_AddFacetLL( TTestResult& aResult ) |
|
2448 { |
|
2449 SetupL(); |
|
2450 |
|
2451 CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL(); |
|
2452 CSenFacet *senFacet; |
|
2453 CSenFacet *senFacet2; |
|
2454 |
|
2455 senFacet = CSenFacet::NewL(); |
|
2456 senFacet2 = CSenFacet::NewL(); |
|
2457 senFacet->SetNameL(KText); |
|
2458 senFacet2->SetNameL(KText2); |
|
2459 RFacetArray array; |
|
2460 |
|
2461 if(!(xmlService->AddFacetL(*senFacet) == KErrNone))return KErrArgument; |
|
2462 |
|
2463 if(!(xmlService->AddFacetL(*senFacet) == KErrAlreadyExists))return KErrArgument; |
|
2464 |
|
2465 if(!(xmlService->AddFacetL(*senFacet2) == KErrNone))return KErrArgument; |
|
2466 |
|
2467 //_LIT16(KRef, "<ServiceDescription><ProviderPolicy/><ServicePolicy/><Facet name=\"text\"/><Facet name=\"text2\"/></ServiceDescription>"); |
|
2468 //TPtrC16 ptrRef = KRef(); |
|
2469 //TL(ConvertToPtr16LC(*xmlService) == ptrRef); |
|
2470 |
|
2471 //CleanupStack::PopAndDestroy();//Ptr |
|
2472 TPtr16 ptr = ConvertToPtr16LC(*xmlService); |
|
2473 TInt posId(-1); |
|
2474 TPtrC16 messageToParse; |
|
2475 messageToParse.Set(ptr); |
|
2476 posId = messageToParse.Find(_L("<Facet name=\"text\"/><Facet name=\"text2\"/>")); |
|
2477 TL(posId != -1); |
|
2478 CleanupStack::PopAndDestroy();//Ptr |
|
2479 |
|
2480 if(!(xmlService->FacetsL(array) == KErrNone))return KErrArgument; |
|
2481 |
|
2482 if(!(array.Count() == 2))return KErrArgument; |
|
2483 |
|
2484 __ASSERT_ALWAYS_NO_LEAVE(delete senFacet); |
|
2485 senFacet = NULL; |
|
2486 __ASSERT_ALWAYS_NO_LEAVE(delete senFacet2); |
|
2487 senFacet2 = NULL; |
|
2488 __ASSERT_ALWAYS_NO_LEAVE(delete xmlService); |
|
2489 xmlService = NULL; |
|
2490 array.ResetAndDestroy(); |
|
2491 array.Close(); |
|
2492 Teardown(); |
|
2493 return KErrNone; |
|
2494 } |
|
2495 |
|
2496 TInt CSenServDesc::MT_CSenXmlServiceDescription_SetFacetLL( TTestResult& aResult ) |
|
2497 { |
|
2498 SetupL(); |
|
2499 |
|
2500 CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL(); |
|
2501 CSenFacet* senFacet; |
|
2502 senFacet = CSenFacet::NewL(); |
|
2503 senFacet->SetNameL(KText); |
|
2504 senFacet->SetValueL(KText); |
|
2505 |
|
2506 RFacetArray array; |
|
2507 if(!(xmlService->SetFacetL(*senFacet) == KErrNone))return KErrArgument; |
|
2508 |
|
2509 if(!(xmlService->SetFacetL(*senFacet) == KErrNone))return KErrArgument; |
|
2510 |
|
2511 senFacet->SetValueL(KText2); |
|
2512 if(!(xmlService->SetFacetL(*senFacet) == KErrNone))return KErrArgument; |
|
2513 |
|
2514 _LIT16(KRef, "<ServiceDescription><ProviderPolicy/><ServicePolicy/><Facet name=\"text\">text2</Facet></ServiceDescription>"); |
|
2515 //TPtrC16 ptrRef = KRef(); |
|
2516 //TL(ConvertToPtr16LC(*xmlService) == ptrRef); |
|
2517 |
|
2518 //CleanupStack::PopAndDestroy();//Ptr |
|
2519 TPtr16 ptr = ConvertToPtr16LC(*xmlService); |
|
2520 TInt posId(-1); |
|
2521 TPtrC16 messageToParse; |
|
2522 messageToParse.Set(ptr); |
|
2523 posId = messageToParse.Find(_L("<Facet name=\"text\">text2</Facet>")); |
|
2524 TL(posId != -1); |
|
2525 CleanupStack::PopAndDestroy();//Ptr |
|
2526 |
|
2527 if(!(xmlService->FacetsL(array) == KErrNone))return KErrArgument; |
|
2528 |
|
2529 if(!(array.Count() == 1))return KErrArgument; |
|
2530 |
|
2531 __ASSERT_ALWAYS_NO_LEAVE(delete senFacet); |
|
2532 senFacet = NULL; |
|
2533 __ASSERT_ALWAYS_NO_LEAVE(delete xmlService); |
|
2534 xmlService = NULL; |
|
2535 array.ResetAndDestroy(); |
|
2536 array.Close(); |
|
2537 Teardown(); |
|
2538 return KErrNone; |
|
2539 } |
|
2540 |
|
2541 TInt CSenServDesc::MT_CSenXmlServiceDescription_RemoveFacetL( TTestResult& aResult ) |
|
2542 { |
|
2543 SetupL(); |
|
2544 |
|
2545 CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL(); |
|
2546 CSenFacet *senFacet; |
|
2547 CSenFacet *senFacet2; |
|
2548 |
|
2549 senFacet = CSenFacet::NewL(); |
|
2550 senFacet2 = CSenFacet::NewL(); |
|
2551 senFacet->SetNameL(KText); |
|
2552 senFacet2->SetNameL(KText2); |
|
2553 RFacetArray array; |
|
2554 |
|
2555 |
|
2556 if(!(xmlService->AddFacetL(*senFacet) == KErrNone))return KErrArgument; |
|
2557 |
|
2558 if(!(xmlService->AddFacetL(*senFacet) == KErrAlreadyExists))return KErrArgument; |
|
2559 |
|
2560 if(!(xmlService->AddFacetL(*senFacet2) == KErrNone))return KErrArgument; |
|
2561 |
|
2562 if(!(xmlService->FacetsL(array) == KErrNone))return KErrArgument; |
|
2563 |
|
2564 if(!(array.Count() == 2))return KErrArgument; |
|
2565 |
|
2566 array.ResetAndDestroy(); |
|
2567 //removing, haFacet |
|
2568 TBool has(FALSE); |
|
2569 if(!(xmlService->HasFacetL(KText, has) == KErrNone))return KErrArgument; |
|
2570 |
|
2571 if(!(has == TRUE))return KErrArgument; |
|
2572 |
|
2573 if(!(xmlService->HasFacetL(KText2, has) == KErrNone))return KErrArgument; |
|
2574 |
|
2575 if(!(has == TRUE))return KErrArgument; |
|
2576 |
|
2577 if(!(xmlService->RemoveFacet(KText2) == KErrNone))return KErrArgument; |
|
2578 |
|
2579 __ASSERT_ALWAYS_NO_LEAVE(xmlService->RemoveFacet(KText2)); |
|
2580 if(!(xmlService->HasFacetL(KText2, has) == KErrNone))return KErrArgument; |
|
2581 |
|
2582 if(!(has == FALSE))return KErrArgument; |
|
2583 |
|
2584 if(!(xmlService->RemoveFacet(KText2) == KErrNotFound))return KErrArgument; |
|
2585 |
|
2586 if(!(xmlService->HasFacetL(KText2, has) == KErrNone))return KErrArgument; |
|
2587 |
|
2588 if(!(has == FALSE))return KErrArgument; |
|
2589 |
|
2590 if(!(xmlService->FacetsL(array) == KErrNone))return KErrArgument; |
|
2591 |
|
2592 if(!(array.Count() == 1))return KErrArgument; |
|
2593 |
|
2594 __ASSERT_ALWAYS_NO_LEAVE(delete senFacet); |
|
2595 senFacet = NULL; |
|
2596 __ASSERT_ALWAYS_NO_LEAVE(delete senFacet2); |
|
2597 senFacet2 = NULL; |
|
2598 __ASSERT_ALWAYS_NO_LEAVE(delete xmlService); |
|
2599 xmlService = NULL; |
|
2600 array.ResetAndDestroy(); |
|
2601 array.Close(); |
|
2602 Teardown(); |
|
2603 return KErrNone; |
|
2604 } |
|
2605 |
|
2606 TInt CSenServDesc::MT_CSenXmlServiceDescription_FacetsLL( TTestResult& aResult ) |
|
2607 { |
|
2608 return MT_CSenXmlServiceDescription_AddFacetLL(aResult); |
|
2609 } |
|
2610 //------------end facet |
|
2611 |
|
2612 TInt CSenServDesc::MT_CSenXmlServiceDescription_AsXmlLL( TTestResult& aResult ) |
|
2613 { |
|
2614 SetupL(); |
|
2615 CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL(KText, KText); |
|
2616 |
|
2617 HBufC8* xmlBuffer = xmlService->AsXmlL(); |
|
2618 CleanupStack::PushL( xmlBuffer ); |
|
2619 TPtr8 ptr = xmlBuffer->Des(); |
|
2620 if (ptr.Length() > 0) |
|
2621 RDebug::Print( _L( "WSModTester: xmlBuffer [%S]"),&ptr); |
|
2622 else |
|
2623 RDebug::Print( _L( "WSModTester: xmlBuffer empty")); |
|
2624 _LIT8(KRef, "<ServiceDescription><Endpoint>text</Endpoint><Contract>text</Contract><ProviderPolicy/><ServicePolicy/></ServiceDescription>"); |
|
2625 /*EUNIT_ASSERT_EQUALS(ptr, KRef);*/ |
|
2626 //TL(ptr == KRef); |
|
2627 TInt posId(-1); |
|
2628 TPtrC8 messageToParse; |
|
2629 messageToParse.Set(ptr); |
|
2630 posId = messageToParse.Find(_L8("<facet>")); |
|
2631 TL(posId == -1); |
|
2632 CleanupStack::PopAndDestroy(xmlBuffer); |
|
2633 |
|
2634 __ASSERT_ALWAYS_NO_LEAVE(delete xmlService); |
|
2635 xmlService = NULL; |
|
2636 Teardown(); |
|
2637 return KErrNone ; |
|
2638 } |
|
2639 |
|
2640 TInt CSenServDesc::MT_CSenXmlServiceDescription_WriteAsXMLToLL( TTestResult& aResult ) |
|
2641 { |
|
2642 SetupL(); |
|
2643 |
|
2644 TBuf8<50> StreamBuf; |
|
2645 CSenBaseElement* pElement=CSenBaseElement::NewL(_L8("Nokia")); |
|
2646 CleanupStack::PushL(pElement); |
|
2647 pElement->AddElementL(_L8("webservices")); |
|
2648 RWriteStream& ElemntStream=pElement->ContentWriteStreamL(); |
|
2649 |
|
2650 CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL(KText, KText); |
|
2651 CleanupStack::PushL(xmlService); |
|
2652 xmlService->WriteAsXMLToL(ElemntStream); |
|
2653 |
|
2654 CleanupStack::PopAndDestroy(xmlService); |
|
2655 CleanupStack::PopAndDestroy(pElement); |
|
2656 Teardown(); |
|
2657 return KErrNone ; |
|
2658 } |
|
2659 |
|
2660 |
|
2661 TInt CSenServDesc::MT_CSenXmlServiceDescription_CredentialsL( TTestResult& aResult ) |
|
2662 { |
|
2663 SetupL(); |
|
2664 CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL(KText, KText); |
|
2665 xmlService->Credentials(); |
|
2666 __ASSERT_ALWAYS_NO_LEAVE(delete xmlService); |
|
2667 xmlService = NULL; |
|
2668 Teardown(); |
|
2669 return KErrNone ; |
|
2670 } |
|
2671 |
|
2672 TInt CSenServDesc::MT_CSenXmlServiceDescription_AsXmlUnicodeLL( TTestResult& aResult ) |
|
2673 { |
|
2674 SetupL(); |
|
2675 CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL(KText, KText); |
|
2676 |
|
2677 HBufC* xmlBuffer = xmlService->AsXmlUnicodeL(); |
|
2678 CleanupStack::PushL( xmlBuffer ); |
|
2679 TPtr ptr = xmlBuffer->Des(); |
|
2680 if (ptr.Length() > 0) |
|
2681 RDebug::Print( _L( "WSModTester: xmlBuffer [%S]"),&ptr); |
|
2682 else |
|
2683 RDebug::Print( _L( "WSModTester: xmlBuffer empty")); |
|
2684 _LIT(KRef, "<ServiceDescription><Endpoint>text</Endpoint><Contract>text</Contract><ProviderPolicy/><ServicePolicy/></ServiceDescription>"); |
|
2685 /*EUNIT_ASSERT_EQUALS(ptr, KRef);*/ |
|
2686 TL(ptr == KRef); |
|
2687 CleanupStack::PopAndDestroy(xmlBuffer); |
|
2688 |
|
2689 __ASSERT_ALWAYS_NO_LEAVE(delete xmlService); |
|
2690 xmlService = NULL; |
|
2691 Teardown(); |
|
2692 return KErrNone ; |
|
2693 } |
|
2694 |
|
2695 TInt CSenServDesc::MT_CSenXmlServiceDescription_HasEqualPrimaryKeysLL( TTestResult& aResult ) |
|
2696 { |
|
2697 SetupL(); |
|
2698 TBool retVal; |
|
2699 CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL(KText, KText); |
|
2700 xmlService->SetFrameworkIdL(KText); |
|
2701 CSenXmlServiceDescription* xmlService1= CSenXmlServiceDescription::NewL(); |
|
2702 |
|
2703 retVal = xmlService->HasEqualPrimaryKeysL(*xmlService); |
|
2704 //TL(retVal == ETrue) |
|
2705 if(retVal); |
|
2706 __ASSERT_ALWAYS_NO_LEAVE(delete xmlService); |
|
2707 xmlService = NULL; |
|
2708 |
|
2709 __ASSERT_ALWAYS_NO_LEAVE(delete xmlService1); |
|
2710 xmlService1 = NULL; |
|
2711 Teardown(); |
|
2712 return KErrNone ; |
|
2713 } |
|
2714 |
|
2715 TInt CSenServDesc::MT_CSenXmlServiceDescription_IsLocalLL( TTestResult& aResult ) |
|
2716 { |
|
2717 SetupL(); |
|
2718 TBool retVal; |
|
2719 CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL(KText, KText); |
|
2720 |
|
2721 retVal = xmlService->IsLocalL(); |
|
2722 //TL(retVal == ETrue) |
|
2723 if(retVal); |
|
2724 __ASSERT_ALWAYS_NO_LEAVE(delete xmlService); |
|
2725 xmlService = NULL; |
|
2726 |
|
2727 Teardown(); |
|
2728 return KErrNone ; |
|
2729 } |
|
2730 |
|
2731 TInt CSenServDesc::MT_CSenXmlServiceDescription_SetTransportCueLL( TTestResult& aResult ) |
|
2732 { |
|
2733 SetupL(); |
|
2734 TBool retVal; |
|
2735 CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL(KText, KText); |
|
2736 |
|
2737 retVal = xmlService->SetTransportCueL(KText); |
|
2738 if(!(retVal == 0)) return KErrArgument; |
|
2739 |
|
2740 __ASSERT_ALWAYS_NO_LEAVE(delete xmlService); |
|
2741 xmlService = NULL; |
|
2742 |
|
2743 Teardown(); |
|
2744 return KErrNone ; |
|
2745 } |
|
2746 |
|
2747 TInt CSenServDesc::MT_CSenXmlServiceDescription_TransportCueL( TTestResult& aResult ) |
|
2748 { |
|
2749 SetupL(); |
|
2750 //TBool retVal; |
|
2751 //HBufC8* xmlBuffer; |
|
2752 //TPtrC8 ptr; |
|
2753 CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL(KText, KText); |
|
2754 xmlService->SetTransportCueL(KText); |
|
2755 xmlService->TransportCue(); |
|
2756 //ptr = xmBuffer.Desc(;) |
|
2757 //TL(ptr == KText); |
|
2758 |
|
2759 __ASSERT_ALWAYS_NO_LEAVE(delete xmlService); |
|
2760 xmlService = NULL; |
|
2761 |
|
2762 Teardown(); |
|
2763 return KErrNone ; |
|
2764 } |
|
2765 /* |
|
2766 TInt CSenServDesc::MT_CSenXmlServiceDescription_ServicePolicyL( TTestResult& aResult ) |
|
2767 { |
|
2768 SetupL(); |
|
2769 TBool retVal; |
|
2770 CServicePolicy* policy = CSenServicePolicy::NewL(); |
|
2771 CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL(KText, KText); |
|
2772 policy = (CServicePolicy)xmlService->ServicePolicyL(); |
|
2773 |
|
2774 __ASSERT_ALWAYS_NO_LEAVE(delete xmlService); |
|
2775 xmlService = NULL; |
|
2776 |
|
2777 Teardown(); |
|
2778 return KErrNone ; |
|
2779 } |
|
2780 |
|
2781 */ |
|
2782 |
|
2783 TInt CSenServDesc::MT_CSenXmlServiceDescription_ProviderIdL( TTestResult& aResult ) |
|
2784 { |
|
2785 SetupL(); |
|
2786 //TBool retVal; |
|
2787 //TPtrC8 ptr; |
|
2788 CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL(KText, KText); |
|
2789 xmlService->ProviderId(); |
|
2790 |
|
2791 __ASSERT_ALWAYS_NO_LEAVE(delete xmlService); |
|
2792 xmlService = NULL; |
|
2793 |
|
2794 Teardown(); |
|
2795 return KErrNone ; |
|
2796 } |
|
2797 |
|
2798 TInt CSenServDesc::MT_CSenXmlServiceDescription_SetPromptUserInfoLL( TTestResult& aResult ) |
|
2799 { |
|
2800 SetupL(); |
|
2801 TBool var = ETrue; |
|
2802 TPtrC8 ptr; |
|
2803 CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL(KText, KText); |
|
2804 xmlService->SetPromptUserInfoL(var); |
|
2805 |
|
2806 __ASSERT_ALWAYS_NO_LEAVE(delete xmlService); |
|
2807 xmlService = NULL; |
|
2808 |
|
2809 Teardown(); |
|
2810 return KErrNone ; |
|
2811 } |
|
2812 |
|
2813 TInt CSenServDesc::MT_CSenXmlServiceDescription_PromptUserInfoL( TTestResult& aResult ) |
|
2814 { |
|
2815 SetupL(); |
|
2816 TBool retVal;; |
|
2817 |
|
2818 CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL(KText, KText); |
|
2819 retVal = xmlService->PromptUserInfo(); |
|
2820 |
|
2821 if(retVal); |
|
2822 |
|
2823 __ASSERT_ALWAYS_NO_LEAVE(delete xmlService); |
|
2824 xmlService = NULL; |
|
2825 |
|
2826 Teardown(); |
|
2827 return KErrNone ; |
|
2828 } |
|
2829 TInt CSenServDesc::MT_CSenXmlServiceDescription_StartEndElementLL(TTestResult& aResult) |
|
2830 { |
|
2831 /*_LIT8(KServiceDescription, "<?xml version=\"1.0\" encoding=\"utf-8\" ?> <a:Test character=\""\" xmlns=\"nsuri\" xmlns:a=\"nasuria\" \ |
|
2832 xmlns:b=\"nasurib\" a:x=\"value1\" b:z=\"value2\">\ |
|
2833 <Element1 xmlns:c=\"nsuric\" c:x=\"value3\">Content1</Element1>\ |
|
2834 <Element2 z=\"value4\"><Content2"></Element2>\ |
|
2835 <Element3>Content3</Element3>\ |
|
2836 <Element4/></a:Test>"); |
|
2837 */ |
|
2838 |
|
2839 |
|
2840 _LIT8(KServiceDescription, "<ServiceDescription framework=\"WS-STAR\">\ |
|
2841 <Contract>urn:wstar:sts</Contract>\ |
|
2842 <Endpoint>http://10.21.32.20/WSStar/BgRsp/STS.aspx</Endpoint>\ |
|
2843 <ProviderID>provider01</ProviderID>\ |
|
2844 </ServiceDescription>"); |
|
2845 /* |
|
2846 _LIT8(KServiceDescription, "<ServiceDescription framework=\"WS-STAR\"> |
|
2847 <Contract>urn:wstar:sts</Contract> |
|
2848 <Endpoint>http://10.21.32.20/WSStar/BgRsp/STS.aspx</Endpoint> |
|
2849 <ProviderID>provider01</ProviderID> |
|
2850 <ProviderPolicy> |
|
2851 <Transport> |
|
2852 <IapId> |
|
2853 1234567890 |
|
2854 </IapId> |
|
2855 </Transport> |
|
2856 <IdentityProviderIDs strict=\"true\"> |
|
2857 <IdentityProviderID> |
|
2858 urn:first.id.example.com |
|
2859 </IdentityProviderID> |
|
2860 <IdentityProviderID> |
|
2861 urn:second.id.example.com |
|
2862 </IdentityProviderID> |
|
2863 </IdentityProviderIDs> |
|
2864 </ProviderPolicy> |
|
2865 <Credentials CredentialsMaxID=\"1\"> |
|
2866 <CredentialContainer> |
|
2867 <Identifier><garbage>1</garbage><Endpoint>http://10.21.32.20/WSStar/CredMan/WSService.aspx</Endpoint><ProviderID>provider01</ProviderID></Identifier> |
|
2868 <Properties> |
|
2869 <ServiceInterval>-60540625</ServiceInterval><ValidUntil>2020-06-19T10:28:31.000000Z</ValidUntil> |
|
2870 <Created>2007-06-18T10:23:52Z</Created><PhoneTimeWhenMTResolved>2007-06-18T10:24:52.504375Z</PhoneTimeWhenMTResolved> |
|
2871 <POP>cnqlXcxDmY4h4tjbgNssLMwhCkOnc+4c</POP> |
|
2872 <TokenType>http://docs.oasis-open.org/wss/oasis-wss-saml-token-profile-1.1#SAMLV1.1</TokenType>\ |
|
2873 <BinaryType>simmetric</BinaryType> |
|
2874 </Properties></CredentialContainer></Credentials> |
|
2875 </ServiceDescription>");*/ |
|
2876 |
|
2877 CSenXmlServiceDescription* pDescription = CSenXmlServiceDescription::NewL(_L8("ServiceDescription")); |
|
2878 CleanupStack::PushL(pDescription); |
|
2879 CSenXmlReader *pXmlReader = CSenXmlReader::NewL(); |
|
2880 CleanupStack::PushL(pXmlReader); |
|
2881 pDescription->SetReader(*pXmlReader ); |
|
2882 TRAPD(retVal,pDescription->ParseL(KServiceDescription)); |
|
2883 CleanupStack::PopAndDestroy(pXmlReader); |
|
2884 CleanupStack::PopAndDestroy(pDescription); |
|
2885 return retVal; |
|
2886 } |
|
2887 |
|
2888 |
|
2889 TInt CSenServDesc::MT_CSenXmlServiceDescription_ScoreMatchLL( TTestResult& aResult ) |
|
2890 { |
|
2891 SetupL(); |
|
2892 |
|
2893 CSenXmlServiceDescription *xmlService; |
|
2894 CSenXmlServiceDescription *xmlService2; |
|
2895 |
|
2896 xmlService = CSenXmlServiceDescription::NewL(); |
|
2897 xmlService2 = CSenXmlServiceDescription::NewL(); |
|
2898 |
|
2899 if(!(xmlService->ScoreMatchL(*xmlService2) == 0))return KErrArgument; |
|
2900 |
|
2901 __ASSERT_ALWAYS_NO_LEAVE(delete xmlService); |
|
2902 xmlService = NULL; |
|
2903 __ASSERT_ALWAYS_NO_LEAVE(delete xmlService2); |
|
2904 xmlService2 = NULL; |
|
2905 //--------------- |
|
2906 xmlService = CSenXmlServiceDescription::NewL(KText, KText2); |
|
2907 xmlService2 = CSenXmlServiceDescription::NewL(KText, KText2); |
|
2908 |
|
2909 if(!(xmlService->ScoreMatchL(*xmlService2) == 2))return KErrArgument; |
|
2910 |
|
2911 __ASSERT_ALWAYS_NO_LEAVE(delete xmlService); |
|
2912 xmlService = NULL; |
|
2913 __ASSERT_ALWAYS_NO_LEAVE(delete xmlService2); |
|
2914 xmlService2 = NULL; |
|
2915 //--------------- |
|
2916 xmlService = CSenXmlServiceDescription::NewL(KText2, KText); |
|
2917 xmlService2 = CSenXmlServiceDescription::NewL(KText, KText2); |
|
2918 |
|
2919 if(!(xmlService->ScoreMatchL(*xmlService2) == 0))return KErrArgument; |
|
2920 |
|
2921 __ASSERT_ALWAYS_NO_LEAVE(delete xmlService); |
|
2922 xmlService = NULL; |
|
2923 __ASSERT_ALWAYS_NO_LEAVE(delete xmlService2); |
|
2924 xmlService2 = NULL; |
|
2925 //--------------- |
|
2926 xmlService = CSenXmlServiceDescription::NewL(KText2, KText); |
|
2927 xmlService2 = CSenXmlServiceDescription::NewL(KText, KText2); |
|
2928 CSenFacet* senFacet = CSenFacet::NewL(); |
|
2929 senFacet->SetNameL(KText); |
|
2930 xmlService->AddFacetL(*senFacet); |
|
2931 xmlService2->AddFacetL(*senFacet); |
|
2932 |
|
2933 if(!(xmlService->ScoreMatchL(*xmlService2) == 1))return KErrArgument; |
|
2934 |
|
2935 __ASSERT_ALWAYS_NO_LEAVE(delete senFacet); |
|
2936 senFacet = NULL; |
|
2937 __ASSERT_ALWAYS_NO_LEAVE(delete xmlService); |
|
2938 xmlService = NULL; |
|
2939 __ASSERT_ALWAYS_NO_LEAVE(delete xmlService2); |
|
2940 xmlService2 = NULL; |
|
2941 Teardown(); |
|
2942 return KErrNone; |
|
2943 } |
|
2944 |
|
2945 TInt CSenServDesc::MT_CSenXmlServiceDescription_EndpointL( TTestResult& aResult ) |
|
2946 { |
|
2947 SetupL(); |
|
2948 |
|
2949 CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL(); |
|
2950 |
|
2951 xmlService ->SetEndPointL(KText); |
|
2952 //checking xml |
|
2953 _LIT16(KRef, "<ServiceDescription><ProviderPolicy/><ServicePolicy/><Endpoint>text</Endpoint></ServiceDescription>"); |
|
2954 //TL(ConvertToPtr16LC(*xmlService) == KRef); |
|
2955 |
|
2956 TL(xmlService->Endpoint() == KText); |
|
2957 TPtr16 ptr = ConvertToPtr16LC(*xmlService); |
|
2958 TInt posId(-1); |
|
2959 TPtrC16 messageToParse; |
|
2960 messageToParse.Set(ptr); |
|
2961 posId = messageToParse.Find(_L("<Endpoint>")); |
|
2962 TL(posId != -1); |
|
2963 CleanupStack::PopAndDestroy();//Ptr |
|
2964 |
|
2965 //2nd time |
|
2966 xmlService ->SetEndPointL(KText); |
|
2967 //checking xml |
|
2968 //TL(ConvertToPtr16LC(*xmlService) == KRef); |
|
2969 ptr = ConvertToPtr16LC(*xmlService); |
|
2970 posId = -1; |
|
2971 messageToParse.Set(ptr); |
|
2972 posId = messageToParse.Find(_L("<Endpoint>")); |
|
2973 TL(posId != -1); |
|
2974 TL(xmlService->Endpoint() == KText); |
|
2975 |
|
2976 CleanupStack::PopAndDestroy();//Ptr |
|
2977 |
|
2978 |
|
2979 xmlService ->SetEndPointL(KText2); |
|
2980 //checking xml |
|
2981 _LIT16(KRef2, "<ServiceDescription><ProviderPolicy/><ServicePolicy/><Endpoint>text2</Endpoint></ServiceDescription>"); |
|
2982 //TL(ConvertToPtr16LC(*xmlService) == KRef2); |
|
2983 |
|
2984 TL(xmlService->Endpoint() == KText2); |
|
2985 ptr = ConvertToPtr16LC(*xmlService); |
|
2986 posId = -1; |
|
2987 messageToParse.Set(ptr); |
|
2988 posId = messageToParse.Find(_L("<Endpoint>")); |
|
2989 TL(posId != -1); |
|
2990 CleanupStack::PopAndDestroy();//Ptr |
|
2991 |
|
2992 __ASSERT_ALWAYS_NO_LEAVE(delete xmlService); |
|
2993 xmlService = NULL; |
|
2994 Teardown(); |
|
2995 return KErrNone; |
|
2996 } |
|
2997 |
|
2998 TInt CSenServDesc::MT_CSenXmlServiceDescription_FrameworkIdL( TTestResult& aResult ) |
|
2999 { |
|
3000 return MT_CSenXmlServiceDescription_SetFrameworkIdLL(aResult); |
|
3001 } |
|
3002 |
|
3003 TInt CSenServDesc::MT_CSenXmlServiceDescription_FrameworkVersionL( TTestResult& aResult ) |
|
3004 { |
|
3005 SetupL(); |
|
3006 |
|
3007 CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL(); |
|
3008 __ASSERT_ALWAYS_NO_LEAVE(xmlService ->FrameworkVersion()); |
|
3009 if(!(xmlService ->FrameworkVersion() == KNullDesC8))return KErrArgument; |
|
3010 |
|
3011 __ASSERT_ALWAYS_NO_LEAVE(delete xmlService); |
|
3012 xmlService = NULL; |
|
3013 Teardown(); |
|
3014 return KErrNone; |
|
3015 } |
|
3016 |
|
3017 TInt CSenServDesc::MT_CSenXmlServiceDescription_SetContractLL( TTestResult& aResult ) |
|
3018 { |
|
3019 return MT_CSenXmlServiceDescription_ContractL(aResult); |
|
3020 } |
|
3021 |
|
3022 TInt CSenServDesc::MT_CSenXmlServiceDescription_SetEndPointLL( TTestResult& aResult ) |
|
3023 { |
|
3024 return MT_CSenXmlServiceDescription_EndpointL(aResult); |
|
3025 } |
|
3026 |
|
3027 TInt CSenServDesc::MT_CSenXmlServiceDescription_SetAttributesLL( TTestResult& aResult ) |
|
3028 { |
|
3029 SetupL(); |
|
3030 |
|
3031 CSenXmlServiceDescription* xmlService = CSenXmlServiceDescription::NewL(); |
|
3032 RAttributeArray attributeArray; |
|
3033 xmlService->SetAttributesL(attributeArray); |
|
3034 __ASSERT_ALWAYS_NO_LEAVE(delete xmlService); |
|
3035 xmlService = NULL; |
|
3036 attributeArray.Reset(); |
|
3037 attributeArray.Close(); |
|
3038 Teardown(); |
|
3039 return KErrNone; |
|
3040 } |
|
3041 |
|
3042 TInt CSenServDesc::MT_CSenXmlServiceDescription_CopyFromLL( TTestResult& aResult ) |
|
3043 { |
|
3044 SetupL(); |
|
3045 _LIT8(KContent, "content"); |
|
3046 _LIT8(KFacet, "Facet"); |
|
3047 |
|
3048 CSenFacet* senFacet = CSenFacet::NewL(); |
|
3049 TL(senFacet != (CSenFacet*)NULL); |
|
3050 |
|
3051 RStringPool stringPool; |
|
3052 stringPool.OpenL(); |
|
3053 CleanupClosePushL(stringPool); |
|
3054 |
|
3055 RString nsUriRString = stringPool.OpenStringL(_L8("nsuri")); |
|
3056 CleanupClosePushL(nsUriRString); |
|
3057 RString nsPrefixRString = stringPool.OpenStringL(_L8("pr")); |
|
3058 CleanupClosePushL(nsPrefixRString); |
|
3059 RString localNameRString = stringPool.OpenStringL(_L8("LocalName")); |
|
3060 CleanupClosePushL(localNameRString); |
|
3061 RString valueRString = stringPool.OpenStringL(_L8("Value")); |
|
3062 CleanupClosePushL(valueRString); |
|
3063 |
|
3064 RAttribute attribute; |
|
3065 attribute.Open(nsUriRString, nsPrefixRString, localNameRString, |
|
3066 valueRString); |
|
3067 CleanupStack::Pop(4); |
|
3068 CleanupClosePushL(attribute); |
|
3069 |
|
3070 RAttributeArray attrArray; |
|
3071 attrArray.AppendL(attribute); |
|
3072 CleanupClosePushL(attrArray); |
|
3073 |
|
3074 CSenXmlElement* xmlElem = CSenXmlElement::NewL(KText, KText, KText); |
|
3075 CSenXmlElement* xmlElem2 = CSenXmlElement::NewL(KText2); |
|
3076 xmlElem->AddElementL(*xmlElem2); |
|
3077 TL (xmlElem->SetContentL(KContent) == KContent); |
|
3078 xmlElem->SetAttributesL(attrArray); |
|
3079 |
|
3080 senFacet->CopyFromL(*xmlElem); |
|
3081 |
|
3082 TL (senFacet->LocalName() == KFacet); |
|
3083 TL (senFacet->NamespaceURI() == KNullDesC8); |
|
3084 TL (senFacet->NsPrefix() == KNullDesC8); |
|
3085 TL (senFacet->Content() == KContent); |
|
3086 RPointerArray<CSenElement>& xmlElemList = senFacet->ElementsL(); |
|
3087 TL (xmlElemList.Count() == 1); |
|
3088 RPointerArray<CSenBaseAttribute>& xmlElemAttrList = senFacet->AttributesL(); |
|
3089 TL (xmlElemAttrList.Count() == 1); |
|
3090 |
|
3091 CleanupStack::PopAndDestroy(&attrArray); |
|
3092 CleanupStack::PopAndDestroy(&attribute); |
|
3093 CleanupStack::PopAndDestroy(&stringPool); |
|
3094 |
|
3095 __ASSERT_ALWAYS_NO_LEAVE(delete xmlElem); |
|
3096 xmlElem = NULL; |
|
3097 |
|
3098 __ASSERT_ALWAYS_NO_LEAVE(delete senFacet); |
|
3099 senFacet = NULL; |
|
3100 |
|
3101 Teardown(); |
|
3102 return KErrNone; |
|
3103 } |
|
3104 |
|
3105 |
|
3106 // ----------------------------------------------------------------------------- |
|
3107 // ?classname::?member_function |
|
3108 // ?implementation_description |
|
3109 // (other items were commented in a header). |
|
3110 // ----------------------------------------------------------------------------- |
|
3111 // |
|
3112 /* |
|
3113 ?type ?classname::?member_function( |
|
3114 ?arg_type arg, |
|
3115 ?arg_type arg ) |
|
3116 { |
|
3117 |
|
3118 ?code |
|
3119 |
|
3120 } |
|
3121 */ |
|
3122 |
|
3123 // ========================== OTHER EXPORTED FUNCTIONS ========================= |
|
3124 |
|
3125 // ----------------------------------------------------------------------------- |
|
3126 // ?function_name implements... |
|
3127 // ?implementation_description. |
|
3128 // Returns: ?value_1: ?description |
|
3129 // ?value_n: ?description |
|
3130 // ?description |
|
3131 // ----------------------------------------------------------------------------- |
|
3132 // |
|
3133 /* |
|
3134 ?type ?function_name( |
|
3135 ?arg_type arg, // ?description |
|
3136 ?arg_type arg ) // ?description |
|
3137 { |
|
3138 |
|
3139 ?code |
|
3140 |
|
3141 } |
|
3142 */ |
|
3143 // End of File |
|
3144 |
|
3145 // End of File |