From 5b69033400476be749862631609f60bd7daaacd7 Mon Sep 17 00:00:00 2001 From: seungho Date: Tue, 21 Aug 2012 21:48:42 +0900 Subject: [PATCH] external/icu --- TC/build.sh | 20 ++ TC/execute.sh | 20 ++ TC/tet_code | 12 ++ TC/tet_scen | 7 + TC/tetbuild.cfg | 3 + TC/tetclean.cfg | 2 + TC/tetexec.cfg | 1 + TC/unit/Makefile | 100 ++++++++++ TC/unit/tc_gen.sh | 28 +++ TC/unit/tslist | 78 ++++++++ TC/unit/utc_MODULE_API_func.c.in | 65 +++++++ TC/unit/utc_tizen_icu_api_u_errorName_func.c | 103 +++++++++++ TC/unit/utc_tizen_icu_api_u_strFromWCS_func.c | 114 ++++++++++++ TC/unit/utc_tizen_icu_api_u_strToWCS_func.c | 113 ++++++++++++ TC/unit/utc_tizen_icu_api_ucal_clearField_func.c | 91 +++++++++ TC/unit/utc_tizen_icu_api_ucal_clear_func.c | 108 +++++++++++ TC/unit/utc_tizen_icu_api_ucal_close_func.c | 84 +++++++++ TC/unit/utc_tizen_icu_api_ucal_equivalentTo_func.c | 131 +++++++++++++ TC/unit/utc_tizen_icu_api_ucal_getAvailable_func.c | 103 +++++++++++ .../utc_tizen_icu_api_ucal_getDSTSavings_func.c | 81 ++++++++ ...tc_tizen_icu_api_ucal_getDefaultTimeZone_func.c | 114 ++++++++++++ TC/unit/utc_tizen_icu_api_ucal_getLimit_func.c | 161 ++++++++++++++++ TC/unit/utc_tizen_icu_api_ucal_getMillis_func.c | 93 ++++++++++ ...izen_icu_api_ucal_getTimeZoneDisplayName_func.c | 102 +++++++++++ .../utc_tizen_icu_api_ucal_inDaylightTime_func.c | 93 ++++++++++ TC/unit/utc_tizen_icu_api_ucal_isSet_func.c | 125 +++++++++++++ TC/unit/utc_tizen_icu_api_ucal_open_func.c | 113 ++++++++++++ TC/unit/utc_tizen_icu_api_ucal_roll_func.c | 101 ++++++++++ TC/unit/utc_tizen_icu_api_ucal_setDateTime_func.c | 142 ++++++++++++++ TC/unit/utc_tizen_icu_api_ucal_setDate_func.c | 132 ++++++++++++++ ...tc_tizen_icu_api_ucal_setDefaultTimeZone_func.c | 85 +++++++++ ...tc_tizen_icu_api_ucal_setGregorianChange_func.c | 96 ++++++++++ TC/unit/utc_tizen_icu_api_ucal_setMillis_func.c | 93 ++++++++++ TC/unit/utc_tizen_icu_api_ucal_setTimeZone_func.c | 91 +++++++++ TC/unit/utc_tizen_icu_api_ucal_set_func.c | 101 ++++++++++ TC/unit/utc_tizen_icu_api_ucnv_close_func.c | 83 +++++++++ TC/unit/utc_tizen_icu_api_ucnv_compareNames_func.c | 101 ++++++++++ TC/unit/utc_tizen_icu_api_ucnv_convertEx_func.c | 158 ++++++++++++++++ .../utc_tizen_icu_api_ucnv_countAvailable_func.c | 91 +++++++++ TC/unit/utc_tizen_icu_api_ucnv_flushCache_func.c | 113 ++++++++++++ TC/unit/utc_tizen_icu_api_ucnv_fromUChars_func.c | 137 ++++++++++++++ TC/unit/utc_tizen_icu_api_ucnv_fromUnicode_func.c | 126 +++++++++++++ TC/unit/utc_tizen_icu_api_ucnv_getAlias_func.c | 114 ++++++++++++ .../utc_tizen_icu_api_ucnv_getAvailableName_func.c | 111 +++++++++++ .../utc_tizen_icu_api_ucnv_getCanonicalName_func.c | 128 +++++++++++++ .../utc_tizen_icu_api_ucnv_getDisplayName_func.c | 132 ++++++++++++++ .../utc_tizen_icu_api_ucnv_getMaxCharSize_func.c | 92 ++++++++++ .../utc_tizen_icu_api_ucnv_getMinCharSize_func.c | 92 ++++++++++ TC/unit/utc_tizen_icu_api_ucnv_getName_func.c | 92 ++++++++++ TC/unit/utc_tizen_icu_api_ucnv_open_func.c | 107 +++++++++++ TC/unit/utc_tizen_icu_api_ucnv_reset_func.c | 83 +++++++++ TC/unit/utc_tizen_icu_api_ucnv_setFallback_func.c | 129 +++++++++++++ .../utc_tizen_icu_api_ucnv_setFromUCallBack_func.c | 143 +++++++++++++++ .../utc_tizen_icu_api_ucnv_setToUCallBack_func.c | 135 ++++++++++++++ TC/unit/utc_tizen_icu_api_ucnv_toUChars_func.c | 133 ++++++++++++++ TC/unit/utc_tizen_icu_api_ucnv_toUnicode_func.c | 126 +++++++++++++ TC/unit/utc_tizen_icu_api_udat_close_func.c | 89 +++++++++ TC/unit/utc_tizen_icu_api_udat_format_func.c | 100 ++++++++++ TC/unit/utc_tizen_icu_api_udat_getCalendar_func.c | 96 ++++++++++ TC/unit/utc_tizen_icu_api_udat_getSymbols_func.c | 145 +++++++++++++++ TC/unit/utc_tizen_icu_api_udat_isLenient_func.c | 98 ++++++++++ TC/unit/utc_tizen_icu_api_udat_open_func.c | 123 +++++++++++++ TC/unit/utc_tizen_icu_api_udat_setLenient_func.c | 97 ++++++++++ TC/unit/utc_tizen_icu_api_udat_setSymbols_func.c | 102 +++++++++++ ...tizen_icu_api_udat_toPatternRelativeDate_func.c | 160 ++++++++++++++++ TC/unit/utc_tizen_icu_api_uloc_getAvailable_func.c | 103 +++++++++++ TC/unit/utc_tizen_icu_api_uloc_getCountry_func.c | 140 ++++++++++++++ TC/unit/utc_tizen_icu_api_uloc_getDefault_func.c | 80 ++++++++ ...utc_tizen_icu_api_uloc_getDisplayCountry_func.c | 176 ++++++++++++++++++ ...tc_tizen_icu_api_uloc_getDisplayLanguage_func.c | 169 +++++++++++++++++ .../utc_tizen_icu_api_uloc_getDisplayName_func.c | 175 ++++++++++++++++++ ...utc_tizen_icu_api_uloc_getDisplayVariant_func.c | 169 +++++++++++++++++ .../utc_tizen_icu_api_uloc_getISO3Country_func.c | 111 +++++++++++ .../utc_tizen_icu_api_uloc_getISO3Language_func.c | 113 ++++++++++++ .../utc_tizen_icu_api_uloc_getISOCountries_func.c | 85 +++++++++ .../utc_tizen_icu_api_uloc_getISOLanguages_func.c | 85 +++++++++ TC/unit/utc_tizen_icu_api_uloc_getLanguage_func.c | 141 ++++++++++++++ TC/unit/utc_tizen_icu_api_uloc_getVariant_func.c | 113 ++++++++++++ TC/unit/utc_tizen_icu_api_uloc_setDefault_func.c | 134 ++++++++++++++ TC/unit/utc_tizen_icu_api_unum_close_func.c | 89 +++++++++ .../utc_tizen_icu_api_unum_formatDecimal_func.c | 146 +++++++++++++++ TC/unit/utc_tizen_icu_api_unum_formatDouble_func.c | 142 ++++++++++++++ TC/unit/utc_tizen_icu_api_unum_formatInt64_func.c | 137 ++++++++++++++ TC/unit/utc_tizen_icu_api_unum_format_func.c | 141 ++++++++++++++ TC/unit/utc_tizen_icu_api_unum_open_func.c | 131 +++++++++++++ TC/unit/utc_tizen_icu_api_unum_parseDecimal_func.c | 138 ++++++++++++++ TC/unit/utc_tizen_icu_api_unum_parseDouble_func.c | 134 ++++++++++++++ TC/unit/utc_tizen_icu_api_unum_parseInt64_func.c | 135 ++++++++++++++ TC/unit/utc_tizen_icu_api_unum_parse_func.c | 135 ++++++++++++++ data/in/icudt48l.dat | Bin 11911184 -> 11885168 bytes debian/changelog | 203 ++++++++++++++++++++- debian/copyright | 26 +++ packaging/hack-atomics.diff | 45 +---- packaging/icu.spec | 2 +- 94 files changed, 9697 insertions(+), 43 deletions(-) create mode 100755 TC/build.sh create mode 100755 TC/execute.sh create mode 100755 TC/tet_code create mode 100755 TC/tet_scen create mode 100755 TC/tetbuild.cfg create mode 100755 TC/tetclean.cfg create mode 100755 TC/tetexec.cfg create mode 100755 TC/unit/Makefile create mode 100755 TC/unit/tc_gen.sh create mode 100755 TC/unit/tslist create mode 100755 TC/unit/utc_MODULE_API_func.c.in create mode 100755 TC/unit/utc_tizen_icu_api_u_errorName_func.c create mode 100755 TC/unit/utc_tizen_icu_api_u_strFromWCS_func.c create mode 100755 TC/unit/utc_tizen_icu_api_u_strToWCS_func.c create mode 100755 TC/unit/utc_tizen_icu_api_ucal_clearField_func.c create mode 100755 TC/unit/utc_tizen_icu_api_ucal_clear_func.c create mode 100755 TC/unit/utc_tizen_icu_api_ucal_close_func.c create mode 100755 TC/unit/utc_tizen_icu_api_ucal_equivalentTo_func.c create mode 100755 TC/unit/utc_tizen_icu_api_ucal_getAvailable_func.c create mode 100755 TC/unit/utc_tizen_icu_api_ucal_getDSTSavings_func.c create mode 100755 TC/unit/utc_tizen_icu_api_ucal_getDefaultTimeZone_func.c create mode 100755 TC/unit/utc_tizen_icu_api_ucal_getLimit_func.c create mode 100755 TC/unit/utc_tizen_icu_api_ucal_getMillis_func.c create mode 100755 TC/unit/utc_tizen_icu_api_ucal_getTimeZoneDisplayName_func.c create mode 100755 TC/unit/utc_tizen_icu_api_ucal_inDaylightTime_func.c create mode 100755 TC/unit/utc_tizen_icu_api_ucal_isSet_func.c create mode 100755 TC/unit/utc_tizen_icu_api_ucal_open_func.c create mode 100755 TC/unit/utc_tizen_icu_api_ucal_roll_func.c create mode 100755 TC/unit/utc_tizen_icu_api_ucal_setDateTime_func.c create mode 100755 TC/unit/utc_tizen_icu_api_ucal_setDate_func.c create mode 100755 TC/unit/utc_tizen_icu_api_ucal_setDefaultTimeZone_func.c create mode 100755 TC/unit/utc_tizen_icu_api_ucal_setGregorianChange_func.c create mode 100755 TC/unit/utc_tizen_icu_api_ucal_setMillis_func.c create mode 100755 TC/unit/utc_tizen_icu_api_ucal_setTimeZone_func.c create mode 100755 TC/unit/utc_tizen_icu_api_ucal_set_func.c create mode 100755 TC/unit/utc_tizen_icu_api_ucnv_close_func.c create mode 100755 TC/unit/utc_tizen_icu_api_ucnv_compareNames_func.c create mode 100755 TC/unit/utc_tizen_icu_api_ucnv_convertEx_func.c create mode 100755 TC/unit/utc_tizen_icu_api_ucnv_countAvailable_func.c create mode 100755 TC/unit/utc_tizen_icu_api_ucnv_flushCache_func.c create mode 100755 TC/unit/utc_tizen_icu_api_ucnv_fromUChars_func.c create mode 100755 TC/unit/utc_tizen_icu_api_ucnv_fromUnicode_func.c create mode 100755 TC/unit/utc_tizen_icu_api_ucnv_getAlias_func.c create mode 100755 TC/unit/utc_tizen_icu_api_ucnv_getAvailableName_func.c create mode 100755 TC/unit/utc_tizen_icu_api_ucnv_getCanonicalName_func.c create mode 100755 TC/unit/utc_tizen_icu_api_ucnv_getDisplayName_func.c create mode 100755 TC/unit/utc_tizen_icu_api_ucnv_getMaxCharSize_func.c create mode 100755 TC/unit/utc_tizen_icu_api_ucnv_getMinCharSize_func.c create mode 100755 TC/unit/utc_tizen_icu_api_ucnv_getName_func.c create mode 100755 TC/unit/utc_tizen_icu_api_ucnv_open_func.c create mode 100755 TC/unit/utc_tizen_icu_api_ucnv_reset_func.c create mode 100755 TC/unit/utc_tizen_icu_api_ucnv_setFallback_func.c create mode 100755 TC/unit/utc_tizen_icu_api_ucnv_setFromUCallBack_func.c create mode 100755 TC/unit/utc_tizen_icu_api_ucnv_setToUCallBack_func.c create mode 100755 TC/unit/utc_tizen_icu_api_ucnv_toUChars_func.c create mode 100755 TC/unit/utc_tizen_icu_api_ucnv_toUnicode_func.c create mode 100755 TC/unit/utc_tizen_icu_api_udat_close_func.c create mode 100755 TC/unit/utc_tizen_icu_api_udat_format_func.c create mode 100755 TC/unit/utc_tizen_icu_api_udat_getCalendar_func.c create mode 100755 TC/unit/utc_tizen_icu_api_udat_getSymbols_func.c create mode 100755 TC/unit/utc_tizen_icu_api_udat_isLenient_func.c create mode 100755 TC/unit/utc_tizen_icu_api_udat_open_func.c create mode 100755 TC/unit/utc_tizen_icu_api_udat_setLenient_func.c create mode 100755 TC/unit/utc_tizen_icu_api_udat_setSymbols_func.c create mode 100755 TC/unit/utc_tizen_icu_api_udat_toPatternRelativeDate_func.c create mode 100755 TC/unit/utc_tizen_icu_api_uloc_getAvailable_func.c create mode 100755 TC/unit/utc_tizen_icu_api_uloc_getCountry_func.c create mode 100755 TC/unit/utc_tizen_icu_api_uloc_getDefault_func.c create mode 100755 TC/unit/utc_tizen_icu_api_uloc_getDisplayCountry_func.c create mode 100755 TC/unit/utc_tizen_icu_api_uloc_getDisplayLanguage_func.c create mode 100755 TC/unit/utc_tizen_icu_api_uloc_getDisplayName_func.c create mode 100755 TC/unit/utc_tizen_icu_api_uloc_getDisplayVariant_func.c create mode 100755 TC/unit/utc_tizen_icu_api_uloc_getISO3Country_func.c create mode 100755 TC/unit/utc_tizen_icu_api_uloc_getISO3Language_func.c create mode 100755 TC/unit/utc_tizen_icu_api_uloc_getISOCountries_func.c create mode 100755 TC/unit/utc_tizen_icu_api_uloc_getISOLanguages_func.c create mode 100755 TC/unit/utc_tizen_icu_api_uloc_getLanguage_func.c create mode 100755 TC/unit/utc_tizen_icu_api_uloc_getVariant_func.c create mode 100755 TC/unit/utc_tizen_icu_api_uloc_setDefault_func.c create mode 100755 TC/unit/utc_tizen_icu_api_unum_close_func.c create mode 100755 TC/unit/utc_tizen_icu_api_unum_formatDecimal_func.c create mode 100755 TC/unit/utc_tizen_icu_api_unum_formatDouble_func.c create mode 100755 TC/unit/utc_tizen_icu_api_unum_formatInt64_func.c create mode 100755 TC/unit/utc_tizen_icu_api_unum_format_func.c create mode 100755 TC/unit/utc_tizen_icu_api_unum_open_func.c create mode 100755 TC/unit/utc_tizen_icu_api_unum_parseDecimal_func.c create mode 100755 TC/unit/utc_tizen_icu_api_unum_parseDouble_func.c create mode 100755 TC/unit/utc_tizen_icu_api_unum_parseInt64_func.c create mode 100755 TC/unit/utc_tizen_icu_api_unum_parse_func.c mode change 100644 => 100755 data/in/icudt48l.dat create mode 100644 debian/copyright diff --git a/TC/build.sh b/TC/build.sh new file mode 100755 index 0000000..2d93822 --- /dev/null +++ b/TC/build.sh @@ -0,0 +1,20 @@ +#!/bin/sh + +export TET_INSTALL_PATH=/home/tetware/TETware # local tetware path +export TET_TARGET_PATH=$TET_INSTALL_PATH/tetware-target +export PATH=$TET_TARGET_PATH/bin:$PATH +export LD_LIBRARY_PATH=$TET_TARGET_PATH/lib/tet3:$LD_LIBRARY_PATH +export TET_ROOT=$TET_TARGET_PATH + +export TET_SUITE_ROOT=`pwd` +FILE_NAME_EXTENSION=`date +%s` + +RESULT_DIR=results +HTML_RESULT=$RESULT_DIR/build-tar-result-$FILE_NAME_EXTENSION.html +JOURNAL_RESULT=$RESULT_DIR/build-tar-result-$FILE_NAME_EXTENSION.journal + +mkdir -p $RESULT_DIR + +tcc -c -p ./ +tcc -b -j $JOURNAL_RESULT -p ./ +grw -c 3 -f chtml -o $HTML_RESULT $JOURNAL_RESULT diff --git a/TC/execute.sh b/TC/execute.sh new file mode 100755 index 0000000..3fe6ab2 --- /dev/null +++ b/TC/execute.sh @@ -0,0 +1,20 @@ +#!/bin/sh +#export TET_INSTALL_PATH=/mnt/nfs/tetware +export TET_INSTALL_PATH=/mnt/nfs/tetware/TETware/ +export TET_TARGET_PATH=$TET_INSTALL_PATH/tetware-target +export PATH=$TET_TARGET_PATH/bin:$PATH +export LD_LIBRARY_PATH=$TET_TARGET_PATH/lib/tet3:$LD_LIBRARY_PATH + +export TET_ROOT=$TET_TARGET_PATH + +export TET_SUITE_ROOT=`pwd` +FILE_NAME_EXTENSION=`date +%s` + +RESULT_DIR=results +HTML_RESULT=$RESULT_DIR/exec-tar-result-$FILE_NAME_EXTENSION.html +JOURNAL_RESULT=$RESULT_DIR/exec-tar-result-$FILE_NAME_EXTENSION.journal + +mkdir -p $RESULT_DIR + +tcc -e -j $JOURNAL_RESULT -p ./ +grw -c 3 -f chtml -o $HTML_RESULT $JOURNAL_RESULT diff --git a/TC/tet_code b/TC/tet_code new file mode 100755 index 0000000..a2cf6c1 --- /dev/null +++ b/TC/tet_code @@ -0,0 +1,12 @@ +# TET reserved codes +0 "PASS" +1 "FAIL" +2 "UNRESOLVED" +3 "NOTINUSE" +4 "UNSUPPORTED" +5 "UNTESTED" +6 "UNINITIATED" +7 "NORESULT" + +# Test suite additional codes +33 "INSPECT" diff --git a/TC/tet_scen b/TC/tet_scen new file mode 100755 index 0000000..43cbc9b --- /dev/null +++ b/TC/tet_scen @@ -0,0 +1,7 @@ +all + ^TEST +##### Scenarios for TEST ##### + +# Test scenario +TEST + :include:/unit/tslist diff --git a/TC/tetbuild.cfg b/TC/tetbuild.cfg new file mode 100755 index 0000000..6192c78 --- /dev/null +++ b/TC/tetbuild.cfg @@ -0,0 +1,3 @@ +TET_OUTPUT_CAPTURE=False +TET_BUILD_TOOL=make +TET_PASS_TC_NAME=True diff --git a/TC/tetclean.cfg b/TC/tetclean.cfg new file mode 100755 index 0000000..c66eda4 --- /dev/null +++ b/TC/tetclean.cfg @@ -0,0 +1,2 @@ +TET_OUTPUT_CAPTURE=False +TET_CLEAN_TOOL=make clean diff --git a/TC/tetexec.cfg b/TC/tetexec.cfg new file mode 100755 index 0000000..0d9d39a --- /dev/null +++ b/TC/tetexec.cfg @@ -0,0 +1 @@ +TET_OUTPUT_CAPTURE=False diff --git a/TC/unit/Makefile b/TC/unit/Makefile new file mode 100755 index 0000000..418b5c8 --- /dev/null +++ b/TC/unit/Makefile @@ -0,0 +1,100 @@ +CC ?= gcc + +TARGETS = utc_tizen_icu_api_uloc_getDefault_func \ + utc_tizen_icu_api_uloc_setDefault_func \ + utc_tizen_icu_api_uloc_getAvailable_func \ + utc_tizen_icu_api_uloc_getCountry_func \ + utc_tizen_icu_api_uloc_getDisplayCountry_func \ + utc_tizen_icu_api_uloc_getDisplayLanguage_func \ + utc_tizen_icu_api_uloc_getDisplayName_func \ + utc_tizen_icu_api_uloc_getDisplayVariant_func \ + utc_tizen_icu_api_uloc_getISO3Country_func \ + utc_tizen_icu_api_uloc_getISO3Language_func \ + utc_tizen_icu_api_uloc_getISOCountries_func \ + utc_tizen_icu_api_uloc_getISOLanguages_func \ + utc_tizen_icu_api_uloc_getLanguage_func \ + utc_tizen_icu_api_uloc_getVariant_func \ + utc_tizen_icu_api_ucal_clearField_func \ + utc_tizen_icu_api_ucal_clear_func \ + utc_tizen_icu_api_ucal_close_func \ + utc_tizen_icu_api_ucal_equivalentTo_func \ + utc_tizen_icu_api_ucal_getAvailable_func \ + utc_tizen_icu_api_ucal_getDefaultTimeZone_func \ + utc_tizen_icu_api_ucal_getDSTSavings_func \ + utc_tizen_icu_api_ucal_getLimit_func \ + utc_tizen_icu_api_ucal_getMillis_func \ + utc_tizen_icu_api_ucal_getTimeZoneDisplayName_func \ + utc_tizen_icu_api_ucal_inDaylightTime_func \ + utc_tizen_icu_api_ucal_isSet_func \ + utc_tizen_icu_api_ucal_open_func \ + utc_tizen_icu_api_ucal_roll_func \ + utc_tizen_icu_api_ucal_setDate_func \ + utc_tizen_icu_api_ucal_setDateTime_func \ + utc_tizen_icu_api_ucal_setDefaultTimeZone_func \ + utc_tizen_icu_api_ucal_set_func \ + utc_tizen_icu_api_ucal_setGregorianChange_func \ + utc_tizen_icu_api_ucal_setMillis_func \ + utc_tizen_icu_api_ucal_setTimeZone_func \ + utc_tizen_icu_api_ucnv_close_func \ + utc_tizen_icu_api_ucnv_compareNames_func \ + utc_tizen_icu_api_ucnv_convertEx_func \ + utc_tizen_icu_api_ucnv_countAvailable_func \ + utc_tizen_icu_api_ucnv_flushCache_func \ + utc_tizen_icu_api_u_errorName_func \ + utc_tizen_icu_api_u_strFromWCS_func \ + utc_tizen_icu_api_u_strToWCS_func \ + utc_tizen_icu_api_udat_close_func \ + utc_tizen_icu_api_udat_format_func \ + utc_tizen_icu_api_udat_getCalendar_func \ + utc_tizen_icu_api_udat_getSymbols_func \ + utc_tizen_icu_api_udat_isLenient_func \ + utc_tizen_icu_api_udat_open_func \ + utc_tizen_icu_api_udat_setLenient_func \ + utc_tizen_icu_api_udat_setSymbols_func \ + utc_tizen_icu_api_udat_toPatternRelativeDate_func \ + utc_tizen_icu_api_unum_close_func \ + utc_tizen_icu_api_unum_formatDecimal_func \ + utc_tizen_icu_api_unum_formatDouble_func \ + utc_tizen_icu_api_unum_format_func \ + utc_tizen_icu_api_unum_formatInt64_func \ + utc_tizen_icu_api_unum_open_func \ + utc_tizen_icu_api_unum_parseDecimal_func \ + utc_tizen_icu_api_unum_parseDouble_func \ + utc_tizen_icu_api_unum_parse_func \ + utc_tizen_icu_api_unum_parseInt64_func \ + utc_tizen_icu_api_ucnv_fromUChars_func \ + utc_tizen_icu_api_ucnv_fromUnicode_func \ + utc_tizen_icu_api_ucnv_getAlias_func \ + utc_tizen_icu_api_ucnv_getAvailableName_func \ + utc_tizen_icu_api_ucnv_getCanonicalName_func \ + utc_tizen_icu_api_ucnv_getDisplayName_func \ + utc_tizen_icu_api_ucnv_getMaxCharSize_func \ + utc_tizen_icu_api_ucnv_getMinCharSize_func \ + utc_tizen_icu_api_ucnv_getName_func \ + utc_tizen_icu_api_ucnv_open_func \ + utc_tizen_icu_api_ucnv_reset_func \ + utc_tizen_icu_api_ucnv_setFallback_func \ + utc_tizen_icu_api_ucnv_setFromUCallBack_func \ + utc_tizen_icu_api_ucnv_setToUCallBack_func \ + utc_tizen_icu_api_ucnv_toUChars_func \ + utc_tizen_icu_api_ucnv_toUnicode_func + + +PKGS= icu-i18n icu-io icu-le icu-lx icu-uc + +LDFLAGS= `pkg-config --libs $(PKGS)` +LDFLAGS+= $(TET_ROOT)/lib/tet3/tcm_s.o +LDFLAGS+= -L$(TET_ROOT)/lib/tet3 -ltcm_s +LDFLAGS+= -L$(TET_ROOT)/lib/tet3 -lapi_s + +CFLAGS= -I. `pkg-config --cflags $(PKGS)` +CFLAGS+= -I$(TET_ROOT)/inc/tet3 +CFLAGS+= -Wall + +all: $(TARGETS) + +$(TARGETS): %: %.c + $(CC) -o $@ $< $(CFLAGS) $(LDFLAGS) + +clean: + rm -f $(TARGETS) diff --git a/TC/unit/tc_gen.sh b/TC/unit/tc_gen.sh new file mode 100755 index 0000000..54f482d --- /dev/null +++ b/TC/unit/tc_gen.sh @@ -0,0 +1,28 @@ +#!/bin/sh + +TMPSTR=$0 +SCRIPT=${TMPSTR##*/} + +if [ $# -lt 2 ]; then + echo "Usage) $SCRIPT module_name api_name" + exit 1 +fi + +MODULE=$1 +API=$2 +TEMPLATE=utc_MODULE_API_func.c.in +TESTCASE=utc_${MODULE}_${API}_func + +sed -e ' + s^@API@^'"$API"'^g + s^@MODULE@^'"$MODULE"'^g + ' $TEMPLATE > $TESTCASE.c + +if [ ! -e "$TESTCASE.c" ]; then + echo "Failed" + exit 1 +fi +echo "Testcase file is $TESTCASE.c" +echo "Done" +echo "please put \"$TESTCASE\" as Target in Makefile" +echo "please put \"/unit/$TESTCASE\" in tslist" diff --git a/TC/unit/tslist b/TC/unit/tslist new file mode 100755 index 0000000..2636e7d --- /dev/null +++ b/TC/unit/tslist @@ -0,0 +1,78 @@ +/unit/utc_tizen_icu_api_uloc_getDefault_func +/unit/utc_tizen_icu_api_uloc_setDefault_func +/unit/utc_tizen_icu_api_uloc_getAvailable_func +/unit/utc_tizen_icu_api_uloc_getCountry_func +/unit/utc_tizen_icu_api_uloc_getDisplayCountry_func +/unit/utc_tizen_icu_api_uloc_getDisplayLanguage_func +/unit/utc_tizen_icu_api_uloc_getDisplayName_func +/unit/utc_tizen_icu_api_uloc_getDisplayVariant_func +/unit/utc_tizen_icu_api_uloc_getISO3Country_func +/unit/utc_tizen_icu_api_uloc_getISO3Language_func +/unit/utc_tizen_icu_api_uloc_getISOCountries_func +/unit/utc_tizen_icu_api_uloc_getISOLanguages_func +/unit/utc_tizen_icu_api_uloc_getLanguage_func +/unit/utc_tizen_icu_api_uloc_getVariant_func +/unit/utc_tizen_icu_api_ucal_clearField_func +/unit/utc_tizen_icu_api_ucal_clear_func +/unit/utc_tizen_icu_api_ucal_close_func +/unit/utc_tizen_icu_api_ucal_equivalentTo_func +/unit/utc_tizen_icu_api_ucal_getAvailable_func +/unit/utc_tizen_icu_api_ucal_getDefaultTimeZone_func +/unit/utc_tizen_icu_api_ucal_getDSTSavings_func +/unit/utc_tizen_icu_api_ucal_getLimit_func +/unit/utc_tizen_icu_api_ucal_getMillis_func +/unit/utc_tizen_icu_api_ucal_getTimeZoneDisplayName_func +/unit/utc_tizen_icu_api_ucal_inDaylightTime_func +/unit/utc_tizen_icu_api_ucal_isSet_func +/unit/utc_tizen_icu_api_ucal_open_func +/unit/utc_tizen_icu_api_ucal_roll_func +/unit/utc_tizen_icu_api_ucal_setDate_func +/unit/utc_tizen_icu_api_ucal_setDateTime_func +/unit/utc_tizen_icu_api_ucal_setDefaultTimeZone_func +/unit/utc_tizen_icu_api_ucal_set_func +/unit/utc_tizen_icu_api_ucal_setGregorianChange_func +/unit/utc_tizen_icu_api_ucal_setMillis_func +/unit/utc_tizen_icu_api_ucal_setTimeZone_func +/unit/utc_tizen_icu_api_ucnv_close_func +/unit/utc_tizen_icu_api_ucnv_compareNames_func +/unit/utc_tizen_icu_api_ucnv_convertEx_func +/unit/utc_tizen_icu_api_ucnv_countAvailable_func +/unit/utc_tizen_icu_api_ucnv_flushCache_func +/unit/utc_tizen_icu_api_u_errorName_func +/unit/utc_tizen_icu_api_u_strFromWCS_func +/unit/utc_tizen_icu_api_u_strToWCS_func +/unit/utc_tizen_icu_api_udat_close_func +/unit/utc_tizen_icu_api_udat_format_func +/unit/utc_tizen_icu_api_udat_getCalendar_func +/unit/utc_tizen_icu_api_udat_getSymbols_func +/unit/utc_tizen_icu_api_udat_isLenient_func +/unit/utc_tizen_icu_api_udat_open_func +/unit/utc_tizen_icu_api_udat_setLenient_func +/unit/utc_tizen_icu_api_udat_setSymbols_func +/unit/utc_tizen_icu_api_udat_toPatternRelativeDate_func +/unit/utc_tizen_icu_api_unum_close_func +/unit/utc_tizen_icu_api_unum_formatDecimal_func +/unit/utc_tizen_icu_api_unum_formatDouble_func +/unit/utc_tizen_icu_api_unum_format_func +/unit/utc_tizen_icu_api_unum_formatInt64_func +/unit/utc_tizen_icu_api_unum_open_func +/unit/utc_tizen_icu_api_unum_parseDecimal_func +/unit/utc_tizen_icu_api_unum_parseDouble_func +/unit/utc_tizen_icu_api_unum_parse_func +/unit/utc_tizen_icu_api_unum_parseInt64_func +/unit/utc_tizen_icu_api_ucnv_fromUChars_func +/unit/utc_tizen_icu_api_ucnv_fromUnicode_func +/unit/utc_tizen_icu_api_ucnv_getAlias_func +/unit/utc_tizen_icu_api_ucnv_getAvailableName_func +/unit/utc_tizen_icu_api_ucnv_getCanonicalName_func +/unit/utc_tizen_icu_api_ucnv_getDisplayName_func +/unit/utc_tizen_icu_api_ucnv_getMaxCharSize_func +/unit/utc_tizen_icu_api_ucnv_getMinCharSize_func +/unit/utc_tizen_icu_api_ucnv_getName_func +/unit/utc_tizen_icu_api_ucnv_open_func +/unit/utc_tizen_icu_api_ucnv_reset_func +/unit/utc_tizen_icu_api_ucnv_setFallback_func +/unit/utc_tizen_icu_api_ucnv_setFromUCallBack_func +/unit/utc_tizen_icu_api_ucnv_setToUCallBack_func +/unit/utc_tizen_icu_api_ucnv_toUChars_func +/unit/utc_tizen_icu_api_ucnv_toUnicode_func diff --git a/TC/unit/utc_MODULE_API_func.c.in b/TC/unit/utc_MODULE_API_func.c.in new file mode 100755 index 0000000..383a897 --- /dev/null +++ b/TC/unit/utc_MODULE_API_func.c.in @@ -0,0 +1,65 @@ +#include + +static void startup(void); +static void cleanup(void); + +void (*tet_startup)(void) = startup; +void (*tet_cleanup)(void) = cleanup; + +static void utc_@MODULE@_@API@_func_01(void); +static void utc_@MODULE@_@API@_func_02(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + { utc_@MODULE@_@API@_func_01, POSITIVE_TC_IDX }, + { utc_@MODULE@_@API@_func_02, NEGATIVE_TC_IDX }, + { NULL, 0 } +}; + +static void startup(void) +{ +} + +static void cleanup(void) +{ +} + +/** + * @brief Positive test case of @API@() + */ +static void utc_@MODULE@_@API@_func_01(void) +{ + int r = 0; + +/* + r = @API@(...); +*/ + if (r) { + tet_infoline("@API@() failed in positive test case"); + tet_result(TET_FAIL); + return; + } + tet_result(TET_PASS); +} + +/** + * @brief Negative test case of ug_init @API@() + */ +static void utc_@MODULE@_@API@_func_02(void) +{ + int r = 0; + +/* + r = @API@(...); +*/ + if (r) { + tet_infoline("@API@() failed in negative test case"); + tet_result(TET_FAIL); + return; + } + tet_result(TET_PASS); +} diff --git a/TC/unit/utc_tizen_icu_api_u_errorName_func.c b/TC/unit/utc_tizen_icu_api_u_errorName_func.c new file mode 100755 index 0000000..18b102f --- /dev/null +++ b/TC/unit/utc_tizen_icu_api_u_errorName_func.c @@ -0,0 +1,103 @@ + /* + * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jayoun Lee + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static void startup(void); +static void cleanup(void); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_tizen_icu_api_u_errorName_func_01(void); +static void utc_tizen_icu_api_u_errorName_func_02(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + {utc_tizen_icu_api_u_errorName_func_01, POSITIVE_TC_IDX}, + {utc_tizen_icu_api_u_errorName_func_02, NEGATIVE_TC_IDX}, + {NULL, 0} +}; + +static void startup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_u_errorName start"); + return; +} + +static void cleanup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_u_errorName ends "); + return; +} + +/** + * @brief Positive test case of utc_tizen_icu_api_u_errorName() + */ +static void utc_tizen_icu_api_u_errorName_func_01(void) +{ + const char *result = NULL; + + result = u_errorName(2); + if (result != NULL) { + tet_infoline("utc_tizen_icu_api_u_errorName test PASS!"); + tet_printf("error name for %d error code is %s\n", 2, result); + tet_result(TET_PASS); + } else { + tet_infoline("utc_tizen_icu_api_u_errorName test FAIL!"); + tet_result(TET_FAIL); + } + return; + +} + +/** + * @brief Negative test case of utc_tizen_icu_api_u_errorName() + * Giving wrong error code will return null + */ +static void utc_tizen_icu_api_u_errorName_func_02(void) +{ + const char *result = NULL; + int32_t U_INVALID_ERROR_CODE = -100; + /* Giving wrong error code will return null */ + result = u_errorName(U_INVALID_ERROR_CODE); + if (result != NULL) { + tet_infoline("utc_tizen_icu_api_u_errorName test PASS!"); + tet_printf("error name %s\n", result); + tet_result(TET_PASS); + } else { + tet_infoline("utc_tizen_icu_api_u_errorName test FAIL!"); + tet_result(TET_FAIL); + } + return; + +} diff --git a/TC/unit/utc_tizen_icu_api_u_strFromWCS_func.c b/TC/unit/utc_tizen_icu_api_u_strFromWCS_func.c new file mode 100755 index 0000000..198e4e0 --- /dev/null +++ b/TC/unit/utc_tizen_icu_api_u_strFromWCS_func.c @@ -0,0 +1,114 @@ + /* + * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jayoun Lee + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static void startup(void); +static void cleanup(void); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_tizen_icu_api_u_strFromWCS_func_01(void); +static void utc_tizen_icu_api_u_strFromWCS_func_02(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + {utc_tizen_icu_api_u_strFromWCS_func_01, POSITIVE_TC_IDX}, + {utc_tizen_icu_api_u_strFromWCS_func_02, NEGATIVE_TC_IDX}, + {NULL, 0} +}; + +static void startup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_u_strFromWCS start"); + return; +} + +static void cleanup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_u_strFromWCS ends "); + return; +} + +/** + * @brief Positive test case of utc_tizen_icu_api_u_strFromWCS() + */ +static void utc_tizen_icu_api_u_strFromWCS_func_01(void) +{ + UChar dest[50]; + int32_t dest_capacity = 50; + int32_t *pdest_len = &dest_capacity; + const wchar_t *src = L"hello world"; + int32_t src_len = 12; + UErrorCode status = U_ZERO_ERROR; + UChar *result = NULL; + + result = + u_strFromWCS(dest, dest_capacity, pdest_len, src, src_len, &status); + if (U_SUCCESS(status)) { + tet_infoline("utc_tizen_icu_api_u_strFromWCS test PASS!"); + tet_result(TET_PASS); + } else { + tet_infoline("utc_tizen_icu_api_u_strFromWCS test FAIL!"); + tet_printf("error code %s\n", u_errorName(status)); + tet_result(TET_FAIL); + } + return; + +} + +/** + * @brief Negative test case of utc_tizen_icu_api_u_strFromWCS() + * sending source as null will return error + */ +static void utc_tizen_icu_api_u_strFromWCS_func_02(void) +{ + UChar dest[50]; + int32_t dest_capacity = 50; + int32_t *pdest_len = &dest_capacity; + UErrorCode status = U_ZERO_ERROR; + UChar *result = NULL; + + result = + u_strFromWCS(dest, dest_capacity, pdest_len, NULL, -1, &status); + if (U_FAILURE(status)) { + tet_infoline("utc_tizen_icu_api_u_strFromWCS test PASS!"); + tet_result(TET_PASS); + } else { + tet_infoline("utc_tizen_icu_api_u_strFromWCS test FAIL!"); + tet_printf("error code %s\n", u_errorName(status)); + tet_result(TET_FAIL); + } + return; + +} diff --git a/TC/unit/utc_tizen_icu_api_u_strToWCS_func.c b/TC/unit/utc_tizen_icu_api_u_strToWCS_func.c new file mode 100755 index 0000000..1ffc983 --- /dev/null +++ b/TC/unit/utc_tizen_icu_api_u_strToWCS_func.c @@ -0,0 +1,113 @@ + /* + * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jayoun Lee + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static void startup(void); +static void cleanup(void); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_tizen_icu_api_u_strToWCS_func_01(void); +static void utc_tizen_icu_api_u_strToWCS_func_02(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + {utc_tizen_icu_api_u_strToWCS_func_01, POSITIVE_TC_IDX}, + {utc_tizen_icu_api_u_strToWCS_func_02, NEGATIVE_TC_IDX}, + {NULL, 0} +}; + +static void startup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_u_strToWCS start"); + return; +} + +static void cleanup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_u_strToWCS ends "); + return; +} + +/** + * @brief Positive test case of utc_tizen_icu_api_u_strToWCS() + */ +static void utc_tizen_icu_api_u_strToWCS_func_01(void) +{ + wchar_t dest[100]; + int32_t dest_capacity = 100; + int32_t *pdest_len = &dest_capacity; + const UChar *src = (const UChar *)"hello world"; + int32_t src_len = u_strlen(src); + UErrorCode status = U_ZERO_ERROR; + wchar_t *result = NULL; + + result = + u_strToWCS(dest, dest_capacity, pdest_len, src, src_len, &status); + if (U_SUCCESS(status)) { + tet_infoline("utc_tizen_icu_api_u_strToWCS test PASS!"); + tet_result(TET_PASS); + } else { + tet_infoline("utc_tizen_icu_api_u_strToWCS test FAIL!"); + tet_printf("error code %s\n", u_errorName(status)); + tet_result(TET_FAIL); + } + return; + +} + +/** + * @brief Negative test case of utc_tizen_icu_api_u_strToWCS() + * sending source as null will return error + */ +static void utc_tizen_icu_api_u_strToWCS_func_02(void) +{ + wchar_t dest[50]; + int32_t dest_capacity = 50; + int32_t *pdest_len = &dest_capacity; + UErrorCode status = U_ZERO_ERROR; + wchar_t *result = NULL; + + result = u_strToWCS(dest, dest_capacity, pdest_len, NULL, -1, &status); + if (U_FAILURE(status)) { + tet_infoline("utc_tizen_icu_api_u_strToWCS test PASS!"); + tet_result(TET_PASS); + } else { + tet_infoline("utc_tizen_icu_api_u_strToWCS test FAIL!"); + tet_printf("error code %s\n", u_errorName(status)); + tet_result(TET_FAIL); + } + return; + +} diff --git a/TC/unit/utc_tizen_icu_api_ucal_clearField_func.c b/TC/unit/utc_tizen_icu_api_ucal_clearField_func.c new file mode 100755 index 0000000..0a2833d --- /dev/null +++ b/TC/unit/utc_tizen_icu_api_ucal_clearField_func.c @@ -0,0 +1,91 @@ + /* + * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jayoun Lee + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static void startup(void); +static void cleanup(void); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_tizen_icu_api_ucal_clearField_func_01(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + {utc_tizen_icu_api_ucal_clearField_func_01, POSITIVE_TC_IDX}, + {NULL, 0} +}; + +static void startup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_ucal_clearField start"); + return; +} + +static void cleanup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_ucal_clearField ends "); + return; +} + +/** + * @brief Positive test case of utc_tizen_icu_api_ucal_clearField() + */ +static void utc_tizen_icu_api_ucal_clearField_func_01(void) +{ + UCalendar *cal = NULL; + UErrorCode status = U_ZERO_ERROR; + int32_t type = UCAL_DEFAULT; + int32_t field = UCAL_MONTH; + + cal = ucal_open(NULL, -1, NULL, type, &status); + if (U_SUCCESS(status) && (NULL != cal)) { + ucal_clearField(cal, field); + if (ucal_isSet(cal, field) == FALSE) { + tet_infoline + ("utc_tizen_icu_api_ucal_clearField test PASS!"); + tet_result(TET_PASS); + } else { + tet_infoline + ("utc_tizen_icu_api_ucal_clearField test FAIL!"); + tet_result(TET_FAIL); + } + } else { + tet_infoline("utc_tizen_icu_api_ucal_open test FAIL!"); + tet_printf("Error code %s", u_errorName(status)); + tet_result(TET_FAIL); + } + ucal_close(cal); + return; + +} diff --git a/TC/unit/utc_tizen_icu_api_ucal_clear_func.c b/TC/unit/utc_tizen_icu_api_ucal_clear_func.c new file mode 100755 index 0000000..1dfad29 --- /dev/null +++ b/TC/unit/utc_tizen_icu_api_ucal_clear_func.c @@ -0,0 +1,108 @@ + /* + * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jayoun Lee + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static void startup(void); +static void cleanup(void); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_tizen_icu_api_ucal_clear_func_01(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + {utc_tizen_icu_api_ucal_clear_func_01, POSITIVE_TC_IDX}, + {NULL, 0} +}; + +static void startup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_ucal_clear start"); + return; +} + +static void cleanup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_ucal_clear ends "); + return; +} + +/** + * @brief Positive test case of utc_tizen_icu_api_ucal_clear() + */ +static void utc_tizen_icu_api_ucal_clear_func_01(void) +{ + UCalendar *cal = NULL; + UErrorCode status = U_ZERO_ERROR; + int32_t type = UCAL_DEFAULT; + int32_t field[] = { UCAL_ERA, UCAL_YEAR, UCAL_MONTH, UCAL_WEEK_OF_YEAR, + UCAL_WEEK_OF_MONTH, UCAL_DATE, UCAL_DAY_OF_YEAR, + UCAL_DAY_OF_WEEK, UCAL_DAY_OF_WEEK_IN_MONTH, + UCAL_AM_PM, UCAL_HOUR, UCAL_HOUR_OF_DAY, + UCAL_MINUTE, UCAL_SECOND, UCAL_MILLISECOND, + UCAL_ZONE_OFFSET, UCAL_DST_OFFSET + }; + int32_t index = 0; + int32_t value = 1; + + cal = ucal_open(NULL, -1, NULL, type, &status); + if (U_SUCCESS(status) && (NULL != cal)) { + /* setting all the field in that calendar */ + for (index = 0; index < 17; index++) { + ucal_set(cal, field[index], value); + } + /* clear the entire calendar */ + ucal_clear(cal); + for (index = 0; index < 17; index++) { + if (!ucal_isSet(cal, field[index])) { + tet_infoline + ("utc_tizen_icu_api_ucal_open test PASS!"); + tet_result(TET_PASS); + + } else { + tet_infoline + ("utc_tizen_icu_api_ucal_open test FAIL!"); + tet_result(TET_FAIL); + } + } + + } else { + tet_infoline("utc_tizen_icu_api_ucal_open test FAIL!"); + tet_printf("Error code %s", u_errorName(status)); + tet_result(TET_FAIL); + } + ucal_close(cal); + return; + +} diff --git a/TC/unit/utc_tizen_icu_api_ucal_close_func.c b/TC/unit/utc_tizen_icu_api_ucal_close_func.c new file mode 100755 index 0000000..2b11520 --- /dev/null +++ b/TC/unit/utc_tizen_icu_api_ucal_close_func.c @@ -0,0 +1,84 @@ + /* + * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jayoun Lee + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static void startup(void); +static void cleanup(void); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_tizen_icu_api_ucal_close_func_01(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + {utc_tizen_icu_api_ucal_close_func_01, POSITIVE_TC_IDX}, + {NULL, 0} +}; + +static void startup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_ucal_close start"); + return; +} + +static void cleanup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_ucal_close ends "); + return; +} + +/** + * @brief Positive test case of utc_tizen_icu_api_ucal_close() + */ +static void utc_tizen_icu_api_ucal_close_func_01(void) +{ + UCalendar *cal = NULL; + UErrorCode status = U_ZERO_ERROR; + int32_t type = UCAL_DEFAULT; + + cal = ucal_open(NULL, -1, NULL, type, &status); + if (U_SUCCESS(status) && (NULL != cal)) { + ucal_close(cal); + tet_infoline("utc_tizen_icu_api_ucal_close test PASS!"); + tet_result(TET_PASS); + } + else { + tet_infoline("utc_tizen_icu_api_ucal_open test FAIL!"); + tet_printf("Error code %s", u_errorName(status)); + tet_result(TET_FAIL); + } + + return; + +} diff --git a/TC/unit/utc_tizen_icu_api_ucal_equivalentTo_func.c b/TC/unit/utc_tizen_icu_api_ucal_equivalentTo_func.c new file mode 100755 index 0000000..28b1597 --- /dev/null +++ b/TC/unit/utc_tizen_icu_api_ucal_equivalentTo_func.c @@ -0,0 +1,131 @@ + /* + * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jayoun Lee + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static void startup(void); +static void cleanup(void); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_tizen_icu_api_ucal_equivalentTo_func_01(void); +static void utc_tizen_icu_api_ucal_equivalentTo_func_02(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + {utc_tizen_icu_api_ucal_equivalentTo_func_01, POSITIVE_TC_IDX}, + {utc_tizen_icu_api_ucal_equivalentTo_func_02, NEGATIVE_TC_IDX}, + {NULL, 0} +}; + +static void startup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_ucal_equivalentTo start"); + return; +} + +static void cleanup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_ucal_equivalentTo ends "); + return; +} + +/** + * @brief Positive test case of utc_tizen_icu_api_ucal_equivalentTo() + */ +static void utc_tizen_icu_api_ucal_equivalentTo_func_01(void) +{ + UCalendar *cal1 = NULL; + UCalendar *cal2 = NULL; + UBool result; + UErrorCode status = U_ZERO_ERROR; + int32_t type = UCAL_DEFAULT; + + cal1 = ucal_open(NULL, -1, NULL, type, &status); + if (U_SUCCESS(status) && (NULL != cal1)) { + cal2 = cal1; + result = ucal_equivalentTo(cal1, cal2); + if (result) { + tet_infoline + ("utc_tizen_icu_api_ucal_equivalentTo test PASS!"); + tet_result(TET_PASS); + } else { + tet_infoline + ("utc_tizen_icu_api_ucal_equivalentTo test FAIL!"); + tet_result(TET_FAIL); + } + } else { + tet_infoline("utc_tizen_icu_api_ucal_open test FAIL!"); + tet_printf("Error code %s", u_errorName(status)); + tet_result(TET_FAIL); + } + ucal_close(cal1); + return; + +} + +/** + * @brief Negative test case of utc_tizen_icu_api_ucal_equivalentTo() + * camparing two calendar + */ +static void utc_tizen_icu_api_ucal_equivalentTo_func_02(void) +{ + UCalendar *cal1 = NULL; + UCalendar *cal2 = NULL; + UBool result; + UErrorCode status = U_ZERO_ERROR; + int32_t type = UCAL_DEFAULT; + + cal1 = ucal_open(NULL, -1, NULL, type, &status); + cal2 = ucal_open(NULL, -1, NULL, UCAL_GREGORIAN, &status); + + if (U_SUCCESS(status)) { + result = ucal_equivalentTo(cal1, cal2); + if (result == TRUE) { + tet_infoline + ("utc_tizen_icu_api_ucal_equivalentTo test PASS!"); + tet_result(TET_PASS); + } else { + tet_infoline + ("utc_tizen_icu_api_ucal_equivalentTo test FAIL!"); + tet_result(TET_FAIL); + } + } else { + tet_infoline("utc_tizen_icu_api_ucal_open test FAIL!"); + tet_printf("Error code %s", u_errorName(status)); + tet_result(TET_FAIL); + } + ucal_close(cal1); + return; + +} diff --git a/TC/unit/utc_tizen_icu_api_ucal_getAvailable_func.c b/TC/unit/utc_tizen_icu_api_ucal_getAvailable_func.c new file mode 100755 index 0000000..cc99201 --- /dev/null +++ b/TC/unit/utc_tizen_icu_api_ucal_getAvailable_func.c @@ -0,0 +1,103 @@ + /* + * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jayoun Lee + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static void startup(void); +static void cleanup(void); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_tizen_icu_api_ucal_getAvailable_func_01(void); +static void utc_tizen_icu_api_ucal_getAvailable_func_02(void); +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + {utc_tizen_icu_api_ucal_getAvailable_func_01, POSITIVE_TC_IDX}, + {utc_tizen_icu_api_ucal_getAvailable_func_02, POSITIVE_TC_IDX}, + {NULL, 0} +}; + +static void startup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_ucal_getAvailable start"); + return; +} + +static void cleanup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_ucal_getAvailable ends "); + return; +} + +/** + * @brief Positive test case of utc_tizen_icu_api_ucal_getAvailable() + */ +static void utc_tizen_icu_api_ucal_getAvailable_func_01(void) +{ + const char *calendar = NULL; + int32_t locale_index = 5; + + calendar = ucal_getAvailable(locale_index); + if (NULL != calendar) { + tet_infoline("utc_tizen_icu_api_ucal_getAvailable test PASS!"); + tet_printf("Calendar for the give locale %s\n", calendar); + tet_result(TET_PASS); + } else { + tet_infoline("utc_tizen_icu_api_ucal_getAvailable test FAIL!"); + tet_result(TET_FAIL); + } + + return; + +} + +/** + * @brief Negative test case of utc_tizen_icu_api_ucal_getAvailable() + * Invalid locale index will return null + */ +static void utc_tizen_icu_api_ucal_getAvailable_func_02(void) +{ + const char *calendar = NULL; + + calendar = ucal_getAvailable(-20); + if (NULL == calendar) { + tet_infoline("utc_tizen_icu_api_ucal_getAvailable test PASS!"); + tet_result(TET_PASS); + } else { + tet_infoline("utc_tizen_icu_api_ucal_getAvailable test FAIL!"); + tet_result(TET_FAIL); + } + + return; + +} diff --git a/TC/unit/utc_tizen_icu_api_ucal_getDSTSavings_func.c b/TC/unit/utc_tizen_icu_api_ucal_getDSTSavings_func.c new file mode 100755 index 0000000..d1df840 --- /dev/null +++ b/TC/unit/utc_tizen_icu_api_ucal_getDSTSavings_func.c @@ -0,0 +1,81 @@ + /* + * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jayoun Lee + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static void startup(void); +static void cleanup(void); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_tizen_icu_api_ucal_getDSTSavings_func_01(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + {utc_tizen_icu_api_ucal_getDSTSavings_func_01, POSITIVE_TC_IDX}, + {NULL, 0} +}; + +static void startup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_ucal_getDSTSavings start"); + return; +} + +static void cleanup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_ucal_getDSTSavings ends "); + return; +} + +/** + * @brief Positive test case of utc_tizen_icu_api_ucal_getDSTSavings() + */ +static void utc_tizen_icu_api_ucal_getDSTSavings_func_01(void) +{ + UErrorCode status = U_ZERO_ERROR; + int32_t result; + + result = ucal_getDSTSavings((const UChar *)"PST", &status); + if (U_SUCCESS(status)) { + tet_infoline("utc_tizen_icu_api_ucal_getDSTSavings test PASS!"); + tet_printf("DST Saving %d\n", result); + tet_result(TET_PASS); + } else { + tet_infoline("utc_tizen_icu_api_ucal_getDSTSavings test FAIL!"); + tet_result(TET_FAIL); + } + + return; + +} diff --git a/TC/unit/utc_tizen_icu_api_ucal_getDefaultTimeZone_func.c b/TC/unit/utc_tizen_icu_api_ucal_getDefaultTimeZone_func.c new file mode 100755 index 0000000..f8b323b --- /dev/null +++ b/TC/unit/utc_tizen_icu_api_ucal_getDefaultTimeZone_func.c @@ -0,0 +1,114 @@ + /* + * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jayoun Lee + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static void startup(void); +static void cleanup(void); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_tizen_icu_api_ucal_getDefaultTimeZone_func_01(void); +static void utc_tizen_icu_api_ucal_getDefaultTimeZone_func_02(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + {utc_tizen_icu_api_ucal_getDefaultTimeZone_func_01, POSITIVE_TC_IDX}, + {utc_tizen_icu_api_ucal_getDefaultTimeZone_func_02, POSITIVE_TC_IDX}, + {NULL, 0} +}; + +static void startup(void) +{ + tet_infoline + ("Testing API utc_tizen_icu_api_ucal_getDefaultTimeZone start"); + return; +} + +static void cleanup(void) +{ + tet_infoline + ("Testing API utc_tizen_icu_api_ucal_getDefaultTimeZone ends "); + return; +} + +/** + * @brief Positive test case of utc_tizen_icu_api_ucal_getDefaultTimeZone() + */ +static void utc_tizen_icu_api_ucal_getDefaultTimeZone_func_01(void) +{ + UErrorCode status = U_ZERO_ERROR; + UChar result[20] = { 0, }; + int32_t result_capacity = 20; + int32_t ret; + + ret = ucal_getDefaultTimeZone(result, result_capacity, &status); + if (U_SUCCESS(status) && (0 != ret)) { + tet_infoline + ("utc_tizen_icu_api_ucal_getDefaultTimeZone test PASS!"); + tet_printf("Default time zone is %s\n", result); + tet_result(TET_PASS); + } else { + tet_infoline + ("utc_tizen_icu_api_ucal_getDefaultTimeZone test FAIL!"); + tet_printf("Error code %s", u_errorName(status)); + tet_result(TET_FAIL); + } + + return; +} + +/** + * @brief Negative test case of utc_tizen_icu_api_ucal_getDefaultTimeZone() + * checks if null sends as a result arg will return buffer overflow error status + */ +static void utc_tizen_icu_api_ucal_getDefaultTimeZone_func_02(void) +{ + UErrorCode status = U_ZERO_ERROR; + int32_t ret; + + ret = ucal_getDefaultTimeZone(NULL, 0, &status); + if (U_FAILURE(status)) { + tet_infoline + ("utc_tizen_icu_api_ucal_getDefaultTimeZone test PASS!"); + tet_result(TET_PASS); + } else { + tet_infoline + ("utc_tizen_icu_api_ucal_getDefaultTimeZone test FAIL!"); + tet_printf("Error code %s", u_errorName(status)); + tet_result(TET_FAIL); + } + + return; + +} diff --git a/TC/unit/utc_tizen_icu_api_ucal_getLimit_func.c b/TC/unit/utc_tizen_icu_api_ucal_getLimit_func.c new file mode 100755 index 0000000..2737200 --- /dev/null +++ b/TC/unit/utc_tizen_icu_api_ucal_getLimit_func.c @@ -0,0 +1,161 @@ + /* + * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jayoun Lee + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static void startup(void); +static void cleanup(void); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_tizen_icu_api_ucal_getLimit_func_01(void); +static void utc_tizen_icu_api_ucal_getLimit_func_02(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + {utc_tizen_icu_api_ucal_getLimit_func_01, POSITIVE_TC_IDX}, + {utc_tizen_icu_api_ucal_getLimit_func_02, NEGATIVE_TC_IDX}, + {NULL, 0} +}; + +static void startup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_ucal_getLimit start"); + return; +} + +static void cleanup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_ucal_getLimit ends "); + return; +} + +/** + * @brief Positive test case of utc_tizen_icu_api_ucal_getLimit() + */ +static void utc_tizen_icu_api_ucal_getLimit_func_01(void) +{ + UCalendar *cal = NULL; + UErrorCode status = U_ZERO_ERROR; + int32_t type = UCAL_DEFAULT; + int32_t field[] = { UCAL_ERA, UCAL_YEAR, UCAL_MONTH, UCAL_WEEK_OF_YEAR, + UCAL_WEEK_OF_MONTH, UCAL_DATE, UCAL_DAY_OF_YEAR, + UCAL_DAY_OF_WEEK, UCAL_DAY_OF_WEEK_IN_MONTH, + UCAL_AM_PM, UCAL_HOUR, UCAL_HOUR_OF_DAY, + UCAL_MINUTE, UCAL_SECOND, UCAL_MILLISECOND, + UCAL_ZONE_OFFSET, UCAL_DST_OFFSET + }; + int32_t index = 0; + int32_t limit_type[] = + { UCAL_MINIMUM, UCAL_MAXIMUM, UCAL_GREATEST_MINIMUM, + UCAL_LEAST_MAXIMUM, UCAL_ACTUAL_MINIMUM, UCAL_ACTUAL_MAXIMUM + }; + int32_t value = 1; + int32_t result = 0; + int32_t lp_cnt = 0; + + cal = ucal_open(NULL, -1, NULL, type, &status); + if (U_SUCCESS(status) && (NULL != cal)) { + for (index = 0; index < 17; index++) { + ucal_set(cal, field[index], value); + if (ucal_isSet(cal, field[index])) { + for (lp_cnt = 0; lp_cnt < 6; lp_cnt++) { + result = + ucal_getLimit(cal, field[index], + limit_type[lp_cnt], + &status); + if (U_SUCCESS(status)) { + tet_infoline + ("utc_tizen_icu_api_ucal_getLimit test PASS!"); + tet_result(TET_PASS); + + } else { + tet_infoline + ("utc_tizen_icu_api_ucal_getLimit test FAIL!"); + tet_printf("Error code %s", + u_errorName(status)); + tet_result(TET_FAIL); + } + } + + } else { + tet_infoline + ("utc_tizen_icu_api_ucal_open test FAIL!"); + tet_printf("Error code %s", + u_errorName(status)); + tet_result(TET_FAIL); + } + } + } else { + tet_infoline("utc_tizen_icu_api_ucal_open test FAIL!"); + tet_printf("Error code %s", u_errorName(status)); + tet_result(TET_FAIL); + } + + ucal_close(cal); + return; + +} + +/** + * @brief Negative test case of utc_tizen_icu_api_ucal_getLimit() + * if status is null will return error + */ +static void utc_tizen_icu_api_ucal_getLimit_func_02(void) +{ + UCalendar *cal = NULL; + UErrorCode status = U_ZERO_ERROR; + int32_t type = UCAL_DEFAULT; + int32_t field = UCAL_ERA; + int32_t limit_type = UCAL_GREATEST_MINIMUM; + int32_t result = 0; + + cal = ucal_open(NULL, -1, NULL, type, &status); + if (U_SUCCESS(status) && (NULL != cal)) { + result = ucal_getLimit(cal, field, limit_type, NULL); + if (result) { + tet_infoline("utc_tizen_icu_api_ucal_getLimit test PASS!"); + tet_result(TET_PASS); + + } else { + tet_infoline("utc_tizen_icu_api_ucal_getLimit test FAIL!"); + tet_printf("Error code %s", u_errorName(status)); + tet_result(TET_FAIL); + } + } else { + tet_infoline("utc_tizen_icu_api_ucal_open test FAIL!"); + tet_printf("Error code %s", u_errorName(status)); + tet_result(TET_FAIL); + } + return; +} diff --git a/TC/unit/utc_tizen_icu_api_ucal_getMillis_func.c b/TC/unit/utc_tizen_icu_api_ucal_getMillis_func.c new file mode 100755 index 0000000..6a14b5c --- /dev/null +++ b/TC/unit/utc_tizen_icu_api_ucal_getMillis_func.c @@ -0,0 +1,93 @@ + /* + * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jayoun Lee + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static void startup(void); +static void cleanup(void); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_tizen_icu_api_ucal_getMillis_func_01(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + {utc_tizen_icu_api_ucal_getMillis_func_01, POSITIVE_TC_IDX}, + {NULL, 0} +}; + +static void startup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_ucal_getMillis start"); + return; +} + +static void cleanup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_ucal_getMillis ends "); + return; +} + +/** + * @brief Positive test case of utc_tizen_icu_api_ucal_getMillis() + */ +static void utc_tizen_icu_api_ucal_getMillis_func_01(void) +{ + UCalendar *cal = NULL; + UErrorCode status = U_ZERO_ERROR; + int32_t type = UCAL_DEFAULT; + UDate date; + + cal = ucal_open(NULL, -1, NULL, type, &status); + if (U_SUCCESS(status) && (NULL != cal)) { + date = ucal_getMillis(cal, &status); + if (U_SUCCESS(status)) { + tet_infoline + ("utc_tizen_icu_api_ucal_getMillis test PASS!"); + tet_printf("The current time in millis %ld\n", date); + tet_result(TET_PASS); + } else { + tet_infoline + ("utc_tizen_icu_api_ucal_getMillis test FAIL!"); + tet_printf("Error code %s", u_errorName(status)); + tet_result(TET_FAIL); + } + } else { + tet_infoline("utc_tizen_icu_api_ucal_open test FAIL!"); + tet_printf("Error code %s", u_errorName(status)); + tet_result(TET_FAIL); + } + ucal_close(cal); + return; + +} diff --git a/TC/unit/utc_tizen_icu_api_ucal_getTimeZoneDisplayName_func.c b/TC/unit/utc_tizen_icu_api_ucal_getTimeZoneDisplayName_func.c new file mode 100755 index 0000000..ba8db66 --- /dev/null +++ b/TC/unit/utc_tizen_icu_api_ucal_getTimeZoneDisplayName_func.c @@ -0,0 +1,102 @@ + /* + * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jayoun Lee + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static void startup(void); +static void cleanup(void); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_tizen_icu_api_ucal_getTimeZoneDisplayName_func_01(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + {utc_tizen_icu_api_ucal_getTimeZoneDisplayName_func_01, + POSITIVE_TC_IDX}, + {NULL, 0} +}; + +static void startup(void) +{ + tet_infoline + ("Testing API utc_tizen_icu_api_ucal_getTimeZoneDisplayName start"); + return; +} + +static void cleanup(void) +{ + tet_infoline + ("Testing API utc_tizen_icu_api_ucal_getTimeZoneDisplayName ends "); + return; +} + +/** + * @brief Positive test case of utc_tizen_icu_api_ucal_getTimeZoneDisplayName() + */ +static void utc_tizen_icu_api_ucal_getTimeZoneDisplayName_func_01(void) +{ + UCalendar *cal = NULL; + UErrorCode status = U_ZERO_ERROR; + int32_t type = UCAL_DEFAULT; + int32_t display_type = UCAL_STANDARD; + UChar result[20] = { 0, }; + int32_t ret = 0; + + cal = ucal_open(NULL, -1, NULL, type, &status); + if (U_SUCCESS(status) && (NULL != cal)) { + ret = ucal_getTimeZoneDisplayName(cal, display_type, + NULL, result, 20, + &status); + if (U_SUCCESS(status)) { + tet_printf("Time zone Display Name %s\n", + result); + tet_infoline + ("utc_tizen_icu_api_ucal_getTimeZoneDisplayName test PASS!"); + tet_result(TET_PASS); + } else { + tet_infoline + ("utc_tizen_icu_api_ucal_getTimeZoneDisplayName test FAIL!"); + tet_printf("Error name %s\n", + u_errorName(status)); + tet_result(TET_FAIL); + } + } else { + tet_infoline("utc_tizen_icu_api_ucal_open test FAIL!"); + tet_printf("Error code %s\n", u_errorName(status)); + tet_result(TET_FAIL); + } + + ucal_close(cal); + return; +} diff --git a/TC/unit/utc_tizen_icu_api_ucal_inDaylightTime_func.c b/TC/unit/utc_tizen_icu_api_ucal_inDaylightTime_func.c new file mode 100755 index 0000000..808af00 --- /dev/null +++ b/TC/unit/utc_tizen_icu_api_ucal_inDaylightTime_func.c @@ -0,0 +1,93 @@ + /* + * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jayoun Lee + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static void startup(void); +static void cleanup(void); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_tizen_icu_api_ucal_inDaylightTime_func_01(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + {utc_tizen_icu_api_ucal_inDaylightTime_func_01, POSITIVE_TC_IDX}, + {NULL, 0} +}; + +static void startup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_ucal_inDaylightTime start"); + return; +} + +static void cleanup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_ucal_inDaylightTime ends "); + return; +} + +/** + * @brief Positive test case of utc_tizen_icu_api_ucal_inDaylightTime() + */ +static void utc_tizen_icu_api_ucal_inDaylightTime_func_01(void) +{ + UCalendar *cal = NULL; + UErrorCode status = U_ZERO_ERROR; + int32_t type = UCAL_DEFAULT; + UBool result; + + cal = ucal_open(NULL, -1, NULL, type, &status); + if (U_SUCCESS(status) && (NULL != cal)) { + result = ucal_inDaylightTime(cal, &status); + if (U_SUCCESS(status)) { + tet_infoline + ("utc_tizen_icu_api_ucal_inDaylightTime test PASS!"); + tet_result(TET_PASS); + } else { + tet_infoline + ("utc_tizen_icu_api_ucal_inDaylightTime test FAIL!"); + tet_printf("Error code %s", u_errorName(status)); + tet_result(TET_FAIL); + } + + } else { + tet_infoline("utc_tizen_icu_api_ucal_open test FAIL!"); + tet_printf("Error code %s", u_errorName(status)); + tet_result(TET_FAIL); + } + + return; + +} diff --git a/TC/unit/utc_tizen_icu_api_ucal_isSet_func.c b/TC/unit/utc_tizen_icu_api_ucal_isSet_func.c new file mode 100755 index 0000000..e8fc031 --- /dev/null +++ b/TC/unit/utc_tizen_icu_api_ucal_isSet_func.c @@ -0,0 +1,125 @@ + /* + * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jayoun Lee + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static void startup(void); +static void cleanup(void); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_tizen_icu_api_ucal_isSet_func_01(void); +static void utc_tizen_icu_api_ucal_isSet_func_02(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + {utc_tizen_icu_api_ucal_isSet_func_01, POSITIVE_TC_IDX}, + {utc_tizen_icu_api_ucal_isSet_func_02, POSITIVE_TC_IDX}, + {NULL, 0} +}; + +static void startup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_ucal_isSet start"); + return; +} + +static void cleanup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_ucal_isSet ends "); + return; +} + +/** + * @brief Positive test case of utc_tizen_icu_api_ucal_isSet() + */ +static void utc_tizen_icu_api_ucal_isSet_func_01(void) +{ + UCalendar *cal = NULL; + UErrorCode status = U_ZERO_ERROR; + int32_t type = UCAL_DEFAULT; + int32_t field = UCAL_MONTH; + UBool result; + int32_t value = UCAL_JANUARY; + + cal = ucal_open(NULL, -1, NULL, type, &status); + if (U_SUCCESS(status) && (NULL != cal)) { + ucal_set(cal, field, value); + result = ucal_isSet(cal, field); + if (result) { + tet_infoline("utc_tizen_icu_api_ucal_isSet test PASS!"); + tet_result(TET_PASS); + } else { + tet_infoline("utc_tizen_icu_api_ucal_isSet test FAIL!"); + tet_result(TET_FAIL); + } + } else { + tet_infoline("utc_tizen_icu_api_ucal_open test FAIL!"); + tet_printf("Error code %s", u_errorName(status)); + tet_result(TET_FAIL); + } + ucal_close(cal); + return; +} + +/** + * @brief Negative test case of utc_tizen_icu_api_ucal_isSet() + * verify after clearing the field it should show false + */ +static void utc_tizen_icu_api_ucal_isSet_func_02(void) +{ + UCalendar *cal = NULL; + UErrorCode status = U_ZERO_ERROR; + int32_t type = UCAL_DEFAULT; + int32_t field = UCAL_MONTH; + UBool result; + + cal = ucal_open(NULL, -1, NULL, type, &status); + if (U_SUCCESS(status) && (NULL != cal)) { + ucal_clearField(cal, field); + result = ucal_isSet(cal, field); + if (result == FALSE) { + tet_infoline("utc_tizen_icu_api_ucal_isSet test PASS!"); + tet_result(TET_PASS); + } else { + tet_infoline("utc_tizen_icu_api_ucal_isSet test FAIL!"); + tet_result(TET_FAIL); + } + } else { + tet_infoline("utc_tizen_icu_api_ucal_open test FAIL!"); + tet_printf("Error code %s", u_errorName(status)); + tet_result(TET_FAIL); + } + ucal_close(cal); + return; +} diff --git a/TC/unit/utc_tizen_icu_api_ucal_open_func.c b/TC/unit/utc_tizen_icu_api_ucal_open_func.c new file mode 100755 index 0000000..3b9e3ec --- /dev/null +++ b/TC/unit/utc_tizen_icu_api_ucal_open_func.c @@ -0,0 +1,113 @@ + /* + * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jayoun Lee + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static void startup(void); +static void cleanup(void); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_tizen_icu_api_ucal_open_func_01(void); +static void utc_tizen_icu_api_ucal_open_func_02(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + {utc_tizen_icu_api_ucal_open_func_01, POSITIVE_TC_IDX}, + {utc_tizen_icu_api_ucal_open_func_02, NEGATIVE_TC_IDX}, + {NULL, 0} +}; + +static void startup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_ucal_open start"); + return; +} + +static void cleanup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_ucal_open ends "); + return; +} + +/** + * @brief Positive test case of utc_tizen_icu_api_ucal_open() + */ +static void utc_tizen_icu_api_ucal_open_func_01(void) +{ + UCalendar *cal = NULL; + UErrorCode status = U_ZERO_ERROR; + int32_t type[] = { UCAL_TRADITIONAL, UCAL_GREGORIAN }; + int32_t index; + + for (index = 0; index < 2; index++) { + status = U_ZERO_ERROR; + cal = + ucal_open((const UChar *)"PST", -1, NULL, type[index], + &status); + if (U_SUCCESS(status) ) { + tet_infoline("utc_tizen_icu_api_ucal_open test PASS!"); + tet_result(TET_PASS); + } else { + tet_infoline("utc_tizen_icu_api_ucal_open test FAIL!"); + tet_printf("Error code %s\n", u_errorName(status)); + tet_result(TET_FAIL); + } + ucal_close(cal); + } + return; +} + +/** + * @brief Negative test case of utc_tizen_icu_api_ucal_open() + * sending time zone as null will take default time zone + */ +static void utc_tizen_icu_api_ucal_open_func_02(void) +{ + UCalendar *cal = NULL; + UErrorCode status = U_ZERO_ERROR; + int32_t type = UCAL_DEFAULT; + + cal = ucal_open(NULL, -1, NULL, type, &status); + if (U_SUCCESS(status)) { + tet_infoline("utc_tizen_icu_api_ucal_open test PASS!"); + tet_result(TET_PASS); + } else { + tet_infoline("utc_tizen_icu_api_ucal_open test FAIL!"); + tet_printf("Error code %s\n", u_errorName(status)); + tet_result(TET_FAIL); + } + ucal_close(cal); + return; + +} diff --git a/TC/unit/utc_tizen_icu_api_ucal_roll_func.c b/TC/unit/utc_tizen_icu_api_ucal_roll_func.c new file mode 100755 index 0000000..1a3eebd --- /dev/null +++ b/TC/unit/utc_tizen_icu_api_ucal_roll_func.c @@ -0,0 +1,101 @@ + /* + * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jayoun Lee + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static void startup(void); +static void cleanup(void); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_tizen_icu_api_ucal_roll_func_01(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + {utc_tizen_icu_api_ucal_roll_func_01, POSITIVE_TC_IDX}, + {NULL, 0} +}; + +static void startup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_ucal_roll start"); + return; +} + +static void cleanup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_ucal_roll ends "); + return; +} + +/** + * @brief Positive test case of utc_tizen_icu_api_ucal_roll() + */ +static void utc_tizen_icu_api_ucal_roll_func_01(void) +{ + UCalendar *cal = NULL; + UErrorCode status = U_ZERO_ERROR; + int32_t type = UCAL_DEFAULT; + int32_t field[] = { UCAL_ERA, UCAL_YEAR, UCAL_MONTH, UCAL_WEEK_OF_YEAR, + UCAL_WEEK_OF_MONTH, UCAL_DATE, UCAL_DAY_OF_YEAR, + UCAL_DAY_OF_WEEK, UCAL_DAY_OF_WEEK_IN_MONTH, + UCAL_AM_PM, UCAL_HOUR, UCAL_HOUR_OF_DAY, + UCAL_MINUTE, UCAL_SECOND, UCAL_MILLISECOND, + UCAL_ZONE_OFFSET, UCAL_DST_OFFSET + }; + int32_t index = 0; + int32_t amount = 1; + + cal = ucal_open(NULL, -1, NULL, type, &status); + if (U_SUCCESS(status)) { + for (index = 0; index < 15; index++) { + ucal_roll(cal, field[index], amount, &status); + if (U_SUCCESS(status)) { + tet_infoline + ("utc_tizen_icu_api_ucal_roll test PASS!"); + tet_result(TET_PASS); + } else { + tet_infoline + ("utc_tizen_icu_api_ucal_roll test FAIL!"); + tet_result(TET_FAIL); + } + } + } else { + tet_infoline("utc_tizen_icu_api_ucal_open test FAIL!"); + tet_printf("Error code %s\n", u_errorName(status)); + tet_result(TET_FAIL); + } + ucal_close(cal); + return; + +} diff --git a/TC/unit/utc_tizen_icu_api_ucal_setDateTime_func.c b/TC/unit/utc_tizen_icu_api_ucal_setDateTime_func.c new file mode 100755 index 0000000..1be3222 --- /dev/null +++ b/TC/unit/utc_tizen_icu_api_ucal_setDateTime_func.c @@ -0,0 +1,142 @@ + /* + * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jayoun Lee + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static void startup(void); +static void cleanup(void); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_tizen_icu_api_ucal_setDateTime_func_01(void); +static void utc_tizen_icu_api_ucal_setDateTime_func_02(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + {utc_tizen_icu_api_ucal_setDateTime_func_01, POSITIVE_TC_IDX}, + {utc_tizen_icu_api_ucal_setDateTime_func_02, NEGATIVE_TC_IDX}, + {NULL, 0} +}; + +static void startup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_ucal_setDateTime start"); + return; +} + +static void cleanup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_ucal_setDateTime ends "); + return; +} + +/** + * @brief Postive test case of utc_tizen_icu_api_ucal_setDateTime() + */ +static void utc_tizen_icu_api_ucal_setDateTime_func_01(void) +{ + UCalendar *cal = NULL; + UErrorCode status = U_ZERO_ERROR; + int32_t type = UCAL_DEFAULT; + int32_t year = 2012; + int32_t month = UCAL_MARCH; + int32_t date = 10; + int32_t hour = 0; + int32_t minute = 0; + int32_t second = 0; + + cal = ucal_open(NULL, -1, NULL, type, &status); + if (U_SUCCESS(status) && (NULL != cal)) { + ucal_setDateTime(cal, year, month, date, hour, minute, second, + &status); + if (U_SUCCESS(status)) { + tet_infoline + ("utc_tizen_icu_api_ucal_setDateTime test PASS!"); + tet_printf("The current time in millis %ld\n", date); + tet_result(TET_PASS); + } else { + tet_infoline + ("utc_tizen_icu_api_ucal_setDateTime test FAIL!"); + tet_printf("Error code %s\n", u_errorName(status)); + tet_result(TET_FAIL); + } + } else { + tet_infoline("utc_tizen_icu_api_ucal_open test FAIL!"); + tet_printf("Error code %s\n", u_errorName(status)); + tet_result(TET_FAIL); + } + ucal_close(cal); + return; + +} +/** + * @brief Negative test case of utc_tizen_icu_api_ucal_setDateTime() + * Invalid miniute will give error + */ +static void utc_tizen_icu_api_ucal_setDateTime_func_02(void) +{ + UCalendar *cal = NULL; + UErrorCode status = U_ZERO_ERROR; + int32_t type = UCAL_DEFAULT; + int32_t year = 2012; + int32_t month = UCAL_MARCH; + int32_t date = 10; + int32_t hour = 0; + int32_t minute = 80; /* invalid minute*/ + int32_t second = 0; + + cal = ucal_open(NULL, -1, NULL, type, &status); + if (U_SUCCESS(status) && (NULL != cal)) { + ucal_setDateTime(cal, year, month, date, hour, minute, second, + &status); + if (U_SUCCESS(status)) { /* It will give fallback warning*/ + tet_infoline + ("utc_tizen_icu_api_ucal_setDateTime test PASS!"); + tet_printf("The current time in millis %ld\n", date); + tet_result(TET_PASS); + } else { + tet_infoline + ("utc_tizen_icu_api_ucal_setDateTime test FAIL!"); + tet_printf("Error code %s\n", u_errorName(status)); + tet_result(TET_FAIL); + } + } else { + tet_infoline("utc_tizen_icu_api_ucal_open test FAIL!"); + tet_printf("Error code %s\n", u_errorName(status)); + tet_result(TET_FAIL); + } + ucal_close(cal); + return; + +} + diff --git a/TC/unit/utc_tizen_icu_api_ucal_setDate_func.c b/TC/unit/utc_tizen_icu_api_ucal_setDate_func.c new file mode 100755 index 0000000..f56de9c --- /dev/null +++ b/TC/unit/utc_tizen_icu_api_ucal_setDate_func.c @@ -0,0 +1,132 @@ + /* + * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jayoun Lee + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static void startup(void); +static void cleanup(void); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_tizen_icu_api_ucal_setDate_func_01(void); +static void utc_tizen_icu_api_ucal_setDate_func_02(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + {utc_tizen_icu_api_ucal_setDate_func_01, POSITIVE_TC_IDX}, + {utc_tizen_icu_api_ucal_setDate_func_02, NEGATIVE_TC_IDX}, + {NULL, 0} +}; + +static void startup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_ucal_setDate start"); + return; +} + +static void cleanup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_ucal_setDate ends "); + return; +} + +/** + * @brief Positive test case of utc_tizen_icu_api_ucal_setDate() + */ +static void utc_tizen_icu_api_ucal_setDate_func_01(void) +{ + UCalendar *cal = NULL; + UErrorCode status = U_ZERO_ERROR; + int32_t type = UCAL_DEFAULT; + int32_t year = 2012; + int32_t month = UCAL_MARCH; + int32_t date = 10; + cal = ucal_open(NULL, -1, NULL, type, &status); + if (U_SUCCESS(status) && (NULL != cal)) { + ucal_setDate(cal, year, month, date, &status); + if (U_SUCCESS(status)) { + tet_infoline + ("utc_tizen_icu_api_ucal_setDate test PASS!"); + tet_printf("The current time in millis %ld\n", date); + tet_result(TET_PASS); + } else { + tet_infoline + ("utc_tizen_icu_api_ucal_setDate test FAIL!"); + tet_printf("Error code %s", u_errorName(status)); + tet_result(TET_FAIL); + } + } else { + tet_infoline("utc_tizen_icu_api_ucal_open test FAIL!"); + tet_printf("Error code %s\n", u_errorName(status)); + tet_result(TET_FAIL); + } + ucal_close(cal); + return; + +} + +/** + * @brief Negative test case of utc_tizen_icu_api_ucal_setDate() + * calling this API without opening the calendar handler + */ +static void utc_tizen_icu_api_ucal_setDate_func_02(void) +{ + UCalendar *cal = NULL; + UErrorCode status = U_ZERO_ERROR; + int32_t type = UCAL_DEFAULT; + int32_t year = 2012; + int32_t month = UCAL_MARCH; + int32_t date = 32; /* invalid date */ + cal = ucal_open(NULL, -1, NULL, type, &status); + if (U_SUCCESS(status)) { + ucal_setDate(cal, year, month, date, &status); + if (U_SUCCESS(status)) { /* it will give fallback waring*/ + tet_infoline + ("utc_tizen_icu_api_ucal_setDate test PASS!"); + tet_printf("The current time in millis %ld\n", date); + tet_result(TET_PASS); + } else { + tet_infoline + ("utc_tizen_icu_api_ucal_setDate test FAIL!"); + tet_printf("Error code %s", u_errorName(status)); + tet_result(TET_FAIL); + } + } else { + tet_infoline("utc_tizen_icu_api_ucal_open test FAIL!"); + tet_printf("Error code %s\n", u_errorName(status)); + tet_result(TET_FAIL); + } + ucal_close(cal); + return; + +} diff --git a/TC/unit/utc_tizen_icu_api_ucal_setDefaultTimeZone_func.c b/TC/unit/utc_tizen_icu_api_ucal_setDefaultTimeZone_func.c new file mode 100755 index 0000000..0f5b9fe --- /dev/null +++ b/TC/unit/utc_tizen_icu_api_ucal_setDefaultTimeZone_func.c @@ -0,0 +1,85 @@ + /* + * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jayoun Lee + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static void startup(void); +static void cleanup(void); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_tizen_icu_api_ucal_setDefaultTimeZone_func_01(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + {utc_tizen_icu_api_ucal_setDefaultTimeZone_func_01, POSITIVE_TC_IDX}, + {NULL, 0} +}; + +static void startup(void) +{ + tet_infoline + ("Testing API utc_tizen_icu_api_ucal_setDefaultTimeZone start"); + return; +} + +static void cleanup(void) +{ + tet_infoline + ("Testing API utc_tizen_icu_api_ucal_setDefaultTimeZone ends "); + return; +} + +/** + * @brief Positive test case of utc_tizen_icu_api_ucal_setDefaultTimeZone() + */ +static void utc_tizen_icu_api_ucal_setDefaultTimeZone_func_01(void) +{ + UErrorCode status = U_ZERO_ERROR; + + ucal_setDefaultTimeZone((const UChar *)"PST", &status); + if (U_SUCCESS(status)) { + tet_infoline + ("utc_tizen_icu_api_ucal_setDefaultTimeZone test PASS!"); + tet_result(TET_PASS); + } else { + tet_infoline + ("utc_tizen_icu_api_ucal_setDefaultTimeZone test FAIL!"); + tet_printf("Error code %s\n", u_errorName(status)); + tet_result(TET_FAIL); + } + + return; + +} + diff --git a/TC/unit/utc_tizen_icu_api_ucal_setGregorianChange_func.c b/TC/unit/utc_tizen_icu_api_ucal_setGregorianChange_func.c new file mode 100755 index 0000000..a1340c5 --- /dev/null +++ b/TC/unit/utc_tizen_icu_api_ucal_setGregorianChange_func.c @@ -0,0 +1,96 @@ + /* + * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jayoun Lee + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static void startup(void); +static void cleanup(void); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_tizen_icu_api_ucal_setGregorianChange_func_01(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + {utc_tizen_icu_api_ucal_setGregorianChange_func_01, POSITIVE_TC_IDX}, + {NULL, 0} +}; + +static void startup(void) +{ + tet_infoline + ("Testing API utc_tizen_icu_api_ucal_setGregorianChange start"); + return; +} + +static void cleanup(void) +{ + tet_infoline + ("Testing API utc_tizen_icu_api_ucal_setGregorianChange ends "); + return; +} + +/** + * @brief Positive test case of utc_tizen_icu_api_ucal_setGregorianChange() + */ +static void utc_tizen_icu_api_ucal_setGregorianChange_func_01(void) +{ + UCalendar *cal = NULL; + UErrorCode status = U_ZERO_ERROR; + int32_t type = UCAL_GREGORIAN; + UDate date = ucal_getNow(); + + cal = ucal_open(NULL, -1, NULL, type, &status); + if (U_SUCCESS(status) && (NULL != cal)) { + ucal_setGregorianChange(cal, date, &status); + if (U_SUCCESS(status)) { + tet_infoline + ("utc_tizen_icu_api_ucal_setGregorianChange test PASS!"); + tet_result(TET_PASS); + } else { + tet_infoline + ("utc_tizen_icu_api_ucal_setGregorianChange test FAIL!"); + tet_printf("Error code %s\n", u_errorName(status)); + tet_result(TET_FAIL); + } + + } else { + tet_infoline("utc_tizen_icu_api_ucal_open test FAIL!"); + tet_printf("Error code %s\n", u_errorName(status)); + tet_result(TET_FAIL); + } + + return; + +} + diff --git a/TC/unit/utc_tizen_icu_api_ucal_setMillis_func.c b/TC/unit/utc_tizen_icu_api_ucal_setMillis_func.c new file mode 100755 index 0000000..2f6f6d8 --- /dev/null +++ b/TC/unit/utc_tizen_icu_api_ucal_setMillis_func.c @@ -0,0 +1,93 @@ + /* + * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jayoun Lee + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static void startup(void); +static void cleanup(void); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_tizen_icu_api_ucal_setMillis_func_01(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + {utc_tizen_icu_api_ucal_setMillis_func_01, POSITIVE_TC_IDX}, + {NULL, 0} +}; + +static void startup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_ucal_setMillis start"); + return; +} + +static void cleanup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_ucal_setMillis ends "); + return; +} + +/** + * @brief Positive test case of utc_tizen_icu_api_ucal_setMillis() + */ +static void utc_tizen_icu_api_ucal_setMillis_func_01(void) +{ + UCalendar *cal = NULL; + UErrorCode status = U_ZERO_ERROR; + int32_t type = UCAL_DEFAULT; + UDate date = ucal_getNow(); + + cal = ucal_open(NULL, -1, NULL, type, &status); + if (U_SUCCESS(status) && (NULL != cal)) { + ucal_setMillis(cal, date, &status); + if (U_SUCCESS(status)) { + tet_infoline + ("utc_tizen_icu_api_ucal_setMillis test PASS!"); + tet_result(TET_PASS); + } else { + tet_infoline + ("utc_tizen_icu_api_ucal_setMillis test FAIL!"); + tet_printf("Error code %s\n", u_errorName(status)); + tet_result(TET_FAIL); + } + } else { + tet_infoline("utc_tizen_icu_api_ucal_open test FAIL!"); + tet_printf("Error code %s\n", u_errorName(status)); + tet_result(TET_FAIL); + } + ucal_close(cal); + return; + +} + diff --git a/TC/unit/utc_tizen_icu_api_ucal_setTimeZone_func.c b/TC/unit/utc_tizen_icu_api_ucal_setTimeZone_func.c new file mode 100755 index 0000000..17e1ec7 --- /dev/null +++ b/TC/unit/utc_tizen_icu_api_ucal_setTimeZone_func.c @@ -0,0 +1,91 @@ + /* + * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jayoun Lee + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static void startup(void); +static void cleanup(void); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_tizen_icu_api_ucal_setTimeZone_func_01(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + {utc_tizen_icu_api_ucal_setTimeZone_func_01, POSITIVE_TC_IDX}, + {NULL, 0} +}; + +static void startup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_ucal_setTimeZone start"); + return; +} + +static void cleanup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_ucal_setTimeZone ends "); + return; +} + +/** + * @brief Positive test case of utc_tizen_icu_api_ucal_setTimeZone() + */ +static void utc_tizen_icu_api_ucal_setTimeZone_func_01(void) +{ + UCalendar *cal = NULL; + UErrorCode status = U_ZERO_ERROR; + int32_t type = UCAL_DEFAULT; + + cal = ucal_open(NULL, -1, NULL, type, &status); + if (U_SUCCESS(status) && (NULL != cal)) { + ucal_setTimeZone(cal, (const UChar *)"PST", 4, &status); + if (U_SUCCESS(status)) { + tet_infoline + ("utc_tizen_icu_api_ucal_setTimeZone test PASS!"); + tet_result(TET_PASS); + } else { + tet_infoline + ("utc_tizen_icu_api_ucal_setTimeZone test FAIL!"); + tet_printf("Error code %s\n", u_errorName(status)); + tet_result(TET_FAIL); + } + } else { + tet_infoline("utc_tizen_icu_api_ucal_open test FAIL!"); + tet_printf("Error code %s\n", u_errorName(status)); + tet_result(TET_FAIL); + } + + return; + +} diff --git a/TC/unit/utc_tizen_icu_api_ucal_set_func.c b/TC/unit/utc_tizen_icu_api_ucal_set_func.c new file mode 100755 index 0000000..8848405 --- /dev/null +++ b/TC/unit/utc_tizen_icu_api_ucal_set_func.c @@ -0,0 +1,101 @@ + /* + * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jayoun Lee + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static void startup(void); +static void cleanup(void); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_tizen_icu_api_ucal_set_func_01(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + {utc_tizen_icu_api_ucal_set_func_01, POSITIVE_TC_IDX}, + {NULL, 0} +}; + +static void startup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_ucal_set start"); + return; +} + +static void cleanup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_ucal_set ends "); + return; +} + +/** + * @brief Positive test case of utc_tizen_icu_api_ucal_set() + */ +static void utc_tizen_icu_api_ucal_set_func_01(void) +{ + UCalendar *cal = NULL; + UErrorCode status = U_ZERO_ERROR; + int32_t type = UCAL_DEFAULT; + int32_t field[] = { UCAL_ERA, UCAL_YEAR, UCAL_MONTH, UCAL_WEEK_OF_YEAR, + UCAL_WEEK_OF_MONTH, UCAL_DATE, UCAL_DAY_OF_YEAR, + UCAL_DAY_OF_WEEK, UCAL_DAY_OF_WEEK_IN_MONTH, + UCAL_AM_PM, UCAL_HOUR, UCAL_HOUR_OF_DAY, + UCAL_MINUTE, UCAL_SECOND, UCAL_MILLISECOND, + UCAL_ZONE_OFFSET, UCAL_DST_OFFSET + }; + int32_t index = 0; + int32_t value = 1; + + cal = ucal_open(NULL, -1, NULL, type, &status); + if (U_SUCCESS(status) && (NULL != cal)) { + for (index = 0; index < 17; index++) { + ucal_set(cal, field[index], value); + if (ucal_isSet(cal, field[index])) { + tet_infoline + ("utc_tizen_icu_api_ucal_set test PASS!"); + tet_result(TET_PASS); + } else { + tet_infoline + ("utc_tizen_icu_api_ucal_set test FAIL!"); + tet_result(TET_FAIL); + } + } + } else { + tet_infoline("utc_tizen_icu_api_ucal_open test FAIL!"); + tet_printf("Error code %s", u_errorName(status)); + tet_result(TET_FAIL); + } + ucal_close(cal); + return; + +} diff --git a/TC/unit/utc_tizen_icu_api_ucnv_close_func.c b/TC/unit/utc_tizen_icu_api_ucnv_close_func.c new file mode 100755 index 0000000..e0c130c --- /dev/null +++ b/TC/unit/utc_tizen_icu_api_ucnv_close_func.c @@ -0,0 +1,83 @@ + /* + * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jayoun Lee + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static void startup(void); +static void cleanup(void); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_tizen_icu_api_ucnv_close_func_01(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + {utc_tizen_icu_api_ucnv_close_func_01, POSITIVE_TC_IDX}, + {NULL, 0} +}; + +static void startup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_ucnv_close start"); + return; +} + +static void cleanup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_ucnv_close ends "); + return; +} + +/** + * @brief Positive test case of utc_tizen_icu_api_ucnv_close() + */ +static void utc_tizen_icu_api_ucnv_close_func_01(void) +{ + const char *converter_name = "UTF-7,version=1"; + UErrorCode status = U_ZERO_ERROR; + UConverter *cnv = NULL; + + cnv = ucnv_open(converter_name, &status); + if (U_SUCCESS(status) && (NULL != cnv)) { + ucnv_close(cnv); + tet_infoline("utc_tizen_icu_api_ucnv_close test PASS!"); + tet_result(TET_PASS); + } + else { + tet_infoline("utc_tizen_icu_api_ucnv_open test FAIL!"); + tet_printf("Error code %s", u_errorName(status)); + tet_result(TET_FAIL); + } + + return; +} diff --git a/TC/unit/utc_tizen_icu_api_ucnv_compareNames_func.c b/TC/unit/utc_tizen_icu_api_ucnv_compareNames_func.c new file mode 100755 index 0000000..21b8c3c --- /dev/null +++ b/TC/unit/utc_tizen_icu_api_ucnv_compareNames_func.c @@ -0,0 +1,101 @@ + /* + * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jayoun Lee + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static void startup(void); +static void cleanup(void); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_tizen_icu_api_ucnv_compareNames_func_01(void); +static void utc_tizen_icu_api_ucnv_compareNames_func_02(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + {utc_tizen_icu_api_ucnv_compareNames_func_01, POSITIVE_TC_IDX}, + {utc_tizen_icu_api_ucnv_compareNames_func_02, POSITIVE_TC_IDX}, + {NULL, 0} +}; + +static void startup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_ucnv_compareNames start"); + return; +} + +static void cleanup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_ucnv_compareNames ends "); + return; +} + +/** + * @brief Positive test case of utc_tizen_icu_api_ucnv_compareNames() + */ +static void utc_tizen_icu_api_ucnv_compareNames_func_01(void) +{ + const char *converter_name1 = "UTF-8,version=1"; + const char *converter_name2 = "UTF-8,version=1"; + int result; + + result = ucnv_compareNames(converter_name1, converter_name2); + if (0 == result) { + tet_infoline("utc_tizen_icu_api_ucnv_compareNames test PASS!"); + tet_result(TET_PASS); + } else { + tet_infoline("utc_tizen_icu_api_ucnv_compareNames test FAIL!"); + tet_result(TET_FAIL); + } + return; +} + +/** + * @brief Positive test case of utc_tizen_icu_api_ucnv_compareNames() + */ +static void utc_tizen_icu_api_ucnv_compareNames_func_02(void) +{ + const char *converter_name1 = "UTF-7,version=1"; + const char *converter_name2 = "UTF-8,version=1"; + int result; + + result = ucnv_compareNames(converter_name1, converter_name2); + if (0 != result) { + tet_infoline("utc_tizen_icu_api_ucnv_compareNames test PASS!"); + tet_result(TET_PASS); + } else { + tet_infoline("utc_tizen_icu_api_ucnv_compareNames test FAIL!"); + tet_result(TET_FAIL); + } + return; +} diff --git a/TC/unit/utc_tizen_icu_api_ucnv_convertEx_func.c b/TC/unit/utc_tizen_icu_api_ucnv_convertEx_func.c new file mode 100755 index 0000000..7008613 --- /dev/null +++ b/TC/unit/utc_tizen_icu_api_ucnv_convertEx_func.c @@ -0,0 +1,158 @@ + /* + * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jayoun Lee + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static void startup(void); +static void cleanup(void); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_tizen_icu_api_ucnv_convertEx_func_01(void); +static void utc_tizen_icu_api_ucnv_convertEx_func_02(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + {utc_tizen_icu_api_ucnv_convertEx_func_01, POSITIVE_TC_IDX}, + {utc_tizen_icu_api_ucnv_convertEx_func_02, NEGATIVE_TC_IDX}, + {NULL, 0} +}; + +static void startup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_ucnv_convertEx start"); + return; +} + +static void cleanup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_ucnv_convertEx ends "); + return; +} + +/** + * @brief Positive test case of utc_tizen_icu_api_ucnv_convertEx() + */ +static void utc_tizen_icu_api_ucnv_convertEx_func_01(void) +{ + const char *cnv_name1 = "UTF-8"; + const char *cnv_name2 = "US-ASCII"; + UErrorCode status = U_ZERO_ERROR; + UErrorCode err1 = U_ZERO_ERROR; + UErrorCode err2 = U_ZERO_ERROR; + UConverter *src_cnv = NULL; + UConverter *target_cnv = NULL; + char output[100]; + int32_t capacity = 100; + const char *input = "Text here"; + int32_t length = strlen(input); + char *target = output; + const char *src = input; + + src_cnv = ucnv_open(cnv_name1, &err1); + target_cnv = ucnv_open(cnv_name2, &err2); + if (U_SUCCESS(err1) && (U_SUCCESS(err2))) { + ucnv_convertEx(target_cnv, src_cnv, + &target, output + capacity, + &src, input + length, NULL, NULL, + NULL, NULL, TRUE, TRUE, &status); + + if (U_SUCCESS(status)) { + tet_infoline + ("utc_tizen_icu_api_ucnv_convertEx test PASS!"); + tet_result(TET_PASS); + } else { + tet_infoline + ("utc_tizen_icu_api_ucnv_convertEx test FAIL!"); + tet_printf("Error code %s\n", u_errorName(status)); + tet_result(TET_FAIL); + } + } else { + tet_infoline("utc_tizen_icu_api_ucnv_open test FAIL!"); + tet_printf("Error code %s\n", u_errorName(status)); + tet_result(TET_FAIL); + } + + ucnv_close(src_cnv); + ucnv_close(target_cnv); + return; +} + +/** + * @brief Negative test case of utc_tizen_icu_api_ucnv_convertEx() + * sending target as null will return error + */ +static void utc_tizen_icu_api_ucnv_convertEx_func_02(void) +{ + const char *cnv_name1 = "UTF-8"; + const char *cnv_name2 = "US-ASCII"; + UErrorCode status = U_ZERO_ERROR; + UErrorCode err1 = U_ZERO_ERROR; + UErrorCode err2 = U_ZERO_ERROR; + UConverter *src_cnv = NULL; + UConverter *target_cnv = NULL; + char output[100]; + int32_t capacity = 100; + const char *input = "Text here"; + int32_t length = strlen(input); + const char *src = input; + + src_cnv = ucnv_open(cnv_name1, &err1); + target_cnv = ucnv_open(cnv_name2, &err2); + if (U_SUCCESS(err1) && (U_SUCCESS(err2))) { + ucnv_convertEx(target_cnv, src_cnv, + NULL, output + capacity, + &src, input + length, NULL, NULL, + NULL, NULL, TRUE, TRUE, &status); + + if (U_FAILURE(status)) { + tet_infoline + ("utc_tizen_icu_api_ucnv_convertEx test PASS!"); + tet_result(TET_PASS); + } else { + tet_infoline + ("utc_tizen_icu_api_ucnv_convertEx test FAIL!"); + tet_printf("Error code %s\n", u_errorName(status)); + tet_result(TET_FAIL); + } + } else { + tet_infoline("utc_tizen_icu_api_ucnv_open test FAIL!"); + tet_printf("Error code %s\n", u_errorName(status)); + tet_result(TET_FAIL); + } + + ucnv_close(src_cnv); + ucnv_close(target_cnv); + return; + +} diff --git a/TC/unit/utc_tizen_icu_api_ucnv_countAvailable_func.c b/TC/unit/utc_tizen_icu_api_ucnv_countAvailable_func.c new file mode 100755 index 0000000..aabc62a --- /dev/null +++ b/TC/unit/utc_tizen_icu_api_ucnv_countAvailable_func.c @@ -0,0 +1,91 @@ + /* + * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jayoun Lee + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static void startup(void); +static void cleanup(void); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_tizen_icu_api_ucnv_countAvailable_func_01(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + {utc_tizen_icu_api_ucnv_countAvailable_func_01, POSITIVE_TC_IDX}, + {NULL, 0} +}; + +static void startup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_ucnv_countAvailable start"); + return; +} + +static void cleanup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_ucnv_countAvailable ends "); + return; +} + +/** + * @brief Positive test case of utc_tizen_icu_api_ucnv_countAvailable() + */ +static void utc_tizen_icu_api_ucnv_countAvailable_func_01(void) +{ + const char *converter_name = "UTF-7,version=1"; + UErrorCode status = U_ZERO_ERROR; + UConverter *cnv = NULL; + int8_t result; + + cnv = ucnv_open(converter_name, &status); + if (U_SUCCESS(status) && (NULL != cnv)) { + result = ucnv_countAvailable(); + if (0 != result) { + tet_infoline + ("utc_tizen_icu_api_ucnv_countAvailable test PASS!"); + tet_result(TET_PASS); + } else { + tet_infoline + ("utc_tizen_icu_api_ucnv_countAvailable test FAIL!"); + tet_result(TET_FAIL); + } + } else { + tet_infoline("utc_tizen_icu_api_ucnv_open test FAIL!"); + tet_printf("Error code %s\n", u_errorName(status)); + tet_result(TET_FAIL); + } + + ucnv_close(cnv); + return; +} diff --git a/TC/unit/utc_tizen_icu_api_ucnv_flushCache_func.c b/TC/unit/utc_tizen_icu_api_ucnv_flushCache_func.c new file mode 100755 index 0000000..ccaa03d --- /dev/null +++ b/TC/unit/utc_tizen_icu_api_ucnv_flushCache_func.c @@ -0,0 +1,113 @@ + /* + * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jayoun Lee + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static void startup(void); +static void cleanup(void); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_tizen_icu_api_ucnv_flushCache_func_01(void); +static void utc_tizen_icu_api_ucnv_flushCache_func_02(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + {utc_tizen_icu_api_ucnv_flushCache_func_01, POSITIVE_TC_IDX}, + {utc_tizen_icu_api_ucnv_flushCache_func_02, NEGATIVE_TC_IDX}, + {NULL, 0} +}; + +static void startup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_ucnv_flushCache start"); + return; +} + +static void cleanup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_ucnv_flushCache ends "); + return; +} + +/** + * @brief Positive test case of utc_tizen_icu_api_ucnv_flushCache() + */ +static void utc_tizen_icu_api_ucnv_flushCache_func_01(void) +{ + const char *converter_name = "UTF-7,version=1"; + UErrorCode status = U_ZERO_ERROR; + UConverter *cnv = NULL; + int32_t result; + + cnv = ucnv_open(converter_name, &status); + if (U_SUCCESS(status)) { + result = ucnv_flushCache(); + if (0 <= result) { + tet_infoline + ("utc_tizen_icu_api_ucnv_flushCache test PASS!"); + tet_result(TET_PASS); + } else { + tet_infoline + ("utc_tizen_icu_api_ucnv_flushCache test FAIL!"); + tet_result(TET_FAIL); + } + } else { + tet_infoline("utc_tizen_icu_api_ucnv_open test FAIL!"); + tet_printf("Error code %s\n", u_errorName(status)); + tet_result(TET_FAIL); + } + + ucnv_close(cnv); + return; +} + +/** + * @brief Negative test case of utc_tizen_icu_api_ucnv_flushCache() + * calling this api without opening the converter will return 0 + */ +static void utc_tizen_icu_api_ucnv_flushCache_func_02(void) +{ + int32_t result = 0; + + result = ucnv_flushCache(); + if (result == 0) { + tet_infoline("utc_tizen_icu_api_ucnv_flushCache test PASS!"); + tet_result(TET_PASS); + } else { + tet_infoline("utc_tizen_icu_api_ucnv_flushCache test FAIL!"); + tet_result(TET_FAIL); + } + return; + +} diff --git a/TC/unit/utc_tizen_icu_api_ucnv_fromUChars_func.c b/TC/unit/utc_tizen_icu_api_ucnv_fromUChars_func.c new file mode 100755 index 0000000..51b5e8d --- /dev/null +++ b/TC/unit/utc_tizen_icu_api_ucnv_fromUChars_func.c @@ -0,0 +1,137 @@ + /* + * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Hakjoo Ko + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static void startup(void); +static void cleanup(void); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_tizen_icu_api_ucnv_fromUChars_func_01(void); +static void utc_tizen_icu_api_ucnv_fromUChars_func_02(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + {utc_tizen_icu_api_ucnv_fromUChars_func_01, POSITIVE_TC_IDX}, + {utc_tizen_icu_api_ucnv_fromUChars_func_02, NEGATIVE_TC_IDX}, + {NULL, 0} +}; + +static void startup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_ucnv_fromUChars start"); + return; +} + +static void cleanup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_ucnv_fromUChars ends "); + return; +} + +/** + * @brief Positive test case of utc_tizen_icu_api_ucnv_fromUChars() + */ +static void utc_tizen_icu_api_ucnv_fromUChars_func_01(void) +{ + const char *converter_name = "UTF-8"; + UErrorCode status = U_ZERO_ERROR; + UConverter *cnv = NULL; + char dest[50] = { 0, }; + const UChar *src = "The text is here"; + int32_t length = u_strlen(src); + int8_t result; + + cnv = ucnv_open(converter_name, &status); + if (U_SUCCESS(status) && (NULL != cnv)) { + ucnv_resetFromUnicode(cnv); + result = + ucnv_fromUChars(cnv, dest, 50, (const UChar *)"hello", + length, &status); + if (U_SUCCESS(status)) { + tet_infoline + ("utc_tizen_icu_api_ucnv_fromUChars test PASS!"); + tet_result(TET_PASS); + } else { + tet_infoline + ("utc_tizen_icu_api_ucnv_fromUChars test FAIL!"); + tet_printf("Error code %s", u_errorName(status)); + tet_result(TET_FAIL); + } + } else { + tet_infoline("utc_tizen_icu_api_ucnv_open test FAIL!"); + tet_printf("Error code %s\n", u_errorName(status)); + tet_result(TET_FAIL); + } + + ucnv_close(cnv); + return; +} + +/** + * @brief Negative test case of utc_tizen_icu_api_ucnv_fromUChars() + * sending source as null will return error + */ +static void utc_tizen_icu_api_ucnv_fromUChars_func_02(void) +{ + const char *converter_name = "UTF-8"; + UErrorCode status = U_ZERO_ERROR; + UConverter *cnv = NULL; + char dest[50] = { 0, }; + int8_t result; + + cnv = ucnv_open(converter_name, &status); + if (U_SUCCESS(status) && (NULL != cnv)) { + ucnv_resetFromUnicode(cnv); + result = ucnv_fromUChars(cnv, dest, 50, NULL, 1, &status); + if (U_FAILURE(status)) { + tet_infoline + ("utc_tizen_icu_api_ucnv_fromUChars test PASS!"); + tet_result(TET_PASS); + } else { + tet_infoline + ("utc_tizen_icu_api_ucnv_fromUChars test FAIL!"); + tet_printf("Error code %s\n", u_errorName(status)); + tet_result(TET_FAIL); + } + } else { + tet_infoline("utc_tizen_icu_api_ucnv_open test FAIL!"); + tet_printf("Error code %s", u_errorName(status)); + tet_result(TET_FAIL); + } + + ucnv_close(cnv); + return; + +} diff --git a/TC/unit/utc_tizen_icu_api_ucnv_fromUnicode_func.c b/TC/unit/utc_tizen_icu_api_ucnv_fromUnicode_func.c new file mode 100755 index 0000000..6e42841 --- /dev/null +++ b/TC/unit/utc_tizen_icu_api_ucnv_fromUnicode_func.c @@ -0,0 +1,126 @@ + /* + * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jayoun Lee + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static void startup(void); +static void cleanup(void); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_tizen_icu_api_ucnv_fromUnicode_func_01(void); +static void utc_tizen_icu_api_ucnv_fromUnicode_func_02(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + {utc_tizen_icu_api_ucnv_fromUnicode_func_01, POSITIVE_TC_IDX}, + {utc_tizen_icu_api_ucnv_fromUnicode_func_02, NEGATIVE_TC_IDX}, + {NULL, 0} +}; + +static void startup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_ucnv_fromUnicode start"); + return; +} + +static void cleanup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_ucnv_fromUnicode ends "); + return; +} + +/** + * @brief Positive test case of utc_tizen_icu_api_ucnv_fromUnicode() + */ +static void utc_tizen_icu_api_ucnv_fromUnicode_func_01(void) +{ + const char *converter_name = "UTF-7,version=1"; + UErrorCode status = U_ZERO_ERROR; + UChar *input = "Hello world"; + char output[100] = { 0, }; + char *target = output; + const UChar *source = input; + UConverter *cnv = NULL; + + cnv = ucnv_open(converter_name, &status); + if (U_SUCCESS(status) && (NULL != cnv)) { + ucnv_fromUnicode(cnv, &target, + output + sizeof(output) / U_SIZEOF_UCHAR, + &source, input + sizeof(input), NULL, TRUE, + &status); + if (U_SUCCESS(status)) { + tet_infoline + ("utc_tizen_icu_api_ucnv_fromUnicode test PASS!"); + tet_result(TET_PASS); + } else { + tet_infoline + ("utc_tizen_icu_api_ucnv_fromUnicode test FAIL!"); + tet_printf("Error code %s\n", u_errorName(status)); + tet_result(TET_FAIL); + } + } else { + tet_infoline("utc_tizen_icu_api_ucnv_open test FAIL!"); + tet_printf("Error code %s", u_errorName(status)); + tet_result(TET_FAIL); + } + + ucnv_close(cnv); + return; +} + +/** + * @brief Negative test case of utc_tizen_icu_api_ucnv_fromUnicode() + * sending target as a null will return buffer overflow error + */ +static void utc_tizen_icu_api_ucnv_fromUnicode_func_02(void) +{ + UErrorCode status = U_ZERO_ERROR; + UChar *input = "Hello world"; + char output[100] = { 0, }; + const UChar *source = input; + + ucnv_fromUnicode(NULL, NULL, + output + sizeof(output) / U_SIZEOF_UCHAR, &source, + input + sizeof(input), NULL, TRUE, &status); + if (U_FAILURE(status)) { + tet_infoline("utc_tizen_icu_api_ucnv_fromUnicode test PASS!"); + tet_result(TET_PASS); + } else { + tet_infoline("utc_tizen_icu_api_ucnv_fromUnicode test FAIL!"); + tet_printf("Error code %s\n", u_errorName(status)); + tet_result(TET_FAIL); + } + return; + +} diff --git a/TC/unit/utc_tizen_icu_api_ucnv_getAlias_func.c b/TC/unit/utc_tizen_icu_api_ucnv_getAlias_func.c new file mode 100755 index 0000000..41f03c1 --- /dev/null +++ b/TC/unit/utc_tizen_icu_api_ucnv_getAlias_func.c @@ -0,0 +1,114 @@ + /* + * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Hakjoo Ko + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static void startup(void); +static void cleanup(void); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_tizen_icu_api_ucnv_getAlias_func_01(void); +static void utc_tizen_icu_api_ucnv_getAlias_func_02(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + {utc_tizen_icu_api_ucnv_getAlias_func_01, POSITIVE_TC_IDX}, + {utc_tizen_icu_api_ucnv_getAlias_func_02, NEGATIVE_TC_IDX}, + {NULL, 0} +}; + +static void startup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_ucnv_getAlias start"); + return; +} + +static void cleanup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_ucnv_getAlias ends "); + return; +} + +/** + * @brief Positive test case of utc_tizen_icu_api_ucnv_getAlias() + */ +static void utc_tizen_icu_api_ucnv_getAlias_func_01(void) +{ + UErrorCode status = U_ZERO_ERROR; + const char *result = NULL; + const char *name = NULL; + int32_t ncnv_cnt; + + ncnv_cnt = ucnv_countAvailable(); + + if(ncnv_cnt > 0) { + name = ucnv_getAvailableName(0); + result = ucnv_getAlias(name, 0, &status); + if ((U_SUCCESS(status)) && (NULL != result)) { + tet_infoline("utc_tizen_icu_api_ucnv_getAlias test PASS!"); + tet_result(TET_PASS); + } else { + tet_infoline("utc_tizen_icu_api_ucnv_getAlias test FAIL!"); + tet_printf("Error code %s\n", u_errorName(status)); + tet_result(TET_FAIL); + } + } else { + tet_infoline("utc_tizen_icu_api_ucnv_getAlias test FAIL!"); + tet_printf("ucnv available count is 0\n"); + tet_result(TET_FAIL); + } + return; +} + +/** + * @brief Negative test case of utc_tizen_icu_api_ucnv_getAlias() + * sending converter as null will return error + */ +static void utc_tizen_icu_api_ucnv_getAlias_func_02(void) +{ + UErrorCode status = U_ZERO_ERROR; + const char *result; + + result = ucnv_getAlias("UTF-7", 2, &status); + if ((U_FAILURE(status)) || (NULL == result)) { + tet_infoline("utc_tizen_icu_api_ucnv_getAlias test PASS!"); + tet_result(TET_PASS); + } else { + tet_infoline("utc_tizen_icu_api_ucnv_getAlias test FAIL!"); + tet_printf("Error code %s\n", u_errorName(status)); + tet_result(TET_FAIL); + } + return; + +} diff --git a/TC/unit/utc_tizen_icu_api_ucnv_getAvailableName_func.c b/TC/unit/utc_tizen_icu_api_ucnv_getAvailableName_func.c new file mode 100755 index 0000000..e890fb3 --- /dev/null +++ b/TC/unit/utc_tizen_icu_api_ucnv_getAvailableName_func.c @@ -0,0 +1,111 @@ + /* + * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jayoun Lee + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +static void startup(void); +static void cleanup(void); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_tizen_icu_api_ucnv_getAvailableName_func_01(void); +static void utc_tizen_icu_api_ucnv_getAvailableName_func_02(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + {utc_tizen_icu_api_ucnv_getAvailableName_func_01, POSITIVE_TC_IDX}, + {utc_tizen_icu_api_ucnv_getAvailableName_func_02, NEGATIVE_TC_IDX}, + {NULL, 0} +}; + +static void startup(void) +{ + tet_infoline + ("Testing API utc_tizen_icu_api_ucnv_getAvailableName start"); + return; +} + +static void cleanup(void) +{ + tet_infoline + ("Testing API utc_tizen_icu_api_ucnv_getAvailableName ends "); + return; +} + +/** + * @brief Positive test case of utc_tizen_icu_api_ucnv_getAvailableName() + */ +static void utc_tizen_icu_api_ucnv_getAvailableName_func_01(void) +{ + const char *result = NULL; + int32_t max_count = ucnv_countAvailable(); + int32_t index = 0; + + for (index = 0; index < max_count; index++) { + result = ucnv_getAvailableName(index); + if (NULL != result) { + tet_infoline + ("utc_tizen_icu_api_ucnv_getAvailableName test PASS!"); + tet_printf("Converter Name %s\n", result); + tet_result(TET_PASS); + } else { + tet_infoline + ("utc_tizen_icu_api_ucnv_getAvailableName test FAIL!"); + tet_result(TET_FAIL); + } + } + return; +} + +/** + * @brief Negative test case of utc_tizen_icu_api_ucnv_getAvailableName() + * giving index as out of bound will return null + */ +static void utc_tizen_icu_api_ucnv_getAvailableName_func_02(void) +{ + const char *result = NULL; + int32_t index = 0; + + index = ucnv_countAvailable() + 2; + result = ucnv_getAvailableName(index); /* index is out of bound value */ + if (result == NULL) { + tet_infoline + ("utc_tizen_icu_api_ucnv_getAvailableName test PASS!"); + tet_result(TET_PASS); + } else { + tet_infoline + ("utc_tizen_icu_api_ucnv_getAvailableName test FAIL!"); + tet_result(TET_FAIL); + } + return; + +} diff --git a/TC/unit/utc_tizen_icu_api_ucnv_getCanonicalName_func.c b/TC/unit/utc_tizen_icu_api_ucnv_getCanonicalName_func.c new file mode 100755 index 0000000..de4b471 --- /dev/null +++ b/TC/unit/utc_tizen_icu_api_ucnv_getCanonicalName_func.c @@ -0,0 +1,128 @@ + /* + * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Hakjoo Ko + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static void startup(void); +static void cleanup(void); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_tizen_icu_api_ucnv_getCanonicalName_func_01(void); +static void utc_tizen_icu_api_ucnv_getCanonicalName_func_02(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + {utc_tizen_icu_api_ucnv_getCanonicalName_func_01, POSITIVE_TC_IDX}, + {utc_tizen_icu_api_ucnv_getCanonicalName_func_02, NEGATIVE_TC_IDX}, + {NULL, 0} +}; + +static void startup(void) +{ + tet_infoline + ("Testing API utc_tizen_icu_api_ucnv_getCanonicalName start"); + return; +} + +static void cleanup(void) +{ + tet_infoline + ("Testing API utc_tizen_icu_api_ucnv_getCanonicalName ends "); + return; +} + +/** + * @brief Positive test case of utc_tizen_icu_api_ucnv_getCanonicalName() + */ +static void utc_tizen_icu_api_ucnv_getCanonicalName_func_01(void) +{ + const char *alias = "ibm-1208"; + const char *standard = "IBM"; + UErrorCode status = U_ZERO_ERROR; + const char *result = NULL; + const char *expect = "UTF-8"; + + result = ucnv_getCanonicalName(alias, standard, &status); + if ((U_SUCCESS(status)) && (NULL != result)) { + if(strcmp(expect, result) == 0) { + tet_infoline + ("utc_tizen_icu_api_ucnv_getCanonicalName test PASS!"); + tet_result(TET_PASS); + } else { + tet_infoline + ("utc_tizen_icu_api_ucnv_getCanonicalName test FAIL!"); + tet_printf("Error code %s\n", u_errorName(status)); + tet_result(TET_FAIL); + } + } else { + tet_infoline + ("utc_tizen_icu_api_ucnv_getCanonicalName test FAIL!"); + tet_printf("Error code %s\n", u_errorName(status)); + tet_result(TET_FAIL); + } + return; +} + +/** + * @brief Negative test case of utc_tizen_icu_api_ucnv_getCanonicalName() + * sending converter as null will return error + */ +static void utc_tizen_icu_api_ucnv_getCanonicalName_func_02(void) +{ + const char *alias = "ibm-5305"; + const char *standard = "IBM"; + UErrorCode status = U_ZERO_ERROR; + const char *result = NULL; + const char *expect = "UTF-16BE"; + + result = ucnv_getCanonicalName(alias, standard, &status); + if ((U_SUCCESS(status)) && (NULL != result)) { + if(alias == result || strcmp(expect, result) != 0) { + tet_infoline + ("utc_tizen_icu_api_ucnv_getCanonicalName test PASS!"); + tet_result(TET_PASS); + } else { + tet_infoline + ("utc_tizen_icu_api_ucnv_getCanonicalName test FAIL!"); + tet_printf("Error code %s\n", u_errorName(status)); + tet_result(TET_FAIL); + } + } else { + tet_infoline + ("utc_tizen_icu_api_ucnv_getCanonicalName test FAIL!"); + tet_printf("Error code %s\n", u_errorName(status)); + tet_result(TET_FAIL); + } + return; +} diff --git a/TC/unit/utc_tizen_icu_api_ucnv_getDisplayName_func.c b/TC/unit/utc_tizen_icu_api_ucnv_getDisplayName_func.c new file mode 100755 index 0000000..e4f0d30 --- /dev/null +++ b/TC/unit/utc_tizen_icu_api_ucnv_getDisplayName_func.c @@ -0,0 +1,132 @@ + /* + * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jayoun Lee + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static void startup(void); +static void cleanup(void); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_tizen_icu_api_ucnv_getDisplayName_func_01(void); +static void utc_tizen_icu_api_ucnv_getDisplayName_func_02(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + {utc_tizen_icu_api_ucnv_getDisplayName_func_01, POSITIVE_TC_IDX}, + {utc_tizen_icu_api_ucnv_getDisplayName_func_02, NEGATIVE_TC_IDX}, + {NULL, 0} +}; + +static void startup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_ucnv_getDisplayName start"); + return; +} + +static void cleanup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_ucnv_getDisplayName ends "); + return; +} + +/** + * @brief Positive test case of utc_tizen_icu_api_ucnv_getDisplayName() + */ +static void utc_tizen_icu_api_ucnv_getDisplayName_func_01(void) +{ + const char *converter_name = "UTF-7,version=1"; + UErrorCode status = U_ZERO_ERROR; + UConverter *cnv = NULL; + UChar display_name[20] = { 0, }; + int8_t result; + + cnv = ucnv_open(converter_name, &status); + if (U_SUCCESS(status) && (NULL != cnv)) { + result = + ucnv_getDisplayName(cnv, NULL, display_name, 20, &status); + if (U_SUCCESS(status)) { + tet_infoline + ("utc_tizen_icu_api_ucnv_getDisplayName test PASS!"); + tet_printf("Display name %s\n", display_name); + tet_result(TET_PASS); + } else { + tet_infoline + ("utc_tizen_icu_api_ucnv_getDisplayName test FAIL!"); + tet_printf("Error code %s\n", u_errorName(status)); + tet_result(TET_FAIL); + } + } else { + tet_infoline("utc_tizen_icu_api_ucnv_open test FAIL!"); + tet_printf("Error code %s\n", u_errorName(status)); + tet_result(TET_FAIL); + } + + ucnv_close(cnv); + return; +} + +/** + * @brief Negative test case of utc_tizen_icu_api_ucnv_getDisplayName() + * sending display name null will return buffer overflow error + */ +static void utc_tizen_icu_api_ucnv_getDisplayName_func_02(void) +{ + const char *converter_name = "UTF-7,version=1"; + UErrorCode status = U_ZERO_ERROR; + UConverter *cnv = NULL; + int8_t result; + + cnv = ucnv_open(converter_name, &status); + if (U_SUCCESS(status) && (NULL != cnv)) { + result = ucnv_getDisplayName(cnv, NULL, NULL, 20, &status); + if (U_FAILURE(status)) { + tet_infoline + ("utc_tizen_icu_api_ucnv_getDisplayName test PASS!"); + tet_result(TET_PASS); + } else { + tet_infoline + ("utc_tizen_icu_api_ucnv_getDisplayName test FAIL!"); + tet_printf("Error code %s\n", u_errorName(status)); + tet_result(TET_FAIL); + } + } else { + tet_infoline("utc_tizen_icu_api_ucnv_open test FAIL!"); + tet_printf("Error code %s\n", u_errorName(status)); + tet_result(TET_FAIL); + } + + ucnv_close(cnv); + return; + +} diff --git a/TC/unit/utc_tizen_icu_api_ucnv_getMaxCharSize_func.c b/TC/unit/utc_tizen_icu_api_ucnv_getMaxCharSize_func.c new file mode 100755 index 0000000..4e269eb --- /dev/null +++ b/TC/unit/utc_tizen_icu_api_ucnv_getMaxCharSize_func.c @@ -0,0 +1,92 @@ + /* + * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jayoun Lee + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static void startup(void); +static void cleanup(void); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_tizen_icu_api_ucnv_getMaxCharSize_func_01(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + {utc_tizen_icu_api_ucnv_getMaxCharSize_func_01, POSITIVE_TC_IDX}, + {NULL, 0} +}; + +static void startup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_ucnv_getMaxCharSize start"); + return; +} + +static void cleanup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_ucnv_getMaxCharSize ends "); + return; +} + +/** + * @brief Positive test case of utc_tizen_icu_api_ucnv_getMaxCharSize() + */ +static void utc_tizen_icu_api_ucnv_getMaxCharSize_func_01(void) +{ + const char *converter_name = "UTF-7,version=1"; + UErrorCode status = U_ZERO_ERROR; + UConverter *cnv = NULL; + int8_t result; + + cnv = ucnv_open(converter_name, &status); + if (U_SUCCESS(status) && (NULL != cnv)) { + result = ucnv_getMaxCharSize(cnv); + if (0 != result) { + tet_infoline + ("utc_tizen_icu_api_ucnv_getMaxCharSize test PASS!"); + tet_result(TET_PASS); + } else { + tet_infoline + ("utc_tizen_icu_api_ucnv_getMaxCharSize test FAIL!"); + tet_printf("Error code %s\n", u_errorName(status)); + tet_result(TET_FAIL); + } + } else { + tet_infoline("utc_tizen_icu_api_ucnv_open test FAIL!"); + tet_printf("Error code %s\n", u_errorName(status)); + tet_result(TET_FAIL); + } + + ucnv_close(cnv); + return; +} diff --git a/TC/unit/utc_tizen_icu_api_ucnv_getMinCharSize_func.c b/TC/unit/utc_tizen_icu_api_ucnv_getMinCharSize_func.c new file mode 100755 index 0000000..1c5f3d1 --- /dev/null +++ b/TC/unit/utc_tizen_icu_api_ucnv_getMinCharSize_func.c @@ -0,0 +1,92 @@ + /* + * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jayoun Lee + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static void startup(void); +static void cleanup(void); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_tizen_icu_api_ucnv_getMinCharSize_func_01(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + {utc_tizen_icu_api_ucnv_getMinCharSize_func_01, POSITIVE_TC_IDX}, + {NULL, 0} +}; + +static void startup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_ucnv_getMinCharSize start"); + return; +} + +static void cleanup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_ucnv_getMinCharSize ends "); + return; +} + +/** + * @brief Positive test case of utc_tizen_icu_api_ucnv_getMinCharSize() + */ +static void utc_tizen_icu_api_ucnv_getMinCharSize_func_01(void) +{ + const char *converter_name = "UTF-7,version=1"; + UErrorCode status = U_ZERO_ERROR; + UConverter *cnv = NULL; + int8_t result; + + cnv = ucnv_open(converter_name, &status); + if (U_SUCCESS(status) && (NULL != cnv)) { + result = ucnv_getMinCharSize(cnv); + if (0 != result) { + tet_infoline + ("utc_tizen_icu_api_ucnv_getMinCharSize test PASS!"); + tet_result(TET_PASS); + } else { + tet_infoline + ("utc_tizen_icu_api_ucnv_getMinCharSize test FAIL!"); + tet_printf("Error code %s\n", u_errorName(status)); + tet_result(TET_FAIL); + } + } else { + tet_infoline("utc_tizen_icu_api_ucnv_open test FAIL!"); + tet_printf("Error code %s\n", u_errorName(status)); + tet_result(TET_FAIL); + } + + ucnv_close(cnv); + return; +} diff --git a/TC/unit/utc_tizen_icu_api_ucnv_getName_func.c b/TC/unit/utc_tizen_icu_api_ucnv_getName_func.c new file mode 100755 index 0000000..5743b5f --- /dev/null +++ b/TC/unit/utc_tizen_icu_api_ucnv_getName_func.c @@ -0,0 +1,92 @@ + /* + * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jayoun Lee + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static void startup(void); +static void cleanup(void); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_tizen_icu_api_ucnv_getName_func_01(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + {utc_tizen_icu_api_ucnv_getName_func_01, POSITIVE_TC_IDX}, + {NULL, 0} +}; + +static void startup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_ucnv_getName start"); + return; +} + +static void cleanup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_ucnv_getName ends "); + return; +} + +/** + * @brief Positive test case of utc_tizen_icu_api_ucnv_getName() + */ +static void utc_tizen_icu_api_ucnv_getName_func_01(void) +{ + const char *converter_name = "UTF-7,version=1"; + UErrorCode status = U_ZERO_ERROR; + UConverter *cnv = NULL; + const char *result; + + cnv = ucnv_open(converter_name, &status); + if (U_SUCCESS(status) && (NULL != cnv)) { + result = ucnv_getName(cnv, &status); + if ((U_SUCCESS(status)) && (NULL != result)) { + tet_infoline + ("utc_tizen_icu_api_ucnv_getName test PASS!"); + tet_result(TET_PASS); + } else { + tet_infoline + ("utc_tizen_icu_api_ucnv_getName test FAIL!"); + tet_printf("Error code %s\n", u_errorName(status)); + tet_result(TET_FAIL); + } + } else { + tet_infoline("utc_tizen_icu_api_ucnv_open test FAIL!"); + tet_printf("Error code %s", u_errorName(status)); + tet_result(TET_FAIL); + } + + ucnv_close(cnv); + return; +} diff --git a/TC/unit/utc_tizen_icu_api_ucnv_open_func.c b/TC/unit/utc_tizen_icu_api_ucnv_open_func.c new file mode 100755 index 0000000..13ef632 --- /dev/null +++ b/TC/unit/utc_tizen_icu_api_ucnv_open_func.c @@ -0,0 +1,107 @@ + /* + * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jayoun Lee + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static void startup(void); +static void cleanup(void); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_tizen_icu_api_ucnv_open_func_01(void); +static void utc_tizen_icu_api_ucnv_open_func_02(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + {utc_tizen_icu_api_ucnv_open_func_01, POSITIVE_TC_IDX}, + {utc_tizen_icu_api_ucnv_open_func_02, NEGATIVE_TC_IDX}, + {NULL, 0} +}; + +static void startup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_ucnv_open start"); + return; +} + +static void cleanup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_ucnv_open ends "); + return; +} + +/** + * @brief Positive test case of utc_tizen_icu_api_ucnv_open() + */ +static void utc_tizen_icu_api_ucnv_open_func_01(void) +{ + const char *converter_name = "UTF-7,version=1"; + UErrorCode status = U_ZERO_ERROR; + UConverter *cnv = NULL; + + cnv = ucnv_open(converter_name, &status); + if (U_SUCCESS(status) && (NULL != cnv)) { + tet_infoline("utc_tizen_icu_api_ucnv_open test PASS!"); + tet_result(TET_PASS); + } else { + tet_infoline("utc_tizen_icu_api_ucnv_open test FAIL!"); + tet_printf("Error code %s\n", u_errorName(status)); + tet_result(TET_FAIL); + } + ucnv_close(cnv); + + return; +} + +/** + * @brief Negative test case of utc_tizen_icu_api_ucnv_open() + * sending converter name as null will take default converter + */ +static void utc_tizen_icu_api_ucnv_open_func_02(void) +{ + UConverter *cnv = NULL; + UErrorCode status = U_ZERO_ERROR; + + cnv = ucnv_open(NULL, &status); + if (U_SUCCESS(status) && (NULL != cnv)) { + tet_infoline("utc_tizen_icu_api_ucnv_open test PASS!"); + tet_result(TET_PASS); + } else { + tet_infoline("utc_tizen_icu_api_ucnv_open test FAIL!"); + tet_printf("Error code %s\n", u_errorName(status)); + tet_result(TET_FAIL); + } + ucnv_close(cnv); + return; + +} diff --git a/TC/unit/utc_tizen_icu_api_ucnv_reset_func.c b/TC/unit/utc_tizen_icu_api_ucnv_reset_func.c new file mode 100755 index 0000000..6734e22 --- /dev/null +++ b/TC/unit/utc_tizen_icu_api_ucnv_reset_func.c @@ -0,0 +1,83 @@ + /* + * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jayoun Lee + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static void startup(void); +static void cleanup(void); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_tizen_icu_api_ucnv_reset_func_01(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + {utc_tizen_icu_api_ucnv_reset_func_01, POSITIVE_TC_IDX}, + {NULL, 0} +}; + +static void startup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_ucnv_reset start"); + return; +} + +static void cleanup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_ucnv_reset ends "); + return; +} + +/** + * @brief Positive test case of utc_tizen_icu_api_ucnv_reset() + */ +static void utc_tizen_icu_api_ucnv_reset_func_01(void) +{ + const char *converter_name = "UTF-7,version=1"; + UErrorCode status = U_ZERO_ERROR; + UConverter *cnv = NULL; + + cnv = ucnv_open(converter_name, &status); + if (U_SUCCESS(status) && (NULL != cnv)) { + ucnv_reset(cnv); + tet_infoline("utc_tizen_icu_api_ucnv_reset test PASS!"); + tet_result(TET_PASS); + } else { + tet_infoline("utc_tizen_icu_api_ucnv_reset test FAIL!"); + tet_printf("Error code %s\n", u_errorName(status)); + tet_result(TET_FAIL); + } + ucnv_close(cnv); + + return; +} diff --git a/TC/unit/utc_tizen_icu_api_ucnv_setFallback_func.c b/TC/unit/utc_tizen_icu_api_ucnv_setFallback_func.c new file mode 100755 index 0000000..505d52d --- /dev/null +++ b/TC/unit/utc_tizen_icu_api_ucnv_setFallback_func.c @@ -0,0 +1,129 @@ + /* + * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jayoun Lee + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static void startup(void); +static void cleanup(void); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_tizen_icu_api_ucnv_setFallback_func_01(void); +static void utc_tizen_icu_api_ucnv_setFallback_func_02(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + {utc_tizen_icu_api_ucnv_setFallback_func_01, POSITIVE_TC_IDX}, + {utc_tizen_icu_api_ucnv_setFallback_func_02, NEGATIVE_TC_IDX}, + {NULL, 0} +}; + +static void startup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_ucnv_setFallback start"); + return; +} + +static void cleanup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_ucnv_setFallback ends "); + return; +} + +/** + * @brief Positive test case of utc_tizen_icu_api_ucnv_setFallback() + */ +static void utc_tizen_icu_api_ucnv_setFallback_func_01(void) +{ + const char *converter_name = "UTF-7,version=1"; + UErrorCode status = U_ZERO_ERROR; + UConverter *cnv = NULL; + UBool uses_fallback = TRUE; + + cnv = ucnv_open(converter_name, &status); + if (U_SUCCESS(status) && (NULL != cnv)) { + ucnv_setFallback(cnv, uses_fallback); + /* checks if converter uses fallback or not */ + if (ucnv_usesFallback(cnv)) { + tet_infoline + ("utc_tizen_icu_api_ucnv_setFallback test PASS!"); + tet_result(TET_PASS); + } else { + tet_infoline + ("utc_tizen_icu_api_ucnv_setFallback test FAIL!"); + tet_result(TET_FAIL); + } + } else { + tet_infoline("utc_tizen_icu_api_ucnv_open test FAIL!"); + tet_printf("Error code %s\n", u_errorName(status)); + tet_result(TET_FAIL); + } + + ucnv_close(cnv); + return; +} + +/** + * @brief Negative test case of utc_tizen_icu_api_ucnv_setFallback() + * sending converter as null will return error + */ +static void utc_tizen_icu_api_ucnv_setFallback_func_02(void) +{ + const char *converter_name = "UTF-7,version=1"; + UErrorCode status = U_ZERO_ERROR; + UConverter *cnv = NULL; + UBool uses_fallback = FALSE; + + cnv = ucnv_open(converter_name, &status); + if (U_SUCCESS(status) && (NULL != cnv)) { + ucnv_setFallback(cnv, uses_fallback); + /* checks if converter uses fallback or not */ + if (ucnv_usesFallback(cnv) == FALSE) { + tet_infoline + ("utc_tizen_icu_api_ucnv_setFallback test PASS!"); + tet_result(TET_PASS); + } else { + tet_infoline + ("utc_tizen_icu_api_ucnv_setFallback test FAIL!"); + tet_result(TET_FAIL); + } + } else { + tet_infoline("utc_tizen_icu_api_ucnv_open test FAIL!"); + tet_printf("Error code %s\n", u_errorName(status)); + tet_result(TET_FAIL); + } + + ucnv_close(cnv); + return; + +} diff --git a/TC/unit/utc_tizen_icu_api_ucnv_setFromUCallBack_func.c b/TC/unit/utc_tizen_icu_api_ucnv_setFromUCallBack_func.c new file mode 100755 index 0000000..d3b8190 --- /dev/null +++ b/TC/unit/utc_tizen_icu_api_ucnv_setFromUCallBack_func.c @@ -0,0 +1,143 @@ + /* + * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jayoun Lee + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static void startup(void); +static void cleanup(void); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_tizen_icu_api_ucnv_setFromUCallBack_func_01(void); +static void utc_tizen_icu_api_ucnv_setFromUCallBack_func_02(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + {utc_tizen_icu_api_ucnv_setFromUCallBack_func_01, POSITIVE_TC_IDX}, + {utc_tizen_icu_api_ucnv_setFromUCallBack_func_02, NEGATIVE_TC_IDX}, + {NULL, 0} +}; + +static void startup(void) +{ + tet_infoline + ("Testing API utc_tizen_icu_api_ucnv_setFromUCallBack start"); + return; +} + +static void cleanup(void) +{ + tet_infoline + ("Testing API utc_tizen_icu_api_ucnv_setFromUCallBack ends "); + return; +} + +/** + * @brief Positive test case of utc_tizen_icu_api_ucnv_setFromUCallBack() + */ +static void utc_tizen_icu_api_ucnv_setFromUCallBack_func_01(void) +{ + const char *converter_name = "UTF-8"; + UErrorCode status = U_ZERO_ERROR; + UConverter *cnv = NULL; + UConverterFromUCallback oldFromUAction = NULL; + UConverterFromUCallback oldFromUAction2 = NULL; + const void* oldFromUContext = NULL; + const void* oldFromUContext2 = NULL; + UChar newFromUContext = 0x0000; + + cnv = ucnv_open(converter_name, &status); + if (U_SUCCESS(status) && (NULL != cnv)) { + ucnv_getFromUCallBack(cnv, &oldFromUAction, &oldFromUContext); + ucnv_setFromUCallBack(cnv, + UCNV_FROM_U_CALLBACK_SUBSTITUTE, &newFromUContext, + &oldFromUAction2, &oldFromUContext2, + &status); + if (U_FAILURE(status) || oldFromUAction != oldFromUAction2 || oldFromUContext != oldFromUContext2) { + tet_infoline + ("utc_tizen_icu_api_ucnv_setFromUCallBack test FAIL!"); + tet_printf("Error code %s\n", u_errorName(status)); + tet_result(TET_FAIL); + } else { + tet_infoline + ("utc_tizen_icu_api_ucnv_setFromUCallBack test PASS!"); + tet_result(TET_PASS); + + } + } else { + tet_infoline("utc_tizen_icu_api_ucnv_open test FAIL!"); + tet_printf("Error code %s\n", u_errorName(status)); + tet_result(TET_FAIL); + } + + ucnv_close(cnv); + return; +} + +/** + * @brief Negative test case of utc_tizen_icu_api_ucnv_setFromUCallBack() + * sending callback function as null will return error + */ +static void utc_tizen_icu_api_ucnv_setFromUCallBack_func_02(void) +{ + const char *converter_name = "UTF-8"; + UErrorCode status = U_ZERO_ERROR; + UConverter *cnv = NULL; + UChar newFromUContext = 0x0000; + + cnv = ucnv_open(converter_name, &status); + if (U_SUCCESS(status) && (NULL != cnv)) { + status = U_ILLEGAL_ARGUMENT_ERROR; + ucnv_setFromUCallBack(cnv, + UCNV_FROM_U_CALLBACK_STOP, &newFromUContext, + NULL, NULL, &status); + if (U_FAILURE(status)) { + tet_infoline + ("utc_tizen_icu_api_ucnv_setFromUCallBack test PASS!"); + tet_result(TET_PASS); + } else { + tet_infoline + ("utc_tizen_icu_api_ucnv_setFromUCallBack test FAIL!"); + tet_printf("Error code %s\n", u_errorName(status)); + tet_result(TET_FAIL); + } + } else { + tet_infoline("utc_tizen_icu_api_ucnv_open test FAIL!"); + tet_printf("Error code %s\n", u_errorName(status)); + tet_result(TET_FAIL); + } + + ucnv_close(cnv); + return; + +} diff --git a/TC/unit/utc_tizen_icu_api_ucnv_setToUCallBack_func.c b/TC/unit/utc_tizen_icu_api_ucnv_setToUCallBack_func.c new file mode 100755 index 0000000..2b9b350 --- /dev/null +++ b/TC/unit/utc_tizen_icu_api_ucnv_setToUCallBack_func.c @@ -0,0 +1,135 @@ + /* + * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Hakjoo ko + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static void startup(void); +static void cleanup(void); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_tizen_icu_api_ucnv_setToUCallBack_func_01(void); +static void utc_tizen_icu_api_ucnv_setToUCallBack_func_02(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + {utc_tizen_icu_api_ucnv_setToUCallBack_func_01, POSITIVE_TC_IDX}, + {utc_tizen_icu_api_ucnv_setToUCallBack_func_02, NEGATIVE_TC_IDX}, + {NULL, 0} +}; + +static void startup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_ucnv_setToUCallBack start"); + return; +} + +static void cleanup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_ucnv_setToUCallBack ends "); + return; +} + +/** + * @brief Positive test case of utc_tizen_icu_api_ucnv_setToUCallBack() + */ +static void utc_tizen_icu_api_ucnv_setToUCallBack_func_01(void) +{ + const char *converter_name = "UTF-8"; + UErrorCode status = U_ZERO_ERROR; + UConverter *cnv = NULL; + UConverterToUCallback oldToUAction = NULL; + UConverterToUCallback oldToUAction2 = NULL; + const void* oldToUContext = NULL; + const void* oldToUContext2 = NULL; + UChar newToUContext = 0x0000; + + cnv = ucnv_open(converter_name, &status); + if (U_SUCCESS(status) && (NULL != cnv)) { + ucnv_getToUCallBack(cnv, &oldToUAction, &oldToUContext); + ucnv_setToUCallBack(cnv, UCNV_TO_U_CALLBACK_SUBSTITUTE, &newToUContext, &oldToUAction2, &oldToUContext2, &status); + if (U_FAILURE(status) || oldToUAction != oldToUAction2 || oldToUContext != oldToUContext2) { + tet_infoline + ("utc_tizen_icu_api_ucnv_setToUCallBack test FAIL!"); + tet_printf("Error code %s\n", u_errorName(status)); + tet_result(TET_FAIL); + } else { + tet_infoline + ("utc_tizen_icu_api_ucnv_setToUCallBack test PASS!"); + tet_result(TET_PASS); + } + } else { + tet_infoline("utc_tizen_icu_api_ucnv_open test FAIL!"); + tet_printf("Error code %s", u_errorName(status)); + tet_result(TET_FAIL); + } + + ucnv_close(cnv); + return; +} + +/** + * @brief Negative test case of utc_tizen_icu_api_ucnv_setToUCallBack() + * sending callback function as null will return error + */ +static void utc_tizen_icu_api_ucnv_setToUCallBack_func_02(void) +{ + const char *converter_name = "UTF-8"; + UErrorCode status = U_ZERO_ERROR; + UConverter *cnv = NULL; + UChar newToUContext = 0x0000; + cnv = ucnv_open(converter_name, &status); + + if (U_SUCCESS(status) && (NULL != cnv)) { + status = U_ILLEGAL_ARGUMENT_ERROR; + ucnv_setToUCallBack(cnv, UCNV_TO_U_CALLBACK_STOP, &newToUContext, NULL, NULL, &status); + if (U_FAILURE(status)) { + tet_infoline + ("utc_tizen_icu_api_ucnv_setToUCallBack test PASS!"); + tet_result(TET_PASS); + } else { + tet_infoline + ("utc_tizen_icu_api_ucnv_setToUCallBack test FAIL!"); + tet_printf("Error code %s", u_errorName(status)); + tet_result(TET_FAIL); + } + } else { + tet_infoline("utc_tizen_icu_api_ucnv_open test FAIL!"); + tet_printf("Error code %s\n", u_errorName(status)); + tet_result(TET_FAIL); + } + + ucnv_close(cnv); + return; + +} diff --git a/TC/unit/utc_tizen_icu_api_ucnv_toUChars_func.c b/TC/unit/utc_tizen_icu_api_ucnv_toUChars_func.c new file mode 100755 index 0000000..7d497ed --- /dev/null +++ b/TC/unit/utc_tizen_icu_api_ucnv_toUChars_func.c @@ -0,0 +1,133 @@ + /* + * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jayoun Lee + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static void startup(void); +static void cleanup(void); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_tizen_icu_api_ucnv_toUChars_func_01(void); +static void utc_tizen_icu_api_ucnv_toUChars_func_02(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + {utc_tizen_icu_api_ucnv_toUChars_func_01, POSITIVE_TC_IDX}, + {utc_tizen_icu_api_ucnv_toUChars_func_02, NEGATIVE_TC_IDX}, + {NULL, 0} +}; + +static void startup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_ucnv_ucnv_toUChars start"); + return; +} + +static void cleanup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_ucnv_ucnv_toUChars ends "); + return; +} + +/** + * @brief Positive test case of utc_tizen_icu_api_ucnv_ucnv_toUChars() + */ +static void utc_tizen_icu_api_ucnv_toUChars_func_01(void) +{ + const char *converter_name = "UTF-8"; + UErrorCode status = U_ZERO_ERROR; + UConverter *cnv = NULL; + UChar dest[50] = { 0, }; + int8_t result; + + cnv = ucnv_open(converter_name, &status); + if (U_SUCCESS(status) && (NULL != cnv)) { + result = + ucnv_toUChars(cnv, dest, 50, "hello world", 12, &status); + if (U_SUCCESS(status)) { + tet_infoline + ("utc_tizen_icu_api_ucnv_ucnv_toUChars test PASS!"); + tet_result(TET_PASS); + } else { + tet_infoline + ("utc_tizen_icu_api_ucnv_ucnv_toUChars test FAIL!"); + tet_printf("Error code %s\n", u_errorName(status)); + tet_result(TET_FAIL); + } + } else { + tet_infoline("utc_tizen_icu_api_ucnv_open test FAIL!"); + tet_printf("Error code %s\n", u_errorName(status)); + tet_result(TET_FAIL); + } + + ucnv_close(cnv); + return; +} + +/** + * @brief Negative test case of utc_tizen_icu_api_ucnv_ucnv_toUChars() + * sending source as null will return error + */ +static void utc_tizen_icu_api_ucnv_toUChars_func_02(void) +{ + const char *converter_name = "UTF-8"; + UErrorCode status = U_ZERO_ERROR; + UConverter *cnv = NULL; + UChar dest[50]; + int8_t result; + + cnv = ucnv_open(converter_name, &status); + if (U_SUCCESS(status) && (NULL != cnv)) { + ucnv_resetToUnicode(cnv); /* reset it to unicode */ + result = ucnv_toUChars(cnv, dest, 50, NULL, 0, &status); + if (U_SUCCESS(status)) { + tet_infoline + ("utc_tizen_icu_api_ucnv_ucnv_toUChars test PASS!"); + tet_result(TET_PASS); + } else { + tet_infoline + ("utc_tizen_icu_api_ucnv_ucnv_toUChars test FAIL!"); + tet_printf("Error code %s\n", u_errorName(status)); + tet_result(TET_FAIL); + } + } else { + tet_infoline("utc_tizen_icu_api_ucnv_open test FAIL!"); + tet_printf("Error code %s\n", u_errorName(status)); + tet_result(TET_FAIL); + } + + ucnv_close(cnv); + return; + +} diff --git a/TC/unit/utc_tizen_icu_api_ucnv_toUnicode_func.c b/TC/unit/utc_tizen_icu_api_ucnv_toUnicode_func.c new file mode 100755 index 0000000..a001c26 --- /dev/null +++ b/TC/unit/utc_tizen_icu_api_ucnv_toUnicode_func.c @@ -0,0 +1,126 @@ + /* + * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jayoun Lee + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static void startup(void); +static void cleanup(void); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_tizen_icu_api_ucnv_toUnicode_func_01(void); +static void utc_tizen_icu_api_ucnv_toUnicode_func_02(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + {utc_tizen_icu_api_ucnv_toUnicode_func_01, POSITIVE_TC_IDX}, + {utc_tizen_icu_api_ucnv_toUnicode_func_02, NEGATIVE_TC_IDX}, + {NULL, 0} +}; + +static void startup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_ucnv_toUnicode start"); + return; +} + +static void cleanup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_ucnv_toUnicode ends "); + return; +} + +/** + * @brief Positive test case of utc_tizen_icu_api_ucnv_toUnicode() + */ +static void utc_tizen_icu_api_ucnv_toUnicode_func_01(void) +{ + const char *converter_name = "UTF-7,version=1"; + UErrorCode status = U_ZERO_ERROR; + char input[] = { '\xEF', '\xBB', '\xBF', '\x41', '\x42', '\x43' }; + UChar output[100]; + UChar *target = output; + const char *source = input; + UConverter *cnv = NULL; + + cnv = ucnv_open(converter_name, &status); + if (U_SUCCESS(status) && (NULL != cnv)) { + + ucnv_toUnicode(cnv, &target, + output + sizeof(output) / U_SIZEOF_UCHAR, + &source, input + sizeof(input), NULL, TRUE, + &status); + if (U_SUCCESS(status)) { + tet_infoline + ("utc_tizen_icu_api_ucnv_toUnicode test PASS!"); + tet_result(TET_PASS); + } else { + tet_infoline + ("utc_tizen_icu_api_ucnv_toUnicode test FAIL!"); + tet_printf("Error code %s\n", u_errorName(status)); + tet_result(TET_FAIL); + } + } else { + tet_infoline("utc_tizen_icu_api_ucnv_open test FAIL!"); + tet_printf("Error code %s\n", u_errorName(status)); + tet_result(TET_FAIL); + } + + ucnv_close(cnv); + return; +} + +/** + * @brief Negative test case of utc_tizen_icu_api_ucnv_toUnicode() + * sending target as null will return buffer overflow error + */ +static void utc_tizen_icu_api_ucnv_toUnicode_func_02(void) +{ + UErrorCode status = U_ZERO_ERROR; + char input[] = { '\xEF', '\xBB', '\xBF', '\x41', '\x42', '\x43' }; + UChar output[100]; + const char *source = input; + + ucnv_toUnicode(NULL, NULL, output + sizeof(output) / U_SIZEOF_UCHAR, + &source, input + sizeof(input), NULL, TRUE, &status); + if (U_FAILURE(status)) { + tet_infoline("utc_tizen_icu_api_ucnv_toUnicode test PASS!"); + tet_result(TET_PASS); + } else { + tet_infoline("utc_tizen_icu_api_ucnv_toUnicode test FAIL!"); + tet_printf("Error code %s\n", u_errorName(status)); + tet_result(TET_FAIL); + } + return; + +} diff --git a/TC/unit/utc_tizen_icu_api_udat_close_func.c b/TC/unit/utc_tizen_icu_api_udat_close_func.c new file mode 100755 index 0000000..ae68bdb --- /dev/null +++ b/TC/unit/utc_tizen_icu_api_udat_close_func.c @@ -0,0 +1,89 @@ +/* + * tizen-icu-api + * + * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jayoun Lee + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static void startup(void); +static void cleanup(void); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_tizen_icu_api_udat_close_func_01(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + {utc_tizen_icu_api_udat_close_func_01, POSITIVE_TC_IDX}, + + {NULL, 0} +}; + +static void startup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_udat_close start"); + return; +} + +static void cleanup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_udat_close ends "); + return; +} + +/** + * @brief Positive test case of utc_tizen_icu_api_udat_close() + */ +static void utc_tizen_icu_api_udat_close_func_01(void) +{ + UDateFormat *date_fmt; + const char *locale = uloc_getDefault(); + UErrorCode status = U_ZERO_ERROR; + + date_fmt = + udat_open(UDAT_NONE, UDAT_LONG, locale, NULL, -1, NULL, -1, + &status); + + if (U_SUCCESS(status) && (NULL != date_fmt)) { + udat_close(date_fmt); + tet_infoline("utc_tizen_icu_api_udat_close test PASS!"); + tet_result(TET_PASS); + + } else { + tet_infoline("utc_tizen_icu_api_udat_open test FAIL!"); + tet_printf("Error code %s\n", u_errorName(status)); + tet_result(TET_FAIL); + } + + return; +} diff --git a/TC/unit/utc_tizen_icu_api_udat_format_func.c b/TC/unit/utc_tizen_icu_api_udat_format_func.c new file mode 100755 index 0000000..d10eac9 --- /dev/null +++ b/TC/unit/utc_tizen_icu_api_udat_format_func.c @@ -0,0 +1,100 @@ +/* + * tizen-icu-api + * + * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jayoun Lee + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static void startup(void); +static void cleanup(void); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_tizen_icu_api_udat_format_func_01(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + {utc_tizen_icu_api_udat_format_func_01, POSITIVE_TC_IDX}, + {NULL, 0} +}; + +static void startup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_udat_format start"); + return; +} + +static void cleanup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_udat_format ends "); + return; +} + +/** + * @brief Positive test case of utc_tizen_icu_api_udat_format() + */ +static void utc_tizen_icu_api_udat_format_func_01(void) +{ + UDateFormat *date_fmt = NULL; + const char *locale = uloc_getDefault(); + UErrorCode status = U_ZERO_ERROR; + UChar str[100] = { 0, }; + int32_t len; + UDate date = ucal_getNow(); + + date_fmt = + udat_open(UDAT_DEFAULT, UDAT_DEFAULT, locale, NULL, -1, NULL, + -1, &status); + + if (U_SUCCESS(status) && (NULL != date_fmt)) { + status = U_ZERO_ERROR; + len = udat_format(date_fmt, date, str, 100, NULL, &status); + if (U_SUCCESS(status)) { + tet_infoline + ("utc_tizen_icu_api_udat_format test PASS!"); + tet_result(TET_PASS); + } else { + tet_infoline + ("utc_tizen_icu_api_udat_format test FAIL!"); + tet_printf("Error code %s\n", u_errorName(status)); + tet_result(TET_FAIL); + } + } else { + tet_infoline("utc_tizen_icu_api_udat_open test FAIL!"); + tet_printf("Error code %s\n", u_errorName(status)); + tet_result(TET_FAIL); + } + udat_close(date_fmt); + + return; +} diff --git a/TC/unit/utc_tizen_icu_api_udat_getCalendar_func.c b/TC/unit/utc_tizen_icu_api_udat_getCalendar_func.c new file mode 100755 index 0000000..30f9457 --- /dev/null +++ b/TC/unit/utc_tizen_icu_api_udat_getCalendar_func.c @@ -0,0 +1,96 @@ +/* + * tizen-icu-api + * + * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jayoun Lee + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static void startup(void); +static void cleanup(void); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_tizen_icu_api_udat_getCalendar_func_01(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + {utc_tizen_icu_api_udat_getCalendar_func_01, POSITIVE_TC_IDX}, + {NULL, 0} +}; + +static void startup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_udat_getCalendar start"); + return; +} + +static void cleanup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_udat_getCalendar ends "); + return; +} + +/** + * @brief Positive test case of utc_tizen_icu_api_udat_getCalendar() + */ +static void utc_tizen_icu_api_udat_getCalendar_func_01(void) +{ + UDateFormat *date_fmt = NULL; + const char *locale = uloc_getDefault(); + UErrorCode status = U_ZERO_ERROR; + const UCalendar *calendar = NULL; + + date_fmt = + udat_open(UDAT_NONE, UDAT_SHORT, locale, NULL, -1, NULL, -1, + &status); + + if (U_SUCCESS(status) && (NULL != date_fmt)) { + calendar = udat_getCalendar(date_fmt); + if ((NULL != calendar)) { + tet_infoline + ("utc_tizen_icu_api_udat_getCalendar test PASS!"); + tet_result(TET_PASS); + } else { + tet_infoline + ("utc_tizen_icu_api_udat_getCalendar test FAIL!"); + tet_result(TET_FAIL); + } + } else { + tet_infoline("utc_tizen_icu_api_udat_open test FAIL!"); + tet_printf("Error code %s", u_errorName(status)); + tet_result(TET_FAIL); + } + udat_close(date_fmt); + + return; +} diff --git a/TC/unit/utc_tizen_icu_api_udat_getSymbols_func.c b/TC/unit/utc_tizen_icu_api_udat_getSymbols_func.c new file mode 100755 index 0000000..524e34c --- /dev/null +++ b/TC/unit/utc_tizen_icu_api_udat_getSymbols_func.c @@ -0,0 +1,145 @@ +/* + * tizen-icu-api + * + * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jayoun Lee + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static void startup(void); +static void cleanup(void); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_tizen_icu_api_udat_getSymbols_func_01(void); +static void utc_tizen_icu_api_udat_getSymbols_func_02(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + {utc_tizen_icu_api_udat_getSymbols_func_01, POSITIVE_TC_IDX}, + {utc_tizen_icu_api_udat_getSymbols_func_02, NEGATIVE_TC_IDX}, + {NULL, 0} +}; + +static void startup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_udat_getSymbols start"); + return; +} + +static void cleanup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_udat_getSymbols ends "); + return; +} + +/** + * @brief Positive test case of utc_tizen_icu_api_udat_getSymbols() + */ +static void utc_tizen_icu_api_udat_getSymbols_func_01(void) +{ + UDateFormat *date_fmt = NULL; + int32_t type[] = + { UDAT_ERAS, UDAT_MONTHS, UDAT_SHORT_MONTHS, UDAT_WEEKDAYS, + UDAT_SHORT_WEEKDAYS, UDAT_AM_PMS, UDAT_LOCALIZED_CHARS + }; + UChar result[50] = { 0, }; + UErrorCode status = U_ZERO_ERROR; + int32_t ret = 0; + int32_t i; + + date_fmt = + udat_open(UDAT_NONE, UDAT_SHORT, NULL, NULL, -1, NULL, -1, &status); + + if (U_SUCCESS(status) ) { + for (i = 0; i < 7; i++) { + ret = + udat_getSymbols(date_fmt, type[i], 5, result, 50, + &status); + if ((U_SUCCESS(status))) { + tet_infoline + ("utc_tizen_icu_api_udat_getSymbols test PASS!"); + tet_printf("Date Symbol %s\n", result); + tet_result(TET_PASS); + } else { + tet_infoline + ("utc_tizen_icu_api_udat_getSymbols test FAIL!"); + tet_printf("Error code %s\n", u_errorName(status)); + tet_result(TET_FAIL); + } + } + } else { + tet_infoline("utc_tizen_icu_api_udat_open test FAIL!"); + tet_printf("Error code %s\n", u_errorName(status)); + tet_result(TET_FAIL); + } + udat_close(date_fmt); + + return; +} + + +/** + * @brief Negative test case of utc_tizen_icu_api_udat_getSymbols() + * passing the NULL as a result will through error. + */ +static void utc_tizen_icu_api_udat_getSymbols_func_02(void) +{ + UDateFormat *date_fmt = NULL; + UErrorCode status = U_ZERO_ERROR; + int32_t ret; + + date_fmt = + udat_open(UDAT_NONE, UDAT_SHORT, NULL, NULL, -1, NULL, -1, &status); + + if (U_SUCCESS(status) && (NULL != date_fmt)) { + + ret = + udat_getSymbols(date_fmt, UDAT_MONTHS, 1, NULL, -1, + &status); + if (U_FAILURE(status)) { + tet_infoline + ("utc_tizen_icu_api_udat_getSymbols test PASS!"); + tet_result(TET_PASS); + } else { + tet_infoline + ("utc_tizen_icu_api_udat_getSymbols test FAIL!"); + tet_result(TET_FAIL); + } + } else { + tet_infoline("utc_tizen_icu_api_udat_open test FAIL!"); + tet_printf("Error code %s\n", u_errorName(status)); + tet_result(TET_FAIL); + } + udat_close(date_fmt); + +} diff --git a/TC/unit/utc_tizen_icu_api_udat_isLenient_func.c b/TC/unit/utc_tizen_icu_api_udat_isLenient_func.c new file mode 100755 index 0000000..90b17e7 --- /dev/null +++ b/TC/unit/utc_tizen_icu_api_udat_isLenient_func.c @@ -0,0 +1,98 @@ +/* + * tizen-icu-api + * + * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jayoun Lee + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static void startup(void); +static void cleanup(void); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_tizen_icu_api_udat_isLenient_func_01(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + {utc_tizen_icu_api_udat_isLenient_func_01, POSITIVE_TC_IDX}, + {NULL, 0} +}; + +static void startup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_udat_isLenient start"); + return; +} + +static void cleanup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_udat_isLenient ends "); + return; +} + +/** + * @brief Positive test case of utc_tizen_icu_api_udat_isLenient() + */ +static void utc_tizen_icu_api_udat_isLenient_func_01(void) +{ + UDateFormat *date_fmt = NULL; + const char *locale = uloc_getDefault(); + UErrorCode status = U_ZERO_ERROR; + UBool result; + + date_fmt = + udat_open(UDAT_NONE, UDAT_SHORT, locale, NULL, -1, NULL, -1, + &status); + + if (U_SUCCESS(status) && (NULL != date_fmt)) { + udat_setLenient(date_fmt, TRUE); /* Setting the date handler to lenient format */ + result = udat_isLenient(date_fmt); + if ((TRUE == result)) { + tet_infoline + ("utc_tizen_icu_api_udat_isLenient test PASS!"); + tet_result(TET_PASS); + } else { + tet_infoline + ("utc_tizen_icu_api_udat_isLenient test FAIL!"); + tet_result(TET_FAIL); + } + } else { + tet_infoline("utc_tizen_icu_api_udat_open test FAIL!"); + tet_printf("Error code %s\n", u_errorName(status)); + tet_result(TET_FAIL); + } + udat_close(date_fmt); + + return; +} + diff --git a/TC/unit/utc_tizen_icu_api_udat_open_func.c b/TC/unit/utc_tizen_icu_api_udat_open_func.c new file mode 100755 index 0000000..0101d4d --- /dev/null +++ b/TC/unit/utc_tizen_icu_api_udat_open_func.c @@ -0,0 +1,123 @@ +/* + * tizen-icu-api + * + * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jayoun Lee + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static void startup(void); +static void cleanup(void); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_tizen_icu_api_udat_open_func_01(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + {utc_tizen_icu_api_udat_open_func_01, POSITIVE_TC_IDX}, + {NULL, 0} +}; + +static void startup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_udat_open start"); + return; +} + +static void cleanup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_udat_open ends "); + return; +} + +/** + * @brief Positive test case of utc_tizen_icu_api_udat_open() + */ +static void utc_tizen_icu_api_udat_open_func_01(void) +{ + UDateFormat *date_fmt = NULL; + const char *locale = uloc_getDefault(); + UErrorCode status = U_ZERO_ERROR; + int32_t pattern[] = { UDAT_FULL, UDAT_LONG, UDAT_MEDIUM, UDAT_SHORT }; + int32_t i; + + for (i = 0; i < 4; i++) { + date_fmt = + udat_open(UDAT_NONE, pattern[i], locale, NULL, -1, NULL, -1, + &status); + + if (U_SUCCESS(status) && (NULL != date_fmt)) { + tet_infoline("utc_tizen_icu_api_udat_open test PASS!"); + tet_result(TET_PASS); + } else { + tet_infoline("utc_tizen_icu_api_udat_open test FAIL!"); + tet_printf("Error code %s", u_errorName(status)); + tet_result(TET_FAIL); + } + udat_close(date_fmt); + } + + for (i = 0; i < 4; i++) { + date_fmt = + udat_open(pattern[i], UDAT_NONE, locale, NULL, -1, NULL, -1, + &status); + + if (U_SUCCESS(status) && (NULL != date_fmt)) { + tet_infoline("utc_tizen_icu_api_udat_open test PASS!"); + tet_result(TET_PASS); + } else { + tet_infoline("utc_tizen_icu_api_udat_open test FAIL!"); + tet_printf("Error code %s", u_errorName(status)); + tet_result(TET_FAIL); + } + udat_close(date_fmt); + } + + for (i = 0; i < 4; i++) { + date_fmt = + udat_open(pattern[i], pattern[i], locale, NULL, -1, NULL, + -1, &status); + + if (U_SUCCESS(status) && (NULL != date_fmt)) { + tet_infoline("utc_tizen_icu_api_udat_open test PASS!"); + tet_result(TET_PASS); + } else { + tet_infoline("utc_tizen_icu_api_udat_open test FAIL!"); + tet_printf("Error code %s", u_errorName(status)); + tet_result(TET_FAIL); + } + udat_close(date_fmt); + } + + return; +} diff --git a/TC/unit/utc_tizen_icu_api_udat_setLenient_func.c b/TC/unit/utc_tizen_icu_api_udat_setLenient_func.c new file mode 100755 index 0000000..dbd139f --- /dev/null +++ b/TC/unit/utc_tizen_icu_api_udat_setLenient_func.c @@ -0,0 +1,97 @@ +/* + * tizen-icu-api + * + * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jayoun Lee + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static void startup(void); +static void cleanup(void); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_tizen_icu_api_udat_setLenient_func_01(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + {utc_tizen_icu_api_udat_setLenient_func_01, POSITIVE_TC_IDX}, + {NULL, 0} +}; + +static void startup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_udat_setLenient start"); + return; +} + +static void cleanup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_udat_setLenient ends "); + return; +} + +/** + * @brief Positive test case of utc_tizen_icu_api_udat_setLenient() + */ +static void utc_tizen_icu_api_udat_setLenient_func_01(void) +{ + UDateFormat *date_fmt = NULL; + const char *locale = uloc_getDefault(); + UErrorCode status = U_ZERO_ERROR; + UBool result; + + date_fmt = + udat_open(UDAT_NONE, UDAT_SHORT, locale, NULL, -1, NULL, -1, + &status); + + if (U_SUCCESS(status) && (NULL != date_fmt)) { + udat_setLenient(date_fmt, TRUE); /* Setting the date handler to lenient format */ + result = udat_isLenient(date_fmt); + if ((TRUE == result)) { + tet_infoline + ("utc_tizen_icu_api_udat_setLenient test PASS!"); + tet_result(TET_PASS); + } else { + tet_infoline + ("utc_tizen_icu_api_udat_setLenient test FAIL!"); + tet_result(TET_FAIL); + } + } else { + tet_infoline("utc_tizen_icu_api_udat_open test FAIL!"); + tet_printf("Error code %s\n", u_errorName(status)); + tet_result(TET_FAIL); + } + udat_close(date_fmt); + + return; +} diff --git a/TC/unit/utc_tizen_icu_api_udat_setSymbols_func.c b/TC/unit/utc_tizen_icu_api_udat_setSymbols_func.c new file mode 100755 index 0000000..3c1c011 --- /dev/null +++ b/TC/unit/utc_tizen_icu_api_udat_setSymbols_func.c @@ -0,0 +1,102 @@ +/* + * tizen-icu-api + * + * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jayoun Lee + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static void startup(void); +static void cleanup(void); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_tizen_icu_api_udat_setSymbols_func_01(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + {utc_tizen_icu_api_udat_setSymbols_func_01, POSITIVE_TC_IDX}, + {NULL, 0} +}; + +static void startup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_udat_setSymbols start"); + return; +} + +static void cleanup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_udat_setSymbols ends "); + return; +} + +/** + * @brief Positive test case of utc_tizen_icu_api_udat_setSymbols() + */ +static void utc_tizen_icu_api_udat_setSymbols_func_01(void) +{ + UDateFormat *date_fmt; + int32_t type[] = + { UDAT_ERAS, UDAT_MONTHS, UDAT_SHORT_MONTHS, UDAT_WEEKDAYS, + UDAT_SHORT_WEEKDAYS, UDAT_AM_PMS, UDAT_LOCALIZED_CHARS + }; + UChar value[50]; + UErrorCode status = U_ZERO_ERROR; + int32_t i; + + date_fmt = + udat_open(UDAT_NONE, UDAT_SHORT, NULL, NULL, -1, NULL, -1, &status); + + if (U_SUCCESS(status) ) { + for (i = 0; i < 5; i++) { + udat_setSymbols(date_fmt, type[i], i, value, -1, + &status); + if ((U_SUCCESS(status))) { + tet_infoline + ("utc_tizen_icu_api_udat_setSymbols test PASS!"); + tet_result(TET_PASS); + } else { + tet_infoline + ("utc_tizen_icu_api_udat_setSymbols test FAIL!"); + tet_result(TET_FAIL); + } + } + } else { + tet_infoline("utc_tizen_icu_api_udat_open test FAIL!"); + tet_printf("Error code %s", u_errorName(status)); + tet_result(TET_FAIL); + } + udat_close(date_fmt); + + return; +} diff --git a/TC/unit/utc_tizen_icu_api_udat_toPatternRelativeDate_func.c b/TC/unit/utc_tizen_icu_api_udat_toPatternRelativeDate_func.c new file mode 100755 index 0000000..b94eb8d --- /dev/null +++ b/TC/unit/utc_tizen_icu_api_udat_toPatternRelativeDate_func.c @@ -0,0 +1,160 @@ +/* + * tizen-icu-api + * + * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jayoun Lee + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static void startup(void); +static void cleanup(void); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_tizen_icu_api_udat_toPatternRelativeDate_func_01(void); +static void utc_tizen_icu_api_udat_toPatternRelativeDate_func_02(void); +static void utc_tizen_icu_api_udat_toPatternRelativeDate_func_03(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + {utc_tizen_icu_api_udat_toPatternRelativeDate_func_01, POSITIVE_TC_IDX}, + {utc_tizen_icu_api_udat_toPatternRelativeDate_func_02, NEGATIVE_TC_IDX}, + {utc_tizen_icu_api_udat_toPatternRelativeDate_func_03, NEGATIVE_TC_IDX}, + {NULL, 0} +}; + +static void startup(void) +{ + tet_infoline + ("Testing API utc_tizen_icu_api_udat_toPatternRelativeDate start"); + return; +} + +static void cleanup(void) +{ + tet_infoline + ("Testing API utc_tizen_icu_api_udat_toPatternRelativeDate ends "); + return; +} + +/** + * @brief Positive test case of utc_tizen_icu_api_udat_toPatternRelativeDate() + */ +static void utc_tizen_icu_api_udat_toPatternRelativeDate_func_01(void) +{ + UDateFormat *date_fmt = NULL; + const char *locale = uloc_getDefault(); + UChar result[50] = { 0, }; + UErrorCode status = U_ZERO_ERROR; + int32_t ret; + + date_fmt = + udat_open(UDAT_NONE, UDAT_SHORT, locale, NULL, -1, NULL, -1, + &status); + + if (U_SUCCESS(status)) { + ret = udat_toPatternRelativeDate(date_fmt, result, 50, &status); + if (!(U_SUCCESS(status))) { + tet_infoline + ("utc_tizen_icu_api_udat_toPatternRelativeDate test PASS!"); + tet_printf("Date patttern %s\n", result); + tet_result(TET_PASS); + } else { + tet_infoline + ("utc_tizen_icu_api_udat_toPatternRelativeDate test FAIL!"); + tet_printf("Error code %s\n", u_errorName(status)); + tet_result(TET_FAIL); + } + } else { + tet_infoline("utc_tizen_icu_api_udat_open test FAIL!"); + tet_printf("Error code %s\n", u_errorName(status)); + tet_result(TET_FAIL); + } + + udat_close(date_fmt); + + return; +} + +/** + * @brief Negative test case of utc_tizen_icu_api_udat_toPatternRelativeDate() + * passing the fmt arg to function without opening udat_open + */ +static void utc_tizen_icu_api_udat_toPatternRelativeDate_func_02(void) +{ + UChar result[50] = { 0, }; + UErrorCode status = U_ZERO_ERROR; + int32_t ret; + + ret = udat_toPatternRelativeDate(NULL, result, 50, &status); + if (U_FAILURE(status)) { + tet_infoline + ("utc_tizen_icu_api_udat_toPatternRelativeDate test PASS!"); + tet_result(TET_PASS); + } else { + tet_infoline + ("utc_tizen_icu_api_udat_toPatternRelativeDate test FAIL!"); + tet_printf("Error code %s\n", u_errorName(status)); + tet_result(TET_FAIL); + } + +} + +/** + * @brief Negative test case of utc_tizen_icu_api_udat_toPatternRelativeDate() + * passing the NULL as a result will through error. + */ +static void utc_tizen_icu_api_udat_toPatternRelativeDate_func_03(void) +{ + UDateFormat *date_fmt = NULL; + const char *locale = uloc_getDefault(); + UErrorCode status = U_ZERO_ERROR; + int32_t ret; + + date_fmt = + udat_open(UDAT_NONE, UDAT_SHORT, locale, NULL, -1, NULL, -1, + &status); + if (U_SUCCESS(status) && (NULL != date_fmt)) { + ret = udat_toPatternRelativeDate(date_fmt, NULL, -1, &status); + if (U_FAILURE(status)) { + tet_infoline + ("utc_tizen_icu_api_udat_toPatternRelativeDate test PASS!"); + tet_result(TET_PASS); + } else { + tet_infoline + ("utc_tizen_icu_api_udat_toPatternRelativeDate test FAIL!"); + tet_printf("Error code %s\n", u_errorName(status)); + tet_result(TET_FAIL); + } + } + +} diff --git a/TC/unit/utc_tizen_icu_api_uloc_getAvailable_func.c b/TC/unit/utc_tizen_icu_api_uloc_getAvailable_func.c new file mode 100755 index 0000000..3ff63de --- /dev/null +++ b/TC/unit/utc_tizen_icu_api_uloc_getAvailable_func.c @@ -0,0 +1,103 @@ +/* + * tizen-icu-api + * + * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jayoun Lee + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static void startup(void); +static void cleanup(void); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_tizen_icu_api_uloc_getAvailable_func_01(void); +static void utc_tizen_icu_api_uloc_getAvailable_func_02(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + {utc_tizen_icu_api_uloc_getAvailable_func_01, POSITIVE_TC_IDX}, + {utc_tizen_icu_api_uloc_getAvailable_func_02, NEGATIVE_TC_IDX}, + {NULL, 0} +}; + +static void startup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_uloc_getAvailable start"); + return; +} + +static void cleanup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_uloc_getAvailable ends "); + return; +} + +/** + * @brief Positive test case of utc_tizen_icu_api_uloc_getAvailable() + */ +static void utc_tizen_icu_api_uloc_getAvailable_func_01(void) +{ + const char *result = NULL; + int32_t index = 5; + result = uloc_getAvailable(index); + + if (NULL != result) { + tet_infoline("utc_tizen_icu_api_uloc_getAvailable test PASS!"); + tet_printf("locale for give index %d is %s\n", index, result); + tet_result(TET_PASS); + } else { + tet_infoline("utc_tizen_icu_api_uloc_getAvailable test FAIL!"); + tet_result(TET_FAIL); + } + return; +} + +/** + * @brief Negative test case of utc_tizen_icu_api_uloc_getAvailable() + * if index is greater than installed locale count it will return null + */ +static void utc_tizen_icu_api_uloc_getAvailable_func_02(void) +{ + const char *result = NULL; + int32_t index = 5000; /* invalide index */ + result = uloc_getAvailable(index); + + if (NULL == result) { + tet_infoline("utc_tizen_icu_api_uloc_getAvailable test PASS!"); + tet_result(TET_PASS); + } else { + tet_infoline("utc_tizen_icu_api_uloc_getAvailable test FAIL!"); + tet_result(TET_FAIL); + } + return; +} diff --git a/TC/unit/utc_tizen_icu_api_uloc_getCountry_func.c b/TC/unit/utc_tizen_icu_api_uloc_getCountry_func.c new file mode 100755 index 0000000..b7293be --- /dev/null +++ b/TC/unit/utc_tizen_icu_api_uloc_getCountry_func.c @@ -0,0 +1,140 @@ +/* + * tizen-icu-api + * + * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jayoun Lee + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static void startup(void); +static void cleanup(void); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_tizen_icu_api_uloc_getCountry_func_01(void); +static void utc_tizen_icu_api_uloc_getCountry_func_02(void); +static void utc_tizen_icu_api_uloc_getCountry_func_03(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + {utc_tizen_icu_api_uloc_getCountry_func_01, POSITIVE_TC_IDX}, + {utc_tizen_icu_api_uloc_getCountry_func_02, NEGATIVE_TC_IDX}, + {utc_tizen_icu_api_uloc_getCountry_func_03, NEGATIVE_TC_IDX}, + {NULL, 0} +}; + +static void startup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_uloc_getCountry start"); + return; +} + +static void cleanup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_uloc_getCountry ends "); + return; +} + +/** + * @brief Positive test case of utc_tizen_icu_api_uloc_getCountry() + */ +static void utc_tizen_icu_api_uloc_getCountry_func_01(void) +{ + const char *locale_id = uloc_getDefault(); + char country[ULOC_COUNTRY_CAPACITY]; + int32_t country_capacity = ULOC_COUNTRY_CAPACITY; + UErrorCode err = U_ZERO_ERROR; + int32_t result; + + result = uloc_getCountry(locale_id, country, country_capacity, &err); + + if (U_SUCCESS(err)) { + tet_infoline("utc_tizen_icu_api_uloc_getCountry test PASS!"); + tet_printf("country for this %s locale %s\n", locale_id, + country); + tet_result(TET_PASS); + } else { + tet_infoline("utc_tizen_icu_api_uloc_getCountry test FAIL!"); + tet_printf("Error is %d\n", err); + tet_result(TET_FAIL); + } + return; +} + +/** + * @brief Negative test case of utc_tizen_icu_api_uloc_getCountry() + * function should return 0 if errcode is null + */ +static void utc_tizen_icu_api_uloc_getCountry_func_02(void) +{ + const char *locale_id = "fr_FR"; + char country[ULOC_COUNTRY_CAPACITY]; + int32_t country_capacity = ULOC_COUNTRY_CAPACITY; + UErrorCode err = U_ZERO_ERROR; + int32_t result; + + result = uloc_getCountry(locale_id, country, country_capacity, NULL); + + if (0 == result) { + tet_infoline("utc_tizen_icu_api_uloc_getCountry test PASS!"); + tet_result(TET_PASS); + } else { + tet_infoline("utc_tizen_icu_api_uloc_getCountry test FAIL!"); + tet_printf("Error is %d\n", err); + tet_result(TET_FAIL); + } + return; +} + +/** + * @brief Negative test case of utc_tizen_icu_api_uloc_getCountry() + * function should return 0 if error code is positive value. + */ +static void utc_tizen_icu_api_uloc_getCountry_func_03(void) +{ + const char *locale_id = "fr_FR"; + char country[ULOC_COUNTRY_CAPACITY]; + int32_t country_capacity = ULOC_COUNTRY_CAPACITY; + UErrorCode err = 1; + int32_t result; + + result = uloc_getCountry(locale_id, country, country_capacity, &err); + + if (0 == result) { + tet_infoline("utc_tizen_icu_api_uloc_getCountry test PASS!"); + tet_result(TET_PASS); + } else { + tet_infoline("utc_tizen_icu_api_uloc_getCountry test FAIL!"); + tet_result(TET_FAIL); + } + return; +} diff --git a/TC/unit/utc_tizen_icu_api_uloc_getDefault_func.c b/TC/unit/utc_tizen_icu_api_uloc_getDefault_func.c new file mode 100755 index 0000000..53a4fd2 --- /dev/null +++ b/TC/unit/utc_tizen_icu_api_uloc_getDefault_func.c @@ -0,0 +1,80 @@ +/* + * tizen-icu-api + * + * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jayoun Lee + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static void startup(void); +static void cleanup(void); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_tizen_icu_api_uloc_getDefault_func_01(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + {utc_tizen_icu_api_uloc_getDefault_func_01, POSITIVE_TC_IDX}, + {NULL, 0} +}; + +static void startup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_uloc_getDefault start"); + return; +} + +static void cleanup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_uloc_getDefault ends "); + return; +} + +/** + * @brief Positive test case of utc_tizen_icu_api_uloc_getDefault() + */ +static void utc_tizen_icu_api_uloc_getDefault_func_01(void) +{ + const char *result = NULL; + result = uloc_getDefault(); + + if (NULL != result) { + tet_infoline("utc_tizen_icu_api_uloc_getDefault test PASS!"); + tet_printf("Default locale %s\n", result); + tet_result(TET_PASS); + } else { + tet_infoline("utc_tizen_icu_api_uloc_getDefault test FAIL!"); + tet_result(TET_FAIL); + } + return; +} diff --git a/TC/unit/utc_tizen_icu_api_uloc_getDisplayCountry_func.c b/TC/unit/utc_tizen_icu_api_uloc_getDisplayCountry_func.c new file mode 100755 index 0000000..082ed74 --- /dev/null +++ b/TC/unit/utc_tizen_icu_api_uloc_getDisplayCountry_func.c @@ -0,0 +1,176 @@ +/* + * tizen-icu-api + * + * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jayoun Lee + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static void startup(void); +static void cleanup(void); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_tizen_icu_api_uloc_getDisplayCountry_func_01(void); +static void utc_tizen_icu_api_uloc_getDisplayCountry_func_02(void); +static void utc_tizen_icu_api_uloc_getDisplayCountry_func_03(void); +static void utc_tizen_icu_api_uloc_getDisplayCountry_func_04(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + {utc_tizen_icu_api_uloc_getDisplayCountry_func_01, POSITIVE_TC_IDX}, + {utc_tizen_icu_api_uloc_getDisplayCountry_func_02, NEGATIVE_TC_IDX}, + {utc_tizen_icu_api_uloc_getDisplayCountry_func_03, NEGATIVE_TC_IDX}, + {utc_tizen_icu_api_uloc_getDisplayCountry_func_04, NEGATIVE_TC_IDX}, + {NULL, 0} +}; + +static void startup(void) +{ + tet_infoline + ("Testing API utc_tizen_icu_api_uloc_getDisplayCountry start"); + return; +} + +static void cleanup(void) +{ + tet_infoline + ("Testing API utc_tizen_icu_api_uloc_getDisplayCountry ends "); + return; +} + +/** + * @brief Positive test case of utc_tizen_icu_api_uloc_getDisplayCountry() + */ +static void utc_tizen_icu_api_uloc_getDisplayCountry_func_01(void) +{ + const char *locale = uloc_getDefault(); + UChar Country[50] = { 0, }; + int32_t Country_capacity = 50; + int32_t result; + UErrorCode status = U_ZERO_ERROR; + + result = + uloc_getDisplayCountry(locale, NULL, Country, Country_capacity, + &status); + if ((U_SUCCESS(status)) ) { + tet_infoline + ("utc_tizen_icu_api_uloc_getDisplayCountry test PASS!"); + tet_printf("Display Country %s\n", Country); + tet_result(TET_PASS); + } else { + tet_infoline + ("utc_tizen_icu_api_uloc_getDisplayCountry test FAIL!"); + tet_result(TET_FAIL); + } + return; +} + +/** + * @brief Negative test case of utc_tizen_icu_api_uloc_getDisplayCountry() + * status variable null will return error + */ +static void utc_tizen_icu_api_uloc_getDisplayCountry_func_02(void) +{ + const char *locale = uloc_getDefault(); + UChar Country[50] = { 0, }; + int32_t Country_capacity = 50; + int32_t result; + + result = + uloc_getDisplayCountry(locale, NULL, Country, Country_capacity, + NULL); + if (result == 0) { + tet_infoline + ("utc_tizen_icu_api_uloc_getDisplayCountry test PASS!"); + tet_result(TET_PASS); + } else { + tet_infoline + ("utc_tizen_icu_api_uloc_getDisplayCountry test FAIL!"); + tet_result(TET_FAIL); + } + return; +} + +/** + * @brief Negative test case of utc_tizen_icu_api_uloc_getDisplayCountry() + * if Country is null it should return the status as U_ILLEGAL_ARGUMENT_ERROR + * + */ +static void utc_tizen_icu_api_uloc_getDisplayCountry_func_03(void) +{ + int32_t Country_capacity = 50; + int32_t result; + UErrorCode status = U_ZERO_ERROR; + + result = + uloc_getDisplayCountry(NULL, NULL, NULL, Country_capacity, &status); + if ((result == 0) || (U_FAILURE(status))) { + tet_infoline + ("utc_tizen_icu_api_uloc_getDisplayCountry test PASS!"); + tet_result(TET_PASS); + } else { + tet_infoline + ("utc_tizen_icu_api_uloc_getDisplayCountry test FAIL!"); + tet_printf("Status %d\n", status); + tet_result(TET_FAIL); + } + return; +} + +/** + * @brief Negative test case of utc_tizen_icu_api_uloc_getDisplayCountry() + * if Country capacity is less than zero it will return status as U_ILLEGAL_ARGUMENT_ERROR + * + */ +static void utc_tizen_icu_api_uloc_getDisplayCountry_func_04(void) +{ + UChar Country[50] = { 0, }; + int32_t Country_capacity = 0; + int32_t result; + UErrorCode status = U_ZERO_ERROR; + + result = + uloc_getDisplayCountry(NULL, NULL, Country, Country_capacity, + &status); + if ((result == 0) || (U_FAILURE(status))) { + tet_infoline + ("utc_tizen_icu_api_uloc_getDisplayCountry test PASS!"); + tet_result(TET_PASS); + } else { + tet_infoline + ("utc_tizen_icu_api_uloc_getDisplayCountry test FAIL!"); + tet_printf("Status %d\n", status); + tet_result(TET_FAIL); + } + return; +} diff --git a/TC/unit/utc_tizen_icu_api_uloc_getDisplayLanguage_func.c b/TC/unit/utc_tizen_icu_api_uloc_getDisplayLanguage_func.c new file mode 100755 index 0000000..86c9863 --- /dev/null +++ b/TC/unit/utc_tizen_icu_api_uloc_getDisplayLanguage_func.c @@ -0,0 +1,169 @@ +/* + * tizen-icu-api + * + * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jayoun Lee + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static void startup(void); +static void cleanup(void); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_tizen_icu_api_uloc_getDisplayLanguage_func_01(void); +static void utc_tizen_icu_api_uloc_getDisplayLanguage_func_02(void); +static void utc_tizen_icu_api_uloc_getDisplayLanguage_func_03(void); +static void utc_tizen_icu_api_uloc_getDisplayLanguage_func_04(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + {utc_tizen_icu_api_uloc_getDisplayLanguage_func_01, POSITIVE_TC_IDX}, + {utc_tizen_icu_api_uloc_getDisplayLanguage_func_02, NEGATIVE_TC_IDX}, + {utc_tizen_icu_api_uloc_getDisplayLanguage_func_03, NEGATIVE_TC_IDX}, + {utc_tizen_icu_api_uloc_getDisplayLanguage_func_04, NEGATIVE_TC_IDX}, + {NULL, 0} +}; + +static void startup(void) +{ + tet_infoline + ("Testing API utc_tizen_icu_api_uloc_getDisplayLanguage start"); + return; +} + +static void cleanup(void) +{ + tet_infoline + ("Testing API utc_tizen_icu_api_uloc_getDisplayLanguage ends "); + return; +} + +/** + * @brief Positive test case of utc_tizen_icu_api_uloc_getDisplayLanguage() + */ +static void utc_tizen_icu_api_uloc_getDisplayLanguage_func_01(void) +{ + const char *locale = uloc_getDefault(); + UChar language[50] = { 0, }; + int32_t result; + UErrorCode status = U_ZERO_ERROR; + + result = uloc_getDisplayLanguage(locale, NULL, language, 50, &status); + if (U_SUCCESS(status)) { + tet_infoline + ("utc_tizen_icu_api_uloc_getDisplayLanguage test PASS!"); + tet_printf("Display language %s\n", language); + tet_result(TET_PASS); + } else { + tet_infoline + ("utc_tizen_icu_api_uloc_getDisplayLanguage test FAIL!"); + tet_result(TET_FAIL); + } + return; +} + +/** + * @brief Negative test case of utc_tizen_icu_api_uloc_getDisplayLanguage() + * status variable null will return error + */ +static void utc_tizen_icu_api_uloc_getDisplayLanguage_func_02(void) +{ + const char *locale = uloc_getDefault(); + UChar language[50] = { 0, }; + int32_t language_capacity = 50; + int32_t result; + + result = + uloc_getDisplayLanguage(locale, NULL, language, language_capacity, + NULL); + if (result == 0) { + tet_infoline + ("utc_tizen_icu_api_uloc_getDisplayLanguage test PASS!"); + tet_result(TET_PASS); + } else { + tet_infoline + ("utc_tizen_icu_api_uloc_getDisplayLanguage test FAIL!"); + tet_result(TET_FAIL); + } + return; +} + +/** + * @brief Negative test case of utc_tizen_icu_api_uloc_getDisplayLanguage() + * if language is null it should return the status as U_ILLEGAL_ARGUMENT_ERROR + * + */ +static void utc_tizen_icu_api_uloc_getDisplayLanguage_func_03(void) +{ + int32_t result; + UErrorCode status; + + /* locale and display locale is null mean it will take default one */ + result = uloc_getDisplayLanguage(NULL, NULL, NULL, 50, &status); + if ((result == 0) || (U_FAILURE(status))) { + tet_infoline + ("utc_tizen_icu_api_uloc_getDisplayLanguage test PASS!"); + tet_result(TET_PASS); + } else { + tet_infoline + ("utc_tizen_icu_api_uloc_getDisplayLanguage test FAIL!"); + tet_printf("Status %d\n", status); + tet_result(TET_FAIL); + } + return; +} + +/** + * @brief Negative test case of utc_tizen_icu_api_uloc_getDisplayLanguage() + * if language capacity is less than zero it will return status as U_ILLEGAL_ARGUMENT_ERROR + * + */ +static void utc_tizen_icu_api_uloc_getDisplayLanguage_func_04(void) +{ + UChar language[50] = { 0, }; + int32_t result; + UErrorCode status; + + result = uloc_getDisplayLanguage(NULL, NULL, language, 0, &status); + if (U_FAILURE(status)) { + tet_infoline + ("utc_tizen_icu_api_uloc_getDisplayLanguage test PASS!"); + tet_result(TET_PASS); + } else { + tet_infoline + ("utc_tizen_icu_api_uloc_getDisplayLanguage test FAIL!"); + tet_printf("Status %d\n", status); + tet_result(TET_FAIL); + } + return; +} diff --git a/TC/unit/utc_tizen_icu_api_uloc_getDisplayName_func.c b/TC/unit/utc_tizen_icu_api_uloc_getDisplayName_func.c new file mode 100755 index 0000000..3c53500 --- /dev/null +++ b/TC/unit/utc_tizen_icu_api_uloc_getDisplayName_func.c @@ -0,0 +1,175 @@ +/* + * tizen-icu-api + * + * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jayoun Lee + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static void startup(void); +static void cleanup(void); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_tizen_icu_api_uloc_getDisplayName_func_01(void); +static void utc_tizen_icu_api_uloc_getDisplayName_func_02(void); +static void utc_tizen_icu_api_uloc_getDisplayName_func_03(void); +static void utc_tizen_icu_api_uloc_getDisplayName_func_04(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + {utc_tizen_icu_api_uloc_getDisplayName_func_01, POSITIVE_TC_IDX}, + {utc_tizen_icu_api_uloc_getDisplayName_func_02, NEGATIVE_TC_IDX}, + {utc_tizen_icu_api_uloc_getDisplayName_func_03, NEGATIVE_TC_IDX}, + {utc_tizen_icu_api_uloc_getDisplayName_func_04, NEGATIVE_TC_IDX}, + {NULL, 0} +}; + +static void startup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_uloc_getDisplayName start"); + return; +} + +static void cleanup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_uloc_getDisplayName ends "); + return; +} + +/** + * @brief Positive test case of utc_tizen_icu_api_uloc_getDisplayName() + */ +static void utc_tizen_icu_api_uloc_getDisplayName_func_01(void) +{ + const char *locale_id = "fr_FR"; + UChar result[50] = { 0, }; + int32_t max_result_size = 50; + UErrorCode err = U_ZERO_ERROR; + int32_t ret; + + ret = + uloc_getDisplayName(locale_id, NULL, result, max_result_size, &err); + if ((U_SUCCESS(err)) && (0 != ret)) { + tet_infoline + ("utc_tizen_icu_api_uloc_getDisplayName test PASS!"); + tet_printf("Display Name %s\n", result); + tet_result(TET_PASS); + } else { + tet_infoline + ("utc_tizen_icu_api_uloc_getDisplayName test FAIL!"); + tet_result(TET_FAIL); + } + return; +} + +/** + * @brief Negative test case of utc_tizen_icu_api_uloc_getDisplayName() + * if error code is null it will return 0 + */ +static void utc_tizen_icu_api_uloc_getDisplayName_func_02(void) +{ + const char *locale_id = "fr_FR"; + UChar result[50] = { 0, }; + int32_t max_result_size = 50; + int32_t ret; + + ret = + uloc_getDisplayName(locale_id, NULL, result, max_result_size, NULL); + + if (ret == 0) { + tet_infoline + ("utc_tizen_icu_api_uloc_getDisplayName test PASS!"); + tet_result(TET_PASS); + } else { + tet_infoline + ("utc_tizen_icu_api_uloc_getDisplayName test FAIL!"); + tet_result(TET_FAIL); + } + return; +} + +/** + * @brief Negative test case of utc_tizen_icu_api_uloc_getDisplayName() + * if result is null it should return the status as U_ILLEGAL_ARGUMENT_ERROR + * + */ +static void utc_tizen_icu_api_uloc_getDisplayName_func_03(void) +{ + const char *locale_id = "fr_FR"; + int32_t max_result_size = 50; + UErrorCode err = U_ZERO_ERROR; + int32_t ret; + + ret = uloc_getDisplayName(locale_id, NULL, NULL, max_result_size, &err); + + if ((U_FAILURE(err))) { + tet_infoline + ("utc_tizen_icu_api_uloc_getDisplayName test PASS!"); + tet_result(TET_PASS); + } else { + tet_infoline + ("utc_tizen_icu_api_uloc_getDisplayName test FAIL!"); + tet_printf("Status %d\n", err); + tet_result(TET_FAIL); + } + return; +} + +/** + * @brief Negative test case of utc_tizen_icu_api_uloc_getDisplayName() + * if result size is less than zero it will return status as U_ILLEGAL_ARGUMENT_ERROR + * + */ +static void utc_tizen_icu_api_uloc_getDisplayName_func_04(void) +{ + const char *locale_id = "fr_FR"; + UChar result[50] = { 0, }; + int32_t max_result_size = 0; + UErrorCode err = U_ZERO_ERROR; + int32_t ret; + + ret = + uloc_getDisplayName(locale_id, NULL, result, max_result_size, &err); + + if ((result == 0) || (U_FAILURE(err))) { + tet_infoline + ("utc_tizen_icu_api_uloc_getDisplayName test PASS!"); + tet_result(TET_PASS); + } else { + tet_infoline + ("utc_tizen_icu_api_uloc_getDisplayName test FAIL!"); + tet_printf("Status %d\n", err); + tet_result(TET_FAIL); + } + return; +} diff --git a/TC/unit/utc_tizen_icu_api_uloc_getDisplayVariant_func.c b/TC/unit/utc_tizen_icu_api_uloc_getDisplayVariant_func.c new file mode 100755 index 0000000..f0fdc4e --- /dev/null +++ b/TC/unit/utc_tizen_icu_api_uloc_getDisplayVariant_func.c @@ -0,0 +1,169 @@ +/* + * tizen-icu-api + * + * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jayoun Lee + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static void startup(void); +static void cleanup(void); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_tizen_icu_api_uloc_getDisplayVariant_func_01(void); +static void utc_tizen_icu_api_uloc_getDisplayVariant_func_02(void); +static void utc_tizen_icu_api_uloc_getDisplayVariant_func_03(void); +static void utc_tizen_icu_api_uloc_getDisplayVariant_func_04(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + {utc_tizen_icu_api_uloc_getDisplayVariant_func_01, POSITIVE_TC_IDX}, + {utc_tizen_icu_api_uloc_getDisplayVariant_func_02, NEGATIVE_TC_IDX}, + {utc_tizen_icu_api_uloc_getDisplayVariant_func_03, NEGATIVE_TC_IDX}, + {utc_tizen_icu_api_uloc_getDisplayVariant_func_04, NEGATIVE_TC_IDX}, + {NULL, 0} +}; + +static void startup(void) +{ + tet_infoline + ("Testing API utc_tizen_icu_api_uloc_getDisplayVariant start"); + return; +} + +static void cleanup(void) +{ + tet_infoline + ("Testing API utc_tizen_icu_api_uloc_getDisplayVariant ends "); + return; +} + +/** + * @brief Positive test case of utc_tizen_icu_api_uloc_getDisplayVariant() + */ +static void utc_tizen_icu_api_uloc_getDisplayVariant_func_01(void) +{ + const char *locale = uloc_getDefault(); + UChar variant[50] = { 0, }; + int32_t variant_capacity = 50; + int32_t result; + UErrorCode status = U_ZERO_ERROR; + + result = + uloc_getDisplayVariant(locale, NULL, variant, variant_capacity, + &status); + if (U_SUCCESS(status) && (result > 0)) { + tet_infoline + ("utc_tizen_icu_api_uloc_getDisplayVariant test PASS!"); + tet_printf("Display Variant %s\n", variant); + tet_result(TET_PASS); + } else { + tet_infoline + ("utc_tizen_icu_api_uloc_getDisplayVariant test FAIL!"); + tet_result(TET_FAIL); + } + return; +} + +/** + * @brief Negative test case of utc_tizen_icu_api_uloc_getDisplayVariant() + * if status is null it will return 0 + */ +static void utc_tizen_icu_api_uloc_getDisplayVariant_func_02(void) +{ + UChar variant[50] = { 0, }; + int32_t variant_capacity = 50; + int32_t result; + + result = + uloc_getDisplayVariant(NULL, NULL, variant, variant_capacity, NULL); + if (result == 0) { + tet_infoline + ("utc_tizen_icu_api_uloc_getDisplayVariant test PASS!"); + tet_result(TET_PASS); + } else { + tet_infoline + ("utc_tizen_icu_api_uloc_getDisplayVariant test FAIL!"); + tet_result(TET_FAIL); + } + return; +} + +/** + * @brief Negative test case of utc_tizen_icu_api_uloc_getDisplayVariant() + * if Variant is null it should return the status as U_ILLEGAL_ARGUMENT_ERROR + * + */ +static void utc_tizen_icu_api_uloc_getDisplayVariant_func_03(void) +{ + int32_t result; + UErrorCode status = U_ZERO_ERROR; + + result = uloc_getDisplayVariant(NULL, NULL, NULL, 50, &status); + if ((result == 0) || (U_FAILURE(status))) { + tet_infoline + ("utc_tizen_icu_api_uloc_getDisplayVariant test PASS!"); + tet_result(TET_PASS); + } else { + tet_infoline + ("utc_tizen_icu_api_uloc_getDisplayVariant test FAIL!"); + tet_printf("Status %d\n", status); + tet_result(TET_FAIL); + } + return; +} + +/** + * @brief Negative test case of utc_tizen_icu_api_uloc_getDisplayVariant() + * if Variant capacity is less than zero it will return status as U_ILLEGAL_ARGUMENT_ERROR + * + */ +static void utc_tizen_icu_api_uloc_getDisplayVariant_func_04(void) +{ + UChar variant[50] = { 0, }; + int32_t result; + UErrorCode status = U_ZERO_ERROR; + + result = uloc_getDisplayVariant(NULL, NULL, variant, 0, &status); + if ((result == 0) || (U_FAILURE(status))) { + tet_infoline + ("utc_tizen_icu_api_uloc_getDisplayVariant test PASS!"); + tet_result(TET_PASS); + } else { + tet_infoline + ("utc_tizen_icu_api_uloc_getDisplayVariant test FAIL!"); + tet_printf("Status %d\n", status); + tet_result(TET_FAIL); + } + return; +} diff --git a/TC/unit/utc_tizen_icu_api_uloc_getISO3Country_func.c b/TC/unit/utc_tizen_icu_api_uloc_getISO3Country_func.c new file mode 100755 index 0000000..27220ef --- /dev/null +++ b/TC/unit/utc_tizen_icu_api_uloc_getISO3Country_func.c @@ -0,0 +1,111 @@ +/* + * tizen-icu-api + * + * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jayoun Lee + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static void startup(void); +static void cleanup(void); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_tizen_icu_api_uloc_getISO3Country_func_01(void); +static void utc_tizen_icu_api_uloc_getISO3Country_func_02(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + {utc_tizen_icu_api_uloc_getISO3Country_func_01, POSITIVE_TC_IDX}, + {utc_tizen_icu_api_uloc_getISO3Country_func_02, NEGATIVE_TC_IDX}, + {NULL, 0} +}; + +static void startup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_uloc_getISO3Country start"); + return; +} + +static void cleanup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_uloc_getISO3Country ends "); + return; +} + +/** + * @brief Positive test case of utc_tizen_icu_api_uloc_getISO3Country() + */ +static void utc_tizen_icu_api_uloc_getISO3Country_func_01(void) +{ + const char *result = NULL; + const char *locale_id = "fr_FR"; + + result = uloc_getISO3Country(locale_id); + + if (NULL != result) { + tet_infoline + ("utc_tizen_icu_api_uloc_getISO3Country test PASS!"); + tet_printf("ISO3 Country for %s locale is %s\n", locale_id, + result); + tet_result(TET_PASS); + } else { + tet_infoline + ("utc_tizen_icu_api_uloc_getISO3Country test FAIL!"); + tet_result(TET_FAIL); + } + return; +} + +/** + * @brief Negative test case of utc_tizen_icu_api_uloc_getISO3Country() + * if locale id is null if will return the Country code of default locale. + */ +static void utc_tizen_icu_api_uloc_getISO3Country_func_02(void) +{ + const char *result = NULL; + + result = uloc_getISO3Country(NULL); + + if (NULL != result) { + tet_infoline + ("utc_tizen_icu_api_uloc_getISO3Country test PASS!"); + tet_printf("ISO3 Country for %s\n", result); + tet_result(TET_PASS); + } else { + tet_infoline + ("utc_tizen_icu_api_uloc_getISO3Country test FAIL!"); + tet_result(TET_FAIL); + } + return; + +} diff --git a/TC/unit/utc_tizen_icu_api_uloc_getISO3Language_func.c b/TC/unit/utc_tizen_icu_api_uloc_getISO3Language_func.c new file mode 100755 index 0000000..519ab8b --- /dev/null +++ b/TC/unit/utc_tizen_icu_api_uloc_getISO3Language_func.c @@ -0,0 +1,113 @@ +/* + * tizen-icu-api + * + * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jayoun Lee + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static void startup(void); +static void cleanup(void); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_tizen_icu_api_uloc_getISO3Language_func_01(void); +static void utc_tizen_icu_api_uloc_getISO3Language_func_02(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + {utc_tizen_icu_api_uloc_getISO3Language_func_01, POSITIVE_TC_IDX}, + {utc_tizen_icu_api_uloc_getISO3Language_func_02, NEGATIVE_TC_IDX}, + {NULL, 0} +}; + +static void startup(void) +{ + tet_infoline + ("Testing API utc_tizen_icu_api_uloc_getISO3Language start"); + return; +} + +static void cleanup(void) +{ + tet_infoline + ("Testing API utc_tizen_icu_api_uloc_getISO3Language ends "); + return; +} + +/** + * @brief Positive test case of utc_tizen_icu_api_uloc_getISO3Language() + */ +static void utc_tizen_icu_api_uloc_getISO3Language_func_01(void) +{ + const char *result = NULL; + const char *locale_id = "fr_FR"; + + result = uloc_getISO3Language(locale_id); + + if (NULL != result) { + tet_infoline + ("utc_tizen_icu_api_uloc_getISO3Language test PASS!"); + tet_printf("ISO3 language for %s locale is %s\n", locale_id, + result); + tet_result(TET_PASS); + } else { + tet_infoline + ("utc_tizen_icu_api_uloc_getISO3Language test FAIL!"); + tet_result(TET_FAIL); + } + return; +} + +/** + * @brief Negative test case of utc_tizen_icu_api_uloc_getISO3Language() + * if locale id is null if will return the langauge code of default locale. + */ +static void utc_tizen_icu_api_uloc_getISO3Language_func_02(void) +{ + const char *result = NULL; + + result = uloc_getISO3Language(NULL); + + if (NULL != result) { + tet_infoline + ("utc_tizen_icu_api_uloc_getISO3Language test PASS!"); + tet_printf("ISO3 language for %s\n", result); + tet_result(TET_PASS); + } else { + tet_infoline + ("utc_tizen_icu_api_uloc_getISO3Language test FAIL!"); + tet_result(TET_FAIL); + } + return; + +} diff --git a/TC/unit/utc_tizen_icu_api_uloc_getISOCountries_func.c b/TC/unit/utc_tizen_icu_api_uloc_getISOCountries_func.c new file mode 100755 index 0000000..81abcd1 --- /dev/null +++ b/TC/unit/utc_tizen_icu_api_uloc_getISOCountries_func.c @@ -0,0 +1,85 @@ +/* + * tizen-icu-api + * + * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jayoun Lee + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static void startup(void); +static void cleanup(void); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_tizen_icu_api_uloc_getISOCountries_func_01(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + {utc_tizen_icu_api_uloc_getISOCountries_func_01, POSITIVE_TC_IDX}, + {NULL, 0} +}; + +static void startup(void) +{ + tet_infoline + ("Testing API utc_tizen_icu_api_uloc_getISOCountries start"); + return; +} + +static void cleanup(void) +{ + tet_infoline + ("Testing API utc_tizen_icu_api_uloc_getISOCountries ends "); + return; +} + +/** + * @brief Positive test case of utc_tizen_icu_api_uloc_getISOCountries() + */ +static void utc_tizen_icu_api_uloc_getISOCountries_func_01(void) +{ + const char *const *result = NULL; + + result = uloc_getISOCountries(); + + if (NULL != result) { + tet_infoline + ("utc_tizen_icu_api_uloc_getISOCountries test PASS!"); + tet_printf("ISO3 language for %s \n", result); + tet_result(TET_PASS); + } else { + tet_infoline + ("utc_tizen_icu_api_uloc_getISOCountries test FAIL!"); + tet_result(TET_FAIL); + } + return; +} diff --git a/TC/unit/utc_tizen_icu_api_uloc_getISOLanguages_func.c b/TC/unit/utc_tizen_icu_api_uloc_getISOLanguages_func.c new file mode 100755 index 0000000..4ef9a2d --- /dev/null +++ b/TC/unit/utc_tizen_icu_api_uloc_getISOLanguages_func.c @@ -0,0 +1,85 @@ +/* + * tizen-icu-api + * + * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jayoun Lee + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static void startup(void); +static void cleanup(void); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_tizen_icu_api_uloc_getISOLanguages_func_01(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + {utc_tizen_icu_api_uloc_getISOLanguages_func_01, POSITIVE_TC_IDX}, + {NULL, 0} +}; + +static void startup(void) +{ + tet_infoline + ("Testing API utc_tizen_icu_api_uloc_getISOLanguages start"); + return; +} + +static void cleanup(void) +{ + tet_infoline + ("Testing API utc_tizen_icu_api_uloc_getISOLanguages ends "); + return; +} + +/** + * @brief Positive test case of utc_tizen_icu_api_uloc_getISOLanguages() + */ +static void utc_tizen_icu_api_uloc_getISOLanguages_func_01(void) +{ + const char *const *result = NULL; + + result = uloc_getISOLanguages(); + + if (NULL != result) { + tet_infoline + ("utc_tizen_icu_api_uloc_getISOLanguages test PASS!"); + tet_printf("ISO3 language for %s \n", result); + tet_result(TET_PASS); + } else { + tet_infoline + ("utc_tizen_icu_api_uloc_getISOLanguages test FAIL!"); + tet_result(TET_FAIL); + } + return; +} diff --git a/TC/unit/utc_tizen_icu_api_uloc_getLanguage_func.c b/TC/unit/utc_tizen_icu_api_uloc_getLanguage_func.c new file mode 100755 index 0000000..4092379 --- /dev/null +++ b/TC/unit/utc_tizen_icu_api_uloc_getLanguage_func.c @@ -0,0 +1,141 @@ +/* + * tizen-icu-api + * + * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jayoun Lee + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static void startup(void); +static void cleanup(void); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_tizen_icu_api_uloc_getLangugae_func_01(void); +static void utc_tizen_icu_api_uloc_getLangugae_func_02(void); +static void utc_tizen_icu_api_uloc_getLangugae_func_03(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + {utc_tizen_icu_api_uloc_getLangugae_func_01, POSITIVE_TC_IDX}, + {utc_tizen_icu_api_uloc_getLangugae_func_02, NEGATIVE_TC_IDX}, + {utc_tizen_icu_api_uloc_getLangugae_func_03, NEGATIVE_TC_IDX}, + {NULL, 0} +}; + +static void startup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_uloc_getLangugae start"); + return; +} + +static void cleanup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_uloc_getLangugae ends "); + return; +} + +/** + * @brief Positive test case of utc_tizen_icu_api_uloc_getLangugae() + */ +static void utc_tizen_icu_api_uloc_getLangugae_func_01(void) +{ + const char *locale_id = uloc_getDefault(); + char language[20] = { 0, }; + int32_t language_capacity = 20; + UErrorCode err = U_ZERO_ERROR; + int32_t result; + + result = uloc_getLanguage(locale_id, language, language_capacity, &err); + + /*result = 0 failed to getLanguage result > languageCapacity mean + language truncated */ + if ((result != 0) && (U_SUCCESS(err))) { + + tet_infoline("utc_tizen_icu_api_uloc_getLangugae test PASS!"); + tet_printf("Langauage for the %s locale %s", locale_id, + language); + tet_result(TET_PASS); + } else { + tet_infoline("utc_tizen_icu_api_uloc_getLangugae test FAIL!"); + tet_printf("Error is %d\n", err); + tet_result(TET_FAIL); + } + return; +} + +/** + * @brief Negative test case of utc_tizen_icu_api_uloc_getLangugae() + * if errcode is assigned to null function should return 0 + */ +static void utc_tizen_icu_api_uloc_getLangugae_func_02(void) +{ + const char *locale_id = uloc_getDefault(); + char language[20] = { + 0, + }; + int32_t language_capacity = 20; + int32_t result; + result = uloc_getLanguage(locale_id, language, language_capacity, NULL); + /* function should return zero if errorcode is null */ + if (0 == result) { + tet_infoline("utc_tizen_icu_api_uloc_getLangugae test PASS!"); + tet_result(TET_PASS); + } else { + tet_infoline("utc_tizen_icu_api_uloc_getLangugae test FAIL!"); + tet_result(TET_FAIL); + } + return; +} + +/** + * @brief Negative test case of utc_tizen_icu_api_uloc_getLangugae() + * if errcode is postive value it will return 0 + */ +static void utc_tizen_icu_api_uloc_getLangugae_func_03(void) +{ + const char *locale_id = uloc_getDefault(); + UErrorCode err = 5; + char language[20] = {0,}; + int32_t result; + result = uloc_getLanguage(locale_id, language, 20, &err); + /* function should return zero if the errorcode is not equal to zero */ + if (0 == result) { + tet_infoline("utc_tizen_icu_api_uloc_getLangugae test PASS!"); + tet_result(TET_PASS); + } else { + tet_infoline("utc_tizen_icu_api_uloc_getLangugae test FAIL!"); + tet_printf("Error is %d\n", err); + tet_result(TET_FAIL); + } + return; +} diff --git a/TC/unit/utc_tizen_icu_api_uloc_getVariant_func.c b/TC/unit/utc_tizen_icu_api_uloc_getVariant_func.c new file mode 100755 index 0000000..b986c0b --- /dev/null +++ b/TC/unit/utc_tizen_icu_api_uloc_getVariant_func.c @@ -0,0 +1,113 @@ +/* + * tizen-icu-api + * + * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jayoun Lee + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static void startup(void); +static void cleanup(void); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_tizen_icu_api_uloc_getVariant_func_01(void); +static void utc_tizen_icu_api_uloc_getVariant_func_02(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + {utc_tizen_icu_api_uloc_getVariant_func_01, POSITIVE_TC_IDX}, + {utc_tizen_icu_api_uloc_getVariant_func_02, NEGATIVE_TC_IDX}, + {NULL, 0} +}; + +static void startup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_uloc_getVariant start"); + return; +} + +static void cleanup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_uloc_getVariant ends "); + return; +} + +/** + * @brief Positive test case of utc_tizen_icu_api_uloc_getVariant() + */ +static void utc_tizen_icu_api_uloc_getVariant_func_01(void) +{ + const char *locale_id = uloc_getDefault(); + char variant[20] = {0,}; + int32_t variant_capacity = 20; + UErrorCode err = U_ZERO_ERROR; + int32_t result; + + result = uloc_getVariant(locale_id, variant, variant_capacity, &err); + + if (U_SUCCESS(err)) { + tet_infoline("utc_tizen_icu_api_uloc_getVariant test PASS!"); + tet_printf("variant for this %s locale %s\n", locale_id, + variant); + tet_result(TET_PASS); + } else { + tet_infoline("utc_tizen_icu_api_uloc_getVariant test FAIL!"); + tet_printf("Error is %d\n", err); + tet_result(TET_FAIL); + } + return; +} + + +/** + * @brief Negative test case of utc_tizen_icu_api_uloc_getVariant() + * if err code is null will return error + */ +static void utc_tizen_icu_api_uloc_getVariant_func_02(void) +{ + const char *locale_id = uloc_getDefault(); + char variant[20] = { 0, }; + int32_t variant_capacity = 20; + int32_t result; + + result = uloc_getVariant(locale_id, variant, variant_capacity, NULL); + + if (0 == result) { + tet_infoline("utc_tizen_icu_api_uloc_getVariant test PASS!"); + tet_result(TET_PASS); + } else { + tet_infoline("utc_tizen_icu_api_uloc_getVariant test FAIL!"); + tet_result(TET_FAIL); + } + return; +} diff --git a/TC/unit/utc_tizen_icu_api_uloc_setDefault_func.c b/TC/unit/utc_tizen_icu_api_uloc_setDefault_func.c new file mode 100755 index 0000000..44b2052 --- /dev/null +++ b/TC/unit/utc_tizen_icu_api_uloc_setDefault_func.c @@ -0,0 +1,134 @@ +/* + * tizen-icu-api + * + * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jayoun Lee + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static void startup(void); +static void cleanup(void); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_tizen_icu_api_uloc_setDefault_func_01(void); +static void utc_tizen_icu_api_uloc_setDefault_func_02(void); +static void utc_tizen_icu_api_uloc_setDefault_func_03(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + {utc_tizen_icu_api_uloc_setDefault_func_01, POSITIVE_TC_IDX}, + {utc_tizen_icu_api_uloc_setDefault_func_02, NEGATIVE_TC_IDX}, + {utc_tizen_icu_api_uloc_setDefault_func_03, NEGATIVE_TC_IDX}, + {NULL, 0} +}; + +static void startup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_uloc_setDefault start"); + return; +} + +static void cleanup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_uloc_setDefault ends "); + return; +} + +/** + * @brief Positive test case of utc_tizen_icu_api_uloc_setDefault() + */ +static void utc_tizen_icu_api_uloc_setDefault_func_01(void) +{ + UErrorCode status = U_ZERO_ERROR; + const char *locale = uloc_getDefault(); + + uloc_setDefault(locale, &status); + + if (U_SUCCESS(status)) { + tet_infoline("utc_tizen_icu_api_uloc_setDefault test PASS!"); + tet_result(TET_PASS); + } else { + tet_infoline("utc_tizen_icu_api_uloc_setDefault test FAIL!"); + tet_printf("Error is %d", status); + tet_result(TET_FAIL); + } + return; +} + +/** + * @brief Negative test case of utc_tizen_icu_api_uloc_setDefault() + * to check if null send as a locale id it should set default locale id + */ +static void utc_tizen_icu_api_uloc_setDefault_func_02(void) +{ + UErrorCode status = U_ZERO_ERROR; + const char *def_locale_before = uloc_getDefault(); + const char *def_locale_after; + + uloc_setDefault(NULL, &status); + // If null send to the locale id it will set the default locale + def_locale_after = uloc_getDefault(); + + //checking old and new locale id is same + if (!strcmp(def_locale_before, def_locale_after)) { + tet_infoline("utc_tizen_icu_api_uloc_setDefault test PASS!"); + tet_result(TET_PASS); + } else { + tet_infoline("utc_tizen_icu_api_uloc_setDefault test FAIL!"); + tet_printf("Error is %d", status); + tet_result(TET_FAIL); + } + return; +} + +/** + * @brief Negative test case of utc_tizen_icu_api_uloc_setDefault() + * to check if error code is greater than zero it should return the error code + */ +static void utc_tizen_icu_api_uloc_setDefault_func_03(void) +{ + UErrorCode status = U_ILLEGAL_ARGUMENT_ERROR; + + uloc_setDefault(uloc_getDefault(), &status); + + // the status value is more than 0 it will simply return + if (U_ILLEGAL_ARGUMENT_ERROR == status) { + tet_infoline("utc_tizen_icu_api_uloc_setDefault test PASS!"); + tet_result(TET_PASS); + } else { + tet_infoline("utc_tizen_icu_api_uloc_setDefault test FAIL!"); + tet_printf("Error is %d", status); + tet_result(TET_FAIL); + } + return; +} diff --git a/TC/unit/utc_tizen_icu_api_unum_close_func.c b/TC/unit/utc_tizen_icu_api_unum_close_func.c new file mode 100755 index 0000000..07282e7 --- /dev/null +++ b/TC/unit/utc_tizen_icu_api_unum_close_func.c @@ -0,0 +1,89 @@ +/* + * tizen-icu-api + * + * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Hakjoo Ko + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static void startup(void); +static void cleanup(void); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_tizen_icu_api_unum_close_func_01(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + {utc_tizen_icu_api_unum_close_func_01, POSITIVE_TC_IDX}, + {NULL, 0} +}; + +static void startup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_unum_close start"); + return; +} + +static void cleanup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_unum_close ends "); + return; +} + +/** + * @brief Positive test case of utc_tizen_icu_api_unum_close() + */ +static void utc_tizen_icu_api_unum_close_func_01(void) +{ + UErrorCode status = U_ZERO_ERROR; + UNumberFormat *num_fmt = NULL; + + num_fmt = unum_open(UNUM_DEFAULT, NULL, -1, NULL, NULL, &status); + + if (U_SUCCESS(status) && (NULL != num_fmt)) { + unum_close(num_fmt); + tet_infoline("utc_tizen_icu_api_unum_close test PASS!"); + tet_result(TET_PASS); + } else { + tet_infoline("utc_tizen_icu_api_unum_open test FAIL!"); + tet_printf("Error code %s", u_errorName(status)); + tet_result(TET_FAIL); + unum_close(num_fmt); + } + return; +} + +/** + * @brief No Negative test case + */ + diff --git a/TC/unit/utc_tizen_icu_api_unum_formatDecimal_func.c b/TC/unit/utc_tizen_icu_api_unum_formatDecimal_func.c new file mode 100755 index 0000000..75cafc3 --- /dev/null +++ b/TC/unit/utc_tizen_icu_api_unum_formatDecimal_func.c @@ -0,0 +1,146 @@ +/* + * tizen-icu-api + * + * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Hakjoo Ko + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static void startup(void); +static void cleanup(void); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_tizen_icu_api_unum_formatDecimal_func_01(void); +static void utc_tizen_icu_api_unum_formatDecimal_func_02(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + {utc_tizen_icu_api_unum_formatDecimal_func_01, POSITIVE_TC_IDX}, + {utc_tizen_icu_api_unum_formatDecimal_func_02, NEGATIVE_TC_IDX}, + {NULL, 0} +}; + +static void startup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_unum_formatDecimal start"); + return; +} + +static void cleanup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_unum_formatDecimal ends "); + return; +} + +/** + * @brief Positive test case of utc_tizen_icu_api_unum_formatDecimal() + */ +static void utc_tizen_icu_api_unum_formatDecimal_func_01(void) +{ + uint32_t index = 0; + UErrorCode status = U_ZERO_ERROR; + const char *number[] = { "768.3412", "8970.21", "23114" }; + UNumberFormat *num_fmt = NULL; + UChar result[20] = { 0, }; + uint32_t ret; + + num_fmt = unum_open(UNUM_DEFAULT, NULL, -1, NULL, NULL, &status); + if (U_SUCCESS(status) && (NULL != num_fmt)) { + + for (index = 0; index < 3; index++) { + ret = + unum_formatDecimal(num_fmt, number[index], -1, + result, 20, NULL, &status); + if (U_SUCCESS(status)) { + tet_infoline + ("utc_tizen_icu_api_unum_formatDecimal test PASS!"); + tet_printf + ("Input number %s formatted result %s\n", + number[index], result); + memset(result, '\0', 20); + tet_result(TET_PASS); + } else { + tet_infoline + ("utc_tizen_icu_api_unum_formatDecimal test FAIL!"); + tet_printf("Error code %s\n", + u_errorName(status)); + tet_result(TET_FAIL); + } + } + } else { + tet_infoline("utc_tizen_icu_api_unum_open test FAIL!"); + tet_printf("Error code %s\n", u_errorName(status)); + tet_result(TET_FAIL); + } + unum_close(num_fmt); + return; +} + +/** + * @brief Negative test case of utc_tizen_icu_api_unum_formatDecimal() + * passing result NULL will give BUFFER_OVERFLOW error + */ +static void utc_tizen_icu_api_unum_formatDecimal_func_02(void) +{ + UErrorCode status = U_ZERO_ERROR; + const char *number = "7611.21"; + UNumberFormat *num_fmt = NULL; + UChar result[20] = { 0, }; + uint32_t ret; + + num_fmt = unum_open(UNUM_DEFAULT, NULL, -1, NULL, NULL, &status); + if (U_SUCCESS(status) && (NULL != num_fmt)) { + ret = + unum_formatDecimal(num_fmt, NULL, 0, NULL, 20, NULL, + &status); + if (U_FAILURE(status)) { + tet_infoline + ("utc_tizen_icu_api_unum_formatDecimal test PASS!"); + tet_printf("Input number %s formatted result %s\n", + number, result); + tet_result(TET_PASS); + } else { + tet_infoline + ("utc_tizen_icu_api_unum_formatDecimal test FAIL!"); + tet_printf("Error code %s\n", u_errorName(status)); + tet_result(TET_FAIL); + } + } else { + tet_infoline("utc_tizen_icu_api_unum_open test FAIL!"); + tet_printf("Error code %s\n", u_errorName(status)); + tet_result(TET_FAIL); + } + unum_close(num_fmt); + return; + +} diff --git a/TC/unit/utc_tizen_icu_api_unum_formatDouble_func.c b/TC/unit/utc_tizen_icu_api_unum_formatDouble_func.c new file mode 100755 index 0000000..215ce6e --- /dev/null +++ b/TC/unit/utc_tizen_icu_api_unum_formatDouble_func.c @@ -0,0 +1,142 @@ +/* + * tizen-icu-api + * + * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jayoun Lee + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static void startup(void); +static void cleanup(void); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_tizen_icu_api_unum_formatDouble_func_01(void); +static void utc_tizen_icu_api_unum_formatDouble_func_02(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + {utc_tizen_icu_api_unum_formatDouble_func_01, POSITIVE_TC_IDX}, + {utc_tizen_icu_api_unum_formatDouble_func_02, NEGATIVE_TC_IDX}, + {NULL, 0} +}; + +static void startup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_unum_formatDouble start"); + return; +} + +static void cleanup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_unum_formatDouble ends "); + return; +} + +/** + * @brief Positive test case of utc_tizen_icu_api_unum_formatDouble() + */ +static void utc_tizen_icu_api_unum_formatDouble_func_01(void) +{ + uint32_t index = 0; + UErrorCode status = U_ZERO_ERROR; + double number[] = { 5.0, 6.2, -1.7 }; + UNumberFormat *num_fmt = NULL; + UChar result[20] = { 0, }; + uint32_t ret; + + num_fmt = unum_open(UNUM_DEFAULT, NULL, -1, NULL, NULL, &status); + if (U_SUCCESS(status) && (NULL != num_fmt)) { + + for (index = 0; index < 3; index++) { + ret = + unum_formatDouble(num_fmt, number[index], result, + 20, NULL, &status); + if (U_SUCCESS(status)) { + tet_infoline + ("utc_tizen_icu_api_unum_formatDouble test PASS!"); + tet_printf + ("Input number %f formatted result %s\n", + number[index], result); + memset(result, '\0', 20); + tet_result(TET_PASS); + } else { + tet_infoline + ("utc_tizen_icu_api_unum_formatDouble test FAIL!"); + tet_printf("Error code %s\n", + u_errorName(status)); + tet_result(TET_FAIL); + } + } + } else { + tet_infoline("utc_tizen_icu_api_unum_open test FAIL!"); + tet_printf("Error code %s\n", u_errorName(status)); + tet_result(TET_FAIL); + } + unum_close(num_fmt); + return; +} + +/** + * @brief Negative test case of utc_tizen_icu_api_unum_formatDouble() + * passing result NULL will give BUFFER_OVERFLOW error + */ +static void utc_tizen_icu_api_unum_formatDouble_func_02(void) +{ + UErrorCode status = U_ZERO_ERROR; + double number = 9.0; + UNumberFormat *num_fmt = NULL; + uint32_t ret; + + num_fmt = unum_open(UNUM_DEFAULT, NULL, -1, NULL, NULL, &status); + if (U_SUCCESS(status) && (NULL != num_fmt)) { + ret = + unum_formatDouble(num_fmt, number, NULL, 20, NULL, &status); + if (U_FAILURE(status)) { + tet_infoline + ("utc_tizen_icu_api_unum_formatDouble test PASS!"); + tet_result(TET_PASS); + } else { + tet_infoline + ("utc_tizen_icu_api_unum_formatDouble test FAIL!"); + tet_printf("Error code %s\n", u_errorName(status)); + tet_result(TET_FAIL); + } + } else { + tet_infoline("utc_tizen_icu_api_unum_open test FAIL!"); + tet_printf("Error code %s\n", u_errorName(status)); + tet_result(TET_FAIL); + } + unum_close(num_fmt); + return; + +} diff --git a/TC/unit/utc_tizen_icu_api_unum_formatInt64_func.c b/TC/unit/utc_tizen_icu_api_unum_formatInt64_func.c new file mode 100755 index 0000000..18450f2 --- /dev/null +++ b/TC/unit/utc_tizen_icu_api_unum_formatInt64_func.c @@ -0,0 +1,137 @@ +/* + * tizen-icu-api + * + * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Hakjoo Ko + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static void startup(void); +static void cleanup(void); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_tizen_icu_api_unum_formatInt64_func_01(void); +static void utc_tizen_icu_api_unum_formatInt64_func_02(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + {utc_tizen_icu_api_unum_formatInt64_func_01, POSITIVE_TC_IDX}, + {utc_tizen_icu_api_unum_formatInt64_func_02, NEGATIVE_TC_IDX}, + {NULL, 0} +}; + +static void startup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_unum_formatInt64 start"); + return; +} + +static void cleanup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_unum_formatInt64 ends "); + return; +} + +/** + * @brief Positive test case of utc_tizen_icu_api_unum_formatInt64() + */ +static void utc_tizen_icu_api_unum_formatInt64_func_01(void) +{ + uint32_t index = 0; + UErrorCode status = U_ZERO_ERROR; + int64_t number[] = { 574857, 454, -435454 }; + UNumberFormat *num_fmt = NULL; + UChar result[20] = { 0, }; + uint32_t ret; + + num_fmt = unum_open(UNUM_DEFAULT, NULL, -1, NULL, NULL, &status); + if (U_SUCCESS(status) && (NULL != num_fmt)) { + + for (index = 0; index < 3; index++) { + ret = + unum_formatInt64(num_fmt, number[index], result, 20, + NULL, &status); + if (U_SUCCESS(status)) { + tet_infoline + ("utc_tizen_icu_api_unum_formatInt64 test PASS!"); + tet_result(TET_PASS); + } else { + tet_infoline + ("utc_tizen_icu_api_unum_formatInt64 test FAIL!"); + tet_printf("Error code %s\n", + u_errorName(status)); + tet_result(TET_FAIL); + } + } + } else { + tet_infoline("utc_tizen_icu_api_unum_open test FAIL!"); + tet_printf("Error code %s\n", u_errorName(status)); + tet_result(TET_FAIL); + } + unum_close(num_fmt); + return; +} + +/** + * @brief Negative test case of utc_tizen_icu_api_unum_formatInt64() + * passing result NULL will give BUFFER_OVERFLOW error + */ +static void utc_tizen_icu_api_unum_formatInt64_func_02(void) +{ + UErrorCode status = U_ZERO_ERROR; + int64_t number = 123142; + UNumberFormat *num_fmt = NULL; + uint32_t ret; + + num_fmt = unum_open(UNUM_DEFAULT, NULL, -1, NULL, NULL, &status); + if (U_SUCCESS(status) && (NULL != num_fmt)) { + ret = + unum_formatInt64(num_fmt, number, NULL, 20, NULL, &status); + if (U_FAILURE(status)) { + tet_infoline + ("utc_tizen_icu_api_unum_formatInt64 test PASS!"); + tet_result(TET_PASS); + } else { + tet_infoline + ("utc_tizen_icu_api_unum_formatInt64 test FAIL!"); + tet_printf("Error code %s\n", u_errorName(status)); + tet_result(TET_FAIL); + } + } else { + tet_infoline("utc_tizen_icu_api_unum_open test FAIL!"); + tet_printf("Error code %s\n", u_errorName(status)); + tet_result(TET_FAIL); + } + unum_close(num_fmt); + return; +} diff --git a/TC/unit/utc_tizen_icu_api_unum_format_func.c b/TC/unit/utc_tizen_icu_api_unum_format_func.c new file mode 100755 index 0000000..db2fc28 --- /dev/null +++ b/TC/unit/utc_tizen_icu_api_unum_format_func.c @@ -0,0 +1,141 @@ +/* + * tizen-icu-api + * + * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jayoun Lee + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static void startup(void); +static void cleanup(void); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_tizen_icu_api_unum_format_func_01(void); +static void utc_tizen_icu_api_unum_format_func_02(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + {utc_tizen_icu_api_unum_format_func_01, POSITIVE_TC_IDX}, + {utc_tizen_icu_api_unum_format_func_02, NEGATIVE_TC_IDX}, + {NULL, 0} +}; + +static void startup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_unum_format start"); + return; +} + +static void cleanup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_unum_format ends "); + return; +} + +/** + * @brief Positive test case of utc_tizen_icu_api_unum_format() + */ +static void utc_tizen_icu_api_unum_format_func_01(void) +{ + uint32_t index = 0; + UErrorCode status = U_ZERO_ERROR; + uint32_t number[] = { 123, 3333, -1234567 }; + UNumberFormat *num_fmt; + UChar result[20] = { 0, }; + uint32_t ret; + + num_fmt = unum_open(UNUM_DEFAULT, NULL, -1, NULL, NULL, &status); + if (U_SUCCESS(status) && (NULL != num_fmt)) { + + for (index = 0; index < 3; index++) { + ret = + unum_format(num_fmt, number[index], result, 20, + NULL, &status); + if (U_SUCCESS(status)) { + tet_infoline + ("utc_tizen_icu_api_unum_format test PASS!"); + tet_printf + ("Input number %d formatted result %s\n", + number[index], result); + memset(result, '\0', 20); + tet_result(TET_PASS); + } else { + tet_infoline + ("utc_tizen_icu_api_unum_format test FAIL!"); + tet_printf("Error code %s\n", + u_errorName(status)); + tet_result(TET_FAIL); + } + } + } else { + tet_infoline("utc_tizen_icu_api_unum_open test FAIL!"); + tet_printf("Error code %s\n", u_errorName(status)); + tet_result(TET_FAIL); + } + unum_close(num_fmt); + return; +} + +/** + * @brief Negative test case of utc_tizen_icu_api_unum_format() + * passing result NULL will give BUFFER_OVERFLOW error + */ +static void utc_tizen_icu_api_unum_format_func_02(void) +{ + UErrorCode status = U_ZERO_ERROR; + uint32_t number = 123; + UNumberFormat *num_fmt; + uint32_t ret; + + num_fmt = unum_open(UNUM_DEFAULT, NULL, -1, NULL, NULL, &status); + if (U_SUCCESS(status) && (NULL != num_fmt)) { + ret = unum_format(num_fmt, number, NULL, 20, NULL, &status); + if (U_FAILURE(status)) { + tet_infoline + ("utc_tizen_icu_api_unum_format test PASS!"); + tet_result(TET_PASS); + } else { + tet_infoline + ("utc_tizen_icu_api_unum_format test FAIL!"); + tet_printf("Error code %s\n", u_errorName(status)); + tet_result(TET_FAIL); + } + } else { + tet_infoline("utc_tizen_icu_api_unum_open test FAIL!"); + tet_printf("Error code %s\n", u_errorName(status)); + tet_result(TET_FAIL); + } + unum_close(num_fmt); + return; + +} diff --git a/TC/unit/utc_tizen_icu_api_unum_open_func.c b/TC/unit/utc_tizen_icu_api_unum_open_func.c new file mode 100755 index 0000000..39ffd3f --- /dev/null +++ b/TC/unit/utc_tizen_icu_api_unum_open_func.c @@ -0,0 +1,131 @@ +/* + * tizen-icu-api + * + * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Hakjoo Ko + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static void startup(void); +static void cleanup(void); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_tizen_icu_api_unum_open_func_01(void); +static void utc_tizen_icu_api_unum_open_func_02(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + {utc_tizen_icu_api_unum_open_func_01, POSITIVE_TC_IDX}, + {utc_tizen_icu_api_unum_open_func_02, NEGATIVE_TC_IDX}, + {NULL, 0} +}; + +static void startup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_unum_open start"); + return; +} + +static void cleanup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_unum_open ends "); + return; +} + +/** + * @brief Positive test case of utc_tizen_icu_api_unum_open() + */ +static void utc_tizen_icu_api_unum_open_func_01(void) +{ + + int32_t style[] = + { UNUM_DECIMAL, UNUM_CURRENCY, UNUM_PERCENT, UNUM_SCIENTIFIC, + UNUM_SPELLOUT, UNUM_PATTERN_DECIMAL, + UNUM_PATTERN_RULEBASED, UNUM_DEFAULT + }; + UErrorCode status = U_ZERO_ERROR; + UNumberFormat *num_fmt = NULL; + int i; + + for (i = 0; i < 8; i++) { /*If UNUM_PATTERN_DECIMAL or UNUM_PATTERN_RULEBASED is passed then + the number format is opened using the given pattern */ + status = U_ZERO_ERROR; + if ((style[i] == UNUM_PATTERN_DECIMAL) + || (style[i] == UNUM_PATTERN_RULEBASED)) { + + num_fmt = + unum_open(style[i], (const UChar *)"#,##,###", -1, + NULL, NULL, &status); + } else { + num_fmt = + unum_open(style[i], NULL, -1, NULL, NULL, &status); + } + if (U_SUCCESS(status) && (NULL != num_fmt)) { + tet_infoline("utc_tizen_icu_api_unum_open test PASS!"); + tet_result(TET_PASS); + } else { + tet_infoline("utc_tizen_icu_api_unum_open test FAIL!"); + tet_printf("Error code %s", u_errorName(status)); + tet_result(TET_FAIL); + } + unum_close(num_fmt); + } + + return; +} + +/** + * @brief Negative test case of utc_tizen_icu_api_unum_open() + * sent null for pattern in UNUM_PATTERN_DECIMAL & UNUM_PATTERN_RULEBASED + */ +static void utc_tizen_icu_api_unum_open_func_02(void) +{ + UErrorCode status = U_ZERO_ERROR; + UNumberFormat *num_fmt = NULL; + + num_fmt = + unum_open(-1, NULL, -1, NULL, NULL, &status); + + if (U_FAILURE(status) && (NULL == num_fmt)) { + tet_infoline("utc_tizen_icu_api_unum_open test PASS!"); + tet_result(TET_PASS); + } else { + tet_infoline("utc_tizen_icu_api_unum_open test FAIL!"); + tet_printf("Error code %s\n", u_errorName(status)); + tet_result(TET_FAIL); + } + unum_close(num_fmt); + + return; + +} diff --git a/TC/unit/utc_tizen_icu_api_unum_parseDecimal_func.c b/TC/unit/utc_tizen_icu_api_unum_parseDecimal_func.c new file mode 100755 index 0000000..9590fb1 --- /dev/null +++ b/TC/unit/utc_tizen_icu_api_unum_parseDecimal_func.c @@ -0,0 +1,138 @@ +/* + * tizen-icu-api + * + * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Hakjoo Ko + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static void startup(void); +static void cleanup(void); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_tizen_icu_api_unum_parseDecimal_func_01(void); +static void utc_tizen_icu_api_unum_parseDecimal_func_02(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + {utc_tizen_icu_api_unum_parseDecimal_func_01, POSITIVE_TC_IDX}, + {utc_tizen_icu_api_unum_parseDecimal_func_02, NEGATIVE_TC_IDX}, + {NULL, 0} +}; + +static void startup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_unum_parseDecimal start"); + return; +} + +static void cleanup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_unum_parseDecimal ends "); + return; +} + +/** + * @brief Positive test case of utc_tizen_icu_api_unum_parseDecimal() + */ +static void utc_tizen_icu_api_unum_parseDecimal_func_01(void) +{ + UErrorCode status = U_ZERO_ERROR; + int32_t num = 0; + UNumberFormat num_fmt = NULL; + const char *cs = "123,456,789,0"; + const char *comp = "123"; + const int text_len = 13; + UChar text[13]; + char parse[64]; + + u_charsToUChars(cs, text, text_len); + num_fmt = unum_open(UNUM_DEFAULT, NULL, -1, NULL, NULL, &status); + if (U_SUCCESS(status) && (NULL != num_fmt)) { + num = unum_parseDecimal(num_fmt, text, -1, NULL, parse, 64, &status); + if (U_SUCCESS(status) && strcmp(comp,parse)==0) { + tet_infoline + ("utc_tizen_icu_api_unum_parseDecimal test PASS!"); + tet_printf("The parsed number %ld\n", num); + tet_result(TET_PASS); + } else { + tet_infoline + ("utc_tizen_icu_api_unum_parseDecimal test FAIL!"); + tet_result(TET_FAIL); + } + } else { + tet_infoline("utc_tizen_icu_api_unum_open test FAIL!"); + tet_printf("Error code %s", u_errorName(status)); + tet_result(TET_FAIL); + } + unum_close(num_fmt); + return; +} + +/** + * @brief Negative test case of utc_tizen_icu_api_unum_parseDecimal() + * Passing input text as null will return buffer overflow error + */ +static void utc_tizen_icu_api_unum_parseDecimal_func_02(void) +{ + UErrorCode status = U_ZERO_ERROR; + int32_t num = 0; + UNumberFormat num_fmt = NULL; + const char *cs = "123,456,789,0"; + const char *comp = "1234567890"; + const int text_len = 13; + UChar text[13]; + char parse[64]; + + u_charsToUChars(cs, text, text_len); + num_fmt = unum_open(UNUM_DEFAULT, NULL, -1, NULL, NULL, &status); + + if (U_SUCCESS(status) && (NULL != num_fmt)) { + num = unum_parseDecimal(num_fmt, text, -1, NULL, parse, 64, &status); + if (U_FAILURE(status) || strcmp(comp,parse) != 0) { + tet_infoline + ("utc_tizen_icu_api_unum_parseDecimal test PASS!"); + tet_result(TET_PASS); + } else { + tet_infoline + ("utc_tizen_icu_api_unum_parseDecimal test FAIL!"); + tet_result(TET_FAIL); + } + } else { + tet_infoline("utc_tizen_icu_api_unum_open test FAIL!"); + tet_printf("Error code %s", u_errorName(status)); + tet_result(TET_FAIL); + } + unum_close(num_fmt); + return; +} diff --git a/TC/unit/utc_tizen_icu_api_unum_parseDouble_func.c b/TC/unit/utc_tizen_icu_api_unum_parseDouble_func.c new file mode 100755 index 0000000..9f3a2c1 --- /dev/null +++ b/TC/unit/utc_tizen_icu_api_unum_parseDouble_func.c @@ -0,0 +1,134 @@ +/* + * tizen-icu-api + * + * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Hakjoo Ko + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static void startup(void); +static void cleanup(void); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_tizen_icu_api_unum_parseDouble_func_01(void); +static void utc_tizen_icu_api_unum_parseDouble_func_02(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + {utc_tizen_icu_api_unum_parseDouble_func_01, POSITIVE_TC_IDX}, + {utc_tizen_icu_api_unum_parseDouble_func_02, NEGATIVE_TC_IDX}, + {NULL, 0} +}; + +static void startup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_unum_parseDouble start"); + return; +} + +static void cleanup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_unum_parseDouble ends "); + return; +} + +/** + * @brief Positive test case of utc_tizen_icu_api_unum_parseDouble() + */ +static void utc_tizen_icu_api_unum_parseDouble_func_01(void) +{ + UErrorCode status = U_ZERO_ERROR; + double num; + UNumberFormat num_fmt = NULL; + const char *cs = "1234.5678"; + const double comp = 1234.5678; + const int text_len = 9; + UChar text[9]; + + u_charsToUChars(cs, text, text_len); + num_fmt = unum_open(UNUM_DEFAULT, NULL, -1, NULL, NULL, &status); + if (U_SUCCESS(status) && (NULL != num_fmt)) { + num = unum_parseDouble(num_fmt, text, text_len, 0, &status); + if (U_SUCCESS(status) && num == comp) { + tet_infoline + ("utc_tizen_icu_api_unum_parseDouble test PASS!"); + tet_printf("The parsed number %ld\n", num); + tet_result(TET_PASS); + } else { + tet_infoline + ("utc_tizen_icu_api_unum_parseDouble test FAIL!"); + tet_result(TET_FAIL); + } + } else { + tet_infoline("utc_tizen_icu_api_unum_open test FAIL!"); + tet_printf("Error code %s", u_errorName(status)); + tet_result(TET_FAIL); + } + unum_close(num_fmt); + return; +} + +/** + * @brief Negative test case of utc_tizen_icu_api_unum_parseDouble() + * Passing input text as null will return buffer overflow error + */ +static void utc_tizen_icu_api_unum_parseDouble_func_02(void) +{ + UErrorCode status = U_ZERO_ERROR; + double num; + UNumberFormat num_fmt = NULL; + const char *cs = "1234.5678"; + const int text_len = 9; + UChar text[9]; + + u_charsToUChars(cs, text, text_len); + num_fmt = unum_open(UNUM_DEFAULT, NULL, -1, NULL, NULL, &status); + if (U_SUCCESS(status) && (NULL != num_fmt)) { + status = U_ILLEGAL_ARGUMENT_ERROR; + num = unum_parseDouble(num_fmt, text, text_len, 0, &status); + if (U_FAILURE(status)) { + tet_infoline("utc_tizen_icu_api_unum_parseDouble test PASS!"); + tet_result(TET_PASS); + } else { + tet_infoline("utc_tizen_icu_api_unum_parseDouble test FAIL!"); + tet_printf("Error code %s\n", u_errorName(status)); + tet_result(TET_FAIL); + } + } else { + tet_infoline("utc_tizen_icu_api_unum_open test FAIL!"); + tet_printf("Error code %s", u_errorName(status)); + tet_result(TET_FAIL); + } + unum_close(num_fmt); + return; +} diff --git a/TC/unit/utc_tizen_icu_api_unum_parseInt64_func.c b/TC/unit/utc_tizen_icu_api_unum_parseInt64_func.c new file mode 100755 index 0000000..0f33db4 --- /dev/null +++ b/TC/unit/utc_tizen_icu_api_unum_parseInt64_func.c @@ -0,0 +1,135 @@ +/* + * tizen-icu-api + * + * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Hakjoo Ko + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static void startup(void); +static void cleanup(void); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_tizen_icu_api_unum_parseInt64_func_01(void); +static void utc_tizen_icu_api_unum_parseInt64_func_02(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + {utc_tizen_icu_api_unum_parseInt64_func_01, POSITIVE_TC_IDX}, + {utc_tizen_icu_api_unum_parseInt64_func_02, NEGATIVE_TC_IDX}, + {NULL, 0} +}; + +static void startup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_unum_parseInt64 start"); + return; +} + +static void cleanup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_unum_parseInt64 ends "); + return; +} + +/** + * @brief Positive test case of utc_tizen_icu_api_unum_parseInt64() + */ +static void utc_tizen_icu_api_unum_parseInt64_func_01(void) +{ + UErrorCode status = U_ZERO_ERROR; + int32_t num; + UNumberFormat num_fmt = NULL; + const char *cs = "980006754"; + const int text_len = 9; + UChar text[9]; + + u_charsToUChars(cs, text, text_len); + num_fmt = unum_open(UNUM_DEFAULT, NULL, -1, NULL, NULL, &status); + if (U_SUCCESS(status) && (NULL != num_fmt)) { + num = unum_parseInt64(num_fmt, text, text_len, 0, &status); + if (U_SUCCESS(status) && num == atoi(cs)) { + tet_infoline + ("utc_tizen_icu_api_unum_parseInt64 test PASS!"); + tet_printf("The parsed number %ld\n", num); + tet_result(TET_PASS); + } else { + tet_infoline + ("utc_tizen_icu_api_unum_parseInt64 test FAIL!"); + tet_result(TET_FAIL); + } + } else { + tet_infoline("utc_tizen_icu_api_unum_open test FAIL!"); + tet_printf("Error code %s", u_errorName(status)); + tet_result(TET_FAIL); + } + unum_close(num_fmt); + return; +} + +/** + * @brief Negative test case of utc_tizen_icu_api_unum_parseInt64() + * Passing input text as null will return buffer overflow error + */ +static void utc_tizen_icu_api_unum_parseInt64_func_02(void) +{ + UErrorCode status = U_ZERO_ERROR; + int32_t num; + UNumberFormat num_fmt = NULL; + const char *cs = "980006754"; + const int text_len = 9; + UChar text[9]; + + u_charsToUChars(cs, text, text_len); + num_fmt = unum_open(UNUM_DEFAULT, NULL, -1, NULL, NULL, &status); + if (U_SUCCESS(status) && (NULL != num_fmt)) { + num = unum_parseInt64(num_fmt, text, text_len-1, 0, &status); + if (U_FAILURE(status) || num != atoi(cs)) { + tet_infoline + ("utc_tizen_icu_api_unum_parseInt64 test PASS!"); + tet_printf("The parsed number %d\n", num); + tet_result(TET_PASS); + } else { + tet_infoline + ("utc_tizen_icu_api_unum_parseInt64 test FAIL!"); + tet_printf("Error code %s", u_errorName(status)); + tet_result(TET_FAIL); + } + } else { + tet_infoline("utc_tizen_icu_api_unum_open test FAIL!"); + tet_printf("Error code %s", u_errorName(status)); + tet_result(TET_FAIL); + } + unum_close(num_fmt); + return; +} diff --git a/TC/unit/utc_tizen_icu_api_unum_parse_func.c b/TC/unit/utc_tizen_icu_api_unum_parse_func.c new file mode 100755 index 0000000..543538b --- /dev/null +++ b/TC/unit/utc_tizen_icu_api_unum_parse_func.c @@ -0,0 +1,135 @@ +/* + * tizen-icu-api + * + * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Hakjoo Ko + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static void startup(void); +static void cleanup(void); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_tizen_icu_api_unum_parse_func_01(void); +static void utc_tizen_icu_api_unum_parse_func_02(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + {utc_tizen_icu_api_unum_parse_func_01, POSITIVE_TC_IDX}, + {utc_tizen_icu_api_unum_parse_func_02, NEGATIVE_TC_IDX}, + {NULL, 0} +}; + +static void startup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_unum_parse start"); + return; +} + +static void cleanup(void) +{ + tet_infoline("Testing API utc_tizen_icu_api_unum_parse ends "); + return; +} + +/** + * @brief Positive test case of utc_tizen_icu_api_unum_parse() + */ +static void utc_tizen_icu_api_unum_parse_func_01(void) +{ + UErrorCode status = U_ZERO_ERROR; + int32_t num; + UNumberFormat *num_fmt = NULL; + const char *cs = "1234"; + const int text_len = 4; + UChar text[4]; + int32_t parse = 1; + + u_charsToUChars(cs, text, text_len); + num_fmt = unum_open(UNUM_DEFAULT, NULL, -1, NULL, NULL, &status); + if (U_SUCCESS(status) && (NULL != num_fmt)) { + num = unum_parse(num_fmt, text, text_len, &parse, &status); + if (U_SUCCESS(status) && num == 234) { + tet_infoline("utc_tizen_icu_api_unum_parse test PASS!"); + tet_printf("The parsed number %d\n", num); + tet_result(TET_PASS); + } else { + tet_infoline("utc_tizen_icu_api_unum_parse test FAIL!"); + tet_printf("Error code %s\n", u_errorName(status)); + tet_result(TET_FAIL); + } + } else { + tet_infoline("utc_tizen_icu_api_unum_open test FAIL!"); + tet_printf("Error code %s\n", u_errorName(status)); + tet_result(TET_FAIL); + } + unum_close(num_fmt); + return; +} + +/** + * @brief Negative test case of utc_tizen_icu_api_unum_parse() + * Passing input text as null will return buffer overflow error + */ +static void utc_tizen_icu_api_unum_parse_func_02(void) +{ + UErrorCode status = U_ZERO_ERROR; + int32_t num; + UNumberFormat *num_fmt = NULL; + const char *cs = "1234"; + const int text_len = 4; + UChar text[4]; + int32_t parse = 1; + + u_charsToUChars(cs, text, text_len); + num_fmt = unum_open(UNUM_DEFAULT, NULL, -1, NULL, NULL, &status); + if (U_SUCCESS(status) && (NULL != num_fmt)) { + status = U_ILLEGAL_ARGUMENT_ERROR; + num = unum_parse(num_fmt, text, text_len, &parse, &status); + if (U_FAILURE(status) || num != 1234) { + tet_infoline("utc_tizen_icu_api_unum_parse test PASS!"); + tet_printf("The parsed number %d\n", num); + tet_result(TET_PASS); + } else { + tet_infoline("utc_tizen_icu_api_unum_parse test FAIL!"); + tet_printf("Error code %s\n", u_errorName(status)); + tet_result(TET_FAIL); + } + } else { + tet_infoline("utc_tizen_icu_api_unum_open test FAIL!"); + tet_printf("Error code %s\n", u_errorName(status)); + tet_result(TET_FAIL); + } + unum_close(num_fmt); + return; +} diff --git a/data/in/icudt48l.dat b/data/in/icudt48l.dat old mode 100644 new mode 100755 index d175867e87219b2df200c3cfdba3acff52966595..fbe7c0c76cf5ef8fb9ba1dfd193e9acb9aa627d1 GIT binary patch delta 56556 zcmbTf2Ygh;_y2u%v)S}Q+NNje9YU9$KmsJRKmbKr0--|^x+1bc5wHNEgbP7&Rct5_ zK*dhP0*XRxSWt`&6&0gcP!XT^xqBn%_y2!hujl#k`|NvW?#!7pXJ+obyU2XY%ii;^ zd+c5RagGXFS{M2rQ*NdnAR8Yf*~ z`S)=$MDyq3WG1XTlqfeVe@m1*p?hJHJOfMXlH@&DHa}U;!`g1C5|jixq)96DzL+MR zVI3R-GhRxQB3KTWC3&bwVlxHlFQ>_)unfKgYv30!@0B$99Tpr-lLpB|2DXIqYMS(c zrEm?PSx%yk#1@$G zW}57QRq%CK-r6l+z*=|_rnhlROd5{Bmaz1!Tl&IkcnysF)-9#50Iq>m&$~+ zAYF+Uehursb9)#D9e?kZcvue8VJ#d4)6co30G7e)U=1vX?jPLp5G;k&uo}J(BkSD4 z|4RWMfemp0x}p5&maAYM%!6JyAG&|?xMeko@}JytH>`yRVfuNuoPcHUD_8^nhVGx; z;%WqcbxV6#3J1b!I0;7n=9VR}0Ir8s@IfdS+;Rx!!S|pS{s8MdBmx=}f#2Pd2FqbL zSPO^4^grA(9hN~4tbqn}|LK;!uoNDF)$kJ-dC@Ju!2%f31P5SqD1R|kFb`f0y|4s& z>PW27g4IpsE?5U2hZ$>{${Vm8egx565D4|ErGl&4@RJPy6Tb(Ax(4oY(zc)W|m!fOA1(i%oO`$>OT2FEpL{ne3J zL_tPCKiLS&;a*q^U)73%{p1X+fqpIMFsPrnVJW-{*1|lP7u-)~z-qV}W`y*UotlTw z!KzmMT9!&thu=WJwXsIGQD%WhA^L zHtU5~v*b~j_ga>`1l`B7z1*%H*6smaKehEOuIr91S(5ip})w#WqagZDu1;B0vUx=&=waaaw{z=E1=xdbEM%$B&eL=Lutd2eOQ0GR%Ewv2=BOwRx* zB~dzefUJSl@KLQ$JV0L1yfHvd!mjudmB@=HX13cWaI;gH>=ntX-cY_ri?w9C^Hh?*ENBa+HD^cnVf;&XIGld`phl*urIZ z=12^zdN4q1Uh2`*&@<@)n1?%9K z9ohfoM|0!?1=YuMB%~9boyd_?SYDGO9bg^IQofrbS8Msn9GRtgcq1%*j|eK?CxWmB zJ_`#@5kZ*uagKZfy^<^EVTLnToSktvFjo>hB)lZrz^dR}=?gPLb7iDf2+NhJunboSMJw*cCI`LYv3`MJ|I_4!*ci|tb>lOaAdBy zU|xQ%w1QQzH;f#WD|wn9ohwr`KPJ~Bi%FD@$(37S4ZIVkU!5y^VL3bu>)^XE@0wis z8dkwSVdU6c3GYUG*bvIKxzZUHz=5zDUJKpha%CAEA9u2KFZHp{L*@43LnoFaW(j zVgP1b!~m>yj*<^yRn#c?1E!~rlEhv(&~lXYfRSBB$+a*&W0Wk_{E$&nsrjo%$@}g>F3lW>Dib4U*lgW z<0$aHFLLz`$?Qr6+XTXUMfMGHixi z4<&wvY=w1=X2?NU+jfSWgc(=OkY8YW{}~dOiT$f*NM8>L@2QzGK?}~zlw~mE{7l)d z`Aak9X;>FFOFq={q*?NZ=9|uv#C{^uVV3lOk-cWgSj`WdCD+4(k+WnQtQ|i~o`QKZ zXUPY!deJQT9j4zjOA`9y__|r*=}w}y5(BXGK@4dAAO@5#VgS0|!~je`HAjBe@(Xh% zK8yO!V(A8JV~S-AOmAE)i(p3EV%e;`s#p%d$o|FhHY^`nEI+}jamCUgo5;^B_DDL3 z((8(4IILP#EXB~fxmea}{@!AF6qZ*N%Q0Abs94Uzn&ZV1G=LF*QYGkpwc@~!KD3McI{%DE(2_v5@k;FlC{7Q**hv{#X$ThI$;}Th-`EN>O3oQG& zL>`A?FO_#-URbH{#FiRQe5pj`FgMLgr30+$P%3$_^x!-xQGUKa*6H=ui)6Q6PhTXj zYkuG&`4)PoEfO9ZIJih!!m{&=B?p$v5}6508!VAqVO`1+c?e3gC2|C&H@;rZKu_L; z>&1UCi{_i9(gap_zEK8i{*~o23zi>SF1Nvq$z@UnYp+`&Ct==QH_1il{^Dk7G=zHR zR>~k)JL?uHhUqV?lFhL6*VXbgbpO3tYGHNY8gUL~GEz42KzI8)X_SU$;?ifRU#*$|fj3ZIr#R0KNj<=QqkJnBH%b zoY(99H%Z_KM!J5Jq(Jwxo1_aYheM$}w@IeM0_a&uqKd>ldg1UUc^+oGvPn*9h1WL8 zFM9o_O%gSd{BN72J*+l?1feBHp|P(ahv5+=$^enlLq@{VXAPMOYoGNPavh0`=M1?WR>2+6 z{k$RjVB}Fcf@SannEsI==b!{_6~EDR&}^&3!>XLE(gC_>Y?U0%!$O!bbE{krYv2Z0 zFl(zk4C~+vu*@@it9(Era?V!y5qe?J7&@A}RT{!-*d68-ZRfyb7z}r!ZswR{0&)!0@Z-XYE#L2CE<1Dt(}*;K)|VCn2A2l^HPOo2_yq zto?DTY=r5yZStU&H`*qLU^RSC^NqL351NMo*O1THCTXx5_JrmAw#i6XyLg*Shq8K` zEQ5KQx5)-rvvZp~at-^x;PGv8n1X_Lw#i3Y;p8?sulZlLN$^+F-s_9ObD>xf$mDfk9aAw_Torb?_Z6cWjq$VQr)BVjssyGPX+sEX&(2onRdt z3JXSTmzl5{u7Qywx66aD7QOUxXQRw#)ml^x5t51FZUCy97?4e(yV_AxvLzr*u`mbf*l5-k7^&I?T(x zi|_v=3YOm`8=(8KyW{~__0?VSjOJ5!$XhV4WQTkK3trzLKf}71yCq;E<*|25BCLXK zVWjJB84Sx#+%3~!L6TP%D|>t8R#*-1)qEeXJOjOby&gG9qU`I3!r%fT z_0eu=1k29umL9O`f@il3C*khCN2Wt>uRUxD^>B|Euo~`y>3#Reb9x=tz{rd}@+B;o zw@3bfWl!#rh(hZ9vPYULf88T}VJ*BGmi@LzN}%_`9$5|L_dRkqtn!dJNTT46J@PuN z8@N}#gylo_${$+c$-NRaneytr(j3aUz0wQ1)2n0@EQQy>TDTTQmQ=~Tu&3ApO2F5M?}=(_3qp{@gshOM%18aLv;1Fc6c3^?%E*kGG|>cUMc zCd3|i{@MW{n-ZqQ+?+mbb^0_LvLip_K>o;y0#G0dLcu5mg`zMNjv`PbYJj3pG>Sp7 zC=R($JW4=`Ck&4Mc-b4$4J?(GWBg4MW3G9vXp0 zqI@(8jYeb8)#w^D7F~{b2gE zJ1#t4zs8Jv0t(x2N}ujDMqRw4m(6`}-a93?+dcj^Da%BUx}_`?6_9?AEl>y_hVgbO zdjwujem7hSZ$MR~_n}bI{m_jl#m!!%>>yfBJ`5$${u%NkN#~>M&@xm_*$W~OWrs=F zDR>DwZAS3+QLTDJlJAe+qU>$-4$32c5?%{S(FdeIM5oY4D4w!JyD{Ps zXgA{S7O~Hyrk{v7Xr-U|r>r{Sg^0uCUP4Aq{Mxukk+&k=j(CUsNwbzw9$FgX6!}7H zxU=))dhmK2aX#W_^1qrjevkMg;?IbSX8LdQ^TmkIBkqZ~H{#`pFU`F6zCYrr2qW*Q zQ8C7y1^JEC_jUpIMI4BDGvY^M#PcIvf$v8A67g)ra}mbtiEHC+4;VjA%1<-4em*K3 z6VFFH8nGv0Z^WU9$0D9I?s<1)2czKgQ4ZT_+EZeve1ouZ9vFJ857%AD?fm zZkoIntwZZkIofcrY4XOw*B*2)+gN>gb>#X@2P4;Sb{D4fYbNdhyc`uMGN74H_u54G zf7yC)Xx-+=Z1#R5w*0g?&7ObF!PK8NZwYqJpSoaSN%6tG@%#4L4vxLF*=-9RJilzkE#8m_vd*Um?jk;HM#~WGk6^)E@u8KsXEWRSn=rid+yzzv7q{dgo z8>c7I%<;zVC}WSSBGQ=XqHK#^Sm(k(+#o(~n{=R&5!hyL40BuIFq){TWlbsqjpwz> zv>6ykbkSu@G8de)4@4U6rX2`1E+kfj8mFg{avx<~tvj+i)u@|7wq0^XXJcg=y}6TU z_G==|-iarBJg>rOT$fyNl~J2SS=ZycBaOVoiWuWu!GS=dG>I-prSFY5u4{tjN007K zG%hC4%sI{*Zn&r5M&JfMjwfJrj9v&WIuK*D(bUd_iezI~TimTF#Di%?jA*G|pkAV{ za^%zl!NwD}VIVg_%_mj#FkyOr@#B5gM(5yWec;E-coR=lxu8l$Wm;|(=lO2LYE zGHt^rA4p_#k^L?e0}rLp><;}f{VUfnWi_m5WrU~T#uHO9kT~l==oZbrKAqf!>9n7d zT9IlzkV>m4cSQ>$U8DKf*?ldx%p@_SIU}oGalm1OrsDQ^ZIw0aK(g`mP&y2qOAk8k zEe$bwv@svS(<%D!?MkcF^RpRyo*I8Z=e1btJ)o^>reOpR9mYpmrDGb_n=QinYct4_ z3O9=8P^E4TWz8C4U|1R>IgS5DksFVzv{~dF40z{|y2)K1)$7#MjM=QVt7aT%XFT@m z?qs85&x$DHQbSxemk7$0aYkebD`-_C){?n0 z+)XhMGuG=i){G!^)oZ(1K}{IQ_$C!@BXm3qDzX_DHqJkgYJAa{3up4k)-A$lx?Z?& zjW^ktp=-FZF&_gK;ckyfUY33_zD!dOf)^2q@r_wV#f@n3gj%jEWuc5|jvJw`5sBM$ zpPX(+IA*k>in}qXCz=u7x@H*7(`Lz~2ih19HR8fUTDeDaQmu&4mgZdat@8Qwcya}E zw6rOXez$<^plcbyon!H*#TyK5h`Ky~Arnxo1H!P=s5{1{T+^Cm{d6Oy;@4I<)nXhi zh8&~CnAO-TUvePI7}Oe9F0|yse!~H`@!1kS7Js`h(zs49n0JoEmg>uDDkthN9%!m9 zT4;-9bXj*JlMpw_8)byQ&Xz5|j;uMBQcZ1D*RD}hn@h>AJGML2__{TrA|j29qe-|n zrWIojY(v@6))j4xJvUHqO-r&{dUN6078rO)v!>6Hi*duen_Oi!yOp3tE~mwyao$wp zq=(>Kqk~}wL>jw}?RFdS+IiO;KHhId{7P@&-f&G@>|JPs`Cm`$jxjDZ$BhBHUADHR zO4l~HcIn%FZYIHDw9|M6YQWR;$S%|6n|ll4yQU2`o6RDXz8srdHEZ4rSl2Pe(f2F4 z1GJ^Ag>IwL8}WNsIyc_bY<9Uf3sYx1&`(}}?gLRBxlq=DvWw}s65k)s%KMWI&m>#k zkNf)j9q}wTyP{EaM@g3s{Ar8Q`Rpj&j15^8(MGQUR4MLX(af0Kfz-8Ku>40hBQ4El zK`iUb{dL(u96Hy7Dn%JoG2Os&xG}5)eR#X$+B+TSJUE@QCS6!FxY5Y?qLV&0vb0`j znvrc}l%``eqf>>0@=#+}J3c6K7{S>UF}Ci;-yJH_{5nW?BQ3kaWt<*}sY^X+b~ua9 zBl}X@+aHG}UWG%u+S704RrI^LFWEZ=kZO}j*|aQ;OFyhuT}8i9-PISp1z(j-l_4E5 zm7K+ef()uK4vco>g4yD`49s^N$o=UL4c*zcdbKb0=5(S;m4@V81|N+EF!It&IvSI~ z0KZmyfoiHcleT+$kb0;mS2qr1v~YuBAaIIdNIJFUbyy_nm6at zoIJPQ4HxUkiD@Gvxji3$w8QZyHJjQ2^N+Qs3T2_jy7pXXrBku9Q$;&tVJ}j1u3{QL zYll}8yW#F~t#_dt9lg?psr{lGZj|YTW$9Gz*9)Vs=|^~PJ{V=ZQPZ19UexS$-N~NT zU^Bo-C}IyH-jx*N#QuDOhVeHD_u_PfW4|7qy}`uUac;m%VAokyQ_z8cWzq_qgn&|Q&)T; z#92mxu9Ld9eDvsh#bBJqwC)Ughwjm4Js8KHt{51UMVFg3V4-@OSgA`cy`KiG8v~?E zr%|J~H#2HYI$@7H46mO3DKqDzJOcxxj`9Lqt@o}A>5L=38+}af$H%hnbcE4n#?yUC zIl7W+p|^_8-5J6|y|MB&3uH?V>MqnRkkN;a0oU>ze6kl|sq9Pm%zME@{YWM2TDbTI zZ`Gk1`VX~58-1qq(A96g)7IX?&3*sPysEe-dYwkEH+IJvPil*$>J&>g&N!{N8g@yr zak2+}?CL?=f=rw@N8jgW9tR&;H-so7y$_3XR!>^&SjoJP)GkkJ40*_LAMQu9;7lfZ zPJ1k~?CGcvmdiV8GaXj7uF!%3cwdy4#h8cCEKr|$x8>5pd<+%m^VZme2CMoI%sIKt zOU&%bD5Dp3{W4{magT8z+8DBmcZb9^2bvh=6TC6T4t+(azMX8|^(=xRgRr}FHL>8; z%V`|{ZeO^uWeDc>4CZy;d}A1pL)Lr(UL1s<7jMS^L5lNrdtor$n)QkY;jw9DhL)Kv zjt;@uEye7W@*FxcpYRj4%zTx|(4m+vuNll$^Ytk;R~Lr9oVcE0+6w`B2;P6@@qIa^BC)*J^WO6W1~u<-=H?>(csK$^4W9L~UBnM}R7 z4GeP4a0VV(;Egxt)bJ(7e6uUd<7KpJlDC!5pE)CVhff_*(a-m~xMhT{oec+C8L#Mf zl4V;+MUG^{U8OIW$7^_BEgQ*LdT80Q0(J=I9Yz}ipCj|xli!Ubnq}j?fkyR6otP7R zTgu31ubpj!J*w~mr!PIMwsrO{X~w1eig?cjXMFtT&|i~(4(;b$>RcHR%+q0!Tqifk za#WuR#<|N~CGNGso*)}FV?zD-+%Jzyhv0r zwY(uU^0u6m59A~HM85EA6Zlfn&tW|RZ%f_c{3B_nGuXMA-*`IqlEr>%=o!=8vLsE< zGE3eM4kVpmOSYxi8rhoKTG(3K9AUcyUydD=wkNrh`}4Gc#+#!mqCGz+lm!-rbZ9s# ztRVQS;D|K!D4FWV0`HF=_fPJ@w8WH!+M~2H%}4XYQAav=@_D^&nayLn$##n^*l(qO zrK5*mU;FDez5b$GKW}KLpBwnStD_VJy7)X~J8XN|cGPyvcHEdUx+2B%r|pvMrLZr; zTF1QlC(X{Yu1E)(?&g^;lsUA{NHb!m%=FhDGjL-9^+KFEz7uJhUYls=^Dg^u zL4D1N1I%liL$q|S{bB|mwYWk`&+eb21h)a+)I>F%AuTJCe@7k)JB zC=N3+g$)~NrcZ!=7MmScnj=_mI+U86M!8WnV0$y$31fYq%2-cRM`6&AfOzL)A@79l zcXoCT3an0U6!2t&YXh2ut@FF&H!b<1zklLe{*O5#BA@q*35W@QC~{J4o0QPxj*fo8 zx<(iHE%v+KZ<(LR?-(i0impmQC-;B%){F>QOnwedF zVNU-v)3DFA&gPmuX|CUI%#r+N&bx0J?J-9`#H_#2jE8TX?ldjGWmw@mE%Y$A(AQ?2MrJE^kcW<|%~AUnRg5{Zlji=8 zH$5F?2C>L==)5^f-}oAt-JCJU;j{3X>0)PdiN={V*PC6gGN)vLX)VC){x!3Eb&L7; z-RPRotp3l4U_WsNPjFQw_(|uWs)RFfnm-fwqD%8Hx?HT45yVFS#G3Sz$te?DWz^$0 z@i@I+N=JH4*~zlkK1$oSk2+x5J3u`@kJ(ZE1#MXWM>|l((pZgmOHwDgCDqqa!>TNv zNu@y(T#F+8sJ|%E=iL96)jOn4`J7fV|MiCIz0D#LDvd&oOmO8A1)Jn1_ze3R*BiJp z0-cE1k!T&^k?5BgVW;4i;{L*^&Ov`gjt`U5KskAl!6J zN8lTABWu(U3t`XoS`=c?;lbZvB^t*6N4}u5C<5 z=a6mTy<@I_k_nCQ~~LP1_4i+eIu|owg|+b95SZpU3K@dfb{0wzBFoxo(q88tEFC z;JStU&ahj|yhb3+G@51_)wbH9j(Rm~Dwz5QaeAE`G@aInXk_&I))YTD!Q~l;;Q=Y* z59`%Ys-}A)OH~8Hw`2C-T_2oW?e8%d_{%>`Mn>L1HLkHn=^lcXA z>WH`F>mB-#h;SOPcpL+lY!l7Zt)qO)4EtLNV_DTZ!^S3k%)-f+ zkHar-Mc?Rs#(cIkO4URx73~cBzeT|p%~>AiS;O%lUKNEt*dWDRh$+#h*ltCkry@Tv z7u^R@^C>S1ogdx840j9jX5?EZK0~_5{yQy~2edE#ZrWY44K)X*({i)f&&|>1{#OU; zS2^E6aj3#vFgtk|sbO6x%L(Jk(B*`&zC)W_V1)H+Md{P!n^?Z&MPH7TO+tyDZohNp z_B+Sjko&(DtT7ALXn~oZX6C1vd3El;TSp!G){NM<4gNi!It706wPS+IO$0mJ+~(c# z%AHXkHQ%=MOmNlDT_5JYb4VX^@%U~azNz`|^}p2h1|v%R0CJ zyZC%lv6d&hF1pL|Me#e0K*)Dy1nTdGIz>9I_0#6jO#M9T4d%-E(vFXF6MBZ}*qZoE zcp;u2PbrLk-ORrp{=S)iKU&uWU)^L*LqF-4Ji&Dnk$K8}lNreh-t`{v^WE*XFl9q! zi+Qsu;pHPcp7);(yq$FBIsPQ!De;@&dYDc}q(02k(D&ldiLz_CIgM~!%gxD8M%yR2 zKB7*%{iBGl2yg4uugp2$ZI$2P_ff<#uD4D-W~ew0%-M z8_mYgQ7MQg+X{OSTf`=338%ib?4shkl%KS{YnCVR;?xBLh18$NC~pm!XU_j{@=p+r zOnHK6_)%wqYY_L0o-!!OU>drJVNQeEY|OPRBKV>`E8OLwa%Vj6OXFEdeWN$&qOxx? zLl;3u{R1Yrdg6V7y{Gxeyq?B?)3{Uc-{$VPhK~EuL8kPh13&rqb(SKvnxSFWe` z>G(;c)BA0Jp9~6O|Bs^L%g#{|4dI}mh7ld%Yb5`-oypCPIPJJRY z9!Fa?9BtVe3BJfD<{nbI+VNMQAX_yJ{pz7ZWtPpV?L^N&pUaeeV=awN|pX;+|b8JuCF8P z{h0SFIf(08=INL0+q1JVYIDyvjp~KtEEc8SIP_+rTU6DF4(ikO^p*KZHx_Fki?vg5 zpzno-H{D4@V=xi2$zU@=`t~bKk5%R|3w1GEQAn8@ncxbb;cN+rzsEFskGTW>TTeS( zhVz|*mnHteF4FwHY}ro1_nJ?;&aCpylskhrM>k_jb`ENmw1fK2;2jK>_y7NRWO;dc zlxo^afxO$63rXfW#@c-c*ffHTg(1J`Uuvi zV*MAKfxH`F$HT+HCU;WV-~}^~)w&Y{bu5<-yguK@cKVtH^d|H5b;_IO;{1;5M=2l3 zGd`C29AJy(JK^PTN=-t(FxOB0Hz!}-CQGmv#>>oiJfP09lln)T<^I9^_s6pj*#-ac zOupc2`AJ4MgePR4^M9{b@^$+-BYyzLZ)ECXaH^JVd)X-l!Zf{v!|fT68(TM^h@f4& zp5w3Ox=KHp=HcI@+{-=bGx=VAmf5j(Tac}tEzeeHyD4^E?6%l>wl%hmww<;|ZBN*2 z_Go(>dmnqAeSE?jvE%I1>~rl4?aS;p+wZXd6}vW}B4)GQYj>qRY~OEp#TBH^OMS-v zlKoYFfO;V29s9wUd2y%h-`bm}{c68tFY;UG=k=SG=6Trfpx+U{<9;jCwxpd(_}lOH zun0#(M<>VAY1xk7!iGBTiK~j6;F#uE;8^9@>e%IY*71Vl>9`|~fce7t=bq!u&(rF8_x9&HdZ^_wv6lvBdRe%u-jj{}BI&Q`@*l`#+U>CT5!dq2v<( zq3$LAH~Qc1Z+QI2xo5chG}!6?y6a=tSFZj3+uYCizwZC8|A+o({D1X-(EX&lRs093 zDX|mdQ&Q%{JDs6UmveJ`Bj>vbt(={l>9K#g?~Cu_+#CN~e2#O3vu(qxofDn2o%5a7 zJO7Sf;k?7S*_oK|V@hUhkA?#qwobSzVQ|6@=az<&w+-Fd&?9-fNgPHmqu0^r=nVP> zeTRNPKOw(Hk{5%LP$Se7wLq=WRj4QGgECPTT7VX#>(MggK{ugW&>D0*TBn5@&}L+y zN^}?UqWjPT=n=FB?L$wXXVCNL1@sa+f?h*!pc?cxI*C3&AE8gsXXs1xHEP~i@_M06 zWE2h9A7gk2>~E2(C8oIa+~MqSfd&w6+QVE~}ix zCbR`@LwBOP(Y@$?^bmRk?Lqs{W9T4y8a;=q(TnI6^eTECoj`A)chURk6grLcza#v# ziIgipHyI`JB?$)wU%_vY@pW-UuMS!zsHv}Nh{Z6-V@=P6D33-iWG9~l(~LzW6^$Ec zv({E|TiC&Pm|~CC>P1_)cC;Spz&1e*Q3d2UjPkpX zoqzoz_mH?B>BWcPZnO_+qsJ{CwD=U%PM(2>(2M8@I)=3U3HUa859xqT!B3F3`5bH@o? z-d1_0#r_s;*~W@_6-hjrM21>r!=XAn0**#w(F9b8wBA&xwx`3{sKhE?0M*w;@OpG3 zT7k69Ef!Z>$IUR&BuT=x%f$dJsK=I0eSEd%&VGYGFl;xd@)2 zyMpCI+{bBkX>t@{=H)++nK;*S>3Tl~f1Z$5HjidFEZ z#lN6-_P4SHLqghF2-Hr(U;`^13lpq#3T$Ylo5Gez+qH!{`R!pR)D87SYO8Mx7D0b9 zT5+Jo9E*c34z)Pk;s~e?=EJMeIIDb;#X@LKHk^)TqY|_LX{Srz4M_X+aAJ;GxB}i{ z72XQfJDo6ZnC|d8DKJ&EoG+ z8~+Law#xik`s(;Yy%qpNtg;A;4J<}mjJ4>3+9m;}SY-{(GM*WYNi;_q!q%`o>SX1+ z!JeouQUm?rK%~wNw#tUW5mtIM9E#zuE}Unj7s2b1I&>pk zfo?%+^j4^j+z!_xt+NRlXgkt6cSEgn54_(>KMZ$U>3#5VEA4rT#B)d+zF_f1i!WO| zV)0dr$1J`9wWAa8Z7cmAJY}UnfuAF_{guUUtZU!GA6m*t)4+K$zgZRjv?~0i`BuKh z{uTo)23ZWT7zWjm2pDa2xSofb1}2GY8fuKxhvrbLwS;Z0vJO^RC)f>XyPmKw>W{SD zK#MsR2U{Epb)yc4`RHmi4$)?SO!6h9(Bc$}Q=vLB9nQAWC2#@K&X!nZ*TWl)%%v6G z%zN}EvW9hOJG>jIulK1J?vzqyTP7F zmqTCJ9}PrpetbDXpHrC=eixVtPf?Br_PDT8p$Ll-^^=LLMK?{(%T#T{H zDw49bzWRByRlFK%^;_Xuw81K`uxLQ_l>^Pn??U&W`;8AUWv;fpWDg+i;UH8~Pr>KV z3s(8d7LQnb6{^W&@C14ry@%AsDT^Ol`~<4YpTaM#vTuAGDc@QJ-&_2_;*S>3Tl~f1 zZx%Uw&Ft(?i+@@C+j!x|ioWKPF1C%Yipyex#U!Zyq`-z&SyPM6t!o_RR^HZ1cYs~2 zba&Vr={Pej_P4HO!yI3kM}}G#hg%m%z|mIOSc~H@K{`7@n(y+zl66guMBXCFHuD~Y)UkiLc z@J!&(f%c#VL5(~?9fLB1Mg&a?nisS(XiLxoL5~L=4tgu-lb|1i?7>mNO@jLdPYhlh zydn6};8%icgU<#39UKEYSo6T+_x-x&T-_~Gym!+!|B6doRt8qp@AXT;SJvm&mKSQSwju{+|$ zh_@m>i}*3Z78w)SEV5hVz{s(YGa_$@Tp#I;tcpAw`EKNy$loIa8zeMn*`RBK0SzWM zSl-~S2D=+P+n}bw=MBy`2##_`b&eY3i5ed@FRCnReUvxqK-AHw52DUSNpw_n^XRLh z2SksLo*TV9dVTag(T_#H7JWMUyJ(4tjB&@L$MlOC9WyOvam;No+hZP$c_rpl%=a-8 z8x`9$wrlL5*zvK`V&})+7<+5%=2&m+p4ew%kH)?g`$_D#u@_<;aZz!N;yT3ji5n7k zb)2U#Zcg0NxRr6`ad*Z&68CuA;kXlVAIE(c_gkFP7434n+PV6=Mz|)rX1Nx*ZgQ2o z?sPrmdfauy^}g#f*LSXqu8{b|_@?ol<1^!j#*dAk9=|w#Mg02s9r3&3pNxMw{>}K) z@!!P%5${ZhO=y*gtVp;?%@N ziK`N~CGJjqA@R+`&l1lj{*>sK6qV#oN>A#Ol$TVHG%smI(uSn_lJ+GXPI@cpv!q{= z{F9@TnbhvKd1S*W8F>MUESI4 ze0PDn)a`L^aNq5&avyTP<38j5#qDSq-LPrHjt%=Z+_memH2%$Wnk1HSXl&Wj=n#4V zy@)uKx9o_~;id|g=OoDw&?)pW`UHK7K1XK|XUvwJMc<)w=tp!O{faK2KhQ;V35lD3 za*Z6wi2_kD3Ps^45=Em}wXbvhyrAEV>c_~{?vJ9<6tI+LeEn1H@pv`Ct+J?5HyU^X}9<&oZ zh;||Ur|f%B721y;M+ebU=o$1JdI7zNUPedIt8Vd>9V77uI)UCq@1Xb5N9a@Z1v-Py zqI0MYokzc+-_b>6Z^$XnC;$ba5EOA z^+J762I_~h&;T?D<)UFI59OmVXe=6!CZZ{58k&J-p*g4+l_JgsE?bPQLrXn;l%bo^ zEocq84XsBT&}PI>>}8ecPP7Ag(Yn9NaajUNMrnV&$Y?x+{)gECNmGyn}k zgV9hl9F0KvXf(P8U5mz}0yG&-MbptNRNN?nIUzA0Ekuirp{v;Ut4Q98_B9&|r?5Iv0eD~7V&XfN7_4xq=;LG%>juN=yrLx&K5?NIh2dKn!- z{MAF*>l&2fB>4M>vbWGXh`)m_d<-g3%Y!OV!DuKNjz*y|=o)k_nt&#uLNo%p4y+xD~`A0TedY>*&S5a5#=d-~STHTmn@;c$+1kV2VhtZ!85GUiXNj7b?KB{Cg} z43RHnq0A&TjL+#ZRpuMp8doNHhLJ3#nfjT-e}GZQpV_1_Wz%#K>A}<~=D&d{Bt4YR zIhfM)Fig)k+i2Tj>drLFhfseixkc0&MA=NPY5jqGPNq$3QE)2upIXu30>@@&c%SmPW-`AjRVaZxKe{!AQRgd5t|VDT*a zCo@Vea%s9*X#k%^vfQQ(@-V7R)S-OS(Ycgp<3+NVly;(57SW>KS#u&dInn33#!{m& z$Fx0!&zU%IQC*lL9L>ugHK`*T&F6G3%r~o!G`m~KnADNMlxp4C+R&Vc`COlkG&&2+ zsOco=~?eWcEp`Pn#8okK;tDyzt`k5mwrW3uEi-|&Wb*O6v zw))ZfYRWMBb+KT_@nK7lcwXHOKu?bbnW=o04FW$0w|Ozrr&wi1#P0;7h(OJ=H>T9;S#!9)c$c*_=n$9r|EH-|;r82hn80za@)p^!F z#*m&$i4NWuP+bR?Lov|wMvdtZGjZA|2;LqZGRCZ>Ypc+(t*UGqrq1cYGUvy*=l;rQ zqw@p&Bg&%1+c~9RbtNYVtg4Jm_059zp&Qq?!!*<-IJw+rWE`#JU($ET3OC+aQyFJ0 z%p{tP)>K9{)G3*b7ryz^p$?{vuICbQOO}i=Rzz3C8lRyUTFSs*DU7X7*)nC!=sNcfG?8RmNlv$BU_4(fYpS zkx77c$6r}8pZ;|>)z=xxbXXj4=xwFtw;6uDefXwLCu0U>_4`y8Jcj91SGh0n`R1*n(Co6_Uj5QBPA}aa%BkSL;F#V_ z)E?H2!d(QrDq_1MOjmAwD2j|9U#oO^@~K*4-Wo4Qm;Yr1N_A#^_co1@u5&G$YSz_p z>*GRKgxCifnQreFUyImBE_dhfcT+*r}RGRc@fw=%vp4-&f52d_@Sl_T}dceWW3b2swS z;`Ws2D-G&Rh1-@fFKT})I{I`}FZlZ~b5b-)mp8pmmHq{YZ+-vo6&=0rjbQ;k<0ZCyZSIMbN7w=%7Zx~A_xdLh$vP~Y^-TbTJ~q|11+ z+1$5ueQT*fhsre1mC^Cte=pC(l{5F>S-NuK|M%LzSKpN}ztSf0_u!SeoEU)y^=GDc zDx)akfAS@Vty;n;G)Vdit#?7+(*5_u`ChNNX2C4*xah zw%)f&sNs9PoX-|nKnvYgZsMk6)K|I%#_(4B^W`ho-oM8&l&Zcbpl^rjiXB3kE}r`P z!hhGnNDR-wTi<@vtN#sSJ}$fYLgITJUl5M5E2{Qv*_%MEZWcw>h zY3d<|i=mhAywZ1&MdF}Tt1ASN4FzD;c|7jLV|GAa<9*MpO=09(&W-S52ukwAz%qC`wjU%rP zNHGfDsf_XX>gd~~Zhqg_BYl$n@1w>|sOmRY{lNZD4qsmJ8eCm7`W;apQ5sD1royoF z9!cM!|5^d_M)!|)`RcgMHxKpOcR!nL{55QQQUjm6x`gz#j_)|ekGTV*%{hHxNoDNR z|C2-d#dQu}u6zr#{#EaPch5)G@-4Eu)Ndo|yuOdse^W8{l9Ac1GGX@r8t^@9d|#=2 zQ>M?~|3>rjeeQq8Xm;lNPUstX5s_lZ#=I@OvRw|W@3H*HGyqohYe4Dd~ z(adFJzN@-%bc~m;TH!X!b^TcrB@6UdfXiFs|NQ)|e>&>V3O+;iLDYA=`bC>#?O5GZ zzGt1T4c`Xztr=b9y2k2Pi%vT~zYj8JLLcq=bx>blt-GR8m}2d0+fr_9T2EcI!bdkl zx$kAsLT_IBHvHdPZ6*%ui;OQSzAp&%_s#l!Kh*5q{Hlf(T^GM#OTQtSuc*-XR2rFV zx}{Hj4fd6xrxW9arIl${`_{33OQ`>n=o^V|HZt*4Z=l6AZi_DeKI1lhm}$<6jzhiH zuRJ=Rv!%rNVeA2y=l^3Py3r+Y$A^4t@8!SG)+At};|cpj`+9zX+hNbN?ep8|ag^D{*jxcy{AM^-+bV3q z0e{(_4qh5G-1cffo%0O;bablJa9~6S|MK7ivOTbkqlayR?Pq(1^E3N{QsCD-_+7t7 zK~DR2X=eZ2dEEB1;~~FioyX*m{1DhC z|K*?{Tdz=0SBJkW3Ycw62wfX8%x}Kq9{E$+1y1l^We>Oi;Wt*YLVC)r;|FpSK^e$NTjPzQ&p1d{fQ`I2^&!%P-P7I3U;YmERWoBpK+R%D=3Lw9U7* zvsVV+>s;V}I`DD-7c!V+){Bjn1H5;~YTfJESBo(`m%dB6^DHtx=2FlSdeoPc zB?oUA=$&K>(jNe)@MnSX{UBQESNDZH1@!koeY>Bg8{4=i2bc8AlpP+eB!?oV$^zn zoMpT^!kg56HhpMp_0j^W=^W_~qC|o}zO*(kp@x?0^y<@iw$XB=w{KgurpL@`bM;Gq zanWj1aDE!88KgCII$N`i-6Or70{EXPqQ5!DS0lYsqqU34_^4h^!_S4(nw0NN!F`>_ zBJ)E1bZaFYt43vpu_52+-K$2V-}>H^~Se<&F2( zx?PQwQC?T?C7hes;fjhKq|+6-D@|%mJ$=#F-Bfa&jVYtNJ)3Kc^pR=4hF#%}{(_>f z8oJn6&&Cgqd0HuAzU}&M|(R@n8kGsl7>%zEiE-IT?LDlr0bS&qmRgdTJ z+;}~7dGjkA_ZK`yPeRi}tGiC(Oxof}dO)#WE!D%G&lGTInI0LvMNe7|z1o}MJ4cQ~ zkCXMNwO(APQ5Y|XV^uaVoD z)6C4XVa)@jIo6d!a`pIEj=|(4Pdysndbt=Oyan_50`U#Ufj)`I`_U_ zaDPX=rN=PJ8Ic@tsb$3zyiN4HKaTFy6KmT|pzMqu_L$X+Kupxb<#KQ0f_VrX$J@mj z7xmy`&hd*ec24ki*2DB-t~eU+>~c zT*@W6)Jq`r-g}48d+$i^K~OqDdhakGEhy6a?YZH6uuEZ);n`tN!gjjLhtFZp z7omh_gk^;t4oMB&5;`DcKz0b5fB&6fB|^Koong+f7q%Zm+J=>gc)~$H3%eO|Eqs00 zzL5Fu^l&}msJj_!u~vsR3at>fE4)$Yh|p`Hj?k||>W58q4+wcZyj|##uux9rJ@?q~ z#}U=tv0)1$7DVg{muY{;!B41}cJaqcIs38;vka_JShuhtVcB7e!Zw8M4LccjJ?!hS z-@{xi11s*X@bANw zh=_=!h%yoNBf3NkiWnC$J3>V4;A{EsMSLFdDB_=pNKb~RlBbcUvuCJh605*AWPA2{ zPIxYRZh8Lj#6*^ltRLAnazNzx$hna@k#9%78~H`#PmzwO*r<%CN>NRsdPa?871*k% zZBfUfu0-96`YFm19TS}qT{*gGbnoaf(bJ+=MQ@3IJNjJor_m3i|Beo06acQgr zs}a{Yu6i={+9Ry@u%Y7kG~!NQ~a~|2%q0q#@E2t-q+tZ&bQe2hA-ed=eyy18F}TKb}dRS7u>I}_e!HQ1$uj}mSt+)wy9;c0>+F)}eRu~1^!#2Sg2 ziER_RCk{x=N}P~5BXLpU>clq^_avT3%)XL%EAhL;zY@cel9Ea$)l6!^;;`XKQ<4@X zZAjXmbSmj;(%qyVlKxI|CnqMCOs<~XIJpZ;!^R{}OJ2ll)vn~j$>);aPtHyLDOpR2 zNl8yBol+;IRZ5SP;VBbR=B9|0Eh$FIJ1HNee4X-hiX+vVS}3)AYTeYftPC5Gnw`2R zJ2fOdDt&$Gj?^Qmmr`%0ew+GNYKTA1U&LR{-_+mJKh!_TztErK-|Ii+zvjQ|f9!we z4@*l*E1p&}tyx<4w4rHJ)0U-eO52xqBJFzG7ikaE);SkBzOaq4>so>`!5*bebDXyP zsLjyAoX4$Uwq=%|lo0irqpc&#dBy&zEqjCgu44$RGw0b9E!;K4I>O?#`0ZQNsY(Oa z9<8ILt5!{ovFuRZa8A*7IjlUdds;o}EG5A;)%BIFpQD5&$*Mc;TC5{o?WxAtTRQ)+ zx3>Ib-(oG}ysI9y|76K>yyW`Lxx;?Yk;`+bl+|f3Vtw6F$yvi$&t}b5WB6jrSx1g_ zYe*4CDYcl^)wYhV^dRM|I>-94V~neu(%!bmc3Szz{u?=S)8uR&V80@jt$CRj??xW^;_%PydAt@JE{F+ z`P(*3+h94zcObJLIImd~>>XVT>}9k?YR{04A)h)oTgKUTsa9)iCCfU+S;khuI?I*g z=x#smxS*tjoYSuH>B-H?hn5W?18h}X#T= zmZhm>nWEU5tAp&f94pj0jxcSKqr1hW{NN}NGQxh+Hq7?2?XYu1$h+zV`wZtx_QP7P zeU4hfHP0EZ{b7lBzN)sgZE;+&yz1y|{l>n))zx{Hr zCs>ZFz4`h1SI+Ld)j!ZCD3h#zDBmeBYguY9G!^8Ur*UB6$s zSvZCvIwQVm!tAm`a=<3=26z)}25*5aU@O=Lwu2pDC)j0_9kTmG+vH4p-s@aR7Hv1N z=Rv-Kso;QcAKQIZY&yl~k$*b2yNqSf;66s=@!bxKYuMlsgGUT}xlccldTMuDmF)o(wV2yJK7`*5hcJ?qwIHf#@DGKsKJl|7(I}vKi zgQQ4Jf*I$LGB_)R4mL=El9VJqrHigfh?tTr&y$xe1Lz}}N+^7% zI!SEkj~0a~UxEaQl&P1mZ|01sl)o^)cKlq6134b4n1M(KpCune_qSi?oNA)Z!~F@O z=Md=ei@VE6kp#M6U640G$AZ4@ySqz>A4k&L{7%YHT#>dnC7-Z+X*F(6rPvLv}Ll7IS~OndW9Q%t$lLcjoqVwi#%=8EBnp z;w!QoAlBR;Vn$eK?!Rj$G2aaTnz?_#%(Tn2#G0|Dn&Ce(x8IreC1#krrlp3tZXt%iM2jCN#o~u)wtZX!?#cx4q3+Z<+fw&5-hAqM1sV z8U72?^0m3&+}sv0Ek(^R4y&3?(EeuLFPqy7<^eu5gFZ6%bu+@>=3&a4+cxI*Z_{^_ z={qIQZl+Miw8(D>XDX}BFg?uFisbE^2QFb+77{)?Q`uz(l^-$6RC<|Pm$`k#+*UIq zTsFgOGNUD#+kWO@u9@4v%T3PeUfL9GnYLX!rQOng(ON0dmco{LmiCr`e2I9zoxmy3cyiy4G>q`poLJmA5sq^{|b#Ewk;jU9`=1-nFUrczbDk zLwh&-82du|7W+~AHT$=AizCrd+R?z#%`uYE-{wm8YR3V`+m2(7vyMv)@IH0KIm?{V$z)G+htOXmuCa@W71v|iQunz>l+u#s53QmC2;2m%Q zTmo0Xb?_nh1l$ClgIw?>_y*iB!{$5i2>b+o1%H4i;2)qm&^rYVpz<(3FkAh2H`oLA zf_-4Wp?-YeQJ>_>>++t;EqDsoUYCcY{HL;2)NCC%CZ4qplrpNc3A}C*$5*UOu{2le zihJz?X_jV6Ls4=iA75$RAz*hkVP-~7KhzT=SFTJG6FLN<(po5Wv9&a}?U)RbD->m@ z`sTKt(m?F)5GZeHp)?ZhR;?^4VmtDnYThvrZ>g^|6MZ@csL~v5e#bz`?D}RZndY`G z=_q{Hy%F2?=C-xDZJEC>ecPE~>M`pg7naFwd(%?i-0x`acQCgtSbfkQ|JLMQy7kF% z9?x^@Ds7ea@=y)=&kK;}Hp%BL^4*sCZl`=#W-~7#5-<~PFS>LJRJ2JYl(J%er$G74 zh8#}%HRQzd!sNManQg6)y)_4yuH?;d>*l9j@84sUiIHE=W*9*keC$^l8%UdbhRE|o^eNneB8WH8*dOa$;3DKS}l9Cftnbd=l zWd8YDk4D7q%j=emDOZ%Xgv*)D=WAM8DqRULuUcNg$VGyEneymBamj*t!Sf1Iu85Wc zz2*W&h3}j`50J_9VO|M8FOIrO8)54jXeMG#?TZrDZh?YoIkCTMps?82l@YFWax+J6 z#>h>PZisJv)gi~Ts$0MsDOV!NqAN|dQqOHrRR2g1-)DbYkN{HqySWTaovl? z4rdxAZuSV2P|L_rKKf62(NO+EI?UFVGaD$>ZaL8oxg3N!OcB{9kSN6inks0`d(#^|C&yt;-9WQfJw?W)SB*TH?4dS~LnGpHZ!*74Dw)01n=&!G z+ttpa!u4E{FkEczNupJx1V#4;`w_p9U3F93@T=aGli6vX(VHN;+_aBdSw1iXAcahBmnba?R7>ImOoUXb@cFWCy|6L)>wH{BS+PFGM9%d90Y4 zAvFdE($%V>?4p2AoJ25CUQmSaQYa@=BN55OBBE<5m4-oTy7^L%&?yxR(L7AZ(^oV# zSYBupZj%y#69y8_R75nD;Y_u{l+L`Gn5vehZsE}f`=i9sPS_A3?CiP|7 z4v<6pDBRiV(mu5pk5ds_>nW3tNk#r-m^>1SjbVB6bEaydyy>J8WWM^_)M0^e-}6?h z0}Yv6{VZo%*c`#oYT#rr0}YgW;ob+dsQq=95;}t1`iD@dugv$Wtb^c}$Nur`-72inh#=oQ_-Bdpb zed;6gCCHw*bp{>DmKS-2-j~X`d=B+ zE~kh&Bf0C$*Yp?f$INF~d9t!pMW{o0v`rmDyj4<|F-ab{`3TZFy@vL=SW9Z5`R2SW zi&A8dGaN&Zmdy!lia(k!v@etyJ4%g4vlaY1i!7Xz#c_HRSupQ(Q=IaRQJi{HDV)<= z76kREY&1_$psird#IRSw6=(TE1Gkkk-a;o?Wj23}^;6v{M(A59&| z0bO%q9G$3L%*2T{$@~uBpws|;n;9sZoCF^&P83)f7uuE(eW`~7XkWS%)P(Ok)BMVLC5L?2GoL8ZUZD(gUM5p$c7~hf z$oPagG?644^x$gu9LZUn%i!8M<+PheDnsTqf-jS-DOs8&6)9Im<2!{;xYT7ta!t;? znQinnIY?oit*K4<4f>bQ6&l0D9H|p&Dq5Z%%X5S)9wvT#mAxub>yaT4ztmeY^&7+T zlFO2!p5Kk7kjjAQ^64gjvoa{JmQIj2gQ-P(P3mX%lk=&jM6fB_xkRRi-Y8c#U;ET)lZ*KJh}4OJ z3=tv^VvbPB>ggE7NoP^9)eF0$#XhO{DdjxH`%;8+z-U<)i_p|?6Nih|Qohu@5&y4| zFORGR&Wd|cJ^fe3(<9H67RsC;&R6?fGJ$Yr{vvXk^u?sHDSl|SMy8P6FVo43 z*;$z?bpcl;ul1~|$_2kEHIB_*0{Vldh;6>!ojJ>F4w{*_6r*G@Vv@W#rmkQSnX`m! zIl?Ao=@1I@%Vr~8YVej5f5_aLbIbl3bVtTzak}PgG`UC-yQV`2Oyk)yOXmB~N<}ke5b4*-nr~_=%D6nK zWlq?qNENz9QbVulJT}#&Q1*9oWV6$R1SqO}9XwM_&un5ANew;vSsleL!TnyMF$Fnc zK2mKAbml8Ww@#$OXpK2|>lUQK$YzL`RGF@{DKCi3o?l#(MPdrtnmTwi1W{tw9EyI? ztU#4Ksl2~t5yWg(k=~2{kIbGqFm8^wzEBJNv@-=}%JG?N4tT0tMTIx$E}3_@`D`>7 z9vq$>3vdN&lDmaag|}@|4qg3Ln)$HY%xihy1k}i zpQ&;;bpbZBCpvWrduFeQhY2n5VshVmA(IW&mXJwPyswhf_%qweMe+)w)>kWUjfH;^ zr(iz!vszK6W_>~YuV0=*o+;?}_9Aj`uBMvXwaxQLi1Tg|)Dmt4^sUrOyXyU1n&hnG?@6P8mh=l~WI zC68n{+Q7*JbPH}4`$2E(+=L%w&SCAJWtC+G1N^@L7Jh(@8WrJ!qz~XC-A&VkKu}ws@bepvIaDP)uP$vyRVN$$6BJUF_$=g!vkivjlO?3u?+1 zl2asBrQD^NQ)CMZ%7gP7B{(EUixtOva|O++(p8Y%A0HxXd2LmobDo|d%Hu=wvO8@J zC7HFBQ|-8h`^PD(Wb7$MmL5RG^uWGdL*sI zgScJu>iFh%baTz5(${ecW{|^c1GU70wNhexEw}FL>nW1=*KtOq*H+Y9&)$#gC>%EY z098ioy*^MaFYb5i1A}CYwxab~*@kZjBxDcQ%7%5YJk{=KRV|)~51rqqjPp3$W!(!y zZ@2?tm)x~uT`6AQaaYykSrG}PbPQNzXVSYF;?f; z#43&!?&3*RL)(On3ccs<>RI4B5tABmJ7!|oiNsOKbrVx#M@D@R(biepJI{3_sYqO} zZ13o#=t8qHvIhpzs9kQuF)wru+-NPHE z7fvn_xi)l0`j6?O)5b@PjG37f5j!VhWb~JbV+uq>=_!k2wuV27x|P;EA~Ahs(p9$F|J+-4!JXKSF%dn@%75t}QBik6q1iRC*G~{taac5~)CtEM)QO9PN-yyIjtI?l90~c+lWV&Zx;Zk&aWQ1F ztGnZ2*gnUwY-fG@&eVNz&!R5d2YU+nQk<(((_Ot{G83LfmiIsM4vM^)a?Q6Xj=^PMH+{L2T*RuJOsCi&DDzE2pWU5#Ej7GU?A^PWYl((xQ9Tr**MZ zw0vbh8ULZGqNKiPpu|H?5JjxwfIU7JOI!l691|i@l`1rM-$>x6QP! zvF^6MV#~JmvDLR_*jiY9VFj&8*12KZ?7gg&62?Y;5PHUw>fIRfYhvk`!tp1fQ=@!I zyF*UJJ<5*k6%8Kl#24uOGHIs%;KjVb44{v7d(>b5BgD7-qF<+TWHc z)*IHV);8AUu%axf|6a?m{9?K1pB}O(?yz%vs3qZ~J-c?y(D--4Yeo#ST(BftW=Bo5 z3{F~Od8}R6d=?{ma$GY{i}3xiU&b|w|5fu^64e;%F3U&S=UNMkYKgRDMt|-4HMVqA zH}|YaBXoOGt7xw)BVlktMD!DXmTQkMHeN|x<>`}@8yT9|H1bz>Uso${Fk)dsudpid zd%ayE&u6FIPTCUTb*~Ojj;xs!>Ad7pJU`msvNW(Zv9z(cE!!iXxl*G)b(M}TAJQwj zw!2Ws-sr9&wWGsAZbt%uUXrHAED zt*>>s_J;a~+C*8a>1qpYkoK2WP_3iXQ6?#Uzfj**o+`g98xS;Dt0ic?)e1_6;#J3J zA1J4_(TYWVi1=tT^@{es`k3DpEY`Ma?`TQv?P9DxMeU@Zj^e*6qKd-ccuL zA(lx>4K-a!=5V^&PJI4mpg^C^kVeW~#ilhgqMq5{AD_XR{`K(yRrve#$?nG1OBxi(Z@gHHi#YF)x7w3l{iuyhIOZEw=^P+k@(BZ zfiilD_^Pe)D;Bo%zufPd1_Vu|56G9;_SgPadnz$nntEJ` z)Y2^SKb3G%>O>Mhs{NousmIhQq`F7lqxMn$R*Ne#E9df4xS?!QKUR82tFNgZ#luHr zwy9m2((R(bu%7S_EKa(=usQ#tZB$WJL zs~slf|L1>pegfl_5?VDy(^{%$)TPQrrl?n`AE|FDht*7NwboQSuMAcVPApv8rcTu~ zZMoW8t!n+2-Q!T7ER^NvQl?D7hMkt%K@70s)eB~qJ&C)_OpY>yW zUu9u`gt<=>{Df_f?T7ZeJNiGe{68Q;2<~) zu7O+NTks1|;*{Jl5DyB*DapBI*r@>;1G!wQ@v?80$qzHhKe294pr9)opXqUmXQsHg zCos{w7`hR<8JFc=+*pb-O?25CXcxH;Qvd|P5rP~uj_nON)bPvjAHdJpp2msy_XWB} zM#d|-F@UEFN(13LP#+9SD?mjfYNzP8Qn_5O+3oK6IhD5A_M?TIhOQ3;CAd*GI~1qiP_qQ;Xb+ zeJ3d7Q*w*@6i+kpYcO!e)fGAxnr)nVJ5XPBFN7ZgC$L=-kp}~rA$Oqnp!a>^rGtS+ zA-}?(z@PfW0l3SRpyWm*D4s~69wM8`&{SxesCtNO7KfIGmKEaUToH*%Zd{_`@rk0x0{2{nq0OKjgzq?c?F$_U z9W1&?IvP3_I$o@ibUJi4bgsA|>2j!mt`WWy&^Mu5q1#256M=T_05k}WU^*ra$q<*I zSE1L%pOStCy$!u1s-6tg4tWTD1bv(+rkxCway^AVgR9~Y-mcIj3OUIv+G%_zL#IP$iW|~* zIaEN`h_o{t>@Db4D5rJ?-vHEr9uk|*1e*EYfu0AKFujK>uUQpf6SlK~&)lD3`T{(| z+bO<38~EKFpRD9o1GST7_8z|zSey}NReE1`C|O-F_W=X(8iFfpadprdbTi&M7l_u< zreU82J^{B0_iKJQD`9GYuEvcEfe0-!B1OrK2K~U$6vgwJ`14)LeJyk&bd#uhiL==W z-3#4syml#2SPeM_e*}M;VjQ>}*ud`rQVg$awAJz+%-s8Gaa?z;?|@ z{*>c{e+B0=i@62T$pu#V+&Q?%8MsA7WDPyZnEQ1gRE<1Lpj!m0j7MJrj1+Hu6Bz261w|dl zBZTi>;F9Z2=o#o`x}Jx1kP(2&kH9N`v&kPerIuITJpz_%fV`~@<|}m{W0d7;5I?-i2F|h_rmxJ zeQtDdp2EeI+*Pynf^RhfJf*4M*Z?L3ZUrXk@=DA7O{Mk>5ZcL4U$6Oj_~c`rW{EvCpXwOZ-RLN-3UlrD)Rd ztFZ0y)cneBRCeiyUewcCgjh_-%|Z>;pTq^BpFzLIT}{LVQx0yJ^zmUMI!y0lF*El$ zHT5?csWi7*X~lEIm>Z!_RK005@Ur56f<3wn6}*h%DJ*=EdSzdAXl-a+TzN?+0+#eC zm&M>ny}G*@=2oB`K{|;2k$NvzALvl%Na2gp+qow~CxhvjW{UAqdS>b6PytMU_9qg%zk zc)g16Rhob=D2XK`yc|3OmU4p%3_=j_>qg!hX~z8n<_Mp-b6h@^X?(Q0T5B1OHp3&l)x=2 zQ%o{CByNU?iRsjZrE3bk)5S{w}zR?Y5!%_0p>QS9o#-o+uR*PbpC|O+OLY z0NNRJ!_)`2s622%QPi(b6s=SBByk~KpX45k&nB>yPywS&0lkyzz6k#lJi``d1Pkh8 zU(~|%iZp!{x!y+2Li%hq`T2F4f&C2j4{&AqF9e#nQ&`{Vet_wFV5y{dLX3q)bcg1P zucYJ-1|zY}#FbH&0AcJdrW=}fJ+>U+txUhYvf`(yPiptqrS#GTUm#`7yC zdEKJAK7>Dmhl;rs^o_o_s@$lccvZzy23O{IEnpE$Mg0?ZJxmS3K)ka=MkT$zYYKEa zbfy?pNq^{F3JpMy;mXJxL8us2SwHWU&&Us`hga~r4jvNhC!<9b{dd*vtfu641-+^% zo>xShYWmuL+y1$j*J9ozo>tR;_vz4&z-O4g#+3)z48nxFhW^RF2l*ARKR{e{D!TD! z4ZZk_Cb)cc9@5xH;w~j>>$hLDMwzt``~J7pn?{J38l+M~@zfNf>gvn?%~l)CeK8L< zy!G@WYUFqM584UX&tU&p+^Mg}Xb%q?zt`7izDV+W{8!iHlxixT^I~bHUfOj7`Wf_d z<6@>Bs(J6h>(`>oQY-KDc9F+k#{DMx8B6LgY$HKRZEl0wil;TMT(g_C{NRS(9PCmH zeZTr|{`=v(8w3b>-dNg7w`jf_@M3j%N2;TE8sf?V+zW;qyW3DB+&!@M2J`V>WgKg( zx6<63;VjI^4XsPxN7U`4KQf#h^%APPI>r@1;IY@hgKo$>a6Z_XTcDoescwwwqKB%k zHt@0V*Tl@OdZv37bTwFuX}xiyEA3m<^LuP3_J`R2t|#Vo*L(U{I-8qXpEnO&*~}Oq zmP~gSY7c#MWLeA=K^;(^V3}fO5B-_DBXj~_IW+H2OM6nxYoKeP>&3;M`X%pH=y~Wh zTv-N3LA==BOK+EY3)5|I7u+MreOy_{`Ta#BvG;!q`44>SHlPu0z$G*8^x^6AZ?|hW z_MO;|h~a(pXT`5UpFr&m^UmcYiH@Uz%}R!}ZR|Ju|7oU^MpexbmW207J|J z_8FmnqN!Jns-yH)7T0^&U&cOBEFHt$#FKyP7@eQId@L4@)0f+>;eAtNjMrCa^jMCJ z*Z)*CTbS|oME$Nxm^G92M3?*$$j2bWI5t_YtVMsq{&5uO&ZsuRNz2%bk>bH7c z%+g<_6RT3h?H21rD_+<~nX&s0%ynO@(!2)Z1) z5?5A@ufRQH;WB-#>U)VReS_Mx3BS$YA>sbPZ6WHe(65R?!}QMH|E=n@5Xmd`O5)^K zfrL=bF@z-LpD2?MtddlNj+^YRc-rtdXrp+>;8LDvYsaJLh z=vwG{QFIk_D|9Dxw-_v`0X+geW^7-jmsdm1!=J#NZH;e)K0uB9oRj#3bwbhVYaK6s$Nor>_TBny%y`|cbK@7uiWyw4SKZ&{P^-Jza znE2pc?pnOxH2Q3i{f!{}A$WxCAMwscy?#`9dpbnz>5Ai~5WB%jG2)rtQ;f^e=R}So zUsuRi8lLqD)LcYvq7~}{?F;R1G})xjSG^@Du4@DviG3dk;P;Mk{|&vB8uAG|q62Rt z9Ynp&dLviK4vg5qD;i5TQx@L3@X_$8xbh7C22aI}xAfWWC770jH}T#khHufQyAMK7 zf-{)T8Be$9g|)PeWb!kPehYi;jx_O5ATQKwIlj+?^9?*H%`4@O@(CaecY_H1u6?71R5o;tBoDkO$CbP+NC# z_k>=`>+MdLsXK$7xH8v?93;ueI4S%31+WzY?eOnq)IBB7ayWc1{A7Ok6vEdMcTVfg z-0x%h2z-Y3=c4KveZKo4^cV01(=&1Xj9%Is*@GLY2R9O~JYX6LTsFLCxo^FvsG{-) zNyRT6bRt}TWAHoj)W*V(z%Lt5&q;m@p4yYKV`J$B$?Nu{e!*858Sm=NRM!^xXYl)C z{3X3p$P=ig7w6qe+`Oc}6cXKwemp#-muPfZf5}}6UIA3bR!syi(_L-~Z3S&(sPBlM9xxbG8eH$m|}+{AtI z{7c~CuxBLD8CHFf}dk_u0QT9)H&Vz?= z7Y4x_T^d9sFTzUBNMCWP#gm;gBFsVb8+;9**RPn^)%6e6SAg_Qp(dKV` zzON+avY((box6SI`&l0r}pQ@Xj>mKBepEn}jVJYy&$9W8lV< zgj0;#p?4RqXL>u=Ic&G_`^M=1Os}tce}fkv#)#Iiyu(!`y=TE=!P=Uy38v;CfcJa( z-qrE0A-tAgX7X)Jcfmcp@8inzsfo8rt}SA`B{($scg#HR5Of+doAue{tmx6h&$ zy~plq`MfJ3T^R*6cs*7;T&ugpyB+m3k#(2_P1|JrAGKgu`1>5?BM>)I@e~xjRt%AE$^ z2;VNAMh4q?k3!Et-@%n<(~PreF8W6We-Hlv)5qWm-nLQ3kmz8P#Tz$@N6{!=VsK^n zR)qiASQ;B#t44i+?G8wPnI`UKF8a%&R(!CWt2w+Cyp0$iAFS-|2JHpygWJ$J79WhG zVbA|-C_eWEGezqQx>G$X)VqOHG4(nNMRP6(oZg{C2oUict~_>oj@?gmNe)gDYGUxA zSu7pQVo3>h5}8TChRGij^adz7ng{M^no?XDwF6Q6itS0k<;lG<^#x57Ln! zgAGzo)S?z(TMWJg4+*1UT{mJ4FuqRb(7xwKc!b|ipyexE&sP-BP~po6 zZuRkr=-d@RVA_Byqjx8IPvb^LaI9MNB`q(5yYSl!z6B2n`y@YXFTxH4?Zob+U~yw} z;oxO8Ir>%Jb-)lX@>PZuaAm?T5pa-LSTwk?~t z?HR>LJL&=fuYmNiRFbj0&5so!vx9d3^54i8p3tORlTh7iGw&MA=CF@_< z%H-RoE`DLFm~YE^?S-vczReS!D$h6XjBDo`a~8a?H4t?x1fy#<$@eZaG;to8om>L z7*`%*KS`efSHVZ%6Y!PsO0{5w>b**skHHi0j5r|^S<)cfvxAk5Yt@6TRd))8ZlKph zh5(I{HG_S%@EPz2;1RZvNydiS!IxB*e-Z&FF{^60>IMzfHxYgsoX2((SJrcbBi}M^ z)C=xaqrSuT2o#&l*wkdjQ+u-UdV^qF)z=HdG9WO%g)1Y@A>tv!)+kut5@}#N44O}& zy`RGPq0yyDaHr;547X%cJlPCd;mUYNiFZLHHxE8bu8FA*7>M^MT-kPp;e8x*HmbG= zp4Yt7vCjsK1>{<$DxLzkEo5nwHyXDN?&EC%!+fw9&&`IdEe{p%VfbzMeO!6W(DseL6{G5Wr;liEeQ9X z@#lbGwwnAi_TNFdS)?_K;W%8G)^x&LF;)(uy7;j}=|e>dMhfd4fkawrdv$iJ{X z1yyD<`#GDHBgUFxr0wek7w|2(^4RYa=R_s}WiAB;D$i9s4UC0jf{7Fq{53Ee+cG2g z3OAE$3;Z+qeIsKmX?e7H#F@uXDsBdu5>rbAV~i!^f*#e~5!)n?jsHBcdwlSjdo%PM za0$~##-Rzpp=$U&xPLwub3PO0^Nn(og7Z{&Lk#0VHpYd<#mPbDw06QD!vDsVh598Y z-_Yoi&6CF+wt#m((02i&YDSmWg0)rmVz>d0U^{2LH7!^`t#lXeSV-7~JlAk#I?w-P zn^h{`_TR@%`Gw-2>A|M1D)`kVUR}{D!3B@I9g=pj*bRp5(Scsw1vS= zTJmJ1FI+8XWom4$aCia#}FH-t57>Ma|{GKAP1ga+U|1Cp;gR z-9%EGfpsZWVX5NrFBSF`!7Z+8@OJR7BDf;htI`1IU@#KXC|nM#ej*DK9b9fF2UQRaBlc(DTrX zqR*;eY41nSPoOt&W%`BLG!btR()}f-Z@@#mzZZ{J1v9;WLZ3m^WqF~C61ul&A%a5- zxiNV_EJ$3&t9gEq|5oqP%fuHV*fG2Uew9IW!qr?R>a7ko^|gSv2JNtQz?GS?vMDLv zS{>{a*%#9QFc^#^$SC1m6U=l^gU$f6F>(59I9~x>3tca^uL-tuZ-wpvdok@7uGfQ| zTqmICp%=yA*Mr^MpFnSd+nDZ%>#ql!xgSG+2ESwaQxshrZ0B<<=T=^>c%pD+4XQ}q zYJve`<=SAcs1(fUAOjR9SjpwWzAjkJRSRAp-cU4IM=GtLZ9peXU2x@DR$)_B1lLjI z12GK&Bk>+3)b-r^lcCe0Gew*A!AtI?&|P3JCPNh6K>p7|FM_L>u8XA`f~8$|pkG42 z78f^AB#)p!Lw^;njlq%O&!CPKOfs!dJmD+Etc}5HAt~?z@QfAW-HpLYDW&1%;T3UZ zCjZ-Ct-ZoX$q9C}6#I(q{2{vY4G8oZxJQJDm3a~V+i^`@X>53t2t}VqC`h0q;QUHn zWb-5ZxA*(ZNZuOkWU2W)ymb}V6l`6kc&_5g9R0Uq-OjiDw`cs7v42Of-HT)1C(KmA z^GV2ev%EC^+iN~!l-$EH|IOnC!t`3ra)i~2XF0As=6`$CZyLMz6W;qgkJ|`Sdktd= zYZT9D!xyBJmpvW67k(IbI0^8&n8h1YRvnUJ31?OfFfUH=?*wN-NW9`N2wc(+w2;A8M3uqG(}cu)vb0*%4+1SQ+Qnw>r15(r6D{OO=47y+h$MPLKi z1I~hv!8hO!U{4}ZPzcljt-$~=4lDvWU=KJ6J_Mm;Ix?Befw4eK$tEDWsawE7U`{0vo^w zpm-t0-w;d%D?mbF(jnaJY`IfJ@n?ZWKpu26?m@7-sN&BBtdhy9542*OEw}`}1%--J z+~5~5r-b6SA()W>-UN5RpMcq}tZATXDJ~)S4qPs+_{)@0{Ea|%S2nML1>g-Zv#jDT zQcm%A0-Hd^@``^JcmS$aQ2fKdaS&IL>rKKFaC1RqCB@$Wz6`fvWyOCTOoy{ZD(hSJ zBdaL>^MExErY))}B~_K{KbD<|7#HB41y2F5Sy@x6DgGVc2T-Is*Az6WK}mrx!Ihed z|1Nl`7MZOL2W{&p{`H_tUB!PGG^)pmfz7~OU-6d!Ex|JI1~{!`vMPw3AHhov6#qHk zZpc134fu74Ul#ou_W*d08}Br3WLw2Q1bhODwxh0sJ%DMYEJu6Ap9DIA zA>cA7(t-MqSeHMR1m;8b17>itKEhS8_3o(n=Y!4Q0QedV=|o)wiJiG4!JFVQ=+K2L zOq|iUb3nVUTy^jP_zk3XQ~VV`3}HIp9s^$jPxoxapVFP&;V}UBJ@6F>=|Q~&!@wt? zMo+31_zi^j;tWB3&>8Fir@{N6Z(pwP04~N5#Dz)oBJQ6cV<>kzcm*5>k3oZBivQDW zHW37@0e)mZYB(8Uzdvqm+_|_LfNg~09}M0DsaT~m> z_&b6D;5z7!f4k9&e+F=m$>U3KvyZa*7QFllZ5V;x!nMCj9RxB`7jTmO4!G?>gRzRg z8*VS~66gq+{?3w@>@+TGF-*P|m!;@g8wt-exEyQ9N*%{#AY3;4x4=oJ>9d&7&SKCZ zO9o=@S{k!H1Lpue#jL5gyk}-zA!1(=$O89(Z0QeSd&d4;T>E$$OW*-skN{FaK~NNw z0_8y!P!q^F^~Pr_{!B=7&<1n_-9T^99}EE_!5A^5^1 z|61?|Xg-g?7}wz50y1#5`8<<=V*!;1$Vi{y7FekG%L18ciMjs^D&g){`>k}e7O1!$}2Mu5BE9ylm? zVu01F=|O-=@{3n@#U6;YP7k5l{$>D^vjgN!_X{|DuwQPThb delta 76264 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 D)<;Ic diff --git a/debian/changelog b/debian/changelog index 5c8a6a8..90fc95d 100755 --- a/debian/changelog +++ b/debian/changelog @@ -1,7 +1,202 @@ +icu (4.8-1slp11) unstable; urgency=low + + * icu timezone upgrade to 2012b + * ISO-8859-16 added as default encoding + * Git : slp/unmodified/icu + * Tag : icu_4.8-1slp11 + + -- Hyungdeuk Kim Thu, 5 Apr 2012 10:16:04 +0900 + +icu (4.8-1slp10) unstable; urgency=low + + * upload TC + * Git : slp/unmodified/icu + * Tag : icu_4.8-1slp10 + + -- Hyungdeuk Kim Thu, 22 Mar 2012 12:39:12 +0900 + +icu (4.8-1slp9) unstable; urgency=low + + * update latest spec file + * Git : slp/unmodified/icu + * Tag : icu_4.8-1slp9 + + -- Hyungdeuk Kim Tue, 20 Mar 2012 20:09:33 +0900 + icu (4.8-1slp8) unstable; urgency=low + * upload spec file for rpm + * Git : slp/unmodified/icu + * Tag : icu_4.8-1slp8 + + -- Hyungdeuk Kim Sun, 18 Mar 2012 00:29:33 +0900 + +icu (4.8-1slp7) unstable; urgency=low + + * icu timezone upgrade to 2011n + * Git : slp/unmodified/icu + * Tag : icu_4.8-1slp7 + + -- Shivakumar B T Fri, 13 Jan 2012 09:39:33 +0900 + +icu (4.8-1slp6) unstable; urgency=low + + * icu library upgrade 4.8.1 + * Git : 165.213.180.234:slp/unmodified/icu + * Tag : icu_4.8-1slp6 + + -- Sangil Yoon Tue, 25 Oct 2011 09:39:33 +0900 + +icu (4.8-1slp5) unstable; urgency=low + + * add missed files + * Git : 165.213.180.234:slp/unmodified/icu + * Tag : icu_4.8-1slp5 + + -- Sangil Yoon Fri, 21 Oct 2011 10:40:39 +0900 + +icu (4.8-1slp4) unstable; urgency=low + + * rollback icu version to 4.6-1slp6 + * Git : 165.213.180.234:slp/unmodified/icu + * Tag : icu_4.8-1slp4 + + -- Sangil Yoon Fri, 21 Oct 2011 09:30:50 +0900 + +icu (4.8-1slp3) unstable; urgency=low + + * Git : 165.213.180.234:slp/unmodified/icu + * Tag : icu_4.8-1slp3 + * icu (4.8.1) TZDEFAULT modified to /opt/etc/localtime + + -- Seokkyu Jang Thu, 20 Oct 2011 09:15:05 +0900 + +icu (4.8-1slp2) unstable; urgency=low + + * Git : 165.213.180.234:slp/unmodified/icu + * Tag : icu_4.8-1slp2 + * icu (4.8.1) Added dbg package for ICU + + -- Seokkyu Jang Tue, 18 Oct 2011 04:41:07 +0900 + +icu (4.8-1slp1) unstable; urgency=low + + * Git : 165.213.180.234:slp/unmodified/icu + * Tag : icu_4.8-1slp1 + * icu (4.8.1) removed autogenerated makefiles,unwanted files + + -- Seokkyu Jang Wed, 05 Oct 2011 07:47:07 +0900 + +icu (4.8-1slp1) unstable; urgency=low + + * Git : 165.213.180.234:slp/unmodified/icu + * Tag : icu_4.8-1slp1 + * icu library upgrade (4.8.1) + + -- Seokkyu Jang Mon, 04 Oct 2011 09:00:07 +0900 + +icu (4.6-1slp6) unstable; urgency=low + + * Git : 165.213.180.234:slp/unmodified/icu + * Tag : icu_4.6-1slp6 + * ICU Timezone upgradation from 2011c to 2011h + + -- Seokkyu Jang Thu, 29 Sep 2011 16:47:05 +0900 + +icu (4.6-1slp5) unstable; urgency=low + + * Git : 165.213.180.234:slp/unmodified/icu + * Tag : icu_4.6-1slp5 + * Add ko locales (korean) + + -- Seokkyu Jang Wed, 10 Aug 2011 20:12:37 +0900 + +icu (4.6-1slp4) unstable; urgency=low + + * Git : 165.213.180.234:slp/unmodified/icu + * Tag : icu_4.6-1slp4 + + * Locale Resource Customization corresponding to SLP 15 languages + * Before : 435 locales , After : 123 locales + + -- Seokkyu Jang Wed, 10 Aug 2011 11:27:26 +0900 + +icu (4.6-1slp3) unstable; urgency=low + + * Git : 165.213.180.234:slp/unmodified/icu + * Tag : icu_4.6-1slp3 + + * Re-release + + -- Jaehun Lim Mon, 16 May 2011 09:51:24 +0900 + +icu (4.6-1slp1) unstable; urgency=low + + * Git : 165.213.180.234:/git/slp/unmodified/icu + * Tag : icu_4.6-1slp1 + + * icu library upgrade (4.6.1) + + -- Jaehun Lim Wed, 11 May 2011 19:25:07 +0900 + +icu (4.0-1slp2) unstable; urgency=low + + * Git : 165.213.180.234:/git/slp/unmodified/icu + * Tag : icu_4.0-1slp2 + + * Re-release icu + + -- Gyuyoung Kim Wed, 01 Dec 2010 08:16:18 +0900 + +icu (4.0-1slp1) unstable; urgency=low + + * Git : 165.213.180.234:/git/slp/unmodified/icu + * Tag : icu_4.0-1slp1 + + * Just version up + + -- Gyuyoung Kim Fri, 12 Nov 2010 14:16:25 +0900 + +icu (3.6-6slp2) unstable; urgency=low + + * change the package name + + -- SooChan Lim Tue, 30 Mar 2010 13:17:53 +0900 + +icu (3.6-5) unstable; urgency=low + + * To sync version between i386 and armel. No source changed. + + -- Jongwoo Chae Fri, 08 Jan 2010 10:09:50 +0900 + +icu (3.6-4) unstable; urgency=low + + * Location of license.html changed from ../license.html to + * ./license.html + + -- Jongwoo Chae Fri, 08 Jan 2010 09:30:52 +0900 + +icu (3.6-3) unstable; urgency=low + + * Previous version of this package has arm-built *.o files. + * Just remove them and upload again. + + -- Jongwoo Chae Fri, 08 Jan 2010 08:56:25 +0900 + +icu (3.6-2) unstable; urgency=low + + * fix dependency + + -- youmin Fri, 27 Nov 2009 18:01:56 +0900 + +icu (3.6-1) unstable; urgency=low + + * change arch to any + + -- youmin Fri, 27 Nov 2009 16:40:56 +0900 + +icu (3.6) unstable; urgency=low + * Initial Release. - * Git: pkgs/i/icu - * Tag: icu_4.8-1slp8 - - -- Seokkyu Jang Wed, 07 Dec 2011 12:58:04 +0900 + + -- youmin Fri, 20 Nov 2009 21:54:04 +0900 diff --git a/debian/copyright b/debian/copyright new file mode 100644 index 0000000..8534dc4 --- /dev/null +++ b/debian/copyright @@ -0,0 +1,26 @@ +This is icu, written and maintained by unknown +on Fri, 20 Nov 2009 21:54:04 +0900. + +The original source can always be found at: + ftp://ftp.debian.org/dists/unstable/main/source/ + +Copyright Holder: unknown + +License: + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this package; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + +On Debian systems, the complete text of the GNU General +Public License can be found in `/usr/share/common-licenses/GPL'. diff --git a/packaging/hack-atomics.diff b/packaging/hack-atomics.diff index 2a3a923..c20bb64 100644 --- a/packaging/hack-atomics.diff +++ b/packaging/hack-atomics.diff @@ -1,42 +1,11 @@ -3b1de280a4acb348b7d704ce568c4d82af112a13 diff --git a/configure.in b/configure.in -index 107912b..d9302de 100644 ---- a/source/configure.in -+++ b/source/configure.in -@@ -808,21 +808,22 @@ AC_SUBST(U_HAVE_PLACEMENT_NEW) - - # gcc atomic built-in functions check - # AC_TRY_LINK([], [int foo, bar; bar = __sync_val_compare_and_swap(&foo, 0, 1);],, --AC_LANG(C) --AC_MSG_CHECKING([for gcc atomic functions]) --AC_LINK_IFELSE([AC_LANG_PROGRAM( -- [[ -- void *p; -- int i; -- ]], -- [[ -- __sync_fetch_and_add(&i, 1); -- __sync_fetch_and_sub(&i, 1); -- __sync_val_compare_and_swap(&p, 0, 0); -- ]] --)], --[U_HAVE_GCC_ATOMICS=1; AC_MSG_RESULT([yes])], --[U_HAVE_GCC_ATOMICS=0; AC_MSG_RESULT([no])]) -+dnl AC_LANG(C) -+dnl AC_MSG_CHECKING([for gcc atomic functions]) -+dnl AC_LINK_IFELSE([AC_LANG_PROGRAM( -+dnl [[ -+dnl void *p; -+dnl int i; -+dnl ]], -+dnl [[ -+dnl __sync_fetch_and_add(&i, 1); -+dnl __sync_fetch_and_sub(&i, 1); -+dnl __sync_val_compare_and_swap(&p, 0, 0); -+dnl ]] -+dnl )], -+dnl [U_HAVE_GCC_ATOMICS=1; AC_MSG_RESULT([yes])], -+dnl [U_HAVE_GCC_ATOMICS=0; AC_MSG_RESULT([no])]) +index 107912b..aad44c8 100644 +--- a/configure.in ++++ b/configure.in +@@ -823,6 +823,7 @@ AC_LINK_IFELSE([AC_LANG_PROGRAM( + )], + [U_HAVE_GCC_ATOMICS=1; AC_MSG_RESULT([yes])], + [U_HAVE_GCC_ATOMICS=0; AC_MSG_RESULT([no])]) +U_HAVE_GCC_ATOMICS=0 AC_SUBST(U_HAVE_GCC_ATOMICS) diff --git a/packaging/icu.spec b/packaging/icu.spec index 299bcb3..5943321 100644 --- a/packaging/icu.spec +++ b/packaging/icu.spec @@ -64,7 +64,7 @@ rm -rf $RPM_BUILD_ROOT %files %files -n lib%{name} -%{_libdir}/*.so.* +%{_libdir}/*.so* %{_bindir}/derb %{_bindir}/genbrk %{_bindir}/gencfu -- 2.7.4