home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 6 / AACD06.ISO / AACD / Programming / ICU / src / icu / source / test / cintltst / cdattst.c < prev    next >
Encoding:
C/C++ Source or Header  |  1999-10-19  |  23.1 KB  |  651 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 CDATTST.C
  15. *
  16. * Modification History:
  17. *        Name                     Description            
  18. *     Madhu Katragadda               Creation
  19. *********************************************************************************
  20. */
  21.  
  22. /* C API TEST FOR DATE FORMAT */
  23.  
  24. #include "uloc.h"
  25. #include "utypes.h"
  26. #include "udat.h"
  27. #include "ucal.h"
  28. #include "unum.h"
  29. #include "ustring.h"
  30. #include "cintltst.h"
  31. #include "cdattst.h"
  32. #include<stdio.h>
  33. #include<string.h>
  34. #include "cformtst.h"
  35.  
  36.  
  37. void addDateForTest(TestNode** root)
  38. {
  39.     addTest(root, &TestDateFormat, "tsformat/cdattst/TestDateFormat");
  40.     addTest(root, &TestSymbols, "tsformat/cdattst/TestSymbols");
  41. }
  42. /* Testing the DateFormat API */
  43. void TestDateFormat()
  44. {
  45.     UDateFormat *def, *fr, *it, *de, *def1, *fr_pat;
  46.     UDateFormat *copy;
  47.     UErrorCode status = U_ZERO_ERROR;
  48.     UChar* result;
  49.     const UCalendar *cal;
  50.     const UNumberFormat *numformat1, *numformat2;
  51.     UChar temp[30];
  52.     int32_t numlocales;
  53.     UDate d1;
  54.     int32_t resultlength;
  55.     int32_t resultlengthneeded;
  56.     int32_t parsepos;
  57.     UFieldPosition pos;
  58.     UDate d = 837039928046.0;
  59.     double num = -10456.37;
  60.     const char* str="yyyy.MM.dd G 'at' hh:mm:ss z";
  61.     const char t[]="2/3/76 2:50 AM";
  62.     /*Testing udat_open() to open a dateformat */
  63.     log_verbose("\nTesting udat_open() with various parameters\n");
  64.     fr = udat_open(UDAT_FULL, UDAT_DEFAULT, "fr_FR", NULL,0, &status);
  65.     if(U_FAILURE(status))
  66.     {
  67.         log_err("FAIL: error in creating the dateformat using full time style with french locale\n %s\n", 
  68.             myErrorName(status) );
  69.     }
  70.     def = udat_open(UDAT_SHORT, UDAT_SHORT, NULL, NULL, 0, &status);
  71.     if(U_FAILURE(status))
  72.     {
  73.         log_err("FAIL: error in creating the dateformat using short date and time style\n %s\n", 
  74.             myErrorName(status) );
  75.     }
  76.     it = udat_open(UDAT_DEFAULT, UDAT_MEDIUM, "it_IT", NULL, 0, &status);
  77.     if(U_FAILURE(status))
  78.     {
  79.         log_err("FAIL: error in creating the dateformat using medium date style with italian locale\n %s\n", 
  80.             myErrorName(status) );
  81.     }
  82.     de = udat_open(UDAT_LONG, UDAT_LONG, "de_DE", NULL, 0, &status);
  83.     if(U_FAILURE(status))
  84.     {
  85.         log_err("FAIL: error in creating the dateformat using long time and date styles with german locale\n %s\n",
  86.             myErrorName(status));
  87.     }
  88.     /*creating a default dateformat */
  89.     def1 = udat_open(UDAT_SHORT, UDAT_SHORT, NULL, NULL, 0, &status);
  90.     if(U_FAILURE(status))
  91.     {
  92.         log_err("FAIL: error in creating the dateformat using short date and time style\n %s\n", 
  93.             myErrorName(status) );
  94.     }
  95.  
  96.  
  97.     /*Testing udat_getAvailable() and udat_countAvailable()*/ 
  98.     log_verbose("\nTesting getAvailableLocales and countAvailable()\n");
  99.     numlocales=udat_countAvailable();
  100.     /* use something sensible w/o hardcoding the count */
  101.     if(numlocales < 0)
  102.         log_err("FAIL: error in countAvailable\n");
  103.     log_verbose("The number of locales for which date/time formatting patterns are available is %d\n", numlocales);
  104.     /*for(i=0;i<numlocales;i++)
  105.         log_verbose("%s\n", uloc_getName(udat_getAvailable(i))); */
  106.     
  107.     /*Testing udat_clone()*/
  108.     log_verbose("\nTesting the udat_clone() function of date format\n");
  109.     copy=udat_clone(def, &status);
  110.     if(U_FAILURE(status)){
  111.         log_err("Error in creating the clone using udat_clone: %s\n", myErrorName(status) );
  112.     }
  113.     /*if(def != copy)
  114.         log_err("Error in udat_clone");*//*how should i check for equality????*/
  115.     
  116.     /*Testing udat_format()*/
  117.     log_verbose("\nTesting the udat_format() function of date format\n");
  118.     u_uastrcpy(temp, "7/10/96 4:05 PM");
  119.     /*format using def */
  120.     resultlength=0;
  121.     resultlengthneeded=udat_format(def, d, NULL, resultlength, &pos, &status);
  122.     if(status==U_BUFFER_OVERFLOW_ERROR)
  123.     {
  124.         status=U_ZERO_ERROR;
  125.         resultlength=resultlengthneeded+1;
  126.         result=(UChar*)malloc(sizeof(UChar) * resultlength);
  127.         udat_format(def, d, result, resultlength, &pos, &status);
  128.     }
  129.     if(U_FAILURE(status))
  130.     {
  131.         log_err("FAIL: Error in formatting using udat_format(.....) %s\n", myErrorName(status) );
  132.     }
  133.     else
  134.         log_verbose("PASS: formatting successful\n");
  135.     if(u_strcmp(result, temp)==0)
  136.         log_verbose("PASS: Date Format for US locale successful uisng udat_format()\n");
  137.     else
  138.         log_err("FAIL: Date Format for US locale failed using udat_format()\n");
  139.     /*format using fr */
  140.     
  141.     u_uastrcpy(temp, "10 juil. 96 16 h 05 GMT-07:00");
  142.     result=myDateFormat(fr, d);
  143.     if(u_strcmp(result, temp)==0)
  144.         log_verbose("PASS: Date Format for french locale successful uisng udat_format()\n");
  145.     else
  146.         log_err("FAIL: Date Format for french locale failed using udat_format()\n");
  147.     /*foramt using it */
  148.     u_uastrcpy(temp, "10-lug-96 16.05.28");
  149.     
  150.     if(u_strcmp(myDateFormat(it,d), temp)==0)
  151.         log_verbose("PASS: Date Format for italian locale successful uisng udat_format()\n");
  152.     else
  153.         log_err("FAIL: Date Format for italian locale failed using udat_format()\n");
  154.  
  155. free(result);
  156.     
  157.     /*Testing parsing using udat_parse()*/
  158.     log_verbose("\nTesting parsing using udat_parse()\n");
  159.     u_uastrcpy(temp,"2/3/76 2:50 AM");
  160.     parsepos=0;
  161.     
  162.     d1=udat_parse(def, temp, u_strlen(temp), &parsepos, &status);
  163.     if(U_FAILURE(status))
  164.     {
  165.         log_err("FAIL: Error in parsing using udat_parse(.....) %s\n", myErrorName(status) );
  166.     }
  167.     else
  168.         log_verbose("PASS: parsing succesful\n");
  169.     /*format it back and check for equality */
  170.     
  171.     
  172.     if(u_strcmp(myDateFormat(def, d1),temp)!=0)
  173.         log_err("FAIL: error in parsing\n");
  174.  
  175.         
  176.         
  177.     
  178.     /*Testing udat_openPattern()  */
  179.     status=U_ZERO_ERROR;
  180.     log_verbose("\nTesting the udat_openPattern with a specified pattern\n");
  181.     /*for french locale */
  182.     fr_pat=udat_openPattern(temp, u_strlen(temp), "fr_FR", &status);
  183.     if(U_FAILURE(status))
  184.     {
  185.         log_err("FAIL: Error in creating a date format using udat_openPattern \n %s\n", 
  186.             myErrorName(status) );
  187.     }
  188.     else
  189.         log_verbose("PASS: creating dateformat using udat_openPattern() succesful\n");
  190.  
  191.     
  192.         /*Testing applyPattern and toPattern */
  193.     log_verbose("\nTesting applyPattern and toPattern()\n");
  194.     udat_applyPattern(def1, FALSE, temp, u_strlen(temp));
  195.     log_verbose("Extracting the pattern\n");
  196.  
  197.     resultlength=0;
  198.     resultlengthneeded=udat_toPattern(def1, FALSE, NULL, resultlength, &status);
  199.     if(status==U_BUFFER_OVERFLOW_ERROR)
  200.     {
  201.         status=U_ZERO_ERROR;
  202.         resultlength=resultlengthneeded + 1;
  203.         result=(UChar*)malloc(sizeof(UChar) * resultlength);
  204.         udat_toPattern(def1, FALSE, result, resultlength, &status);
  205.     }
  206.     if(U_FAILURE(status))
  207.     {
  208.         log_err("FAIL: error in extracting the pattern from UNumberFormat\n %s\n", 
  209.             myErrorName(status) );
  210.     }
  211.     if(u_strcmp(result, temp)!=0)
  212.         log_err("FAIL: Error in extracting the pattern\n");
  213.     else
  214.         log_verbose("PASS: applyPattern and toPattern work fine\n");
  215.     
  216.  
  217. free(result);    
  218.     
  219.     
  220.     /*Testing getter and setter functions*/
  221.     /*isLenient and setLenient()*/
  222.     log_verbose("\nTesting the isLenient and setLenient properties\n");
  223.     udat_setLenient(fr, udat_isLenient(it));
  224.     if(udat_isLenient(fr) != udat_isLenient(it)) 
  225.         log_err("ERROR: setLenient() failed\n");
  226.     else
  227.         log_verbose("PASS: setLenient() successful\n");
  228.  
  229.  
  230.     /*Test get2DigitYearStart set2DigitYearStart */
  231.     log_verbose("\nTesting the get and set 2DigitYearStart properties\n");
  232.     d1= udat_get2DigitYearStart(fr_pat,&status);
  233.     if(U_FAILURE(status)) {
  234.             log_err("ERROR: udat_get2DigitYearStart failed %s\n", myErrorName(status) );
  235.     }
  236.     status = U_ZERO_ERROR;
  237.     udat_set2DigitYearStart(def1 ,d1, &status);
  238.     if(U_FAILURE(status)) {
  239.         log_err("ERROR: udat_set2DigitYearStart failed %s\n", myErrorName(status) );
  240.     }
  241.     if(udat_get2DigitYearStart(fr_pat, &status) != udat_get2DigitYearStart(def1, &status))
  242.         log_err("FAIL: error in set2DigitYearStart\n");
  243.     else
  244.         log_verbose("PASS: set2DigitYearStart successful\n");
  245.     /*try setting it to another value */
  246.     udat_set2DigitYearStart(de, 2000.0, &status);
  247.     if(U_FAILURE(status)){
  248.         log_verbose("ERROR: udat_set2DigitYearStart failed %s\n", myErrorName(status) );
  249.     }
  250.     if(udat_get2DigitYearStart(de, &status) != 2000)
  251.         log_err("FAIL: error in set2DigitYearStart\n");
  252.     else
  253.         log_verbose("PASS: set2DigitYearStart successful\n");
  254.  
  255.     
  256.  
  257.     /*Test getNumberFormat() and setNumberFormat() */
  258.     log_verbose("\nTesting the get and set NumberFormat properties of date format\n");
  259.     numformat1=udat_getNumberFormat(fr_pat);
  260.     udat_setNumberFormat(def1, numformat1);
  261.     numformat2=udat_getNumberFormat(def1);
  262.     if(u_strcmp(myNumformat(numformat1, num), myNumformat(numformat2, num)) !=0)
  263.         log_err("FAIL: error in setNumberFormat or getNumberFormat()\n");
  264.     else
  265.         log_verbose("PASS:setNumberFormat and getNumberFormat succesful\n");
  266.     /*try setting the number format to another format */
  267.     numformat1=udat_getNumberFormat(def);
  268.     udat_setNumberFormat(def1, numformat1);
  269.     numformat2=udat_getNumberFormat(def1);
  270.     if(u_strcmp(myNumformat(numformat1, num), myNumformat(numformat2, num)) !=0)
  271.         log_err("FAIL: error in setNumberFormat or getNumberFormat()\n");
  272.     else
  273.         log_verbose("PASS: setNumberFormat and getNumberFormat succesful\n");
  274.  
  275.  
  276.  
  277.     /*Test getCalendar and setCalendar*/
  278.     log_verbose("\nTesting the udat_getCalendar() and udat_setCalendar() properties\n");
  279.     cal=udat_getCalendar(fr_pat);
  280.     
  281.     
  282.     udat_setCalendar(def1, cal);
  283.     if(!ucal_equivalentTo(udat_getCalendar(fr_pat), udat_getCalendar(def1)))
  284.         log_err("FAIL: Error in setting and getting the calendar\n");
  285.     else
  286.         log_verbose("PASS: getting and setting calendar successful\n");
  287.         
  288.         
  289.     
  290.     /*Closing the UDateForamt */
  291.     udat_close(def);
  292.     udat_close(fr);
  293.     udat_close(it);
  294.     udat_close(de);
  295.     udat_close(def1);
  296.     udat_close(fr_pat);
  297.     
  298. }
  299.  
  300. /*Testing udat_getSymbols() and udat_setSymbols() and udat_countSymbols()*/
  301. void TestSymbols()
  302. {
  303.     UDateFormat *def, *fr;
  304.     UErrorCode status = U_ZERO_ERROR;
  305.     UChar *value, *result;
  306.     int32_t resultlength;
  307.     int32_t resultlengthout;
  308.     UChar *pattern;
  309.         
  310.  
  311.     /*creating a dateformat with french locale */
  312.     log_verbose("\ncreating a date format with french locale\n");
  313.     fr = udat_open(UDAT_FULL, UDAT_DEFAULT, "fr_FR", NULL, 0, &status);
  314.     if(U_FAILURE(status))
  315.     {
  316.         log_err("error in creating the dateformat using full time style with french locale\n %s\n", 
  317.             myErrorName(status) );
  318.     }
  319.     /*creating a default dateformat */
  320.     log_verbose("\ncreating a date format with default locale\n");
  321.     def = udat_open(UDAT_DEFAULT,UDAT_DEFAULT ,NULL, NULL, 0, &status);
  322.     if(U_FAILURE(status))
  323.     {
  324.         log_err("error in creating the dateformat using short date and time style\n %s\n", 
  325.             myErrorName(status) );
  326.     }
  327.     
  328.     
  329.     /*Testing countSymbols, getSymbols and setSymbols*/
  330.     log_verbose("\nTesting countSymbols\n");
  331.     /*since the month names has the last string empty and week names are 1 based 1.e first string in the weeknames array is empty */
  332.     if(udat_countSymbols(def, UDAT_ERAS)!=2 || udat_countSymbols(def, UDAT_MONTHS)!=13 || 
  333.         udat_countSymbols(def, UDAT_SHORT_MONTHS)!=13 || udat_countSymbols(def, UDAT_WEEKDAYS)!=8 ||
  334.         udat_countSymbols(def, UDAT_SHORT_WEEKDAYS)!=8 || udat_countSymbols(def, UDAT_AM_PMS)!=2 ||
  335.         udat_countSymbols(def, UDAT_LOCALIZED_CHARS)!=1)
  336.       log_err("FAIL: error in udat_countSymbols\n");
  337.     else
  338.         log_verbose("PASS: udat_countSymbols() successful\n");
  339.  
  340.     /*testing getSymbols*/
  341.     log_verbose("\nTesting getSymbols\n");
  342.     pattern=(UChar*)malloc(sizeof(UChar) * 10);
  343.     u_uastrcpy(pattern, "jeudi");
  344.     resultlength=0;
  345.     resultlengthout=udat_getSymbols(fr, UDAT_WEEKDAYS, 5 , NULL, resultlength, &status);
  346.     if(status==U_BUFFER_OVERFLOW_ERROR)
  347.     {
  348.         status=U_ZERO_ERROR;
  349.         resultlength=resultlengthout+1;
  350.         result=(UChar*)malloc(sizeof(UChar) * resultlength);
  351.         udat_getSymbols(fr, UDAT_WEEKDAYS, 5, result, resultlength, &status);
  352.         
  353.     }
  354.     if(U_FAILURE(status))
  355.     {
  356.         log_err("FAIL: Error in udat_getSymbols().... %s\n", myErrorName(status) );
  357.     }
  358.     else
  359.         log_verbose("PASS: getSymbols succesful\n");
  360.  
  361.     if(u_strcmp(result, pattern)==0)
  362.         log_verbose("PASS: getSymbols retrieved the right value\n");
  363.     else
  364.         log_err("FAIL: getSymbols retrieved the wrong value\n");
  365.  
  366.     /*run series of tests to test getsymbols regressively*/
  367.     log_verbose("\nTesting getSymbols() regressively\n");
  368.     VerifygetSymbols(fr, UDAT_WEEKDAYS, 1, "dimanche");
  369.     VerifygetSymbols(def, UDAT_WEEKDAYS, 1, "Sunday");
  370.     VerifygetSymbols(fr, UDAT_SHORT_WEEKDAYS, 7, "sam.");
  371.     VerifygetSymbols(def, UDAT_SHORT_WEEKDAYS, 7, "Sat");
  372.     VerifygetSymbols(def, UDAT_MONTHS, 11, "December");
  373.     VerifygetSymbols(def, UDAT_MONTHS, 0, "January");
  374.     VerifygetSymbols(fr, UDAT_ERAS, 0, "BC");
  375.     VerifygetSymbols(def, UDAT_AM_PMS, 0, "AM");
  376.     VerifygetSymbols(def, UDAT_AM_PMS, 1, "PM");
  377.     VerifygetSymbols(fr, UDAT_SHORT_MONTHS, 0, "janv.");
  378.     VerifygetSymbols(def, UDAT_SHORT_MONTHS, 11, "Dec");
  379.     VerifygetSymbols(def,UDAT_LOCALIZED_CHARS, 0, "GyMdkHmsSEDFwWahKz");
  380.  
  381.  
  382. free(result);
  383. free(pattern);    
  384.     
  385.     log_verbose("\nTesting setSymbols\n");
  386.     /*applying the pattern so that setSymbolss works */
  387.     resultlength=0;
  388.     resultlengthout=udat_toPattern(fr, FALSE, NULL, resultlength, &status);
  389.     if(status==U_BUFFER_OVERFLOW_ERROR)
  390.     {
  391.         status=U_ZERO_ERROR;
  392.         resultlength=resultlengthout + 1;
  393.         pattern=(UChar*)malloc(sizeof(UChar) * resultlength);
  394.         udat_toPattern(fr, FALSE, pattern, resultlength, &status);
  395.     }
  396.     if(U_FAILURE(status))
  397.     {
  398.         log_err("FAIL: error in extracting the pattern from UNumberFormat\n %s\n", 
  399.             myErrorName(status) );
  400.     }
  401.     
  402.     udat_applyPattern(def, FALSE, pattern, u_strlen(pattern));
  403.     resultlength=0;
  404.     resultlengthout=udat_toPattern(def, FALSE, NULL, resultlength,&status);
  405.     if(status==U_BUFFER_OVERFLOW_ERROR)
  406.     {
  407.         status=U_ZERO_ERROR;
  408.         resultlength=resultlengthout + 1;
  409.         result=(UChar*)malloc(sizeof(UChar) * resultlength);
  410.         udat_toPattern(fr, FALSE,result, resultlength, &status);
  411.     }
  412.     if(U_FAILURE(status))
  413.     {
  414.         log_err("FAIL: error in extracting the pattern from UNumberFormat\n %s\n", 
  415.             myErrorName(status) );
  416.     }
  417.     if(u_strcmp(result, pattern)==0)
  418.         log_verbose("Pattern applied properly\n");
  419.     else
  420.         log_err("pattern could not be applied properly\n");
  421.  
  422. free(result);
  423. free(pattern);
  424.     /*testing set symbols */
  425.     resultlength=0;
  426.     resultlengthout=udat_getSymbols(fr, UDAT_MONTHS, 11 , NULL, resultlength, &status);
  427.     if(status==U_BUFFER_OVERFLOW_ERROR){
  428.         status=U_ZERO_ERROR;
  429.         resultlength=resultlengthout+1;
  430.         result=(UChar*)malloc(sizeof(UChar) * resultlength);
  431.         udat_getSymbols(fr, UDAT_MONTHS, 11, result, resultlength, &status);
  432.         
  433.     }
  434.     if(U_FAILURE(status))
  435.         log_err("FAIL: error in getSymbols() %s\n", myErrorName(status) );
  436.     resultlength=resultlengthout+1;
  437.     
  438.     udat_setSymbols(def, UDAT_MONTHS, 11, result, resultlength, &status);
  439.     if(U_FAILURE(status))
  440.         {
  441.             log_err("FAIL: Error in udat_setSymbols() : %s\n", myErrorName(status) );
  442.         }
  443.     else
  444.         log_verbose("PASS: SetSymbols successful\n");
  445.     
  446.     resultlength=0;
  447.     resultlengthout=udat_getSymbols(def, UDAT_MONTHS, 11, NULL, resultlength, &status);
  448.     if(status==U_BUFFER_OVERFLOW_ERROR){
  449.         status=U_ZERO_ERROR;
  450.         resultlength=resultlengthout+1;
  451.         value=(UChar*)malloc(sizeof(UChar) * resultlength);
  452.         udat_getSymbols(def, UDAT_MONTHS, 11, value, resultlength, &status);
  453.     }
  454.     if(U_FAILURE(status))
  455.         log_err("FAIL: error in retrieving the value using getSymbols i.e roundtrip\n");
  456.     
  457.     if(u_strcmp(result, value)!=0)
  458.         log_err("FAIL: Error in settting and getting symbols\n");
  459.     else
  460.         log_verbose("PASS: setSymbols successful\n");
  461.     
  462.     
  463.     /*run series of tests to test setSymbols regressively*/
  464.     log_verbose("\nTesting setSymbols regressively\n");
  465.     VerifysetSymbols(def, UDAT_WEEKDAYS, 1, "Sundayweek");
  466.     VerifysetSymbols(def, UDAT_ERAS, 0, "BeforeChrist");
  467.     VerifysetSymbols(def, UDAT_SHORT_WEEKDAYS, 7, "Satweek");
  468.     VerifysetSymbols(fr, UDAT_MONTHS, 11, "december");
  469.     VerifysetSymbols(fr, UDAT_SHORT_MONTHS, 0, "Jan");
  470.  
  471.     
  472.     /*run series of tests to test get and setSymbols regressively*/
  473.     log_verbose("\nTesting get and set symbols regressively\n");
  474.     VerifygetsetSymbols(fr, def, UDAT_WEEKDAYS, 1);
  475.     VerifygetsetSymbols(fr, def, UDAT_WEEKDAYS, 7);
  476.     VerifygetsetSymbols(fr, def, UDAT_SHORT_WEEKDAYS, 1);
  477.     VerifygetsetSymbols(fr, def, UDAT_SHORT_WEEKDAYS, 7);
  478.     VerifygetsetSymbols(fr, def, UDAT_MONTHS, 0);
  479.     VerifygetsetSymbols(fr, def, UDAT_SHORT_MONTHS, 0);
  480.     VerifygetsetSymbols(fr, def, UDAT_ERAS,1);
  481.     VerifygetsetSymbols(fr, def, UDAT_LOCALIZED_CHARS, 0);
  482.     VerifygetsetSymbols(fr, def, UDAT_AM_PMS, 1);
  483.  
  484.  
  485.     /*closing*/
  486.     
  487.     udat_close(fr);
  488.     udat_close(def);
  489.     free(result);
  490.     free(value);
  491.     
  492. }
  493.  
  494. /*INTERNAL FUNCTIONS USED*/
  495. void VerifygetSymbols(UDateFormat* datfor, UDateFormatSymbolType type, int32_t index, const char* expected)
  496. {
  497.     UChar *pattern;
  498.     UErrorCode status = U_ZERO_ERROR;
  499.     UChar *result;
  500.     int32_t resultlength, resultlengthout;
  501.  
  502.     
  503.     pattern=(UChar*)malloc(sizeof(UChar) * (strlen(expected)+1));
  504.     u_uastrcpy(pattern, expected);
  505.     resultlength=0;
  506.     resultlengthout=udat_getSymbols(datfor, type, index , NULL, resultlength, &status);
  507.     if(status==U_BUFFER_OVERFLOW_ERROR)
  508.     {
  509.         status=U_ZERO_ERROR;
  510.         resultlength=resultlengthout+1;
  511.         result=(UChar*)malloc(sizeof(UChar) * resultlength);
  512.         udat_getSymbols(datfor, type, index, result, resultlength, &status);
  513.         
  514.     }
  515.     if(U_FAILURE(status))
  516.     {
  517.         log_err("FAIL: Error in udat_getSymbols()... %s\n", myErrorName(status) );
  518.         return;
  519.     }
  520.     if(u_strcmp(result, pattern)==0)
  521.         log_verbose("PASS: getSymbols retrieved the right value\n");
  522.     else{
  523.         log_err("FAlL: getSymbols retrieved the wrong value\n Expected %s Got %s\n", austrdup(pattern), 
  524.             austrdup(result) );
  525.     }
  526.     free(result);
  527.     free(pattern);
  528. }
  529.  
  530. void VerifysetSymbols(UDateFormat* datfor, UDateFormatSymbolType type, int32_t index, const char* expected)
  531. {
  532.     UChar *result;
  533.     UChar *value;
  534.     int32_t resultlength, resultlengthout;
  535.     UErrorCode status = U_ZERO_ERROR;
  536.  
  537.     value=(UChar*)malloc(sizeof(UChar) * (strlen(expected) + 1));
  538.     u_uastrcpy(value, expected);
  539.     udat_setSymbols(datfor, type, index, value, u_strlen(value), &status);
  540.     if(U_FAILURE(status))
  541.         {
  542.             log_err("FAIL: Error in udat_setSymbols()  %s\n", myErrorName(status) );
  543.             return;
  544.         }
  545.  
  546.     resultlength=0;
  547.     resultlengthout=udat_getSymbols(datfor, type, index, NULL, resultlength, &status);
  548.     if(status==U_BUFFER_OVERFLOW_ERROR){
  549.         status=U_ZERO_ERROR;
  550.         resultlength=resultlengthout+1;
  551.         result=(UChar*)malloc(sizeof(UChar) * resultlength);
  552.         udat_getSymbols(datfor, type, index, result, resultlength, &status);
  553.     }
  554.     if(U_FAILURE(status)){
  555.         log_err("FAIL: error in retrieving the value using getSymbols after setting it previously\n %s\n", 
  556.             myErrorName(status) );
  557.         return;
  558.     }
  559.     
  560.     if(u_strcmp(result, value)!=0){
  561.         log_err("FAIL:Error in setting and then getting symbols\n Expected %s Got %s\n", austrdup(value),
  562.             austrdup(result) );
  563.     }
  564.     else
  565.         log_verbose("PASS: setSymbols successful\n");
  566.  
  567.     free(value);
  568.     free(result);
  569. }
  570.  
  571.  
  572. void VerifygetsetSymbols(UDateFormat* from, UDateFormat* to, UDateFormatSymbolType type, int32_t index)
  573. {
  574.     UChar *result;
  575.     UChar *value;
  576.     int32_t resultlength, resultlengthout;
  577.     UErrorCode status = U_ZERO_ERROR;
  578.     
  579.     resultlength=0;
  580.     resultlengthout=udat_getSymbols(from, type, index , NULL, resultlength, &status);
  581.     if(status==U_BUFFER_OVERFLOW_ERROR){
  582.         status=U_ZERO_ERROR;
  583.         resultlength=resultlengthout+1;
  584.         result=(UChar*)malloc(sizeof(UChar) * resultlength);
  585.         udat_getSymbols(from, type, index, result, resultlength, &status);
  586.     }
  587.     if(U_FAILURE(status)){
  588.         log_err("FAIL: error in getSymbols() %s\n", myErrorName(status) );
  589.         return;
  590.     }
  591.     
  592.     resultlength=resultlengthout+1;
  593.     udat_setSymbols(to, type, index, result, resultlength, &status);
  594.     if(U_FAILURE(status))
  595.         {
  596.             log_err("FAIL: Error in udat_setSymbols() : %s\n", myErrorName(status) );
  597.             return;
  598.         }
  599.  
  600.     resultlength=0;
  601.     resultlengthout=udat_getSymbols(to, type, index, NULL, resultlength, &status);
  602.     if(status==U_BUFFER_OVERFLOW_ERROR){
  603.         status=U_ZERO_ERROR;
  604.         resultlength=resultlengthout+1;
  605.         value=(UChar*)malloc(sizeof(UChar) * resultlength);
  606.         udat_getSymbols(to, type, index, value, resultlength, &status);
  607.     }
  608.     if(U_FAILURE(status)){
  609.         log_err("FAIL: error in retrieving the value using getSymbols i.e roundtrip\n %s\n", 
  610.             myErrorName(status) );
  611.         return;
  612.     }
  613.     
  614.     if(u_strcmp(result, value)!=0){
  615.         log_err("FAIL:Error in setting and then getting symbols\n Expected %s Got %s\n", austrdup(result),
  616.             austrdup(value) );
  617.     }
  618.     else
  619.         log_verbose("PASS: setSymbols successful\n");
  620.  
  621.     free(value);
  622.     free(result);
  623. }
  624.  
  625.  
  626.  
  627. UChar* myNumformat(const UNumberFormat* numfor, double d)
  628. {
  629.     UChar *result2;
  630.     int32_t resultlength, resultlengthneeded;
  631.     UFieldPosition pos;
  632.     UErrorCode status = U_ZERO_ERROR;
  633.     
  634.     resultlength=0;
  635.     resultlengthneeded=unum_formatDouble(numfor, d, NULL, resultlength, &pos, &status);
  636.     if(status==U_BUFFER_OVERFLOW_ERROR)
  637.     {
  638.         status=U_ZERO_ERROR;
  639.         resultlength=resultlengthneeded+1;
  640.         result2=(UChar*)malloc(sizeof(UChar) * resultlength);
  641.         unum_formatDouble(numfor, d, result2, resultlength, &pos, &status);
  642.     }
  643.     if(U_FAILURE(status))
  644.     {
  645.         log_err("FAIL: Error in formatting using unum_format(.....) %s\n", myErrorName(status) );
  646.         return 0;
  647.     }
  648.     
  649.     return result2;
  650. }
  651.