AuroraMiddleware/scuffed-code
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
f7309c34cf
scuffed-code/icu4c/source/test/perf/DateFmtPerf/DateFmtPerf.h
Andy Heninger 242e02c388 ICU-12764 icu4c utf-8 source files, update Copyright notices. 
X-SVN-Rev: 39583
2017-01-20 00:20:31 +00:00

850 lines
19 KiB
C++
Raw Blame History

/*
***********************************************************************
* © 2016 and later: Unicode, Inc. and others.
* License & terms of use: http://www.unicode.org/copyright.html#License
***********************************************************************
***********************************************************************
* Copyright (c) 2002-2016,International Business Machines
* Corporation and others. All Rights Reserved.
***********************************************************************
***********************************************************************
*/
#ifndef _DATEFMTPERF_H
#define _DATEFMTPERF_H
#include "cmemory.h"
#include "unicode/stringpiece.h"
#include "unicode/unistr.h"
#include "unicode/uperf.h"
#include "unicode/dtitvfmt.h"
#include "unicode/utypes.h"
#include "unicode/datefmt.h"
#include "unicode/calendar.h"
#include "unicode/uclean.h"
#include "unicode/brkiter.h"
#include "unicode/numfmt.h"
#include "unicode/coll.h"
#include "util.h"
#include "datedata.h"
#include "breakdata.h"
#include "collationdata.h"
#include <stdlib.h>
#include <string.h>
#include <fstream>
#include <iostream>
using namespace std;
// Stubs for Windows API functions when building on UNIXes.
//
#if U_PLATFORM_USES_ONLY_WIN32_API
// do nothing
#else
#define _UNICODE
typedef int DWORD;
inline int FoldStringW(DWORD dwMapFlags, const UChar* lpSrcStr,int cchSrc, UChar* lpDestStr,int cchDest);
#endif
class BreakItFunction : public UPerfFunction
{
private:
int num;
bool wordIteration;
public:
BreakItFunction(){num = -1;}
BreakItFunction(int a, bool b){num = a; wordIteration = b;}
virtual void call(UErrorCode * status)
{
BreakIterator* boundary;
if(wordIteration)
{
for(int i = 0; i < num; i++)
{
boundary = BreakIterator::createWordInstance("en", *status);
boundary->setText(str);
int32_t start = boundary->first();
for (int32_t end = boundary->next();
end != BreakIterator::DONE;
start = end, end = boundary->next())
{
printTextRange( *boundary, start, end );
}
}
}
else // character iteration
{
for(int i = 0; i < num; i++)
{
boundary = BreakIterator::createCharacterInstance(Locale::getUS(), *status);
boundary->setText(str);
int32_t start = boundary->first();
for (int32_t end = boundary->next();
end != BreakIterator::DONE;
start = end, end = boundary->next())
{
printTextRange( *boundary, start, end );
}
}
}
}
virtual long getOperationsPerIteration()
{
if(wordIteration) return 125*num;
else return 355*num;
}
void printUnicodeString(const UnicodeString &s) {
char charBuf[1000];
s.extract(0, s.length(), charBuf, sizeof(charBuf)-1, 0);
charBuf[sizeof(charBuf)-1] = 0;
printf("%s", charBuf);
}
void printTextRange( BreakIterator& iterator,
int32_t start, int32_t end )
{
CharacterIterator *strIter = iterator.getText().clone();
UnicodeString s;
strIter->getText(s);
//printUnicodeString(UnicodeString(s, start, end-start));
//puts("");
delete strIter;
}
// Print the given string to stdout (for debugging purposes)
void uprintf(const UnicodeString &str) {
char *buf = 0;
int32_t len = str.length();
int32_t bufLen = len + 16;
int32_t actualLen;
buf = new char[bufLen + 1];
actualLen = str.extract(0, len, buf/*, bufLen*/); // Default codepage conversion
buf[actualLen] = 0;
printf("%s", buf);
delete[] buf;
}
};
class DateFmtFunction : public UPerfFunction
{
private:
int num;
char locale[25];
public:
DateFmtFunction()
{
num = -1;
}
DateFmtFunction(int a, const char* loc)
{
num = a;
strcpy(locale, loc);
}
virtual void call(UErrorCode* status)
{
UErrorCode status2 = U_ZERO_ERROR;
Calendar *cal;
TimeZone *zone;
UnicodeString str;
UDate date;
cal = Calendar::createInstance(status2);
check(status2, "Calendar::createInstance");
zone = TimeZone::createTimeZone("GMT"); // Create a GMT zone
cal->adoptTimeZone(zone);
Locale loc(locale);
DateFormat *fmt;
fmt = DateFormat::createDateTimeInstance(
DateFormat::kShort, DateFormat::kFull, loc);
// (dates are imported from datedata.h)
for(int j = 0; j < num; j++)
for(int i = 0; i < NUM_DATES; i++)
{
cal->clear();
cal->set(years[i], months[i], days[i]);
date = cal->getTime(status2);
check(status2, "Calendar::getTime");
fmt->setCalendar(*cal);
// Format the date
str.remove();
fmt->format(date, str, status2);
// Display the formatted date string
//uprintf(str);
//printf("\n");
}
delete fmt;
delete cal;
//u_cleanup();
}
virtual long getOperationsPerIteration()
{
return NUM_DATES * num;
}
// Print the given string to stdout (for debugging purposes)
void uprintf(const UnicodeString &str) {
char *buf = 0;
int32_t len = str.length();
int32_t bufLen = len + 16;
int32_t actualLen;
buf = new char[bufLen + 1];
actualLen = str.extract(0, len, buf/*, bufLen*/); // Default codepage conversion
buf[actualLen] = 0;
printf("%s", buf);
delete[] buf;
}
// Verify that a UErrorCode is successful; exit(1) if not
void check(UErrorCode& status, const char* msg) {
if (U_FAILURE(status)) {
printf("ERROR: %s (%s)\n", u_errorName(status), msg);
exit(1);
}
}
};
class DateFmtCreateFunction : public UPerfFunction
{
private:
int num;
char locale[25];
public:
DateFmtCreateFunction(int a, const char* loc)
{
num = a;
strcpy(locale, loc);
}
virtual void call(UErrorCode* /* status */)
{
Locale loc(locale);
DateFormat *fmt;
// (dates are imported from datedata.h)
for(int j = 0; j < num; j++) {
fmt = DateFormat::createDateTimeInstance(
DateFormat::kShort, DateFormat::kFull, loc);
delete fmt;
}
}
virtual long getOperationsPerIteration()
{
return num;
}
};
class DateFmtCopyFunction : public UPerfFunction
{
private:
int num;
char locale[25];
public:
DateFmtCopyFunction()
{
num = -1;
}
DateFmtCopyFunction(int a, const char* loc)
{
num = a;
strcpy(locale, loc);
}
virtual void call(UErrorCode* /* status */)
{
Locale loc(locale);
UErrorCode status2 = U_ZERO_ERROR;
DateFormat *fmt = DateFormat::createDateTimeInstance(
DateFormat::kShort, DateFormat::kFull, loc);
for(int j = 0; j < num; j++) {
Format *cp = fmt->clone();
delete cp;
}
delete fmt;
}
virtual long getOperationsPerIteration()
{
return num;
}
// Verify that a UErrorCode is successful; exit(1) if not
void check(UErrorCode& status, const char* msg) {
if (U_FAILURE(status)) {
printf("ERROR: %s (%s)\n", u_errorName(status), msg);
exit(1);
}
}
};
class DIFCreateFunction : public UPerfFunction
{
private:
int num;
char locale[25];
public:
DIFCreateFunction()
{
num = -1;
}
DIFCreateFunction(int a, const char* loc)
{
num = a;
strcpy(locale, loc);
}
virtual void call(UErrorCode* /* status */)
{
UErrorCode status2 = U_ZERO_ERROR;
Calendar *cal;
TimeZone *zone;
cal = Calendar::createInstance(status2);
check(status2, "Calendar::createInstance");
zone = TimeZone::createTimeZone("GMT"); // Create a GMT zone
cal->adoptTimeZone(zone);
Locale loc(locale);
UnicodeString skeleton("yMMMMdHms");
for(int j = 0; j < num; j++) {
DateIntervalFormat* fmt(DateIntervalFormat::createInstance(skeleton, loc, status2));
delete fmt;
}
delete cal;
}
virtual long getOperationsPerIteration()
{
return num;
}
// Verify that a UErrorCode is successful; exit(1) if not
void check(UErrorCode& status, const char* msg) {
if (U_FAILURE(status)) {
printf("ERROR: %s (%s)\n", u_errorName(status), msg);
exit(1);
}
}
};
class TimeZoneCreateFunction : public UPerfFunction
{
private:
int num;
char locale[25];
public:
TimeZoneCreateFunction()
{
num = -1;
}
TimeZoneCreateFunction(int a, const char* loc)
{
num = a;
strcpy(locale, loc);
}
virtual void call(UErrorCode* /* status */)
{
Locale loc(locale);
UnicodeString tzname("UTC");
for(int j = 0; j < num; j++) {
TimeZone* tz(TimeZone::createTimeZone(tzname));
delete tz;
}
}
virtual long getOperationsPerIteration()
{
return num;
}
// Verify that a UErrorCode is successful; exit(1) if not
void check(UErrorCode& status, const char* msg) {
if (U_FAILURE(status)) {
printf("ERROR: %s (%s)\n", u_errorName(status), msg);
exit(1);
}
}
};
class DTPatternGeneratorCreateFunction : public UPerfFunction
{
private:
int num;
char locale[25];
public:
DTPatternGeneratorCreateFunction()
{
num = -1;
}
DTPatternGeneratorCreateFunction(int a, const char* loc)
{
num = a;
strcpy(locale, loc);
}
virtual void call(UErrorCode* /* status */)
{
UErrorCode status2 = U_ZERO_ERROR;
Locale loc(locale);
for(int j = 0; j < num; j++) {
DateTimePatternGenerator* gen(DateTimePatternGenerator::createInstance(loc, status2));
delete gen;
}
}
virtual long getOperationsPerIteration()
{
return num;
}
// Verify that a UErrorCode is successful; exit(1) if not
void check(UErrorCode& status, const char* msg) {
if (U_FAILURE(status)) {
printf("ERROR: %s (%s)\n", u_errorName(status), msg);
exit(1);
}
}
};
class DTPatternGeneratorCopyFunction : public UPerfFunction
{
private:
int num;
char locale[25];
public:
DTPatternGeneratorCopyFunction()
{
num = -1;
}
DTPatternGeneratorCopyFunction(int a, const char* loc)
{
num = a;
strcpy(locale, loc);
}
virtual void call(UErrorCode* /* status */)
{
UErrorCode status2 = U_ZERO_ERROR;
Locale loc(locale);
DateTimePatternGenerator* gen(DateTimePatternGenerator::createInstance(loc, status2));
for(int j = 0; j < num; j++) {
DateTimePatternGenerator *cl = gen->clone();
delete cl;
}
delete gen;
}
virtual long getOperationsPerIteration()
{
return num;
}
// Verify that a UErrorCode is successful; exit(1) if not
void check(UErrorCode& status, const char* msg) {
if (U_FAILURE(status)) {
printf("ERROR: %s (%s)\n", u_errorName(status), msg);
exit(1);
}
}
};
class DTPatternGeneratorBestValueFunction : public UPerfFunction
{
private:
int num;
char locale[25];
public:
DTPatternGeneratorBestValueFunction()
{
num = -1;
}
DTPatternGeneratorBestValueFunction(int a, const char* loc)
{
num = a;
strcpy(locale, loc);
}
virtual void call(UErrorCode* /* status */)
{
UErrorCode status2 = U_ZERO_ERROR;
Locale loc(locale);
DateTimePatternGenerator* gen(DateTimePatternGenerator::createInstance(loc, status2));
UnicodeString skeleton("yMMMMdHms");
for(int j = 0; j < num; j++) {
gen->getBestPattern(skeleton, status2);
}
check(status2, "getBestPattern");
delete gen;
}
virtual long getOperationsPerIteration()
{
return num;
}
// Verify that a UErrorCode is successful; exit(1) if not
void check(UErrorCode& status, const char* msg) {
if (U_FAILURE(status)) {
printf("ERROR: %s (%s)\n", u_errorName(status), msg);
exit(1);
}
}
};
class NumFmtFunction : public UPerfFunction
{
private:
int num;
char locale[25];
public:
NumFmtFunction()
{
num = -1;
}
NumFmtFunction(int a, const char* loc)
{
num = a;
strcpy(locale, loc);
}
virtual void call(UErrorCode* status2)
{
Locale loc(locale);
UErrorCode status = U_ZERO_ERROR;
// Create a number formatter for the locale
NumberFormat *fmt = NumberFormat::createInstance(loc, status);
// Parse a string. The string uses the digits '0' through '9'
// and the decimal separator '.', standard in the US locale
for(int i = 0; i < num; i++)
{
UnicodeString str("9876543210.123");
Formattable result;
fmt->parse(str, result, status);
//uprintf(formattableToString(result));
//printf("\n");
// Take the number parsed above, and use the formatter to
// format it.
str.remove(); // format() will APPEND to this string
fmt->format(result, str, status);
//uprintf(str);
//printf("\n");
}
delete fmt; // Release the storage used by the formatter
}
enum {
U_SPACE=0x20,
U_DQUOTE=0x22,
U_COMMA=0x2c,
U_LEFT_SQUARE_BRACKET=0x5b,
U_BACKSLASH=0x5c,
U_RIGHT_SQUARE_BRACKET=0x5d,
U_SMALL_U=0x75
};
// Create a display string for a formattable
UnicodeString formattableToString(const Formattable& f) {
switch (f.getType()) {
case Formattable::kDate:
// TODO: Finish implementing this
return UNICODE_STRING_SIMPLE("Formattable_DATE_TBD");
case Formattable::kDouble:
{
char buf[256];
sprintf(buf, "%gD", f.getDouble());
return UnicodeString(buf, "");
}
case Formattable::kLong:
case Formattable::kInt64:
{
char buf[256];
sprintf(buf, "%ldL", f.getLong());
return UnicodeString(buf, "");
}
case Formattable::kString:
return UnicodeString((UChar)U_DQUOTE).append(f.getString()).append((UChar)U_DQUOTE);
case Formattable::kArray:
{
int32_t i, count;
const Formattable* array = f.getArray(count);
UnicodeString result((UChar)U_LEFT_SQUARE_BRACKET);
for (i=0; i<count; ++i) {
if (i > 0) {
(result += (UChar)U_COMMA) += (UChar)U_SPACE;
}
result += formattableToString(array[i]);
}
result += (UChar)U_RIGHT_SQUARE_BRACKET;
return result;
}
default:
return UNICODE_STRING_SIMPLE("INVALID_Formattable");
}
}
virtual long getOperationsPerIteration()
{
return num;
}
// Print the given string to stdout using the UTF-8 converter (for debugging purposes only)
void uprintf(const UnicodeString &str) {
char stackBuffer[100];
char *buf = 0;
int32_t bufLen = str.extract(0, 0x7fffffff, stackBuffer, sizeof(stackBuffer), "UTF-8");
if(bufLen < sizeof(stackBuffer)) {
buf = stackBuffer;
} else {
buf = new char[bufLen + 1];
bufLen = str.extract(0, 0x7fffffff, buf, bufLen + 1, "UTF-8");
}
printf("%s", buf);
if(buf != stackBuffer) {
delete[] buf;
}
}
};
#define NUM_STRING "9876543210.123"
#define NUM_NUM 9876543210.123
class StdioNumFmtFunction : public UPerfFunction
{
private:
int num;
char locale[25];
public:
StdioNumFmtFunction()
{
num = -1;
}
StdioNumFmtFunction(int a, const char* loc)
{
num = a;
strcpy(locale, loc);
}
virtual void call(UErrorCode* status2)
{
Locale loc(locale);
UErrorCode status = U_ZERO_ERROR;
// Parse a string. The string uses the digits '0' through '9'
// and the decimal separator '.', standard in the US locale
double result;
char outbuf[500];
const char *str = NUM_STRING;
for(int i = 0; i < num; i++)
{
if(sscanf(str, "%lg", &result)!=1) {
cout << "Failed Stdio: failed to sscanf" << endl;
*status2 = U_PARSE_ERROR;
return;
}
sprintf(outbuf, "%lg", result);
}
if(result!=NUM_NUM) {
cout << "Failed Stdio: sscanf got wrong result, expected " << NUM_NUM << " got " << result << endl;
*status2 = U_PARSE_ERROR;
}
if(strcmp(str,NUM_STRING)) {
cout << "Failed Stdio: sprintf got wrong result, expected " << NUM_STRING << " got " << str << endl;
*status2 = U_PARSE_ERROR;
}
}
virtual long getOperationsPerIteration()
{
return num;
}
};
class CollationFunction : public UPerfFunction
{
private:
int num;
char locale[25];
UnicodeString *collation_strings;
/**
* Unescape the strings
*/
void init() {
uint32_t listSize = UPRV_LENGTHOF(collation_strings_escaped);
collation_strings = new UnicodeString[listSize];
for(uint32_t k=0;k<listSize;k++) {
collation_strings[k] = collation_strings_escaped[k].unescape();
}
UnicodeString shorty((UChar32)0x12345);
}
public:
CollationFunction()
{
num = -1;
init();
}
~CollationFunction() {
delete [] collation_strings;
}
CollationFunction(int a, const char* loc)
{
num = a;
strcpy(locale, loc);
init();
}
virtual void call(UErrorCode* status2)
{
uint32_t listSize = UPRV_LENGTHOF(collation_strings_escaped);
UErrorCode status = U_ZERO_ERROR;
Collator *coll = Collator::createInstance(Locale(locale), status);
for(int k = 0; k < num; k++)
{
uint32_t i, j;
for(i=listSize-1; i>=1; i--) {
for(j=0; j<i; j++) {
if(coll->compare(collation_strings[j], collation_strings[j+1]) == UCOL_LESS) {
//cout << "Success!" << endl;
}
}
}
}
delete coll;
}
virtual long getOperationsPerIteration()
{
return num;
}
};
class DateFormatPerfTest : public UPerfTest
{
private:
public:
DateFormatPerfTest(int32_t argc, const char* argv[], UErrorCode& status);
~DateFormatPerfTest();
virtual UPerfFunction* runIndexedTest(int32_t index, UBool exec,const char* &name, char* par);
UPerfFunction* DateFmt250();
UPerfFunction* DateFmt10000();
UPerfFunction* DateFmt100000();
UPerfFunction* DateFmtCreate250();
UPerfFunction* DateFmtCreate10000();
UPerfFunction* DateFmtCopy250();
UPerfFunction* DateFmtCopy10000();
UPerfFunction* BreakItWord250();
UPerfFunction* BreakItWord10000();
UPerfFunction* BreakItChar250();
UPerfFunction* BreakItChar10000();
UPerfFunction* NumFmt10000();
UPerfFunction* NumFmt100000();
UPerfFunction* Collation10000();
UPerfFunction* Collation100000();
UPerfFunction* DIFCreate250();
UPerfFunction* DIFCreate10000();
UPerfFunction* TimeZoneCreate250();
UPerfFunction* TimeZoneCreate10000();
UPerfFunction* DTPatternGeneratorCreate250();
UPerfFunction* DTPatternGeneratorCreate10000();
UPerfFunction* DTPatternGeneratorCopy250();
UPerfFunction* DTPatternGeneratorCopy10000();
UPerfFunction* DTPatternGeneratorBestValue250();
UPerfFunction* DTPatternGeneratorBestValue10000();
};
#endif // DateFmtPerf
Reference in New Issue View Git Blame Copy Permalink