/*

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

#include <iostream>

#include<algorithm>  

#include<set>

#include<functional>

#include <vector>

#include <numeric>

#include<list>

#include<exception>

#include <valarray>

#include<memory>

#include<fstream> 

#include<ios>

#include<exception>

#include "tstl_1.h"

using namespace std;

#define STDCPP_OOM FALSE// TRUE for OOM testing

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

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

// Ctstl_1::Delete

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

// Called from destructor. 

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

//

void Ctstl_1::Delete() 

    {

    }

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

// Ctstl_1::RunMethodL

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

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

//

TInt Ctstl_1::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( "ToUpper", Ctstl_1::ToUpper ),

        ENTRY( "ToLower", Ctstl_1::ToLower ),

        ENTRY( "Islower", Ctstl_1::Islower ),

        ENTRY( "Isupper", Ctstl_1::Isupper ),

        ENTRY( "Maxof", Ctstl_1::Maxof ),

        ENTRY( "Minof", Ctstl_1::Minof ),

        ENTRY( "Maxelement", Ctstl_1::Maxelement ),

        ENTRY( "Minelement", Ctstl_1::Minelement ),

        ENTRY( "Lowerbound", Ctstl_1::Lowerbound ),

        ENTRY( "Upperbound", Ctstl_1::Upperbound ),

        ENTRY( "Swapof", Ctstl_1::Swapof ),

        ENTRY( "Accumulate", Ctstl_1::Accumulate ),

 		ENTRY( "Adjacent_difference", Ctstl_1::Adjacent_difference),

        ENTRY( "Adjacent_find", Ctstl_1::Adjacent_find),

        ENTRY( "Logical_or", Ctstl_1::Logical_or ),

        ENTRY( "Logical_and", Ctstl_1::Logical_and ),

        ENTRY( "Logical_not", Ctstl_1::Logical_not ),

        ENTRY( "count_fun", Ctstl_1::count_fun),

        ENTRY( "countif_fun", Ctstl_1::countif_fun),

        ENTRY( "equal_fun", Ctstl_1::equal_fun),

        ENTRY( "equalto", Ctstl_1::equalto),

        ENTRY( "notequalto", Ctstl_1::notequalto),

 		ENTRY( "sort_fun", Ctstl_1::sort_fun),

 		ENTRY( "less_equal_fun", Ctstl_1::less_equal_fun),

 		ENTRY( "greater_equal_fun", Ctstl_1::greater_equal_fun),

 		ENTRY( "greater_fun", Ctstl_1::greater_fun),

 		ENTRY( "less_fun", Ctstl_1::less_fun),

 		ENTRY( "find_fun", Ctstl_1::find_fun),

 		ENTRY( "findif_fun", Ctstl_1::findif_fun),

 		ENTRY( "findend_fun", Ctstl_1::findend_fun),

 		ENTRY( "findfirstof_fun", Ctstl_1::findfirstof_fun),

 		ENTRY( "Minus", Ctstl_1::Minus),

        ENTRY( "Plus", Ctstl_1::Plus),

        ENTRY( "Divides", Ctstl_1::Divides),

        ENTRY( "Modulus", Ctstl_1::Modulus),

        ENTRY( "Negate", Ctstl_1::Negate),

        ENTRY( "Logicalnot", Ctstl_1::Logicalnot),

        ENTRY( "Logicaland", Ctstl_1::Logicaland),

        ENTRY( "Logicalor", Ctstl_1::Logicalor),

        ENTRY( "Remove", Ctstl_1::Remove),

        ENTRY( "Removeif", Ctstl_1::Removeif),

        ENTRY( "Removecopy", Ctstl_1::Removecopy),

        ENTRY( "Removecopy_if", Ctstl_1::Removecopy_if),

        ENTRY( "Replace_fun", Ctstl_1::Replace_fun),

        ENTRY( "Replacecopy_fun", Ctstl_1::Replacecopy_fun),

        ENTRY( "Replacecopyif_fun", Ctstl_1::Replacecopyif_fun),

        ENTRY( "Replaceif_fun", Ctstl_1::Replaceif_fun),

        ENTRY( "Reverse_fun", Ctstl_1::Reverse_fun),

        ENTRY( "Reversecopy_fun", Ctstl_1::Reversecopy_fun),

        ENTRY( "Rotate_fun", Ctstl_1::Rotate_fun),

        ENTRY( "Rotatecopy_fun", Ctstl_1::Rotatecopy_fun),

 		ENTRY( "equalrange", Ctstl_1::equalrange),

 		ENTRY( "exceptionL", Ctstl_1::exceptionL),

        ENTRY( "foreach", Ctstl_1::foreach),

 		ENTRY( "gsliceL", Ctstl_1::gsliceL),

        ENTRY( "sliceL", Ctstl_1::sliceL),

 		ENTRY( "unaryfunc", Ctstl_1::unaryfunc),

 		ENTRY( "uni_fill", Ctstl_1::uni_fill),

 		ENTRY( "uni_fill_n", Ctstl_1::uni_fill_n),

 		ENTRY( "uni_copy", Ctstl_1::uni_copy),

 		ENTRY( "maskarray", Ctstl_1::maskarray),

	    ENTRY( "autoptr", Ctstl_1::autoptr),

 		ENTRY( "randshuf", Ctstl_1::randshuf),

 		ENTRY( "randstoriter", Ctstl_1::randstoriter),

 		ENTRY( "iterswap", Ctstl_1::iterswap),

 		ENTRY( "ios1", Ctstl_1::ios1),

 		ENTRY( "ios2", Ctstl_1::ios2),

 		ENTRY( "ios3", Ctstl_1::ios3),

 		ENTRY( "nthelement", Ctstl_1::nthelement),

 		ENTRY( "hasfacet", Ctstl_1::hasfacet),

        };

    const TInt count = sizeof( KFunctions ) / 

                        sizeof( TStifFunctionInfo );

    return RunInternalL( KFunctions, count, aItem );

    }

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

// Ctstl_1::ToUpper

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

//

TInt Ctstl_1::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_1::ToLower

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

//

    TInt Ctstl_1::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_1::Islower

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

//

  TInt Ctstl_1::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_1::Isupper

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

//

 TInt Ctstl_1::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_1::Maxof

 TInt Ctstl_1::Maxof( 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 = 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_1::Minof

    TInt Ctstl_1::Minof( CStifItemParser& aItem )

    {