/*
* 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 "tstl_4.h"



#include <locale>
 #include <numeric>
 #include <valarray>
 #include<fstream> 
 
#include<list>
#include<string>
#include<cstring>
#include<vector>
#include<iterator>

#include<ios>
#include<algorithm>
#include <numeric>
#include<functional>
#include <locale>
#include<iostream>
#include<memory>
#include<complex>
#include<map>
//#include<set>
 #include<exception>
 // #include<bitset>

#include <stl/char_traits.h> // fpos
 
#undef test
 using namespace std;
 #define STDCPP_OOM FALSE// TRUE for OOM testing

// EXTERNAL DATA STRUCTURES
//extern  ?external_data;

// EXTERNAL FUNCTION PROTOTYPES  
//extern ?external_function( ?arg_type,?arg_type );

// CONSTANTS
//const ?type ?constant_var = ?constant;

// MACROS
//#define ?macro ?macro_def

// LOCAL CONSTANTS AND MACROS
//const ?type ?constant_var = ?constant;
//#define ?macro_name ?macro_def

// MODULE DATA STRUCTURES
//enum ?declaration
//typedef ?declaration

// LOCAL FUNCTION PROTOTYPES
//?type ?function_name( ?arg_type, ?arg_type );

// FORWARD DECLARATIONS
//class ?FORWARD_CLASSNAME;

// ============================= LOCAL FUNCTIONS ===============================

// -----------------------------------------------------------------------------
// ?function_name ?description.
// ?description
// Returns: ?value_1: ?description
//          ?value_n: ?description_line1
//                    ?description_line2
// -----------------------------------------------------------------------------
//
/*
?type ?function_name(
    ?arg_type arg,  // ?description
    ?arg_type arg)  // ?description
    {

    ?code  // ?comment

    // ?comment
    ?code
    }
*/

// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------
// Ctstl_4::Delete
// Delete here all resources allocated and opened from test methods. 
// Called from destructor. 
// -----------------------------------------------------------------------------
//
void Ctstl_4::Delete() 
    {

    }

// -----------------------------------------------------------------------------
// Ctstl_4::RunMethodL
// Run specified method. Contains also table of test mothods and their names.
// -----------------------------------------------------------------------------
//
TInt Ctstl_4::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. 
        		 
        	        ENTRY( "Swapof", Ctstl_4::Swapof ),
        	        ENTRY( "Accumulate", Ctstl_4::Accumulate ),
        	 		ENTRY( "Adjacent_difference", Ctstl_4::Adjacent_difference),
        	        ENTRY( "Adjacent_find", Ctstl_4::Adjacent_find),
        	        ENTRY( "Logical_or", Ctstl_4::Logical_or ),
        	        ENTRY( "Logical_and", Ctstl_4::Logical_and ),
        	        ENTRY( "Logical_not", Ctstl_4::Logical_not ),
        	        ENTRY( "count_fun", Ctstl_4::count_fun),
        	        ENTRY( "countif_fun", Ctstl_4::countif_fun),
        	        ENTRY( "equal_fun", Ctstl_4::equal_fun),
        	        ENTRY( "equalto", Ctstl_4::equalto),
        	        ENTRY( "notequalto", Ctstl_4::notequalto),
        	 		ENTRY( "sort_fun", Ctstl_4::sort_fun),
        	 		ENTRY( "less_equal_fun", Ctstl_4::less_equal_fun),
        	 		ENTRY( "greater_equal_fun", Ctstl_4::greater_equal_fun),
        	 		ENTRY( "greater_fun", Ctstl_4::greater_fun),
        	 		ENTRY( "less_fun", Ctstl_4::less_fun),
        	 		ENTRY( "find_fun", Ctstl_4::find_fun),
        	 		ENTRY( "findif_fun", Ctstl_4::findif_fun),
        	 		ENTRY( "findend_fun", Ctstl_4::findend_fun),
        	 		  ENTRY( "Minof", Ctstl_4::Minof ),
        	 	        ENTRY( "Maxelement", Ctstl_4::Maxelement ),
        	 	        ENTRY( "Minelement", Ctstl_4::Minelement ),
        	 	      
        	 	        
        	 	       ENTRY( "ToUpper", Ctstl_4::ToUpper ),
        	 	        ENTRY( "ToLower", Ctstl_4::ToLower ),
        	 	        ENTRY( "Islower", Ctstl_4::Islower ),
        	 	        ENTRY( "Isupper", Ctstl_4::Isupper ),
        	 	        ENTRY( "Maxof", Ctstl_4::Maxof ),
        	 	        
        	 	        
        	 	       ENTRY("Advance", Ctstl_4::Advance ),
        	 	      ENTRY("Backinsert_iterator", Ctstl_4::Backinsert_iterator ),
        	 	      ENTRY("Frontinsert_iterator", Ctstl_4::Frontinsert_iterator ),
        	 	      ENTRY("Insert_iterator", Ctstl_4::Insert_iterator ),
        	 	      ENTRY("Reverse_iterator", Ctstl_4::Reverse_iterator ),
        	 	      ENTRY("Distance", Ctstl_4::Distance ),
        	 	     
        	 	 
        	 	      ENTRY("Isdigit", Ctstl_4::Isdigit ),
        	 	      ENTRY("Isgraph", Ctstl_4::Isgraph ),
        	 	      ENTRY("Isalnum", Ctstl_4::Isalnum ),
        	 	      ENTRY("Isalpha", Ctstl_4::Isalpha ),
        	 	      ENTRY("Iscntrl", Ctstl_4::Iscntrl ),
        	 	      ENTRY("Isprint", Ctstl_4::Isprint ),
        	 	      ENTRY("Ispunct", Ctstl_4::Ispunct ),
        	 	      ENTRY("Isspace", Ctstl_4::Isspace ),
        	 	      ENTRY("Isxdigit", Ctstl_4::Isxdigit ),
        	 	      ENTRY("Fill", Ctstl_4::Fill ),
        	 	      ENTRY("Generate", Ctstl_4::Generate ),
        	 	      ENTRY("Search", Ctstl_4::Search ),
        	 	      ENTRY("Search_n", Ctstl_4::Search_n ),
        	 	      ENTRY("Times", Ctstl_4::Times ),
        	 	      ENTRY("Unique", Ctstl_4::Unique ),
        	 	      ENTRY("Uniquecopy", Ctstl_4::Uniquecopy ),
        	 	      ENTRY("Partialsort", Ctstl_4::Partialsort ),
        	 	      ENTRY("Partialsortcopy", Ctstl_4::Partialsortcopy ),
        	 	      ENTRY("Partition", Ctstl_4::Partition ),
        	 	      ENTRY("Stablepartition", Ctstl_4::Stablepartition ),
        	 	      ENTRY("Setdifference", Ctstl_4::Setdifference ),
       

        };

    const TInt count = sizeof( KFunctions ) / 
                        sizeof( TStifFunctionInfo );

    return RunInternalL( KFunctions, count, aItem );

    }





















