/*

 * 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<stl/_locale.h>

 #include<iostream>

 #include<string>

 #include "tlocale.h"

 #define STDCPP_OOM FALSE

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

  ENTRY( "c_type", Ctlocale::c_type ),

         };

     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;

     try

     {

  bool result = true;

   bool result_w = true;

  // __UHEAP_MARK;

    cout<<"";  

  #if  STDCPP_OOM

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

   #endif 

 // char* p = "c";

 //  const char* _Loc_ctype_default(p) ;

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

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

   result_w = has_facet <ctype<wchar_t> > ( loc );

  #if  STDCPP_OOM

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

   #endif 

 //__UHEAP_MARKEND;

 /*

  if(result)

  return KErrNone;

  else

  return KErrGeneral;

  */

  if(!result)

  failures++;

   if(!result_w)

  failures++;

     }

  catch(bad_alloc&)

    {

    	//do nothing

     }

    catch(...)

    {

    	failures++;

    }

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

   bool result_w = use_facet<ctype<wchar_t> > ( loc ).is(ctype_base::alpha, L'b');

  #if  STDCPP_OOM

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

   #endif 

 // __UHEAP_MARKEND;

 /* if (result)

  return KErrNone;

  else

  return KErrGeneral;

 */

 if(!result)

  failures++;

 if(!result_w)

  failures++;

  }

  catch(bad_alloc&)

    {

    	//do nothing

     }

    catch(...)

    {

    	failures++;

    }

 		  if(failures  )

 		  return KErrGeneral;

 		  return KErrNone;

     }

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

 // Ctlocale::num_get

 // num_get test method function.

 //  

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

 //

 TInt Ctlocale::numget( CStifItemParser& aItem )

     {

     int failures=0;

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

    }

 		  if(failures  )

 		  return KErrGeneral;

 		  return KErrNone;

     }

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

 // Ctlocale::num_put

 // num_put test method function.

 //  

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

 //

 TInt Ctlocale::numput( CStifItemParser& aItem )

     {

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

    }

 		  if(failures  )

 		  return KErrGeneral;

 		  return KErrNone;

     }

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

 // Ctlocale::num_punct

 // num_punct test method function.

 //  

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

 // 

 TInt Ctlocale::num_punct( CStifItemParser& aItem )

  {

  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 <wchar_t> &npunct_w = use_facet <numpunct <wchar_t> >( 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++;

   if(npunct_w.truename() !=  L"true")

   failures++;

  if(npunct_w.falsename()!=L"false")  

  failures++;

  if(npunct_w.decimal_point() != L'.')

  failures++;

  if(npunct_w.thousands_sep() !=L',')

  failures++;

  }

  catch(bad_alloc&)

    {

    	//do nothing

     }

    catch(...)

    {

    	failures++;

    }

 		  if(failures  )

 		  return KErrGeneral;

 		  return KErrNone;

     }

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

 // Ctlocale::numpunct_byname

 // numpunct_byname test method function.

 //  

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

 //

 TInt Ctlocale::numpunctbyname( CStifItemParser& aItem )

     {

     int failures=0;

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

   const numpunct_byname <wchar_t> &npunct_w = use_facet <numpunct_byname <wchar_t> >( 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++;

  if(npunct_w.truename() !=  L"true")

 failures++;

  if(npunct_w.falsename()!= L"false") 

  failures++;

  if(npunct_w.decimal_point( ) != L'.')

  failures++;

  if(npunct_w.thousands_sep( ) != L',')

  failures++;

  }

  catch(bad_alloc&)

    {

    	//do nothing

     }

    catch(...)

    {

    	failures++;

    }

 		  if(failures  )

 		  return KErrGeneral;

 		  return KErrNone;

     }

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

 // Ctlocale::money_get

 // money_get test method function.

 //  

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

 //

 TInt Ctlocale::moneyget( CStifItemParser& aItem )

     {

     int failures=0;

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

    }

 		  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;

  }

  catch(bad_alloc&)

    {

    	//do nothing

     }

    catch(...)

    {

    	failures++;

    }

 		  if(failures  )

 		  return KErrGeneral;

 		  return KErrNone;

     }

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

 // Ctlocale::moneypunct

 // moneypunct test method function.

 //  

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

 //

 TInt Ctlocale::money_punct( CStifItemParser& aItem )

     {

      int failures=0;

      try

      {

  locale loc;

  cout<<"";

 #if  STDCPP_OOM

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

   #endif 

   const moneypunct<char,false>& mp = use_facet<moneypunct<char,false> >(loc);

     const moneypunct<char,true>& mp_true = use_facet<moneypunct<char,true> >(loc);

    const moneypunct<wchar_t,false>& mp_w = use_facet<moneypunct<wchar_t,false> >(loc);

       const moneypunct<wchar_t,true>& mp_w_true = use_facet<moneypunct<wchar_t,true> >(loc);

    #if  STDCPP_OOM

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

   #endif    

  mp.curr_symbol();

  mp.negative_sign();

 mp.grouping();

 mp.curr_symbol();

 mp.frac_digits();

 mp.pos_format() ;

 mp.neg_format(); 

 mp_true.curr_symbol();

  mp_true.negative_sign();

 mp_true.grouping();

 mp_true.curr_symbol();

 mp_true.frac_digits();

 mp_true.pos_format() ;

 mp_true.neg_format(); 

  mp_w.curr_symbol();

  mp_w.negative_sign();

 mp_w.grouping();

 mp_w.curr_symbol();

 mp_w.frac_digits();

 mp_w.pos_format() ;

 mp_w.neg_format(); 

 mp_w_true.curr_symbol();

  mp_w_true.negative_sign();

 mp_w_true.grouping();

 mp_w_true.curr_symbol();

 mp_w_true.frac_digits();

 mp_w_true.pos_format() ;

 mp_w_true.neg_format(); 

 /* if(mp.decimal_point() == '.')

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

  if( mp.frac_digits() == 0)

 return KErrNone;

 else

 return KErrGeneral;*/

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

 failures++;

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

  failures++;

  if( mp.frac_digits() != 0)

  failures++;

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

 failures++;

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

  failures++;

  if( mp_true.frac_digits() != 0)

  failures++;

  if(mp_w.decimal_point() != L'.')

 failures++;

  if(mp_w.thousands_sep() != L',')

  failures++;

  if( mp_w.frac_digits() != 0)

  failures++;

  if(mp_w_true.decimal_point() != L'.')

 failures++;

  if(mp_w_true.thousands_sep() != L',')

  failures++;

  if( mp_w_true.frac_digits() != 0)

  failures++;

  }

  catch(bad_alloc&)

    {

    	//do nothing

     }

    catch(...)

    {

    	failures++;

    }

 		  if(failures  )

 		  return KErrGeneral;

 		  return KErrNone;

     }

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

 // Ctlocale::moneypunct_byname

 // moneypunct_byname test method function.

 //  

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

 // 

 TInt Ctlocale::moneypunctbyname( CStifItemParser& aItem )

     {

     int failures=0;

     try

     {

  locale loc;

  cout<<"";

  #if  STDCPP_OOM

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

   #endif 

   const moneypunct_byname<char,false>& mp = 

  use_facet<moneypunct_byname<char,false> >(loc);

    const moneypunct_byname<char,true>& mp_true = 

  use_facet<moneypunct_byname<char,true> >(loc);

    const moneypunct_byname<wchar_t,false>& mp_w = 

  use_facet<moneypunct_byname<wchar_t,false> >(loc);

     const moneypunct_byname<wchar_t,true>& mp_w_true = 

  use_facet<moneypunct_byname<wchar_t,true> >(loc);

    #if  STDCPP_OOM

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

   #endif 

  mp.curr_symbol();

  mp.negative_sign();

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

  failures++;

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

  failures++;

  if( mp.frac_digits() != 0)

  failures++;

  mp_true.curr_symbol();

  mp_true.negative_sign();

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

  failures++;

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

  failures++;

  if( mp_true.frac_digits() != 0)

  failures++;

  mp_w.curr_symbol();

  mp_w.negative_sign();

  if(mp_w.decimal_point() != L'.')

  failures++;

  if(mp_w.thousands_sep() != L',')

  failures++;

  if( mp_w.frac_digits() != 0)

  failures++;

  mp_w_true.curr_symbol();

  mp_w_true.negative_sign();

  if(mp_w_true.decimal_point() != L'.')

  failures++;

  if(mp_w_true.thousands_sep() != L',')

  failures++;

  if( mp_w_true.frac_digits() != 0)

  failures++; 

  }

  catch(bad_alloc&)

    {

    	//do nothing

     }

    catch(...)

    {

    	failures++;

    }

 		  if(failures  )

 		  return KErrGeneral;

 		  return KErrNone;

     }

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

 // Ctlocale::time_get

 // time_get  test method function.

 //  

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

 // 

 TInt Ctlocale::timeget( CStifItemParser& aItem )

     {

     int failures=0;

     try

     {

   typedef std::istreambuf_iterator<char,

   std::char_traits<char> > Iter;

 //  static struct tm timeb;  

 //  std::ios_base::iostate state;

 cout<<"";

     #if  STDCPP_OOM

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

   #endif 

  const std::time_get<char, Iter> &tg =

  std::use_facet<std::time_get<char, Iter> >(std::locale ("C"));

  #if  STDCPP_OOM

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

   #endif 

  //return KErrNone;

 	}

  catch(bad_alloc&)

    {

    	//do nothing

     }

    catch(...)

    {

    	failures++;

    }

 		  if(failures  )

 		  return KErrGeneral;

 		  return KErrNone;

     }

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

 // Ctlocale::time_put

 // time_put  test method function.

 //  

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

 // 

 TInt Ctlocale::timeput( CStifItemParser& aItem )

     { 

     int failures=0; 

     try

     {

 /*    std::tm t = std::tm ();

     t.tm_sec   = 56;    

     t.tm_min   = 34;    

     t.tm_hour  = 14;    

     t.tm_mday  = 29;   

     t.tm_mon   =  1;    

     t.tm_year  = 84;    

     t.tm_yday  = 59;    

     t.tm_wday  =  3;   

     t.tm_isdst =  0;   

     const char* const fmt[] = {

       "%a", "%A", "%b", "%B", "%c", "%C", "%d", "%D",

       "%e", "%F", "%g", "%G", "%h", "%H", "%I", "%j",

       "%k", "%l", "%m", "%M", "%n", "%p", "%r", "%R",

       "%S", "%t", "%T", "%u", "%U", "%V", "%w", "%W", "%x",

       "%X", "%y", "%Y", "%z", "%Z", "%%", "%Ec", "%EC", "%Ex",

       "%EX", "%Ey", "%EY", "%Od", "%Oe", "%OH", "%OI", "%Om",

       "%OM", "%OS", "%Ou", "%OU", "%OV", "%Ow", "%OW", "%Oy"         

     };*/

     cout<<"";

 #if  STDCPP_OOM

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

   #endif 

      const std::time_put<char> &tput =

         std::use_facet<std::time_put<char> >(std::cout.getloc ());

 #if  STDCPP_OOM

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

   #endif 

 //return KErrNone;

  }

  catch(bad_alloc&)

    {

    	//do nothing

     }

    catch(...)

    {

    	failures++;

    }

 		  if(failures  )

 		  return KErrGeneral;

 		  return KErrNone;

     }

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

 // Ctlocale::messages

 // messages  test method function.

 //  

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

 // 

 TInt Ctlocale::messagesL( CStifItemParser& aItem )

 {

 int failures=0;

 try

 {

       locale loc;

       cout<<"";

 #if  STDCPP_OOM

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

   #endif 

        const messages<char>& mess =use_facet<messages<char> >(loc);

 #if  STDCPP_OOM

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

   #endif 

   // no support to .cat files

       /*  

       string def("Message Not Found");

       messages<char>::catalog cat =

               mess.open("./rwstdmessages.cat",loc);

       if (cat != -1)

        {

         string msg0 = mess.get(cat,1,1,def);

         string msg1 = mess.get(cat,1,2,def);

         string msg2 = mess.get(cat,1,6,def); // invalid msg #

         string msg3 = mess.get(cat,2,1,def);

         mess.close(cat);

         cout << msg0 << endl << msg1 << endl

               << msg2 << endl << msg3 << endl;

        }

       else

         cout << "Unable to open message catalog" << endl;*/

       //return KErrNone;

 }

  catch(bad_alloc&)

    {

    	//do nothing

     }

    catch(...)

    {

    	failures++;

    }

 		  if(failures  )

 		  return KErrGeneral;

 		  return KErrNone;

     }

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

 // Ctlocale::messages_byname

 // messages_byname  test method function.

 //  

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

 // 

 TInt Ctlocale::messagesbyname( CStifItemParser& aItem )

 {

 int failures=0;

 try

 {

  locale loc;

  cout<<"";

 #if  STDCPP_OOM

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

   #endif 

  const messages_byname<char>& mess =

         use_facet<messages_byname<char> >(loc);

 #if  STDCPP_OOM

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

   #endif 

 // no support to .cat files

     /*    

       string def("Message Not Found");

       messages_byname<char>::catalog cat =

               mess.open("./rwstdmessages.cat",loc);

       if (cat != -1)

        {

         string msg0 = mess.get(cat,1,1,def);

         string msg1 = mess.get(cat,1,2,def);

         string msg2 = mess.get(cat,1,6,def); // invalid msg #

         string msg3 = mess.get(cat,2,1,def);

         mess.close(cat);

         cout << msg0 << endl << msg1 << endl

               << msg2 << endl << msg3 << endl;

        }

       else

         cout << "Unable to open message catalog" << endl;*/

       //return KErrNone;	

 }

  catch(bad_alloc&)

    {

    	//do nothing

     }

    catch(...)

    {

    	failures++;

    }

 		  if(failures  )

 		  return KErrGeneral;

 		  return KErrNone;

     }

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

 // Ctlocale::collate

 // collate  test method function.

 //  

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

 // 

 TInt Ctlocale::collateL( CStifItemParser& aItem )

 {

  int failures =0;

  try

  {

  locale loc;

  string s1("blue");

  string s2("blues");

   wstring ws1(L"blue");

  wstring ws2(L"blues");

  cout<<"";

  #if  STDCPP_OOM

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

   #endif 

  const collate<char>& co =

  use_facet<collate<char> >(loc);

   const collate<wchar_t>& w_co =

  use_facet<collate<wchar_t> >(loc);  //wchar

  if( co.compare(s1.begin(),s1.end(),s2.begin(),s2.end()-1) != 0)

  failures++;

  if( co.compare(s1.begin(),s1.end(), s2.begin(),s2.end()) != -1)

  failures++;

  // Retrieve hash values for two strings

  if( co.hash(s1.begin(),s1.end())!= 15636)

  failures++;

  //wchar

  if( w_co.compare(ws1.begin(),ws1.end(),ws2.begin(),ws2.end()-1) != 0)

  failures++;

  if( w_co.compare(ws1.begin(),ws1.end(), ws2.begin(),ws2.end()) != -1)

  failures++;

  // Retrieve hash values for two strings

  if( w_co.hash(ws1.begin(),ws1.end())!= 15636)

  failures++;

    #if  STDCPP_OOM

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

   #endif    

 }

  catch(bad_alloc&)

    {

    	//do nothing

     }

    catch(...)

    {

    	failures++;

    }

 		  if(failures  )

 		  return KErrGeneral;

 		  return KErrNone;

     }

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

 // Ctlocale::collatebyname

 // collatebyname  test method function.

 //  

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

 // 

 TInt Ctlocale::collatebyname( CStifItemParser& aItem )

 {

  int failures =0;

  try

  {

  locale loc;

  string s1("blue");

  string s2("blues");

   wstring ws1(L"blue");

  wstring ws2(L"blues");

  cout<<"";

  #if  STDCPP_OOM

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

   #endif 

  const collate_byname<char>& co = use_facet<collate_byname<char> >(loc);

  const collate_byname<wchar_t>& w_co = use_facet<collate_byname<wchar_t> >(loc);

  if( co.compare(s1.begin(),s1.end(),s2.begin(),s2.end()-1) != 0)

  failures++;

  if( co.compare(s1.begin(),s1.end(),  s2.begin(),s2.end()) != -1)

  failures++;

  // Retrieve hash values for two strings

  if( co.hash(s1.begin(),s1.end())!= 15636)

  failures++;

  //wchar

  if( w_co.compare(ws1.begin(),ws1.end(),ws2.begin(),ws2.end()-1) != 0)

  failures++;

  if( w_co.compare(ws1.begin(),ws1.end(), ws2.begin(),ws2.end()) != -1)

  failures++;

  // Retrieve hash values for two strings

  if( w_co.hash(ws1.begin(),ws1.end())!= 15636)

  failures++;

    #if  STDCPP_OOM

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

   #endif    

 }

  catch(bad_alloc&)

    {

    	//do nothing

     }

    catch(...)

    {

    	failures++;

    }

 		  if(failures  )

 		  return KErrGeneral;

 		  return KErrNone;

     }

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

 // Ctlocale::codecvt1

 // codecvt1  test method function.

 //  

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

 // 

 TInt Ctlocale::codecvt1( CStifItemParser& aItem )

 {

 /*	locale loc ( "de_DE.ISO-8859-15" );

 	int failures=0;

 	try

 	{

 	cout<<"";	

 	#if  STDCPP_OOM

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

   #endif 

     int result = use_facet<codecvt<char, char, mbstate_t> > ( loc ).encoding ();

     if(result != 1)

     failures++;

     char* str = "This is the string whose length is to be measured!";

     mbstate_t state = {0};

     locale loc1("C");//English_Britain");//German_Germany

    //int res = use_facet<codecvt<wchar_t, char, mbstate_t>>( loc ).length( state,str, &str[strlen(str)], 90 );

     int res = use_facet<codecvt<wchar_t, char, mbstate_t> >

      ( loc1 ).length( state,str, &str[strlen(str)], 90 );

     if(res!=50)

     failures++;

      locale loc2( "C");//English_Britain" );//German_Germany

      int res2 = use_facet<codecvt<char, char, mbstate_t> >

      ( loc ).max_length( );

      if(res2!=1)

      failures++;

    #if  STDCPP_OOM

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

   #endif 

 }

  catch(bad_alloc&)

    {

    	//do nothing

     }

    catch(...)

    {

    	failures++;

    }

 		  if(failures  )

 		  return KErrGeneral;*/

 		  return KErrNone;

     }

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

 // Ctlocale::codecvt2

 // codecvt2 test method function.

 //  

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

 // 

 TInt Ctlocale::codecvt2( CStifItemParser& aItem )

 {

 int failures=0;

 try

 {

  char strout[91];

  wchar_t *strin = L"This is the wchar_t string to be converted.";

  memset( &strout[0], 0, ( sizeof( char ) )*( 91 ) );

  char* strnext;

  const wchar_t* pwszNext;

  mbstate_t state;

  locale loc("C"); 

  cout<<"";

  #if  STDCPP_OOM

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

   #endif 

  int res = use_facet<codecvt<wchar_t, char, mbstate_t> >

       ( loc ).out( state,strin, &strin[wcslen( strin )], pwszNext ,

  strout, &strout[wcslen( strin )], strnext );

  #if  STDCPP_OOM

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

   #endif 

  strout[wcslen( strin )] = 0;

   string str = "This is the wchar_t string to be converted.";

 /*if(str.compare(&strout[0]) == 0)

 return KErrNone;

 else

 return KErrGeneral;

 */

 if(str.compare(&strout[0]) != 0)

 failures++;

 }

  catch(bad_alloc&)

    {

    	//do nothing

     }

    catch(...)

    {

    	failures++;

    }

 		  if(failures  )

 		  return KErrGeneral;

 		  return KErrNone;

     }

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

 // Ctlocale::codecvtbyname1

 // codecvtbyname1 test method function.

 //  

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

 // 

 TInt Ctlocale::codecvtbyname1( CStifItemParser& aItem )

 {

 /* locale loc ( "de_DE.ISO-8859-15" );

  int failures=0;

  try

  {

  cout<<"";	

  #if  STDCPP_OOM

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

   #endif 

  int result = use_facet<codecvt_byname<char, char, mbstate_t> > ( loc ).encoding ();

  #if  STDCPP_OOM

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

   #endif 

  if(result != 1)

  failures++;

  char* str = "This is the string whose length is to be measured!";

  mbstate_t state = {0};

  locale loc1("C"); 

   #if  STDCPP_OOM

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

   #endif 

   int res = use_facet<codecvt_byname<wchar_t, char, mbstate_t> >

      ( loc1 ).length( state,str, &str[strlen(str)], 90 );

   #if  STDCPP_OOM

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

   #endif 

   if(res!=50)

   failures++;

  locale loc2( "C"); 

  #if  STDCPP_OOM

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

   #endif 

  int res2 = use_facet<codecvt_byname<char, char, mbstate_t> >( loc ).max_length( );

  #if  STDCPP_OOM

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

   #endif 

  if(res2!=1)

  failures++;

 }

  catch(bad_alloc&)

    {

    	//do nothing

     }

    catch(...)

    {

    	failures++;

    }

 		  if(failures  )

 		  return KErrGeneral;*/

 		  return KErrNone;

     }

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

 // Ctlocale::codecvtbyname2

 // codecvtbyname2 test method function.

 //  

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

 // 

 TInt Ctlocale::codecvtbyname2( CStifItemParser& aItem )

 {

 int failures=0;

 try

 {

  char* strout = "This is the string to be converted!";

  wchar_t strin [91];

  memset(&strin[0], 0, (sizeof(wchar_t))*(91));

  const char* pszNext;

  wchar_t* pwszNext;

  mbstate_t state = {0};

  locale loc("C"); 

  cout<<"";

  #if  STDCPP_OOM

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

   #endif 

  int res = use_facet<codecvt<wchar_t, char, mbstate_t> >

      ( loc ).in( state, strout, &strout[strlen(strout)], pszNext,

           strin, &strin[strlen(strout)], pwszNext );

       #if  STDCPP_OOM

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

   #endif     

  strin[strlen(strout)] = 0;

  wstring str = L"This is the string to be converted!";

 /*

 if(str.compare(&strin[0]) == 0)

 return KErrNone;

 else

 return KErrGeneral;

    */

  if(str.compare(&strin[0]) != 0)

  failures++;

 }

  catch(bad_alloc&)

    {

    	//do nothing

     }

    catch(...)

    {

    	failures++;

    }

 		  if(failures  )

 		  return KErrGeneral;

 		  return KErrNone;

     }

 //cataloge

 TInt Ctlocale::catalog(CStifItemParser& aItem )

     {

     int failures=0;

     try

     {

   // __UHEAP_MARK;

    cout<<"";  

  #if  STDCPP_OOM

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

   #endif 

 // char* p = "c";

 /*  const char* _Loc_ctype_default(p);

    const char* _Loc_numeric_default(p) ;

 	const char* _Loc_time_default(p) ;

    const char* _Loc_collate_default(p) ;

    const char* _Loc_monetary_default(p) ;

    const char* _Loc_messages_default(p) ;*/

 /*    locale::category c;

    //_Locale* L = "k";

    const char* name1 = "catalog";

     const char* name2="test";*/

    const locale& L1= 0;

    const locale& L2= 0;

 //   const char* name = "testing";

   // void _Stl_loc_combine_names(L,name1,name2,c);

    //locale::locale(const locale& L1, const locale& L2, category c)

    //locale::category c;

   //locale loc1(L1,name,c);

   //locale loc(L1,L2,c);

   #if  STDCPP_OOM

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

   #endif 

 //__UHEAP_MARKEND;

 /*

  if(result)

  return KErrNone;

  else

  return KErrGeneral;

  */

     }

  catch(bad_alloc&)

    {

    	//do nothing

     }

    catch(...)

    {

    	failures++;

    }

 		  if(failures  )

 		  return KErrGeneral;

 		  return KErrNone;

     }

     //cataloge

 TInt Ctlocale::c_type(CStifItemParser& aItem )

     {

     int failures=0;

     try

     {

   // __UHEAP_MARK;

    cout<<"";  

  #if  STDCPP_OOM

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

   #endif 

   locale loc1 ( "C" );

    char *string = "Hello, my name is John!";

 //    wchar_t *wstring = L"Hello, my name is John!";

    const char* i = use_facet<ctype<char> > ( loc1 ).scan_is ( ctype_base::punct, &string[0], &string[strlen(&string[0])-1] );

     // const wchar_t* wi = use_facet<ctype<wchar_t> > ( loc1 ).scan_is ( ctype_base::punct, &wstring[0], &wstring[strlen(&wstring[0])-1] );

    const char* j = use_facet<ctype<char> > ( loc1 ).scan_not( ctype_base::alpha, &string[0], &string[strlen(&string[0])-1] );

    if((*i)!= ',')

    failures++;

     if((*j)!= ',')

    failures++;

     //lower

     char string2[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";

     wchar_t wstring2[] = L"ABCDEFGHIJKLMNOPQRSTUVWXYZ";

 char to_lower = 'a';

 wchar_t wto_lower = L'a';

    use_facet<ctype<char> > ( loc1 ).tolower( &string2[0], &string2[strlen(&string2[0])] );

      use_facet<ctype<wchar_t> > ( loc1 ).tolower( &wstring2[0], &wstring2[27] );

    use_facet<ctype<char> > ( loc1 ).tolower(to_lower);

      use_facet<ctype<wchar_t> > ( loc1 ).tolower(wto_lower);

 //upper

     char string3[] = "abcdefghijklmnopqrstuvwxyz";

     wchar_t wstring3[] = L"abcdefghijklmnopqrstuvwxyz";

 char to_upper = 'A';

 wchar_t wto_upper = L'A';

 char str2[16];

 //char test;

    use_facet<ctype<char> > ( loc1 ).toupper( &string3[0], &string3[strlen(&string3[0])] );

      use_facet<ctype<wchar_t> > ( loc1 ).toupper( &wstring3[0], &wstring3[27] );

    use_facet<ctype<char> > ( loc1 ).toupper(to_upper);

      use_facet<ctype<wchar_t> > ( loc1 ).toupper(wto_upper);

  bool result1 = (use_facet<ctype<wchar_t> > ( loc1 ).narrow

       (wstring3, wstring3 + wcslen(wstring3), 'X', &str2[0] ) != 0);

        bool result2 = (use_facet<ctype<char> > ( loc1 ).narrow

       (string3, string3 + strlen(string3), 'X', &str2[0] ) != 0);

       	const ctype_base::mask* _get_classic_table();   

       		const unsigned char*  _get_S_upper_table();

       			const unsigned char*  _get_S_lower_table();

       			void Dummy_API(void); 

      //  ctype::narrow(to_upper,test);

       //char ctype<char>::do_narrow(char __c, char /* dfault */ ) 

   #if  STDCPP_OOM

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

   #endif 

 //__UHEAP_MARKEND;

 /*

  if(result)

  return KErrNone;

  else

  return KErrGeneral;

  */

     }

  catch(bad_alloc&)

    {

    	//do nothing

     }

    catch(...)

    {

    	failures++;

    }

 		  if(failures  )

 		  return KErrGeneral;

 		  return KErrNone;

     }