~ubuntu-branches/ubuntu/gutsy/icu/gutsy

static void TestRoundTrippingAllUTF(void);

   addTest(root, &TestRoundTrippingAllUTF, "tsconv/nucnvtst/TestRoundTrippingAllUTF");

        static const UChar unicodeInput[]    = { 0x20ac, 0x0005, 0x0006, 0x000b, 0xdbc4, 0xde34, 0xd84d, 0xdc56, 0x000e};

        static const uint8_t expectedtest4[] = { 0x00, 0x05, 0xff, 0x01, 0x02, 0x03, 0x0b,  0x07,  0x01, 0x02, 0x03, 0x0a,  0xff,};

        static const int32_t totest4Offs[]   = { 0, 1, 2, 3, 3, 3, 3, 4, 6, 6, 6, 6, 8,};

        static const uint8_t test4input[]    = { 0x00, 0x05, 0x06, 0x01, 0x02, 0x03, 0x0b,  0x07,  0x01, 0x02, 0x03, 0x0a, 0x01, 0x02, 0x03, 0x0c,};

        static const UChar expectedUnicode[] = { 0x20ac, 0x0005, 0x0006, 0x000b, 0xdbc4, 0xde34, 0xd84d, 0xdc56, 0xfffd};

        static const int32_t fromtest4Offs[] = { 0, 1, 2, 3, 7, 7, 8, 8, 12,};

static void TestConverterType(const char *convName, UConverterType convType) {

    UConverter* myConverter;

    UErrorCode err = U_ZERO_ERROR;

 

    myConverter = ucnv_open(convName, &err);

    if (U_FAILURE(err)) {

        log_err("Failed to create an %s converter\n", convName);

        return;

    }

    else

    {

        if (ucnv_getType(myConverter)!=convType) {

            log_err("ucnv_getType Failed for %s. Got enum value 0x%X\n",

                convName, convType);

        }

        else {

            log_verbose("ucnv_getType %s ok\n", convName);

        }

    }

    ucnv_close(myConverter);

}

    UConverter* myConverter;

    log_verbose("Testing KSC, ibm-930, ibm-878  for starters and their conversion types.");

    myConverter = ucnv_open("ksc", &err);

        if (ucnv_getType(myConverter)!=UCNV_MBCS)

        if(myConverter!=NULL)

            ucnv_getStarters(myConverter, mystarters, &err);

    ucnv_close(myConverter);

 

    TestConverterType("ibm-930", UCNV_EBCDIC_STATEFUL);

    TestConverterType("ibm-878", UCNV_SBCS);

    TestConverterType("iso-8859-1", UCNV_LATIN_1);

    TestConverterType("ibm-1208", UCNV_UTF8);

    TestConverterType("utf-8", UCNV_UTF8);

    TestConverterType("UTF-16BE", UCNV_UTF16_BigEndian);

    TestConverterType("UTF-16LE", UCNV_UTF16_LittleEndian);

    TestConverterType("UTF-32BE", UCNV_UTF32_BigEndian);

    TestConverterType("UTF-32LE", UCNV_UTF32_LittleEndian);

    TestConverterType("iso-2022", UCNV_ISO_2022);

    TestConverterType("hz", UCNV_HZ);

    TestConverterType("scsu", UCNV_SCSU);

    TestConverterType("x-iscii-de", UCNV_ISCII);

    TestConverterType("ascii", UCNV_US_ASCII);

    TestConverterType("utf-7", UCNV_UTF7);

            if (uSourceLimit < sourceLimit) {

                uSourceLimit = uSourceLimit+1;

            }

            if (cSourceLimit < cBuf + (cTarget - cBuf)) {

                cSourceLimit = cSourceLimit+1;

            }

        0x093d,0x0966,0x0967,0x0968,0x0969,0x096A,0x096B,0x096C,

       /* 0x0958,

        0x0959,

        0x095A,

        0x095B,

        0x095C,

        0x095D,

        0x095E,

        0x095F,*/

        0x0960 /* Vocallic RRI 0xAB, 0xE9*/,

        0x0944 /* Vowel Sign Vocallic RRI 0xDF, 0xE9 */,

        0x090C ,

        0x0962,

        0x0961 /* Vocallic LL 0xa6, 0xE9 */,

        0x0963 /* Vowel Sign Vocallic LL 0xdb, 0xE9, */,

        0x0950 /* OM Symbol 0xa1, 0xE9,*/,

        0x093D /* Avagraha  0xEA, 0xE9*/, 

        0x0958,

        0x0959,

        0x095A,

        0x095B,

        0x095C,

        0x095D,

        0x095E,

        0xEF, 0x42, 0xF0, 0xBF, 0xF0, 0xB8,

 

       

        0xAA, 0xE9,/* RI + NUKTA 0x0960*/

        

        0xDF, 0xE9,/* Vowel sign RI + NUKTA 0x0944*/

        

        0xa6, 0xE9,/* Vowel I + NUKTA 0x090C*/

        

        0xdb, 0xE9,/* Vowel sign I + Nukta 0x0962*/

        

        0xa7, 0xE9,/* Vowel II + NUKTA 0x0961*/

        

        0xdc, 0xE9,/* Vowel sign II + Nukta 0x0963*/

        

        0xa1, 0xE9,/* chandrabindu + Nukta 0x0950*/

        

        0xEA, 0xE9, /* Danda + Nukta 0x093D*/

        

        0xB3, 0xE9, /* Ka + NUKTA */

        

        0xB4, 0xE9, /* Kha + NUKTA */

        

        0xB5, 0xE9, /* Ga + NUKTA */

 

        0xBA, 0xE9,

 

        0xBF, 0xE9,

        

        0xC0, 0xE9,

 

        0xC9, 0xE9,

 

    int32_t uBufSize = 120*10;

    int32_t* offsets = (int32_t*) malloc(uBufSize * sizeof(int32_t) );

    uBuf =  (UChar*)malloc(uBufSize * sizeof(UChar));

    cBuf =(char*)malloc(uBufSize * sizeof(char));

    cTargetLimit = cBuf +uBufSize;

    uTargetLimit = uBuf+ uBufSize;

    /*log_verbose("length of compressed string for language %s using %s:%i \n",conv,lang,(cTarget-cBuf));*/

            log_err("for codeapge %s : Expected : \\u%04X \t Got: \\u%04X\n",conv,*uSource,(int)*test) ;

