/*

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

#include<algorithm>

#include<vector>

#include<iostream>

 #include<ostream>

#include<iterator>

#include<numeric>

#include <queue>

#include <deque>

#include <stack>

#include<list>

#include <string>

#include<functional>

#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

#include "tstl_3.h"

using namespace std;

 #define STDCPP_OOM FALSE// TRUE for OOM testing

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

// -----------------------------------------------------------------------------

// Ctstl_3::Delete

// Delete here all resources allocated and opened from test methods. 

// Called from destructor. 

// -----------------------------------------------------------------------------

//

void Ctstl_3::Delete() 

    {

    }

// -----------------------------------------------------------------------------

// Ctstl_3::RunMethodL

// Run specified method. Contains also table of test mothods and their names.

// -----------------------------------------------------------------------------

//

TInt Ctstl_3::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( "Includes", Ctstl_3::Includes ),

		ENTRY( "innerproduct", Ctstl_3::innerproduct ),

		ENTRY( "inplacemerge", Ctstl_3::inplacemerge ),

		ENTRY( "Queue", Ctstl_3::Queue ),

		ENTRY( "Pqueue", Ctstl_3::Pqueue ),

 		ENTRY( "stablesortL", Ctstl_3::stablesortL ),

 		ENTRY( "Stack", Ctstl_3::Stack ),

  		ENTRY( "string1_testL", Ctstl_3::string1_testL ),

  		 ENTRY("Setintersection", Ctstl_3::Setintersection ),

 ENTRY("Setsymdifference", Ctstl_3::Setsymdifference ),

 ENTRY("Setunion", Ctstl_3::Setunion ),

 ENTRY("HeapL", Ctstl_3::HeapL ),

 ENTRY("Swapranges", Ctstl_3::Swapranges ),

 ENTRY("Partialsums", Ctstl_3::Partialsums ),

 ENTRY("Unarynegate", Ctstl_3::Unarynegate ),

 ENTRY("Not2", Ctstl_3::Not2),

 ENTRY("GettemporarybufferL", Ctstl_3::GettemporarybufferL),

 ENTRY("Pair", Ctstl_3::Pair),

 ENTRY("Lexicographicalcompare", Ctstl_3::Lexicographicalcompare ),

 ENTRY("Mismatch", Ctstl_3::Mismatch ),

 ENTRY("Compare_fun", Ctstl_3::Compare_fun ),

 ENTRY("Copy_fun", Ctstl_3::Copy_fun ),

 ENTRY("Copybackward_fun", Ctstl_3::Copybackward_fun ),

 ENTRY("mergeL", Ctstl_3::mergeL ),

 ENTRY("allocatoradd", Ctstl_3::allocatoradd ),

 ENTRY("alldeall", Ctstl_3::alldeall ),

 ENTRY("allcons", Ctstl_3::allcons ),

 ENTRY("allrebind", Ctstl_3::allrebind ),

 ENTRY("allmaxsize", Ctstl_3::allmaxsize ),

        };

    const TInt count = sizeof( KFunctions ) / 

                        sizeof( TStifFunctionInfo );

    return RunInternalL( KFunctions, count, aItem );

    }

// -----------------------------------------------------------------------------

// Ctstl_3::ExampleL

// Example test method function.

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

bool myfunction (int i, int j) { return i<j; }

TInt Ctstl_3::Includes( CStifItemParser& aItem )

    {

int failures =0;

try

{

   int container1[] = {5,10,15,20,25,30,35,40,45,50};

  int container2[] = {40,30,20,10};

int container3[]={100,200,300,400,10,20,30,40};

  sort (container1,container1+10);

  sort (container2,container2+4);

sort(container3,container3+8);

/*

if(!includes(container1,container1+10,container3,container3+8))

   if ( includes(container1,container1+10,container2,container2+4) )

   if ( includes(container1,container1+10,container2,container2+4, myfunction) )

  return KErrNone;

  return KErrGeneral;

*/

 // cout<<"";

 #if  STDCPP_OOM

User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);

  #endif 

if(includes(container1,container1+10,container3,container3+8))

failures++;

   if ( !includes(container1,container1+10,container2,container2+4) )

   failures++;

   if ( !includes(container1,container1+10,container2,container2+4, myfunction) )

   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;

    } 

   // vector<int> myvector (8,10); 

// -----------------------------------------------------------------------------

// Ctstl_3::innerproduct

// Example test method function.

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

TInt Ctstl_3::innerproduct( CStifItemParser& aItem )

    {

    int failures=0;

    try

    {

typedef vector < int > intArray;

typedef ostream_iterator < int, char, char_traits<char> >

FloatOstreamIt;

    FloatOstreamIt itOstream(cout," ");

    // Initialize the arrays

    intArray rgF1, rgF2;

    for (int i=1; i<=5; i++) {

        rgF1.push_back(i);

        rgF2.push_back(i*i);

    };

    // Print the arrays

    copy(rgF1.begin(),rgF1.end(),itOstream);

    copy(rgF2.begin(),rgF2.end(),itOstream);

   // cout<<"";

 #if  STDCPP_OOM

User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);

  #endif 

    // Compute the inner_product of the arrays.  This is the

    // sum of the products (S.O.P) of the corresponding elements

    int ip1 = inner_product(rgF1.begin(),rgF1.end(),rgF2.begin(),0);

 int ip2 = inner_product(rgF1.begin(),rgF1.end(),rgF2.begin(),1,multiplies<int>(),plus<int>());

  #if  STDCPP_OOM

User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);

  #endif 