//swap

TInt Ctstl_4::Swapof(CStifItemParser& aItem)
{
int x= 10,y=20;

//__UHEAP_MARK;
int failures =0;
  

 try
 {  //cout<<"";
 #if  STDCPP_OOM
User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);

#endif 
swap(x,y);
#if  STDCPP_OOM 	
User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);


#endif
/*if (x==20 && y==10)


//__UHEAP_MARKEND;

 return KErrNone;
 return KErrGeneral;*/
 if(x!=20)
 failures++;
 if(y!=10)
 failures++;
 
//#if STDCPP_OOM
 // failures++;
 // #endif
}
 catch(bad_alloc&)
 {
  }
 catch(...)
 {
 	failures++;
 	
 }
     
   
  if(failures)
  return KErrGeneral;
  return KErrNone;  
} 



//accumulate 
int mult(int x,int y)
{
	return x*y;
}


 TInt Ctstl_4::Accumulate(CStifItemParser& aItem)
{
    
int failures =0;

   // __UHEAP_MARK;
    
 try
 {
 	
 
  int test_array[10] = {1,2,3,4,5,6,7,8,9,10};
  vector<int> v1(test_array, test_array+10);
 //   cout<<"";
 #if  STDCPP_OOM
User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);

#endif 
  int sum = accumulate(v1.begin(), v1.end(),0);
  
  int prod = accumulate(v1.begin(), v1.end(),1,mult);
  #if  STDCPP_OOM 	
User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);


#endif
  v1.erase(v1.begin(),v1.end());
   
  /* if(sum == 55  &&  prod == 3628800)
  // __UHEAP_MARKEND;    
   
   return KErrNone;
   return KErrGeneral;*/
   if(sum!=55)
   failures++;
   if(prod!=3628800)
   failures++;
  //#if STDCPP_OOM //failures++; //#endif
   
 }
 catch(bad_alloc&)
 {
  }
 catch(...)
 {
 	failures++;
 	
 }
     
   
  if(failures)
  return KErrGeneral;
  return KErrNone;
}  





TInt Ctstl_4::Adjacent_difference(CStifItemParser& aItem)
{
    

     //__UHEAP_MARK;
    
     
  int failures =0;
 

 try
 { 
 vector<int> V1( 10 ), V2( 10 );
 vector<int>::iterator VIter1, VIter2, VIterend, VIterend2;


int array1[10];
int array2[10];
 list <int> L1;
 list <int>::iterator LIter1, LIterend, LIterend2;

 int t;
 for ( t = 1 ; t <= 10 ; t++ )
 {
    L1.push_back( t * t );
 }
//cout<<"";
 #if  STDCPP_OOM
	User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);

#endif 
 // The first member function for the adjacent_differences of
 // elements in a list output to a vector
 VIterend = adjacent_difference ( L1.begin (),L1.end (),V1.begin () );
 #if  STDCPP_OOM 	
User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);


#endif
  for ( VIter1 = V1.begin( ) ; VIter1 != VIterend ; VIter1++ )
    
    
 {
 	static int i;
 	
 	array1[i] = *VIter1;	
 	i++;
 	}

#if  STDCPP_OOM
	User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);

#endif 
 // The second member function used to compute
 // the adjacent products of the elements in a list
 VIterend2 = adjacent_difference ( L1.begin (),L1.end ( ),V2.begin ( ),multiplies<int>( ) );
 #if  STDCPP_OOM 	
User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);


#endif
  for ( VIter2 = V2.begin( ) ; VIter2 != VIterend2 ; VIter2++ )
 {
 	
 static int i;
 array2[i] = *VIter2;
 i++;
}
     
