summaryrefslogtreecommitdiff
path: root/src/regress/lib/libc/db
diff options
context:
space:
mode:
authorcvs2svn <admin@example.com>2025-04-14 17:32:06 +0000
committercvs2svn <admin@example.com>2025-04-14 17:32:06 +0000
commiteb8dd9dca1228af0cd132f515509051ecfabf6f6 (patch)
treeedb6da6af7e865d488dc1a29309f1e1ec226e603 /src/regress/lib/libc/db
parent247f0352e0ed72a4f476db9dc91f4d982bc83eb2 (diff)
downloadopenbsd-tb_20250414.tar.gz
openbsd-tb_20250414.tar.bz2
openbsd-tb_20250414.zip
This commit was manufactured by cvs2git to create tag 'tb_20250414'.tb_20250414
Diffstat (limited to 'src/regress/lib/libc/db')
-rw-r--r--src/regress/lib/libc/db/Makefile20
-rw-r--r--src/regress/lib/libc/db/README69
-rw-r--r--src/regress/lib/libc/db/dbtest.c729
-rw-r--r--src/regress/lib/libc/db/run.test707
4 files changed, 0 insertions, 1525 deletions
diff --git a/src/regress/lib/libc/db/Makefile b/src/regress/lib/libc/db/Makefile
deleted file mode 100644
index a7ba659707..0000000000
--- a/src/regress/lib/libc/db/Makefile
+++ /dev/null
@@ -1,20 +0,0 @@
1# $OpenBSD: Makefile,v 1.11 2021/09/27 18:47:46 bluhm Exp $
2# $NetBSD: Makefile,v 1.11 1995/12/12 01:54:15 cgd Exp $
3
4PROG= dbtest
5
6# add -DSTATISTICS to CFLAGS to get usage statistics. Note that
7# for this to work, libc must be compiled with -DSTATISTICS as well
8CFLAGS+= -g -D__DBINTERFACE_PRIVATE -DDEBUG
9CLEANFILES+= t1 t2 t3 log
10
11DBTARGETS=1 2 3 4 5 6 7 8 9 10 11 12 13 20
12
13.for DT in ${DBTARGETS}
14db-${DT}: ${PROG}
15 sh ${.CURDIR}/run.test ${DT}
16REGRESS_TARGETS+=db-${DT}
17.PHONY: db-${DT}
18.endfor
19
20.include <bsd.regress.mk>
diff --git a/src/regress/lib/libc/db/README b/src/regress/lib/libc/db/README
deleted file mode 100644
index 23a1b77221..0000000000
--- a/src/regress/lib/libc/db/README
+++ /dev/null
@@ -1,69 +0,0 @@
1# $OpenBSD: README,v 1.3 2001/01/29 02:05:40 niklas Exp $
2# $NetBSD: README,v 1.5 1996/05/03 21:54:19 cgd Exp $
3# @(#)README 8.8 (Berkeley) 7/31/94
4
5To run the tests, enter "make regress".
6
7Fairly large files (the command files) are built in this directory during
8the test runs, and even larger files (the database files) are created in
9"/var/tmp". If the latter directory doesn't exist, set the environmental
10variable TMPDIR to a directory where the files can be built.
11
12=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
13The script file consists of lines with an initial character which is
14the command for that line, or an initial character indicating a key
15or data entry for a previous command.
16
17Legal command characters are as follows:
18
19c: compare a record
20 + must be followed by [kK][dD]; the data value in the database
21 associated with the specified key is compared to the specified
22 data value.
23e: echo a string
24 + writes out the rest of the line into the output file; if the
25 last character is not a carriage-return, a newline is appended.
26f: set the flags for the next command
27 + no value zero's the flags
28g: do a get command
29 + must be followed by [kK]
30 + writes out the retrieved data DBT.
31o [r]: dump [reverse]
32 + dump the database out, if 'r' is set, in reverse order.
33p: do a put command
34 + must be followed by [kK][dD]
35r: do a del command
36 + must be followed by [kK] unless R_CURSOR flag set.
37S: sync the database
38s: do a seq command
39 + must be followed by [kK] if R_CURSOR flag set.
40 + writes out the retrieved data DBT.
41
42Legal key/data characters are as follows:
43
44D [file]: data file
45 + set the current data value to the contents of the file
46d [data]:
47 + set the current key value to the contents of the line.
48K [file]: key file
49 + set the current key value to the contents of the file
50k [data]:
51 + set the current key value to the contents of the line.
52
53Blank lines, lines with leading white space, and lines with leading
54hash marks (#) are ignored.
55
56Options to dbtest are as follows:
57
58 -d: Set the DB_LOCK flag.
59 -f: Use the file argument as the database file.
60 -i: Use the rest of the argument to set elements in the info
61 structure. If the type is btree, then "-i cachesize=10240"
62 will set BTREEINFO.cachesize to 10240.
63 -o: The rest of the argument is the output file instead of
64 using stdout.
65 -s: Don't delete the database file before opening it, i.e.
66 use the database file from a previous run.
67
68Dbtest requires two arguments, the type of access "hash", "recno"
69or "btree", and the script name or "-" to indicate stdin.
diff --git a/src/regress/lib/libc/db/dbtest.c b/src/regress/lib/libc/db/dbtest.c
deleted file mode 100644
index 3207bafda3..0000000000
--- a/src/regress/lib/libc/db/dbtest.c
+++ /dev/null
@@ -1,729 +0,0 @@
1/* $OpenBSD: dbtest.c,v 1.21 2022/12/04 23:50:46 cheloha Exp $ */
2/* $NetBSD: dbtest.c,v 1.8 1996/05/03 21:57:48 cgd Exp $ */
3
4/*-
5 * Copyright (c) 1992, 1993, 1994
6 * The Regents of the University of California. All rights reserved.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
16 * 3. Neither the name of the University nor the names of its contributors
17 * may be used to endorse or promote products derived from this software
18 * without specific prior written permission.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
21 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
24 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30 * SUCH DAMAGE.
31 */
32
33#include <sys/stat.h>
34
35#include <ctype.h>
36#include <errno.h>
37#include <fcntl.h>
38#include <stdint.h>
39#include <stdio.h>
40#include <stdlib.h>
41#include <string.h>
42#include <stdarg.h>
43#include <unistd.h>
44
45#include <db.h>
46
47#define MINIMUM(a, b) (((a) < (b)) ? (a) : (b))
48
49enum S { COMMAND, COMPARE, GET, PUT, REMOVE, SEQ, SEQFLAG, KEY, DATA };
50
51void compare(DBT *, DBT *);
52DBTYPE dbtype(char *);
53void dump(DB *, int);
54void __dead dberr(const char *, ...);
55void get(DB *, DBT *);
56void getdata(DB *, DBT *, DBT *);
57void put(DB *, DBT *, DBT *);
58void rem(DB *, DBT *);
59char *sflags(int);
60void synk(DB *);
61void *rfile(char *, size_t *);
62void seq(DB *, DBT *);
63u_int setflags(char *);
64void *setinfo(DBTYPE, char *);
65void __dead usage(void);
66void *xmalloc(char *, size_t);
67
68DBTYPE type; /* Database type. */
69void *infop; /* Iflags. */
70u_long lineno; /* Current line in test script. */
71u_int flags; /* Current DB flags. */
72int ofd = STDOUT_FILENO; /* Standard output fd. */
73
74DB *XXdbp; /* Global for gdb. */
75int XXlineno; /* Fast breakpoint for gdb. */
76
77int
78main(int argc, char *argv[])
79{
80 enum S command, state;
81 DB *dbp;
82 DBT data, key, keydata;
83 size_t len;
84 int ch, oflags, sflag;
85 char *fname, *infoarg, *p, *t, buf[8 * 1024];
86
87 infoarg = NULL;
88 fname = NULL;
89 oflags = O_CREAT | O_RDWR;
90 sflag = 0;
91 while ((ch = getopt(argc, argv, "f:i:lo:s")) != -1)
92 switch (ch) {
93 case 'f':
94 fname = optarg;
95 break;
96 case 'i':
97 infoarg = optarg;
98 break;
99 case 'l':
100 oflags |= DB_LOCK;
101 break;
102 case 'o':
103 if ((ofd = open(optarg,
104 O_WRONLY|O_CREAT|O_TRUNC, 0666)) < 0)
105 dberr("%s: %s", optarg, strerror(errno));
106 break;
107 case 's':
108 sflag = 1;
109 break;
110 default:
111 usage();
112 }
113 argc -= optind;
114 argv += optind;
115
116 if (argc != 2)
117 usage();
118
119 /* Set the type. */
120 type = dbtype(*argv++);
121
122 /* Open the descriptor file. */
123 if (strcmp(*argv, "-") && freopen(*argv, "r", stdin) == NULL)
124 dberr("%s: %s", *argv, strerror(errno));
125
126 /* Set up the db structure as necessary. */
127 if (infoarg == NULL)
128 infop = NULL;
129 else
130 for (p = strtok(infoarg, ",\t "); p != NULL;
131 p = strtok(0, ",\t "))
132 if (*p != '\0')
133 infop = setinfo(type, p);
134
135 /*
136 * Open the DB. Delete any preexisting copy, you almost never
137 * want it around, and it often screws up tests.
138 */
139 if (fname == NULL) {
140 p = getenv("TMPDIR");
141 if (p == NULL)
142 p = "/tmp";
143 (void)snprintf(buf, sizeof buf, "%s/__dbtest", p);
144 fname = buf;
145 (void)unlink(buf);
146 } else if (!sflag)
147 (void)unlink(fname);
148
149 if ((dbp = dbopen(fname,
150 oflags, S_IRUSR | S_IWUSR, type, infop)) == NULL)
151 dberr("dbopen: %s", strerror(errno));
152 XXdbp = dbp;
153
154 state = COMMAND;
155 for (lineno = 1;
156 (p = fgets(buf, sizeof(buf), stdin)) != NULL; ++lineno) {
157 /* Delete the newline, displaying the key/data is easier. */
158 if (ofd == STDOUT_FILENO && (t = strchr(p, '\n')) != NULL)
159 *t = '\0';
160 if ((len = strlen(buf)) == 0 || isspace((unsigned char)*p) || *p == '#')
161 continue;
162
163 /* Convenient gdb break point. */
164 if (XXlineno == lineno)
165 XXlineno = 1;
166 switch (*p) {
167 case 'c': /* compare */
168 if (state != COMMAND)
169 dberr("line %lu: not expecting command",
170 lineno);
171 state = KEY;
172 command = COMPARE;
173 break;
174 case 'e': /* echo */
175 if (state != COMMAND)
176 dberr("line %lu: not expecting command",
177 lineno);
178 /* Don't display the newline, if CR at EOL. */
179 if (p[len - 2] == '\r')
180 --len;
181 if (write(ofd, p + 1, len - 1) != len - 1 ||
182 write(ofd, "\n", 1) != 1)
183 dberr("write: %s", strerror(errno));
184 break;
185 case 'g': /* get */
186 if (state != COMMAND)
187 dberr("line %lu: not expecting command",
188 lineno);
189 state = KEY;
190 command = GET;
191 break;
192 case 'p': /* put */
193 if (state != COMMAND)
194 dberr("line %lu: not expecting command",
195 lineno);
196 state = KEY;
197 command = PUT;
198 break;
199 case 'r': /* remove */
200 if (state != COMMAND)
201 dberr("line %lu: not expecting command",
202 lineno);
203 if (flags == R_CURSOR) {
204 rem(dbp, &key);
205 state = COMMAND;
206 } else {
207 state = KEY;
208 command = REMOVE;
209 }
210 break;
211 case 'S': /* sync */
212 if (state != COMMAND)
213 dberr("line %lu: not expecting command",
214 lineno);
215 synk(dbp);
216 state = COMMAND;
217 break;
218 case 's': /* seq */
219 if (state != COMMAND)
220 dberr("line %lu: not expecting command",
221 lineno);
222 if (flags == R_CURSOR) {
223 state = KEY;
224 command = SEQ;
225 } else
226 seq(dbp, &key);
227 break;
228 case 'f':
229 flags = setflags(p + 1);
230 break;
231 case 'D': /* data file */
232 if (state != DATA)
233 dberr("line %lu: not expecting data", lineno);
234 data.data = rfile(p + 1, &data.size);
235 goto ldata;
236 case 'd': /* data */
237 if (state != DATA)
238 dberr("line %lu: not expecting data", lineno);
239 data.data = xmalloc(p + 1, len - 1);
240 data.size = len - 1;
241ldata: switch (command) {
242 case COMPARE:
243 compare(&keydata, &data);
244 break;
245 case PUT:
246 put(dbp, &key, &data);
247 break;
248 default:
249 dberr("line %lu: command doesn't take data",
250 lineno);
251 }
252 if (type != DB_RECNO)
253 free(key.data);
254 free(data.data);
255 state = COMMAND;
256 break;
257 case 'K': /* key file */
258 if (state != KEY)
259 dberr("line %lu: not expecting a key", lineno);
260 if (type == DB_RECNO)
261 dberr("line %lu: 'K' not available for recno",
262 lineno);
263 key.data = rfile(p + 1, &key.size);
264 goto lkey;
265 case 'k': /* key */
266 if (state != KEY)
267 dberr("line %lu: not expecting a key", lineno);
268 if (type == DB_RECNO) {
269 static recno_t recno;
270 recno = atoi(p + 1);
271 key.data = &recno;
272 key.size = sizeof(recno);
273 } else {
274 key.data = xmalloc(p + 1, len - 1);
275 key.size = len - 1;
276 }
277lkey: switch (command) {
278 case COMPARE:
279 getdata(dbp, &key, &keydata);
280 state = DATA;
281 break;
282 case GET:
283 get(dbp, &key);
284 if (type != DB_RECNO)
285 free(key.data);
286 state = COMMAND;
287 break;
288 case PUT:
289 state = DATA;
290 break;
291 case REMOVE:
292 rem(dbp, &key);
293 if ((type != DB_RECNO) && (flags != R_CURSOR))
294 free(key.data);
295 state = COMMAND;
296 break;
297 case SEQ:
298 seq(dbp, &key);
299 if ((type != DB_RECNO) && (flags != R_CURSOR))
300 free(key.data);
301 state = COMMAND;
302 break;
303 default:
304 dberr("line %lu: command doesn't take a key",
305 lineno);
306 }
307 break;
308 case 'o':
309 dump(dbp, p[1] == 'r');
310 break;
311 default:
312 dberr("line %lu: %s: unknown command character",
313 lineno, p);
314 }
315 }
316#ifdef STATISTICS
317 /*
318 * -l must be used (DB_LOCK must be set) for this to be
319 * used, otherwise a page will be locked and it will fail.
320 */
321 if (type == DB_BTREE && oflags & DB_LOCK)
322 __bt_stat(dbp);
323#endif
324 if (dbp->close(dbp))
325 dberr("db->close: %s", strerror(errno));
326 (void)close(ofd);
327 exit(0);
328}
329
330#define NOOVERWRITE "put failed, would overwrite key\n"
331
332void
333compare(db1, db2)
334 DBT *db1, *db2;
335{
336 register size_t len;
337 register u_char *p1, *p2;
338
339 if (db1->size != db2->size)
340 printf("compare failed: key->data len %lu != data len %lu\n",
341 db1->size, db2->size);
342
343 len = MINIMUM(db1->size, db2->size);
344 for (p1 = db1->data, p2 = db2->data; len--;)
345 if (*p1++ != *p2++) {
346 printf("compare failed at offset %ld\n",
347 p1 - (u_char *)db1->data);
348 break;
349 }
350}
351
352void
353get(dbp, kp)
354 DB *dbp;
355 DBT *kp;
356{
357 DBT data;
358
359 switch (dbp->get(dbp, kp, &data, flags)) {
360 case 0:
361 (void)write(ofd, data.data, data.size);
362 if (ofd == STDOUT_FILENO)
363 (void)write(ofd, "\n", 1);
364 break;
365 case -1:
366 dberr("line %lu: get: %s", lineno, strerror(errno));
367 /* NOTREACHED */
368 case 1:
369#define NOSUCHKEY "get failed, no such key\n"
370 if (ofd != STDOUT_FILENO)
371 (void)write(ofd, NOSUCHKEY, sizeof(NOSUCHKEY) - 1);
372 else
373 (void)fprintf(stderr, "%lu: %.*s: %s", lineno,
374 MINIMUM((int)kp->size, 20), kp->data, NOSUCHKEY);
375#undef NOSUCHKEY
376 break;
377 }
378}
379
380void
381getdata(dbp, kp, dp)
382 DB *dbp;
383 DBT *kp, *dp;
384{
385 switch (dbp->get(dbp, kp, dp, flags)) {
386 case 0:
387 return;
388 case -1:
389 dberr("line %lu: getdata: %s", lineno, strerror(errno));
390 /* NOTREACHED */
391 case 1:
392 dberr("line %lu: getdata failed, no such key", lineno);
393 /* NOTREACHED */
394 }
395}
396
397void
398put(dbp, kp, dp)
399 DB *dbp;
400 DBT *kp, *dp;
401{
402 switch (dbp->put(dbp, kp, dp, flags)) {
403 case 0:
404 break;
405 case -1:
406 dberr("line %lu: put: %s", lineno, strerror(errno));
407 /* NOTREACHED */
408 case 1:
409 (void)write(ofd, NOOVERWRITE, sizeof(NOOVERWRITE) - 1);
410 break;
411 }
412}
413
414void
415rem(dbp, kp)
416 DB *dbp;
417 DBT *kp;
418{
419 switch (dbp->del(dbp, kp, flags)) {
420 case 0:
421 break;
422 case -1:
423 dberr("line %lu: rem: %s", lineno, strerror(errno));
424 /* NOTREACHED */
425 case 1:
426#define NOSUCHKEY "rem failed, no such key\n"
427 if (ofd != STDOUT_FILENO)
428 (void)write(ofd, NOSUCHKEY, sizeof(NOSUCHKEY) - 1);
429 else if (flags != R_CURSOR)
430 (void)fprintf(stderr, "%lu: %.*s: %s", lineno,
431 MINIMUM((int)kp->size, 20), kp->data, NOSUCHKEY);
432 else
433 (void)fprintf(stderr,
434 "%lu: rem of cursor failed\n", lineno);
435#undef NOSUCHKEY
436 break;
437 }
438}
439
440void
441synk(dbp)
442 DB *dbp;
443{
444 switch (dbp->sync(dbp, flags)) {
445 case 0:
446 break;
447 case -1:
448 dberr("line %lu: synk: %s", lineno, strerror(errno));
449 /* NOTREACHED */
450 }
451}
452
453void
454seq(dbp, kp)
455 DB *dbp;
456 DBT *kp;
457{
458 DBT data;
459
460 switch (dbp->seq(dbp, kp, &data, flags)) {
461 case 0:
462 (void)write(ofd, data.data, data.size);
463 if (ofd == STDOUT_FILENO)
464 (void)write(ofd, "\n", 1);
465 break;
466 case -1:
467 dberr("line %lu: seq: %s", lineno, strerror(errno));
468 /* NOTREACHED */
469 case 1:
470#define NOSUCHKEY "seq failed, no such key\n"
471 if (ofd != STDOUT_FILENO)
472 (void)write(ofd, NOSUCHKEY, sizeof(NOSUCHKEY) - 1);
473 else if (flags == R_CURSOR)
474 (void)fprintf(stderr, "%lu: %.*s: %s", lineno,
475 MINIMUM((int)kp->size, 20), kp->data, NOSUCHKEY);
476 else
477 (void)fprintf(stderr,
478 "%lu: seq (%s) failed\n", lineno, sflags(flags));
479#undef NOSUCHKEY
480 break;
481 }
482}
483
484void
485dump(dbp, rev)
486 DB *dbp;
487 int rev;
488{
489 DBT key, data;
490 int flags, nflags;
491
492 if (rev) {
493 flags = R_LAST;
494 nflags = R_PREV;
495 } else {
496 flags = R_FIRST;
497 nflags = R_NEXT;
498 }
499 for (;; flags = nflags)
500 switch (dbp->seq(dbp, &key, &data, flags)) {
501 case 0:
502 (void)write(ofd, data.data, data.size);
503 if (ofd == STDOUT_FILENO)
504 (void)write(ofd, "\n", 1);
505 break;
506 case 1:
507 goto done;
508 case -1:
509 dberr("line %lu: (dump) seq: %s",
510 lineno, strerror(errno));
511 /* NOTREACHED */
512 }
513done: return;
514}
515
516u_int
517setflags(s)
518 char *s;
519{
520 char *p;
521
522 for (; isspace((unsigned char)*s); ++s);
523 if (*s == '\n' || *s == '\0')
524 return (0);
525 if ((p = strchr(s, '\n')) != NULL)
526 *p = '\0';
527 if (!strcmp(s, "R_CURSOR")) return (R_CURSOR);
528 if (!strcmp(s, "R_FIRST")) return (R_FIRST);
529 if (!strcmp(s, "R_IAFTER")) return (R_IAFTER);
530 if (!strcmp(s, "R_IBEFORE")) return (R_IBEFORE);
531 if (!strcmp(s, "R_LAST")) return (R_LAST);
532 if (!strcmp(s, "R_NEXT")) return (R_NEXT);
533 if (!strcmp(s, "R_NOOVERWRITE")) return (R_NOOVERWRITE);
534 if (!strcmp(s, "R_PREV")) return (R_PREV);
535 if (!strcmp(s, "R_SETCURSOR")) return (R_SETCURSOR);
536
537 dberr("line %lu: %s: unknown flag", lineno, s);
538 /* NOTREACHED */
539}
540
541char *
542sflags(flags)
543 int flags;
544{
545 switch (flags) {
546 case R_CURSOR: return ("R_CURSOR");
547 case R_FIRST: return ("R_FIRST");
548 case R_IAFTER: return ("R_IAFTER");
549 case R_IBEFORE: return ("R_IBEFORE");
550 case R_LAST: return ("R_LAST");
551 case R_NEXT: return ("R_NEXT");
552 case R_NOOVERWRITE: return ("R_NOOVERWRITE");
553 case R_PREV: return ("R_PREV");
554 case R_SETCURSOR: return ("R_SETCURSOR");
555 }
556
557 return ("UNKNOWN!");
558}
559
560DBTYPE
561dbtype(s)
562 char *s;
563{
564 if (!strcmp(s, "btree"))
565 return (DB_BTREE);
566 if (!strcmp(s, "hash"))
567 return (DB_HASH);
568 if (!strcmp(s, "recno"))
569 return (DB_RECNO);
570 dberr("%s: unknown type (use btree, hash or recno)", s);
571 /* NOTREACHED */
572}
573
574void *
575setinfo(type, s)
576 DBTYPE type;
577 char *s;
578{
579 static BTREEINFO ib;
580 static HASHINFO ih;
581 static RECNOINFO rh;
582 char *eq;
583
584 if ((eq = strchr(s, '=')) == NULL)
585 dberr("%s: illegal structure set statement", s);
586 *eq++ = '\0';
587 if (!isdigit((unsigned char)*eq))
588 dberr("%s: structure set statement must be a number", s);
589
590 switch (type) {
591 case DB_BTREE:
592 if (!strcmp("flags", s)) {
593 ib.flags = atoi(eq);
594 return (&ib);
595 }
596 if (!strcmp("cachesize", s)) {
597 ib.cachesize = atoi(eq);
598 return (&ib);
599 }
600 if (!strcmp("maxkeypage", s)) {
601 ib.maxkeypage = atoi(eq);
602 return (&ib);
603 }
604 if (!strcmp("minkeypage", s)) {
605 ib.minkeypage = atoi(eq);
606 return (&ib);
607 }
608 if (!strcmp("lorder", s)) {
609 ib.lorder = atoi(eq);
610 return (&ib);
611 }
612 if (!strcmp("psize", s)) {
613 ib.psize = atoi(eq);
614 return (&ib);
615 }
616 break;
617 case DB_HASH:
618 if (!strcmp("bsize", s)) {
619 ih.bsize = atoi(eq);
620 return (&ih);
621 }
622 if (!strcmp("ffactor", s)) {
623 ih.ffactor = atoi(eq);
624 return (&ih);
625 }
626 if (!strcmp("nelem", s)) {
627 ih.nelem = atoi(eq);
628 return (&ih);
629 }
630 if (!strcmp("cachesize", s)) {
631 ih.cachesize = atoi(eq);
632 return (&ih);
633 }
634 if (!strcmp("lorder", s)) {
635 ih.lorder = atoi(eq);
636 return (&ih);
637 }
638 break;
639 case DB_RECNO:
640 if (!strcmp("flags", s)) {
641 rh.flags = atoi(eq);
642 return (&rh);
643 }
644 if (!strcmp("cachesize", s)) {
645 rh.cachesize = atoi(eq);
646 return (&rh);
647 }
648 if (!strcmp("lorder", s)) {
649 rh.lorder = atoi(eq);
650 return (&rh);
651 }
652 if (!strcmp("reclen", s)) {
653 rh.reclen = atoi(eq);
654 return (&rh);
655 }
656 if (!strcmp("bval", s)) {
657 rh.bval = atoi(eq);
658 return (&rh);
659 }
660 if (!strcmp("psize", s)) {
661 rh.psize = atoi(eq);
662 return (&rh);
663 }
664 break;
665 }
666 dberr("%s: unknown structure value", s);
667 /* NOTREACHED */
668}
669
670void *
671rfile(name, lenp)
672 char *name;
673 size_t *lenp;
674{
675 struct stat sb;
676 void *p;
677 int fd;
678 char *np;
679
680 for (; isspace((unsigned char)*name); ++name);
681 if ((np = strchr(name, '\n')) != NULL)
682 *np = '\0';
683 if ((fd = open(name, O_RDONLY)) < 0 ||
684 fstat(fd, &sb))
685 dberr("%s: %s\n", name, strerror(errno));
686 if (sb.st_size > (off_t)INT_MAX)
687 dberr("%s: %s\n", name, strerror(E2BIG));
688 if ((p = (void *)malloc((u_int)sb.st_size)) == NULL)
689 dberr("%s", strerror(errno));
690 (void)read(fd, p, (int)sb.st_size);
691 *lenp = sb.st_size;
692 (void)close(fd);
693 return (p);
694}
695
696void *
697xmalloc(text, len)
698 char *text;
699 size_t len;
700{
701 void *p;
702
703 if ((p = (void *)malloc(len)) == NULL)
704 dberr("%s", strerror(errno));
705 memmove(p, text, len);
706 return (p);
707}
708
709void __dead
710usage()
711{
712 (void)fprintf(stderr,
713 "usage: dbtest [-l] [-f file] [-i info] [-o file] type script\n");
714 exit(1);
715}
716
717void __dead
718dberr(const char *fmt, ...)
719{
720 va_list ap;
721
722 va_start(ap, fmt);
723 (void)fprintf(stderr, "dbtest: ");
724 (void)vfprintf(stderr, fmt, ap);
725 va_end(ap);
726 (void)fprintf(stderr, "\n");
727 exit(1);
728 /* NOTREACHED */
729}
diff --git a/src/regress/lib/libc/db/run.test b/src/regress/lib/libc/db/run.test
deleted file mode 100644
index 0d6837e360..0000000000
--- a/src/regress/lib/libc/db/run.test
+++ /dev/null
@@ -1,707 +0,0 @@
1#!/bin/sh -
2#
3# $OpenBSD: run.test,v 1.3 2001/01/29 02:05:41 niklas Exp $
4# $NetBSD: run.test,v 1.8 1996/05/03 21:57:51 cgd Exp $
5# @(#)run.test 8.10 (Berkeley) 7/26/94
6#
7
8# db regression tests
9main()
10{
11
12 PROG=./dbtest
13 TMP1=t1
14 TMP2=t2
15 TMP3=t3
16
17 if [ -f /usr/share/dict/words ]; then
18 DICT=/usr/share/dict/words
19 elif [ -f /usr/dict/words ]; then
20 DICT=/usr/dict/words
21 else
22 echo 'run.test: no dictionary'
23 exit 1
24 fi
25
26 if [ $# -eq 0 ]; then
27 for t in 1 2 3 4 5 6 7 8 9 10 11 12 13 20; do
28 test$t
29 done
30 else
31 while [ $# -gt 0 ]
32 do case "$1" in
33 test*)
34 $1;;
35 [0-9]*)
36 test$1;;
37 btree)
38 for t in 1 2 3 7 8 9 10 12 13; do
39 test$t
40 done;;
41 hash)
42 for t in 1 2 3 8 13 20; do
43 test$t
44 done;;
45 recno)
46 for t in 1 2 3 4 5 6 7 10 11; do
47 test$t
48 done;;
49 *)
50 echo "run.test: unknown test $1"
51 echo "usage: run.test test# | type"
52 exit 1
53 esac
54 shift
55 done
56 fi
57 rm -f $TMP1 $TMP2 $TMP3
58 exit 0
59}
60
61# Take the first hundred entries in the dictionary, and make them
62# be key/data pairs.
63test1()
64{
65 echo "Test 1: btree, hash: small key, small data pairs"
66 sed 200q $DICT > $TMP1
67 for type in btree hash; do
68 rm -f $TMP2 $TMP3
69 for i in `sed 200q $DICT`; do
70 echo p
71 echo k$i
72 echo d$i
73 echo g
74 echo k$i
75 done > $TMP2
76 $PROG -o $TMP3 $type $TMP2
77 if (cmp -s $TMP1 $TMP3) ; then :
78 else
79 echo "test1: type $type: failed"
80 exit 1
81 fi
82 done
83 echo "Test 1: recno: small key, small data pairs"
84 rm -f $TMP2 $TMP3
85 sed 200q $DICT |
86 awk '{
87 ++i;
88 printf("p\nk%d\nd%s\ng\nk%d\n", i, $0, i);
89 }' > $TMP2
90 $PROG -o $TMP3 recno $TMP2
91 if (cmp -s $TMP1 $TMP3) ; then :
92 else
93 echo "test1: type recno: failed"
94 exit 1
95 fi
96}
97
98# Take the first 200 entries in the dictionary, and give them
99# each a medium size data entry.
100test2()
101{
102 echo "Test 2: btree, hash: small key, medium data pairs"
103 mdata=abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz
104 echo $mdata |
105 awk '{ for (i = 1; i < 201; ++i) print $0 }' > $TMP1
106 for type in hash btree; do
107 rm -f $TMP2 $TMP3
108 for i in `sed 200q $DICT`; do
109 echo p
110 echo k$i
111 echo d$mdata
112 echo g
113 echo k$i
114 done > $TMP2
115 $PROG -o $TMP3 $type $TMP2
116 if (cmp -s $TMP1 $TMP3) ; then :
117 else
118 echo "test2: type $type: failed"
119 exit 1
120 fi
121 done
122 echo "Test 2: recno: small key, medium data pairs"
123 rm -f $TMP2 $TMP3
124 echo $mdata |
125 awk '{ for (i = 1; i < 201; ++i)
126 printf("p\nk%d\nd%s\ng\nk%d\n", i, $0, i);
127 }' > $TMP2
128 $PROG -o $TMP3 recno $TMP2
129 if (cmp -s $TMP1 $TMP3) ; then :
130 else
131 echo "test2: type recno: failed"
132 exit 1
133 fi
134}
135
136# Insert the programs in /bin with their paths as their keys.
137test3()
138{
139 echo "Test 3: hash: small key, big data pairs"
140 rm -f $TMP1
141 (find /bin -type f -print | xargs cat) > $TMP1
142 for type in hash; do
143 rm -f $TMP2 $TMP3
144 for i in `find /bin -type f -print`; do
145 echo p
146 echo k$i
147 echo D$i
148 echo g
149 echo k$i
150 done > $TMP2
151 $PROG -o $TMP3 $type $TMP2
152 if (cmp -s $TMP1 $TMP3) ; then :
153 else
154 echo "test3: $type: failed"
155 exit 1
156 fi
157 done
158 echo "Test 3: btree: small key, big data pairs"
159 for psize in 512 16384 65536; do
160 echo " page size $psize"
161 for type in btree; do
162 rm -f $TMP2 $TMP3
163 for i in `find /bin -type f -print`; do
164 echo p
165 echo k$i
166 echo D$i
167 echo g
168 echo k$i
169 done > $TMP2
170 $PROG -i psize=$psize -o $TMP3 $type $TMP2
171 if (cmp -s $TMP1 $TMP3) ; then :
172 else
173 echo "test3: $type: page size $psize: failed"
174 exit 1
175 fi
176 done
177 done
178 echo "Test 3: recno: big data pairs"
179 rm -f $TMP2 $TMP3
180 find /bin -type f -print |
181 awk '{
182 ++i;
183 printf("p\nk%d\nD%s\ng\nk%d\n", i, $0, i);
184 }' > $TMP2
185 for psize in 512 16384 65536; do
186 echo " page size $psize"
187 $PROG -i psize=$psize -o $TMP3 recno $TMP2
188 if (cmp -s $TMP1 $TMP3) ; then :
189 else
190 echo "test3: recno: page size $psize: failed"
191 exit 1
192 fi
193 done
194}
195
196# Do random recno entries.
197test4()
198{
199 echo "Test 4: recno: random entries"
200 echo "abcdefg abcdefg abcdefg abcdefg abcdefg abcdefg abcdefg" |
201 awk '{
202 for (i = 37; i <= 37 + 88 * 17; i += 17) {
203 if (i % 41)
204 s = substr($0, 1, i % 41);
205 else
206 s = substr($0, 1);
207 printf("input key %d: %s\n", i, s);
208 }
209 for (i = 1; i <= 15; ++i) {
210 if (i % 41)
211 s = substr($0, 1, i % 41);
212 else
213 s = substr($0, 1);
214 printf("input key %d: %s\n", i, s);
215 }
216 for (i = 19234; i <= 19234 + 61 * 27; i += 27) {
217 if (i % 41)
218 s = substr($0, 1, i % 41);
219 else
220 s = substr($0, 1);
221 printf("input key %d: %s\n", i, s);
222 }
223 exit
224 }' > $TMP1
225 rm -f $TMP2 $TMP3
226 cat $TMP1 |
227 awk 'BEGIN {
228 i = 37;
229 incr = 17;
230 }
231 {
232 printf("p\nk%d\nd%s\n", i, $0);
233 if (i == 19234 + 61 * 27)
234 exit;
235 if (i == 37 + 88 * 17) {
236 i = 1;
237 incr = 1;
238 } else if (i == 15) {
239 i = 19234;
240 incr = 27;
241 } else
242 i += incr;
243 }
244 END {
245 for (i = 37; i <= 37 + 88 * 17; i += 17)
246 printf("g\nk%d\n", i);
247 for (i = 1; i <= 15; ++i)
248 printf("g\nk%d\n", i);
249 for (i = 19234; i <= 19234 + 61 * 27; i += 27)
250 printf("g\nk%d\n", i);
251 }' > $TMP2
252 $PROG -o $TMP3 recno $TMP2
253 if (cmp -s $TMP1 $TMP3) ; then :
254 else
255 echo "test4: type recno: failed"
256 exit 1
257 fi
258}
259
260# Do reverse order recno entries.
261test5()
262{
263 echo "Test 5: recno: reverse order entries"
264 echo "abcdefg abcdefg abcdefg abcdefg abcdefg abcdefg abcdefg" |
265 awk ' {
266 for (i = 1500; i; --i) {
267 if (i % 34)
268 s = substr($0, 1, i % 34);
269 else
270 s = substr($0, 1);
271 printf("input key %d: %s\n", i, s);
272 }
273 exit;
274 }' > $TMP1
275 rm -f $TMP2 $TMP3
276 cat $TMP1 |
277 awk 'BEGIN {
278 i = 1500;
279 }
280 {
281 printf("p\nk%d\nd%s\n", i, $0);
282 --i;
283 }
284 END {
285 for (i = 1500; i; --i)
286 printf("g\nk%d\n", i);
287 }' > $TMP2
288 $PROG -o $TMP3 recno $TMP2
289 if (cmp -s $TMP1 $TMP3) ; then :
290 else
291 echo "test5: type recno: failed"
292 exit 1
293 fi
294}
295
296# Do alternating order recno entries.
297test6()
298{
299 echo "Test 6: recno: alternating order entries"
300 echo "abcdefg abcdefg abcdefg abcdefg abcdefg abcdefg abcdefg" |
301 awk ' {
302 for (i = 1; i < 1200; i += 2) {
303 if (i % 34)
304 s = substr($0, 1, i % 34);
305 else
306 s = substr($0, 1);
307 printf("input key %d: %s\n", i, s);
308 }
309 for (i = 2; i < 1200; i += 2) {
310 if (i % 34)
311 s = substr($0, 1, i % 34);
312 else
313 s = substr($0, 1);
314 printf("input key %d: %s\n", i, s);
315 }
316 exit;
317 }' > $TMP1
318 rm -f $TMP2 $TMP3
319 cat $TMP1 |
320 awk 'BEGIN {
321 i = 1;
322 even = 0;
323 }
324 {
325 printf("p\nk%d\nd%s\n", i, $0);
326 i += 2;
327 if (i >= 1200) {
328 if (even == 1)
329 exit;
330 even = 1;
331 i = 2;
332 }
333 }
334 END {
335 for (i = 1; i < 1200; ++i)
336 printf("g\nk%d\n", i);
337 }' > $TMP2
338 $PROG -o $TMP3 recno $TMP2
339 sort -o $TMP1 $TMP1
340 sort -o $TMP3 $TMP3
341 if (cmp -s $TMP1 $TMP3) ; then :
342 else
343 echo "test6: type recno: failed"
344 exit 1
345 fi
346}
347
348# Delete cursor record
349test7()
350{
351 echo "Test 7: btree, recno: delete cursor record"
352 echo "abcdefg abcdefg abcdefg abcdefg abcdefg abcdefg abcdefg" |
353 awk '{
354 for (i = 1; i <= 120; ++i)
355 printf("%05d: input key %d: %s\n", i, i, $0);
356 printf("%05d: input key %d: %s\n", 120, 120, $0);
357 printf("seq failed, no such key\n");
358 printf("%05d: input key %d: %s\n", 1, 1, $0);
359 printf("%05d: input key %d: %s\n", 2, 2, $0);
360 exit;
361 }' > $TMP1
362 rm -f $TMP2 $TMP3
363
364 for type in btree recno; do
365 cat $TMP1 |
366 awk '{
367 if (i == 120)
368 exit;
369 printf("p\nk%d\nd%s\n", ++i, $0);
370 }
371 END {
372 printf("fR_NEXT\n");
373 for (i = 1; i <= 120; ++i)
374 printf("s\n");
375 printf("fR_CURSOR\ns\nk120\n");
376 printf("r\n");
377 printf("fR_NEXT\ns\n");
378 printf("fR_CURSOR\ns\nk1\n");
379 printf("r\n");
380 printf("fR_FIRST\ns\n");
381 }' > $TMP2
382 $PROG -o $TMP3 recno $TMP2
383 if (cmp -s $TMP1 $TMP3) ; then :
384 else
385 echo "test7: type $type: failed"
386 exit 1
387 fi
388 done
389}
390
391# Make sure that overflow pages are reused.
392test8()
393{
394 echo "Test 8: btree, hash: repeated small key, big data pairs"
395 rm -f $TMP1
396 echo "" |
397 awk 'BEGIN {
398 for (i = 1; i <= 10; ++i) {
399 printf("p\nkkey1\nD/bin/sh\n");
400 printf("p\nkkey2\nD/bin/csh\n");
401 if (i % 8 == 0) {
402 printf("c\nkkey2\nD/bin/csh\n");
403 printf("c\nkkey1\nD/bin/sh\n");
404 printf("e\t%d of 10 (comparison)\n", i);
405 } else
406 printf("e\t%d of 10 \n", i);
407 printf("r\nkkey1\nr\nkkey2\n");
408 }
409 }' > $TMP1
410 $PROG btree $TMP1
411# $PROG hash $TMP1
412 # No explicit test for success.
413}
414
415# Test btree duplicate keys
416test9()
417{
418 echo "Test 9: btree: duplicate keys"
419 echo "abcdefg abcdefg abcdefg abcdefg abcdefg abcdefg abcdefg" |
420 awk '{
421 for (i = 1; i <= 543; ++i)
422 printf("%05d: input key %d: %s\n", i, i, $0);
423 exit;
424 }' > $TMP1
425 rm -f $TMP2 $TMP3
426
427 for type in btree; do
428 cat $TMP1 |
429 awk '{
430 if (i++ % 2)
431 printf("p\nkduplicatekey\nd%s\n", $0);
432 else
433 printf("p\nkunique%dkey\nd%s\n", i, $0);
434 }
435 END {
436 printf("o\n");
437 }' > $TMP2
438 $PROG -iflags=1 -o $TMP3 $type $TMP2
439 sort -o $TMP3 $TMP3
440 if (cmp -s $TMP1 $TMP3) ; then :
441 else
442 echo "test9: type $type: failed"
443 exit 1
444 fi
445 done
446}
447
448# Test use of cursor flags without initialization
449test10()
450{
451 echo "Test 10: btree, recno: test cursor flag use"
452 echo "abcdefg abcdefg abcdefg abcdefg abcdefg abcdefg abcdefg" |
453 awk '{
454 for (i = 1; i <= 20; ++i)
455 printf("%05d: input key %d: %s\n", i, i, $0);
456 exit;
457 }' > $TMP1
458 rm -f $TMP2 $TMP3
459
460 # Test that R_CURSOR doesn't succeed before cursor initialized
461 for type in btree recno; do
462 cat $TMP1 |
463 awk '{
464 if (i == 10)
465 exit;
466 printf("p\nk%d\nd%s\n", ++i, $0);
467 }
468 END {
469 printf("fR_CURSOR\nr\n");
470 printf("eR_CURSOR SHOULD HAVE FAILED\n");
471 }' > $TMP2
472 $PROG -o $TMP3 $type $TMP2 > /dev/null 2>&1
473 if [ -s $TMP3 ] ; then
474 echo "Test 10: delete: R_CURSOR SHOULD HAVE FAILED"
475 exit 1
476 fi
477 done
478 for type in btree recno; do
479 cat $TMP1 |
480 awk '{
481 if (i == 10)
482 exit;
483 printf("p\nk%d\nd%s\n", ++i, $0);
484 }
485 END {
486 printf("fR_CURSOR\np\nk1\ndsome data\n");
487 printf("eR_CURSOR SHOULD HAVE FAILED\n");
488 }' > $TMP2
489 $PROG -o $TMP3 $type $TMP2 > /dev/null 2>&1
490 if [ -s $TMP3 ] ; then
491 echo "Test 10: put: R_CURSOR SHOULD HAVE FAILED"
492 exit 1
493 fi
494 done
495}
496
497# Test insert in reverse order.
498test11()
499{
500 echo "Test 11: recno: reverse order insert"
501 echo "abcdefg abcdefg abcdefg abcdefg abcdefg abcdefg abcdefg" |
502 awk '{
503 for (i = 1; i <= 779; ++i)
504 printf("%05d: input key %d: %s\n", i, i, $0);
505 exit;
506 }' > $TMP1
507 rm -f $TMP2 $TMP3
508
509 for type in recno; do
510 cat $TMP1 |
511 awk '{
512 if (i == 0) {
513 i = 1;
514 printf("p\nk1\nd%s\n", $0);
515 printf("%s\n", "fR_IBEFORE");
516 } else
517 printf("p\nk1\nd%s\n", $0);
518 }
519 END {
520 printf("or\n");
521 }' > $TMP2
522 $PROG -o $TMP3 $type $TMP2
523 if (cmp -s $TMP1 $TMP3) ; then :
524 else
525 echo "test11: type $type: failed"
526 exit 1
527 fi
528 done
529}
530
531# Take the first 20000 entries in the dictionary, reverse them, and give
532# them each a small size data entry. Use a small page size to make sure
533# the btree split code gets hammered.
534test12()
535{
536 echo "Test 12: btree: lots of keys, small page size"
537 mdata=abcdefghijklmnopqrstuvwxy
538 echo $mdata |
539 awk '{ for (i = 1; i < 20001; ++i) print $0 }' > $TMP1
540 for type in btree; do
541 rm -f $TMP2 $TMP3
542 for i in `sed 20000q $DICT | rev`; do
543 echo p
544 echo k$i
545 echo d$mdata
546 echo g
547 echo k$i
548 done > $TMP2
549 $PROG -i psize=512 -o $TMP3 $type $TMP2
550 if (cmp -s $TMP1 $TMP3) ; then :
551 else
552 echo "test12: type $type: failed"
553 exit 1
554 fi
555 done
556}
557
558# Test different byte orders.
559test13()
560{
561 echo "Test 13: btree, hash: differing byte orders"
562 sed 50q $DICT > $TMP1
563 for order in 1234 4321; do
564 for type in btree hash; do
565 rm -f byte.file $TMP2 $TMP3
566 for i in `sed 50q $DICT`; do
567 echo p
568 echo k$i
569 echo d$i
570 echo g
571 echo k$i
572 done > $TMP2
573 $PROG -ilorder=$order -f byte.file -o $TMP3 $type $TMP2
574 if (cmp -s $TMP1 $TMP3) ; then :
575 else
576 echo "test13: $type/$order put failed"
577 exit 1
578 fi
579 for i in `sed 50q $DICT`; do
580 echo g
581 echo k$i
582 done > $TMP2
583 $PROG -s \
584 -ilorder=$order -f byte.file -o $TMP3 $type $TMP2
585 if (cmp -s $TMP1 $TMP3) ; then :
586 else
587 echo "test13: $type/$order get failed"
588 exit 1
589 fi
590 done
591 done
592 rm -f byte.file
593}
594
595# Try a variety of bucketsizes and fill factors for hashing
596test20()
597{
598 echo\
599 "Test 20: hash: bucketsize, fill factor; nelem 25000 cachesize 65536"
600 echo "abcdefg abcdefg abcdefg abcdefg abcdefg abcdefg abcdefg" |
601 awk '{
602 for (i = 1; i <= 10000; ++i) {
603 if (i % 34)
604 s = substr($0, 1, i % 34);
605 else
606 s = substr($0, 1);
607 printf("%s\n", s);
608 }
609 exit;
610 }' > $TMP1
611 sed 10000q $DICT |
612 awk 'BEGIN {
613 ds="abcdefg abcdefg abcdefg abcdefg abcdefg abcdefg abcdefg"
614 }
615 {
616 if (++i % 34)
617 s = substr(ds, 1, i % 34);
618 else
619 s = substr(ds, 1);
620 printf("p\nk%s\nd%s\n", $0, s);
621 }' > $TMP2
622 sed 10000q $DICT |
623 awk '{
624 ++i;
625 printf("g\nk%s\n", $0);
626 }' >> $TMP2
627 bsize=256
628 for ffactor in 11 14 21; do
629 echo " bucketsize $bsize, fill factor $ffactor"
630 $PROG -o$TMP3 \
631 -ibsize=$bsize,ffactor=$ffactor,nelem=25000,cachesize=65536\
632 hash $TMP2
633 if (cmp -s $TMP1 $TMP3) ; then :
634 else
635 echo "test20: type hash:\
636bsize=$bsize ffactor=$ffactor nelem=25000 cachesize=65536 failed"
637 exit 1
638 fi
639 done
640 bsize=512
641 for ffactor in 21 28 43; do
642 echo " bucketsize $bsize, fill factor $ffactor"
643 $PROG -o$TMP3 \
644 -ibsize=$bsize,ffactor=$ffactor,nelem=25000,cachesize=65536\
645 hash $TMP2
646 if (cmp -s $TMP1 $TMP3) ; then :
647 else
648 echo "test20: type hash:\
649bsize=$bsize ffactor=$ffactor nelem=25000 cachesize=65536 failed"
650 exit 1
651 fi
652 done
653 bsize=1024
654 for ffactor in 43 57 85; do
655 echo " bucketsize $bsize, fill factor $ffactor"
656 $PROG -o$TMP3 \
657 -ibsize=$bsize,ffactor=$ffactor,nelem=25000,cachesize=65536\
658 hash $TMP2
659 if (cmp -s $TMP1 $TMP3) ; then :
660 else
661 echo "test20: type hash:\
662bsize=$bsize ffactor=$ffactor nelem=25000 cachesize=65536 failed"
663 exit 1
664 fi
665 done
666 bsize=2048
667 for ffactor in 85 114 171; do
668 echo " bucketsize $bsize, fill factor $ffactor"
669 $PROG -o$TMP3 \
670 -ibsize=$bsize,ffactor=$ffactor,nelem=25000,cachesize=65536\
671 hash $TMP2
672 if (cmp -s $TMP1 $TMP3) ; then :
673 else
674 echo "test20: type hash:\
675bsize=$bsize ffactor=$ffactor nelem=25000 cachesize=65536 failed"
676 exit 1
677 fi
678 done
679 bsize=4096
680 for ffactor in 171 228 341; do
681 echo " bucketsize $bsize, fill factor $ffactor"
682 $PROG -o$TMP3 \
683 -ibsize=$bsize,ffactor=$ffactor,nelem=25000,cachesize=65536\
684 hash $TMP2
685 if (cmp -s $TMP1 $TMP3) ; then :
686 else
687 echo "test20: type hash:\
688bsize=$bsize ffactor=$ffactor nelem=25000 cachesize=65536 failed"
689 exit 1
690 fi
691 done
692 bsize=8192
693 for ffactor in 341 455 683; do
694 echo " bucketsize $bsize, fill factor $ffactor"
695 $PROG -o$TMP3 \
696 -ibsize=$bsize,ffactor=$ffactor,nelem=25000,cachesize=65536\
697 hash $TMP2
698 if (cmp -s $TMP1 $TMP3) ; then :
699 else
700 echo "test20: type hash:\
701bsize=$bsize ffactor=$ffactor nelem=25000 cachesize=65536 failed"
702 exit 1
703 fi
704 done
705}
706
707main $*
generated by cgit v1.2.3-55-g6feb (git 2.39.1) at 2025-04-21 13:53:41 +0000