[apple/icu.git] / icuSources / test / intltest / v32test.cpp

/********************************************************************
 * COPYRIGHT:
 * Copyright (c) 2002-2007, International Business Machines Corporation and
 * others. All Rights Reserved.
 ********************************************************************/

//
//   regextst.cpp
//
//      ICU Regular Expressions test, part of intltest.
//

#include "intltest.h"

#include "v32test.h"
#include "uvectr32.h"
#include "uvector.h"
#include "util.h"
#include <stdlib.h>
#include <stdio.h>


//---------------------------------------------------------------------------
//
//  Test class boilerplate
//
//---------------------------------------------------------------------------
UVector32Test::UVector32Test() 
{
}


UVector32Test::~UVector32Test()
{
}


void UVector32Test::runIndexedTest( int32_t index, UBool exec, const char* &name, char* /*par*/ )
{
    if (exec) logln("TestSuite UVector32Test: ");
    switch (index) {

        case 0: name = "UVector32_API";
            if (exec) UVector32_API(); 
            break;
        default: name = ""; 
            break; //needed to end loop
    }
}


//---------------------------------------------------------------------------
//
//   Error Checking / Reporting macros used in all of the tests.
//
//---------------------------------------------------------------------------
#define TEST_CHECK_STATUS(status) \
    if (U_FAILURE(status)) {\
        errln("UVector32Test failure at line %d.  status=%s\n", __LINE__, u_errorName(status));\
        return;\
    }

#define TEST_ASSERT(expr) \
    if ((expr)==FALSE) {\
        errln("UVector32Test failure at line %d.\n", __LINE__);\
    }