/*
  if(array1[0] == 1)
  if(array1[1] == 3)
  if(array1[2] == 5)
  if(array1[3] == 7)
  if(array1[4] == 9)
  if(array1[5] == 11)
  if(array1[6] == 13)
  if(array1[7] == 15)
  if(array1[8] == 17)
  if(array1[9] == 19)
  
  if(array2[0] == 1)
  if(array2[1] == 4)
  if(array2[2] == 36)
  if(array2[3] == 144)
  if(array2[4] == 400)
  if(array2[5] == 900)
  if(array2[6] == 1764)
  if(array2[7] == 3136)
  if(array2[8] == 5184)
  if(array2[9] == 8100)
  
 //__UHEAP_MARKEND;
  return KErrNone;
  return KErrGeneral;*/
  if(array1[0] != 1)
  failures++;
  if(array1[1] != 3)
  failures++;
  if(array1[2] != 5)
  failures++;
  if(array1[3] != 7)
  failures++;
  if(array1[4] != 9)
  failures++;
  if(array1[5] != 11)
  failures++;
  if(array1[6] != 13)
  failures++;
  if(array1[7] != 15)
  failures++;
  if(array1[8] != 17)
  failures++;
  if(array1[9] != 19)
  failures++;
  
  if(array2[0] != 1)
  failures++;
  if(array2[1] != 4)
  failures++;
  if(array2[2] != 36)
  failures++;
  if(array2[3] != 144)
  failures++;
  if(array2[4] != 400)
  failures++;
  if(array2[5] != 900)
  failures++;
  if(array2[6] != 1764)
  failures++;
  if(array2[7] != 3136)
  failures++;
  if(array2[8] != 5184)
  failures++;
  if(array2[9] != 8100)   
  failures++;
      //#if STDCPP_OOM //failures++; //#endif
  
  
}
 catch(bad_alloc&)
 {
  }
 catch(...)
 {
 	failures++;
 	
 }
     
 // __UHEAP_MARKEND;
  
  if(failures)
  return KErrGeneral;
  return KErrNone; 
 


}  



TInt Ctstl_4::Adjacent_find(CStifItemParser& aItem)
{
    

     //__UHEAP_MARK;
   
  int failures =0;
  

 try
 {     
 int myints[] = {10,20,30,30,20,10,50,60};
 int myints1[]=
 {
 	10,20,30,40,50,60,70
 };
vector<int> myvector (myints,myints+8) ,myvector1(myints1,myints1+7);
vector<int>::iterator it,it2; 
//cout<<"";
#if  STDCPP_OOM
User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);

#endif 
 it = adjacent_find (myvector.begin(), myvector.end());
 #if  STDCPP_OOM 	
User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);


#endif 
/*
if(*it == 30)


    // __UHEAP_MARKEND;
return KErrNone;
return KErrGeneral;

*/
if(*it!=30)
failures++;

//#if STDCPP_OOM //failures++; //#endif  
}
 catch(bad_alloc&)
 {
 
 }
 catch(...)
 {
 	failures++;
 	
 }
   
 // __UHEAP_MARKEND;
  
  if(failures)
  return KErrGeneral;
  return KErrNone;  
  




}  










// logical or 
TInt Ctstl_4::Logical_or(CStifItemParser& aItem)
{
	

//__UHEAP_MARK;
int failures =0;
 

 try
 {    
int input1 [4] = { 1, 1, 0, 1 };
int input2 [4] = { 0, 1, 0, 0 };
 int output [4];
  #if  STDCPP_OOM
User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);

#endif 
transform((int*)input1, (int*)input1 + 4, (int*)input2, (int*)output, logical_or<bool>());

#if  STDCPP_OOM 	
User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);


#endif
 /* if(output[0] == 1 && output[1] == 1 && output[2] ==0 && output[3] == 1)
  
 // __UHEAP_MARKEND;
return KErrNone;
return KErrGeneral;  */
if(output[0] != 1)
failures++;
if(output[1] != 1 )
failures++;
if(output[2] !=0)
failures++;
if( output[3] != 1)
failures++;

//#if STDCPP_OOM //failures++; //#endif
}
 catch(bad_alloc&)
 {
  }
 catch(...)
 {
 	failures++;
 	
 }
     
 // __UHEAP_MARKEND;
  
  if(failures)
  return KErrGeneral;
  return KErrNone; 

}


//logical and

TInt Ctstl_4::Logical_and(CStifItemParser& aItem)
{
	

//__UHEAP_MARK;
int failures =0;
  

 try
 {    
int input1 [4] = { 1, 1, 0, 1 };
int input2 [4] = { 0, 1, 0, 0 };
 int output [4];
 #if  STDCPP_OOM
User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);

#endif 
transform((int*)input1, (int*)input1 + 4, (int*)input2, (int*)output, logical_and<bool>());
 
#if  STDCPP_OOM 	
User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);


#endif   

/*  if(output[0] == 0 && output[1] == 1 && output[2] ==0 && output[3] == 0)
 
 //__UHEAP_MARKEND;
  
return KErrNone;
return KErrGeneral;  */
if(output[0] != 0)
failures++;
if(output[1] != 1 )
failures++;
if(output[2] !=0)
failures++;
if( output[3] != 0)
failures++;

//#if STDCPP_OOM //failures++; //#endif
}
 catch(bad_alloc&)
 {
  }
 catch(...)
 {
 	failures++;
 }
 
 // __UHEAP_MARKEND;
  
  if(failures)
  return KErrGeneral;
  return KErrNone;


}


//LOGICAL NOT


TInt Ctstl_4::Logical_not(CStifItemParser& aItem)
{
	
//__UHEAP_MARK;
int failures =0;
  

 try
 {    
int input1 [4] = { 1, 1, 0, 1 };

 int output [4];
  #if  STDCPP_OOM
User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);

#endif
transform((int*)input1, (int*)input1 + 4,  (int*)output, logical_not<bool>());
 
 
#if  STDCPP_OOM 	
User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);


#endif
/*
  if(output[0] == 0 && output[1] == 0 && output[2] ==1 && output[3] == 0)
  
//__UHEAP_MARKEND;
  
return KErrNone;
return KErrGeneral; */ 
if(output[0] != 0)
failures++;
if(output[1] != 0 )
failures++;
if(output[2] !=1)
failures++;
if( output[3] != 0)
failures++;