static UChar

_charAt(int32_t offset, void *context) {

    return ((char*)context)[offset];

}

 

static int32_t

unescape(UChar* dst, int32_t dstLen,const char* src,int32_t srcLen,UErrorCode *status){

    int32_t srcIndex=0;

    int32_t dstIndex=0;

    if(U_FAILURE(*status)){

        return 0;

    }

    if((dst==NULL && dstLen>0) || (src==NULL ) || dstLen < -1 || srcLen <-1 ){

        *status = U_ILLEGAL_ARGUMENT_ERROR;

        return 0;

    }

    if(srcLen==-1){

        srcLen = uprv_strlen(src);

    }

 

    for (; srcIndex<srcLen; ) {

        UChar32 c = src[srcIndex++];

        if (c == 0x005C /*'\\'*/) {

            c = u_unescapeAt(_charAt,&srcIndex,srcLen,(void*)src); /* advances i*/

            if (c == (UChar32)0xFFFFFFFF) {

                *status=U_INVALID_CHAR_FOUND; /* return empty string */

                break; /* invalid escape sequence */

            }

        }

        if(dstIndex < dstLen){

            if(c>0xFFFF){

               dst[dstIndex++] = UTF16_LEAD(c);

               if(dstIndex<dstLen){

                    dst[dstIndex]=UTF16_TRAIL(c);

               }else{

                   *status=U_BUFFER_OVERFLOW_ERROR;

               }

            }else{

                dst[dstIndex]=(UChar)c;

            }

 

        }else{

            *status = U_BUFFER_OVERFLOW_ERROR;

        }

        dstIndex++; /* for preflighting */

    }

    return dstIndex;

}

 

static void

