/*

* 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

// ============================ 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>::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(...)