/*

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

#include <sstream>

#include "tlocale.h"

#define STDCPP_OOM FALSE

#define	testChar	unsigned char

using namespace std;

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

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

// Ctlocale::Delete

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

// Called from destructor. 

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

//

void Ctlocale::Delete() 

    {

    }

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

// Ctlocale::RunMethodL

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

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

//

TInt Ctlocale::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( "hasfacet", Ctlocale::hasfacet ),

					 ENTRY( "usefacet", Ctlocale::usefacet ),

					 ENTRY( "numget", Ctlocale::numget ),

					 ENTRY( "numput", Ctlocale::numput ),

					 ENTRY( "num_punct", Ctlocale::num_punct ),  

					 ENTRY( "numpunctbyname", Ctlocale::numpunctbyname ),

					 ENTRY( "moneyget", Ctlocale::moneyget ),

					 ENTRY( "moneyput", Ctlocale::moneyput ),

					 ENTRY( "money_punct", Ctlocale::money_punct ),  

					 ENTRY( "moneypunctbyname", Ctlocale::moneypunctbyname ),

					 ENTRY( "timeget", Ctlocale::timeget ),

					 ENTRY( "timeput", Ctlocale::timeput ),

					 ENTRY( "messagesL", Ctlocale::messagesL ),

					 ENTRY( "messagesbyname", Ctlocale::messagesbyname ),

					 ENTRY( "collateL", Ctlocale::collateL ),

					 ENTRY( "collatebyname", Ctlocale::collatebyname ),

					 ENTRY( "codecvt1", Ctlocale::codecvt1 ),

					 ENTRY( "codecvt2", Ctlocale::codecvt2 ),

					 ENTRY( "codecvtbyname1", Ctlocale::codecvtbyname1 ),

					 ENTRY( "codecvtbyname2", Ctlocale::codecvtbyname2 ),

					 ENTRY( "ctype_byname1", Ctlocale::ctype_byname1L),

					 ENTRY( "moneypunct_byname1", Ctlocale::moneypunct_byname1L),

					 ENTRY( "moneypunct1", Ctlocale::moneypunct1L),

					 ENTRY( "numpunct1", Ctlocale::numpunct1L),

					 ENTRY( "numpunct_byname1", Ctlocale::numpunct_byname1L),

        };

    const TInt count = sizeof( KFunctions ) / 

                        sizeof( TStifFunctionInfo );

    return RunInternalL( KFunctions, count, aItem );

    }

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

// Ctlocale::has_facet

// has_facet test method function.

//  

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

//

TInt Ctlocale::hasfacet( CStifItemParser& aItem )

    {

    int failures=0;

__UHEAP_MARK;

    try

    {

 bool result = true;

 // __UHEAP_MARK;

   cout<<"";  

 #if  STDCPP_OOM

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

  #endif 

  locale loc("en_GB.UTF-8") ;

 result = has_facet <ctype<char> > ( loc );

 #if  STDCPP_OOM

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

  #endif 

//__UHEAP_MARKEND;

/*

 if(result)

 return KErrNone;

 else

 return KErrGeneral;

 */

 if(!result)

 failures++;

    }

 catch(bad_alloc&)

   {

   	//do nothing

    }

   catch(...)

   {

   	failures++;

   }

__UHEAP_MARKEND;   

		  if(failures  )

		  return KErrGeneral;

		  return KErrNone;

    }

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

// Ctlocale::use_facet

// use_facet test method function.

//  

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

//

TInt Ctlocale::usefacet( CStifItemParser& aItem )

    {

    int failures=0;

__UHEAP_MARK;

try

{

 locale   loc ("en_GB.UTF-8");

 cout<<"";

 #if  STDCPP_OOM

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

  #endif 

 bool result = use_facet<ctype<char> > ( loc ).is(ctype_base::alpha, 'b');

 #if  STDCPP_OOM

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

  #endif 

// __UHEAP_MARKEND;

/* if (result)

 return KErrNone;

 else

 return KErrGeneral;

*/

if(!result)

 failures++;

 }

 catch(bad_alloc&)

   {

   	//do nothing

    }

   catch(...)

   {

   	failures++;

   }

__UHEAP_MARKEND;

		  if(failures  )

		  return KErrGeneral;

		  return KErrNone;

    }

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

// Ctlocale::num_get

// num_get test method function.

//  

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

//

TInt Ctlocale::numget( CStifItemParser& aItem )

    {

    int failures=0;

 __UHEAP_MARK;   

    try

    {

 typedef istreambuf_iterator<char,char_traits<char> >

 iter_type;

 locale loc;

 iter_type end;

 cout<<"";

#if  STDCPP_OOM

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

  #endif 

  const num_get<char,iter_type>& tg = use_facet<num_get<char,iter_type> >(loc);

 	#if  STDCPP_OOM

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

  #endif 

 //return KErrNone;

	}

 catch(bad_alloc&)

   {

   	//do nothing

    }

   catch(...)

   {

   	failures++;

   }

 __UHEAP_MARKEND;  

		  if(failures  )

		  return KErrGeneral;

		  return KErrNone;

    }

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

