source/test/perf/charperf/charperf.cpp

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