Mercurial > hg > webserver / file comparison

comparison: src/server/test/object.c

src/server/test/object.c

changeset 633
392ec9026b07
parent 579
e10457d74fe1
equal deleted inserted replaced
632:1defab20b477 633:392ec9026b07
34 #include <cx/compare.h> 34 #include <cx/compare.h>
35 35
36 #include "object.h" 36 #include "object.h"
37 37
38 38
39 UCX_TEST(test_expr_parse_expr_value) { 39 CX_TEST(test_expr_parse_expr_value) {
40 pool_handle_t *pool = pool_create(); 40 pool_handle_t *pool = pool_create();
41 41
42 CxList *tokens = cxLinkedListCreate(pool_allocator(pool), NULL, sizeof(cxstring)); 42 CxList *tokens = cxLinkedListCreate(pool_allocator(pool), NULL, sizeof(cxstring));
43 cxstring token = cx_str("123"); 43 cxstring token = cx_str("123");
44 cxListAdd(tokens, &token); 44 cxListAdd(tokens, &token);
45 45
46 UCX_TEST_BEGIN; 46 CX_TEST_DO {
47 47
48 size_t pos = 0; 48 size_t pos = 0;
49 NSAPIExpression *expr = expr_parse_logical_expr(pool, tokens, &pos); 49 NSAPIExpression *expr = expr_parse_logical_expr(pool, tokens, &pos);
50 50
51 UCX_TEST_ASSERT(pos == 1, "wrong token pos"); 51 CX_TEST_ASSERT(pos == 1);
52 UCX_TEST_ASSERT(expr, "expression is null"); 52 CX_TEST_ASSERT(expr);
53 UCX_TEST_ASSERT(expr->type == NSAPI_EXPRESSION_INT, "wrong type"); 53 CX_TEST_ASSERT(expr->type == NSAPI_EXPRESSION_INT);
54 54
55 UCX_TEST_END; 55 }
56 56
57 pool_destroy(pool); 57 pool_destroy(pool);
58 } 58 }
59 59
60 UCX_TEST(test_expr_parse_expr_neg_value) { 60 CX_TEST(test_expr_parse_expr_neg_value) {
61 pool_handle_t *pool = pool_create(); 61 pool_handle_t *pool = pool_create();
62 62
63 CxList *tokens = cxLinkedListCreate(pool_allocator(pool), NULL, sizeof(cxstring)); 63 CxList *tokens = cxLinkedListCreate(pool_allocator(pool), NULL, sizeof(cxstring));
64 cxstring token = cx_str("-123"); 64 cxstring token = cx_str("-123");
65 cxListAdd(tokens, &token); 65 cxListAdd(tokens, &token);
66 66
67 UCX_TEST_BEGIN; 67 CX_TEST_DO {
68 68
69 size_t pos = 0; 69 size_t pos = 0;
70 NSAPIExpression *expr = expr_parse_logical_expr(pool, tokens, &pos); 70 NSAPIExpression *expr = expr_parse_logical_expr(pool, tokens, &pos);
71 71
72 UCX_TEST_ASSERT(pos == 1, "wrong token pos"); 72 CX_TEST_ASSERT(pos == 1);
73 UCX_TEST_ASSERT(expr, "expression is null"); 73 CX_TEST_ASSERT(expr);
74 UCX_TEST_ASSERT(expr->type == NSAPI_EXPRESSION_INT, "wrong type"); 74 CX_TEST_ASSERT(expr->type == NSAPI_EXPRESSION_INT);
75 UCX_TEST_ASSERT(expr->value.i == -123, "wrong value"); 75 CX_TEST_ASSERT(expr->value.i == -123);
76 76
77 UCX_TEST_END; 77 }
78 78
79 pool_destroy(pool); 79 pool_destroy(pool);
80 } 80 }
81 81
82 UCX_TEST(test_expr_parse_expr_value_str) { 82 CX_TEST(test_expr_parse_expr_value_str) {
83 pool_handle_t *pool = pool_create(); 83 pool_handle_t *pool = pool_create();
84 84
85 CxList *tokens = cxLinkedListCreate(pool_allocator(pool), NULL, sizeof(cxstring)); 85 CxList *tokens = cxLinkedListCreate(pool_allocator(pool), NULL, sizeof(cxstring));
86 cxstring token = cx_str("\"hello world\""); 86 cxstring token = cx_str("\"hello world\"");
87 cxListAdd(tokens, &token); 87 cxListAdd(tokens, &token);
88 88
89 UCX_TEST_BEGIN; 89 CX_TEST_DO {
90 90
91 size_t pos = 0; 91 size_t pos = 0;
92 NSAPIExpression *expr = expr_parse_logical_expr(pool, tokens, &pos); 92 NSAPIExpression *expr = expr_parse_logical_expr(pool, tokens, &pos);
93 93
94 UCX_TEST_ASSERT(pos == 1, "wrong token pos"); 94 CX_TEST_ASSERT(pos == 1);
95 UCX_TEST_ASSERT(expr, "expression is null"); 95 CX_TEST_ASSERT(expr);
96 UCX_TEST_ASSERT(expr->type == NSAPI_EXPRESSION_STRING, "wrong type"); 96 CX_TEST_ASSERT(expr->type == NSAPI_EXPRESSION_STRING);
97 UCX_TEST_ASSERT(!cx_strcmp(expr->value.str, cx_str("hello world")), "wrong value"); 97 CX_TEST_ASSERT(!cx_strcmp(expr->value.str, cx_str("hello world")));
98 98
99 UCX_TEST_END; 99 }
100 100
101 pool_destroy(pool); 101 pool_destroy(pool);
102 } 102 }
103 103
104 UCX_TEST(test_expr_parse_expr_value_bool) { 104 CX_TEST(test_expr_parse_expr_value_bool) {
105 pool_handle_t *pool = pool_create(); 105 pool_handle_t *pool = pool_create();
106 106
107 CxList *tokens = cxLinkedListCreate(pool_allocator(pool), NULL, sizeof(cxstring)); 107 CxList *tokens = cxLinkedListCreate(pool_allocator(pool), NULL, sizeof(cxstring));
108 cxstring token = cx_str("true"); 108 cxstring token = cx_str("true");
109 cxListAdd(tokens, &token); 109 cxListAdd(tokens, &token);
110 110
111 UCX_TEST_BEGIN; 111 CX_TEST_DO {
112 112
113 size_t pos = 0; 113 size_t pos = 0;
114 NSAPIExpression *expr = expr_parse_logical_expr(pool, tokens, &pos); 114 NSAPIExpression *expr = expr_parse_logical_expr(pool, tokens, &pos);
115 115
116 UCX_TEST_ASSERT(pos == 1, "wrong token pos"); 116 CX_TEST_ASSERT(pos == 1);
117 UCX_TEST_ASSERT(expr, "expression is null"); 117 CX_TEST_ASSERT(expr);
118 UCX_TEST_ASSERT(expr->type == NSAPI_EXPRESSION_BOOL, "wrong type"); 118 CX_TEST_ASSERT(expr->type == NSAPI_EXPRESSION_BOOL);
119 UCX_TEST_ASSERT(expr->value.b == 1, "wrong value"); 119 CX_TEST_ASSERT(expr->value.b == 1);
120 120
121 UCX_TEST_END; 121 }
122 122
123 pool_destroy(pool); 123 pool_destroy(pool);
124 } 124 }
125 125
126 UCX_TEST(test_expr_parse_expr_value_var) { 126 CX_TEST(test_expr_parse_expr_value_var) {
127 pool_handle_t *pool = pool_create(); 127 pool_handle_t *pool = pool_create();
128 128
129 CxList *tokens = cxLinkedListCreate(pool_allocator(pool), NULL, sizeof(cxstring)); 129 CxList *tokens = cxLinkedListCreate(pool_allocator(pool), NULL, sizeof(cxstring));
130 cxstring token = cx_str("$test"); 130 cxstring token = cx_str("$test");
131 cxListAdd(tokens, &token); 131 cxListAdd(tokens, &token);
132 132
133 UCX_TEST_BEGIN; 133 CX_TEST_DO {
134 134
135 size_t pos = 0; 135 size_t pos = 0;
136 NSAPIExpression *expr = expr_parse_logical_expr(pool, tokens, &pos); 136 NSAPIExpression *expr = expr_parse_logical_expr(pool, tokens, &pos);
137 137
138 UCX_TEST_ASSERT(pos == 1, "wrong token pos"); 138 CX_TEST_ASSERT(pos == 1);
139 UCX_TEST_ASSERT(expr, "expression is null"); 139 CX_TEST_ASSERT(expr);
140 UCX_TEST_ASSERT(expr->type == NSAPI_EXPRESSION_VARIABLE, "wrong type"); 140 CX_TEST_ASSERT(expr->type == NSAPI_EXPRESSION_VARIABLE);
141 UCX_TEST_ASSERT(!cx_strcmp(expr->value.var, cx_str("test")), "wrong var name"); 141 CX_TEST_ASSERT(!cx_strcmp(expr->value.var, cx_str("test")));
142 142
143 UCX_TEST_END; 143 }
144 144
145 pool_destroy(pool); 145 pool_destroy(pool);
146 } 146 }
147 147
148 UCX_TEST(test_expr_parse_expr_not_value) { 148 CX_TEST(test_expr_parse_expr_not_value) {
149 pool_handle_t *pool = pool_create(); 149 pool_handle_t *pool = pool_create();
150 150
151 CxList *tokens = cxLinkedListCreate(pool_allocator(pool), NULL, sizeof(cxstring)); 151 CxList *tokens = cxLinkedListCreate(pool_allocator(pool), NULL, sizeof(cxstring));
152 cxstring token = cx_str("not"); 152 cxstring token = cx_str("not");
153 cxListAdd(tokens, &token); 153 cxListAdd(tokens, &token);
154 token = cx_str("true"); 154 token = cx_str("true");
155 cxListAdd(tokens, &token); 155 cxListAdd(tokens, &token);
156 156
157 UCX_TEST_BEGIN; 157 CX_TEST_DO {
158 158
159 size_t pos = 0; 159 size_t pos = 0;
160 NSAPIExpression *expr = expr_parse_logical_expr(pool, tokens, &pos); 160 NSAPIExpression *expr = expr_parse_logical_expr(pool, tokens, &pos);
161 161
162 UCX_TEST_ASSERT(pos == 2, "wrong token pos"); 162 CX_TEST_ASSERT(pos == 2);
163 UCX_TEST_ASSERT(expr, "expression is null"); 163 CX_TEST_ASSERT(expr);
164 164
165 UCX_TEST_ASSERT(expr->type == NSAPI_EXPRESSION_UNARY, "wrong root expression type"); 165 CX_TEST_ASSERT(expr->type == NSAPI_EXPRESSION_UNARY);
166 UCX_TEST_ASSERT(expr->left, "missing left expression"); 166 CX_TEST_ASSERT(expr->left);
167 UCX_TEST_ASSERT(!expr->right, "right expression should be null"); 167 CX_TEST_ASSERT(!expr->right);
168 UCX_TEST_ASSERT(expr->left->type == NSAPI_EXPRESSION_BOOL, "left expression has wrong type"); 168 CX_TEST_ASSERT(expr->left->type == NSAPI_EXPRESSION_BOOL);
169 UCX_TEST_ASSERT(expr->left->value.b == 1, "left expression has wrong value"); 169 CX_TEST_ASSERT(expr->left->value.b == 1);
170 170
171 UCX_TEST_END; 171 }
172 172
173 pool_destroy(pool); 173 pool_destroy(pool);
174 } 174 }
175 175
176 UCX_TEST(test_expr_parse_expr_sign_value) { 176 CX_TEST(test_expr_parse_expr_sign_value) {
177 pool_handle_t *pool = pool_create(); 177 pool_handle_t *pool = pool_create();
178 178
179 CxList *tokens1 = cxLinkedListCreate(pool_allocator(pool), NULL, sizeof(cxstring)); 179 CxList *tokens1 = cxLinkedListCreate(pool_allocator(pool), NULL, sizeof(cxstring));
180 cxstring token = cx_str("+"); 180 cxstring token = cx_str("+");
181 cxListAdd(tokens1, &token); 181 cxListAdd(tokens1, &token);
186 token = cx_str("-"); 186 token = cx_str("-");
187 cxListAdd(tokens2, &token); 187 cxListAdd(tokens2, &token);
188 token = cx_str("123"); 188 token = cx_str("123");
189 cxListAdd(tokens2, &token); 189 cxListAdd(tokens2, &token);
190 190
191 UCX_TEST_BEGIN; 191 CX_TEST_DO {
192 192
193 size_t pos = 0; 193 size_t pos = 0;
194 NSAPIExpression *expr = expr_parse_logical_expr(pool, tokens1, &pos); 194 NSAPIExpression *expr = expr_parse_logical_expr(pool, tokens1, &pos);
195 195
196 UCX_TEST_ASSERT(pos == 2, "test1: wrong token pos"); 196 CX_TEST_ASSERT(pos == 2);
197 UCX_TEST_ASSERT(expr, "test1: expression is null"); 197 CX_TEST_ASSERT(expr);
198 198
199 pos = 0; 199 pos = 0;
200 expr = expr_parse_logical_expr(pool, tokens2, &pos); 200 expr = expr_parse_logical_expr(pool, tokens2, &pos);
201 201
202 UCX_TEST_ASSERT(pos == 2, "test2: wrong token pos"); 202 CX_TEST_ASSERT(pos == 2);
203 UCX_TEST_ASSERT(expr, "test2: expression is null"); 203 CX_TEST_ASSERT(expr);
204 204
205 UCX_TEST_ASSERT(expr->type == NSAPI_EXPRESSION_UNARY, "wrong expression type"); 205 CX_TEST_ASSERT(expr->type == NSAPI_EXPRESSION_UNARY);
206 UCX_TEST_ASSERT(expr->operator == NSAPI_EXPRESSION_SUB, "wrong expression operator"); 206 CX_TEST_ASSERT(expr->operator == NSAPI_EXPRESSION_SUB);
207 UCX_TEST_ASSERT(expr->left, "missing left expresion"); 207 CX_TEST_ASSERT(expr->left);
208 UCX_TEST_ASSERT(expr->left->type == NSAPI_EXPRESSION_INT, "left expression has wrong type"); 208 CX_TEST_ASSERT(expr->left->type == NSAPI_EXPRESSION_INT);
209 UCX_TEST_ASSERT(expr->left->value.i == 123, "left expression has wrong value"); 209 CX_TEST_ASSERT(expr->left->value.i == 123);
210 210
211 UCX_TEST_END; 211 }
212 212
213 pool_destroy(pool); 213 pool_destroy(pool);
214 } 214 }
215 215
216 216
217 217
218 UCX_TEST(test_expr_parse_expr_compare2values) { 218 CX_TEST(test_expr_parse_expr_compare2values) {
219 pool_handle_t *pool = pool_create(); 219 pool_handle_t *pool = pool_create();
220 220
221 CxList *tokens = cxLinkedListCreate(pool_allocator(pool), NULL, sizeof(cxstring)); 221 CxList *tokens = cxLinkedListCreate(pool_allocator(pool), NULL, sizeof(cxstring));
222 cxstring token = cx_str("2"); 222 cxstring token = cx_str("2");
223 cxListAdd(tokens, &token); 223 cxListAdd(tokens, &token);
224 token = cx_str("=="); 224 token = cx_str("==");
225 cxListAdd(tokens, &token); 225 cxListAdd(tokens, &token);
226 token = cx_str("2"); 226 token = cx_str("2");
227 cxListAdd(tokens, &token); 227 cxListAdd(tokens, &token);
228 228
229 UCX_TEST_BEGIN; 229 CX_TEST_DO {
230 230
231 size_t pos = 0; 231 size_t pos = 0;
232 NSAPIExpression *expr = expr_parse_logical_expr(pool, tokens, &pos); 232 NSAPIExpression *expr = expr_parse_logical_expr(pool, tokens, &pos);
233 233
234 UCX_TEST_ASSERT(pos == 3, "wrong token pos"); 234 CX_TEST_ASSERT(pos == 3);
235 UCX_TEST_ASSERT(expr, "expression is null"); 235 CX_TEST_ASSERT(expr);
236 236
237 UCX_TEST_ASSERT(expr->type == NSAPI_EXPRESSION_BINARY, "wrong expression type"); 237 CX_TEST_ASSERT(expr->type == NSAPI_EXPRESSION_BINARY);
238 UCX_TEST_ASSERT(expr->left, "left expression is null"); 238 CX_TEST_ASSERT(expr->left);
239 UCX_TEST_ASSERT(expr->right, "right expression is null"); 239 CX_TEST_ASSERT(expr->right);
240 240
241 UCX_TEST_ASSERT(expr->left->operator == NSAPI_EXPRESSION_NOOP, "left should be a literal with no operator"); 241 CX_TEST_ASSERT(expr->left->operator == NSAPI_EXPRESSION_NOOP);
242 UCX_TEST_ASSERT(expr->right->operator == NSAPI_EXPRESSION_NOOP, "right should be a literal with no operator"); 242 CX_TEST_ASSERT(expr->right->operator == NSAPI_EXPRESSION_NOOP);
243 243
244 UCX_TEST_END; 244 }
245 245
246 pool_destroy(pool); 246 pool_destroy(pool);
247 } 247 }
248 248
249 UCX_TEST(test_expr_parse_expr_compare2value_expr) { 249 CX_TEST(test_expr_parse_expr_compare2value_expr) {
250 pool_handle_t *pool = pool_create(); 250 pool_handle_t *pool = pool_create();
251 251
252 CxList *tokens = cxLinkedListCreate(pool_allocator(pool), NULL, sizeof(cxstring)); 252 CxList *tokens = cxLinkedListCreate(pool_allocator(pool), NULL, sizeof(cxstring));
253 cxstring token = cx_str("2"); 253 cxstring token = cx_str("2");
254 cxListAdd(tokens, &token); 254 cxListAdd(tokens, &token);
259 token = cx_str("+"); 259 token = cx_str("+");
260 cxListAdd(tokens, &token); 260 cxListAdd(tokens, &token);
261 token = cx_str("1"); 261 token = cx_str("1");
262 cxListAdd(tokens, &token); 262 cxListAdd(tokens, &token);
263 263
264 UCX_TEST_BEGIN; 264 CX_TEST_DO {
265 265
266 size_t pos = 0; 266 size_t pos = 0;
267 NSAPIExpression *expr = expr_parse_logical_expr(pool, tokens, &pos); 267 NSAPIExpression *expr = expr_parse_logical_expr(pool, tokens, &pos);
268 268
269 UCX_TEST_ASSERT(pos == 5, "wrong token pos"); 269 CX_TEST_ASSERT(pos == 5);
270 UCX_TEST_ASSERT(expr, "expression is null"); 270 CX_TEST_ASSERT(expr);
271 271
272 UCX_TEST_ASSERT(expr->type == NSAPI_EXPRESSION_BINARY, "wrong expression type"); 272 CX_TEST_ASSERT(expr->type == NSAPI_EXPRESSION_BINARY);
273 UCX_TEST_ASSERT(expr->left, "left expression is null"); 273 CX_TEST_ASSERT(expr->left);
274 UCX_TEST_ASSERT(expr->right, "right expression is null"); 274 CX_TEST_ASSERT(expr->right);
275 275
276 UCX_TEST_ASSERT(expr->left->operator == NSAPI_EXPRESSION_NOOP, "left should be a literal with no operator"); 276 CX_TEST_ASSERT(expr->left->operator == NSAPI_EXPRESSION_NOOP);
277 UCX_TEST_ASSERT(expr->right->operator == NSAPI_EXPRESSION_ADD, "right should be a binary expression"); 277 CX_TEST_ASSERT(expr->right->operator == NSAPI_EXPRESSION_ADD);
278 278
279 UCX_TEST_END; 279 }
280 280
281 pool_destroy(pool); 281 pool_destroy(pool);
282 } 282 }
283 283
284 UCX_TEST(test_expr_parse_expr_compare2expr_value) { 284 CX_TEST(test_expr_parse_expr_compare2expr_value) {
285 pool_handle_t *pool = pool_create(); 285 pool_handle_t *pool = pool_create();
286 286
287 CxList *tokens = cxLinkedListCreate(pool_allocator(pool), NULL, sizeof(cxstring)); 287 CxList *tokens = cxLinkedListCreate(pool_allocator(pool), NULL, sizeof(cxstring));
288 cxstring token = cx_str("1"); 288 cxstring token = cx_str("1");
289 cxListAdd(tokens, &token); 289 cxListAdd(tokens, &token);
294 token = cx_str("=="); 294 token = cx_str("==");
295 cxListAdd(tokens, &token); 295 cxListAdd(tokens, &token);
296 token = cx_str("2"); 296 token = cx_str("2");
297 cxListAdd(tokens, &token); 297 cxListAdd(tokens, &token);
298 298
299 UCX_TEST_BEGIN; 299 CX_TEST_DO {
300 300
301 size_t pos = 0; 301 size_t pos = 0;
302 NSAPIExpression *expr = expr_parse_logical_expr(pool, tokens, &pos); 302 NSAPIExpression *expr = expr_parse_logical_expr(pool, tokens, &pos);
303 303
304 UCX_TEST_ASSERT(pos == 5, "wrong token pos"); 304 CX_TEST_ASSERT(pos == 5);
305 UCX_TEST_ASSERT(expr, "expression is null"); 305 CX_TEST_ASSERT(expr);
306 306
307 UCX_TEST_ASSERT(expr->type == NSAPI_EXPRESSION_BINARY, "wrong expression type"); 307 CX_TEST_ASSERT(expr->type == NSAPI_EXPRESSION_BINARY);
308 UCX_TEST_ASSERT(expr->left, "left expression is null"); 308 CX_TEST_ASSERT(expr->left);
309 UCX_TEST_ASSERT(expr->right, "right expression is null"); 309 CX_TEST_ASSERT(expr->right);
310 UCX_TEST_ASSERT(expr->right->value.i == 2, "right wrong value"); 310 CX_TEST_ASSERT(expr->right->value.i == 2);
311 311
312 UCX_TEST_ASSERT(expr->left->operator == NSAPI_EXPRESSION_ADD, "left should be a binary operation"); 312 CX_TEST_ASSERT(expr->left->operator == NSAPI_EXPRESSION_ADD);
313 UCX_TEST_ASSERT(expr->right->operator == NSAPI_EXPRESSION_NOOP, "right should be NOOP"); 313 CX_TEST_ASSERT(expr->right->operator == NSAPI_EXPRESSION_NOOP);
314 UCX_TEST_ASSERT(expr->left->left, "ADD-op missing left"); 314 CX_TEST_ASSERT(expr->left->left);
315 UCX_TEST_ASSERT(expr->left->right, "ADD-op missing right"); 315 CX_TEST_ASSERT(expr->left->right);
316 UCX_TEST_ASSERT(expr->left->left->value.i == 1, "ADD-op: wrong left value"); 316 CX_TEST_ASSERT(expr->left->left->value.i == 1);
317 UCX_TEST_ASSERT(expr->left->right->value.i == 1, "ADD-op: wrong right value"); 317 CX_TEST_ASSERT(expr->left->right->value.i == 1);
318 318
319 UCX_TEST_END; 319 }
320 320
321 pool_destroy(pool); 321 pool_destroy(pool);
322 } 322 }
323 323
324 UCX_TEST(test_expr_parse_expr_bracket) { 324 CX_TEST(test_expr_parse_expr_bracket) {
325 pool_handle_t *pool = pool_create(); 325 pool_handle_t *pool = pool_create();
326 326
327 // expression: 2 * (1 + 2) == 6 327 // expression: 2 * (1 + 2) == 6
328 CxList *tokens = cxLinkedListCreate(pool_allocator(pool), NULL, sizeof(cxstring)); 328 CxList *tokens = cxLinkedListCreate(pool_allocator(pool), NULL, sizeof(cxstring));
329 cxstring token = cx_str("2"); 329 cxstring token = cx_str("2");
343 token = cx_str("=="); 343 token = cx_str("==");
344 cxListAdd(tokens, &token); 344 cxListAdd(tokens, &token);
345 token = cx_str("6"); 345 token = cx_str("6");
346 cxListAdd(tokens, &token); 346 cxListAdd(tokens, &token);
347 347
348 UCX_TEST_BEGIN; 348 CX_TEST_DO {
349 349
350 size_t pos = 0; 350 size_t pos = 0;
351 NSAPIExpression *expr = expr_parse_logical_expr(pool, tokens, &pos); 351 NSAPIExpression *expr = expr_parse_logical_expr(pool, tokens, &pos);
352 352
353 UCX_TEST_ASSERT(pos == 9, "wrong token pos"); 353 CX_TEST_ASSERT(pos == 9);
354 UCX_TEST_ASSERT(expr, "expression is null"); 354 CX_TEST_ASSERT(expr);
355 UCX_TEST_ASSERT(expr->operator == NSAPI_EXPRESSION_EQ, "root: wrong operator"); 355 CX_TEST_ASSERT(expr->operator == NSAPI_EXPRESSION_EQ);
356 UCX_TEST_ASSERT(expr->left, "missing left expression"); 356 CX_TEST_ASSERT(expr->left);
357 UCX_TEST_ASSERT(expr->right, "missing right expression"); 357 CX_TEST_ASSERT(expr->right);
358 UCX_TEST_ASSERT(expr->right->type == NSAPI_EXPRESSION_INT, "right expression has wrong type"); 358 CX_TEST_ASSERT(expr->right->type == NSAPI_EXPRESSION_INT);
359 UCX_TEST_ASSERT(expr->left->operator == NSAPI_EXPRESSION_MUL, "left expression has wrong operator"); 359 CX_TEST_ASSERT(expr->left->operator == NSAPI_EXPRESSION_MUL);
360 UCX_TEST_ASSERT(expr->left->left, "mul: missing left"); 360 CX_TEST_ASSERT(expr->left->left);
361 UCX_TEST_ASSERT(expr->left->right, "mul: missing right"); 361 CX_TEST_ASSERT(expr->left->right);
362 UCX_TEST_ASSERT(expr->left->right->operator == NSAPI_EXPRESSION_ADD, "missing add operator"); 362 CX_TEST_ASSERT(expr->left->right->operator == NSAPI_EXPRESSION_ADD);
363 UCX_TEST_ASSERT(expr->left->right->left, "add: missing left"); 363 CX_TEST_ASSERT(expr->left->right->left);
364 UCX_TEST_ASSERT(expr->left->right->left, "add: missing right"); 364 CX_TEST_ASSERT(expr->left->right->left);
365 365
366 UCX_TEST_END; 366 }
367 367
368 pool_destroy(pool); 368 pool_destroy(pool);
369 } 369 }
370 370
371 UCX_TEST(test_expr_op_defined_simple) { 371 CX_TEST(test_expr_op_defined_simple) {
372 pool_handle_t *pool = pool_create(); 372 pool_handle_t *pool = pool_create();
373 373
374 CxList *tokens = cxLinkedListCreate(pool_allocator(pool), NULL, sizeof(cxstring)); 374 CxList *tokens = cxLinkedListCreate(pool_allocator(pool), NULL, sizeof(cxstring));
375 cxstring token = cx_str("defined"); 375 cxstring token = cx_str("defined");
376 cxListAdd(tokens, &token); 376 cxListAdd(tokens, &token);
377 377
378 token = cx_str("$testvar1"); 378 token = cx_str("$testvar1");
379 cxListAdd(tokens, &token); 379 cxListAdd(tokens, &token);
380 380
381 UCX_TEST_BEGIN; 381 CX_TEST_DO {
382 382
383 size_t pos = 0; 383 size_t pos = 0;
384 NSAPIExpression *expr = expr_parse_logical_expr(pool, tokens, &pos); 384 NSAPIExpression *expr = expr_parse_logical_expr(pool, tokens, &pos);
385 385
386 UCX_TEST_ASSERT(pos == 2, "wrong token pos"); 386 CX_TEST_ASSERT(pos == 2);
387 UCX_TEST_ASSERT(expr, "expression is null"); 387 CX_TEST_ASSERT(expr);
388 UCX_TEST_ASSERT(expr->type == NSAPI_EXPRESSION_UNARY, "wrong type"); 388 CX_TEST_ASSERT(expr->type == NSAPI_EXPRESSION_UNARY);
389 UCX_TEST_ASSERT(expr->operator == NSAPI_EXPRESSION_VALUE_DEFINED, "wrong operator"); 389 CX_TEST_ASSERT(expr->operator == NSAPI_EXPRESSION_VALUE_DEFINED);
390 UCX_TEST_ASSERT(expr->left, "missing left operand"); 390 CX_TEST_ASSERT(expr->left);
391 UCX_TEST_ASSERT(expr->left->type == NSAPI_EXPRESSION_VARIABLE, "operand is not a variable"); 391 CX_TEST_ASSERT(expr->left->type == NSAPI_EXPRESSION_VARIABLE);
392 392
393 UCX_TEST_END; 393 }
394 394
395 pool_destroy(pool); 395 pool_destroy(pool);
396 } 396 }
397 397
398 UCX_TEST(test_expr_op_defined) { 398 CX_TEST(test_expr_op_defined) {
399 pool_handle_t *pool = pool_create(); 399 pool_handle_t *pool = pool_create();
400 400
401 CxList *tokens = cxLinkedListCreate(pool_allocator(pool), NULL, sizeof(cxstring)); 401 CxList *tokens = cxLinkedListCreate(pool_allocator(pool), NULL, sizeof(cxstring));
402 cxstring token = cx_str("true"); 402 cxstring token = cx_str("true");
403 cxListAdd(tokens, &token); 403 cxListAdd(tokens, &token);
412 cxListAdd(tokens, &token); 412 cxListAdd(tokens, &token);
413 413
414 token = cx_str("$var"); 414 token = cx_str("$var");
415 cxListAdd(tokens, &token); 415 cxListAdd(tokens, &token);
416 416
417 UCX_TEST_BEGIN; 417 CX_TEST_DO {
418 418
419 size_t pos = 0; 419 size_t pos = 0;
420 NSAPIExpression *expr = expr_parse_logical_expr(pool, tokens, &pos); 420 NSAPIExpression *expr = expr_parse_logical_expr(pool, tokens, &pos);
421 421
422 UCX_TEST_ASSERT(pos == 5, "wrong token pos"); 422 CX_TEST_ASSERT(pos == 5);
423 UCX_TEST_ASSERT(expr, "expression is null"); 423 CX_TEST_ASSERT(expr);
424 UCX_TEST_ASSERT(expr->operator == NSAPI_EXPRESSION_EQ, "wrong operator"); 424 CX_TEST_ASSERT(expr->operator == NSAPI_EXPRESSION_EQ);
425 UCX_TEST_ASSERT(expr->left, "missing left"); 425 CX_TEST_ASSERT(expr->left);
426 UCX_TEST_ASSERT(expr->right, "missing right"); 426 CX_TEST_ASSERT(expr->right);
427 UCX_TEST_ASSERT(expr->left->type == NSAPI_EXPRESSION_BOOL, "left expression is not a bool"); 427 CX_TEST_ASSERT(expr->left->type == NSAPI_EXPRESSION_BOOL);
428 UCX_TEST_ASSERT(expr->right->operator == NSAPI_EXPRESSION_NOT, "right: wrong operator"); 428 CX_TEST_ASSERT(expr->right->operator == NSAPI_EXPRESSION_NOT);
429 UCX_TEST_ASSERT(expr->right->left, "not op: missing left"); 429 CX_TEST_ASSERT(expr->right->left);
430 UCX_TEST_ASSERT(expr->right->left->operator == NSAPI_EXPRESSION_VALUE_DEFINED, "missing defined operator"); 430 CX_TEST_ASSERT(expr->right->left->operator == NSAPI_EXPRESSION_VALUE_DEFINED);
431 431
432 UCX_TEST_END; 432 }
433 433
434 pool_destroy(pool); 434 pool_destroy(pool);
435 } 435 }
436 436
437 UCX_TEST(test_expr_op_file_exists_simple) { 437 CX_TEST(test_expr_op_file_exists_simple) {
438 pool_handle_t *pool = pool_create(); 438 pool_handle_t *pool = pool_create();
439 439
440 CxList *tokens = cxLinkedListCreate(pool_allocator(pool), NULL, sizeof(cxstring)); 440 CxList *tokens = cxLinkedListCreate(pool_allocator(pool), NULL, sizeof(cxstring));
441 cxstring token = cx_str("-e"); 441 cxstring token = cx_str("-e");
442 cxListAdd(tokens, &token); 442 cxListAdd(tokens, &token);
443 443
444 token = cx_str("\"/path/file\""); 444 token = cx_str("\"/path/file\"");
445 cxListAdd(tokens, &token); 445 cxListAdd(tokens, &token);
446 446
447 UCX_TEST_BEGIN; 447 CX_TEST_DO {
448 448
449 size_t pos = 0; 449 size_t pos = 0;
450 NSAPIExpression *expr = expr_parse_logical_expr(pool, tokens, &pos); 450 NSAPIExpression *expr = expr_parse_logical_expr(pool, tokens, &pos);
451 451
452 UCX_TEST_ASSERT(pos == 2, "wrong token pos"); 452 CX_TEST_ASSERT(pos == 2);
453 UCX_TEST_ASSERT(expr, "expression is null"); 453 CX_TEST_ASSERT(expr);
454 UCX_TEST_ASSERT(expr->type == NSAPI_EXPRESSION_UNARY, "wrong type"); 454 CX_TEST_ASSERT(expr->type == NSAPI_EXPRESSION_UNARY);
455 UCX_TEST_ASSERT(expr->operator == NSAPI_EXPRESSION_FILE_DIR_EXISTS, "wrong operator"); 455 CX_TEST_ASSERT(expr->operator == NSAPI_EXPRESSION_FILE_DIR_EXISTS);
456 UCX_TEST_ASSERT(expr->left, "missing left operand"); 456 CX_TEST_ASSERT(expr->left);
457 UCX_TEST_ASSERT(expr->left->type == NSAPI_EXPRESSION_STRING, "operand is not a string"); 457 CX_TEST_ASSERT(expr->left->type == NSAPI_EXPRESSION_STRING);
458 UCX_TEST_ASSERT(!cx_strcmp(expr->left->value.str, cx_str("/path/file")), "wrong string operand"); 458 CX_TEST_ASSERT(!cx_strcmp(expr->left->value.str, cx_str("/path/file")));
459 459
460 UCX_TEST_END; 460 }
461 461
462 pool_destroy(pool); 462 pool_destroy(pool);
463 } 463 }
464 464
465 UCX_TEST(test_expr_parse_expr_func_arg0) { 465 CX_TEST(test_expr_parse_expr_func_arg0) {
466 pool_handle_t *pool = pool_create(); 466 pool_handle_t *pool = pool_create();
467 467
468 CxList *tokens = cxLinkedListCreate(pool_allocator(pool), NULL, sizeof(cxstring)); 468 CxList *tokens = cxLinkedListCreate(pool_allocator(pool), NULL, sizeof(cxstring));
469 cxstring token = cx_str("test"); 469 cxstring token = cx_str("test");
470 cxListAdd(tokens, &token); 470 cxListAdd(tokens, &token);
471 token = cx_str("("); 471 token = cx_str("(");
472 cxListAdd(tokens, &token); 472 cxListAdd(tokens, &token);
473 token = cx_str(")"); 473 token = cx_str(")");
474 cxListAdd(tokens, &token); 474 cxListAdd(tokens, &token);
475 475
476 UCX_TEST_BEGIN; 476 CX_TEST_DO {
477 477
478 size_t pos = 0; 478 size_t pos = 0;
479 NSAPIExpression *expr = expr_parse_logical_expr(pool, tokens, &pos); 479 NSAPIExpression *expr = expr_parse_logical_expr(pool, tokens, &pos);
480 480
481 UCX_TEST_ASSERT(pos == 3, "wrong token pos"); 481 CX_TEST_ASSERT(pos == 3);
482 UCX_TEST_ASSERT(expr, "expression is null"); 482 CX_TEST_ASSERT(expr);
483 UCX_TEST_ASSERT(expr->type == NSAPI_EXPRESSION_IDENTIFIER, "wrong expression type"); 483 CX_TEST_ASSERT(expr->type == NSAPI_EXPRESSION_IDENTIFIER);
484 UCX_TEST_ASSERT(expr->operator == NSAPI_EXPRESSION_CALL, "wrong expression operator"); 484 CX_TEST_ASSERT(expr->operator == NSAPI_EXPRESSION_CALL);
485 UCX_TEST_ASSERT(!expr->left, "left is not null"); 485 CX_TEST_ASSERT(!expr->left);
486 UCX_TEST_ASSERT(!expr->right, "right is not null"); 486 CX_TEST_ASSERT(!expr->right);
487 487
488 UCX_TEST_END; 488 }
489 489
490 pool_destroy(pool); 490 pool_destroy(pool);
491 } 491 }
492 492
493 493
516 516
517 return 0; 517 return 0;
518 } 518 }
519 519
520 520
521 UCX_TEST(test_expr_parse_expr_func_arg1) { 521 CX_TEST(test_expr_parse_expr_func_arg1) {
522 pool_handle_t *pool = pool_create(); 522 pool_handle_t *pool = pool_create();
523 523
524 CxList *tokens = cxLinkedListCreate(pool_allocator(pool), NULL, sizeof(cxstring)); 524 CxList *tokens = cxLinkedListCreate(pool_allocator(pool), NULL, sizeof(cxstring));
525 cxstring token = cx_str("test"); 525 cxstring token = cx_str("test");
526 cxListAdd(tokens, &token); 526 cxListAdd(tokens, &token);
529 token = cx_str("1"); 529 token = cx_str("1");
530 cxListAdd(tokens, &token); 530 cxListAdd(tokens, &token);
531 token = cx_str(")"); 531 token = cx_str(")");
532 cxListAdd(tokens, &token); 532 cxListAdd(tokens, &token);
533 533
534 UCX_TEST_BEGIN; 534 CX_TEST_DO {
535 535
536 size_t pos = 0; 536 size_t pos = 0;
537 NSAPIExpression *expr = expr_parse_logical_expr(pool, tokens, &pos); 537 NSAPIExpression *expr = expr_parse_logical_expr(pool, tokens, &pos);
538 538
539 UCX_TEST_ASSERT(pos == cxListSize(tokens), "wrong token pos"); 539 CX_TEST_ASSERT(pos == cxListSize(tokens));
540 UCX_TEST_ASSERT(expr, "expression is null"); 540 CX_TEST_ASSERT(expr);
541 UCX_TEST_ASSERT(expr->type == NSAPI_EXPRESSION_IDENTIFIER, "wrong expression type"); 541 CX_TEST_ASSERT(expr->type == NSAPI_EXPRESSION_IDENTIFIER);
542 UCX_TEST_ASSERT(expr->operator == NSAPI_EXPRESSION_CALL, "wrong expression operator"); 542 CX_TEST_ASSERT(expr->operator == NSAPI_EXPRESSION_CALL);
543 543
544 size_t numArgs = 0; 544 size_t numArgs = 0;
545 NSAPIExpression args[8]; 545 NSAPIExpression args[8];
546 int err = test_get_args(args, 8, &numArgs, expr->left); 546 int err = test_get_args(args, 8, &numArgs, expr->left);
547 UCX_TEST_ASSERT(err == 0, "too much args"); 547 CX_TEST_ASSERT(err == 0);
548 UCX_TEST_ASSERT(numArgs == 1, "wrong arg count"); 548 CX_TEST_ASSERT(numArgs == 1);
549 UCX_TEST_ASSERT(args[0].value.i == 1, "wrong arg value"); 549 CX_TEST_ASSERT(args[0].value.i == 1);
550 550
551 UCX_TEST_END; 551 }
552 552
553 pool_destroy(pool); 553 pool_destroy(pool);
554 } 554 }
555 555
556 UCX_TEST(test_expr_parse_expr_func_arg3) { 556 CX_TEST(test_expr_parse_expr_func_arg3) {
557 pool_handle_t *pool = pool_create(); 557 pool_handle_t *pool = pool_create();
558 558
559 CxList *tokens = cxLinkedListCreate(pool_allocator(pool), NULL, sizeof(cxstring)); 559 CxList *tokens = cxLinkedListCreate(pool_allocator(pool), NULL, sizeof(cxstring));
560 cxstring token = cx_str("test"); 560 cxstring token = cx_str("test");
561 cxListAdd(tokens, &token); 561 cxListAdd(tokens, &token);
572 token = cx_str("3"); 572 token = cx_str("3");
573 cxListAdd(tokens, &token); 573 cxListAdd(tokens, &token);
574 token = cx_str(")"); 574 token = cx_str(")");
575 cxListAdd(tokens, &token); 575 cxListAdd(tokens, &token);
576 576
577 UCX_TEST_BEGIN; 577 CX_TEST_DO {
578 578
579 size_t pos = 0; 579 size_t pos = 0;
580 NSAPIExpression *expr = expr_parse_logical_expr(pool, tokens, &pos); 580 NSAPIExpression *expr = expr_parse_logical_expr(pool, tokens, &pos);
581 581
582 UCX_TEST_ASSERT(pos == cxListSize(tokens), "wrong token pos"); 582 CX_TEST_ASSERT(pos == cxListSize(tokens));
583 UCX_TEST_ASSERT(expr, "expression is null"); 583 CX_TEST_ASSERT(expr);
584 UCX_TEST_ASSERT(expr->type == NSAPI_EXPRESSION_IDENTIFIER, "wrong expression type"); 584 CX_TEST_ASSERT(expr->type == NSAPI_EXPRESSION_IDENTIFIER);
585 UCX_TEST_ASSERT(expr->operator == NSAPI_EXPRESSION_CALL, "wrong expression operator"); 585 CX_TEST_ASSERT(expr->operator == NSAPI_EXPRESSION_CALL);
586 586
587 size_t numArgs = 0; 587 size_t numArgs = 0;
588 NSAPIExpression args[8]; 588 NSAPIExpression args[8];
589 int err = test_get_args(args, 8, &numArgs, expr->left); 589 int err = test_get_args(args, 8, &numArgs, expr->left);
590 UCX_TEST_ASSERT(err == 0, "too much args"); 590 CX_TEST_ASSERT(err == 0);
591 UCX_TEST_ASSERT(numArgs == 3, "wrong arg count"); 591 CX_TEST_ASSERT(numArgs == 3);
592 UCX_TEST_ASSERT(args[0].value.i == 1, "arg0: wrong value"); 592 CX_TEST_ASSERT(args[0].value.i == 1);
593 UCX_TEST_ASSERT(args[1].value.i == 2, "arg1: wrong value"); 593 CX_TEST_ASSERT(args[1].value.i == 2);
594 UCX_TEST_ASSERT(args[2].value.i == 3, "arg2: wrong value"); 594 CX_TEST_ASSERT(args[2].value.i == 3);
595 595
596 UCX_TEST_END; 596 }
597 597
598 pool_destroy(pool); 598 pool_destroy(pool);
599 } 599 }
600 600
601 UCX_TEST(test_expr_parse_expr_func_expr1) { 601 CX_TEST(test_expr_parse_expr_func_expr1) {
602 pool_handle_t *pool = pool_create(); 602 pool_handle_t *pool = pool_create();
603 603
604 CxList *tokens = cxLinkedListCreate(pool_allocator(pool), NULL, sizeof(cxstring)); 604 CxList *tokens = cxLinkedListCreate(pool_allocator(pool), NULL, sizeof(cxstring));
605 cxstring token = cx_str("test"); 605 cxstring token = cx_str("test");
606 cxListAdd(tokens, &token); 606 cxListAdd(tokens, &token);
617 token = cx_str("3"); 617 token = cx_str("3");
618 cxListAdd(tokens, &token); 618 cxListAdd(tokens, &token);
619 token = cx_str(")"); 619 token = cx_str(")");
620 cxListAdd(tokens, &token); 620 cxListAdd(tokens, &token);
621 621
622 UCX_TEST_BEGIN; 622 CX_TEST_DO {
623 623
624 size_t pos = 0; 624 size_t pos = 0;
625 NSAPIExpression *expr = expr_parse_logical_expr(pool, tokens, &pos); 625 NSAPIExpression *expr = expr_parse_logical_expr(pool, tokens, &pos);
626 626
627 UCX_TEST_ASSERT(pos == cxListSize(tokens), "wrong token pos"); 627 CX_TEST_ASSERT(pos == cxListSize(tokens));
628 UCX_TEST_ASSERT(expr, "expression is null"); 628 CX_TEST_ASSERT(expr);
629 UCX_TEST_ASSERT(expr->type == NSAPI_EXPRESSION_IDENTIFIER, "wrong expression type"); 629 CX_TEST_ASSERT(expr->type == NSAPI_EXPRESSION_IDENTIFIER);
630 UCX_TEST_ASSERT(expr->operator == NSAPI_EXPRESSION_CALL, "wrong expression operator"); 630 CX_TEST_ASSERT(expr->operator == NSAPI_EXPRESSION_CALL);
631 631
632 size_t numArgs = 0; 632 size_t numArgs = 0;
633 NSAPIExpression args[8]; 633 NSAPIExpression args[8];
634 int err = test_get_args(args, 8, &numArgs, expr->left); 634 int err = test_get_args(args, 8, &numArgs, expr->left);
635 UCX_TEST_ASSERT(err == 0, "too much args"); 635 CX_TEST_ASSERT(err == 0);
636 UCX_TEST_ASSERT(numArgs == 2, "wrong arg count"); 636 CX_TEST_ASSERT(numArgs == 2);
637 UCX_TEST_ASSERT(args[0].value.i == 1, "arg0: wrong value"); 637 CX_TEST_ASSERT(args[0].value.i == 1);
638 UCX_TEST_ASSERT(args[1].operator == NSAPI_EXPRESSION_ADD, "arg1: wrong operator"); 638 CX_TEST_ASSERT(args[1].operator == NSAPI_EXPRESSION_ADD);
639 UCX_TEST_ASSERT(args[1].left && args[1].right, "arg1: missing operator values"); 639 CX_TEST_ASSERT(args[1].left && args[1].right);
640 UCX_TEST_ASSERT(args[1].left->value.i == 2 && args[1].right->value.i == 3, "arg1: wrong operator values"); 640 CX_TEST_ASSERT(args[1].left->value.i == 2 && args[1].right->value.i == 3);
641 641
642 UCX_TEST_END; 642 }
643 643
644 pool_destroy(pool); 644 pool_destroy(pool);
645 } 645 }
646 646
647 UCX_TEST(test_expr_parse_expr_func_expr2) { 647 CX_TEST(test_expr_parse_expr_func_expr2) {
648 pool_handle_t *pool = pool_create(); 648 pool_handle_t *pool = pool_create();
649 649
650 CxList *tokens = cxLinkedListCreate(pool_allocator(pool), NULL, sizeof(cxstring)); 650 CxList *tokens = cxLinkedListCreate(pool_allocator(pool), NULL, sizeof(cxstring));
651 cxstring token = cx_str("test"); 651 cxstring token = cx_str("test");
652 cxListAdd(tokens, &token); 652 cxListAdd(tokens, &token);
673 token = cx_str("6"); 673 token = cx_str("6");
674 cxListAdd(tokens, &token); 674 cxListAdd(tokens, &token);
675 token = cx_str(")"); 675 token = cx_str(")");
676 cxListAdd(tokens, &token); 676 cxListAdd(tokens, &token);
677 677
678 UCX_TEST_BEGIN; 678 CX_TEST_DO {
679 679
680 size_t pos = 0; 680 size_t pos = 0;
681 NSAPIExpression *expr = expr_parse_logical_expr(pool, tokens, &pos); 681 NSAPIExpression *expr = expr_parse_logical_expr(pool, tokens, &pos);
682 682
683 UCX_TEST_ASSERT(pos == cxListSize(tokens), "wrong token pos"); 683 CX_TEST_ASSERT(pos == cxListSize(tokens));
684 UCX_TEST_ASSERT(expr, "expression is null"); 684 CX_TEST_ASSERT(expr);
685 UCX_TEST_ASSERT(expr->type == NSAPI_EXPRESSION_IDENTIFIER, "wrong expression type"); 685 CX_TEST_ASSERT(expr->type == NSAPI_EXPRESSION_IDENTIFIER);
686 UCX_TEST_ASSERT(expr->operator == NSAPI_EXPRESSION_CALL, "wrong expression operator"); 686 CX_TEST_ASSERT(expr->operator == NSAPI_EXPRESSION_CALL);
687 687
688 size_t numArgs = 0; 688 size_t numArgs = 0;
689 NSAPIExpression args[8]; 689 NSAPIExpression args[8];
690 int err = test_get_args(args, 8, &numArgs, expr->left); 690 int err = test_get_args(args, 8, &numArgs, expr->left);
691 UCX_TEST_ASSERT(err == 0, "too much args"); 691 CX_TEST_ASSERT(err == 0);
692 UCX_TEST_ASSERT(numArgs == 3, "wrong arg count"); 692 CX_TEST_ASSERT(numArgs == 3);
693 UCX_TEST_ASSERT(args[0].operator == NSAPI_EXPRESSION_ADD, "arg0: wrong operator"); 693 CX_TEST_ASSERT(args[0].operator == NSAPI_EXPRESSION_ADD);
694 UCX_TEST_ASSERT(args[0].left && args[0].right, "arg0: missing operator values"); 694 CX_TEST_ASSERT(args[0].left && args[0].right);
695 UCX_TEST_ASSERT(args[1].operator == NSAPI_EXPRESSION_CALL, "arg1: wrong operator"); 695 CX_TEST_ASSERT(args[1].operator == NSAPI_EXPRESSION_CALL);
696 UCX_TEST_ASSERT(args[1].left, "arg1: missing args"); 696 CX_TEST_ASSERT(args[1].left);
697 UCX_TEST_ASSERT(args[2].type == NSAPI_EXPRESSION_INT, "arg2: wrong type"); 697 CX_TEST_ASSERT(args[2].type == NSAPI_EXPRESSION_INT);
698 UCX_TEST_ASSERT(args[2].value.i == 6, "arg2: wrong value"); 698 CX_TEST_ASSERT(args[2].value.i == 6);
699 699
700 UCX_TEST_END; 700 }
701 701
702 pool_destroy(pool); 702 pool_destroy(pool);
703 } 703 }

Mercurial Repository: webserver

mercurial