//#if STDCPP_OOM //failures++; //#endif
 }
 catch(bad_alloc&)
 {
 }
 catch(...)
 {
 	failures++;
 }
 	
     
 // __UHEAP_MARKEND;
  
  if(failures)
  return KErrGeneral;
  return KErrNone;


}


//COUNT



TInt Ctstl_4::count_fun(CStifItemParser& aItem)
{
	
	
int failures =0;
  

 try
 {    //	__UHEAP_MARK;
	
int sequence[10] = {1,2,3,4,5,5,7,8,9,10};
  int i=0,j=0,k=0;
   vector<int> v(sequence,sequence + 10); 
   //cout<<"";
#if  STDCPP_OOM
User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);

#endif 
  count(v.begin(),v.end(),5,i);  
  count(v.begin(),v.end(),6,j);
  count(v.begin(),v.end(),10,k);
  
  #if  STDCPP_OOM 	
User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);


#endif   
   /* 
   if(i==2 && j==0 && k ==1)
  
    //__UHEAP_MARKEND;
   return KErrNone;
   return KErrGeneral;*/
   if(i!=2)
   failures++;
   if(j!=0)
   failures++;
   if(k!=1)
   failures++;
   //#if STDCPP_OOM //failures++; //#endif
   
 }
 catch(bad_alloc&)
 {
 }
 catch(...)
 {
 	failures++;
 	
 }
  
 // __UHEAP_MARKEND;
  
  if(failures)
  return KErrGeneral;
  return KErrNone; 
   
}




//COUNTIF
TInt Ctstl_4::countif_fun(CStifItemParser& aItem)
{

//__UHEAP_MARK;
	int failures =0;

 try
 {   
	int sequence[10] = {1,2,3,4,5,5,7,8,9,10};
  int i=0 ,j=0;
  vector<int> v(sequence,sequence + 10); 
  //cout<<"";
 #if  STDCPP_OOM
User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);

#endif 

  count_if(v.begin(),v.end(),bind2nd(less<int>(),8),i);  
  count_if(v.begin(),v.end(),bind2nd(less<int>(),1),j);  
   #if  STDCPP_OOM 	
User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);


#endif
  
    /*
   if(i==7 && j==0)

    //__UHEAP_MARKEND ;  
   return KErrNone;
   return KErrGeneral;*/
   if(i!=7)
   failures++;
   if(j!=0)
   failures++;
 //#if STDCPP_OOM //failures++; //#endif  
}
 catch(bad_alloc&)
 {
  }
 catch(...)
 {
 	failures++;
 	
 }
     
 // __UHEAP_MARKEND;
  
  if(failures)
  return KErrGeneral;
  return KErrNone;
   
}


//equal


TInt Ctstl_4::equal_fun(CStifItemParser& aItem)
{


//__UHEAP_MARK;
	int failures =0;
  

 try
 {   
	int input1 [4] = { 0, 4, 6, -7 };
  int input2 [4] = { -0, 34, 6, -7 };
 
vector<int> v1(input1+0, input1 + 3), v2(input2+0, input2 + 3);
#if  STDCPP_OOM
User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);

#endif 
   // Check for equality
    if(equal(v1.begin(),v1.end(),v2.begin()))
    failures++;
    //__UHEAP_MARKEND;
    //return KErrNone;
    //return KErrGeneral;
    
 #if  STDCPP_OOM 	
User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);


#endif   
//#if STDCPP_OOM //failures++; //#endif   
}
 catch(bad_alloc&)
 {
  }
 catch(...)
 {
 	failures++;
 	
 }
   
 // __UHEAP_MARKEND;
  
  if(failures)
  return KErrGeneral;
  return KErrNone;

 

 
}






//equalto 

TInt Ctstl_4::equalto(CStifItemParser& aItem)
{
	
	
//	__UHEAP_MARK;
		int failures =0;
  
 try
 {   
	int input1 [4] = { 0, 4, 6, -7 };
  int input2 [4] = { -0, 34, 6, -7 };
 int output [4];
 #if  STDCPP_OOM
User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);

#endif 

transform((int*)input1, (int*)input1 + 4, (int*)input2, (int*)output, equal_to<int>());
#if  STDCPP_OOM 	
User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);


#endif    
/* 
if(output[0] == 1 && output[1] == 0 && output[2] ==1 && output[3] == 1)

//__UHEAP_MARKEND;  

return KErrNone;
return KErrGeneral;*/
if(output[0] != 1)
failures++;
if(output[1] != 0 )
failures++;
if(output[2] !=1)
failures++;
if( output[3] != 1)
failures++;

//#if STDCPP_OOM //failures++; //#endif
 }
 catch(bad_alloc&)
 {
  }
 catch(...)
 {
 	failures++;
 	
 }
 
 // __UHEAP_MARKEND;
  
  if(failures)
  return KErrGeneral;
  return KErrNone; 
}


//NOTEQUAL TO

TInt Ctstl_4::notequalto(CStifItemParser& aItem)
{
	int failures =0;
  

 try
 {   

//__UHEAP_MARK;	
	int input1 [4] = { 0, 4, 6, -7 };
  int input2 [4] = { -0, 34, 6, -7 };
 int output [4];
 #if  STDCPP_OOM
User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);

#endif 
transform((int*)input1, (int*)input1 + 4, (int*)input2, (int*)output, not_equal_to<int>());

#if  STDCPP_OOM 	
User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);


