[sword-cvs] icu-sword/source/test/cintltst .cvsignore,1.2,1.3 Makefile.in,1.3,1.4 bocu1tst.c,NONE,1.1 callcoll.c,1.3,1.4 callcoll.h,1.2,1.3 calldata.h,NONE,1.1 calltest.c,1.2,1.3 capitst.c,1.3,1.4 capitst.h,1.2,1.3 cbiapts.c,1.2,1.3 cbiapts.h,1.2,1.3 cbididat.c,1.2,1.3 cbiditst.c,1.3,1.4 cbiditst.h,1.2,1.3 cbkittst.c,1.2,1.3 ccaltst.c,1.2,1.3 ccaltst.h,1.2,1.3 ccapitst.c,1.3,1.4 ccapitst.h,1.2,1.3 ccolltst.c,1.3,1.4 ccolltst.h,1.2,1.3 cconvtst.c,1.2,1.3 cctest.c,NONE,1.1 ccurrtst.c,1.2,1.3 ccurrtst.h,1.2,1.3 cdantst.c,1.2,1.3 cdantst.h,1.2,1.3 cdattst.c,1.2,1.3 cdattst.h,1.2,1.3 cdetst.c,1.2,1.3 cdetst.h,1.2,1.3 cdtdptst.c,1.2,1.3 cdtdptst.h,1.2,1.3 cdtrgtst.c,1.2,1.3 cdtrgtst.h,1.2,1.3 cestst.c,1.2,1.3 cestst.h,1.2,1.3 cfintst.c,1.2,1.3 cfintst.h,1.2,1.3 cformtst.c,1.2,1.3 cformtst.h,1.2,1.3 cfrtst.c,1.2,1.3 cfrtst.h,1.2,1.3 cg7coll.c,1.2,1.3 cg7coll.h,1.2,1.3 chashtst.c,1.3,1.4 cintltst.c,1.3,1.4 cintltst.dsp,1.2,1.3 cintltst.h,1.2,1.3 cintltst.vcproj,NONE,1.1 citertst.c,1.3,1.4 citertst.h,1.2,1.3 cjaptst.c,1.3,1.4 cjaptst.h,1.2,1.3 cloctst.c,1.3,1.4 cloctst.h,1.2,1.3 cmsccoll.c,1.5,1.6 cmsgtst.c,1.2,1.3 cmsgtst.h,1.2,1.3 cnmdptst.c,1.3,1.4 cnmdptst.h,1.2,1.3 cnormtst.c,1.3,1.4 cnormtst.h,1.2,1.3 cnumtst.c,1.3,1.4 cnumtst.h,1.2,1.3 colutil.c,NONE,1.1 cposxtst.c,NONE,1.1 cregrtst.c,1.2,1.3 cregrtst.h,1.2,1.3 crestst.c,1.3,1.4 crestst.h,1.2,1.3 creststn.c,1.3,1.4 creststn.h,1.2,1.3 cstrcase.c,NONE,1.1 cstrtest.c,1.2,1.3 ctstdep.c,1.4,1.5 cturtst.c,1.2,1.3 cturtst.h,1.2,1.3 cucdapi.c,NONE,1.1 cucdtst.c,1.4,1.5 cucdtst.h,1.2,1.3 custrtrn.c,1.3,1.4 custrtst.c,NONE,1.1 cutiltst.c,1.2,1.3 encoll.c,1.2,1.3 encoll.h,1.2,1.3 eurocreg.c,1.2,1.3 mstrmtst.c,1.2,1.3 nccbtst.c,1.3,1.4 nccbtst.h,1.2,1.3 ncnvfbts.c,1.2,1.3 ncnvfbts.h,1.2,1.3 ncnvtst.c,1.2,1.3 nucnvtst.c,1.3,1.4 nucnvtst.h,1.2,1.3 putiltst.c,1.3,1.4 stdnmtst.c,1.3,1.4 trietest.c,NONE,1.1 ucmptst.c,1.4,1.5 udatatst.c,1.4,1.5 uenumtst.c,NONE,1.1 usettest.c,NONE,1.1 usrchdat.c,1.2,1.3 usrchtst.c,1.3,1.4 utf16tst.c,1.3,1.4 utf8tst.c,1.2,1.3 utransts.c,1.3,1.4
sword@www.crosswire.org
sword@www.crosswire.org
Tue, 9 Sep 2003 19:43:35 -0700
- Previous message: [sword-cvs] icu-sword/source/tools/genprops .cvsignore,1.2,1.3 Makefile.in,1.3,1.4 genprops.8.in,NONE,1.1 genprops.c,1.3,1.4 genprops.dsp,1.2,1.3 genprops.h,1.2,1.3 genprops.vcproj,NONE,1.1 props2.c,NONE,1.1 propsvec.c,NONE,1.1 propsvec.h,NONE,1.1 store.c,1.2,1.3
- Next message: [sword-cvs] icu-sword/source/i18n/unicode calendar.h,1.3,1.4 choicfmt.h,1.2,1.3 coleitr.h,1.3,1.4 coll.h,1.3,1.4 datefmt.h,1.3,1.4 dcfmtsym.h,1.3,1.4 decimfmt.h,1.6,1.7 dtfmtsym.h,1.2,1.3 fieldpos.h,1.2,1.3 fmtable.h,1.2,1.3 format.h,1.2,1.3 gregocal.h,1.3,1.4 msgfmt.h,1.2,1.3 numfmt.h,1.3,1.4 rbnf.h,1.3,1.4 regex.h,NONE,1.1 search.h,1.4,1.5 simpletz.h,1.2,1.3 smpdtfmt.h,1.3,1.4 sortkey.h,1.3,1.4 stsearch.h,1.4,1.5 tblcoll.h,1.3,1.4 timezone.h,1.3,1.4 translit.h,1.4,1.5 ucal.h,1.3,1.4 ucol.h,1.4,1.5 ucoleitr.h,1.3,1.4 ucurr.h,NONE,1.1 udat.h,1.4,1.5 umsg.h,1.3,1.4 unifltlg.h,1.3,1.4 unirepl.h,NONE,1.1 unum.h,1.4,1.5 usearch.h,1.3,1.4 utrans.h,1.4,1.5
- Messages sorted by:
[ date ]
[ thread ]
[ subject ]
[ author ]
Update of /usr/local/cvsroot/icu-sword/source/test/cintltst
In directory www:/tmp/cvs-serv19862/source/test/cintltst
Added Files:
.cvsignore Makefile.in bocu1tst.c callcoll.c callcoll.h
calldata.h calltest.c capitst.c capitst.h cbiapts.c cbiapts.h
cbididat.c cbiditst.c cbiditst.h cbkittst.c ccaltst.c
ccaltst.h ccapitst.c ccapitst.h ccolltst.c ccolltst.h
cconvtst.c cctest.c ccurrtst.c ccurrtst.h cdantst.c cdantst.h
cdattst.c cdattst.h cdetst.c cdetst.h cdtdptst.c cdtdptst.h
cdtrgtst.c cdtrgtst.h cestst.c cestst.h cfintst.c cfintst.h
cformtst.c cformtst.h cfrtst.c cfrtst.h cg7coll.c cg7coll.h
chashtst.c cintltst.c cintltst.dsp cintltst.h cintltst.vcproj
citertst.c citertst.h cjaptst.c cjaptst.h cloctst.c cloctst.h
cmsccoll.c cmsgtst.c cmsgtst.h cnmdptst.c cnmdptst.h
cnormtst.c cnormtst.h cnumtst.c cnumtst.h colutil.c cposxtst.c
cregrtst.c cregrtst.h crestst.c crestst.h creststn.c
creststn.h cstrcase.c cstrtest.c ctstdep.c cturtst.c cturtst.h
cucdapi.c cucdtst.c cucdtst.h custrtrn.c custrtst.c cutiltst.c
encoll.c encoll.h eurocreg.c mstrmtst.c nccbtst.c nccbtst.h
ncnvfbts.c ncnvfbts.h ncnvtst.c nucnvtst.c nucnvtst.h
putiltst.c stdnmtst.c trietest.c ucmptst.c udatatst.c
uenumtst.c usettest.c usrchdat.c usrchtst.c utf16tst.c
utf8tst.c utransts.c
Log Message:
ICU 2.6 commit
--- NEW FILE: bocu1tst.c ---
/*
******************************************************************************
*
* Copyright (C) 2002, International Business Machines
* Corporation and others. All Rights Reserved.
*
******************************************************************************
* file name: bocu1tst.c
* encoding: US-ASCII
* tab size: 8 (not used)
* indentation:4
*
* created on: 2002may27
* created by: Markus W. Scherer
*
* This is the reference implementation of BOCU-1,
* the MIME-friendly form of the Binary Ordered Compression for Unicode,
* taken directly from ### http://oss.software.ibm.com/cvs/icu/icuhtml/design/conversion/bocu1/
* The files bocu1.h and bocu1.c from the design folder are taken
[...975 lines suppressed...]
length=0;
for(i=1; length<5000; i+=7) {
if(i>=LENGTHOF(strings)) {
i-=LENGTHOF(strings);
}
u_memcpy(text+length, strings[i].s, strings[i].length);
length+=strings[i].length;
}
roundtripBOCU1(bocu1, 3, text, length);
ucnv_close(bocu1);
}
U_CFUNC void addBOCU1Tests(TestNode** root);
U_CFUNC void
addBOCU1Tests(TestNode** root) {
addTest(root, TestBOCU1RefDiff, "tsconv/bocu1tst/TestBOCU1RefDiff");
addTest(root, TestBOCU1, "tsconv/bocu1tst/TestBOCU1");
}
--- NEW FILE: calldata.h ---
/********************************************************************
* COPYRIGHT:
* Copyright (c) 1997-2003, International Business Machines Corporation and
* others. All Rights Reserved.
********************************************************************/
#ifndef COLLATION_TEST_DATA
#define COLLATION_TEST_DATA
#define COUNT_TEST_CASES 13
const UChar testSourceCases[][16] = {
{0x61, 0x62, 0x27, 0x63, 0},
{0x63, 0x6f, 0x2d, 0x6f, 0x70, 0},
{0x61, 0x62, 0},
{0x61, 0x6d, 0x70, 0x65, 0x72, 0x73, 0x61, 0x64, 0},
{0x61, 0x6c, 0x6c, 0},
{0x66, 0x6f, 0x75, 0x72, 0},
{0x66, 0x69, 0x76, 0x65, 0},
{0x31, 0},
{0x31, 0},
{0x31, 0}, /* 10 */
{0x32, 0},
{0x32, 0},
{0x48, 0x65, 0x6c, 0x6c, 0x6f, 0},
{0x61, 0x3c, 0x62, 0},
{0x61, 0x3c, 0x62, 0},
{0x61, 0x63, 0x63, 0},
{0x61, 0x63, 0x48, 0x63, 0}, /* simple test */
{0x70, 0x00EA, 0x63, 0x68, 0x65, 0},
{0x61, 0x62, 0x63, 0},
{0x61, 0x62, 0x63, 0}, /* 20 */
{0x61, 0x62, 0x63, 0},
{0x61, 0x62, 0x63, 0},
{0x61, 0x62, 0x63, 0},
{0x61, 0x00E6, 0x63, 0},
{0x61, 0x63, 0x48, 0x63, 0}, /* primary test */
{0x62, 0x6c, 0x61, 0x63, 0x6b, 0},
{0x66, 0x6f, 0x75, 0x72, 0},
{0x66, 0x69, 0x76, 0x65, 0},
{0x31, 0},
{0x61, 0x62, 0x63, 0}, /* 30 */
{0x61, 0x62, 0x63, 0},
{0x61, 0x62, 0x63, 0x48, 0},
{0x61, 0x62, 0x63, 0},
{0x61, 0x63, 0x48, 0x63, 0}, /* 34 */
{0x61, 0x63, 0x65, 0x30},
{0x31, 0x30},
{0x70, 0x00EA,0x30} /* 37 */
};
const UChar testTargetCases[][16] = {
{0x61, 0x62, 0x63, 0x27, 0},
{0x43, 0x4f, 0x4f, 0x50, 0},
{0x61, 0x62, 0x63, 0},
{0x26, 0},
{0x26, 0},
{0x34, 0},
{0x35, 0},
{0x6f, 0x6e, 0x65, 0},
{0x6e, 0x6e, 0x65, 0},
{0x70, 0x6e, 0x65, 0}, /* 10 */
{0x74, 0x77, 0x6f, 0},
{0x75, 0x77, 0x6f, 0},
{0x68, 0x65, 0x6c, 0x6c, 0x4f, 0},
{0x61, 0x3c, 0x3d, 0x62, 0},
{0x61, 0x62, 0x63, 0},
{0x61, 0x43, 0x48, 0x63, 0},
{0x61, 0x43, 0x48, 0x63, 0}, /* simple test */
{0x70, (UChar)0x00E9, 0x63, 0x68, 0x00E9, 0},
{0x61, 0x62, 0x63, 0},
{0x61, 0x42, 0x43, 0}, /* 20 */
{0x61, 0x62, 0x63, 0x68, 0},
{0x61, 0x62, 0x64, 0},
{(UChar)0x00E4, 0x62, 0x63, 0},
{0x61, (UChar)0x00C6, 0x63, 0},
{0x61, 0x43, 0x48, 0x63, 0}, /* primary test */
{0x62, 0x6c, 0x61, 0x63, 0x6b, 0x2d, 0x62, 0x69, 0x72, 0x64, 0},
{0x34, 0},
{0x35, 0},
{0x6f, 0x6e, 0x65, 0},
{0x61, 0x62, 0x63, 0},
{0x61, 0x42, 0x63, 0}, /* 30 */
{0x61, 0x62, 0x63, 0x68, 0},
{0x61, 0x62, 0x64, 0},
{0x61, 0x43, 0x48, 0x63, 0}, /* 34 */
{0x61, 0x63, 0x65, 0x30},
{0x31, 0x30},
{0x70, (UChar)0x00EB,0x30} /* 37 */
};
const UChar testCases[][4] =
{
{0x61, 0},
{0x41, 0},
{0x00e4, 0},
{0x00c4, 0},
{0x61, 0x65, 0},
{0x61, 0x45, 0},
{0x41, 0x65, 0},
{0x41, 0x45, 0},
{(UChar)0x00e6, 0},
{(UChar)0x00c6, 0},
{0x62, 0},
{0x63, 0},
{0x7a, 0}
};
#endif /* #ifndef COLLATION_TEST_DATA */
--- NEW FILE: cctest.c ---
/********************************************************************
* COPYRIGHT:
* Copyright (c) 1997-2003, International Business Machines Corporation and
* others. All Rights Reserved.
********************************************************************/
#include "unicode/ucnv.h"
#include "unicode/ucnv_err.h"
#include "cintltst.h"
#include "ustr_imp.h"
void TestFlushCache(void); /* keep gcc happy */
void TestFlushCache(void) {
UErrorCode err = U_ZERO_ERROR;
UConverter* someConverters[5];
int flushCount = 0;
/* flush the converter cache to get a consistent state before the flushing is tested */
ucnv_flushCache();
/*Testing ucnv_open()*/
/* Note: These converters have been chosen because they do NOT
encode the Latin characters (U+0041, ...), and therefore are
highly unlikely to be chosen as system default codepages */
someConverters[0] = ucnv_open("ibm-1047", &err);
if (U_FAILURE(err)) {
log_data_err("FAILURE! %s\n", myErrorName(err));
}
someConverters[1] = ucnv_open("ibm-1047", &err);
if (U_FAILURE(err)) {
log_data_err("FAILURE! %s\n", myErrorName(err));
}
someConverters[2] = ucnv_open("ibm-1047", &err);
if (U_FAILURE(err)) {
log_data_err("FAILURE! %s\n", myErrorName(err));
}
someConverters[3] = ucnv_open("gb18030", &err);
if (U_FAILURE(err)) {
log_data_err("FAILURE! %s\n", myErrorName(err));
}
someConverters[4] = ucnv_open("ibm-949", &err);
if (U_FAILURE(err)) {
log_data_err("FAILURE! %s\n", myErrorName(err));
}
/* Testing ucnv_flushCache() */
log_verbose("\n---Testing ucnv_flushCache...\n");
if ((flushCount=ucnv_flushCache())==0)
log_verbose("Flush cache ok\n");
else
log_data_err("Flush Cache failed [line %d], expect 0 got %d \n", __LINE__, flushCount);
/*testing ucnv_close() and ucnv_flushCache() */
ucnv_close(someConverters[0]);
ucnv_close(someConverters[1]);
if ((flushCount=ucnv_flushCache())==0)
log_verbose("Flush cache ok\n");
else
log_data_err("Flush Cache failed [line %d], expect 0 got %d \n", __LINE__, flushCount);
ucnv_close(someConverters[2]);
ucnv_close(someConverters[3]);
if ((flushCount=ucnv_flushCache())==2)
log_verbose("Flush cache ok\n"); /*because first, second and third are same */
else
log_data_err("Flush Cache failed line %d, got %d expected 2 or there is an error in ucnv_close()\n",
__LINE__,
flushCount);
ucnv_close(someConverters[4]);
if ( (flushCount=ucnv_flushCache())==1)
log_verbose("Flush cache ok\n");
else
log_data_err("Flush Cache failed line %d, expected 1 got %d \n", __LINE__, flushCount);
}
--- NEW FILE: cintltst.vcproj ---
<?xml version="1.0" encoding = "Windows-1252"?>
<VisualStudioProject
ProjectType="Visual C++"
Version="7.00"
Name="cintltst"
SccProjectName=""
SccLocalPath="">
<Platforms>
<Platform
Name="Win32"/>
</Platforms>
<Configurations>
<Configuration
Name="Debug|Win32"
OutputDirectory=".\Debug"
IntermediateDirectory=".\Debug"
ConfigurationType="1"
UseOfMFC="0"
ATLMinimizesCRunTimeLibraryUsage="FALSE"
CharacterSet="2">
<Tool
Name="VCCLCompilerTool"
Optimization="0"
ImproveFloatingPointConsistency="TRUE"
OptimizeForProcessor="2"
AdditionalIncludeDirectories="..\..\..\include,..\..\tools\ctestfw,..\..\common,..\..\i18n,..\..\tools\toolutil"
PreprocessorDefinitions="WIN32,_DEBUG,_CONSOLE"
BasicRuntimeChecks="3"
RuntimeLibrary="1"
DisableLanguageExtensions="TRUE"
PrecompiledHeaderFile=".\Debug/cintltst.pch"
AssemblerListingLocation=".\Debug/"
ObjectFile=".\Debug/"
ProgramDataBaseFileName=".\Debug/"
BrowseInformation="1"
WarningLevel="3"
SuppressStartupBanner="TRUE"
DebugInformationFormat="4"
CompileAs="0"/>
<Tool
Name="VCCustomBuildTool"/>
<Tool
Name="VCLinkerTool"
AdditionalOptions="/MACHINE:I386"
AdditionalDependencies="icuucd.lib icuind.lib icutud.lib ctestfwd.lib"
OutputFile=".\Debug/cintltst.exe"
LinkIncremental="1"
SuppressStartupBanner="TRUE"
AdditionalLibraryDirectories="..\..\..\lib"
GenerateDebugInformation="TRUE"
ProgramDatabaseFile=".\Debug/cintltst.pdb"
SubSystem="1"/>
<Tool
Name="VCMIDLTool"
TypeLibraryName=".\Debug/cintltst.tlb"/>
<Tool
Name="VCPostBuildEventTool"/>
<Tool
Name="VCPreBuildEventTool"/>
<Tool
Name="VCPreLinkEventTool"/>
<Tool
Name="VCResourceCompilerTool"
PreprocessorDefinitions="_DEBUG"
Culture="1033"/>
<Tool
Name="VCWebServiceProxyGeneratorTool"/>
<Tool
Name="VCWebDeploymentTool"/>
</Configuration>
<Configuration
Name="Release|Win32"
OutputDirectory=".\Release"
IntermediateDirectory=".\Release"
ConfigurationType="1"
UseOfMFC="0"
ATLMinimizesCRunTimeLibraryUsage="FALSE"
CharacterSet="2">
<Tool
Name="VCCLCompilerTool"
Optimization="0"
ImproveFloatingPointConsistency="TRUE"
AdditionalIncludeDirectories="..\..\..\include,..\..\tools\ctestfw,..\..\common,..\..\i18n,..\..\tools\toolutil"
PreprocessorDefinitions="WIN32,NDEBUG,_CONSOLE"
StringPooling="TRUE"
RuntimeLibrary="0"
EnableFunctionLevelLinking="TRUE"
DisableLanguageExtensions="TRUE"
PrecompiledHeaderFile=".\Release/cintltst.pch"
AssemblerListingLocation=".\Release/"
ObjectFile=".\Release/"
ProgramDataBaseFileName=".\Release/"
WarningLevel="3"
SuppressStartupBanner="TRUE"
DebugInformationFormat="4"
CompileAs="0"/>
<Tool
Name="VCCustomBuildTool"/>
<Tool
Name="VCLinkerTool"
AdditionalOptions="/MACHINE:I386"
AdditionalDependencies="icuuc.lib icuin.lib ctestfw.lib icutu.lib"
OutputFile=".\Release/cintltst.exe"
LinkIncremental="2"
SuppressStartupBanner="TRUE"
AdditionalLibraryDirectories="..\..\..\lib\"
GenerateDebugInformation="TRUE"
ProgramDatabaseFile=".\Release/cintltst.pdb"
SubSystem="1"/>
<Tool
Name="VCMIDLTool"
TypeLibraryName=".\Release/cintltst.tlb"/>
<Tool
Name="VCPostBuildEventTool"/>
<Tool
Name="VCPreBuildEventTool"/>
<Tool
Name="VCPreLinkEventTool"/>
<Tool
Name="VCResourceCompilerTool"
PreprocessorDefinitions="NDEBUG"
Culture="1033"/>
<Tool
Name="VCWebServiceProxyGeneratorTool"/>
<Tool
Name="VCWebDeploymentTool"/>
</Configuration>
</Configurations>
<Files>
<Filter
Name="bidi"
Filter="">
<File
RelativePath=".\cbididat.c">
</File>
<File
RelativePath=".\cbiditst.c">
</File>
<File
RelativePath=".\cbiditst.h">
</File>
</Filter>
<Filter
Name="break iteration"
Filter="">
<File
RelativePath=".\cbiapts.c">
</File>
<File
RelativePath=".\cbiapts.h">
</File>
<File
RelativePath=".\cbkittst.c">
</File>
<File
RelativePath=".\cregrtst.c">
</File>
<File
RelativePath=".\cregrtst.h">
</File>
</Filter>
<Filter
Name="collation"
Filter="">
<File
RelativePath=".\callcoll.c">
</File>
<File
RelativePath=".\callcoll.h">
</File>
<File
RelativePath=".\capitst.c">
</File>
<File
RelativePath=".\capitst.h">
</File>
<File
RelativePath=".\ccolltst.c">
</File>
<File
RelativePath=".\ccolltst.h">
</File>
<File
RelativePath=".\cctest.c">
</File>
<File
RelativePath=".\ccurrtst.c">
</File>
<File
RelativePath=".\ccurrtst.h">
</File>
<File
RelativePath=".\cdantst.c">
</File>
<File
RelativePath=".\cdantst.h">
</File>
<File
RelativePath=".\cdetst.c">
</File>
<File
RelativePath=".\cdetst.h">
</File>
<File
RelativePath=".\cestst.c">
</File>
<File
RelativePath=".\cestst.h">
</File>
<File
RelativePath=".\cfintst.c">
</File>
<File
RelativePath=".\cfintst.h">
</File>
<File
RelativePath=".\cfrtst.c">
</File>
<File
RelativePath=".\cfrtst.h">
</File>
<File
RelativePath=".\cg7coll.c">
</File>
<File
RelativePath=".\cg7coll.h">
</File>
<File
RelativePath=".\citertst.c">
</File>
<File
RelativePath=".\citertst.h">
</File>
<File
RelativePath=".\cjaptst.c">
</File>
<File
RelativePath=".\cjaptst.h">
</File>
<File
RelativePath=".\cmsccoll.c">
</File>
<File
RelativePath=".\colutil.c">
</File>
<File
RelativePath=".\cturtst.c">
</File>
<File
RelativePath=".\cturtst.h">
</File>
<File
RelativePath=".\encoll.c">
</File>
<File
RelativePath=".\encoll.h">
</File>
<File
RelativePath=".\usrchdat.c">
</File>
<File
RelativePath=".\usrchtst.c">
</File>
</Filter>
<Filter
Name="collections"
Filter="">
<File
RelativePath=".\chashtst.c">
</File>
<File
RelativePath=".\trietest.c">
</File>
<File
RelativePath=".\ucmptst.c">
</File>
<File
RelativePath=".\uenumtst.c">
</File>
</Filter>
<Filter
Name="conversion"
Filter="">
<File
RelativePath=".\bocu1tst.c">
</File>
<File
RelativePath=".\ccapitst.c">
</File>
<File
RelativePath=".\ccapitst.h">
</File>
<File
RelativePath=".\cconvtst.c">
</File>
<File
RelativePath=".\eurocreg.c">
</File>
<File
RelativePath=".\nccbtst.c">
</File>
<File
RelativePath=".\nccbtst.h">
</File>
<File
RelativePath=".\ncnvfbts.c">
</File>
<File
RelativePath=".\ncnvfbts.h">
</File>
<File
RelativePath=".\ncnvtst.c">
</File>
<File
RelativePath=".\nucnvtst.c">
</File>
<File
RelativePath=".\nucnvtst.h">
</File>
<File
RelativePath=".\stdnmtst.c">
</File>
</Filter>
<Filter
Name="data & memory"
Filter="">
<File
RelativePath=".\udatatst.c">
<FileConfiguration
Name="Debug|Win32">
<Tool
Name="VCCLCompilerTool"
DisableLanguageExtensions="FALSE"/>
</FileConfiguration>
<FileConfiguration
Name="Release|Win32">
<Tool
Name="VCCLCompilerTool"
DisableLanguageExtensions="FALSE"/>
</FileConfiguration>
</File>
</Filter>
<Filter
Name="formatting"
Filter="">
<File
RelativePath=".\calltest.c">
</File>
<File
RelativePath=".\ccaltst.c">
</File>
<File
RelativePath=".\ccaltst.h">
</File>
<File
RelativePath=".\cdattst.c">
</File>
<File
RelativePath=".\cdattst.h">
</File>
<File
RelativePath=".\cdtdptst.c">
</File>
<File
RelativePath=".\cdtdptst.h">
</File>
<File
RelativePath=".\cdtrgtst.c">
</File>
<File
RelativePath=".\cdtrgtst.h">
</File>
<File
RelativePath=".\cformtst.c">
</File>
<File
RelativePath=".\cformtst.h">
</File>
<File
RelativePath=".\cmsgtst.c">
</File>
<File
RelativePath=".\cmsgtst.h">
</File>
<File
RelativePath=".\cnmdptst.c">
</File>
<File
RelativePath=".\cnmdptst.h">
</File>
<File
RelativePath=".\cnumtst.c">
</File>
<File
RelativePath=".\cnumtst.h">
</File>
</Filter>
<Filter
Name="locales & resources"
Filter="">
<File
RelativePath=".\cloctst.c">
</File>
<File
RelativePath=".\cloctst.h">
</File>
<File
RelativePath=".\cposxtst.c">
</File>
<File
RelativePath=".\crestst.c">
</File>
<File
RelativePath=".\crestst.h">
</File>
<File
RelativePath=".\creststn.c">
</File>
<File
RelativePath=".\creststn.h">
</File>
</Filter>
<Filter
Name="misc"
Filter="">
<File
RelativePath=".\cintltst.c">
</File>
<File
RelativePath=".\cintltst.h">
</File>
<File
RelativePath=".\ctstdep.c">
</File>
<File
RelativePath=".\cutiltst.c">
</File>
<File
RelativePath=".\mstrmtst.c">
</File>
<File
RelativePath=".\putiltst.c">
</File>
</Filter>
<Filter
Name="normalization"
Filter="">
<File
RelativePath=".\cnormtst.c">
</File>
<File
RelativePath=".\cnormtst.h">
</File>
</Filter>
<Filter
Name="properties & sets"
Filter="">
<File
RelativePath=".\cucdapi.c">
</File>
<File
RelativePath=".\cucdtst.c">
</File>
<File
RelativePath=".\cucdtst.h">
</File>
<File
RelativePath=".\usettest.c">
</File>
</Filter>
<Filter
Name="strings"
Filter="">
<File
RelativePath=".\cstrcase.c">
</File>
<File
RelativePath=".\cstrtest.c">
</File>
<File
RelativePath=".\custrtrn.c">
</File>
<File
RelativePath=".\custrtst.c">
</File>
<File
RelativePath=".\utf16tst.c">
</File>
<File
RelativePath=".\utf8tst.c">
</File>
</Filter>
<Filter
Name="transforms"
Filter="">
<File
RelativePath=".\utransts.c">
</File>
</Filter>
<Filter
Name="regex"
Filter="">
</Filter>
</Files>
<Globals>
</Globals>
</VisualStudioProject>
--- NEW FILE: colutil.c ---
/********************************************************************
* COPYRIGHT:
* Copyright (c) 1997-2003, International Business Machines Corporation and
* others. All Rights Reserved.
********************************************************************/
#include "ucol_imp.h"
#if !UCONFIG_NO_COLLATION
int TestBufferSize(void); /* keep gcc happy */
int TestBufferSize(void)
{
return (U_COL_SAFECLONE_BUFFERSIZE < sizeof(UCollator));
}
#endif
--- NEW FILE: cposxtst.c ---
/*
**********************************************************************
* Copyright (c) 2003, International Business Machines
* Corporation and others. All Rights Reserved.
**********************************************************************
* Author: Alan Liu
* Created: March 20 2003
* Since: ICU 2.6
**********************************************************************
*/
#include "cintltst.h"
#include "cmemory.h"
#include "cstring.h"
#include "unicode/ucat.h"
#include "unicode/ustring.h"
/**********************************************************************/
/* Prototypes */
void TestMessageCatalog(void);
/**********************************************************************/
/* Add our tests into the hierarchy */
void addPosixTest(TestNode** root);
void addPosixTest(TestNode** root)
{
addTest(root, &TestMessageCatalog, "tsutil/cposxtst/TestMessageCatalog");
}
/**********************************************************************/
/* Test basic ucat.h API */
void TestMessageCatalog(void) {
UErrorCode ec = U_ZERO_ERROR;
u_nl_catd catd;
const char* DATA[] = {
/* set_num, msg_num, expected string result, expected error code */
"1", "4", "Good morning.", "U_ZERO_ERROR",
"1", "5", "Good afternoon.", "U_ZERO_ERROR",
"1", "6", "FAIL", "U_MISSING_RESOURCE_ERROR",
"1", "7", "Good evening.", "U_ZERO_ERROR",
"1", "8", "Good night.", "U_ZERO_ERROR",
"1", "9", "FAIL", "U_MISSING_RESOURCE_ERROR",
"3", "1", "FAIL", "U_MISSING_RESOURCE_ERROR",
"4", "14", "Please ", "U_ZERO_ERROR",
"4", "15", "FAIL", "U_MISSING_RESOURCE_ERROR",
"4", "19", "Thank you.", "U_ZERO_ERROR",
"4", "20", "Sincerely,", "U_ZERO_ERROR",
NULL
};
const UChar FAIL[] = {0x46, 0x41, 0x49, 0x4C, 0x00}; /* "FAIL" */
int32_t i;
const char *path = loadTestData(&ec);
if (U_FAILURE(ec)) {
log_err("FAIL: loadTestData => %s\n", u_errorName(ec));
return;
}
catd = u_catopen(path, "mc", &ec);
if (U_FAILURE(ec)) {
log_err("FAIL: u_catopen => %s\n", u_errorName(ec));
return;
}
for (i=0; DATA[i]!=NULL; i+=4) {
int32_t set_num = T_CString_stringToInteger(DATA[i], 10);
int32_t msg_num = T_CString_stringToInteger(DATA[i+1], 10);
UChar exp[128];
int32_t len = -1;
const char* err;
char str[128];
const UChar* ustr;
u_uastrcpy(exp, DATA[i+2]);
ec = U_ZERO_ERROR;
ustr = u_catgets(catd, set_num, msg_num, FAIL, &len, &ec);
u_austrcpy(str, ustr);
err = u_errorName(ec);
log_verbose("u_catgets(%d, %d) => \"%s\", len=%d, %s\n",
set_num, msg_num, str, len, err);
if (u_strcmp(ustr, exp) != 0) {
log_err("FAIL: u_catgets => \"%s\", exp. \"%s\"\n",
str, DATA[i+2]);
}
if (len != (int32_t) uprv_strlen(DATA[i+2])) {
log_err("FAIL: u_catgets => len=%d, exp. %d\n",
len, uprv_strlen(DATA[i+2]));
}
if (uprv_strcmp(err, DATA[i+3]) != 0) {
log_err("FAIL: u_catgets => %s, exp. %s\n",
err, DATA[i+3]);
}
}
u_catclose(catd);
}
/*eof*/
--- NEW FILE: cstrcase.c ---
/*
*******************************************************************************
*
* Copyright (C) 2002, International Business Machines
* Corporation and others. All Rights Reserved.
*
*******************************************************************************
* file name: cstrcase.c
* encoding: US-ASCII
* tab size: 8 (not used)
* indentation:4
*
* created on: 2002feb21
* created by: Markus W. Scherer
*
* Test file for string casing C API functions.
*/
#include "unicode/utypes.h"
#include "unicode/uchar.h"
#include "unicode/ustring.h"
#include "unicode/uloc.h"
#include "unicode/ubrk.h"
#include "cmemory.h"
#include "cintltst.h"
#include "cucdtst.h"
/* test string case mapping functions --------------------------------------- */
U_CFUNC void
TestCaseLower() {
static const UChar
beforeLower[]= { 0x61, 0x42, 0x49, 0x3a3, 0xdf, 0x3a3, 0x2f, 0xd93f, 0xdfff },
lowerRoot[]= { 0x61, 0x62, 0x69, 0x3c3, 0xdf, 0x3c2, 0x2f, 0xd93f, 0xdfff },
lowerTurkish[]={ 0x61, 0x62, 0x131, 0x3c3, 0xdf, 0x3c2, 0x2f, 0xd93f, 0xdfff };
UChar buffer[32];
int32_t length;
UErrorCode errorCode;
/* lowercase with root locale and separate buffers */
buffer[0]=0xabcd;
errorCode=U_ZERO_ERROR;
length=u_strToLower(buffer, sizeof(buffer)/U_SIZEOF_UCHAR,
beforeLower, sizeof(beforeLower)/U_SIZEOF_UCHAR,
"",
&errorCode);
if( U_FAILURE(errorCode) ||
length!=(sizeof(lowerRoot)/U_SIZEOF_UCHAR) ||
uprv_memcmp(lowerRoot, buffer, length*U_SIZEOF_UCHAR)!=0 ||
buffer[length]!=0
) {
log_err("error in u_strToLower(root locale)=%ld error=%s string matches: %s\t\nlowerRoot=%s\t\nbuffer=%s\n",
length,
u_errorName(errorCode),
uprv_memcmp(lowerRoot, buffer, length*U_SIZEOF_UCHAR)==0 &&
buffer[length]==0 ? "yes" : "no",
aescstrdup(lowerRoot,-1),
aescstrdup(buffer,-1));
}
/* lowercase with turkish locale and in the same buffer */
uprv_memcpy(buffer, beforeLower, sizeof(beforeLower));
buffer[sizeof(beforeLower)/U_SIZEOF_UCHAR]=0;
errorCode=U_ZERO_ERROR;
length=u_strToLower(buffer, sizeof(buffer)/U_SIZEOF_UCHAR,
buffer, -1, /* implicit srcLength */
"tr",
&errorCode);
if( U_FAILURE(errorCode) ||
length!=(sizeof(lowerTurkish)/U_SIZEOF_UCHAR) ||
uprv_memcmp(lowerTurkish, buffer, length*U_SIZEOF_UCHAR)!=0 ||
buffer[length]!=0
) {
log_err("error in u_strToLower(turkish locale)=%ld error=%s string matches: %s\n",
length,
u_errorName(errorCode),
uprv_memcmp(lowerTurkish, buffer, length*U_SIZEOF_UCHAR)==0 && buffer[length]==0 ? "yes" : "no");
}
/* test preflighting */
buffer[0]=buffer[2]=0xabcd;
errorCode=U_ZERO_ERROR;
length=u_strToLower(buffer, 2, /* set destCapacity=2 */
beforeLower, sizeof(beforeLower)/U_SIZEOF_UCHAR,
"",
&errorCode);
if( errorCode!=U_BUFFER_OVERFLOW_ERROR ||
length!=(sizeof(lowerRoot)/U_SIZEOF_UCHAR) ||
uprv_memcmp(lowerRoot, buffer, 2*U_SIZEOF_UCHAR)!=0 ||
buffer[2]!=0xabcd
) {
log_err("error in u_strToLower(root locale preflighting)=%ld error=%s string matches: %s\n",
length,
u_errorName(errorCode),
uprv_memcmp(lowerRoot, buffer, 2*U_SIZEOF_UCHAR)==0 && buffer[2]==0xabcd ? "yes" : "no");
}
/* test error handling */
errorCode=U_ZERO_ERROR;
length=u_strToLower(NULL, sizeof(buffer)/U_SIZEOF_UCHAR,
beforeLower, sizeof(beforeLower)/U_SIZEOF_UCHAR,
"",
&errorCode);
if(errorCode!=U_ILLEGAL_ARGUMENT_ERROR) {
log_err("error in u_strToLower(root locale dest=NULL)=%ld error=%s\n",
length,
u_errorName(errorCode));
}
buffer[0]=0xabcd;
errorCode=U_ZERO_ERROR;
length=u_strToLower(buffer, -1,
beforeLower, sizeof(beforeLower)/U_SIZEOF_UCHAR,
"",
&errorCode);
if( errorCode!=U_ILLEGAL_ARGUMENT_ERROR ||
buffer[0]!=0xabcd
) {
log_err("error in u_strToLower(root locale destCapacity=-1)=%ld error=%s buffer[0]==0x%lx\n",
length,
u_errorName(errorCode),
buffer[0]);
}
}
U_CFUNC void
TestCaseUpper() {
static const UChar
beforeUpper[]= { 0x61, 0x42, 0x69, 0x3c2, 0xdf, 0x3c3, 0x2f, 0xfb03, 0xd93f, 0xdfff },
upperRoot[]= { 0x41, 0x42, 0x49, 0x3a3, 0x53, 0x53, 0x3a3, 0x2f, 0x46, 0x46, 0x49, 0xd93f, 0xdfff },
upperTurkish[]={ 0x41, 0x42, 0x130, 0x3a3, 0x53, 0x53, 0x3a3, 0x2f, 0x46, 0x46, 0x49, 0xd93f, 0xdfff };
UChar buffer[32];
int32_t length;
UErrorCode errorCode;
/* uppercase with root locale and in the same buffer */
uprv_memcpy(buffer, beforeUpper, sizeof(beforeUpper));
errorCode=U_ZERO_ERROR;
length=u_strToUpper(buffer, sizeof(buffer)/U_SIZEOF_UCHAR,
buffer, sizeof(beforeUpper)/U_SIZEOF_UCHAR,
"",
&errorCode);
if( U_FAILURE(errorCode) ||
length!=(sizeof(upperRoot)/U_SIZEOF_UCHAR) ||
uprv_memcmp(upperRoot, buffer, length*U_SIZEOF_UCHAR)!=0 ||
buffer[length]!=0
) {
log_err("error in u_strToUpper(root locale)=%ld error=%s string matches: %s\n",
length,
u_errorName(errorCode),
uprv_memcmp(upperRoot, buffer, length*U_SIZEOF_UCHAR)==0 && buffer[length]==0 ? "yes" : "no");
}
/* uppercase with turkish locale and separate buffers */
buffer[0]=0xabcd;
errorCode=U_ZERO_ERROR;
length=u_strToUpper(buffer, sizeof(buffer)/U_SIZEOF_UCHAR,
beforeUpper, sizeof(beforeUpper)/U_SIZEOF_UCHAR,
"tr",
&errorCode);
if( U_FAILURE(errorCode) ||
length!=(sizeof(upperTurkish)/U_SIZEOF_UCHAR) ||
uprv_memcmp(upperTurkish, buffer, length*U_SIZEOF_UCHAR)!=0 ||
buffer[length]!=0
) {
log_err("error in u_strToUpper(turkish locale)=%ld error=%s string matches: %s\n",
length,
u_errorName(errorCode),
uprv_memcmp(upperTurkish, buffer, length*U_SIZEOF_UCHAR)==0 && buffer[length]==0 ? "yes" : "no");
}
/* test preflighting */
errorCode=U_ZERO_ERROR;
length=u_strToUpper(NULL, 0,
beforeUpper, sizeof(beforeUpper)/U_SIZEOF_UCHAR,
"tr",
&errorCode);
if( errorCode!=U_BUFFER_OVERFLOW_ERROR ||
length!=(sizeof(upperTurkish)/U_SIZEOF_UCHAR)
) {
log_err("error in u_strToUpper(turkish locale pure preflighting)=%ld error=%s\n",
length,
u_errorName(errorCode));
}
/* test error handling */
buffer[0]=0xabcd;
errorCode=U_ZERO_ERROR;
length=u_strToUpper(buffer, sizeof(buffer)/U_SIZEOF_UCHAR,
NULL, sizeof(beforeUpper)/U_SIZEOF_UCHAR,
"tr",
&errorCode);
if( errorCode!=U_ILLEGAL_ARGUMENT_ERROR ||
buffer[0]!=0xabcd
) {
log_err("error in u_strToUpper(turkish locale src=NULL)=%ld error=%s buffer[0]==0x%lx\n",
length,
u_errorName(errorCode),
buffer[0]);
}
buffer[0]=0xabcd;
errorCode=U_ZERO_ERROR;
length=u_strToUpper(buffer, sizeof(buffer)/U_SIZEOF_UCHAR,
beforeUpper, -2,
"tr",
&errorCode);
if( errorCode!=U_ILLEGAL_ARGUMENT_ERROR ||
buffer[0]!=0xabcd
) {
log_err("error in u_strToUpper(turkish locale srcLength=-2)=%ld error=%s buffer[0]==0x%lx\n",
length,
u_errorName(errorCode),
buffer[0]);
}
}
#if !UCONFIG_NO_BREAK_ITERATION
U_CFUNC void
TestCaseTitle() {
static const UChar
beforeTitle[]= { 0x61, 0x42, 0x20, 0x69, 0x3c2, 0x20, 0xdf, 0x3c3, 0x2f, 0xfb03, 0xd93f, 0xdfff },
titleWord[]= { 0x41, 0x62, 0x20, 0x49, 0x3c2, 0x20, 0x53, 0x73, 0x3c3, 0x2f, 0x46, 0x66, 0x69, 0xd93f, 0xdfff },
titleChar[]= { 0x41, 0x42, 0x20, 0x49, 0x3a3, 0x20, 0x53, 0x73, 0x3a3, 0x2f, 0x46, 0x66, 0x69, 0xd93f, 0xdfff };
UChar buffer[32];
UBreakIterator *titleIterChars;
int32_t length;
UErrorCode errorCode;
errorCode=U_ZERO_ERROR;
titleIterChars=ubrk_open(UBRK_CHARACTER, "", beforeTitle, sizeof(beforeTitle)/U_SIZEOF_UCHAR, &errorCode);
if(U_FAILURE(errorCode)) {
log_err("error: ubrk_open(UBRK_CHARACTER)->%s\n", u_errorName(errorCode));
return;
}
/* titlecase with standard break iterator and in the same buffer */
uprv_memcpy(buffer, beforeTitle, sizeof(beforeTitle));
errorCode=U_ZERO_ERROR;
length=u_strToTitle(buffer, sizeof(buffer)/U_SIZEOF_UCHAR,
buffer, sizeof(beforeTitle)/U_SIZEOF_UCHAR,
NULL, "",
&errorCode);
if( U_FAILURE(errorCode) ||
length!=(sizeof(titleWord)/U_SIZEOF_UCHAR) ||
uprv_memcmp(titleWord, buffer, length*U_SIZEOF_UCHAR)!=0 ||
buffer[length]!=0
) {
log_err("error in u_strToTitle(standard iterator)=%ld error=%s string matches: %s\n",
length,
u_errorName(errorCode),
uprv_memcmp(titleWord, buffer, length*U_SIZEOF_UCHAR)==0 && buffer[length]==0 ? "yes" : "no");
}
/* titlecase with UBRK_CHARACTERS and separate buffers */
buffer[0]=0xabcd;
errorCode=U_ZERO_ERROR;
length=u_strToTitle(buffer, sizeof(buffer)/U_SIZEOF_UCHAR,
beforeTitle, sizeof(beforeTitle)/U_SIZEOF_UCHAR,
titleIterChars, "",
&errorCode);
if( U_FAILURE(errorCode) ||
length!=(sizeof(titleChar)/U_SIZEOF_UCHAR) ||
uprv_memcmp(titleChar, buffer, length*U_SIZEOF_UCHAR)!=0 ||
buffer[length]!=0
) {
log_err("error in u_strToTitle(UBRK_CHARACTERS)=%ld error=%s string matches: %s\n",
length,
u_errorName(errorCode),
uprv_memcmp(titleChar, buffer, length*U_SIZEOF_UCHAR)==0 && buffer[length]==0 ? "yes" : "no");
}
/* test preflighting */
errorCode=U_ZERO_ERROR;
length=u_strToTitle(NULL, 0,
beforeTitle, sizeof(beforeTitle)/U_SIZEOF_UCHAR,
titleIterChars, "",
&errorCode);
if( errorCode!=U_BUFFER_OVERFLOW_ERROR ||
length!=(sizeof(titleChar)/U_SIZEOF_UCHAR)
) {
log_err("error in u_strToTitle(UBRK_CHARACTERS pure preflighting)=%ld error=%s\n",
length,
u_errorName(errorCode));
}
/* test error handling */
buffer[0]=0xabcd;
errorCode=U_ZERO_ERROR;
length=u_strToTitle(buffer, sizeof(buffer)/U_SIZEOF_UCHAR,
NULL, sizeof(beforeTitle)/U_SIZEOF_UCHAR,
titleIterChars, "",
&errorCode);
if( errorCode!=U_ILLEGAL_ARGUMENT_ERROR ||
buffer[0]!=0xabcd
) {
log_err("error in u_strToTitle(UBRK_CHARACTERS src=NULL)=%ld error=%s buffer[0]==0x%lx\n",
length,
u_errorName(errorCode),
buffer[0]);
}
buffer[0]=0xabcd;
errorCode=U_ZERO_ERROR;
length=u_strToTitle(buffer, sizeof(buffer)/U_SIZEOF_UCHAR,
beforeTitle, -2,
titleIterChars, "",
&errorCode);
if( errorCode!=U_ILLEGAL_ARGUMENT_ERROR ||
buffer[0]!=0xabcd
) {
log_err("error in u_strToTitle(UBRK_CHARACTERS srcLength=-2)=%ld error=%s buffer[0]==0x%lx\n",
length,
u_errorName(errorCode),
buffer[0]);
}
ubrk_close(titleIterChars);
}
#endif
/* test case folding and case-insensitive string compare -------------------- */
U_CFUNC void
TestCaseFolding() {
static const UChar32
simple[]={
/* input, default, exclude special i */
0x61, 0x61, 0x61,
0x49, 0x69, 0x131,
0x130, 0x69, 0x69,
0x131, 0x131, 0x131,
0xdf, 0xdf, 0xdf,
0xfb03, 0xfb03, 0xfb03,
0x1040e,0x10436,0x10436,
0x5ffff,0x5ffff,0x5ffff
};
static const UChar
mixed[]= { 0x61, 0x42, 0x130, 0x49, 0x131, 0x3d0, 0xdf, 0xfb03, 0xd93f, 0xdfff },
foldedDefault[]= { 0x61, 0x62, 0x69, 0x307, 0x69, 0x131, 0x3b2, 0x73, 0x73, 0x66, 0x66, 0x69, 0xd93f, 0xdfff },
foldedExcludeSpecialI[]={ 0x61, 0x62, 0x69, 0x131, 0x131, 0x3b2, 0x73, 0x73, 0x66, 0x66, 0x69, 0xd93f, 0xdfff };
UVersionInfo unicodeVersion={ 0, 0, 17, 89 }, unicode_3_1={ 3, 1, 0, 0 };
const UChar32 *p;
int32_t i;
UChar buffer[32];
int32_t length;
UErrorCode errorCode;
UBool isUnicode_3_1;
/* if unicodeVersion()>=3.1 then test exclude-special-i cases as well */
u_getUnicodeVersion(unicodeVersion);
isUnicode_3_1= uprv_memcmp(unicodeVersion, unicode_3_1, 4)>=0;
/* test simple case folding */
p=simple;
for(i=0; i<sizeof(simple)/12; p+=3, ++i) {
if(u_foldCase(p[0], U_FOLD_CASE_DEFAULT)!=p[1]) {
log_err("error: u_foldCase(0x%04lx, default)=0x%04lx instead of 0x%04lx\n",
p[0], u_foldCase(p[0], U_FOLD_CASE_DEFAULT), p[1]);
return;
}
if(isUnicode_3_1 && u_foldCase(p[0], U_FOLD_CASE_EXCLUDE_SPECIAL_I)!=p[2]) {
log_err("error: u_foldCase(0x%04lx, exclude special i)=0x%04lx instead of 0x%04lx\n",
p[0], u_foldCase(p[0], U_FOLD_CASE_EXCLUDE_SPECIAL_I), p[2]);
return;
}
}
/* test full string case folding with default option and separate buffers */
buffer[0]=0xabcd;
errorCode=U_ZERO_ERROR;
length=u_strFoldCase(buffer, sizeof(buffer)/U_SIZEOF_UCHAR,
mixed, sizeof(mixed)/U_SIZEOF_UCHAR,
U_FOLD_CASE_DEFAULT,
&errorCode);
if( U_FAILURE(errorCode) ||
length!=(sizeof(foldedDefault)/U_SIZEOF_UCHAR) ||
uprv_memcmp(foldedDefault, buffer, length*U_SIZEOF_UCHAR)!=0 ||
buffer[length]!=0
) {
log_err("error in u_strFoldCase(default)=%ld error=%s string matches: %s\n",
length,
u_errorName(errorCode),
uprv_memcmp(foldedDefault, buffer, length*U_SIZEOF_UCHAR)==0 && buffer[length]==0 ? "yes" : "no");
}
/* exclude special i */
if(isUnicode_3_1) {
buffer[0]=0xabcd;
errorCode=U_ZERO_ERROR;
length=u_strFoldCase(buffer, sizeof(buffer)/U_SIZEOF_UCHAR,
mixed, sizeof(mixed)/U_SIZEOF_UCHAR,
U_FOLD_CASE_EXCLUDE_SPECIAL_I,
&errorCode);
if( U_FAILURE(errorCode) ||
length!=(sizeof(foldedExcludeSpecialI)/U_SIZEOF_UCHAR) ||
uprv_memcmp(foldedExcludeSpecialI, buffer, length*U_SIZEOF_UCHAR)!=0 ||
buffer[length]!=0
) {
log_err("error in u_strFoldCase(exclude special i)=%ld error=%s string matches: %s\n",
length,
u_errorName(errorCode),
uprv_memcmp(foldedExcludeSpecialI, buffer, length*U_SIZEOF_UCHAR)==0 && buffer[length]==0 ? "yes" : "no");
}
}
/* test full string case folding with default option and in the same buffer */
uprv_memcpy(buffer, mixed, sizeof(mixed));
buffer[sizeof(mixed)/U_SIZEOF_UCHAR]=0;
errorCode=U_ZERO_ERROR;
length=u_strFoldCase(buffer, sizeof(buffer)/U_SIZEOF_UCHAR,
buffer, -1, /* implicit srcLength */
U_FOLD_CASE_DEFAULT,
&errorCode);
if( U_FAILURE(errorCode) ||
length!=(sizeof(foldedDefault)/U_SIZEOF_UCHAR) ||
uprv_memcmp(foldedDefault, buffer, length*U_SIZEOF_UCHAR)!=0 ||
buffer[length]!=0
) {
log_err("error in u_strFoldCase(default same buffer)=%ld error=%s string matches: %s\n",
length,
u_errorName(errorCode),
uprv_memcmp(foldedDefault, buffer, length*U_SIZEOF_UCHAR)==0 && buffer[length]==0 ? "yes" : "no");
}
/* test full string case folding, exclude special i, in the same buffer */
if(isUnicode_3_1) {
uprv_memcpy(buffer, mixed, sizeof(mixed));
errorCode=U_ZERO_ERROR;
length=u_strFoldCase(buffer, sizeof(buffer)/U_SIZEOF_UCHAR,
buffer, sizeof(mixed)/U_SIZEOF_UCHAR,
U_FOLD_CASE_EXCLUDE_SPECIAL_I,
&errorCode);
if( U_FAILURE(errorCode) ||
length!=(sizeof(foldedExcludeSpecialI)/U_SIZEOF_UCHAR) ||
uprv_memcmp(foldedExcludeSpecialI, buffer, length*U_SIZEOF_UCHAR)!=0 ||
buffer[length]!=0
) {
log_err("error in u_strFoldCase(exclude special i same buffer)=%ld error=%s string matches: %s\n",
length,
u_errorName(errorCode),
uprv_memcmp(foldedExcludeSpecialI, buffer, length*U_SIZEOF_UCHAR)==0 && buffer[length]==0 ? "yes" : "no");
}
}
/* test preflighting */
buffer[0]=buffer[2]=0xabcd;
errorCode=U_ZERO_ERROR;
length=u_strFoldCase(buffer, 2, /* set destCapacity=2 */
mixed, sizeof(mixed)/U_SIZEOF_UCHAR,
U_FOLD_CASE_DEFAULT,
&errorCode);
if( errorCode!=U_BUFFER_OVERFLOW_ERROR ||
length!=(sizeof(foldedDefault)/U_SIZEOF_UCHAR) ||
uprv_memcmp(foldedDefault, buffer, 2*U_SIZEOF_UCHAR)!=0 ||
buffer[2]!=0xabcd
) {
log_err("error in u_strFoldCase(default preflighting)=%ld error=%s string matches: %s\n",
length,
u_errorName(errorCode),
uprv_memcmp(foldedDefault, buffer, 2*U_SIZEOF_UCHAR)==0 && buffer[2]==0xabcd ? "yes" : "no");
}
errorCode=U_ZERO_ERROR;
length=u_strFoldCase(NULL, 0,
mixed, sizeof(mixed)/U_SIZEOF_UCHAR,
U_FOLD_CASE_DEFAULT,
&errorCode);
if( errorCode!=U_BUFFER_OVERFLOW_ERROR ||
length!=(sizeof(foldedDefault)/U_SIZEOF_UCHAR)
) {
log_err("error in u_strFoldCase(default pure preflighting)=%ld error=%s\n",
length,
u_errorName(errorCode));
}
/* test error handling */
errorCode=U_ZERO_ERROR;
length=u_strFoldCase(NULL, sizeof(buffer)/U_SIZEOF_UCHAR,
mixed, sizeof(mixed)/U_SIZEOF_UCHAR,
U_FOLD_CASE_DEFAULT,
&errorCode);
if(errorCode!=U_ILLEGAL_ARGUMENT_ERROR) {
log_err("error in u_strFoldCase(default dest=NULL)=%ld error=%s\n",
length,
u_errorName(errorCode));
}
buffer[0]=0xabcd;
errorCode=U_ZERO_ERROR;
length=u_strFoldCase(buffer, -1,
mixed, sizeof(mixed)/U_SIZEOF_UCHAR,
U_FOLD_CASE_DEFAULT,
&errorCode);
if( errorCode!=U_ILLEGAL_ARGUMENT_ERROR ||
buffer[0]!=0xabcd
) {
log_err("error in u_strFoldCase(default destCapacity=-1)=%ld error=%s buffer[0]==0x%lx\n",
length,
u_errorName(errorCode),
buffer[0]);
}
buffer[0]=0xabcd;
errorCode=U_ZERO_ERROR;
length=u_strFoldCase(buffer, sizeof(buffer)/U_SIZEOF_UCHAR,
NULL, sizeof(mixed)/U_SIZEOF_UCHAR,
U_FOLD_CASE_EXCLUDE_SPECIAL_I,
&errorCode);
if( errorCode!=U_ILLEGAL_ARGUMENT_ERROR ||
buffer[0]!=0xabcd
) {
log_err("error in u_strFoldCase(exclude special i src=NULL)=%ld error=%s buffer[0]==0x%lx\n",
length,
u_errorName(errorCode),
buffer[0]);
}
buffer[0]=0xabcd;
errorCode=U_ZERO_ERROR;
length=u_strFoldCase(buffer, sizeof(buffer)/U_SIZEOF_UCHAR,
mixed, -2,
U_FOLD_CASE_EXCLUDE_SPECIAL_I,
&errorCode);
if( errorCode!=U_ILLEGAL_ARGUMENT_ERROR ||
buffer[0]!=0xabcd
) {
log_err("error in u_strFoldCase(exclude special i srcLength=-2)=%ld error=%s buffer[0]==0x%lx\n",
length,
u_errorName(errorCode),
buffer[0]);
}
}
U_CFUNC void
TestCaseCompare() {
static const UChar
mixed[]= { 0x61, 0x42, 0x131, 0x3a3, 0xdf, 0xfb03, 0xd93f, 0xdfff, 0 },
otherDefault[]= { 0x41, 0x62, 0x131, 0x3c3, 0x73, 0x53, 0x46, 0x66, 0x49, 0xd93f, 0xdfff, 0 },
otherExcludeSpecialI[]={ 0x41, 0x62, 0x131, 0x3c3, 0x53, 0x73, 0x66, 0x46, 0x69, 0xd93f, 0xdfff, 0 },
different[]= { 0x41, 0x62, 0x131, 0x3c3, 0x73, 0x53, 0x46, 0x66, 0x49, 0xd93f, 0xdffd, 0 };
UVersionInfo unicodeVersion={ 0, 0, 17, 89 }, unicode_3_1={ 3, 1, 0, 0 };
int32_t result, lenMixed, lenOtherDefault, lenOtherExcludeSpecialI, lenDifferent;
UErrorCode errorCode;
UBool isUnicode_3_1;
errorCode=U_ZERO_ERROR;
lenMixed=u_strlen(mixed);
lenOtherDefault=u_strlen(otherDefault);
lenOtherExcludeSpecialI=u_strlen(otherExcludeSpecialI);
lenDifferent=u_strlen(different);
/* if unicodeVersion()>=3.1 then test exclude-special-i cases as well */
u_getUnicodeVersion(unicodeVersion);
isUnicode_3_1= uprv_memcmp(unicodeVersion, unicode_3_1, 4)>=0;
/* test u_strcasecmp() */
result=u_strcasecmp(mixed, otherDefault, U_FOLD_CASE_DEFAULT);
if(result!=0) {
log_err("error: u_strcasecmp(mixed, other, default)=%ld instead of 0\n", result);
}
result=u_strCaseCompare(mixed, -1, otherDefault, -1, U_FOLD_CASE_DEFAULT, &errorCode);
if(result!=0) {
log_err("error: u_strCaseCompare(mixed, other, default)=%ld instead of 0\n", result);
}
/* test u_strcasecmp() - exclude special i */
result=u_strcasecmp(mixed, otherExcludeSpecialI, U_FOLD_CASE_EXCLUDE_SPECIAL_I);
if(result!=0) {
log_err("error: u_strcasecmp(mixed, other, exclude special i)=%ld instead of 0\n", result);
}
result=u_strCaseCompare(mixed, lenMixed, otherExcludeSpecialI, lenOtherExcludeSpecialI, U_FOLD_CASE_EXCLUDE_SPECIAL_I, &errorCode);
if(result!=0) {
log_err("error: u_strCaseCompare(mixed, other, exclude special i)=%ld instead of 0\n", result);
}
/* test u_strcasecmp() */
result=u_strcasecmp(mixed, different, U_FOLD_CASE_DEFAULT);
if(result<=0) {
log_err("error: u_strcasecmp(mixed, different, default)=%ld instead of positive\n", result);
}
result=u_strCaseCompare(mixed, -1, different, lenDifferent, U_FOLD_CASE_DEFAULT, &errorCode);
if(result<=0) {
log_err("error: u_strCaseCompare(mixed, different, default)=%ld instead of positive\n", result);
}
/* test u_strncasecmp() - stop before the sharp s (U+00df) */
result=u_strncasecmp(mixed, different, 4, U_FOLD_CASE_DEFAULT);
if(result!=0) {
log_err("error: u_strncasecmp(mixed, different, 4, default)=%ld instead of 0\n", result);
}
result=u_strCaseCompare(mixed, 4, different, 4, U_FOLD_CASE_DEFAULT, &errorCode);
if(result!=0) {
log_err("error: u_strCaseCompare(mixed, 4, different, 4, default)=%ld instead of 0\n", result);
}
/* test u_strncasecmp() - stop in the middle of the sharp s (U+00df) */
result=u_strncasecmp(mixed, different, 5, U_FOLD_CASE_DEFAULT);
if(result<=0) {
log_err("error: u_strncasecmp(mixed, different, 5, default)=%ld instead of positive\n", result);
}
result=u_strCaseCompare(mixed, 5, different, 5, U_FOLD_CASE_DEFAULT, &errorCode);
if(result<=0) {
log_err("error: u_strCaseCompare(mixed, 5, different, 5, default)=%ld instead of positive\n", result);
}
/* test u_memcasecmp() - stop before the sharp s (U+00df) */
result=u_memcasecmp(mixed, different, 4, U_FOLD_CASE_DEFAULT);
if(result!=0) {
log_err("error: u_memcasecmp(mixed, different, 4, default)=%ld instead of 0\n", result);
}
/* test u_memcasecmp() - stop in the middle of the sharp s (U+00df) */
result=u_memcasecmp(mixed, different, 5, U_FOLD_CASE_DEFAULT);
if(result<=0) {
log_err("error: u_memcasecmp(mixed, different, 5, default)=%ld instead of positive\n", result);
}
}
--- NEW FILE: cucdapi.c ---
/********************************************************************
* COPYRIGHT:
* Copyright (c) 1997-2003, International Business Machines Corporation and
* others. All Rights Reserved.
********************************************************************/
#include <string.h>
#include "unicode/utypes.h"
#include "unicode/uscript.h"
#include "unicode/uchar.h"
#include "cintltst.h"
void TestUScriptCodeAPI(){
int i =0;
int numErrors =0;
{
const char* testNames[]={
/* test locale */
"en", "en_US", "sr", "ta" , "te_IN",
"hi", "he", "ar",
/* test abbr */
"Hani", "Hang","Hebr","Hira",
"Knda","Kana","Khmr","Lao",
"Latn",/*"Latf","Latg",*/
"Mlym", "Mong",
/* test names */
"CYRILLIC","DESERET","DEVANAGARI","ETHIOPIC","GEORGIAN",
"GOTHIC", "GREEK", "GUJARATI", "COMMON", "INHERITED",
/* test lower case names */
"malayalam", "mongolian", "myanmar", "ogham", "old-italic",
"oriya", "runic", "sinhala", "syriac","tamil",
"telugu", "thaana", "thai", "tibetan",
/* test the bounds*/
"tagb", "arabic",
/* test bogus */
"asfdasd", "5464", "12235",
/* test the last index */
"zyyy", "YI",
'\0'
};
UScriptCode expected[] ={
/* locales should return */
USCRIPT_LATIN, USCRIPT_LATIN, USCRIPT_CYRILLIC, USCRIPT_TAMIL, USCRIPT_TELUGU,
USCRIPT_DEVANAGARI, USCRIPT_HEBREW, USCRIPT_ARABIC,
/* abbr should return */
USCRIPT_HAN, USCRIPT_HANGUL, USCRIPT_HEBREW, USCRIPT_HIRAGANA,
USCRIPT_KANNADA, USCRIPT_KATAKANA, USCRIPT_KHMER, USCRIPT_LAO,
USCRIPT_LATIN,/* USCRIPT_LATIN, USCRIPT_LATIN,*/
USCRIPT_MALAYALAM, USCRIPT_MONGOLIAN,
/* names should return */
USCRIPT_CYRILLIC, USCRIPT_DESERET, USCRIPT_DEVANAGARI, USCRIPT_ETHIOPIC, USCRIPT_GEORGIAN,
USCRIPT_GOTHIC, USCRIPT_GREEK, USCRIPT_GUJARATI, USCRIPT_COMMON, USCRIPT_INHERITED,
/* lower case names should return */
USCRIPT_MALAYALAM, USCRIPT_MONGOLIAN, USCRIPT_MYANMAR, USCRIPT_OGHAM, USCRIPT_OLD_ITALIC,
USCRIPT_ORIYA, USCRIPT_RUNIC, USCRIPT_SINHALA, USCRIPT_SYRIAC, USCRIPT_TAMIL,
USCRIPT_TELUGU, USCRIPT_THAANA, USCRIPT_THAI, USCRIPT_TIBETAN,
/* bounds */
USCRIPT_TAGBANWA, USCRIPT_ARABIC,
/* bogus names should return invalid code */
USCRIPT_INVALID_CODE, USCRIPT_INVALID_CODE, USCRIPT_INVALID_CODE,
USCRIPT_COMMON, USCRIPT_YI,
};
UErrorCode err = U_ZERO_ERROR;
const int32_t capacity = 10;
for( ; testNames[i]!='\0'; i++){
UScriptCode script[10]={USCRIPT_INVALID_CODE};
uscript_getCode(testNames[i],script,capacity, &err);
if( script[0] != expected[i]){
log_err("Error getting script code Got: %i Expected: %i for name %s\n",
script[0],expected[i],testNames[i]);
numErrors++;
}
}
if(numErrors >0 ){
log_data_err("Errors uchar_getScriptCode() : %i \n",numErrors);
}
}
{
UErrorCode err = U_ZERO_ERROR;
int32_t capacity=0;
UScriptCode jaCode[]={ USCRIPT_KATAKANA,USCRIPT_HIRAGANA,USCRIPT_HAN};
UScriptCode script[10]={USCRIPT_INVALID_CODE};
int32_t num = uscript_getCode("ja",script,capacity, &err);
/* preflight */
if(err==U_BUFFER_OVERFLOW_ERROR){
err = U_ZERO_ERROR;
capacity = 10;
num = uscript_getCode("ja",script,capacity, &err);
if(num!=(sizeof(jaCode)/sizeof(UScriptCode)) || script[0]!=jaCode[0] || script[1]!=jaCode[1]){
log_err("Errors uscript_getScriptCode() for Japaneese locale \n");
}
}else{
log_data_err("Errors in uscript_getScriptCode() expected error : %s got: %s \n",
"U_BUFFER_OVERFLOW_ERROR",
u_errorName(err));
}
}
{
UScriptCode testAbbr[]={
/* names should return */
USCRIPT_CYRILLIC, USCRIPT_DESERET, USCRIPT_DEVANAGARI, USCRIPT_ETHIOPIC, USCRIPT_GEORGIAN,
USCRIPT_GOTHIC, USCRIPT_GREEK, USCRIPT_GUJARATI,
};
const char* expectedNames[]={
/* test names */
"Cyrillic","Deseret","Devanagari","Ethiopic","Georgian",
"Gothic", "Greek", "Gujarati",
'\0'
};
i=0;
while(i<sizeof(testAbbr)/sizeof(UScriptCode)){
const char* name = uscript_getName(testAbbr[i]);
if(name == NULL) {
log_data_err("Couldn't get script name\n");
return;
}
numErrors=0;
if(strcmp(expectedNames[i],name)!=0){
log_err("Error getting abbreviations Got: %s Expected: %s\n",name,expectedNames[i]);
numErrors++;
}
if(numErrors > 0){
if(numErrors >0 ){
log_err("Errors uchar_getScriptAbbr() : %i \n",numErrors);
}
}
i++;
}
}
{
UScriptCode testAbbr[]={
/* abbr should return */
USCRIPT_HAN, USCRIPT_HANGUL, USCRIPT_HEBREW, USCRIPT_HIRAGANA,
USCRIPT_KANNADA, USCRIPT_KATAKANA, USCRIPT_KHMER, USCRIPT_LAO,
USCRIPT_LATIN,
USCRIPT_MALAYALAM, USCRIPT_MONGOLIAN,
};
const char* expectedAbbr[]={
/* test abbr */
"Hani", "Hang","Hebr","Hira",
"Knda","Kana","Khmr","Laoo",
"Latn",
"Mlym", "Mong",
'\0'
};
i=0;
while(i<sizeof(testAbbr)/sizeof(UScriptCode)){
const char* name = uscript_getShortName(testAbbr[i]);
numErrors=0;
if(strcmp(expectedAbbr[i],name)!=0){
log_err("Error getting abbreviations Got: %s Expected: %s\n",name,expectedAbbr[i]);
numErrors++;
}
if(numErrors > 0){
if(numErrors >0 ){
log_err("Errors uchar_getScriptAbbr() : %i \n",numErrors);
}
}
i++;
}
}
/* now test uscript_getScript() API */
{
#define MAX_ARRAY_SIZE 23
uint32_t codepoints[] = {
0x0000FF9D, /* USCRIPT_KATAKANA*/
0x0000FFBE, /* USCRIPT_HANGUL*/
0x0000FFC7, /* USCRIPT_HANGUL*/
0x0000FFCF, /* USCRIPT_HANGUL*/
0x0000FFD7, /* USCRIPT_HANGUL*/
0x0000FFDC, /* USCRIPT_HANGUL*/
0x00010300, /* USCRIPT_OLD_ITALIC*/
0x00010330, /* USCRIPT_GOTHIC*/
0x0001034A, /* USCRIPT_GOTHIC*/
0x00010400, /* USCRIPT_DESERET*/
0x00010428, /* USCRIPT_DESERET*/
0x0001D167, /* USCRIPT_INHERITED*/
0x0001D17B, /* USCRIPT_INHERITED*/
0x0001D185, /* USCRIPT_INHERITED*/
0x0001D1AA, /* USCRIPT_INHERITED*/
0x00020000, /* USCRIPT_HAN*/
0x00000D02, /* USCRIPT_MALAYALAM*/
0x00000D00, /* USCRIPT_COMMON */
0x00000000, /* USCRIPT_COMMON*/
0x0001D169, /* USCRIPT_INHERITED*/
0x0001D182, /* USCRIPT_INHERITED*/
0x0001D18B, /* USCRIPT_INHERITED*/
0x0001D1AD, /* USCRIPT_INHERITED*/
0x00110000, /* USCRIPT_INVALID_CODE */
};
UScriptCode expected[] = {
USCRIPT_KATAKANA ,
USCRIPT_HANGUL ,
USCRIPT_HANGUL ,
USCRIPT_HANGUL ,
USCRIPT_HANGUL ,
USCRIPT_HANGUL ,
USCRIPT_OLD_ITALIC,
USCRIPT_GOTHIC ,
USCRIPT_GOTHIC ,
USCRIPT_DESERET ,
USCRIPT_DESERET ,
USCRIPT_INHERITED,
USCRIPT_INHERITED,
USCRIPT_INHERITED,
USCRIPT_INHERITED,
USCRIPT_HAN ,
USCRIPT_MALAYALAM,
USCRIPT_COMMON,
USCRIPT_COMMON,
USCRIPT_INHERITED ,
USCRIPT_INHERITED ,
USCRIPT_INHERITED ,
USCRIPT_INHERITED ,
USCRIPT_INVALID_CODE,
};
UScriptCode code = USCRIPT_INVALID_CODE;
UErrorCode status = U_ZERO_ERROR;
UBool passed = TRUE;
i =0;
while(i< MAX_ARRAY_SIZE){
code = uscript_getScript(codepoints[i],&status);
if(U_SUCCESS(status)){
if( code != expected[i] ||
code != (UScriptCode)u_getIntPropertyValue(codepoints[i], UCHAR_SCRIPT)
) {
log_err("uscript_getScript for codepoint \\U%08X failed\n",codepoints[i]);
passed = FALSE;
}
}else{
log_err("uscript_getScript for codepoint \\U%08X failed. Error: %s\n",
codepoints[i],u_errorName(status));
break;
}
i++;
}
if(passed==FALSE){
log_err("uscript_getScript failed.\n");
}
}
{
UScriptCode code= USCRIPT_INVALID_CODE;
UErrorCode status = U_ZERO_ERROR;
code = uscript_getScript(0x001D169,&status);
if(code != USCRIPT_INHERITED){
log_err("\\U001D169 is not contained in USCRIPT_INHERITED");
}
}
{
UScriptCode code= USCRIPT_INVALID_CODE;
UErrorCode status = U_ZERO_ERROR;
int32_t err = 0;
for(i = 0; i<=0x10ffff; i++){
code = uscript_getScript(i,&status);
if(code == USCRIPT_INVALID_CODE){
err++;
log_err("uscript_getScript for codepoint \\U%08X failed.\n", i);
}
}
if(err>0){
log_err("uscript_getScript failed for %d codepoints\n", err);
}
}
{
for(i=0; (UScriptCode)i< USCRIPT_CODE_LIMIT; i++){
const char* name = uscript_getName((UScriptCode)i);
if(name==NULL || strcmp(name,"")==0){
log_err("uscript_getName failed for code : %i\n",i);
}
}
}
}
--- NEW FILE: custrtst.c ---
/*
******************************************************************************
*
* Copyright (C) 2002-2003, International Business Machines
* Corporation and others. All Rights Reserved.
*
******************************************************************************
* file name: custrtst.c
* encoding: US-ASCII
* tab size: 8 (not used)
* indentation:4
*
* created on: 2002oct09
* created by: Markus W. Scherer
*
* Tests of ustring.h Unicode string API functions.
*/
#include "unicode/utypes.h"
[...1735 lines suppressed...]
testUNormIteratorWithText(text, length, length, "UCharIterEnd", "UNormIterEnd1");
/* test again, this time with an insane string to cause internal buffer overflows */
middle=u_strchr(text, 0x327)-text; /* see comment at text[] */
memcpy(longText, text, middle*U_SIZEOF_UCHAR);
for(i=0; i<150; ++i) {
longText[middle+i]=0x30a; /* insert many rings between 'A-ring' and cedilla */
}
memcpy(longText+middle+i, text+middle, (LENGTHOF(text)-middle)*U_SIZEOF_UCHAR);
length=LENGTHOF(text)+i;
testUNormIteratorWithText(longText, length, length/2, "UCharIterLong", "UNormIterLong1");
testUNormIteratorWithText(longText, length, length, "UCharIterLongEnd", "UNormIterLongEnd1");
length=LENGTHOF(surrogateText);
testUNormIteratorWithText(surrogateText, length, length/2, "UCharIterSurr", "UNormIterSurr1");
testUNormIteratorWithText(surrogateText, length, length, "UCharIterSurrEnd", "UNormIterSurrEnd1");
}
#endif
--- NEW FILE: trietest.c ---
/*
******************************************************************************
*
* Copyright (C) 2001, International Business Machines
* Corporation and others. All Rights Reserved.
*
******************************************************************************
* file name: trietest.c
* encoding: US-ASCII
* tab size: 8 (not used)
* indentation:4
*
* created on: 2001nov20
* created by: Markus W. Scherer
*/
#include <stdio.h>
#include "unicode/utypes.h"
#include "utrie.h"
#include "cstring.h"
#include "cmemory.h"
#if 1
#include "cintltst.h"
#else
/* definitions from standalone utrie development */
#define log_err printf
#define log_verbose printf
#undef u_errorName
#define u_errorName(errorCode) "some error code"
#endif
#define ARRAY_LENGTH(array) (sizeof(array)/sizeof(array[0]))
/* Values for setting possibly overlapping, out-of-order ranges of values */
typedef struct SetRange {
UChar32 start, limit;
uint32_t value;
UBool overwrite;
} SetRange;
/*
* Values for testing:
* value is set from the previous boundary's limit to before
* this boundary's limit
*/
typedef struct CheckRange {
UChar32 limit;
uint32_t value;
} CheckRange;
struct{
double bogus; /* needed for aligining the storage */
uint8_t storage[10000000];
} storageHolder;
static uint32_t U_CALLCONV
_testFoldedValue32(UNewTrie *trie, UChar32 start, int32_t offset) {
uint32_t foldedValue, value;
UChar32 limit;
UBool inBlockZero;
foldedValue=0;
limit=start+0x400;
while(start<limit) {
value=utrie_get32(trie, start, &inBlockZero);
if(inBlockZero) {
start+=UTRIE_DATA_BLOCK_LENGTH;
} else {
foldedValue|=value;
++start;
}
}
if(foldedValue!=0) {
return ((uint32_t)offset<<16)|foldedValue;
} else {
return 0;
}
}
static int32_t U_CALLCONV
_testFoldingOffset32(uint32_t data) {
return (int32_t)(data>>16);
}
static uint32_t U_CALLCONV
_testFoldedValue16(UNewTrie *trie, UChar32 start, int32_t offset) {
uint32_t foldedValue, value;
UChar32 limit;
UBool inBlockZero;
foldedValue=0;
limit=start+0x400;
while(start<limit) {
value=utrie_get32(trie, start, &inBlockZero);
if(inBlockZero) {
start+=UTRIE_DATA_BLOCK_LENGTH;
} else {
foldedValue|=value;
++start;
}
}
if(foldedValue!=0) {
return (uint32_t)(offset|0x8000);
} else {
return 0;
}
}
static int32_t U_CALLCONV
_testFoldingOffset16(uint32_t data) {
if(data&0x8000) {
return (int32_t)(data&0x7fff);
} else {
return 0;
}
}
static uint32_t U_CALLCONV
_testEnumValue(const void *context, uint32_t value) {
return value^0x5555;
}
static UBool U_CALLCONV
_testEnumRange(const void *context, UChar32 start, UChar32 limit, uint32_t value) {
const CheckRange **pb=(const CheckRange **)context;
const CheckRange *b=(*pb)++;
value^=0x5555;
if(start!=(b-1)->limit || limit!=b->limit || value!=b->value) {
log_err("error: utrie_enum() delivers wrong range [U+%04lx..U+%04lx[.0x%lx instead of [U+%04lx..U+%04lx[.0x%lx\n",
start, limit, value,
(b-1)->limit, b->limit, b->value);
}
return TRUE;
}
static void
testTrieIteration(const char *testName,
const UTrie *trie,
const CheckRange checkRanges[], int32_t countCheckRanges) {
UChar s[100];
uint32_t values[30];
const UChar *p, *limit;
uint32_t value;
UChar32 c;
int32_t i, length, countValues;
UChar c2;
/* write a string */
length=countValues=0;
for(i=0; i<countCheckRanges; ++i) {
c=checkRanges[i].limit;
if(c!=0) {
--c;
UTF_APPEND_CHAR_UNSAFE(s, length, c);
values[countValues++]=checkRanges[i].value;
}
}
limit=s+length;
/* try forward */
p=s;
i=0;
while(p<limit) {
c=c2=0x33;
if(trie->data32!=NULL) {
UTRIE_NEXT32(trie, p, limit, c, c2, value);
} else {
UTRIE_NEXT16(trie, p, limit, c, c2, value);
}
if(value!=values[i]) {
log_err("error: wrong value from UTRIE_NEXT(%s)(U+%04lx, U+%04lx): 0x%lx instead of 0x%lx\n",
testName, c, c2, value, values[i]);
}
if(
c2==0 ?
c!=*(p-1) :
!UTF_IS_LEAD(c) || !UTF_IS_TRAIL(c2) || c!=*(p-2) || c2!=*(p-1)
) {
log_err("error: wrong (c, c2) from UTRIE_NEXT(%s): (U+%04lx, U+%04lx)\n",
testName, c, c2);
continue;
}
if(c2!=0) {
int32_t offset;
if(trie->data32==NULL) {
value=UTRIE_GET16_FROM_LEAD(trie, c);
offset=trie->getFoldingOffset(value);
if(offset>0) {
value=UTRIE_GET16_FROM_OFFSET_TRAIL(trie, offset, c2);
} else {
value=trie->initialValue;
}
} else {
value=UTRIE_GET32_FROM_LEAD(trie, c);
offset=trie->getFoldingOffset(value);
if(offset>0) {
value=UTRIE_GET32_FROM_OFFSET_TRAIL(trie, offset, c2);
} else {
value=trie->initialValue;
}
}
if(value!=values[i]) {
log_err("error: wrong value from UTRIE_GETXX_FROM_OFFSET_TRAIL(%s)(U+%04lx, U+%04lx): 0x%lx instead of 0x%lx\n",
testName, c, c2, value, values[i]);
}
}
if(c2!=0) {
value=0x44;
if(trie->data32==NULL) {
UTRIE_GET16_FROM_PAIR(trie, c, c2, value);
} else {
UTRIE_GET32_FROM_PAIR(trie, c, c2, value);
}
if(value!=values[i]) {
log_err("error: wrong value from UTRIE_GETXX_FROM_PAIR(%s)(U+%04lx, U+%04lx): 0x%lx instead of 0x%lx\n",
testName, c, c2, value, values[i]);
}
}
++i;
}
/* try backward */
p=limit;
i=countValues;
while(s<p) {
--i;
c=c2=0x33;
if(trie->data32!=NULL) {
UTRIE_PREVIOUS32(trie, s, p, c, c2, value);
} else {
UTRIE_PREVIOUS16(trie, s, p, c, c2, value);
}
if(value!=values[i]) {
log_err("error: wrong value from UTRIE_PREVIOUS(%s)(U+%04lx, U+%04lx): 0x%lx instead of 0x%lx\n",
testName, c, c2, value, values[i]);
}
if(
c2==0 ?
c!=*p:
!UTF_IS_LEAD(c) || !UTF_IS_TRAIL(c2) || c!=*p || c2!=*(p+1)
) {
log_err("error: wrong (c, c2) from UTRIE_PREVIOUS(%s): (U+%04lx, U+%04lx)\n",
testName, c, c2);
}
}
}
static void
testTrieRangesWithMalloc(const char *testName,
const SetRange setRanges[], int32_t countSetRanges,
const CheckRange checkRanges[], int32_t countCheckRanges,
UBool dataIs32, UBool latin1Linear) {
UTrieGetFoldingOffset *getFoldingOffset;
const CheckRange *enumRanges;
UNewTrie *newTrie;
UTrie trie={ 0 };
uint32_t value, value2;
UChar32 start, limit;
int32_t i, length;
UErrorCode errorCode;
UBool overwrite, ok;
uint8_t* storage =NULL;
storage = (uint8_t*) uprv_malloc(sizeof(uint8_t)*100000);
log_verbose("\ntesting Trie '%s'\n", testName);
newTrie=utrie_open(NULL, NULL, 2000, checkRanges[0].value, latin1Linear);
/* set values from setRanges[] */
ok=TRUE;
for(i=0; i<countSetRanges; ++i) {
start=setRanges[i].start;
limit=setRanges[i].limit;
value=setRanges[i].value;
overwrite=setRanges[i].overwrite;
if((limit-start)==1 && overwrite) {
ok&=utrie_set32(newTrie, start, value);
} else {
ok&=utrie_setRange32(newTrie, start, limit, value, overwrite);
}
}
if(!ok) {
log_err("error: setting values into a trie failed (%s)\n", testName);
return;
}
/* verify that all these values are in the new Trie */
start=0;
for(i=0; i<countCheckRanges; ++i) {
limit=checkRanges[i].limit;
value=checkRanges[i].value;
while(start<limit) {
if(value!=utrie_get32(newTrie, start, NULL)) {
log_err("error: newTrie(%s)[U+%04lx]==0x%lx instead of 0x%lx\n",
testName, start, utrie_get32(newTrie, start, NULL), value);
}
++start;
}
}
if(dataIs32) {
getFoldingOffset=_testFoldingOffset32;
} else {
getFoldingOffset=_testFoldingOffset16;
}
errorCode=U_ZERO_ERROR;
length=utrie_serialize(newTrie, storage, 1000000,
dataIs32 ? _testFoldedValue32 : _testFoldedValue16,
(UBool)!dataIs32,
&errorCode);
if(U_FAILURE(errorCode)) {
log_err("error: utrie_serialize(%s) failed: %s\n", testName, u_errorName(errorCode));
utrie_close(newTrie);
return;
}
/* test linear Latin-1 range from utrie_getData() */
if(latin1Linear) {
uint32_t *data;
int32_t dataLength;
data=utrie_getData(newTrie, &dataLength);
start=0;
for(i=0; i<countCheckRanges && start<=0xff; ++i) {
limit=checkRanges[i].limit;
value=checkRanges[i].value;
while(start<limit && start<=0xff) {
if(value!=data[UTRIE_DATA_BLOCK_LENGTH+start]) {
log_err("error: newTrie(%s).latin1Data[U+%04lx]==0x%lx instead of 0x%lx\n",
testName, start, data[UTRIE_DATA_BLOCK_LENGTH+start], value);
}
++start;
}
}
}
utrie_close(newTrie);
errorCode=U_ZERO_ERROR;
if(!utrie_unserialize(&trie, storage, length, &errorCode)) {
log_err("error: utrie_unserialize() failed, %s\n", u_errorName(errorCode));
return;
}
trie.getFoldingOffset=getFoldingOffset;
if(dataIs32!=(trie.data32!=NULL)) {
log_err("error: trie serialization (%s) did not preserve 32-bitness\n", testName);
}
if(latin1Linear!=trie.isLatin1Linear) {
log_err("error: trie serialization (%s) did not preserve Latin-1-linearity\n", testName);
}
/* verify that all these values are in the unserialized Trie */
start=0;
for(i=0; i<countCheckRanges; ++i) {
limit=checkRanges[i].limit;
value=checkRanges[i].value;
if(start==0xd800) {
/* skip surrogates */
start=limit;
continue;
}
while(start<limit) {
if(start<=0xffff) {
if(dataIs32) {
value2=UTRIE_GET32_FROM_BMP(&trie, start);
} else {
value2=UTRIE_GET16_FROM_BMP(&trie, start);
}
if(value!=value2) {
log_err("error: unserialized trie(%s).fromBMP(U+%04lx)==0x%lx instead of 0x%lx\n",
testName, start, value2, value);
}
if(!UTF_IS_LEAD(start)) {
if(dataIs32) {
value2=UTRIE_GET32_FROM_LEAD(&trie, start);
} else {
value2=UTRIE_GET16_FROM_LEAD(&trie, start);
}
if(value!=value2) {
log_err("error: unserialized trie(%s).fromLead(U+%04lx)==0x%lx instead of 0x%lx\n",
testName, start, value2, value);
}
}
}
if(dataIs32) {
UTRIE_GET32(&trie, start, value2);
} else {
UTRIE_GET16(&trie, start, value2);
}
if(value!=value2) {
log_err("error: unserialized trie(%s).get(U+%04lx)==0x%lx instead of 0x%lx\n",
testName, start, value2, value);
}
++start;
}
}
/* enumerate and verify all ranges */
enumRanges=checkRanges+1;
utrie_enum(&trie, _testEnumValue, _testEnumRange, &enumRanges);
/* test linear Latin-1 range */
if(trie.isLatin1Linear) {
if(trie.data32!=NULL) {
const uint32_t *latin1=UTRIE_GET32_LATIN1(&trie);
for(start=0; start<0x100; ++start) {
if(latin1[start]!=UTRIE_GET32_FROM_LEAD(&trie, start)) {
log_err("error: (%s) trie.latin1[U+%04lx]=0x%lx!=0x%lx=trie.get32(U+%04lx)\n",
testName, start, latin1[start], UTRIE_GET32_FROM_LEAD(&trie, start), start);
}
}
} else {
const uint16_t *latin1=UTRIE_GET16_LATIN1(&trie);
for(start=0; start<0x100; ++start) {
if(latin1[start]!=UTRIE_GET16_FROM_LEAD(&trie, start)) {
log_err("error: (%s) trie.latin1[U+%04lx]=0x%lx!=0x%lx=trie.get16(U+%04lx)\n",
testName, start, latin1[start], UTRIE_GET16_FROM_LEAD(&trie, start), start);
}
}
}
}
testTrieIteration(testName, &trie, checkRanges, countCheckRanges);
uprv_free(storage);
}
static void
testTrieRanges(const char *testName,
const SetRange setRanges[], int32_t countSetRanges,
const CheckRange checkRanges[], int32_t countCheckRanges,
UBool dataIs32, UBool latin1Linear) {
UTrieGetFoldingOffset *getFoldingOffset;
const CheckRange *enumRanges;
UNewTrie *newTrie;
UTrie trie={ 0 };
uint32_t value, value2;
UChar32 start, limit;
int32_t i, length;
UErrorCode errorCode;
UBool overwrite, ok;
log_verbose("\ntesting Trie '%s'\n", testName);
newTrie=utrie_open(NULL, NULL, 2000, checkRanges[0].value, latin1Linear);
/* set values from setRanges[] */
ok=TRUE;
for(i=0; i<countSetRanges; ++i) {
start=setRanges[i].start;
limit=setRanges[i].limit;
value=setRanges[i].value;
overwrite=setRanges[i].overwrite;
if((limit-start)==1 && overwrite) {
ok&=utrie_set32(newTrie, start, value);
} else {
ok&=utrie_setRange32(newTrie, start, limit, value, overwrite);
}
}
if(!ok) {
log_err("error: setting values into a trie failed (%s)\n", testName);
return;
}
/* verify that all these values are in the new Trie */
start=0;
for(i=0; i<countCheckRanges; ++i) {
limit=checkRanges[i].limit;
value=checkRanges[i].value;
while(start<limit) {
if(value!=utrie_get32(newTrie, start, NULL)) {
log_err("error: newTrie(%s)[U+%04lx]==0x%lx instead of 0x%lx\n",
testName, start, utrie_get32(newTrie, start, NULL), value);
}
++start;
}
}
if(dataIs32) {
getFoldingOffset=_testFoldingOffset32;
} else {
getFoldingOffset=_testFoldingOffset16;
}
errorCode=U_ZERO_ERROR;
length=utrie_serialize(newTrie, storageHolder.storage, sizeof(storageHolder.storage),
dataIs32 ? _testFoldedValue32 : _testFoldedValue16,
(UBool)!dataIs32,
&errorCode);
if(U_FAILURE(errorCode)) {
log_err("error: utrie_serialize(%s) failed: %s\n", testName, u_errorName(errorCode));
utrie_close(newTrie);
return;
}
/* test linear Latin-1 range from utrie_getData() */
if(latin1Linear) {
uint32_t *data;
int32_t dataLength;
data=utrie_getData(newTrie, &dataLength);
start=0;
for(i=0; i<countCheckRanges && start<=0xff; ++i) {
limit=checkRanges[i].limit;
value=checkRanges[i].value;
while(start<limit && start<=0xff) {
if(value!=data[UTRIE_DATA_BLOCK_LENGTH+start]) {
log_err("error: newTrie(%s).latin1Data[U+%04lx]==0x%lx instead of 0x%lx\n",
testName, start, data[UTRIE_DATA_BLOCK_LENGTH+start], value);
}
++start;
}
}
}
utrie_close(newTrie);
errorCode=U_ZERO_ERROR;
if(!utrie_unserialize(&trie, storageHolder.storage, length, &errorCode)) {
log_err("error: utrie_unserialize() failed, %s\n", u_errorName(errorCode));
return;
}
trie.getFoldingOffset=getFoldingOffset;
if(dataIs32!=(trie.data32!=NULL)) {
log_err("error: trie serialization (%s) did not preserve 32-bitness\n", testName);
}
if(latin1Linear!=trie.isLatin1Linear) {
log_err("error: trie serialization (%s) did not preserve Latin-1-linearity\n", testName);
}
/* verify that all these values are in the unserialized Trie */
start=0;
for(i=0; i<countCheckRanges; ++i) {
limit=checkRanges[i].limit;
value=checkRanges[i].value;
if(start==0xd800) {
/* skip surrogates */
start=limit;
continue;
}
while(start<limit) {
if(start<=0xffff) {
if(dataIs32) {
value2=UTRIE_GET32_FROM_BMP(&trie, start);
} else {
value2=UTRIE_GET16_FROM_BMP(&trie, start);
}
if(value!=value2) {
log_err("error: unserialized trie(%s).fromBMP(U+%04lx)==0x%lx instead of 0x%lx\n",
testName, start, value2, value);
}
if(!UTF_IS_LEAD(start)) {
if(dataIs32) {
value2=UTRIE_GET32_FROM_LEAD(&trie, start);
} else {
value2=UTRIE_GET16_FROM_LEAD(&trie, start);
}
if(value!=value2) {
log_err("error: unserialized trie(%s).fromLead(U+%04lx)==0x%lx instead of 0x%lx\n",
testName, start, value2, value);
}
}
}
if(dataIs32) {
UTRIE_GET32(&trie, start, value2);
} else {
UTRIE_GET16(&trie, start, value2);
}
if(value!=value2) {
log_err("error: unserialized trie(%s).get(U+%04lx)==0x%lx instead of 0x%lx\n",
testName, start, value2, value);
}
++start;
}
}
/* enumerate and verify all ranges */
enumRanges=checkRanges+1;
utrie_enum(&trie, _testEnumValue, _testEnumRange, &enumRanges);
/* test linear Latin-1 range */
if(trie.isLatin1Linear) {
if(trie.data32!=NULL) {
const uint32_t *latin1=UTRIE_GET32_LATIN1(&trie);
for(start=0; start<0x100; ++start) {
if(latin1[start]!=UTRIE_GET32_FROM_LEAD(&trie, start)) {
log_err("error: (%s) trie.latin1[U+%04lx]=0x%lx!=0x%lx=trie.get32(U+%04lx)\n",
testName, start, latin1[start], UTRIE_GET32_FROM_LEAD(&trie, start), start);
}
}
} else {
const uint16_t *latin1=UTRIE_GET16_LATIN1(&trie);
for(start=0; start<0x100; ++start) {
if(latin1[start]!=UTRIE_GET16_FROM_LEAD(&trie, start)) {
log_err("error: (%s) trie.latin1[U+%04lx]=0x%lx!=0x%lx=trie.get16(U+%04lx)\n",
testName, start, latin1[start], UTRIE_GET16_FROM_LEAD(&trie, start), start);
}
}
}
}
testTrieIteration(testName, &trie, checkRanges, countCheckRanges);
}
static void
testTrieRanges2(const char *testName,
const SetRange setRanges[], int32_t countSetRanges,
const CheckRange checkRanges[], int32_t countCheckRanges,
UBool dataIs32) {
char name[40];
testTrieRanges(testName,
setRanges, countSetRanges,
checkRanges, countCheckRanges,
dataIs32, FALSE);
testTrieRangesWithMalloc(testName,
setRanges, countSetRanges,
checkRanges, countCheckRanges,
dataIs32, FALSE);
uprv_strcpy(name, testName);
uprv_strcat(name, "-latin1Linear");
testTrieRanges(name,
setRanges, countSetRanges,
checkRanges, countCheckRanges,
dataIs32, TRUE);
testTrieRangesWithMalloc(name,
setRanges, countSetRanges,
checkRanges, countCheckRanges,
dataIs32, TRUE);
}
static void
testTrieRanges4(const char *testName,
const SetRange setRanges[], int32_t countSetRanges,
const CheckRange checkRanges[], int32_t countCheckRanges) {
char name[40];
uprv_strcpy(name, testName);
uprv_strcat(name, ".32");
testTrieRanges2(name,
setRanges, countSetRanges,
checkRanges, countCheckRanges,
TRUE);
uprv_strcpy(name, testName);
uprv_strcat(name, ".16");
testTrieRanges2(name,
setRanges, countSetRanges,
checkRanges, countCheckRanges,
FALSE);
}
/* test data ----------------------------------------------------------------*/
/* set consecutive ranges, even with value 0 */
static const SetRange
setRanges1[]={
{0, 0x20, 0, FALSE},
{0x20, 0xa7, 0x1234, FALSE},
{0xa7, 0x3400, 0, FALSE},
{0x3400, 0x9fa6, 0x6162, FALSE},
{0x9fa6, 0xdada, 0x3132, FALSE},
{0xdada, 0xeeee, 0x27, FALSE},
{0xeeee, 0x11111, 1, FALSE},
{0x11111, 0x44444, 0x6162, FALSE},
{0x44444, 0xf0003, 0, FALSE},
{0xf0003, 0xf0004, 0xf, FALSE},
{0xf0004, 0xf0006, 0x10, FALSE},
{0xf0006, 0xf0007, 0x11, FALSE},
{0xf0007, 0xf0020, 0x12, FALSE},
{0xf0020, 0x110000, 0, FALSE}
};
static const CheckRange
checkRanges1[]={
{0, 0}, /* dummy start range to make _testEnumRange() simpler */
{0x20, 0},
{0xa7, 0x1234},
{0x3400, 0},
{0x9fa6, 0x6162},
{0xdada, 0x3132},
{0xeeee, 0x27},
{0x11111,1},
{0x44444,0x6162},
{0xf0003,0},
{0xf0004,0xf},
{0xf0006,0x10},
{0xf0007,0x11},
{0xf0020,0x12},
{0x110000, 0}
};
/* set some interesting overlapping ranges */
static const SetRange
setRanges2[]={
{0x21, 0x7f, 0x5555, TRUE},
{0x2f800,0x2fedc, 0x7a, TRUE},
{0x72, 0xdd, 3, TRUE},
{0xdd, 0xde, 4, FALSE},
{0x2f987,0x2fa98, 5, TRUE},
{0x2f777,0x2f833, 0, TRUE},
{0x2f900,0x2ffee, 1, FALSE},
{0x2ffee,0x2ffef, 2, TRUE}
};
static const CheckRange
checkRanges2[]={
{0, 0}, /* dummy start range to make _testEnumRange() simpler */
{0x21, 0},
{0x72, 0x5555},
{0xdd, 3},
{0xde, 4},
{0x2f833,0},
{0x2f987,0x7a},
{0x2fa98,5},
{0x2fedc,0x7a},
{0x2ffee,1},
{0x2ffef,2},
{0x110000, 0}
};
/* use a non-zero initial value */
static const SetRange
setRanges3[]={
{0x31, 0xa4, 1, FALSE},
{0x3400, 0x6789, 2, FALSE},
{0x30000,0x34567,9, TRUE},
{0x45678,0x56789,3, TRUE}
};
static const CheckRange
checkRanges3[]={
{0, 9}, /* dummy start range, also carries the initial value */
{0x31, 9},
{0xa4, 1},
{0x3400, 9},
{0x6789, 2},
{0x45678,9},
{0x56789,3},
{0x110000,9}
};
static void
TrieTest(void) {
testTrieRanges4("set1",
setRanges1, ARRAY_LENGTH(setRanges1),
checkRanges1, ARRAY_LENGTH(checkRanges1));
testTrieRanges4("set2-overlap",
setRanges2, ARRAY_LENGTH(setRanges2),
checkRanges2, ARRAY_LENGTH(checkRanges2));
testTrieRanges4("set3-initial-9",
setRanges3, ARRAY_LENGTH(setRanges3),
checkRanges3, ARRAY_LENGTH(checkRanges3));
}
#if 1
void
addTrieTest(TestNode** root);
void
addTrieTest(TestNode** root) {
addTest(root, &TrieTest, "tsutil/TrieTest");
}
#else
/* standalone utrie development */
int main(int argc, const char *argv[]) {
TrieTest();
return 0;
}
#endif
--- NEW FILE: uenumtst.c ---
/*
*******************************************************************************
*
* Copyright (C) 2002-2003, International Business Machines
* Corporation and others. All Rights Reserved.
*
*******************************************************************************
* file name: uenumtst.c
* encoding: US-ASCII
* tab size: 8 (not used)
* indentation:2
*
* created on: 2002jul08
* created by: Vladimir Weinstein
*/
#include "cintltst.h"
#include "uenumimp.h"
#include "cmemory.h"
#include "cstring.h"
#include "unicode/ustring.h"
static char quikBuf[256];
static char* quikU2C(const UChar* str, int32_t len) {
u_UCharsToChars(str, quikBuf, len);
quikBuf[len] = 0;
return quikBuf;
}
static const char* test1[] = {
"first",
"second",
"third",
"fourth"
};
struct chArrayContext {
int32_t currIndex;
int32_t maxIndex;
char *currChar;
UChar *currUChar;
char **array;
};
typedef struct chArrayContext chArrayContext;
#define cont ((chArrayContext *)en->context)
static void U_CALLCONV
chArrayClose(UEnumeration *en) {
if(cont->currUChar != NULL) {
free(cont->currUChar);
cont->currUChar = NULL;
}
free(en);
}
static int32_t U_CALLCONV
chArrayCount(UEnumeration *en, UErrorCode *status) {
return cont->maxIndex;
}
static const UChar* U_CALLCONV
chArrayUNext(UEnumeration *en, int32_t *resultLength, UErrorCode *status) {
if(cont->currIndex >= cont->maxIndex) {
return NULL;
}
if(cont->currUChar == NULL) {
cont->currUChar = (UChar *)malloc(1024*sizeof(UChar));
}
cont->currChar = (cont->array)[cont->currIndex];
*resultLength = uprv_strlen(cont->currChar);
u_charsToUChars(cont->currChar, cont->currUChar, *resultLength);
cont->currIndex++;
return cont->currUChar;
}
static const char* U_CALLCONV
chArrayNext(UEnumeration *en, int32_t *resultLength, UErrorCode *status) {
if(cont->currIndex >= cont->maxIndex) {
return NULL;
}
cont->currChar = (cont->array)[cont->currIndex];
*resultLength = uprv_strlen(cont->currChar);
cont->currIndex++;
return cont->currChar;
}
static void U_CALLCONV
chArrayReset(UEnumeration *en, UErrorCode *status) {
cont->currIndex = 0;
}
chArrayContext myCont = {
0, 0,
NULL, NULL,
NULL
};
UEnumeration chEnum = {
NULL,
&myCont,
chArrayClose,
chArrayCount,
chArrayUNext,
chArrayNext,
chArrayReset
};
static const UEnumeration emptyEnumerator = {
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
};
static const UEnumeration emptyPartialEnumerator = {
NULL,
NULL,
NULL,
NULL,
uenum_unextDefault,
NULL,
NULL,
};
/********************************************************************/
static const UChar _first[] = {102,105,114,115,116,0}; /* "first" */
static const UChar _second[]= {115,101,99,111,110,100,0}; /* "second" */
static const UChar _third[] = {116,104,105,114,100,0}; /* "third" */
static const UChar _fourth[]= {102,111,117,114,116,104,0};/* "fourth" */
static const UChar* test2[] = {
_first, _second, _third, _fourth
};
struct uchArrayContext {
int32_t currIndex;
int32_t maxIndex;
UChar *currUChar;
UChar **array;
};
typedef struct uchArrayContext uchArrayContext;
#define ucont ((uchArrayContext *)en->context)
static void U_CALLCONV
uchArrayClose(UEnumeration *en) {
free(en);
}
static int32_t U_CALLCONV
uchArrayCount(UEnumeration *en, UErrorCode *status) {
return ucont->maxIndex;
}
static const UChar* U_CALLCONV
uchArrayUNext(UEnumeration *en, int32_t *resultLength, UErrorCode *status) {
if(ucont->currIndex >= ucont->maxIndex) {
return NULL;
}
ucont->currUChar = (ucont->array)[ucont->currIndex];
*resultLength = u_strlen(ucont->currUChar);
ucont->currIndex++;
return ucont->currUChar;
}
static void U_CALLCONV
uchArrayReset(UEnumeration *en, UErrorCode *status) {
ucont->currIndex = 0;
}
uchArrayContext myUCont = {
0, 0,
NULL, NULL
};
UEnumeration uchEnum = {
NULL,
&myUCont,
uchArrayClose,
uchArrayCount,
uchArrayUNext,
uenum_nextDefault,
uchArrayReset
};
/********************************************************************/
static UEnumeration *getchArrayEnum(const char** source, int32_t size) {
UEnumeration *en = (UEnumeration *)malloc(sizeof(UEnumeration));
memcpy(en, &chEnum, sizeof(UEnumeration));
cont->array = (char **)source;
cont->maxIndex = size;
return en;
}
static void EnumerationTest(void) {
UErrorCode status = U_ZERO_ERROR;
int32_t len = 0;
UEnumeration *en = getchArrayEnum(test1, sizeof(test1)/sizeof(test1[0]));
const char *string = NULL;
const UChar *uString = NULL;
while ((string = uenum_next(en, &len, &status))) {
log_verbose("read \"%s\", length %i\n", string, len);
}
uenum_reset(en, &status);
while ((uString = uenum_unext(en, &len, &status))) {
log_verbose("read \"%s\" (UChar), length %i\n", quikU2C(uString, len), len);
}
uenum_close(en);
}
static void EmptyEnumerationTest(void) {
UErrorCode status = U_ZERO_ERROR;
UEnumeration *emptyEnum = uprv_malloc(sizeof(UEnumeration));
uprv_memcpy(emptyEnum, &emptyEnumerator, sizeof(UEnumeration));
if (uenum_count(emptyEnum, &status) != -1 || status != U_UNSUPPORTED_ERROR) {
log_err("uenum_count failed\n");
}
status = U_ZERO_ERROR;
if (uenum_next(emptyEnum, NULL, &status) != NULL || status != U_UNSUPPORTED_ERROR) {
log_err("uenum_next failed\n");
}
status = U_ZERO_ERROR;
if (uenum_unext(emptyEnum, NULL, &status) != NULL || status != U_UNSUPPORTED_ERROR) {
log_err("uenum_unext failed\n");
}
status = U_ZERO_ERROR;
uenum_reset(emptyEnum, &status);
if (status != U_UNSUPPORTED_ERROR) {
log_err("uenum_reset failed\n");
}
uenum_close(emptyEnum);
status = U_ZERO_ERROR;
if (uenum_next(NULL, NULL, &status) != NULL || status != U_ZERO_ERROR) {
log_err("uenum_next(NULL) failed\n");
}
status = U_ZERO_ERROR;
if (uenum_unext(NULL, NULL, &status) != NULL || status != U_ZERO_ERROR) {
log_err("uenum_unext(NULL) failed\n");
}
status = U_ZERO_ERROR;
uenum_reset(NULL, &status);
if (status != U_ZERO_ERROR) {
log_err("uenum_reset(NULL) failed\n");
}
emptyEnum = uprv_malloc(sizeof(UEnumeration));
uprv_memcpy(emptyEnum, &emptyPartialEnumerator, sizeof(UEnumeration));
status = U_ZERO_ERROR;
if (uenum_unext(emptyEnum, NULL, &status) != NULL || status != U_UNSUPPORTED_ERROR) {
log_err("partial uenum_unext failed\n");
}
uenum_close(emptyEnum);
}
static UEnumeration *getuchArrayEnum(const UChar** source, int32_t size) {
UEnumeration *en = (UEnumeration *)malloc(sizeof(UEnumeration));
memcpy(en, &uchEnum, sizeof(UEnumeration));
ucont->array = (UChar **)source;
ucont->maxIndex = size;
return en;
}
static void DefaultNextTest(void) {
UErrorCode status = U_ZERO_ERROR;
int32_t len = 0;
UEnumeration *en = getuchArrayEnum(test2, sizeof(test2)/sizeof(test2[0]));
const char *string = NULL;
const UChar *uString = NULL;
while ((uString = uenum_unext(en, &len, &status))) {
log_verbose("read \"%s\" (UChar), length %i\n", quikU2C(uString, len), len);
}
if (U_FAILURE(status)) {
log_err("FAIL: uenum_unext => %s\n", u_errorName(status));
}
uenum_reset(en, &status);
while ((string = uenum_next(en, &len, &status))) {
log_verbose("read \"%s\", length %i\n", string, len);
}
if (U_FAILURE(status)) {
log_err("FAIL: uenum_next => %s\n", u_errorName(status));
}
uenum_close(en);
}
void addEnumerationTest(TestNode** root);
void addEnumerationTest(TestNode** root)
{
addTest(root, &EnumerationTest, "tsutil/uenumtst/EnumerationTest");
addTest(root, &EmptyEnumerationTest, "tsutil/uenumtst/EmptyEnumerationTest");
addTest(root, &DefaultNextTest, "tsutil/uenumtst/DefaultNextTest");
}
--- NEW FILE: usettest.c ---
/*
**********************************************************************
* Copyright (c) 2002-2003, International Business Machines
* Corporation and others. All Rights Reserved.
**********************************************************************
* $Source: /usr/local/cvsroot/icu-sword/source/test/cintltst/usettest.c,v $
**********************************************************************
*/
#include "unicode/uset.h"
#include "unicode/ustring.h"
#include "cintltst.h"
#include <stdlib.h>
#include <string.h>
#define LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0]))
#define TEST(x) addTest(root, &x, "uset/" # x)
static void TestAPI(void);
static void Testj2269(void);
static void TestSerialized(void);
void addUSetTest(TestNode** root);
static void expect(const USet* set,
const char* inList,
const char* outList,
UErrorCode* ec);
static void expectContainment(const USet* set,
const char* list,
UBool isIn);
static char oneUCharToChar(UChar32 c);
static void expectItems(const USet* set,
const char* items);
void
addUSetTest(TestNode** root) {
TEST(TestAPI);
TEST(Testj2269);
TEST(TestSerialized);
}
/*------------------------------------------------------------------
* Tests
*------------------------------------------------------------------*/
static void Testj2269() {
UErrorCode status = U_ZERO_ERROR;
UChar a[4] = { 0x61, 0x62, 0x63, 0 };
USet *s = uset_open(1, 0);
uset_addString(s, a, 3);
a[0] = 0x63; a[1] = 0x63;
expect(s, "{abc}", "{ccc}", &status);
uset_close(s);
}
static const UChar PAT[] = {91,97,45,99,123,97,98,125,93,0}; /* "[a-c{ab}]" */
static const int32_t PAT_LEN = (sizeof(PAT) / sizeof(PAT[0])) - 1;
static const UChar STR_bc[] = {98,99,0}; /* "bc" */
static const int32_t STR_bc_LEN = (sizeof(STR_bc) / sizeof(STR_bc[0])) - 1;
static const UChar STR_ab[] = {97,98,0}; /* "ab" */
static const int32_t STR_ab_LEN = (sizeof(STR_ab) / sizeof(STR_ab[0])) - 1;
/**
* Basic API test for uset.x
*/
static void TestAPI() {
USet* set;
UErrorCode ec;
/* [] */
set = uset_open(1, 1);
uset_clear(set);
expect(set, "", "abc{ab}", NULL);
uset_close(set);
/* [ABC] */
set = uset_open(0x0041, 0x0043);
expect(set, "ABC", "DEF{ab}", NULL);
uset_close(set);
/* [a-c{ab}] */
ec = U_ZERO_ERROR;
set = uset_openPattern(PAT, PAT_LEN, &ec);
if(U_FAILURE(ec)) {
log_data_err("uset_openPattern([a-c{ab}]) failed - %s\n", u_errorName(ec));
return;
}
expect(set, "abc{ab}", "def{bc}", &ec);
/* [a-d{ab}] */
uset_add(set, 0x64);
expect(set, "abcd{ab}", "ef{bc}", NULL);
/* [acd{ab}{bc}] */
uset_remove(set, 0x62);
uset_addString(set, STR_bc, STR_bc_LEN);
expect(set, "acd{ab}{bc}", "bef{cd}", NULL);
/* [acd{bc}] */
uset_removeString(set, STR_ab, STR_ab_LEN);
expect(set, "acd{bc}", "bfg{ab}", NULL);
/* [^acd{bc}] */
uset_complement(set);
expect(set, "bef{bc}", "acd{ac}", NULL);
/* [a-e{bc}] */
uset_complement(set);
uset_addRange(set, 0x0062, 0x0065);
expect(set, "abcde{bc}", "fg{ab}", NULL);
/* [de{bc}] */
uset_removeRange(set, 0x0050, 0x0063);
expect(set, "de{bc}", "bcfg{ab}", NULL);
uset_close(set);
}
/*------------------------------------------------------------------
* Support
*------------------------------------------------------------------*/
/**
* Verifies that the given set contains the characters and strings in
* inList, and does not contain those in outList. Also verifies that
* 'set' is not NULL and that 'ec' succeeds.
* @param set the set to test, or NULL (on error)
* @param inList list of set contents, in iteration order. Format is
* list of individual strings, in iteration order, followed by sorted
* list of strings, delimited by {}. This means we do not test
* characters '{' or '}' and we do not test strings containing those
* characters either.
* @param outList list of things not in the set. Same format as
* inList.
* @param ec an error code, checked for success. May be NULL in which
* case it is ignored.
*/
static void expect(const USet* set,
const char* inList,
const char* outList,
UErrorCode* ec) {
if (ec!=NULL && U_FAILURE(*ec)) {
log_err("FAIL: %s\n", u_errorName(*ec));
return;
}
if (set == NULL) {
log_err("FAIL: USet is NULL\n");
return;
}
expectContainment(set, inList, TRUE);
expectContainment(set, outList, FALSE);
expectItems(set, inList);
}
static void expectContainment(const USet* set,
const char* list,
UBool isIn) {
const char* p = list;
UChar ustr[128];
char pat[128];
UErrorCode ec;
int32_t rangeStart = -1, rangeEnd = -1;
ec = U_ZERO_ERROR;
uset_toPattern(set, ustr, sizeof(ustr), TRUE, &ec);
u_UCharsToChars(ustr, pat, u_strlen(ustr)+1);
while (*p) {
if (*p=='{') {
const char* stringStart = ++p;
int32_t stringLength = 0;
char strCopy[64];
while (*p++ != '}') {}
stringLength = p - stringStart - 1;
strncpy(strCopy, stringStart, stringLength);
strCopy[stringLength] = 0;
u_charsToUChars(stringStart, ustr, stringLength);
if (uset_containsString(set, ustr, stringLength) == isIn) {
log_verbose("Ok: %s %s \"%s\"\n", pat,
(isIn ? "contains" : "does not contain"),
strCopy);
} else {
log_err("FAIL: %s %s \"%s\"\n", pat,
(isIn ? "does not contain" : "contains"),
strCopy);
}
}
else {
UChar32 c;
u_charsToUChars(p, ustr, 1);
c = ustr[0];
if (uset_contains(set, c) == isIn) {
log_verbose("Ok: %s %s '%c'\n", pat,
(isIn ? "contains" : "does not contain"),
*p);
} else {
log_err("FAIL: %s %s '%c'\n", pat,
(isIn ? "does not contain" : "contains"),
*p);
}
/* Test the range API too by looking for ranges */
if (c == rangeEnd+1) {
rangeEnd = c;
} else {
if (rangeStart >= 0) {
if (uset_containsRange(set, rangeStart, rangeEnd) == isIn) {
log_verbose("Ok: %s %s U+%04X-U+%04X\n", pat,
(isIn ? "contains" : "does not contain"),
rangeStart, rangeEnd);
} else {
log_err("FAIL: %s %s U+%04X-U+%04X\n", pat,
(isIn ? "does not contain" : "contains"),
rangeStart, rangeEnd);
}
}
rangeStart = rangeEnd = c;
}
++p;
}
}
if (rangeStart >= 0) {
if (uset_containsRange(set, rangeStart, rangeEnd) == isIn) {
log_verbose("Ok: %s %s U+%04X-U+%04X\n", pat,
(isIn ? "contains" : "does not contain"),
rangeStart, rangeEnd);
} else {
log_err("FAIL: %s %s U+%04X-U+%04X\n", pat,
(isIn ? "does not contain" : "contains"),
rangeStart, rangeEnd);
}
}
}
/* This only works for BMP chars */
static char oneUCharToChar(UChar32 c) {
UChar ubuf[1];
char buf[1];
ubuf[0] = (UChar) c;
u_UCharsToChars(ubuf, buf, 1);
return buf[0];
}
static void expectItems(const USet* set,
const char* items) {
const char* p = items;
UChar ustr[128], itemStr[128];
char pat[128], buf[128];
UErrorCode ec;
int32_t expectedSize = 0;
int32_t itemCount = uset_getItemCount(set);
int32_t itemIndex = 0;
UChar32 start = 1, end = 0;
int32_t itemLen = 0;
ec = U_ZERO_ERROR;
uset_toPattern(set, ustr, sizeof(ustr), TRUE, &ec);
if (U_FAILURE(ec)) {
log_err("FAIL: uset_toPattern => %s\n", u_errorName(ec));
return;
}
u_UCharsToChars(ustr, pat, u_strlen(ustr)+1);
if (uset_isEmpty(set) != (strlen(items)==0)) {
log_err("FAIL: %s should return %s from isEmpty\n",
pat,
strlen(items)==0 ? "TRUE" : "FALSE");
}
/* Don't test patterns starting with "[^" */
if (strlen(pat) > 2 && pat[1] == '^') {
return;
}
while (*p) {
++expectedSize;
if (start > end || start == -1) {
/* Fetch our next item */
if (itemIndex >= itemCount) {
log_err("FAIL: ran out of items iterating %s\n", pat);
return;
}
itemLen = uset_getItem(set, itemIndex, &start, &end,
itemStr, sizeof(itemStr), &ec);
if (U_FAILURE(ec) || itemLen < 0) {
log_err("FAIL: uset_getItem => %s\n", u_errorName(ec));
return;
}
if (itemLen == 0) {
log_verbose("Ok: %s item %d is %c-%c\n", pat,
itemIndex, oneUCharToChar(start),
oneUCharToChar(end));
} else {
itemStr[itemLen] = 0;
u_UCharsToChars(itemStr, buf, itemLen+1);
log_verbose("Ok: %s item %d is \"%s\"\n", pat, itemIndex, buf);
}
++itemIndex;
}
if (*p=='{') {
const char* stringStart = ++p;
int32_t stringLength = 0;
char strCopy[64];
while (*p++ != '}') {}
stringLength = p - stringStart - 1;
strncpy(strCopy, stringStart, stringLength);
strCopy[stringLength] = 0;
u_charsToUChars(stringStart, ustr, stringLength);
ustr[stringLength] = 0;
if (itemLen == 0) {
log_err("FAIL: for %s expect \"%s\" next, but got a char\n",
pat, strCopy);
return;
}
if (u_strcmp(ustr, itemStr) != 0) {
log_err("FAIL: for %s expect \"%s\" next\n",
pat, strCopy);
return;
}
}
else {
UChar32 c;
u_charsToUChars(p, ustr, 1);
c = ustr[0];
if (itemLen != 0) {
log_err("FAIL: for %s expect '%c' next, but got a string\n",
pat, *p);
return;
}
if (c != start++) {
log_err("FAIL: for %s expect '%c' next\n",
pat, *p);
return;
}
++p;
}
}
if (uset_size(set) == expectedSize) {
log_verbose("Ok: %s size is %d\n", pat, expectedSize);
} else {
log_err("FAIL: %s size is %d, expected %d\n",
pat, uset_size(set), expectedSize);
}
}
static void
TestSerialized() {
uint16_t buffer[1000];
USerializedSet sset;
USet *set;
UErrorCode errorCode;
UChar32 c;
int32_t length;
/* use a pattern that generates both BMP and supplementary code points */
U_STRING_DECL(pattern, "[:Cf:]", 6);
U_STRING_INIT(pattern, "[:Cf:]", 6);
errorCode=U_ZERO_ERROR;
set=uset_openPattern(pattern, -1, &errorCode);
if(U_FAILURE(errorCode)) {
log_data_err("uset_openPattern([:Cf:]) failed - %s\n", u_errorName(errorCode));
return;
}
length=uset_serialize(set, buffer, LENGTHOF(buffer), &errorCode);
if(U_FAILURE(errorCode)) {
log_err("unable to uset_serialize([:Cf:]) - %s\n", u_errorName(errorCode));
uset_close(set);
return;
}
uset_getSerializedSet(&sset, buffer, length);
for(c=0; c<=0x10ffff; ++c) {
if(uset_contains(set, c)!=uset_serializedContains(&sset, c)) {
log_err("uset_contains(U+%04x)!=uset_serializedContains(U+%04x)\n", c);
break;
}
}
uset_close(set);
}
/*eof*/
- Previous message: [sword-cvs] icu-sword/source/tools/genprops .cvsignore,1.2,1.3 Makefile.in,1.3,1.4 genprops.8.in,NONE,1.1 genprops.c,1.3,1.4 genprops.dsp,1.2,1.3 genprops.h,1.2,1.3 genprops.vcproj,NONE,1.1 props2.c,NONE,1.1 propsvec.c,NONE,1.1 propsvec.h,NONE,1.1 store.c,1.2,1.3
- Next message: [sword-cvs] icu-sword/source/i18n/unicode calendar.h,1.3,1.4 choicfmt.h,1.2,1.3 coleitr.h,1.3,1.4 coll.h,1.3,1.4 datefmt.h,1.3,1.4 dcfmtsym.h,1.3,1.4 decimfmt.h,1.6,1.7 dtfmtsym.h,1.2,1.3 fieldpos.h,1.2,1.3 fmtable.h,1.2,1.3 format.h,1.2,1.3 gregocal.h,1.3,1.4 msgfmt.h,1.2,1.3 numfmt.h,1.3,1.4 rbnf.h,1.3,1.4 regex.h,NONE,1.1 search.h,1.4,1.5 simpletz.h,1.2,1.3 smpdtfmt.h,1.3,1.4 sortkey.h,1.3,1.4 stsearch.h,1.4,1.5 tblcoll.h,1.3,1.4 timezone.h,1.3,1.4 translit.h,1.4,1.5 ucal.h,1.3,1.4 ucol.h,1.4,1.5 ucoleitr.h,1.3,1.4 ucurr.h,NONE,1.1 udat.h,1.4,1.5 umsg.h,1.3,1.4 unifltlg.h,1.3,1.4 unirepl.h,NONE,1.1 unum.h,1.4,1.5 usearch.h,1.3,1.4 utrans.h,1.4,1.5
- Messages sorted by:
[ date ]
[ thread ]
[ subject ]
[ author ]