/* if(ip1==225)

if(ip2==86400)

return KErrNone;

return KErrGeneral;*/

    // Compute the inner_product of the arrays.  This is the

    // product of the sums (P.O.S.) of the corresponding elements

   if(ip1!=225)

   failures++;

if(ip2!=86400)

failures++;

 //#if STDCPP_OOM

//failures++;

// #endif

    }

catch(bad_alloc&)

   {

   	//do nothing

    }

   catch(...)

   {

   	failures++;

   }

		  if(failures  )

		  return KErrGeneral;

		  return KErrNone;

    }

 // -----------------------------------------------------------------------------

// Ctstl_3::inplacemerge

// Example test method function.

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

TInt Ctstl_3::inplacemerge( CStifItemParser& aItem )

    {

int failures=0;

try

{

    int first[] = {5,10,15,20,25};

  int second[] = {50,40,30,20,10};

  vector<int> v(10);

  vector<int>::iterator it;

int a[10];

  sort (first,first+5);

  sort (second,second+5);

  copy (first,first+5,v.begin());

  copy (second,second+5,v.begin()+5); 

  // cout<<"";

 #if  STDCPP_OOM

User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);

  #endif 

  inplace_merge(v.begin(),v.begin()+5,v.end());

 #if  STDCPP_OOM

User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);

  #endif 

   for (it=v.begin(); it!=v.end(); ++it)

   {

   	static int i;

   	a[i]=*it;

   	i++;

   }

 /*

   if(a[0]==5)

   if(a[1]==10)

   if(a[2]==10)

   if(a[3]==15)

   if(a[4]==20)

   if(a[5]==20)

   if(a[6]==25)

   if(a[7]==30)

   if(a[8]==40)

   if(a[9]==50)

   return KErrNone;

   return KErrGeneral;

 */

  if(a[0]!=5)

   if(a[1]!=10)

   if(a[2]!=10)

   if(a[3]!=15)

   if(a[4]!=20)

   if(a[5]!=20)

   if(a[6]!=25)

   if(a[7]!=30)

   if(a[8]!=40)

   if(a[9]!=50)

   failures++;

 //#if STDCPP_OOM

//failures++;

// #endif

    }

catch(bad_alloc&)

   {

   	//do nothing

    }

   catch(...)

   {

   	failures++;

   }

		  if(failures  )

		  return KErrGeneral;

		  return KErrNone;

    }

// -----------------------------------------------------------------------------

// Ctstl_3::Queue

// Queue test method function.

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

TInt Ctstl_3::Queue( CStifItemParser& aItem )

    {

    int failures=0;

    try

    {

  int arr[3];

   // cout<<"";

   #if  STDCPP_OOM

User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);

  #endif 

   queue<int,list<int> >  q;

   q.push(1);

   arr[0]=q.back();

   if(q.size()!=1)

   failures++;

   if(q.back()!=1)

   failures++;

   if(arr[0]!=1)

   failures++;

   q.push(2);

   arr[1]=q.back();

   if(q.size()!=2)

   failures++;

   if(q.back()!=2)

   failures++;

   if(arr[1]!=2)

   failures++;

   q.push(3);

   arr[2]=q.back();

   if(q.size()!=3)

   failures++;

   if(q.back()!=3)

   failures++;

   if(arr[2]!=3)

   failures++;

   q.pop();

   if(q.size()!=2)

   failures++;

   if(q.back()!=3)

   failures++;

   if(q.front()!=2)

   failures++;

   q.pop();

   q.pop();

    #if  STDCPP_OOM

User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);

  #endif 

   if(!q.empty())

   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;

    }

// -----------------------------------------------------------------------------

// Ctstl_3::PQueue

// PQueue test method function.

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

TInt Ctstl_3::Pqueue( CStifItemParser& aItem )

    {

    int failures=0;

    try

    {

  int arr[3];

  typedef deque<int> d; 

  // cout<<"";

   #if  STDCPP_OOM

User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);

  #endif 

 priority_queue<int, d, less<int> > q;

  q.push(1);

  arr[0]=q.top();

   if(q.size()!=1)

   failures++;

   if(q.top()!=1)

   failures++;

   if(arr[0]!=1)

   failures++;

   q.push(2);

   arr[1]=q.top();

   if(q.size()!=2)

   failures++;

   if(q.top()!=2)

   failures++;

   if(arr[1]!=2)

   failures++;

   q.push(3);

   arr[2]=q.top();

   if(q.size()!=3)