#endif 
/*
if(output[0] == 0 && output[1] == 1 && output[2] ==0 && output[3] == 0)

//__UHEAP_MARKEND;

return KErrNone;
return KErrGeneral;*/
if(output[0] != 0)
failures++;
if(output[1] != 1)
failures++;
if(output[2] !=0)
failures++;
if( output[3] != 0)
failures++;

//#if STDCPP_OOM //failures++; //#endif


}
 catch(bad_alloc&)
 {
  }
 catch(...)
 {
 	failures++;
 	
 }
    
 // __UHEAP_MARKEND;
  
  if(failures)
  return KErrGeneral;
  return KErrNone;    
}




//sort

TInt Ctstl_4::sort_fun(CStifItemParser& aItem)
{

int failures =0;
  

 try
 {   
// __UHEAP_MARK;
int sequence[7] = {6262, 6262, 41 ,18467, 6334, 26500, 19169 };
   vector <int>::iterator Iter1;

int output[7];

  vector<int> v1(sequence,sequence + 7); 
  //cout<<"";
#if  STDCPP_OOM
User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);

#endif 
sort( v1.begin( ), v1.end( ) );
#if  STDCPP_OOM 	
User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);


#endif  
  for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )

  {
  static int i = 0;
  
  output[i] = *Iter1;
  i++;
 
  }
 
	/*(output[0] == 41 && output[1] == 6262 && output[2] == 6262 && output[3] == 6334 && output[4] == 18467  &&  output[5] == 19169 && output[6] == 26500)
	
	//	__UHEAP_MARKEND;

	return KErrNone ;
	return KErrGeneral;*/
if(output[0] != 41)
failures++;
if(output[1] != 6262)
failures++;
if(output[2] !=6262)
failures++;
if( output[3] != 6334)
failures++;
if(output[4] != 18467)
failures++;
if(output[5] !=19169)
failures++;
if( output[6] != 26500)
failures++;

//#if STDCPP_OOM //failures++; //#endif 	
}
 catch(bad_alloc&)
 {
  }
 catch(...)
 {
 	failures++;
 	
 }
   
 // __UHEAP_MARKEND;
  
  if(failures)
  return KErrGeneral;
  return KErrNone; 

}




//less_equal

TInt Ctstl_4::less_equal_fun(CStifItemParser& aItem)
{


// __UHEAP_MARK;
	int failures =0;
   

 try
 {   
int sequence[7] = {6262, 6262, 41 ,18467, 6334, 26500, 19169 };
   vector <int>::iterator Iter1;

int output[7];

  vector<int> v1(sequence,sequence + 7);
#if  STDCPP_OOM
User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);

#endif
sort( v1.begin( ), v1.end( ),less_equal<int>( ) );
 #if  STDCPP_OOM 	
User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);


#endif 
  for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )

  {
  static int i = 0;
  
  output[i] = *Iter1;
  i++;
 
  }
 
/*	if(output[0] == 41 && output[1] == 6262 && output[2] == 6262 && output[3] == 6334 && output[4] == 18467  &&  output[5] == 19169 && output[6] == 26500)
	
	//	__UHEAP_MARKEND;

	
	return KErrNone ;
	return KErrGeneral;*/
if(output[0] != 41)
failures++;
if(output[1] != 6262)
failures++;
if(output[2] !=6262)
failures++;
if( output[3] != 6334)
failures++;
if(output[4] != 18467)
failures++;
if(output[5] !=19169)
failures++;
if( output[6] != 26500)
failures++;

//#if STDCPP_OOM //failures++; //#endif 
	
}
 catch(bad_alloc&)
 {
  }
 catch(...)
 {
 	failures++;
 	
 }
   
 // __UHEAP_MARKEND;
  
  if(failures)
  return KErrGeneral;
  return KErrNone;  	
}





//greater_equal

TInt Ctstl_4::greater_equal_fun(CStifItemParser& aItem)
{


// __UHEAP_MARK;
	int failures =0;
 

 try
 {   
int sequence[7] = {6262, 6262, 41 ,18467, 6334, 26500, 19169 };
   vector <int>::iterator Iter1;

int output[7];

  vector<int> v1(sequence,sequence + 7);
 #if  STDCPP_OOM
User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);

#endif 
sort( v1.begin( ), v1.end( ) ,greater_equal<int>( ) );
#if  STDCPP_OOM 	
User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);


#endif
  for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )

  {
  static int i = 0;
  
  output[i] = *Iter1;
  i++;
 
  }
 
/*  	if(output[6] == 41 && output[5] == 6262 && output[4] == 6262 && output[3] == 6334 && output[2] == 18467  &&  output[1] == 19169 && output[0] == 26500)
	
	//	__UHEAP_MARKEND;

	return KErrNone ;
	return KErrGeneral;*/
	 if(output[6] != 41)
failures++;
if(output[5] != 6262)
failures++;
if(output[4] !=6262)
failures++;
if( output[3] != 6334)
failures++;
if(output[2] != 18467)
failures++;
if(output[1] !=19169)
failures++;
if( output[0] != 26500)
failures++;

//#if STDCPP_OOM //failures++; //#endif 
}
 catch(bad_alloc&)
 {
  }
 catch(...)
 {
 	failures++;
 	
 }
     
 // __UHEAP_MARKEND;
  
  if(failures)
  return KErrGeneral;
  return KErrNone; 	
}



//greater

TInt Ctstl_4::greater_fun(CStifItemParser& aItem)
{

	int failures =0;
  

 try
 {   
//__UHEAP_MARK;
int input1 [4] = { 0, 4, 6, 8 };
  int input2 [4] = { -0, 34, 6, -7 };
 int output [4];
 #if  STDCPP_OOM
User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);

#endif 
transform((int*)input1, (int*)input1 + 4, (int*)input2, (int*)output, greater<int>());
#if  STDCPP_OOM 	
User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);