TestFullRoundtrip(const char* cp){

    UChar usource[10] ={0};

    UChar nsrc[10] = {0};

    uint32_t i=1;

    int len=0;

    nsrc[0]=0x0061;

    /* Test codepoint 0 */

    TestConv(usource,1,cp,"",NULL,0);

    TestConv(usource,2,cp,"",NULL,0);

    nsrc[2]=0x5555;

    TestConv(nsrc,3,cp,"",NULL,0);

 

    for(;i<=0x10FFFF;i++){

        if(i>=0xD800 && i<=0xDFFF){

            continue;

        }

        if(i<=0xFFFF){

            usource[0] =(UChar) i;

            len=1;

        }else{

            usource[0]=UTF16_LEAD(i);

            usource[1]=UTF16_TRAIL(i);

            len=2;

        }

        /* Test only single code points */

        TestConv(usource,u_strlen(usource),cp,"",NULL,0);

        /* Test codepoint repeated twice */

        u_strncat(usource,usource,len);

        TestConv(usource,u_strlen(usource),cp,"",NULL,0);

        /* Test codepoint repeated 3 times */

        u_strncat(usource,usource,len);

        TestConv(usource,u_strlen(usource),cp,"",NULL,0);

        /* Test codepoint in between 2 codepoints */

        nsrc[1]=0;

        u_strncat(nsrc,usource,len);

        nsrc[len+1]=0x5555;

        TestConv(nsrc,len+2,cp,"",NULL,0);        

        uprv_memset(usource,0,sizeof(UChar)*10);

    }

}

 

static void

