diff -r e20de85af2ee -r ce057bb09d0b stdcpp/tsrc/BC/apps/widecharclassapiBCTest/src/widecharclassapiBCTestCases.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/stdcpp/tsrc/BC/apps/widecharclassapiBCTest/src/widecharclassapiBCTestCases.cpp Fri Jun 04 16:20:51 2010 +0100 @@ -0,0 +1,694 @@ +/* +* 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 +#include "widecharclassapiBCTest.h" + +#include +#include +#include +#include + + +// 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