|
1 /* |
|
2 * Copyright (c) 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: |
|
15 * |
|
16 */ |
|
17 |
|
18 |
|
19 |
|
20 |
|
21 // INCLUDE FILES |
|
22 #include <e32svr.h> |
|
23 #include <StifParser.h> |
|
24 #include <Stiftestinterface.h> |
|
25 #include<list> |
|
26 #include<string> |
|
27 #include<cstring> |
|
28 #include<vector> |
|
29 #include<iterator> |
|
30 #include<bitset> |
|
31 #include<ios> |
|
32 #include<algorithm> |
|
33 #include <numeric> |
|
34 #include<functional> |
|
35 #include <locale> |
|
36 #include<iostream> |
|
37 #include<memory> |
|
38 #include<complex> |
|
39 #include<map> |
|
40 #include<set> |
|
41 #include<exception> |
|
42 |
|
43 |
|
44 #include <stl/char_traits.h> // fpos |
|
45 #include "tstl_2.h" |
|
46 #undef test |
|
47 using namespace std; |
|
48 #define STDCPP_OOM FALSE// TRUE for OOM testing |
|
49 |
|
50 #ifdef __ARMCC__ |
|
51 #pragma diag_suppress 550 |
|
52 #pragma diag_suppress 177 |
|
53 #pragma diag_suppress 1134 |
|
54 #pragma diag_suppress 1250 |
|
55 #endif |
|
56 |
|
57 // ============================ MEMBER FUNCTIONS =============================== |
|
58 |
|
59 // ----------------------------------------------------------------------------- |
|
60 // Ctstl_2::Delete |
|
61 // Delete here all resources allocated and opened from test methods. |
|
62 // Called from destructor. |
|
63 // ----------------------------------------------------------------------------- |
|
64 // |
|
65 void Ctstl_2::Delete() |
|
66 { |
|
67 |
|
68 } |
|
69 |
|
70 // ----------------------------------------------------------------------------- |
|
71 // Ctstl_2::RunMethodL |
|
72 // Run specified method. Contains also table of test mothods and their names. |
|
73 // ----------------------------------------------------------------------------- |
|
74 // |
|
75 TInt Ctstl_2::RunMethodL( |
|
76 CStifItemParser& aItem ) |
|
77 { |
|
78 |
|
79 static TStifFunctionInfo const KFunctions[] = |
|
80 { |
|
81 // Copy this line for every implemented function. |
|
82 // First string is the function name used in TestScripter script file. |
|
83 // Second is the actual implementation member function. |
|
84 // Second is the actual implementation member function. |
|
85 ENTRY("Advance", Ctstl_2::Advance ), |
|
86 ENTRY("Backinsert_iterator", Ctstl_2::Backinsert_iterator ), |
|
87 ENTRY("Frontinsert_iterator", Ctstl_2::Frontinsert_iterator ), |
|
88 ENTRY("Insert_iterator", Ctstl_2::Insert_iterator ), |
|
89 ENTRY("Reverse_iterator", Ctstl_2::Reverse_iterator ), |
|
90 ENTRY("Distance", Ctstl_2::Distance ), |
|
91 //ENTRY("Distancetype", Ctstl_2::Distancetype ), |
|
92 ENTRY("Bit_set", Ctstl_2::Bit_set ), |
|
93 ENTRY("Isdigit", Ctstl_2::Isdigit ), |
|
94 ENTRY("Isgraph", Ctstl_2::Isgraph ), |
|
95 ENTRY("Isalnum", Ctstl_2::Isalnum ), |
|
96 ENTRY("Isalpha", Ctstl_2::Isalpha ), |
|
97 ENTRY("Iscntrl", Ctstl_2::Iscntrl ), |
|
98 ENTRY("Isprint", Ctstl_2::Isprint ), |
|
99 ENTRY("Ispunct", Ctstl_2::Ispunct ), |
|
100 ENTRY("Isspace", Ctstl_2::Isspace ), |
|
101 ENTRY("Isxdigit", Ctstl_2::Isxdigit ), |
|
102 ENTRY("Fill", Ctstl_2::Fill ), |
|
103 ENTRY("Generate", Ctstl_2::Generate ), |
|
104 ENTRY("Search", Ctstl_2::Search ), |
|
105 ENTRY("Search_n", Ctstl_2::Search_n ), |
|
106 ENTRY("Times", Ctstl_2::Times ), |
|
107 ENTRY("Unique", Ctstl_2::Unique ), |
|
108 ENTRY("Uniquecopy", Ctstl_2::Uniquecopy ), |
|
109 ENTRY("Partialsort", Ctstl_2::Partialsort ), |
|
110 ENTRY("Partialsortcopy", Ctstl_2::Partialsortcopy ), |
|
111 ENTRY("Partition", Ctstl_2::Partition ), |
|
112 ENTRY("Stablepartition", Ctstl_2::Stablepartition ), |
|
113 ENTRY("Setdifference", Ctstl_2::Setdifference ), |
|
114 ENTRY("Setintersection", Ctstl_2::Setintersection ), |
|
115 ENTRY("Setsymdifference", Ctstl_2::Setsymdifference ), |
|
116 ENTRY("Setunion", Ctstl_2::Setunion ), |
|
117 ENTRY("HeapL", Ctstl_2::HeapL ), |
|
118 ENTRY("Swapranges", Ctstl_2::Swapranges ), |
|
119 ENTRY("Partialsums", Ctstl_2::Partialsums ), |
|
120 ENTRY("Unarynegate", Ctstl_2::Unarynegate ), |
|
121 ENTRY("Not2", Ctstl_2::Not2), |
|
122 ENTRY("GettemporarybufferL", Ctstl_2::GettemporarybufferL), |
|
123 ENTRY("Pair", Ctstl_2::Pair), |
|
124 ENTRY("Lexicographicalcompare", Ctstl_2::Lexicographicalcompare ), |
|
125 ENTRY("Mismatch", Ctstl_2::Mismatch ), |
|
126 ENTRY("Compare_fun", Ctstl_2::Compare_fun ), |
|
127 ENTRY("Copy_fun", Ctstl_2::Copy_fun ), |
|
128 ENTRY("Copybackward_fun", Ctstl_2::Copybackward_fun ), |
|
129 ENTRY("mergeL", Ctstl_2::mergeL ), |
|
130 ENTRY("allocatoradd", Ctstl_2::allocatoradd ), |
|
131 ENTRY("alldeall", Ctstl_2::alldeall ), |
|
132 ENTRY("allcons", Ctstl_2::allcons ), |
|
133 ENTRY("allrebind", Ctstl_2::allrebind ), |
|
134 ENTRY("allmaxsize", Ctstl_2::allmaxsize ), |
|
135 ENTRY("complexL",Ctstl_2::complexL), |
|
136 ENTRY("limitsL",Ctstl_2::limitsL), |
|
137 ENTRY("nextperm",Ctstl_2::nextperm), |
|
138 ENTRY("prevperm",Ctstl_2::prevperm), |
|
139 ENTRY("ptrfun",Ctstl_2::ptrfun), |
|
140 ENTRY("itertraits",Ctstl_2::itertraits), |
|
141 ENTRY("map1",Ctstl_2:: map1), |
|
142 ENTRY("map2",Ctstl_2::map2), |
|
143 ENTRY("map3",Ctstl_2::map3), |
|
144 ENTRY("map4",Ctstl_2::map4), |
|
145 ENTRY("map5",Ctstl_2::map5), |
|
146 ENTRY("map6",Ctstl_2::map6), |
|
147 ENTRY("map7",Ctstl_2::map7), |
|
148 ENTRY("map8",Ctstl_2::map8), |
|
149 ENTRY("map9",Ctstl_2::map9), |
|
150 ENTRY("map10",Ctstl_2::map10), |
|
151 ENTRY("map11",Ctstl_2::map11), |
|
152 ENTRY("map12",Ctstl_2::map12), |
|
153 ENTRY("map13",Ctstl_2::map13), |
|
154 ENTRY("multimap1",Ctstl_2:: multimap1), |
|
155 ENTRY("multimap2",Ctstl_2::multimap2), |
|
156 ENTRY("multimap3",Ctstl_2::multimap3), |
|
157 ENTRY("multimap4",Ctstl_2::multimap4), |
|
158 ENTRY("multimap5",Ctstl_2::multimap5), |
|
159 ENTRY("multimap6",Ctstl_2::multimap6), |
|
160 ENTRY("multimap7",Ctstl_2::multimap7), |
|
161 ENTRY("multimap8",Ctstl_2::multimap8), |
|
162 ENTRY("multimap9",Ctstl_2::multimap9), |
|
163 ENTRY("multimap10",Ctstl_2::multimap10), |
|
164 ENTRY("multimap11",Ctstl_2::multimap11), |
|
165 ENTRY("multimap12",Ctstl_2::multimap12), |
|
166 ENTRY("multimap13",Ctstl_2::multimap13), |
|
167 ENTRY("multi_set",Ctstl_2::multi_set), |
|
168 ENTRY("multi_set2",Ctstl_2::multi_set2), |
|
169 ENTRY("multi_set3",Ctstl_2::multi_set3), |
|
170 |
|
171 }; |
|
172 |
|
173 const TInt count = sizeof( KFunctions ) / |
|
174 sizeof( TStifFunctionInfo ); |
|
175 |
|
176 return RunInternalL( KFunctions, count, aItem ); |
|
177 |
|
178 } |
|
179 // ----------------------------------------------------------------------------- |
|
180 // Ctstl_2::ExampleL |
|
181 // Example test method function. |
|
182 // (other items were commented in a header). |
|
183 // ----------------------------------------------------------------------------- |
|
184 // |
|
185 TInt Ctstl_2::Advance( CStifItemParser& aItem ) |
|
186 { |
|
187 |
|
188 |
|
189 int failures=0 ; |
|
190 |
|
191 |
|
192 |
|
193 |
|
194 try |
|
195 { |
|
196 |
|
197 list<string>::iterator iList1,iList2; |
|
198 list<string> List; |
|
199 List.push_back("A1"); |
|
200 List.push_back("B2"); |
|
201 List.push_back("C3"); |
|
202 List.push_back("D4"); |
|
203 List.push_back("E5"); |
|
204 List.push_back("F6"); |
|
205 List.push_back("G7"); |
|
206 // cout<<""; |
|
207 #if STDCPP_OOM |
|
208 User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1); |
|
209 #endif |
|
210 |
|
211 iList1=List.begin(); |
|
212 advance(iList1,2); |
|
213 iList2 = List.begin(); |
|
214 advance(iList2,0); |
|
215 #if STDCPP_OOM |
|
216 User::__DbgSetAllocFail(FALSE,RHeap::ENone,1); |
|
217 |
|
218 |
|
219 #endif |
|
220 if(*iList1 != "C3") |
|
221 failures++; |
|
222 |
|
223 if(*iList2 != "A1") |
|
224 failures++; |
|
225 |
|
226 //#if STDCPP_OOM |
|
227 //failures++; |
|
228 // #endif |
|
229 /* |
|
230 if(*iList1 == "C3") |
|
231 if(*iList2 == "A1") |
|
232 return KErrNone; |
|
233 return KErrGeneral; |
|
234 */ |
|
235 } |
|
236 catch(bad_alloc&) |
|
237 { |
|
238 //do nothing |
|
239 } |
|
240 catch(...) |
|
241 { |
|
242 failures++; |
|
243 |
|
244 } |
|
245 |
|
246 if(failures ) |
|
247 return KErrGeneral; |
|
248 return KErrNone; |
|
249 } |
|
250 |
|
251 |
|
252 |
|
253 |
|
254 |
|
255 TInt Ctstl_2::Backinsert_iterator( CStifItemParser& aItem ) |
|
256 { |
|
257 int failures=0; |
|
258 try |
|
259 { |
|
260 |
|
261 |
|
262 |
|
263 int i; |
|
264 int output[4]; |
|
265 vector<int> vec; |
|
266 for (i = 1 ; i < 4 ; ++i ) |
|
267 { |
|
268 vec.push_back ( i ); |
|
269 } |
|
270 |
|
271 |
|
272 vector <int>::iterator vIter; |
|
273 |
|
274 |
|
275 |
|
276 back_insert_iterator<vector<int> >::container_type vec1 = vec; |
|
277 // cout<<""; |
|
278 #if STDCPP_OOM |
|
279 User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1); |
|
280 #endif |
|
281 back_inserter ( vec1 ) = 40; |
|
282 |
|
283 #if STDCPP_OOM |
|
284 User::__DbgSetAllocFail(FALSE,RHeap::ENone,1); |
|
285 |
|
286 |
|
287 #endif |
|
288 for ( vIter = vec1.begin ( ) ; vIter != vec1.end ( ); vIter++) |
|
289 |
|
290 |
|
291 { |
|
292 |
|
293 static int i; |
|
294 output[i] = *vIter; |
|
295 i++; |
|
296 |
|
297 } |
|
298 |
|
299 |
|
300 if(output[0] != 1) |
|
301 failures++; |
|
302 if(output[1] != 2) |
|
303 failures++; |
|
304 if(output[2] != 3) |
|
305 failures++; |
|
306 if(output[3] != 40) |
|
307 failures++; |
|
308 |
|
309 /* |
|
310 if(output[0] == 1) |
|
311 if(output[1] == 2) |
|
312 if(output[2] == 3) |
|
313 if(output[3] == 40) |
|
314 return KErrNone; |
|
315 return KErrGeneral; |
|
316 */ |
|
317 //#if STDCPP_OOM |
|
318 //failures++; |
|
319 // #endif |
|
320 } |
|
321 catch(bad_alloc&) |
|
322 { |
|
323 //do nothing |
|
324 } |
|
325 catch(...) |
|
326 { |
|
327 failures++; |
|
328 |
|
329 } |
|
330 |
|
331 if(failures ) |
|
332 return KErrGeneral; |
|
333 return KErrNone; |
|
334 } |
|
335 |
|
336 |
|
337 |
|
338 TInt Ctstl_2::Frontinsert_iterator( CStifItemParser& aItem ) |
|
339 { |
|
340 int failures=0; |
|
341 try{ |
|
342 int i; |
|
343 list <int>::iterator L_Iter; |
|
344 int output[12]; |
|
345 list<int> L; |
|
346 for (i = -1 ; i < 9 ; ++i ) |
|
347 { |
|
348 L.push_back ( 2 * i ); |
|
349 } |
|
350 // cout<<""; |
|
351 #if STDCPP_OOM |
|
352 User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1); |
|
353 #endif |
|
354 |
|
355 // Using the member function to insert an element |
|
356 front_inserter ( L ) = 20; |
|
357 |
|
358 // Alternatively, one may use the template function |
|
359 front_insert_iterator< list < int> > Iter(L); |
|
360 #if STDCPP_OOM |
|
361 User::__DbgSetAllocFail(FALSE,RHeap::ENone,1); |
|
362 #endif |
|
363 *Iter = 30; |
|
364 |
|
365 for ( L_Iter = L.begin( ) ; L_Iter != L.end( ); L_Iter++) |
|
366 |
|
367 |
|
368 { |
|
369 static int i; |
|
370 output[i] = *L_Iter; |
|
371 i++; |
|
372 } |
|
373 if(output[0] != 30) |
|
374 failures++; |
|
375 if(output[1] != 20) |
|
376 failures++; |
|
377 if(output[2] != -2) |
|
378 failures++; |
|
379 if(output[3] != 0) |
|
380 failures++; |
|
381 |
|
382 //#if STDCPP_OOM |
|
383 //failures++; |
|
384 // #endif |
|
385 |
|
386 /* |
|
387 if(output[0] == 30) |
|
388 if(output[1] == 20) |
|
389 if(output[2] == -2) |
|
390 if(output[3] == 0) |
|
391 return KErrNone; |
|
392 return KErrGeneral;*/ |
|
393 |
|
394 |
|
395 |
|
396 } |
|
397 |
|
398 |
|
399 catch(bad_alloc&) |
|
400 { |
|
401 //do nothing |
|
402 } |
|
403 catch(...) |
|
404 { |
|
405 failures++; |
|
406 |
|
407 } |
|
408 |
|
409 if(failures ) |
|
410 return KErrGeneral; |
|
411 return KErrNone; |
|
412 } |
|
413 |
|
414 |
|
415 |
|
416 |
|
417 TInt Ctstl_2::Insert_iterator( CStifItemParser& aItem ) |
|
418 { |
|
419 int failures=0; |
|
420 try{ |
|
421 int i; |
|
422 list <int>::iterator L_Iter; |
|
423 int output[5]; |
|
424 list<int> L; |
|
425 for (i = 2 ; i < 5 ; ++i ) |
|
426 { |
|
427 L.push_back ( 10 * i ); |
|
428 } |
|
429 // cout<<""; |
|
430 #if STDCPP_OOM |
|
431 User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1); |
|
432 #endif |
|
433 |
|
434 // Using the template version to insert an element |
|
435 insert_iterator<list <int> > Iter( L, L.begin ( ) ); |
|
436 *Iter = 1; |
|
437 |
|
438 // Alternatively, using the member function to insert an element |
|
439 inserter ( L, L.end ( ) ) = 500; |
|
440 #if STDCPP_OOM |
|
441 User::__DbgSetAllocFail(FALSE,RHeap::ENone,1); |
|
442 #endif |
|
443 for ( L_Iter = L.begin( ) ; L_Iter != L.end( ); L_Iter++) |
|
444 |
|
445 { |
|
446 static int i; |
|
447 output[i] = *L_Iter; |
|
448 i++; |
|
449 } |
|
450 |
|
451 if(output[0] != 1) |
|
452 failures++; |
|
453 if(output[4] != 500) |
|
454 failures++; |
|
455 /* |
|
456 if(output[0] == 1) |
|
457 if(output[4] == 500) |
|
458 |
|
459 return KErrNone; |
|
460 return KErrGeneral; |
|
461 */ |
|
462 //#if STDCPP_OOM |
|
463 //failures++; |
|
464 // #endif |
|
465 |
|
466 } |
|
467 |
|
468 |
|
469 catch(bad_alloc&) |
|
470 { |
|
471 //do nothing |
|
472 } |
|
473 catch(...) |
|
474 { |
|
475 failures++; |
|
476 |
|
477 } |
|
478 |
|
479 if(failures ) |
|
480 return KErrGeneral; |
|
481 return KErrNone; |
|
482 } |
|
483 |
|
484 TInt Ctstl_2::Reverse_iterator( CStifItemParser& aItem ) |
|
485 |
|
486 { |
|
487 int failures=0; |
|
488 try{ |
|
489 int i; |
|
490 |
|
491 |
|
492 vector<int> vec; |
|
493 |
|
494 for ( i = 1 ; i < 6 ; ++i ) |
|
495 { |
|
496 vec.push_back ( i ); |
|
497 } |
|
498 |
|
499 // vector <int>::iterator vIter; |
|
500 |
|
501 |
|
502 // vector <int>::reverse_iterator rvIter; |
|
503 |
|
504 vector <int>::iterator pos; |
|
505 |
|
506 pos = find ( vec.begin ( ), vec.end ( ), 4 ); |
|
507 |
|
508 |
|
509 if(*pos != 4) |
|
510 failures++; |
|
511 // cout<<""; |
|
512 #if STDCPP_OOM |
|
513 User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1); |
|
514 #endif |
|
515 vector <int>::reverse_iterator rpos ( pos ); |
|
516 #if STDCPP_OOM |
|
517 User::__DbgSetAllocFail(FALSE,RHeap::ENone,1); |
|
518 #endif |
|
519 if(*rpos != 3) |
|
520 failures++; |
|
521 |
|
522 |
|
523 //#if STDCPP_OOM |
|
524 //failures++; |
|
525 // #endif |
|
526 |
|
527 |
|
528 } |
|
529 |
|
530 |
|
531 |
|
532 catch(bad_alloc&) |
|
533 { |
|
534 //do nothing |
|
535 } |
|
536 catch(...) |
|
537 { |
|
538 failures++; |
|
539 |
|
540 } |
|
541 |
|
542 if(failures ) |
|
543 return KErrGeneral; |
|
544 return KErrNone; |
|
545 } |
|
546 |
|
547 TInt Ctstl_2::Distance( CStifItemParser& aItem ) |
|
548 |
|
549 { |
|
550 int failures =0; |
|
551 try{ |
|
552 int i; |
|
553 |
|
554 |
|
555 list<int> L; |
|
556 for ( i = -1 ; i < 9 ; ++i ) |
|
557 { |
|
558 L.push_back ( 2 * i ); |
|
559 } |
|
560 |
|
561 |
|
562 list <int>::iterator LPOS = L.begin ( ); |
|
563 |
|
564 |
|
565 |
|
566 |
|
567 advance ( LPOS , 7 ); |
|
568 |
|
569 list<int>::difference_type Ldiff ; |
|
570 // cout<<""; |
|
571 #if STDCPP_OOM |
|
572 User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1); |
|
573 #endif |
|
574 Ldiff = distance ( L.begin ( ) , LPOS ); |
|
575 |
|
576 #if STDCPP_OOM |
|
577 User::__DbgSetAllocFail(FALSE,RHeap::ENone,1); |
|
578 #endif |
|
579 /*if(*LPOS ==12) |
|
580 if(Ldiff==7) |
|
581 return KErrNone; |
|
582 return KErrGeneral;*/ |
|
583 |
|
584 if(*LPOS !=12) |
|
585 failures++; |
|
586 if(Ldiff!=7) |
|
587 failures++; |
|
588 //#if STDCPP_OOM |
|
589 //failures++; |
|
590 // #endif |
|
591 |
|
592 } |
|
593 catch(bad_alloc&) |
|
594 { |
|
595 //do nothing |
|
596 } |
|
597 catch(...) |
|
598 { |
|
599 failures++; |
|
600 |
|
601 } |
|
602 |
|
603 if(failures ) |
|
604 return KErrGeneral; |
|
605 return KErrNone; |
|
606 } |
|
607 |
|
608 /* |
|
609 TInt Ctstl_2::Distancetype( CStifItemParser& aItem ) |
|
610 |
|
611 { |
|
612 |
|
613 int i; |
|
614 |
|
615 |
|
616 list<int> L; |
|
617 for ( i = -1 ; i < 9 ; ++i ) |
|
618 { |
|
619 L.push_back ( 2 * i ); |
|
620 } |
|
621 |
|
622 |
|
623 list <int>::iterator L_Iter, LPOS = L.begin ( ); |
|
624 |
|
625 |
|
626 |
|
627 |
|
628 advance ( LPOS , 7 ); |
|
629 |
|
630 list<int>::difference_type Ldiff ; |
|
631 Ldiff = distance_type ( L.begin ( ) , LPOS ); |
|
632 |
|
633 |
|
634 if(*LPOS ==12) |
|
635 if(Ldiff==7) |
|
636 return KErrNone; |
|
637 return KErrGeneral; |
|
638 |
|
639 |
|
640 |
|
641 } |
|
642 */ |
|
643 |
|
644 |
|
645 |
|
646 TInt Ctstl_2::Bit_set( CStifItemParser& aItem ) |
|
647 |
|
648 { |
|
649 |
|
650 int failures =0; |
|
651 try{ |
|
652 bitset<2> b0; |
|
653 if(b0 != 00) |
|
654 failures++; |
|
655 |
|
656 |
|
657 // Using the second member function |
|
658 bitset<5> b1(6); |
|
659 if(b1 != 6) |
|
660 failures++; |
|
661 // cout<<""; |
|
662 |
|
663 #if STDCPP_OOM |
|
664 User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1); |
|
665 #endif |
|
666 |
|
667 bitset<3> b3 (6); |
|
668 #if STDCPP_OOM |
|
669 User::__DbgSetAllocFail(FALSE,RHeap::ENone,1); |
|
670 #endif |
|
671 bool b = b3.any ( ); |
|
672 if(!b) |
|
673 failures++; |
|
674 bool n = b3.none ( ); |
|
675 |
|
676 if(n) |
|
677 failures++; |
|
678 |
|
679 size_t i; |
|
680 i = b3.count(); |
|
681 if(i!=2) |
|
682 failures++; |
|
683 |
|
684 bitset<3> fb1; |
|
685 fb1 = b3.flip(); |
|
686 |
|
687 |
|
688 size_t j; |
|
689 j= b3.count(); |
|
690 |
|
691 if(j!=1) |
|
692 failures++; |
|
693 |
|
694 |
|
695 |
|
696 bitset<5> a1 ( 13 ); |
|
697 |
|
698 |
|
699 i = a1.count(); |
|
700 |
|
701 if(i!=3) |
|
702 failures++; |
|
703 |
|
704 bitset<5> b1r3; |
|
705 b1r3 = a1.reset( 2 ); |
|
706 |
|
707 i = b1r3.count(); |
|
708 |
|
709 |
|
710 if(i!=2) |
|
711 failures++; |
|
712 |
|
713 |
|
714 |
|
715 bitset<5> b1r; |
|
716 b1r = a1.reset( ); |
|
717 |
|
718 i= b1r.count(); |
|
719 if(i!=0) |
|
720 failures++; |
|
721 bitset<5> b1s; |
|
722 b1s = a1.set(); |
|
723 i=b1s.count(); |
|
724 if(i!=5) |
|
725 failures++; |
|
726 |
|
727 int k ; |
|
728 k= a1.size(); |
|
729 if(k!=5) |
|
730 failures++; |
|
731 |
|
732 bool test = a1.test ( 3 ); |
|
733 |
|
734 if(!test) |
|
735 failures++; |
|
736 #define test(x) __test(x,__LINE__,__FILE__) |
|
737 |
|
738 bitset<5> str ( 7 ); |
|
739 |
|
740 |
|
741 |
|
742 string s1; |
|
743 s1 = str.template to_string<char, char_traits<char>, allocator<char> >( ); |
|
744 |
|
745 |
|
746 if(s1.compare("00111")) |
|
747 failures++; |
|
748 bitset<5> tlon( 7 ); |
|
749 |
|
750 |
|
751 |
|
752 |
|
753 unsigned long int lon; |
|
754 lon = tlon.to_ulong( ); |
|
755 if(lon!=7) |
|
756 failures++; |
|
757 |
|
758 |
|
759 //#if STDCPP_OOM |
|
760 //failures++; |
|
761 // #endif |
|
762 |
|
763 |
|
764 } |
|
765 |
|
766 catch(bad_alloc&) |
|
767 { |
|
768 //do nothing |
|
769 } |
|
770 catch(...) |
|
771 { |
|
772 failures++; |
|
773 |
|
774 } |
|
775 |
|
776 if(failures ) |
|
777 return KErrGeneral; |
|
778 return KErrNone; |
|
779 } |
|
780 |
|
781 |
|
782 TInt Ctstl_2::Isdigit( CStifItemParser& aItem ) |
|
783 |
|
784 { |
|
785 |
|
786 char str[]="1776ad"; |
|
787 |
|
788 int failures =0; |
|
789 try{ |
|
790 // cout<<""; |
|
791 #if STDCPP_OOM |
|
792 User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1); |
|
793 #endif |
|
794 if (!isdigit(str[0])) |
|
795 failures++; |
|
796 if (!isdigit(str[1])) |
|
797 failures++; |
|
798 if (!isdigit(str[2])) |
|
799 failures++; |
|
800 if (!isdigit(str[3])) |
|
801 failures++; |
|
802 if (isdigit(str[4])) |
|
803 failures++; |
|
804 if (isdigit(str[5])) |
|
805 failures++; |
|
806 #if STDCPP_OOM |
|
807 User::__DbgSetAllocFail(FALSE,RHeap::ENone,1); |
|
808 #endif |
|
809 //#if STDCPP_OOM |
|
810 //failures++; |
|
811 // #endif |
|
812 |
|
813 |
|
814 |
|
815 |
|
816 |
|
817 } |
|
818 catch(bad_alloc&) |
|
819 { |
|
820 //do nothing |
|
821 } |
|
822 catch(...) |
|
823 { |
|
824 failures++; |
|
825 |
|
826 } |
|
827 |
|
828 if(failures ) |
|
829 return KErrGeneral; |
|
830 return KErrNone; |
|
831 } |
|
832 |
|
833 |
|
834 TInt Ctstl_2::Isgraph( CStifItemParser& aItem ) |
|
835 |
|
836 { |
|
837 |
|
838 int failures =0; |
|
839 // char array[42] = "!"#$%&'()*+,-./0123456789:;<=>?@[\]^_`{|}~"; |
|
840 |
|
841 |
|
842 try{ |
|
843 |
|
844 for(char i=0x21;i<=0x7E;i++) |
|
845 { |
|
846 // cout<<""; |
|
847 #if STDCPP_OOM |
|
848 User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1); |
|
849 #endif |
|
850 |
|
851 if(!isgraph(i)) |
|
852 |
|
853 failures++; |
|
854 #if STDCPP_OOM |
|
855 User::__DbgSetAllocFail(FALSE,RHeap::ENone,1); |
|
856 #endif |
|
857 |
|
858 |
|
859 } |
|
860 |
|
861 |
|
862 |
|
863 |
|
864 |
|
865 //#if STDCPP_OOM |
|
866 //failures++; |
|
867 // #endif |
|
868 |
|
869 |
|
870 |
|
871 } |
|
872 |
|
873 catch(bad_alloc&) |
|
874 { |
|
875 //do nothing |
|
876 } |
|
877 catch(...) |
|
878 { |
|
879 failures++; |
|
880 |
|
881 } |
|
882 |
|
883 if(failures ) |
|
884 return KErrGeneral; |
|
885 return KErrNone; |
|
886 } |
|
887 |
|
888 |
|
889 |
|
890 TInt Ctstl_2::Isalnum( CStifItemParser& aItem ) |
|
891 |
|
892 { |
|
893 |
|
894 int failures =0; |
|
895 |
|
896 |
|
897 try{ |
|
898 |
|
899 for(char text='a';text<='z';text++) |
|
900 { |
|
901 |
|
902 #if STDCPP_OOM |
|
903 User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1); |
|
904 #endif |
|
905 if(!isalnum(text)) |
|
906 failures++; |
|
907 #if STDCPP_OOM |
|
908 User::__DbgSetAllocFail(FALSE,RHeap::ENone,1); |
|
909 #endif |
|
910 |
|
911 |
|
912 |
|
913 } |
|
914 |
|
915 |
|
916 for(char text='A';text<='Z';text++) |
|
917 { |
|
918 |
|
919 #if STDCPP_OOM |
|
920 User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1); |
|
921 #endif |
|
922 if(!isalnum(text)) |
|
923 failures++; |
|
924 #if STDCPP_OOM |
|
925 User::__DbgSetAllocFail(FALSE,RHeap::ENone,1); |
|
926 #endif |
|
927 |
|
928 |
|
929 |
|
930 } |
|
931 |
|
932 |
|
933 |
|
934 for(int text='0';text<='9';text++) |
|
935 { |
|
936 |
|
937 |
|
938 if(!isalnum(text)) |
|
939 failures++; |
|
940 |
|
941 |
|
942 } |
|
943 |
|
944 //#if STDCPP_OOM |
|
945 //failures++; |
|
946 // #endif |
|
947 |
|
948 |
|
949 |
|
950 } |
|
951 |
|
952 |
|
953 |
|
954 catch(bad_alloc&) |
|
955 { |
|
956 //do nothing |
|
957 } |
|
958 catch(...) |
|
959 { |
|
960 failures++; |
|
961 |
|
962 } |
|
963 |
|
964 if(failures ) |
|
965 return KErrGeneral; |
|
966 return KErrNone; |
|
967 } |
|
968 TInt Ctstl_2::Isalpha( CStifItemParser& aItem ) |
|
969 |
|
970 { |
|
971 |
|
972 int failures =0; |
|
973 |
|
974 try{ |
|
975 |
|
976 |
|
977 for(char text='a';text<='z';text++) |
|
978 { |
|
979 |
|
980 #if STDCPP_OOM |
|
981 User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1); |
|
982 #endif |
|
983 if(!isalpha(text)) |
|
984 failures++; |
|
985 #if STDCPP_OOM |
|
986 User::__DbgSetAllocFail(FALSE,RHeap::ENone,1); |
|
987 #endif |
|
988 |
|
989 |
|
990 |
|
991 } |
|
992 |
|
993 |
|
994 for(char text='A';text<='Z';text++) |
|
995 { |
|
996 |
|
997 |
|
998 if(!isalpha(text)) |
|
999 failures++; |
|
1000 |
|
1001 |
|
1002 } |
|
1003 |
|
1004 |
|
1005 |
|
1006 for(int text='0';text<='9';text++) |
|
1007 { |
|
1008 |
|
1009 |
|
1010 if(isalpha(text)) |
|
1011 failures++; |
|
1012 |
|
1013 |
|
1014 } |
|
1015 |
|
1016 //#if STDCPP_OOM |
|
1017 //failures++; |
|
1018 // #endif |
|
1019 |
|
1020 |
|
1021 } |
|
1022 catch(bad_alloc&) |
|
1023 { |
|
1024 //do nothing |
|
1025 } |
|
1026 catch(...) |
|
1027 { |
|
1028 failures++; |
|
1029 |
|
1030 } |
|
1031 |
|
1032 if(failures ) |
|
1033 return KErrGeneral; |
|
1034 return KErrNone; |
|
1035 } |
|
1036 |
|
1037 |
|
1038 |
|
1039 TInt Ctstl_2::Iscntrl( CStifItemParser& aItem ) |
|
1040 |
|
1041 { |
|
1042 int failures =0; |
|
1043 |
|
1044 try{ |
|
1045 |
|
1046 |
|
1047 |
|
1048 |
|
1049 for(char text=0x00;text<=0x1F;text++) |
|
1050 { |
|
1051 |
|
1052 #if STDCPP_OOM |
|
1053 User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1); |
|
1054 #endif |
|
1055 if(!iscntrl(text)) |
|
1056 failures++; |
|
1057 #if STDCPP_OOM |
|
1058 User::__DbgSetAllocFail(FALSE,RHeap::ENone,1); |
|
1059 #endif |
|
1060 |
|
1061 |
|
1062 } |
|
1063 |
|
1064 if(!iscntrl(0x7F)) |
|
1065 failures++; |
|
1066 /* |
|
1067 if(failures) |
|
1068 return KErrGeneral; |
|
1069 return KErrNone; |
|
1070 */ |
|
1071 //#if STDCPP_OOM |
|
1072 //failures++; |
|
1073 // #endif |
|
1074 |
|
1075 |
|
1076 } |
|
1077 |
|
1078 catch(bad_alloc&) |
|
1079 { |
|
1080 //do nothing |
|
1081 } |
|
1082 catch(...) |
|
1083 { |
|
1084 failures++; |
|
1085 |
|
1086 } |
|
1087 |
|
1088 if(failures ) |
|
1089 return KErrGeneral; |
|
1090 return KErrNone; |
|
1091 } |
|
1092 |
|
1093 |
|
1094 TInt Ctstl_2::Isprint( CStifItemParser& aItem ) |
|
1095 |
|
1096 { |
|
1097 |
|
1098 int failures =0; |
|
1099 |
|
1100 try{ |
|
1101 |
|
1102 |
|
1103 for(char text=0x20;text<=0x7E;text++) |
|
1104 { |
|
1105 |
|
1106 #if STDCPP_OOM |
|
1107 User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1); |
|
1108 #endif |
|
1109 if(!isprint(text)) |
|
1110 failures++; |
|
1111 #if STDCPP_OOM |
|
1112 User::__DbgSetAllocFail(FALSE,RHeap::ENone,1); |
|
1113 #endif |
|
1114 |
|
1115 } |
|
1116 |
|
1117 |
|
1118 /* |
|
1119 if(failures) |
|
1120 return KErrGeneral; |
|
1121 return KErrNone; |
|
1122 */ |
|
1123 //#if STDCPP_OOM |
|
1124 //failures++; |
|
1125 // #endif |
|
1126 |
|
1127 |
|
1128 } |
|
1129 |
|
1130 catch(bad_alloc&) |
|
1131 { |
|
1132 //do nothing |
|
1133 } |
|
1134 catch(...) |
|
1135 { |
|
1136 failures++; |
|
1137 |
|
1138 } |
|
1139 |
|
1140 if(failures ) |
|
1141 return KErrGeneral; |
|
1142 return KErrNone; |
|
1143 } |
|
1144 |
|
1145 |
|
1146 TInt Ctstl_2::Ispunct( CStifItemParser& aItem ) |
|
1147 |
|
1148 { |
|
1149 |
|
1150 int failures =0; |
|
1151 |
|
1152 try{ |
|
1153 for(char text=0x21;text<=0x2F;text++) |
|
1154 { |
|
1155 #if STDCPP_OOM |
|
1156 User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1); |
|
1157 #endif |
|
1158 if(!ispunct(text)) |
|
1159 failures++; |
|
1160 #if STDCPP_OOM |
|
1161 User::__DbgSetAllocFail(FALSE,RHeap::ENone,1); |
|
1162 #endif |
|
1163 |
|
1164 |
|
1165 } |
|
1166 |
|
1167 for(char text=0x3A;text<=0x40;text++) |
|
1168 { |
|
1169 |
|
1170 if(!ispunct(text)) |
|
1171 failures++; |
|
1172 |
|
1173 } |
|
1174 |
|
1175 for(char text=0x5B;text<=0x60;text++) |
|
1176 { |
|
1177 |
|
1178 if(!ispunct(text)) |
|
1179 failures++; |
|
1180 |
|
1181 } |
|
1182 |
|
1183 for(char text=0x7B;text<=0x7E;text++) |
|
1184 { |
|
1185 |
|
1186 |
|
1187 if(!ispunct(text)) |
|
1188 failures++; |
|
1189 |
|
1190 } |
|
1191 |
|
1192 /* |
|
1193 |
|
1194 if(failures) |
|
1195 return KErrGeneral; |
|
1196 return KErrNone; |
|
1197 */ |
|
1198 //#if STDCPP_OOM |
|
1199 //failures++; |
|
1200 // #endif |
|
1201 } |
|
1202 catch(bad_alloc&) |
|
1203 { |
|
1204 //do nothing |
|
1205 } |
|
1206 catch(...) |
|
1207 { |
|
1208 failures++; |
|
1209 |
|
1210 } |
|
1211 |
|
1212 if(failures ) |
|
1213 return KErrGeneral; |
|
1214 return KErrNone; |
|
1215 } |
|
1216 TInt Ctstl_2::Isspace( CStifItemParser& aItem ) |
|
1217 |
|
1218 { |
|
1219 |
|
1220 int failures =0; |
|
1221 |
|
1222 try{ |
|
1223 |
|
1224 |
|
1225 for(char text=0x09;text<=0x0D;text++) |
|
1226 { |
|
1227 #if STDCPP_OOM |
|
1228 User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1); |
|
1229 #endif |
|
1230 if(!isspace(text)) |
|
1231 failures++; |
|
1232 #if STDCPP_OOM |
|
1233 User::__DbgSetAllocFail(FALSE,RHeap::ENone,1); |
|
1234 #endif |
|
1235 |
|
1236 |
|
1237 } |
|
1238 |
|
1239 if(!isspace(0x20)) |
|
1240 failures++; |
|
1241 |
|
1242 |
|
1243 /* |
|
1244 |
|
1245 |
|
1246 if(failures) |
|
1247 return KErrGeneral; |
|
1248 return KErrNone; |
|
1249 */ |
|
1250 //#if STDCPP_OOM |
|
1251 //failures++; |
|
1252 // #endif |
|
1253 |
|
1254 |
|
1255 } |
|
1256 catch(bad_alloc&) |
|
1257 { |
|
1258 //do nothing |
|
1259 } |
|
1260 catch(...) |
|
1261 { |
|
1262 failures++; |
|
1263 |
|
1264 } |
|
1265 |
|
1266 if(failures ) |
|
1267 return KErrGeneral; |
|
1268 return KErrNone; |
|
1269 } |
|
1270 |
|
1271 TInt Ctstl_2::Isxdigit( CStifItemParser& aItem ) |
|
1272 |
|
1273 { |
|
1274 |
|
1275 int failures =0; |
|
1276 try{ |
|
1277 for(char text=0x30;text<=0x39;text++) |
|
1278 { |
|
1279 |
|
1280 #if STDCPP_OOM |
|
1281 User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1); |
|
1282 #endif |
|
1283 if(!isxdigit(text)) |
|
1284 failures++; |
|
1285 #if STDCPP_OOM |
|
1286 User::__DbgSetAllocFail(FALSE,RHeap::ENone,1); |
|
1287 #endif |
|
1288 |
|
1289 |
|
1290 } |
|
1291 |
|
1292 |
|
1293 for(char text=0x41;text<=0x46;text++) |
|
1294 { |
|
1295 |
|
1296 |
|
1297 if(!isxdigit(text)) |
|
1298 failures++; |
|
1299 |
|
1300 } |
|
1301 |
|
1302 |
|
1303 for(char text=0x61;text<=0x66;text++) |
|
1304 { |
|
1305 |
|
1306 |
|
1307 if(!isxdigit(text)) |
|
1308 failures++; |
|
1309 |
|
1310 } |
|
1311 |
|
1312 |
|
1313 |
|
1314 /* |
|
1315 |
|
1316 if(failures) |
|
1317 return KErrGeneral; |
|
1318 return KErrNone;*/ |
|
1319 //#if STDCPP_OOM |
|
1320 //failures++; |
|
1321 // #endif |
|
1322 |
|
1323 |
|
1324 |
|
1325 } |
|
1326 |
|
1327 catch(bad_alloc&) |
|
1328 { |
|
1329 //do nothing |
|
1330 } |
|
1331 catch(...) |
|
1332 { |
|
1333 failures++; |
|
1334 |
|
1335 } |
|
1336 |
|
1337 if(failures ) |
|
1338 return KErrGeneral; |
|
1339 return KErrNone; |
|
1340 } |
|
1341 |
|
1342 |
|
1343 TInt Ctstl_2::Fill( CStifItemParser& aItem ) |
|
1344 |
|
1345 { |
|
1346 |
|
1347 int failures =0; |
|
1348 |
|
1349 try |
|
1350 { |
|
1351 |
|
1352 vector<int> myvector (8,10); // myvector: 10 10 10 10 10 10 10 10 |
|
1353 vector<int>::iterator it ; |
|
1354 // cout<<""; |
|
1355 #if STDCPP_OOM |
|
1356 User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1); |
|
1357 #endif |
|
1358 fill_n(myvector.begin(),4,20); // myvector: 20 20 20 20 10 10 10 10 |
|
1359 #if STDCPP_OOM |
|
1360 User::__DbgSetAllocFail(FALSE,RHeap::ENone,1); |
|
1361 #endif |
|
1362 |
|
1363 for( it = myvector.begin();it!=myvector.begin()+4;++it) |
|
1364 { |
|
1365 |
|
1366 if(*it!=20) |
|
1367 failures++; |
|
1368 |
|
1369 } |
|
1370 |
|
1371 |
|
1372 |
|
1373 |
|
1374 vector<int> myvector1 (8); |
|
1375 // cout<<""; |
|
1376 #if STDCPP_OOM |
|
1377 User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1); |
|
1378 #endif // myvector: 0 0 0 0 0 0 0 0 |
|
1379 fill (myvector1.begin(),myvector1.begin()+4,5); |
|
1380 #if STDCPP_OOM |
|
1381 User::__DbgSetAllocFail(FALSE,RHeap::ENone,1); |
|
1382 #endif |
|
1383 |
|
1384 |
|
1385 for (vector<int>::iterator it=myvector1.begin(); it!=myvector1.begin()+3; ++it) |
|
1386 { |
|
1387 |
|
1388 if(*it!=5) |
|
1389 failures++; |
|
1390 |
|
1391 } |
|
1392 |
|
1393 //#if STDCPP_OOM |
|
1394 //failures++; |
|
1395 // #endif |
|
1396 |
|
1397 } |
|
1398 |
|
1399 catch(bad_alloc&) |
|
1400 { |
|
1401 //do nothing |
|
1402 } |
|
1403 catch(...) |
|
1404 { |
|
1405 failures++; |
|
1406 |
|
1407 } |
|
1408 |
|
1409 if(failures ) |
|
1410 return KErrGeneral; |
|
1411 return KErrNone; |
|
1412 } |
|
1413 |
|
1414 |
|
1415 |
|
1416 |
|
1417 |
|
1418 static int UniqueNumber() |
|
1419 { |
|
1420 |
|
1421 static int current; |
|
1422 return current++; |
|
1423 } |
|
1424 |
|
1425 |
|
1426 TInt Ctstl_2::Generate( CStifItemParser& aItem ) |
|
1427 |
|
1428 { |
|
1429 int failures = 0; |
|
1430 |
|
1431 try{ |
|
1432 vector<int> myvector (8); |
|
1433 vector<int>::iterator it; |
|
1434 int output[8]; |
|
1435 // cout<<""; |
|
1436 #if STDCPP_OOM |
|
1437 User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1); |
|
1438 #endif |
|
1439 generate(myvector.begin(), myvector.end(), UniqueNumber); |
|
1440 #if STDCPP_OOM |
|
1441 User::__DbgSetAllocFail(FALSE,RHeap::ENone,1); |
|
1442 #endif |
|
1443 |
|
1444 for (it=myvector.begin(); it!=myvector.end(); ++it) |
|
1445 |
|
1446 { |
|
1447 static int i; |
|
1448 output[i] = *it; |
|
1449 i++; |
|
1450 |
|
1451 |
|
1452 } |
|
1453 |
|
1454 |
|
1455 for(int i=0;i<=7;i++) |
|
1456 { |
|
1457 if(!output[i] == i) |
|
1458 failures++; |
|
1459 } |
|
1460 // cout<<""; |
|
1461 #if STDCPP_OOM |
|
1462 User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1); |
|
1463 #endif |
|
1464 generate_n(myvector.begin()+5,3,UniqueNumber); |
|
1465 #if STDCPP_OOM |
|
1466 User::__DbgSetAllocFail(FALSE,RHeap::ENone,1); |
|
1467 #endif |
|
1468 |
|
1469 |
|
1470 for(int i=5;i<=7;i++) |
|
1471 { |
|
1472 if(!output[0] == 0) |
|
1473 if(!output[1]==0) |
|
1474 if(!output[2]==0) |
|
1475 if(!output[3]==0) |
|
1476 if(!output[4]==0) |
|
1477 if(!output[i] == i) |
|
1478 failures++; |
|
1479 } |
|
1480 |
|
1481 |
|
1482 |
|
1483 /* |
|
1484 if(!failures) |
|
1485 return KErrNone; |
|
1486 return KErrGeneral; |
|
1487 */ |
|
1488 //#if STDCPP_OOM |
|
1489 //failures++; |
|
1490 // #endif |
|
1491 |
|
1492 } |
|
1493 |
|
1494 |
|
1495 catch(bad_alloc&) |
|
1496 { |
|
1497 //do nothing |
|
1498 } |
|
1499 catch(...) |
|
1500 { |
|
1501 failures++; |
|
1502 |
|
1503 } |
|
1504 |
|
1505 if(failures ) |
|
1506 return KErrGeneral; |
|
1507 return KErrNone; |
|
1508 } |
|
1509 |
|
1510 |
|
1511 |
|
1512 |
|
1513 bool mypredicate1 (int i, int j) { |
|
1514 return (i==j); |
|
1515 } |
|
1516 |
|
1517 |
|
1518 |
|
1519 TInt Ctstl_2::Search( CStifItemParser& aItem ) |
|
1520 |
|
1521 { |
|
1522 int failures=0; |
|
1523 try{ |
|
1524 |
|
1525 vector<int> myvector; |
|
1526 vector<int>::iterator it; |
|
1527 |
|
1528 // set some values: myvector: 10 20 30 40 50 60 70 80 90 |
|
1529 for (int i=1; i<10; i++) |
|
1530 myvector.push_back(i*10); |
|
1531 |
|
1532 |
|
1533 // using default comparison: |
|
1534 int match1[] = {40,50,60,70}; |
|
1535 // cout<<""; |
|
1536 #if STDCPP_OOM |
|
1537 User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1); |
|
1538 #endif |
|
1539 it = search (myvector.begin(), myvector.end(), match1, match1+4); |
|
1540 |
|
1541 #if STDCPP_OOM |
|
1542 User::__DbgSetAllocFail(FALSE,RHeap::ENone,1); |
|
1543 #endif |
|
1544 if(int(it-myvector.begin())!=3) |
|
1545 |
|
1546 failures++; |
|
1547 |
|
1548 |
|
1549 // using predicate comparison: |
|
1550 int match2[] = {20,30,50}; |
|
1551 #if STDCPP_OOM |
|
1552 User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1); |
|
1553 #endif |
|
1554 it = search (myvector.begin(), myvector.end(), match2, match2+3, mypredicate1); |
|
1555 |
|
1556 #if STDCPP_OOM |
|
1557 User::__DbgSetAllocFail(FALSE,RHeap::ENone,1); |
|
1558 #endif |
|
1559 |
|
1560 if(int(it-myvector.begin()) == 1) |
|
1561 failures++; |
|
1562 |
|
1563 //#if STDCPP_OOM |
|
1564 //failures++; |
|
1565 // #endif |
|
1566 //return KErrNone; |
|
1567 //return KErrGeneral; |
|
1568 } |
|
1569 |
|
1570 |
|
1571 catch(bad_alloc&) |
|
1572 { |
|
1573 //do nothing |
|
1574 } |
|
1575 catch(...) |
|
1576 { |
|
1577 failures++; |
|
1578 |
|
1579 } |
|
1580 |
|
1581 if(failures ) |
|
1582 return KErrGeneral; |
|
1583 return KErrNone; |
|
1584 } |
|
1585 |
|
1586 |
|
1587 |
|
1588 |
|
1589 TInt Ctstl_2::Search_n(CStifItemParser& aItem ) |
|
1590 |
|
1591 { |
|
1592 |
|
1593 int failures=0; |
|
1594 try{ |
|
1595 int myints[]={10,20,30,30,20,10,10,20}; |
|
1596 vector<int> myvector (myints,myints+8); |
|
1597 |
|
1598 vector<int>::iterator it; |
|
1599 // cout<<""; |
|
1600 #if STDCPP_OOM |
|
1601 User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1); |
|
1602 #endif |
|
1603 // using default comparison: |
|
1604 it = search_n (myvector.begin(), myvector.end(), 2, 30); |
|
1605 |
|
1606 #if STDCPP_OOM |
|
1607 User::__DbgSetAllocFail(FALSE,RHeap::ENone,1); |
|
1608 #endif |
|
1609 |
|
1610 |
|
1611 /* |
|
1612 if(int(it-myvector.begin())==2) |
|
1613 return KErrNone; |
|
1614 return KErrGeneral; |
|
1615 */ |
|
1616 |
|
1617 if(int(it-myvector.begin())!=2) |
|
1618 failures++; |
|
1619 |
|
1620 //#if STDCPP_OOM |
|
1621 //failures++; |
|
1622 // #endif |
|
1623 } |
|
1624 |
|
1625 catch(bad_alloc&) |
|
1626 { |
|
1627 //do nothing |
|
1628 } |
|
1629 catch(...) |
|
1630 { |
|
1631 failures++; |
|
1632 |
|
1633 } |
|
1634 |
|
1635 if(failures ) |
|
1636 return KErrGeneral; |
|
1637 return KErrNone; |
|
1638 } |
|
1639 //code to be verified |
|
1640 //-------------------------- |
|
1641 |
|
1642 TInt Ctstl_2::Times(CStifItemParser& aItem) |
|
1643 { |
|
1644 int failures=0; |
|
1645 |
|
1646 //__UHEAP_MARK; |
|
1647 try |
|
1648 { |
|
1649 |
|
1650 |
|
1651 int input1 [4] = { -10, 20, 30, 40 }; |
|
1652 int input2 [4] = { 40, 30, 20, -10 }; |
|
1653 int output [4]; |
|
1654 #if STDCPP_OOM |
|
1655 User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1); |
|
1656 #endif |
|
1657 transform((int*)input1, (int*)input1 + 4, (int*)input2, (int*)output, multiplies<int>()); |
|
1658 #if STDCPP_OOM |
|
1659 User::__DbgSetAllocFail(FALSE,RHeap::ENone,1); |
|
1660 #endif |
|
1661 if( output[1] != 600) |
|
1662 failures++; |
|
1663 if( output[2] != 600 ) |
|
1664 failures++; |
|
1665 |
|
1666 if( output[3] != -400) |
|
1667 failures++; |
|
1668 |
|
1669 |
|
1670 |
|
1671 |
|
1672 //__UHEAP_MARKEND; |
|
1673 } |
|
1674 |
|
1675 catch(bad_alloc&) |
|
1676 { |
|
1677 //do nothing |
|
1678 } |
|
1679 catch(...) |
|
1680 { |
|
1681 failures++; |
|
1682 |
|
1683 } |
|
1684 |
|
1685 if(failures ) |
|
1686 return KErrGeneral; |
|
1687 return KErrNone; |
|
1688 } |
|
1689 |
|
1690 TInt Ctstl_2::Unique(CStifItemParser& aItem) |
|
1691 { |
|
1692 |
|
1693 int failures=0; |
|
1694 //__UHEAP_MARK; |
|
1695 try{ |
|
1696 int myints[] = {10,20,20,20,30,30,20,20,10}; // 10 20 20 20 30 30 20 20 10 |
|
1697 vector<int> myvector (myints,myints+9); |
|
1698 vector<int>::iterator it; |
|
1699 int output[5]; // cout<<""; |
|
1700 #if STDCPP_OOM |
|
1701 User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1); |
|
1702 #endif |
|
1703 |
|
1704 // using default comparison: |
|
1705 it = unique (myvector.begin(), myvector.end()); // 10 20 30 20 10 30 20 20 10 |
|
1706 // ^ |
|
1707 #if STDCPP_OOM |
|
1708 User::__DbgSetAllocFail(FALSE,RHeap::ENone,1); |
|
1709 #endif |
|
1710 myvector.resize( it - myvector.begin() ); // 10 20 30 20 10 |
|
1711 |
|
1712 |
|
1713 // print out content: |
|
1714 for (it=myvector.begin(); it!=myvector.end(); ++it) |
|
1715 |
|
1716 { |
|
1717 |
|
1718 static int i; |
|
1719 output[i] = *it; |
|
1720 i++; |
|
1721 |
|
1722 } |
|
1723 |
|
1724 |
|
1725 /* |
|
1726 |
|
1727 if(output[0]== 10) |
|
1728 if(output[1]== 20) |
|
1729 if(output[2]== 30) |
|
1730 if(output[3]== 20) |
|
1731 if(output[4]== 10) |
|
1732 |
|
1733 return KErrNone; |
|
1734 return KErrGeneral;*/ |
|
1735 // __UHEAP_MARKEND; |
|
1736 |
|
1737 if(output[0]!=10) |
|
1738 failures++; |
|
1739 |
|
1740 if(output[1]!=20) |
|
1741 failures++; |
|
1742 |
|
1743 if(output[2]!=30) |
|
1744 failures++; |
|
1745 if(output[3]!=20) |
|
1746 failures++; |
|
1747 if(output[4]!=10) |
|
1748 failures++; |
|
1749 |
|
1750 |
|
1751 |
|
1752 |
|
1753 //#if STDCPP_OOM |
|
1754 //failures++; |
|
1755 // #endif |
|
1756 |
|
1757 } |
|
1758 |
|
1759 catch(bad_alloc&) |
|
1760 { |
|
1761 //do nothing |
|
1762 } |
|
1763 catch(...) |
|
1764 { |
|
1765 failures++; |
|
1766 |
|
1767 } |
|
1768 |
|
1769 if(failures ) |
|
1770 return KErrGeneral; |
|
1771 return KErrNone; |
|
1772 } |
|
1773 |
|
1774 TInt Ctstl_2::Uniquecopy(CStifItemParser& aItem) |
|
1775 { |
|
1776 int failures=0; |
|
1777 |
|
1778 try{ |
|
1779 //__UHEAP_MARK; |
|
1780 int myints[] = {10,20,20,20,30,30,20,20,10}; |
|
1781 vector<int> myvector (9); // 0 0 0 0 0 0 0 0 0 |
|
1782 vector<int>::iterator it; |
|
1783 int output[9]; // cout<<""; |
|
1784 #if STDCPP_OOM |
|
1785 User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1); |
|
1786 #endif |
|
1787 // using default comparison: |
|
1788 it=unique_copy(myints,myints+9,myvector.begin()); // 10 20 30 20 10 0 0 0 0 |
|
1789 #if STDCPP_OOM |
|
1790 User::__DbgSetAllocFail(FALSE,RHeap::ENone,1); |
|
1791 #endif // ^ |
|
1792 for (it=myvector.begin(); it!=myvector.end(); ++it) |
|
1793 { |
|
1794 static int i; |
|
1795 output[i] = *it; |
|
1796 i++; |
|
1797 } |
|
1798 // 10 20 30 20 30 0 0 0 0 |
|
1799 /* // ^ |
|
1800 if(output[0]==10) |
|
1801 if(output[1]==20) |
|
1802 if(output[2]==30) |
|
1803 if(output[3]==20) |
|
1804 if(output[4]==10) |
|
1805 if(output[5]==0) |
|
1806 if(output[6]==0) |
|
1807 if(output[7]==0) |
|
1808 if(output[8]==0) |
|
1809 return KErrNone; |
|
1810 return KErrGeneral; |
|
1811 */ |
|
1812 if(output[0]!=10) |
|
1813 failures++; |
|
1814 |
|
1815 if(output[1]!=20) |
|
1816 failures++; |
|
1817 |
|
1818 if(output[2]!=30) |
|
1819 failures++; |
|
1820 if(output[3]!=20) |
|
1821 failures++; |
|
1822 if(output[4]!=10) |
|
1823 failures++; |
|
1824 if(output[5]!=0) |
|
1825 failures++; |
|
1826 if(output[6]!=0) |
|
1827 failures++; |
|
1828 if(output[7]!=0) |
|
1829 failures++; |
|
1830 if(output[8]!=0) |
|
1831 failures++; |
|
1832 |
|
1833 |
|
1834 //#if STDCPP_OOM |
|
1835 //failures++; |
|
1836 // #endif |
|
1837 |
|
1838 // __UHEAP_MARKEND; |
|
1839 |
|
1840 } |
|
1841 |
|
1842 catch(bad_alloc&) |
|
1843 { |
|
1844 //do nothing |
|
1845 } |
|
1846 catch(...) |
|
1847 { |
|
1848 failures++; |
|
1849 |
|
1850 } |
|
1851 |
|
1852 if(failures ) |
|
1853 return KErrGeneral; |
|
1854 return KErrNone; |
|
1855 } |
|
1856 |
|
1857 |
|
1858 TInt Ctstl_2::Partialsort(CStifItemParser& aItem) |
|
1859 { |
|
1860 int failures=0; |
|
1861 try |
|
1862 { |
|
1863 |
|
1864 //__UHEAP_MARK; |
|
1865 int myints[] = {9,8,7,6,5,4,3,2,1}; |
|
1866 vector<int> myvector (myints, myints+9); |
|
1867 vector<int>::iterator it; |
|
1868 int output[9]; // cout<<""; |
|
1869 #if STDCPP_OOM |
|
1870 User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1); |
|
1871 #endif |
|
1872 // using default comparison (operator <): |
|
1873 partial_sort (myvector.begin(), myvector.begin()+5, myvector.end()); |
|
1874 |
|
1875 #if STDCPP_OOM |
|
1876 User::__DbgSetAllocFail(FALSE,RHeap::ENone,1); |
|
1877 #endif |
|
1878 for (it=myvector.begin(); it!=myvector.end(); ++it) |
|
1879 { |
|
1880 static int i; |
|
1881 output[i] = *it; |
|
1882 i++; |
|
1883 } |
|
1884 |
|
1885 /* |
|
1886 if(output[0]==1) |
|
1887 if(output[1]==2) |
|
1888 if(output[2]==3) |
|
1889 if(output[3]==4) |
|
1890 if(output[5]==9) |
|
1891 if(output[6]==8) |
|
1892 if(output[7]==7) |
|
1893 if(output[8]==6) |
|
1894 if(output[4]==5) |
|
1895 |
|
1896 return KErrNone; |
|
1897 return KErrGeneral; |
|
1898 */ |
|
1899 |
|
1900 // __UHEAP_MARKEND; |
|
1901 if(output[0]!=1) |
|
1902 failures++; |
|
1903 |
|
1904 if(output[1]!=2) |
|
1905 failures++; |
|
1906 |
|
1907 if(output[2]!=3) |
|
1908 failures++; |
|
1909 if(output[3]!=4) |
|
1910 failures++; |
|
1911 if(output[4]!=5) |
|
1912 failures++; |
|
1913 if(output[5]!=9) |
|
1914 failures++; |
|
1915 if(output[6]!=8) |
|
1916 failures++; |
|
1917 if(output[7]!=7) |
|
1918 failures++; |
|
1919 if(output[8]!=6) |
|
1920 failures++; |
|
1921 |
|
1922 |
|
1923 //#if STDCPP_OOM |
|
1924 //failures++; |
|
1925 // #endif |
|
1926 } |
|
1927 |
|
1928 catch(bad_alloc&) |
|
1929 { |
|
1930 //do nothing |
|
1931 } |
|
1932 catch(...) |
|
1933 { |
|
1934 failures++; |
|
1935 |
|
1936 } |
|
1937 |
|
1938 if(failures ) |
|
1939 return KErrGeneral; |
|
1940 return KErrNone; |
|
1941 } |
|
1942 |
|
1943 |
|
1944 TInt Ctstl_2::Partialsortcopy(CStifItemParser& aItem) |
|
1945 { |
|
1946 int failures=0; |
|
1947 try{ |
|
1948 //__UHEAP_MARK; |
|
1949 int myints[] = {9,8,7,6,5,4,3,2,1}; |
|
1950 vector<int> myvector (5); |
|
1951 vector<int>::iterator it; |
|
1952 int output[5]; // cout<<""; |
|
1953 #if STDCPP_OOM |
|
1954 User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1); |
|
1955 #endif |
|
1956 // using default comparison (operator <): |
|
1957 partial_sort_copy (myints, myints+9, myvector.begin(), myvector.end()); |
|
1958 |
|
1959 |
|
1960 #if STDCPP_OOM |
|
1961 User::__DbgSetAllocFail(FALSE,RHeap::ENone,1); |
|
1962 #endif |
|
1963 |
|
1964 |
|
1965 for (it=myvector.begin(); it!=myvector.end(); ++it) |
|
1966 { |
|
1967 static int i; |
|
1968 output[i] = *it; |
|
1969 i++; |
|
1970 } |
|
1971 |
|
1972 /* |
|
1973 if(output[0]==1) |
|
1974 if(output[1]==2) |
|
1975 if(output[2]==3) |
|
1976 if(output[3]==4) |
|
1977 if(output[4]==5) |
|
1978 |
|
1979 return KErrNone; |
|
1980 return KErrGeneral;*/ |
|
1981 |
|
1982 //__UHEAP_MARKEND; |
|
1983 |
|
1984 if(output[0]!=1) |
|
1985 failures++; |
|
1986 if(output[1]!=2) |
|
1987 failures++; |
|
1988 if(output[2]!=3) |
|
1989 failures++; |
|
1990 if(output[3]!=4) |
|
1991 failures++; |
|
1992 if(output[4]!=5) |
|
1993 failures++; |
|
1994 //#if STDCPP_OOM |
|
1995 //failures++; |
|
1996 // #endif |
|
1997 |
|
1998 } |
|
1999 |
|
2000 catch(bad_alloc&) |
|
2001 { |
|
2002 //do nothing |
|
2003 } |
|
2004 catch(...) |
|
2005 { |
|
2006 failures++; |
|
2007 |
|
2008 } |
|
2009 |
|
2010 if(failures ) |
|
2011 return KErrGeneral; |
|
2012 return KErrNone; |
|
2013 } |
|
2014 |
|
2015 |
|
2016 |
|
2017 bool IsOdd(int i) |
|
2018 { |
|
2019 return (i%2)==1; |
|
2020 } |
|
2021 |
|
2022 |
|
2023 TInt Ctstl_2::Partition(CStifItemParser& aItem) |
|
2024 { |
|
2025 int failures=0; |
|
2026 try{ |
|
2027 //__UHEAP_MARK; |
|
2028 //int myints[] = {9,8,7,6,5,4,3,2,1}; |
|
2029 vector<int> myvector; |
|
2030 vector<int>::iterator it, bound; |
|
2031 int Odd[5]; |
|
2032 int Even[4]; |
|
2033 // set some values: |
|
2034 for (int i=1; i<10; ++i) myvector.push_back(i); // 1 2 3 4 5 6 7 8 9 |
|
2035 // cout<<""; |
|
2036 #if STDCPP_OOM |
|
2037 User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1); |
|
2038 #endif |
|
2039 bound = partition (myvector.begin(), myvector.end(), IsOdd); |
|
2040 #if STDCPP_OOM |
|
2041 User::__DbgSetAllocFail(FALSE,RHeap::ENone,1); |
|
2042 #endif |
|
2043 // print out content: |
|
2044 for (it=myvector.begin(); it!=bound; ++it) |
|
2045 |
|
2046 { |
|
2047 static int i; |
|
2048 Odd[i] = *it; |
|
2049 i++; |
|
2050 } |
|
2051 |
|
2052 |
|
2053 for (it=bound; it!=myvector.end(); ++it) |
|
2054 |
|
2055 { |
|
2056 static int i; |
|
2057 Even[i]=*it; |
|
2058 i++; |
|
2059 } |
|
2060 |
|
2061 /* |
|
2062 if(Odd[0] ==1) |
|
2063 if(Odd[1] ==9) |
|
2064 if(Odd[2] ==3) |
|
2065 if(Odd[3] ==7) |
|
2066 if(Odd[4] ==5) |
|
2067 if(Even[0]==6) |
|
2068 if(Even[1]==4) |
|
2069 if(Even[2]==8) |
|
2070 if(Even[3]==2) |
|
2071 |
|
2072 return KErrNone; |
|
2073 return KErrGeneral;*/ |
|
2074 if(Odd[0] !=1) |
|
2075 failures++; |
|
2076 |
|
2077 if(Odd[1] !=9) |
|
2078 failures++; |
|
2079 if(Odd[2] !=3) |
|
2080 failures++; |
|
2081 if(Odd[3] !=7) |
|
2082 failures++; |
|
2083 if(Odd[4] !=5) |
|
2084 failures++; |
|
2085 if(Even[0]!=6) |
|
2086 failures++; |
|
2087 if(Even[1]!=4) |
|
2088 failures++; |
|
2089 if(Even[2]!=8) |
|
2090 failures++; |
|
2091 if(Even[3]!=2) |
|
2092 failures++; |
|
2093 |
|
2094 //#if STDCPP_OOM |
|
2095 //failures++; |
|
2096 // #endif |
|
2097 // __UHEAP_MARKEND; |
|
2098 |
|
2099 } |
|
2100 |
|
2101 catch(bad_alloc&) |
|
2102 { |
|
2103 //do nothing |
|
2104 } |
|
2105 catch(...) |
|
2106 { |
|
2107 failures++; |
|
2108 |
|
2109 } |
|
2110 |
|
2111 if(failures ) |
|
2112 return KErrGeneral; |
|
2113 return KErrNone; |
|
2114 } |
|
2115 |
|
2116 |
|
2117 |
|
2118 TInt Ctstl_2::Stablepartition(CStifItemParser& aItem) |
|
2119 { |
|
2120 int failures=0; |
|
2121 try{ |
|
2122 //__UHEAP_MARK; |
|
2123 //int myints[] = {9,8,7,6,5,4,3,2,1}; |
|
2124 vector<int> myvector; |
|
2125 vector<int>::iterator it, bound; |
|
2126 int Odd[5]; |
|
2127 int Even[4]; |
|
2128 // set some values: |
|
2129 for (int i=1; i<10; ++i) myvector.push_back(i); // 1 2 3 4 5 6 7 8 9 |
|
2130 // cout<<""; |
|
2131 #if STDCPP_OOM |
|
2132 User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1); |
|
2133 #endif |
|
2134 bound = stable_partition (myvector.begin(), myvector.end(), IsOdd); |
|
2135 #if STDCPP_OOM |
|
2136 User::__DbgSetAllocFail(FALSE,RHeap::ENone,1); |
|
2137 #endif |
|
2138 // print out content: |
|
2139 for (it=myvector.begin(); it!=bound; ++it) |
|
2140 |
|
2141 { |
|
2142 static int i; |
|
2143 Odd[i] = *it; |
|
2144 i++; |
|
2145 } |
|
2146 |
|
2147 |
|
2148 for (it=bound; it!=myvector.end(); ++it) |
|
2149 |
|
2150 { |
|
2151 static int i; |
|
2152 Even[i]=*it; |
|
2153 i++; |
|
2154 } |
|
2155 |
|
2156 /* |
|
2157 if(Odd[0] ==1) |
|
2158 if(Odd[1] ==3) |
|
2159 if(Odd[2] ==5) |
|
2160 if(Odd[3] ==7) |
|
2161 if(Odd[4] ==9) |
|
2162 if(Even[0]==2) |
|
2163 if(Even[1]==4) |
|
2164 if(Even[2]==6) |
|
2165 if(Even[3]==8) |
|
2166 |
|
2167 return KErrNone; |
|
2168 return KErrGeneral;*/ |
|
2169 |
|
2170 //__UHEAP_MARKEND; |
|
2171 |
|
2172 if(Odd[0] !=1) |
|
2173 failures++; |
|
2174 |
|
2175 if(Odd[1] !=3) |
|
2176 failures++; |
|
2177 if(Odd[2] !=5) |
|
2178 failures++; |
|
2179 if(Odd[3] !=7) |
|
2180 failures++; |
|
2181 if(Odd[4] !=9) |
|
2182 failures++; |
|
2183 if(Even[0]!=2) |
|
2184 failures++; |
|
2185 if(Even[1]!=4) |
|
2186 failures++; |
|
2187 if(Even[2]!=6) |
|
2188 failures++; |
|
2189 if(Even[3]!=8) |
|
2190 failures++; |
|
2191 |
|
2192 //#if STDCPP_OOM |
|
2193 //failures++; |
|
2194 // #endif |
|
2195 } |
|
2196 catch(bad_alloc&) |
|
2197 { |
|
2198 //do nothing |
|
2199 } |
|
2200 catch(...) |
|
2201 { |
|
2202 failures++; |
|
2203 |
|
2204 } |
|
2205 |
|
2206 if(failures ) |
|
2207 return KErrGeneral; |
|
2208 return KErrNone; |
|
2209 } |
|
2210 |
|
2211 |
|
2212 TInt Ctstl_2::Setdifference(CStifItemParser& aItem) |
|
2213 { |
|
2214 int failures=0; |
|
2215 try{ |
|
2216 |
|
2217 //__UHEAP_MARK; |
|
2218 int first[] = {5,10,15,20,25}; |
|
2219 |
|
2220 int second[] = {50,40,30,20,10}; |
|
2221 |
|
2222 int output[10]; |
|
2223 vector<int> v(10); // 0 0 0 0 0 0 0 0 0 0 |
|
2224 vector<int>::iterator it; |
|
2225 |
|
2226 sort (first,first+5); // 5 10 15 20 25 |
|
2227 sort (second,second+5); // 10 20 30 40 50 |
|
2228 // cout<<""; |
|
2229 #if STDCPP_OOM |
|
2230 User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1); |
|
2231 #endif |
|
2232 it=set_difference (first, first+5, second, second+5, v.begin()); |
|
2233 // 5 15 25 0 0 0 0 0 0 0 |
|
2234 #if STDCPP_OOM |
|
2235 User::__DbgSetAllocFail(FALSE,RHeap::ENone,1); |
|
2236 #endif |
|
2237 for(it=v.begin();it!=v.end();++it) |
|
2238 { |
|
2239 |
|
2240 static int i; |
|
2241 output[i] = *it; |
|
2242 i++; |
|
2243 |
|
2244 } |
|
2245 |
|
2246 /*if(output[0]==5) |
|
2247 if(output[1]==15) |
|
2248 if(output[2]==25) |
|
2249 return KErrNone; |
|
2250 return KErrGeneral;*/ |
|
2251 if(output[0]!=5) |
|
2252 failures++; |
|
2253 if(output[1]!=15) |
|
2254 failures++; |
|
2255 if(output[2]!=25) |
|
2256 failures++; |
|
2257 |
|
2258 //#if STDCPP_OOM |
|
2259 //failures++; |
|
2260 // #endif |
|
2261 |
|
2262 // __UHEAP_MARKEND; |
|
2263 |
|
2264 } |
|
2265 |
|
2266 catch(bad_alloc&) |
|
2267 { |
|
2268 //do nothing |
|
2269 } |
|
2270 catch(...) |
|
2271 { |
|
2272 failures++; |
|
2273 |
|
2274 } |
|
2275 |
|
2276 if(failures ) |
|
2277 return KErrGeneral; |
|
2278 return KErrNone; |
|
2279 } |
|
2280 |
|
2281 |
|
2282 |
|
2283 TInt Ctstl_2::Setintersection(CStifItemParser& aItem) |
|
2284 { |
|
2285 int failures=0; |
|
2286 try{ |
|
2287 //__UHEAP_MARK; |
|
2288 |
|
2289 int first[] = {5,10,15,20,25}; |
|
2290 int second[] = {50,40,30,20,10}; |
|
2291 int output[10]; |
|
2292 vector<int> v(10); // 0 0 0 0 0 0 0 0 0 0 |
|
2293 vector<int>::iterator it; |
|
2294 |
|
2295 sort (first,first+5); // 5 10 15 20 25 |
|
2296 sort (second,second+5); // 10 20 30 40 50 |
|
2297 // cout<<""; |
|
2298 #if STDCPP_OOM |
|
2299 User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1); |
|
2300 #endif |
|
2301 it=set_intersection (first, first+5, second, second+5, v.begin()); |
|
2302 #if STDCPP_OOM |
|
2303 User::__DbgSetAllocFail(FALSE,RHeap::ENone,1); |
|
2304 #endif // 10 20 0 0 0 0 0 0 0 0 |
|
2305 |
|
2306 for(it=v.begin();it!=v.end();++it) |
|
2307 { |
|
2308 |
|
2309 static int i; |
|
2310 output[i] = *it; |
|
2311 i++; |
|
2312 |
|
2313 } |
|
2314 /* |
|
2315 if(output[0]==10) |
|
2316 if(output[1]==20) |
|
2317 if(output[2]==0) |
|
2318 return KErrNone; |
|
2319 return KErrGeneral; |
|
2320 |
|
2321 */ |
|
2322 |
|
2323 if(output[0]!=10) |
|
2324 failures++; |
|
2325 if(output[1]!=20) |
|
2326 failures++; |
|
2327 if(output[2]!=0) |
|
2328 failures++; |
|
2329 |
|
2330 //#if STDCPP_OOM |
|
2331 //failures++; |
|
2332 // #endif |
|
2333 } |
|
2334 |
|
2335 catch(bad_alloc&) |
|
2336 { |
|
2337 //do nothing |
|
2338 } |
|
2339 catch(...) |
|
2340 { |
|
2341 failures++; |
|
2342 |
|
2343 } |
|
2344 |
|
2345 if(failures ) |
|
2346 return KErrGeneral; |
|
2347 return KErrNone; |
|
2348 } |
|
2349 |
|
2350 |
|
2351 |
|
2352 |
|
2353 TInt Ctstl_2::Setsymdifference(CStifItemParser& aItem) |
|
2354 {int failures=0; |
|
2355 try{ |
|
2356 |
|
2357 //__UHEAP_MARK; |
|
2358 |
|
2359 int first[] = {5,10,15,20,25}; |
|
2360 int second[] = {50,40,30,20,10}; |
|
2361 int output[10]; |
|
2362 vector<int> v(10); // 0 0 0 0 0 0 0 0 0 0 |
|
2363 vector<int>::iterator it; |
|
2364 |
|
2365 sort (first,first+5); // 5 10 15 20 25 |
|
2366 sort (second,second+5); // 10 20 30 40 50 |
|
2367 // cout<<""; |
|
2368 #if STDCPP_OOM |
|
2369 User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1); |
|
2370 #endif |
|
2371 it=set_symmetric_difference(first, first+5, second, second+5, v.begin()); |
|
2372 #if STDCPP_OOM |
|
2373 User::__DbgSetAllocFail(FALSE,RHeap::ENone,1); |
|
2374 #endif |
|
2375 for(it=v.begin();it!=v.end();++it) |
|
2376 { |
|
2377 |
|
2378 static int i; |
|
2379 output[i] = *it; |
|
2380 i++; |
|
2381 |
|
2382 } |
|
2383 |
|
2384 |
|
2385 /* |
|
2386 if(output[0]==5) |
|
2387 if(output[1]==15) |
|
2388 if(output[2]==25) |
|
2389 if(output[3]==30) |
|
2390 if(output[4]==40) |
|
2391 if(output[5]==50) |
|
2392 return KErrNone; |
|
2393 return KErrGeneral; |
|
2394 */// __UHEAP_MARKEND; |
|
2395 |
|
2396 |
|
2397 if(output[0]!=5) |
|
2398 failures++; |
|
2399 if(output[1]!=15) |
|
2400 failures++; |
|
2401 if(output[2]!=25) |
|
2402 failures++; |
|
2403 if(output[3]!=30) |
|
2404 failures++; |
|
2405 if(output[4]!=40) |
|
2406 failures++; |
|
2407 if(output[5]!=50) |
|
2408 failures++; |
|
2409 |
|
2410 //#if STDCPP_OOM |
|
2411 //failures++; |
|
2412 // #endif |
|
2413 } |
|
2414 |
|
2415 catch(bad_alloc&) |
|
2416 { |
|
2417 //do nothing |
|
2418 } |
|
2419 catch(...) |
|
2420 { |
|
2421 failures++; |
|
2422 |
|
2423 } |
|
2424 |
|
2425 if(failures ) |
|
2426 return KErrGeneral; |
|
2427 return KErrNone; |
|
2428 } |
|
2429 |
|
2430 TInt Ctstl_2::Setunion(CStifItemParser& aItem) |
|
2431 { |
|
2432 int failures=0; |
|
2433 |
|
2434 //__UHEAP_MARK; |
|
2435 try{ |
|
2436 int first[] = {5,10,15,20,25}; |
|
2437 int second[] = {50,40,30,20,10}; |
|
2438 int output[10]; |
|
2439 vector<int> v(10); // 0 0 0 0 0 0 0 0 0 0 |
|
2440 vector<int>::iterator it; |
|
2441 |
|
2442 sort (first,first+5); // 5 10 15 20 25 |
|
2443 sort (second,second+5); // 10 20 30 40 50 |
|
2444 // cout<<""; |
|
2445 #if STDCPP_OOM |
|
2446 User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1); |
|
2447 #endif |
|
2448 it=set_union(first, first+5, second, second+5, v.begin()); |
|
2449 #if STDCPP_OOM |
|
2450 User::__DbgSetAllocFail(FALSE,RHeap::ENone,1); |
|
2451 #endif |
|
2452 for(it=v.begin();it!=v.end();++it) |
|
2453 { |
|
2454 |
|
2455 static int i; |
|
2456 output[i] = *it; |
|
2457 i++; |
|
2458 |
|
2459 }/* |
|
2460 if(output[0]==5) |
|
2461 if(output[1]==10) |
|
2462 if(output[2]==15) |
|
2463 if(output[3]==20) |
|
2464 if(output[4]==25) |
|
2465 if(output[5]==30) |
|
2466 if(output[6]==40) |
|
2467 if(output[7]==50) |
|
2468 return KErrNone; |
|
2469 return KErrGeneral;*/ |
|
2470 //__UHEAP_MARKEND; |
|
2471 |
|
2472 if(output[0]!=5) |
|
2473 failures++; |
|
2474 |
|
2475 if(output[1]!=10) |
|
2476 failures++; |
|
2477 |
|
2478 if(output[2]!=15) |
|
2479 failures++; |
|
2480 if(output[3]!=20) |
|
2481 failures++; |
|
2482 if(output[4]!=25) |
|
2483 failures++; |
|
2484 if(output[5]!=30) |
|
2485 failures++; |
|
2486 if(output[6]!=40) |
|
2487 failures++; |
|
2488 if(output[7]!=50) |
|
2489 failures++; |
|
2490 |
|
2491 |
|
2492 //#if STDCPP_OOM |
|
2493 //failures++; |
|
2494 // #endif |
|
2495 } |
|
2496 catch(bad_alloc&) |
|
2497 { |
|
2498 //do nothing |
|
2499 } |
|
2500 catch(...) |
|
2501 { |
|
2502 failures++; |
|
2503 |
|
2504 } |
|
2505 |
|
2506 if(failures ) |
|
2507 return KErrGeneral; |
|
2508 return KErrNone; |
|
2509 } |
|
2510 |
|
2511 |
|
2512 |
|
2513 TInt Ctstl_2::HeapL(CStifItemParser& aItem) |
|
2514 { |
|
2515 |
|
2516 |
|
2517 //__UHEAP_MARK; |
|
2518 |
|
2519 |
|
2520 int failures=0; |
|
2521 try{ |
|
2522 int myints[] = {10,20,30,5,15}; |
|
2523 |
|
2524 vector<int> v(myints,myints+5); |
|
2525 |
|
2526 // vector<int>::iterator it; |
|
2527 // cout<<""; |
|
2528 #if STDCPP_OOM |
|
2529 User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1); |
|
2530 #endif |
|
2531 make_heap(v.begin(),v.end()); //make_heap |
|
2532 |
|
2533 if(v.front()!=30) |
|
2534 failures++; |
|
2535 |
|
2536 pop_heap(v.begin(),v.end()); //pop_heap |
|
2537 v.pop_back(); //pop_back |
|
2538 |
|
2539 |
|
2540 if(v.front()!=20) |
|
2541 failures++; |
|
2542 |
|
2543 v.push_back(99); //push_back |
|
2544 |
|
2545 |
|
2546 push_heap(v.begin(),v.end()); //push heap |
|
2547 |
|
2548 if(v.front()!=99) |
|
2549 failures++; |
|
2550 |
|
2551 |
|
2552 sort_heap(v.begin(),v.end()); //sort_heap |
|
2553 |
|
2554 #if STDCPP_OOM |
|
2555 User::__DbgSetAllocFail(FALSE,RHeap::ENone,1); |
|
2556 #endif |
|
2557 if(v[0]!=5) |
|
2558 failures++; |
|
2559 if(v[1]!=10) |
|
2560 failures++; |
|
2561 if(v[2]!=15) |
|
2562 failures++; |
|
2563 if(v[3]!=20) |
|
2564 failures++; |
|
2565 if(v[4]!=99) |
|
2566 failures++; |
|
2567 |
|
2568 |
|
2569 /* |
|
2570 if(failures) |
|
2571 return KErrGeneral; |
|
2572 return KErrNone; |
|
2573 */ |
|
2574 //#if STDCPP_OOM |
|
2575 //failures++; |
|
2576 // #endif |
|
2577 |
|
2578 //__UHEAP_MARKEND; |
|
2579 |
|
2580 } |
|
2581 |
|
2582 catch(bad_alloc&) |
|
2583 { |
|
2584 //do nothing |
|
2585 } |
|
2586 catch(...) |
|
2587 { |
|
2588 failures++; |
|
2589 |
|
2590 } |
|
2591 |
|
2592 if(failures ) |
|
2593 return KErrGeneral; |
|
2594 return KErrNone; |
|
2595 } |
|
2596 |
|
2597 |
|
2598 TInt Ctstl_2::Swapranges(CStifItemParser& aItem) |
|
2599 { |
|
2600 int failures=0; |
|
2601 // __UHEAP_MARK; |
|
2602 try{ |
|
2603 |
|
2604 vector<int> first (5,10); // first: 10 10 10 10 10 |
|
2605 vector<int> second (5,33); // second: 33 33 33 33 33 |
|
2606 vector<int>::iterator it; |
|
2607 int output[5]; |
|
2608 // cout<<""; |
|
2609 #if STDCPP_OOM |
|
2610 User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1); |
|
2611 #endif |
|
2612 swap_ranges(first.begin()+1, first.end()-1, second.begin()); |
|
2613 #if STDCPP_OOM |
|
2614 User::__DbgSetAllocFail(FALSE,RHeap::ENone,1); |
|
2615 #endif |
|
2616 |
|
2617 |
|
2618 // print out results of swap: |
|
2619 for (it=first.begin(); it!=first.end(); ++it) |
|
2620 |
|
2621 |
|
2622 { |
|
2623 static int i; |
|
2624 output[i] = *it; |
|
2625 i++; |
|
2626 } |
|
2627 |
|
2628 |
|
2629 /* |
|
2630 if(output[0]==10) |
|
2631 if(output[1]==33) |
|
2632 if(output[2]==33) |
|
2633 if(output[3]==33) |
|
2634 if(output[4]==10) |
|
2635 return KErrNone; |
|
2636 return KErrGeneral; |
|
2637 */ |
|
2638 if(output[0]!=10) |
|
2639 failures++; |
|
2640 if(output[1]!=33) |
|
2641 failures++; |
|
2642 if(output[2]!=33) |
|
2643 failures++; |
|
2644 |
|
2645 if(output[3]!=33) |
|
2646 failures++; |
|
2647 if(output[4]!=10) |
|
2648 failures++; |
|
2649 |
|
2650 //#if STDCPP_OOM |
|
2651 //failures++; |
|
2652 // #endif |
|
2653 |
|
2654 //__UHEAP_MARKEND; |
|
2655 |
|
2656 } |
|
2657 |
|
2658 catch(bad_alloc&) |
|
2659 { |
|
2660 //do nothing |
|
2661 } |
|
2662 catch(...) |
|
2663 { |
|
2664 failures++; |
|
2665 |
|
2666 } |
|
2667 |
|
2668 if(failures ) |
|
2669 return KErrGeneral; |
|
2670 return KErrNone; |
|
2671 } |
|
2672 |
|
2673 |
|
2674 TInt Ctstl_2::Partialsums(CStifItemParser& aItem) |
|
2675 { |
|
2676 int failures=0; |
|
2677 //__UHEAP_MARK; |
|
2678 try{ |
|
2679 |
|
2680 vector<int> V1( 10 ), V2( 10 ); |
|
2681 vector<int>::iterator VIter1, VIterend; |
|
2682 |
|
2683 int sum =1; |
|
2684 int i=2 ; |
|
2685 list <int> L1; |
|
2686 // list <int>::iterator LIter1, LIterend; |
|
2687 |
|
2688 int t; |
|
2689 for ( t = 1 ; t <= 10 ; t++ ) |
|
2690 { |
|
2691 L1.push_back( t ); |
|
2692 } |
|
2693 |
|
2694 // cout<<""; |
|
2695 #if STDCPP_OOM |
|
2696 User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1); |
|
2697 #endif |
|
2698 // The first member function for the partial sums of |
|
2699 // elements in a list output to a vector |
|
2700 VIterend = partial_sum ( L1.begin ( ) , L1.end ( ) , |
|
2701 V1.begin ( ) ); |
|
2702 #if STDCPP_OOM |
|
2703 User::__DbgSetAllocFail(FALSE,RHeap::ENone,1); |
|
2704 #endif |
|
2705 for ( VIter1 = V1.begin( ) ; VIter1 != VIterend ; VIter1++ ) |
|
2706 |
|
2707 { |
|
2708 |
|
2709 if(sum!=*VIter1) |
|
2710 failures++; |
|
2711 sum = sum+i; |
|
2712 i++; |
|
2713 |
|
2714 } |
|
2715 |
|
2716 /* |
|
2717 if(failures) |
|
2718 return KErrGeneral; |
|
2719 return KErrNone; |
|
2720 */ |
|
2721 |
|
2722 //#if STDCPP_OOM |
|
2723 //failures++; |
|
2724 // #endif |
|
2725 |
|
2726 //__UHEAP_MARKEND; |
|
2727 |
|
2728 } |
|
2729 |
|
2730 catch(bad_alloc&) |
|
2731 { |
|
2732 //do nothing |
|
2733 } |
|
2734 catch(...) |
|
2735 { |
|
2736 failures++; |
|
2737 |
|
2738 } |
|
2739 |
|
2740 if(failures ) |
|
2741 return KErrGeneral; |
|
2742 return KErrNone; |
|
2743 } |
|
2744 |
|
2745 |
|
2746 TInt Ctstl_2::Unarynegate(CStifItemParser& aItem) |
|
2747 { |
|
2748 int failures=0; |
|
2749 // __UHEAP_MARK; |
|
2750 try{ |
|
2751 vector <int> v1; |
|
2752 |
|
2753 //vector <int>::iterator Iter; |
|
2754 |
|
2755 int i; |
|
2756 for ( i = 0 ; i <= 7 ; i++ ) |
|
2757 { |
|
2758 v1.push_back( 5 * i ); |
|
2759 } |
|
2760 |
|
2761 |
|
2762 |
|
2763 int result2; |
|
2764 int result3; |
|
2765 // Use the negator to count the elements less than or equal to 10 |
|
2766 // cout<<""; |
|
2767 #if STDCPP_OOM |
|
2768 User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1); |
|
2769 #endif |
|
2770 result2 = count_if( v1.begin( ), v1.end( ),unary_negate<binder2nd <greater<int> > >( bind2nd( greater<int>( ),10 ) ) ); |
|
2771 #if STDCPP_OOM |
|
2772 User::__DbgSetAllocFail(FALSE,RHeap::ENone,1); |
|
2773 #endif |
|
2774 result3 = count_if( v1.begin( ), v1.end( ),not1(bind2nd( greater<int>( ), 10) ) ); |
|
2775 |
|
2776 |
|
2777 |
|
2778 /* |
|
2779 if(result2 == 3) |
|
2780 if(result3 == 3) |
|
2781 return KErrNone; |
|
2782 return KErrGeneral; |
|
2783 */ |
|
2784 if(result2 != 3) |
|
2785 failures++; |
|
2786 if(result3 != 3) |
|
2787 failures++; |
|
2788 |
|
2789 |
|
2790 //__UHEAP_MARKEND; |
|
2791 //#if STDCPP_OOM |
|
2792 //failures++; |
|
2793 // #endif |
|
2794 } |
|
2795 |
|
2796 catch(bad_alloc&) |
|
2797 { |
|
2798 //do nothing |
|
2799 } |
|
2800 catch(...) |
|
2801 { |
|
2802 failures++; |
|
2803 |
|
2804 } |
|
2805 |
|
2806 if(failures ) |
|
2807 return KErrGeneral; |
|
2808 return KErrNone; |
|
2809 } |
|
2810 |
|
2811 |
|
2812 TInt Ctstl_2::Not2(CStifItemParser& aItem) |
|
2813 { |
|
2814 int failures=0; |
|
2815 //__UHEAP_MARK; |
|
2816 try{ |
|
2817 vector <int> v1; |
|
2818 vector <int>::iterator Iter1; |
|
2819 int output[7]; |
|
2820 //int i; |
|
2821 v1.push_back( 6262 ); |
|
2822 v1.push_back( 6262 ); |
|
2823 v1.push_back( 18467 ); |
|
2824 v1.push_back( 6334 ); |
|
2825 v1.push_back( 26500 ); |
|
2826 v1.push_back( 19169); |
|
2827 v1.push_back(41); |
|
2828 |
|
2829 |
|
2830 |
|
2831 // cout<<""; |
|
2832 #if STDCPP_OOM |
|
2833 User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1); |
|
2834 #endif |
|
2835 |
|
2836 // To sort in descending order, |
|
2837 // use the binary_negate helper function not2 |
|
2838 sort( v1.begin( ), v1.end( ), not2(less<int>( ) ) ); |
|
2839 |
|
2840 #if STDCPP_OOM |
|
2841 User::__DbgSetAllocFail(FALSE,RHeap::ENone,1); |
|
2842 #endif |
|
2843 |
|
2844 for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ ) |
|
2845 { |
|
2846 static int i; |
|
2847 output[i] = *Iter1; |
|
2848 i++; |
|
2849 } |
|
2850 |
|
2851 /* |
|
2852 if(output[0]==26500) |
|
2853 if(output[1]==19169) |
|
2854 if(output[2]== 18467) |
|
2855 if(output[3]== 6334) |
|
2856 if(output[4]== 6262) |
|
2857 if(output[5]== 6262) |
|
2858 if(output[6]== 41) |
|
2859 |
|
2860 return KErrNone; |
|
2861 return KErrGeneral; |
|
2862 */ |
|
2863 |
|
2864 |
|
2865 if(output[0]!=26500) |
|
2866 failures++; |
|
2867 if(output[1]!=19169) |
|
2868 failures++; |
|
2869 if(output[2]!= 18467) |
|
2870 failures++; |
|
2871 if(output[3]!= 6334) |
|
2872 failures++; |
|
2873 if(output[4]!= 6262) |
|
2874 failures++; |
|
2875 if(output[5]!= 6262) |
|
2876 failures++; |
|
2877 if(output[6]!= 41) |
|
2878 failures++; |
|
2879 |
|
2880 //#if STDCPP_OOM |
|
2881 //failures++; |
|
2882 // #endif |
|
2883 |
|
2884 //__UHEAP_MARKEND; |
|
2885 |
|
2886 } |
|
2887 |
|
2888 catch(bad_alloc&) |
|
2889 { |
|
2890 //do nothing |
|
2891 } |
|
2892 catch(...) |
|
2893 { |
|
2894 failures++; |
|
2895 |
|
2896 } |
|
2897 |
|
2898 if(failures ) |
|
2899 return KErrGeneral; |
|
2900 return KErrNone; |
|
2901 } |
|
2902 |
|
2903 |
|
2904 |
|
2905 TInt Ctstl_2::GettemporarybufferL(CStifItemParser& aItem) |
|
2906 { |
|
2907 int failures=0; |
|
2908 //__UHEAP_MARK; |
|
2909 try{ |
|
2910 // Create an array of ints |
|
2911 int intArray [ ] = { 10, 20, 30, 40, 100, 200, 300, 1000, 2000 }; |
|
2912 int count = sizeof ( intArray ) / sizeof ( int ); |
|
2913 |
|
2914 |
|
2915 pair<int *, ptrdiff_t> resultPair; |
|
2916 // cout<<""; |
|
2917 #if STDCPP_OOM |
|
2918 User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1); |
|
2919 #endif |
|
2920 resultPair = get_temporary_buffer<int>( count ); |
|
2921 #if STDCPP_M |
|
2922 User::__DbgSetAllocFail(FALSE,RHeap::ENone,1); |
|
2923 #endif |
|
2924 |
|
2925 int* tempBuffer = resultPair.first; |
|
2926 |
|
2927 return_temporary_buffer(tempBuffer); |
|
2928 /* |
|
2929 if(count==9) |
|
2930 if(resultPair.second == 9) |
|
2931 return KErrNone; |
|
2932 return KErrGeneral; |
|
2933 */ |
|
2934 if(count!=9) |
|
2935 failures++; |
|
2936 #if STDCPP_OOM |
|
2937 if(resultPair.second!=0) |
|
2938 #else |
|
2939 if(resultPair.second!=9) |
|
2940 #endif |
|
2941 failures++; |
|
2942 |
|
2943 |
|
2944 //#if STDCPP_OOM |
|
2945 //failures++; |
|
2946 // #endif |
|
2947 // __UHEAP_MARKEND; |
|
2948 |
|
2949 } |
|
2950 |
|
2951 catch(bad_alloc&) |
|
2952 { |
|
2953 //do nothing |
|
2954 } |
|
2955 catch(...) |
|
2956 { |
|
2957 failures++; |
|
2958 |
|
2959 } |
|
2960 |
|
2961 if(failures ) |
|
2962 return KErrGeneral; |
|
2963 return KErrNone; |
|
2964 } |
|
2965 |
|
2966 |
|
2967 |
|
2968 |
|
2969 TInt Ctstl_2::Pair(CStifItemParser& aItem) |
|
2970 { |
|
2971 |
|
2972 //__UHEAP_MARK; |
|
2973 |
|
2974 int failures=0; |
|
2975 try{ |
|
2976 |
|
2977 // cout<<""; |
|
2978 #if STDCPP_OOM |
|
2979 User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1); |
|
2980 #endif |
|
2981 typedef struct pair<int, float> PAIR_IF; |
|
2982 |
|
2983 PAIR_IF A(10,3.14f); |
|
2984 PAIR_IF B(18,3.14f); |
|
2985 PAIR_IF C(10,6.28f); |
|
2986 PAIR_IF D(10,3.14f); |
|
2987 |
|
2988 #if STDCPP_OOM |
|
2989 User::__DbgSetAllocFail(FALSE,RHeap::ENone,1); |
|
2990 #endif |
|
2991 |
|
2992 if (A==D) |
|
2993 |
|
2994 if (B!=C) |
|
2995 |
|
2996 if (A>C) |
|
2997 failures++; |
|
2998 |
|
2999 |
|
3000 if (A>=C) |
|
3001 failures++; |
|
3002 |
|
3003 |
|
3004 /* |
|
3005 if(failures) |
|
3006 return KErrGeneral; |
|
3007 return KErrNone; |
|
3008 */ |
|
3009 //#if STDCPP_OOM |
|
3010 //failures++; |
|
3011 // #endif |
|
3012 |
|
3013 |
|
3014 //__UHEAP_MARKEND; |
|
3015 |
|
3016 } |
|
3017 |
|
3018 |
|
3019 catch(bad_alloc&) |
|
3020 { |
|
3021 //do nothing |
|
3022 } |
|
3023 catch(...) |
|
3024 { |
|
3025 failures++; |
|
3026 |
|
3027 } |
|
3028 |
|
3029 if(failures ) |
|
3030 return KErrGeneral; |
|
3031 return KErrNone; |
|
3032 } |
|
3033 |
|
3034 |
|
3035 |
|
3036 bool twice ( int elem1, int elem2 ) |
|
3037 { |
|
3038 return 2 * elem1 < elem2; |
|
3039 } |
|
3040 |
|
3041 |
|
3042 TInt Ctstl_2::Lexicographicalcompare(CStifItemParser& aItem) |
|
3043 { |
|
3044 |
|
3045 //__UHEAP_MARK; |
|
3046 |
|
3047 |
|
3048 |
|
3049 |
|
3050 int failures=0; |
|
3051 |
|
3052 try |
|
3053 { |
|
3054 |
|
3055 vector <int> v1, v2; |
|
3056 list <int> L1; |
|
3057 // vector <int>::iterator Iter1, Iter2; |
|
3058 // list <int>::iterator L1_Iter, L1_inIter; |
|
3059 |
|
3060 int i; |
|
3061 for ( i = 0 ; i <= 5 ; i++ ) |
|
3062 { |
|
3063 v1.push_back( 5 * i ); |
|
3064 } |
|
3065 int ii; |
|
3066 for ( ii = 0 ; ii <= 6 ; ii++ ) |
|
3067 { |
|
3068 L1.push_back( 5 * ii ); |
|
3069 } |
|
3070 |
|
3071 int iii; |
|
3072 for ( iii = 0 ; iii <= 5 ; iii++ ) |
|
3073 { |
|
3074 v2.push_back( 10 * iii ); |
|
3075 } |
|
3076 |
|
3077 |
|
3078 // Self lexicographical_comparison of v1 under identity |
|
3079 bool result1; |
|
3080 // cout<<""; |
|
3081 #if STDCPP_OOM |
|
3082 User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1); |
|
3083 #endif |
|
3084 |
|
3085 result1 = lexicographical_compare (v1.begin( ), v1.end( ), v1.begin( ), v1.end( ) ); |
|
3086 |
|
3087 |
|
3088 |
|
3089 // lexicographical_comparison of v1 and L2 under identity |
|
3090 bool result2; |
|
3091 result2 = lexicographical_compare (v1.begin( ), v1.end( ), L1.begin( ), L1.end( ) ); |
|
3092 |
|
3093 |
|
3094 |
|
3095 bool result3; |
|
3096 result3 = lexicographical_compare (v1.begin( ), v1.end( ), v2.begin( ), v2.end( ), twice ); |
|
3097 #if STDCPP_OOM |
|
3098 User::__DbgSetAllocFail(FALSE,RHeap::ENone,1); |
|
3099 #endif |
|
3100 /* |
|
3101 if (!result1) |
|
3102 if ( result2 ) |
|
3103 if (!result3 ) |
|
3104 |
|
3105 return KErrNone; |
|
3106 return KErrGeneral; |
|
3107 |
|
3108 */ |
|
3109 |
|
3110 if(result1) |
|
3111 failures++; |
|
3112 if(!result2) |
|
3113 failures++; |
|
3114 if(result3) |
|
3115 failures++; |
|
3116 |
|
3117 //#if STDCPP_OOM |
|
3118 //failures++; |
|
3119 // #endif |
|
3120 |
|
3121 // __UHEAP_MARKEND; |
|
3122 |
|
3123 } |
|
3124 catch(bad_alloc&) |
|
3125 { |
|
3126 //do nothing |
|
3127 } |
|
3128 catch(...) |
|
3129 { |
|
3130 failures++; |
|
3131 |
|
3132 } |
|
3133 |
|
3134 if(failures ) |
|
3135 return KErrGeneral; |
|
3136 return KErrNone; |
|
3137 } |
|
3138 |
|
3139 //Mismatch |
|
3140 |
|
3141 bool mypredicate (int i, int j) { |
|
3142 return (i==j); |
|
3143 } |
|
3144 |
|
3145 |
|
3146 |
|
3147 TInt Ctstl_2::Mismatch(CStifItemParser& aItem) |
|
3148 { |
|
3149 |
|
3150 // __UHEAP_MARK; |
|
3151 |
|
3152 |
|
3153 int failures=0; |
|
3154 try{ |
|
3155 |
|
3156 vector<int> myvector; |
|
3157 for (int i=1; i<6; i++) myvector.push_back (i*10); // myvector: 10 20 30 40 50 |
|
3158 |
|
3159 int myints[] = {10,20,80,320,1024}; // myints: 10 20 80 320 1024 |
|
3160 |
|
3161 pair<vector<int>::iterator,int*> mypair; |
|
3162 // cout<<""; |
|
3163 #if STDCPP_OOM |
|
3164 User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1); |
|
3165 #endif |
|
3166 // using default comparison: |
|
3167 mypair = mismatch (myvector.begin(), myvector.end(), myints); |
|
3168 // cout<<""; |
|
3169 #if STDCPP_OOM |
|
3170 User::__DbgSetAllocFail(FALSE,RHeap::ENone,1); |
|
3171 #endif |
|
3172 if(*mypair.first != 30) |
|
3173 failures++; |
|
3174 |
|
3175 if(*mypair.second != 80) |
|
3176 failures++; |
|
3177 |
|
3178 |
|
3179 mypair.first++; |
|
3180 mypair.second++; |
|
3181 #if STDCPP_OOM |
|
3182 User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1); |
|
3183 #endif |
|
3184 // using predicate comparison: |
|
3185 mypair = mismatch (mypair.first, myvector.end(), mypair.second, mypredicate); |
|
3186 #if STDCPP_OOM |
|
3187 User::__DbgSetAllocFail(FALSE,RHeap::ENone,1); |
|
3188 #endif |
|
3189 if(*mypair.first != 40) |
|
3190 failures++; |
|
3191 if(*mypair.second != 320) |
|
3192 failures++; |
|
3193 /* |
|
3194 if(failures) |
|
3195 return KErrGeneral; |
|
3196 return KErrNone; |
|
3197 */ |
|
3198 //#if STDCPP_OOM |
|
3199 //failures++; |
|
3200 // #endif |
|
3201 |
|
3202 // __UHEAP_MARKEND; |
|
3203 |
|
3204 } |
|
3205 |
|
3206 catch(bad_alloc&) |
|
3207 { |
|
3208 //do nothing |
|
3209 } |
|
3210 catch(...) |
|
3211 { |
|
3212 failures++; |
|
3213 |
|
3214 } |
|
3215 |
|
3216 if(failures ) |
|
3217 return KErrGeneral; |
|
3218 return KErrNone; |
|
3219 } |
|
3220 |
|
3221 |
|
3222 TInt Ctstl_2::Compare_fun(CStifItemParser& aItem) |
|
3223 |
|
3224 { |
|
3225 int failures=0; |
|
3226 //__UHEAP_MARK; |
|
3227 try |
|
3228 { |
|
3229 |
|
3230 |
|
3231 string str1 ("green apple"); |
|
3232 string str2 ("red apple"); |
|
3233 // cout<<""; |
|
3234 #if STDCPP_OOM |
|
3235 User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1); |
|
3236 #endif |
|
3237 if (str1.compare("str2") == 0) |
|
3238 failures++; |
|
3239 |
|
3240 if (str1.compare(6,5,"apple") != 0) |
|
3241 failures++; |
|
3242 |
|
3243 if (str2.compare(str2.size()-5,5,"apple") != 0) |
|
3244 |
|
3245 failures++; |
|
3246 |
|
3247 |
|
3248 if (str1.compare(6,5,str2,4,5) != 0) |
|
3249 failures++; |
|
3250 #if STDCPP_OOM |
|
3251 User::__DbgSetAllocFail(FALSE,RHeap::ENone,1); |
|
3252 #endif |
|
3253 /* |
|
3254 if(failures) |
|
3255 |
|
3256 return KErrGeneral; |
|
3257 return KErrNone; |
|
3258 */ |
|
3259 //__UHEAP_MARKEND; |
|
3260 //#if STDCPP_OOM |
|
3261 //failures++; |
|
3262 // #endif |
|
3263 } |
|
3264 |
|
3265 catch(bad_alloc&) |
|
3266 { |
|
3267 //do nothing |
|
3268 } |
|
3269 catch(...) |
|
3270 { |
|
3271 failures++; |
|
3272 |
|
3273 } |
|
3274 |
|
3275 if(failures ) |
|
3276 return KErrGeneral; |
|
3277 return KErrNone; |
|
3278 } |
|
3279 |
|
3280 |
|
3281 |
|
3282 TInt Ctstl_2::Copy_fun(CStifItemParser& aItem) |
|
3283 |
|
3284 { |
|
3285 int failures=0; |
|
3286 // __UHEAP_MARK; |
|
3287 try |
|
3288 { |
|
3289 int myints[]={10,20,30,40,50,60,70}; |
|
3290 vector<int> myvector; |
|
3291 vector<int>::iterator it; |
|
3292 int a[7]; |
|
3293 |
|
3294 myvector.resize(7); |
|
3295 // cout<<""; |
|
3296 #if STDCPP_OOM |
|
3297 User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1); |
|
3298 #endif |
|
3299 copy ( myints, myints+7, myvector.begin() ); |
|
3300 #if STDCPP_OOM |
|
3301 User::__DbgSetAllocFail(FALSE,RHeap::ENone,1); |
|
3302 #endif |
|
3303 for (it=myvector.begin(); it!=myvector.end(); ++it) |
|
3304 { |
|
3305 static int i; |
|
3306 a[i] = *it; |
|
3307 i++; |
|
3308 } |
|
3309 /* |
|
3310 if(a[0]==10) |
|
3311 if(a[1]==20) |
|
3312 if(a[2]==30) |
|
3313 if(a[3]==40) |
|
3314 if(a[4]==50) |
|
3315 if(a[5]==60) |
|
3316 if(a[6]==70) |
|
3317 return KErrNone; |
|
3318 return KErrGeneral;*/ |
|
3319 |
|
3320 if(a[0]!=10) |
|
3321 failures++; |
|
3322 if(a[1]!=20) |
|
3323 failures++; |
|
3324 |
|
3325 if(a[2]!=30) |
|
3326 failures++; |
|
3327 if(a[3]!=40) |
|
3328 failures++; |
|
3329 if(a[4]!=50) |
|
3330 failures++; |
|
3331 if(a[5]!=60) |
|
3332 failures++; |
|
3333 if(a[6]!=70) |
|
3334 failures++; |
|
3335 |
|
3336 |
|
3337 //__UHEAP_MARKEND; |
|
3338 //#if STDCPP_OOM |
|
3339 //failures++; |
|
3340 // #endif |
|
3341 } |
|
3342 |
|
3343 |
|
3344 catch(bad_alloc&) |
|
3345 { |
|
3346 //do nothing |
|
3347 } |
|
3348 catch(...) |
|
3349 { |
|
3350 failures++; |
|
3351 |
|
3352 } |
|
3353 |
|
3354 if(failures ) |
|
3355 return KErrGeneral; |
|
3356 return KErrNone; |
|
3357 } |
|
3358 |
|
3359 TInt Ctstl_2::Copybackward_fun(CStifItemParser& aItem) |
|
3360 |
|
3361 { |
|
3362 |
|
3363 int failures=0; |
|
3364 |
|
3365 //__UHEAP_MARK; |
|
3366 try{ |
|
3367 |
|
3368 vector<int> myvector; |
|
3369 vector<int>::iterator it; |
|
3370 int a[11]; |
|
3371 // set some values: |
|
3372 for (int i=1; i<=5; i++) |
|
3373 myvector.push_back(i*10); // myvector: 10 20 30 40 50 |
|
3374 |
|
3375 myvector.resize(myvector.size()+6); // allocate space for 6 more elements |
|
3376 // cout<<""; |
|
3377 #if STDCPP_OOM |
|
3378 User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1); |
|
3379 #endif |
|
3380 copy_backward ( myvector.begin(), myvector.begin()+5, myvector.end() ); |
|
3381 #if STDCPP_OOM |
|
3382 User::__DbgSetAllocFail(FALSE,RHeap::ENone,1); |
|
3383 #endif |
|
3384 |
|
3385 for (it=myvector.begin(); it!=myvector.end(); ++it) |
|
3386 { |
|
3387 static int i; |
|
3388 a[i] = *it; |
|
3389 i++; |
|
3390 } |
|
3391 /* |
|
3392 if(a[0]==10) |
|
3393 if(a[1]==20) |
|
3394 if(a[2]==30) |
|
3395 if(a[3]==40) |
|
3396 if(a[4]==50) |
|
3397 |
|
3398 if(a[6]==10) |
|
3399 if(a[7]==20) |
|
3400 if(a[8]==30) |
|
3401 if(a[9]==40) |
|
3402 if(a[10]==50) |
|
3403 |
|
3404 return KErrNone; |
|
3405 else |
|
3406 |
|
3407 return KErrGeneral; |
|
3408 */ |
|
3409 // __UHEAP_MARKEND; |
|
3410 |
|
3411 if(a[0]!=10) |
|
3412 failures++; |
|
3413 |
|
3414 if(a[1]!=20) |
|
3415 failures++; |
|
3416 if(a[2]!=30) |
|
3417 failures++; |
|
3418 if(a[3]!=40) |
|
3419 failures++; |
|
3420 if(a[4]!=50) |
|
3421 failures++; |
|
3422 |
|
3423 if(a[6]!=10) |
|
3424 failures++; |
|
3425 if(a[7]!=20) |
|
3426 failures++; |
|
3427 if(a[8]!=30) |
|
3428 failures++; |
|
3429 if(a[9]!=40) |
|
3430 failures++; |
|
3431 if(a[10]!=50) |
|
3432 failures++; |
|
3433 //#if STDCPP_OOM |
|
3434 //failures++; |
|
3435 // #endif |
|
3436 } |
|
3437 |
|
3438 catch(bad_alloc&) |
|
3439 { |
|
3440 //do nothing |
|
3441 } |
|
3442 catch(...) |
|
3443 { |
|
3444 failures++; |
|
3445 |
|
3446 } |
|
3447 |
|
3448 if(failures ) |
|
3449 return KErrGeneral; |
|
3450 return KErrNone; |
|
3451 } |
|
3452 |
|
3453 |
|
3454 TInt Ctstl_2::mergeL(CStifItemParser& aItem) |
|
3455 |
|
3456 { |
|
3457 int failures=0; |
|
3458 try |
|
3459 { |
|
3460 int a[4]; |
|
3461 |
|
3462 list <int> c1, c2; |
|
3463 list <int>::iterator c2_Iter ; |
|
3464 |
|
3465 // __UHEAP_MARK; |
|
3466 |
|
3467 |
|
3468 |
|
3469 |
|
3470 |
|
3471 c1.push_back( 3 ); |
|
3472 c1.push_back( 6 ); |
|
3473 c2.push_back( 2 ); |
|
3474 c2.push_back( 4 ); |
|
3475 |
|
3476 // cout<<""; |
|
3477 #if STDCPP_OOM |
|
3478 User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1); |
|
3479 #endif |
|
3480 |
|
3481 c2.merge( c1 ); // Merge c1 into c2 in (default) ascending order |
|
3482 |
|
3483 #if STDCPP_OOM |
|
3484 User::__DbgSetAllocFail(FALSE,RHeap::ENone,1); |
|
3485 #endif |
|
3486 c2.sort( greater<int>( ) ); |
|
3487 for ( c2_Iter = c2.begin( ); c2_Iter != c2.end( ); c2_Iter++ ) |
|
3488 |
|
3489 { |
|
3490 static int i; |
|
3491 a[i]= *c2_Iter; |
|
3492 i++; |
|
3493 } |
|
3494 |
|
3495 // __UHEAP_MARKEND; |
|
3496 |
|
3497 /* if(a[0]==6) |
|
3498 if(a[1]==4) |
|
3499 if(a[2]==3) |
|
3500 if(a[3]==2) |
|
3501 |
|
3502 |
|
3503 |
|
3504 return KErrNone; |
|
3505 |
|
3506 return KErrGeneral; |
|
3507 */ |
|
3508 |
|
3509 |
|
3510 if(a[0]!=6) |
|
3511 |
|
3512 failures++; |
|
3513 |
|
3514 if(a[1]!=4) |
|
3515 failures++; |
|
3516 if(a[2]!=3) |
|
3517 failures++; |
|
3518 if(a[3]!=2) |
|
3519 failures++; |
|
3520 |
|
3521 //#if STDCPP_OOM |
|
3522 //failures++; |
|
3523 // #endif |
|
3524 |
|
3525 |
|
3526 } |
|
3527 |
|
3528 catch(bad_alloc&) |
|
3529 { |
|
3530 //do nothing |
|
3531 } |
|
3532 catch(...) |
|
3533 { |
|
3534 failures++; |
|
3535 |
|
3536 } |
|
3537 |
|
3538 if(failures ) |
|
3539 return KErrGeneral; |
|
3540 return KErrNone; |
|
3541 } |
|
3542 |
|
3543 TInt Ctstl_2::allocatoradd(CStifItemParser& aItem) |
|
3544 |
|
3545 { |
|
3546 int failures = 0; |
|
3547 |
|
3548 // __UHEAP_MARK; |
|
3549 try{ |
|
3550 vector <int> v1; |
|
3551 // vector <int>::iterator v1Iter; |
|
3552 vector <int>:: allocator_type v1Alloc; |
|
3553 |
|
3554 int i; |
|
3555 for ( i = 1 ; i <= 7 ; i++ ) |
|
3556 { |
|
3557 v1.push_back( 2 * i ); |
|
3558 } |
|
3559 |
|
3560 // cout<<""; |
|
3561 #if STDCPP_OOM |
|
3562 User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1); |
|
3563 #endif |
|
3564 |
|
3565 allocator<int>::const_pointer v1Ptr; |
|
3566 |
|
3567 |
|
3568 const int k = 8; |
|
3569 v1Ptr = v1Alloc.address( k ); |
|
3570 #if STDCPP_OOM |
|
3571 User::__DbgSetAllocFail(FALSE,RHeap::ENone,1); |
|
3572 #endif |
|
3573 |
|
3574 /* |
|
3575 if( *v1Ptr == 8) |
|
3576 // __UHEAP_MARKEND; |
|
3577 |
|
3578 return KErrNone; |
|
3579 |
|
3580 return KErrGeneral; |
|
3581 */ |
|
3582 |
|
3583 |
|
3584 if(*v1Ptr!=8) |
|
3585 failures++; |
|
3586 |
|
3587 |
|
3588 //#if STDCPP_OOM |
|
3589 //failures++; |
|
3590 // #endif |
|
3591 |
|
3592 |
|
3593 } |
|
3594 |
|
3595 catch(bad_alloc&) |
|
3596 { |
|
3597 //do nothing |
|
3598 } |
|
3599 catch(...) |
|
3600 { |
|
3601 failures++; |
|
3602 |
|
3603 } |
|
3604 |
|
3605 if(failures ) |
|
3606 return KErrGeneral; |
|
3607 return KErrNone; |
|
3608 } |
|
3609 |
|
3610 |
|
3611 |
|
3612 TInt Ctstl_2::alldeall(CStifItemParser& aItem) |
|
3613 |
|
3614 |
|
3615 { |
|
3616 |
|
3617 //__UHEAP_MARK; |
|
3618 |
|
3619 int failures =0; |
|
3620 |
|
3621 try{ |
|
3622 |
|
3623 |
|
3624 allocator<int> v1Alloc; |
|
3625 |
|
3626 allocator<int>::pointer aPtr; |
|
3627 |
|
3628 aPtr = v1Alloc.allocate ( 5 ); |
|
3629 |
|
3630 int i; |
|
3631 for ( i = 0 ; i < 5 ; i++ ) |
|
3632 { |
|
3633 aPtr[ i ] = i; |
|
3634 } |
|
3635 |
|
3636 if(aPtr[0] != 0) |
|
3637 failures++; |
|
3638 // cout<<""; |
|
3639 #if STDCPP_OOM |
|
3640 User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1); |
|
3641 #endif |
|
3642 v1Alloc.deallocate( aPtr, 5 ); |
|
3643 #if STDCPP_OOM |
|
3644 User::__DbgSetAllocFail(FALSE,RHeap::ENone,1); |
|
3645 #endif |
|
3646 |
|
3647 if(aPtr[0] == 0) |
|
3648 failures++; |
|
3649 |
|
3650 |
|
3651 //__UHEAP_MARKEND; |
|
3652 /* |
|
3653 if (failures) |
|
3654 return KErrGeneral; |
|
3655 else |
|
3656 return KErrNone; |
|
3657 |
|
3658 */ |
|
3659 |
|
3660 //#if STDCPP_OOM |
|
3661 //failures++; |
|
3662 // #endif |
|
3663 } |
|
3664 |
|
3665 catch(bad_alloc&) |
|
3666 { |
|
3667 //do nothing |
|
3668 } |
|
3669 catch(...) |
|
3670 { |
|
3671 failures++; |
|
3672 |
|
3673 } |
|
3674 |
|
3675 if(failures ) |
|
3676 return KErrGeneral; |
|
3677 return KErrNone; |
|
3678 } |
|
3679 |
|
3680 |
|
3681 TInt Ctstl_2::allcons(CStifItemParser& aItem) |
|
3682 { |
|
3683 |
|
3684 |
|
3685 // __UHEAP_MARK; |
|
3686 |
|
3687 int output[7],failures = 0; |
|
3688 try{ |
|
3689 vector <int> v1; |
|
3690 vector <int>::iterator v1Iter; |
|
3691 vector <int>:: allocator_type v1Alloc; |
|
3692 |
|
3693 int i; |
|
3694 for ( i = 1 ; i <= 7 ; i++ ) |
|
3695 { |
|
3696 v1.push_back( 3 * i ); |
|
3697 } |
|
3698 |
|
3699 for ( v1Iter = v1.begin( ) ; v1Iter != v1.end( ) ; v1Iter++ ) |
|
3700 |
|
3701 { |
|
3702 static int i; |
|
3703 output[i] = *v1Iter; |
|
3704 i++; |
|
3705 |
|
3706 } |
|
3707 |
|
3708 |
|
3709 if(output[1] != 6) |
|
3710 failures++; |
|
3711 |
|
3712 |
|
3713 allocator<int>::pointer v1PtrA; |
|
3714 int kA = 6, kB = 7; |
|
3715 v1PtrA = v1Alloc.address( *find( v1.begin( ), v1.end( ), kA ) ); |
|
3716 v1Alloc.destroy ( v1PtrA ); |
|
3717 // cout<<""; |
|
3718 #if STDCPP_OOM |
|
3719 User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1); |
|
3720 #endif |
|
3721 v1Alloc.construct ( v1PtrA , kB ); |
|
3722 #if STDCPP_OOM |
|
3723 User::__DbgSetAllocFail(FALSE,RHeap::ENone,1); |
|
3724 #endif |
|
3725 for ( v1Iter = v1.begin( ) ; v1Iter != v1.end( ) ; v1Iter++ ) |
|
3726 |
|
3727 { |
|
3728 static int i; |
|
3729 output[i] = *v1Iter; |
|
3730 i++; |
|
3731 |
|
3732 } |
|
3733 |
|
3734 if(output[1] != 7) |
|
3735 failures++; |
|
3736 |
|
3737 |
|
3738 // __UHEAP_MARKEND; |
|
3739 |
|
3740 /* if(failures) |
|
3741 return KErrGeneral; |
|
3742 return KErrNone; |
|
3743 */ |
|
3744 |
|
3745 //#if STDCPP_OOM |
|
3746 //failures++; |
|
3747 // #endif |
|
3748 |
|
3749 |
|
3750 |
|
3751 |
|
3752 |
|
3753 } |
|
3754 catch(bad_alloc&) |
|
3755 { |
|
3756 //do nothing |
|
3757 } |
|
3758 catch(...) |
|
3759 { |
|
3760 failures++; |
|
3761 |
|
3762 } |
|
3763 |
|
3764 if(failures ) |
|
3765 return KErrGeneral; |
|
3766 return KErrNone; |
|
3767 } |
|
3768 |
|
3769 TInt Ctstl_2::allrebind(CStifItemParser& aItem) |
|
3770 { |
|
3771 |
|
3772 |
|
3773 |
|
3774 |
|
3775 // __UHEAP_MARK; |
|
3776 int failures =0; |
|
3777 try{ |
|
3778 |
|
3779 typedef vector<int>::allocator_type IntAlloc; |
|
3780 |
|
3781 IntAlloc v1Iter; |
|
3782 vector<int> v1; |
|
3783 // cout<<""; |
|
3784 #if STDCPP_OOM |
|
3785 User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1); |
|
3786 #endif |
|
3787 IntAlloc::rebind<char>::other::pointer pszC = IntAlloc::rebind<char>::other(v1.get_allocator()).allocate(1, (void *)0); |
|
3788 #if STDCPP_OOM |
|
3789 User::__DbgSetAllocFail(FALSE,RHeap::ENone,1); |
|
3790 #endif |
|
3791 int * pInt = v1Iter.allocate(10); |
|
3792 |
|
3793 |
|
3794 |
|
3795 // __UHEAP_MARKEND; |
|
3796 |
|
3797 /* if(failures) |
|
3798 return KErrGeneral; |
|
3799 return KErrNone; |
|
3800 */ |
|
3801 |
|
3802 //#if STDCPP_OOM |
|
3803 //failures++; |
|
3804 // #endif |
|
3805 |
|
3806 } |
|
3807 |
|
3808 catch(bad_alloc&) |
|
3809 { |
|
3810 //do nothing |
|
3811 } |
|
3812 catch(...) |
|
3813 { |
|
3814 failures++; |
|
3815 |
|
3816 } |
|
3817 |
|
3818 if(failures ) |
|
3819 return KErrGeneral; |
|
3820 return KErrNone; |
|
3821 } |
|
3822 |
|
3823 |
|
3824 TInt Ctstl_2::allmaxsize(CStifItemParser& aItem) |
|
3825 |
|
3826 {int failures=0; |
|
3827 |
|
3828 |
|
3829 try{ |
|
3830 vector <int> v1; |
|
3831 // vector <int>::iterator v1Iter; |
|
3832 vector <int>:: allocator_type v1Alloc; |
|
3833 |
|
3834 |
|
3835 |
|
3836 |
|
3837 allocator<int>::size_type v1size; |
|
3838 // cout<<""; |
|
3839 #if STDCPP_OOM |
|
3840 User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1); |
|
3841 #endif |
|
3842 v1size = v1Alloc.max_size( ); |
|
3843 #if STDCPP_OOM |
|
3844 User::__DbgSetAllocFail(FALSE,RHeap::ENone,1); |
|
3845 #endif |
|
3846 /*if(v1size == 1073741823) |
|
3847 return KErrNone; |
|
3848 else |
|
3849 return KErrGeneral;*/ |
|
3850 |
|
3851 |
|
3852 if(v1size != 1073741823) |
|
3853 failures++; |
|
3854 |
|
3855 |
|
3856 //#if STDCPP_OOM |
|
3857 //failures++; |
|
3858 // #endif |
|
3859 |
|
3860 } |
|
3861 |
|
3862 |
|
3863 catch(bad_alloc&) |
|
3864 { |
|
3865 //do nothing |
|
3866 } |
|
3867 catch(...) |
|
3868 { |
|
3869 failures++; |
|
3870 |
|
3871 } |
|
3872 |
|
3873 if(failures ) |
|
3874 return KErrGeneral; |
|
3875 return KErrNone; |
|
3876 } |
|
3877 |
|
3878 |
|
3879 |
|
3880 |
|
3881 TInt Ctstl_2::complexL(CStifItemParser& aItem) |
|
3882 |
|
3883 {int failures=0; |
|
3884 try |
|
3885 { |
|
3886 |
|
3887 |
|
3888 |
|
3889 // double pi = 3.14159265359; |
|
3890 // cout<<""; |
|
3891 #if STDCPP_OOM |
|
3892 User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1); |
|
3893 #endif |
|
3894 complex <double> c1 ( 4.0 , 5.0 ); |
|
3895 |
|
3896 double re = real(c1); |
|
3897 |
|
3898 double im = imag(c1); |
|
3899 #if STDCPP_OOM |
|
3900 User::__DbgSetAllocFail(FALSE,RHeap::ENone,1); |
|
3901 #endif |
|
3902 /* if(re == 4) |
|
3903 if(im == 5) |
|
3904 return KErrNone; |
|
3905 return KErrGeneral; |
|
3906 |
|
3907 */ |
|
3908 |
|
3909 if(re!=4) |
|
3910 failures++; |
|
3911 if (im!= 5) |
|
3912 failures++; |
|
3913 |
|
3914 |
|
3915 //#if STDCPP_OOM |
|
3916 //failures++; |
|
3917 // #endif |
|
3918 |
|
3919 |
|
3920 } |
|
3921 catch(bad_alloc&) |
|
3922 { |
|
3923 //do nothing |
|
3924 } |
|
3925 catch(...) |
|
3926 { |
|
3927 failures++; |
|
3928 |
|
3929 } |
|
3930 |
|
3931 if(failures ) |
|
3932 return KErrGeneral; |
|
3933 return KErrNone; |
|
3934 } |
|
3935 |
|
3936 |
|
3937 TInt Ctstl_2::limitsL(CStifItemParser& aItem) |
|
3938 |
|
3939 { |
|
3940 |
|
3941 //__UHEAP_MARK; |
|
3942 |
|
3943 int failures=0; |
|
3944 |
|
3945 try |
|
3946 { |
|
3947 // cout<<""; |
|
3948 #if STDCPP_OOM |
|
3949 User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1); |
|
3950 #endif |
|
3951 //is_speciallized |
|
3952 if(!numeric_limits<float>::is_specialized) |
|
3953 failures++; |
|
3954 |
|
3955 if(!numeric_limits<int>::is_specialized) |
|
3956 failures++; |
|
3957 |
|
3958 |
|
3959 //if(!numeric_limits<long double>::is_specialized) //failing |
|
3960 //failures++; |
|
3961 |
|
3962 |
|
3963 if(!numeric_limits<double>::is_specialized) |
|
3964 failures++; |
|
3965 |
|
3966 if(!numeric_limits<wchar_t>::is_specialized) |
|
3967 failures++; |
|
3968 |
|
3969 |
|
3970 if(!numeric_limits<char>::is_specialized) |
|
3971 failures++; |
|
3972 |
|
3973 |
|
3974 |
|
3975 if(!numeric_limits<bool>::is_specialized) |
|
3976 failures++; |
|
3977 |
|
3978 |
|
3979 |
|
3980 |
|
3981 if(!numeric_limits<signed char>::is_specialized) |
|
3982 failures++; |
|
3983 |
|
3984 |
|
3985 if(!numeric_limits<unsigned char>::is_specialized) |
|
3986 failures++; |
|
3987 |
|
3988 |
|
3989 |
|
3990 if(!numeric_limits<short>::is_specialized) |
|
3991 failures++; |
|
3992 |
|
3993 |
|
3994 |
|
3995 if(!numeric_limits<unsigned short>::is_specialized) |
|
3996 failures++; |
|
3997 |
|
3998 |
|
3999 |
|
4000 |
|
4001 //if(!numeric_limits<_int64>::is_specialized) |
|
4002 //failures++; |
|
4003 |
|
4004 |
|
4005 |
|
4006 |
|
4007 |
|
4008 //digits |
|
4009 if(numeric_limits<float>::digits !=24) |
|
4010 failures++; |
|
4011 |
|
4012 if( numeric_limits<double>::digits !=53) |
|
4013 failures++; |
|
4014 |
|
4015 //if( numeric_limits<long double>::digits !=64) failed 0 |
|
4016 //failures++; |
|
4017 |
|
4018 if (numeric_limits<int>::digits != 31) |
|
4019 failures++; |
|
4020 |
|
4021 if(numeric_limits<__int64>::digits !=63) |
|
4022 failures++; |
|
4023 |
|
4024 |
|
4025 if(numeric_limits<char>::digits != 7) |
|
4026 failures++; |
|
4027 |
|
4028 |
|
4029 if(numeric_limits<short>::digits != 15) |
|
4030 failures++; |
|
4031 |
|
4032 if(numeric_limits<unsigned short>::digits != 16) |
|
4033 failures++; |
|
4034 |
|
4035 if(numeric_limits<long>::digits != 31) |
|
4036 failures++; |
|
4037 |
|
4038 |
|
4039 if(numeric_limits<unsigned long>::digits != 32) |
|
4040 failures++; |
|
4041 |
|
4042 |
|
4043 if(numeric_limits<wchar_t>::digits != 16) |
|
4044 failures++; |
|
4045 |
|
4046 if(numeric_limits<unsigned char>::digits != 8) |
|
4047 failures++; |
|
4048 |
|
4049 |
|
4050 if(numeric_limits<signed char>::digits != 7) |
|
4051 failures++; |
|
4052 |
|
4053 if(numeric_limits<bool>::digits != 1) |
|
4054 failures++; |
|
4055 |
|
4056 |
|
4057 |
|
4058 //digit10 |
|
4059 |
|
4060 if(numeric_limits<float>::digits10 !=6) |
|
4061 failures++; |
|
4062 |
|
4063 if( numeric_limits<double>::digits10 !=15) |
|
4064 failures++; |
|
4065 |
|
4066 //if( numeric_limits<long double>::digits10 !=18) |
|
4067 //failures++; |
|
4068 |
|
4069 if (numeric_limits<int>::digits10 != 9) |
|
4070 failures++; |
|
4071 |
|
4072 //if(numeric_limits<__int64>::digits10 !=63) |
|
4073 // failures++; |
|
4074 |
|
4075 |
|
4076 if(numeric_limits<char>::digits10 != 2) |
|
4077 failures++; |
|
4078 |
|
4079 |
|
4080 if(numeric_limits<short>::digits10 != 4) |
|
4081 failures++; |
|
4082 |
|
4083 if(numeric_limits<unsigned short>::digits10 != 4) |
|
4084 failures++; |
|
4085 |
|
4086 if(numeric_limits<long>::digits10 != 9) |
|
4087 failures++; |
|
4088 |
|
4089 |
|
4090 |
|
4091 if(numeric_limits<unsigned long>::digits10 !=9) |
|
4092 failures++; |
|
4093 |
|
4094 if(numeric_limits<wchar_t>::digits10 != 4) |
|
4095 failures++; |
|
4096 |
|
4097 if(numeric_limits<unsigned char>::digits10 != 2) |
|
4098 failures++; |
|
4099 |
|
4100 |
|
4101 if(numeric_limits<signed char>::digits10 != 2) |
|
4102 failures++; |
|
4103 |
|
4104 if(numeric_limits<bool>::digits10 != 0) |
|
4105 failures++; |
|
4106 #if STDCPP_OOM |
|
4107 User::__DbgSetAllocFail(FALSE,RHeap::ENone,1); |
|
4108 #endif |
|
4109 |
|
4110 //de_norm |
|
4111 |
|
4112 //__UHEAP_MARKEND; |
|
4113 |
|
4114 |
|
4115 /* |
|
4116 if(failures) |
|
4117 return KErrGeneral; |
|
4118 return KErrNone; |
|
4119 |
|
4120 */ |
|
4121 //#if STDCPP_OOM |
|
4122 //failures++; |
|
4123 // #endif |
|
4124 |
|
4125 |
|
4126 |
|
4127 |
|
4128 |
|
4129 } |
|
4130 |
|
4131 |
|
4132 |
|
4133 |
|
4134 |
|
4135 catch(bad_alloc&) |
|
4136 { |
|
4137 //do nothing |
|
4138 } |
|
4139 catch(...) |
|
4140 { |
|
4141 failures++; |
|
4142 |
|
4143 } |
|
4144 |
|
4145 if(failures ) |
|
4146 return KErrGeneral; |
|
4147 return KErrNone; |
|
4148 } |
|
4149 |
|
4150 |
|
4151 |
|
4152 TInt Ctstl_2::nextperm(CStifItemParser& aItem) |
|
4153 { |
|
4154 |
|
4155 int failures =0; |
|
4156 |
|
4157 try |
|
4158 { |
|
4159 int myints[] = {1,2}; |
|
4160 |
|
4161 // cout<<""; |
|
4162 #if STDCPP_OOM |
|
4163 User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1); |
|
4164 #endif |
|
4165 |
|
4166 do { |
|
4167 |
|
4168 |
|
4169 static int i; |
|
4170 if (i==0) |
|
4171 { |
|
4172 if(myints[0]!=1) |
|
4173 failures++; |
|
4174 if(myints[1]!=2) |
|
4175 failures++; |
|
4176 |
|
4177 } |
|
4178 |
|
4179 else |
|
4180 { |
|
4181 if(myints[0]!=2) |
|
4182 failures++; |
|
4183 if(myints[1]!=1) |
|
4184 failures++; |
|
4185 } |
|
4186 i++; |
|
4187 |
|
4188 } while ( next_permutation (myints,myints+2) ); |
|
4189 |
|
4190 |
|
4191 #if STDCPP_OOM |
|
4192 User::__DbgSetAllocFail(FALSE,RHeap::ENone,1); |
|
4193 #endif |
|
4194 |
|
4195 |
|
4196 |
|
4197 |
|
4198 /* |
|
4199 |
|
4200 if(failures) |
|
4201 return KErrGeneral; |
|
4202 else |
|
4203 return KErrNone; |
|
4204 |
|
4205 */ |
|
4206 //#if STDCPP_OOM |
|
4207 //failures++; |
|
4208 // #endif |
|
4209 |
|
4210 } |
|
4211 |
|
4212 catch(bad_alloc&) |
|
4213 { |
|
4214 //do nothing |
|
4215 } |
|
4216 catch(...) |
|
4217 { |
|
4218 failures++; |
|
4219 |
|
4220 } |
|
4221 |
|
4222 if(failures ) |
|
4223 return KErrGeneral; |
|
4224 return KErrNone; |
|
4225 } |
|
4226 |
|
4227 |
|
4228 |
|
4229 |
|
4230 TInt Ctstl_2::prevperm(CStifItemParser& aItem) |
|
4231 { |
|
4232 |
|
4233 int failures =0; |
|
4234 |
|
4235 try{ |
|
4236 int myints[] = {2,1}; |
|
4237 // cout<<""; |
|
4238 #if STDCPP_OOM |
|
4239 User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1); |
|
4240 #endif |
|
4241 |
|
4242 do { |
|
4243 |
|
4244 |
|
4245 static int i; |
|
4246 if (i==0) |
|
4247 { |
|
4248 if(myints[0]!=2) |
|
4249 failures++; |
|
4250 if(myints[1]!=1) |
|
4251 failures++; |
|
4252 |
|
4253 } |
|
4254 |
|
4255 else |
|
4256 { |
|
4257 if(myints[0]!=1) |
|
4258 failures++; |
|
4259 if(myints[1]!=2) |
|
4260 failures++; |
|
4261 } |
|
4262 i++; |
|
4263 |
|
4264 } while ( prev_permutation (myints,myints+2) ); |
|
4265 |
|
4266 #if STDCPP_OOM |
|
4267 User::__DbgSetAllocFail(FALSE,RHeap::ENone,1); |
|
4268 #endif |
|
4269 |
|
4270 |
|
4271 |
|
4272 |
|
4273 |
|
4274 |
|
4275 /* |
|
4276 if(failures) |
|
4277 return KErrGeneral; |
|
4278 else |
|
4279 return KErrNone; |
|
4280 */ |
|
4281 //#if STDCPP_OOM |
|
4282 //failures++; |
|
4283 // #endif |
|
4284 |
|
4285 |
|
4286 } |
|
4287 |
|
4288 catch(bad_alloc&) |
|
4289 { |
|
4290 //do nothing |
|
4291 } |
|
4292 catch(...) |
|
4293 { |
|
4294 failures++; |
|
4295 |
|
4296 } |
|
4297 |
|
4298 if(failures ) |
|
4299 return KErrGeneral; |
|
4300 return KErrNone; |
|
4301 } |
|
4302 |
|
4303 |
|
4304 TInt Ctstl_2::ptrfun(CStifItemParser& aItem) |
|
4305 { |
|
4306 int failures=0; |
|
4307 try |
|
4308 |
|
4309 { |
|
4310 |
|
4311 vector <char*> v1; |
|
4312 vector <char*>::iterator RIter; |
|
4313 |
|
4314 v1.push_back ( "this" ); |
|
4315 v1.push_back ( "is" ); |
|
4316 v1.push_back ( "ptrfun" ); |
|
4317 v1.push_back ( "test" ); |
|
4318 v1.push_back ( "case" ); |
|
4319 // cout<<""; |
|
4320 #if STDCPP_OOM |
|
4321 User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1); |
|
4322 #endif |
|
4323 // To search the sequence for "pearly" |
|
4324 // use a pointer_to_function conversion |
|
4325 // __UHEAP_MARK; |
|
4326 RIter = find_if( v1.begin( ), v1.end( ), not1 ( bind2nd (ptr_fun ( strcmp ), "ptrfun" ) ) ); |
|
4327 |
|
4328 #if STDCPP_OOM |
|
4329 User::__DbgSetAllocFail(FALSE,RHeap::ENone,1); |
|
4330 #endif |
|
4331 //__UHEAP_MARKEND; |
|
4332 /* |
|
4333 if(strcmp(*RIter,"ptrfun\n")) |
|
4334 |
|
4335 return KErrNone; |
|
4336 else |
|
4337 return KErrGeneral; |
|
4338 |
|
4339 */ |
|
4340 |
|
4341 if(!strcmp(*RIter,"ptrfun\n")) |
|
4342 failures++; |
|
4343 |
|
4344 //#if STDCPP_OOM |
|
4345 //failures++; |
|
4346 // #endif |
|
4347 } |
|
4348 catch(bad_alloc&) |
|
4349 { |
|
4350 //do nothing |
|
4351 } |
|
4352 catch(...) |
|
4353 { |
|
4354 failures++; |
|
4355 |
|
4356 } |
|
4357 |
|
4358 if(failures ) |
|
4359 return KErrGeneral; |
|
4360 return KErrNone; |
|
4361 } |
|
4362 |
|
4363 TInt Ctstl_2::itertraits(CStifItemParser& aItem) |
|
4364 { |
|
4365 int failures=0; |
|
4366 |
|
4367 try |
|
4368 |
|
4369 { |
|
4370 vector<int> vi; |
|
4371 vector<char> vc; |
|
4372 list<char> lc; |
|
4373 // cout<<""; |
|
4374 #if STDCPP_OOM |
|
4375 User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1); |
|
4376 #endif |
|
4377 iterator_traits<vector<int>:: iterator>::iterator_category cati; |
|
4378 iterator_traits<vector<char>:: iterator>::iterator_category catc; |
|
4379 iterator_traits<list<char>:: iterator>::iterator_category catlc; |
|
4380 #if STDCPP_OOM |
|
4381 User::__DbgSetAllocFail(FALSE,RHeap::ENone,1); |
|
4382 #endif |
|
4383 |
|
4384 //if ( typeid ( cati ) != typeid( catc ) ) //compiler error |
|
4385 // failures++; |
|
4386 |
|
4387 |
|
4388 // if ( typeid ( vi.begin( ) ) == typeid( vc.begin( ) ) ) |
|
4389 //failures++; |
|
4390 /* if(failures) |
|
4391 return KErrGeneral; |
|
4392 return KErrNone;*/ |
|
4393 |
|
4394 |
|
4395 //#if STDCPP_OOM |
|
4396 //failures++; |
|
4397 // #endif |
|
4398 |
|
4399 |
|
4400 |
|
4401 |
|
4402 } |
|
4403 catch(bad_alloc&) |
|
4404 { |
|
4405 //do nothing |
|
4406 } |
|
4407 catch(...) |
|
4408 { |
|
4409 failures++; |
|
4410 |
|
4411 } |
|
4412 |
|
4413 if(failures ) |
|
4414 return KErrGeneral; |
|
4415 return KErrNone; |
|
4416 } |
|
4417 |
|
4418 TInt Ctstl_2::map1(CStifItemParser& aItem) |
|
4419 { |
|
4420 |
|
4421 int failures=0; |
|
4422 //insert,begin,map |
|
4423 try |
|
4424 { |
|
4425 // cout<<""; |
|
4426 #if STDCPP_OOM |
|
4427 User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1); |
|
4428 #endif |
|
4429 map <int, int> m1; |
|
4430 |
|
4431 map <int, int> :: iterator m1_Iter; |
|
4432 map <int, int> :: const_iterator m1_cIter; |
|
4433 typedef pair <int, int> Int_Pair; |
|
4434 |
|
4435 m1.insert ( Int_Pair ( 0, 0 ) ); |
|
4436 m1.insert ( Int_Pair ( 1, 1 ) ); |
|
4437 m1.insert ( Int_Pair ( 2, 4 ) ); |
|
4438 |
|
4439 m1_cIter = m1.begin ( ); |
|
4440 if(m1_cIter -> first != 0) |
|
4441 failures++; |
|
4442 |
|
4443 m1_Iter = m1.begin ( ); |
|
4444 m1.erase ( m1_Iter ); |
|
4445 |
|
4446 |
|
4447 |
|
4448 m1_cIter = m1.begin( ); |
|
4449 |
|
4450 #if STDCPP_OOM |
|
4451 User::__DbgSetAllocFail(FALSE,RHeap::ENone,1); |
|
4452 #endif |
|
4453 if( m1_cIter -> first !=1) |
|
4454 failures++; |
|
4455 /* |
|
4456 if(failures) |
|
4457 return KErrGeneral; |
|
4458 else |
|
4459 return KErrNone; |
|
4460 */ |
|
4461 |
|
4462 //#if STDCPP_OOM |
|
4463 //failures++; |
|
4464 // #endif |
|
4465 |
|
4466 } |
|
4467 |
|
4468 catch(bad_alloc&) |
|
4469 { |
|
4470 //do nothing |
|
4471 } |
|
4472 catch(...) |
|
4473 { |
|
4474 failures++; |
|
4475 |
|
4476 } |
|
4477 |
|
4478 if(failures ) |
|
4479 return KErrGeneral; |
|
4480 return KErrNone; |
|
4481 } |
|
4482 |
|
4483 |
|
4484 |
|
4485 TInt Ctstl_2::map2(CStifItemParser& aItem) |
|
4486 { |
|
4487 //clear,size |
|
4488 |
|
4489 int failures=0; |
|
4490 |
|
4491 try |
|
4492 { |
|
4493 map<int, int> m1; |
|
4494 map<int, int>::size_type i; |
|
4495 typedef pair<int, int> Int_Pair; |
|
4496 // cout<<""; |
|
4497 #if STDCPP_OOM |
|
4498 User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1); |
|
4499 #endif |
|
4500 m1.insert(Int_Pair(1, 1)); |
|
4501 m1.insert(Int_Pair(2, 4)); |
|
4502 |
|
4503 i = m1.size(); |
|
4504 if(i!=2) |
|
4505 failures++; |
|
4506 |
|
4507 m1.clear(); |
|
4508 i = m1.size(); |
|
4509 |
|
4510 #if STDCPP_OOM |
|
4511 User::__DbgSetAllocFail(FALSE,RHeap::ENone,1); |
|
4512 #endif |
|
4513 if(i!=0) |
|
4514 failures++; |
|
4515 |
|
4516 /* |
|
4517 if(failures) |
|
4518 return KErrGeneral; |
|
4519 else |
|
4520 return KErrNone; |
|
4521 */ |
|
4522 |
|
4523 //#if STDCPP_OOM |
|
4524 //failures++; |
|
4525 // #endif |
|
4526 |
|
4527 } |
|
4528 |
|
4529 catch(bad_alloc&) |
|
4530 { |
|
4531 //do nothing |
|
4532 } |
|
4533 catch(...) |
|
4534 { |
|
4535 failures++; |
|
4536 |
|
4537 } |
|
4538 |
|
4539 if(failures ) |
|
4540 return KErrGeneral; |
|
4541 return KErrNone; |
|
4542 } |
|
4543 |
|
4544 TInt Ctstl_2::map3(CStifItemParser& aItem) |
|
4545 { |
|
4546 //count |
|
4547 int failures=0; |
|
4548 |
|
4549 try |
|
4550 { |
|
4551 map<int, int> m1; |
|
4552 map<int, int>::size_type i; |
|
4553 typedef pair<int, int> Int_Pair; |
|
4554 |
|
4555 m1.insert(Int_Pair(1, 1)); |
|
4556 m1.insert(Int_Pair(2, 1)); |
|
4557 m1.insert(Int_Pair(1, 4)); |
|
4558 m1.insert(Int_Pair(2, 1)); |
|
4559 // cout<<""; |
|
4560 #if STDCPP_OOM |
|
4561 User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1); |
|
4562 #endif |
|
4563 // Keys must be unique in map, so duplicates are ignored |
|
4564 i = m1.count(1); |
|
4565 if(i!=1) |
|
4566 failures++; |
|
4567 |
|
4568 #if STDCPP_OOM |
|
4569 User::__DbgSetAllocFail(FALSE,RHeap::ENone,1); |
|
4570 #endif |
|
4571 i = m1.count(2); |
|
4572 if(i!=1) |
|
4573 failures++; |
|
4574 |
|
4575 i = m1.count(3); |
|
4576 if(i!=0) |
|
4577 failures++; |
|
4578 |
|
4579 |
|
4580 |
|
4581 /* |
|
4582 |
|
4583 if(failures) |
|
4584 return KErrGeneral; |
|
4585 else |
|
4586 return KErrNone; |
|
4587 */ |
|
4588 //#if STDCPP_OOM |
|
4589 //failures++; |
|
4590 // #endif |
|
4591 |
|
4592 } |
|
4593 catch(bad_alloc&) |
|
4594 { |
|
4595 //do nothing |
|
4596 } |
|
4597 catch(...) |
|
4598 { |
|
4599 failures++; |
|
4600 |
|
4601 } |
|
4602 |
|
4603 if(failures ) |
|
4604 return KErrGeneral; |
|
4605 return KErrNone; |
|
4606 } |
|
4607 |
|
4608 TInt Ctstl_2::map4(CStifItemParser& aItem) |
|
4609 { |
|
4610 //empty |
|
4611 int failures=0; |
|
4612 |
|
4613 try |
|
4614 { |
|
4615 map <int, int> m1, m2; |
|
4616 |
|
4617 typedef pair <int, int> Int_Pair; |
|
4618 m1.insert ( Int_Pair ( 1, 1 ) ); |
|
4619 // cout<<""; |
|
4620 #if STDCPP_OOM |
|
4621 User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1); |
|
4622 #endif |
|
4623 if ( m1.empty( ) ) |
|
4624 failures++; |
|
4625 |
|
4626 if ( !m2.empty( ) ) |
|
4627 failures++; |
|
4628 |
|
4629 #if STDCPP_OOM |
|
4630 User::__DbgSetAllocFail(FALSE,RHeap::ENone,1); |
|
4631 #endif |
|
4632 /* |
|
4633 if(failures) |
|
4634 return KErrGeneral; |
|
4635 else |
|
4636 return KErrNone; |
|
4637 */ |
|
4638 |
|
4639 |
|
4640 //#if STDCPP_OOM |
|
4641 //failures++; |
|
4642 // #endif |
|
4643 |
|
4644 } |
|
4645 |
|
4646 |
|
4647 catch(bad_alloc&) |
|
4648 { |
|
4649 //do nothing |
|
4650 } |
|
4651 catch(...) |
|
4652 { |
|
4653 failures++; |
|
4654 |
|
4655 } |
|
4656 |
|
4657 if(failures ) |
|
4658 return KErrGeneral; |
|
4659 return KErrNone; |
|
4660 } |
|
4661 |
|
4662 TInt Ctstl_2::map5(CStifItemParser& aItem) |
|
4663 { |
|
4664 //erase,end |
|
4665 int failures=0; |
|
4666 |
|
4667 try |
|
4668 { |
|
4669 map <int, int> m1; |
|
4670 |
|
4671 map <int, int> :: iterator m1_Iter; |
|
4672 map <int, int> :: const_iterator m1_cIter; |
|
4673 typedef pair <int, int> Int_Pair; |
|
4674 |
|
4675 m1.insert ( Int_Pair ( 1, 10 ) ); |
|
4676 m1.insert ( Int_Pair ( 2, 20 ) ); |
|
4677 m1.insert ( Int_Pair ( 3, 30 ) ); |
|
4678 // cout<<""; |
|
4679 #if STDCPP_OOM |
|
4680 User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1); |
|
4681 #endif |
|
4682 m1_cIter = m1.end( ); |
|
4683 m1_cIter--; |
|
4684 |
|
4685 if( m1_cIter -> second != 30) |
|
4686 failures++; |
|
4687 |
|
4688 m1_Iter = m1.end( ); |
|
4689 m1_Iter--; |
|
4690 m1.erase ( m1_Iter ); |
|
4691 |
|
4692 |
|
4693 |
|
4694 m1_cIter = m1.end( ); |
|
4695 m1_cIter--; |
|
4696 if( m1_cIter -> second !=20) |
|
4697 failures++; |
|
4698 #if STDCPP_OOM |
|
4699 User::__DbgSetAllocFail(FALSE,RHeap::ENone,1); |
|
4700 #endif |
|
4701 /* |
|
4702 if(failures) |
|
4703 return KErrGeneral; |
|
4704 else |
|
4705 return KErrNone; |
|
4706 */ |
|
4707 //#if STDCPP_OOM |
|
4708 //failures++; |
|
4709 // #endif |
|
4710 |
|
4711 } |
|
4712 catch(bad_alloc&) |
|
4713 { |
|
4714 //do nothing |
|
4715 } |
|
4716 catch(...) |
|
4717 { |
|
4718 failures++; |
|
4719 |
|
4720 } |
|
4721 |
|
4722 if(failures ) |
|
4723 return KErrGeneral; |
|
4724 return KErrNone; |
|
4725 } |
|
4726 |
|
4727 |
|
4728 TInt Ctstl_2::map6(CStifItemParser& aItem) |
|
4729 { |
|
4730 //equal_range,upper_bound |
|
4731 int failures=0; |
|
4732 |
|
4733 try |
|
4734 { |
|
4735 typedef map <int, int, less<int> > IntMap; |
|
4736 IntMap m1; |
|
4737 map <int, int> :: const_iterator m1_RcIter; |
|
4738 typedef pair <int, int> Int_Pair; |
|
4739 |
|
4740 m1.insert ( Int_Pair ( 1, 10 ) ); |
|
4741 m1.insert ( Int_Pair ( 2, 20 ) ); |
|
4742 m1.insert ( Int_Pair ( 3, 30 ) ); |
|
4743 |
|
4744 pair <IntMap::const_iterator, IntMap::const_iterator> p1, p2; |
|
4745 p1 = m1.equal_range( 2 ); |
|
4746 |
|
4747 if( p1.first -> second !=20) |
|
4748 failures++; |
|
4749 |
|
4750 |
|
4751 if( p1.second -> second != 30) |
|
4752 failures++; |
|
4753 // cout<<""; |
|
4754 #if STDCPP_OOM |
|
4755 User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1); |
|
4756 #endif |
|
4757 |
|
4758 // Compare the upper_bound called directly |
|
4759 m1_RcIter = m1.upper_bound( 2 ); |
|
4760 |
|
4761 if( m1_RcIter -> second!=30) |
|
4762 failures++; |
|
4763 |
|
4764 p2 = m1.equal_range( 4 ); |
|
4765 |
|
4766 // If no match is found for the key, |
|
4767 // both elements of the pair return end( ) |
|
4768 if ( ( p2.first == m1.end( ) ) && ( p2.second == m1.end( ) ) == 0) |
|
4769 failures++; |
|
4770 #if STDCPP_OOM |
|
4771 User::__DbgSetAllocFail(FALSE,RHeap::ENone,1); |
|
4772 #endif |
|
4773 /* |
|
4774 if(failures) |
|
4775 return KErrGeneral; |
|
4776 else |
|
4777 return KErrNone; |
|
4778 */ |
|
4779 |
|
4780 |
|
4781 //#if STDCPP_OOM |
|
4782 //failures++; |
|
4783 // #endif |
|
4784 |
|
4785 } |
|
4786 |
|
4787 catch(bad_alloc&) |
|
4788 { |
|
4789 //do nothing |
|
4790 } |
|
4791 catch(...) |
|
4792 { |
|
4793 failures++; |
|
4794 |
|
4795 } |
|
4796 |
|
4797 if(failures ) |
|
4798 return KErrGeneral; |
|
4799 return KErrNone; |
|
4800 } |
|
4801 |
|
4802 TInt Ctstl_2::map7(CStifItemParser& aItem) |
|
4803 { |
|
4804 //find |
|
4805 int failures=0; |
|
4806 |
|
4807 try |
|
4808 { |
|
4809 map <int, int> m1; |
|
4810 map <int, int> :: const_iterator m1_AcIter, m1_RcIter; |
|
4811 typedef pair <int, int> Int_Pair; |
|
4812 |
|
4813 m1.insert ( Int_Pair ( 1, 10 ) ); |
|
4814 m1.insert ( Int_Pair ( 2, 20 ) ); |
|
4815 m1.insert ( Int_Pair ( 3, 30 ) ); |
|
4816 // cout<<""; |
|
4817 #if STDCPP_OOM |
|
4818 User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1); |
|
4819 #endif |
|
4820 m1_RcIter = m1.find( 2 ); |
|
4821 if( m1_RcIter -> second != 20) |
|
4822 failures++; |
|
4823 |
|
4824 // If no match is found for the key, end( ) is returned |
|
4825 m1_RcIter = m1.find( 4 ); |
|
4826 |
|
4827 if ( m1_RcIter == m1.end( ) ); |
|
4828 // cout << "The map m1 doesn't have an element " |
|
4829 // << "with a key of 4." << endl; |
|
4830 else |
|
4831 if( m1_RcIter -> second != 4) |
|
4832 failures++; |
|
4833 |
|
4834 |
|
4835 // The element at a specific location in the map can be found |
|
4836 // using a dereferenced iterator addressing the location |
|
4837 m1_AcIter = m1.end( ); |
|
4838 m1_AcIter--; |
|
4839 m1_RcIter = m1.find( m1_AcIter -> first ); |
|
4840 if( m1_RcIter -> second != 30) |
|
4841 failures++; |
|
4842 |
|
4843 #if STDCPP_OOM |
|
4844 User::__DbgSetAllocFail(FALSE,RHeap::ENone,1); |
|
4845 #endif |
|
4846 /* |
|
4847 if(failures) |
|
4848 return KErrGeneral; |
|
4849 else |
|
4850 return KErrNone; |
|
4851 */ |
|
4852 |
|
4853 //#if STDCPP_OOM |
|
4854 //failures++; |
|
4855 // #endif |
|
4856 |
|
4857 |
|
4858 } |
|
4859 catch(bad_alloc&) |
|
4860 { |
|
4861 //do nothing |
|
4862 } |
|
4863 catch(...) |
|
4864 { |
|
4865 failures++; |
|
4866 |
|
4867 } |
|
4868 |
|
4869 if(failures ) |
|
4870 return KErrGeneral; |
|
4871 return KErrNone; |
|
4872 } |
|
4873 |
|
4874 TInt Ctstl_2::map8(CStifItemParser& aItem) |
|
4875 { |
|
4876 |
|
4877 //key_comp |
|
4878 int failures=0; |
|
4879 |
|
4880 try |
|
4881 { |
|
4882 |
|
4883 map <int, int, less<int> > m1; |
|
4884 map <int, int, less<int> >::key_compare kc1 = m1.key_comp( ) ; |
|
4885 bool result1 = kc1( 2, 3 ) ; |
|
4886 // cout<<""; |
|
4887 #if STDCPP_OOM |
|
4888 User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1); |
|
4889 #endif |
|
4890 if( result1 == false) |
|
4891 failures++; |
|
4892 |
|
4893 |
|
4894 |
|
4895 map <int, int, greater<int> > m2; |
|
4896 map <int, int, greater<int> >::key_compare kc2 = m2.key_comp( ); |
|
4897 bool result2 = kc2( 2, 3 ) ; |
|
4898 if( result2 == true ) |
|
4899 failures++; |
|
4900 |
|
4901 #if STDCPP_OOM |
|
4902 User::__DbgSetAllocFail(FALSE,RHeap::ENone,1); |
|
4903 #endif |
|
4904 /* |
|
4905 if(failures) |
|
4906 return KErrGeneral; |
|
4907 else |
|
4908 return KErrNone; |
|
4909 */ |
|
4910 |
|
4911 |
|
4912 //#if STDCPP_OOM |
|
4913 //failures++; |
|
4914 // #endif |
|
4915 |
|
4916 |
|
4917 } |
|
4918 catch(bad_alloc&) |
|
4919 { |
|
4920 //do nothing |
|
4921 } |
|
4922 catch(...) |
|
4923 { |
|
4924 failures++; |
|
4925 |
|
4926 } |
|
4927 |
|
4928 if(failures ) |
|
4929 return KErrGeneral; |
|
4930 return KErrNone; |
|
4931 } |
|
4932 |
|
4933 TInt Ctstl_2::map9(CStifItemParser& aItem) |
|
4934 |
|
4935 { |
|
4936 |
|
4937 |
|
4938 //lowerbound |
|
4939 int failures=0; |
|
4940 |
|
4941 |
|
4942 try |
|
4943 |
|
4944 { |
|
4945 map <int, int> m1; |
|
4946 map <int, int> :: const_iterator m1_AcIter, m1_RcIter; |
|
4947 typedef pair <int, int> Int_Pair; |
|
4948 |
|
4949 m1.insert ( Int_Pair ( 1, 10 ) ); |
|
4950 m1.insert ( Int_Pair ( 2, 20 ) ); |
|
4951 m1.insert ( Int_Pair ( 3, 30 ) ); |
|
4952 // cout<<""; |
|
4953 #if STDCPP_OOM |
|
4954 User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1); |
|
4955 #endif |
|
4956 m1_RcIter = m1.lower_bound( 2 ); |
|
4957 |
|
4958 if( m1_RcIter -> second != 20) |
|
4959 failures++; |
|
4960 |
|
4961 |
|
4962 // If no match is found for this key, end( ) is returned |
|
4963 m1_RcIter = m1. lower_bound ( 4 ); |
|
4964 |
|
4965 if ( m1_RcIter == m1.end( ) ); |
|
4966 // << "The map m1 doesn't have an element " |
|
4967 // << "with a key of 4." << endl; |
|
4968 else |
|
4969 if( m1_RcIter -> second != 4) |
|
4970 failures++; |
|
4971 |
|
4972 |
|
4973 // The element at a specific location in the map can be found |
|
4974 // using a dereferenced iterator addressing the location |
|
4975 m1_AcIter = m1.end( ); |
|
4976 m1_AcIter--; |
|
4977 m1_RcIter = m1. lower_bound ( m1_AcIter -> first ); |
|
4978 if( m1_RcIter -> second != 30) |
|
4979 failures++; |
|
4980 #if STDCPP_OOM |
|
4981 User::__DbgSetAllocFail(FALSE,RHeap::ENone,1); |
|
4982 #endif |
|
4983 /* |
|
4984 if(failures) |
|
4985 return KErrGeneral; |
|
4986 else |
|
4987 return KErrNone; |
|
4988 */ |
|
4989 |
|
4990 //#if STDCPP_OOM |
|
4991 //failures++; |
|
4992 // #endif |
|
4993 |
|
4994 |
|
4995 } |
|
4996 catch(bad_alloc&) |
|
4997 { |
|
4998 //do nothing |
|
4999 } |
|
5000 catch(...) |
|
5001 { |
|
5002 failures++; |
|
5003 |
|
5004 } |
|
5005 |
|
5006 if(failures ) |
|
5007 return KErrGeneral; |
|
5008 return KErrNone; |
|
5009 } |
|
5010 |
|
5011 TInt Ctstl_2::map10(CStifItemParser& aItem) |
|
5012 |
|
5013 { |
|
5014 //swap |
|
5015 int failures=0; |
|
5016 |
|
5017 try |
|
5018 |
|
5019 { |
|
5020 int a[2]; |
|
5021 using namespace std; |
|
5022 map <int, int> m1, m2, m3; |
|
5023 map <int, int>::iterator m1_Iter; |
|
5024 typedef pair <int, int> Int_Pair; |
|
5025 |
|
5026 m1.insert ( Int_Pair ( 1, 10 ) ); |
|
5027 m1.insert ( Int_Pair ( 2, 20 ) ); |
|
5028 m1.insert ( Int_Pair ( 3, 30 ) ); |
|
5029 m2.insert ( Int_Pair ( 10, 100 ) ); |
|
5030 m2.insert ( Int_Pair ( 20, 200 ) ); |
|
5031 m3.insert ( Int_Pair ( 30, 300 ) ); |
|
5032 |
|
5033 // cout<<""; |
|
5034 #if STDCPP_OOM |
|
5035 User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1); |
|
5036 #endif |
|
5037 |
|
5038 m1.swap( m2 ); |
|
5039 |
|
5040 for ( m1_Iter = m1.begin( ); m1_Iter != m1.end( ); m1_Iter++ ) |
|
5041 { |
|
5042 static int i; |
|
5043 |
|
5044 a[i] = m1_Iter -> second; |
|
5045 |
|
5046 i++; |
|
5047 |
|
5048 } |
|
5049 if(a[0]!=100) |
|
5050 failures++; |
|
5051 if(a[1]!= 200) |
|
5052 failures++; |
|
5053 |
|
5054 |
|
5055 swap( m1, m3 ); |
|
5056 |
|
5057 for ( m1_Iter = m1.begin( ); m1_Iter != m1.end( ); m1_Iter++ ) |
|
5058 { |
|
5059 |
|
5060 |
|
5061 int a= m1_Iter -> second; |
|
5062 if(a!=300) |
|
5063 failures++; |
|
5064 } |
|
5065 |
|
5066 #if STDCPP_OOM |
|
5067 User::__DbgSetAllocFail(FALSE,RHeap::ENone,1); |
|
5068 #endif |
|
5069 /* |
|
5070 if(failures) |
|
5071 return KErrGeneral; |
|
5072 else |
|
5073 return KErrNone; |
|
5074 */ |
|
5075 |
|
5076 |
|
5077 //#if STDCPP_OOM |
|
5078 //failures++; |
|
5079 // #endif |
|
5080 |
|
5081 } |
|
5082 catch(bad_alloc&) |
|
5083 { |
|
5084 //do nothing |
|
5085 } |
|
5086 catch(...) |
|
5087 { |
|
5088 failures++; |
|
5089 |
|
5090 } |
|
5091 |
|
5092 if(failures ) |
|
5093 return KErrGeneral; |
|
5094 return KErrNone; |
|
5095 } |
|
5096 |
|
5097 |
|
5098 |
|
5099 TInt Ctstl_2::map11(CStifItemParser& aItem) |
|
5100 { |
|
5101 |
|
5102 |
|
5103 int failures=0; |
|
5104 |
|
5105 try |
|
5106 { |
|
5107 map <int, int, less<int> > m1; |
|
5108 map <int, int, less<int> >::value_compare vc1 = m1.value_comp( ); |
|
5109 pair< map<int,int>::iterator, bool > pr1, pr2; |
|
5110 |
|
5111 pr1= m1.insert ( map <int, int> :: value_type ( 1, 10 ) ); |
|
5112 pr2= m1.insert ( map <int, int> :: value_type ( 2, 5 ) ); // cout<<""; |
|
5113 #if STDCPP_OOM |
|
5114 User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1); |
|
5115 #endif |
|
5116 if( vc1( *pr1.first, *pr2.first ) == false ) |
|
5117 |
|
5118 failures++; |
|
5119 |
|
5120 |
|
5121 |
|
5122 if(vc1( *pr2.first, *pr1.first ) == true ) |
|
5123 |
|
5124 failures++; |
|
5125 |
|
5126 #if STDCPP_OOM |
|
5127 User::__DbgSetAllocFail(FALSE,RHeap::ENone,1); |
|
5128 #endif |
|
5129 |
|
5130 |
|
5131 /* |
|
5132 if(failures) |
|
5133 return KErrGeneral; |
|
5134 else |
|
5135 return KErrNone;*/ |
|
5136 |
|
5137 //#if STDCPP_OOM |
|
5138 //failures++; |
|
5139 // #endif |
|
5140 } |
|
5141 |
|
5142 catch(bad_alloc&) |
|
5143 { |
|
5144 //do nothing |
|
5145 } |
|
5146 catch(...) |
|
5147 { |
|
5148 failures++; |
|
5149 |
|
5150 } |
|
5151 |
|
5152 if(failures ) |
|
5153 return KErrGeneral; |
|
5154 return KErrNone; |
|
5155 } |
|
5156 |
|
5157 TInt Ctstl_2::map12(CStifItemParser& aItem) |
|
5158 { |
|
5159 |
|
5160 |
|
5161 int psize,failures=0; |
|
5162 try |
|
5163 { |
|
5164 map<char,int> mymap; |
|
5165 pair<const char,int>* p; // cout<<""; |
|
5166 #if STDCPP_OOM |
|
5167 User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1); |
|
5168 #endif |
|
5169 p=mymap.get_allocator().allocate(2); |
|
5170 |
|
5171 psize = (int) sizeof(map<char,int>::value_type)*2; |
|
5172 |
|
5173 if(psize!=16) |
|
5174 failures++; |
|
5175 |
|
5176 |
|
5177 mymap.get_allocator().deallocate(p,2); |
|
5178 |
|
5179 #if STDCPP_OOM |
|
5180 User::__DbgSetAllocFail(FALSE,RHeap::ENone,1); |
|
5181 #endif |
|
5182 if(mymap.max_size()!=4294967295) |
|
5183 failures++; |
|
5184 |
|
5185 |
|
5186 /* |
|
5187 if(failures) |
|
5188 return KErrGeneral; |
|
5189 else |
|
5190 return KErrNone;*/ |
|
5191 //#if STDCPP_OOM |
|
5192 //failures++; |
|
5193 // #endif |
|
5194 } |
|
5195 |
|
5196 catch(bad_alloc&) |
|
5197 { |
|
5198 //do nothing |
|
5199 } |
|
5200 catch(...) |
|
5201 { |
|
5202 failures++; |
|
5203 |
|
5204 } |
|
5205 |
|
5206 if(failures ) |
|
5207 return KErrGeneral; |
|
5208 return KErrNone; |
|
5209 } |
|
5210 |
|
5211 |
|
5212 TInt Ctstl_2::map13(CStifItemParser& aItem) |
|
5213 { |
|
5214 |
|
5215 int failures=0; |
|
5216 |
|
5217 try |
|
5218 { |
|
5219 map<char,int> mymap; |
|
5220 map<char,int>::reverse_iterator rit; |
|
5221 |
|
5222 mymap['x'] = 100; |
|
5223 mymap['y'] = 200; // cout<<""; |
|
5224 |
|
5225 #if STDCPP_OOM |
|
5226 User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1); |
|
5227 #endif |
|
5228 for ( rit=mymap.rbegin() ; rit != mymap.rend(); rit++ ) |
|
5229 |
|
5230 |
|
5231 { |
|
5232 static int i; |
|
5233 if(i==0) |
|
5234 { |
|
5235 |
|
5236 |
|
5237 if( rit->second !=200) |
|
5238 failures++; |
|
5239 } |
|
5240 i++; |
|
5241 } |
|
5242 |
|
5243 #if STDCPP_OOM |
|
5244 User::__DbgSetAllocFail(FALSE,RHeap::ENone,1); |
|
5245 #endif |
|
5246 |
|
5247 /* |
|
5248 if(failures) |
|
5249 return KErrGeneral; |
|
5250 else |
|
5251 return KErrNone;*/ |
|
5252 |
|
5253 |
|
5254 //#if STDCPP_OOM |
|
5255 //failures++; |
|
5256 // #endif |
|
5257 } |
|
5258 catch(bad_alloc&) |
|
5259 { |
|
5260 //do nothing |
|
5261 } |
|
5262 catch(...) |
|
5263 { |
|
5264 failures++; |
|
5265 |
|
5266 } |
|
5267 |
|
5268 if(failures ) |
|
5269 return KErrGeneral; |
|
5270 return KErrNone; |
|
5271 } |
|
5272 |
|
5273 |
|
5274 TInt Ctstl_2::multimap1(CStifItemParser& aItem) |
|
5275 { |
|
5276 |
|
5277 |
|
5278 |
|
5279 |
|
5280 multimap <int, int> m1; |
|
5281 int failures=0; |
|
5282 |
|
5283 try{ // cout<<""; |
|
5284 #if STDCPP_OOM |
|
5285 User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1); |
|
5286 #endif |
|
5287 multimap <int, int> :: iterator m1_Iter; |
|
5288 multimap <int, int> :: const_iterator m1_cIter; |
|
5289 typedef pair <int, int> Int_Pair; |
|
5290 |
|
5291 m1.insert ( Int_Pair ( 0, 0 ) ); |
|
5292 m1.insert ( Int_Pair ( 1, 1 ) ); |
|
5293 m1.insert ( Int_Pair ( 2, 4 ) ); |
|
5294 |
|
5295 m1_cIter = m1.begin ( ); |
|
5296 if(m1_cIter -> first != 0) |
|
5297 failures++; |
|
5298 |
|
5299 m1_Iter = m1.begin ( ); |
|
5300 m1.erase ( m1_Iter ); |
|
5301 |
|
5302 |
|
5303 |
|
5304 m1_cIter = m1.begin( ); |
|
5305 if( m1_cIter -> first !=1) |
|
5306 failures++; |
|
5307 #if STDCPP_OOM |
|
5308 User::__DbgSetAllocFail(FALSE,RHeap::ENone,1); |
|
5309 #endif |
|
5310 |
|
5311 /*if(failures) |
|
5312 return KErrGeneral; |
|
5313 else |
|
5314 return KErrNone; |
|
5315 */ |
|
5316 |
|
5317 //#if STDCPP_OOM |
|
5318 //failures++; |
|
5319 // #endif |
|
5320 |
|
5321 } |
|
5322 |
|
5323 |
|
5324 catch(bad_alloc&) |
|
5325 { |
|
5326 //do nothing |
|
5327 } |
|
5328 catch(...) |
|
5329 { |
|
5330 failures++; |
|
5331 |
|
5332 } |
|
5333 |
|
5334 if(failures ) |
|
5335 return KErrGeneral; |
|
5336 return KErrNone; |
|
5337 } |
|
5338 |
|
5339 |
|
5340 TInt Ctstl_2::multimap2(CStifItemParser& aItem) |
|
5341 { |
|
5342 //clear,size |
|
5343 |
|
5344 int failures=0; |
|
5345 |
|
5346 try |
|
5347 { |
|
5348 multimap<int, int> m1; |
|
5349 multimap<int, int>::size_type i; |
|
5350 typedef pair<int, int> Int_Pair; // cout<<""; |
|
5351 #if STDCPP_OOM |
|
5352 User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1); |
|
5353 #endif |
|
5354 m1.insert(Int_Pair(1, 1)); |
|
5355 m1.insert(Int_Pair(2, 4)); |
|
5356 |
|
5357 i = m1.size(); |
|
5358 if(i!=2) |
|
5359 failures++; |
|
5360 |
|
5361 m1.clear(); |
|
5362 i = m1.size(); |
|
5363 if(i!=0) |
|
5364 failures++; |
|
5365 |
|
5366 #if STDCPP_OOM |
|
5367 User::__DbgSetAllocFail(FALSE,RHeap::ENone,1); |
|
5368 #endif |
|
5369 /*if(failures) |
|
5370 return KErrGeneral; |
|
5371 else |
|
5372 return KErrNone;*/ |
|
5373 |
|
5374 //#if STDCPP_OOM |
|
5375 //failures++; |
|
5376 // #endif |
|
5377 |
|
5378 |
|
5379 } |
|
5380 |
|
5381 catch(bad_alloc&) |
|
5382 { |
|
5383 //do nothing |
|
5384 } |
|
5385 catch(...) |
|
5386 { |
|
5387 failures++; |
|
5388 |
|
5389 } |
|
5390 |
|
5391 if(failures ) |
|
5392 return KErrGeneral; |
|
5393 return KErrNone; |
|
5394 } |
|
5395 |
|
5396 |
|
5397 |
|
5398 TInt Ctstl_2::multimap3(CStifItemParser& aItem) |
|
5399 { |
|
5400 //count |
|
5401 int failures=0; |
|
5402 |
|
5403 |
|
5404 try |
|
5405 { |
|
5406 |
|
5407 multimap<int, int> m1; |
|
5408 multimap<int, int>::size_type i; |
|
5409 typedef pair<int, int> Int_Pair; |
|
5410 |
|
5411 m1.insert(Int_Pair(1, 1)); |
|
5412 m1.insert(Int_Pair(2, 1)); |
|
5413 m1.insert(Int_Pair(1, 4)); |
|
5414 m1.insert(Int_Pair(2, 1)); |
|
5415 |
|
5416 // Keys must be unique in multimap, so duplicates are ignored |
|
5417 #if STDCPP_OOM |
|
5418 User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1); |
|
5419 #endif |
|
5420 i = m1.count(1); |
|
5421 if(i!=2) |
|
5422 failures++; |
|
5423 |
|
5424 |
|
5425 i = m1.count(2); |
|
5426 if(i!=2) |
|
5427 failures++; |
|
5428 |
|
5429 i = m1.count(3); |
|
5430 if(i!=0) |
|
5431 failures++; |
|
5432 #if STDCPP_OOM |
|
5433 User::__DbgSetAllocFail(FALSE,RHeap::ENone,1); |
|
5434 #endif |
|
5435 /* |
|
5436 |
|
5437 if(failures) |
|
5438 return KErrGeneral; |
|
5439 else |
|
5440 return KErrNone;*/ |
|
5441 |
|
5442 //#if STDCPP_OOM |
|
5443 //failures++; |
|
5444 // #endif |
|
5445 |
|
5446 |
|
5447 } |
|
5448 catch(bad_alloc&) |
|
5449 { |
|
5450 //do nothing |
|
5451 } |
|
5452 catch(...) |
|
5453 { |
|
5454 failures++; |
|
5455 |
|
5456 } |
|
5457 |
|
5458 if(failures ) |
|
5459 return KErrGeneral; |
|
5460 return KErrNone; |
|
5461 } |
|
5462 |
|
5463 TInt Ctstl_2::multimap4(CStifItemParser& aItem) |
|
5464 { |
|
5465 //empty |
|
5466 int failures=0; |
|
5467 |
|
5468 try |
|
5469 { |
|
5470 multimap <int, int> m1, m2; |
|
5471 |
|
5472 typedef pair <int, int> Int_Pair; |
|
5473 m1.insert ( Int_Pair ( 1, 1 ) ); |
|
5474 #if STDCPP_OOM |
|
5475 User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1); |
|
5476 #endif |
|
5477 if ( m1.empty( ) ) |
|
5478 failures++; |
|
5479 |
|
5480 if ( !m2.empty( ) ) |
|
5481 failures++; |
|
5482 |
|
5483 /*if(failures) |
|
5484 return KErrGeneral; |
|
5485 else |
|
5486 return KErrNone;*/ |
|
5487 #if STDCPP_OOM |
|
5488 User::__DbgSetAllocFail(FALSE,RHeap::ENone,1); |
|
5489 #endif |
|
5490 //#if STDCPP_OOM |
|
5491 //failures++; |
|
5492 // #endif |
|
5493 |
|
5494 |
|
5495 } |
|
5496 |
|
5497 |
|
5498 catch(bad_alloc&) |
|
5499 { |
|
5500 //do nothing |
|
5501 } |
|
5502 catch(...) |
|
5503 { |
|
5504 failures++; |
|
5505 |
|
5506 } |
|
5507 |
|
5508 if(failures ) |
|
5509 return KErrGeneral; |
|
5510 return KErrNone; |
|
5511 } |
|
5512 |
|
5513 TInt Ctstl_2::multimap5(CStifItemParser& aItem) |
|
5514 { |
|
5515 //erase,end |
|
5516 int failures=0; |
|
5517 |
|
5518 try |
|
5519 { |
|
5520 |
|
5521 multimap <int, int> m1; |
|
5522 |
|
5523 multimap <int, int> :: iterator m1_Iter; |
|
5524 multimap <int, int> :: const_iterator m1_cIter; |
|
5525 typedef pair <int, int> Int_Pair; |
|
5526 |
|
5527 m1.insert ( Int_Pair ( 1, 10 ) ); |
|
5528 m1.insert ( Int_Pair ( 2, 20 ) ); |
|
5529 m1.insert ( Int_Pair ( 3, 30 ) ); |
|
5530 #if STDCPP_OOM |
|
5531 User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1); |
|
5532 #endif |
|
5533 m1_cIter = m1.end( ); |
|
5534 m1_cIter--; |
|
5535 |
|
5536 if( m1_cIter -> second != 30) |
|
5537 failures++; |
|
5538 |
|
5539 m1_Iter = m1.end( ); |
|
5540 m1_Iter--; |
|
5541 m1.erase ( m1_Iter ); |
|
5542 |
|
5543 |
|
5544 |
|
5545 m1_cIter = m1.end( ); |
|
5546 m1_cIter--; |
|
5547 #if STDCPP_OOM |
|
5548 User::__DbgSetAllocFail(FALSE,RHeap::ENone,1); |
|
5549 #endif |
|
5550 if( m1_cIter -> second !=20) |
|
5551 failures++; |
|
5552 |
|
5553 |
|
5554 /* if(failures) |
|
5555 return KErrGeneral; |
|
5556 else |
|
5557 return KErrNone;*/ |
|
5558 |
|
5559 //#if STDCPP_OOM |
|
5560 //failures++; |
|
5561 // #endif |
|
5562 |
|
5563 |
|
5564 } |
|
5565 catch(bad_alloc&) |
|
5566 { |
|
5567 //do nothing |
|
5568 } |
|
5569 catch(...) |
|
5570 { |
|
5571 failures++; |
|
5572 |
|
5573 } |
|
5574 |
|
5575 if(failures ) |
|
5576 return KErrGeneral; |
|
5577 return KErrNone; |
|
5578 } |
|
5579 |
|
5580 |
|
5581 TInt Ctstl_2::multimap6(CStifItemParser& aItem) |
|
5582 { |
|
5583 //equal_range,upper_bound |
|
5584 int failures=0; |
|
5585 |
|
5586 try |
|
5587 { |
|
5588 typedef multimap <int, int, less<int> > Intmultimap; |
|
5589 Intmultimap m1; |
|
5590 multimap <int, int> :: const_iterator m1_RcIter; |
|
5591 typedef pair <int, int> Int_Pair; |
|
5592 |
|
5593 m1.insert ( Int_Pair ( 1, 10 ) ); |
|
5594 m1.insert ( Int_Pair ( 2, 20 ) ); |
|
5595 m1.insert ( Int_Pair ( 3, 30 ) ); |
|
5596 #if STDCPP_OOM |
|
5597 User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1); |
|
5598 #endif |
|
5599 pair <Intmultimap::const_iterator, Intmultimap::const_iterator> p1, p2; |
|
5600 p1 = m1.equal_range( 2 ); |
|
5601 |
|
5602 if( p1.first -> second !=20) |
|
5603 failures++; |
|
5604 |
|
5605 |
|
5606 if( p1.second -> second != 30) |
|
5607 failures++; |
|
5608 |
|
5609 |
|
5610 // Compare the upper_bound called directly |
|
5611 m1_RcIter = m1.upper_bound( 2 ); |
|
5612 |
|
5613 if( m1_RcIter -> second!=30) |
|
5614 failures++; |
|
5615 |
|
5616 p2 = m1.equal_range( 4 ); |
|
5617 #if STDCPP_OOM |
|
5618 User::__DbgSetAllocFail(FALSE,RHeap::ENone,1); |
|
5619 #endif |
|
5620 // If no match is found for the key, |
|
5621 // both elements of the pair return end( ) |
|
5622 if ( ( p2.first == m1.end( ) ) && ( p2.second == m1.end( ) ) == 0) |
|
5623 failures++; |
|
5624 |
|
5625 /* |
|
5626 if(failures) |
|
5627 return KErrGeneral; |
|
5628 else |
|
5629 return KErrNone;*/ |
|
5630 |
|
5631 //#if STDCPP_OOM |
|
5632 //failures++; |
|
5633 // #endif |
|
5634 |
|
5635 |
|
5636 } |
|
5637 |
|
5638 catch(bad_alloc&) |
|
5639 { |
|
5640 //do nothing |
|
5641 } |
|
5642 catch(...) |
|
5643 { |
|
5644 failures++; |
|
5645 |
|
5646 } |
|
5647 |
|
5648 if(failures ) |
|
5649 return KErrGeneral; |
|
5650 return KErrNone; |
|
5651 } |
|
5652 |
|
5653 TInt Ctstl_2::multimap7(CStifItemParser& aItem) |
|
5654 { |
|
5655 //find |
|
5656 int failures=0; |
|
5657 |
|
5658 try |
|
5659 { |
|
5660 multimap <int, int> m1; |
|
5661 multimap <int, int> :: const_iterator m1_AcIter, m1_RcIter; |
|
5662 typedef pair <int, int> Int_Pair; |
|
5663 |
|
5664 m1.insert ( Int_Pair ( 1, 10 ) ); |
|
5665 m1.insert ( Int_Pair ( 2, 20 ) ); |
|
5666 m1.insert ( Int_Pair ( 3, 30 ) ); |
|
5667 |
|
5668 #if STDCPP_OOM |
|
5669 User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1); |
|
5670 #endif |
|
5671 m1_RcIter = m1.find( 2 ); |
|
5672 if( m1_RcIter -> second != 20) |
|
5673 failures++; |
|
5674 |
|
5675 // If no match is found for the key, end( ) is returned |
|
5676 m1_RcIter = m1.find( 4 ); |
|
5677 |
|
5678 if ( m1_RcIter == m1.end( ) ); |
|
5679 // cout << "The multimap m1 doesn't have an element " |
|
5680 // << "with a key of 4." << endl; |
|
5681 else |
|
5682 if( m1_RcIter -> second != 4) |
|
5683 failures++; |
|
5684 |
|
5685 |
|
5686 // The element at a specific location in the multimap can be found |
|
5687 // using a dereferenced iterator addressing the location |
|
5688 m1_AcIter = m1.end( ); |
|
5689 m1_AcIter--; |
|
5690 m1_RcIter = m1.find( m1_AcIter -> first ); |
|
5691 |
|
5692 #if STDCPP_OOM |
|
5693 User::__DbgSetAllocFail(FALSE,RHeap::ENone,1); |
|
5694 #endif |
|
5695 if( m1_RcIter -> second != 30) |
|
5696 failures++; |
|
5697 /* |
|
5698 if(failures) |
|
5699 return KErrGeneral; |
|
5700 else |
|
5701 return KErrNone;*/ |
|
5702 |
|
5703 //#if STDCPP_OOM |
|
5704 //failures++; |
|
5705 // #endif |
|
5706 |
|
5707 |
|
5708 |
|
5709 } |
|
5710 |
|
5711 |
|
5712 catch(bad_alloc&) |
|
5713 { |
|
5714 //do nothing |
|
5715 } |
|
5716 catch(...) |
|
5717 { |
|
5718 failures++; |
|
5719 |
|
5720 } |
|
5721 |
|
5722 if(failures ) |
|
5723 return KErrGeneral; |
|
5724 return KErrNone; |
|
5725 } |
|
5726 |
|
5727 |
|
5728 TInt Ctstl_2::multimap8(CStifItemParser& aItem) |
|
5729 { |
|
5730 |
|
5731 //key_comp |
|
5732 int failures=0; |
|
5733 |
|
5734 try |
|
5735 { |
|
5736 |
|
5737 multimap <int, int, less<int> > m1; |
|
5738 multimap <int, int, less<int> >::key_compare kc1 = m1.key_comp( ) ; |
|
5739 bool result1 = kc1( 2, 3 ) ; |
|
5740 |
|
5741 if( result1 == false) |
|
5742 failures++; |
|
5743 |
|
5744 #if STDCPP_OOM |
|
5745 User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1); |
|
5746 #endif |
|
5747 |
|
5748 multimap <int, int, greater<int> > m2; |
|
5749 multimap <int, int, greater<int> >::key_compare kc2 = m2.key_comp( ); |
|
5750 bool result2 = kc2( 2, 3 ) ; |
|
5751 if( result2 == true ) |
|
5752 failures++; |
|
5753 #if STDCPP_OOM |
|
5754 User::__DbgSetAllocFail(FALSE,RHeap::ENone,1); |
|
5755 #endif |
|
5756 /* if(failures) |
|
5757 return KErrGeneral; |
|
5758 else |
|
5759 return KErrNone;*/ |
|
5760 |
|
5761 //#if STDCPP_OOM |
|
5762 //failures++; |
|
5763 // #endif |
|
5764 |
|
5765 } |
|
5766 catch(bad_alloc&) |
|
5767 { |
|
5768 //do nothing |
|
5769 } |
|
5770 catch(...) |
|
5771 { |
|
5772 failures++; |
|
5773 |
|
5774 } |
|
5775 |
|
5776 if(failures ) |
|
5777 return KErrGeneral; |
|
5778 return KErrNone; |
|
5779 } |
|
5780 |
|
5781 TInt Ctstl_2::multimap9(CStifItemParser& aItem) |
|
5782 |
|
5783 { |
|
5784 |
|
5785 |
|
5786 //lowerbound |
|
5787 int failures=0; |
|
5788 |
|
5789 try |
|
5790 { |
|
5791 multimap <int, int> m1; |
|
5792 multimap <int, int> :: const_iterator m1_AcIter, m1_RcIter; |
|
5793 typedef pair <int, int> Int_Pair; |
|
5794 |
|
5795 m1.insert ( Int_Pair ( 1, 10 ) ); |
|
5796 m1.insert ( Int_Pair ( 2, 20 ) ); |
|
5797 m1.insert ( Int_Pair ( 3, 30 ) ); // cout<<""; |
|
5798 #if STDCPP_OOM |
|
5799 User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1); |
|
5800 #endif |
|
5801 m1_RcIter = m1.lower_bound( 2 ); |
|
5802 |
|
5803 if( m1_RcIter -> second != 20) |
|
5804 failures++; |
|
5805 |
|
5806 |
|
5807 // If no match is found for this key, end( ) is returned |
|
5808 m1_RcIter = m1. lower_bound ( 4 ); |
|
5809 |
|
5810 if ( m1_RcIter == m1.end( ) ); |
|
5811 //cout << "The multimap m1 doesn't have an element " |
|
5812 // << "with a key of 4." << endl; |
|
5813 else |
|
5814 if( m1_RcIter -> second != 4) |
|
5815 failures++; |
|
5816 |
|
5817 |
|
5818 // The element at a specific location in the multimap can be found |
|
5819 // using a dereferenced iterator addressing the location |
|
5820 m1_AcIter = m1.end( ); |
|
5821 m1_AcIter--; |
|
5822 m1_RcIter = m1. lower_bound ( m1_AcIter -> first ); |
|
5823 #if STDCPP_OOM |
|
5824 User::__DbgSetAllocFail(FALSE,RHeap::ENone,1); |
|
5825 #endif |
|
5826 if( m1_RcIter -> second != 30) |
|
5827 failures++; |
|
5828 |
|
5829 /*if(failures) |
|
5830 return KErrGeneral; |
|
5831 else |
|
5832 return KErrNone; |
|
5833 */ |
|
5834 //#if STDCPP_OOM |
|
5835 //failures++; |
|
5836 // #endif |
|
5837 |
|
5838 |
|
5839 } |
|
5840 catch(bad_alloc&) |
|
5841 { |
|
5842 //do nothing |
|
5843 } |
|
5844 catch(...) |
|
5845 { |
|
5846 failures++; |
|
5847 |
|
5848 } |
|
5849 |
|
5850 if(failures ) |
|
5851 return KErrGeneral; |
|
5852 return KErrNone; |
|
5853 } |
|
5854 |
|
5855 |
|
5856 TInt Ctstl_2::multimap10(CStifItemParser& aItem) |
|
5857 |
|
5858 { |
|
5859 //swap |
|
5860 int failures=0; |
|
5861 |
|
5862 try |
|
5863 { |
|
5864 int a[2]; |
|
5865 using namespace std; |
|
5866 multimap <int, int> m1, m2, m3; |
|
5867 multimap <int, int>::iterator m1_Iter; |
|
5868 typedef pair <int, int> Int_Pair; |
|
5869 |
|
5870 m1.insert ( Int_Pair ( 1, 10 ) ); |
|
5871 m1.insert ( Int_Pair ( 2, 20 ) ); |
|
5872 m1.insert ( Int_Pair ( 3, 30 ) ); |
|
5873 m2.insert ( Int_Pair ( 10, 100 ) ); |
|
5874 m2.insert ( Int_Pair ( 20, 200 ) ); |
|
5875 m3.insert ( Int_Pair ( 30, 300 ) ); |
|
5876 |
|
5877 |
|
5878 #if STDCPP_OOM |
|
5879 User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1); |
|
5880 #endif |
|
5881 // This is the member function version of swap |
|
5882 //m2 is said to be the argument multimap; m1 the target multimap |
|
5883 m1.swap( m2 ); |
|
5884 |
|
5885 for ( m1_Iter = m1.begin( ); m1_Iter != m1.end( ); m1_Iter++ ) |
|
5886 { |
|
5887 static int i; |
|
5888 |
|
5889 a[i] = m1_Iter -> second; |
|
5890 |
|
5891 i++; |
|
5892 |
|
5893 } |
|
5894 |
|
5895 #if STDCPP_OOM |
|
5896 User::__DbgSetAllocFail(FALSE,RHeap::ENone,1); |
|
5897 #endif |
|
5898 if(a[0]!=100) |
|
5899 failures++; |
|
5900 if(a[1]!= 200) |
|
5901 failures++; |
|
5902 |
|
5903 |
|
5904 // This is the specialized template version of swap |
|
5905 swap( m1, m3 ); |
|
5906 |
|
5907 for ( m1_Iter = m1.begin( ); m1_Iter != m1.end( ); m1_Iter++ ) |
|
5908 { |
|
5909 |
|
5910 |
|
5911 int a= m1_Iter -> second; |
|
5912 if(a!=300) |
|
5913 failures++; |
|
5914 } |
|
5915 /* |
|
5916 if(failures) |
|
5917 return KErrGeneral; |
|
5918 else |
|
5919 return KErrNone; |
|
5920 */ |
|
5921 //#if STDCPP_OOM |
|
5922 //failures++; |
|
5923 // #endif |
|
5924 |
|
5925 } |
|
5926 catch(bad_alloc&) |
|
5927 { |
|
5928 //do nothing |
|
5929 } |
|
5930 catch(...) |
|
5931 { |
|
5932 failures++; |
|
5933 |
|
5934 } |
|
5935 |
|
5936 if(failures ) |
|
5937 return KErrGeneral; |
|
5938 return KErrNone; |
|
5939 } |
|
5940 |
|
5941 TInt Ctstl_2::multimap11(CStifItemParser& aItem) |
|
5942 { |
|
5943 |
|
5944 //val_comp |
|
5945 int failures=0; |
|
5946 |
|
5947 try |
|
5948 { |
|
5949 |
|
5950 #if STDCPP_OOM |
|
5951 User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1); |
|
5952 #endif |
|
5953 |
|
5954 multimap <int, int, less<int> > m1; |
|
5955 multimap <int, int, less<int> >::value_compare vc1 = m1.value_comp( ); |
|
5956 multimap<int,int>::iterator Iter1, Iter2; |
|
5957 |
|
5958 Iter1= m1.insert ( multimap <int, int> :: value_type ( 1, 10 ) ); |
|
5959 Iter2= m1.insert ( multimap <int, int> :: value_type ( 2, 5 ) ); |
|
5960 |
|
5961 if( vc1( *Iter1, *Iter2 ) == false ) |
|
5962 failures++; |
|
5963 |
|
5964 if( vc1( *Iter2, *Iter1 ) == true ) |
|
5965 failures++; |
|
5966 #if STDCPP_OOM |
|
5967 User::__DbgSetAllocFail(FALSE,RHeap::ENone,1); |
|
5968 #endif |
|
5969 |
|
5970 /* |
|
5971 if(failures) |
|
5972 return KErrGeneral; |
|
5973 else |
|
5974 return KErrNone;*/ |
|
5975 |
|
5976 //#if STDCPP_OOM |
|
5977 //failures++; |
|
5978 // #endif |
|
5979 } |
|
5980 |
|
5981 catch(bad_alloc&) |
|
5982 { |
|
5983 //do nothing |
|
5984 } |
|
5985 catch(...) |
|
5986 { |
|
5987 failures++; |
|
5988 |
|
5989 } |
|
5990 |
|
5991 if(failures ) |
|
5992 return KErrGeneral; |
|
5993 return KErrNone; |
|
5994 } |
|
5995 |
|
5996 |
|
5997 |
|
5998 |
|
5999 TInt Ctstl_2::multimap12(CStifItemParser& aItem) |
|
6000 { |
|
6001 |
|
6002 |
|
6003 int psize1,failures=0; |
|
6004 |
|
6005 try |
|
6006 { |
|
6007 multimap<char,int> mymap1; |
|
6008 pair<const char,int>* p; |
|
6009 #if STDCPP_OOM |
|
6010 User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1); |
|
6011 #endif |
|
6012 p=mymap1.get_allocator().allocate(2); |
|
6013 |
|
6014 psize1 = (int) sizeof(map<char,int>::value_type)*2; |
|
6015 |
|
6016 if(psize1!=16) |
|
6017 failures++; |
|
6018 |
|
6019 |
|
6020 mymap1.get_allocator().deallocate(p,2); |
|
6021 |
|
6022 #if STDCPP_OOM |
|
6023 User::__DbgSetAllocFail(FALSE,RHeap::ENone,1); |
|
6024 #endif |
|
6025 if(mymap1.max_size()!=4294967295) |
|
6026 failures++; |
|
6027 |
|
6028 |
|
6029 /* |
|
6030 if(failures) |
|
6031 return KErrGeneral; |
|
6032 else |
|
6033 return KErrNone; |
|
6034 */ |
|
6035 //#if STDCPP_OOM |
|
6036 //failures++; |
|
6037 // #endif |
|
6038 } |
|
6039 catch(bad_alloc&) |
|
6040 { |
|
6041 //do nothing |
|
6042 } |
|
6043 catch(...) |
|
6044 { |
|
6045 failures++; |
|
6046 |
|
6047 } |
|
6048 |
|
6049 if(failures ) |
|
6050 return KErrGeneral; |
|
6051 return KErrNone; |
|
6052 } |
|
6053 |
|
6054 |
|
6055 TInt Ctstl_2::multimap13(CStifItemParser& aItem) |
|
6056 { |
|
6057 |
|
6058 int failures=0; |
|
6059 |
|
6060 try |
|
6061 { |
|
6062 multimap<char,int> mymap; |
|
6063 multimap<char,int>::reverse_iterator rit; |
|
6064 |
|
6065 |
|
6066 mymap.insert (pair<char,int>('x',100)); |
|
6067 mymap.insert (pair<char,int>('y',200)); |
|
6068 |
|
6069 #if STDCPP_OOM |
|
6070 User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1); |
|
6071 #endif |
|
6072 |
|
6073 for ( rit=mymap.rbegin() ; rit != mymap.rend(); rit++ ) |
|
6074 |
|
6075 { |
|
6076 static int i; |
|
6077 if(i==0) |
|
6078 { |
|
6079 |
|
6080 if( rit->second !=200) |
|
6081 failures++; |
|
6082 } |
|
6083 i++; |
|
6084 } |
|
6085 |
|
6086 #if STDCPP_OOM |
|
6087 User::__DbgSetAllocFail(FALSE,RHeap::ENone,1); |
|
6088 #endif |
|
6089 |
|
6090 /* |
|
6091 if(failures) |
|
6092 return KErrGeneral; |
|
6093 else |
|
6094 return KErrNone;*/ |
|
6095 //#if STDCPP_OOM |
|
6096 //failures++; |
|
6097 // #endif |
|
6098 } |
|
6099 |
|
6100 catch(bad_alloc&) |
|
6101 { |
|
6102 //do nothing |
|
6103 } |
|
6104 catch(...) |
|
6105 { |
|
6106 failures++; |
|
6107 |
|
6108 } |
|
6109 |
|
6110 if(failures ) |
|
6111 return KErrGeneral; |
|
6112 return KErrNone; |
|
6113 } |
|
6114 |
|
6115 TInt Ctstl_2::multi_set(CStifItemParser& aItem) |
|
6116 |
|
6117 { |
|
6118 |
|
6119 |
|
6120 int failures =0; |
|
6121 |
|
6122 try |
|
6123 { |
|
6124 |
|
6125 |
|
6126 #if STDCPP_OOM |
|
6127 User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1); |
|
6128 #endif |
|
6129 |
|
6130 //__UHEAP_MARK; |
|
6131 //{ |
|
6132 multiset <int> ms1; |
|
6133 multiset <int> :: const_iterator low,ms1_AcIter,up,find1; |
|
6134 multiset<int>::iterator Iter; |
|
6135 |
|
6136 multiset<int>::size_type count1, maxsize; |
|
6137 |
|
6138 |
|
6139 |
|
6140 |
|
6141 |
|
6142 |
|
6143 |
|
6144 if(ms1.size()!= 0) |
|
6145 |
|
6146 failures++; |
|
6147 |
|
6148 |
|
6149 |
|
6150 |
|
6151 ms1.insert( 10 ); |
|
6152 ms1.insert( 20 ); |
|
6153 ms1.insert( 30 ); |
|
6154 |
|
6155 find1 = ms1.find(20); |
|
6156 |
|
6157 if(*find1!=20) |
|
6158 failures++; |
|
6159 |
|
6160 |
|
6161 if(ms1.size()!=3) |
|
6162 failures++; |
|
6163 |
|
6164 |
|
6165 |
|
6166 count1 = ms1.count(10); |
|
6167 |
|
6168 if(count1 != 1) |
|
6169 failures++; |
|
6170 |
|
6171 |
|
6172 count1 = ms1.count(40); |
|
6173 |
|
6174 if(count1!=0) |
|
6175 failures++; |
|
6176 |
|
6177 |
|
6178 |
|
6179 |
|
6180 Iter = ms1.begin(); |
|
6181 |
|
6182 ms1.erase(Iter); |
|
6183 |
|
6184 |
|
6185 if(*ms1.begin()!=20) |
|
6186 failures++; |
|
6187 |
|
6188 |
|
6189 |
|
6190 low = ms1.lower_bound( 20 ); |
|
6191 if( *low != 20) |
|
6192 failures++; |
|
6193 |
|
6194 |
|
6195 up = ms1.upper_bound(20); |
|
6196 if(*up!=30) |
|
6197 failures++; |
|
6198 |
|
6199 low = ms1.lower_bound( 40 ); |
|
6200 up = ms1.upper_bound(30); |
|
6201 |
|
6202 |
|
6203 // If no match is found for the key, end( ) is returned |
|
6204 |
|
6205 |
|
6206 if(up!=ms1.end()) |
|
6207 failures++; |
|
6208 |
|
6209 |
|
6210 if(ms1.empty()) |
|
6211 failures++; |
|
6212 |
|
6213 |
|
6214 ms1.clear(); |
|
6215 |
|
6216 if(!ms1.empty()) |
|
6217 failures++; |
|
6218 |
|
6219 |
|
6220 maxsize = ms1.max_size(); |
|
6221 #if STDCPP_OOM |
|
6222 User::__DbgSetAllocFail(FALSE,RHeap::ENone,1); |
|
6223 #endif |
|
6224 if(maxsize!= 4294967295) |
|
6225 failures++; |
|
6226 |
|
6227 //__UHEAP_MARKEND; |
|
6228 /*if(failures) |
|
6229 |
|
6230 return KErrGeneral; |
|
6231 else |
|
6232 return KErrNone;*/ |
|
6233 //#if STDCPP_OOM |
|
6234 //failures++; |
|
6235 // #endif |
|
6236 |
|
6237 |
|
6238 |
|
6239 } |
|
6240 |
|
6241 |
|
6242 catch(bad_alloc&) |
|
6243 { |
|
6244 //do nothing |
|
6245 } |
|
6246 catch(...) |
|
6247 { |
|
6248 failures++; |
|
6249 |
|
6250 } |
|
6251 |
|
6252 if(failures ) |
|
6253 return KErrGeneral; |
|
6254 return KErrNone; |
|
6255 } |
|
6256 |
|
6257 |
|
6258 |
|
6259 TInt Ctstl_2::multi_set2(CStifItemParser& aItem) |
|
6260 |
|
6261 { |
|
6262 int myints[] = {77,16,2,30,30},failures=0; |
|
6263 |
|
6264 try |
|
6265 { |
|
6266 #if STDCPP_OOM |
|
6267 User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1); |
|
6268 #endif |
|
6269 multiset<int> mymultiset (myints,myints+5); |
|
6270 |
|
6271 multiset<int>::reverse_iterator rit; |
|
6272 |
|
6273 for ( rit=mymultiset.rbegin() ; rit != mymultiset.rend(); rit++ ) |
|
6274 { |
|
6275 |
|
6276 static int i; |
|
6277 if(i==0) |
|
6278 { |
|
6279 if(*rit!=77) |
|
6280 failures++; |
|
6281 } |
|
6282 i++; |
|
6283 } |
|
6284 #if STDCPP_OOM |
|
6285 User::__DbgSetAllocFail(FALSE,RHeap::ENone,1); |
|
6286 #endif |
|
6287 /* |
|
6288 |
|
6289 if(failures) |
|
6290 return KErrGeneral; |
|
6291 else |
|
6292 return KErrNone;*/ |
|
6293 //#if STDCPP_OOM |
|
6294 //failures++; |
|
6295 // #endif |
|
6296 } |
|
6297 |
|
6298 catch(bad_alloc&) |
|
6299 { |
|
6300 //do nothing |
|
6301 } |
|
6302 catch(...) |
|
6303 { |
|
6304 failures++; |
|
6305 |
|
6306 } |
|
6307 |
|
6308 if(failures ) |
|
6309 return KErrGeneral; |
|
6310 return KErrNone; |
|
6311 } |
|
6312 |
|
6313 |
|
6314 |
|
6315 TInt Ctstl_2::multi_set3(CStifItemParser& aItem) |
|
6316 |
|
6317 { |
|
6318 multiset<int> mymultiset; |
|
6319 int * p,failures=0; |
|
6320 |
|
6321 try |
|
6322 { |
|
6323 unsigned int i; |
|
6324 #if STDCPP_OOM |
|
6325 User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1); |
|
6326 #endif |
|
6327 p = mymultiset.get_allocator().allocate(5); |
|
6328 #if STDCPP_OOM |
|
6329 User::__DbgSetAllocFail(FALSE,RHeap::ENone,1); |
|
6330 #endif |
|
6331 for (i=0; i<5; i++) |
|
6332 p[i]=(i+1)*10; |
|
6333 |
|
6334 if(sizeof(p)!=4) |
|
6335 failures++; |
|
6336 #if STDCPP_OOM |
|
6337 User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1); |
|
6338 #endif |
|
6339 mymultiset.get_allocator().deallocate(p,5); |
|
6340 |
|
6341 #if STDCPP_OOM |
|
6342 User::__DbgSetAllocFail(FALSE,RHeap::ENone,1); |
|
6343 #endif |
|
6344 |
|
6345 |
|
6346 /* |
|
6347 if(failures) |
|
6348 return KErrGeneral; |
|
6349 else |
|
6350 return KErrNone; |
|
6351 */ |
|
6352 //#if STDCPP_OOM |
|
6353 //failures++; |
|
6354 // #endif |
|
6355 } |
|
6356 |
|
6357 |
|
6358 catch(bad_alloc&) |
|
6359 { |
|
6360 //do nothing |
|
6361 } |
|
6362 catch(...) |
|
6363 { |
|
6364 failures++; |
|
6365 |
|
6366 } |
|
6367 |
|
6368 if(failures ) |
|
6369 return KErrGeneral; |
|
6370 return KErrNone; |
|
6371 } |
|
6372 |
|
6373 |
|
6374 |
|
6375 |
|
6376 |
|
6377 |
|
6378 |
|
6379 |
|
6380 |
|
6381 |
|
6382 |
|
6383 |
|
6384 |
|
6385 |
|
6386 |
|
6387 |
|
6388 |
|
6389 |
|
6390 |
|
6391 |
|
6392 |
|
6393 // End of File |