#endif 
	// After this call to transform, output will contain a "1" if input1
//was greater than  input2 or a "0" if input1 was less than or equal to
//input2.
/*
	if(output[0] == 0 && output[1] == 0 && output[2] == 0 && output[3] == 1)
//	__UHEAP_MARKEND;
	return KErrNone;
	return KErrGeneral;*/
	 if(output[0] != 0)
failures++;
if(output[1] != 0)
failures++;
if(output[2] !=0)
failures++;
if( output[3] != 1)
failures++;

//#if STDCPP_OOM //failures++; //#endif
}
 catch(bad_alloc&)
 {
  }
 catch(...)
 {
 	failures++;
 	
 }
    
 // __UHEAP_MARKEND;
  
  if(failures)
  return KErrGeneral;
  return KErrNone; 



	
}


//LESS

TInt Ctstl_4::less_fun(CStifItemParser& aItem)
{
// __UHEAP_MARK;	
	int failures =0;
   

 try
 {    int input1 [4] = { 0, 4, 6, 8 };
  int input2 [4] = { -0, 34, 6, -7 };
 int output [4];
 #if  STDCPP_OOM
User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);

#endif
transform((int*)input1, (int*)input1 + 4, (int*)input2, (int*)output, less<int>());
#if  STDCPP_OOM 	
User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);


#endif  
//After this call to transform, output will contain a "1" if intput1
//was less than  input2 or a "0" if intput1 was greater than or equal to
//input2.

/*	if(output[0] == 0 && output[1] == 1 && output[2] == 0 && output[3] == 0)
//	__UHEAP_MARKEND;
	return KErrNone;
	return KErrGeneral;*/
	if(output[0] != 0)
failures++;
if(output[1] != 1)
failures++;
if(output[2] !=0)
failures++;
if( output[3] != 0)
failures++;

//#if STDCPP_OOM //failures++; //#endif

}
 catch(bad_alloc&)
 {
  }
 catch(...)
 {
 	failures++;
 	
 }
   
 // __UHEAP_MARKEND;
  
  if(failures)
  return KErrGeneral;
  return KErrNone; 	
}



// find code check
//---------------------

TInt Ctstl_4::find_fun(CStifItemParser& aItem)
{
// __UHEAP_MARK;		
	int failures =0;
  
 try
 {     typedef vector<int>::iterator iterator;
  int d1[10] = {0,1,2,2,3,4,2,2,6,7};

   vector<int> v1(d1,d1 + 10); 
   //cout<<"";
#if  STDCPP_OOM
User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);

#endif 

   iterator it1 = find(v1.begin(),v1.end(),3);
     #if  STDCPP_OOM 	
User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);


#endif      
//last iterator is returned  if unfound

  /* if((it1) && ((*it1) == 3)  ) 
   

	     
//	__UHEAP_MARKEND;
    return KErrNone;
   return  KErrGeneral; */
    
if((it1) && ((*it1) != 3)  )
failures++;
//#if STDCPP_OOM
//  failures++;
 // #endif
}
 catch(bad_alloc&)
 {
  }
 catch(...)
 {
 	failures++;
 	
 }
    
 // __UHEAP_MARKEND;
  
  if(failures)
  return KErrGeneral;
  return KErrNone; 

	
}



// find_if   
//----------------------


TInt Ctstl_4::findif_fun(CStifItemParser& aItem)
{

//__UHEAP_MARK;
	
	int failures =0;
  

 try
 {    typedef vector<int>::iterator iterator;
  int d1[10] = {0,1,2,2,3,4,2,2,6,7};

   vector<int> v1(d1,d1 + 10); 
   //cout<<"";
#if  STDCPP_OOM
User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);

#endif 
   iterator it1 = find_if(v1.begin(),v1.end(),bind1st(equal_to<int>(),7));

      #if  STDCPP_OOM 	
User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);


#endif        
//last iterator is returned  if unfound
/*   if((it1) && ((*it1) == 7)  ) 
   
//__UHEAP_MARKEND;
   return KErrNone;
   return KErrGeneral;*/
   if((it1) && ((*it1) != 7) ) 
   failures++;
  //#if STDCPP_OOM //failures++; //#endif
    
  }
 catch(bad_alloc&)
 {
  }
 catch(...)
 {
 	failures++;
 	
 }
  
 // __UHEAP_MARKEND;
  
  if(failures)
  return KErrGeneral;
  return KErrNone;  


	
}



//find_end 

TInt Ctstl_4::findend_fun(CStifItemParser& aItem)
{


//__UHEAP_MARK;
	int failures =0;
   

 try
 {   
 int array1[12] = {0,5,10,15,20,25,0,5,10,15,20,25};
int array2[3]    =  {20,30,40 };
int array3[4]= {5,10,15,20 };
int array4[4] ={30,40,50,60  }; //not found iterator


vector <int> v1(array1,array1+12), v2(array2,array2+3),v3(array3,array3+4);
  vector<int> v4(array4,array4+4);
  vector <int>::iterator Iter1, Iter2,Iter3 ,Iter4;


  

 
 vector <int>::iterator result1,result2; 
 //cout<<"";
 #if  STDCPP_OOM
	User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);

	 #endif
 result1 = find_end( v1.begin( ), v1.end( ), v3.begin( ), v3.end( ) );
 
 result2 = find_end ( v1.begin( ), v1.end( ), v4.begin( ), v4.end( ) );
#if  STDCPP_OOM 	
User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);

