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