ICU 56 update step 1

source/test/perf/DateFmtPerf/DateFmtPerf.h

 /*
 **********************************************************************
-* Copyright (c) 2002-2011,International Business Machines
+* Copyright (c) 2002-2014,International Business Machines
 * Corporation and others.  All Rights Reserved.
 **********************************************************************
 **********************************************************************
 */
 
 #ifndef _DATEFMTPERF_H
 #define _DATEFMTPERF_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"
@@ skipping 22 matching lines @@
 {
 private:
         int num;
         bool wordIteration;
 
 public:
 
         BreakItFunction(){num = -1;}
         BreakItFunction(int a, bool b){num = a; wordIteration = b;}
 
-        virtual void call(UErrorCode *status)
+        virtual void call(UErrorCode * status)
         {               
                 BreakIterator* boundary;
 
                 if(wordIteration)
                 {
                         for(int i = 0; i < num; i++)
                         {
                                 boundary = BreakIterator::createWordInstance("en", *status);
                                 boundary->setText(str);
 
@@ skipping 154 matching lines @@
         // 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()
         {
@@ skipping 246 matching lines @@
 
 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