[apple/icu.git] / icuSources / test / cintltst / utexttst.c

// © 2016 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html
/********************************************************************
 * COPYRIGHT: 
 * Copyright (c) 2005-2013, International Business Machines Corporation and
 * others. All Rights Reserved.
 ********************************************************************/
/*
* File utexttst.c
*
* Modification History:
*
*   Date          Name               Description
*   06/13/2005    Andy Heninger      Creation 
*******************************************************************************
*/

#include "unicode/utypes.h"
#include "unicode/utext.h"
#include "unicode/ustring.h"
#include "cintltst.h"
#include "memory.h"
#include "string.h"


static void TestAPI(void);
void addUTextTest(TestNode** root);


void
addUTextTest(TestNode** root)
{
  addTest(root, &TestAPI           ,    "tsutil/UTextTest/TestAPI");
}


#define TEST_ASSERT(x) \
   {if ((x)==FALSE) {log_err("Test failure in file %s at line %d\n", __FILE__, __LINE__);\
                     gFailed = TRUE;\
   }}


#define TEST_SUCCESS(status) \
   {if (U_FAILURE(status)) {log_err("Test failure in file %s at line %d. Error = \"%s\"\n", \
       __FILE__, __LINE__, u_errorName(status)); \
       gFailed = TRUE;\
   }}


/*
 *  TestAPI   verify that the UText API is accessible from C programs.
 *            This is not intended to be a complete test of the API functionality.  That is
 *            in the C++ intltest program.
 *            This test is intended to check that everything can be accessed and built in 
 *            a pure C enviornment.
 */


