/*

 * 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] - do not remove

 #include <e32math.h>

 #include "widecharclassapiBCTest.h"

 #include <stl\_cwchar.h>

 #include <stdio.h>

 #include <time.h>

 #include <stdarg.h>

 // EXTERNAL DATA STRUCTURES

 //extern  ?external_data;

 // EXTERNAL FUNCTION PROTOTYPES  

 //extern ?external_function( ?arg_type,?arg_type );

 // CONSTANTS

 //const ?type ?constant_var = ?constant;

 // MACROS

 //#define ?macro ?macro_def

 // LOCAL CONSTANTS AND MACROS

 //const ?type ?constant_var = ?constant;

 //#define ?macro_name ?macro_def

 // MODULE DATA STRUCTURES

 //enum ?declaration

 //typedef ?declaration

 // LOCAL FUNCTION PROTOTYPES

 //?type ?function_name( ?arg_type, ?arg_type );

 // FORWARD DECLARATIONS

 //class ?FORWARD_CLASSNAME;

 // ============================= LOCAL FUNCTIONS ===============================

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

 // ?function_name ?description.

 // ?description

 // Returns: ?value_1: ?description

 //          ?value_n: ?description_line1

 //                    ?description_line2

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

 //

 /*

 ?type ?function_name(

     ?arg_type arg,  // ?description

     ?arg_type arg)  // ?description

     {

     ?code  // ?comment

     // ?comment

     ?code

     }

 */

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

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

 // CwidecharclassapiBCTest::Case

 // Returns a test case by number.

 //

 // This function contains an array of all available test cases 

 // i.e pair of case name and test function. If case specified by parameter

 // aCaseNumber is found from array, then that item is returned.

 // 

 // The reason for this rather complicated function is to specify all the

 // test cases only in one place. It is not necessary to understand how

 // function pointers to class member functions works when adding new test

 // cases. See function body for instructions how to add new test case.

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

 //

 const TCaseInfo CwidecharclassapiBCTest::Case ( 

     const TInt aCaseNumber ) const 

      {

     /**

     * To add new test cases, implement new test case function and add new 

     * line to KCases array specify the name of the case and the function 

     * doing the test case

     * In practice, do following

     * 1) Make copy of existing test case function and change its name

     *    and functionality. Note that the function must be added to 

     *    widecharclassapiBCTest.cpp file and to widecharclassapiBCTest.h 

     *    header file.

     *

     * 2) Add entry to following KCases array either by using:

     *

     * 2.1: FUNCENTRY or ENTRY macro

     * ENTRY macro takes two parameters: test case name and test case 

     * function name.

     *

     * FUNCENTRY macro takes only test case function name as a parameter and

     * uses that as a test case name and test case function name.

     *

     * Or

     *

     * 2.2: OOM_FUNCENTRY or OOM_ENTRY macro. Note that these macros are used

     * only with OOM (Out-Of-Memory) testing!

     *

     * OOM_ENTRY macro takes five parameters: test case name, test case 

     * function name, TBool which specifies is method supposed to be run using

     * OOM conditions, TInt value for first heap memory allocation failure and 

     * TInt value for last heap memory allocation failure.

     * 

     * OOM_FUNCENTRY macro takes test case function name as a parameter and uses

     * that as a test case name, TBool which specifies is method supposed to be

     * run using OOM conditions, TInt value for first heap memory allocation 

     * failure and TInt value for last heap memory allocation failure. 

     */ 

     static TCaseInfoInternal const KCases[] =

         {

         // [test cases entries] - do not remove

         // NOTE: When compiled to GCCE, there must be Classname::

         // declaration in front of the method name, e.g. 

         // CwidecharclassapiBCTest::PrintTest. Otherwise the compiler

         // gives errors.

         ENTRY( "Arithmetic Functions test", CwidecharclassapiBCTest::ArithmeticTest ),

         ENTRY( "File Manipulation test", CwidecharclassapiBCTest::FileManipulationTest ),

         ENTRY( "Console Operations test", CwidecharclassapiBCTest::ConsoleOperationsTest ),

         ENTRY( "String Operations test", CwidecharclassapiBCTest::StringOperationsTest ),

         ENTRY( "Conversion Operations test", CwidecharclassapiBCTest::ConversionOperationsTest ),

         // Example how to use OOM functionality

         //OOM_ENTRY( "Loop test with OOM", CwidecharclassapiBCTest::LoopTest, ETrue, 2, 3),

         //OOM_FUNCENTRY( CwidecharclassapiBCTest::PrintTest, ETrue, 1, 3 ),

         };

     // Verify that case number is valid

     if( (TUint) aCaseNumber >= sizeof( KCases ) / 

                                sizeof( TCaseInfoInternal ) )

         {

         // Invalid case, construct empty object

         TCaseInfo null( (const TText*) L"" );

         null.iMethod = NULL;

         null.iIsOOMTest = EFalse;

         null.iFirstMemoryAllocation = 0;

         null.iLastMemoryAllocation = 0;

         return null;

         } 

     // Construct TCaseInfo object and return it

     TCaseInfo tmp ( KCases[ aCaseNumber ].iCaseName );

     tmp.iMethod = KCases[ aCaseNumber ].iMethod;

     tmp.iIsOOMTest = KCases[ aCaseNumber ].iIsOOMTest;

     tmp.iFirstMemoryAllocation = KCases[ aCaseNumber ].iFirstMemoryAllocation;

     tmp.iLastMemoryAllocation = KCases[ aCaseNumber ].iLastMemoryAllocation;

     return tmp;

     }

 int WriteVarPrintfConsole (char *format, ...)

 {

   int result;

   va_list args;

   va_start (args, format);

   result = std::vwprintf (L"%d", args);

   va_end (args);

   return result;

 }

 int WriteVarPrintfFile (FILE * stream, char * format, ...)

 {

   int result;

   va_list args;

   va_start (args, format);

   result = std::vfwprintf (stream, L"%d", args);

   va_end (args);

   return result;

 }

 int WriteVarPrintfString (wchar_t * outputBuf, int sizeBuf, char * format, ...)

 {

   int result;

   va_list args;

   va_start (args, format);

   result = std::vswprintf (outputBuf, sizeBuf, L"%d", args);

   va_end (args);

   return result;

 }

 TInt CwidecharclassapiBCTest::FileManipulationTest( TTestResult& aResult )

     {

   		int testError = 0;

 __UHEAP_MARK;

 		const  wchar_t *wsList = L"This is Wide Character Class API test.";

 		const  wchar_t *wPrintfTestFormat = L"%d";

 		wchar_t wsListRead[64];

 		wchar_t wPrintfTestReadList[64];

 		std::wint_t wc = 88;

 		int c = 65;

 		char fileName[]="c:\\data\\others\\widechartest.txt";

 		remove(fileName);

 		FILE *fp = NULL;

 		/* opening the output file */

 		fp = fopen(fileName,"w");

 		if(fp == NULL)

 		{

 		   testError++;

 		}

 //Test std::fwide

 		int fileOrientation ;

 		fileOrientation = std::fwide(fp, 0);

 //Test std::fwprintf

 		int fWritePrResult = std::fwprintf(fp, wPrintfTestFormat, c);

 		if(fWritePrResult < 0)

 			testError++;

 //Test std::vfwprintf

 		int fWriteVPrResult = WriteVarPrintfFile(fp, "%d", c);

 		if(fWriteVPrResult < 0)

 			testError++;

 //Test std::fputwc		 

 		std::wint_t fWriteWCResult = std::fputwc(wc,fp);

 		if(fWriteWCResult == WEOF)

 			testError++;

 //Test std::fputws		 

 		int fWriteWSResult = std::fputws(wsList, fp);

 		if(fWriteWSResult < 0)

 			testError++;

 		fclose(fp);

 		int wsListLength = std::wcslen(wsList);

 		int wPrintTestListLength = std::wcslen(wPrintfTestFormat);

 		/* opening the input file */

 		fp = fopen(fileName,"r");

 		if(fp == NULL)

 		{

 		   testError++;

 		}

 //Test std::fwscanf

 		int inpC;

 		int fReadPrResult = std::fwscanf(fp, wPrintfTestFormat, &inpC);

 		if(fReadPrResult < 0)

 			testError++;

 		fReadPrResult = std::fwscanf(fp, wPrintfTestFormat, &inpC);

 		if(fReadPrResult < 0)

 			testError++;

 //Test std::fputwc		 

 		std::wint_t fReadWCResult = std::fgetwc(fp);

 		if(fReadWCResult == WEOF)

 			testError++;

 //Test std::fgetws		 

 		wchar_t * ptrReadWSResult = std::fgetws(wsListRead, wsListLength, fp);

 		if(ptrReadWSResult == 0)

 			testError++;

 		fclose(fp);

 		remove(fileName);

     // Test case passed

 __UHEAP_MARKEND;

     // Sets test case result and description(Maximum size is KStifMaxResultDes)

 	if(testError)

 	{

  	   _LIT( KDescriptionErr, "FileManipulationTest failed" );

  	   aResult.SetResult( KErrGeneral, KDescriptionErr );

  	   // Case was executed

 	    return testError;

 	}

     // Case was executed

     return KErrNone;

     }

 TInt CwidecharclassapiBCTest::ConsoleOperationsTest( TTestResult& aResult )

     {

   		int testError = 0;

 __UHEAP_MARK;

   		freopen("c:\\data\\others\\myconsole.txt", "w", stdout);

 //Test std::putwc 		

   		wchar_t * consoleMessage = L"Enter Character 'v' ";

 		fputws(consoleMessage, stdout);

 		wint_t putWCResult = std::putwc(L':', stdout);

 //Test std::vwprintf

 		int c=89;

 		int fWriteVPrResult = WriteVarPrintfConsole("%d", c);

 		if(fWriteVPrResult < 0)

 			testError++;

 		ungetwc(L'v', stdin);

 //Test std::getwc		

 		wint_t getWCResult;

 		getWCResult = std::getwc(stdin);

 		ungetwc(L'v', stdin);

 		getWCResult = std::getwchar();

 		fclose(stdout);

 		fclose(stderr);

 		fclose(stdin);

     // Test case passed

 __UHEAP_MARKEND;

     // Sets test case result and description(Maximum size is KStifMaxResultDes)

 	if(testError)

 	{

  	   // Case was executed

 	    return testError;

 	}

     // Case was executed

     return KErrNone;

     }

 TInt CwidecharclassapiBCTest::StringOperationsTest( TTestResult& aResult )

     {

   		int testError = 0;

 __UHEAP_MARK;

 //Test std::wcscat  		

 		wchar_t wcSRC[64] = L"Wide character";

 		wchar_t wcDST[64] = L"Class API";

 		wchar_t *wcWCSCATResult= std::wcscat(wcDST, (const wchar_t*)wcSRC);

 //Test std::wcsncat		

 		wchar_t *wcWCSNCATResult= std::wcsncat(wcDST, (const wchar_t*)wcSRC, 4);

 		wchar_t *wcSTR = L"Wide Character Class API";

 		wchar_t wcSearch = L'A';

 //Test std::wcschr

 		wchar_t* wcWCSCHRResult = std::wcschr(wcSTR, wcSearch);

 //Test std::wcsrchr

 		wchar_t* wcWCSRCHRResult = std::wcsrchr(wcSTR, wcSearch);

 //Test std::wmemchr

 		wchar_t* wcWMEMCHRResult = std::wmemchr(wcSTR, wcSearch, 4);

 //Test std::wcscmp

 		wchar_t *wcS1 = L"ABCDE";

 		wchar_t *wcS2 = L"ACCD";

 		int intWCSCMPResult = std::wcscmp(wcS1, wcS2);

 //Test std::wcsncmp

 		int intWCSNCMPResult = std::wcsncmp(wcS1, wcS2, 4);

 //Test std::wcscoll

 		int intWCSCOLLResult = std::wcscoll(wcS1, wcS2);

 //Test std::wmemcmp

 		int intWMEMCMPResult = std::wmemcmp(wcS1, wcS2, 4);

 //Test std::wcscpy

 		wchar_t wcSRC1[64] = L"Wide character";

 		wchar_t wcDST1[64] = L"Class API";

 		wchar_t *wcWCSCPYResult = std::wcscpy(wcDST1, wcSRC1);

 //Test std::wcsncpy

 		wchar_t *wcWCSNCPYResult = std::wcsncpy(wcDST1, wcSRC1, 4);

 //Test std::wmemcpy

 		wchar_t *wcWMEMCPYResult = std::wmemcpy(wcDST1, wcSRC1, 4);

 //Test std::wmemmove

 		wchar_t *wcWMEMMOVEResult = std::wmemmove(wcDST1, wcSRC1, 4);

 //Test std::wmemset

 		wchar_t *wcWMEMSETResult = std::wmemset(wcDST1, L'V', 4);

 //Test std::wcsxfrm

 		size_t lenWCSXFRMResult = std::wcsxfrm(wcDST1, wcSRC1, 15);

 //Test std::wcscspn

  		const wchar_t wcSTR1[30] = L"1234567890ABCDE!@#$$";

   		const wchar_t wcSpanset[20] = L"ABCDE!@#$$";

 		size_t intWCSCSPNResult = std::wcscspn(wcSTR1, wcSpanset);

 //Test std::wcsspn	

 		size_t intWCSSPNResult = std::wcsspn(wcSTR1, wcSpanset);

 //Test std::wcspbrk	

 		wchar_t * wcptrWCSSPNResult = std::wcspbrk(wcSTR1, wcSpanset);

 //Test std::wcsftime	

 		time_t rawtime;

   		struct tm * timeinfo;

   		wchar_t wcTimeOutput [80];

   		time ( &rawtime );

   		timeinfo = localtime ( &rawtime );

   		size_t lenString = std::wcsftime (wcTimeOutput,80,L"Now is %I:%M%p.",timeinfo);

 //Test std::wcslen	

 		size_t lenSTR = std::wcslen(wcSTR);

 //Test std::wcsstr	

 		wchar_t wcSTR2[64] = L"Wide character Class API";

 		wchar_t wcSUBSTR[64] = L"Class API";

 		wchar_t* wcptrWCSSTR = std::wcsstr(wcSTR2, wcSUBSTR);

 		wchar_t wcSTRDest[64];

 //Test std::swprintf	

 		wchar_t *formatSTR = L"%d";

 		int intSampleOutput = 78;

 		int returnPrintf = std::swprintf(wcSTRDest, 63, formatSTR, intSampleOutput);

 //Test std::swscanf	

 		int intSampleInput;

 		int returnScanf = std::swscanf(wcSTRDest, formatSTR, &intSampleInput);

 //Test std::vswprintf

 		wchar_t outputSTR[32];

 		int c = 76;

 		int fWriteVPrResult = WriteVarPrintfString(outputSTR, 32, "%d", c);

 		if(fWriteVPrResult < 0)

 			testError++;

     // Test case passed

 __UHEAP_MARKEND;

     // Sets test case result and description(Maximum size is KStifMaxResultDes)

 	if(testError)

 	{

  	   // Case was executed

 	    return testError;

 	}

     // Case was executed

     return KErrNone;

     }

 TInt CwidecharclassapiBCTest::ConversionOperationsTest( TTestResult& aResult )

     {

   		int testError = 0;

 //__UHEAP_MARK;

  		size_t len;

 		char *szMBTest = "this is test";

 		mbstate_t mbs;

 		mbstate_t ps;

 //Test std::btowc

 		int c = 65;

 		std::wint_t wc;

  		/* converting single byte to wide-character */

  		wc = std::btowc(c);

 //Test std::wcstod

 		 wchar_t wcs1[21] = L"  1.23abcd";

 		 wchar_t wcs2[5]=L"abcd";

 		 wchar_t *eptr;

 		 float d;

 		 /* convert wide-char string to double */  

 		 d = std::wcstod(wcs1, &eptr);

 		 /* compare the result */

 		 if(!((d == 1.23F) && !(std::wcscmp (eptr, wcs2))))

 		   testError++;

 //Test std::wcstol

 		 wchar_t wcs3[8]=L".23abcd";

 		 long longintOutput;

 		 /* convert wide-char string to long int */  

 		 longintOutput = std::wcstol(wcs1, &eptr, 10);

 		 /* compare the result */

 		 if(!((longintOutput == 1) && !(std::wcscmp (eptr, wcs3))))

 		   testError++;

 //Test std::wcstoul

 		 unsigned long unslongintOutput;

 		 /* convert wide-char string to long int */  

 		 unslongintOutput = std::wcstoul(wcs1, &eptr, 10);

 		 /* compare the result */

 		 if(!((unslongintOutput == 1) && !(std::wcscmp (eptr, wcs3))))

 		   testError++;

 //Test std::wcstok

 		 const wchar_t *seps = L":";

 		 wchar_t *last, *tok, text[] = L"one:twothree";

 		 tok = std::wcstok(text, seps, &last);

 		 if(!tok)

 		   testError++;

 //Test std::mbsrtowcs

 		wchar_t wideCharStringOutput[64];

 		len = std::mbsrtowcs(wideCharStringOutput, (const char**)&szMBTest, 10, &ps);

 		/* checking for error */

 		if(len < 0)

 		{

 			testError++;

 		}

 //Test std::wcsrtombs

 		char mbOutputString[64];

 		wchar_t *wcptrString = wideCharStringOutput;

 		size_t lenWCS = std::wcsrtombs(mbOutputString, (const wchar_t**) &wcptrString, len, &ps);

 //Test std::wcrtomb

 		wchar_t wcWCRTOMB = L'v';

 		char mbWCRTOMB[10];

 		len = std::wcrtomb(mbWCRTOMB, wcWCRTOMB, &ps);

     // Test case passed

 __UHEAP_MARKEND ;

     // Sets test case result and description(Maximum size is KStifMaxResultDes)

 	if(testError)

 	{

 	    return testError;

 	}

     // Case was executed

     return KErrNone;

     }

 TInt CwidecharclassapiBCTest::ArithmeticTest( TTestResult& aResult )

     {

   		int testError = 0;

 __UHEAP_MARK;

 //Test std::mbrlen

 		char *szMBTest = "this is test";

 		int aa = 2;

 		mbstate_t mbs;

 		memset(&mbs, 0, sizeof(mbs));

 //		size_t charlen = std::mbrlen(szMBTest, 6, &mbs); 

 		size_t charlen = std::mbrlen((const char*)&aa, 6, &mbs); 

 //Test std::mbrtowc

 		size_t len;

 		wchar_t wcMBCOutput[100];

 		char *s = "a";

 		size_t n = 1;

 		mbstate_t ps;

 		/* converting multibyte sequence to a wide-char sequence */

 		len = std::mbrtowc(wcMBCOutput,(const char *) s, n, &ps);

 		/* checking for error value */

 		if(len < 0)

 		{

 			testError++;

 		}

 //Test std::mbsinit

 		int mbINITOutput = std::mbsinit((const mbstate_t*) &ps);

     // Test case passed

     // Sets test case result and description(Maximum size is KStifMaxResultDes)

 	if(testError)

 	{

  	   _LIT( KDescriptionErr, "ArithmeticTest failed" );

  	   aResult.SetResult( KErrGeneral, KDescriptionErr );

  	   // Case was executed

 	    return testError;

 	}

     _LIT( KDescription, "LoopTest passed" );

     aResult.SetResult( KErrNone, KDescription );

 __UHEAP_MARK;

 // Case was executed

     return KErrNone;

     }

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

 // ?classname::?member_function

 // ?implementation_description

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

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

 //

 /*

 ?type ?classname::?member_function(

    ?arg_type arg,

    ?arg_type arg )

    {

    ?code

    }

 */

 // ========================== OTHER EXPORTED FUNCTIONS =========================

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

 // ?function_name implements...

 // ?implementation_description.

 // Returns: ?value_1: ?description

 //          ?value_n: ?description

 //                    ?description

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

 //

 /*

 ?type  ?function_name(

     ?arg_type arg,  // ?description

     ?arg_type arg )  // ?description

     {

     ?code

     }

 */

 //  [End of File] - do not remove