[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) UPRV_BLOCK_MACRO_BEGIN { \
    if ((x)==FALSE) { \
        log_err("Test failure in file %s at line %d\n", __FILE__, __LINE__); \
        gFailed = TRUE; \
    } \
} UPRV_BLOCK_MACRO_END


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


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