static void TestAPI(void) {
    UErrorCode      status = U_ZERO_ERROR;
    UBool           gFailed = FALSE;
    (void)gFailed;   /* Suppress set but not used warning. */

    /* Open    */
    {
        UText           utLoc = UTEXT_INITIALIZER;
        const char *    cString = "\x61\x62\x63\x64";
        UChar           uString[]  = {0x41, 0x42, 0x43, 0};
        UText          *uta;
        UText          *utb;
        UChar           c;

        uta = utext_openUChars(NULL, uString, -1, &status);
        TEST_SUCCESS(status);
        c = utext_next32(uta);
        TEST_ASSERT(c == 0x41);
        utb = utext_close(uta); 
        TEST_ASSERT(utb == NULL);

        uta = utext_openUTF8(&utLoc, cString, -1, &status);
        TEST_SUCCESS(status);
        TEST_ASSERT(uta == &utLoc);

        uta = utext_close(&utLoc);
        TEST_ASSERT(uta == &utLoc);
    }

    /* utext_clone()  */
    {
        UChar   uString[]  = {0x41, 0x42, 0x43, 0};
        int64_t len;
        UText   *uta;
        UText   *utb;

        status = U_ZERO_ERROR;
        uta = utext_openUChars(NULL, uString, -1, &status);
        TEST_SUCCESS(status);
        utb = utext_clone(NULL, uta, FALSE, FALSE, &status);
        TEST_SUCCESS(status);
        TEST_ASSERT(utb != NULL);
        TEST_ASSERT(utb != uta);
        len = utext_nativeLength(uta);
        TEST_ASSERT(len == u_strlen(uString));
        utext_close(uta);
        utext_close(utb);
    }

    /* basic access functions  */
    {
        UChar     uString[]  = {0x41, 0x42, 0x43, 0};
        UText     *uta;
        UChar32   c;
        int64_t   len;
        UBool     b;
        int64_t   i;

        status = U_ZERO_ERROR;
        uta = utext_openUChars(NULL, uString, -1, &status);
        TEST_ASSERT(uta!=NULL);
        TEST_SUCCESS(status);
        b = utext_isLengthExpensive(uta);
        TEST_ASSERT(b==TRUE);
        len = utext_nativeLength(uta);
        TEST_ASSERT(len == u_strlen(uString));
        b = utext_isLengthExpensive(uta);
        TEST_ASSERT(b==FALSE);

        c = utext_char32At(uta, 0);
        TEST_ASSERT(c==uString[0]);
        
        c = utext_current32(uta);
        TEST_ASSERT(c==uString[0]);

        c = utext_next32(uta);
        TEST_ASSERT(c==uString[0]);
        c = utext_current32(uta);
        TEST_ASSERT(c==uString[1]);

        c = utext_previous32(uta);
        TEST_ASSERT(c==uString[0]);
        c = utext_current32(uta);
        TEST_ASSERT(c==uString[0]);

        c = utext_next32From(uta, 1);
        TEST_ASSERT(c==uString[1]);
        c = utext_next32From(uta, u_strlen(uString));
        TEST_ASSERT(c==U_SENTINEL);

        c = utext_previous32From(uta, 2);
        TEST_ASSERT(c==uString[1]);
        i = utext_getNativeIndex(uta);
        TEST_ASSERT(i == 1);

        utext_setNativeIndex(uta, 0);
        b = utext_moveIndex32(uta, 1);
        TEST_ASSERT(b==TRUE);
        i = utext_getNativeIndex(uta);
        TEST_ASSERT(i==1);

        b = utext_moveIndex32(uta, u_strlen(uString)-1);
        TEST_ASSERT(b==TRUE);
        i = utext_getNativeIndex(uta);
        TEST_ASSERT(i==u_strlen(uString));

        b = utext_moveIndex32(uta, 1);
        TEST_ASSERT(b==FALSE);
        i = utext_getNativeIndex(uta);
        TEST_ASSERT(i==u_strlen(uString));

        utext_setNativeIndex(uta, 0);
        c = UTEXT_NEXT32(uta);
        TEST_ASSERT(c==uString[0]);
        c = utext_current32(uta);
        TEST_ASSERT(c==uString[1]);

        c = UTEXT_PREVIOUS32(uta);
        TEST_ASSERT(c==uString[0]);
        c = UTEXT_PREVIOUS32(uta);
        TEST_ASSERT(c==U_SENTINEL);


        utext_close(uta);
    }

    {
        /*
         * UText opened on a NULL string with zero length
         */
        UText    *uta;
        UChar32   c;

        status = U_ZERO_ERROR;
        uta = utext_openUChars(NULL, NULL, 0, &status);
        TEST_SUCCESS(status);
        c = UTEXT_NEXT32(uta);
        TEST_ASSERT(c == U_SENTINEL);
        utext_close(uta);

        uta = utext_openUTF8(NULL, NULL, 0, &status);
        TEST_SUCCESS(status);
        c = UTEXT_NEXT32(uta);
        TEST_ASSERT(c == U_SENTINEL);
        utext_close(uta);
    }


    {
        /*
         * extract
         */
        UText     *uta;
        UChar     uString[]  = {0x41, 0x42, 0x43, 0};
        UChar     buf[100];
        int32_t   i;
        /* Test pinning of input bounds */
        UChar     uString2[]  = {0x41, 0x42, 0x43, 0x44, 0x45,
                                 0x46, 0x47, 0x48, 0x49, 0x4A, 0};
        UChar *   uString2Ptr = uString2 + 5;

        status = U_ZERO_ERROR;
        uta = utext_openUChars(NULL, uString, -1, &status);
        TEST_SUCCESS(status);

        status = U_ZERO_ERROR;
        i = utext_extract(uta, 0, 100, NULL, 0, &status);
        TEST_ASSERT(status==U_BUFFER_OVERFLOW_ERROR);
        TEST_ASSERT(i == u_strlen(uString));

        status = U_ZERO_ERROR;
        memset(buf, 0, sizeof(buf));
        i = utext_extract(uta, 0, 100, buf, 100, &status);
        TEST_SUCCESS(status);
        TEST_ASSERT(i == u_strlen(uString));
        i = u_strcmp(uString, buf);
        TEST_ASSERT(i == 0);
        utext_close(uta);

        /* Test pinning of input bounds */
        status = U_ZERO_ERROR;
        uta = utext_openUChars(NULL, uString2Ptr, -1, &status);
        TEST_SUCCESS(status);

        status = U_ZERO_ERROR;
        memset(buf, 0, sizeof(buf));
        i = utext_extract(uta, -3, 20, buf, 100, &status);
        TEST_SUCCESS(status);
        TEST_ASSERT(i == u_strlen(uString2Ptr));
        i = u_strcmp(uString2Ptr, buf);
        TEST_ASSERT(i == 0);
        utext_close(uta);
    }

    {
        /*
         *  Copy, Replace, isWritable
         *    Can't create an editable UText from plain C, so all we
         *    can easily do is check that errors returned.
         */
        UText     *uta;
        UChar     uString[]  = {0x41, 0x42, 0x43, 0};
        UBool     b;

        status = U_ZERO_ERROR;
        uta = utext_openUChars(NULL, uString, -1, &status);
        TEST_SUCCESS(status);

        b = utext_isWritable(uta);
        TEST_ASSERT(b == FALSE);

        b = utext_hasMetaData(uta);
        TEST_ASSERT(b == FALSE);

        utext_replace(uta,
                      0, 1,     /* start, limit */
                      uString, -1,  /* replacement, replacement length */
                      &status);
        TEST_ASSERT(status == U_NO_WRITE_PERMISSION);


        utext_copy(uta,
                   0, 1,         /* start, limit      */
                   2,            /* destination index */
                   FALSE,        /* move flag         */
                   &status);
        TEST_ASSERT(status == U_NO_WRITE_PERMISSION);

        utext_close(uta);
    }


}
Commit	Line	Data
f3c0d7a5 A	1	// © 2016 and later: Unicode, Inc. and others.
f3c0d7a5 A	2	// License & terms of use: http://www.unicode.org/copyright.html
73c04bcf A	3	/********************************************************************
73c04bcf A	4	* COPYRIGHT:
57a6839d	5	* Copyright (c) 2005-2013, International Business Machines Corporation and
73c04bcf A	6	* others. All Rights Reserved.
	7	********************************************************************/
	8	/*
	9	* File utexttst.c
	10	*
	11	* Modification History:
	12	*
	13	* Date Name Description
	14	* 06/13/2005 Andy Heninger Creation
	15	*******************************************************************************
	16	*/
	17
	18	#include "unicode/utypes.h"
	19	#include "unicode/utext.h"
	20	#include "unicode/ustring.h"
	21	#include "cintltst.h"
	22	#include "memory.h"
	23	#include "string.h"
	24
	25
	26	static void TestAPI(void);
	27	void addUTextTest(TestNode** root);
	28
	29
	30	void
	31	addUTextTest(TestNode** root)
	32	{
	33	addTest(root, &TestAPI , "tsutil/UTextTest/TestAPI");
	34	}
	35
	36
	37	#define TEST_ASSERT(x) \
	38	{if ((x)==FALSE) {log_err("Test failure in file %s at line %d\n", __FILE__, __LINE__);\
	39	gFailed = TRUE;\
	40	}}
	41
	42
	43	#define TEST_SUCCESS(status) \
	44	{if (U_FAILURE(status)) {log_err("Test failure in file %s at line %d. Error = \"%s\"\n", \
	45	__FILE__, __LINE__, u_errorName(status)); \
	46	gFailed = TRUE;\
	47	}}
	48
	49
	50
	51	/*
	52	* TestAPI verify that the UText API is accessible from C programs.
	53	* This is not intended to be a complete test of the API functionality. That is
	54	* in the C++ intltest program.
	55	* This test is intended to check that everything can be accessed and built in
	56	* a pure C enviornment.
	57	*/
	58
	59
	60	static void TestAPI(void) {
	61	UErrorCode status = U_ZERO_ERROR;
	62	UBool gFailed = FALSE;
57a6839d	63	(void)gFailed; /* Suppress set but not used warning. */
73c04bcf A	64
	65	/* Open */
	66	{
	67	UText utLoc = UTEXT_INITIALIZER;
	68	const char * cString = "\x61\x62\x63\x64";
	69	UChar uString[] = {0x41, 0x42, 0x43, 0};
	70	UText *uta;
	71	UText *utb;
	72	UChar c;
	73
	74	uta = utext_openUChars(NULL, uString, -1, &status);
	75	TEST_SUCCESS(status);
	76	c = utext_next32(uta);
	77	TEST_ASSERT(c == 0x41);
	78	utb = utext_close(uta);
	79	TEST_ASSERT(utb == NULL);
	80
	81	uta = utext_openUTF8(&utLoc, cString, -1, &status);
	82	TEST_SUCCESS(status);
	83	TEST_ASSERT(uta == &utLoc);
	84
	85	uta = utext_close(&utLoc);
	86	TEST_ASSERT(uta == &utLoc);
	87	}
	88
	89	/* utext_clone() */
	90	{
	91	UChar uString[] = {0x41, 0x42, 0x43, 0};
	92	int64_t len;
	93	UText *uta;
	94	UText *utb;
	95
	96	status = U_ZERO_ERROR;
	97	uta = utext_openUChars(NULL, uString, -1, &status);
	98	TEST_SUCCESS(status);
	99	utb = utext_clone(NULL, uta, FALSE, FALSE, &status);
	100	TEST_SUCCESS(status);
	101	TEST_ASSERT(utb != NULL);
	102	TEST_ASSERT(utb != uta);
	103	len = utext_nativeLength(uta);
	104	TEST_ASSERT(len == u_strlen(uString));
	105	utext_close(uta);
	106	utext_close(utb);
	107	}
	108
	109	/* basic access functions */
	110	{
	111	UChar uString[] = {0x41, 0x42, 0x43, 0};
	112	UText *uta;
	113	UChar32 c;
	114	int64_t len;
	115	UBool b;
	116	int64_t i;
	117
	118	status = U_ZERO_ERROR;
	119	uta = utext_openUChars(NULL, uString, -1, &status);
	120	TEST_ASSERT(uta!=NULL);
	121	TEST_SUCCESS(status);
	122	b = utext_isLengthExpensive(uta);
	123	TEST_ASSERT(b==TRUE);
	124	len = utext_nativeLength(uta);
	125	TEST_ASSERT(len == u_strlen(uString));
	126	b = utext_isLengthExpensive(uta);
	127	TEST_ASSERT(b==FALSE);
128
129	c = utext_char32At(uta, 0);
130	TEST_ASSERT(c==uString[0]);
131
132	c = utext_current32(uta);
133	TEST_ASSERT(c==uString[0]);
134
135	c = utext_next32(uta);
136	TEST_ASSERT(c==uString[0]);
137	c = utext_current32(uta);
138	TEST_ASSERT(c==uString[1]);
139
140	c = utext_previous32(uta);
141	TEST_ASSERT(c==uString[0]);
142	c = utext_current32(uta);
143	TEST_ASSERT(c==uString[0]);
144
145	c = utext_next32From(uta, 1);
146	TEST_ASSERT(c==uString[1]);
147	c = utext_next32From(uta, u_strlen(uString));
148	TEST_ASSERT(c==U_SENTINEL);
149
150	c = utext_previous32From(uta, 2);
151	TEST_ASSERT(c==uString[1]);
152	i = utext_getNativeIndex(uta);
153	TEST_ASSERT(i == 1);
154
155	utext_setNativeIndex(uta, 0);
156	b = utext_moveIndex32(uta, 1);
157	TEST_ASSERT(b==TRUE);
158	i = utext_getNativeIndex(uta);
159	TEST_ASSERT(i==1);
160
161	b = utext_moveIndex32(uta, u_strlen(uString)-1);
162	TEST_ASSERT(b==TRUE);
163	i = utext_getNativeIndex(uta);
164	TEST_ASSERT(i==u_strlen(uString));
165
166	b = utext_moveIndex32(uta, 1);
167	TEST_ASSERT(b==FALSE);
168	i = utext_getNativeIndex(uta);
169	TEST_ASSERT(i==u_strlen(uString));
170
171	utext_setNativeIndex(uta, 0);
172	c = UTEXT_NEXT32(uta);
173	TEST_ASSERT(c==uString[0]);
174	c = utext_current32(uta);
175	TEST_ASSERT(c==uString[1]);
176
177	c = UTEXT_PREVIOUS32(uta);
178	TEST_ASSERT(c==uString[0]);
179	c = UTEXT_PREVIOUS32(uta);
180	TEST_ASSERT(c==U_SENTINEL);
181
182
183	utext_close(uta);
184	}
185
729e4ab9 A	186	{
	187	/*
	188	* UText opened on a NULL string with zero length
	189	*/
	190	UText *uta;
	191	UChar32 c;
	192
	193	status = U_ZERO_ERROR;
	194	uta = utext_openUChars(NULL, NULL, 0, &status);
	195	TEST_SUCCESS(status);
	196	c = UTEXT_NEXT32(uta);
	197	TEST_ASSERT(c == U_SENTINEL);
	198	utext_close(uta);
	199
	200	uta = utext_openUTF8(NULL, NULL, 0, &status);
	201	TEST_SUCCESS(status);
	202	c = UTEXT_NEXT32(uta);
	203	TEST_ASSERT(c == U_SENTINEL);
	204	utext_close(uta);
	205	}
	206
	207
73c04bcf A	208	{
	209	/*
	210	* extract
	211	*/
	212	UText *uta;
	213	UChar uString[] = {0x41, 0x42, 0x43, 0};
	214	UChar buf[100];
	215	int32_t i;
729e4ab9 A	216	/* Test pinning of input bounds */
	217	UChar uString2[] = {0x41, 0x42, 0x43, 0x44, 0x45,
	218	0x46, 0x47, 0x48, 0x49, 0x4A, 0};
	219	UChar * uString2Ptr = uString2 + 5;
73c04bcf A	220
	221	status = U_ZERO_ERROR;
	222	uta = utext_openUChars(NULL, uString, -1, &status);
	223	TEST_SUCCESS(status);
	224
	225	status = U_ZERO_ERROR;
	226	i = utext_extract(uta, 0, 100, NULL, 0, &status);
	227	TEST_ASSERT(status==U_BUFFER_OVERFLOW_ERROR);
	228	TEST_ASSERT(i == u_strlen(uString));
	229
	230	status = U_ZERO_ERROR;
	231	memset(buf, 0, sizeof(buf));
	232	i = utext_extract(uta, 0, 100, buf, 100, &status);
	233	TEST_SUCCESS(status);
	234	TEST_ASSERT(i == u_strlen(uString));
	235	i = u_strcmp(uString, buf);
	236	TEST_ASSERT(i == 0);
	237	utext_close(uta);
729e4ab9 A	238
	239	/* Test pinning of input bounds */
	240	status = U_ZERO_ERROR;
	241	uta = utext_openUChars(NULL, uString2Ptr, -1, &status);
	242	TEST_SUCCESS(status);
	243
	244	status = U_ZERO_ERROR;
	245	memset(buf, 0, sizeof(buf));
	246	i = utext_extract(uta, -3, 20, buf, 100, &status);
	247	TEST_SUCCESS(status);
	248	TEST_ASSERT(i == u_strlen(uString2Ptr));
	249	i = u_strcmp(uString2Ptr, buf);
	250	TEST_ASSERT(i == 0);
	251	utext_close(uta);
73c04bcf A	252	}
	253
	254	{
	255	/*
	256	* Copy, Replace, isWritable
	257	* Can't create an editable UText from plain C, so all we
	258	* can easily do is check that errors returned.
	259	*/
	260	UText *uta;
	261	UChar uString[] = {0x41, 0x42, 0x43, 0};
	262	UBool b;
	263
	264	status = U_ZERO_ERROR;
	265	uta = utext_openUChars(NULL, uString, -1, &status);
	266	TEST_SUCCESS(status);
	267
	268	b = utext_isWritable(uta);
	269	TEST_ASSERT(b == FALSE);
	270
	271	b = utext_hasMetaData(uta);
	272	TEST_ASSERT(b == FALSE);
	273
	274	utext_replace(uta,
	275	0, 1, /* start, limit */
	276	uString, -1, /* replacement, replacement length */
	277	&status);
	278	TEST_ASSERT(status == U_NO_WRITE_PERMISSION);
	279
	280
	281	utext_copy(uta,
	282	0, 1, /* start, limit */
	283	2, /* destination index */
	284	FALSE, /* move flag */
	285	&status);
	286	TEST_ASSERT(status == U_NO_WRITE_PERMISSION);
	287
	288	utext_close(uta);
	289	}
	290
	291
	292	}
	293