1 /********************************************************************
2 * COPYRIGHT:
3 * Copyright (C) 2002-2006 IBM, Inc. All Rights Reserved.
4 *
5 ********************************************************************/
6 /*****************************************************************************
7 * File charperf.cpp
8 *
9 * Modification History:
10 * Name Description
11 * Syn Wee Quek First Version
12 ******************************************************************************
13 */
14
15 /**
16 * This program tests character properties performance.
17 * APIs tested:
18 * ICU4C
19 * Windows
20 */
21
22 #include "charperf.h"
23 #include "uoptions.h"
24
25 UOption options[] = {
26 UOPTION_DEF("min", 'n', UOPT_REQUIRES_ARG),
27 UOPTION_DEF("min", 'x', UOPT_REQUIRES_ARG),
28 };
29 int MIN_OPTION_ = 0;
30 int MAX_OPTION_ = 1;
31
main(int argc,const char * argv[])32 int main(int argc, const char *argv[])
33 {
34 UErrorCode status = U_ZERO_ERROR;
35 CharPerformanceTest test(argc, argv, status);
36 if (U_FAILURE(status)){
37 return status;
38 }
39 if (test.run() == FALSE){
40 fprintf(stderr, "FAILED: Tests could not be run please check the "
41 "arguments.\n");
42 return -1;
43 }
44 return 0;
45 }
46
CharPerformanceTest(int32_t argc,const char * argv[],UErrorCode & status)47 CharPerformanceTest::CharPerformanceTest(int32_t argc, const char *argv[],
48 UErrorCode &status)
49 : UPerfTest(argc, argv, status)
50 {
51 if (status== U_ILLEGAL_ARGUMENT_ERROR){
52 fprintf(stderr,gUsageString, "charperf");
53 return;
54 }
55 if (U_FAILURE(status)){
56 fprintf(stderr, "FAILED to create UPerfTest object. Error: %s\n",
57 u_errorName(status));
58 return;
59 }
60
61 if (_remainingArgc < 0) {
62 // that means there are some -names not matched in the super class
63 // first tag is always skipped in u_parseArgs
64 int size = - _remainingArgc;
65 argv += argc - size;
66 argc = size;
67 _remainingArgc = u_parseArgs(argc, (char**)argv,
68 (int32_t)(sizeof(options)/sizeof(options[0])), options);
69 }
70 MIN_ = 0;
71 if (sizeof(wchar_t) > 2) {
72 // for stdlibs like glibc that supports 32 bits wchar
73 // we test for the whole unicode character set by default
74 MAX_ = 0x10ffff;
75 }
76 else {
77 MAX_ = 0xffff;
78 }
79 printf("MAX_ size will be 0x%x\n", MAX_);
80 if (options[MIN_OPTION_].doesOccur) {
81 MIN_ = atoi(options[MIN_OPTION_].value);
82 }
83 if (options[MAX_OPTION_].doesOccur) {
84 MAX_ = atoi(options[MAX_OPTION_].value);
85 }
86 }
87
~CharPerformanceTest()88 CharPerformanceTest::~CharPerformanceTest()
89 {
90 }
91
runIndexedTest(int32_t index,UBool exec,const char * & name,char * par)92 UPerfFunction* CharPerformanceTest::runIndexedTest(int32_t index, UBool exec,
93 const char *&name,
94 char* par)
95 {
96 switch (index) {
97 TESTCASE(0, TestIsAlpha);
98 TESTCASE(1, TestIsUpper);
99 TESTCASE(2, TestIsLower);
100 TESTCASE(3, TestIsDigit);
101 TESTCASE(4, TestIsSpace);
102 TESTCASE(5, TestIsAlphaNumeric);
103 TESTCASE(6, TestIsPrint);
104 TESTCASE(7, TestIsControl);
105 TESTCASE(8, TestToLower);
106 TESTCASE(9, TestToUpper);
107 TESTCASE(10, TestIsWhiteSpace);
108 TESTCASE(11, TestStdLibIsAlpha);
109 TESTCASE(12, TestStdLibIsUpper);
110 TESTCASE(13, TestStdLibIsLower);
111 TESTCASE(14, TestStdLibIsDigit);
112 TESTCASE(15, TestStdLibIsSpace);
113 TESTCASE(16, TestStdLibIsAlphaNumeric);
114 TESTCASE(17, TestStdLibIsPrint);
115 TESTCASE(18, TestStdLibIsControl);
116 TESTCASE(19, TestStdLibToLower);
117 TESTCASE(20, TestStdLibToUpper);
118 TESTCASE(21, TestStdLibIsWhiteSpace);
119 default:
120 name = "";
121 return NULL;
122 }
123 return NULL;
124 }
125
TestIsAlpha()126 UPerfFunction* CharPerformanceTest::TestIsAlpha()
127 {
128 return new CharPerfFunction(isAlpha, MIN_, MAX_);
129 }
130
TestIsUpper()131 UPerfFunction* CharPerformanceTest::TestIsUpper()
132 {
133 return new CharPerfFunction(isUpper, MIN_, MAX_);
134 }
135
TestIsLower()136 UPerfFunction* CharPerformanceTest::TestIsLower()
137 {
138 return new CharPerfFunction(isLower, MIN_, MAX_);
139 }
140
TestIsDigit()141 UPerfFunction* CharPerformanceTest::TestIsDigit()
142 {
143 return new CharPerfFunction(isDigit, MIN_, MAX_);
144 }
145
TestIsSpace()146 UPerfFunction* CharPerformanceTest::TestIsSpace()
147 {
148 return new CharPerfFunction(isSpace, MIN_, MAX_);
149 }
150
TestIsAlphaNumeric()151 UPerfFunction* CharPerformanceTest::TestIsAlphaNumeric()
152 {
153 return new CharPerfFunction(isAlphaNumeric, MIN_, MAX_);
154 }
155
156 /**
157 * This test may be different since c lib has a type PUNCT and it is printable.
158 * iswgraph is not used for testing since it is a subset of iswprint with the
159 * exception of returning true for white spaces. no match found in icu4c.
160 */
TestIsPrint()161 UPerfFunction* CharPerformanceTest::TestIsPrint()
162 {
163 return new CharPerfFunction(isPrint, MIN_, MAX_);
164 }
165
TestIsControl()166 UPerfFunction* CharPerformanceTest::TestIsControl()
167 {
168 return new CharPerfFunction(isControl, MIN_, MAX_);
169 }
170
TestToLower()171 UPerfFunction* CharPerformanceTest::TestToLower()
172 {
173 return new CharPerfFunction(toLower, MIN_, MAX_);
174 }
175
TestToUpper()176 UPerfFunction* CharPerformanceTest::TestToUpper()
177 {
178 return new CharPerfFunction(toUpper, MIN_, MAX_);
179 }
180
TestIsWhiteSpace()181 UPerfFunction* CharPerformanceTest::TestIsWhiteSpace()
182 {
183 return new CharPerfFunction(isWhiteSpace, MIN_, MAX_);
184 }
185
TestStdLibIsAlpha()186 UPerfFunction* CharPerformanceTest::TestStdLibIsAlpha()
187 {
188 return new StdLibCharPerfFunction(StdLibIsAlpha, (wchar_t)MIN_,
189 (wchar_t)MAX_);
190 }
191
TestStdLibIsUpper()192 UPerfFunction* CharPerformanceTest::TestStdLibIsUpper()
193 {
194 return new StdLibCharPerfFunction(StdLibIsUpper, (wchar_t)MIN_,
195 (wchar_t)MAX_);
196 }
197
TestStdLibIsLower()198 UPerfFunction* CharPerformanceTest::TestStdLibIsLower()
199 {
200 return new StdLibCharPerfFunction(StdLibIsLower, (wchar_t)MIN_,
201 (wchar_t)MAX_);
202 }
203
TestStdLibIsDigit()204 UPerfFunction* CharPerformanceTest::TestStdLibIsDigit()
205 {
206 return new StdLibCharPerfFunction(StdLibIsDigit, (wchar_t)MIN_,
207 (wchar_t)MAX_);
208 }
209
TestStdLibIsSpace()210 UPerfFunction* CharPerformanceTest::TestStdLibIsSpace()
211 {
212 return new StdLibCharPerfFunction(StdLibIsSpace, (wchar_t)MIN_,
213 (wchar_t)MAX_);
214 }
215
TestStdLibIsAlphaNumeric()216 UPerfFunction* CharPerformanceTest::TestStdLibIsAlphaNumeric()
217 {
218 return new StdLibCharPerfFunction(StdLibIsAlphaNumeric, (wchar_t)MIN_,
219 (wchar_t)MAX_);
220 }
221
222 /**
223 * This test may be different since c lib has a type PUNCT and it is printable.
224 * iswgraph is not used for testing since it is a subset of iswprint with the
225 * exception of returning true for white spaces. no match found in icu4c.
226 */
TestStdLibIsPrint()227 UPerfFunction* CharPerformanceTest::TestStdLibIsPrint()
228 {
229 return new StdLibCharPerfFunction(StdLibIsPrint, (wchar_t)MIN_,
230 (wchar_t)MAX_);
231 }
232
TestStdLibIsControl()233 UPerfFunction* CharPerformanceTest::TestStdLibIsControl()
234 {
235 return new StdLibCharPerfFunction(StdLibIsControl, (wchar_t)MIN_,
236 (wchar_t)MAX_);
237 }
238
TestStdLibToLower()239 UPerfFunction* CharPerformanceTest::TestStdLibToLower()
240 {
241 return new StdLibCharPerfFunction(StdLibToLower, (wchar_t)MIN_,
242 (wchar_t)MAX_);
243 }
244
TestStdLibToUpper()245 UPerfFunction* CharPerformanceTest::TestStdLibToUpper()
246 {
247 return new StdLibCharPerfFunction(StdLibToUpper, (wchar_t)MIN_,
248 (wchar_t)MAX_);
249 }
250
TestStdLibIsWhiteSpace()251 UPerfFunction* CharPerformanceTest::TestStdLibIsWhiteSpace()
252 {
253 return new StdLibCharPerfFunction(StdLibIsWhiteSpace, (wchar_t)MIN_,
254 (wchar_t)MAX_);
255 }
256