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