|
1 /* |
|
2 * Copyright (c) 2002-2009 Nokia Corporation and/or its subsidiary(-ies). |
|
3 * All rights reserved. |
|
4 * This component and the accompanying materials are made available |
|
5 * under the terms of "Eclipse Public License v1.0" |
|
6 * which accompanies this distribution, and is available |
|
7 * at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
8 * |
|
9 * Initial Contributors: |
|
10 * Nokia Corporation - initial contribution. |
|
11 * |
|
12 * Contributors: |
|
13 * |
|
14 * Description: ?Description |
|
15 * |
|
16 */ |
|
17 |
|
18 |
|
19 |
|
20 |
|
21 |
|
22 |
|
23 |
|
24 |
|
25 |
|
26 // INCLUDE FILES |
|
27 #include <StifTestModule.h> |
|
28 #include <e32math.h> |
|
29 #include <libc/assert.h> |
|
30 #include <e32panic.h> |
|
31 #include "senutilsbctest.h" |
|
32 |
|
33 // ============================ MEMBER FUNCTIONS =============================== |
|
34 |
|
35 // ----------------------------------------------------------------------------- |
|
36 // CSenUtilsBCTest::Case |
|
37 // Returns a test case by number. |
|
38 // |
|
39 // This function contains an array of all available test cases |
|
40 // i.e pair of case name and test function. If case specified by parameter |
|
41 // aCaseNumber is found from array, then that item is returned. |
|
42 // |
|
43 // The reason for this rather complicated function is to specify all the |
|
44 // test cases only in one place. It is not necessary to understand how |
|
45 // function pointers to class member functions works when adding new test |
|
46 // cases. See function body for instructions how to add new test case. |
|
47 // ----------------------------------------------------------------------------- |
|
48 // |
|
49 const TCaseInfo CSenUtilsBCTest::Case ( |
|
50 const TInt aCaseNumber ) const |
|
51 { |
|
52 |
|
53 /** |
|
54 * To add new test cases, implement new test case function and add new |
|
55 * line to KCases array specify the name of the case and the function |
|
56 * doing the test case |
|
57 * In practice, do following |
|
58 * 1) Make copy of existing test case function and change its name |
|
59 * and functionality. Note that the function must be added to |
|
60 * SenUtils.cpp file and to SenUtils.h |
|
61 * header file. |
|
62 * |
|
63 * 2) Add entry to following KCases array either by using: |
|
64 * |
|
65 * 2.1: FUNCENTRY or ENTRY macro |
|
66 * ENTRY macro takes two parameters: test case name and test case |
|
67 * function name. |
|
68 * |
|
69 * FUNCENTRY macro takes only test case function name as a parameter and |
|
70 * uses that as a test case name and test case function name. |
|
71 * |
|
72 * Or |
|
73 * |
|
74 * 2.2: OOM_FUNCENTRY or OOM_ENTRY macro. Note that these macros are used |
|
75 * only with OOM (Out-Of-Memory) testing! |
|
76 * |
|
77 * OOM_ENTRY macro takes five parameters: test case name, test case |
|
78 * function name, TBool which specifies is method supposed to be run using |
|
79 * OOM conditions, TInt value for first heap memory allocation failure and |
|
80 * TInt value for last heap memory allocation failure. |
|
81 * |
|
82 * OOM_FUNCENTRY macro takes test case function name as a parameter and uses |
|
83 * that as a test case name, TBool which specifies is method supposed to be |
|
84 * run using OOM conditions, TInt value for first heap memory allocation |
|
85 * failure and TInt value for last heap memory allocation failure. |
|
86 */ |
|
87 |
|
88 static TCaseInfoInternal const KCases[] = |
|
89 { |
|
90 |
|
91 ENTRY( "NewL - CSenSoapEnvelope", CSenUtilsBCTest::CSenSoapEnvelope_NewLL ), |
|
92 ENTRY( "SetBodyL - CSenSoapEnvelope ", CSenUtilsBCTest::CSenSoapEnvelope_SetBodyLL ), |
|
93 ENTRY( "BodyL - CSenSoapEnvelope ", CSenUtilsBCTest::CSenSoapEnvelope_BodyLL ), |
|
94 ENTRY( "HeaderL - CSenSoapEnvelope ", CSenUtilsBCTest::CSenSoapEnvelope_HeaderLL ), |
|
95 ENTRY( "AddHeaderL - CSenSoapEnvelope", CSenUtilsBCTest::CSenSoapEnvelope_AddHeaderLL ), |
|
96 ENTRY( "BodyAsStringL - CSenSoapEnvelope ", CSenUtilsBCTest::CSenSoapEnvelope_BodyAsStringLL ), |
|
97 ENTRY( "DetachFaultL - CSenSoapEnvelope ", CSenUtilsBCTest::CSenSoapEnvelope_DetachFaultLL ), |
|
98 ENTRY( "FaultL - CSenSoapEnvelope ", CSenUtilsBCTest::CSenSoapEnvelope_FaultLL ), |
|
99 ENTRY( "SoapAction - CSenSoapEnvelope ", CSenUtilsBCTest::CSenSoapEnvelope_SoapActionL ), |
|
100 // ENTRY( "SoapAction2 - CSenSoapEnvelope ", CSenUtilsBCTest::CSenSoapEnvelope_SoapAction2L ), |
|
101 ENTRY( "HasHeader - CSenSoapEnvelope ", CSenUtilsBCTest::CSenSoapEnvelope_HasHeaderL ), |
|
102 ENTRY( "SoapVersion - CSenSoapEnvelope ", CSenUtilsBCTest::CSenSoapEnvelope_SoapVersionL ), |
|
103 ENTRY( "HasBody - CSenSoapEnvelope ", CSenUtilsBCTest::CSenSoapEnvelope_HasBodyL ), |
|
104 ENTRY( "IsFault - CSenSoapEnvelope ", CSenUtilsBCTest::CSenSoapEnvelope_IsFaultL ), |
|
105 ENTRY( "ParseL - CSenSoapEnvelope ", CSenUtilsBCTest::CSenSoapEnvelope_ParseLL ), |
|
106 |
|
107 ENTRY( "NewL - CSenSoapFault ", CSenUtilsBCTest::CSenSoapFault_NewLL ), |
|
108 ENTRY( "NewL - CSenSoapFault ", CSenUtilsBCTest::CSenSoapFault_NewL_1L ), |
|
109 ENTRY( "FaultCode - CSenSoapFault ", CSenUtilsBCTest::CSenSoapFault_FaultCodeL ), |
|
110 ENTRY( "FaultSubcode - CSenSoapFault ", CSenUtilsBCTest::CSenSoapFault_FaultSubcodeL ), |
|
111 |
|
112 ENTRY( "FaultString - CSenSoapFault ", CSenUtilsBCTest::CSenSoapFault_FaultStringL ), |
|
113 ENTRY( "FaultActor - CSenSoapFault ", CSenUtilsBCTest::CSenSoapFault_FaultActorL ), |
|
114 ENTRY( "Detail - CSenSoapFault ", CSenUtilsBCTest::CSenSoapFault_DetailL ), |
|
115 ENTRY( "NewL - CSenSoapMessage ", CSenUtilsBCTest::CSenSoapMessage_NewLL ), |
|
116 ENTRY( "SetSecurityHeaderL - CSenSoapMessage ", CSenUtilsBCTest::CSenSoapMessage_SetSecurityHeaderLL ), |
|
117 ENTRY( "AddSecurityTokenL - CSenSoapMessage ", CSenUtilsBCTest::CSenSoapMessage_AddSecurityTokenLL ), |
|
118 ENTRY( "NewL - CSenWsSecurityHeader ", CSenUtilsBCTest::CSenWsSecurityHeader_NewLL ), |
|
119 ENTRY( "ParseL - CSenSoapMessage ", CSenUtilsBCTest::CSenSoapMessage_ParseLL ), |
|
120 |
|
121 ENTRY( "NewLC - CSenWsSecurityHeader ", CSenUtilsBCTest::CSenWsSecurityHeader_NewLCL ), |
|
122 ENTRY( "NewL - CSenWsSecurityHeader ", CSenUtilsBCTest::CSenWsSecurityHeader_NewL_1L ), |
|
123 ENTRY( "NewLC - CSenWsSecurityHeader ", CSenUtilsBCTest::CSenWsSecurityHeader_NewLC_1L ), |
|
124 ENTRY( "NewL - CSenWsSecurityHeader ", CSenUtilsBCTest::CSenWsSecurityHeader_NewL_2L ), |
|
125 ENTRY( "NewLC - CSenWsSecurityHeader ", CSenUtilsBCTest::CSenWsSecurityHeader_NewLC_2L ), |
|
126 ENTRY( "BinarySecurityToken - CSenWsSecurityHeader ", CSenUtilsBCTest::CSenWsSecurityHeader_BinarySecurityTokenL_L ), |
|
127 ENTRY( "BinarySecurityToken1 - CSenWsSecurityHeader ", CSenUtilsBCTest::CSenWsSecurityHeader_BinarySecurityTokenL_1L ), |
|
128 // ENTRY( "UsernameTokenL - CSenWsSecurityHeader ", CSenUtilsBCTest::CSenWsSecurityHeader_UsernameTokenLL ), |
|
129 ENTRY( "TimestampL - CSenWsSecurityHeader ", CSenUtilsBCTest::CSenWsSecurityHeader_TimestampL_L ), |
|
130 ENTRY( "TimestampL - CSenWsSecurityHeader ", CSenUtilsBCTest::CSenWsSecurityHeader_TimestampL_1L ), |
|
131 // ENTRY( "UsernameTokenL - CSenWsSecurityHeader ", CSenUtilsBCTest::CSenWsSecurityHeader_UsernameTokenL_1L ), |
|
132 // ENTRY( "UsernameTokenL - CSenWsSecurityHeader ", CSenUtilsBCTest::CSenWsSecurityHeader_UsernameTokenL_2L ), |
|
133 // ENTRY( "UsernameTokenL - CSenWsSecurityHeader ", CSenUtilsBCTest::CSenWsSecurityHeader_UsernameTokenL_3L ), |
|
134 // ENTRY( "UsernameTokenL - CSenWsSecurityHeader ", CSenUtilsBCTest::CSenWsSecurityHeader_UsernameTokenL_4L ), |
|
135 ENTRY( "XmlNs - CSenWsSecurityHeader ", CSenUtilsBCTest::CSenWsSecurityHeader_XmlNsL ), |
|
136 ENTRY( "XmlNsPrefix - CSenWsSecurityHeader ", CSenUtilsBCTest::CSenWsSecurityHeader_XmlNsPrefixL ), |
|
137 ENTRY( "FromXmlDateTimeL - SenDateUtils ", CSenUtilsBCTest::SenDateUtils_FromXmlDateTimeLL ), |
|
138 ENTRY( "ToXmlDateTimeUtf8L - SenDateUtils ", CSenUtilsBCTest::SenDateUtils_ToXmlDateTimeUtf8LL ), |
|
139 ENTRY( "ToXmlDateTimeUtf82L - SenDateUtils ", CSenUtilsBCTest::SenDateUtils_ToXmlDateTimeUtf82LL ), |
|
140 |
|
141 ENTRY( "FileAttachmentL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_FileAttachmentLL ), |
|
142 ENTRY( "NewL - CSenXmlProperties", CSenUtilsBCTest::SenXmlProperties_NewLL ), |
|
143 ENTRY( "NewLC - CSenXmlProperties", CSenUtilsBCTest::SenXmlProperties_NewLCL ), |
|
144 ENTRY( "NewL - CSenXmlProperties", CSenUtilsBCTest::SenXmlProperties_NewL_1L ), |
|
145 ENTRY( "NewLC - CSenXmlProperties", CSenUtilsBCTest::SenXmlProperties_NewLC_1L ), |
|
146 ENTRY( "NewL - CSenXmlProperties", CSenUtilsBCTest::SenXmlProperties_NewL_2L ), |
|
147 ENTRY( "NewLC - CSenXmlProperties", CSenUtilsBCTest::SenXmlProperties_NewLC_2L ), |
|
148 ENTRY( "NewL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_NewLL ), |
|
149 ENTRY( "NewLC - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_NewLCL ), |
|
150 ENTRY( "NewL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_NewL_1L ), |
|
151 ENTRY( "NewLC - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_NewLC_1L ), |
|
152 ENTRY( "NewL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_NewL_2L ), |
|
153 ENTRY( "NewLC - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_NewLC_2L ), |
|
154 ENTRY( "AsUtf8L - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_AsUtf8LL ), |
|
155 ENTRY( "SetPropertyL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_SetPropertyLL ), |
|
156 ENTRY( "PropertyL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_PropertyLL ), |
|
157 ENTRY( "SetIntPropertyL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_SetIntPropertyLL ), |
|
158 ENTRY( "IntPropertyL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_IntPropertyLL ), |
|
159 ENTRY( "SetBoolPropertyL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_SetBoolPropertyLL ), |
|
160 ENTRY( "BoolPropertyL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_BoolPropertyLL ), |
|
161 ENTRY( "SetOmittedL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_SetOmittedLL ), |
|
162 ENTRY( "RemovePropertyL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_RemovePropertyLL ), |
|
163 ENTRY( "HeartbeatL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_HeartbeatLL ), |
|
164 ENTRY( "SetHeartbeatL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_SetHeartbeatLL ), |
|
165 ENTRY( "IapIdL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_IapIdLL ), |
|
166 ENTRY( "SetIapIdL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_SetIapIdLL ), |
|
167 ENTRY( "ProxyPortL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_ProxyPortLL ), |
|
168 ENTRY( "SetProxyPortL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_SetProxyPortLL ), |
|
169 ENTRY( "ProxyHostL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_ProxyHostLL ), |
|
170 ENTRY( "SetProxyHostL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_SetProxyHostLL ), |
|
171 ENTRY( "ProxyUsageL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_ProxyUsageLL ), |
|
172 ENTRY( "SetProxyUsageL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_SetProxyUsageLL ), |
|
173 ENTRY( "SecureDialogL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_SecureDialogLL ), |
|
174 ENTRY( "SetSecureDialogL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_SetSecureDialogLL ), |
|
175 ENTRY( "UserAgentL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_UserAgentLL ), |
|
176 ENTRY( "SetUserAgentL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_SetUserAgentLL ), |
|
177 ENTRY( "DeviceIDL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_DeviceIDLL ), |
|
178 ENTRY( "SetDeviceIDL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_SetDeviceIDLL ), |
|
179 ENTRY( "SoapActionL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_SoapActionLL ), |
|
180 ENTRY( "SetSoapActionL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_SetSoapActionLL ), |
|
181 ENTRY( "DownloadFolderL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_DownloadFolderLL ), |
|
182 ENTRY( "SetDownloadFolderL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_SetDownloadFolderLL ), |
|
183 ENTRY( "SetFileAttachmentL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_SetFileAttachmentLL ), |
|
184 ENTRY( "MwsNamespaceL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_MwsNamespaceLL ), |
|
185 ENTRY( "SetMwsNamespaceL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_SetMwsNamespaceLL ), |
|
186 ENTRY( "MessageIdL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_MessageIdLL ), |
|
187 ENTRY( "SetMessageIdL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_SetMessageIdLL ), |
|
188 ENTRY( "OnewayMessageOnOffL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_OnewayMessageOnOffLL ), |
|
189 ENTRY( "SetOnewayMessageOnOffL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_SetOnewayMessageOnOffLL ), |
|
190 ENTRY( "SetMaxTimeToLiveL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_SetMaxTimeToLiveLL ), |
|
191 ENTRY( "MaxTimeToLiveL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_MaxTimeToLiveLL ), |
|
192 ENTRY( "SetMaxTimeToLiveL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_SetMaxTimeToLiveLL), |
|
193 ENTRY( "MinTimeToLiveL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_MinTimeToLiveLL ), |
|
194 ENTRY( "SetMinTimeToLiveL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_SetMinTimeToLiveLL ), |
|
195 ENTRY( "SetReaderL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_SetReaderL ), |
|
196 ENTRY( "PropertiesClassTypeL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_PropertiesClassTypeL ), |
|
197 ENTRY( "WriteToLL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_WriteToLL ), |
|
198 ENTRY( "ReadFromLL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_ReadFromLL ), |
|
199 ENTRY( "CloneL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_CloneL ), |
|
200 ENTRY( "IsSafeToCastL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_IsSafeToCastL ), |
|
201 ENTRY( "CloneLL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_CloneLL ), |
|
202 ENTRY( "ApplyBindingLL - CSenTransportProperties", CSenUtilsBCTest::SenTransportProperties_ApplyBindingLL ), |
|
203 |
|
204 ENTRY( "NewL - CSenHttpTransportProperties", CSenUtilsBCTest::SenHttpTransportProperties_NewLL ), |
|
205 ENTRY( "NewLC - CSenHttpTransportProperties", CSenUtilsBCTest::SenHttpTransportProperties_NewLCL ), |
|
206 ENTRY( "NewL - CSenHttpTransportProperties", CSenUtilsBCTest::SenHttpTransportProperties_NewL_1L ), |
|
207 ENTRY( "NewLC - CSenHttpTransportProperties", CSenUtilsBCTest::SenHttpTransportProperties_NewLC_1L ), |
|
208 ENTRY( "NewL - CSenHttpTransportProperties", CSenUtilsBCTest::SenHttpTransportProperties_NewL_2L ), |
|
209 ENTRY( "NewLC - CSenHttpTransportProperties", CSenUtilsBCTest::SenHttpTransportProperties_NewLC_2L), |
|
210 //ENTRY( "NewL - CSenVtcpTransportProperties", CSenUtilsBCTest::SenVtcpTransportProperties_NewLL ), |
|
211 //ENTRY( "NewLC - CSenVtcpTransportProperties", CSenUtilsBCTest::SenVtcpTransportProperties_NewLCL ), |
|
212 //ENTRY( "NewL - CSenVtcpTransportProperties", CSenUtilsBCTest::SenVtcpTransportProperties_NewL_1L ), |
|
213 //ENTRY( "NewLC - CSenVtcpTransportProperties", CSenUtilsBCTest::SenVtcpTransportProperties_NewLC_1L ), |
|
214 //ENTRY( "NewL - CSenVtcpTransportProperties", CSenUtilsBCTest::SenVtcpTransportProperties_NewL_2L ), |
|
215 //ENTRY( "NewLC - CSenVtcpTransportProperties", CSenUtilsBCTest::SenVtcpTransportProperties_NewLC_2L ), |
|
216 //ENTRY( "OnewayMessageOnOffL - CSenVtcpTransportProperties", CSenUtilsBCTest::SenVtcpTransportProperties_OnewayMessageOnOffLL ), |
|
217 //ENTRY( "SetOnewayMessageOnOffL - CSenVtcpTransportProperties", CSenUtilsBCTest::SenVtcpTransportProperties_SetOnewayMessageOnOffLL ), |
|
218 //ENTRY( "SetMaxTimeToLiveL - CSenVtcpTransportProperties", CSenUtilsBCTest::SenVtcpTransportProperties_SetMaxTimeToLiveLL ), |
|
219 //ENTRY( "MaxTimeToLiveL - CSenVtcpTransportProperties", CSenUtilsBCTest::SenVtcpTransportProperties_MaxTimeToLiveLL ), |
|
220 //ENTRY( "MinTimeToLiveL - CSenVtcpTransportProperties", CSenUtilsBCTest::SenVtcpTransportProperties_MinTimeToLiveLL ), |
|
221 //ENTRY( "SetMinTimeToLiveL - CSenVtcpTransportProperties", CSenUtilsBCTest::SenVtcpTransportProperties_SetMinTimeToLiveLL ),*/ |
|
222 |
|
223 |
|
224 // Example how to use OOM functionality |
|
225 //OOM_ENTRY( "Loop test with OOM", CSenUtilsBCTest::LoopTest, ETrue, 2, 3), |
|
226 //OOM_FUNCENTRY( CSenUtilsBCTest::PrintTest, ETrue, 1, 3 ), |
|
227 }; |
|
228 |
|
229 // Verify that case number is valid |
|
230 if( (TUint) aCaseNumber >= sizeof( KCases ) / |
|
231 sizeof( TCaseInfoInternal ) ) |
|
232 { |
|
233 // Invalid case, construct empty object |
|
234 TCaseInfo null( (const TText*) L"" ); |
|
235 null.iMethod = NULL; |
|
236 null.iIsOOMTest = EFalse; |
|
237 null.iFirstMemoryAllocation = 0; |
|
238 null.iLastMemoryAllocation = 0; |
|
239 return null; |
|
240 } |
|
241 |
|
242 // Construct TCaseInfo object and return it |
|
243 TCaseInfo tmp ( KCases[ aCaseNumber ].iCaseName ); |
|
244 tmp.iMethod = KCases[ aCaseNumber ].iMethod; |
|
245 tmp.iIsOOMTest = KCases[ aCaseNumber ].iIsOOMTest; |
|
246 tmp.iFirstMemoryAllocation = KCases[ aCaseNumber ].iFirstMemoryAllocation; |
|
247 tmp.iLastMemoryAllocation = KCases[ aCaseNumber ].iLastMemoryAllocation; |
|
248 return tmp; |
|
249 |
|
250 } |
|
251 |
|
252 void CSenUtilsBCTest::SetupL( ){ |
|
253 if ( iXmlReader ){ |
|
254 delete iXmlReader; |
|
255 iXmlReader = NULL; |
|
256 } |
|
257 iXmlReader = CSenXmlReader::NewL(); |
|
258 } |
|
259 |
|
260 void CSenUtilsBCTest::Teardown( ){ |
|
261 if ( iXmlReader){ |
|
262 delete iXmlReader; |
|
263 iXmlReader = NULL; |
|
264 } |
|
265 } |
|
266 |
|
267 |
|
268 TPtr16 CSenUtilsBCTest::ConvertToPtr16LC(CSenBaseFragment &fragment){ |
|
269 HBufC16* xmlBuffer = fragment.AsElement().AsXmlUnicodeL();//Parent()-> |
|
270 CleanupStack::PushL( xmlBuffer ); |
|
271 TPtr16 ptr = xmlBuffer->Des(); |
|
272 if (ptr.Length()){ |
|
273 RDebug::Print( _L( "WSModTester: xmlBuffer length [%d]"),ptr.Length()); |
|
274 if (ptr.Length()<=254){//below string must be =< max byte value |
|
275 RDebug::Print( _L( "WSModTester: xmlBuffer #START#")); |
|
276 RDebug::Print( _L( "[%S]"),&ptr); |
|
277 RDebug::Print( _L( "WSModTester: xmlBuffer #END#")); |
|
278 } |
|
279 else |
|
280 RDebug::Print( _L( "WSModTester: xmlBuffer too long to display, must be <=256- 2//[]")); |
|
281 } |
|
282 else |
|
283 RDebug::Print( _L( "WSModTester: xmlBuffer empty")); |
|
284 return ptr; |
|
285 } |
|
286 |
|
287 TPtr16 CSenUtilsBCTest::ConvertToPtr16LC(MSenElement &element){ |
|
288 HBufC16* xmlBuffer = element.AsXmlUnicodeL();//Parent()-> |
|
289 CleanupStack::PushL( xmlBuffer ); |
|
290 TPtr16 ptr = xmlBuffer->Des(); |
|
291 if (ptr.Length() > 0){ |
|
292 RDebug::Print( _L( "WSModTester: xmlBuffer length [%d]"),ptr.Length()); |
|
293 if (ptr.Length()<=254){//below string must be =< max byte value |
|
294 RDebug::Print( _L( "WSModTester: xmlBuffer #START#")); |
|
295 RDebug::Print( _L( "[%S]"),&ptr); |
|
296 RDebug::Print( _L( "WSModTester: xmlBuffer #END#")); |
|
297 } |
|
298 else |
|
299 RDebug::Print( _L( "WSModTester: xmlBuffer too long to display, must be <=256- 2//[]")); |
|
300 } |
|
301 else |
|
302 RDebug::Print( _L( "WSModTester: xmlBuffer empty")); |
|
303 return ptr; |
|
304 } |
|
305 |
|
306 TInt CSenUtilsBCTest::CSenSoapEnvelope_NewLL( TTestResult& aResult ) |
|
307 { |
|
308 SetupL(); |
|
309 CSenSoapEnvelope* env = CSenSoapEnvelope::NewL(); |
|
310 CleanupStack::PushL(env); |
|
311 /*EUNIT_ASSERT_NOT_EQUALS(env, (CSenSoapEnvelope*)NULL);*/ |
|
312 TL(env != (CSenSoapEnvelope*)NULL); |
|
313 //checking xml |
|
314 _LIT16(KRef, "<S:Envelope xmlns:S=\"http://schemas.xmlsoap.org/soap/envelope/\"/>"); |
|
315 TPtrC16 ptrRef = KRef(); |
|
316 /*EUNIT_ASSERT_EQUALS(ConvertToPtr16LC(*env), ptrRef);*/ |
|
317 TL(ConvertToPtr16LC(*env) == ptrRef); |
|
318 CleanupStack::PopAndDestroy();//Ptr |
|
319 CleanupStack::Pop(env); |
|
320 /*EUNIT_ASSERT_NO_LEAVE(delete env);*/ |
|
321 __ASSERT_ALWAYS_NO_LEAVE(delete env); |
|
322 env = NULL; |
|
323 Teardown(); |
|
324 return KErrNone; |
|
325 } |
|
326 |
|
327 TInt CSenUtilsBCTest::CSenSoapEnvelope_SetBodyLL( TTestResult& aResult ) |
|
328 { |
|
329 SetupL(); |
|
330 CSenSoapEnvelope* env = CSenSoapEnvelope::NewL(); |
|
331 /*EUNIT_ASSERT_NOT_EQUALS(env, (CSenSoapEnvelope*)NULL); */ |
|
332 TL(env != (CSenSoapEnvelope*)NULL); |
|
333 _LIT8(KBody,"ComarchBody"); |
|
334 TPtrC8 result = env->SetBodyL(KBody); |
|
335 |
|
336 _LIT16(KRef2, "ComarchBody"); |
|
337 TPtrC16 result16(reinterpret_cast<const TUint16*>(result.Ptr()),(result.Size()/2)); |
|
338 RDebug::Print( _L( "WSModTester: body [%S]"),&result16); |
|
339 /*EUNIT_ASSERT_EQUALS(result, KBody);*/ |
|
340 TL(result == KBody); |
|
341 _LIT16(KRef, "<S:Envelope xmlns:S=\"http://schemas.xmlsoap.org/soap/envelope/\"><S:Body>ComarchBody</S:Body></S:Envelope>"); |
|
342 /*EUNIT_ASSERT_EQUALS(ConvertToPtr16LC(*env), KRef);*/ |
|
343 TL(ConvertToPtr16LC(*env) == KRef); |
|
344 CleanupStack::PopAndDestroy();//Ptr |
|
345 |
|
346 /*EUNIT_ASSERT_NO_LEAVE(delete env);*/ |
|
347 __ASSERT_ALWAYS_NO_LEAVE(delete env); |
|
348 env = NULL; |
|
349 Teardown(); |
|
350 return KErrNone; |
|
351 } |
|
352 |
|
353 TInt CSenUtilsBCTest::CSenSoapEnvelope_BodyLL( TTestResult& aResult ) |
|
354 { |
|
355 SetupL(); |
|
356 CSenSoapEnvelope* env = CSenSoapEnvelope::NewL(); |
|
357 /*EUNIT_ASSERT_NOT_EQUALS(env, (CSenSoapEnvelope*)NULL); */ |
|
358 TL(env != (CSenSoapEnvelope*)NULL); |
|
359 _LIT8(KBody,"ComarchBody"); |
|
360 env->SetBodyL(KBody); |
|
361 |
|
362 CSenElement& element = env->BodyL(); |
|
363 |
|
364 _LIT16(KRef, "<S:Body>ComarchBody</S:Body>"); |
|
365 /*EUNIT_ASSERT_EQUALS(ConvertToPtr16LC(element), KRef);*/ |
|
366 TL(ConvertToPtr16LC(element) == KRef); |
|
367 CleanupStack::PopAndDestroy();//Ptr |
|
368 |
|
369 /*EUNIT_ASSERT_NO_LEAVE(delete env);*/ |
|
370 __ASSERT_ALWAYS_NO_LEAVE(delete env); |
|
371 env = NULL; |
|
372 |
|
373 Teardown(); |
|
374 return KErrNone; |
|
375 } |
|
376 |
|
377 TInt CSenUtilsBCTest::CSenSoapEnvelope_HeaderLL( TTestResult& aResult ) |
|
378 { |
|
379 SetupL(); |
|
380 CSenSoapEnvelope* env = CSenSoapEnvelope::NewL(); |
|
381 /*EUNIT_ASSERT_NOT_EQUALS(env, (CSenSoapEnvelope*)NULL); */ |
|
382 TL(env != (CSenSoapEnvelope*)NULL); |
|
383 CSenBaseElement* el = CSenBaseElement::NewL(KText); |
|
384 env->AddHeaderL(*el); |
|
385 el = &(CSenBaseElement&)env->HeaderL(); |
|
386 |
|
387 _LIT16(KRef, "<S:Header><text/></S:Header>"); |
|
388 /*EUNIT_ASSERT_EQUALS(ConvertToPtr16LC(*el), KRef);*/ |
|
389 TL(ConvertToPtr16LC(*el)== KRef); |
|
390 CleanupStack::PopAndDestroy();//Ptr |
|
391 |
|
392 /*EUNIT_ASSERT_NO_LEAVE*/ |
|
393 __ASSERT_ALWAYS_NO_LEAVE(delete env); |
|
394 env = NULL; |
|
395 Teardown(); |
|
396 return KErrNone; |
|
397 } |
|
398 |
|
399 TInt CSenUtilsBCTest::CSenSoapEnvelope_AddHeaderLL( TTestResult& aResult ) |
|
400 { |
|
401 SetupL(); |
|
402 CSenSoapEnvelope* env = CSenSoapEnvelope::NewL(); |
|
403 /*EUNIT_ASSERT_NOT_EQUALS*/TL(env != (CSenSoapEnvelope*)NULL); |
|
404 |
|
405 CSenBaseElement* el = CSenBaseElement::NewL(KText); |
|
406 //el = &(CSenBaseElement&) env->AddHeaderL(*el);//ok |
|
407 el = &(CSenBaseElement&) env->AddHeaderL(*el);//ok |
|
408 //checking xml |
|
409 _LIT16(KRef, "<S:Envelope xmlns:S=\"http://schemas.xmlsoap.org/soap/envelope/\"><S:Header><text/></S:Header><S:Body/></S:Envelope>"); |
|
410 TL(ConvertToPtr16LC(*env) == KRef); |
|
411 CleanupStack::PopAndDestroy();//Ptr |
|
412 |
|
413 _LIT16(KRef2, "<text/>"); |
|
414 TL(ConvertToPtr16LC(*el)== KRef2); |
|
415 CleanupStack::PopAndDestroy();//Ptr |
|
416 |
|
417 /*EUNIT_ASSERT_NO_LEAVE*/ |
|
418 __ASSERT_ALWAYS_NO_LEAVE(delete env); |
|
419 env = NULL; |
|
420 Teardown(); |
|
421 return KErrNone; |
|
422 } |
|
423 |
|
424 TInt CSenUtilsBCTest::CSenSoapEnvelope_BodyAsStringLL( TTestResult& aResult ) |
|
425 { |
|
426 SetupL(); |
|
427 CSenSoapEnvelope* env = CSenSoapEnvelope::NewL(); |
|
428 /*EUNIT_ASSERT_NOT_EQUALS*/TL(env != (CSenSoapEnvelope*)NULL); |
|
429 |
|
430 _LIT8(KBody,"ComarchBody"); |
|
431 env->SetBodyL(KBody); |
|
432 HBufC8* str = env->BodyAsStringL(); |
|
433 |
|
434 _LIT8(KRef, "<S:Body xmlns:S=\"http://schemas.xmlsoap.org/soap/envelope/\">ComarchBody</S:Body>"); |
|
435 TPtrC8 ptrRef = KRef(); |
|
436 TPtr8 ptr = str->Des(); |
|
437 TL(ptr == ptrRef); |
|
438 |
|
439 /*EUNIT_ASSERT_NO_LEAVE*/ |
|
440 __ASSERT_ALWAYS_NO_LEAVE(delete str); |
|
441 str = NULL; |
|
442 /*EUNIT_ASSERT_NO_LEAVE*/ |
|
443 __ASSERT_ALWAYS_NO_LEAVE(delete env); |
|
444 env = NULL; |
|
445 Teardown(); |
|
446 return KErrNone; |
|
447 } |
|
448 |
|
449 TInt CSenUtilsBCTest::CSenSoapEnvelope_DetachFaultLL( TTestResult& aResult ) |
|
450 { |
|
451 SetupL(); |
|
452 CSenSoapEnvelope* env = CSenSoapEnvelope::NewL(); |
|
453 env->SetReader( *iXmlReader ); |
|
454 iXmlReader->SetContentHandler(*env); |
|
455 env->ParseL(KFaultMessage); |
|
456 CSenSoapFault* fault = env->DetachFaultL(); |
|
457 |
|
458 //checking Envelope without Fault |
|
459 _LIT16(KRefEnvFault, "<S:Envelope xmlns:S=\"http://schemas.xmlsoap.org/soap/envelope/\"><S:Body/></S:Envelope>"); |
|
460 TPtrC16 ptrRefEnvFault = KRefEnvFault(); |
|
461 TL(ConvertToPtr16LC(*env) == ptrRefEnvFault); |
|
462 CleanupStack::PopAndDestroy();//Ptr |
|
463 |
|
464 //checking Fault |
|
465 _LIT16(KRefFault, "<S:Fault xmlns:S=\"http://schemas.xmlsoap.org/soap/envelope/\"><faultcode>VersionMismatch</faultcode><faultstring>some string</faultstring><faultactor>some actor</faultactor><detail>bla bla</detail></S:Fault>"); |
|
466 TPtrC16 ptrRefFault = KRefFault(); |
|
467 TL(ConvertToPtr16LC(*fault) == ptrRefFault); |
|
468 CleanupStack::PopAndDestroy();//Ptr |
|
469 /*EUNIT_ASSERT_NO_LEAVE*/ |
|
470 __ASSERT_ALWAYS_NO_LEAVE(delete env); |
|
471 env = NULL; |
|
472 /*EUNIT_ASSERT_NO_LEAVE*/ |
|
473 __ASSERT_ALWAYS_NO_LEAVE(delete fault); |
|
474 fault = NULL; |
|
475 |
|
476 |
|
477 env = CSenSoapEnvelope::NewL(); |
|
478 env->SetReader( *iXmlReader ); |
|
479 iXmlReader->SetContentHandler(*env); |
|
480 env->ParseL(KSOAPMessage); |
|
481 TL(env->DetachFaultL() == (CSenSoapFault* )NULL); |
|
482 //checking Envelope not touched should be |
|
483 _LIT16(KRefEnv, "<S:Envelope xmlns:S=\"http://schemas.xmlsoap.org/soap/envelope/\"><S:Header/><S:Body><QueryResponse><Data>Hard Coded response, alway the same</Data></QueryResponse></S:Body></S:Envelope>"); |
|
484 TPtrC16 ptrRefEnv = KRefEnv(); |
|
485 TL(ConvertToPtr16LC(*env) == ptrRefEnv); |
|
486 CleanupStack::PopAndDestroy();//Ptr |
|
487 /*EUNIT_ASSERT_NO_LEAVE*/ |
|
488 __ASSERT_ALWAYS_NO_LEAVE(delete env); |
|
489 env = NULL; |
|
490 Teardown(); |
|
491 return KErrNone; |
|
492 } |
|
493 |
|
494 TInt CSenUtilsBCTest::CSenSoapEnvelope_FaultLL( TTestResult& aResult ) |
|
495 { |
|
496 SetupL(); |
|
497 CSenSoapEnvelope* env = CSenSoapEnvelope::NewL(); |
|
498 env->SetReader( *iXmlReader ); |
|
499 iXmlReader->SetContentHandler(*env); |
|
500 |
|
501 |
|
502 env->ParseL(KFaultMessage); |
|
503 CSenSoapFault* fault = env->FaultL(); |
|
504 |
|
505 //checking Envelope, still Fault exist |
|
506 _LIT16(KRefEnvFault, "<S:Envelope xmlns:S=\"http://schemas.xmlsoap.org/soap/envelope/\"><S:Body><S:Fault><faultcode>VersionMismatch</faultcode><faultstring>some string</faultstring><faultactor>some actor</faultactor><detail>bla bla</detail></S:Fault></S:Body></S:Envelope>"); |
|
507 TL(ConvertToPtr16LC(*env)== KRefEnvFault); |
|
508 CleanupStack::PopAndDestroy();//Ptr |
|
509 //checking Fault |
|
510 _LIT16(KRefFault, "<S:Fault><faultcode>VersionMismatch</faultcode><faultstring>some string</faultstring><faultactor>some actor</faultactor><detail>bla bla</detail></S:Fault>"); |
|
511 TL(ConvertToPtr16LC(*fault) == KRefFault); |
|
512 CleanupStack::PopAndDestroy();//Ptr |
|
513 /*EUNIT_ASSERT_NO_LEAVE*/ |
|
514 __ASSERT_ALWAYS_NO_LEAVE(delete env); |
|
515 env = NULL; |
|
516 |
|
517 |
|
518 env = CSenSoapEnvelope::NewL(); |
|
519 env->SetReader( *iXmlReader ); |
|
520 iXmlReader->SetContentHandler(*env); |
|
521 env->ParseL(KSOAPMessage); |
|
522 TL(env->FaultL() == (CSenSoapFault* )NULL); |
|
523 //checking Envelope not touched should be |
|
524 _LIT16(KRefEnv, "<S:Envelope xmlns:S=\"http://schemas.xmlsoap.org/soap/envelope/\"><S:Header/><S:Body><QueryResponse><Data>Hard Coded response, alway the same</Data></QueryResponse></S:Body></S:Envelope>"); |
|
525 TL(ConvertToPtr16LC(*env) == KRefEnv); |
|
526 CleanupStack::PopAndDestroy();//Ptr |
|
527 /*EUNIT_ASSERT_NO_LEAVE*/ |
|
528 __ASSERT_ALWAYS_NO_LEAVE(delete env); |
|
529 env = NULL; |
|
530 Teardown(); |
|
531 return KErrNone; |
|
532 } |
|
533 |
|
534 TInt CSenUtilsBCTest::CSenSoapEnvelope_SoapActionL( TTestResult& aResult ) |
|
535 { |
|
536 SetupL(); |
|
537 CSenSoapEnvelope* env = CSenSoapEnvelope::NewL(); |
|
538 /*EUNIT_ASSERT_NOT_EQUALS*/TL(env != (CSenSoapEnvelope*)NULL); |
|
539 |
|
540 _LIT8(KRef, "\"\""); |
|
541 _LIT8(KRef2, "\"URI-referenceRFC2396\""); |
|
542 _LIT8(KRef3, ""); |
|
543 TL(env->SoapAction() == KRef); |
|
544 env->SetSoapActionL(_L8("URI-referenceRFC2396")); |
|
545 TL(env->SoapAction() == KRef2); |
|
546 env->SetSoapActionL(KRef2); |
|
547 TL(env->SoapAction() == KRef2); |
|
548 |
|
549 env->SetSoapActionL(KRef3); |
|
550 TL(env->SoapAction() == KRef3); |
|
551 |
|
552 |
|
553 /*EUNIT_ASSERT_NO_LEAVE*/ |
|
554 __ASSERT_ALWAYS_NO_LEAVE(delete env); |
|
555 env = NULL; |
|
556 Teardown(); |
|
557 return KErrNone; |
|
558 } |
|
559 |
|
560 TInt CSenUtilsBCTest::CSenSoapEnvelope_SoapAction2L( TTestResult& aResult ) |
|
561 { |
|
562 SetupL(); |
|
563 CSenSoapEnvelope* env = CSenSoapEnvelope::NewL(); |
|
564 /*EUNIT_ASSERT_NOT_EQUALS*/TL(env != (CSenSoapEnvelope*)NULL); |
|
565 |
|
566 _LIT8(KRef, ""); |
|
567 _LIT8(KRef2, "\"URI-referenceRFC2396\""); |
|
568 |
|
569 TL(env->SoapAction2() == KRef); |
|
570 env->SetSoapActionL(_L8("URI-referenceRFC2396")); |
|
571 TL(env->SoapAction2() == KRef2); |
|
572 env->SetSoapActionL(KRef2); |
|
573 TL(env->SoapAction2() == KRef2); |
|
574 |
|
575 |
|
576 /*EUNIT_ASSERT_NO_LEAVE*/ |
|
577 __ASSERT_ALWAYS_NO_LEAVE(delete env); |
|
578 env = NULL; |
|
579 Teardown(); |
|
580 return KErrNone; |
|
581 } |
|
582 |
|
583 TInt CSenUtilsBCTest::CSenSoapEnvelope_HasHeaderL( TTestResult& aResult ) |
|
584 { |
|
585 SetupL(); |
|
586 |
|
587 _LIT8(KHeaderElementName, "HeaderElement"); |
|
588 _LIT8(KHeaderContent, "HeaderContent"); |
|
589 |
|
590 CSenSoapEnvelope* pEnvelope = CSenSoapEnvelope::NewL(); |
|
591 |
|
592 if(!( pEnvelope->HasHeader() == EFalse )) return KErrArgument; |
|
593 CSenBaseElement* el = CSenBaseElement::NewL(KText); |
|
594 pEnvelope->AddHeaderL(*el); |
|
595 if(( pEnvelope->HasHeader() == EFalse )) return KErrArgument; |
|
596 |
|
597 |
|
598 __ASSERT_ALWAYS_NO_LEAVE(delete pEnvelope); |
|
599 pEnvelope = NULL; |
|
600 Teardown(); |
|
601 return KErrNone; |
|
602 |
|
603 //EUNIT_ASSERT_NO_LEAVE(delete el); |
|
604 //el = NULL; |
|
605 } |
|
606 |
|
607 TInt CSenUtilsBCTest::CSenSoapEnvelope_SoapVersionL( TTestResult& aResult ) |
|
608 { |
|
609 SetupL(); |
|
610 |
|
611 TSOAPVersion var = ESOAP11; |
|
612 CSenSoapEnvelope* pEnvelope = CSenSoapEnvelope::NewL(); |
|
613 CleanupStack::PushL(pEnvelope); |
|
614 |
|
615 TL(var == pEnvelope->SoapVersion()); |
|
616 CleanupStack::PopAndDestroy(pEnvelope); |
|
617 Teardown(); |
|
618 return KErrNone; |
|
619 |
|
620 } |
|
621 |
|
622 TInt CSenUtilsBCTest::CSenSoapEnvelope_HasBodyL( TTestResult& aResult ) |
|
623 { |
|
624 SetupL(); |
|
625 |
|
626 CSenSoapEnvelope* env = CSenSoapEnvelope::NewL(); |
|
627 TL(env != (CSenSoapEnvelope*)NULL); |
|
628 |
|
629 _LIT8(KBody,"ComarchBody"); |
|
630 TPtrC8 result = env->SetBodyL(KBody); |
|
631 if(( env->HasBody() == EFalse )) return KErrArgument; |
|
632 |
|
633 __ASSERT_ALWAYS_NO_LEAVE(delete env); |
|
634 env = NULL; |
|
635 |
|
636 CSenSoapEnvelope* env1 = CSenSoapEnvelope::NewL(); |
|
637 TL(env1 != (CSenSoapEnvelope*)NULL); |
|
638 |
|
639 if(!( env1->HasBody() == EFalse )) return KErrArgument; |
|
640 |
|
641 __ASSERT_ALWAYS_NO_LEAVE(delete env1); |
|
642 env1 = NULL; |
|
643 Teardown(); |
|
644 return KErrNone; |
|
645 |
|
646 } |
|
647 |
|
648 TInt CSenUtilsBCTest::CSenSoapEnvelope_IsFaultL( TTestResult& aResult ) |
|
649 { |
|
650 SetupL(); |
|
651 |
|
652 CSenSoapEnvelope* env = CSenSoapEnvelope::NewL(); |
|
653 TL(env!= (CSenSoapEnvelope*)NULL); |
|
654 if(!( env->IsFault() == EFalse )) return KErrArgument; |
|
655 __ASSERT_ALWAYS_NO_LEAVE(delete env); |
|
656 env = NULL; |
|
657 Teardown(); |
|
658 return KErrNone; |
|
659 |
|
660 } |
|
661 |
|
662 TInt CSenUtilsBCTest::CSenSoapEnvelope_ParseLL( TTestResult& aResult ) |
|
663 { |
|
664 SetupL(); |
|
665 _LIT8(KInputString, "<S:Envelope \ |
|
666 xmlns:S=\"http://schemas.xmlsoap.org/soap/envelope/\">\ |
|
667 <S:Header>\ |
|
668 <sb:Correlation xmlns:sb=\"urn:liberty:sb:2003-08\" \ |
|
669 messageID=\"URN:UUID:860949DC-134D-A989-E328-2FD7F20E31CE\" timestamp=\"2006-06-01T14:53:19Z\"/>\ |
|
670 <wsse:Security xmlns:wsse=\"http://schemas.xmlsoap.org/ws/2003/06/secext\"/>\ |
|
671 </S:Header>\ |
|
672 <S:Body>\ |
|
673 <sa:SASLRequest xmlns:sa=\"urn:liberty:sa:2004-04\" mechanism=\"ANONYMOUS PLAIN CRAM-MD5\" authzID=\"testuser1\"/>\ |
|
674 </S:Body>\ |
|
675 </S:Envelope>"); |
|
676 _LIT8(KBodyAsString, "\ |
|
677 <S:Body xmlns:S=\"http://schemas.xmlsoap.org/soap/envelope/\" xmlns:sa=\"urn:liberty:sa:2004-04\">\ |
|
678 <sa:SASLRequest xmlns:sa=\"urn:liberty:sa:2004-04\" mechanism=\"ANONYMOUS PLAIN CRAM-MD5\" authzID=\"testuser1\"/>\ |
|
679 </S:Body>"); |
|
680 |
|
681 _LIT8(KEmptyBodyAsString, "<S:Body/>"); |
|
682 |
|
683 _LIT8(KEmptyBodyWithNsAsString, "<S:Body xmlns:S=\"http://schemas.xmlsoap.org/soap/envelope/\"/>"); |
|
684 CSenParser* pParser = CSenParser::NewLC(); |
|
685 CSenSoapEnvelope* pEnvelope = CSenSoapEnvelope::NewL(); |
|
686 pEnvelope->SetReader( *iXmlReader ); |
|
687 iXmlReader->SetContentHandler(*pEnvelope); |
|
688 |
|
689 CleanupStack::PushL(pEnvelope); |
|
690 |
|
691 |
|
692 pEnvelope->ParseL(KInputString); |
|
693 |
|
694 CleanupStack::PopAndDestroy(pEnvelope); |
|
695 CleanupStack::PopAndDestroy(pParser); |
|
696 Teardown(); |
|
697 return KErrNone; |
|
698 } |
|
699 |
|
700 |
|
701 |
|
702 TInt CSenUtilsBCTest::CSenSoapFault_NewLL( TTestResult& aResult ) |
|
703 { |
|
704 SetupL(); |
|
705 RAttributeArray attributeArray; |
|
706 _LIT8(KFault, "Fault"); |
|
707 CSenSoapFault* soapFault = CSenSoapFault::NewL(KFault, KFault, KFault, attributeArray); |
|
708 CleanupStack::PushL(soapFault); |
|
709 /*EUNIT_ASSERT_NOT_EQUALS*/TL(soapFault != (CSenSoapFault*)NULL); |
|
710 |
|
711 //checking xml |
|
712 _LIT16(KRef, "<Fault xmlns=\"Fault\"/>"); |
|
713 TPtrC16 ptrRef = KRef(); |
|
714 TL(ConvertToPtr16LC(*soapFault) == ptrRef); |
|
715 CleanupStack::PopAndDestroy();//Ptr |
|
716 CleanupStack::Pop(soapFault); |
|
717 attributeArray.Close(); |
|
718 /*EUNIT_ASSERT_NO_LEAVE*/ |
|
719 __ASSERT_ALWAYS_NO_LEAVE(delete soapFault); |
|
720 soapFault = NULL; |
|
721 Teardown(); |
|
722 return KErrNone; |
|
723 } |
|
724 |
|
725 TInt CSenUtilsBCTest::CSenSoapFault_NewL_1L( TTestResult& aResult ) |
|
726 { |
|
727 SetupL(); |
|
728 RAttributeArray attributeArray; |
|
729 _LIT8(KFault, "Fault"); |
|
730 CSenSoapFault* orgSoapFault = CSenSoapFault::NewL(KFault, KFault, KFault, attributeArray); |
|
731 CSenSoapFault* soapFault = CSenSoapFault::NewL(*orgSoapFault); |
|
732 /*EUNIT_ASSERT_NOT_EQUALS*/TL(soapFault != (CSenSoapFault*)NULL); |
|
733 |
|
734 //checking xml |
|
735 _LIT16(KRef, "<Fault xmlns=\"Fault\"/>"); |
|
736 TL(ConvertToPtr16LC(*soapFault) == KRef); |
|
737 CleanupStack::PopAndDestroy();//Ptr |
|
738 |
|
739 /*EUNIT_ASSERT_NO_LEAVE*/ |
|
740 __ASSERT_ALWAYS_NO_LEAVE(delete orgSoapFault); |
|
741 orgSoapFault = NULL; |
|
742 /*EUNIT_ASSERT_NO_LEAVE*/ |
|
743 __ASSERT_ALWAYS_NO_LEAVE(delete soapFault); |
|
744 soapFault = NULL; |
|
745 Teardown(); |
|
746 return KErrNone; |
|
747 } |
|
748 |
|
749 TInt CSenUtilsBCTest::CSenSoapFault_FaultCodeL( TTestResult& aResult ) |
|
750 { |
|
751 SetupL(); |
|
752 CSenSoapEnvelope* env = CSenSoapEnvelope::NewL(); |
|
753 env->SetReader( *iXmlReader ); |
|
754 iXmlReader->SetContentHandler(*env); |
|
755 env->ParseL(KFaultMessage); |
|
756 CSenSoapFault* fault = env->DetachFaultL(); |
|
757 //not empty |
|
758 _LIT8(KCode, "VersionMismatch"); |
|
759 |
|
760 __ASSERT_ALWAYS_NO_LEAVE(fault->FaultCode()); |
|
761 TL(fault->FaultCode()== KCode); |
|
762 //TPtrC16 result16(reinterpret_cast<const TUint16*>(fault->FaultCode().Ptr()),(fault->FaultCode().Size()/2)); |
|
763 //RDebug::Print( _L( "WSModTester: faultCode [%S]"),&result16); |
|
764 |
|
765 /*EUNIT_ASSERT_NO_LEAVE*/ |
|
766 __ASSERT_ALWAYS_NO_LEAVE(delete fault); |
|
767 fault = NULL; |
|
768 /*EUNIT_ASSERT_NO_LEAVE*/ |
|
769 __ASSERT_ALWAYS_NO_LEAVE(delete env); |
|
770 env = NULL; |
|
771 |
|
772 //empty |
|
773 RAttributeArray attributeArray; |
|
774 fault = CSenSoapFault::NewL(KText, KText, KText, attributeArray); |
|
775 __ASSERT_ALWAYS_NO_LEAVE(fault->FaultCode()); |
|
776 TL(fault->FaultCode() == KNullDesC8); |
|
777 /*EUNIT_ASSERT_NO_LEAVE*/ |
|
778 __ASSERT_ALWAYS_NO_LEAVE(delete fault); |
|
779 fault = NULL; |
|
780 Teardown(); |
|
781 return KErrNone; |
|
782 } |
|
783 |
|
784 TInt CSenUtilsBCTest::CSenSoapFault_FaultSubcodeL( TTestResult& aResult ) |
|
785 { |
|
786 SetupL(); |
|
787 CSenSoapEnvelope* env = CSenSoapEnvelope::NewL(); |
|
788 env->SetReader( *iXmlReader ); |
|
789 iXmlReader->SetContentHandler(*env); |
|
790 env->ParseL(KFaultMessage); |
|
791 CSenSoapFault* fault = env->DetachFaultL(); |
|
792 |
|
793 |
|
794 //empty |
|
795 RAttributeArray attributeArray; |
|
796 fault = CSenSoapFault::NewL(KText, KText, KText, attributeArray); |
|
797 __ASSERT_ALWAYS_NO_LEAVE(fault->FaultSubcode()); |
|
798 TL(fault->FaultSubcode() == KNullDesC8); |
|
799 /*EUNIT_ASSERT_NO_LEAVE*/ |
|
800 __ASSERT_ALWAYS_NO_LEAVE(delete fault); |
|
801 fault = NULL; |
|
802 __ASSERT_ALWAYS_NO_LEAVE(delete env); |
|
803 env = NULL; |
|
804 |
|
805 Teardown(); |
|
806 return KErrNone; |
|
807 } |
|
808 |
|
809 TInt CSenUtilsBCTest::CSenSoapFault_FaultStringL( TTestResult& aResult ) |
|
810 { |
|
811 SetupL(); |
|
812 CSenSoapEnvelope* env = CSenSoapEnvelope::NewL(); |
|
813 env->SetReader( *iXmlReader ); |
|
814 iXmlReader->SetContentHandler(*env); |
|
815 env->ParseL(KFaultMessage); |
|
816 CSenSoapFault* fault = env->DetachFaultL(); |
|
817 //not empty |
|
818 _LIT8(KString, "some string"); |
|
819 /*EUNIT_ASSERT_NO_LEAVE*/ |
|
820 __ASSERT_ALWAYS_NO_LEAVE(fault->FaultString()); |
|
821 TL(fault->FaultString() == KString); |
|
822 /*EUNIT_ASSERT_NO_LEAVE*/ |
|
823 __ASSERT_ALWAYS_NO_LEAVE(delete fault); |
|
824 fault = NULL; |
|
825 /*EUNIT_ASSERT_NO_LEAVE*/ |
|
826 __ASSERT_ALWAYS_NO_LEAVE(delete env); |
|
827 env = NULL; |
|
828 |
|
829 //empty |
|
830 RAttributeArray attributeArray; |
|
831 fault = CSenSoapFault::NewL(KText, KText, KText, attributeArray); |
|
832 /*EUNIT_ASSERT_NO_LEAVE*/ |
|
833 __ASSERT_ALWAYS_NO_LEAVE(fault->FaultString()); |
|
834 TL(fault->FaultString() == KNullDesC8); |
|
835 /*EUNIT_ASSERT_NO_LEAVE*/ |
|
836 __ASSERT_ALWAYS_NO_LEAVE(delete fault); |
|
837 fault = NULL; |
|
838 Teardown(); |
|
839 return KErrNone; |
|
840 } |
|
841 |
|
842 TInt CSenUtilsBCTest::CSenSoapFault_FaultActorL( TTestResult& aResult ) |
|
843 { |
|
844 SetupL(); |
|
845 CSenSoapEnvelope* env = CSenSoapEnvelope::NewL(); |
|
846 env->SetReader( *iXmlReader ); |
|
847 iXmlReader->SetContentHandler(*env); |
|
848 env->ParseL(KFaultMessage); |
|
849 CSenSoapFault* fault = env->DetachFaultL(); |
|
850 //not empty |
|
851 _LIT8(KActor, "some actor"); |
|
852 /*EUNIT_ASSERT_NO_LEAVEP*/ |
|
853 __ASSERT_ALWAYS_NO_LEAVE(fault->FaultActor()); |
|
854 TL(fault->FaultActor() == KActor); |
|
855 /*EUNIT_ASSERT_NO_LEAVE*/ |
|
856 __ASSERT_ALWAYS_NO_LEAVE(delete fault); |
|
857 fault = NULL; |
|
858 /*EUNIT_ASSERT_NO_LEAVE*/ |
|
859 __ASSERT_ALWAYS_NO_LEAVE(delete env); |
|
860 env = NULL; |
|
861 |
|
862 //empty |
|
863 RAttributeArray attributeArray; |
|
864 fault = CSenSoapFault::NewL(KText, KText, KText, attributeArray); |
|
865 /*EUNIT_ASSERT_NO_LEAVE*/ |
|
866 __ASSERT_ALWAYS_NO_LEAVE(fault->FaultActor()); |
|
867 TL(fault->FaultActor() == KNullDesC8); |
|
868 /*EUNIT_ASSERT_NO_LEAVE*/ |
|
869 __ASSERT_ALWAYS_NO_LEAVE(delete fault); |
|
870 fault = NULL; |
|
871 Teardown(); |
|
872 return KErrNone; |
|
873 } |
|
874 |
|
875 TInt CSenUtilsBCTest::CSenSoapFault_DetailL( TTestResult& aResult ) |
|
876 { |
|
877 SetupL(); |
|
878 CSenSoapEnvelope* env = CSenSoapEnvelope::NewL(); |
|
879 env->SetReader( *iXmlReader ); |
|
880 iXmlReader->SetContentHandler(*env); |
|
881 env->ParseL(KFaultMessage); |
|
882 CSenSoapFault* fault = env->DetachFaultL(); |
|
883 //not empty |
|
884 _LIT8(KDetail, "bla bla"); |
|
885 /*EUNIT_ASSERT_NO_LEAVE*/ |
|
886 __ASSERT_ALWAYS_NO_LEAVE(fault->Detail()); |
|
887 TL(fault->Detail() == KDetail); |
|
888 /*EUNIT_ASSERT_NO_LEAVE*/ |
|
889 __ASSERT_ALWAYS_NO_LEAVE(delete fault); |
|
890 fault = NULL; |
|
891 /*EUNIT_ASSERT_NO_LEAVE*/ |
|
892 __ASSERT_ALWAYS_NO_LEAVE(delete env); |
|
893 env = NULL; |
|
894 |
|
895 //empty |
|
896 RAttributeArray attributeArray; |
|
897 fault = CSenSoapFault::NewL(KText, KText, KText, attributeArray); |
|
898 /*EUNIT_ASSERT_NO_LEAVE*/ |
|
899 __ASSERT_ALWAYS_NO_LEAVE(fault->Detail()); |
|
900 TL(fault->Detail() == KNullDesC8); |
|
901 /*EUNIT_ASSERT_NO_LEAVE*/ |
|
902 __ASSERT_ALWAYS_NO_LEAVE(delete fault); |
|
903 fault = NULL; |
|
904 Teardown(); |
|
905 return KErrNone; |
|
906 } |
|
907 |
|
908 TInt CSenUtilsBCTest::CSenSoapMessage_NewLL( TTestResult& aResult ) |
|
909 { |
|
910 SetupL(); |
|
911 CSenSoapMessage* msg = CSenSoapMessage::NewL(); |
|
912 /*EUNIT_ASSERT_NOT_EQUALS*/TL(msg != (CSenSoapMessage*)NULL); |
|
913 |
|
914 //checking xml |
|
915 _LIT16(KRef, "<S:Envelope xmlns:S=\"http://schemas.xmlsoap.org/soap/envelope/\"/>"); |
|
916 TL(ConvertToPtr16LC(*msg) == KRef); |
|
917 CleanupStack::PopAndDestroy();//Ptr |
|
918 |
|
919 /*EUNIT_ASSERT_NO_LEAVE*/ |
|
920 __ASSERT_ALWAYS_NO_LEAVE(delete msg); |
|
921 msg = NULL; |
|
922 Teardown(); |
|
923 return KErrNone; |
|
924 } |
|
925 |
|
926 TInt CSenUtilsBCTest::CSenSoapMessage_SetSecurityHeaderLL( TTestResult& aResult ) |
|
927 { |
|
928 SetupL(); |
|
929 CSenSoapMessage* msg = CSenSoapMessage::NewL(); |
|
930 /*EUNIT_ASSERT_NOT_EQUALS*/TL(msg != (CSenSoapMessage*)NULL); |
|
931 |
|
932 |
|
933 msg->SetSecurityHeaderL(KText); |
|
934 //checking xml |
|
935 _LIT16(KRef, "<S:Envelope xmlns:S=\"http://schemas.xmlsoap.org/soap/envelope/\"><S:Header><wsse:Security xmlns:wsse=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd\">text</wsse:Security></S:Header><S:Body/></S:Envelope>"); |
|
936 TPtrC16 ptrRef = KRef(); |
|
937 TL(ConvertToPtr16LC(*msg) == ptrRef); |
|
938 CleanupStack::PopAndDestroy();//Ptr |
|
939 |
|
940 msg->SetSecurityHeaderL(KText2); |
|
941 //checking xml |
|
942 _LIT16(KRef2, "<S:Envelope xmlns:S=\"http://schemas.xmlsoap.org/soap/envelope/\"><S:Header><wsse:Security xmlns:wsse=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd\">text2</wsse:Security></S:Header><S:Body/></S:Envelope>"); |
|
943 TPtrC16 ptrRef2 = KRef2(); |
|
944 TL(ConvertToPtr16LC(*msg) == ptrRef2); |
|
945 CleanupStack::PopAndDestroy();//Ptr |
|
946 |
|
947 |
|
948 /*EUNIT_ASSERT_NO_LEAVE*/ |
|
949 __ASSERT_ALWAYS_NO_LEAVE(delete msg); |
|
950 msg = NULL; |
|
951 Teardown(); |
|
952 return KErrNone; |
|
953 } |
|
954 |
|
955 TInt CSenUtilsBCTest::CSenSoapMessage_AddSecurityTokenLL( TTestResult& aResult ) |
|
956 { |
|
957 SetupL(); |
|
958 CSenSoapMessage* msg = CSenSoapMessage::NewL(); |
|
959 /*EUNIT_ASSERT_NOT_EQUALS*/TL(msg != (CSenSoapMessage*)NULL); |
|
960 |
|
961 |
|
962 /*EUNIT_ASSERT*/TL(msg->AddSecurityTokenL(KText)==KErrNone); |
|
963 //checking xml |
|
964 _LIT16(KRef, "<S:Envelope xmlns:S=\"http://schemas.xmlsoap.org/soap/envelope/\"><S:Header><wsse:Security xmlns:wsse=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd\">text</wsse:Security></S:Header><S:Body/></S:Envelope>"); |
|
965 TPtrC16 ptrRef = KRef(); |
|
966 TL(ConvertToPtr16LC(*msg) == ptrRef); |
|
967 CleanupStack::PopAndDestroy();//Ptr |
|
968 |
|
969 /*EUNIT_ASSERT*/TL(msg->AddSecurityTokenL(KText2)==KErrNone); |
|
970 //checking xml |
|
971 _LIT16(KRef2, "<S:Envelope xmlns:S=\"http://schemas.xmlsoap.org/soap/envelope/\"><S:Header><wsse:Security xmlns:wsse=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd\">texttext2</wsse:Security></S:Header><S:Body/></S:Envelope>"); |
|
972 TPtrC16 ptrRef2 = KRef2(); |
|
973 TL(ConvertToPtr16LC(*msg) == ptrRef2); |
|
974 CleanupStack::PopAndDestroy();//Ptr |
|
975 |
|
976 |
|
977 /*EUNIT_ASSERT_NO_LEAVE*/ |
|
978 __ASSERT_ALWAYS_NO_LEAVE(delete msg); |
|
979 msg = NULL; |
|
980 Teardown(); |
|
981 return KErrNone; |
|
982 } |
|
983 |
|
984 TInt CSenUtilsBCTest::CSenSoapMessage_ParseLL( TTestResult& aResult ) |
|
985 { |
|
986 SetupL(); |
|
987 _LIT8(KInputString, "<S:Envelope \ |
|
988 xmlns:S=\"http://schemas.xmlsoap.org/soap/envelope/\">\ |
|
989 <S:Header>\ |
|
990 <sb:Correlation xmlns:sb=\"urn:liberty:sb:2003-08\" \ |
|
991 messageID=\"URN:UUID:860949DC-134D-A989-E328-2FD7F20E31CE\" timestamp=\"2006-06-01T14:53:19Z\"/>\ |
|
992 <wsse:Security xmlns:wsse=\"http://schemas.xmlsoap.org/ws/2003/06/secext\"/>\ |
|
993 </S:Header>\ |
|
994 <S:Body>\ |
|
995 <sa:SASLRequest xmlns:sa=\"urn:liberty:sa:2004-04\" mechanism=\"ANONYMOUS PLAIN CRAM-MD5\" authzID=\"testuser1\"/>\ |
|
996 </S:Body>\ |
|
997 </S:Envelope>"); |
|
998 _LIT8(KBodyAsString, "\ |
|
999 <S:Body xmlns:S=\"http://schemas.xmlsoap.org/soap/envelope/\" xmlns:sa=\"urn:liberty:sa:2004-04\">\ |
|
1000 <sa:SASLRequest xmlns:sa=\"urn:liberty:sa:2004-04\" mechanism=\"ANONYMOUS PLAIN CRAM-MD5\" authzID=\"testuser1\"/>\ |
|
1001 </S:Body>"); |
|
1002 |
|
1003 _LIT8(KEmptyBodyAsString, "<S:Body/>"); |
|
1004 |
|
1005 _LIT8(KEmptyBodyWithNsAsString, "<S:Body xmlns:S=\"http://schemas.xmlsoap.org/soap/envelope/\"/>"); |
|
1006 CSenParser* pParser = CSenParser::NewLC(); |
|
1007 CSenSoapMessage* pMessage = CSenSoapMessage::NewL(); |
|
1008 pMessage->SetReader( *iXmlReader ); |
|
1009 iXmlReader->SetContentHandler(*pMessage); |
|
1010 |
|
1011 CleanupStack::PushL(pMessage); |
|
1012 |
|
1013 |
|
1014 pMessage->ParseL(KInputString); |
|
1015 |
|
1016 CleanupStack::PopAndDestroy(pMessage); |
|
1017 CleanupStack::PopAndDestroy(pParser); |
|
1018 Teardown(); |
|
1019 return KErrNone; |
|
1020 } |
|
1021 |
|
1022 |
|
1023 TInt CSenUtilsBCTest::CSenWsSecurityHeader_NewLL( TTestResult& aResult ) |
|
1024 { |
|
1025 SetupL(); |
|
1026 CSenWsSecurityHeader* hdr = CSenWsSecurityHeader::NewL(); |
|
1027 /*EUNIT_ASSERT_NOT_EQUALS*/TL(hdr != (CSenWsSecurityHeader*)NULL); |
|
1028 CleanupStack::PushL(hdr); |
|
1029 //checking xml |
|
1030 _LIT16(KRef, "<wsse:Security xmlns:wsse=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd\"/>"); |
|
1031 TPtrC16 ptrRef = KRef(); |
|
1032 TL(ConvertToPtr16LC(*hdr) == ptrRef); |
|
1033 CleanupStack::PopAndDestroy();//Ptr |
|
1034 CleanupStack::Pop(hdr); |
|
1035 /*EUNIT_ASSERT_NO_LEAVE*/ |
|
1036 __ASSERT_ALWAYS_NO_LEAVE(delete hdr); |
|
1037 hdr = NULL; |
|
1038 Teardown(); |
|
1039 return KErrNone; |
|
1040 } |
|
1041 |
|
1042 TInt CSenUtilsBCTest::CSenWsSecurityHeader_NewLCL( TTestResult& aResult ) |
|
1043 { |
|
1044 SetupL(); |
|
1045 CSenWsSecurityHeader* hdr = CSenWsSecurityHeader::NewLC(); |
|
1046 TL(hdr!= (CSenWsSecurityHeader*)NULL); |
|
1047 |
|
1048 //checking xml |
|
1049 _LIT16(KRef, "<wsse:Security xmlns:wsse=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd\"/>"); |
|
1050 TPtrC16 ptrRef(KRef); |
|
1051 TL(ConvertToPtr16LC(*hdr)== ptrRef); |
|
1052 CleanupStack::PopAndDestroy(2);//Ptr |
|
1053 Teardown(); |
|
1054 return KErrNone; |
|
1055 } |
|
1056 |
|
1057 |
|
1058 TInt CSenUtilsBCTest::CSenWsSecurityHeader_NewLC_1L( TTestResult& aResult ) |
|
1059 { |
|
1060 SetupL(); |
|
1061 CSenWsSecurityHeader* hdr = CSenWsSecurityHeader::NewLC(KText); |
|
1062 TL(hdr!= (CSenWsSecurityHeader*)NULL); |
|
1063 |
|
1064 //checking xml |
|
1065 _LIT16(KRef, "<wsse:Security xmlns:wsse=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd\">text</wsse:Security>"); |
|
1066 TPtrC16 ptrRef(KRef); |
|
1067 TL(ConvertToPtr16LC(*hdr)== ptrRef); |
|
1068 CleanupStack::PopAndDestroy(2); |
|
1069 |
|
1070 //EUNIT_ASSERT_NO_LEAVE(delete hdr); |
|
1071 hdr = NULL; |
|
1072 Teardown(); |
|
1073 return KErrNone; |
|
1074 } |
|
1075 |
|
1076 TInt CSenUtilsBCTest::CSenWsSecurityHeader_NewL_2L( TTestResult& aResult ) |
|
1077 { |
|
1078 SetupL(); |
|
1079 CSenWsSecurityHeader* hdr = CSenWsSecurityHeader::NewL(KText, KText); |
|
1080 TL(hdr!= (CSenWsSecurityHeader*)NULL); |
|
1081 CleanupStack::PushL(hdr); |
|
1082 //checking xml |
|
1083 _LIT16(KRef, "<wsse:Security xmlns:wsse=\"text\">text</wsse:Security>"); |
|
1084 TPtrC16 ptrRef(KRef); |
|
1085 TL(ConvertToPtr16LC(*hdr)== ptrRef); |
|
1086 CleanupStack::PopAndDestroy(2); |
|
1087 Teardown(); |
|
1088 return KErrNone; |
|
1089 } |
|
1090 |
|
1091 TInt CSenUtilsBCTest::CSenWsSecurityHeader_NewLC_2L( TTestResult& aResult ) |
|
1092 { |
|
1093 CSenWsSecurityHeader* hdr = CSenWsSecurityHeader::NewLC(KText, KText); |
|
1094 TL(hdr != (CSenWsSecurityHeader*)NULL); |
|
1095 |
|
1096 //checking xml |
|
1097 _LIT16(KRef, "<wsse:Security xmlns:wsse=\"text\">text</wsse:Security>"); |
|
1098 TPtrC16 ptrRef(KRef); |
|
1099 TL(ConvertToPtr16LC(*hdr)== ptrRef); |
|
1100 CleanupStack::PopAndDestroy(2); |
|
1101 Teardown(); |
|
1102 return KErrNone; |
|
1103 } |
|
1104 |
|
1105 |
|
1106 TInt CSenUtilsBCTest::CSenWsSecurityHeader_BinarySecurityTokenL_L( TTestResult& aResult ) |
|
1107 { |
|
1108 SetupL(); |
|
1109 //testing NULL |
|
1110 HBufC8* token=NULL; |
|
1111 TL(CSenWsSecurityHeader::BinarySecurityTokenL(KNullDesC8, token)==KErrNone); |
|
1112 TL(token != (HBufC8*)NULL); |
|
1113 //-----checking xml |
|
1114 _LIT8(KRef, "<wsse:BinarySecurityToken wsu:Id=\"token\" xmlns:wsu=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd\"></wsse:BinarySecurityToken>"); |
|
1115 TPtrC8 ptrRef(KRef); |
|
1116 TPtr8 ptrToken = token->Des(); |
|
1117 TL(ptrToken == ptrRef); |
|
1118 __ASSERT_ALWAYS_NO_LEAVE(delete token); |
|
1119 token = NULL; |
|
1120 |
|
1121 |
|
1122 //testing normal |
|
1123 TL(CSenWsSecurityHeader::BinarySecurityTokenL(KText, token)==KErrNone); |
|
1124 TL(token != (HBufC8*)NULL); |
|
1125 //-----checking xml |
|
1126 _LIT8(KRef2, "<wsse:BinarySecurityToken wsu:Id=\"token\" xmlns:wsu=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd\">text</wsse:BinarySecurityToken>"); |
|
1127 TPtrC8 ptrRef2(KRef2); |
|
1128 ptrToken = token->Des(); |
|
1129 TL(ptrToken == ptrRef2); |
|
1130 __ASSERT_ALWAYS_NO_LEAVE(delete token); |
|
1131 token = NULL; |
|
1132 Teardown(); |
|
1133 return KErrNone; |
|
1134 } |
|
1135 |
|
1136 TInt CSenUtilsBCTest::CSenWsSecurityHeader_BinarySecurityTokenL_1L( TTestResult& aResult ) |
|
1137 { |
|
1138 SetupL(); |
|
1139 //testing NULL |
|
1140 HBufC8* token=NULL; |
|
1141 TL(CSenWsSecurityHeader::BinarySecurityTokenL(KNullDesC8, KNullDesC8, token)==KErrNone); |
|
1142 TL(token != (HBufC8*)NULL); |
|
1143 //-----checking xml |
|
1144 _LIT8(KRef, "<wsse:BinarySecurityToken wsu:Id=\"token\" ValueType=\"\" xmlns:wsu=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd\"></wsse:BinarySecurityToken>"); |
|
1145 TPtrC8 ptrRef(KRef); |
|
1146 TPtr8 ptrToken = token->Des(); |
|
1147 TL(ptrToken == ptrRef); |
|
1148 __ASSERT_ALWAYS_NO_LEAVE(delete token); |
|
1149 token = NULL; |
|
1150 |
|
1151 |
|
1152 //testing normal |
|
1153 TL(CSenWsSecurityHeader::BinarySecurityTokenL(KText, KText, token)==KErrNone); |
|
1154 TL(token != (HBufC8*)NULL); |
|
1155 //-----checking xml |
|
1156 _LIT8(KRef2, "<wsse:BinarySecurityToken wsu:Id=\"token\" ValueType=\"text\" xmlns:wsu=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd\">text</wsse:BinarySecurityToken>"); |
|
1157 TPtrC8 ptrRef2(KRef2); |
|
1158 ptrToken = token->Des(); |
|
1159 TL(ptrToken == ptrRef2); |
|
1160 __ASSERT_ALWAYS_NO_LEAVE(delete token); |
|
1161 token = NULL; |
|
1162 Teardown(); |
|
1163 return KErrNone; |
|
1164 } |
|
1165 |
|
1166 TInt CSenUtilsBCTest::CSenWsSecurityHeader_TimestampL_L( TTestResult& aResult ) |
|
1167 { |
|
1168 SetupL(); |
|
1169 //testing NULL |
|
1170 HBufC8* timestamp=NULL; |
|
1171 TL(CSenWsSecurityHeader::TimestampL(KNullDesC8, timestamp)==KErrNone); |
|
1172 TL(timestamp != (HBufC8*)NULL); |
|
1173 //-----checking xml |
|
1174 _LIT8(KRef, "<wsu:Timestamp xmlns:wsu=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd\"><wsu:Created></wsu:Created></wsu:Timestamp>"); |
|
1175 TPtrC8 ptrRef(KRef); |
|
1176 TPtr8 ptrToken = timestamp->Des(); |
|
1177 TL(ptrToken == ptrRef); |
|
1178 __ASSERT_ALWAYS_NO_LEAVE(delete timestamp); |
|
1179 timestamp = NULL; |
|
1180 |
|
1181 |
|
1182 //testing normal |
|
1183 TL(CSenWsSecurityHeader::TimestampL(KText, timestamp)==KErrNone); |
|
1184 TL(timestamp != (HBufC8*)NULL); |
|
1185 //-----checking xml |
|
1186 _LIT8(KRef2, "<wsu:Timestamp xmlns:wsu=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd\"><wsu:Created>text</wsu:Created></wsu:Timestamp>"); |
|
1187 TPtrC8 ptrRef2(KRef2); |
|
1188 ptrToken = timestamp->Des(); |
|
1189 TL(ptrToken == ptrRef2); |
|
1190 __ASSERT_ALWAYS_NO_LEAVE(delete timestamp); |
|
1191 timestamp = NULL; |
|
1192 Teardown(); |
|
1193 return KErrNone; |
|
1194 } |
|
1195 |
|
1196 TInt CSenUtilsBCTest::CSenWsSecurityHeader_TimestampL_1L( TTestResult& aResult ) |
|
1197 { |
|
1198 SetupL(); |
|
1199 //testing NULL |
|
1200 HBufC8* timestamp=NULL; |
|
1201 TL(CSenWsSecurityHeader::TimestampL(KNullDesC8, KNullDesC8, timestamp)==KErrNone); |
|
1202 TL(timestamp != (HBufC8*)NULL); |
|
1203 //-----checking xml |
|
1204 _LIT8(KRef, "<wsu:Timestamp xmlns:wsu=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd\"><wsu:Created></wsu:Created><wsu:Expires></wsu:Expires></wsu:Timestamp>"); |
|
1205 TPtrC8 ptrRef(KRef); |
|
1206 TPtr8 ptrToken = timestamp->Des(); |
|
1207 TL(ptrToken == ptrRef); |
|
1208 __ASSERT_ALWAYS_NO_LEAVE(delete timestamp); |
|
1209 timestamp = NULL; |
|
1210 |
|
1211 |
|
1212 TL(CSenWsSecurityHeader::TimestampL(KNullDesC8, KText, timestamp)==KErrNone); |
|
1213 TL(timestamp != (HBufC8*)NULL); |
|
1214 //-----checking xml |
|
1215 _LIT8(KRef2, "<wsu:Timestamp xmlns:wsu=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd\"><wsu:Created></wsu:Created><wsu:Expires>text</wsu:Expires></wsu:Timestamp>"); |
|
1216 TPtrC8 ptrRef2(KRef2); |
|
1217 ptrToken = timestamp->Des(); |
|
1218 TL(ptrToken == ptrRef2); |
|
1219 __ASSERT_ALWAYS_NO_LEAVE(delete timestamp); |
|
1220 timestamp = NULL; |
|
1221 |
|
1222 TL(CSenWsSecurityHeader::TimestampL(KText, KNullDesC8, timestamp)==KErrNone); |
|
1223 TL(timestamp != (HBufC8*)NULL); |
|
1224 //-----checking xml |
|
1225 _LIT8(KRef3, "<wsu:Timestamp xmlns:wsu=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd\"><wsu:Created>text</wsu:Created><wsu:Expires></wsu:Expires></wsu:Timestamp>"); |
|
1226 TPtrC8 ptrRef3(KRef3); |
|
1227 ptrToken = timestamp->Des(); |
|
1228 TL(ptrToken == ptrRef3); |
|
1229 __ASSERT_ALWAYS_NO_LEAVE(delete timestamp); |
|
1230 timestamp = NULL; |
|
1231 |
|
1232 //testing normal |
|
1233 TL(CSenWsSecurityHeader::TimestampL(KText, KText, timestamp)==KErrNone); |
|
1234 TL(timestamp != (HBufC8*)NULL); |
|
1235 //-----checking xml |
|
1236 _LIT8(KRef4, "<wsu:Timestamp xmlns:wsu=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd\"><wsu:Created>text</wsu:Created><wsu:Expires>text</wsu:Expires></wsu:Timestamp>"); |
|
1237 TPtrC8 ptrRef4(KRef4); |
|
1238 ptrToken = timestamp->Des(); |
|
1239 TL(ptrToken == ptrRef4); |
|
1240 __ASSERT_ALWAYS_NO_LEAVE(delete timestamp); |
|
1241 timestamp = NULL; |
|
1242 Teardown(); |
|
1243 return KErrNone; |
|
1244 } |
|
1245 |
|
1246 |
|
1247 |
|
1248 |
|
1249 |
|
1250 TInt CSenUtilsBCTest::CSenWsSecurityHeader_UsernameTokenL_2L( TTestResult& aResult ) |
|
1251 { |
|
1252 SetupL(); |
|
1253 //testing NULL |
|
1254 HBufC8* token=NULL; |
|
1255 TL(CSenWsSecurityHeader::UsernameTokenL(KNullDesC8, KNullDesC8, token)==KErrNone); |
|
1256 TL(token != (HBufC8*)NULL); |
|
1257 //-----checking xml |
|
1258 _LIT8(KRef, "<wsse:UsernameToken><wsse:Username></wsse:Username><wsse:Password></wsse:Password></wsse:UsernameToken>"); |
|
1259 TPtrC8 ptrRef(KRef); |
|
1260 TPtr8 ptrToken = token->Des(); |
|
1261 TL(ptrToken == ptrRef); |
|
1262 __ASSERT_ALWAYS_NO_LEAVE(delete token); |
|
1263 token = NULL; |
|
1264 |
|
1265 |
|
1266 TL(CSenWsSecurityHeader::UsernameTokenL(KNullDesC8, KText, token)==KErrNone); |
|
1267 TL(token != (HBufC8*)NULL); |
|
1268 //-----checking xml |
|
1269 _LIT8(KRef2, "<wsse:UsernameToken><wsse:Username></wsse:Username><wsse:Password>text</wsse:Password></wsse:UsernameToken>"); |
|
1270 TPtrC8 ptrRef2(KRef2); |
|
1271 ptrToken = token->Des(); |
|
1272 TL(ptrToken == ptrRef2); |
|
1273 __ASSERT_ALWAYS_NO_LEAVE(delete token); |
|
1274 token = NULL; |
|
1275 |
|
1276 TL(CSenWsSecurityHeader::UsernameTokenL(KText, KNullDesC8, token)==KErrNone); |
|
1277 TL(token != (HBufC8*)NULL); |
|
1278 //-----checking xml |
|
1279 _LIT8(KRef3, "<wsse:UsernameToken><wsse:Username>text</wsse:Username><wsse:Password></wsse:Password></wsse:UsernameToken>"); |
|
1280 TPtrC8 ptrRef3(KRef3); |
|
1281 ptrToken = token->Des(); |
|
1282 TL(ptrToken == ptrRef3); |
|
1283 __ASSERT_ALWAYS_NO_LEAVE(delete token); |
|
1284 token = NULL; |
|
1285 |
|
1286 //testing normal |
|
1287 TL(CSenWsSecurityHeader::UsernameTokenL(KText, KText, token)==KErrNone); |
|
1288 TL(token != (HBufC8*)NULL); |
|
1289 //-----checking xml |
|
1290 _LIT8(KRef4, "<wsse:UsernameToken><wsse:Username>text</wsse:Username><wsse:Password>text</wsse:Password></wsse:UsernameToken>"); |
|
1291 TPtrC8 ptrRef4(KRef4); |
|
1292 ptrToken = token->Des(); |
|
1293 TL(ptrToken == ptrRef4); |
|
1294 __ASSERT_ALWAYS_NO_LEAVE(delete token); |
|
1295 token = NULL; |
|
1296 Teardown(); |
|
1297 return KErrNone; |
|
1298 } |
|
1299 |
|
1300 TInt CSenUtilsBCTest::CSenWsSecurityHeader_UsernameTokenL_3L( TTestResult& aResult ) |
|
1301 { |
|
1302 SetupL(); |
|
1303 CSenWsSecurityHeader::TPasswordType aType = CSenWsSecurityHeader::EText; |
|
1304 |
|
1305 //testing NULL |
|
1306 HBufC8* token=NULL; |
|
1307 TL(CSenWsSecurityHeader::UsernameTokenL(KNullDesC8, KNullDesC8, aType, token)==KErrNone); |
|
1308 TL(token != (HBufC8*)NULL); |
|
1309 //-----checking xml |
|
1310 _LIT8(KRef, "<wsse:UsernameToken><wsse:Username></wsse:Username><wsse:Password></wsse:Password></wsse:UsernameToken>"); |
|
1311 TPtrC8 ptrRef(KRef); |
|
1312 TPtr8 ptrToken = token->Des(); |
|
1313 TL(ptrToken == ptrRef); |
|
1314 __ASSERT_ALWAYS_NO_LEAVE(delete token); |
|
1315 token = NULL; |
|
1316 |
|
1317 |
|
1318 TL(CSenWsSecurityHeader::UsernameTokenL(KNullDesC8, KText, aType, token)==KErrNone); |
|
1319 TL(token != (HBufC8*)NULL); |
|
1320 //-----checking xml |
|
1321 _LIT8(KRef2, "<wsse:UsernameToken><wsse:Username></wsse:Username><wsse:Password>text</wsse:Password></wsse:UsernameToken>"); |
|
1322 TPtrC8 ptrRef2(KRef2); |
|
1323 ptrToken = token->Des(); |
|
1324 TL(ptrToken == ptrRef2); |
|
1325 __ASSERT_ALWAYS_NO_LEAVE(delete token); |
|
1326 token = NULL; |
|
1327 |
|
1328 |
|
1329 TL(CSenWsSecurityHeader::UsernameTokenL(KText, KNullDesC8, aType, token)==KErrNone); |
|
1330 TL(token != (HBufC8*)NULL); |
|
1331 //-----checking xml |
|
1332 _LIT8(KRef3, "<wsse:UsernameToken><wsse:Username>text</wsse:Username><wsse:Password></wsse:Password></wsse:UsernameToken>"); |
|
1333 TPtrC8 ptrRef3(KRef3); |
|
1334 ptrToken = token->Des(); |
|
1335 TL(ptrToken == ptrRef3); |
|
1336 __ASSERT_ALWAYS_NO_LEAVE(delete token); |
|
1337 token = NULL; |
|
1338 |
|
1339 //testing normal |
|
1340 TL(CSenWsSecurityHeader::UsernameTokenL(KText, KText, aType, token)==KErrNone); |
|
1341 TL(token != (HBufC8*)NULL); |
|
1342 //-----checking xml |
|
1343 _LIT8(KRef4, "<wsse:UsernameToken><wsse:Username>text</wsse:Username><wsse:Password>text</wsse:Password></wsse:UsernameToken>"); |
|
1344 TPtrC8 ptrRef4(KRef4); |
|
1345 ptrToken = token->Des(); |
|
1346 TL(ptrToken == ptrRef4); |
|
1347 __ASSERT_ALWAYS_NO_LEAVE(delete token); |
|
1348 token = NULL; |
|
1349 Teardown(); |
|
1350 return KErrNone; |
|
1351 } |
|
1352 |
|
1353 TInt CSenUtilsBCTest::CSenWsSecurityHeader_UsernameTokenL_4L( TTestResult& aResult ) |
|
1354 { |
|
1355 SetupL(); |
|
1356 |
|
1357 CSenWsSecurityHeader* hdr = CSenWsSecurityHeader::NewL(KText); |
|
1358 TL(hdr!= (CSenWsSecurityHeader*)NULL); |
|
1359 |
|
1360 CSenWsSecurityHeader::TPasswordType aType = CSenWsSecurityHeader::EText; |
|
1361 |
|
1362 //testing NULL |
|
1363 CSenIdentityProvider* provider = CSenIdentityProvider::NewL(KText, KText); |
|
1364 HBufC8* token=NULL; |
|
1365 token = hdr->UsernameTokenL(*provider, aType); |
|
1366 TL(token != (HBufC8*)NULL); |
|
1367 //-----checking xml |
|
1368 _LIT8(KRef, "<wsse:UsernameToken><wsse:Username></wsse:Username><wsse:Password></wsse:Password></wsse:UsernameToken>"); |
|
1369 TPtrC8 ptrRef(KRef); |
|
1370 TPtr8 ptrToken = token->Des(); |
|
1371 TL(ptrToken == ptrRef); |
|
1372 __ASSERT_ALWAYS_NO_LEAVE(delete provider); |
|
1373 provider = NULL; |
|
1374 __ASSERT_ALWAYS_NO_LEAVE(delete token); |
|
1375 token = NULL; |
|
1376 |
|
1377 |
|
1378 //testing normal |
|
1379 provider = CSenIdentityProvider::NewL(KText, KText); |
|
1380 provider->SetUserInfoL(KText, KText2, KText); |
|
1381 token = hdr->UsernameTokenL(*provider, aType); |
|
1382 TL(token != (HBufC8*)NULL); |
|
1383 //checking xml |
|
1384 _LIT8(KRef2, "<wsse:UsernameToken><wsse:Username>text</wsse:Username><wsse:Password>text</wsse:Password></wsse:UsernameToken>"); |
|
1385 TPtrC8 ptrRef2(KRef2); |
|
1386 TPtr8 ptrToken2 = token->Des(); |
|
1387 TL(ptrToken2 == ptrRef2); |
|
1388 __ASSERT_ALWAYS_NO_LEAVE(delete token); |
|
1389 token = NULL; |
|
1390 __ASSERT_ALWAYS_NO_LEAVE(delete provider); |
|
1391 provider = NULL; |
|
1392 __ASSERT_ALWAYS_NO_LEAVE(delete hdr); |
|
1393 hdr = NULL; |
|
1394 Teardown(); |
|
1395 return KErrNone; |
|
1396 |
|
1397 } |
|
1398 |
|
1399 |
|
1400 TInt CSenUtilsBCTest::CSenWsSecurityHeader_NewL_1L( TTestResult& aResult ) |
|
1401 { |
|
1402 SetupL(); |
|
1403 CSenWsSecurityHeader* hdr = CSenWsSecurityHeader::NewL(KText); |
|
1404 /*EUNIT_ASSERT_NOT_EQUALS*/TL(hdr != (CSenWsSecurityHeader*)NULL); |
|
1405 |
|
1406 //checking xml |
|
1407 _LIT16(KRef, "<wsse:Security xmlns:wsse=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd\">text</wsse:Security>"); |
|
1408 TPtrC16 ptrRef = KRef(); |
|
1409 TL(ConvertToPtr16LC(*hdr) == ptrRef); |
|
1410 CleanupStack::PopAndDestroy();//Ptr |
|
1411 |
|
1412 /*EUNIT_ASSERT_NO_LEAVE*/ |
|
1413 __ASSERT_ALWAYS_NO_LEAVE(delete hdr); |
|
1414 hdr = NULL; |
|
1415 Teardown(); |
|
1416 return KErrNone; |
|
1417 } |
|
1418 |
|
1419 TInt CSenUtilsBCTest::CSenWsSecurityHeader_UsernameTokenLL( TTestResult& aResult ) |
|
1420 { |
|
1421 SetupL(); |
|
1422 CSenWsSecurityHeader* hdr = CSenWsSecurityHeader::NewL(KText); |
|
1423 /*EUNIT_ASSERT_NOT_EQUALS*/TL(hdr != (CSenWsSecurityHeader*)NULL); |
|
1424 |
|
1425 //testing NULL |
|
1426 CSenIdentityProvider* provider = CSenIdentityProvider::NewL(KText, KText); |
|
1427 HBufC8* token=NULL; |
|
1428 token = hdr->UsernameTokenL(*provider); |
|
1429 /*EUNIT_ASSERT_NOT_EQUALS*/TL(token != (HBufC8*)NULL); |
|
1430 //-----checking xml |
|
1431 _LIT8(KRef, "<wsse:UsernameToken><wsse:Username></wsse:Username></wsse:UsernameToken>"); |
|
1432 TPtrC8 ptrRef = KRef(); |
|
1433 TPtr8 ptrToken = token->Des(); |
|
1434 TL(ptrToken == ptrRef); |
|
1435 /*EUNIT_ASSERT_NO_LEAVE*/ |
|
1436 __ASSERT_ALWAYS_NO_LEAVE(delete provider); |
|
1437 provider = NULL; |
|
1438 /*EUNIT_ASSERT_NO_LEAVE*/ |
|
1439 __ASSERT_ALWAYS_NO_LEAVE(delete token); |
|
1440 token = NULL; |
|
1441 |
|
1442 |
|
1443 //testing normal |
|
1444 provider = CSenIdentityProvider::NewL(KText, KText); |
|
1445 provider->SetUserInfoL(KText, KText2, KText); |
|
1446 token = hdr->UsernameTokenL(*provider); |
|
1447 /*EUNIT_ASSERT_NOT_EQUALS*/TL(token != (HBufC8*)NULL); |
|
1448 //checking xml |
|
1449 _LIT8(KRef2, "<wsse:UsernameToken><wsse:Username>text</wsse:Username></wsse:UsernameToken>"); |
|
1450 TPtrC8 ptrRef2 = KRef2(); |
|
1451 TPtr8 ptrToken2 = token->Des(); |
|
1452 TL(ptrToken2 == ptrRef2); |
|
1453 /*EUNIT_ASSERT_NO_LEAVE*/ |
|
1454 __ASSERT_ALWAYS_NO_LEAVE(delete token); |
|
1455 token = NULL; |
|
1456 /*EUNIT_ASSERT_NO_LEAVE*/ |
|
1457 __ASSERT_ALWAYS_NO_LEAVE(delete provider); |
|
1458 provider = NULL; |
|
1459 /*EUNIT_ASSERT_NO_LEAVE*/ |
|
1460 __ASSERT_ALWAYS_NO_LEAVE(delete hdr); |
|
1461 hdr = NULL; |
|
1462 Teardown(); |
|
1463 return KErrNone; |
|
1464 } |
|
1465 |
|
1466 TInt CSenUtilsBCTest::CSenWsSecurityHeader_UsernameTokenL_1L( TTestResult& aResult ) |
|
1467 { |
|
1468 SetupL(); |
|
1469 //testing NULL |
|
1470 HBufC8* token=NULL; |
|
1471 /*EUNIT_ASSERT*/TL(CSenWsSecurityHeader::UsernameTokenL(KNullDesC8, token)==KErrNone); |
|
1472 /*EUNIT_ASSERT_NOT_EQUALS*/TL(token != (HBufC8*)NULL); |
|
1473 //-----checking xml |
|
1474 _LIT8(KRef, "<wsse:UsernameToken><wsse:Username></wsse:Username></wsse:UsernameToken>"); |
|
1475 TPtrC8 ptrRef = KRef(); |
|
1476 TPtr8 ptrToken = token->Des(); |
|
1477 TL(ptrToken == ptrRef); |
|
1478 /*EUNIT_ASSERT_NO_LEAVE*/ |
|
1479 __ASSERT_ALWAYS_NO_LEAVE(delete token); |
|
1480 token = NULL; |
|
1481 |
|
1482 |
|
1483 //testing normal |
|
1484 /*EUNIT_ASSERT*/TL(CSenWsSecurityHeader::UsernameTokenL(KText, token)==KErrNone); |
|
1485 /*EUNIT_ASSERT_NOT_EQUALS*/TL(token != (HBufC8*)NULL); |
|
1486 //-----checking xml |
|
1487 _LIT8(KRef2, "<wsse:UsernameToken><wsse:Username>text</wsse:Username></wsse:UsernameToken>"); |
|
1488 TPtrC8 ptrRef2 = KRef2(); |
|
1489 ptrToken = token->Des(); |
|
1490 TL(ptrToken == ptrRef2); |
|
1491 /*EUNIT_ASSERT_NO_LEAVE*/ |
|
1492 __ASSERT_ALWAYS_NO_LEAVE(delete token); |
|
1493 token = NULL; |
|
1494 Teardown(); |
|
1495 return KErrNone; |
|
1496 } |
|
1497 |
|
1498 TInt CSenUtilsBCTest::CSenWsSecurityHeader_XmlNsL( TTestResult& aResult ) |
|
1499 { |
|
1500 SetupL(); |
|
1501 CSenWsSecurityHeader* hdr = CSenWsSecurityHeader::NewL(); |
|
1502 /*EUNIT_ASSERT_NOT_EQUALS*/TL(hdr != (CSenWsSecurityHeader*)NULL); |
|
1503 _LIT8(KSecurityXmlNsRef, "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd"); |
|
1504 /*EUNIT_ASSERT_NO_LEAVE*/ |
|
1505 __ASSERT_ALWAYS_NO_LEAVE(hdr->XmlNs()); |
|
1506 TL(hdr->XmlNs() == KSecurityXmlNsRef); |
|
1507 /*EUNIT_ASSERT_NO_LEAVE*/ |
|
1508 __ASSERT_ALWAYS_NO_LEAVE(delete hdr); |
|
1509 hdr = NULL; |
|
1510 Teardown(); |
|
1511 return KErrNone; |
|
1512 } |
|
1513 |
|
1514 TInt CSenUtilsBCTest::CSenWsSecurityHeader_XmlNsPrefixL( TTestResult& aResult ) |
|
1515 { |
|
1516 SetupL(); |
|
1517 CSenWsSecurityHeader* hdr = CSenWsSecurityHeader::NewL(); |
|
1518 /*EUNIT_ASSERT_NOT_EQUALS*/TL(hdr != (CSenWsSecurityHeader*)NULL); |
|
1519 _LIT8(KSecurityXmlNsPrefixRef, "wsse"); |
|
1520 /*EUNIT_ASSERT_NO_LEAVE*/ |
|
1521 __ASSERT_ALWAYS_NO_LEAVE(hdr->XmlNsPrefix()); |
|
1522 TL(hdr->XmlNsPrefix() == KSecurityXmlNsPrefixRef); |
|
1523 /*EUNIT_ASSERT_NO_LEAVE*/ |
|
1524 __ASSERT_ALWAYS_NO_LEAVE(delete hdr); |
|
1525 hdr = NULL; |
|
1526 Teardown(); |
|
1527 return KErrNone; |
|
1528 } |
|
1529 |
|
1530 |
|
1531 TInt CSenUtilsBCTest::SenDateUtils_FromXmlDateTimeLL( TTestResult& aResult ) |
|
1532 { |
|
1533 SetupL(); |
|
1534 //normal |
|
1535 TTime ttime, ttime2; |
|
1536 _LIT8(KIn1, "2005-02-28T13:20:05Z"); |
|
1537 _LIT(KDateTimeString1, "28-feb/05 01:20.05pm"); |
|
1538 ttime = SenDateUtils::FromXmlDateTimeL(KIn1); |
|
1539 ttime2.Parse(KDateTimeString1); |
|
1540 TL(ttime == ttime2); |
|
1541 |
|
1542 //-5 |
|
1543 _LIT8(KIn2, "2005-02-28T13:20:05-05:00"); |
|
1544 _LIT(KDateTimeString2, "28-feb/05 08:20.05am"); |
|
1545 ttime = SenDateUtils::FromXmlDateTimeL(KIn2); |
|
1546 ttime2.Parse(KDateTimeString2); |
|
1547 TL(ttime == ttime2); |
|
1548 |
|
1549 //+5 |
|
1550 _LIT8(KIn3, "2005-02-28T13:20:05+05:00"); |
|
1551 _LIT(KDateTimeString3, "28-feb/05 06:20.05pm"); |
|
1552 ttime = SenDateUtils::FromXmlDateTimeL(KIn3); |
|
1553 ttime2.Parse(KDateTimeString3); |
|
1554 TL(ttime == ttime2); |
|
1555 |
|
1556 //1 increase precision |
|
1557 _LIT8(KIn4, "2005-02-28T13:20:05.5Z"); |
|
1558 _LIT(KDateTimeString4, "20050127:132005.500000");//The month and day values are offset from zero. |
|
1559 ttime = SenDateUtils::FromXmlDateTimeL(KIn4); |
|
1560 ttime2 = TTime(KDateTimeString4); |
|
1561 TL(ttime == ttime2); |
|
1562 |
|
1563 |
|
1564 //3 increase precision |
|
1565 _LIT8(KIn5, "2005-02-28T13:20:05.231Z"); |
|
1566 _LIT(KDateTimeString5, "20050127:132005.231000");//The month and day values are offset from zero. |
|
1567 ttime = SenDateUtils::FromXmlDateTimeL(KIn5); |
|
1568 ttime2 = TTime(KDateTimeString5); |
|
1569 TL(ttime == ttime2); |
|
1570 |
|
1571 //-----------wrong |
|
1572 |
|
1573 //month |
|
1574 _LIT8(KIn6, "2005-55-28T13:20:05Z"); |
|
1575 TRAPD( err, SenDateUtils::FromXmlDateTimeL(KIn6)); |
|
1576 if(err != KErrOverflow) return err; |
|
1577 |
|
1578 //day |
|
1579 _LIT8(KIn7, "2005-02-58T13:20:05Z"); |
|
1580 TRAP(err, SenDateUtils::FromXmlDateTimeL(KIn7)); |
|
1581 if(err != KErrOverflow) return err; |
|
1582 |
|
1583 |
|
1584 //hour |
|
1585 _LIT8(KIn9, "2005-02-28T33:20:05Z"); |
|
1586 TRAP(err, SenDateUtils::FromXmlDateTimeL(KIn9)); |
|
1587 if(err != KErrOverflow) return err; |
|
1588 |
|
1589 //minute |
|
1590 _LIT8(KIn10, "2005-02-28T13:70:05Z"); |
|
1591 TRAP(err, SenDateUtils::FromXmlDateTimeL(KIn10)); |
|
1592 if(err != KErrOverflow) return err; |
|
1593 |
|
1594 //second |
|
1595 _LIT8(KIn11, "2005-02-28T13:20:65Z"); |
|
1596 TRAP(err, SenDateUtils::FromXmlDateTimeL(KIn11)); |
|
1597 if(err != KErrOverflow) return err; |
|
1598 |
|
1599 //+hour |
|
1600 _LIT8(KIn12, "2005-02-28T13:20:05+88:00"); |
|
1601 TRAP(err, SenDateUtils::FromXmlDateTimeL(KIn12)); |
|
1602 if(err != KErrOverflow) return err; |
|
1603 |
|
1604 //UTC wrong designator |
|
1605 _LIT8(KIn13, "2005-02-28T13:20:65Z05:00"); |
|
1606 TRAP(err, SenDateUtils::FromXmlDateTimeL(KIn13)); |
|
1607 if(err != KErrOverflow) return err; |
|
1608 |
|
1609 |
|
1610 //short garbage |
|
1611 _LIT8(KIn14, "xx"); |
|
1612 TRAP(err, SenDateUtils::FromXmlDateTimeL(KIn14)); |
|
1613 if(err != KErrUnderflow) return err; |
|
1614 |
|
1615 //garbage year |
|
1616 _LIT8(KIn15, "xxxx-02-28T13:20:65Z"); |
|
1617 //EUNIT_ASSERT_LEAVE |
|
1618 //ASSERT(SenDateUtils::FromXmlDateTimeL(KIn15)); |
|
1619 |
|
1620 //"-" |
|
1621 _LIT8(KIn16, "2005x02-28T13:20:65Z"); |
|
1622 TRAP(err, SenDateUtils::FromXmlDateTimeL(KIn16)); |
|
1623 if(err != KErrGeneral) return err; |
|
1624 |
|
1625 _LIT8(KIn17, "2005-02x28T13:20:65Z"); |
|
1626 TRAP(err, SenDateUtils::FromXmlDateTimeL(KIn17)); |
|
1627 if(err != KErrGeneral) return err; |
|
1628 |
|
1629 _LIT8(KIn18, "2005-02-28X13:20:65Z"); |
|
1630 TRAP(err, SenDateUtils::FromXmlDateTimeL(KIn18)); |
|
1631 if(err != KErrGeneral) return err; |
|
1632 |
|
1633 _LIT8(KIn19, "2005-02-28X13:20:65Z"); |
|
1634 TRAP(err, SenDateUtils::FromXmlDateTimeL(KIn19)); |
|
1635 if(err != KErrGeneral) return err; |
|
1636 |
|
1637 _LIT8(KIn20, "2005-02-28T13-20:65Z"); |
|
1638 TRAP(err, SenDateUtils::FromXmlDateTimeL(KIn20)); |
|
1639 if(err != KErrGeneral) return err; |
|
1640 |
|
1641 _LIT8(KIn21, "2005-02-28T13:20-65Z"); |
|
1642 TRAP(err, SenDateUtils::FromXmlDateTimeL(KIn21)); |
|
1643 if(err != KErrGeneral) return err; |
|
1644 |
|
1645 //31 II |
|
1646 _LIT8(KIn8, "2005-02-31T13:20:05Z"); |
|
1647 // EUNIT_ASSERT_PANIC(SenDateUtils::FromXmlDateTimeL(KIn8),"USER", 3 ); |
|
1648 TestModuleIf().SetExitReason (TestModuleIf(). EPanic, ETDateTimeBadDateTime); |
|
1649 SenDateUtils::FromXmlDateTimeL(KIn8); |
|
1650 |
|
1651 Teardown(); |
|
1652 return KErrNone; |
|
1653 } |
|
1654 |
|
1655 TInt CSenUtilsBCTest::SenDateUtils_ToXmlDateTimeUtf8LL( TTestResult& aResult ) |
|
1656 { |
|
1657 SetupL(); |
|
1658 //KXmlDateTimeMaxLength = 25 |
|
1659 _LIT(KDate, "23:34.56"); |
|
1660 _LIT8(KRef, "0000-01-01T23:34:56Z"); |
|
1661 TTime ttime; |
|
1662 TInt res(0); |
|
1663 HBufC8* writeBuf; |
|
1664 TInt error = ttime.Parse(KDate); |
|
1665 |
|
1666 //OK, more |
|
1667 writeBuf=HBufC8::New(SenDateUtils::KXmlDateTimeMaxLength+10); |
|
1668 //ptrResult = writeBuf->Des(); it wrong, becouse = operator will only copy, creation has been done in previous case |
|
1669 TPtr8 ptrResult2 = writeBuf->Des(); |
|
1670 // EUNIT_ASSERT_NO_LEAVE |
|
1671 __ASSERT_ALWAYS_NO_LEAVE(SenDateUtils::ToXmlDateTimeUtf8L(ptrResult2, ttime)); |
|
1672 TL(ptrResult2 == KRef); |
|
1673 delete writeBuf; |
|
1674 writeBuf = NULL; |
|
1675 |
|
1676 //OK,equal |
|
1677 writeBuf=HBufC8::New(SenDateUtils::KXmlDateTimeMaxLength); |
|
1678 //ptrResult = writeBuf->Des(); it wrong, becouse = operator will only copy, creation has been done in previous case |
|
1679 TPtr8 ptrResult3 = writeBuf->Des(); |
|
1680 //EUNIT_ASSERT_NO_LEAVE |
|
1681 __ASSERT_ALWAYS_NO_LEAVE(SenDateUtils::ToXmlDateTimeUtf8L(ptrResult3, ttime)); |
|
1682 TL(ptrResult3 == KRef); |
|
1683 delete writeBuf; |
|
1684 writeBuf = NULL; |
|
1685 |
|
1686 Teardown(); |
|
1687 |
|
1688 TRAP(res, |
|
1689 //SetupL(); |
|
1690 //CleanupStack::PushL(iXmlReader); |
|
1691 //KErrOverflow |
|
1692 writeBuf=HBufC8::NewLC(SenDateUtils::KXmlDateTimeMaxLength - 20); |
|
1693 TPtr8 ptrResult = writeBuf->Des(); |
|
1694 SenDateUtils::ToXmlDateTimeUtf8L(ptrResult, ttime); |
|
1695 CleanupStack::PopAndDestroy();//writeBuf |
|
1696 //CleanupStack::Pop();//iXmlReader |
|
1697 //Teardown(); |
|
1698 ); |
|
1699 if(res != KErrOverflow) |
|
1700 return res; |
|
1701 return KErrNone; |
|
1702 } |
|
1703 |
|
1704 |
|
1705 TInt CSenUtilsBCTest::SenDateUtils_ToXmlDateTimeUtf82LL( TTestResult& aResult ) |
|
1706 { |
|
1707 SetupL(); |
|
1708 //KXmlDateTimeMaxLength = 25 |
|
1709 _LIT(KDate, "23:34.56"); |
|
1710 _LIT8(KRef, "0000-01-01T23:34:56.000000Z"); |
|
1711 TTime ttime; |
|
1712 TInt res(0); |
|
1713 HBufC8* writeBuf; |
|
1714 TInt error = ttime.Parse(KDate); |
|
1715 |
|
1716 //OK, more |
|
1717 writeBuf=HBufC8::New(SenDateUtils::KXmlDateTimeMaxLength+10); |
|
1718 //ptrResult = writeBuf->Des(); it wrong, becouse = operator will only copy, creation has been done in previous case |
|
1719 TPtr8 ptrResult2 = writeBuf->Des(); |
|
1720 // EUNIT_ASSERT_NO_LEAVE |
|
1721 __ASSERT_ALWAYS_NO_LEAVE(SenDateUtils::ToXmlDateTimeUtf82L(ptrResult2, ttime)); |
|
1722 TL(ptrResult2 == KRef); |
|
1723 delete writeBuf; |
|
1724 writeBuf = NULL; |
|
1725 |
|
1726 //OK,equal |
|
1727 writeBuf=HBufC8::New(SenDateUtils::KXmlDateTimeMaxLength); |
|
1728 //ptrResult = writeBuf->Des(); it wrong, becouse = operator will only copy, creation has been done in previous case |
|
1729 TPtr8 ptrResult3 = writeBuf->Des(); |
|
1730 //EUNIT_ASSERT_NO_LEAVE |
|
1731 __ASSERT_ALWAYS_NO_LEAVE(SenDateUtils::ToXmlDateTimeUtf82L(ptrResult3, ttime)); |
|
1732 TL(ptrResult3 == KRef); |
|
1733 delete writeBuf; |
|
1734 writeBuf = NULL; |
|
1735 |
|
1736 Teardown(); |
|
1737 TRAP(res, |
|
1738 //KErrOverflow |
|
1739 writeBuf=HBufC8::NewLC(SenDateUtils::KXmlDateTimeMaxLength - 20); |
|
1740 TPtr8 ptrResult = writeBuf->Des(); |
|
1741 SenDateUtils::ToXmlDateTimeUtf82L(ptrResult, ttime); |
|
1742 CleanupStack::PopAndDestroy();//writeBuf |
|
1743 ); |
|
1744 if(res != KErrOverflow) |
|
1745 return res; |
|
1746 return KErrNone; |
|
1747 } |
|
1748 |
|
1749 TInt CSenUtilsBCTest::SenTransportProperties_FileAttachmentLL(TTestResult& aResult ) |
|
1750 { |
|
1751 SetupL(); |
|
1752 |
|
1753 CSenTransportProperties* transProp = CSenTransportProperties::NewLC(); |
|
1754 HBufC8* value = NULL; |
|
1755 TL(transProp->FileAttachmentL(_L8("1"),value) == KErrNotFound); |
|
1756 TL(value == (HBufC8*)NULL); |
|
1757 |
|
1758 transProp->SetFileAttachmentL(_L8("1"),_L8("abcd")); |
|
1759 TL(transProp->FileAttachmentL(_L8("1"),value) == KErrNone); |
|
1760 TL(*value == _L8("abcd")); |
|
1761 |
|
1762 delete value; |
|
1763 CleanupStack::PopAndDestroy(transProp); |
|
1764 Teardown(); |
|
1765 return KErrNone; |
|
1766 |
|
1767 } |
|
1768 |
|
1769 TInt CSenUtilsBCTest::SenXmlProperties_NewLL(TTestResult& aResult ) |
|
1770 { |
|
1771 SetupL(); |
|
1772 TBool Flag; |
|
1773 CSenXmlProperties *pXmlElement=CSenXmlProperties::NewL(); |
|
1774 CleanupStack::PushL(pXmlElement); |
|
1775 if(pXmlElement) |
|
1776 Flag=1; |
|
1777 else |
|
1778 Flag=0; |
|
1779 if(!( Flag )) return KErrArgument; |
|
1780 CleanupStack::PopAndDestroy(pXmlElement); |
|
1781 Teardown(); |
|
1782 return KErrNone; |
|
1783 } |
|
1784 |
|
1785 TInt CSenUtilsBCTest::SenXmlProperties_NewLCL(TTestResult& aResult ) |
|
1786 { |
|
1787 SetupL(); |
|
1788 TBool Flag; |
|
1789 CSenXmlProperties *pXmlElement=CSenXmlProperties::NewLC(); |
|
1790 |
|
1791 if(pXmlElement) |
|
1792 Flag=1; |
|
1793 else |
|
1794 Flag=0; |
|
1795 if(!( Flag )) return KErrArgument; |
|
1796 CleanupStack::PopAndDestroy(pXmlElement); |
|
1797 Teardown(); |
|
1798 return KErrNone; |
|
1799 } |
|
1800 |
|
1801 TInt CSenUtilsBCTest::SenXmlProperties_NewL_1L(TTestResult& aResult ) |
|
1802 { |
|
1803 SetupL(); |
|
1804 TBool Flag; |
|
1805 _LIT8(KString,"<parent><element1/><element2/><element3/>parent content</parent>"); |
|
1806 CSenXmlReader* pParser = CSenXmlReader::NewL(); |
|
1807 CleanupStack::PushL(pParser); |
|
1808 CSenXmlProperties *pXmlElement=CSenXmlProperties::NewL(KString,*pParser); |
|
1809 CleanupStack::PushL(pXmlElement); |
|
1810 if(pXmlElement) |
|
1811 Flag=1; |
|
1812 else |
|
1813 Flag=0; |
|
1814 if(!( Flag )) return KErrArgument; |
|
1815 CleanupStack::PopAndDestroy(pXmlElement); |
|
1816 CleanupStack::PopAndDestroy(pParser); |
|
1817 Teardown(); |
|
1818 return KErrNone; |
|
1819 } |
|
1820 |
|
1821 TInt CSenUtilsBCTest::SenXmlProperties_NewLC_1L(TTestResult& aResult ) |
|
1822 { |
|
1823 SetupL(); |
|
1824 TBool Flag; |
|
1825 _LIT8(KString,"<parent><element1/><element2/><element3/>parent content</parent>"); |
|
1826 CSenXmlReader* pParser = CSenXmlReader::NewL(); |
|
1827 CleanupStack::PushL(pParser); |
|
1828 CSenXmlProperties *pXmlElement=CSenXmlProperties::NewLC(KString,*pParser); |
|
1829 if(pXmlElement) |
|
1830 Flag=1; |
|
1831 else |
|
1832 Flag=0; |
|
1833 if(!( Flag )) return KErrArgument; |
|
1834 CleanupStack::PopAndDestroy(pXmlElement); |
|
1835 CleanupStack::PopAndDestroy(pParser); |
|
1836 Teardown(); |
|
1837 return KErrNone; |
|
1838 } |
|
1839 |
|
1840 TInt CSenUtilsBCTest::SenXmlProperties_NewL_2L(TTestResult& aResult ) |
|
1841 { |
|
1842 SetupL(); |
|
1843 TBool Flag; |
|
1844 CSenBaseElement* pElement= CSenBaseElement::NewL(_L8("Nokia")); |
|
1845 CleanupStack::PushL(pElement); |
|
1846 CSenXmlProperties *pXmlElement=CSenXmlProperties::NewL(*pElement); |
|
1847 CleanupStack::PushL(pXmlElement); |
|
1848 if(pXmlElement) |
|
1849 Flag=1; |
|
1850 else |
|
1851 Flag=0; |
|
1852 if(!( Flag )) return KErrArgument; |
|
1853 CleanupStack::PopAndDestroy(pXmlElement); |
|
1854 CleanupStack::PopAndDestroy(pElement); |
|
1855 Teardown(); |
|
1856 return KErrNone; |
|
1857 } |
|
1858 |
|
1859 TInt CSenUtilsBCTest::SenXmlProperties_NewLC_2L(TTestResult& aResult ) |
|
1860 { |
|
1861 SetupL(); |
|
1862 TBool Flag; |
|
1863 CSenBaseElement* pElement= CSenBaseElement::NewL(_L8("Nokia")); |
|
1864 CleanupStack::PushL(pElement); |
|
1865 CSenXmlProperties *pXmlElement=CSenXmlProperties::NewLC(*pElement); |
|
1866 if(pXmlElement) |
|
1867 Flag=1; |
|
1868 else |
|
1869 Flag=0; |
|
1870 if(!( Flag )) return KErrArgument; |
|
1871 CleanupStack::PopAndDestroy(pXmlElement); |
|
1872 CleanupStack::PopAndDestroy(pElement); |
|
1873 Teardown(); |
|
1874 return KErrNone; |
|
1875 } |
|
1876 |
|
1877 TInt CSenUtilsBCTest::SenTransportProperties_NewLL(TTestResult& aResult ) |
|
1878 { |
|
1879 SetupL(); |
|
1880 TBool Flag; |
|
1881 CSenTransportProperties* pElement= CSenTransportProperties::NewL(); |
|
1882 CleanupStack::PushL(pElement); |
|
1883 if(pElement) |
|
1884 Flag=1; |
|
1885 else |
|
1886 Flag=0; |
|
1887 if(!( Flag )) return KErrArgument; |
|
1888 CleanupStack::PopAndDestroy(pElement); |
|
1889 Teardown(); |
|
1890 return KErrNone; |
|
1891 } |
|
1892 |
|
1893 TInt CSenUtilsBCTest::SenTransportProperties_NewLCL(TTestResult& aResult ) |
|
1894 { |
|
1895 SetupL(); |
|
1896 TBool Flag; |
|
1897 CSenTransportProperties* pElement= CSenTransportProperties::NewLC(); |
|
1898 if(pElement) |
|
1899 Flag=1; |
|
1900 else |
|
1901 Flag=0; |
|
1902 if(!( Flag )) return KErrArgument; |
|
1903 CleanupStack::PopAndDestroy(pElement); |
|
1904 Teardown(); |
|
1905 return KErrNone; |
|
1906 } |
|
1907 |
|
1908 TInt CSenUtilsBCTest::SenTransportProperties_NewL_1L(TTestResult& aResult ) |
|
1909 { |
|
1910 SetupL(); |
|
1911 TBool Flag; |
|
1912 _LIT8(KString,"<parent><element1/><element2/><element3/>parent content</parent>"); |
|
1913 CSenXmlReader* pParser = CSenXmlReader::NewL(); |
|
1914 CleanupStack::PushL(pParser); |
|
1915 CSenTransportProperties *pXmlElement=CSenTransportProperties::NewL(KString,*pParser); |
|
1916 CleanupStack::PushL(pXmlElement); |
|
1917 if(pXmlElement) |
|
1918 Flag=1; |
|
1919 else |
|
1920 Flag=0; |
|
1921 if(!( Flag )) return KErrArgument; |
|
1922 CleanupStack::PopAndDestroy(pXmlElement); |
|
1923 CleanupStack::PopAndDestroy(pParser); |
|
1924 Teardown(); |
|
1925 return KErrNone; |
|
1926 } |
|
1927 |
|
1928 TInt CSenUtilsBCTest::SenTransportProperties_NewLC_1L(TTestResult& aResult ) |
|
1929 { |
|
1930 SetupL(); |
|
1931 TBool Flag; |
|
1932 _LIT8(KString,"<parent><element1/><element2/><element3/>parent content</parent>"); |
|
1933 CSenXmlReader* pParser = CSenXmlReader::NewL(); |
|
1934 CleanupStack::PushL(pParser); |
|
1935 CSenTransportProperties *pXmlElement=CSenTransportProperties::NewLC(KString,*pParser); |
|
1936 |
|
1937 if(pXmlElement) |
|
1938 Flag=1; |
|
1939 else |
|
1940 Flag=0; |
|
1941 if(!( Flag )) return KErrArgument; |
|
1942 CleanupStack::PopAndDestroy(pXmlElement); |
|
1943 CleanupStack::PopAndDestroy(pParser); |
|
1944 Teardown(); |
|
1945 return KErrNone; |
|
1946 } |
|
1947 |
|
1948 TInt CSenUtilsBCTest::SenTransportProperties_NewL_2L(TTestResult& aResult ) |
|
1949 { |
|
1950 SetupL(); |
|
1951 TBool Flag; |
|
1952 CSenBaseElement* pElement= CSenBaseElement::NewL(_L8("Nokia")); |
|
1953 CleanupStack::PushL(pElement); |
|
1954 CSenTransportProperties *pXmlElement=CSenTransportProperties::NewL(*pElement); |
|
1955 CleanupStack::PushL(pXmlElement); |
|
1956 if(pXmlElement) |
|
1957 Flag=1; |
|
1958 else |
|
1959 Flag=0; |
|
1960 if(!( Flag )) return KErrArgument; |
|
1961 CleanupStack::PopAndDestroy(pXmlElement); |
|
1962 CleanupStack::PopAndDestroy(pElement); |
|
1963 Teardown(); |
|
1964 return KErrNone; |
|
1965 } |
|
1966 |
|
1967 TInt CSenUtilsBCTest::SenTransportProperties_NewLC_2L(TTestResult& aResult ) |
|
1968 { |
|
1969 SetupL(); |
|
1970 TBool Flag; |
|
1971 CSenBaseElement* pElement= CSenBaseElement::NewL(_L8("Nokia")); |
|
1972 CleanupStack::PushL(pElement); |
|
1973 CSenTransportProperties *pXmlElement=CSenTransportProperties::NewLC(*pElement); |
|
1974 if(pXmlElement) |
|
1975 Flag=1; |
|
1976 else |
|
1977 Flag=0; |
|
1978 if(!( Flag )) KErrArgument; |
|
1979 CleanupStack::PopAndDestroy(pXmlElement); |
|
1980 CleanupStack::PopAndDestroy(pElement); |
|
1981 Teardown(); |
|
1982 return KErrNone; |
|
1983 } |
|
1984 |
|
1985 |
|
1986 TInt CSenUtilsBCTest::SenTransportProperties_AsUtf8LL(TTestResult& aResult ) |
|
1987 { |
|
1988 SetupL(); |
|
1989 _LIT8(KElementText,"<Properties><Property>value</Property></Properties>"); |
|
1990 CSenTransportProperties* pElement= CSenTransportProperties::NewL(); |
|
1991 CleanupStack::PushL(pElement); |
|
1992 pElement->SetPropertyL(_L8("Property"),_L8("value")); |
|
1993 HBufC8* Utf8Buf=pElement->AsUtf8L(); |
|
1994 TL(*Utf8Buf == KElementText); |
|
1995 CleanupStack::PopAndDestroy(pElement); |
|
1996 delete Utf8Buf; |
|
1997 Teardown(); |
|
1998 return KErrNone; |
|
1999 } |
|
2000 |
|
2001 TInt CSenUtilsBCTest::SenTransportProperties_SetPropertyLL(TTestResult& aResult ) |
|
2002 { |
|
2003 SetupL(); |
|
2004 _LIT8(KElementText,"<Properties><Property>value</Property></Properties>"); |
|
2005 CSenTransportProperties* pElement= CSenTransportProperties::NewL(); |
|
2006 CleanupStack::PushL(pElement); |
|
2007 TInt retval=pElement->SetPropertyL(_L8("Property"),_L8("value")); |
|
2008 HBufC8* ElementBuf=pElement->AsUtf8L(); |
|
2009 TL(retval == KErrNone); |
|
2010 TL(*ElementBuf == KElementText); |
|
2011 CleanupStack::PopAndDestroy(pElement); |
|
2012 delete ElementBuf; |
|
2013 Teardown(); |
|
2014 return KErrNone; |
|
2015 } |
|
2016 TInt CSenUtilsBCTest::SenTransportProperties_PropertyLL(TTestResult& aResult ) |
|
2017 { |
|
2018 SetupL(); |
|
2019 _LIT8(KValue,"Value"); |
|
2020 TPtrC8 ValuePtr; |
|
2021 TPtrC8 ValuePtr1; |
|
2022 CSenTransportProperties* pElement= CSenTransportProperties::NewL(); |
|
2023 CleanupStack::PushL(pElement); |
|
2024 pElement->SetPropertyL(_L8("Property"),_L8("value")); |
|
2025 |
|
2026 //true case |
|
2027 TInt retval=pElement->PropertyL(_L8("Property"),ValuePtr); |
|
2028 TL(retval == KErrNone); |
|
2029 |
|
2030 //false case |
|
2031 retval=pElement->PropertyL(_L8("NoProperty"),ValuePtr1); |
|
2032 TL(retval == KErrNotFound); |
|
2033 |
|
2034 CleanupStack::PopAndDestroy(pElement); |
|
2035 Teardown(); |
|
2036 return KErrNone; |
|
2037 |
|
2038 } |
|
2039 TInt CSenUtilsBCTest::SenTransportProperties_SetIntPropertyLL(TTestResult& aResult ) |
|
2040 { |
|
2041 SetupL(); |
|
2042 _LIT8(KElementText,"<Properties><Property>10</Property></Properties>"); |
|
2043 CSenTransportProperties* pElement= CSenTransportProperties::NewL(); |
|
2044 CleanupStack::PushL(pElement); |
|
2045 TInt retval=pElement->SetIntPropertyL(_L8("Property"),10); |
|
2046 HBufC8* ElementBuf=pElement->AsUtf8L(); |
|
2047 TL(retval==KErrNone); |
|
2048 TL(*ElementBuf == KElementText); |
|
2049 CleanupStack::PopAndDestroy(pElement); |
|
2050 delete ElementBuf; |
|
2051 Teardown(); |
|
2052 return KErrNone; |
|
2053 } |
|
2054 TInt CSenUtilsBCTest::SenTransportProperties_IntPropertyLL(TTestResult& aResult ) |
|
2055 { |
|
2056 SetupL(); |
|
2057 TInt PropValue; |
|
2058 TInt PropValue1; |
|
2059 CSenTransportProperties* pElement= CSenTransportProperties::NewL(); |
|
2060 CleanupStack::PushL(pElement); |
|
2061 pElement->SetIntPropertyL(_L8("Property"),10); |
|
2062 //true case |
|
2063 TInt retval=pElement->IntPropertyL(_L8("Property"),PropValue); |
|
2064 TL(retval == KErrNone); |
|
2065 TL(PropValue == 10); |
|
2066 //false case |
|
2067 retval=pElement->IntPropertyL(_L8("NoProperty"),PropValue1); |
|
2068 TL(retval == KErrNotFound); |
|
2069 |
|
2070 CleanupStack::PopAndDestroy(pElement); |
|
2071 Teardown(); |
|
2072 return KErrNone; |
|
2073 } |
|
2074 TInt CSenUtilsBCTest::SenTransportProperties_SetBoolPropertyLL(TTestResult& aResult ) |
|
2075 { |
|
2076 SetupL(); |
|
2077 _LIT8(KElementText,"<Properties><Property>true</Property></Properties>"); |
|
2078 CSenTransportProperties* pElement= CSenTransportProperties::NewL(); |
|
2079 CleanupStack::PushL(pElement); |
|
2080 TInt retval=pElement->SetBoolPropertyL(_L8("Property"),1); |
|
2081 HBufC8* ElementBuf=pElement->AsUtf8L(); |
|
2082 TL(retval == KErrNone); |
|
2083 TL(*ElementBuf == KElementText); |
|
2084 CleanupStack::PopAndDestroy(pElement); |
|
2085 delete ElementBuf; |
|
2086 Teardown(); |
|
2087 return KErrNone; |
|
2088 } |
|
2089 TInt CSenUtilsBCTest::SenTransportProperties_BoolPropertyLL(TTestResult& aResult ) |
|
2090 { |
|
2091 SetupL(); |
|
2092 TBool BoolValue=1; |
|
2093 TBool BoolValue1; |
|
2094 TBool BoolValue2; |
|
2095 CSenTransportProperties* pElement= CSenTransportProperties::NewL(); |
|
2096 CleanupStack::PushL(pElement); |
|
2097 pElement->SetBoolPropertyL(_L8("Property"),BoolValue); |
|
2098 //true case |
|
2099 TInt retval=pElement->BoolPropertyL(_L8("Property"),BoolValue1); |
|
2100 TL(retval == KErrNone); |
|
2101 TL(BoolValue == BoolValue1); |
|
2102 //false case |
|
2103 retval=pElement->BoolPropertyL(_L8("NoProperty"),BoolValue2); |
|
2104 TL(retval == KErrNotFound); |
|
2105 CleanupStack::PopAndDestroy(pElement); |
|
2106 Teardown(); |
|
2107 return KErrNone; |
|
2108 } |
|
2109 TInt CSenUtilsBCTest::SenTransportProperties_SetOmittedLL(TTestResult& aResult ) |
|
2110 { |
|
2111 SetupL(); |
|
2112 _LIT8(KText,"<Properties><Property Omitted=\"true\">value</Property></Properties>"); |
|
2113 CSenTransportProperties* pElement= CSenTransportProperties::NewL(); |
|
2114 CleanupStack::PushL(pElement); |
|
2115 pElement->SetPropertyL(_L8("Property"),_L8("value")); |
|
2116 TInt retval=pElement->SetOmittedL(_L8("Property"),1); |
|
2117 HBufC8* ElementBuf=pElement->AsUtf8L(); |
|
2118 TL(retval == KErrNone); |
|
2119 TL(*ElementBuf == KText); |
|
2120 CleanupStack::PopAndDestroy(pElement); |
|
2121 delete ElementBuf; |
|
2122 Teardown(); |
|
2123 return KErrNone; |
|
2124 } |
|
2125 TInt CSenUtilsBCTest::SenTransportProperties_RemovePropertyLL(TTestResult& aResult ) |
|
2126 { |
|
2127 SetupL(); |
|
2128 _LIT8(KText,"<Properties><Property1>value</Property1><Property2>value</Property2></Properties>"); |
|
2129 CSenTransportProperties* pElement= CSenTransportProperties::NewL(); |
|
2130 CleanupStack::PushL(pElement); |
|
2131 pElement->SetPropertyL(_L8("Property"),_L8("value")); |
|
2132 pElement->SetPropertyL(_L8("Property1"),_L8("value")); |
|
2133 pElement->SetPropertyL(_L8("Property2"),_L8("value")); |
|
2134 //True |
|
2135 TInt retval=pElement->RemovePropertyL(_L8("Property")); |
|
2136 HBufC8* ElementBuf=pElement->AsUtf8L(); |
|
2137 TL(retval == KErrNone); |
|
2138 //False |
|
2139 retval=pElement->RemovePropertyL(_L8("NoProperty")); |
|
2140 TL(retval == KErrNotFound); |
|
2141 TL(*ElementBuf == KText); |
|
2142 CleanupStack::PopAndDestroy(pElement); |
|
2143 delete ElementBuf; |
|
2144 ElementBuf=NULL; |
|
2145 Teardown(); |
|
2146 return KErrNone; |
|
2147 } |
|
2148 /* |
|
2149 TInt CSenUtilsBCTest::SenTransportProperties_CloneLL() |
|
2150 { |
|
2151 _LIT8(KCloneText,"<Properties><Property>value</Property><Property1>value</Property1></Properties>"); |
|
2152 TInt okRnotok; |
|
2153 CSenTransportProperties* pElement= CSenTransportProperties::NewL(); |
|
2154 CleanupStack::PushL(pElement); |
|
2155 pElement->SetPropertyL(_L8("Property"),_L8("value")); |
|
2156 pElement->SetPropertyL(_L8("Property1"),_L8("value")); |
|
2157 MSenProperties* pCloneElement=pElement->Clone(okRnotok); |
|
2158 CleanupStack::PushL(pCloneElement); |
|
2159 HBufC8* CloneElementBuf=pCloneElement->AsUtf8L(); |
|
2160 EUNIT_ASSERT_EQUALS(*CloneElementBuf,KCloneText); |
|
2161 EUNIT_ASSERT_EQUALS(okRnotok,KErrNone); |
|
2162 delete CloneElementBuf; |
|
2163 CleanupStack::PopAndDestroy(pCloneElement); |
|
2164 CleanupStack::PopAndDestroy(pElement); |
|
2165 } |
|
2166 */ |
|
2167 TInt CSenUtilsBCTest::SenTransportProperties_HeartbeatLL(TTestResult& aResult ) |
|
2168 { |
|
2169 SetupL(); |
|
2170 TInt Delta=10; |
|
2171 TInt Delta1; |
|
2172 CSenTransportProperties* pElement= CSenTransportProperties::NewL(); |
|
2173 CleanupStack::PushL(pElement); |
|
2174 pElement->SetHeartbeatL(Delta); |
|
2175 TInt retval=pElement->HeartbeatL(Delta1); |
|
2176 TL(retval == KErrNone); |
|
2177 TL(Delta1 == Delta); |
|
2178 CleanupStack::PopAndDestroy(pElement); |
|
2179 Teardown(); |
|
2180 return KErrNone; |
|
2181 } |
|
2182 |
|
2183 TInt CSenUtilsBCTest::SenTransportProperties_SetHeartbeatLL(TTestResult& aResult ) |
|
2184 { |
|
2185 SetupL(); |
|
2186 _LIT8(KElementText,"<Properties><Heartbeat>10</Heartbeat></Properties>"); |
|
2187 TInt Delta=10; |
|
2188 CSenTransportProperties* pElement= CSenTransportProperties::NewL(); |
|
2189 CleanupStack::PushL(pElement); |
|
2190 TInt retval=pElement->SetHeartbeatL(Delta); |
|
2191 HBufC8* ElementBuf=pElement->AsUtf8L(); |
|
2192 TL(retval == KErrNone); |
|
2193 TL(*ElementBuf == KElementText); |
|
2194 CleanupStack::PopAndDestroy(pElement); |
|
2195 delete ElementBuf; |
|
2196 Teardown(); |
|
2197 return KErrNone; |
|
2198 } |
|
2199 |
|
2200 TInt CSenUtilsBCTest::SenTransportProperties_IapIdLL(TTestResult& aResult ) |
|
2201 { |
|
2202 SetupL(); |
|
2203 TUint32 Delta; |
|
2204 CSenTransportProperties* pElement= CSenTransportProperties::NewL(); |
|
2205 CleanupStack::PushL(pElement); |
|
2206 pElement->SetIapIdL(101); |
|
2207 TInt retval=pElement->IapIdL(Delta); |
|
2208 TL(retval == KErrNone); |
|
2209 TL(Delta == 101); |
|
2210 CleanupStack::PopAndDestroy(pElement); |
|
2211 Teardown(); |
|
2212 return KErrNone; |
|
2213 } |
|
2214 |
|
2215 TInt CSenUtilsBCTest::SenTransportProperties_SetIapIdLL(TTestResult& aResult ) |
|
2216 { |
|
2217 SetupL(); |
|
2218 _LIT8(KElementText,"<Properties><IapId>101</IapId></Properties>"); |
|
2219 CSenTransportProperties* pElement= CSenTransportProperties::NewL(); |
|
2220 CleanupStack::PushL(pElement); |
|
2221 pElement->SetIapIdL(101); |
|
2222 HBufC8* ElementBuf=pElement->AsUtf8L(); |
|
2223 TL(*ElementBuf == KElementText); |
|
2224 CleanupStack::PopAndDestroy(pElement); |
|
2225 delete ElementBuf; |
|
2226 Teardown(); |
|
2227 return KErrNone; |
|
2228 } |
|
2229 |
|
2230 TInt CSenUtilsBCTest::SenTransportProperties_ProxyPortLL(TTestResult& aResult ) |
|
2231 { |
|
2232 SetupL(); |
|
2233 TInt PortNum; |
|
2234 CSenTransportProperties* pElement= CSenTransportProperties::NewL(); |
|
2235 CleanupStack::PushL(pElement); |
|
2236 pElement->SetProxyPortL(8080); |
|
2237 TInt retval=pElement->ProxyPortL(PortNum); |
|
2238 TL(retval == KErrNone); |
|
2239 TL(PortNum == 8080); |
|
2240 CleanupStack::PopAndDestroy(pElement); |
|
2241 Teardown(); |
|
2242 return KErrNone; |
|
2243 } |
|
2244 |
|
2245 TInt CSenUtilsBCTest::SenTransportProperties_SetProxyPortLL(TTestResult& aResult ) |
|
2246 { |
|
2247 SetupL(); |
|
2248 _LIT8(KElementText,"<Properties><ProxyPort>8080</ProxyPort></Properties>"); |
|
2249 CSenTransportProperties* pElement= CSenTransportProperties::NewL(); |
|
2250 CleanupStack::PushL(pElement); |
|
2251 pElement->SetProxyPortL(8080); |
|
2252 HBufC8* ElementBuf=pElement->AsUtf8L(); |
|
2253 TL(*ElementBuf == KElementText); |
|
2254 CleanupStack::PopAndDestroy(pElement); |
|
2255 delete ElementBuf; |
|
2256 Teardown(); |
|
2257 return KErrNone; |
|
2258 } |
|
2259 |
|
2260 TInt CSenUtilsBCTest::SenTransportProperties_ProxyHostLL(TTestResult& aResult ) |
|
2261 { |
|
2262 SetupL(); |
|
2263 TPtrC8 host; |
|
2264 CSenTransportProperties* pElement= CSenTransportProperties::NewL(); |
|
2265 CleanupStack::PushL(pElement); |
|
2266 pElement->SetProxyHostL(_L8("tcp.mws.mobile.msn-ppe.com")); |
|
2267 TInt retval=pElement->ProxyHostL(host); |
|
2268 TL(retval == KErrNone); |
|
2269 TL(host == _L8("tcp.mws.mobile.msn-ppe.com")); |
|
2270 CleanupStack::PopAndDestroy(pElement); |
|
2271 Teardown(); |
|
2272 return KErrNone; |
|
2273 } |
|
2274 |
|
2275 TInt CSenUtilsBCTest::SenTransportProperties_SetProxyHostLL(TTestResult& aResult ) |
|
2276 { |
|
2277 SetupL(); |
|
2278 _LIT8(KElementText,"<Properties><ProxyHost>tcp.mws.mobile.msn-ppe.com</ProxyHost></Properties>"); |
|
2279 CSenTransportProperties* pElement= CSenTransportProperties::NewL(); |
|
2280 CleanupStack::PushL(pElement); |
|
2281 pElement->SetProxyHostL(_L8("tcp.mws.mobile.msn-ppe.com")); |
|
2282 HBufC8* ElementBuf=pElement->AsUtf8L(); |
|
2283 TL(*ElementBuf == KElementText); |
|
2284 CleanupStack::PopAndDestroy(pElement); |
|
2285 delete ElementBuf; |
|
2286 Teardown(); |
|
2287 return KErrNone; |
|
2288 } |
|
2289 |
|
2290 TInt CSenUtilsBCTest::SenTransportProperties_ProxyUsageLL(TTestResult& aResult ) |
|
2291 { |
|
2292 SetupL(); |
|
2293 TBool Usage; |
|
2294 CSenTransportProperties* pElement= CSenTransportProperties::NewL(); |
|
2295 CleanupStack::PushL(pElement); |
|
2296 pElement->SetProxyUsageL(TRUE); |
|
2297 TInt retval=pElement->ProxyUsageL(Usage); |
|
2298 TL(retval == KErrNone); |
|
2299 TL(Usage == TRUE); |
|
2300 CleanupStack::PopAndDestroy(pElement); |
|
2301 Teardown(); |
|
2302 return KErrNone; |
|
2303 } |
|
2304 |
|
2305 TInt CSenUtilsBCTest::SenTransportProperties_SetProxyUsageLL(TTestResult& aResult ) |
|
2306 { |
|
2307 SetupL(); |
|
2308 _LIT8(KElementText,"<Properties><ProxyUsage>true</ProxyUsage></Properties>"); |
|
2309 CSenTransportProperties* pElement= CSenTransportProperties::NewL(); |
|
2310 CleanupStack::PushL(pElement); |
|
2311 pElement->SetProxyUsageL(TRUE); |
|
2312 HBufC8* ElementBuf=pElement->AsUtf8L(); |
|
2313 TL(*ElementBuf == KElementText); |
|
2314 CleanupStack::PopAndDestroy(pElement); |
|
2315 delete ElementBuf; |
|
2316 Teardown(); |
|
2317 return KErrNone; |
|
2318 } |
|
2319 |
|
2320 TInt CSenUtilsBCTest::SenTransportProperties_SecureDialogLL(TTestResult& aResult ) |
|
2321 { |
|
2322 SetupL(); |
|
2323 TBool Security; |
|
2324 CSenTransportProperties* pElement= CSenTransportProperties::NewL(); |
|
2325 CleanupStack::PushL(pElement); |
|
2326 pElement->SetSecureDialogL(TRUE); |
|
2327 TInt retval=pElement->SecureDialogL(Security); |
|
2328 TL(retval == KErrNone); |
|
2329 TL(Security == TRUE); |
|
2330 CleanupStack::PopAndDestroy(pElement); |
|
2331 Teardown(); |
|
2332 return KErrNone; |
|
2333 } |
|
2334 |
|
2335 TInt CSenUtilsBCTest::SenTransportProperties_SetSecureDialogLL(TTestResult& aResult ) |
|
2336 { |
|
2337 SetupL(); |
|
2338 _LIT8(KElementText,"<Properties><SecureDialog>true</SecureDialog></Properties>"); |
|
2339 CSenTransportProperties* pElement= CSenTransportProperties::NewL(); |
|
2340 CleanupStack::PushL(pElement); |
|
2341 pElement->SetSecureDialogL(TRUE); |
|
2342 HBufC8* ElementBuf=pElement->AsUtf8L(); |
|
2343 TL(*ElementBuf == KElementText); |
|
2344 CleanupStack::PopAndDestroy(pElement); |
|
2345 delete ElementBuf; |
|
2346 Teardown(); |
|
2347 return KErrNone; |
|
2348 } |
|
2349 |
|
2350 TInt CSenUtilsBCTest::SenTransportProperties_UserAgentLL(TTestResult& aResult ) |
|
2351 { |
|
2352 SetupL(); |
|
2353 TPtrC8 UserAgent; |
|
2354 CSenTransportProperties* pElement= CSenTransportProperties::NewL(); |
|
2355 CleanupStack::PushL(pElement); |
|
2356 pElement->SetUserAgentL(_L8("TestAgent")); |
|
2357 TInt retval=pElement->UserAgentL(UserAgent); |
|
2358 TL(retval == KErrNone); |
|
2359 TL(UserAgent ==_L8("TestAgent")); |
|
2360 CleanupStack::PopAndDestroy(pElement); |
|
2361 Teardown(); |
|
2362 return KErrNone; |
|
2363 } |
|
2364 |
|
2365 TInt CSenUtilsBCTest::SenTransportProperties_SetUserAgentLL(TTestResult& aResult ) |
|
2366 { |
|
2367 SetupL(); |
|
2368 _LIT8(KElementText,"<Properties><User-Agent>TestAgent</User-Agent></Properties>"); |
|
2369 CSenTransportProperties* pElement= CSenTransportProperties::NewL(); |
|
2370 CleanupStack::PushL(pElement); |
|
2371 pElement->SetUserAgentL(_L8("TestAgent")); |
|
2372 HBufC8* ElementBuf=pElement->AsUtf8L(); |
|
2373 TL(*ElementBuf == KElementText); |
|
2374 CleanupStack::PopAndDestroy(pElement); |
|
2375 delete ElementBuf; |
|
2376 Teardown(); |
|
2377 return KErrNone; |
|
2378 } |
|
2379 |
|
2380 TInt CSenUtilsBCTest::SenTransportProperties_DeviceIDLL(TTestResult& aResult ) |
|
2381 { |
|
2382 SetupL(); |
|
2383 TPtrC8 DeviceID; |
|
2384 CSenTransportProperties* pElement= CSenTransportProperties::NewL(); |
|
2385 CleanupStack::PushL(pElement); |
|
2386 pElement->SetDeviceIDL(_L8("TestDevice")); |
|
2387 TInt retval=pElement->DeviceIDL(DeviceID); |
|
2388 TL(retval == KErrNone); |
|
2389 TL(DeviceID == _L8("TestDevice")); |
|
2390 CleanupStack::PopAndDestroy(pElement); |
|
2391 Teardown(); |
|
2392 return KErrNone; |
|
2393 } |
|
2394 |
|
2395 TInt CSenUtilsBCTest::SenTransportProperties_SetDeviceIDLL(TTestResult& aResult ) |
|
2396 { |
|
2397 SetupL(); |
|
2398 _LIT8(KElementText,"<Properties><DeviceID>TestDevice</DeviceID></Properties>"); |
|
2399 CSenTransportProperties* pElement= CSenTransportProperties::NewL(); |
|
2400 CleanupStack::PushL(pElement); |
|
2401 pElement->SetDeviceIDL(_L8("TestDevice")); |
|
2402 HBufC8* ElementBuf=pElement->AsUtf8L(); |
|
2403 TL(*ElementBuf == KElementText); |
|
2404 CleanupStack::PopAndDestroy(pElement); |
|
2405 delete ElementBuf; |
|
2406 Teardown(); |
|
2407 return KErrNone; |
|
2408 } |
|
2409 |
|
2410 TInt CSenUtilsBCTest::SenTransportProperties_SoapActionLL(TTestResult& aResult ) |
|
2411 { |
|
2412 SetupL(); |
|
2413 TPtrC8 SoapURI; |
|
2414 CSenTransportProperties* pElement= CSenTransportProperties::NewL(); |
|
2415 CleanupStack::PushL(pElement); |
|
2416 pElement->SetSoapActionL(_L8("URI-referenceRFC2396")); |
|
2417 TInt retval=pElement->SoapActionL(SoapURI); |
|
2418 TL(retval == KErrNone); |
|
2419 TL(SoapURI == _L8("URI-referenceRFC2396")); |
|
2420 CleanupStack::PopAndDestroy(pElement); |
|
2421 Teardown(); |
|
2422 return KErrNone; |
|
2423 } |
|
2424 |
|
2425 TInt CSenUtilsBCTest::SenTransportProperties_SetSoapActionLL(TTestResult& aResult ) |
|
2426 { |
|
2427 SetupL(); |
|
2428 _LIT8(KElementText,"<Properties><SOAPAction>URI-referenceRFC2396</SOAPAction></Properties>"); |
|
2429 CSenTransportProperties* pElement= CSenTransportProperties::NewL(); |
|
2430 CleanupStack::PushL(pElement); |
|
2431 pElement->SetSoapActionL(_L8("URI-referenceRFC2396")); |
|
2432 HBufC8* ElementBuf=pElement->AsUtf8L(); |
|
2433 TL(*ElementBuf == KElementText); |
|
2434 CleanupStack::PopAndDestroy(pElement); |
|
2435 delete ElementBuf; |
|
2436 Teardown(); |
|
2437 return KErrNone; |
|
2438 } |
|
2439 |
|
2440 TInt CSenUtilsBCTest::SenTransportProperties_DownloadFolderLL(TTestResult& aResult ) |
|
2441 { |
|
2442 SetupL(); |
|
2443 TPtrC8 Download; |
|
2444 CSenTransportProperties* pElement= CSenTransportProperties::NewL(); |
|
2445 CleanupStack::PushL(pElement); |
|
2446 pElement->SetDownloadFolderL(_L8("Download")); |
|
2447 TInt retval=pElement->DownloadFolderL(Download); |
|
2448 TL(retval == KErrNone); |
|
2449 TL(Download ==_L8("Download")); |
|
2450 CleanupStack::PopAndDestroy(pElement); |
|
2451 Teardown(); |
|
2452 return KErrNone; |
|
2453 } |
|
2454 |
|
2455 TInt CSenUtilsBCTest::SenTransportProperties_SetDownloadFolderLL(TTestResult& aResult ) |
|
2456 { |
|
2457 SetupL(); |
|
2458 _LIT8(KElementText,"<Properties><DownloadFolder>Download</DownloadFolder></Properties>"); |
|
2459 CSenTransportProperties* pElement= CSenTransportProperties::NewL(); |
|
2460 CleanupStack::PushL(pElement); |
|
2461 pElement->SetDownloadFolderL(_L8("Download")); |
|
2462 HBufC8* ElementBuf=pElement->AsUtf8L(); |
|
2463 TL(*ElementBuf==KElementText); |
|
2464 CleanupStack::PopAndDestroy(pElement); |
|
2465 delete ElementBuf; |
|
2466 Teardown(); |
|
2467 return KErrNone; |
|
2468 } |
|
2469 |
|
2470 |
|
2471 TInt CSenUtilsBCTest::SenTransportProperties_SetFileAttachmentLL(TTestResult& aResult ) |
|
2472 { |
|
2473 SetupL(); |
|
2474 _LIT8(KElementText,"<Properties><FileAttachments><Attachments><Attachment0 cid="test:cid">c:\\test.file.txt</Attachment0></Attachments></FileAttachments></Properties>"); |
|
2475 CSenTransportProperties* pElement= CSenTransportProperties::NewL(); |
|
2476 CleanupStack::PushL(pElement); |
|
2477 pElement->SetFileAttachmentL(_L8("test:cid"),_L8("c:\\test.file.txt")); |
|
2478 HBufC8* ElementBuf=pElement->AsUtf8L(); |
|
2479 TL(*ElementBuf==KElementText); |
|
2480 CleanupStack::PopAndDestroy(pElement); |
|
2481 delete ElementBuf; |
|
2482 Teardown(); |
|
2483 return KErrNone; |
|
2484 } |
|
2485 |
|
2486 |
|
2487 |
|
2488 TInt CSenUtilsBCTest::SenTransportProperties_MwsNamespaceLL(TTestResult& aResult ) |
|
2489 { |
|
2490 SetupL(); |
|
2491 |
|
2492 TPtrC8 NameSpace; |
|
2493 CSenTransportProperties* pElement= CSenTransportProperties::NewL(); |
|
2494 CleanupStack::PushL(pElement); |
|
2495 pElement->SetMwsNamespaceL(_L8("Mwsnsuri")); |
|
2496 TInt retval=pElement->MwsNamespaceL(NameSpace); |
|
2497 TL(retval == KErrNone); |
|
2498 TL(NameSpace == _L8("Mwsnsuri")); |
|
2499 CleanupStack::PopAndDestroy(pElement); |
|
2500 Teardown(); |
|
2501 return KErrNone; |
|
2502 |
|
2503 } |
|
2504 |
|
2505 TInt CSenUtilsBCTest::SenTransportProperties_SetMwsNamespaceLL(TTestResult& aResult ) |
|
2506 { |
|
2507 SetupL(); |
|
2508 |
|
2509 |
|
2510 _LIT8(KElementText,"<Properties><MwsNamespace>Mwsnsuri</MwsNamespace></Properties>"); |
|
2511 CSenTransportProperties* pElement= CSenTransportProperties::NewL(); |
|
2512 CleanupStack::PushL(pElement); |
|
2513 pElement->SetMwsNamespaceL(_L8("Mwsnsuri")); |
|
2514 HBufC8* ElementBuf=pElement->AsUtf8L(); |
|
2515 TL(*ElementBuf == KElementText); |
|
2516 CleanupStack::PopAndDestroy(pElement); |
|
2517 delete ElementBuf; |
|
2518 Teardown(); |
|
2519 return KErrNone; |
|
2520 |
|
2521 |
|
2522 } |
|
2523 |
|
2524 |
|
2525 TInt CSenUtilsBCTest::SenTransportProperties_MessageIdLL(TTestResult& aResult ) |
|
2526 { |
|
2527 SetupL(); |
|
2528 |
|
2529 TPtrC8 MsgId; |
|
2530 CSenTransportProperties* pElement= CSenTransportProperties::NewL(); |
|
2531 CleanupStack::PushL(pElement); |
|
2532 pElement->SetMessageIdL(_L8("test-message")); |
|
2533 TInt retval=pElement->MessageIdL(MsgId); |
|
2534 TL(retval == KErrNone); |
|
2535 TL(MsgId == _L8("test-message")); |
|
2536 CleanupStack::PopAndDestroy(pElement); |
|
2537 Teardown(); |
|
2538 return KErrNone; |
|
2539 |
|
2540 } |
|
2541 |
|
2542 TInt CSenUtilsBCTest::SenTransportProperties_SetMessageIdLL(TTestResult& aResult ) |
|
2543 { |
|
2544 SetupL(); |
|
2545 |
|
2546 _LIT8(KElementText,"<Properties><MessageID>test-message</MessageID></Properties>"); |
|
2547 CSenTransportProperties* pElement= CSenTransportProperties::NewL(); |
|
2548 CleanupStack::PushL(pElement); |
|
2549 pElement->SetMessageIdL(_L8("test-message")); |
|
2550 HBufC8* ElementBuf=pElement->AsUtf8L(); |
|
2551 TL(*ElementBuf == KElementText); |
|
2552 CleanupStack::PopAndDestroy(pElement); |
|
2553 delete ElementBuf; |
|
2554 Teardown(); |
|
2555 return KErrNone; |
|
2556 |
|
2557 } |
|
2558 |
|
2559 TInt CSenUtilsBCTest::SenTransportProperties_OnewayMessageOnOffLL(TTestResult& aResult ) |
|
2560 { |
|
2561 SetupL(); |
|
2562 |
|
2563 TBool OnRoff; |
|
2564 CSenTransportProperties* pElement= CSenTransportProperties::NewL(); |
|
2565 CleanupStack::PushL(pElement); |
|
2566 pElement->SetOnewayMessageOnOffL(TRUE); |
|
2567 TInt retval=pElement->OnewayMessageOnOffL(OnRoff); |
|
2568 TL(retval == KErrNone); |
|
2569 TL(OnRoff == TRUE); |
|
2570 CleanupStack::PopAndDestroy(pElement); |
|
2571 Teardown(); |
|
2572 return KErrNone; |
|
2573 |
|
2574 } |
|
2575 |
|
2576 TInt CSenUtilsBCTest::SenTransportProperties_SetOnewayMessageOnOffLL( TTestResult& aResult) |
|
2577 { |
|
2578 |
|
2579 SetupL(); |
|
2580 |
|
2581 _LIT8(KElementText,"<Properties><OneWayMessage>true</OneWayMessage></Properties>"); |
|
2582 CSenTransportProperties* pElement= CSenTransportProperties::NewL(); |
|
2583 CleanupStack::PushL(pElement); |
|
2584 pElement->SetOnewayMessageOnOffL(TRUE); |
|
2585 HBufC8* ElementBuf=pElement->AsUtf8L(); |
|
2586 TL(*ElementBuf == KElementText); |
|
2587 CleanupStack::PopAndDestroy(pElement); |
|
2588 delete ElementBuf; |
|
2589 Teardown(); |
|
2590 return KErrNone; |
|
2591 |
|
2592 } |
|
2593 |
|
2594 TInt CSenUtilsBCTest::SenTransportProperties_SetMaxTimeToLiveLL(TTestResult& aResult ) |
|
2595 { |
|
2596 SetupL(); |
|
2597 |
|
2598 TInt PropValue; |
|
2599 CSenTransportProperties* pElement= CSenTransportProperties::NewL(); |
|
2600 CleanupStack::PushL(pElement); |
|
2601 pElement->SetMaxTimeToLiveL(10); |
|
2602 //true case |
|
2603 TInt retval=pElement->MaxTimeToLiveL(PropValue); |
|
2604 TL(retval == KErrNone); |
|
2605 TL(PropValue == 10); |
|
2606 |
|
2607 CleanupStack::PopAndDestroy(pElement); |
|
2608 Teardown(); |
|
2609 return KErrNone; |
|
2610 |
|
2611 } |
|
2612 |
|
2613 TInt CSenUtilsBCTest::SenTransportProperties_MaxTimeToLiveLL(TTestResult& aResult ) |
|
2614 { |
|
2615 TTestResult Result; |
|
2616 SenTransportProperties_SetMaxTimeToLiveLL( Result); |
|
2617 } |
|
2618 |
|
2619 TInt CSenUtilsBCTest::SenTransportProperties_SetMinTimeToLiveLL(TTestResult& aResult ) |
|
2620 { |
|
2621 SetupL(); |
|
2622 |
|
2623 TInt PropValue; |
|
2624 CSenTransportProperties* pElement= CSenTransportProperties::NewL(); |
|
2625 CleanupStack::PushL(pElement); |
|
2626 pElement->SetMinTimeToLiveL(10); |
|
2627 //true case |
|
2628 TInt retval=pElement->MinTimeToLiveL(PropValue); |
|
2629 TL(retval == KErrNone); |
|
2630 TL(PropValue == 10); |
|
2631 |
|
2632 CleanupStack::PopAndDestroy(pElement); |
|
2633 Teardown(); |
|
2634 return KErrNone; |
|
2635 |
|
2636 } |
|
2637 |
|
2638 TInt CSenUtilsBCTest::SenTransportProperties_SetReaderL(TTestResult& aResult ) |
|
2639 { |
|
2640 SetupL(); |
|
2641 |
|
2642 CSenTransportProperties* pElement= CSenTransportProperties::NewL(); |
|
2643 CleanupStack::PushL(pElement); |
|
2644 pElement->SetReader(*iXmlReader); |
|
2645 |
|
2646 CleanupStack::PopAndDestroy(pElement); |
|
2647 Teardown(); |
|
2648 return KErrNone; |
|
2649 |
|
2650 } |
|
2651 |
|
2652 |
|
2653 TInt CSenUtilsBCTest::SenTransportProperties_PropertiesClassTypeL(TTestResult& aResult ) |
|
2654 { |
|
2655 SetupL(); |
|
2656 MSenProperties::TSenPropertiesClassType var = MSenProperties::ESenTransportProperties; |
|
2657 CSenTransportProperties* pElement= CSenTransportProperties::NewL(); |
|
2658 CleanupStack::PushL(pElement); |
|
2659 TL(var == pElement->PropertiesClassType()); |
|
2660 |
|
2661 CleanupStack::PopAndDestroy(pElement); |
|
2662 Teardown(); |
|
2663 return KErrNone; |
|
2664 |
|
2665 } |
|
2666 |
|
2667 TInt CSenUtilsBCTest::SenTransportProperties_WriteToLL(TTestResult& aResult ) |
|
2668 { |
|
2669 SetupL(); |
|
2670 |
|
2671 TBuf8<50> StreamBuf; |
|
2672 CSenBaseElement* pElement=CSenBaseElement::NewL(_L8("Nokia")); |
|
2673 CleanupStack::PushL(pElement); |
|
2674 pElement->AddElementL(_L8("webservices")); |
|
2675 RWriteStream& ElemntStream=pElement->ContentWriteStreamL(); |
|
2676 |
|
2677 CSenTransportProperties* pElement1= CSenTransportProperties::NewL(); |
|
2678 CleanupStack::PushL(pElement1); |
|
2679 pElement1->WriteToL(ElemntStream); |
|
2680 |
|
2681 CleanupStack::PopAndDestroy(pElement1); |
|
2682 CleanupStack::PopAndDestroy(pElement); |
|
2683 |
|
2684 Teardown(); |
|
2685 return KErrNone; |
|
2686 |
|
2687 } |
|
2688 |
|
2689 TInt CSenUtilsBCTest::SenTransportProperties_ReadFromLL(TTestResult& aResult ) |
|
2690 { |
|
2691 SetupL(); |
|
2692 CSenTransportProperties* pElement= CSenTransportProperties::NewL(); |
|
2693 CleanupStack::PushL(pElement); |
|
2694 pElement->ReadFromL(_L8("")); |
|
2695 |
|
2696 CleanupStack::PopAndDestroy(pElement); |
|
2697 Teardown(); |
|
2698 return KErrNone; |
|
2699 |
|
2700 } |
|
2701 |
|
2702 TInt CSenUtilsBCTest::SenTransportProperties_CloneL(TTestResult& aResult ) |
|
2703 { |
|
2704 SetupL(); |
|
2705 TBool Flag; |
|
2706 TInt var; |
|
2707 CSenTransportProperties* pElement= CSenTransportProperties::NewL(); |
|
2708 CleanupStack::PushL(pElement); |
|
2709 CSenTransportProperties* pClone = NULL; |
|
2710 pClone = (CSenTransportProperties*)pElement->Clone(var); |
|
2711 if(pClone != NULL) |
|
2712 Flag = 1; |
|
2713 if(!(Flag)) return KErrArgument; |
|
2714 |
|
2715 delete pClone; |
|
2716 CleanupStack::PopAndDestroy(pElement); |
|
2717 |
|
2718 Teardown(); |
|
2719 return KErrNone; |
|
2720 |
|
2721 } |
|
2722 |
|
2723 TInt CSenUtilsBCTest::SenTransportProperties_IsSafeToCastL(TTestResult& aResult ) |
|
2724 { |
|
2725 SetupL(); |
|
2726 TBool Flag, retVal; |
|
2727 MSenProperties::TSenPropertiesClassType pVar = MSenProperties::ESenTransportProperties; |
|
2728 |
|
2729 CSenTransportProperties* pElement= CSenTransportProperties::NewL(); |
|
2730 CleanupStack::PushL(pElement); |
|
2731 |
|
2732 retVal = pElement->IsSafeToCast(pVar); |
|
2733 if(retVal != EFalse) |
|
2734 Flag = 1; |
|
2735 else |
|
2736 Flag = 0; |
|
2737 |
|
2738 MSenProperties::TSenPropertiesClassType xVar = MSenProperties::ESenXmlProperties; |
|
2739 retVal = pElement->IsSafeToCast(xVar); |
|
2740 if(retVal != EFalse) |
|
2741 Flag = 1; |
|
2742 else |
|
2743 return KErrArgument; |
|
2744 |
|
2745 CleanupStack::PopAndDestroy(pElement); |
|
2746 |
|
2747 Teardown(); |
|
2748 return KErrNone; |
|
2749 |
|
2750 } |
|
2751 |
|
2752 |
|
2753 TInt CSenUtilsBCTest::SenTransportProperties_CloneLL(TTestResult& aResult ) |
|
2754 { |
|
2755 SetupL(); |
|
2756 TBool Flag; |
|
2757 CSenTransportProperties* pElement= CSenTransportProperties::NewL(); |
|
2758 CleanupStack::PushL(pElement); |
|
2759 CSenTransportProperties* pClone = NULL; |
|
2760 pClone = (CSenTransportProperties*)pElement->CloneL(); |
|
2761 if(pClone != NULL) |
|
2762 Flag = 1; |
|
2763 if(!(Flag)) return KErrArgument; |
|
2764 |
|
2765 delete pClone; |
|
2766 CleanupStack::PopAndDestroy(pElement); |
|
2767 |
|
2768 Teardown(); |
|
2769 return KErrNone; |
|
2770 |
|
2771 } |
|
2772 |
|
2773 TInt CSenUtilsBCTest::SenTransportProperties_ApplyBindingLL(TTestResult& aResult ) |
|
2774 { |
|
2775 SetupL(); |
|
2776 TSOAPVersion var = ESOAP11; |
|
2777 CSenTransportProperties* pElement= CSenTransportProperties::NewL(); |
|
2778 CleanupStack::PushL(pElement); |
|
2779 pElement->ApplyBindingL(var); |
|
2780 CleanupStack::PopAndDestroy(pElement); |
|
2781 |
|
2782 Teardown(); |
|
2783 return KErrNone; |
|
2784 |
|
2785 } |
|
2786 |
|
2787 |
|
2788 TInt CSenUtilsBCTest::SenTransportProperties_MinTimeToLiveLL(TTestResult& aResult ) |
|
2789 { |
|
2790 TTestResult Result; |
|
2791 SenTransportProperties_SetMinTimeToLiveLL(Result); |
|
2792 } |
|
2793 |
|
2794 TInt CSenUtilsBCTest::SenHttpTransportProperties_NewLL(TTestResult& aResult) |
|
2795 { |
|
2796 SetupL(); |
|
2797 |
|
2798 TBool Flag; |
|
2799 CSenHttpTransportProperties *pProperties = CSenHttpTransportProperties::NewL(); |
|
2800 CleanupStack::PushL(pProperties ); |
|
2801 if(pProperties) |
|
2802 Flag=1; |
|
2803 else |
|
2804 Flag=0; |
|
2805 if(! Flag) return KErrArgument; |
|
2806 CleanupStack::PopAndDestroy(pProperties ); |
|
2807 Teardown(); |
|
2808 return KErrNone; |
|
2809 |
|
2810 } |
|
2811 |
|
2812 TInt CSenUtilsBCTest::SenHttpTransportProperties_NewLCL(TTestResult& aResult) |
|
2813 { |
|
2814 SetupL(); |
|
2815 |
|
2816 TBool Flag; |
|
2817 CSenHttpTransportProperties *pProperties = CSenHttpTransportProperties::NewLC(); |
|
2818 if(pProperties) |
|
2819 Flag=1; |
|
2820 else |
|
2821 Flag=0; |
|
2822 if(! Flag) return KErrArgument; |
|
2823 CleanupStack::PopAndDestroy(pProperties ); |
|
2824 Teardown(); |
|
2825 return KErrNone; |
|
2826 |
|
2827 } |
|
2828 |
|
2829 TInt CSenUtilsBCTest::SenHttpTransportProperties_NewL_1L(TTestResult& aResult) |
|
2830 { |
|
2831 SetupL(); |
|
2832 |
|
2833 TBool Flag; |
|
2834 _LIT8(KString,"<parent><element1/><element2/><element3/>parent content</parent>"); |
|
2835 CSenXmlReader* pParser = CSenXmlReader::NewL(); |
|
2836 CleanupStack::PushL(pParser); |
|
2837 CSenHttpTransportProperties *pProperties=CSenHttpTransportProperties::NewL(KString,*pParser); |
|
2838 CleanupStack::PushL(pProperties); |
|
2839 if(pProperties) |
|
2840 Flag=1; |
|
2841 else |
|
2842 Flag=0; |
|
2843 if(!( Flag )) return KErrArgument; |
|
2844 CleanupStack::PopAndDestroy(pProperties); |
|
2845 CleanupStack::PopAndDestroy(pParser); |
|
2846 Teardown(); |
|
2847 return KErrNone; |
|
2848 |
|
2849 } |
|
2850 |
|
2851 TInt CSenUtilsBCTest::SenHttpTransportProperties_NewLC_1L(TTestResult& aResult) |
|
2852 { |
|
2853 SetupL(); |
|
2854 |
|
2855 TBool Flag; |
|
2856 _LIT8(KString,"<parent><element1/><element2/><element3/>parent content</parent>"); |
|
2857 CSenXmlReader* pParser = CSenXmlReader::NewL(); |
|
2858 CleanupStack::PushL(pParser); |
|
2859 CSenHttpTransportProperties *pProperties=CSenHttpTransportProperties::NewLC(KString,*pParser); |
|
2860 if(pProperties) |
|
2861 Flag=1; |
|
2862 else |
|
2863 Flag=0; |
|
2864 if(!( Flag )) return KErrArgument; |
|
2865 CleanupStack::PopAndDestroy(pProperties); |
|
2866 CleanupStack::PopAndDestroy(pParser); |
|
2867 Teardown(); |
|
2868 return KErrNone; |
|
2869 |
|
2870 } |
|
2871 |
|
2872 TInt CSenUtilsBCTest::SenHttpTransportProperties_NewL_2L(TTestResult& aResult) |
|
2873 { |
|
2874 SetupL(); |
|
2875 |
|
2876 |
|
2877 TBool Flag; |
|
2878 CSenBaseElement* pElement= CSenBaseElement::NewL(_L8("Nokia")); |
|
2879 CleanupStack::PushL(pElement); |
|
2880 CSenHttpTransportProperties *pProperties=CSenHttpTransportProperties::NewL(*pElement); |
|
2881 CleanupStack::PushL(pProperties); |
|
2882 if(pProperties) |
|
2883 Flag=1; |
|
2884 else |
|
2885 Flag=0; |
|
2886 if(!( Flag )) return KErrArgument; |
|
2887 CleanupStack::PopAndDestroy(pProperties); |
|
2888 CleanupStack::PopAndDestroy(pElement); |
|
2889 Teardown(); |
|
2890 return KErrNone; |
|
2891 |
|
2892 } |
|
2893 |
|
2894 TInt CSenUtilsBCTest::SenHttpTransportProperties_NewLC_2L(TTestResult& aResult) |
|
2895 { |
|
2896 SetupL(); |
|
2897 |
|
2898 |
|
2899 TBool Flag; |
|
2900 CSenBaseElement* pElement= CSenBaseElement::NewL(_L8("Nokia")); |
|
2901 CleanupStack::PushL(pElement); |
|
2902 CSenHttpTransportProperties *pProperties=CSenHttpTransportProperties::NewLC(*pElement); |
|
2903 if(pProperties) |
|
2904 Flag=1; |
|
2905 else |
|
2906 Flag=0; |
|
2907 if(!( Flag )) return KErrArgument; |
|
2908 CleanupStack::PopAndDestroy(pProperties); |
|
2909 CleanupStack::PopAndDestroy(pElement); |
|
2910 Teardown(); |
|
2911 return KErrNone; |
|
2912 |
|
2913 } |
|
2914 /* |
|
2915 TInt CSenUtilsBCTest::SenVtcpTransportProperties_NewLL(TTestResult& aResult) |
|
2916 { |
|
2917 SetupL(); |
|
2918 |
|
2919 TBool Flag; |
|
2920 CSenVtcpTransportProperties *pProperties = CSenVtcpTransportProperties::NewL(); |
|
2921 CleanupStack::PushL(pProperties ); |
|
2922 if(pProperties) |
|
2923 Flag=1; |
|
2924 else |
|
2925 Flag=0; |
|
2926 if(! Flag) return KErrArgument; |
|
2927 CleanupStack::PopAndDestroy(pProperties ); |
|
2928 Teardown(); |
|
2929 return KErrNone; |
|
2930 |
|
2931 } |
|
2932 |
|
2933 TInt CSenUtilsBCTest::SenVtcpTransportProperties_NewLCL(TTestResult& aResult) |
|
2934 { |
|
2935 SetupL(); |
|
2936 |
|
2937 TBool Flag; |
|
2938 CSenVtcpTransportProperties *pProperties = CSenVtcpTransportProperties::NewLC(); |
|
2939 if(pProperties) |
|
2940 Flag=1; |
|
2941 else |
|
2942 Flag=0; |
|
2943 if(! Flag) return KErrArgument; |
|
2944 CleanupStack::PopAndDestroy(pProperties ); |
|
2945 Teardown(); |
|
2946 return KErrNone; |
|
2947 |
|
2948 } |
|
2949 |
|
2950 |
|
2951 TInt CSenUtilsBCTest::SenVtcpTransportProperties_NewL_1L(TTestResult& aResult) |
|
2952 { |
|
2953 SetupL(); |
|
2954 |
|
2955 TBool Flag; |
|
2956 _LIT8(KString,"<parent><element1/><element2/><element3/>parent content plus some other content</parent>"); |
|
2957 CSenXmlReader* pParser = CSenXmlReader::NewL(); |
|
2958 CleanupStack::PushL(pParser); |
|
2959 CSenVtcpTransportProperties *pProperties=CSenVtcpTransportProperties::NewL(KString,*pParser); |
|
2960 CleanupStack::PushL(pProperties); |
|
2961 if(pProperties) |
|
2962 Flag=1; |
|
2963 else |
|
2964 Flag=0; |
|
2965 if(!( Flag )) return KErrArgument; |
|
2966 CleanupStack::PopAndDestroy(pProperties); |
|
2967 CleanupStack::PopAndDestroy(pParser); |
|
2968 Teardown(); |
|
2969 return KErrNone; |
|
2970 |
|
2971 } |
|
2972 |
|
2973 TInt CSenUtilsBCTest::SenVtcpTransportProperties_NewLC_1L(TTestResult& aResult) |
|
2974 { |
|
2975 SetupL(); |
|
2976 |
|
2977 TBool Flag; |
|
2978 _LIT8(KString,"<parent><element1/><element2/><element3/>parent content plus some other content</parent>"); |
|
2979 CSenXmlReader* pParser = CSenXmlReader::NewL(); |
|
2980 CleanupStack::PushL(pParser); |
|
2981 CSenVtcpTransportProperties *pProperties=CSenVtcpTransportProperties::NewLC(KString,*pParser); |
|
2982 if(pProperties) |
|
2983 Flag=1; |
|
2984 else |
|
2985 Flag=0; |
|
2986 if(!( Flag )) return KErrArgument; |
|
2987 CleanupStack::PopAndDestroy(pProperties); |
|
2988 CleanupStack::PopAndDestroy(pParser); |
|
2989 Teardown(); |
|
2990 return KErrNone; |
|
2991 |
|
2992 } |
|
2993 |
|
2994 TInt CSenUtilsBCTest::SenVtcpTransportProperties_NewL_2L(TTestResult& aResult) |
|
2995 { |
|
2996 SetupL(); |
|
2997 |
|
2998 TBool Flag; |
|
2999 CSenBaseElement* pElement= CSenBaseElement::NewL(_L8("Nokia")); |
|
3000 CleanupStack::PushL(pElement); |
|
3001 CSenVtcpTransportProperties *pProperties=CSenVtcpTransportProperties::NewL(*pElement); |
|
3002 CleanupStack::PushL(pProperties); |
|
3003 if(pProperties) |
|
3004 Flag=1; |
|
3005 else |
|
3006 Flag=0; |
|
3007 if(!( Flag )) return KErrArgument; |
|
3008 CleanupStack::PopAndDestroy(pProperties); |
|
3009 CleanupStack::PopAndDestroy(pElement); |
|
3010 Teardown(); |
|
3011 return KErrNone; |
|
3012 |
|
3013 } |
|
3014 |
|
3015 TInt CSenUtilsBCTest::SenVtcpTransportProperties_NewLC_2L(TTestResult& aResult) |
|
3016 { |
|
3017 SetupL(); |
|
3018 |
|
3019 TBool Flag; |
|
3020 CSenBaseElement* pElement= CSenBaseElement::NewL(_L8("Nokia")); |
|
3021 CleanupStack::PushL(pElement); |
|
3022 CSenVtcpTransportProperties *pProperties=CSenVtcpTransportProperties::NewLC(*pElement); |
|
3023 if(pProperties) |
|
3024 Flag=1; |
|
3025 else |
|
3026 Flag=0; |
|
3027 if(!( Flag )) return KErrArgument; |
|
3028 CleanupStack::PopAndDestroy(pProperties); |
|
3029 CleanupStack::PopAndDestroy(pElement); |
|
3030 Teardown(); |
|
3031 return KErrNone; |
|
3032 |
|
3033 } |
|
3034 |
|
3035 TInt CSenUtilsBCTest::SenVtcpTransportProperties_OnewayMessageOnOffLL(TTestResult& aResult ) |
|
3036 { |
|
3037 SetupL(); |
|
3038 |
|
3039 TBool OnRoff; |
|
3040 CSenVtcpTransportProperties* pElement= CSenVtcpTransportProperties::NewL(); |
|
3041 CleanupStack::PushL(pElement); |
|
3042 pElement->SetOnewayMessageOnOffL(TRUE); |
|
3043 TInt retval=pElement->OnewayMessageOnOffL(OnRoff); |
|
3044 TL(retval == KErrNone); |
|
3045 TL(OnRoff == TRUE); |
|
3046 CleanupStack::PopAndDestroy(pElement); |
|
3047 Teardown(); |
|
3048 return KErrNone; |
|
3049 |
|
3050 } |
|
3051 |
|
3052 TInt CSenUtilsBCTest::SenVtcpTransportProperties_SetOnewayMessageOnOffLL( TTestResult& aResult) |
|
3053 { |
|
3054 |
|
3055 SetupL(); |
|
3056 |
|
3057 _LIT8(KElementText,"<Properties><OneWayMessage>true</OneWayMessage></Properties>"); |
|
3058 CSenVtcpTransportProperties* pElement= CSenVtcpTransportProperties::NewL(); |
|
3059 CleanupStack::PushL(pElement); |
|
3060 pElement->SetOnewayMessageOnOffL(TRUE); |
|
3061 HBufC8* ElementBuf=pElement->AsUtf8L(); |
|
3062 TL(*ElementBuf == KElementText); |
|
3063 CleanupStack::PopAndDestroy(pElement); |
|
3064 delete ElementBuf; |
|
3065 Teardown(); |
|
3066 return KErrNone; |
|
3067 |
|
3068 } |
|
3069 |
|
3070 TInt CSenUtilsBCTest::SenVtcpTransportProperties_SetMaxTimeToLiveLL(TTestResult& aResult ) |
|
3071 { |
|
3072 SetupL(); |
|
3073 |
|
3074 TInt PropValue; |
|
3075 CSenVtcpTransportProperties* pElement= CSenVtcpTransportProperties::NewL(); |
|
3076 CleanupStack::PushL(pElement); |
|
3077 pElement->SetMaxTimeToLiveL(10); |
|
3078 //true case |
|
3079 TInt retval=pElement->MaxTimeToLiveL(PropValue); |
|
3080 TL(retval == KErrNone); |
|
3081 TL(PropValue == 10); |
|
3082 |
|
3083 CleanupStack::PopAndDestroy(pElement); |
|
3084 Teardown(); |
|
3085 return KErrNone; |
|
3086 |
|
3087 } |
|
3088 |
|
3089 TInt CSenUtilsBCTest::SenVtcpTransportProperties_MaxTimeToLiveLL(TTestResult& aResult ) |
|
3090 { |
|
3091 TTestResult Result; |
|
3092 SenVtcpTransportProperties_SetMaxTimeToLiveLL( Result); |
|
3093 } |
|
3094 |
|
3095 TInt CSenUtilsBCTest::SenVtcpTransportProperties_SetMinTimeToLiveLL(TTestResult& aResult ) |
|
3096 { |
|
3097 SetupL(); |
|
3098 |
|
3099 TInt PropValue; |
|
3100 CSenVtcpTransportProperties* pElement= CSenVtcpTransportProperties::NewL(); |
|
3101 CleanupStack::PushL(pElement); |
|
3102 pElement->SetMinTimeToLiveL(10); |
|
3103 //true case |
|
3104 TInt retval=pElement->MinTimeToLiveL(PropValue); |
|
3105 TL(retval == KErrNone); |
|
3106 TL(PropValue == 10); |
|
3107 |
|
3108 CleanupStack::PopAndDestroy(pElement); |
|
3109 Teardown(); |
|
3110 return KErrNone; |
|
3111 |
|
3112 } |
|
3113 |
|
3114 TInt CSenUtilsBCTest::SenVtcpTransportProperties_MinTimeToLiveLL(TTestResult& aResult ) |
|
3115 { |
|
3116 TTestResult Result; |
|
3117 SenVtcpTransportProperties_SetMinTimeToLiveLL(Result); |
|
3118 } |
|
3119 */ |
|
3120 // End of File |