|
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 // Contains definition of CTestStepSocket which is the base class |
|
15 // for all the Socket Test Step classes (p.s. very dummy class) |
|
16 // |
|
17 // |
|
18 |
|
19 // EPOC includes |
|
20 #include <e32base.h> |
|
21 #include <es_sock.h> |
|
22 #include <test/es_dummy.h> |
|
23 |
|
24 // Test system includes |
|
25 #include "TestStepSocket.h" |
|
26 |
|
27 |
|
28 // static consts |
|
29 const TUint CTestStepSocket::KNumTestSockets = 10; |
|
30 const TInt CTestStepSocket::KNumExhaustiveSockets = 100; |
|
31 const TInt CTestStepSocket::KNumStretchOpens = 16; |
|
32 |
|
33 _LIT(KProtocolName, "Dummy Protocol 1"); // Name of test protocol to use in these tests |
|
34 _LIT8(KSendStringTest, "Bad descriptor"); // Sample testdata to send in these tests |
|
35 |
|
36 const TInt segmentlengthtest = 1; |
|
37 const TInt txlengthtest = 42; // Length of KSEndStringTest Its useful to be const |
|
38 |
|
39 // constructor |
|
40 CTestStepSocket::CTestStepSocket() : iErrText() |
|
41 { |
|
42 } |
|
43 |
|
44 // destructor |
|
45 CTestStepSocket::~CTestStepSocket() |
|
46 { |
|
47 } |
|
48 |
|
49 |
|
50 enum TVerdict CTestStepSocket::doTestStepL() |
|
51 { |
|
52 |
|
53 TRAPD(trapRet, |
|
54 Logger().ShareAuto(); |
|
55 enum TVerdict stepRet = InternalDoTestStepL(); |
|
56 if (stepRet !=EPass) |
|
57 { |
|
58 SetTestStepResult(stepRet); |
|
59 } |
|
60 ) |
|
61 |
|
62 if (trapRet != KErrNone) |
|
63 { |
|
64 SetTestStepResult(EFail); |
|
65 return EFail; |
|
66 } |
|
67 return EPass; |
|
68 }; |
|
69 |
|
70 |
|
71 // extra logging methods |
|
72 const TPtrC& CTestStepSocket::EpocErrorToText(const TInt aErrCode) |
|
73 /** |
|
74 Convert a Error code to text. |
|
75 |
|
76 @param aError error code to display as text. |
|
77 @return Text describing the error. |
|
78 */ |
|
79 { |
|
80 // TPtr errText; |
|
81 switch (aErrCode) |
|
82 { |
|
83 case KErrNone: |
|
84 iErrText.Set(_L("KErrNone")); |
|
85 break; |
|
86 case KErrNotFound: |
|
87 iErrText.Set(_L("KErrNotFound")); |
|
88 break; |
|
89 case KErrGeneral: |
|
90 iErrText.Set(_L("KErrGeneral")); |
|
91 break; |
|
92 case KErrCancel: |
|
93 iErrText.Set(_L("KErrCancel")); |
|
94 break; |
|
95 case KErrNoMemory: |
|
96 iErrText.Set(_L("KErrNoMemory")); |
|
97 break; |
|
98 case KErrNotSupported: |
|
99 iErrText.Set(_L("KErrNotSupported")); |
|
100 break; |
|
101 case KErrArgument: |
|
102 iErrText.Set(_L("KErrArgument")); |
|
103 break; |
|
104 case KErrTotalLossOfPrecision: |
|
105 iErrText.Set(_L("KErrTotalLossOfPrecision")); |
|
106 break; |
|
107 case KErrBadHandle: |
|
108 iErrText.Set(_L("KErrBadHandle")); |
|
109 break; |
|
110 case KErrOverflow: |
|
111 iErrText.Set(_L("KErrOverflow")); |
|
112 break; |
|
113 case KErrUnderflow: |
|
114 iErrText.Set(_L("KErrUnderflow")); |
|
115 break; |
|
116 case KErrAlreadyExists: |
|
117 iErrText.Set(_L("KErrAlreadyExists")); |
|
118 break; |
|
119 case KErrPathNotFound: |
|
120 iErrText.Set(_L("KErrPathNotFound")); |
|
121 break; |
|
122 case KErrDied: |
|
123 iErrText.Set(_L("KErrDied")); |
|
124 break; |
|
125 case KErrInUse: |
|
126 iErrText.Set(_L("KErrInUse")); |
|
127 break; |
|
128 case KErrServerTerminated: |
|
129 iErrText.Set(_L("KErrServerTerminated")); |
|
130 break; |
|
131 case KErrServerBusy: |
|
132 iErrText.Set(_L("KErrServerBusy")); |
|
133 break; |
|
134 case KErrCompletion: |
|
135 iErrText.Set(_L("KErrCompletion")); |
|
136 break; |
|
137 case KErrNotReady: |
|
138 iErrText.Set(_L("KErrNotReady")); |
|
139 break; |
|
140 case KErrUnknown: |
|
141 iErrText.Set(_L("KErrUnknown")); |
|
142 break; |
|
143 case KErrCorrupt: |
|
144 iErrText.Set(_L("KErrCorrupt")); |
|
145 break; |
|
146 case KErrAccessDenied: |
|
147 iErrText.Set(_L("KErrAccessDenied")); |
|
148 break; |
|
149 case KErrLocked: |
|
150 iErrText.Set(_L("KErrLocked")); |
|
151 break; |
|
152 case KErrWrite: |
|
153 iErrText.Set(_L("KErrWrite")); |
|
154 break; |
|
155 case KErrDisMounted: |
|
156 iErrText.Set(_L("KErrDisMounted")); |
|
157 break; |
|
158 case KErrEof: |
|
159 iErrText.Set(_L("KErrEof")); |
|
160 break; |
|
161 case KErrDiskFull: |
|
162 iErrText.Set(_L("KErrDiskFull")); |
|
163 break; |
|
164 case KErrBadDriver: |
|
165 iErrText.Set(_L("KErrBadDriver")); |
|
166 break; |
|
167 case KErrBadName: |
|
168 iErrText.Set(_L("KErrBadName")); |
|
169 break; |
|
170 case KErrCommsLineFail: |
|
171 iErrText.Set(_L("KErrCommsLineFail")); |
|
172 break; |
|
173 case KErrCommsFrame: |
|
174 iErrText.Set(_L("KErrCommsFrame")); |
|
175 break; |
|
176 case KErrCommsOverrun: |
|
177 iErrText.Set(_L("KErrCommsOverrun")); |
|
178 break; |
|
179 case KErrCommsParity: |
|
180 iErrText.Set(_L("KErrCommsParity")); |
|
181 break; |
|
182 case KErrTimedOut: |
|
183 iErrText.Set(_L("KErrTimedOut")); |
|
184 break; |
|
185 case KErrCouldNotConnect: |
|
186 iErrText.Set(_L("KErrCouldNotConnect")); |
|
187 break; |
|
188 case KErrCouldNotDisconnect: |
|
189 iErrText.Set(_L("KErrCouldNotDisconnect")); |
|
190 break; |
|
191 case KErrDisconnected: |
|
192 iErrText.Set(_L("KErrDisconnected")); |
|
193 break; |
|
194 case KErrBadLibraryEntryPoint: |
|
195 iErrText.Set(_L("KErrBadLibraryEntryPoint")); |
|
196 break; |
|
197 case KErrBadDescriptor: |
|
198 iErrText.Set(_L("KErrBadDescriptor")); |
|
199 break; |
|
200 case KErrAbort: |
|
201 iErrText.Set(_L("KErrAbort")); |
|
202 break; |
|
203 case KErrTooBig: |
|
204 iErrText.Set(_L("KErrTooBig")); |
|
205 break; |
|
206 case KErrCannotFindProtocol: |
|
207 iErrText.Set(_L("KErrCannotFindProtocol")); |
|
208 break; |
|
209 case KErrPermissionDenied: |
|
210 iErrText.Set(_L("KErrPermissionDenied")); |
|
211 break; |
|
212 default: |
|
213 iErrBuf.Format(_L(" %d"),aErrCode); |
|
214 iErrText.Set(iErrBuf.Ptr()); |
|
215 break; |
|
216 } |
|
217 return iErrText; |
|
218 } |
|
219 |
|
220 // static threads |
|
221 |
|
222 void CTestStepSocket::DoCreateSubsessionsL(CTestStepSocket *aTestStep, TInt aNumSubsess) |
|
223 { |
|
224 aTestStep->Logger().WriteFormat(_L("SocketThread : eSock client test sub thread - creating sockets and resolvers")); |
|
225 |
|
226 aTestStep->Logger().WriteFormat(_L("Attempting to connect to socket server")); |
|
227 RSocketServ ss; |
|
228 TInt ret = ss.Connect(); |
|
229 if (KErrNone != ret) |
|
230 { |
|
231 aTestStep->Logger().WriteFormat(_L("SocketThread : Connect returned %d"), ret); |
|
232 User::Leave(ret); |
|
233 } |
|
234 |
|
235 TProtocolDesc protoInfo; |
|
236 ret = ss.FindProtocol(_L("Dummy Protocol 1"), protoInfo); |
|
237 if (KErrNone != ret) |
|
238 { |
|
239 aTestStep->Logger().WriteFormat(_L("SocketThread : FindProtocol returned %d"), ret); |
|
240 User::Leave(ret); |
|
241 } |
|
242 |
|
243 aTestStep->Logger().WriteFormat(_L("SocketThread : Making %d sockets, host resolvers, service resolvers, net databases"), aNumSubsess); |
|
244 |
|
245 RSocket* sock = new(ELeave) RSocket[aNumSubsess]; |
|
246 RHostResolver* hostR = new(ELeave) RHostResolver[aNumSubsess]; |
|
247 RServiceResolver* servR = new(ELeave) RServiceResolver[aNumSubsess]; |
|
248 RNetDatabase* netDb = new(ELeave) RNetDatabase[aNumSubsess]; |
|
249 |
|
250 for (TInt i=0;i<aNumSubsess;i++) |
|
251 { |
|
252 ret = sock[i].Open(ss, protoInfo.iAddrFamily, protoInfo.iSockType, protoInfo.iProtocol); |
|
253 if (KErrNone != ret) |
|
254 { |
|
255 aTestStep->Logger().WriteFormat(_L("SocketThread : Socket Open returned %d"), ret); |
|
256 User::Leave(ret); |
|
257 } |
|
258 ret = hostR[i].Open(ss, protoInfo.iAddrFamily, protoInfo.iProtocol); |
|
259 if (KErrNone != ret) |
|
260 { |
|
261 aTestStep->Logger().WriteFormat(_L("SocketThread : Host Resolver Open returned %d"), ret); |
|
262 User::Leave(ret); |
|
263 } |
|
264 ret = servR[i].Open(ss, protoInfo.iAddrFamily, protoInfo.iSockType, protoInfo.iProtocol); |
|
265 if (KErrNone != ret) |
|
266 { |
|
267 aTestStep->Logger().WriteFormat(_L("SocketThread : Service Resolver Open returned %d"), ret); |
|
268 User::Leave(ret); |
|
269 } |
|
270 |
|
271 ret = netDb[i].Open(ss, protoInfo.iAddrFamily, protoInfo.iProtocol); |
|
272 if (KErrNone != ret) |
|
273 { |
|
274 aTestStep->Logger().WriteFormat(_L("SocketThread : Net Database Open returned %d"), ret); |
|
275 User::Leave(ret); |
|
276 } |
|
277 } |
|
278 } |
|
279 |
|
280 TInt CTestStepSocket::SocketThread(TAny * anArg) |
|
281 { |
|
282 |
|
283 TSocketThreadArg* tArg = static_cast<TSocketThreadArg*>(anArg); |
|
284 CTestStepSocket *h = tArg->iHandle; |
|
285 |
|
286 TInt trapRet; |
|
287 CTrapCleanup *cleanup = CTrapCleanup::New(); //Creates and then installs the cleanup stack |
|
288 if (cleanup) |
|
289 { |
|
290 TRAP(trapRet, DoCreateSubsessionsL(h, tArg->iNumSockets)); |
|
291 } |
|
292 else |
|
293 { |
|
294 trapRet = KErrNoMemory; |
|
295 } |
|
296 |
|
297 delete cleanup; |
|
298 RSemaphore *s = tArg->iSem; |
|
299 s->Signal(); |
|
300 User::WaitForAnyRequest(); |
|
301 |
|
302 return trapRet; |
|
303 } |
|
304 |
|
305 |
|
306 |
|
307 TInt CTestStepSocket::ConnectThread(TAny * anArg) |
|
308 { |
|
309 TSocketThreadArg* tArg = static_cast<TSocketThreadArg*>(anArg); |
|
310 CTestStepSocket *h = tArg->iHandle; |
|
311 |
|
312 CTrapCleanup *cleanup = CTrapCleanup::New(); |
|
313 if (!cleanup) |
|
314 { |
|
315 tArg->iSem->Signal(); |
|
316 return KErrNoMemory; |
|
317 } |
|
318 |
|
319 TInt trapRet; |
|
320 TRAP(trapRet, |
|
321 h->Logger().WriteFormat(_L("ConnectThread : eSock client test sub thread - connect and disconnect")); |
|
322 |
|
323 h->Logger().WriteFormat(_L("Attempting to connect to socket server")); |
|
324 RSocketServ ss; |
|
325 TInt ret = ss.Connect(); |
|
326 if (KErrNone != ret) |
|
327 { |
|
328 h->Logger().WriteFormat(_L("ConnectThread : Connect returned %d"), ret); |
|
329 delete cleanup; |
|
330 tArg->iSem->Signal(); |
|
331 return ret; |
|
332 } |
|
333 ss.Close(); |
|
334 |
|
335 ) |
|
336 |
|
337 delete cleanup; |
|
338 |
|
339 tArg->iSem->Signal(); |
|
340 |
|
341 return trapRet; |
|
342 } |
|
343 |
|
344 |
|
345 TInt CTestStepSocket::BadHandleThread(TAny* anArg) |
|
346 { |
|
347 TSocketThreadArg* tArg = static_cast<TSocketThreadArg*>(anArg); |
|
348 CTestStepSocket *h = tArg->iHandle; |
|
349 |
|
350 CTrapCleanup *cleanup = CTrapCleanup::New(); |
|
351 if (!cleanup) |
|
352 { |
|
353 return KErrNoMemory; |
|
354 } |
|
355 |
|
356 TInt trapRet; |
|
357 TRAP(trapRet, |
|
358 h->Logger().WriteFormat(_L("BadHandleThread : eSock client test sub thread - use bad handle")); |
|
359 RSocketServ ss; |
|
360 TInt ret = ss.Connect(); |
|
361 if (KErrNone != ret) |
|
362 { |
|
363 h->Logger().WriteFormat(_L("SocketThread : Connect returned %d"), ret); |
|
364 delete cleanup; |
|
365 return ret; |
|
366 } |
|
367 |
|
368 // Give socket a bad handle |
|
369 RSocket socket; |
|
370 *(RSessionBase*)(&socket)=ss; |
|
371 *(((TInt*)&socket)+(sizeof(RSessionBase)/sizeof(TInt))) = 4; |
|
372 |
|
373 // attempt to use it - should panic |
|
374 TSockAddr addr; |
|
375 socket.LocalName(addr); |
|
376 |
|
377 ) |
|
378 // Shouldn't get there (panic before ;-) |
|
379 delete cleanup; //really a waste of time because will not get here. Just here for neatness |
|
380 |
|
381 return trapRet; |
|
382 } |
|
383 |
|
384 TInt CTestStepSocket::ReadTwiceThread(TAny* anArg) |
|
385 { |
|
386 TSocketThreadArg* tArg = static_cast<TSocketThreadArg*>(anArg); |
|
387 CTestStepSocket *h = tArg->iHandle; |
|
388 |
|
389 CTrapCleanup *cleanup = CTrapCleanup::New(); |
|
390 if (!cleanup) |
|
391 { |
|
392 return KErrNoMemory; |
|
393 } |
|
394 |
|
395 TInt trapRet; |
|
396 |
|
397 TRAP(trapRet, |
|
398 |
|
399 h->Logger().WriteFormat(_L("ReadTwiceThread : eSock client test sub thread - read twice")); |
|
400 |
|
401 h->Logger().WriteFormat(_L("Attempting to connect to socket server")); |
|
402 RSocketServ ss; |
|
403 TInt ret = ss.Connect(); |
|
404 if (KErrNone != ret) |
|
405 { |
|
406 h->Logger().WriteFormat(_L("ReadTwiceThread : Connect returned %d"), ret); |
|
407 delete cleanup; |
|
408 return ret; |
|
409 } |
|
410 |
|
411 RSocket socket; |
|
412 h->Logger().WriteFormat(_L("ReadTwiceThread : Opening socket on dummy protocol 1")); |
|
413 ret = socket.Open(ss, _L("Dummy Protocol 1")); |
|
414 h->Logger().WriteFormat(_L("ReadTwiceThread : Open returned %d"), ret); |
|
415 if (KErrNone != ret) |
|
416 { |
|
417 delete cleanup; |
|
418 return ret; |
|
419 } |
|
420 |
|
421 h->Logger().WriteFormat(_L("ReadTwiceThread : Attempting Reads - should panic")); |
|
422 TRequestStatus stat(KRequestPending); |
|
423 TBuf8<100> buf; |
|
424 socket.Read(buf, stat); |
|
425 socket.Read(buf, stat); |
|
426 |
|
427 //Make sure ESock has time to PANIC us before we exit. |
|
428 // We expect ESock will PANIC us immediately upon receiving the |
|
429 // IPC message for the second read. |
|
430 User::After(5000000); |
|
431 |
|
432 ) |
|
433 // Shouldn't get there (panic before ;-) |
|
434 delete cleanup; |
|
435 return trapRet; |
|
436 } |
|
437 |
|
438 TInt CTestStepSocket::BadDescriptorThread(TAny* anArg) |
|
439 { |
|
440 TSocketThreadArg* tArg = static_cast<TSocketThreadArg*>(anArg); |
|
441 CTestStepSocket *h = tArg->iHandle; |
|
442 RSocketServ server; |
|
443 CTrapCleanup *cleanup = CTrapCleanup::New(); |
|
444 if (!cleanup) |
|
445 { |
|
446 return KErrNoMemory; |
|
447 } |
|
448 |
|
449 TInt trapRet; |
|
450 TRAP(trapRet, |
|
451 |
|
452 h->Logger().WriteFormat(_L("Connecting to Socket server")); |
|
453 TInt ret = server.Connect(); |
|
454 |
|
455 RSocket socket; |
|
456 h->Logger().WriteFormat(_L("Openning socket")); |
|
457 ret = socket.Open(server,KProtocolName); |
|
458 |
|
459 TRequestStatus status; |
|
460 TSockAddr addr; |
|
461 h->Logger().WriteFormat(_L("Connecting to socket")); |
|
462 socket.Connect(addr,status); |
|
463 User::WaitForRequest(status); |
|
464 |
|
465 h->Logger().WriteFormat(_L("Attempt is made to pass a negative descriptor.")); |
|
466 h->Logger().WriteFormat(_L("Esock panics when a Negative Descriptor is passed")); |
|
467 |
|
468 TBuf8<txlengthtest> logstr; |
|
469 logstr.Copy(KSendStringTest); |
|
470 TInt* plength=(TInt*)&logstr; |
|
471 *plength=-42; |
|
472 |
|
473 // Send |
|
474 TSockXfrLength length; |
|
475 socket.Send(logstr, 0, status, length); |
|
476 User::WaitForRequest(status); |
|
477 |
|
478 // Receive setup |
|
479 TSockXfrLength rxlength; |
|
480 TBuf8<segmentlengthtest> rxbuf; |
|
481 |
|
482 //Receive 0 octets |
|
483 socket.Recv(rxbuf, 0, status, rxlength); |
|
484 User::WaitForRequest(status); |
|
485 |
|
486 ) |
|
487 |
|
488 delete cleanup; |
|
489 |
|
490 return trapRet; |
|
491 |
|
492 } |
|
493 |
|
494 TInt CTestStepSocket::OptimalConnect(RSocketServ& aSrv) |
|
495 { |
|
496 TSessionPref pref; |
|
497 pref.iAddrFamily = KDummyAddrFamily; |
|
498 pref.iProtocol = KDummyThree; |
|
499 return aSrv.Connect(pref); |
|
500 } |
|
501 |
|
502 TBool CSocketTestStep_OOMCapable::CheckForHeapFailNext() |
|
503 { |
|
504 if(iOOMSess.Handle() != KNullHandle) |
|
505 { |
|
506 // If ESOCK heaps are still in FailNext mode then we try to flag the termination |
|
507 // of the loop to TEF by setting the local heap to fail. Because this might get |
|
508 // "eaten" inside TEF before it checks we walk a failure point here too |
|
509 return iOOMSess.__DbgCheckFailNext(); |
|
510 } |
|
511 return ETrue; |
|
512 } |
|
513 |