1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
|
// © 2016 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html
/********************************************************************
* COPYRIGHT:
* Copyright (c) 2004-2011, International Business Machines Corporation and
* others. All Rights Reserved.
********************************************************************/
// Test parts of UVector and UStack
#include "intltest.h"
#include "uvectest.h"
#include "cstring.h"
#include "hash.h"
#include "uelement.h"
#include "uvector.h"
//---------------------------------------------------------------------------
//
// Test class boilerplate
//
//---------------------------------------------------------------------------
UVectorTest::UVectorTest()
{
}
UVectorTest::~UVectorTest()
{
}
void UVectorTest::runIndexedTest( int32_t index, UBool exec, const char* &name, char* /*par*/ )
{
if (exec) logln("TestSuite UVectorTest: ");
switch (index) {
case 0: name = "UVector_API";
if (exec) UVector_API();
break;
case 1: name = "UStack_API";
if (exec) UStack_API();
break;
case 2: name = "Hashtable_API";
if (exec) Hashtable_API();
break;
default: name = "";
break; //needed to end loop
}
}
//---------------------------------------------------------------------------
//
// Error Checking / Reporting macros used in all of the tests.
//
//---------------------------------------------------------------------------
#define TEST_CHECK_STATUS(status) UPRV_BLOCK_MACRO_BEGIN {\
if (U_FAILURE(status)) {\
errln("UVectorTest failure at line %d. status=%s\n", __LINE__, u_errorName(status));\
return;\
}\
} UPRV_BLOCK_MACRO_END
#define TEST_ASSERT(expr) UPRV_BLOCK_MACRO_BEGIN {\
if ((expr)==false) {\
errln("UVectorTest failure at line %d.\n", __LINE__);\
}\
} UPRV_BLOCK_MACRO_END
static int32_t U_CALLCONV
UVectorTest_compareInt32(UElement key1, UElement key2) {
if (key1.integer > key2.integer) {
return 1;
}
else if (key1.integer < key2.integer) {
return -1;
}
return 0;
}
U_CDECL_BEGIN
static UBool U_CALLCONV
UVectorTest_compareCstrings(const UElement key1, const UElement key2) {
return !strcmp((const char *)key1.pointer, (const char *)key2.pointer);
}
U_CDECL_END
//---------------------------------------------------------------------------
//
// UVector_API Check for basic functionality of UVector.
//
//---------------------------------------------------------------------------
void UVectorTest::UVector_API() {
UErrorCode status = U_ZERO_ERROR;
UVector *a;
a = new UVector(status);
TEST_CHECK_STATUS(status);
delete a;
status = U_ZERO_ERROR;
a = new UVector(2000, status);
TEST_CHECK_STATUS(status);
delete a;
status = U_ZERO_ERROR;
a = new UVector(status);
a->sortedInsert(static_cast<int32_t>(10), UVectorTest_compareInt32, status);
a->sortedInsert(static_cast<int32_t>(20), UVectorTest_compareInt32, status);
a->sortedInsert(static_cast<int32_t>(30), UVectorTest_compareInt32, status);
a->sortedInsert(static_cast<int32_t>(15), UVectorTest_compareInt32, status);
TEST_CHECK_STATUS(status);
TEST_ASSERT(a->elementAti(0) == 10);
TEST_ASSERT(a->elementAti(1) == 15);
TEST_ASSERT(a->elementAti(2) == 20);
TEST_ASSERT(a->elementAti(3) == 30);
TEST_ASSERT(a->indexOf((int32_t)3) == -1);
TEST_ASSERT(a->indexOf((int32_t)15) == 1);
TEST_ASSERT(a->indexOf((int32_t)15, 2) == -1);
TEST_ASSERT(a->contains((int32_t)15));
TEST_ASSERT(!a->contains((int32_t)5));
delete a;
status = U_ZERO_ERROR;
UVector vec(status);
vec.setDeleter(uprv_deleteUObject);
vec.adoptElement(new UnicodeString(), status);
vec.adoptElement(new UnicodeString(), status);
assertSuccess(WHERE, status);
assertEquals(WHERE, 2, vec.size());
// With an incoming error, adoptElement will not add to the vector,
// and will delete the object. Failure here will show as a memory leak.
status = U_ILLEGAL_ARGUMENT_ERROR;
vec.adoptElement(new UnicodeString(), status);
assertEquals(WHERE, U_ILLEGAL_ARGUMENT_ERROR, status);
assertEquals(WHERE, 2, vec.size());
}
void UVectorTest::UStack_API() {
UErrorCode status = U_ZERO_ERROR;
UStack *a;
a = new UStack(status);
TEST_CHECK_STATUS(status);
delete a;
status = U_ZERO_ERROR;
a = new UStack(2000, status);
TEST_CHECK_STATUS(status);
delete a;
status = U_ZERO_ERROR;
a = new UStack(nullptr, nullptr, 2000, status);
TEST_CHECK_STATUS(status);
delete a;
status = U_ZERO_ERROR;
a = new UStack(nullptr, UVectorTest_compareCstrings, status);
TEST_ASSERT(a->empty());
a->push((void*)"abc", status);
TEST_ASSERT(!a->empty());
a->push((void*)"bcde", status);
a->push((void*)"cde", status);
TEST_CHECK_STATUS(status);
TEST_ASSERT(strcmp("cde", (const char *)a->peek()) == 0);
TEST_ASSERT(a->search((void*)"cde") == 1);
TEST_ASSERT(a->search((void*)"bcde") == 2);
TEST_ASSERT(a->search((void*)"abc") == 3);
TEST_ASSERT(strcmp("abc", (const char *)a->firstElement()) == 0);
TEST_ASSERT(strcmp("cde", (const char *)a->lastElement()) == 0);
TEST_ASSERT(strcmp("cde", (const char *)a->pop()) == 0);
TEST_ASSERT(strcmp("bcde", (const char *)a->pop()) == 0);
TEST_ASSERT(strcmp("abc", (const char *)a->pop()) == 0);
delete a;
}
U_CDECL_BEGIN
static UBool U_CALLCONV neverTRUE(const UElement /*key1*/, const UElement /*key2*/) {
return false;
}
U_CDECL_END
void UVectorTest::Hashtable_API() {
UErrorCode status = U_ZERO_ERROR;
Hashtable *a = new Hashtable(status);
TEST_ASSERT((a->puti("a", 1, status) == 0));
TEST_ASSERT((a->find("a") != nullptr));
TEST_ASSERT((a->find("b") == nullptr));
TEST_ASSERT((a->puti("b", 2, status) == 0));
TEST_ASSERT((a->find("b") != nullptr));
TEST_ASSERT((a->removei("a") == 1));
TEST_ASSERT((a->find("a") == nullptr));
/* verify that setValueComparator works */
Hashtable b(status);
TEST_ASSERT((!a->equals(b)));
TEST_ASSERT((b.puti("b", 2, status) == 0));
TEST_ASSERT((!a->equals(b))); // Without a value comparator, this will be false by default.
b.setValueComparator(uhash_compareLong);
TEST_ASSERT((!a->equals(b)));
a->setValueComparator(uhash_compareLong);
TEST_ASSERT((a->equals(b)));
TEST_ASSERT((a->equals(*a))); // This better be reflexive.
/* verify that setKeyComparator works */
TEST_ASSERT((a->puti("a", 1, status) == 0));
TEST_ASSERT((a->find("a") != nullptr));
a->setKeyComparator(neverTRUE);
TEST_ASSERT((a->find("a") == nullptr));
delete a;
}
|
