organicmaps/icu
13
Fork 0
mirror of https://github.com/unicode-org/icu.git synced 2025-04-06 05:55:35 +00:00
Code Issues 1 Projects Releases Wiki Activity Actions 11

ICU-96 Fixed Collation tests

Browse source 
X-SVN-Rev: 3914
This commit is contained in:
Ram Viswanadha 2001-03-06 03:42:35 +00:00
parent 8a59268b64
commit 439b875346
22 changed files with 21 additions and 363 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

8
icu4c/source/test/cintltst/callcoll.c
View file

@ -35,6 +35,7 @@
#include "unicode/utypes.h"
#include "unicode/ucol.h"
#include "unicode/uloc.h"
#include "cstring.h"
#include "cintltst.h"
#include "ccolltst.h"
#include "callcoll.h"
@ -413,10 +414,10 @@ void addAllCollTest(TestNode** root)
addTest(root, &TestJB581, "tscoll/callcoll/TestJB581");
}
static void doTest(UCollator* myCollation, const UChar source[], const UChar target[], UCollationResult result)
void doTest(UCollator* myCollation, const UChar source[], const UChar target[], UCollationResult result)
{
int32_t sortklen1, sortklen2, sortklenmax, sortklenmin;
int32_t temp;
int temp=0;
UCollationResult compareResult, keyResult, incResult;
uint8_t *sortKey1, *sortKey2;
@ -434,8 +435,7 @@ static void doTest(UCollator* myCollation, const UChar source[], const UChar tar
sortKey2=(uint8_t*)malloc(sizeof(uint8_t) * (sortklenmax+1));
ucol_getSortKey(myCollation, target, u_strlen(target), sortKey2, sortklen2+1);
temp= memcmp(sortKey1, sortKey2, sortklenmin);
temp= uprv_strcmp(sortKey1, sortKey2);/*memcmp(sortKey1, sortKey2,sortklenmax);*/
if(temp < 0) keyResult=UCOL_LESS;
else if(temp > 0) keyResult= UCOL_GREATER;
else keyResult = UCOL_EQUAL;

2
icu4c/source/test/cintltst/callcoll.h
View file

@ -28,7 +28,7 @@
#define MAX_TOKEN_LEN 128
/* tests comparison of custom collation with different strengths */
static void doTest(UCollator*, const UChar* source, const UChar* target, UCollationResult result);
void doTest(UCollator*, const UChar* source, const UChar* target, UCollationResult result);
/* perform test with strength PRIMARY */
static void TestPrimary(void);

33
icu4c/source/test/cintltst/cdantst.c
View file

@ -26,6 +26,7 @@
#include "cintltst.h"
#include "ccolltst.h"
#include "cdantst.h"
#include "callcoll.h"
#include "unicode/ustring.h"
static UCollator *myCollation;
@ -189,38 +190,6 @@ void addDanishCollTest(TestNode** root)
static void doTest(UCollator* myCollation, const UChar source[], const UChar target[], UCollationResult result)
{
int32_t sortklen1, sortklen2, sortklenmax, sortklenmin;
int32_t temp;
UCollationResult compareResult, keyResult, incResult;
uint8_t *sortKey1, *sortKey2;
compareResult = ucol_strcoll(myCollation, source, u_strlen(source), target, u_strlen(target));
incResult = ctst_strcollTestIncremental(myCollation, source, u_strlen(source), target, u_strlen(target));
sortklen1=ucol_getSortKey(myCollation, source, u_strlen(source), NULL, 0);
sortklen2=ucol_getSortKey(myCollation, target, u_strlen(target), NULL, 0);
sortklenmax = (sortklen1>sortklen2?sortklen1:sortklen2);
sortklenmin = (sortklen1<sortklen2?sortklen1:sortklen2);
sortKey1=(uint8_t*)malloc(sizeof(uint8_t) * (sortklenmax+1));
ucol_getSortKey(myCollation, source, u_strlen(source), sortKey1, sortklen1+1);
sortKey2=(uint8_t*)malloc(sizeof(uint8_t) * (sortklenmax+1));
ucol_getSortKey(myCollation, target, u_strlen(target), sortKey2, sortklen2+1);
temp= memcmp(sortKey1, sortKey2, sortklenmin);
if(temp < 0) keyResult=UCOL_LESS;
else if(temp > 0) keyResult= UCOL_GREATER;
else keyResult = UCOL_EQUAL;
reportCResult( source, target, sortKey1, sortKey2, compareResult, keyResult, incResult, result );
free(sortKey1);
free(sortKey2);
}
static void TestTertiary( )
{

3
icu4c/source/test/cintltst/cdantst.h
View file

@ -26,9 +26,6 @@
#define MAX_TOKEN_LEN 128
/*main test routine, tests comparisons for a set of strings against sets of expected results */
static void doTest(UCollator*, const UChar source[], const UChar target[], UCollationResult result);
/* performs test with strength PRIMARY */
static void TestPrimary(void);

33
icu4c/source/test/cintltst/cdetst.c
View file

@ -25,6 +25,7 @@
#include "cintltst.h"
#include "cdetst.h"
#include "ccolltst.h"
#include "callcoll.h"
#include "unicode/ustring.h"
#include "string.h"
@ -92,38 +93,6 @@ void addGermanCollTest(TestNode** root)
}
static void doTest(UCollator* myCollation, const UChar source[], const UChar target[], UCollationResult result)
{
int32_t sortklen1, sortklen2, sortklenmax, sortklenmin;
int32_t temp;
UCollationResult compareResult, keyResult, incResult;
uint8_t *sortKey1, *sortKey2;
compareResult = ucol_strcoll(myCollation, source, u_strlen(source), target, u_strlen(target));
incResult = ctst_strcollTestIncremental(myCollation, source, u_strlen(source), target, u_strlen(target));
sortklen1=ucol_getSortKey(myCollation, source, u_strlen(source), NULL, 0);
sortklen2=ucol_getSortKey(myCollation, target, u_strlen(target), NULL, 0);
sortklenmax = (sortklen1>sortklen2?sortklen1:sortklen2);
sortklenmin = (sortklen1<sortklen2?sortklen1:sortklen2);
sortKey1=(uint8_t*)malloc(sizeof(uint8_t) * (sortklenmax+1));
ucol_getSortKey(myCollation, source, u_strlen(source), sortKey1, sortklen1+1);
sortKey2=(uint8_t*)malloc(sizeof(uint8_t) * (sortklenmax+1));
ucol_getSortKey(myCollation, target, u_strlen(target), sortKey2, sortklen2+1);
temp= memcmp(sortKey1, sortKey2, sortklenmin);
if(temp < 0) keyResult=UCOL_LESS;
else if(temp > 0) keyResult= UCOL_GREATER;
else keyResult = UCOL_EQUAL;
reportCResult( source, target, sortKey1, sortKey2, compareResult, keyResult, incResult, result );
free(sortKey1);
free(sortKey2);
}
static void TestTertiary( )
{

6
icu4c/source/test/cintltst/cdetst.h
View file

@ -27,13 +27,9 @@
#define MAX_TOKEN_LEN 128
/* main test routine, tests comparisons for a set of strings against sets of expected results*/
static void doTest(UCollator*, const UChar source[], const UChar target[], UCollationResult result);
/* performs test with strength PRIMARY */
static void TestPrimary(void);
static void TestPrimary(void);
/* perform test with strength TERTIARY */
static void TestTertiary(void);

32
icu4c/source/test/cintltst/cestst.c
View file

@ -25,6 +25,7 @@
#include "cintltst.h"
#include "cestst.h"
#include "ccolltst.h"
#include "callcoll.h"
#include "unicode/ustring.h"
#include "string.h"
@ -76,37 +77,6 @@ void addSpanishCollTest(TestNode** root)
}
static void doTest(UCollator* myCollation, const UChar source[], const UChar target[], UCollationResult result)
{
int32_t sortklen1, sortklen2, sortklenmax, sortklenmin;
int32_t temp;
UCollationResult compareResult, keyResult, incResult;
uint8_t *sortKey1, *sortKey2;
compareResult = ucol_strcoll(myCollation, source, u_strlen(source), target, u_strlen(target));
incResult = ctst_strcollTestIncremental(myCollation, source, u_strlen(source), target, u_strlen(target));
sortklen1=ucol_getSortKey(myCollation, source, u_strlen(source), NULL, 0);
sortklen2=ucol_getSortKey(myCollation, target, u_strlen(target), NULL, 0);
sortklenmax = (sortklen1>sortklen2?sortklen1:sortklen2);
sortklenmin = (sortklen1<sortklen2?sortklen1:sortklen2);
sortKey1=(uint8_t*)malloc(sizeof(uint8_t) * (sortklenmax+1));
ucol_getSortKey(myCollation, source, u_strlen(source), sortKey1, sortklen1+1);
sortKey2=(uint8_t*)malloc(sizeof(uint8_t) * (sortklenmax+1));
ucol_getSortKey(myCollation, target, u_strlen(target), sortKey2, sortklen2+1);
temp= memcmp(sortKey1, sortKey2, sortklenmin);
if(temp < 0) keyResult=UCOL_LESS;
else if(temp > 0) keyResult= UCOL_GREATER;
else keyResult = UCOL_EQUAL;
reportCResult( source, target, sortKey1, sortKey2, compareResult, keyResult, incResult, result );
free(sortKey1);
free(sortKey2);
}
static void TestTertiary( )
{

4
icu4c/source/test/cintltst/cestst.h
View file

@ -27,9 +27,7 @@
#define MAX_TOKEN_LEN 128
/* main test routine, tests comparisons for a set of strings against sets of expected results*/
static void doTest(UCollator*, const UChar* source, const UChar* target, UCollationResult result);
/* perform test with strength SECONDARY */
static void TestPrimary(void);

32
icu4c/source/test/cintltst/cfintst.c
View file

@ -24,6 +24,7 @@
#include "unicode/uloc.h"
#include "cintltst.h"
#include "ccolltst.h"
#include "callcoll.h"
#include "cfintst.h"
#include "unicode/ustring.h"
#include "string.h"
@ -67,37 +68,6 @@ void addFinnishCollTest(TestNode** root)
}
static void doTest(UCollator* myCollation, const UChar source[], const UChar target[], UCollationResult result)
{
int32_t sortklen1, sortklen2, sortklenmax, sortklenmin;
int32_t temp;
UCollationResult compareResult, keyResult, incResult;
uint8_t *sortKey1, *sortKey2;
compareResult = ucol_strcoll(myCollation, source, u_strlen(source), target, u_strlen(target));
incResult = ctst_strcollTestIncremental(myCollation, source, u_strlen(source), target, u_strlen(target));
sortklen1=ucol_getSortKey(myCollation, source, u_strlen(source), NULL, 0);
sortklen2=ucol_getSortKey(myCollation, target, u_strlen(target), NULL, 0);
sortklenmax = (sortklen1>sortklen2?sortklen1:sortklen2);
sortklenmin = (sortklen1<sortklen2?sortklen1:sortklen2);
sortKey1=(uint8_t*)malloc(sizeof(uint8_t) * (sortklenmax+1));
ucol_getSortKey(myCollation, source, u_strlen(source), sortKey1, sortklen1+1);
sortKey2=(uint8_t*)malloc(sizeof(uint8_t) * (sortklenmax+1));
ucol_getSortKey(myCollation, target, u_strlen(target), sortKey2, sortklen2+1);
temp= memcmp(sortKey1, sortKey2, sortklenmin);
if(temp < 0) keyResult=UCOL_LESS;
else if(temp > 0) keyResult= UCOL_GREATER;
else keyResult = UCOL_EQUAL;
reportCResult( source, target, sortKey1, sortKey2, compareResult, keyResult, incResult, result );
free(sortKey1);
free(sortKey2);
}
static void TestTertiary( )
{

2
icu4c/source/test/cintltst/cfintst.h
View file

@ -27,8 +27,6 @@
#define MAX_TOKEN_LEN 128
/* main test routine, tests comparisons for a set of strings against sets of expected results*/
static void doTest(UCollator*, const UChar* source, const UChar* target, UCollationResult result);
/* perform test with strength SECONDARY*/
static void TestPrimary(void);

35
icu4c/source/test/cintltst/cfrtst.c
View file

@ -24,6 +24,7 @@
#include "unicode/uloc.h"
#include "cintltst.h"
#include "ccolltst.h"
#include "callcoll.h"
#include "cfrtst.h"
#include "unicode/ustring.h"
#include "string.h"
@ -136,40 +137,6 @@ void addFrenchCollTest(TestNode** root)
}
static void doTest(UCollator* myCollation, const UChar source[], const UChar target[], UCollationResult result)
{
int32_t sortklen1, sortklen2, sortklenmax, sortklenmin;
int32_t temp;
UCollationResult compareResult, keyResult, incResult;
uint8_t *sortKey1, *sortKey2;
compareResult = ucol_strcoll(myCollation, source, u_strlen(source), target, u_strlen(target));
incResult = ctst_strcollTestIncremental(myCollation, source, u_strlen(source), target, u_strlen(target));
sortklen1=ucol_getSortKey(myCollation, source, u_strlen(source), NULL, 0);
sortklen2=ucol_getSortKey(myCollation, target, u_strlen(target), NULL, 0);
sortklenmax = (sortklen1>sortklen2?sortklen1:sortklen2);
sortklenmin = (sortklen1<sortklen2?sortklen1:sortklen2);
sortKey1=(uint8_t*)malloc(sizeof(uint8_t) * (sortklenmax+1));
ucol_getSortKey(myCollation, source, u_strlen(source), sortKey1, sortklen1+1);
sortKey2=(uint8_t*)malloc(sizeof(uint8_t) * (sortklenmax+1));
ucol_getSortKey(myCollation, target, u_strlen(target), sortKey2, sortklen2+1);
temp= memcmp(sortKey1, sortKey2, sortklenmin);
if(temp < 0)
keyResult=UCOL_LESS;
else if(temp > 0)
keyResult= UCOL_GREATER;
else
keyResult = UCOL_EQUAL;
reportCResult( source, target, sortKey1, sortKey2, compareResult, keyResult, incResult, result );
free(sortKey1);
free(sortKey2);
}
static void TestTertiary( )
{

3
icu4c/source/test/cintltst/cfrtst.h
View file

@ -27,9 +27,6 @@
#define MAX_TOKEN_LEN 128
/*main test routine, tests comparisons for a set of strings against sets of expected results*/
static void doTest(UCollator*, const UChar* source, const UChar* target, UCollationResult result);
/* performs Extra tests*/
static void TestExtra(void);

33
icu4c/source/test/cintltst/cg7coll.c
View file

@ -43,6 +43,7 @@
#include "cintltst.h"
#include "cg7coll.h"
#include "ccolltst.h"
#include "callcoll.h"
#include "unicode/ustring.h"
@ -160,38 +161,6 @@ void addRuleBasedCollTest(TestNode** root)
}
static void doTest(UCollator *myCollation, const UChar source[], const UChar target[], UCollationResult result)
{
int32_t sortklen1, sortklen2, sortklenmax, sortklenmin;
int32_t temp;
UCollationResult compareResult, keyResult, incResult;
uint8_t *sortKey1, *sortKey2;
compareResult = ucol_strcoll(myCollation, source, u_strlen(source), target, u_strlen(target));
incResult = ctst_strcollTestIncremental(myCollation, source, u_strlen(source), target, u_strlen(target));
sortklen1=ucol_getSortKey(myCollation, source, u_strlen(source), NULL, 0);
sortklen2=ucol_getSortKey(myCollation, target, u_strlen(target), NULL, 0);
sortklenmax = (sortklen1>sortklen2?sortklen1:sortklen2);
sortklenmin = (sortklen1<sortklen2?sortklen1:sortklen2);
sortKey1=(uint8_t*)malloc(sizeof(uint8_t) * (sortklenmax+1));
ucol_getSortKey(myCollation, source, u_strlen(source), sortKey1, sortklen1+1);
sortKey2=(uint8_t*)malloc(sizeof(uint8_t) * (sortklenmax+1));
ucol_getSortKey(myCollation, target, u_strlen(target), sortKey2, sortklen2+1);
temp= memcmp(sortKey1, sortKey2, sortklenmin);
if(temp < 0) keyResult=UCOL_LESS;
else if(temp > 0) keyResult= UCOL_GREATER;
else keyResult = UCOL_EQUAL;
reportCResult( source, target, sortKey1, sortKey2, compareResult, keyResult, incResult, result );
free(sortKey1);
free(sortKey2);
}
static void TestG7Locales()
{
UCollator *myCollation, *tblColl1;

5
icu4c/source/test/cintltst/cg7coll.h
View file

@ -45,10 +45,7 @@
#define FIXEDTESTSET 15
#define TOTALTESTSET 30
/* main test routine, tests comparisons for a set of strings against sets of expected results */
static void doTest(UCollator *myCollation, const UChar* source, const UChar* target, UCollationResult result);
/* perform test for G7 locales */
static void TestG7Locales(void);

36
icu4c/source/test/cintltst/cjaptst.c
View file

@ -24,6 +24,7 @@
#include "unicode/uloc.h"
#include "cintltst.h"
#include "ccolltst.h"
#include "callcoll.h"
#include "cjaptst.h"
#include "unicode/ustring.h"
#include "string.h"
@ -79,41 +80,6 @@ void addKannaCollTest(TestNode** root)
}
static void doTest(UCollator* myCollation, const UChar source[], const UChar target[], UCollationResult result)
{
int32_t sortklen1, sortklen2, sortklenmax, sortklenmin;
int32_t temp;
UCollationResult compareResult, keyResult, incResult;
uint8_t *sortKey1, *sortKey2;
compareResult = ucol_strcoll(myCollation, source, u_strlen(source), target, u_strlen(target));
incResult = ctst_strcollTestIncremental(myCollation, source, u_strlen(source), target, u_strlen(target));
sortklen1=ucol_getSortKey(myCollation, source, u_strlen(source), NULL, 0);
sortklen2=ucol_getSortKey(myCollation, target, u_strlen(target), NULL, 0);
sortklenmax = (sortklen1>sortklen2?sortklen1:sortklen2);
sortklenmin = (sortklen1<sortklen2?sortklen1:sortklen2);
sortKey1=(uint8_t*)malloc(sizeof(uint8_t) * (sortklenmax+1));
ucol_getSortKey(myCollation, source, u_strlen(source), sortKey1, sortklen1+1);
sortKey2=(uint8_t*)malloc(sizeof(uint8_t) * (sortklenmax+1));
ucol_getSortKey(myCollation, target, u_strlen(target), sortKey2, sortklen2+1);
temp= memcmp(sortKey1, sortKey2, sortklenmin);
if(temp < 0)
keyResult=UCOL_LESS;
else if(temp > 0)
keyResult= UCOL_GREATER;
else
keyResult = UCOL_EQUAL;
reportCResult( source, target, sortKey1, sortKey2, compareResult, keyResult, incResult, result );
free(sortKey1);
free(sortKey2);
}
static void TestTertiary( )
{

6
icu4c/source/test/cintltst/cjaptst.h
View file

@ -28,11 +28,7 @@
#define MAX_TOKEN_LEN 128
/*main test routine, tests comparisons for a set of strings against sets of expected results*/
static void doTest(UCollator*, const UChar* source, const UChar* target, UCollationResult result);
/*perform test with strength TERTIARY*/
/*perform test with strength TERTIARY*/
static void TestTertiary(void);

34
icu4c/source/test/cintltst/cmsccoll.c
View file

@ -22,6 +22,7 @@
#include "cintltst.h"
#include "cdetst.h"
#include "ccolltst.h"
#include "callcoll.h"
#include "unicode/ustring.h"
#include "string.h"
@ -112,36 +113,3 @@ void addMiscCollTest(TestNode** root)
}
static void doTest(UCollator* myCollation, const UChar source[], const UChar target[], UCollationResult result)
{
int32_t sortklen1, sortklen2, sortklenmax, sortklenmin;
int32_t temp;
UCollationResult compareResult, keyResult, incResult;
uint8_t *sortKey1, *sortKey2;
compareResult = ucol_strcoll(myCollation, source, u_strlen(source), target, u_strlen(target));
incResult = ctst_strcollTestIncremental(myCollation, source, u_strlen(source), target, u_strlen(target));
sortklen1=ucol_getSortKey(myCollation, source, u_strlen(source), NULL, 0);
sortklen2=ucol_getSortKey(myCollation, target, u_strlen(target), NULL, 0);
sortklenmax = (sortklen1>sortklen2?sortklen1:sortklen2);
sortklenmin = (sortklen1<sortklen2?sortklen1:sortklen2);
sortKey1=(uint8_t*)malloc(sizeof(uint8_t) * (sortklenmax+1));
ucol_getSortKey(myCollation, source, u_strlen(source), sortKey1, sortklen1+1);
sortKey2=(uint8_t*)malloc(sizeof(uint8_t) * (sortklenmax+1));
ucol_getSortKey(myCollation, target, u_strlen(target), sortKey2, sortklen2+1);
temp= memcmp(sortKey1, sortKey2, sortklenmin);
if(temp < 0) keyResult=UCOL_LESS;
else if(temp > 0) keyResult= UCOL_GREATER;
else keyResult = UCOL_EQUAL;
reportCResult( source, target, sortKey1, sortKey2, compareResult, keyResult, incResult, result );
free(sortKey1);
free(sortKey2);
}

33
icu4c/source/test/cintltst/cturtst.c
View file

@ -24,6 +24,7 @@
#include "unicode/uloc.h"
#include "cintltst.h"
#include "ccolltst.h"
#include "callcoll.h"
#include "cturtst.h"
#include "unicode/ustring.h"
#include "string.h"
@ -83,38 +84,6 @@ void addTurkishCollTest(TestNode** root)
}
static void doTest(UCollator* myCollation, const UChar source[], const UChar target[], UCollationResult result)
{
int32_t sortklen1, sortklen2, sortklenmax, sortklenmin;
int32_t temp;
UCollationResult compareResult, keyResult, incResult;
uint8_t *sortKey1, *sortKey2;
compareResult = ucol_strcoll(myCollation, source, u_strlen(source), target, u_strlen(target));
incResult = ctst_strcollTestIncremental(myCollation, source, u_strlen(source), target, u_strlen(target));
sortklen1=ucol_getSortKey(myCollation, source, u_strlen(source), NULL, 0);
sortklen2=ucol_getSortKey(myCollation, target, u_strlen(target), NULL, 0);
sortklenmax = (sortklen1>sortklen2?sortklen1:sortklen2);
sortklenmin = (sortklen1<sortklen2?sortklen1:sortklen2);
sortKey1=(uint8_t*)malloc(sizeof(uint8_t) * (sortklenmax+1));
ucol_getSortKey(myCollation, source, u_strlen(source), sortKey1, sortklen1+1);
sortKey2=(uint8_t*)malloc(sizeof(uint8_t) * (sortklenmax+1));
ucol_getSortKey(myCollation, target, u_strlen(target), sortKey2, sortklen2+1);
temp= memcmp(sortKey1, sortKey2, sortklenmin);
if(temp < 0) keyResult=UCOL_LESS;
else if(temp > 0) keyResult= UCOL_GREATER;
else keyResult = UCOL_EQUAL;
reportCResult( source, target, sortKey1, sortKey2, compareResult, keyResult, incResult, result );
free(sortKey1);
free(sortKey2);
}
static void TestTertiary( )
{

3
icu4c/source/test/cintltst/cturtst.h
View file

@ -27,9 +27,6 @@
#define MAX_TOKEN_LEN 128
/* main test routine, tests comparisons for a set of strings against sets of expected results */
static void doTest(UCollator*, const UChar* source, const UChar* target, UCollationResult result);
/*perform test with strength PRIMARY */
static void TestPrimary(void);
/* perform test with strength TERTIARY */

33
icu4c/source/test/cintltst/encoll.c
View file

@ -26,6 +26,7 @@
#include "cintltst.h"
#include "encoll.h"
#include "ccolltst.h"
#include "callcoll.h"
#include "unicode/ustring.h"
static UCollator *myCollation = NULL;
@ -254,38 +255,6 @@ void addEnglishCollTest(TestNode** root)
}
static void doTest(UCollator* myCollation, const UChar source[], const UChar target[], UCollationResult result)
{
int32_t sortklen1, sortklen2, sortklenmax, sortklenmin;
int32_t temp;
UCollationResult compareResult, keyResult, incResult;
uint8_t *sortKey1, *sortKey2;
compareResult = ucol_strcoll(myCollation, source, u_strlen(source), target, u_strlen(target));
incResult = ctst_strcollTestIncremental(myCollation, source, u_strlen(source), target, u_strlen(target));
sortklen1=ucol_getSortKey(myCollation, source, u_strlen(source), NULL, 0);
sortklen2=ucol_getSortKey(myCollation, target, u_strlen(target), NULL, 0);
sortklenmax = (sortklen1>sortklen2?sortklen1:sortklen2);
sortklenmin = (sortklen1<sortklen2?sortklen1:sortklen2);
sortKey1=(uint8_t*)malloc(sizeof(uint8_t) * (sortklenmax+1));
ucol_getSortKey(myCollation, source, u_strlen(source), sortKey1, sortklen1+1);
sortKey2=(uint8_t*)malloc(sizeof(uint8_t) * (sortklenmax+1));
ucol_getSortKey(myCollation, target, u_strlen(target), sortKey2, sortklen2+1);
temp= memcmp(sortKey1, sortKey2, sortklenmin);
if(temp < 0) keyResult=UCOL_LESS;
else if(temp > 0) keyResult= UCOL_GREATER;
else keyResult = UCOL_EQUAL;
reportCResult( source, target, sortKey1, sortKey2, compareResult, keyResult, incResult, result );
free(sortKey1);
free(sortKey2);
}
static void TestTertiary( )
{
int32_t testMoreSize;

4
icu4c/source/test/cintltst/encoll.h
View file

@ -26,10 +26,6 @@
#define MAX_TOKEN_LEN 128
/* main test routine, tests comparisons for a set of strings against sets of expected results */
static void doTest( UCollator*, const UChar source[], const UChar target[], UCollationResult result);
/* performs test with strength PRIMARY */
static void TestPrimary(void);

4
icu4c/source/test/cintltst/nucnvtst.c
View file

@ -1821,7 +1821,7 @@ TestSmallTargetBuffer(const uint16_t* source, const UChar* sourceLimit,UConverte
UChar *uBuf,*test;
int32_t uBufSize = 120;
int len=0;
int i=1;
int i=2;
UErrorCode errorCode=U_ZERO_ERROR;
uBuf = (UChar*)malloc(uBufSize * sizeof(UChar)*5);
cBuf =(char*)malloc(uBufSize * sizeof(char) * 10);
@ -1937,7 +1937,7 @@ static void TestSmallSourceBuffer(const uint16_t* source, const UChar* sourceLim
UChar *uBuf,*test;
int32_t uBufSize = 120;
int len=0;
int i=1;
int i=2;
const UChar *temp = sourceLimit;
UErrorCode errorCode=U_ZERO_ERROR;
uBuf = (UChar*)malloc(uBufSize * sizeof(UChar)*5);