TestRoundTrippingAllUTF(void){

    if(!QUICK){

        log_verbose("Running exhaustive round trip test for SCSU\n");

        TestFullRoundtrip("SCSU");

        log_verbose("Running exhaustive round trip test for UTF-8\n");

        TestFullRoundtrip("UTF-8");

        log_verbose("Running exhaustive round trip test for UTF-16BE\n");

        TestFullRoundtrip("UTF-16BE");

        log_verbose("Running exhaustive round trip test for UTF-16LE\n");

        TestFullRoundtrip("UTF-16LE");

        log_verbose("Running exhaustive round trip test for UTF-32BE\n");

        TestFullRoundtrip("UTF-32BE");

        log_verbose("Running exhaustive round trip test for UTF-32LE\n");

        TestFullRoundtrip("UTF-32LE");

        log_verbose("Running exhaustive round trip test for UTF-7\n");

        TestFullRoundtrip("UTF-7");

        log_verbose("Running exhaustive round trip test for UTF-7\n");

        TestFullRoundtrip("UTF-7,version=1");

        /*#### TODO: Enable this test when BOCU-1 is available */

        /*log_verbose("Running exhaustive round trip test for BOCU-1");*/

        /*TestFullRoundtrip("BOCU-1");*/

        log_verbose("Running exhaustive round trip test for GB18030\n");

        TestFullRoundtrip("GB18030");

    }

}

 

    static const uint16_t germanUTF16[]={

    static const uint8_t germanSCSU[]={

    static const uint16_t russianUTF16[]={

    static const uint8_t russianSCSU[]={

    static const uint16_t japaneseUTF16[]={

    static const uint8_t japaneseSCSU[]={

    static const uint16_t allFeaturesUTF16[]={

    static const uint8_t allFeaturesSCSU[]={

        0xD869, 0xDED5, 0xD800, 0xDC00, 0xD800, 0xDC00, 0xD800, 0xDC00, 0xDBFF, 0xDFFF,

        0xDBFF, 0xDFFF, 0xDBFF, 0xDFFF,

 

    static const char *fTestCases [] = {

          "\\ud800\\udc00", /* smallest surrogate*/

          "\\ud8ff\\udcff",

          "\\udBff\\udFff", /* largest surrogate pair*/

          "\\ud834\\udc00",

          "\\U0010FFFF",

          "Hello \\u9292 \\u9192 World!",

          "Hell\\u0429o \\u9292 \\u9192 W\\u00e4rld!",

          "Hell\\u0429o \\u9292 \\u9292W\\u00e4rld!",

  

          "\\u0648\\u06c8", /* catch missing reset*/

          "\\u0648\\u06c8",

  

          "\\u4444\\uE001", /* lowest quotable*/

          "\\u4444\\uf2FF", /* highest quotable*/

          "\\u4444\\uf188\\u4444",

          "\\u4444\\uf188\\uf288",

          "\\u4444\\uf188abc\\u0429\\uf288",

          "\\u9292\\u2222",

          "Hell\\u0429\\u04230o \\u9292 \\u9292W\\u00e4\\u0192rld!",

          "Hell\\u0429o \\u9292 \\u9292W\\u00e4rld!",

          "Hello World!123456",

          "Hello W\\u0081\\u011f\\u0082!", /* Latin 1 run*/

  

          "abc\\u0301\\u0302",  /* uses SQn for u301 u302*/

          "abc\\u4411d",      /* uses SQU*/

          "abc\\u4411\\u4412d",/* uses SCU*/

          "abc\\u0401\\u0402\\u047f\\u00a5\\u0405", /* uses SQn for ua5*/

          "\\u9191\\u9191\\u3041\\u9191\\u3041\\u3041\\u3000", /* SJIS like data*/

          "\\u9292\\u2222",

          "\\u9191\\u9191\\u3041\\u9191\\u3041\\u3041\\u3000",

          "\\u9999\\u3051\\u300c\\u9999\\u9999\\u3060\\u9999\\u3065\\u3065\\u3065\\u300c",

          "\\u3000\\u266a\\u30ea\\u30f3\\u30b4\\u53ef\\u611b\\u3044\\u3084\\u53ef\\u611b\\u3044\\u3084\\u30ea\\u30f3\\u30b4\\u3002",

  

          "", /* empty input*/

          "\\u0000", /* smallest BMP character*/

          "\\uFFFF", /* largest BMP character*/

  

          /* regression tests*/

          "\\u6441\\ub413\\ua733\\uf8fe\\ueedb\\u587f\\u195f\\u4899\\uf23d\\u49fd\\u0aac\\u5792\\ufc22\\ufc3c\\ufc46\\u00aa",

          "\\u00df\\u01df\\uf000\\udbff\\udfff\\u000d\n\\u0041\\u00df\\u0401\\u015f\\u00df\\u01df\\uf000\\udbff\\udfff",

          "\\u30f9\\u8321\\u05e5\\u181c\\ud72b\\u2019\\u99c9\\u2f2f\\uc10c\\u82e1\\u2c4d\\u1ebc\\u6013\\u66dc\\ubbde\\u94a5\\u4726\\u74af\\u3083\\u55b9\\u000c",

          "\\u0041\\u00df\\u0401\\u015f",

          "\\u9066\\u2123abc",

          "\\ud266\\u43d7\\u\\ue386\\uc9c0\\u4a6b\\u9222\\u901f\\u7410\\ua63f\\u539b\\u9596\\u482e\\u9d47\\ucfe4\\u7b71\\uc280\\uf26a\\u982f\\u862a\\u4edd\\uf513\\ufda6\\u869d\\u2ee0\\ua216\\u3ff6\\u3c70\\u89c0\\u9576\\ud5ec\\ubfda\\u6cca\\u5bb3\\ubcea\\u554c\\u914e\\ufa4a\\uede3\\u2990\\ud2f5\\u2729\\u5141\\u0f26\\uccd8\\u5413\\ud196\\ubbe2\\u51b9\\u9b48\\u0dc8\\u2195\\u21a2\\u21e9\\u00e4\\u9d92\\u0bc0\\u06c5",

          "\\uf95b\\u2458\\u2468\\u0e20\\uf51b\\ue36e\\ubfc1\\u0080\\u02dd\\uf1b5\\u0cf3\\u6059\\u7489",

    };

    int i=0;

    for(;i<sizeof(fTestCases)/sizeof(*fTestCases);i++){

        const char* cSrc = fTestCases[i];

        UErrorCode status = U_ZERO_ERROR;

        int32_t cSrcLen,srcLen;

        UChar* src;

        /* UConverter* cnv = ucnv_open("SCSU",&status); */

        cSrcLen= srcLen =  uprv_strlen(fTestCases[i]);

        src = (UChar*) uprv_malloc((sizeof(UChar) * srcLen) + sizeof(UChar));

        srcLen=unescape(src,srcLen,cSrc,cSrcLen,&status);

        log_verbose("Testing roundtrip for src: %s at index :%d\n",cSrc,i);

        TestConv(src,srcLen,"SCSU","Coverage",NULL,0);

        uprv_free(src);

    }

                                     rules, rules_length, &status);