#endif 

/* if((result1 - v1.begin() == 7) && (result1 - v1.begin( ) != 1))

if(result2 == v1.end()) // if not found 
 
 // __UHEAP_MARKEND;
return KErrNone;
return KErrGeneral;*/
if((result1 - v1.begin() != 7) && (result1 - v1.begin( ) == 1))
failures++;
//#if STDCPP_OOM //failures++; //#endif
}
 catch(bad_alloc&)
 {
  }
 catch(...)
 {
 	failures++;
 	
 }
    
 // __UHEAP_MARKEND;
  
  if(failures)
  return KErrGeneral;
  return KErrNone; 


	
}






// Ctstl_4::Minof


TInt Ctstl_4::Minof( CStifItemParser& aItem )
{

 int failures =0;


try
{ 
  int result_int1;
 int result_int2;
 char result_char;
    #if  STDCPP_OOM
User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);

#endif  
 result_int1 = min(2,1);
 result_int2 = min(-2,-25);
 result_char = min('a','z');
  
 #if  STDCPP_OOM 	
User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);


#endif
 
/* if (result_int1 == 1)
  if(result_int2 == -25) 
 if (result_char == 'a')
if(min(2.23,2.24) == 2.23)  


  return KErrNone;
 return KErrGeneral;
 */
  if (result_int1 != 1)
  failures++;
  
  if(result_int2 != -25) 
  failures++;
 if (result_char != 'a')
 failures++;
if(min(2.23,2.24) != 2.23)    
failures++;

}
catch(bad_alloc&)
{
//do nothing
}
catch(...)
{
	failures++;
	
}
   
 
if(failures)
return KErrGeneral;
return KErrNone; 
 
 
	
}



TInt Ctstl_4::Maxelement(CStifItemParser& aItem)
{
	
	
	

int failures =0;


try
{ 
 
int test_array1[] = { 0,-2,-3333,1,23,3333,234,989};
char test_array2[] =  {'c','d','z','e','w'};

int test_variable1;
char test_variable2;

 #if  STDCPP_OOM
User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);

#endif 
test_variable1  = *max_element(test_array1,test_array1 + 8);
test_variable2 = *max_element(test_array2,test_array2+5);
int test_variable3 =*max_element(test_array1,test_array1 + 10);

#if  STDCPP_OOM 	
User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);


#endif
/*if((test_variable1 == 3333)&&(test_variable2 == 'z'))
if(test_variable3!=3333)
 
return KErrNone;
return KErrGeneral;
*/

if((test_variable1 != 3333)&&(test_variable2 != 'z'))
failures++;
if(test_variable3!=3333)
failures++;
 

}
catch(bad_alloc&)
{
//do nothing
}
catch(...)
{
	failures++;
	
}
  
  

if(failures)
return KErrGeneral;
return KErrNone; 
 

}





TInt Ctstl_4::Minelement(CStifItemParser& aItem)
{


int failures =0;

try
{ 
 
int test_array1[] = { 0,-2,-3333,1,23,3333,234,989};
char test_array2[] =  {'c','d','z','e','w'};

int test_variable1;
char test_variable2;

	  
#if  STDCPP_OOM
User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);

#endif 
test_variable1  = *min_element(test_array1,test_array1 + 8);
test_variable2 =  *min_element(test_array2,test_array2 + 5);

#if  STDCPP_OOM 	
User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);


#endif

/* if((test_variable1 == -3333)&&(test_variable2 == 'c'))

 
 return KErrNone;
return KErrGeneral;*/

if(test_variable1 != -3333)failures++;
if(test_variable2 != 'c') failures++;
}
catch(bad_alloc&)
{
return KErrNone;
}
catch(...)
{
	failures++;
	
}
   
 

if(failures)
return KErrGeneral;
return KErrNone; 


}




// -----------------------------------------------------------------------------
// Ctstl_4::ToUpper
 // -----------------------------------------------------------------------------
//
TInt Ctstl_4::ToUpper( CStifItemParser& aItem )
    {
 
     int failures=0 ; 

//__UHEAP_MARK;


   try
   {
  	//testcase starts
   char lower_char ;
            
      	
		     for(lower_char='a';lower_char<='z';lower_char++)		      
 		      
		     {
		     
 			#if  STDCPP_OOM
			User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
			#endif 		     
		     
		     char upper_char = toupper(lower_char);
		     
		     #if  STDCPP_OOM 	
 			 User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);
  		   	#endif 
 		     		     
		          
		     if ((lower_char - 32) != upper_char )      
		 	 
		 	 failures++;
		     }
		     
		     
		     
		     for(char lower_char=0x00;lower_char<=0x60;lower_char++)
		     {
		     	#if  STDCPP_OOM
				User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
				#endif 
		     	char upper_char = toupper(lower_char);
		     	#if  STDCPP_OOM 	
 				 User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);
 
				 #endif 
 
		     	if(lower_char!=upper_char)
		     	failures++;
		     	
		     }
		     
		     for(char lower_char=0x7B;lower_char<=0x7E;lower_char++)
		     {
		     	#if  STDCPP_OOM
				User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
				#endif 
		     	char upper_char = toupper(lower_char);
		     	#if  STDCPP_OOM 	
  				User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);
 
			 #endif 
 
		     	if(lower_char!=upper_char)
		     	failures++;
		     	


	 		  }
	 		  

	 		  //testcase ends

	 		  
 //#if STDCPP_OOM
 //failures++; 
 //#endif

}

