|
1 // Copyright (c) 2004-2009 Nokia Corporation and/or its subsidiary(-ies). |
|
2 // All rights reserved. |
|
3 // This component and the accompanying materials are made available |
|
4 // under the terms of "Eclipse Public License v1.0" |
|
5 // which accompanies this distribution, and is available |
|
6 // at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
7 // |
|
8 // Initial Contributors: |
|
9 // Nokia Corporation - initial contribution. |
|
10 // |
|
11 // Contributors: |
|
12 // |
|
13 // Description: |
|
14 // |
|
15 |
|
16 #include "CSipUriAndAuthorityTest.h" |
|
17 #include "CUriAndAuthorityTest.h" |
|
18 #include <uriutilscommon.h> |
|
19 #include "SipUriAndAuthorityTests.h" |
|
20 |
|
21 #include <e32base.h> |
|
22 #include <f32file.h> |
|
23 |
|
24 CSipUriAndAuthorityTest* CSipUriAndAuthorityTest::NewLC(CIpuTestHarness* aTestHarness) |
|
25 { |
|
26 CSipUriAndAuthorityTest* self = new (ELeave) CSipUriAndAuthorityTest(aTestHarness); |
|
27 CleanupStack::PushL(self); |
|
28 self->ConstructL(); |
|
29 return self; |
|
30 } |
|
31 |
|
32 CSipUriAndAuthorityTest* CSipUriAndAuthorityTest::NewL(CIpuTestHarness* aTestHarness) |
|
33 { |
|
34 CSipUriAndAuthorityTest* self = CSipUriAndAuthorityTest::NewLC(aTestHarness); |
|
35 CleanupStack::Pop(self); |
|
36 return self; |
|
37 } |
|
38 |
|
39 CSipUriAndAuthorityTest::CSipUriAndAuthorityTest(CIpuTestHarness* aTestHarness) |
|
40 : iTestHarness(aTestHarness) |
|
41 { |
|
42 } |
|
43 |
|
44 void CSipUriAndAuthorityTest::ConstructL() |
|
45 { |
|
46 } |
|
47 |
|
48 CSipUriAndAuthorityTest::~CSipUriAndAuthorityTest() |
|
49 { |
|
50 } |
|
51 |
|
52 // |
|
53 // |
|
54 // SIP Uri tests |
|
55 // |
|
56 // |
|
57 void CSipUriAndAuthorityTest::DoTestsL() |
|
58 { |
|
59 //allredy pushed |
|
60 CUriAndAuthorityTest* uriAndAuthorityTest = CUriAndAuthorityTest::NewLC(iTestHarness); |
|
61 |
|
62 // Test Sips TUriParser Component Extraction |
|
63 uriAndAuthorityTest->TestUriComponentExtractionL(KCompsSip0, KSchemeSip0, KUserInfoSip0, KHostSip0, KPortSip0, KPathSip0, KQuerySip0, KFragmentSip0); |
|
64 uriAndAuthorityTest->TestUriComponentExtractionL(KCompsSip1, KSchemeSip1, KUserInfoSip1, KHostSip1, KPortSip1, KPathSip1, KQuerySip1, KFragmentSip1); |
|
65 uriAndAuthorityTest->TestUriComponentExtractionL(KCompsSip2, KSchemeSip2, KUserInfoSip2, KHostSip2, KPortSip2, KPathSip2, KQuerySip2, KFragmentSip2); |
|
66 uriAndAuthorityTest->TestUriComponentExtractionL(KCompsSip3, KSchemeSip3, KUserInfoSip3, KHostSip3, KPortSip3, KPathSip3, KQuerySip3, KFragmentSip3); |
|
67 uriAndAuthorityTest->TestUriComponentExtractionL(KCompsSip4, KSchemeSip4, KUserInfoSip4, KHostSip4, KPortSip4, KPathSip4, KQuerySip4, KFragmentSip4); |
|
68 uriAndAuthorityTest->TestUriComponentExtractionL(KCompsSip5, KSchemeSip5, KUserInfoSip5, KHostSip5, KPortSip5, KPathSip5, KQuerySip5, KFragmentSip5); |
|
69 |
|
70 // Sip URI construction test |
|
71 uriAndAuthorityTest->TestUriSetComponentL(KSipUri_Scheme0, KSipUri_Host0, KSipUri_Userinfo0, KSipUri_Port0, KSipUri_Path0, KSipUri_Query0, KSipUri_Fragment0, |
|
72 KSipUri_SchemeComp0, KSipUri_HostComp0, KSipUri_UserinfoComp0, KSipUri_PortComp0, KSipUri_PathComp0, KSipUri_QueryComp0, KSipUri_FragmentComp0); |
|
73 |
|
74 /** No Fragment part exist in Sip Uri's as per RFC3261 |
|
75 // Sip URI destruction test |
|
76 uriAndAuthorityTest->TestUriRemoveComponentL(KSipUri_NoScheme0, KSipUri_NoHost0, KSipUri_NoUserinfo0, KSipUri_NoPort0, KSipUri_NoPath0, |
|
77 KSipUri_NoQuery0, KSipUri_NoFragment0, KSipUri_Whole0); |
|
78 */ |
|
79 // Same test as above, but with an IPv6 format host |
|
80 // Sip URI construction test |
|
81 uriAndAuthorityTest->TestUriSetComponentL(KSipUri_Scheme0, KSipUri_IPv6Host0, KSipUri_IPv6UserInfo0, KSipUri_IPv6Port0, KSipUri_IPv6Path0, KSipUri_IPv6Query0, KSipUri_IPv6Fragment0, |
|
82 KSipUri_SchemeComp0, KUri_IPv6HostComp, KSipUri_UserinfoComp0, KSipUri_PortComp0, KSipUri_PathComp0, KSipUri_QueryComp0, KSipUri_FragmentComp0); |
|
83 |
|
84 /** No Fragment part exist in Sip Uri's as per RFC3261 |
|
85 // Sip URI destruction test |
|
86 uriAndAuthorityTest->TestUriRemoveComponentL(KSipUri_IPv6NoScheme0, KSipUri_IPv6NoHost0, KSipUri_IPv6NoUserinfo0, KSipUri_IPv6NoPort0, KSipUri_IPv6NoPath0, |
|
87 KSipUri_IPv6NoQuery0, KSipUri_IPv6NoFragment0, KSipUri_IPv6Whole0); |
|
88 */ |
|
89 CleanupStack::PopAndDestroy(uriAndAuthorityTest); |
|
90 |
|
91 //Sip URI validation |
|
92 TInt error=KErrNone; |
|
93 error=OpenSipURIFile(); |
|
94 if (KErrNone!=error) |
|
95 { |
|
96 iTestHarness->StartTestL(_L("Test TUriParser Component ")); |
|
97 SipLogError(error, KCompsSipUriFileSystemError); |
|
98 } |
|
99 else |
|
100 { |
|
101 error=SipUriValidationL(); |
|
102 if (KErrNone!=error) |
|
103 { |
|
104 iTestHarness->StartTestL(_L("Test TUriParser Component Validation ")); |
|
105 switch (error) |
|
106 { |
|
107 case KErrNotFound: |
|
108 { |
|
109 iTestHarness->LogIt(KCompsSipUriNoValidate); |
|
110 } |
|
111 break; |
|
112 case KErrBadName: |
|
113 { |
|
114 iTestHarness->LogIt(KCompsSipUriNoValidateData); |
|
115 } |
|
116 break; |
|
117 default: |
|
118 break; |
|
119 } |
|
120 iTestHarness->EndTest(KErrNone); |
|
121 } |
|
122 |
|
123 if (iFoundEquivalence) |
|
124 { |
|
125 error=SipUriEquivalenceL(); |
|
126 //No Sip URI Equivalence data |
|
127 if (KErrBadName==error) |
|
128 { |
|
129 iTestHarness->StartTestL(_L("Test TUriParser Component Equivalence ")); |
|
130 iTestHarness->LogIt(KCompsSipUriNoEquivalenceData); |
|
131 iTestHarness->EndTest(KErrNone); |
|
132 } |
|
133 } |
|
134 else |
|
135 { |
|
136 iTestHarness->StartTestL(_L("Test TUriParser Component Equivalence ")); |
|
137 iTestHarness->LogIt(KCompsSipUriNoEquivalence); |
|
138 iTestHarness->EndTest(KErrNone); |
|
139 error=KErrNone; |
|
140 } |
|
141 iFsSession.Close(); |
|
142 } |
|
143 } |
|
144 |
|
145 // |
|
146 // |
|
147 // Open SIP Uri data file |
|
148 // |
|
149 // |
|
150 TInt CSipUriAndAuthorityTest::OpenSipURIFile() |
|
151 { |
|
152 RFile file; |
|
153 TInt error=KErrNone; |
|
154 |
|
155 error = iFsSession.Connect(); |
|
156 if (KErrNone!=error) |
|
157 { |
|
158 return error; |
|
159 } |
|
160 |
|
161 error = file.Open(iFsSession, KCompsSipUriFileName, EFileRead); |
|
162 if (KErrNone!=error) |
|
163 { |
|
164 iFsSession.Close(); |
|
165 return error; |
|
166 } |
|
167 |
|
168 iTUriParserFile.Set(file); |
|
169 return error; |
|
170 } |
|
171 |
|
172 // |
|
173 // |
|
174 // SIP Uri Logger |
|
175 // |
|
176 // |
|
177 void CSipUriAndAuthorityTest::SipLogError(TInt aError, const TDesC16& aSipUri) const |
|
178 { |
|
179 TBool wrongError=EFalse; |
|
180 |
|
181 //compare the Equivalent SIP URI to look for the correct error, these SIP URIs must be in T_UriParserSipUri.txt |
|
182 //All equal |
|
183 if (0==aSipUri.Compare(KCompsSipUriEqual0) && KErrNone != aError |
|
184 || 0==aSipUri.Compare(KCompsSipUriEqual1) && KErrNone != aError |
|
185 || 0==aSipUri.Compare(KCompsSipUriEqual2) && KErrNone != aError) |
|
186 { |
|
187 iTestHarness->LogIt(KCompsSipUriValidMess0); |
|
188 wrongError=ETrue; |
|
189 } |
|
190 //All not equal |
|
191 if (0==aSipUri.Compare(KCompsSipUriNotEqual0) && KUriUtilsErrDifferentUserInfo == aError |
|
192 || 0==aSipUri.Compare(KCompsSipUriNotEqual1) && KUriUtilsErrDifferentPath == aError |
|
193 || 0==aSipUri.Compare(KCompsSipUriNotEqual2) && KUriUtilsErrDifferentPort == aError ) |
|
194 { |
|
195 iTestHarness->LogIt(KCompsSipUriEqualMess1); |
|
196 } |
|
197 |
|
198 //compare the SIP URIs to look for the correct error returned by CUri for validation |
|
199 if (0==aSipUri.Compare(KCompsSipUriNotEqual1) && KUriUtilsErrDifferentPath != aError ) |
|
200 { |
|
201 iTestHarness->LogIt(KCompsSipUriInvalidMess9); |
|
202 wrongError=ETrue; |
|
203 } |
|
204 |
|
205 |
|
206 if (0==aSipUri.Compare(KCompsSipUriValid0) && KErrNone!= aError |
|
207 || 0==aSipUri.Compare(KCompsSipUriValid1) && KErrNone!= aError) |
|
208 { |
|
209 iTestHarness->LogIt(KCompsSipUriValidMess0); |
|
210 wrongError=ETrue; |
|
211 } |
|
212 |
|
213 if (0==aSipUri.Compare(KCompsSipUriInvalid0) && KErrNotSupported != aError) |
|
214 { |
|
215 iTestHarness->LogIt(KCompsSipUriInvalidMess0); |
|
216 wrongError=ETrue; |
|
217 } |
|
218 |
|
219 if( 0==aSipUri.Compare(KCompsSipUriInvalid5) && KUriUtilsErrInvalidParam!= aError |
|
220 || 0==aSipUri.Compare(KCompsSipUriInvalid6) && KUriUtilsErrInvalidParam!= aError) |
|
221 { |
|
222 iTestHarness->LogIt(KCompsSipUriInvalidMess1); |
|
223 wrongError=ETrue; |
|
224 } |
|
225 |
|
226 if (0==aSipUri.Compare(KCompsSipUriInvalid3) && KUriUtilsErrInvalidHost!= aError) |
|
227 { |
|
228 iTestHarness->LogIt(KCompsSipUriInvalidMess2); |
|
229 wrongError=ETrue; |
|
230 } |
|
231 |
|
232 if (0==aSipUri.Compare(KCompsSipUriInvalid2) && KUriUtilsErrInvalidHeaders != aError) |
|
233 { |
|
234 iTestHarness->LogIt(KCompsSipUriInvalidMess8); |
|
235 wrongError=ETrue; |
|
236 } |
|
237 |
|
238 if (0==aSipUri.Compare(KCompsSipUriInvalid1) && KUriUtilsErrInvalidPort != aError |
|
239 || 0==aSipUri.Compare(KCompsSipUriInvalid4) && KUriUtilsErrInvalidPort!= aError |
|
240 || 0==aSipUri.Compare(KCompsSipUriNotEqual2) && KUriUtilsErrDifferentPort != aError) |
|
241 { |
|
242 iTestHarness->LogIt(KCompsSipUriInvalidMess3); |
|
243 wrongError=ETrue; |
|
244 } |
|
245 |
|
246 if (0==aSipUri.Compare(KCompsSipUriInvalid7) && KUriUtilsErrInvalidUserInfo!= aError |
|
247 || 0==aSipUri.Compare(KCompsSipUriNotEqual0) && KUriUtilsErrDifferentUserInfo != aError) |
|
248 { |
|
249 iTestHarness->LogIt(KCompsSipUriInvalidMess7); |
|
250 wrongError=ETrue; |
|
251 } |
|
252 |
|
253 if (wrongError) |
|
254 { |
|
255 iTestHarness->LogIt(KCompsSipUriInvalidMess5); |
|
256 } |
|
257 |
|
258 LogErrorMessage(aSipUri, aError); |
|
259 |
|
260 if (wrongError) |
|
261 { |
|
262 iTestHarness->EndTest(aError); |
|
263 } |
|
264 else |
|
265 { |
|
266 iTestHarness->EndTest(KErrNone); |
|
267 } |
|
268 } |
|
269 |
|
270 // |
|
271 // |
|
272 // SIP Uri Validation Test |
|
273 // |
|
274 // |
|
275 TInt CSipUriAndAuthorityTest::SipUriValidationL() |
|
276 { |
|
277 TBuf<256> data; |
|
278 TInt error=KErrNone; |
|
279 iFoundEquivalence=EFalse; |
|
280 |
|
281 //read the Valid section name in |
|
282 error=iTUriParserFile.Read(data); |
|
283 while(0!=data.Compare(KCompsSipUriValidate) && KErrNone==error) |
|
284 { |
|
285 if (0==data.Compare(KCompsSipUriEquivalence)) |
|
286 { |
|
287 iFoundEquivalence=ETrue; |
|
288 break; |
|
289 } |
|
290 data.Zero(); |
|
291 error=iTUriParserFile.Read(data); |
|
292 } |
|
293 |
|
294 //No Validate Section, KErrEof |
|
295 if (0!=data.Compare(KCompsSipUriValidate)) |
|
296 { |
|
297 return KErrNotFound; |
|
298 } |
|
299 |
|
300 //get the validation Data |
|
301 error=iTUriParserFile.Read(data); |
|
302 |
|
303 //no data |
|
304 if (KErrEof==error) |
|
305 { |
|
306 return KErrBadName; |
|
307 } |
|
308 |
|
309 //found Equivalence |
|
310 if (0==data.Compare(KCompsSipUriEquivalence)) |
|
311 { |
|
312 iFoundEquivalence=ETrue; |
|
313 return KErrBadName; |
|
314 } |
|
315 |
|
316 while (KErrNone==error) |
|
317 { |
|
318 //check for comments |
|
319 while(data.Left(2)==(KCompsSipUriComment)) |
|
320 { |
|
321 data.Zero(); |
|
322 iTUriParserFile.Read(data); |
|
323 } |
|
324 if (0==data.Compare(KCompsSipUriEquivalence)) |
|
325 { |
|
326 iFoundEquivalence=ETrue; |
|
327 break; |
|
328 } |
|
329 |
|
330 //validate the 16 bit Sip URI first |
|
331 iTestHarness->StartTestL(_L("Test TUriParser Component Validation (16-bit SIP URI)")); |
|
332 iTestHarness->LogIt(_L("Uri - %S"), &data); |
|
333 error = DoSipUriValidation <TUriParser16>(data); |
|
334 SipLogError(error, data); |
|
335 |
|
336 // Make 8-bit copies and validate this SIP URI |
|
337 HBufC8* uriBuf = HBufC8::NewLC(data.Length()); |
|
338 TPtr8 uri8Bit = uriBuf->Des(); |
|
339 uri8Bit.Copy(data); |
|
340 |
|
341 iTestHarness->StartTestL(_L("Test TUriParser Component Validation (8-bit SIP URI)")); |
|
342 iTestHarness->LogIt(_L("Uri - %S"), &data); |
|
343 error = DoSipUriValidation <TUriParser8>(uri8Bit); |
|
344 SipLogError(error, data); |
|
345 |
|
346 data.Zero(); |
|
347 CleanupStack::PopAndDestroy(1, uriBuf);// uriBuf |
|
348 |
|
349 error=iTUriParserFile.Read(data); |
|
350 } |
|
351 return KErrNone; |
|
352 } |
|
353 |
|
354 // |
|
355 // |
|
356 // SIP Uri Equivalence Test |
|
357 // |
|
358 // |
|
359 TInt CSipUriAndAuthorityTest::SipUriEquivalenceL() |
|
360 { |
|
361 TBuf<256> valueA; |
|
362 TBuf<256> valueB; |
|
363 TBool sipUriError=EFalse; |
|
364 TInt errorA=KErrNone; |
|
365 TInt errorB=KErrNone; |
|
366 TInt error=KErrNone; |
|
367 |
|
368 //get the Equivalence Data |
|
369 errorA=iTUriParserFile.Read(valueA); |
|
370 while(valueA.Left(2)==(KCompsSipUriComment) && KErrNone==errorA) |
|
371 { |
|
372 valueA.Zero(); |
|
373 errorA=iTUriParserFile.Read(valueA); |
|
374 } |
|
375 |
|
376 errorB=iTUriParserFile.Read(valueB); |
|
377 //no Equivalence Data |
|
378 if (KErrEof==errorA || KErrEof==errorB) |
|
379 { |
|
380 return KErrBadName; |
|
381 } |
|
382 |
|
383 //read the Equivalence Sip URI |
|
384 while (KErrNone==errorA && KErrNone==errorB) |
|
385 { |
|
386 //check for comments |
|
387 while(valueA.Left(2)==(KCompsSipUriComment)) |
|
388 { |
|
389 valueA.Zero(); |
|
390 errorA=iTUriParserFile.Read(valueA); |
|
391 } |
|
392 while(valueB.Left(2)==(KCompsSipUriComment)) |
|
393 { |
|
394 valueB.Zero(); |
|
395 errorB=iTUriParserFile.Read(valueB); |
|
396 } |
|
397 |
|
398 //validate the 16 bit Sip URI first |
|
399 iTestHarness->StartTestL(_L("Test TUriParser Component Equivalence (16-bit SIP)")); |
|
400 iTestHarness->LogIt(_L("Uri - %S"), &valueA); |
|
401 iTestHarness->LogIt(_L("Uri - %S"), &valueB); |
|
402 |
|
403 error= DoSipUriEquivalence<TUriParser16>(valueA, valueB, sipUriError); |
|
404 //check for parsing errors on both Sip URIs |
|
405 if (KErrBadSipUriA==sipUriError) |
|
406 { |
|
407 SipLogError(error, valueA); |
|
408 } |
|
409 if (KErrBadSipUriB==sipUriError) |
|
410 { |
|
411 SipLogError(error, valueB); |
|
412 } |
|
413 SipLogError(error, valueA); |
|
414 |
|
415 // Make 8-bit copies and validate this SIP URI |
|
416 HBufC8* uriBufA = HBufC8::NewLC(valueA.Length()); |
|
417 TPtr8 uri8BitA = uriBufA->Des(); |
|
418 uri8BitA.Copy(valueA); |
|
419 |
|
420 HBufC8* uriBufB = HBufC8::NewLC(valueB.Length()); |
|
421 TPtr8 uri8BitB = uriBufB->Des(); |
|
422 uri8BitB.Copy(valueB); |
|
423 |
|
424 iTestHarness->StartTestL(_L("Test TUriParser Component Equivalence (8-bit SIP)")); |
|
425 iTestHarness->LogIt(_L("Uri - %S"), &valueA); |
|
426 iTestHarness->LogIt(_L("Uri - %S"), &valueB); |
|
427 error = DoSipUriEquivalence<TUriParser8>(uri8BitA, uri8BitB, sipUriError); |
|
428 //check for parsing errors on both Sip URIs |
|
429 if (KErrBadSipUriA==sipUriError) |
|
430 { |
|
431 SipLogError(error, valueA); |
|
432 } |
|
433 if (KErrBadSipUriA==sipUriError) |
|
434 { |
|
435 SipLogError(error, valueB); |
|
436 } |
|
437 SipLogError(error, valueA); |
|
438 |
|
439 CleanupStack::PopAndDestroy(2, uriBufA);// uriBufA, uriBufB |
|
440 |
|
441 errorA=iTUriParserFile.Read(valueA); |
|
442 errorB=iTUriParserFile.Read(valueB); |
|
443 } |
|
444 return KErrNone; |
|
445 } |
|
446 |
|
447 // |
|
448 // |
|
449 // SIP Uri Logger |
|
450 // |
|
451 // |
|
452 void CSipUriAndAuthorityTest::LogErrorMessage(const TDesC16& aSipUri, const TInt aError)const |
|
453 { |
|
454 switch (aError) |
|
455 { |
|
456 case KErrNotFound: |
|
457 iTestHarness->LogIt(aSipUri); |
|
458 break; |
|
459 |
|
460 case KErrNotSupported: |
|
461 iTestHarness->LogIt(_L("Not Supported")); |
|
462 break; |
|
463 |
|
464 case KUriUtilsErrInvalidScheme: |
|
465 case KUriUtilsErrDifferentScheme: |
|
466 iTestHarness->LogIt(_L("Invalid Scheme")); |
|
467 break; |
|
468 |
|
469 case KUriUtilsErrInvalidUserInfo: |
|
470 case KUriUtilsErrDifferentUserInfo: |
|
471 iTestHarness->LogIt(_L("Invalid UserInfo")); |
|
472 break; |
|
473 |
|
474 case KUriUtilsErrInvalidHost: |
|
475 case KUriUtilsErrDifferentHost: |
|
476 iTestHarness->LogIt(_L("Invalid Host")); |
|
477 break; |
|
478 |
|
479 case KUriUtilsErrInvalidPort: |
|
480 case KUriUtilsErrDifferentPort: |
|
481 iTestHarness->LogIt(_L("Invalid Port")); |
|
482 break; |
|
483 |
|
484 case KUriUtilsErrInvalidPath: |
|
485 case KUriUtilsErrDifferentPath: |
|
486 iTestHarness->LogIt(_L("Invalid Path")); |
|
487 break; |
|
488 |
|
489 case KUriUtilsErrInvalidParam: |
|
490 iTestHarness->LogIt(_L("Invalid Parameter")); |
|
491 break; |
|
492 |
|
493 case KUriUtilsErrInvalidQuery: |
|
494 case KUriUtilsErrDifferentQuery: |
|
495 iTestHarness->LogIt(_L("Invalid Query")); |
|
496 break; |
|
497 |
|
498 case KUriUtilsErrInvalidHeaders: |
|
499 iTestHarness->LogIt(_L("Invalid Headers")); |
|
500 break; |
|
501 |
|
502 case KUriUtilsErrInvalidFragment: |
|
503 case KUriUtilsErrDifferentFragment: |
|
504 iTestHarness->LogIt(_L("Invalid Fragment")); |
|
505 break; |
|
506 |
|
507 default: |
|
508 break; |
|
509 } |
|
510 |
|
511 //log correct message for equivalence |
|
512 if (iFoundEquivalence && KErrNone==aError) |
|
513 { |
|
514 iTestHarness->LogIt(KCompsSipUriEqualMess0); |
|
515 } |
|
516 else if (iFoundEquivalence && KErrNone!=aError) |
|
517 { |
|
518 iTestHarness->LogIt(KCompsSipUriEqualMess1); |
|
519 } |
|
520 } |
|
521 |
|
522 // |
|
523 // |
|
524 // Implementation of LOCAL functions |
|
525 // |
|
526 // |
|
527 |
|
528 template<class TUriParserType, class TDesCType> |
|
529 TInt DoSipUriValidation(const TDesCType& aSipUri) |
|
530 { |
|
531 TUriParserType uriParser; |
|
532 TInt error = uriParser.Parse(aSipUri); |
|
533 // Is this a valid SIP Uri? |
|
534 if( KUriUtilsErrInvalidUri == error) |
|
535 { |
|
536 return error; |
|
537 } |
|
538 |
|
539 //Validate the Sip URI |
|
540 return(uriParser.Validate()); |
|
541 } |
|
542 |
|
543 template<class TUriParserType, class TDesCType> |
|
544 TInt DoSipUriEquivalence(const TDesCType& aSipUriA, const TDesCType& aSipUriB, TInt &aSipUriError) |
|
545 { |
|
546 TUriParserType uriParserA; |
|
547 TUriParserType uriParserB; |
|
548 |
|
549 TBool errorA = uriParserA.Parse(aSipUriA); |
|
550 // Is this a valid SIP Uri? |
|
551 if( KUriUtilsErrInvalidUri == errorA) |
|
552 { |
|
553 aSipUriError=KErrBadSipUriA; |
|
554 return errorA; |
|
555 } |
|
556 |
|
557 TBool errorB = uriParserB.Parse(aSipUriB); |
|
558 // Is this a valid SIP Uri? |
|
559 if( KUriUtilsErrInvalidUri == errorB) |
|
560 { |
|
561 aSipUriError=KErrBadSipUriB; |
|
562 return errorB; |
|
563 } |
|
564 |
|
565 return(uriParserA.Equivalent(uriParserB)); |
|
566 } |
|
567 |
|
568 //End of file |