--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/stdcpp/tsrc/Stdcpp_test/bcdrivers/tstl_2/src/tstl_2blocks.cpp Fri Jun 04 16:20:51 2010 +0100
@@ -0,0 +1,6393 @@
+/*
+* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description:
+*
+*/
+
+
+
+
+// INCLUDE FILES
+#include <e32svr.h>
+#include <StifParser.h>
+#include <Stiftestinterface.h>
+#include<list>
+#include<string>
+#include<cstring>
+#include<vector>
+#include<iterator>
+#include<bitset>
+#include<ios>
+#include<algorithm>
+#include <numeric>
+#include<functional>
+#include <locale>
+#include<iostream>
+#include<memory>
+#include<complex>
+#include<map>
+#include<set>
+ #include<exception>
+
+
+#include <stl/char_traits.h> // fpos
+#include "tstl_2.h"
+#undef test
+ using namespace std;
+ #define STDCPP_OOM FALSE// TRUE for OOM testing
+
+#ifdef __ARMCC__
+#pragma diag_suppress 550
+#pragma diag_suppress 177
+#pragma diag_suppress 1134
+#pragma diag_suppress 1250
+#endif
+
+// ============================ MEMBER FUNCTIONS ===============================
+
+// -----------------------------------------------------------------------------
+// Ctstl_2::Delete
+// Delete here all resources allocated and opened from test methods.
+// Called from destructor.
+// -----------------------------------------------------------------------------
+//
+void Ctstl_2::Delete()
+ {
+
+ }
+
+// -----------------------------------------------------------------------------
+// Ctstl_2::RunMethodL
+// Run specified method. Contains also table of test mothods and their names.
+// -----------------------------------------------------------------------------
+//
+TInt Ctstl_2::RunMethodL(
+ CStifItemParser& aItem )
+ {
+
+ static TStifFunctionInfo const KFunctions[] =
+ {
+ // Copy this line for every implemented function.
+ // First string is the function name used in TestScripter script file.
+ // Second is the actual implementation member function.
+ // Second is the actual implementation member function.
+ ENTRY("Advance", Ctstl_2::Advance ),
+ ENTRY("Backinsert_iterator", Ctstl_2::Backinsert_iterator ),
+ ENTRY("Frontinsert_iterator", Ctstl_2::Frontinsert_iterator ),
+ ENTRY("Insert_iterator", Ctstl_2::Insert_iterator ),
+ ENTRY("Reverse_iterator", Ctstl_2::Reverse_iterator ),
+ ENTRY("Distance", Ctstl_2::Distance ),
+//ENTRY("Distancetype", Ctstl_2::Distancetype ),
+ ENTRY("Bit_set", Ctstl_2::Bit_set ),
+ ENTRY("Isdigit", Ctstl_2::Isdigit ),
+ ENTRY("Isgraph", Ctstl_2::Isgraph ),
+ ENTRY("Isalnum", Ctstl_2::Isalnum ),
+ ENTRY("Isalpha", Ctstl_2::Isalpha ),
+ ENTRY("Iscntrl", Ctstl_2::Iscntrl ),
+ ENTRY("Isprint", Ctstl_2::Isprint ),
+ ENTRY("Ispunct", Ctstl_2::Ispunct ),
+ ENTRY("Isspace", Ctstl_2::Isspace ),
+ ENTRY("Isxdigit", Ctstl_2::Isxdigit ),
+ ENTRY("Fill", Ctstl_2::Fill ),
+ ENTRY("Generate", Ctstl_2::Generate ),
+ ENTRY("Search", Ctstl_2::Search ),
+ ENTRY("Search_n", Ctstl_2::Search_n ),
+ ENTRY("Times", Ctstl_2::Times ),
+ ENTRY("Unique", Ctstl_2::Unique ),
+ ENTRY("Uniquecopy", Ctstl_2::Uniquecopy ),
+ ENTRY("Partialsort", Ctstl_2::Partialsort ),
+ ENTRY("Partialsortcopy", Ctstl_2::Partialsortcopy ),
+ ENTRY("Partition", Ctstl_2::Partition ),
+ ENTRY("Stablepartition", Ctstl_2::Stablepartition ),
+ ENTRY("Setdifference", Ctstl_2::Setdifference ),
+ ENTRY("Setintersection", Ctstl_2::Setintersection ),
+ ENTRY("Setsymdifference", Ctstl_2::Setsymdifference ),
+ ENTRY("Setunion", Ctstl_2::Setunion ),
+ ENTRY("HeapL", Ctstl_2::HeapL ),
+ ENTRY("Swapranges", Ctstl_2::Swapranges ),
+ ENTRY("Partialsums", Ctstl_2::Partialsums ),
+ ENTRY("Unarynegate", Ctstl_2::Unarynegate ),
+ ENTRY("Not2", Ctstl_2::Not2),
+ ENTRY("GettemporarybufferL", Ctstl_2::GettemporarybufferL),
+ ENTRY("Pair", Ctstl_2::Pair),
+ ENTRY("Lexicographicalcompare", Ctstl_2::Lexicographicalcompare ),
+ ENTRY("Mismatch", Ctstl_2::Mismatch ),
+ ENTRY("Compare_fun", Ctstl_2::Compare_fun ),
+ ENTRY("Copy_fun", Ctstl_2::Copy_fun ),
+ ENTRY("Copybackward_fun", Ctstl_2::Copybackward_fun ),
+ ENTRY("mergeL", Ctstl_2::mergeL ),
+ ENTRY("allocatoradd", Ctstl_2::allocatoradd ),
+ ENTRY("alldeall", Ctstl_2::alldeall ),
+ ENTRY("allcons", Ctstl_2::allcons ),
+ ENTRY("allrebind", Ctstl_2::allrebind ),
+ ENTRY("allmaxsize", Ctstl_2::allmaxsize ),
+ ENTRY("complexL",Ctstl_2::complexL),
+ ENTRY("limitsL",Ctstl_2::limitsL),
+ ENTRY("nextperm",Ctstl_2::nextperm),
+ ENTRY("prevperm",Ctstl_2::prevperm),
+ ENTRY("ptrfun",Ctstl_2::ptrfun),
+ ENTRY("itertraits",Ctstl_2::itertraits),
+ ENTRY("map1",Ctstl_2:: map1),
+ ENTRY("map2",Ctstl_2::map2),
+ ENTRY("map3",Ctstl_2::map3),
+ ENTRY("map4",Ctstl_2::map4),
+ ENTRY("map5",Ctstl_2::map5),
+ ENTRY("map6",Ctstl_2::map6),
+ ENTRY("map7",Ctstl_2::map7),
+ ENTRY("map8",Ctstl_2::map8),
+ ENTRY("map9",Ctstl_2::map9),
+ ENTRY("map10",Ctstl_2::map10),
+ ENTRY("map11",Ctstl_2::map11),
+ ENTRY("map12",Ctstl_2::map12),
+ ENTRY("map13",Ctstl_2::map13),
+ ENTRY("multimap1",Ctstl_2:: multimap1),
+ ENTRY("multimap2",Ctstl_2::multimap2),
+ ENTRY("multimap3",Ctstl_2::multimap3),
+ ENTRY("multimap4",Ctstl_2::multimap4),
+ ENTRY("multimap5",Ctstl_2::multimap5),
+ ENTRY("multimap6",Ctstl_2::multimap6),
+ ENTRY("multimap7",Ctstl_2::multimap7),
+ ENTRY("multimap8",Ctstl_2::multimap8),
+ ENTRY("multimap9",Ctstl_2::multimap9),
+ ENTRY("multimap10",Ctstl_2::multimap10),
+ ENTRY("multimap11",Ctstl_2::multimap11),
+ ENTRY("multimap12",Ctstl_2::multimap12),
+ ENTRY("multimap13",Ctstl_2::multimap13),
+ ENTRY("multi_set",Ctstl_2::multi_set),
+ ENTRY("multi_set2",Ctstl_2::multi_set2),
+ ENTRY("multi_set3",Ctstl_2::multi_set3),
+
+ };
+
+ const TInt count = sizeof( KFunctions ) /
+ sizeof( TStifFunctionInfo );
+
+ return RunInternalL( KFunctions, count, aItem );
+
+ }
+// -----------------------------------------------------------------------------
+// Ctstl_2::ExampleL
+// Example test method function.
+// (other items were commented in a header).
+// -----------------------------------------------------------------------------
+//
+TInt Ctstl_2::Advance( CStifItemParser& aItem )
+ {
+
+
+ int failures=0 ;
+
+
+
+
+ try
+ {
+
+ list<string>::iterator iList1,iList2;
+ list<string> List;
+ List.push_back("A1");
+ List.push_back("B2");
+ List.push_back("C3");
+ List.push_back("D4");
+ List.push_back("E5");
+ List.push_back("F6");
+ List.push_back("G7");
+ // cout<<"";
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
+ #endif
+
+ iList1=List.begin();
+ advance(iList1,2);
+ iList2 = List.begin();
+ advance(iList2,0);
+ #if STDCPP_OOM
+ User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);
+
+
+ #endif
+if(*iList1 != "C3")
+failures++;
+
+if(*iList2 != "A1")
+failures++;
+
+ //#if STDCPP_OOM
+//failures++;
+// #endif
+/*
+if(*iList1 == "C3")
+if(*iList2 == "A1")
+return KErrNone;
+return KErrGeneral;
+*/
+}
+ catch(bad_alloc&)
+ {
+ //do nothing
+ }
+ catch(...)
+ {
+ failures++;
+
+ }
+
+ if(failures )
+ return KErrGeneral;
+ return KErrNone;
+ }
+
+
+
+
+
+TInt Ctstl_2::Backinsert_iterator( CStifItemParser& aItem )
+ {
+ int failures=0;
+ try
+ {
+
+
+
+ int i;
+int output[4];
+ vector<int> vec;
+ for (i = 1 ; i < 4 ; ++i )
+ {
+ vec.push_back ( i );
+ }
+
+
+ vector <int>::iterator vIter;
+
+
+
+ back_insert_iterator<vector<int> >::container_type vec1 = vec;
+ // cout<<"";
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
+ #endif
+ back_inserter ( vec1 ) = 40;
+
+ #if STDCPP_OOM
+ User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);
+
+
+ #endif
+ for ( vIter = vec1.begin ( ) ; vIter != vec1.end ( ); vIter++)
+
+
+ {
+
+ static int i;
+ output[i] = *vIter;
+ i++;
+
+ }
+
+
+ if(output[0] != 1)
+ failures++;
+ if(output[1] != 2)
+ failures++;
+ if(output[2] != 3)
+ failures++;
+ if(output[3] != 40)
+ failures++;
+
+/*
+ if(output[0] == 1)
+ if(output[1] == 2)
+ if(output[2] == 3)
+ if(output[3] == 40)
+return KErrNone;
+return KErrGeneral;
+ */
+ //#if STDCPP_OOM
+//failures++;
+// #endif
+ }
+ catch(bad_alloc&)
+ {
+ //do nothing
+ }
+ catch(...)
+ {
+ failures++;
+
+ }
+
+ if(failures )
+ return KErrGeneral;
+ return KErrNone;
+ }
+
+
+
+TInt Ctstl_2::Frontinsert_iterator( CStifItemParser& aItem )
+ {
+int failures=0;
+try{
+ int i;
+ list <int>::iterator L_Iter;
+int output[12];
+ list<int> L;
+ for (i = -1 ; i < 9 ; ++i )
+ {
+ L.push_back ( 2 * i );
+ }
+ // cout<<"";
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
+ #endif
+
+ // Using the member function to insert an element
+ front_inserter ( L ) = 20;
+
+ // Alternatively, one may use the template function
+ front_insert_iterator< list < int> > Iter(L);
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);
+ #endif
+ *Iter = 30;
+
+ for ( L_Iter = L.begin( ) ; L_Iter != L.end( ); L_Iter++)
+
+
+ {
+ static int i;
+ output[i] = *L_Iter;
+ i++;
+ }
+ if(output[0] != 30)
+ failures++;
+if(output[1] != 20)
+failures++;
+if(output[2] != -2)
+failures++;
+if(output[3] != 0)
+failures++;
+
+ //#if STDCPP_OOM
+//failures++;
+// #endif
+
+ /*
+if(output[0] == 30)
+if(output[1] == 20)
+if(output[2] == -2)
+if(output[3] == 0)
+return KErrNone;
+return KErrGeneral;*/
+
+
+
+ }
+
+
+catch(bad_alloc&)
+ {
+ //do nothing
+ }
+ catch(...)
+ {
+ failures++;
+
+ }
+
+ if(failures )
+ return KErrGeneral;
+ return KErrNone;
+ }
+
+
+
+
+TInt Ctstl_2::Insert_iterator( CStifItemParser& aItem )
+ {
+int failures=0;
+try{
+ int i;
+ list <int>::iterator L_Iter;
+int output[5];
+ list<int> L;
+ for (i = 2 ; i < 5 ; ++i )
+ {
+ L.push_back ( 10 * i );
+ }
+ // cout<<"";
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
+ #endif
+
+ // Using the template version to insert an element
+ insert_iterator<list <int> > Iter( L, L.begin ( ) );
+ *Iter = 1;
+
+ // Alternatively, using the member function to insert an element
+ inserter ( L, L.end ( ) ) = 500;
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);
+ #endif
+ for ( L_Iter = L.begin( ) ; L_Iter != L.end( ); L_Iter++)
+
+ {
+ static int i;
+ output[i] = *L_Iter;
+ i++;
+ }
+
+ if(output[0] != 1)
+ failures++;
+ if(output[4] != 500)
+ failures++;
+ /*
+ if(output[0] == 1)
+ if(output[4] == 500)
+
+return KErrNone;
+return KErrGeneral;
+ */
+ //#if STDCPP_OOM
+//failures++;
+// #endif
+
+ }
+
+
+catch(bad_alloc&)
+ {
+ //do nothing
+ }
+ catch(...)
+ {
+ failures++;
+
+ }
+
+ if(failures )
+ return KErrGeneral;
+ return KErrNone;
+ }
+
+TInt Ctstl_2::Reverse_iterator( CStifItemParser& aItem )
+
+{
+int failures=0;
+try{
+int i;
+
+
+ vector<int> vec;
+
+ for ( i = 1 ; i < 6 ; ++i )
+ {
+ vec.push_back ( i );
+ }
+
+ // vector <int>::iterator vIter;
+
+
+// vector <int>::reverse_iterator rvIter;
+
+ vector <int>::iterator pos;
+
+ pos = find ( vec.begin ( ), vec.end ( ), 4 );
+
+
+ if(*pos != 4)
+ failures++;
+ // cout<<"";
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
+ #endif
+ vector <int>::reverse_iterator rpos ( pos );
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);
+ #endif
+ if(*rpos != 3)
+ failures++;
+
+
+ //#if STDCPP_OOM
+//failures++;
+// #endif
+
+
+}
+
+
+
+catch(bad_alloc&)
+ {
+ //do nothing
+ }
+ catch(...)
+ {
+ failures++;
+
+ }
+
+ if(failures )
+ return KErrGeneral;
+ return KErrNone;
+ }
+
+TInt Ctstl_2::Distance( CStifItemParser& aItem )
+
+{
+int failures =0;
+try{
+int i;
+
+
+ list<int> L;
+ for ( i = -1 ; i < 9 ; ++i )
+ {
+ L.push_back ( 2 * i );
+ }
+
+
+ list <int>::iterator LPOS = L.begin ( );
+
+
+
+
+ advance ( LPOS , 7 );
+
+ list<int>::difference_type Ldiff ;
+ // cout<<"";
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
+ #endif
+ Ldiff = distance ( L.begin ( ) , LPOS );
+
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);
+ #endif
+ /*if(*LPOS ==12)
+ if(Ldiff==7)
+ return KErrNone;
+ return KErrGeneral;*/
+
+ if(*LPOS !=12)
+ failures++;
+ if(Ldiff!=7)
+ failures++;
+ //#if STDCPP_OOM
+//failures++;
+// #endif
+
+}
+ catch(bad_alloc&)
+ {
+ //do nothing
+ }
+ catch(...)
+ {
+ failures++;
+
+ }
+
+ if(failures )
+ return KErrGeneral;
+ return KErrNone;
+ }
+
+ /*
+ TInt Ctstl_2::Distancetype( CStifItemParser& aItem )
+
+{
+
+int i;
+
+
+ list<int> L;
+ for ( i = -1 ; i < 9 ; ++i )
+ {
+ L.push_back ( 2 * i );
+ }
+
+
+ list <int>::iterator L_Iter, LPOS = L.begin ( );
+
+
+
+
+ advance ( LPOS , 7 );
+
+ list<int>::difference_type Ldiff ;
+ Ldiff = distance_type ( L.begin ( ) , LPOS );
+
+
+ if(*LPOS ==12)
+ if(Ldiff==7)
+ return KErrNone;
+ return KErrGeneral;
+
+
+
+}
+ */
+
+
+
+ TInt Ctstl_2::Bit_set( CStifItemParser& aItem )
+
+{
+
+ int failures =0;
+try{
+bitset<2> b0;
+ if(b0 != 00)
+ failures++;
+
+
+ // Using the second member function
+ bitset<5> b1(6);
+ if(b1 != 6)
+ failures++;
+ // cout<<"";
+
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
+ #endif
+
+ bitset<3> b3 (6);
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);
+ #endif
+ bool b = b3.any ( );
+ if(!b)
+failures++;
+ bool n = b3.none ( );
+
+ if(n)
+ failures++;
+
+ size_t i;
+ i = b3.count();
+ if(i!=2)
+ failures++;
+
+ bitset<3> fb1;
+ fb1 = b3.flip();
+
+
+ size_t j;
+ j= b3.count();
+
+ if(j!=1)
+ failures++;
+
+
+
+ bitset<5> a1 ( 13 );
+
+
+ i = a1.count();
+
+if(i!=3)
+failures++;
+
+ bitset<5> b1r3;
+ b1r3 = a1.reset( 2 );
+
+i = b1r3.count();
+
+
+if(i!=2)
+failures++;
+
+
+
+ bitset<5> b1r;
+ b1r = a1.reset( );
+
+i= b1r.count();
+if(i!=0)
+failures++;
+ bitset<5> b1s;
+ b1s = a1.set();
+ i=b1s.count();
+ if(i!=5)
+ failures++;
+
+int k ;
+k= a1.size();
+if(k!=5)
+failures++;
+
+ bool test = a1.test ( 3 );
+
+ if(!test)
+ failures++;
+ #define test(x) __test(x,__LINE__,__FILE__)
+
+ bitset<5> str ( 7 );
+
+
+
+ string s1;
+ s1 = str.template to_string<char, char_traits<char>, allocator<char> >( );
+
+
+ if(s1.compare("00111"))
+ failures++;
+ bitset<5> tlon( 7 );
+
+
+
+
+ unsigned long int lon;
+ lon = tlon.to_ulong( );
+ if(lon!=7)
+ failures++;
+
+
+ //#if STDCPP_OOM
+//failures++;
+// #endif
+
+
+}
+
+catch(bad_alloc&)
+ {
+ //do nothing
+ }
+ catch(...)
+ {
+ failures++;
+
+ }
+
+ if(failures )
+ return KErrGeneral;
+ return KErrNone;
+ }
+
+
+ TInt Ctstl_2::Isdigit( CStifItemParser& aItem )
+
+{
+
+char str[]="1776ad";
+
+ int failures =0;
+ try{
+ // cout<<"";
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
+ #endif
+ if (!isdigit(str[0]))
+ failures++;
+ if (!isdigit(str[1]))
+ failures++;
+ if (!isdigit(str[2]))
+ failures++;
+ if (!isdigit(str[3]))
+ failures++;
+ if (isdigit(str[4]))
+ failures++;
+ if (isdigit(str[5]))
+ failures++;
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);
+ #endif
+ //#if STDCPP_OOM
+//failures++;
+// #endif
+
+
+
+
+
+}
+catch(bad_alloc&)
+ {
+ //do nothing
+ }
+ catch(...)
+ {
+ failures++;
+
+ }
+
+ if(failures )
+ return KErrGeneral;
+ return KErrNone;
+ }
+
+
+ TInt Ctstl_2::Isgraph( CStifItemParser& aItem )
+
+{
+
+ int failures =0;
+ // char array[42] = "!"#$%&'()*+,-./0123456789:;<=>?@[\]^_`{|}~";
+
+
+ try{
+
+ for(char i=0x21;i<=0x7E;i++)
+ {
+ // cout<<"";
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
+ #endif
+
+ if(!isgraph(i))
+
+ failures++;
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);
+ #endif
+
+
+ }
+
+
+
+
+
+ //#if STDCPP_OOM
+//failures++;
+// #endif
+
+
+
+}
+
+catch(bad_alloc&)
+ {
+ //do nothing
+ }
+ catch(...)
+ {
+ failures++;
+
+ }
+
+ if(failures )
+ return KErrGeneral;
+ return KErrNone;
+ }
+
+
+
+ TInt Ctstl_2::Isalnum( CStifItemParser& aItem )
+
+{
+
+ int failures =0;
+
+
+ try{
+
+ for(char text='a';text<='z';text++)
+ {
+
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
+ #endif
+ if(!isalnum(text))
+ failures++;
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);
+ #endif
+
+
+
+ }
+
+
+ for(char text='A';text<='Z';text++)
+ {
+
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
+ #endif
+ if(!isalnum(text))
+ failures++;
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);
+ #endif
+
+
+
+ }
+
+
+
+ for(int text='0';text<='9';text++)
+ {
+
+
+ if(!isalnum(text))
+ failures++;
+
+
+ }
+
+ //#if STDCPP_OOM
+//failures++;
+// #endif
+
+
+
+}
+
+
+
+catch(bad_alloc&)
+ {
+ //do nothing
+ }
+ catch(...)
+ {
+ failures++;
+
+ }
+
+ if(failures )
+ return KErrGeneral;
+ return KErrNone;
+ }
+TInt Ctstl_2::Isalpha( CStifItemParser& aItem )
+
+{
+
+ int failures =0;
+
+ try{
+
+
+ for(char text='a';text<='z';text++)
+ {
+
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
+ #endif
+ if(!isalpha(text))
+ failures++;
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);
+ #endif
+
+
+
+ }
+
+
+ for(char text='A';text<='Z';text++)
+ {
+
+
+ if(!isalpha(text))
+ failures++;
+
+
+ }
+
+
+
+ for(int text='0';text<='9';text++)
+ {
+
+
+ if(isalpha(text))
+ failures++;
+
+
+ }
+
+ //#if STDCPP_OOM
+//failures++;
+// #endif
+
+
+}
+catch(bad_alloc&)
+ {
+ //do nothing
+ }
+ catch(...)
+ {
+ failures++;
+
+ }
+
+ if(failures )
+ return KErrGeneral;
+ return KErrNone;
+ }
+
+
+
+TInt Ctstl_2::Iscntrl( CStifItemParser& aItem )
+
+{
+ int failures =0;
+
+try{
+
+
+
+
+ for(char text=0x00;text<=0x1F;text++)
+ {
+
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
+ #endif
+ if(!iscntrl(text))
+ failures++;
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);
+ #endif
+
+
+ }
+
+ if(!iscntrl(0x7F))
+failures++;
+ /*
+ if(failures)
+return KErrGeneral;
+ return KErrNone;
+*/
+ //#if STDCPP_OOM
+//failures++;
+// #endif
+
+
+}
+
+catch(bad_alloc&)
+ {
+ //do nothing
+ }
+ catch(...)
+ {
+ failures++;
+
+ }
+
+ if(failures )
+ return KErrGeneral;
+ return KErrNone;
+ }
+
+
+TInt Ctstl_2::Isprint( CStifItemParser& aItem )
+
+{
+
+ int failures =0;
+
+ try{
+
+
+ for(char text=0x20;text<=0x7E;text++)
+ {
+
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
+ #endif
+ if(!isprint(text))
+ failures++;
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);
+ #endif
+
+ }
+
+
+ /*
+ if(failures)
+return KErrGeneral;
+ return KErrNone;
+*/
+ //#if STDCPP_OOM
+//failures++;
+// #endif
+
+
+}
+
+catch(bad_alloc&)
+ {
+ //do nothing
+ }
+ catch(...)
+ {
+ failures++;
+
+ }
+
+ if(failures )
+ return KErrGeneral;
+ return KErrNone;
+ }
+
+
+TInt Ctstl_2::Ispunct( CStifItemParser& aItem )
+
+{
+
+ int failures =0;
+
+ try{
+ for(char text=0x21;text<=0x2F;text++)
+ {
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
+ #endif
+ if(!ispunct(text))
+ failures++;
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);
+ #endif
+
+
+ }
+
+ for(char text=0x3A;text<=0x40;text++)
+ {
+
+ if(!ispunct(text))
+ failures++;
+
+ }
+
+ for(char text=0x5B;text<=0x60;text++)
+ {
+
+ if(!ispunct(text))
+ failures++;
+
+ }
+
+ for(char text=0x7B;text<=0x7E;text++)
+ {
+
+
+ if(!ispunct(text))
+ failures++;
+
+ }
+
+/*
+
+if(failures)
+return KErrGeneral;
+return KErrNone;
+*/
+ //#if STDCPP_OOM
+//failures++;
+// #endif
+}
+catch(bad_alloc&)
+ {
+ //do nothing
+ }
+ catch(...)
+ {
+ failures++;
+
+ }
+
+ if(failures )
+ return KErrGeneral;
+ return KErrNone;
+ }
+ TInt Ctstl_2::Isspace( CStifItemParser& aItem )
+
+{
+
+ int failures =0;
+
+ try{
+
+
+ for(char text=0x09;text<=0x0D;text++)
+ {
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
+ #endif
+ if(!isspace(text))
+ failures++;
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);
+ #endif
+
+
+ }
+
+ if(!isspace(0x20))
+ failures++;
+
+
+ /*
+
+
+if(failures)
+return KErrGeneral;
+return KErrNone;
+*/
+ //#if STDCPP_OOM
+//failures++;
+// #endif
+
+
+}
+catch(bad_alloc&)
+ {
+ //do nothing
+ }
+ catch(...)
+ {
+ failures++;
+
+ }
+
+ if(failures )
+ return KErrGeneral;
+ return KErrNone;
+ }
+
+ TInt Ctstl_2::Isxdigit( CStifItemParser& aItem )
+
+{
+
+ int failures =0;
+try{
+ for(char text=0x30;text<=0x39;text++)
+ {
+
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
+ #endif
+ if(!isxdigit(text))
+ failures++;
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);
+ #endif
+
+
+ }
+
+
+ for(char text=0x41;text<=0x46;text++)
+ {
+
+
+ if(!isxdigit(text))
+ failures++;
+
+ }
+
+
+ for(char text=0x61;text<=0x66;text++)
+ {
+
+
+ if(!isxdigit(text))
+ failures++;
+
+ }
+
+
+
+ /*
+
+ if(failures)
+return KErrGeneral;
+ return KErrNone;*/
+ //#if STDCPP_OOM
+//failures++;
+// #endif
+
+
+
+}
+
+catch(bad_alloc&)
+ {
+ //do nothing
+ }
+ catch(...)
+ {
+ failures++;
+
+ }
+
+ if(failures )
+ return KErrGeneral;
+ return KErrNone;
+ }
+
+
+TInt Ctstl_2::Fill( CStifItemParser& aItem )
+
+{
+
+ int failures =0;
+
+ try
+ {
+
+ vector<int> myvector (8,10); // myvector: 10 10 10 10 10 10 10 10
+ vector<int>::iterator it ;
+ // cout<<"";
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
+ #endif
+ fill_n(myvector.begin(),4,20); // myvector: 20 20 20 20 10 10 10 10
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);
+ #endif
+
+ for( it = myvector.begin();it!=myvector.begin()+4;++it)
+ {
+
+ if(*it!=20)
+ failures++;
+
+ }
+
+
+
+
+ vector<int> myvector1 (8);
+ // cout<<"";
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
+ #endif // myvector: 0 0 0 0 0 0 0 0
+ fill (myvector1.begin(),myvector1.begin()+4,5);
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);
+ #endif
+
+
+ for (vector<int>::iterator it=myvector1.begin(); it!=myvector1.begin()+3; ++it)
+ {
+
+ if(*it!=5)
+ failures++;
+
+ }
+
+ //#if STDCPP_OOM
+//failures++;
+// #endif
+
+ }
+
+catch(bad_alloc&)
+ {
+ //do nothing
+ }
+ catch(...)
+ {
+ failures++;
+
+ }
+
+ if(failures )
+ return KErrGeneral;
+ return KErrNone;
+ }
+
+
+
+
+
+static int UniqueNumber()
+ {
+
+ static int current;
+ return current++;
+ }
+
+
+TInt Ctstl_2::Generate( CStifItemParser& aItem )
+
+{
+ int failures = 0;
+
+try{
+ vector<int> myvector (8);
+ vector<int>::iterator it;
+ int output[8];
+ // cout<<"";
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
+ #endif
+ generate(myvector.begin(), myvector.end(), UniqueNumber);
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);
+ #endif
+
+ for (it=myvector.begin(); it!=myvector.end(); ++it)
+
+ {
+ static int i;
+ output[i] = *it;
+ i++;
+
+
+ }
+
+
+ for(int i=0;i<=7;i++)
+ {
+ if(!output[i] == i)
+ failures++;
+ }
+ // cout<<"";
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
+ #endif
+ generate_n(myvector.begin()+5,3,UniqueNumber);
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);
+ #endif
+
+
+ for(int i=5;i<=7;i++)
+ {
+ if(!output[0] == 0)
+ if(!output[1]==0)
+ if(!output[2]==0)
+ if(!output[3]==0)
+ if(!output[4]==0)
+ if(!output[i] == i)
+ failures++;
+ }
+
+
+
+ /*
+ if(!failures)
+ return KErrNone;
+ return KErrGeneral;
+*/
+ //#if STDCPP_OOM
+//failures++;
+// #endif
+
+}
+
+
+catch(bad_alloc&)
+ {
+ //do nothing
+ }
+ catch(...)
+ {
+ failures++;
+
+ }
+
+ if(failures )
+ return KErrGeneral;
+ return KErrNone;
+ }
+
+
+
+
+bool mypredicate1 (int i, int j) {
+ return (i==j);
+}
+
+
+
+TInt Ctstl_2::Search( CStifItemParser& aItem )
+
+{
+ int failures=0;
+try{
+
+vector<int> myvector;
+ vector<int>::iterator it;
+
+ // set some values: myvector: 10 20 30 40 50 60 70 80 90
+ for (int i=1; i<10; i++)
+ myvector.push_back(i*10);
+
+
+ // using default comparison:
+ int match1[] = {40,50,60,70};
+ // cout<<"";
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
+ #endif
+ it = search (myvector.begin(), myvector.end(), match1, match1+4);
+
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);
+ #endif
+ if(int(it-myvector.begin())!=3)
+
+failures++;
+
+
+// using predicate comparison:
+ int match2[] = {20,30,50};
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
+ #endif
+ it = search (myvector.begin(), myvector.end(), match2, match2+3, mypredicate1);
+
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);
+ #endif
+
+ if(int(it-myvector.begin()) == 1)
+ failures++;
+
+ //#if STDCPP_OOM
+//failures++;
+// #endif
+//return KErrNone;
+//return KErrGeneral;
+}
+
+
+catch(bad_alloc&)
+ {
+ //do nothing
+ }
+ catch(...)
+ {
+ failures++;
+
+ }
+
+ if(failures )
+ return KErrGeneral;
+ return KErrNone;
+ }
+
+
+
+
+TInt Ctstl_2::Search_n(CStifItemParser& aItem )
+
+{
+
+ int failures=0;
+try{
+int myints[]={10,20,30,30,20,10,10,20};
+ vector<int> myvector (myints,myints+8);
+
+ vector<int>::iterator it;
+ // cout<<"";
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
+ #endif
+ // using default comparison:
+ it = search_n (myvector.begin(), myvector.end(), 2, 30);
+
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);
+ #endif
+
+
+/*
+if(int(it-myvector.begin())==2)
+return KErrNone;
+return KErrGeneral;
+*/
+
+if(int(it-myvector.begin())!=2)
+failures++;
+
+ //#if STDCPP_OOM
+//failures++;
+// #endif
+}
+
+catch(bad_alloc&)
+ {
+ //do nothing
+ }
+ catch(...)
+ {
+ failures++;
+
+ }
+
+ if(failures )
+ return KErrGeneral;
+ return KErrNone;
+ }
+//code to be verified
+//--------------------------
+
+TInt Ctstl_2::Times(CStifItemParser& aItem)
+ {
+ int failures=0;
+
+//__UHEAP_MARK;
+try
+{
+
+
+int input1 [4] = { -10, 20, 30, 40 };
+int input2 [4] = { 40, 30, 20, -10 };
+ int output [4];
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
+ #endif
+ transform((int*)input1, (int*)input1 + 4, (int*)input2, (int*)output, multiplies<int>());
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);
+ #endif
+ if( output[1] != 600)
+ failures++;
+ if( output[2] != 600 )
+ failures++;
+
+ if( output[3] != -400)
+ failures++;
+
+
+
+
+ //__UHEAP_MARKEND;
+ }
+
+ catch(bad_alloc&)
+ {
+ //do nothing
+ }
+ catch(...)
+ {
+ failures++;
+
+ }
+
+ if(failures )
+ return KErrGeneral;
+ return KErrNone;
+ }
+
+ TInt Ctstl_2::Unique(CStifItemParser& aItem)
+ {
+
+ int failures=0;
+//__UHEAP_MARK;
+try{
+int myints[] = {10,20,20,20,30,30,20,20,10}; // 10 20 20 20 30 30 20 20 10
+ vector<int> myvector (myints,myints+9);
+ vector<int>::iterator it;
+int output[5]; // cout<<"";
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
+ #endif
+
+ // using default comparison:
+ it = unique (myvector.begin(), myvector.end()); // 10 20 30 20 10 30 20 20 10
+ // ^
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);
+ #endif
+ myvector.resize( it - myvector.begin() ); // 10 20 30 20 10
+
+
+ // print out content:
+ for (it=myvector.begin(); it!=myvector.end(); ++it)
+
+ {
+
+ static int i;
+ output[i] = *it;
+ i++;
+
+ }
+
+
+ /*
+
+ if(output[0]== 10)
+ if(output[1]== 20)
+ if(output[2]== 30)
+ if(output[3]== 20)
+ if(output[4]== 10)
+
+ return KErrNone;
+ return KErrGeneral;*/
+ // __UHEAP_MARKEND;
+
+ if(output[0]!=10)
+ failures++;
+
+ if(output[1]!=20)
+ failures++;
+
+ if(output[2]!=30)
+ failures++;
+ if(output[3]!=20)
+ failures++;
+ if(output[4]!=10)
+ failures++;
+
+
+
+
+ //#if STDCPP_OOM
+//failures++;
+// #endif
+
+ }
+
+ catch(bad_alloc&)
+ {
+ //do nothing
+ }
+ catch(...)
+ {
+ failures++;
+
+ }
+
+ if(failures )
+ return KErrGeneral;
+ return KErrNone;
+ }
+
+ TInt Ctstl_2::Uniquecopy(CStifItemParser& aItem)
+ {
+ int failures=0;
+
+ try{
+//__UHEAP_MARK;
+int myints[] = {10,20,20,20,30,30,20,20,10};
+ vector<int> myvector (9); // 0 0 0 0 0 0 0 0 0
+ vector<int>::iterator it;
+int output[9]; // cout<<"";
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
+ #endif
+ // using default comparison:
+ it=unique_copy(myints,myints+9,myvector.begin()); // 10 20 30 20 10 0 0 0 0
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);
+ #endif // ^
+for (it=myvector.begin(); it!=myvector.end(); ++it)
+{
+static int i;
+output[i] = *it;
+i++;
+}
+ // 10 20 30 20 30 0 0 0 0
+ /* // ^
+ if(output[0]==10)
+ if(output[1]==20)
+ if(output[2]==30)
+ if(output[3]==20)
+ if(output[4]==10)
+ if(output[5]==0)
+ if(output[6]==0)
+ if(output[7]==0)
+ if(output[8]==0)
+ return KErrNone;
+ return KErrGeneral;
+ */
+ if(output[0]!=10)
+ failures++;
+
+ if(output[1]!=20)
+ failures++;
+
+ if(output[2]!=30)
+ failures++;
+ if(output[3]!=20)
+ failures++;
+ if(output[4]!=10)
+ failures++;
+ if(output[5]!=0)
+ failures++;
+ if(output[6]!=0)
+ failures++;
+ if(output[7]!=0)
+ failures++;
+ if(output[8]!=0)
+ failures++;
+
+
+ //#if STDCPP_OOM
+//failures++;
+// #endif
+
+ // __UHEAP_MARKEND;
+
+ }
+
+ catch(bad_alloc&)
+ {
+ //do nothing
+ }
+ catch(...)
+ {
+ failures++;
+
+ }
+
+ if(failures )
+ return KErrGeneral;
+ return KErrNone;
+ }
+
+
+ TInt Ctstl_2::Partialsort(CStifItemParser& aItem)
+ {
+ int failures=0;
+ try
+ {
+
+//__UHEAP_MARK;
+int myints[] = {9,8,7,6,5,4,3,2,1};
+ vector<int> myvector (myints, myints+9);
+ vector<int>::iterator it;
+int output[9]; // cout<<"";
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
+ #endif
+ // using default comparison (operator <):
+ partial_sort (myvector.begin(), myvector.begin()+5, myvector.end());
+
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);
+ #endif
+ for (it=myvector.begin(); it!=myvector.end(); ++it)
+ {
+ static int i;
+ output[i] = *it;
+ i++;
+ }
+
+/*
+ if(output[0]==1)
+ if(output[1]==2)
+ if(output[2]==3)
+ if(output[3]==4)
+ if(output[5]==9)
+ if(output[6]==8)
+ if(output[7]==7)
+ if(output[8]==6)
+ if(output[4]==5)
+
+ return KErrNone;
+ return KErrGeneral;
+*/
+
+ // __UHEAP_MARKEND;
+if(output[0]!=1)
+ failures++;
+
+ if(output[1]!=2)
+ failures++;
+
+ if(output[2]!=3)
+ failures++;
+ if(output[3]!=4)
+ failures++;
+ if(output[4]!=5)
+ failures++;
+ if(output[5]!=9)
+ failures++;
+ if(output[6]!=8)
+ failures++;
+ if(output[7]!=7)
+ failures++;
+ if(output[8]!=6)
+ failures++;
+
+
+ //#if STDCPP_OOM
+//failures++;
+// #endif
+ }
+
+ catch(bad_alloc&)
+ {
+ //do nothing
+ }
+ catch(...)
+ {
+ failures++;
+
+ }
+
+ if(failures )
+ return KErrGeneral;
+ return KErrNone;
+ }
+
+
+TInt Ctstl_2::Partialsortcopy(CStifItemParser& aItem)
+ {
+ int failures=0;
+ try{
+//__UHEAP_MARK;
+int myints[] = {9,8,7,6,5,4,3,2,1};
+ vector<int> myvector (5);
+ vector<int>::iterator it;
+int output[5]; // cout<<"";
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
+ #endif
+ // using default comparison (operator <):
+ partial_sort_copy (myints, myints+9, myvector.begin(), myvector.end());
+
+
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);
+ #endif
+
+
+for (it=myvector.begin(); it!=myvector.end(); ++it)
+ {
+ static int i;
+ output[i] = *it;
+ i++;
+ }
+
+/*
+ if(output[0]==1)
+ if(output[1]==2)
+ if(output[2]==3)
+ if(output[3]==4)
+ if(output[4]==5)
+
+ return KErrNone;
+ return KErrGeneral;*/
+
+ //__UHEAP_MARKEND;
+
+ if(output[0]!=1)
+ failures++;
+ if(output[1]!=2)
+ failures++;
+ if(output[2]!=3)
+ failures++;
+ if(output[3]!=4)
+ failures++;
+ if(output[4]!=5)
+ failures++;
+ //#if STDCPP_OOM
+//failures++;
+// #endif
+
+ }
+
+ catch(bad_alloc&)
+ {
+ //do nothing
+ }
+ catch(...)
+ {
+ failures++;
+
+ }
+
+ if(failures )
+ return KErrGeneral;
+ return KErrNone;
+ }
+
+
+
+ bool IsOdd(int i)
+ {
+ return (i%2)==1;
+ }
+
+
+ TInt Ctstl_2::Partition(CStifItemParser& aItem)
+ {
+ int failures=0;
+ try{
+//__UHEAP_MARK;
+//int myints[] = {9,8,7,6,5,4,3,2,1};
+vector<int> myvector;
+ vector<int>::iterator it, bound;
+int Odd[5];
+int Even[4];
+ // set some values:
+ for (int i=1; i<10; ++i) myvector.push_back(i); // 1 2 3 4 5 6 7 8 9
+ // cout<<"";
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
+ #endif
+ bound = partition (myvector.begin(), myvector.end(), IsOdd);
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);
+ #endif
+ // print out content:
+ for (it=myvector.begin(); it!=bound; ++it)
+
+ {
+ static int i;
+ Odd[i] = *it;
+ i++;
+ }
+
+
+ for (it=bound; it!=myvector.end(); ++it)
+
+ {
+ static int i;
+ Even[i]=*it;
+ i++;
+ }
+
+/*
+if(Odd[0] ==1)
+if(Odd[1] ==9)
+if(Odd[2] ==3)
+if(Odd[3] ==7)
+if(Odd[4] ==5)
+if(Even[0]==6)
+ if(Even[1]==4)
+ if(Even[2]==8)
+ if(Even[3]==2)
+
+ return KErrNone;
+ return KErrGeneral;*/
+ if(Odd[0] !=1)
+ failures++;
+
+if(Odd[1] !=9)
+failures++;
+if(Odd[2] !=3)
+failures++;
+if(Odd[3] !=7)
+failures++;
+if(Odd[4] !=5)
+failures++;
+if(Even[0]!=6)
+failures++;
+if(Even[1]!=4)
+failures++;
+ if(Even[2]!=8)
+ failures++;
+ if(Even[3]!=2)
+ failures++;
+
+ //#if STDCPP_OOM
+//failures++;
+// #endif
+ // __UHEAP_MARKEND;
+
+ }
+
+ catch(bad_alloc&)
+ {
+ //do nothing
+ }
+ catch(...)
+ {
+ failures++;
+
+ }
+
+ if(failures )
+ return KErrGeneral;
+ return KErrNone;
+ }
+
+
+
+ TInt Ctstl_2::Stablepartition(CStifItemParser& aItem)
+ {
+ int failures=0;
+ try{
+//__UHEAP_MARK;
+//int myints[] = {9,8,7,6,5,4,3,2,1};
+vector<int> myvector;
+ vector<int>::iterator it, bound;
+int Odd[5];
+int Even[4];
+ // set some values:
+ for (int i=1; i<10; ++i) myvector.push_back(i); // 1 2 3 4 5 6 7 8 9
+ // cout<<"";
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
+ #endif
+ bound = stable_partition (myvector.begin(), myvector.end(), IsOdd);
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);
+ #endif
+ // print out content:
+ for (it=myvector.begin(); it!=bound; ++it)
+
+ {
+ static int i;
+ Odd[i] = *it;
+ i++;
+ }
+
+
+ for (it=bound; it!=myvector.end(); ++it)
+
+ {
+ static int i;
+ Even[i]=*it;
+ i++;
+ }
+
+ /*
+if(Odd[0] ==1)
+if(Odd[1] ==3)
+if(Odd[2] ==5)
+if(Odd[3] ==7)
+if(Odd[4] ==9)
+if(Even[0]==2)
+if(Even[1]==4)
+ if(Even[2]==6)
+ if(Even[3]==8)
+
+ return KErrNone;
+ return KErrGeneral;*/
+
+ //__UHEAP_MARKEND;
+
+ if(Odd[0] !=1)
+ failures++;
+
+if(Odd[1] !=3)
+failures++;
+if(Odd[2] !=5)
+failures++;
+if(Odd[3] !=7)
+failures++;
+if(Odd[4] !=9)
+failures++;
+if(Even[0]!=2)
+failures++;
+if(Even[1]!=4)
+failures++;
+ if(Even[2]!=6)
+ failures++;
+ if(Even[3]!=8)
+ failures++;
+
+ //#if STDCPP_OOM
+//failures++;
+// #endif
+ }
+catch(bad_alloc&)
+ {
+ //do nothing
+ }
+ catch(...)
+ {
+ failures++;
+
+ }
+
+ if(failures )
+ return KErrGeneral;
+ return KErrNone;
+ }
+
+
+TInt Ctstl_2::Setdifference(CStifItemParser& aItem)
+ {
+ int failures=0;
+ try{
+
+//__UHEAP_MARK;
+int first[] = {5,10,15,20,25};
+
+ int second[] = {50,40,30,20,10};
+
+ int output[10];
+ vector<int> v(10); // 0 0 0 0 0 0 0 0 0 0
+ vector<int>::iterator it;
+
+ sort (first,first+5); // 5 10 15 20 25
+ sort (second,second+5); // 10 20 30 40 50
+ // cout<<"";
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
+ #endif
+ it=set_difference (first, first+5, second, second+5, v.begin());
+ // 5 15 25 0 0 0 0 0 0 0
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);
+ #endif
+for(it=v.begin();it!=v.end();++it)
+{
+
+static int i;
+output[i] = *it;
+i++;
+
+}
+
+ /*if(output[0]==5)
+ if(output[1]==15)
+ if(output[2]==25)
+ return KErrNone;
+ return KErrGeneral;*/
+ if(output[0]!=5)
+ failures++;
+ if(output[1]!=15)
+ failures++;
+ if(output[2]!=25)
+ failures++;
+
+ //#if STDCPP_OOM
+//failures++;
+// #endif
+
+ // __UHEAP_MARKEND;
+
+ }
+
+ catch(bad_alloc&)
+ {
+ //do nothing
+ }
+ catch(...)
+ {
+ failures++;
+
+ }
+
+ if(failures )
+ return KErrGeneral;
+ return KErrNone;
+ }
+
+
+
+ TInt Ctstl_2::Setintersection(CStifItemParser& aItem)
+ {
+ int failures=0;
+ try{
+//__UHEAP_MARK;
+
+int first[] = {5,10,15,20,25};
+ int second[] = {50,40,30,20,10};
+ int output[10];
+ vector<int> v(10); // 0 0 0 0 0 0 0 0 0 0
+ vector<int>::iterator it;
+
+ sort (first,first+5); // 5 10 15 20 25
+ sort (second,second+5); // 10 20 30 40 50
+ // cout<<"";
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
+ #endif
+ it=set_intersection (first, first+5, second, second+5, v.begin());
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);
+ #endif // 10 20 0 0 0 0 0 0 0 0
+
+ for(it=v.begin();it!=v.end();++it)
+{
+
+static int i;
+output[i] = *it;
+i++;
+
+}
+ /*
+ if(output[0]==10)
+ if(output[1]==20)
+ if(output[2]==0)
+ return KErrNone;
+ return KErrGeneral;
+
+ */
+
+ if(output[0]!=10)
+ failures++;
+ if(output[1]!=20)
+ failures++;
+ if(output[2]!=0)
+ failures++;
+
+ //#if STDCPP_OOM
+//failures++;
+// #endif
+ }
+
+ catch(bad_alloc&)
+ {
+ //do nothing
+ }
+ catch(...)
+ {
+ failures++;
+
+ }
+
+ if(failures )
+ return KErrGeneral;
+ return KErrNone;
+ }
+
+
+
+
+ TInt Ctstl_2::Setsymdifference(CStifItemParser& aItem)
+ {int failures=0;
+ try{
+
+//__UHEAP_MARK;
+
+int first[] = {5,10,15,20,25};
+ int second[] = {50,40,30,20,10};
+ int output[10];
+ vector<int> v(10); // 0 0 0 0 0 0 0 0 0 0
+ vector<int>::iterator it;
+
+ sort (first,first+5); // 5 10 15 20 25
+ sort (second,second+5); // 10 20 30 40 50
+ // cout<<"";
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
+ #endif
+ it=set_symmetric_difference(first, first+5, second, second+5, v.begin());
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);
+ #endif
+ for(it=v.begin();it!=v.end();++it)
+{
+
+static int i;
+output[i] = *it;
+i++;
+
+}
+
+
+/*
+ if(output[0]==5)
+ if(output[1]==15)
+ if(output[2]==25)
+ if(output[3]==30)
+ if(output[4]==40)
+ if(output[5]==50)
+ return KErrNone;
+ return KErrGeneral;
+ */// __UHEAP_MARKEND;
+
+
+ if(output[0]!=5)
+ failures++;
+ if(output[1]!=15)
+ failures++;
+ if(output[2]!=25)
+ failures++;
+ if(output[3]!=30)
+ failures++;
+ if(output[4]!=40)
+ failures++;
+ if(output[5]!=50)
+ failures++;
+
+ //#if STDCPP_OOM
+//failures++;
+// #endif
+ }
+
+ catch(bad_alloc&)
+ {
+ //do nothing
+ }
+ catch(...)
+ {
+ failures++;
+
+ }
+
+ if(failures )
+ return KErrGeneral;
+ return KErrNone;
+ }
+
+ TInt Ctstl_2::Setunion(CStifItemParser& aItem)
+ {
+ int failures=0;
+
+//__UHEAP_MARK;
+try{
+int first[] = {5,10,15,20,25};
+ int second[] = {50,40,30,20,10};
+ int output[10];
+ vector<int> v(10); // 0 0 0 0 0 0 0 0 0 0
+ vector<int>::iterator it;
+
+ sort (first,first+5); // 5 10 15 20 25
+ sort (second,second+5); // 10 20 30 40 50
+ // cout<<"";
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
+ #endif
+ it=set_union(first, first+5, second, second+5, v.begin());
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);
+ #endif
+ for(it=v.begin();it!=v.end();++it)
+{
+
+static int i;
+output[i] = *it;
+i++;
+
+}/*
+ if(output[0]==5)
+ if(output[1]==10)
+ if(output[2]==15)
+ if(output[3]==20)
+ if(output[4]==25)
+ if(output[5]==30)
+ if(output[6]==40)
+ if(output[7]==50)
+ return KErrNone;
+ return KErrGeneral;*/
+ //__UHEAP_MARKEND;
+
+ if(output[0]!=5)
+ failures++;
+
+ if(output[1]!=10)
+ failures++;
+
+ if(output[2]!=15)
+ failures++;
+ if(output[3]!=20)
+ failures++;
+ if(output[4]!=25)
+ failures++;
+ if(output[5]!=30)
+ failures++;
+ if(output[6]!=40)
+ failures++;
+ if(output[7]!=50)
+ failures++;
+
+
+ //#if STDCPP_OOM
+//failures++;
+// #endif
+ }
+ catch(bad_alloc&)
+ {
+ //do nothing
+ }
+ catch(...)
+ {
+ failures++;
+
+ }
+
+ if(failures )
+ return KErrGeneral;
+ return KErrNone;
+ }
+
+
+
+ TInt Ctstl_2::HeapL(CStifItemParser& aItem)
+ {
+
+
+//__UHEAP_MARK;
+
+
+int failures=0;
+try{
+int myints[] = {10,20,30,5,15};
+
+ vector<int> v(myints,myints+5);
+
+ // vector<int>::iterator it;
+ // cout<<"";
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
+ #endif
+ make_heap(v.begin(),v.end()); //make_heap
+
+ if(v.front()!=30)
+ failures++;
+
+ pop_heap(v.begin(),v.end()); //pop_heap
+ v.pop_back(); //pop_back
+
+
+ if(v.front()!=20)
+ failures++;
+
+ v.push_back(99); //push_back
+
+
+ push_heap(v.begin(),v.end()); //push heap
+
+ if(v.front()!=99)
+ failures++;
+
+
+ sort_heap(v.begin(),v.end()); //sort_heap
+
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);
+ #endif
+ if(v[0]!=5)
+ failures++;
+ if(v[1]!=10)
+ failures++;
+ if(v[2]!=15)
+ failures++;
+ if(v[3]!=20)
+ failures++;
+ if(v[4]!=99)
+ failures++;
+
+
+/*
+ if(failures)
+ return KErrGeneral;
+ return KErrNone;
+ */
+ //#if STDCPP_OOM
+//failures++;
+// #endif
+
+ //__UHEAP_MARKEND;
+
+ }
+
+ catch(bad_alloc&)
+ {
+ //do nothing
+ }
+ catch(...)
+ {
+ failures++;
+
+ }
+
+ if(failures )
+ return KErrGeneral;
+ return KErrNone;
+ }
+
+
+ TInt Ctstl_2::Swapranges(CStifItemParser& aItem)
+ {
+ int failures=0;
+// __UHEAP_MARK;
+try{
+
+ vector<int> first (5,10); // first: 10 10 10 10 10
+ vector<int> second (5,33); // second: 33 33 33 33 33
+ vector<int>::iterator it;
+int output[5];
+ // cout<<"";
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
+ #endif
+ swap_ranges(first.begin()+1, first.end()-1, second.begin());
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);
+ #endif
+
+
+// print out results of swap:
+ for (it=first.begin(); it!=first.end(); ++it)
+
+
+ {
+ static int i;
+ output[i] = *it;
+ i++;
+ }
+
+
+ /*
+ if(output[0]==10)
+ if(output[1]==33)
+ if(output[2]==33)
+ if(output[3]==33)
+ if(output[4]==10)
+ return KErrNone;
+ return KErrGeneral;
+ */
+ if(output[0]!=10)
+ failures++;
+ if(output[1]!=33)
+ failures++;
+ if(output[2]!=33)
+ failures++;
+
+ if(output[3]!=33)
+ failures++;
+ if(output[4]!=10)
+ failures++;
+
+ //#if STDCPP_OOM
+//failures++;
+// #endif
+
+//__UHEAP_MARKEND;
+
+ }
+
+ catch(bad_alloc&)
+ {
+ //do nothing
+ }
+ catch(...)
+ {
+ failures++;
+
+ }
+
+ if(failures )
+ return KErrGeneral;
+ return KErrNone;
+ }
+
+
+ TInt Ctstl_2::Partialsums(CStifItemParser& aItem)
+ {
+ int failures=0;
+ //__UHEAP_MARK;
+ try{
+
+ vector<int> V1( 10 ), V2( 10 );
+ vector<int>::iterator VIter1, VIterend;
+
+int sum =1;
+ int i=2 ;
+ list <int> L1;
+// list <int>::iterator LIter1, LIterend;
+
+ int t;
+ for ( t = 1 ; t <= 10 ; t++ )
+ {
+ L1.push_back( t );
+ }
+
+ // cout<<"";
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
+ #endif
+ // The first member function for the partial sums of
+ // elements in a list output to a vector
+ VIterend = partial_sum ( L1.begin ( ) , L1.end ( ) ,
+ V1.begin ( ) );
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);
+ #endif
+ for ( VIter1 = V1.begin( ) ; VIter1 != VIterend ; VIter1++ )
+
+ {
+
+ if(sum!=*VIter1)
+ failures++;
+ sum = sum+i;
+ i++;
+
+ }
+
+ /*
+ if(failures)
+ return KErrGeneral;
+ return KErrNone;
+ */
+
+ //#if STDCPP_OOM
+//failures++;
+// #endif
+
+//__UHEAP_MARKEND;
+
+ }
+
+ catch(bad_alloc&)
+ {
+ //do nothing
+ }
+ catch(...)
+ {
+ failures++;
+
+ }
+
+ if(failures )
+ return KErrGeneral;
+ return KErrNone;
+ }
+
+
+TInt Ctstl_2::Unarynegate(CStifItemParser& aItem)
+ {
+ int failures=0;
+// __UHEAP_MARK;
+ try{
+ vector <int> v1;
+
+ //vector <int>::iterator Iter;
+
+ int i;
+ for ( i = 0 ; i <= 7 ; i++ )
+ {
+ v1.push_back( 5 * i );
+ }
+
+
+
+ int result2;
+ int result3;
+ // Use the negator to count the elements less than or equal to 10
+ // cout<<"";
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
+ #endif
+ result2 = count_if( v1.begin( ), v1.end( ),unary_negate<binder2nd <greater<int> > >( bind2nd( greater<int>( ),10 ) ) );
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);
+ #endif
+ result3 = count_if( v1.begin( ), v1.end( ),not1(bind2nd( greater<int>( ), 10) ) );
+
+
+
+ /*
+ if(result2 == 3)
+ if(result3 == 3)
+ return KErrNone;
+ return KErrGeneral;
+ */
+ if(result2 != 3)
+ failures++;
+ if(result3 != 3)
+ failures++;
+
+
+//__UHEAP_MARKEND;
+ //#if STDCPP_OOM
+//failures++;
+// #endif
+ }
+
+ catch(bad_alloc&)
+ {
+ //do nothing
+ }
+ catch(...)
+ {
+ failures++;
+
+ }
+
+ if(failures )
+ return KErrGeneral;
+ return KErrNone;
+ }
+
+
+ TInt Ctstl_2::Not2(CStifItemParser& aItem)
+ {
+ int failures=0;
+ //__UHEAP_MARK;
+ try{
+ vector <int> v1;
+ vector <int>::iterator Iter1;
+int output[7];
+ //int i;
+ v1.push_back( 6262 );
+ v1.push_back( 6262 );
+ v1.push_back( 18467 );
+ v1.push_back( 6334 );
+ v1.push_back( 26500 );
+ v1.push_back( 19169);
+ v1.push_back(41);
+
+
+
+ // cout<<"";
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
+ #endif
+
+ // To sort in descending order,
+ // use the binary_negate helper function not2
+ sort( v1.begin( ), v1.end( ), not2(less<int>( ) ) );
+
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);
+ #endif
+
+ for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
+ {
+ static int i;
+ output[i] = *Iter1;
+ i++;
+ }
+
+ /*
+ if(output[0]==26500)
+ if(output[1]==19169)
+ if(output[2]== 18467)
+ if(output[3]== 6334)
+ if(output[4]== 6262)
+ if(output[5]== 6262)
+ if(output[6]== 41)
+
+ return KErrNone;
+ return KErrGeneral;
+ */
+
+
+ if(output[0]!=26500)
+ failures++;
+ if(output[1]!=19169)
+ failures++;
+ if(output[2]!= 18467)
+ failures++;
+ if(output[3]!= 6334)
+ failures++;
+ if(output[4]!= 6262)
+ failures++;
+ if(output[5]!= 6262)
+ failures++;
+ if(output[6]!= 41)
+ failures++;
+
+ //#if STDCPP_OOM
+//failures++;
+// #endif
+
+ //__UHEAP_MARKEND;
+
+ }
+
+catch(bad_alloc&)
+ {
+ //do nothing
+ }
+ catch(...)
+ {
+ failures++;
+
+ }
+
+ if(failures )
+ return KErrGeneral;
+ return KErrNone;
+ }
+
+
+
+TInt Ctstl_2::GettemporarybufferL(CStifItemParser& aItem)
+ {
+ int failures=0;
+ //__UHEAP_MARK;
+ try{
+ // Create an array of ints
+ int intArray [ ] = { 10, 20, 30, 40, 100, 200, 300, 1000, 2000 };
+ int count = sizeof ( intArray ) / sizeof ( int );
+
+
+ pair<int *, ptrdiff_t> resultPair;
+ // cout<<"";
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
+ #endif
+ resultPair = get_temporary_buffer<int>( count );
+ #if STDCPP_M
+User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);
+ #endif
+
+int* tempBuffer = resultPair.first;
+
+return_temporary_buffer(tempBuffer);
+/*
+ if(count==9)
+ if(resultPair.second == 9)
+ return KErrNone;
+ return KErrGeneral;
+ */
+ if(count!=9)
+ failures++;
+ #if STDCPP_OOM
+ if(resultPair.second!=0)
+ #else
+ if(resultPair.second!=9)
+ #endif
+ failures++;
+
+
+ //#if STDCPP_OOM
+//failures++;
+// #endif
+ // __UHEAP_MARKEND;
+
+ }
+
+ catch(bad_alloc&)
+ {
+ //do nothing
+ }
+ catch(...)
+ {
+ failures++;
+
+ }
+
+ if(failures )
+ return KErrGeneral;
+ return KErrNone;
+ }
+
+
+
+
+ TInt Ctstl_2::Pair(CStifItemParser& aItem)
+ {
+
+ //__UHEAP_MARK;
+
+ int failures=0;
+ try{
+
+ // cout<<"";
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
+ #endif
+typedef struct pair<int, float> PAIR_IF;
+
+ PAIR_IF A(10,3.14f);
+ PAIR_IF B(18,3.14f);
+ PAIR_IF C(10,6.28f);
+ PAIR_IF D(10,3.14f);
+
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);
+ #endif
+
+ if (A==D)
+
+ if (B!=C)
+
+ if (A>C)
+ failures++;
+
+
+ if (A>=C)
+ failures++;
+
+
+/*
+ if(failures)
+ return KErrGeneral;
+ return KErrNone;
+ */
+ //#if STDCPP_OOM
+//failures++;
+// #endif
+
+
+ //__UHEAP_MARKEND;
+
+ }
+
+
+catch(bad_alloc&)
+ {
+ //do nothing
+ }
+ catch(...)
+ {
+ failures++;
+
+ }
+
+ if(failures )
+ return KErrGeneral;
+ return KErrNone;
+ }
+
+
+
+ bool twice ( int elem1, int elem2 )
+{
+ return 2 * elem1 < elem2;
+}
+
+
+ TInt Ctstl_2::Lexicographicalcompare(CStifItemParser& aItem)
+ {
+
+ //__UHEAP_MARK;
+
+
+
+
+ int failures=0;
+
+ try
+ {
+
+ vector <int> v1, v2;
+ list <int> L1;
+// vector <int>::iterator Iter1, Iter2;
+// list <int>::iterator L1_Iter, L1_inIter;
+
+ int i;
+ for ( i = 0 ; i <= 5 ; i++ )
+ {
+ v1.push_back( 5 * i );
+ }
+ int ii;
+ for ( ii = 0 ; ii <= 6 ; ii++ )
+ {
+ L1.push_back( 5 * ii );
+ }
+
+ int iii;
+ for ( iii = 0 ; iii <= 5 ; iii++ )
+ {
+ v2.push_back( 10 * iii );
+ }
+
+
+ // Self lexicographical_comparison of v1 under identity
+ bool result1;
+ // cout<<"";
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
+ #endif
+
+ result1 = lexicographical_compare (v1.begin( ), v1.end( ), v1.begin( ), v1.end( ) );
+
+
+
+ // lexicographical_comparison of v1 and L2 under identity
+ bool result2;
+ result2 = lexicographical_compare (v1.begin( ), v1.end( ), L1.begin( ), L1.end( ) );
+
+
+
+ bool result3;
+ result3 = lexicographical_compare (v1.begin( ), v1.end( ), v2.begin( ), v2.end( ), twice );
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);
+ #endif
+ /*
+ if (!result1)
+ if ( result2 )
+ if (!result3 )
+
+ return KErrNone;
+ return KErrGeneral;
+
+ */
+
+ if(result1)
+ failures++;
+ if(!result2)
+ failures++;
+ if(result3)
+ failures++;
+
+ //#if STDCPP_OOM
+//failures++;
+// #endif
+
+ // __UHEAP_MARKEND;
+
+ }
+catch(bad_alloc&)
+ {
+ //do nothing
+ }
+ catch(...)
+ {
+ failures++;
+
+ }
+
+ if(failures )
+ return KErrGeneral;
+ return KErrNone;
+ }
+
+//Mismatch
+
+bool mypredicate (int i, int j) {
+ return (i==j);
+}
+
+
+
+TInt Ctstl_2::Mismatch(CStifItemParser& aItem)
+ {
+
+// __UHEAP_MARK;
+
+
+int failures=0;
+try{
+
+ vector<int> myvector;
+ for (int i=1; i<6; i++) myvector.push_back (i*10); // myvector: 10 20 30 40 50
+
+ int myints[] = {10,20,80,320,1024}; // myints: 10 20 80 320 1024
+
+ pair<vector<int>::iterator,int*> mypair;
+ // cout<<"";
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
+ #endif
+ // using default comparison:
+ mypair = mismatch (myvector.begin(), myvector.end(), myints);
+ // cout<<"";
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);
+ #endif
+ if(*mypair.first != 30)
+ failures++;
+
+ if(*mypair.second != 80)
+ failures++;
+
+
+ mypair.first++;
+ mypair.second++;
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
+ #endif
+ // using predicate comparison:
+ mypair = mismatch (mypair.first, myvector.end(), mypair.second, mypredicate);
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);
+ #endif
+ if(*mypair.first != 40)
+ failures++;
+ if(*mypair.second != 320)
+ failures++;
+ /*
+ if(failures)
+ return KErrGeneral;
+ return KErrNone;
+ */
+ //#if STDCPP_OOM
+//failures++;
+// #endif
+
+ // __UHEAP_MARKEND;
+
+ }
+
+ catch(bad_alloc&)
+ {
+ //do nothing
+ }
+ catch(...)
+ {
+ failures++;
+
+ }
+
+ if(failures )
+ return KErrGeneral;
+ return KErrNone;
+ }
+
+
+ TInt Ctstl_2::Compare_fun(CStifItemParser& aItem)
+
+ {
+ int failures=0;
+ //__UHEAP_MARK;
+ try
+ {
+
+
+ string str1 ("green apple");
+ string str2 ("red apple");
+ // cout<<"";
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
+ #endif
+ if (str1.compare("str2") == 0)
+ failures++;
+
+ if (str1.compare(6,5,"apple") != 0)
+ failures++;
+
+ if (str2.compare(str2.size()-5,5,"apple") != 0)
+
+ failures++;
+
+
+ if (str1.compare(6,5,str2,4,5) != 0)
+ failures++;
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);
+ #endif
+ /*
+ if(failures)
+
+ return KErrGeneral;
+ return KErrNone;
+ */
+ //__UHEAP_MARKEND;
+ //#if STDCPP_OOM
+//failures++;
+// #endif
+ }
+
+ catch(bad_alloc&)
+ {
+ //do nothing
+ }
+ catch(...)
+ {
+ failures++;
+
+ }
+
+ if(failures )
+ return KErrGeneral;
+ return KErrNone;
+ }
+
+
+
+ TInt Ctstl_2::Copy_fun(CStifItemParser& aItem)
+
+ {
+ int failures=0;
+// __UHEAP_MARK;
+ try
+ {
+ int myints[]={10,20,30,40,50,60,70};
+ vector<int> myvector;
+ vector<int>::iterator it;
+int a[7];
+
+ myvector.resize(7);
+ // cout<<"";
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
+ #endif
+ copy ( myints, myints+7, myvector.begin() );
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);
+ #endif
+ for (it=myvector.begin(); it!=myvector.end(); ++it)
+ {
+ static int i;
+ a[i] = *it;
+ i++;
+ }
+ /*
+if(a[0]==10)
+if(a[1]==20)
+if(a[2]==30)
+if(a[3]==40)
+if(a[4]==50)
+if(a[5]==60)
+if(a[6]==70)
+return KErrNone;
+return KErrGeneral;*/
+
+if(a[0]!=10)
+failures++;
+if(a[1]!=20)
+failures++;
+
+if(a[2]!=30)
+failures++;
+if(a[3]!=40)
+failures++;
+if(a[4]!=50)
+failures++;
+if(a[5]!=60)
+failures++;
+if(a[6]!=70)
+failures++;
+
+
+//__UHEAP_MARKEND;
+ //#if STDCPP_OOM
+//failures++;
+// #endif
+ }
+
+
+ catch(bad_alloc&)
+ {
+ //do nothing
+ }
+ catch(...)
+ {
+ failures++;
+
+ }
+
+ if(failures )
+ return KErrGeneral;
+ return KErrNone;
+ }
+
+ TInt Ctstl_2::Copybackward_fun(CStifItemParser& aItem)
+
+ {
+
+ int failures=0;
+
+ //__UHEAP_MARK;
+ try{
+
+ vector<int> myvector;
+ vector<int>::iterator it;
+int a[11];
+ // set some values:
+ for (int i=1; i<=5; i++)
+ myvector.push_back(i*10); // myvector: 10 20 30 40 50
+
+ myvector.resize(myvector.size()+6); // allocate space for 6 more elements
+ // cout<<"";
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
+ #endif
+ copy_backward ( myvector.begin(), myvector.begin()+5, myvector.end() );
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);
+ #endif
+
+ for (it=myvector.begin(); it!=myvector.end(); ++it)
+ {
+ static int i;
+ a[i] = *it;
+ i++;
+ }
+ /*
+if(a[0]==10)
+if(a[1]==20)
+if(a[2]==30)
+if(a[3]==40)
+if(a[4]==50)
+
+if(a[6]==10)
+if(a[7]==20)
+if(a[8]==30)
+if(a[9]==40)
+if(a[10]==50)
+
+ return KErrNone;
+ else
+
+return KErrGeneral;
+ */
+// __UHEAP_MARKEND;
+
+ if(a[0]!=10)
+ failures++;
+
+if(a[1]!=20)
+failures++;
+if(a[2]!=30)
+failures++;
+if(a[3]!=40)
+failures++;
+if(a[4]!=50)
+failures++;
+
+if(a[6]!=10)
+failures++;
+if(a[7]!=20)
+failures++;
+if(a[8]!=30)
+failures++;
+if(a[9]!=40)
+failures++;
+if(a[10]!=50)
+failures++;
+ //#if STDCPP_OOM
+//failures++;
+// #endif
+ }
+
+ catch(bad_alloc&)
+ {
+ //do nothing
+ }
+ catch(...)
+ {
+ failures++;
+
+ }
+
+ if(failures )
+ return KErrGeneral;
+ return KErrNone;
+ }
+
+
+ TInt Ctstl_2::mergeL(CStifItemParser& aItem)
+
+ {
+ int failures=0;
+ try
+ {
+ int a[4];
+
+ list <int> c1, c2;
+ list <int>::iterator c2_Iter ;
+
+// __UHEAP_MARK;
+
+
+
+
+
+ c1.push_back( 3 );
+ c1.push_back( 6 );
+ c2.push_back( 2 );
+ c2.push_back( 4 );
+
+ // cout<<"";
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
+ #endif
+
+ c2.merge( c1 ); // Merge c1 into c2 in (default) ascending order
+
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);
+ #endif
+ c2.sort( greater<int>( ) );
+ for ( c2_Iter = c2.begin( ); c2_Iter != c2.end( ); c2_Iter++ )
+
+ {
+ static int i;
+ a[i]= *c2_Iter;
+ i++;
+ }
+
+// __UHEAP_MARKEND;
+
+ /* if(a[0]==6)
+ if(a[1]==4)
+ if(a[2]==3)
+ if(a[3]==2)
+
+
+
+ return KErrNone;
+
+ return KErrGeneral;
+ */
+
+
+ if(a[0]!=6)
+
+ failures++;
+
+ if(a[1]!=4)
+ failures++;
+ if(a[2]!=3)
+ failures++;
+ if(a[3]!=2)
+ failures++;
+
+ //#if STDCPP_OOM
+//failures++;
+// #endif
+
+
+ }
+
+catch(bad_alloc&)
+ {
+ //do nothing
+ }
+ catch(...)
+ {
+ failures++;
+
+ }
+
+ if(failures )
+ return KErrGeneral;
+ return KErrNone;
+ }
+
+TInt Ctstl_2::allocatoradd(CStifItemParser& aItem)
+
+ {
+ int failures = 0;
+
+ // __UHEAP_MARK;
+try{
+ vector <int> v1;
+// vector <int>::iterator v1Iter;
+ vector <int>:: allocator_type v1Alloc;
+
+ int i;
+ for ( i = 1 ; i <= 7 ; i++ )
+ {
+ v1.push_back( 2 * i );
+ }
+
+ // cout<<"";
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
+ #endif
+
+ allocator<int>::const_pointer v1Ptr;
+
+
+ const int k = 8;
+ v1Ptr = v1Alloc.address( k );
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);
+ #endif
+
+ /*
+ if( *v1Ptr == 8)
+// __UHEAP_MARKEND;
+
+ return KErrNone;
+
+ return KErrGeneral;
+ */
+
+
+ if(*v1Ptr!=8)
+ failures++;
+
+
+ //#if STDCPP_OOM
+//failures++;
+// #endif
+
+
+ }
+
+catch(bad_alloc&)
+ {
+ //do nothing
+ }
+ catch(...)
+ {
+ failures++;
+
+ }
+
+ if(failures )
+ return KErrGeneral;
+ return KErrNone;
+ }
+
+
+
+ TInt Ctstl_2::alldeall(CStifItemParser& aItem)
+
+
+ {
+
+ //__UHEAP_MARK;
+
+ int failures =0;
+
+ try{
+
+
+ allocator<int> v1Alloc;
+
+ allocator<int>::pointer aPtr;
+
+ aPtr = v1Alloc.allocate ( 5 );
+
+ int i;
+ for ( i = 0 ; i < 5 ; i++ )
+ {
+ aPtr[ i ] = i;
+ }
+
+ if(aPtr[0] != 0)
+ failures++;
+ // cout<<"";
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
+ #endif
+ v1Alloc.deallocate( aPtr, 5 );
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);
+ #endif
+
+ if(aPtr[0] == 0)
+ failures++;
+
+
+ //__UHEAP_MARKEND;
+/*
+ if (failures)
+ return KErrGeneral;
+ else
+ return KErrNone;
+
+ */
+
+ //#if STDCPP_OOM
+//failures++;
+// #endif
+ }
+
+ catch(bad_alloc&)
+ {
+ //do nothing
+ }
+ catch(...)
+ {
+ failures++;
+
+ }
+
+ if(failures )
+ return KErrGeneral;
+ return KErrNone;
+ }
+
+
+ TInt Ctstl_2::allcons(CStifItemParser& aItem)
+ {
+
+
+ // __UHEAP_MARK;
+
+ int output[7],failures = 0;
+ try{
+ vector <int> v1;
+ vector <int>::iterator v1Iter;
+ vector <int>:: allocator_type v1Alloc;
+
+ int i;
+ for ( i = 1 ; i <= 7 ; i++ )
+ {
+ v1.push_back( 3 * i );
+ }
+
+ for ( v1Iter = v1.begin( ) ; v1Iter != v1.end( ) ; v1Iter++ )
+
+ {
+ static int i;
+ output[i] = *v1Iter;
+ i++;
+
+ }
+
+
+ if(output[1] != 6)
+ failures++;
+
+
+ allocator<int>::pointer v1PtrA;
+ int kA = 6, kB = 7;
+ v1PtrA = v1Alloc.address( *find( v1.begin( ), v1.end( ), kA ) );
+ v1Alloc.destroy ( v1PtrA );
+ // cout<<"";
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
+ #endif
+ v1Alloc.construct ( v1PtrA , kB );
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);
+ #endif
+ for ( v1Iter = v1.begin( ) ; v1Iter != v1.end( ) ; v1Iter++ )
+
+ {
+ static int i;
+ output[i] = *v1Iter;
+ i++;
+
+ }
+
+ if(output[1] != 7)
+ failures++;
+
+
+ // __UHEAP_MARKEND;
+
+ /* if(failures)
+ return KErrGeneral;
+ return KErrNone;
+ */
+
+ //#if STDCPP_OOM
+//failures++;
+// #endif
+
+
+
+
+
+ }
+ catch(bad_alloc&)
+ {
+ //do nothing
+ }
+ catch(...)
+ {
+ failures++;
+
+ }
+
+ if(failures )
+ return KErrGeneral;
+ return KErrNone;
+ }
+
+ TInt Ctstl_2::allrebind(CStifItemParser& aItem)
+ {
+
+
+
+
+ // __UHEAP_MARK;
+ int failures =0;
+ try{
+
+ typedef vector<int>::allocator_type IntAlloc;
+
+ IntAlloc v1Iter;
+ vector<int> v1;
+ // cout<<"";
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
+ #endif
+ IntAlloc::rebind<char>::other::pointer pszC = IntAlloc::rebind<char>::other(v1.get_allocator()).allocate(1, (void *)0);
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);
+ #endif
+ int * pInt = v1Iter.allocate(10);
+
+
+
+ // __UHEAP_MARKEND;
+
+ /* if(failures)
+ return KErrGeneral;
+ return KErrNone;
+ */
+
+ //#if STDCPP_OOM
+//failures++;
+// #endif
+
+ }
+
+catch(bad_alloc&)
+ {
+ //do nothing
+ }
+ catch(...)
+ {
+ failures++;
+
+ }
+
+ if(failures )
+ return KErrGeneral;
+ return KErrNone;
+ }
+
+
+ TInt Ctstl_2::allmaxsize(CStifItemParser& aItem)
+
+ {int failures=0;
+
+
+ try{
+ vector <int> v1;
+// vector <int>::iterator v1Iter;
+ vector <int>:: allocator_type v1Alloc;
+
+
+
+
+ allocator<int>::size_type v1size;
+ // cout<<"";
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
+ #endif
+ v1size = v1Alloc.max_size( );
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);
+ #endif
+ /*if(v1size == 1073741823)
+ return KErrNone;
+ else
+ return KErrGeneral;*/
+
+
+ if(v1size != 1073741823)
+ failures++;
+
+
+ //#if STDCPP_OOM
+//failures++;
+// #endif
+
+ }
+
+
+ catch(bad_alloc&)
+ {
+ //do nothing
+ }
+ catch(...)
+ {
+ failures++;
+
+ }
+
+ if(failures )
+ return KErrGeneral;
+ return KErrNone;
+ }
+
+
+
+
+ TInt Ctstl_2::complexL(CStifItemParser& aItem)
+
+ {int failures=0;
+ try
+ {
+
+
+
+// double pi = 3.14159265359;
+ // cout<<"";
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
+ #endif
+ complex <double> c1 ( 4.0 , 5.0 );
+
+ double re = real(c1);
+
+ double im = imag(c1);
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);
+ #endif
+ /* if(re == 4)
+ if(im == 5)
+ return KErrNone;
+ return KErrGeneral;
+
+*/
+
+if(re!=4)
+failures++;
+if (im!= 5)
+failures++;
+
+
+ //#if STDCPP_OOM
+//failures++;
+// #endif
+
+
+ }
+ catch(bad_alloc&)
+ {
+ //do nothing
+ }
+ catch(...)
+ {
+ failures++;
+
+ }
+
+ if(failures )
+ return KErrGeneral;
+ return KErrNone;
+ }
+
+
+TInt Ctstl_2::limitsL(CStifItemParser& aItem)
+
+{
+
+//__UHEAP_MARK;
+
+int failures=0;
+
+try
+{
+ // cout<<"";
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
+ #endif
+//is_speciallized
+if(!numeric_limits<float>::is_specialized)
+failures++;
+
+if(!numeric_limits<int>::is_specialized)
+failures++;
+
+
+//if(!numeric_limits<long double>::is_specialized) //failing
+//failures++;
+
+
+if(!numeric_limits<double>::is_specialized)
+failures++;
+
+if(!numeric_limits<wchar_t>::is_specialized)
+failures++;
+
+
+if(!numeric_limits<char>::is_specialized)
+failures++;
+
+
+
+if(!numeric_limits<bool>::is_specialized)
+failures++;
+
+
+
+
+if(!numeric_limits<signed char>::is_specialized)
+failures++;
+
+
+if(!numeric_limits<unsigned char>::is_specialized)
+failures++;
+
+
+
+if(!numeric_limits<short>::is_specialized)
+failures++;
+
+
+
+if(!numeric_limits<unsigned short>::is_specialized)
+failures++;
+
+
+
+
+//if(!numeric_limits<_int64>::is_specialized)
+//failures++;
+
+
+
+
+
+//digits
+if(numeric_limits<float>::digits !=24)
+failures++;
+
+if( numeric_limits<double>::digits !=53)
+failures++;
+
+//if( numeric_limits<long double>::digits !=64) failed 0
+//failures++;
+
+ if (numeric_limits<int>::digits != 31)
+failures++;
+
+if(numeric_limits<__int64>::digits !=63)
+ failures++;
+
+
+if(numeric_limits<char>::digits != 7)
+ failures++;
+
+
+if(numeric_limits<short>::digits != 15)
+ failures++;
+
+if(numeric_limits<unsigned short>::digits != 16)
+ failures++;
+
+if(numeric_limits<long>::digits != 31)
+failures++;
+
+
+if(numeric_limits<unsigned long>::digits != 32)
+ failures++;
+
+
+if(numeric_limits<wchar_t>::digits != 16)
+failures++;
+
+if(numeric_limits<unsigned char>::digits != 8)
+ failures++;
+
+
+if(numeric_limits<signed char>::digits != 7)
+ failures++;
+
+if(numeric_limits<bool>::digits != 1)
+ failures++;
+
+
+
+//digit10
+
+if(numeric_limits<float>::digits10 !=6)
+failures++;
+
+if( numeric_limits<double>::digits10 !=15)
+failures++;
+
+//if( numeric_limits<long double>::digits10 !=18)
+//failures++;
+
+if (numeric_limits<int>::digits10 != 9)
+failures++;
+
+//if(numeric_limits<__int64>::digits10 !=63)
+// failures++;
+
+
+if(numeric_limits<char>::digits10 != 2)
+ failures++;
+
+
+if(numeric_limits<short>::digits10 != 4)
+ failures++;
+
+if(numeric_limits<unsigned short>::digits10 != 4)
+ failures++;
+
+if(numeric_limits<long>::digits10 != 9)
+failures++;
+
+
+
+if(numeric_limits<unsigned long>::digits10 !=9)
+ failures++;
+
+if(numeric_limits<wchar_t>::digits10 != 4)
+failures++;
+
+if(numeric_limits<unsigned char>::digits10 != 2)
+ failures++;
+
+
+if(numeric_limits<signed char>::digits10 != 2)
+ failures++;
+
+if(numeric_limits<bool>::digits10 != 0)
+ failures++;
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);
+ #endif
+
+//de_norm
+
+//__UHEAP_MARKEND;
+
+
+/*
+if(failures)
+return KErrGeneral;
+return KErrNone;
+
+*/
+ //#if STDCPP_OOM
+//failures++;
+// #endif
+
+
+
+
+
+}
+
+
+
+
+
+catch(bad_alloc&)
+ {
+ //do nothing
+ }
+ catch(...)
+ {
+ failures++;
+
+ }
+
+ if(failures )
+ return KErrGeneral;
+ return KErrNone;
+ }
+
+
+
+TInt Ctstl_2::nextperm(CStifItemParser& aItem)
+{
+
+ int failures =0;
+
+ try
+ {
+ int myints[] = {1,2};
+
+ // cout<<"";
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
+ #endif
+
+ do {
+
+
+ static int i;
+ if (i==0)
+ {
+ if(myints[0]!=1)
+ failures++;
+ if(myints[1]!=2)
+ failures++;
+
+ }
+
+ else
+ {
+ if(myints[0]!=2)
+ failures++;
+ if(myints[1]!=1)
+ failures++;
+ }
+ i++;
+
+ } while ( next_permutation (myints,myints+2) );
+
+
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);
+ #endif
+
+
+
+
+ /*
+
+ if(failures)
+ return KErrGeneral;
+ else
+ return KErrNone;
+
+*/
+ //#if STDCPP_OOM
+//failures++;
+// #endif
+
+}
+
+catch(bad_alloc&)
+ {
+ //do nothing
+ }
+ catch(...)
+ {
+ failures++;
+
+ }
+
+ if(failures )
+ return KErrGeneral;
+ return KErrNone;
+ }
+
+
+
+
+TInt Ctstl_2::prevperm(CStifItemParser& aItem)
+{
+
+ int failures =0;
+
+ try{
+ int myints[] = {2,1};
+ // cout<<"";
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
+ #endif
+
+ do {
+
+
+ static int i;
+ if (i==0)
+ {
+ if(myints[0]!=2)
+ failures++;
+ if(myints[1]!=1)
+ failures++;
+
+ }
+
+ else
+ {
+ if(myints[0]!=1)
+ failures++;
+ if(myints[1]!=2)
+ failures++;
+ }
+ i++;
+
+ } while ( prev_permutation (myints,myints+2) );
+
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);
+ #endif
+
+
+
+
+
+
+/*
+ if(failures)
+ return KErrGeneral;
+ else
+ return KErrNone;
+*/
+ //#if STDCPP_OOM
+//failures++;
+// #endif
+
+
+}
+
+catch(bad_alloc&)
+ {
+ //do nothing
+ }
+ catch(...)
+ {
+ failures++;
+
+ }
+
+ if(failures )
+ return KErrGeneral;
+ return KErrNone;
+ }
+
+
+TInt Ctstl_2::ptrfun(CStifItemParser& aItem)
+{
+int failures=0;
+try
+
+{
+
+ vector <char*> v1;
+ vector <char*>::iterator RIter;
+
+ v1.push_back ( "this" );
+ v1.push_back ( "is" );
+ v1.push_back ( "ptrfun" );
+ v1.push_back ( "test" );
+ v1.push_back ( "case" );
+ // cout<<"";
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
+ #endif
+ // To search the sequence for "pearly"
+ // use a pointer_to_function conversion
+ // __UHEAP_MARK;
+ RIter = find_if( v1.begin( ), v1.end( ), not1 ( bind2nd (ptr_fun ( strcmp ), "ptrfun" ) ) );
+
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);
+ #endif
+//__UHEAP_MARKEND;
+/*
+if(strcmp(*RIter,"ptrfun\n"))
+
+return KErrNone;
+else
+return KErrGeneral;
+
+*/
+
+if(!strcmp(*RIter,"ptrfun\n"))
+failures++;
+
+ //#if STDCPP_OOM
+//failures++;
+// #endif
+}
+catch(bad_alloc&)
+ {
+ //do nothing
+ }
+ catch(...)
+ {
+ failures++;
+
+ }
+
+ if(failures )
+ return KErrGeneral;
+ return KErrNone;
+ }
+
+TInt Ctstl_2::itertraits(CStifItemParser& aItem)
+{
+ int failures=0;
+
+ try
+
+ {
+ vector<int> vi;
+ vector<char> vc;
+ list<char> lc;
+ // cout<<"";
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
+ #endif
+ iterator_traits<vector<int>:: iterator>::iterator_category cati;
+ iterator_traits<vector<char>:: iterator>::iterator_category catc;
+ iterator_traits<list<char>:: iterator>::iterator_category catlc;
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);
+ #endif
+
+ //if ( typeid ( cati ) != typeid( catc ) ) //compiler error
+ // failures++;
+
+
+ // if ( typeid ( vi.begin( ) ) == typeid( vc.begin( ) ) )
+ //failures++;
+ /* if(failures)
+ return KErrGeneral;
+ return KErrNone;*/
+
+
+ //#if STDCPP_OOM
+//failures++;
+// #endif
+
+
+
+
+}
+catch(bad_alloc&)
+ {
+ //do nothing
+ }
+ catch(...)
+ {
+ failures++;
+
+ }
+
+ if(failures )
+ return KErrGeneral;
+ return KErrNone;
+ }
+
+TInt Ctstl_2::map1(CStifItemParser& aItem)
+{
+
+int failures=0;
+//insert,begin,map
+try
+{
+ // cout<<"";
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
+ #endif
+map <int, int> m1;
+
+ map <int, int> :: iterator m1_Iter;
+ map <int, int> :: const_iterator m1_cIter;
+ typedef pair <int, int> Int_Pair;
+
+ m1.insert ( Int_Pair ( 0, 0 ) );
+ m1.insert ( Int_Pair ( 1, 1 ) );
+ m1.insert ( Int_Pair ( 2, 4 ) );
+
+ m1_cIter = m1.begin ( );
+ if(m1_cIter -> first != 0)
+ failures++;
+
+ m1_Iter = m1.begin ( );
+ m1.erase ( m1_Iter );
+
+
+
+ m1_cIter = m1.begin( );
+
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);
+ #endif
+ if( m1_cIter -> first !=1)
+ failures++;
+ /*
+ if(failures)
+ return KErrGeneral;
+ else
+ return KErrNone;
+ */
+
+ //#if STDCPP_OOM
+//failures++;
+// #endif
+
+}
+
+catch(bad_alloc&)
+ {
+ //do nothing
+ }
+ catch(...)
+ {
+ failures++;
+
+ }
+
+ if(failures )
+ return KErrGeneral;
+ return KErrNone;
+ }
+
+
+
+TInt Ctstl_2::map2(CStifItemParser& aItem)
+{
+//clear,size
+
+ int failures=0;
+
+ try
+ {
+ map<int, int> m1;
+ map<int, int>::size_type i;
+ typedef pair<int, int> Int_Pair;
+ // cout<<"";
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
+ #endif
+ m1.insert(Int_Pair(1, 1));
+ m1.insert(Int_Pair(2, 4));
+
+ i = m1.size();
+ if(i!=2)
+ failures++;
+
+ m1.clear();
+ i = m1.size();
+
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);
+ #endif
+ if(i!=0)
+ failures++;
+
+ /*
+ if(failures)
+ return KErrGeneral;
+ else
+ return KErrNone;
+ */
+
+ //#if STDCPP_OOM
+//failures++;
+// #endif
+
+}
+
+catch(bad_alloc&)
+ {
+ //do nothing
+ }
+ catch(...)
+ {
+ failures++;
+
+ }
+
+ if(failures )
+ return KErrGeneral;
+ return KErrNone;
+ }
+
+TInt Ctstl_2::map3(CStifItemParser& aItem)
+{
+//count
+int failures=0;
+
+try
+{
+ map<int, int> m1;
+ map<int, int>::size_type i;
+ typedef pair<int, int> Int_Pair;
+
+ m1.insert(Int_Pair(1, 1));
+ m1.insert(Int_Pair(2, 1));
+ m1.insert(Int_Pair(1, 4));
+ m1.insert(Int_Pair(2, 1));
+ // cout<<"";
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
+ #endif
+ // Keys must be unique in map, so duplicates are ignored
+ i = m1.count(1);
+ if(i!=1)
+ failures++;
+
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);
+ #endif
+ i = m1.count(2);
+ if(i!=1)
+ failures++;
+
+ i = m1.count(3);
+ if(i!=0)
+ failures++;
+
+
+
+/*
+
+ if(failures)
+ return KErrGeneral;
+ else
+ return KErrNone;
+ */
+ //#if STDCPP_OOM
+//failures++;
+// #endif
+
+}
+catch(bad_alloc&)
+ {
+ //do nothing
+ }
+ catch(...)
+ {
+ failures++;
+
+ }
+
+ if(failures )
+ return KErrGeneral;
+ return KErrNone;
+ }
+
+TInt Ctstl_2::map4(CStifItemParser& aItem)
+{
+//empty
+int failures=0;
+
+try
+{
+ map <int, int> m1, m2;
+
+ typedef pair <int, int> Int_Pair;
+ m1.insert ( Int_Pair ( 1, 1 ) );
+ // cout<<"";
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
+ #endif
+ if ( m1.empty( ) )
+ failures++;
+
+ if ( !m2.empty( ) )
+ failures++;
+
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);
+ #endif
+ /*
+ if(failures)
+ return KErrGeneral;
+ else
+ return KErrNone;
+ */
+
+
+ //#if STDCPP_OOM
+//failures++;
+// #endif
+
+}
+
+
+catch(bad_alloc&)
+ {
+ //do nothing
+ }
+ catch(...)
+ {
+ failures++;
+
+ }
+
+ if(failures )
+ return KErrGeneral;
+ return KErrNone;
+ }
+
+TInt Ctstl_2::map5(CStifItemParser& aItem)
+{
+//erase,end
+int failures=0;
+
+try
+{
+ map <int, int> m1;
+
+ map <int, int> :: iterator m1_Iter;
+ map <int, int> :: const_iterator m1_cIter;
+ typedef pair <int, int> Int_Pair;
+
+ m1.insert ( Int_Pair ( 1, 10 ) );
+ m1.insert ( Int_Pair ( 2, 20 ) );
+ m1.insert ( Int_Pair ( 3, 30 ) );
+ // cout<<"";
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
+ #endif
+ m1_cIter = m1.end( );
+ m1_cIter--;
+
+ if( m1_cIter -> second != 30)
+ failures++;
+
+ m1_Iter = m1.end( );
+ m1_Iter--;
+ m1.erase ( m1_Iter );
+
+
+
+ m1_cIter = m1.end( );
+ m1_cIter--;
+ if( m1_cIter -> second !=20)
+ failures++;
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);
+ #endif
+ /*
+ if(failures)
+ return KErrGeneral;
+ else
+ return KErrNone;
+ */
+ //#if STDCPP_OOM
+//failures++;
+// #endif
+
+}
+catch(bad_alloc&)
+ {
+ //do nothing
+ }
+ catch(...)
+ {
+ failures++;
+
+ }
+
+ if(failures )
+ return KErrGeneral;
+ return KErrNone;
+ }
+
+
+TInt Ctstl_2::map6(CStifItemParser& aItem)
+{
+//equal_range,upper_bound
+int failures=0;
+
+try
+{
+ typedef map <int, int, less<int> > IntMap;
+ IntMap m1;
+ map <int, int> :: const_iterator m1_RcIter;
+ typedef pair <int, int> Int_Pair;
+
+ m1.insert ( Int_Pair ( 1, 10 ) );
+ m1.insert ( Int_Pair ( 2, 20 ) );
+ m1.insert ( Int_Pair ( 3, 30 ) );
+
+ pair <IntMap::const_iterator, IntMap::const_iterator> p1, p2;
+ p1 = m1.equal_range( 2 );
+
+ if( p1.first -> second !=20)
+ failures++;
+
+
+ if( p1.second -> second != 30)
+ failures++;
+ // cout<<"";
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
+ #endif
+
+ // Compare the upper_bound called directly
+ m1_RcIter = m1.upper_bound( 2 );
+
+ if( m1_RcIter -> second!=30)
+ failures++;
+
+ p2 = m1.equal_range( 4 );
+
+ // If no match is found for the key,
+ // both elements of the pair return end( )
+ if ( ( p2.first == m1.end( ) ) && ( p2.second == m1.end( ) ) == 0)
+ failures++;
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);
+ #endif
+ /*
+ if(failures)
+ return KErrGeneral;
+ else
+ return KErrNone;
+ */
+
+
+ //#if STDCPP_OOM
+//failures++;
+// #endif
+
+}
+
+catch(bad_alloc&)
+ {
+ //do nothing
+ }
+ catch(...)
+ {
+ failures++;
+
+ }
+
+ if(failures )
+ return KErrGeneral;
+ return KErrNone;
+ }
+
+TInt Ctstl_2::map7(CStifItemParser& aItem)
+{
+//find
+int failures=0;
+
+try
+{
+map <int, int> m1;
+ map <int, int> :: const_iterator m1_AcIter, m1_RcIter;
+ typedef pair <int, int> Int_Pair;
+
+ m1.insert ( Int_Pair ( 1, 10 ) );
+ m1.insert ( Int_Pair ( 2, 20 ) );
+ m1.insert ( Int_Pair ( 3, 30 ) );
+ // cout<<"";
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
+ #endif
+ m1_RcIter = m1.find( 2 );
+ if( m1_RcIter -> second != 20)
+ failures++;
+
+ // If no match is found for the key, end( ) is returned
+ m1_RcIter = m1.find( 4 );
+
+ if ( m1_RcIter == m1.end( ) );
+ // cout << "The map m1 doesn't have an element "
+ // << "with a key of 4." << endl;
+ else
+ if( m1_RcIter -> second != 4)
+ failures++;
+
+
+ // The element at a specific location in the map can be found
+ // using a dereferenced iterator addressing the location
+ m1_AcIter = m1.end( );
+ m1_AcIter--;
+ m1_RcIter = m1.find( m1_AcIter -> first );
+ if( m1_RcIter -> second != 30)
+ failures++;
+
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);
+ #endif
+ /*
+ if(failures)
+ return KErrGeneral;
+ else
+ return KErrNone;
+ */
+
+ //#if STDCPP_OOM
+//failures++;
+// #endif
+
+
+}
+catch(bad_alloc&)
+ {
+ //do nothing
+ }
+ catch(...)
+ {
+ failures++;
+
+ }
+
+ if(failures )
+ return KErrGeneral;
+ return KErrNone;
+ }
+
+TInt Ctstl_2::map8(CStifItemParser& aItem)
+{
+
+//key_comp
+ int failures=0;
+
+ try
+ {
+
+ map <int, int, less<int> > m1;
+ map <int, int, less<int> >::key_compare kc1 = m1.key_comp( ) ;
+ bool result1 = kc1( 2, 3 ) ;
+ // cout<<"";
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
+ #endif
+ if( result1 == false)
+ failures++;
+
+
+
+ map <int, int, greater<int> > m2;
+ map <int, int, greater<int> >::key_compare kc2 = m2.key_comp( );
+ bool result2 = kc2( 2, 3 ) ;
+ if( result2 == true )
+ failures++;
+
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);
+ #endif
+ /*
+ if(failures)
+ return KErrGeneral;
+ else
+ return KErrNone;
+*/
+
+
+ //#if STDCPP_OOM
+//failures++;
+// #endif
+
+
+}
+catch(bad_alloc&)
+ {
+ //do nothing
+ }
+ catch(...)
+ {
+ failures++;
+
+ }
+
+ if(failures )
+ return KErrGeneral;
+ return KErrNone;
+ }
+
+TInt Ctstl_2::map9(CStifItemParser& aItem)
+
+{
+
+
+//lowerbound
+int failures=0;
+
+
+try
+
+{
+map <int, int> m1;
+ map <int, int> :: const_iterator m1_AcIter, m1_RcIter;
+ typedef pair <int, int> Int_Pair;
+
+ m1.insert ( Int_Pair ( 1, 10 ) );
+ m1.insert ( Int_Pair ( 2, 20 ) );
+ m1.insert ( Int_Pair ( 3, 30 ) );
+ // cout<<"";
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
+ #endif
+ m1_RcIter = m1.lower_bound( 2 );
+
+ if( m1_RcIter -> second != 20)
+ failures++;
+
+
+ // If no match is found for this key, end( ) is returned
+ m1_RcIter = m1. lower_bound ( 4 );
+
+ if ( m1_RcIter == m1.end( ) );
+ // << "The map m1 doesn't have an element "
+ // << "with a key of 4." << endl;
+ else
+ if( m1_RcIter -> second != 4)
+ failures++;
+
+
+ // The element at a specific location in the map can be found
+ // using a dereferenced iterator addressing the location
+ m1_AcIter = m1.end( );
+ m1_AcIter--;
+ m1_RcIter = m1. lower_bound ( m1_AcIter -> first );
+ if( m1_RcIter -> second != 30)
+ failures++;
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);
+ #endif
+ /*
+ if(failures)
+ return KErrGeneral;
+ else
+ return KErrNone;
+ */
+
+ //#if STDCPP_OOM
+//failures++;
+// #endif
+
+
+}
+catch(bad_alloc&)
+ {
+ //do nothing
+ }
+ catch(...)
+ {
+ failures++;
+
+ }
+
+ if(failures )
+ return KErrGeneral;
+ return KErrNone;
+ }
+
+TInt Ctstl_2::map10(CStifItemParser& aItem)
+
+{
+//swap
+int failures=0;
+
+try
+
+{
+int a[2];
+using namespace std;
+ map <int, int> m1, m2, m3;
+ map <int, int>::iterator m1_Iter;
+ typedef pair <int, int> Int_Pair;
+
+ m1.insert ( Int_Pair ( 1, 10 ) );
+ m1.insert ( Int_Pair ( 2, 20 ) );
+ m1.insert ( Int_Pair ( 3, 30 ) );
+ m2.insert ( Int_Pair ( 10, 100 ) );
+ m2.insert ( Int_Pair ( 20, 200 ) );
+ m3.insert ( Int_Pair ( 30, 300 ) );
+
+ // cout<<"";
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
+ #endif
+
+ m1.swap( m2 );
+
+ for ( m1_Iter = m1.begin( ); m1_Iter != m1.end( ); m1_Iter++ )
+ {
+ static int i;
+
+ a[i] = m1_Iter -> second;
+
+ i++;
+
+ }
+ if(a[0]!=100)
+ failures++;
+ if(a[1]!= 200)
+ failures++;
+
+
+ swap( m1, m3 );
+
+ for ( m1_Iter = m1.begin( ); m1_Iter != m1.end( ); m1_Iter++ )
+ {
+
+
+ int a= m1_Iter -> second;
+ if(a!=300)
+ failures++;
+ }
+
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);
+ #endif
+ /*
+if(failures)
+return KErrGeneral;
+else
+return KErrNone;
+*/
+
+
+ //#if STDCPP_OOM
+//failures++;
+// #endif
+
+}
+catch(bad_alloc&)
+ {
+ //do nothing
+ }
+ catch(...)
+ {
+ failures++;
+
+ }
+
+ if(failures )
+ return KErrGeneral;
+ return KErrNone;
+ }
+
+
+
+TInt Ctstl_2::map11(CStifItemParser& aItem)
+{
+
+
+int failures=0;
+
+try
+{
+map <int, int, less<int> > m1;
+ map <int, int, less<int> >::value_compare vc1 = m1.value_comp( );
+ pair< map<int,int>::iterator, bool > pr1, pr2;
+
+ pr1= m1.insert ( map <int, int> :: value_type ( 1, 10 ) );
+ pr2= m1.insert ( map <int, int> :: value_type ( 2, 5 ) ); // cout<<"";
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
+ #endif
+ if( vc1( *pr1.first, *pr2.first ) == false )
+
+ failures++;
+
+
+
+ if(vc1( *pr2.first, *pr1.first ) == true )
+
+ failures++;
+
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);
+ #endif
+
+
+/*
+if(failures)
+return KErrGeneral;
+else
+return KErrNone;*/
+
+ //#if STDCPP_OOM
+//failures++;
+// #endif
+}
+
+catch(bad_alloc&)
+ {
+ //do nothing
+ }
+ catch(...)
+ {
+ failures++;
+
+ }
+
+ if(failures )
+ return KErrGeneral;
+ return KErrNone;
+ }
+
+TInt Ctstl_2::map12(CStifItemParser& aItem)
+{
+
+
+int psize,failures=0;
+try
+{
+ map<char,int> mymap;
+ pair<const char,int>* p; // cout<<"";
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
+ #endif
+ p=mymap.get_allocator().allocate(2);
+
+ psize = (int) sizeof(map<char,int>::value_type)*2;
+
+ if(psize!=16)
+ failures++;
+
+
+ mymap.get_allocator().deallocate(p,2);
+
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);
+ #endif
+ if(mymap.max_size()!=4294967295)
+ failures++;
+
+
+/*
+if(failures)
+return KErrGeneral;
+else
+return KErrNone;*/
+ //#if STDCPP_OOM
+//failures++;
+// #endif
+}
+
+catch(bad_alloc&)
+ {
+ //do nothing
+ }
+ catch(...)
+ {
+ failures++;
+
+ }
+
+ if(failures )
+ return KErrGeneral;
+ return KErrNone;
+ }
+
+
+TInt Ctstl_2::map13(CStifItemParser& aItem)
+{
+
+ int failures=0;
+
+ try
+ {
+map<char,int> mymap;
+ map<char,int>::reverse_iterator rit;
+
+ mymap['x'] = 100;
+ mymap['y'] = 200; // cout<<"";
+
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
+ #endif
+ for ( rit=mymap.rbegin() ; rit != mymap.rend(); rit++ )
+
+
+ {
+ static int i;
+ if(i==0)
+ {
+
+
+ if( rit->second !=200)
+ failures++;
+ }
+ i++;
+ }
+
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);
+ #endif
+
+/*
+if(failures)
+return KErrGeneral;
+else
+return KErrNone;*/
+
+
+ //#if STDCPP_OOM
+//failures++;
+// #endif
+}
+catch(bad_alloc&)
+ {
+ //do nothing
+ }
+ catch(...)
+ {
+ failures++;
+
+ }
+
+ if(failures )
+ return KErrGeneral;
+ return KErrNone;
+ }
+
+
+TInt Ctstl_2::multimap1(CStifItemParser& aItem)
+{
+
+
+
+
+multimap <int, int> m1;
+int failures=0;
+
+try{ // cout<<"";
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
+ #endif
+ multimap <int, int> :: iterator m1_Iter;
+ multimap <int, int> :: const_iterator m1_cIter;
+ typedef pair <int, int> Int_Pair;
+
+ m1.insert ( Int_Pair ( 0, 0 ) );
+ m1.insert ( Int_Pair ( 1, 1 ) );
+ m1.insert ( Int_Pair ( 2, 4 ) );
+
+ m1_cIter = m1.begin ( );
+ if(m1_cIter -> first != 0)
+ failures++;
+
+ m1_Iter = m1.begin ( );
+ m1.erase ( m1_Iter );
+
+
+
+ m1_cIter = m1.begin( );
+ if( m1_cIter -> first !=1)
+ failures++;
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);
+ #endif
+
+ /*if(failures)
+ return KErrGeneral;
+ else
+ return KErrNone;
+ */
+
+ //#if STDCPP_OOM
+//failures++;
+// #endif
+
+}
+
+
+catch(bad_alloc&)
+ {
+ //do nothing
+ }
+ catch(...)
+ {
+ failures++;
+
+ }
+
+ if(failures )
+ return KErrGeneral;
+ return KErrNone;
+ }
+
+
+TInt Ctstl_2::multimap2(CStifItemParser& aItem)
+{
+//clear,size
+
+ int failures=0;
+
+ try
+ {
+ multimap<int, int> m1;
+ multimap<int, int>::size_type i;
+ typedef pair<int, int> Int_Pair; // cout<<"";
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
+ #endif
+ m1.insert(Int_Pair(1, 1));
+ m1.insert(Int_Pair(2, 4));
+
+ i = m1.size();
+ if(i!=2)
+ failures++;
+
+ m1.clear();
+ i = m1.size();
+ if(i!=0)
+ failures++;
+
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);
+ #endif
+ /*if(failures)
+ return KErrGeneral;
+ else
+ return KErrNone;*/
+
+ //#if STDCPP_OOM
+//failures++;
+// #endif
+
+
+}
+
+catch(bad_alloc&)
+ {
+ //do nothing
+ }
+ catch(...)
+ {
+ failures++;
+
+ }
+
+ if(failures )
+ return KErrGeneral;
+ return KErrNone;
+ }
+
+
+
+TInt Ctstl_2::multimap3(CStifItemParser& aItem)
+{
+//count
+int failures=0;
+
+
+try
+{
+
+ multimap<int, int> m1;
+ multimap<int, int>::size_type i;
+ typedef pair<int, int> Int_Pair;
+
+ m1.insert(Int_Pair(1, 1));
+ m1.insert(Int_Pair(2, 1));
+ m1.insert(Int_Pair(1, 4));
+ m1.insert(Int_Pair(2, 1));
+
+ // Keys must be unique in multimap, so duplicates are ignored
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
+ #endif
+ i = m1.count(1);
+ if(i!=2)
+ failures++;
+
+
+ i = m1.count(2);
+ if(i!=2)
+ failures++;
+
+ i = m1.count(3);
+ if(i!=0)
+ failures++;
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);
+ #endif
+/*
+
+ if(failures)
+ return KErrGeneral;
+ else
+ return KErrNone;*/
+
+ //#if STDCPP_OOM
+//failures++;
+// #endif
+
+
+}
+catch(bad_alloc&)
+ {
+ //do nothing
+ }
+ catch(...)
+ {
+ failures++;
+
+ }
+
+ if(failures )
+ return KErrGeneral;
+ return KErrNone;
+ }
+
+TInt Ctstl_2::multimap4(CStifItemParser& aItem)
+{
+//empty
+int failures=0;
+
+try
+{
+ multimap <int, int> m1, m2;
+
+ typedef pair <int, int> Int_Pair;
+ m1.insert ( Int_Pair ( 1, 1 ) );
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
+ #endif
+ if ( m1.empty( ) )
+ failures++;
+
+ if ( !m2.empty( ) )
+ failures++;
+
+ /*if(failures)
+ return KErrGeneral;
+ else
+ return KErrNone;*/
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);
+ #endif
+ //#if STDCPP_OOM
+//failures++;
+// #endif
+
+
+}
+
+
+catch(bad_alloc&)
+ {
+ //do nothing
+ }
+ catch(...)
+ {
+ failures++;
+
+ }
+
+ if(failures )
+ return KErrGeneral;
+ return KErrNone;
+ }
+
+TInt Ctstl_2::multimap5(CStifItemParser& aItem)
+{
+//erase,end
+int failures=0;
+
+try
+{
+
+ multimap <int, int> m1;
+
+ multimap <int, int> :: iterator m1_Iter;
+ multimap <int, int> :: const_iterator m1_cIter;
+ typedef pair <int, int> Int_Pair;
+
+ m1.insert ( Int_Pair ( 1, 10 ) );
+ m1.insert ( Int_Pair ( 2, 20 ) );
+ m1.insert ( Int_Pair ( 3, 30 ) );
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
+ #endif
+ m1_cIter = m1.end( );
+ m1_cIter--;
+
+ if( m1_cIter -> second != 30)
+ failures++;
+
+ m1_Iter = m1.end( );
+ m1_Iter--;
+ m1.erase ( m1_Iter );
+
+
+
+ m1_cIter = m1.end( );
+ m1_cIter--;
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);
+ #endif
+ if( m1_cIter -> second !=20)
+ failures++;
+
+
+ /* if(failures)
+ return KErrGeneral;
+ else
+ return KErrNone;*/
+
+ //#if STDCPP_OOM
+//failures++;
+// #endif
+
+
+}
+catch(bad_alloc&)
+ {
+ //do nothing
+ }
+ catch(...)
+ {
+ failures++;
+
+ }
+
+ if(failures )
+ return KErrGeneral;
+ return KErrNone;
+ }
+
+
+TInt Ctstl_2::multimap6(CStifItemParser& aItem)
+{
+//equal_range,upper_bound
+int failures=0;
+
+try
+{
+ typedef multimap <int, int, less<int> > Intmultimap;
+ Intmultimap m1;
+ multimap <int, int> :: const_iterator m1_RcIter;
+ typedef pair <int, int> Int_Pair;
+
+ m1.insert ( Int_Pair ( 1, 10 ) );
+ m1.insert ( Int_Pair ( 2, 20 ) );
+ m1.insert ( Int_Pair ( 3, 30 ) );
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
+ #endif
+ pair <Intmultimap::const_iterator, Intmultimap::const_iterator> p1, p2;
+ p1 = m1.equal_range( 2 );
+
+ if( p1.first -> second !=20)
+ failures++;
+
+
+ if( p1.second -> second != 30)
+ failures++;
+
+
+ // Compare the upper_bound called directly
+ m1_RcIter = m1.upper_bound( 2 );
+
+ if( m1_RcIter -> second!=30)
+ failures++;
+
+ p2 = m1.equal_range( 4 );
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);
+ #endif
+ // If no match is found for the key,
+ // both elements of the pair return end( )
+ if ( ( p2.first == m1.end( ) ) && ( p2.second == m1.end( ) ) == 0)
+ failures++;
+
+ /*
+ if(failures)
+ return KErrGeneral;
+ else
+ return KErrNone;*/
+
+ //#if STDCPP_OOM
+//failures++;
+// #endif
+
+
+}
+
+catch(bad_alloc&)
+ {
+ //do nothing
+ }
+ catch(...)
+ {
+ failures++;
+
+ }
+
+ if(failures )
+ return KErrGeneral;
+ return KErrNone;
+ }
+
+TInt Ctstl_2::multimap7(CStifItemParser& aItem)
+{
+//find
+int failures=0;
+
+try
+{
+multimap <int, int> m1;
+ multimap <int, int> :: const_iterator m1_AcIter, m1_RcIter;
+ typedef pair <int, int> Int_Pair;
+
+ m1.insert ( Int_Pair ( 1, 10 ) );
+ m1.insert ( Int_Pair ( 2, 20 ) );
+ m1.insert ( Int_Pair ( 3, 30 ) );
+
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
+ #endif
+ m1_RcIter = m1.find( 2 );
+ if( m1_RcIter -> second != 20)
+ failures++;
+
+ // If no match is found for the key, end( ) is returned
+ m1_RcIter = m1.find( 4 );
+
+ if ( m1_RcIter == m1.end( ) );
+ // cout << "The multimap m1 doesn't have an element "
+ // << "with a key of 4." << endl;
+ else
+ if( m1_RcIter -> second != 4)
+ failures++;
+
+
+ // The element at a specific location in the multimap can be found
+ // using a dereferenced iterator addressing the location
+ m1_AcIter = m1.end( );
+ m1_AcIter--;
+ m1_RcIter = m1.find( m1_AcIter -> first );
+
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);
+ #endif
+ if( m1_RcIter -> second != 30)
+ failures++;
+ /*
+ if(failures)
+ return KErrGeneral;
+ else
+ return KErrNone;*/
+
+ //#if STDCPP_OOM
+//failures++;
+// #endif
+
+
+
+}
+
+
+catch(bad_alloc&)
+ {
+ //do nothing
+ }
+ catch(...)
+ {
+ failures++;
+
+ }
+
+ if(failures )
+ return KErrGeneral;
+ return KErrNone;
+ }
+
+
+TInt Ctstl_2::multimap8(CStifItemParser& aItem)
+{
+
+//key_comp
+ int failures=0;
+
+ try
+ {
+
+ multimap <int, int, less<int> > m1;
+ multimap <int, int, less<int> >::key_compare kc1 = m1.key_comp( ) ;
+ bool result1 = kc1( 2, 3 ) ;
+
+ if( result1 == false)
+ failures++;
+
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
+ #endif
+
+ multimap <int, int, greater<int> > m2;
+ multimap <int, int, greater<int> >::key_compare kc2 = m2.key_comp( );
+ bool result2 = kc2( 2, 3 ) ;
+ if( result2 == true )
+ failures++;
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);
+ #endif
+ /* if(failures)
+ return KErrGeneral;
+ else
+ return KErrNone;*/
+
+ //#if STDCPP_OOM
+//failures++;
+// #endif
+
+}
+catch(bad_alloc&)
+ {
+ //do nothing
+ }
+ catch(...)
+ {
+ failures++;
+
+ }
+
+ if(failures )
+ return KErrGeneral;
+ return KErrNone;
+ }
+
+TInt Ctstl_2::multimap9(CStifItemParser& aItem)
+
+{
+
+
+//lowerbound
+int failures=0;
+
+try
+{
+multimap <int, int> m1;
+ multimap <int, int> :: const_iterator m1_AcIter, m1_RcIter;
+ typedef pair <int, int> Int_Pair;
+
+ m1.insert ( Int_Pair ( 1, 10 ) );
+ m1.insert ( Int_Pair ( 2, 20 ) );
+ m1.insert ( Int_Pair ( 3, 30 ) ); // cout<<"";
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
+ #endif
+ m1_RcIter = m1.lower_bound( 2 );
+
+ if( m1_RcIter -> second != 20)
+ failures++;
+
+
+ // If no match is found for this key, end( ) is returned
+ m1_RcIter = m1. lower_bound ( 4 );
+
+ if ( m1_RcIter == m1.end( ) );
+ //cout << "The multimap m1 doesn't have an element "
+ // << "with a key of 4." << endl;
+ else
+ if( m1_RcIter -> second != 4)
+ failures++;
+
+
+ // The element at a specific location in the multimap can be found
+ // using a dereferenced iterator addressing the location
+ m1_AcIter = m1.end( );
+ m1_AcIter--;
+ m1_RcIter = m1. lower_bound ( m1_AcIter -> first );
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);
+ #endif
+ if( m1_RcIter -> second != 30)
+ failures++;
+
+ /*if(failures)
+ return KErrGeneral;
+ else
+ return KErrNone;
+ */
+ //#if STDCPP_OOM
+//failures++;
+// #endif
+
+
+}
+catch(bad_alloc&)
+ {
+ //do nothing
+ }
+ catch(...)
+ {
+ failures++;
+
+ }
+
+ if(failures )
+ return KErrGeneral;
+ return KErrNone;
+ }
+
+
+TInt Ctstl_2::multimap10(CStifItemParser& aItem)
+
+{
+//swap
+int failures=0;
+
+try
+{
+int a[2];
+using namespace std;
+ multimap <int, int> m1, m2, m3;
+ multimap <int, int>::iterator m1_Iter;
+ typedef pair <int, int> Int_Pair;
+
+ m1.insert ( Int_Pair ( 1, 10 ) );
+ m1.insert ( Int_Pair ( 2, 20 ) );
+ m1.insert ( Int_Pair ( 3, 30 ) );
+ m2.insert ( Int_Pair ( 10, 100 ) );
+ m2.insert ( Int_Pair ( 20, 200 ) );
+ m3.insert ( Int_Pair ( 30, 300 ) );
+
+
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
+ #endif
+ // This is the member function version of swap
+ //m2 is said to be the argument multimap; m1 the target multimap
+ m1.swap( m2 );
+
+ for ( m1_Iter = m1.begin( ); m1_Iter != m1.end( ); m1_Iter++ )
+ {
+ static int i;
+
+ a[i] = m1_Iter -> second;
+
+ i++;
+
+ }
+
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);
+ #endif
+ if(a[0]!=100)
+ failures++;
+ if(a[1]!= 200)
+ failures++;
+
+
+ // This is the specialized template version of swap
+ swap( m1, m3 );
+
+ for ( m1_Iter = m1.begin( ); m1_Iter != m1.end( ); m1_Iter++ )
+ {
+
+
+ int a= m1_Iter -> second;
+ if(a!=300)
+ failures++;
+ }
+ /*
+if(failures)
+return KErrGeneral;
+else
+return KErrNone;
+*/
+ //#if STDCPP_OOM
+//failures++;
+// #endif
+
+}
+catch(bad_alloc&)
+ {
+ //do nothing
+ }
+ catch(...)
+ {
+ failures++;
+
+ }
+
+ if(failures )
+ return KErrGeneral;
+ return KErrNone;
+ }
+
+TInt Ctstl_2::multimap11(CStifItemParser& aItem)
+{
+
+//val_comp
+int failures=0;
+
+try
+{
+
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
+ #endif
+
+ multimap <int, int, less<int> > m1;
+ multimap <int, int, less<int> >::value_compare vc1 = m1.value_comp( );
+ multimap<int,int>::iterator Iter1, Iter2;
+
+ Iter1= m1.insert ( multimap <int, int> :: value_type ( 1, 10 ) );
+ Iter2= m1.insert ( multimap <int, int> :: value_type ( 2, 5 ) );
+
+ if( vc1( *Iter1, *Iter2 ) == false )
+ failures++;
+
+ if( vc1( *Iter2, *Iter1 ) == true )
+ failures++;
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);
+ #endif
+
+/*
+if(failures)
+return KErrGeneral;
+else
+return KErrNone;*/
+
+ //#if STDCPP_OOM
+//failures++;
+// #endif
+}
+
+catch(bad_alloc&)
+ {
+ //do nothing
+ }
+ catch(...)
+ {
+ failures++;
+
+ }
+
+ if(failures )
+ return KErrGeneral;
+ return KErrNone;
+ }
+
+
+
+
+TInt Ctstl_2::multimap12(CStifItemParser& aItem)
+{
+
+
+ int psize1,failures=0;
+
+ try
+ {
+ multimap<char,int> mymap1;
+ pair<const char,int>* p;
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
+ #endif
+ p=mymap1.get_allocator().allocate(2);
+
+ psize1 = (int) sizeof(map<char,int>::value_type)*2;
+
+ if(psize1!=16)
+ failures++;
+
+
+ mymap1.get_allocator().deallocate(p,2);
+
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);
+ #endif
+ if(mymap1.max_size()!=4294967295)
+ failures++;
+
+
+/*
+if(failures)
+return KErrGeneral;
+else
+return KErrNone;
+*/
+ //#if STDCPP_OOM
+//failures++;
+// #endif
+}
+catch(bad_alloc&)
+ {
+ //do nothing
+ }
+ catch(...)
+ {
+ failures++;
+
+ }
+
+ if(failures )
+ return KErrGeneral;
+ return KErrNone;
+ }
+
+
+TInt Ctstl_2::multimap13(CStifItemParser& aItem)
+{
+
+ int failures=0;
+
+ try
+ {
+ multimap<char,int> mymap;
+ multimap<char,int>::reverse_iterator rit;
+
+
+ mymap.insert (pair<char,int>('x',100));
+ mymap.insert (pair<char,int>('y',200));
+
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
+ #endif
+
+ for ( rit=mymap.rbegin() ; rit != mymap.rend(); rit++ )
+
+ {
+ static int i;
+ if(i==0)
+ {
+
+ if( rit->second !=200)
+ failures++;
+ }
+ i++;
+ }
+
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);
+ #endif
+
+/*
+if(failures)
+return KErrGeneral;
+else
+return KErrNone;*/
+ //#if STDCPP_OOM
+//failures++;
+// #endif
+}
+
+catch(bad_alloc&)
+ {
+ //do nothing
+ }
+ catch(...)
+ {
+ failures++;
+
+ }
+
+ if(failures )
+ return KErrGeneral;
+ return KErrNone;
+ }
+
+TInt Ctstl_2::multi_set(CStifItemParser& aItem)
+
+{
+
+
+int failures =0;
+
+try
+{
+
+
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
+ #endif
+
+//__UHEAP_MARK;
+//{
+multiset <int> ms1;
+ multiset <int> :: const_iterator low,ms1_AcIter,up,find1;
+multiset<int>::iterator Iter;
+
+multiset<int>::size_type count1, maxsize;
+
+
+
+
+
+
+
+if(ms1.size()!= 0)
+
+failures++;
+
+
+
+
+ ms1.insert( 10 );
+ ms1.insert( 20 );
+ ms1.insert( 30 );
+
+find1 = ms1.find(20);
+
+if(*find1!=20)
+failures++;
+
+
+if(ms1.size()!=3)
+failures++;
+
+
+
+count1 = ms1.count(10);
+
+if(count1 != 1)
+failures++;
+
+
+count1 = ms1.count(40);
+
+if(count1!=0)
+failures++;
+
+
+
+
+Iter = ms1.begin();
+
+ms1.erase(Iter);
+
+
+if(*ms1.begin()!=20)
+failures++;
+
+
+
+ low = ms1.lower_bound( 20 );
+ if( *low != 20)
+failures++;
+
+
+up = ms1.upper_bound(20);
+if(*up!=30)
+failures++;
+
+ low = ms1.lower_bound( 40 );
+up = ms1.upper_bound(30);
+
+
+ // If no match is found for the key, end( ) is returned
+
+
+if(up!=ms1.end())
+failures++;
+
+
+if(ms1.empty())
+failures++;
+
+
+ms1.clear();
+
+if(!ms1.empty())
+failures++;
+
+
+maxsize = ms1.max_size();
+#if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);
+ #endif
+if(maxsize!= 4294967295)
+failures++;
+
+//__UHEAP_MARKEND;
+/*if(failures)
+
+return KErrGeneral;
+else
+return KErrNone;*/
+ //#if STDCPP_OOM
+//failures++;
+// #endif
+
+
+
+ }
+
+
+ catch(bad_alloc&)
+ {
+ //do nothing
+ }
+ catch(...)
+ {
+ failures++;
+
+ }
+
+ if(failures )
+ return KErrGeneral;
+ return KErrNone;
+ }
+
+
+
+TInt Ctstl_2::multi_set2(CStifItemParser& aItem)
+
+{
+ int myints[] = {77,16,2,30,30},failures=0;
+
+ try
+ {
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
+ #endif
+ multiset<int> mymultiset (myints,myints+5);
+
+ multiset<int>::reverse_iterator rit;
+
+ for ( rit=mymultiset.rbegin() ; rit != mymultiset.rend(); rit++ )
+ {
+
+ static int i;
+ if(i==0)
+ {
+ if(*rit!=77)
+ failures++;
+ }
+ i++;
+ }
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);
+ #endif
+ /*
+
+ if(failures)
+ return KErrGeneral;
+ else
+ return KErrNone;*/
+ //#if STDCPP_OOM
+//failures++;
+// #endif
+}
+
+catch(bad_alloc&)
+ {
+ //do nothing
+ }
+ catch(...)
+ {
+ failures++;
+
+ }
+
+ if(failures )
+ return KErrGeneral;
+ return KErrNone;
+ }
+
+
+
+TInt Ctstl_2::multi_set3(CStifItemParser& aItem)
+
+{
+ multiset<int> mymultiset;
+ int * p,failures=0;
+
+ try
+ {
+ unsigned int i;
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
+ #endif
+ p = mymultiset.get_allocator().allocate(5);
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);
+ #endif
+ for (i=0; i<5; i++)
+ p[i]=(i+1)*10;
+
+ if(sizeof(p)!=4)
+ failures++;
+#if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
+ #endif
+ mymultiset.get_allocator().deallocate(p,5);
+
+ #if STDCPP_OOM
+User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);
+ #endif
+
+
+ /*
+ if(failures)
+ return KErrGeneral;
+ else
+ return KErrNone;
+ */
+ //#if STDCPP_OOM
+//failures++;
+// #endif
+}
+
+
+catch(bad_alloc&)
+ {
+ //do nothing
+ }
+ catch(...)
+ {
+ failures++;
+
+ }
+
+ if(failures )
+ return KErrGeneral;
+ return KErrNone;
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+// End of File