//---------------------------------------------------------------------------
//
//      UVector32_API      Check for basic functionality of UVector32.
//
//---------------------------------------------------------------------------
void UVector32Test::UVector32_API() {

    UErrorCode  status = U_ZERO_ERROR;
    UVector32     *a;
    UVector32     *b;

    a = new UVector32(status);
    TEST_CHECK_STATUS(status);
    delete a;

    status = U_ZERO_ERROR;
    a = new UVector32(2000, status);
    TEST_CHECK_STATUS(status);
    delete a;

    //
    //  assign()
    //
    status = U_ZERO_ERROR;
    a = new UVector32(status);
    a->addElement(10, status);
    a->addElement(20, status);
    a->addElement(30, status);
    b = new UVector32(status);
    b->assign(*a, status);
    TEST_ASSERT(b->size() == 3);
    TEST_ASSERT(b->elementAti(1) == 20);
    TEST_CHECK_STATUS(status);
    delete a;
    delete b;

    //
    //  operator == and != and equals()
    //
    status = U_ZERO_ERROR;
    a = new UVector32(status);
    a->addElement(10, status);
    a->addElement(20, status);
    a->addElement(30, status);
    b = new UVector32(status);
    TEST_ASSERT(*b != *a);
    TEST_ASSERT(!(*b == *a));
    TEST_ASSERT(!b->equals(*a));
    b->assign(*a, status);
    TEST_ASSERT(*b == *a);
    TEST_ASSERT(!(*b != *a));
    TEST_ASSERT(b->equals(*a));
    b->addElement(666, status);
    TEST_ASSERT(*b != *a);
    TEST_ASSERT(!(*b == *a));
    TEST_ASSERT(!b->equals(*a));
    TEST_CHECK_STATUS(status);
    delete b;
    delete a;

    //
    //  addElement().   Covered by above tests.
    //

    //
    // setElementAt()
    //
    status = U_ZERO_ERROR;
    a = new UVector32(status);
    a->addElement(10, status);
    a->addElement(20, status);
    a->addElement(30, status);
    a->setElementAt(666, 1);
    TEST_ASSERT(a->elementAti(0) == 10);
    TEST_ASSERT(a->elementAti(1) == 666);
    TEST_ASSERT(a->size() == 3);
    TEST_CHECK_STATUS(status);
    delete a;

    //
    // insertElementAt()
    //
    status = U_ZERO_ERROR;
    a = new UVector32(status);
    a->addElement(10, status);
    a->addElement(20, status);
    a->addElement(30, status);
    a->insertElementAt(666, 1, status);
    TEST_ASSERT(a->elementAti(0) == 10);
    TEST_ASSERT(a->elementAti(1) == 666);
    TEST_ASSERT(a->elementAti(2) == 20);
    TEST_ASSERT(a->elementAti(3) == 30);
    TEST_ASSERT(a->size() == 4);
    TEST_CHECK_STATUS(status);
    delete a;

    //
    //  elementAti()    covered by above tests
    //

    //
    //  lastElementi
    //
    status = U_ZERO_ERROR;
    a = new UVector32(status);
    a->addElement(10, status);
    a->addElement(20, status);
    a->addElement(30, status);
    TEST_ASSERT(a->lastElementi() == 30);
    TEST_CHECK_STATUS(status);
    delete a;


    //
    //  indexOf
    //
    status = U_ZERO_ERROR;
    a = new UVector32(status);
    a->addElement(10, status);
    a->addElement(20, status);
    a->addElement(30, status);
    TEST_ASSERT(a->indexOf(30, 0) == 2);
    TEST_ASSERT(a->indexOf(40, 0) == -1);
    TEST_ASSERT(a->indexOf(10, 0) == 0);
    TEST_ASSERT(a->indexOf(10, 1) == -1);
    TEST_CHECK_STATUS(status);
    delete a;

    
    //
    //  contains
    //
    status = U_ZERO_ERROR;
    a = new UVector32(status);
    a->addElement(10, status);
    a->addElement(20, status);
    a->addElement(30, status);
    TEST_ASSERT(a->contains(10) == TRUE);
    TEST_ASSERT(a->contains(11) == FALSE);
    TEST_ASSERT(a->contains(20) == TRUE);
    TEST_ASSERT(a->contains(-10) == FALSE);
    TEST_CHECK_STATUS(status);
    delete a;


    //
    //  containsAll
    //
    status = U_ZERO_ERROR;
    a = new UVector32(status);
    a->addElement(10, status);
    a->addElement(20, status);
    a->addElement(30, status);
    b = new UVector32(status);
    TEST_ASSERT(a->containsAll(*b) == TRUE);
    b->addElement(2, status);
    TEST_ASSERT(a->containsAll(*b) == FALSE);
    b->setElementAt(10, 0);
    TEST_ASSERT(a->containsAll(*b) == TRUE);
    TEST_ASSERT(b->containsAll(*a) == FALSE);
    b->addElement(30, status);
    b->addElement(20, status);
    TEST_ASSERT(a->containsAll(*b) == TRUE);
    TEST_ASSERT(b->containsAll(*a) == TRUE);
    b->addElement(2, status);
    TEST_ASSERT(a->containsAll(*b) == FALSE);
    TEST_ASSERT(b->containsAll(*a) == TRUE);
    TEST_CHECK_STATUS(status);
    delete a;
    delete b;

    //
    //  removeAll
    //
    status = U_ZERO_ERROR;
    a = new UVector32(status);
    a->addElement(10, status);
    a->addElement(20, status);
    a->addElement(30, status);
    b = new UVector32(status);
    a->removeAll(*b);
    TEST_ASSERT(a->size() == 3);
    b->addElement(20, status);
    a->removeAll(*b);
    TEST_ASSERT(a->size() == 2);
    TEST_ASSERT(a->contains(10)==TRUE);
    TEST_ASSERT(a->contains(30)==TRUE);
    b->addElement(10, status);
    a->removeAll(*b);
    TEST_ASSERT(a->size() == 1);
    TEST_ASSERT(a->contains(30) == TRUE);
    TEST_CHECK_STATUS(status);
    delete a;
    delete b;

    //
    // retainAll
    //
    status = U_ZERO_ERROR;
    a = new UVector32(status);
    a->addElement(10, status);
    a->addElement(20, status);
    a->addElement(30, status);
    b = new UVector32(status);
    b->addElement(10, status);
    b->addElement(20, status);
    b->addElement(30, status);
    b->addElement(15, status);
    a->retainAll(*b);
    TEST_ASSERT(a->size() == 3);
    b->removeElementAt(1);
    a->retainAll(*b);
    TEST_ASSERT(a->contains(20) == FALSE);
    TEST_ASSERT(a->size() == 2);
    b->removeAllElements();
    TEST_ASSERT(b->size() == 0);
    a->retainAll(*b);
    TEST_ASSERT(a->size() == 0);
    TEST_CHECK_STATUS(status);
    delete a;
    delete b;

    //
    //  removeElementAt   Tested above.
    //

    //
    //  removeAllElments   Tested above
    //

    //
    //  size()   tested above
    //

    //
    //  isEmpty
    //
    status = U_ZERO_ERROR;
    a = new UVector32(status);
    TEST_ASSERT(a->isEmpty() == TRUE);
    a->addElement(10, status);
    TEST_ASSERT(a->isEmpty() == FALSE);
    a->addElement(20, status);
    a->removeElementAt(0);
    TEST_ASSERT(a->isEmpty() == FALSE);
    a->removeElementAt(0);
    TEST_ASSERT(a->isEmpty() == TRUE);
    TEST_CHECK_STATUS(status);
    delete a;


    //
    // ensureCapacity, expandCapacity
    //
    status = U_ZERO_ERROR;
    a = new UVector32(status);
    TEST_ASSERT(a->isEmpty() == TRUE);
    a->addElement(10, status);
    TEST_ASSERT(a->ensureCapacity(5000, status)== TRUE);
    TEST_ASSERT(a->expandCapacity(20000, status) == TRUE);
    TEST_CHECK_STATUS(status);
    delete a;
    
    //
    // setSize
    //
    status = U_ZERO_ERROR;
    a = new UVector32(status);
    a->addElement(10, status);
    a->addElement(20, status);
    a->addElement(30, status);
    a->setSize(100);
    TEST_ASSERT(a->size() == 100);
    TEST_ASSERT(a->elementAti(0) == 10);
    TEST_ASSERT(a->elementAti(1) == 20);
    TEST_ASSERT(a->elementAti(2) == 30);
    TEST_ASSERT(a->elementAti(3) == 0);
    a->setElementAt(666, 99);
    a->setElementAt(777, 100);
    TEST_ASSERT(a->elementAti(99) == 666);
    TEST_ASSERT(a->elementAti(100) == 0);
    a->setSize(2);
    TEST_ASSERT(a->elementAti(1) == 20);
    TEST_ASSERT(a->elementAti(2) == 0);
    TEST_ASSERT(a->size() == 2);
    a->setSize(0);
    TEST_ASSERT(a->empty() == TRUE);
    TEST_ASSERT(a->size() == 0);

    TEST_CHECK_STATUS(status);
    delete a;

    //
    // containsNone
    //
    status = U_ZERO_ERROR;
    a = new UVector32(status);
    a->addElement(10, status);
    a->addElement(20, status);
    a->addElement(30, status);
    b = new UVector32(status);
    TEST_ASSERT(a->containsNone(*b) == TRUE);
    b->addElement(5, status);
    TEST_ASSERT(a->containsNone(*b) == TRUE);
    b->addElement(30, status);
    TEST_ASSERT(a->containsNone(*b) == FALSE);

    TEST_CHECK_STATUS(status);
    delete a;
    delete b;

    //
    // sortedInsert
    //
    status = U_ZERO_ERROR;
    a = new UVector32(status);
    a->sortedInsert(30, status);
    a->sortedInsert(20, status);
    a->sortedInsert(10, status);
    TEST_ASSERT(a->elementAti(0) == 10);
    TEST_ASSERT(a->elementAti(1) == 20);
    TEST_ASSERT(a->elementAti(2) == 30);

    TEST_CHECK_STATUS(status);
    delete a;

    //
    // getBuffer
    //
    status = U_ZERO_ERROR;
    a = new UVector32(status);
    a->addElement(10, status);
    a->addElement(20, status);
    int32_t *buf = a->getBuffer();
    TEST_ASSERT(buf[0] == 10);
    TEST_ASSERT(buf[1] == 20);
    a->setSize(20000);
    int32_t *resizedBuf;
    resizedBuf = a->getBuffer();
    //TEST_ASSERT(buf != resizedBuf); // The buffer might have been realloc'd
    TEST_ASSERT(resizedBuf[0] == 10);
    TEST_ASSERT(resizedBuf[1] == 20);

    TEST_CHECK_STATUS(status);
    delete a;


    //
    //  empty
    //
    status = U_ZERO_ERROR;
    a = new UVector32(status);
    TEST_ASSERT(a->empty() == TRUE);
    a->addElement(10, status);
    TEST_ASSERT(a->empty() == FALSE);
    a->addElement(20, status);
    a->removeElementAt(0);
    TEST_ASSERT(a->empty() == FALSE);
    a->removeElementAt(0);
    TEST_ASSERT(a->empty() == TRUE);
    TEST_CHECK_STATUS(status);
    delete a;


    //
    //  peeki
    //
    status = U_ZERO_ERROR;
    a = new UVector32(status);
    a->addElement(10, status);
    TEST_ASSERT(a->peeki() == 10);
    a->addElement(20, status);
    TEST_ASSERT(a->peeki() == 20);
    a->addElement(30, status);
    TEST_ASSERT(a->peeki() == 30);
    TEST_CHECK_STATUS(status);
    delete a;


    //
    // popi
    //
    status = U_ZERO_ERROR;
    a = new UVector32(status);
    a->addElement(10, status);
    a->addElement(20, status);
    a->addElement(30, status);
    TEST_ASSERT(a->popi() == 30);
    TEST_ASSERT(a->popi() == 20);
    TEST_ASSERT(a->popi() == 10);
    TEST_ASSERT(a->popi() == 0);
    TEST_ASSERT(a->isEmpty());
    TEST_CHECK_STATUS(status);
    delete a;

    //
    // push
    //
    status = U_ZERO_ERROR;
    a = new UVector32(status);
    TEST_ASSERT(a->push(10, status) == 10);
    TEST_ASSERT(a->push(20, status) == 20);
    TEST_ASSERT(a->push(30, status) == 30);
    TEST_ASSERT(a->size() == 3);
    TEST_ASSERT(a->popi() == 30);
    TEST_ASSERT(a->popi() == 20);
    TEST_ASSERT(a->popi() == 10);
    TEST_ASSERT(a->isEmpty());
    TEST_CHECK_STATUS(status);
    delete a;


    //
    // reserveBlock
    //
    status = U_ZERO_ERROR;
    a = new UVector32(status);
    a->ensureCapacity(1000, status);

    // TODO:

    TEST_CHECK_STATUS(status);
    delete a;

}
Commit	Line	Data
374ca955 A	1	/********************************************************************
374ca955 A	2	* COPYRIGHT:
46f4442e	3	* Copyright (c) 2002-2007, International Business Machines Corporation and
374ca955 A	4	* others. All Rights Reserved.
	5	********************************************************************/
	6
	7	//
	8	// regextst.cpp
	9	//
	10	// ICU Regular Expressions test, part of intltest.
	11	//
	12
	13	#include "intltest.h"
	14
	15	#include "v32test.h"
	16	#include "uvectr32.h"
	17	#include "uvector.h"
	18	#include "util.h"
	19	#include <stdlib.h>
	20	#include <stdio.h>
	21
	22
	23	//---------------------------------------------------------------------------
	24	//
	25	// Test class boilerplate
	26	//
	27	//---------------------------------------------------------------------------
	28	UVector32Test::UVector32Test()
	29	{
73c04bcf	30	}
374ca955 A	31
	32
	33	UVector32Test::~UVector32Test()
	34	{
73c04bcf	35	}
374ca955 A	36
	37
	38
	39	void UVector32Test::runIndexedTest( int32_t index, UBool exec, const char* &name, char* /par/ )
	40	{
	41	if (exec) logln("TestSuite UVector32Test: ");
	42	switch (index) {
	43
	44	case 0: name = "UVector32_API";
	45	if (exec) UVector32_API();
	46	break;
	47	default: name = "";
	48	break; //needed to end loop
	49	}
	50	}
	51
	52
	53	//---------------------------------------------------------------------------
	54	//
	55	// Error Checking / Reporting macros used in all of the tests.
	56	//
	57	//---------------------------------------------------------------------------
	58	#define TEST_CHECK_STATUS(status) \
	59	if (U_FAILURE(status)) {\
	60	errln("UVector32Test failure at line %d. status=%s\n", __LINE__, u_errorName(status));\
	61	return;\
	62	}
	63
	64	#define TEST_ASSERT(expr) \
	65	if ((expr)==FALSE) {\
46f4442e	66	errln("UVector32Test failure at line %d.\n", __LINE__);\
374ca955 A	67	}
	68
	69	//---------------------------------------------------------------------------
	70	//
	71	// UVector32_API Check for basic functionality of UVector32.
	72	//
	73	//---------------------------------------------------------------------------
	74	void UVector32Test::UVector32_API() {
	75
	76	UErrorCode status = U_ZERO_ERROR;
	77	UVector32 *a;
	78	UVector32 *b;
	79
	80	a = new UVector32(status);
	81	TEST_CHECK_STATUS(status);
	82	delete a;
	83
	84	status = U_ZERO_ERROR;
	85	a = new UVector32(2000, status);
	86	TEST_CHECK_STATUS(status);
	87	delete a;
	88
	89	//
	90	// assign()
	91	//
	92	status = U_ZERO_ERROR;
	93	a = new UVector32(status);
	94	a->addElement(10, status);
	95	a->addElement(20, status);
	96	a->addElement(30, status);
	97	b = new UVector32(status);
	98	b->assign(*a, status);
	99	TEST_ASSERT(b->size() == 3);
	100	TEST_ASSERT(b->elementAti(1) == 20);
	101	TEST_CHECK_STATUS(status);
	102	delete a;
	103	delete b;
	104
	105	//
	106	// operator == and != and equals()
	107	//
	108	status = U_ZERO_ERROR;
	109	a = new UVector32(status);
	110	a->addElement(10, status);
	111	a->addElement(20, status);
	112	a->addElement(30, status);
	113	b = new UVector32(status);
	114	TEST_ASSERT(b != a);
	115	TEST_ASSERT(!(b == a));
	116	TEST_ASSERT(!b->equals(*a));
	117	b->assign(*a, status);
	118	TEST_ASSERT(b == a);
	119	TEST_ASSERT(!(b != a));
	120	TEST_ASSERT(b->equals(*a));
	121	b->addElement(666, status);
	122	TEST_ASSERT(b != a);
	123	TEST_ASSERT(!(b == a));
	124	TEST_ASSERT(!b->equals(*a));
	125	TEST_CHECK_STATUS(status);
	126	delete b;
	127	delete a;
	128
	129	//
	130	// addElement(). Covered by above tests.
131	//
132
133	//
134	// setElementAt()
135	//
136	status = U_ZERO_ERROR;
137	a = new UVector32(status);
138	a->addElement(10, status);
139	a->addElement(20, status);
140	a->addElement(30, status);
141	a->setElementAt(666, 1);
142	TEST_ASSERT(a->elementAti(0) == 10);
143	TEST_ASSERT(a->elementAti(1) == 666);
144	TEST_ASSERT(a->size() == 3);
145	TEST_CHECK_STATUS(status);
146	delete a;
147
148	//
149	// insertElementAt()
150	//
151	status = U_ZERO_ERROR;
152	a = new UVector32(status);
153	a->addElement(10, status);
154	a->addElement(20, status);
155	a->addElement(30, status);
156	a->insertElementAt(666, 1, status);
157	TEST_ASSERT(a->elementAti(0) == 10);
158	TEST_ASSERT(a->elementAti(1) == 666);
159	TEST_ASSERT(a->elementAti(2) == 20);
160	TEST_ASSERT(a->elementAti(3) == 30);
161	TEST_ASSERT(a->size() == 4);
162	TEST_CHECK_STATUS(status);
163	delete a;
164
165	//
166	// elementAti() covered by above tests
167	//
168
169	//
170	// lastElementi
171	//
172	status = U_ZERO_ERROR;
173	a = new UVector32(status);
174	a->addElement(10, status);
175	a->addElement(20, status);
176	a->addElement(30, status);
177	TEST_ASSERT(a->lastElementi() == 30);
178	TEST_CHECK_STATUS(status);
179	delete a;
180
181
182	//
183	// indexOf
184	//
185	status = U_ZERO_ERROR;
186	a = new UVector32(status);
187	a->addElement(10, status);
188	a->addElement(20, status);
189	a->addElement(30, status);
190	TEST_ASSERT(a->indexOf(30, 0) == 2);
191	TEST_ASSERT(a->indexOf(40, 0) == -1);
192	TEST_ASSERT(a->indexOf(10, 0) == 0);
193	TEST_ASSERT(a->indexOf(10, 1) == -1);
194	TEST_CHECK_STATUS(status);
195	delete a;
196
197
198	//
199	// contains
200	//
201	status = U_ZERO_ERROR;
202	a = new UVector32(status);
203	a->addElement(10, status);
204	a->addElement(20, status);
205	a->addElement(30, status);
206	TEST_ASSERT(a->contains(10) == TRUE);
207	TEST_ASSERT(a->contains(11) == FALSE);
208	TEST_ASSERT(a->contains(20) == TRUE);
209	TEST_ASSERT(a->contains(-10) == FALSE);
210	TEST_CHECK_STATUS(status);
211	delete a;
212
213
214	//
215	// containsAll
216	//
217	status = U_ZERO_ERROR;
218	a = new UVector32(status);
219	a->addElement(10, status);
220	a->addElement(20, status);
221	a->addElement(30, status);
222	b = new UVector32(status);
223	TEST_ASSERT(a->containsAll(*b) == TRUE);
224	b->addElement(2, status);
225	TEST_ASSERT(a->containsAll(*b) == FALSE);
226	b->setElementAt(10, 0);
227	TEST_ASSERT(a->containsAll(*b) == TRUE);
228	TEST_ASSERT(b->containsAll(*a) == FALSE);
229	b->addElement(30, status);
230	b->addElement(20, status);
231	TEST_ASSERT(a->containsAll(*b) == TRUE);
232	TEST_ASSERT(b->containsAll(*a) == TRUE);
233	b->addElement(2, status);
234	TEST_ASSERT(a->containsAll(*b) == FALSE);
235	TEST_ASSERT(b->containsAll(*a) == TRUE);
236	TEST_CHECK_STATUS(status);
237	delete a;
238	delete b;
239
240	//
241	// removeAll
242	//
243	status = U_ZERO_ERROR;
244	a = new UVector32(status);
245	a->addElement(10, status);
246	a->addElement(20, status);
247	a->addElement(30, status);
248	b = new UVector32(status);
249	a->removeAll(*b);
250	TEST_ASSERT(a->size() == 3);
251	b->addElement(20, status);
252	a->removeAll(*b);
253	TEST_ASSERT(a->size() == 2);
254	TEST_ASSERT(a->contains(10)==TRUE);
255	TEST_ASSERT(a->contains(30)==TRUE);
256	b->addElement(10, status);
257	a->removeAll(*b);
258	TEST_ASSERT(a->size() == 1);
259	TEST_ASSERT(a->contains(30) == TRUE);
260	TEST_CHECK_STATUS(status);
261	delete a;
262	delete b;
263
264	//
265	// retainAll
266	//
267	status = U_ZERO_ERROR;
268	a = new UVector32(status);
269	a->addElement(10, status);
270	a->addElement(20, status);
271	a->addElement(30, status);
272	b = new UVector32(status);
273	b->addElement(10, status);
274	b->addElement(20, status);
275	b->addElement(30, status);
276	b->addElement(15, status);
277	a->retainAll(*b);
278	TEST_ASSERT(a->size() == 3);
279	b->removeElementAt(1);
280	a->retainAll(*b);
281	TEST_ASSERT(a->contains(20) == FALSE);
282	TEST_ASSERT(a->size() == 2);
283	b->removeAllElements();
284	TEST_ASSERT(b->size() == 0);
285	a->retainAll(*b);
286	TEST_ASSERT(a->size() == 0);
287	TEST_CHECK_STATUS(status);
288	delete a;
289	delete b;
290
291	//
292	// removeElementAt Tested above.
293	//
294
295	//
296	// removeAllElments Tested above
297	//
298
299	//
300	// size() tested above
301	//
302
303	//
304	// isEmpty
305	//
306	status = U_ZERO_ERROR;
307	a = new UVector32(status);
308	TEST_ASSERT(a->isEmpty() == TRUE);
309	a->addElement(10, status);
310	TEST_ASSERT(a->isEmpty() == FALSE);
311	a->addElement(20, status);
312	a->removeElementAt(0);
313	TEST_ASSERT(a->isEmpty() == FALSE);
314	a->removeElementAt(0);
315	TEST_ASSERT(a->isEmpty() == TRUE);
316	TEST_CHECK_STATUS(status);
317	delete a;
318
319
320	//
321	// ensureCapacity, expandCapacity
322	//
323	status = U_ZERO_ERROR;
324	a = new UVector32(status);
325	TEST_ASSERT(a->isEmpty() == TRUE);
326	a->addElement(10, status);
327	TEST_ASSERT(a->ensureCapacity(5000, status)== TRUE);
328	TEST_ASSERT(a->expandCapacity(20000, status) == TRUE);
329	TEST_CHECK_STATUS(status);
330	delete a;
331
332	//
333	// setSize
334	//
335	status = U_ZERO_ERROR;
336	a = new UVector32(status);
337	a->addElement(10, status);
338	a->addElement(20, status);
339	a->addElement(30, status);
340	a->setSize(100);
341	TEST_ASSERT(a->size() == 100);
342	TEST_ASSERT(a->elementAti(0) == 10);
343	TEST_ASSERT(a->elementAti(1) == 20);
344	TEST_ASSERT(a->elementAti(2) == 30);
345	TEST_ASSERT(a->elementAti(3) == 0);
346	a->setElementAt(666, 99);
347	a->setElementAt(777, 100);
348	TEST_ASSERT(a->elementAti(99) == 666);
349	TEST_ASSERT(a->elementAti(100) == 0);
350	a->setSize(2);
351	TEST_ASSERT(a->elementAti(1) == 20);
352	TEST_ASSERT(a->elementAti(2) == 0);
353	TEST_ASSERT(a->size() == 2);
354	a->setSize(0);
355	TEST_ASSERT(a->empty() == TRUE);
356	TEST_ASSERT(a->size() == 0);
357
358	TEST_CHECK_STATUS(status);
359	delete a;
360
361	//
362	// containsNone
363	//
364	status = U_ZERO_ERROR;
365	a = new UVector32(status);
366	a->addElement(10, status);
367	a->addElement(20, status);
368	a->addElement(30, status);
369	b = new UVector32(status);
370	TEST_ASSERT(a->containsNone(*b) == TRUE);
371	b->addElement(5, status);
372	TEST_ASSERT(a->containsNone(*b) == TRUE);
373	b->addElement(30, status);
374	TEST_ASSERT(a->containsNone(*b) == FALSE);
375
376	TEST_CHECK_STATUS(status);
377	delete a;
378	delete b;
379
380	//
381	// sortedInsert
382	//
383	status = U_ZERO_ERROR;
384	a = new UVector32(status);
385	a->sortedInsert(30, status);
386	a->sortedInsert(20, status);
387	a->sortedInsert(10, status);
388	TEST_ASSERT(a->elementAti(0) == 10);
389	TEST_ASSERT(a->elementAti(1) == 20);
390	TEST_ASSERT(a->elementAti(2) == 30);
391
392	TEST_CHECK_STATUS(status);
393	delete a;
394
395	//
396	// getBuffer
397	//
398	status = U_ZERO_ERROR;
399	a = new UVector32(status);
400	a->addElement(10, status);
401	a->addElement(20, status);
402	int32_t *buf = a->getBuffer();
403	TEST_ASSERT(buf[0] == 10);
404	TEST_ASSERT(buf[1] == 20);
405	a->setSize(20000);
406	int32_t *resizedBuf;
407	resizedBuf = a->getBuffer();
46f4442e	408	//TEST_ASSERT(buf != resizedBuf); // The buffer might have been realloc'd
374ca955 A	409	TEST_ASSERT(resizedBuf[0] == 10);
	410	TEST_ASSERT(resizedBuf[1] == 20);
	411
	412	TEST_CHECK_STATUS(status);
	413	delete a;
	414
	415
374ca955 A	416	//
	417	// empty
	418	//
	419	status = U_ZERO_ERROR;
	420	a = new UVector32(status);
	421	TEST_ASSERT(a->empty() == TRUE);
	422	a->addElement(10, status);
	423	TEST_ASSERT(a->empty() == FALSE);
	424	a->addElement(20, status);
	425	a->removeElementAt(0);
	426	TEST_ASSERT(a->empty() == FALSE);
	427	a->removeElementAt(0);
	428	TEST_ASSERT(a->empty() == TRUE);
	429	TEST_CHECK_STATUS(status);
	430	delete a;
	431
	432
	433	//
	434	// peeki
	435	//
	436	status = U_ZERO_ERROR;
	437	a = new UVector32(status);
	438	a->addElement(10, status);
	439	TEST_ASSERT(a->peeki() == 10);
	440	a->addElement(20, status);
	441	TEST_ASSERT(a->peeki() == 20);
	442	a->addElement(30, status);
	443	TEST_ASSERT(a->peeki() == 30);
	444	TEST_CHECK_STATUS(status);
	445	delete a;
	446
	447
	448	//
	449	// popi
	450	//
	451	status = U_ZERO_ERROR;
	452	a = new UVector32(status);
	453	a->addElement(10, status);
	454	a->addElement(20, status);
	455	a->addElement(30, status);
	456	TEST_ASSERT(a->popi() == 30);
	457	TEST_ASSERT(a->popi() == 20);
	458	TEST_ASSERT(a->popi() == 10);
	459	TEST_ASSERT(a->popi() == 0);
	460	TEST_ASSERT(a->isEmpty());
	461	TEST_CHECK_STATUS(status);
	462	delete a;
	463
	464	//
	465	// push
	466	//
	467	status = U_ZERO_ERROR;
	468	a = new UVector32(status);
	469	TEST_ASSERT(a->push(10, status) == 10);
	470	TEST_ASSERT(a->push(20, status) == 20);
	471	TEST_ASSERT(a->push(30, status) == 30);
	472	TEST_ASSERT(a->size() == 3);
	473	TEST_ASSERT(a->popi() == 30);
	474	TEST_ASSERT(a->popi() == 20);
	475	TEST_ASSERT(a->popi() == 10);
	476	TEST_ASSERT(a->isEmpty());
	477	TEST_CHECK_STATUS(status);
	478	delete a;
	479
480
481	//
482	// reserveBlock
483	//
484	status = U_ZERO_ERROR;
485	a = new UVector32(status);
486	a->ensureCapacity(1000, status);
487
488	// TODO:
489
490	TEST_CHECK_STATUS(status);
491	delete a;
492
73c04bcf	493	}
374ca955 A	494
374ca955 A	495