Delete source/test

source/test/perf/unisetperf/unisetperf.cpp

Index: source/test/perf/unisetperf/unisetperf.cpp
diff --git a/source/test/perf/unisetperf/unisetperf.cpp b/source/test/perf/unisetperf/unisetperf.cpp
deleted file mode 100644
index 7c4d9bf3a1edb3309134467a2ecd94061ec55f0f..0000000000000000000000000000000000000000
--- a/source/test/perf/unisetperf/unisetperf.cpp
+++ /dev/null
@@ -1,440 +0,0 @@
-/*  
-**********************************************************************
-*   Copyright (C) 2014, International Business Machines
-*   Corporation and others.  All Rights Reserved.
-**********************************************************************
-*   file name:  unisetperf.cpp
-*   encoding:   US-ASCII
-*   tab size:   8 (not used)
-*   indentation:4
-*
-*   created on: 2007jan31
-*   created by: Markus Scherer
-*/
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include "unicode/uperf.h"
-#include "unicode/uniset.h"
-#include "unicode/unistr.h"
-#include "uoptions.h"
-#include "cmemory.h" // for UPRV_LENGTHOF
-
-// Command-line options specific to unisetperf.
-// Options do not have abbreviations: Force readable command lines.
-// (Using U+0001 for abbreviation characters.)
-enum {
-    SET_PATTERN,
-    FAST_TYPE,
-    UNISETPERF_OPTIONS_COUNT
-};
-
-static UOption options[UNISETPERF_OPTIONS_COUNT]={
-    UOPTION_DEF("pattern", '\x01', UOPT_REQUIRES_ARG),
-    UOPTION_DEF("type",    '\x01', UOPT_REQUIRES_ARG)
-};
-
-static const char *const unisetperf_usage =
-    "\t--pattern   UnicodeSet pattern for instantiation.\n"
-    "\t            Default: [:ID_Continue:]\n"
-    "\t--type      Type of UnicodeSet: slow fast\n"
-    "\t            Default: slow\n";
-
-// Test object with setup data.
-class UnicodeSetPerformanceTest : public UPerfTest {
-public:
-    UnicodeSetPerformanceTest(int32_t argc, const char *argv[], UErrorCode &status)
-            : UPerfTest(argc, argv, options, UPRV_LENGTHOF(options), unisetperf_usage, status),
-              utf8(NULL), utf8Length(0), countInputCodePoints(0), spanCount(0) {
-        if (U_SUCCESS(status)) {
-            UnicodeString pattern=UnicodeString(options[SET_PATTERN].value, -1, US_INV).unescape();
-            set.applyPattern(pattern, status);
-            prefrozen=set;
-            if(0==strcmp(options[FAST_TYPE].value, "fast")) {
-                set.freeze();
-            }
-
-            int32_t inputLength;
-            UPerfTest::getBuffer(inputLength, status);
-            if(U_SUCCESS(status) && inputLength>0) {
-                countInputCodePoints = u_countChar32(buffer, bufferLen);
-
-                countSpans();
-
-                // Preflight the UTF-8 length and allocate utf8.
-                u_strToUTF8(NULL, 0, &utf8Length, buffer, bufferLen, &status);
-                if(status==U_BUFFER_OVERFLOW_ERROR) {
-                    utf8=(char *)malloc(utf8Length);
-                    if(utf8!=NULL) {
-                        status=U_ZERO_ERROR;
-                        u_strToUTF8(utf8, utf8Length, NULL, buffer, bufferLen, &status);
-                    } else {
-                        status=U_MEMORY_ALLOCATION_ERROR;
-                    }
-                }
-
-                if(verbose) {
-                    printf("code points:%ld  len16:%ld  len8:%ld  spans:%ld  "
-                           "cp/span:%.3g  UChar/span:%.3g  B/span:%.3g  B/cp:%.3g\n",
-                           (long)countInputCodePoints, (long)bufferLen, (long)utf8Length, (long)spanCount,
-                           (double)countInputCodePoints/spanCount, (double)bufferLen/spanCount, (double)utf8Length/spanCount,
-                           (double)utf8Length/countInputCodePoints);
-                }
-            }
-        }
-    }
-
-    virtual UPerfFunction* runIndexedTest(int32_t index, UBool exec, const char* &name, char* par = NULL);
-
-    // Count spans of characters that are in the set,
-    // and spans of characters that are not in the set.
-    // If the very first character is in the set, then one additional
-    // not-span is counted.
-    void countSpans() {
-        const UChar *s=getBuffer();
-        int32_t length=getBufferLen();
-        int32_t i=0;
-        UBool tf=FALSE;
-        while(i<length) {
-            i=span(s, length, i, tf);
-            tf=(UBool)(!tf);
-            ++spanCount;
-        }
-    }
-    int32_t span(const UChar *s, int32_t length, int32_t start, UBool tf) const {
-        UChar32 c;
-        int32_t prev;
-        while((prev=start)<length) {
-            U16_NEXT(s, start, length, c);
-            if(tf!=set.contains(c)) {
-                break;
-            }
-        }
-        return prev;
-    }
-
-    const UChar *getBuffer() const { return buffer; }
-    int32_t getBufferLen() const { return bufferLen; }
-
-    char *utf8;
-    int32_t utf8Length;
-
-    // Number of code points in the input text.
-    int32_t countInputCodePoints;
-    int32_t spanCount;
-
-    UnicodeSet set;
-    UnicodeSet prefrozen;
-};
-
-// Performance test function object.
-class Command : public UPerfFunction {
-protected:
-    Command(const UnicodeSetPerformanceTest &testcase) : testcase(testcase) {}
-
-public:
-    virtual ~Command() {}
-
-    // virtual void call(UErrorCode* pErrorCode) { ... }
-
-    virtual long getOperationsPerIteration() {
-        // Number of code points tested:
-        // Input code points, plus one for the end of each span except the last span.
-        return testcase.countInputCodePoints+testcase.spanCount-1;
-    }
-
-    virtual long getEventsPerIteration() {
-        return testcase.spanCount;
-    }
-
-    const UnicodeSetPerformanceTest &testcase;
-};
-
-class Contains : public Command {
-protected:
-    Contains(const UnicodeSetPerformanceTest &testcase) : Command(testcase) {
-        // Verify that the frozen set is equal to the unfrozen one.
-        UnicodeSet set;
-        UChar32 c;
-
-        for(c=0; c<=0x10ffff; ++c) {
-            if(testcase.set.contains(c)) {
-                set.add(c);
-            }
-        }
-        if(set!=testcase.set) {
-            fprintf(stderr, "error: frozen set != original!\n");
-        }
-    }
-public:
-    static UPerfFunction* get(const UnicodeSetPerformanceTest &testcase) {
-        return new Contains(testcase);
-    }
-    virtual void call(UErrorCode* pErrorCode) {
-        const UnicodeSet &set=testcase.set;
-        const UChar *s=testcase.getBuffer();
-        int32_t length=testcase.getBufferLen();
-        int32_t count=0;
-        int32_t i=0;
-        UBool tf=FALSE;
-        while(i<length) {
-            i+=span(set, s+i, length-i, tf);
-            tf=(UBool)(!tf);
-            ++count;
-        }
-        if(count!=testcase.spanCount) {
-            fprintf(stderr, "error: Contains() count=%ld != %ld=UnicodeSetPerformanceTest.spanCount\n",
-                    (long)count, (long)testcase.spanCount);
-        }
-    }
-    static int32_t span(const UnicodeSet &set, const UChar *s, int32_t length, UBool tf) {
-        UChar32 c;
-        int32_t start=0, prev;
-        while((prev=start)<length) {
-            U16_NEXT(s, start, length, c);
-            if(tf!=set.contains(c)) {
-                break;
-            }
-        }
-        return prev;
-    }
-};
-
-class SpanUTF16 : public Command {
-protected:
-    SpanUTF16(const UnicodeSetPerformanceTest &testcase) : Command(testcase) {
-        // Verify that the frozen set is equal to the unfrozen one.
-        UnicodeSet set;
-        UChar utf16[2];
-        UChar32 c, c2;
-
-        for(c=0; c<=0xffff; ++c) {
-            utf16[0]=(UChar)c;
-            if(testcase.set.span(utf16, 1, USET_SPAN_CONTAINED)>0) {
-                set.add(c);
-            }
-        }
-        for(c=0xd800; c<=0xdbff; ++c) {
-            utf16[0]=(UChar)c;
-            for(c2=0xdc00; c2<=0xdfff; ++c2) {
-                utf16[1]=(UChar)c2;
-                if(testcase.set.span(utf16, 2, USET_SPAN_CONTAINED)>0) {
-                    set.add(U16_GET_SUPPLEMENTARY(c, c2));
-                }
-            }
-        }
-
-        if(set!=testcase.set) {
-            fprintf(stderr, "error: frozen set != original!\n");
-        }
-    }
-public:
-    static UPerfFunction* get(const UnicodeSetPerformanceTest &testcase) {
-        return new SpanUTF16(testcase);
-    }
-    virtual void call(UErrorCode* pErrorCode) {
-        const UnicodeSet &set=testcase.set;
-        const UChar *s=testcase.getBuffer();
-        int32_t length=testcase.getBufferLen();
-        int32_t count=0;
-        int32_t i=0;
-        UBool tf=FALSE;
-        while(i<length) {
-            i+=set.span(s+i, length-i, (USetSpanCondition)tf);
-            tf=(UBool)(!tf);
-            ++count;
-        }
-        if(count!=testcase.spanCount) {
-            fprintf(stderr, "error: SpanUTF16() count=%ld != %ld=UnicodeSetPerformanceTest.spanCount\n",
-                    (long)count, (long)testcase.spanCount);
-        }
-    }
-};
-
-class SpanBackUTF16 : public Command {
-protected:
-    SpanBackUTF16(const UnicodeSetPerformanceTest &testcase) : Command(testcase) {
-        // Verify that the frozen set is equal to the unfrozen one.
-        UnicodeSet set;
-        UChar utf16[2];
-        UChar32 c, c2;
-
-        for(c=0; c<=0xffff; ++c) {
-            utf16[0]=(UChar)c;
-            if(testcase.set.spanBack(utf16, 1, USET_SPAN_CONTAINED)==0) {
-                set.add(c);
-            }
-        }
-        for(c=0xd800; c<=0xdbff; ++c) {
-            utf16[0]=(UChar)c;
-            for(c2=0xdc00; c2<=0xdfff; ++c2) {
-                utf16[1]=(UChar)c2;
-                if(testcase.set.spanBack(utf16, 2, USET_SPAN_CONTAINED)==0) {
-                    set.add(U16_GET_SUPPLEMENTARY(c, c2));
-                }
-            }
-        }
-
-        if(set!=testcase.set) {
-            fprintf(stderr, "error: frozen set != original!\n");
-        }
-    }
-public:
-    static UPerfFunction* get(const UnicodeSetPerformanceTest &testcase) {
-        return new SpanBackUTF16(testcase);
-    }
-    virtual void call(UErrorCode* pErrorCode) {
-        const UnicodeSet &set=testcase.set;
-        const UChar *s=testcase.getBuffer();
-        int32_t length=testcase.getBufferLen();
-        int32_t count=0;
-        /*
-         * Get the same spans as with span() where we always start with a not-contained span.
-         * If testcase.spanCount is an odd number, then the last span() was not-contained.
-         * The last spanBack() must be not-contained to match the first span().
-         */
-        UBool tf=(UBool)((testcase.spanCount&1)==0);
-        while(length>0 || !tf) {
-            length=set.spanBack(s, length, (USetSpanCondition)tf);
-            tf=(UBool)(!tf);
-            ++count;
-        }
-        if(count!=testcase.spanCount) {
-            fprintf(stderr, "error: SpanBackUTF16() count=%ld != %ld=UnicodeSetPerformanceTest.spanCount\n",
-                    (long)count, (long)testcase.spanCount);
-        }
-    }
-};
-
-class SpanUTF8 : public Command {
-protected:
-    SpanUTF8(const UnicodeSetPerformanceTest &testcase) : Command(testcase) {
-        // Verify that the frozen set is equal to the unfrozen one.
-        UnicodeSet set;
-        char utf8[4];
-        UChar32 c;
-        int32_t length;
-
-        for(c=0; c<=0x10ffff; ++c) {
-            if(c==0xd800) {
-                c=0xe000;
-            }
-            length=0;
-            U8_APPEND_UNSAFE(utf8, length, c);
-            if(testcase.set.spanUTF8(utf8, length, USET_SPAN_CONTAINED)>0) {
-                set.add(c);
-            }
-        }
-        if(set!=testcase.set) {
-            fprintf(stderr, "error: frozen set != original!\n");
-        }
-    }
-public:
-    static UPerfFunction* get(const UnicodeSetPerformanceTest &testcase) {
-        return new SpanUTF8(testcase);
-    }
-    virtual void call(UErrorCode* pErrorCode) {
-        const UnicodeSet &set=testcase.set;
-        const char *s=testcase.utf8;
-        int32_t length=testcase.utf8Length;
-        int32_t count=0;
-        int32_t i=0;
-        UBool tf=FALSE;
-        while(i<length) {
-            i+=set.spanUTF8(s+i, length-i, (USetSpanCondition)tf);
-            tf=(UBool)(!tf);
-            ++count;
-        }
-        if(count!=testcase.spanCount) {
-            fprintf(stderr, "error: SpanUTF8() count=%ld != %ld=UnicodeSetPerformanceTest.spanCount\n",
-                    (long)count, (long)testcase.spanCount);
-        }
-    }
-};
-
-class SpanBackUTF8 : public Command {
-protected:
-    SpanBackUTF8(const UnicodeSetPerformanceTest &testcase) : Command(testcase) {
-        // Verify that the frozen set is equal to the unfrozen one.
-        UnicodeSet set;
-        char utf8[4];
-        UChar32 c;
-        int32_t length;
-
-        for(c=0; c<=0x10ffff; ++c) {
-            if(c==0xd800) {
-                c=0xe000;
-            }
-            length=0;
-            U8_APPEND_UNSAFE(utf8, length, c);
-            if(testcase.set.spanBackUTF8(utf8, length, USET_SPAN_CONTAINED)==0) {
-                set.add(c);
-            }
-        }
-        if(set!=testcase.set) {
-            fprintf(stderr, "error: frozen set != original!\n");
-        }
-    }
-public:
-    static UPerfFunction* get(const UnicodeSetPerformanceTest &testcase) {
-        return new SpanBackUTF8(testcase);
-    }
-    virtual void call(UErrorCode* pErrorCode) {
-        const UnicodeSet &set=testcase.set;
-        const char *s=testcase.utf8;
-        int32_t length=testcase.utf8Length;
-        int32_t count=0;
-        /*
-         * Get the same spans as with span() where we always start with a not-contained span.
-         * If testcase.spanCount is an odd number, then the last span() was not-contained.
-         * The last spanBack() must be not-contained to match the first span().
-         */
-        UBool tf=(UBool)((testcase.spanCount&1)==0);
-        while(length>0 || !tf) {
-            length=set.spanBackUTF8(s, length, (USetSpanCondition)tf);
-            tf=(UBool)(!tf);
-            ++count;
-        }
-        if(count!=testcase.spanCount) {
-            fprintf(stderr, "error: SpanBackUTF8() count=%ld != %ld=UnicodeSetPerformanceTest.spanCount\n",
-                    (long)count, (long)testcase.spanCount);
-        }
-    }
-};
-
-UPerfFunction* UnicodeSetPerformanceTest::runIndexedTest(int32_t index, UBool exec, const char* &name, char* par) {
-    switch (index) {
-        case 0: name = "Contains";     if (exec) return Contains::get(*this); break;
-        case 1: name = "SpanUTF16";    if (exec) return SpanUTF16::get(*this); break;
-        case 2: name = "SpanBackUTF16";if (exec) return SpanBackUTF16::get(*this); break;
-        case 3: name = "SpanUTF8";     if (exec) return SpanUTF8::get(*this); break;
-        case 4: name = "SpanBackUTF8"; if (exec) return SpanBackUTF8::get(*this); break;
-        default: name = ""; break;
-    }
-    return NULL;
-}
-
-int main(int argc, const char *argv[])
-{
-    // Default values for command-line options.
-    options[SET_PATTERN].value = "[:ID_Continue:]";
-    options[FAST_TYPE].value = "slow";
-
-    UErrorCode status = U_ZERO_ERROR;
-    UnicodeSetPerformanceTest test(argc, argv, status);
-
-	if (U_FAILURE(status)){
-        printf("The error is %s\n", u_errorName(status));
-        test.usage();
-        return status;
-    }
-        
-    if (test.run() == FALSE){
-        fprintf(stderr, "FAILED: Tests could not be run, please check the "
-			            "arguments.\n");
-        return 1;
-    }
-
-    return 0;
-}