// Ctlocale::num_put

// num_put test method function.

//  

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

//

TInt Ctlocale::numput( CStifItemParser& aItem )

    {

__UHEAP_MARK;

    int failures=0;

    try

    {

 typedef ostreambuf_iterator<char,char_traits<char> >

 iter_type;

 locale loc;

 // Construct a ostreambuf_iterator on cout

 iter_type begin(cout);

 // Get a num_put facet reference

 cout<<"";

 #if  STDCPP_OOM

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

  #endif 

 const num_put<char,iter_type>& np = use_facet<num_put<char,iter_type> >(loc);

  #if  STDCPP_OOM

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

  #endif     

//return KErrNone;

 }

 catch(bad_alloc&)

   {

   	//do nothing

    }

   catch(...)

   {

   	failures++;

   }

__UHEAP_MARKEND;   

		  if(failures  )

		  return KErrGeneral;

		  return KErrNone;

    }

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

// Ctlocale::num_punct

// num_punct test method function.

//  

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

// 

TInt Ctlocale::num_punct( CStifItemParser& aItem )

 {

__UHEAP_MARK;

 int failures=0;

 try

 {

 locale loc;

cout<<"";

#if  STDCPP_OOM

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

  #endif 

 const numpunct <char> &npunct = use_facet <numpunct <char> >( loc);

   // const numpunct <unsigned> &n1punct = use_facet <numpunct <unsigned> >( loc);

#if  STDCPP_OOM

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

  #endif 

/*   

 if(npunct.truename() ==  "true")

 if(npunct.falsename()=="false")  

 if(npunct.decimal_point() =='.')

 if(npunct.thousands_sep() ==',')

 return KErrNone;

 else

 return KErrGeneral;*/

  if(npunct.truename() !=  "true")

  failures++;

 if(npunct.falsename()!="false")  

 failures++;

 if(npunct.decimal_point() !='.')

 failures++;

 if(npunct.thousands_sep() !=',')

 failures++;

 }

 catch(bad_alloc&)

   {

   	//do nothing

    }

   catch(...)

   {

   	failures++;

   }

__UHEAP_MARKEND;   

		  if(failures  )

		  return KErrGeneral;

		  return KErrNone;

    }

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

// Ctlocale::numpunct_byname

// numpunct_byname test method function.

//  

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

//

TInt Ctlocale::numpunctbyname( CStifItemParser& aItem )

    {

    int failures=0;

__UHEAP_MARK;    

    try

    {

 locale loc;

cout<<"";

#if  STDCPP_OOM

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

  #endif 

 const numpunct_byname <char> &npunct = use_facet <numpunct_byname <char> >( loc);

   #if  STDCPP_OOM

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

  #endif 

 /*if(npunct.truename() ==  "true")

 if(npunct.falsename()=="false") 

 if(npunct.decimal_point( ) =='.')

 if(npunct.thousands_sep( ) ==',')

return KErrNone;

else

return KErrGeneral;*/

if(npunct.truename() !=  "true")

failures++;

 if(npunct.falsename()!="false") 

 failures++;

 if(npunct.decimal_point( ) !='.')

 failures++;

 if(npunct.thousands_sep( ) !=',')

 failures++;

 }

 catch(bad_alloc&)

   {

   	//do nothing

    }

   catch(...)

   {

   	failures++;

   }

 __UHEAP_MARKEND;  

		  if(failures  )

		  return KErrGeneral;

		  return KErrNone;

    }

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

// Ctlocale::money_get

// money_get test method function.

//  

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

//

TInt Ctlocale::moneyget( CStifItemParser& aItem )

    {

    int failures=0;

 __UHEAP_MARK;   

    try

    {

 typedef istreambuf_iterator<char,char_traits<char> >

 iter_type;

 locale loc;

 string buffer("$100.02");

 string dest;

 long double ldest;

 ios_base::iostate state;

 iter_type end;

 cout<<"";

#if  STDCPP_OOM

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

  #endif 

 // Get a money_get facet

 const money_get<char,iter_type>& mgf =  use_facet<money_get<char,iter_type> >(loc);

#if  STDCPP_OOM

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

  #endif 

// return KErrNone;

	}

 catch(bad_alloc&)

   {

   	//do nothing

    }

   catch(...)

   {

   	failures++;

   }

 __UHEAP_MARKEND;  

		  if(failures  )

		  return KErrGeneral;

		  return KErrNone;

    }

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

// Ctlocale::money_put

// money_put test method function.

//  

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

//

TInt Ctlocale::moneyput( CStifItemParser& aItem )

    {

    int failures=0;

    try

    {

 typedef ostreambuf_iterator<char,char_traits<char> >

 iter_type;

 locale loc;

 string buffer("10002");

 long double ldval = 10002;

  iter_type begin(cout);

  cout<<"";

#if  STDCPP_OOM

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

  #endif 

  const money_put<char,iter_type>& mp =   use_facet<money_put<char,iter_type> >(loc);

    #if  STDCPP_OOM

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

  #endif  

//return KErrNone;