/*

* 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;

 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);

//cout<<"";