1 |
/* |
2 |
openisis - an open implementation of the CDS/ISIS database |
3 |
Version 0.8.x (patchlevel see file Version) |
4 |
Copyright (C) 2001-2003 by Erik Grziwotz, erik@openisis.org |
5 |
|
6 |
This library is free software; you can redistribute it and/or |
7 |
modify it under the terms of the GNU Lesser General Public |
8 |
License as published by the Free Software Foundation; either |
9 |
version 2.1 of the License, or (at your option) any later version. |
10 |
|
11 |
This library is distributed in the hope that it will be useful, |
12 |
but WITHOUT ANY WARRANTY; without even the implied warranty of |
13 |
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
14 |
Lesser General Public License for more details. |
15 |
|
16 |
You should have received a copy of the GNU Lesser General Public |
17 |
License along with this library; if not, write to the Free Software |
18 |
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
19 |
|
20 |
see README for more information |
21 |
EOH */ |
22 |
|
23 |
/* |
24 |
$Id: lstbtest.c,v 1.23 2003/06/30 09:52:03 kripke Exp $ |
25 |
tests for lstb methods. |
26 |
*/ |
27 |
|
28 |
#include <errno.h> |
29 |
#include <stdarg.h> |
30 |
#include <stdio.h> |
31 |
#include <stdlib.h> |
32 |
#include <string.h> |
33 |
#include <unistd.h> /* unlink */ |
34 |
|
35 |
#include "openisis.h" |
36 |
#include "loi.h" |
37 |
#include "ldb.h" /* ldb_getdb */ |
38 |
#include "luti.h" /* luti_unwrap */ |
39 |
|
40 |
static int _RspCld[1] = { 0 }; |
41 |
static int _DelCld[1] = { 0 }; |
42 |
|
43 |
static OpenIsisStubCbData cbdta; |
44 |
static Stub st0, st1, st2, st3; |
45 |
static Schema *sc0, *sc1, *sc2, *sc3; |
46 |
static Db *db; |
47 |
static Rec *rqs, *rsp; |
48 |
static char *args[64]; |
49 |
static int alen; |
50 |
|
51 |
|
52 |
/* ************************************************************ |
53 |
utils |
54 |
*/ |
55 |
|
56 |
static void _lstb_assert (int cond, const char *where, char *fmt, ...) { |
57 |
if (! cond) { |
58 |
va_list ap; |
59 |
va_start (ap, fmt); |
60 |
fprintf (stderr, "ERR %s: ", where ? where : ""); |
61 |
vfprintf (stderr, fmt, ap); |
62 |
fprintf (stderr, "\n"); |
63 |
va_end (ap); |
64 |
exit (1); |
65 |
} |
66 |
} |
67 |
|
68 |
static int _rsp_cb (void *cld, Stub stb, Rec *rsprec, Db *x) { |
69 |
(void)stb; (void)rsprec; (void)x; |
70 |
if (cld) { |
71 |
++(*((int*)cld)); |
72 |
} |
73 |
return 0; |
74 |
} |
75 |
|
76 |
static void _del_cb (void *cld, Stub stb, void *cbd) { |
77 |
(void)stb; |
78 |
++(*((int*)cld)); |
79 |
if (cbd) { |
80 |
_lstb_assert (cbd == (void*)_RspCld, "DELCB", |
81 |
"%d: %p != %p", *((int*)cld), cbd, _RspCld); |
82 |
--(*((int*)cbd)); |
83 |
} |
84 |
} |
85 |
|
86 |
static void _cmp_rec (const char *msg, Rec *r1, Rec *r2) { |
87 |
char buf1[32], buf2[32]; |
88 |
Field *f1, *f2; |
89 |
int j; |
90 |
_lstb_assert (0 != r1, msg, "chkr: r1 == 0"); |
91 |
_lstb_assert (0 != r2, msg, "chkr: r2 == 0"); |
92 |
_lstb_assert (r1->len == r2->len, msg, "chkr: reclen = %d/%d", |
93 |
r1->len, r2->len); |
94 |
buf1[31] = buf2[31] = 0; |
95 |
for (f1 = r1->field, f2 = r2->field, j = 0; |
96 |
r1->len > j; |
97 |
++f1, ++f2, ++j) { |
98 |
_lstb_assert (f1->tag == f2->tag, msg, "chkr: tag[%d] = %d/%d", |
99 |
j, f1->tag, f2->tag); |
100 |
_lstb_assert (f1->len == f2->len, msg, "chkr: len[%d] = %d/%d", |
101 |
j, f1->len, f2->len); |
102 |
strncpy (buf1, f1->val, 31 < f1->len ? 31 : f1->len); |
103 |
strncpy (buf2, f2->val, 31 < f1->len ? 31 : f1->len); |
104 |
_lstb_assert (0 == memcmp (f1->val, f2->val, f1->len), msg, |
105 |
"field[%d] = %s/%s", j, buf1, buf2); |
106 |
} |
107 |
} |
108 |
|
109 |
static void _chk_rec (const char *msg, Rec *rec, int dbid, int rowid) { |
110 |
Rec *r2 = dRead (dbid, rowid); |
111 |
_cmp_rec (msg, rec, r2); |
112 |
mFree (r2); |
113 |
} |
114 |
|
115 |
static Rec* _buildrqs (int argc, char **argv) { |
116 |
return rSet (0, RARGV | RFDT | argc, openIsisFdtRqs, argv); |
117 |
} |
118 |
|
119 |
static int _set_tms (const char *msg, char *dbn, int delta) { |
120 |
static char tbuf[32]; |
121 |
int j; |
122 |
|
123 |
_lstb_assert (0 != sc0, msg, "(tms) sc0 == 0"); |
124 |
_lstb_assert (0 < sc0->ndbs, msg, "(tms) sc0->ndbs = %d", sc0->ndbs); |
125 |
for (j = 0, db = 0; sc0->ndbs > j; ++j) { |
126 |
if (0 == strcmp (sc0->dbs[j]->name, dbn)) { |
127 |
db = sc0->dbs[j]; |
128 |
break; |
129 |
} |
130 |
} |
131 |
_lstb_assert (0 != db, msg, "(tms) no such db: %s", dbn); |
132 |
_lstb_assert (0 != db->tms, msg, "(tms) tms == 0"); |
133 |
|
134 |
sprintf (tbuf, "%d", (db->tms + delta)); |
135 |
args[alen++] = "tms"; |
136 |
args[alen++] = tbuf; |
137 |
|
138 |
return db->tms; |
139 |
} |
140 |
|
141 |
/* ************************************************************ |
142 |
tests |
143 |
*/ |
144 |
|
145 |
static void _open_srv (const char *msg, int argc, const char **argv) { |
146 |
const char *scargs[] = { |
147 |
"host", "tonno", "port", "4242" |
148 |
}; |
149 |
int scnum = sizeof (scargs) / sizeof (scargs[0]); |
150 |
|
151 |
st0 = openIsisNInit (argc, argv, &cbdta); |
152 |
_lstb_assert (0 != st0, msg, "st0 == 0"); |
153 |
sc0 = openIsisNSchema (st0); |
154 |
_lstb_assert (0 != sc0, msg, "sc0 == 0"); |
155 |
_lstb_assert (0 == sc0->scid, msg, "sc0.scid = %x", sc0->scid); |
156 |
|
157 |
st1 = openIsisNOpen ("nonno", scnum, scargs, &cbdta); |
158 |
_lstb_assert (0 != st1, msg, "st1 == 0"); |
159 |
_lstb_assert (st0 != st1, msg, "st1 == st0"); |
160 |
sc1 = openIsisNSchema (st1); |
161 |
_lstb_assert (0 != sc1, msg, "sc1 == 0"); |
162 |
_lstb_assert (0x0100 == sc1->scid, msg, "sc1.scid = %x", sc1->scid); |
163 |
|
164 |
st2 = openIsisNInit (0, 0, 0); |
165 |
_lstb_assert (st2 == st0, msg, "st2 %p != %p", st2, st0); |
166 |
sc2 = openIsisNSchema (st2); |
167 |
_lstb_assert (sc2 == sc0, msg, "sc2 %p != %p", sc2, sc0); |
168 |
|
169 |
st3 = openIsisNOpen ("nonno", 0, 0, 0); |
170 |
_lstb_assert (st3 == st1, msg, "st3 %p != %p", st3, st1); |
171 |
sc3 = openIsisNSchema (st1); |
172 |
_lstb_assert (sc3 == sc1, msg, "sc3 %p != %p", sc3, sc1); |
173 |
} |
174 |
|
175 |
static void _open_db (const char *msg, char *dbn) { |
176 |
int rt; |
177 |
|
178 |
alen = 0; |
179 |
args[alen++] = "type"; |
180 |
args[alen++] = "open"; |
181 |
args[alen++] = "db"; |
182 |
args[alen++] = dbn; |
183 |
rqs = _buildrqs (alen, args); |
184 |
_lstb_assert (0 != rqs, msg, "rqs == 0"); |
185 |
rt = openIsisNSend (st0, rqs, &_rsp_cb, _RspCld, 0); |
186 |
_lstb_assert (0 == rt, msg, "rt = %d", rt); |
187 |
|
188 |
rsp = openIsisNRecv (st0, 0); |
189 |
_lstb_assert (0 != rsp, msg, "rsp == 0"); |
190 |
rt = rInt (rsp, OPENISIS_RSP_ERR, -1, 0); |
191 |
_lstb_assert (0 == rt, msg, "err = %d", rt); |
192 |
|
193 |
db = ldb_getdb (0); |
194 |
_lstb_assert (0 != db, msg, "db == 0"); |
195 |
_lstb_assert (0 == strcmp (db->name, "cds"), msg, "db0: %s", db->name); |
196 |
} |
197 |
|
198 |
static void _close_db (const char *msg, char *dbn, int dbid) { |
199 |
int rt; |
200 |
|
201 |
alen = 0; |
202 |
args[alen++] = "type"; |
203 |
args[alen++] = "close"; |
204 |
args[alen++] = "db"; |
205 |
args[alen++] = dbn; |
206 |
rqs = _buildrqs (alen, args); |
207 |
_lstb_assert (0 != rqs, msg, "rqs == 0"); |
208 |
rt = openIsisNSend (st0, rqs, &_rsp_cb, _RspCld, 0); |
209 |
_lstb_assert (0 == rt, msg, "rt = %d", rt); |
210 |
|
211 |
rsp = openIsisNRecv (st0, 0); |
212 |
_lstb_assert (0 != rsp, msg, "rsp == 0"); |
213 |
rt = rInt (rsp, OPENISIS_RSP_ERR, -1, 0); |
214 |
_lstb_assert (0 == rt, msg, "err = %d", rt); |
215 |
|
216 |
if (0 <= dbid) { |
217 |
db = ldb_getdb (dbid); |
218 |
_lstb_assert (0 == db, msg, "db != 0"); |
219 |
} |
220 |
} |
221 |
|
222 |
static void _lsdb (const char *msg) { |
223 |
char dbn[OPENISIS_DB_NAMELEN]; |
224 |
char *n1; |
225 |
int rt, pos; |
226 |
|
227 |
alen = 0; |
228 |
args[alen++] = "type"; |
229 |
args[alen++] = "ls"; |
230 |
rqs = _buildrqs (alen, args); |
231 |
_lstb_assert (0 != rqs, msg, "rqs == 0"); |
232 |
rt = openIsisNSend (st0, rqs, 0, 0, 0); |
233 |
_lstb_assert (0 == rt, msg, "rt = %d", rt); |
234 |
|
235 |
rsp = openIsisNRecv (st0, 0); |
236 |
_lstb_assert (0 != rsp, msg, "rsp == 0"); |
237 |
|
238 |
pos = 0; |
239 |
n1 = rString (rsp, OPENISIS_COM_DBN, &pos, dbn, OPENISIS_DB_NAMELEN); |
240 |
_lstb_assert (0 != n1, msg, "db(0) == 0"); |
241 |
_lstb_assert (0 == strcmp (n1, "cds"), msg, "db(0) = %s", n1); |
242 |
n1 = rString (rsp, OPENISIS_COM_DBN, &pos, dbn, OPENISIS_DB_NAMELEN); |
243 |
_lstb_assert (0 != n1, msg, "db(1) == 0"); |
244 |
_lstb_assert (0 == strcmp (n1, "lstbtest"), msg, "db(1) = %s", n1); |
245 |
n1 = rString (rsp, OPENISIS_COM_DBN, &pos, dbn, OPENISIS_DB_NAMELEN); |
246 |
_lstb_assert (0 == n1, msg, "db(2) = %s", n1); |
247 |
} |
248 |
|
249 |
static void _maxrow (const char *msg, char *dbn, int exp) { |
250 |
int rt; |
251 |
|
252 |
alen = 0; |
253 |
args[alen++] = "type"; |
254 |
args[alen++] = "maxrow"; |
255 |
args[alen++] = "db"; |
256 |
args[alen++] = dbn; |
257 |
rqs = _buildrqs (alen, args); |
258 |
_lstb_assert (0 != rqs, msg, "rqs == 0"); |
259 |
rt = openIsisNSend (st0, rqs, &_rsp_cb, _RspCld, 0); |
260 |
_lstb_assert (0 == rt, msg, "rt = %d", rt); |
261 |
|
262 |
rsp = openIsisNRecv (st0, 0); |
263 |
_lstb_assert (0 != rsp, msg, "rsp == 0"); |
264 |
rt = rInt (rsp, OPENISIS_RSP_ERR, -1, 0); |
265 |
_lstb_assert (0 == rt, msg, "err = %d", rt); |
266 |
rt = rInt (rsp, OPENISIS_RSP_NUMT, -1, 0); |
267 |
_lstb_assert (-1 == rt, msg, "numt = %d", rt); |
268 |
rt = rInt (rsp, OPENISIS_COM_ROW, -1, 0); |
269 |
if (0 <= exp) { |
270 |
_lstb_assert (exp == rt, msg, "rowid = %d(%d)", rt, exp); |
271 |
} |
272 |
else { |
273 |
_lstb_assert (0 <= rt, msg, "rowid = %d", rt); |
274 |
} |
275 |
} |
276 |
|
277 |
static void _maxrowerr (const char *msg, char *dbn) { |
278 |
int rt, tms; |
279 |
|
280 |
alen = 0; |
281 |
args[alen++] = "type"; |
282 |
args[alen++] = "maxrow"; |
283 |
args[alen++] = "db"; |
284 |
args[alen++] = dbn; |
285 |
tms = _set_tms (msg, dbn, -2); |
286 |
rqs = _buildrqs (alen, args); |
287 |
_lstb_assert (0 != rqs, msg, "rqs == 0"); |
288 |
rt = openIsisNSend (st0, rqs, &_rsp_cb, _RspCld, 0); |
289 |
_lstb_assert (0 == rt, msg, "rt = %d x%x", rt, rt); |
290 |
|
291 |
rsp = openIsisNRecv (st0, 0); |
292 |
_lstb_assert (0 != rsp, msg, "rsp == 0"); |
293 |
rt = rInt (rsp, OPENISIS_RSP_ERR, -1, 0); |
294 |
_lstb_assert (ERR_INVAL == rt, msg, "err = %d", rt); |
295 |
rt = rInt (rsp, OPENISIS_COM_TMS, -1, 0); |
296 |
_lstb_assert (tms == rt, msg, "tms = %d(%d)", rt, tms); |
297 |
} |
298 |
|
299 |
static void _lstb_read (const char *msg, int rid, int rlen) { /* no _rsp_cb */ |
300 |
Rec *rec; |
301 |
Db *rdb; |
302 |
char rbuf[32]; |
303 |
int rt; |
304 |
|
305 |
alen = 0; |
306 |
args[alen++] = "type"; |
307 |
args[alen++] = "read"; |
308 |
args[alen++] = "db"; |
309 |
args[alen++] = "cds"; |
310 |
_set_tms (msg, "cds", 0); |
311 |
sprintf (rbuf, "%d", rid); |
312 |
args[alen++] = "rowid"; |
313 |
args[alen++] = rbuf; |
314 |
rqs = _buildrqs (alen, args); |
315 |
_lstb_assert (0 != rqs, msg, "rqs == 0"); |
316 |
rt = openIsisNSend (st0, rqs, 0, _RspCld, 0); |
317 |
_lstb_assert (0 == rt, msg, "rt = %d", rt); |
318 |
|
319 |
rsp = openIsisNRecv (st0, &rdb); |
320 |
_lstb_assert (0 != rsp, msg, "rsp == 0"); |
321 |
_lstb_assert (0 != rdb, msg, "rdb == 0"); |
322 |
rt = rInt (rsp, OPENISIS_RSP_ERR, -1, 0); |
323 |
_lstb_assert (0 == rt, msg, "err = %d", rt); |
324 |
rt = rInt (rsp, OPENISIS_RSP_NUMT, -1, 0); |
325 |
_lstb_assert (1 == rt, msg, "numt = %d", rt); |
326 |
rt = rInt (rsp, OPENISIS_COM_ROW, -1, 0); |
327 |
_lstb_assert (rid == rt, msg, "rowid = %d(%d)", rt, rid); |
328 |
|
329 |
rec = luti_unwrap (rsp, 0, OPENISIS_COM_REC, rdb->dbid); |
330 |
_lstb_assert (0 != rec, msg, "rec == 0"); |
331 |
if (0 < rlen) { |
332 |
_lstb_assert (rlen == rec->len, msg, "rec->len = %d(%d)", rec->len, rlen); |
333 |
} |
334 |
else { |
335 |
_lstb_assert (0 < rec->len, msg, "rec->len = %d", rec->len); |
336 |
} |
337 |
_lstb_assert (rdb->dbid == rec->dbid, msg, |
338 |
"rec->dbid = %d(%d)", rec->dbid, rdb->dbid); |
339 |
|
340 |
_chk_rec (msg, rec, 0, rid); |
341 |
mFree (rec); |
342 |
} |
343 |
|
344 |
static int _query ( /* no _rsp_cb */ |
345 |
const char *msg, int flg, int mode, int skip, int size, int exp |
346 |
) { |
347 |
Rec **recs; |
348 |
Db *rdb; |
349 |
char fbuf[32], mbuf[32], kbuf[32], sbuf[32]; |
350 |
int *rowids; |
351 |
int rt, rr, j; |
352 |
|
353 |
alen = 0; |
354 |
args[alen++] = "type"; |
355 |
args[alen++] = "query"; |
356 |
args[alen++] = "db"; |
357 |
args[alen++] = "cds"; |
358 |
sprintf (mbuf, "%d", mode); |
359 |
args[alen++] = "mode"; |
360 |
args[alen++] = mbuf; |
361 |
if (flg) { |
362 |
sprintf (fbuf, "%d", flg); |
363 |
args[alen++] = "flags"; |
364 |
args[alen++] = fbuf; |
365 |
} |
366 |
if (skip) { |
367 |
sprintf (kbuf, "%d", skip); |
368 |
args[alen++] = "skip"; |
369 |
args[alen++] = kbuf; |
370 |
} |
371 |
if (size) { |
372 |
sprintf (sbuf, "%d", size); |
373 |
args[alen++] = "size"; |
374 |
args[alen++] = sbuf; |
375 |
} |
376 |
args[alen++] = "key"; |
377 |
args[alen++] = "Africa$"; |
378 |
rqs = _buildrqs (alen, args); |
379 |
_lstb_assert (0 != rqs, msg, "rqs == 0"); |
380 |
rt = openIsisNSend (st0, rqs, 0, _RspCld, 0); |
381 |
_lstb_assert (0 == rt, msg, "rt = %d", rt); |
382 |
|
383 |
rsp = openIsisNRecv (st0, &rdb); |
384 |
_lstb_assert (0 != rsp, msg, "rsp == 0"); |
385 |
_lstb_assert (0 != rdb, msg, "rdb == 0"); |
386 |
rt = rInt (rsp, OPENISIS_RSP_ERR, -1, 0); |
387 |
_lstb_assert (0 == rt, msg, "err = %d", rt); |
388 |
|
389 |
rr = openIsisNGetResult (st0, &rowids, &recs, 0, &rt); |
390 |
if (0 <= exp) { |
391 |
_lstb_assert (exp == rr, msg, "numr = %d(%d)", rr, exp); |
392 |
} |
393 |
else { |
394 |
_lstb_assert (0 <= rr, msg, "numr = %d", rr); |
395 |
} |
396 |
_lstb_assert (rt >= rr, msg, "numt = %d/%d", rt, rr); |
397 |
|
398 |
if (recs) { |
399 |
for (j = 0; rr > j; ++j) { |
400 |
_chk_rec (msg, recs[j], 0, rowids[j]); |
401 |
mFree (recs[j]); |
402 |
} |
403 |
mFree (recs); |
404 |
} |
405 |
|
406 |
rt = rr ? rowids[rr - 1] : -1; |
407 |
mFree (rowids); |
408 |
return rt; |
409 |
} |
410 |
|
411 |
static int _update (const char *msg, |
412 |
int rid, int rtag, char *rval, int itag, char *ival, int exp |
413 |
) { |
414 |
Rec *rec; |
415 |
char rbuf[32]; |
416 |
int rt; |
417 |
|
418 |
alen = 0; |
419 |
args[alen++] = "type"; |
420 |
args[alen++] = 0 <= rid ? "update" : "insert"; |
421 |
args[alen++] = "db"; |
422 |
args[alen++] = "lstbtest"; |
423 |
_set_tms (msg, "lstbtest", 0); |
424 |
if (0 <= rid) { |
425 |
sprintf (rbuf, "%d", rid); |
426 |
args[alen++] = "rowid"; |
427 |
args[alen++] = rbuf; |
428 |
} |
429 |
rqs = _buildrqs (alen, args); |
430 |
rec = rSet (0, 0, rtag, rval, |
431 |
88, "summary of the conference in gondor", 0); |
432 |
rqs = luti_wrap (rqs, rec, OPENISIS_COM_REC); |
433 |
mFree (rec); |
434 |
if (itag) { |
435 |
rec = rSet (0, 0, itag, ival, 0); |
436 |
rqs = luti_wrap (rqs, rec, OPENISIS_COM_REC); |
437 |
mFree (rec); |
438 |
} |
439 |
|
440 |
rt = openIsisNSend (st0, rqs, &_rsp_cb, _RspCld, 0); |
441 |
_lstb_assert (0 == rt, msg, "rt = %d", rt); |
442 |
|
443 |
rsp = openIsisNRecv (st0, 0); |
444 |
_lstb_assert (0 != rsp, msg, "rsp == 0"); |
445 |
rt = rInt (rsp, OPENISIS_RSP_ERR, -1, 0); |
446 |
_lstb_assert (0 == rt, msg, "err = %d", rt); |
447 |
rt = rInt (rsp, OPENISIS_COM_ROW, -1, 0); |
448 |
if (0 < exp) { |
449 |
_lstb_assert (exp == rt, msg, "rowid = %d(%d)", rt, exp); |
450 |
} |
451 |
else { |
452 |
_lstb_assert (0 < rt, msg, "rowid = %d", rt); |
453 |
} |
454 |
|
455 |
return rt; |
456 |
} |
457 |
|
458 |
static void _rmtstdb () { |
459 |
char *exts[] = { "oxi", "txt", "ptr" }; |
460 |
char path[1024]; |
461 |
char *p; |
462 |
int err, j; |
463 |
if (! sc0) { |
464 |
fprintf (stderr, "rmtstdb: st0 == 0\n"); |
465 |
return; |
466 |
} |
467 |
if (! sc0->cfg) { |
468 |
fprintf (stderr, "rmtstdb: st0->cfg == 0\n"); |
469 |
return; |
470 |
} |
471 |
if (! rString (sc0->cfg, OPENISIS_SPATH, 0, path, 990)) { |
472 |
fprintf (stderr, "rmtstdb: path not given\n"); |
473 |
return; |
474 |
} |
475 |
p = path + strlen (path); |
476 |
*p++ = '/'; |
477 |
if (rString (sc0->cfg, OPENISIS_DPATH, 0, p, 10)) { |
478 |
p += strlen (p); |
479 |
*p++ = '/'; |
480 |
} |
481 |
|
482 |
err = 0; |
483 |
strcpy (p, "lstbtest."); |
484 |
p += 9; |
485 |
for (j = sizeof (exts) / sizeof (exts[0]); 0 <= --j; ) { |
486 |
strcpy (p, exts[j]); |
487 |
errno = 0; |
488 |
if (unlink (path)) { |
489 |
fprintf (stderr, "rmtstdb: cannot unlink %s: errno = %d\n", |
490 |
p - 9, errno); |
491 |
err = !0; |
492 |
} |
493 |
} |
494 |
if (! err) { |
495 |
log_msg (LOG_INFO, "db lstbtest removed."); |
496 |
} |
497 |
} |
498 |
|
499 |
static void _tstUnwrap () { |
500 |
Rec *r1, *r2, *r31, *r32, *r4; |
501 |
r31 = rSet (0, 0, 11, "r3111", 12, "r3112", 13, "r3113", 0); |
502 |
r32 = rSet (0, 0, 11, "r3211", 12, "r3212", 13, "r3213", 0); |
503 |
r2 = rSet (0, 0, 21, "r221", 22, "r222", 0); |
504 |
r2 = luti_wrap (r2, r31, 89); |
505 |
r2 = rSet (r2, 0, 23, "r223", 0); |
506 |
r2 = luti_wrap (r2, r32, 89); |
507 |
r1 = 0; |
508 |
r1 = luti_wrap (r1, r2, 79); |
509 |
r1 = rSet (r1, 0, 111, "r1111", 112, "r1112", 0); |
510 |
r4 = luti_getembed (r1, ".79.89[1]", 0); |
511 |
_cmp_rec ("unwrap", r4, r32); |
512 |
mFree (r1); |
513 |
mFree (r2); |
514 |
mFree (r31); |
515 |
mFree (r32); |
516 |
mFree (r4); |
517 |
} |
518 |
|
519 |
int main (int argc, char **argv) { |
520 |
char *argd[64]; |
521 |
int lastid, lvl, j; |
522 |
|
523 |
lvl = LOG_ERROR; |
524 |
switch (argc) { |
525 |
case 2: |
526 |
j = atoi (argv[1]); |
527 |
goto dfltargs; |
528 |
case 0: |
529 |
case 1: |
530 |
j = 1; |
531 |
dfltargs: |
532 |
argc = 0; |
533 |
argd[argc++] = "syspath"; |
534 |
argd[argc++] = "/opt/openisis/db"; |
535 |
argd[argc++] = "dbpath"; |
536 |
argd[argc++] = "cds"; |
537 |
argv = argd; |
538 |
break; |
539 |
default: |
540 |
if ((j = atoi (argv[1]))) { |
541 |
--argc; |
542 |
++argv; |
543 |
if (0 < (lastid = atoi (argv[2]))) { |
544 |
lvl = lastid; |
545 |
--argc; |
546 |
++argv; |
547 |
} |
548 |
} |
549 |
else { |
550 |
j = 1; |
551 |
} |
552 |
--argc; |
553 |
++argv; |
554 |
} |
555 |
|
556 |
cLog (lvl, 0); |
557 |
|
558 |
do { |
559 |
_RspCld[0] = _DelCld[0] = 0; |
560 |
st0 = st1 = st2 = st3 = 0; |
561 |
sc0 = sc1 = sc2 = sc3 = 0; |
562 |
db = 0; |
563 |
rqs = rsp = 0; |
564 |
|
565 |
openIsisNInit (0, 0, 0); |
566 |
openIsisNDeinit (); |
567 |
|
568 |
memset (&cbdta, 0, sizeof (OpenIsisStubCbData)); |
569 |
cbdta.delcb = &_del_cb; |
570 |
cbdta.delcld = _DelCld; |
571 |
|
572 |
_open_srv ("A", argc, (const char**)argv); |
573 |
|
574 |
openIsisNDeinit (); |
575 |
_lstb_assert (0 == stub0, "B", "stub0 != 0"); |
576 |
_lstb_assert (2 == _DelCld[0], "B", "_DelCld = %d", _DelCld[0]); |
577 |
sc1 = openIsisNSchema (st1); |
578 |
_lstb_assert (sc1 == 0, "B", "sc1 != 0"); |
579 |
|
580 |
_open_srv ("C", argc, (const char**)argv); |
581 |
|
582 |
openIsisNClose (st3); |
583 |
_lstb_assert (3 == _DelCld[0], "D", "_DelCld = %d", _DelCld[0]); |
584 |
sc1 = openIsisNSchema (st1); |
585 |
_lstb_assert (sc1 == 0, "D", "sc1 != 0"); |
586 |
|
587 |
_open_db ("E", "cds"); |
588 |
_close_db ("F", "cds", 0); |
589 |
_open_db ("G", "cds"); |
590 |
_close_db ("H", "cds", 0); |
591 |
_open_db ("I", "cds"); |
592 |
_lstb_assert (0 == _RspCld[0], "I", "_RspCld = %d", _RspCld[0]); |
593 |
_lstb_assert (8 == _DelCld[0], "I", "_DelCld = %d", _DelCld[0]); |
594 |
|
595 |
_maxrow ("J", "cds", 151); |
596 |
_lstb_read ("K", 94, 7); |
597 |
_lstb_assert (0 == _RspCld[0], "K", "_RspCld = %d", _RspCld[0]); |
598 |
_lstb_assert (9 == _DelCld[0], "K", "_DelCld = %d", _DelCld[0]); |
599 |
|
600 |
_query ("L", 0, OPENISIS_QRY_KEYAT, 0, 0, 5); |
601 |
lastid = _query ("M", 0, OPENISIS_QRY_KEYAT, 0, 4, 4); |
602 |
_query ("N", 0, OPENISIS_QRY_KEYAT, 1 + lastid, 4, 1); |
603 |
_query ("P", OPENISIS_RQSF_QRR, OPENISIS_QRY_KEYAT, 0, 0, 5); |
604 |
lastid = _query ("Q", OPENISIS_RQSF_QRR, OPENISIS_QRY_KEYAT, 0, 4, 4); |
605 |
_query ("R", OPENISIS_RQSF_QRR, OPENISIS_QRY_KEYAT, 1 + lastid, 4, 1); |
606 |
_lstb_assert (0 == _RspCld[0], "R", "_RspCld = %d", _RspCld[0]); |
607 |
_lstb_assert (9 == _DelCld[0], "R", "_DelCld = %d", _DelCld[0]); |
608 |
|
609 |
_open_db ("S", "lstbtest"); |
610 |
lastid = _update ("T", -1, 22, "Gandalf", 22, "Frodo", 1); |
611 |
_update ("U", -1, 23, "Larry", 0, 0, 2); |
612 |
_update ("V", lastid, 22, "Harry", 0, 0, 1); |
613 |
_maxrow ("W", "lstbtest", 2); |
614 |
|
615 |
_lsdb ("X"); |
616 |
|
617 |
_close_db ("Y", "lstbtest", 1); |
618 |
_lstb_assert (0 == _RspCld[0], "Y", "_RspCld = %d", _RspCld[0]); |
619 |
_lstb_assert (15 == _DelCld[0], "Y", "_DelCld = %d", _DelCld[0]); |
620 |
_rmtstdb (); |
621 |
|
622 |
_maxrowerr ("Z", "cds"); |
623 |
|
624 |
_lstb_read ("a", 94, 7); |
625 |
_maxrow ("b", "cds", 151); |
626 |
_lstb_read ("c", 94, 7); |
627 |
|
628 |
_tstUnwrap (); |
629 |
|
630 |
openIsisNDeinit (); |
631 |
|
632 |
_lstb_assert (0 == _RspCld[0], "z", "_RspCld = %d", _RspCld[0]); |
633 |
_lstb_assert (18 == _DelCld[0], "z", "_DelCld = %d", _DelCld[0]); |
634 |
|
635 |
if (0 == (j % 100)) { |
636 |
printf ("%d ...\n", j); |
637 |
} |
638 |
} while (--j); |
639 |
|
640 |
printf ("ok.\n"); |
641 |
return 0; |
642 |
} |
643 |
|