home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 6 / AACD06.ISO / AACD / Programming / ICU / src / icu / source / test / cintltst / ccapitst.c < prev    next >
Encoding:
C/C++ Source or Header  |  1999-10-19  |  21.9 KB  |  689 lines
  1. /*
  2. *****************************************************************************************
  3. *                                                                                       *
  4. * COPYRIGHT:                                                                            *
  5. *   (C) Copyright Taligent, Inc.,  1996                                                 *
  6. *   (C) Copyright International Business Machines Corporation,  1999                    *
  7. *   Licensed Material - Program-Property of IBM - All Rights Reserved.                  *
  8. *   US Government Users Restricted Rights - Use, duplication, or disclosure             *
  9. *   restricted by GSA ADP Schedule Contract with IBM Corp.                              *
  10. *                                                                                       *
  11. *****************************************************************************************
  12. ********************************************************************************
  13. *
  14. * File CU_CAPITST.C
  15. *
  16. * Modification History:
  17. *        Name                      Description            
  18. *     Madhu Katragadda              Ported for C API
  19. *********************************************************************************
  20. */
  21. #include <stdio.h>
  22. #include <stdlib.h>
  23. #include <string.h>
  24. #include <ctype.h>
  25. #include "ccapitst.h"
  26. #include "uloc.h"
  27. #include "ucnv.h"
  28. #include "ucnv_err.h"
  29. #include "cintltst.h"
  30. #include "utypes.h"
  31. #include "ustring.h"
  32.  
  33. #define NUM_CODEPAGE 1
  34. #define MAX_FILE_LEN 1024*20
  35. #define UCS_FILE_NAME_SIZE 100
  36.  
  37. /*writes and entire UChar* (string) along with a BOM to a file*/
  38. void WriteToFile(const UChar *a, FILE *myfile); 
  39. /*Case insensitive compare*/
  40. int32_t strCaseIcmp(const char* a1,const char * a2); 
  41. /*returns an action other than the one provided*/
  42. UConverterFromUCallback otherUnicodeAction(UConverterFromUCallback MIA);
  43. UConverterToUCallback otherCharAction(UConverterToUCallback MIA);
  44.  
  45.  
  46. void addTestConvert(TestNode** root)
  47. {
  48.     addTest(root, &TestConvert, "tsconv/ccapitst/TestConvert");
  49.  
  50. }
  51.  
  52.  
  53. void TestConvert() 
  54. {
  55.     char                myptr[4];
  56.     char                save[4];
  57.     char                subchar [4]         =   {(char)0xBE, (char)0xEF};
  58.     int32_t             testLong1           =   0;
  59.     int16_t             rest                =   0;
  60.     FILE*               f                   =   NULL;
  61.     FILE*               f2                  =   NULL;
  62.     int32_t             uniLen              =   0;
  63.     int32_t             len                 =   0;
  64.     int32_t             x                   =   0;
  65.     FILE*               ucs_file_in         =   NULL;
  66.     UChar                BOM                 =   0x0000;
  67.     UChar                myUChar           =   0x0000;
  68.     char                myChar              =   0x00;
  69.     char                mytarget[MAX_FILE_LEN];
  70.     char*               mytarget_1=mytarget;
  71.     char*               mytarget_use        = mytarget;
  72.     UChar*                consumedUni         =   NULL;
  73.     char*               consumedChar        =   NULL;
  74.     char*               consumed            =   NULL;
  75.     char                output_cp_buffer    [MAX_FILE_LEN];
  76.     UChar                ucs_file_buffer     [MAX_FILE_LEN];
  77.     UChar*                ucs_file_buffer_use = ucs_file_buffer;
  78.     UChar                my_ucs_file_buffer  [MAX_FILE_LEN];
  79.     UChar*                my_ucs_file_buffer_1=my_ucs_file_buffer;
  80.     int32_t             i                   =   0;
  81.     int8_t                ii                  =   0;
  82.     uint16_t            ij                  =   0;
  83.     int32_t             j                   =   0;
  84.     int32_t             k                   =   0;
  85.     uint16_t            codepage_index      =   0;
  86.     int32_t             cp                  =   0;
  87.     UErrorCode          err                 =   U_ZERO_ERROR;
  88.     const char*            available_conv;  
  89.     char                ucs_file_name[UCS_FILE_NAME_SIZE];
  90.     UConverterFromUCallback          MIA1;
  91.     UConverterToUCallback              MIA2;
  92.     UChar                myUnitarget[MAX_FILE_LEN];
  93.     UChar                *myUnitarget_1 = myUnitarget;
  94.     UConverter*            someConverters[5];
  95.     UConverter*         myConverter = 0;
  96.     UChar*                displayname = 0;
  97.    
  98.     const char* locale;
  99.  
  100.     UChar* uchar1 = 0;
  101.     UChar* uchar2 = 0;
  102.     UChar* uchar3 = 0;
  103.     int32_t targetcapacity2;
  104.     int32_t targetcapacity;
  105.     int32_t targetsize;
  106.     int32_t disnamelen;
  107.  
  108.     const UChar* tmp_ucs_buf;
  109.     const UChar* tmp_consumedUni=NULL;
  110.     const char* tmp_mytarget_use;
  111.     const char* tmp_consumed; 
  112.     
  113.     /******************************************************************
  114.                                 Checking Unicode -> ksc
  115.      ******************************************************************/
  116.  
  117.     const char*      CodePagesToTest[NUM_CODEPAGE]       =
  118.     {
  119.        "IBM-949"
  120.  
  121.         
  122.     }; 
  123.     const uint16_t CodePageNumberToTest[NUM_CODEPAGE]             =
  124.     {
  125.         949
  126.     };
  127.     
  128.  
  129.     const int32_t        CodePagesAsciiControls[NUM_CODEPAGE]    =
  130.     { 
  131.         0xFFFFFFFF
  132.             
  133.     
  134.     };
  135.  
  136.     const int32_t        CodePagesOtherControls[NUM_CODEPAGE]    =
  137.     {
  138.          0x00000005
  139.     };
  140.  
  141.  
  142.     const int8_t     CodePagesMinChars[NUM_CODEPAGE] =
  143.     { 
  144.         1
  145.     
  146.     };
  147.  
  148.     const int8_t     CodePagesMaxChars[NUM_CODEPAGE] =
  149.     { 
  150.         2
  151.     
  152.     };
  153.  
  154.     const int16_t        CodePagesSubstitutionChars[NUM_CODEPAGE]    =
  155.     { 
  156.         (int16_t)0xAFFE
  157.     
  158.     };
  159.  
  160.     const char* CodePagesTestFiles[NUM_CODEPAGE]    =
  161.     { 
  162.       "uni-text.txt"
  163.     };
  164.  
  165.     
  166.     const UConverterPlatform        CodePagesPlatform[NUM_CODEPAGE]    =
  167.     { 
  168.         UCNV_IBM
  169.     
  170.     };
  171.  
  172.     const UConverterToUCallback CodePagesMissingCharAction[NUM_CODEPAGE] =
  173.     {
  174.       UCNV_TO_U_CALLBACK_SUBSTITUTE
  175.     };
  176.     
  177.     const UConverterFromUCallback CodePagesMissingUnicodeAction[NUM_CODEPAGE] =
  178.     {
  179.       UCNV_FROM_U_CALLBACK_SUBSTITUTE
  180.     };
  181.  
  182.     const char* CodePagesLocale[NUM_CODEPAGE] =
  183.     {
  184.         "ko_KR"
  185.     };
  186.  
  187.     UChar CodePagesFlakySequence[NUM_CODEPAGE][20] =
  188.     {
  189.         {(UChar)0xAC10,(UChar)0xAC11, (UChar)0xAC12, (UChar)0xAC13 , (UChar)0xAC14, (UChar)0xAC15, (UChar)0xAC16, (UChar)0xAC17, (UChar)0xd7a4 /*Offensive Codepoint*/, (UChar)0xAC14, (UChar)0xAC15}
  190.     };
  191.     
  192.     char CodePagesFlakyCharSequence[NUM_CODEPAGE][20] =
  193.     {
  194.         {   (char)0xB0, (char)0xA8,
  195.             (char)0xB0, (char)0xA9,
  196.             (char)0xB0, (char)0xAA,
  197.             (char)0xB0, (char)0xAB,
  198.             (char)0xb0, (char)0xff,/*Offensive Codepoint*/
  199.             (char)0xB0, (char)0xAC,
  200.             (char)0xB0, (char)0xAD
  201.         }
  202.     };
  203.  
  204.     /*Calling all the UnicodeConverterCPP API and checking functionality*/
  205.   
  206.         /*Tests ucnv_getAvailableName(), getAvialableCount()*/
  207.         
  208.     log_verbose("Testing ucnv_countAvailable()...");
  209.     
  210.     testLong1=ucnv_countAvailable();
  211.     log_verbose("Number of available Codepages:    %d\n", testLong1);
  212.     
  213.     log_verbose("\n---Testing ucnv_getAvailableName..");  /*need to check this out */
  214.     
  215.     available_conv = ucnv_getAvailableName(testLong1);
  216.     
  217.     
  218.      
  219.     /*Testing ucnv_open()*/
  220.  
  221.     someConverters[0] = ucnv_open("ibm-949", &err);
  222.     if (U_FAILURE(err)) { log_err("FAILURE!  %s\n", myErrorName(err)); }
  223.     
  224.     someConverters[1] = ucnv_open("ibm-949", &err);
  225.     if (U_FAILURE(err)) { log_err("FAILURE!  %s\n", myErrorName(err)); }
  226.     
  227.     someConverters[2] = ucnv_open("ibm-949", &err);
  228.     if (U_FAILURE(err)) { log_err("FAILURE! %s\n", myErrorName(err)); }
  229.     
  230.     someConverters[3] = ucnv_open("ibm-834", &err);
  231.     if (U_FAILURE(err)) { log_err("FAILURE! %s\n", myErrorName(err)); }
  232.     
  233.     someConverters[4] = ucnv_open("ibm-943", &err);
  234.     if (U_FAILURE(err)) { log_err("FAILURE! %s\n", myErrorName(err));}
  235.     
  236.     /* Testing ucnv_flushCache() */
  237.     log_verbose("\n---Testing ucnv_flushCache...\n");
  238.         if (ucnv_flushCache()==0)
  239.         log_verbose("Flush cache ok\n");
  240.     else 
  241.         log_err("Flush Cache failed\n");
  242.     
  243.     /*testing ucnv_close() and ucnv_flushCache() */
  244.      ucnv_close(someConverters[0]);
  245.     ucnv_close(someConverters[1]);
  246.     ucnv_close(someConverters[2]);
  247.     ucnv_close(someConverters[3]);
  248.     
  249.         if (j=ucnv_flushCache()==2) 
  250.         log_verbose("Flush cache ok\n");  /*because first, second and third are same  */
  251.     else 
  252.         log_err("Flush Cache failed or there is an error in ucnv_close()\n");
  253.     
  254.     ucnv_close(someConverters[4]);
  255.     if (ucnv_flushCache()==1) 
  256.         log_verbose("Flush cache ok\n");
  257.     else 
  258.         log_err("Flush Cache failed\n");
  259.  
  260.     
  261.     /* Testing ucnv_openCCSID(), ucnv_open(), ucnv_getName() */
  262.     log_verbose("\n---Testing ucnv_open default...\n");
  263.     someConverters[0] = ucnv_open(NULL,&err);
  264.     someConverters[1] = ucnv_open(NULL,&err);
  265.     someConverters[2] = ucnv_open("utf8", &err);
  266.     someConverters[3] = ucnv_openCCSID(949,UCNV_IBM,&err);
  267.     if (U_FAILURE(err)){ log_err("FAILURE! %s\n", myErrorName(err));}
  268.     
  269.     /* Testing ucnv_getName()*/
  270.     /*default code page */
  271. #ifdef WIN32
  272.     if ((strcmp(ucnv_getName(someConverters[0], &err), "IBM-1252")==0)&&
  273.     (strcmp(ucnv_getName(someConverters[1], &err), "IBM-1252")==0))
  274.       log_verbose("getName ok\n");
  275.     else 
  276.         log_err("getName failed\n");
  277. #else
  278.     if ((strcmp(ucnv_getName(someConverters[0], &err), "LATIN_1")==0)&&
  279.     (strcmp(ucnv_getName(someConverters[1], &err), "LATIN_1")==0))
  280.       log_verbose("getName ok\n");
  281.     else 
  282.         log_err("getName failed\n");
  283. #endif    
  284.   
  285.     /*Testing ucnv_getDefaultName() and ucnv_setDefaultNAme()*/
  286. #ifdef WIN32
  287.     if(strcmp(ucnv_getDefaultName(), "cp1252")==0)
  288.       log_verbose("getDefaultName o.k.\n");
  289.     else
  290.       log_err("getDefaultName failed \n");
  291. #else
  292.     if(strcmp(ucnv_getDefaultName(), "LATIN_1")==0)
  293.       log_verbose("getDefaultName o.k.\n");
  294.     else
  295.       log_err("getDefaultName failed\n");
  296. #endif
  297.    
  298.     /*chnage the default name by setting it */
  299.     ucnv_setDefaultName("changed");
  300.     if(strcmp(ucnv_getDefaultName(), "changed")==0)
  301.       log_verbose("setDefaultName o.k");
  302.     else
  303.       log_err("setDefaultName failed");
  304.     /*set it back to the original name */
  305.     
  306.     ucnv_setDefaultName("LATIN_1");
  307.     
  308.         
  309.  
  310.  
  311.    
  312.     ucnv_close(someConverters[0]);
  313.      ucnv_close(someConverters[1]);
  314.     ucnv_close(someConverters[2]);
  315.     ucnv_close(someConverters[3]);   
  316.     
  317.     
  318.    
  319.     
  320.     for (codepage_index=0; codepage_index <  NUM_CODEPAGE; ++codepage_index)
  321.     {
  322.         i = 0;  
  323.     
  324.     strcpy(ucs_file_name, ctest_getTestDirectory());
  325.     strcat(ucs_file_name, CodePagesTestFiles[codepage_index]);
  326.  
  327.     ucs_file_in = fopen(ucs_file_name,"rb");
  328.         if (!ucs_file_in) 
  329.         {
  330.             log_err("Couldn't open the Unicode file...\n");
  331.             exit(0);
  332.         }
  333.  
  334.      /*Creates a converter and testing ucnv_openCCSID(u_int code_page, platform, errstatus*/
  335.  
  336.     /*     myConverter =ucnv_openCCSID(CodePageNumberToTest[codepage_index],UCNV_IBM, &err); */
  337.     /*    ucnv_flushCache(); */
  338.     myConverter =ucnv_open( "ibm-949", &err);
  339.         if (!myConverter || U_FAILURE(err))   
  340.         {
  341.             log_err("Error creating the convertor \n");
  342.             
  343.             exit(0);
  344.         }
  345.     
  346.     /*testing for ucnv_getName()  */
  347.     log_verbose("Testing ucnv_getName()...\n");
  348.     ucnv_getName(myConverter, &err);
  349.     if(U_FAILURE(err))
  350.         log_err("Error in getName\n");
  351.     else
  352.     {
  353.         log_verbose("getName o.k. %s\n", ucnv_getName(myConverter, &err));
  354.     }
  355.     if (strCaseIcmp(ucnv_getName(myConverter, &err), CodePagesToTest[codepage_index]))
  356.         log_err("getName failed\n");
  357.     else 
  358.         log_verbose("getName ok\n");
  359.     
  360.     
  361.     /*Tests ucnv_getMaxCharSize() and ucnv_getMinCharSize()*/
  362.     
  363.     log_verbose("Testing ucnv_getMaxCharSize()...\n");
  364.         if (ucnv_getMaxCharSize(myConverter)==CodePagesMaxChars[codepage_index])  
  365.             log_verbose("Max byte per character OK\n");
  366.         else 
  367.             log_err("Max byte per character failed\n");
  368.     
  369.     log_verbose("\n---Testing ucnv_getMinCharSize()...\n");
  370.         if (ucnv_getMinCharSize(myConverter)==CodePagesMinChars[codepage_index])  
  371.             log_verbose("Min byte per character OK\n");
  372.         else 
  373.             log_err("Min byte per character failed\n");
  374.       
  375.  
  376.     /*Testing for ucnv_getSubstChars() and ucnv_setSubstChars()*/
  377.     log_verbose("\n---Testing ucnv_getSubstChars...\n");
  378.     ii=4;
  379.     ucnv_getSubstChars(myConverter, myptr, &ii, &err);
  380.     
  381.     for(x=0;x<ii;x++) 
  382.         rest = ((unsigned char)rest << 8) + (unsigned char)myptr[x];
  383.     if (rest==CodePagesSubstitutionChars[codepage_index])  
  384.         log_verbose("Substitution character ok\n");
  385.     else 
  386.         log_err("Substitution character failed.\n");
  387.     
  388.     log_verbose("\n---Testing ucnv_setSubstChars RoundTrip Test ...\n");
  389.     ucnv_setSubstChars(myConverter, myptr, ii, &err);
  390.     if (U_FAILURE(err)) 
  391.     { log_err("FAILURE! %s\n", myErrorName(err)); }
  392.     ucnv_getSubstChars(myConverter,save, &ii, &err);
  393.     if (U_FAILURE(err)) 
  394.     { log_err("FAILURE! %s\n", myErrorName(err)); }
  395.     
  396.     if (strncmp(save, myptr, ii)) 
  397.         log_err("Saved substitution character failed\n");
  398.     else 
  399.         log_verbose("Saved substitution character ok\n");
  400.     
  401.     
  402.     
  403.     
  404.     
  405.     
  406.     /*resetState  ucnv_reset()*/
  407.     log_verbose("\n---Testing ucnv_reset()..\n");
  408.     ucnv_reset(myConverter);
  409.     
  410.     
  411.     /*getDisplayName*/
  412.     log_verbose("\n---Testing ucnv_getDisplayName()...\n");
  413.     locale=CodePagesLocale[codepage_index];
  414.     displayname=(UChar*)malloc(1 * sizeof(UChar));
  415.     len=0;
  416.     disnamelen = ucnv_getDisplayName(myConverter,locale,displayname, len, &err); 
  417.     if(err==U_BUFFER_OVERFLOW_ERROR)
  418.       {    
  419.          err=U_ZERO_ERROR;
  420.          displayname=(UChar*)realloc(displayname, (disnamelen+1) * sizeof(UChar));
  421.          ucnv_getDisplayName(myConverter,locale,displayname,disnamelen+1, &err);
  422.          if(U_FAILURE(err))
  423.          {
  424.            log_err("getDisplayName failed the error is  %s\n", myErrorName(err));
  425.          }
  426.          else
  427.            log_verbose(" getDisplayName o.k.\n");
  428.       }
  429.     
  430.  
  431.     
  432.     /* testing getMissingUnicodeAction and setMissingUnicodeAction */
  433.     MIA1 = ucnv_getFromUCallBack(myConverter);
  434.             
  435.     log_verbose("\n---Testing ucnv_setFromUCallBack...\n");
  436.     ucnv_setFromUCallBack(myConverter,otherUnicodeAction(MIA1), &err);
  437.     if (U_FAILURE(err)) 
  438.     { log_err("FAILURE! %s\n", myErrorName(err)); }
  439.     
  440.     if (ucnv_getFromUCallBack(myConverter) != otherUnicodeAction(MIA1)) 
  441.         log_err("get From UCallBack failed\n");
  442.     else 
  443.         log_verbose("get From UCallBack ok\n");
  444.  
  445.     log_verbose("\n---Testing getFromUCallBack Roundtrip...\n");
  446.     ucnv_setFromUCallBack(myConverter,MIA1, &err);
  447.     if (U_FAILURE(err)) 
  448.     { log_err("FAILURE! %s\n", myErrorName(err));  }
  449.     
  450.     if (ucnv_getFromUCallBack(myConverter)!= MIA1) 
  451.         log_err("get From UCallBack action failed\n");
  452.     else 
  453.         log_verbose("get From UCallBack action ok\n");
  454.  
  455.  
  456.     
  457.     /*testin ucnv_setMissingCharAction() and ucnv_getMissingCharAction()*/
  458.     MIA2 = ucnv_getToUCallBack(myConverter);
  459.     
  460.     log_verbose("\n---Testing setTo UCallBack...\n");
  461.     ucnv_setToUCallBack(myConverter,otherCharAction(MIA2),&err);
  462.     if (U_FAILURE(err)) 
  463.     { log_err("FAILURE! %s\n", myErrorName(err));}
  464.  
  465.     if (ucnv_getToUCallBack(myConverter) != otherCharAction(MIA2)) 
  466.         log_err("To UCallBack failed\n");
  467.     else 
  468.         log_verbose("To UCallBack ok\n");
  469.     
  470.     log_verbose("\n---Testing setTo UCallBack Roundtrip...\n");
  471.     ucnv_setToUCallBack(myConverter,MIA2, &err);
  472.     if (U_FAILURE(err)) 
  473.     { log_err("FAILURE! %s\n", myErrorName(err));  }
  474.     
  475.     if (ucnv_getToUCallBack(myConverter) != MIA2)
  476.         log_err("To UCallBack failed\n");
  477.     else 
  478.         log_verbose("To UCallBack ok\n");
  479.  
  480.  
  481.     /*getcodepageid testing ucnv_getCCSID() */
  482.     log_verbose("\n----Testing getCCSID....\n");
  483.     cp =    ucnv_getCCSID(myConverter,&err);
  484.     if (U_FAILURE(err)) 
  485.     {
  486.         log_err("FAILURE!..... %s\n", myErrorName(err));
  487.     }
  488.     if (cp != CodePageNumberToTest[codepage_index]) 
  489.         log_err("Codepage number test failed\n");
  490.     else 
  491.         log_verbose("Codepage number test OK\n");
  492.     
  493.  
  494.     
  495.     /*getCodepagePlatform testing ucnv_getPlatform()*/
  496.     log_verbose("\n---Testing getCodepagePlatform ..\n");
  497.     if (CodePagesPlatform[codepage_index]!=ucnv_getPlatform(myConverter, &err))
  498.         log_err("Platform codepage test failed\n");
  499.     else 
  500.         log_verbose("Platform codepage test ok\n");
  501.     
  502.     if (U_FAILURE(err)) 
  503.     { 
  504.         log_err("FAILURE! %s\n", myErrorName(err));
  505.     }
  506.  
  507.  
  508.      
  509.     /*Reads the BOM*/
  510.         fread(&BOM, sizeof(UChar), 1, ucs_file_in);
  511.         if (BOM!=0xFEFF && BOM!=0xFFFE) 
  512.           {
  513.             log_err("File Missing BOM...Bailing!\n");
  514.             exit(0);
  515.           }
  516.  
  517.         
  518.      /*Reads in the file*/
  519.      while(!feof(ucs_file_in)&&(i+=fread(ucs_file_buffer+i, sizeof(UChar), 1, ucs_file_in)))
  520.         {
  521.             myUChar = ucs_file_buffer[i-1];
  522.             
  523.             ucs_file_buffer[i-1] = (BOM==0xFEFF)?myUChar:((myUChar >> 8) | (myUChar << 8)); /*adjust if BIG_ENDIAN*/
  524.         }
  525.  
  526.       myUChar = ucs_file_buffer[i-1];
  527.       ucs_file_buffer[i-1] = (BOM==0xFEFF)?myUChar:((myUChar >> 8) | (myUChar << 8)); /*adjust if BIG_ENDIAN Corner Case*/
  528.  
  529.  
  530.      /*testing ucnv_fromUChars() and ucnv_toUChars() */
  531.      /*uchar1---fromUChar--->output_cp_buffer --toUChar--->uchar2*/
  532.  
  533.       uchar1=(UChar*)malloc(sizeof(UChar) * (u_strlen(ucs_file_buffer)+1));
  534.       u_uastrcpy(uchar1,"");
  535.       u_strncpy(uchar1,ucs_file_buffer,i);
  536.  
  537.       uchar3=(UChar*)malloc(sizeof(UChar)*(u_strlen(ucs_file_buffer)+1));
  538.       u_uastrcpy(uchar3,"");
  539.       u_strncpy(uchar3,ucs_file_buffer,i);
  540.             
  541.       /*Calls the Conversion Routine */
  542.       testLong1 = MAX_FILE_LEN;
  543.       log_verbose("\n---Testing ucnv_fromUChars()\n");
  544.            targetcapacity = ucnv_fromUChars(myConverter, output_cp_buffer, testLong1,  uchar1, &err);
  545.       if (U_FAILURE(err))  
  546.       {
  547.             log_err("\nFAILURE...%s\n", myErrorName(err));
  548.       }
  549.       else
  550.           log_verbose(" ucnv_fromUChars() o.k.\n");
  551.       /*the codepage intermediate buffer should be null terminated */
  552.       output_cp_buffer[targetcapacity]='\0';
  553.       
  554.       /*test the conversion routine */
  555.       log_verbose("\n---Testing ucnv_toUChars()\n");
  556.       /*call it first time for trapping the targetcapacity and size needed to allocate memory for the buffer uchar2 */
  557.       targetcapacity2=0; 
  558.       targetsize = ucnv_toUChars(myConverter,
  559.                  NULL,
  560.                  targetcapacity2,
  561.                  output_cp_buffer,
  562.                  strlen(output_cp_buffer),
  563.                  &err);
  564.       /*if there is an buffer overflow then trap the values and pass them and make the actual call*/
  565.  
  566.       if(err==U_BUFFER_OVERFLOW_ERROR)
  567.       {    
  568.          err=U_ZERO_ERROR;
  569.          uchar2=(UChar*)malloc((targetsize) * sizeof(UChar));
  570.               targetsize = ucnv_toUChars(myConverter, 
  571.                    uchar2,
  572.                    targetsize, 
  573.                    output_cp_buffer,
  574.                    strlen(output_cp_buffer),
  575.                    &err);
  576.          
  577.          if(U_FAILURE(err))
  578.            log_err("ucnv_toUChars() FAILED %s\n", myErrorName(err));
  579.          else
  580.            log_verbose(" ucnv_toUChars() o.k.\n");
  581.       }
  582.               if(u_strcmp(uchar1,uchar2)!=0) 
  583.         log_err("equality test failed with convertion routine\n");         
  584.     
  585.      /*testing for ucnv_fromUnicode() and ucnv_toUnicode() */
  586.          /*Clean up re-usable vars*/
  587.      j=0;
  588.      log_verbose("Testing ucnv_fromUnicode().....\n");
  589.      tmp_ucs_buf=ucs_file_buffer_use; 
  590.      ucnv_fromUnicode(myConverter, &mytarget_1,
  591.                  mytarget + MAX_FILE_LEN,
  592.                  &tmp_ucs_buf,
  593.                  ucs_file_buffer_use+i,
  594.                  NULL,
  595.                  TRUE,
  596.                  &err);
  597.      consumedUni = (UChar*)tmp_consumedUni;
  598.     
  599.      if (U_FAILURE(err)) 
  600.       { 
  601.          log_err("FAILURE! %s\n", myErrorName(err));
  602.      }
  603.      else
  604.          log_verbose("ucnv_fromUnicode()   o.k.\n");
  605.  
  606.     /*Uni1 ----ToUnicode----> Cp2 ----FromUnicode---->Uni3 */
  607.       log_verbose("Testing ucnv_toUnicode().....\n");
  608.       tmp_mytarget_use=mytarget_use;
  609.       tmp_consumed = consumed;
  610.      ucnv_toUnicode(myConverter, &my_ucs_file_buffer_1,
  611.                my_ucs_file_buffer + MAX_FILE_LEN,
  612.                &tmp_mytarget_use,
  613.                mytarget_use+strlen((char*)mytarget_use),
  614.                NULL,
  615.                FALSE,
  616.                &err);
  617.       consumed = (char*)tmp_consumed;
  618.      if (U_FAILURE(err)) 
  619.      { log_err("FAILURE! %s\n", myErrorName(err)); }
  620.      else
  621.          log_verbose("ucnv_toUnicode()  o.k.\n");
  622.     
  623.   
  624.     log_verbose("\n---Testing   RoundTrip ...\n");
  625.     
  626.     
  627.     u_strncpy(uchar3, my_ucs_file_buffer,i);
  628.     
  629.     if(u_strcmp(uchar1,uchar3)==0)
  630.         log_verbose("Equality test o.k.\n");
  631.     else 
  632.         log_err("Equality test failed\n");
  633.  
  634.     /*sanity compare */
  635.     if(u_strcmp(uchar2, uchar3)==0)
  636.         log_verbose("Equality test o.k.\n");
  637.     else
  638.         log_err("Equality test failed\n");
  639.  
  640.     fclose(ucs_file_in);    
  641.     ucnv_close(myConverter);
  642.     free(displayname); 
  643.     if (uchar1 != 0) free(uchar1);
  644.     if (uchar2 != 0) free(uchar2);
  645.     if (uchar3 != 0) free(uchar3);    
  646.     }
  647.     
  648. }
  649.  
  650. void WriteToFile(const UChar *a, FILE *myfile)
  651. {
  652.       uint32_t  size    =  u_strlen(a);
  653.       uint16_t  i       =   0;
  654.       UChar   b       =   0xFEFF;
  655.  
  656.      /*Writes the BOM*/
  657.      fwrite(&b, sizeof(UChar), 1, myfile);
  658.      for (i=0; i< size; i++)
  659.      {
  660.          b = a[i];
  661.          fwrite(&b, sizeof(UChar), 1, myfile);
  662.      }
  663.      return;
  664. }
  665.  
  666.      
  667. int32_t strCaseIcmp(const char* a1, const char * a2)
  668. {
  669.     int32_t i=0, ret=0;
  670.     while(a1[i]&&a2[i]) 
  671.     { 
  672.         ret += tolower(a1[i])-tolower(a2[i]); 
  673.         i++;
  674.     }
  675.     return ret;
  676. }
  677.  
  678. UConverterFromUCallback otherUnicodeAction(UConverterFromUCallback MIA)
  679. {
  680.     return (MIA==(UConverterFromUCallback)UCNV_FROM_U_CALLBACK_STOP)?(UConverterFromUCallback)UCNV_FROM_U_CALLBACK_SUBSTITUTE:(UConverterFromUCallback)UCNV_FROM_U_CALLBACK_STOP;
  681. }
  682.  
  683.  
  684. UConverterToUCallback otherCharAction(UConverterToUCallback MIA)
  685.  
  686. {
  687.     return (MIA==(UConverterToUCallback)UCNV_TO_U_CALLBACK_STOP)?(UConverterToUCallback)UCNV_TO_U_CALLBACK_SUBSTITUTE:(UConverterToUCallback)UCNV_TO_U_CALLBACK_STOP;
  688. }
  689.