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