//catching bad alloc exception
   catch(bad_alloc&)
   {
    //do nothing
   }
   
   //catching any other exception
   
   catch(...)
   {
   	failures++;
   	
   }
   
   
  
 
		  //__UHEAP_MARKEND;
		  if(failures)
		  return KErrGeneral;
		  return KErrNone;
    
    
    }
    
 // -----------------------------------------------------------------------------
// Ctstl_4::ToLower
// -----------------------------------------------------------------------------
//
    
    
    
   
    TInt Ctstl_4::ToLower( CStifItemParser& aItem )
    {

     //__UHEAP_MARK;
   char upper_char ;
     int failures = 0;       
     

   try
   {
    #if  STDCPP_OOM
User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
  
  #endif 
		     for(upper_char='A';upper_char<='Z';upper_char++)
		     {
		     	
		     
		     char lower_char = tolower(upper_char);
		          
		     if (lower_char  != (upper_char + 32 ))       
		 	 
		 failures++;
		     }
    
    
		     for(char upper_char=0x00;upper_char<=0x40;upper_char++)
		     {
		     	
		     	char lower_char = tolower(upper_char);
		     	if(lower_char!=upper_char)
		     	failures++;
		     	
		     }
		     for(char upper_char=0x5B;upper_char<=0x7E;upper_char++)
		     {
		     	
		     	char lower_char = tolower(upper_char);
		     	if(lower_char!=upper_char)
		     	failures++;
		     	


		     }
		     
 #if  STDCPP_OOM 	
  User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);
  
 #endif		     
		     	 		    
 //#if STDCPP_OOM 
 //failures++; 
 //#endif
		     
}

   catch(bad_alloc&)
   {
   //do nothing
   }
   
   catch(...)
   {
   	failures++;
   	
   }
  		  
	//	  __UHEAP_MARKEND;
		  if(failures)
		  return KErrGeneral;
		  return KErrNone;
    
    }

 
 // -----------------------------------------------------------------------------
// Ctstl_4::Islower
// -----------------------------------------------------------------------------
//
 
  TInt Ctstl_4::Islower( CStifItemParser& aItem )
    {

    // __UHEAP_MARK;
   
    char lower_char;
    int failures =0;
  

   try
   { 
     #if  STDCPP_OOM
User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
  
  #endif 
    for(lower_char = 'a' ;lower_char<='z';lower_char++)
    {
         
    if(!islower(lower_char))
   failures++;
    	
    }
   		     	 		    
  #if  STDCPP_OOM 	
  User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);

  
 #endif		     	 		    
 //#if STDCPP_OOM
  //failures++; 
  //#endif
	
}
   catch(bad_alloc&)
   {
  
   }
   catch(...)
   {
   	failures++;
   	
   }
      
   // __UHEAP_MARKEND;
    
    if(failures)
    return KErrGeneral;
    return KErrNone;
    }

 // -----------------------------------------------------------------------------
// Ctstl_4::Isupper
// -----------------------------------------------------------------------------
//
 
 
 TInt Ctstl_4::Isupper( CStifItemParser& aItem )
    {

      //__UHEAP_MARK;
   
    char upper_char;
    
    int failures =0;
     

   try
   { 
  
    for(upper_char = 'A' ;upper_char<='Z';upper_char++)
    {
    
    #if  STDCPP_OOM
User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
  
  #endif
    if(!isupper(upper_char))
   failures++;
    
    #if  STDCPP_OOM 	
  User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);

  
 #endif 	
    }
    		     	 		    
 //#if STDCPP_OOM 
 //failures++;
  //#endif
   }
   catch(bad_alloc&)
   {
   
   }
   catch(...)
   {
   	failures++;
   	
   }
      
     
    if(failures)
    return KErrGeneral;
    return KErrNone;
  }
 
 
 //  Ctstl_4::Maxof
 
 
 TInt Ctstl_4::Maxof( CStifItemParser& aItem )
    {
      int failures =0;
     

   try
   { 
     int result_int1;
     int result_int2;
     char result_char;
     float result_float;
     #if  STDCPP_OOM
User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);
  
  #endif
     result_int1 = max(2,1);
     result_int2 = max(-2,-25);
     result_char = max('a','z');
       #if  STDCPP_OOM 	
  User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);

  
 #endif 
     
  /*   
     if (result_int1 == 2)
     if(result_int2 == -2)
      if (result_char == 'z')
      if(max(2.23,2.24) == 2.24)  
      // __UHEAP_MARKEND;
     return KErrNone;
     return KErrGeneral;*/
     if (result_int1 != 2)
     failures++;
     if(result_int2 != -2)
     failures++;
      if (result_char != 'z')
      failures++;
      if(max(2.23,2.24) != 2.24)
      failures++;
    
 //#if STDCPP_OOM //failures++; //#endif
    
    
    }
   catch(bad_alloc&)
   {
   //do nothing
   }
   catch(...)
   {
   	failures++;
   	
   }
     
     
    if(failures)
    return KErrGeneral;
    return KErrNone; 
    
    	
    }
    
 
 // -----------------------------------------------------------------------------
 // Ctstl_4::ExampleL
 // Example test method function.
 // (other items were commented in a header).
 // -----------------------------------------------------------------------------
 //
 TInt Ctstl_4::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_4::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_4::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_4::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_4::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_4::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 L_Iter, 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;
     }
  
   
  
  
  
  
   
    //#if STDCPP_OOM
 //failures++;
 // #endif 

  
 	

 TInt  Ctstl_4::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_4::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_4::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_4::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_4::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_4::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_4::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_4::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_4::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_4::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_4::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_4::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_4::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_4::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_4::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_4::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_4::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_4::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_4::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_4::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_4::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;
     }
  
  



 
//  End of File
