ccan/ntdb: demote to junkcode.
[ccan] / junkcode / rusty@rustcorp.com.au-ntdb / test / run-04-basichash.c
1 #include "ntdb-source.h"
2 #include "tap-interface.h"
3 #include "logging.h"
4 #include "helprun-external-agent.h"
5
6 /* We rig the hash so all records clash. */
7 static uint32_t clash(const void *key, size_t len, uint32_t seed, void *priv)
8 {
9         return *((const unsigned int *)key) << 20;
10 }
11
12 int main(int argc, char *argv[])
13 {
14         unsigned int i;
15         struct ntdb_context *ntdb;
16         unsigned int v;
17         struct ntdb_used_record rec;
18         NTDB_DATA key = { (unsigned char *)&v, sizeof(v) };
19         NTDB_DATA dbuf = { (unsigned char *)&v, sizeof(v) };
20         union ntdb_attribute hattr = { .hash = { .base = { NTDB_ATTRIBUTE_HASH },
21                                                 .fn = clash } };
22         int flags[] = { NTDB_INTERNAL, NTDB_DEFAULT, NTDB_NOMMAP,
23                         NTDB_INTERNAL|NTDB_CONVERT, NTDB_CONVERT,
24                         NTDB_NOMMAP|NTDB_CONVERT,
25         };
26
27         hattr.base.next = &tap_log_attr;
28
29         plan_tests(sizeof(flags) / sizeof(flags[0]) * 137 + 1);
30         for (i = 0; i < sizeof(flags) / sizeof(flags[0]); i++) {
31                 struct hash_info h;
32                 ntdb_off_t new_off, new_off2, off;
33
34                 ntdb = ntdb_open("run-04-basichash.ntdb", flags[i]|MAYBE_NOSYNC,
35                                  O_RDWR|O_CREAT|O_TRUNC, 0600, &hattr);
36                 ok1(ntdb);
37                 if (!ntdb)
38                         continue;
39
40                 v = 0;
41                 /* Should not find it. */
42                 ok1(find_and_lock(ntdb, key, F_WRLCK, &h, &rec, NULL) == 0);
43                 /* Should have created correct hash. */
44                 ok1(h.h == ntdb_hash(ntdb, key.dptr, key.dsize));
45                 /* Should have located space in top table, bucket 0. */
46                 ok1(h.table == NTDB_HASH_OFFSET);
47                 ok1(h.table_size == (1 << ntdb->hash_bits));
48                 ok1(h.bucket == 0);
49                 ok1(h.old_val == 0);
50
51                 /* Should have lock on bucket 0 */
52                 ok1(h.h == 0);
53                 ok1((ntdb->flags & NTDB_NOLOCK) || ntdb->file->num_lockrecs == 1);
54                 ok1((ntdb->flags & NTDB_NOLOCK)
55                     || ntdb->file->lockrecs[0].off == NTDB_HASH_LOCK_START);
56                 /* FIXME: Check lock length */
57
58                 /* Allocate a new record. */
59                 new_off = alloc(ntdb, key.dsize, dbuf.dsize,
60                                 NTDB_USED_MAGIC, false);
61                 ok1(!NTDB_OFF_IS_ERR(new_off));
62
63                 /* We should be able to add it now. */
64                 ok1(add_to_hash(ntdb, &h, new_off) == 0);
65
66                 /* Make sure we fill it in for later finding. */
67                 off = new_off + sizeof(struct ntdb_used_record);
68                 ok1(!ntdb->io->twrite(ntdb, off, key.dptr, key.dsize));
69                 off += key.dsize;
70                 ok1(!ntdb->io->twrite(ntdb, off, dbuf.dptr, dbuf.dsize));
71
72                 /* We should be able to unlock that OK. */
73                 ok1(ntdb_unlock_hash(ntdb, h.h, F_WRLCK) == 0);
74
75                 /* Database should be consistent. */
76                 ok1(ntdb_check(ntdb, NULL, NULL) == 0);
77
78                 /* Now, this should give a successful lookup. */
79                 ok1(find_and_lock(ntdb, key, F_WRLCK, &h, &rec, NULL) == new_off);
80                 /* Should have created correct hash. */
81                 ok1(h.h == ntdb_hash(ntdb, key.dptr, key.dsize));
82                 /* Should have located it in top table, bucket 0. */
83                 ok1(h.table == NTDB_HASH_OFFSET);
84                 ok1(h.table_size == (1 << ntdb->hash_bits));
85                 ok1(h.bucket == 0);
86
87                 /* Should have lock on bucket 0 */
88                 ok1(h.h == 0);
89                 ok1((ntdb->flags & NTDB_NOLOCK) || ntdb->file->num_lockrecs == 1);
90                 ok1((ntdb->flags & NTDB_NOLOCK)
91                     || ntdb->file->lockrecs[0].off == NTDB_HASH_LOCK_START);
92                 /* FIXME: Check lock length */
93
94                 ok1(ntdb_unlock_hash(ntdb, h.h, F_WRLCK) == 0);
95
96                 /* Database should be consistent. */
97                 ok1(ntdb_check(ntdb, NULL, NULL) == 0);
98
99                 /* Test expansion. */
100                 v = 1;
101                 ok1(find_and_lock(ntdb, key, F_WRLCK, &h, &rec, NULL) == 0);
102                 /* Should have created correct hash. */
103                 ok1(h.h == ntdb_hash(ntdb, key.dptr, key.dsize));
104                 /* Should have located clash in toplevel bucket 0. */
105                 ok1(h.table == NTDB_HASH_OFFSET);
106                 ok1(h.table_size == (1 << ntdb->hash_bits));
107                 ok1(h.bucket == 0);
108                 ok1((h.old_val & NTDB_OFF_MASK) == new_off);
109
110                 /* Should have lock on bucket 0 */
111                 ok1((h.h & ((1 << ntdb->hash_bits)-1)) == 0);
112                 ok1((ntdb->flags & NTDB_NOLOCK) || ntdb->file->num_lockrecs == 1);
113                 ok1((ntdb->flags & NTDB_NOLOCK)
114                     || ntdb->file->lockrecs[0].off == NTDB_HASH_LOCK_START);
115                 /* FIXME: Check lock length */
116
117                 new_off2 = alloc(ntdb, key.dsize, dbuf.dsize,
118                                  NTDB_USED_MAGIC, false);
119                 ok1(!NTDB_OFF_IS_ERR(new_off2));
120
121                 off = new_off2 + sizeof(struct ntdb_used_record);
122                 ok1(!ntdb->io->twrite(ntdb, off, key.dptr, key.dsize));
123                 off += key.dsize;
124                 ok1(!ntdb->io->twrite(ntdb, off, dbuf.dptr, dbuf.dsize));
125
126                 /* We should be able to add it now. */
127                 ok1(add_to_hash(ntdb, &h, new_off2) == 0);
128                 ok1(ntdb_unlock_hash(ntdb, h.h, F_WRLCK) == 0);
129
130                 /* Should be happy with expansion. */
131                 ok1(ntdb_check(ntdb, NULL, NULL) == 0);
132
133                 /* Should be able to find both. */
134                 v = 1;
135                 ok1(find_and_lock(ntdb, key, F_WRLCK, &h, &rec, NULL) == new_off2);
136                 /* Should have created correct hash. */
137                 ok1(h.h == ntdb_hash(ntdb, key.dptr, key.dsize));
138                 /* Should have located space in chain. */
139                 ok1(h.table > NTDB_HASH_OFFSET);
140                 ok1(h.table_size == 2);
141                 ok1(h.bucket == 1);
142                 /* Should have lock on bucket 0 */
143                 ok1((h.h & ((1 << ntdb->hash_bits)-1)) == 0);
144                 ok1((ntdb->flags & NTDB_NOLOCK) || ntdb->file->num_lockrecs == 1);
145                 ok1((ntdb->flags & NTDB_NOLOCK)
146                     || ntdb->file->lockrecs[0].off == NTDB_HASH_LOCK_START);
147                 ok1(ntdb_unlock_hash(ntdb, h.h, F_WRLCK) == 0);
148
149                 v = 0;
150                 ok1(find_and_lock(ntdb, key, F_WRLCK, &h, &rec, NULL) == new_off);
151                 /* Should have created correct hash. */
152                 ok1(h.h == ntdb_hash(ntdb, key.dptr, key.dsize));
153                 /* Should have located space in chain. */
154                 ok1(h.table > NTDB_HASH_OFFSET);
155                 ok1(h.table_size == 2);
156                 ok1(h.bucket == 0);
157
158                 /* Should have lock on bucket 0 */
159                 ok1((h.h & ((1 << ntdb->hash_bits)-1)) == 0);
160                 ok1((ntdb->flags & NTDB_NOLOCK) || ntdb->file->num_lockrecs == 1);
161                 ok1((ntdb->flags & NTDB_NOLOCK)
162                     || ntdb->file->lockrecs[0].off == NTDB_HASH_LOCK_START);
163                 /* FIXME: Check lock length */
164
165                 /* Simple delete should work. */
166                 ok1(delete_from_hash(ntdb, &h) == 0);
167                 ok1(add_free_record(ntdb, new_off,
168                                     sizeof(struct ntdb_used_record)
169                                     + rec_key_length(&rec)
170                                     + rec_data_length(&rec)
171                                     + rec_extra_padding(&rec),
172                                     NTDB_LOCK_NOWAIT, false) == 0);
173                 ok1(ntdb_unlock_hash(ntdb, h.h, F_WRLCK) == 0);
174                 ok1(ntdb_check(ntdb, NULL, NULL) == 0);
175
176                 /* Should still be able to find other record. */
177                 v = 1;
178                 ok1(find_and_lock(ntdb, key, F_WRLCK, &h, &rec, NULL) == new_off2);
179                 /* Should have created correct hash. */
180                 ok1(h.h == ntdb_hash(ntdb, key.dptr, key.dsize));
181                 /* Should have located space in chain. */
182                 ok1(h.table > NTDB_HASH_OFFSET);
183                 ok1(h.table_size == 2);
184                 ok1(h.bucket == 1);
185                 /* Should have lock on bucket 0 */
186                 ok1((h.h & ((1 << ntdb->hash_bits)-1)) == 0);
187                 ok1((ntdb->flags & NTDB_NOLOCK) || ntdb->file->num_lockrecs == 1);
188                 ok1((ntdb->flags & NTDB_NOLOCK)
189                     || ntdb->file->lockrecs[0].off == NTDB_HASH_LOCK_START);
190                 ok1(ntdb_unlock_hash(ntdb, h.h, F_WRLCK) == 0);
191
192                 /* Now should find empty space. */
193                 v = 0;
194                 ok1(find_and_lock(ntdb, key, F_WRLCK, &h, &rec, NULL) == 0);
195                 /* Should have created correct hash. */
196                 ok1(h.h == ntdb_hash(ntdb, key.dptr, key.dsize));
197                 /* Should have located space in chain, bucket 0. */
198                 ok1(h.table > NTDB_HASH_OFFSET);
199                 ok1(h.table_size == 2);
200                 ok1(h.bucket == 0);
201                 ok1(h.old_val == 0);
202
203                 /* Adding another record should work. */
204                 v = 2;
205                 ok1(find_and_lock(ntdb, key, F_WRLCK, &h, &rec, NULL) == 0);
206                 /* Should have created correct hash. */
207                 ok1(h.h == ntdb_hash(ntdb, key.dptr, key.dsize));
208                 /* Should have located space in chain, bucket 0. */
209                 ok1(h.table > NTDB_HASH_OFFSET);
210                 ok1(h.table_size == 2);
211                 ok1(h.bucket == 0);
212                 ok1(h.old_val == 0);
213
214                 /* Should have lock on bucket 0 */
215                 ok1((h.h & ((1 << ntdb->hash_bits)-1)) == 0);
216                 ok1((ntdb->flags & NTDB_NOLOCK) || ntdb->file->num_lockrecs == 1);
217                 ok1((ntdb->flags & NTDB_NOLOCK)
218                     || ntdb->file->lockrecs[0].off == NTDB_HASH_LOCK_START);
219
220                 new_off = alloc(ntdb, key.dsize, dbuf.dsize,
221                                 NTDB_USED_MAGIC, false);
222                 ok1(!NTDB_OFF_IS_ERR(new_off2));
223                 ok1(add_to_hash(ntdb, &h, new_off) == 0);
224                 ok1(ntdb_unlock_hash(ntdb, h.h, F_WRLCK) == 0);
225
226                 off = new_off + sizeof(struct ntdb_used_record);
227                 ok1(!ntdb->io->twrite(ntdb, off, key.dptr, key.dsize));
228                 off += key.dsize;
229                 ok1(!ntdb->io->twrite(ntdb, off, dbuf.dptr, dbuf.dsize));
230
231                 /* Adding another record should cause expansion. */
232                 v = 3;
233                 ok1(find_and_lock(ntdb, key, F_WRLCK, &h, &rec, NULL) == 0);
234                 /* Should have created correct hash. */
235                 ok1(h.h == ntdb_hash(ntdb, key.dptr, key.dsize));
236                 /* Should not have located space in chain. */
237                 ok1(h.table > NTDB_HASH_OFFSET);
238                 ok1(h.table_size == 2);
239                 ok1(h.bucket == 2);
240                 ok1(h.old_val != 0);
241
242                 /* Should have lock on bucket 0 */
243                 ok1((h.h & ((1 << ntdb->hash_bits)-1)) == 0);
244                 ok1((ntdb->flags & NTDB_NOLOCK) || ntdb->file->num_lockrecs == 1);
245                 ok1((ntdb->flags & NTDB_NOLOCK)
246                     || ntdb->file->lockrecs[0].off == NTDB_HASH_LOCK_START);
247
248                 new_off = alloc(ntdb, key.dsize, dbuf.dsize,
249                                 NTDB_USED_MAGIC, false);
250                 ok1(!NTDB_OFF_IS_ERR(new_off2));
251                 off = new_off + sizeof(struct ntdb_used_record);
252                 ok1(!ntdb->io->twrite(ntdb, off, key.dptr, key.dsize));
253                 off += key.dsize;
254                 ok1(!ntdb->io->twrite(ntdb, off, dbuf.dptr, dbuf.dsize));
255                 ok1(add_to_hash(ntdb, &h, new_off) == 0);
256                 ok1(ntdb_unlock_hash(ntdb, h.h, F_WRLCK) == 0);
257
258                 /* Retrieve it and check. */
259                 ok1(find_and_lock(ntdb, key, F_WRLCK, &h, &rec, NULL) == new_off);
260                 /* Should have created correct hash. */
261                 ok1(h.h == ntdb_hash(ntdb, key.dptr, key.dsize));
262                 /* Should have appended to chain, bucket 2. */
263                 ok1(h.table > NTDB_HASH_OFFSET);
264                 ok1(h.table_size == 3);
265                 ok1(h.bucket == 2);
266
267                 /* Should have lock on bucket 0 */
268                 ok1((h.h & ((1 << ntdb->hash_bits)-1)) == 0);
269                 ok1((ntdb->flags & NTDB_NOLOCK) || ntdb->file->num_lockrecs == 1);
270                 ok1((ntdb->flags & NTDB_NOLOCK)
271                     || ntdb->file->lockrecs[0].off == NTDB_HASH_LOCK_START);
272                 ok1(ntdb_unlock_hash(ntdb, h.h, F_WRLCK) == 0);
273
274                 /* YA record: relocation. */
275                 v = 4;
276                 ok1(find_and_lock(ntdb, key, F_WRLCK, &h, &rec, NULL) == 0);
277                 /* Should have created correct hash. */
278                 ok1(h.h == ntdb_hash(ntdb, key.dptr, key.dsize));
279                 /* Should not have located space in chain. */
280                 ok1(h.table > NTDB_HASH_OFFSET);
281                 ok1(h.table_size == 3);
282                 ok1(h.bucket == 3);
283                 ok1(h.old_val != 0);
284
285                 /* Should have lock on bucket 0 */
286                 ok1((h.h & ((1 << ntdb->hash_bits)-1)) == 0);
287                 ok1((ntdb->flags & NTDB_NOLOCK) || ntdb->file->num_lockrecs == 1);
288                 ok1((ntdb->flags & NTDB_NOLOCK)
289                     || ntdb->file->lockrecs[0].off == NTDB_HASH_LOCK_START);
290
291                 new_off = alloc(ntdb, key.dsize, dbuf.dsize,
292                                 NTDB_USED_MAGIC, false);
293                 ok1(!NTDB_OFF_IS_ERR(new_off2));
294                 off = new_off + sizeof(struct ntdb_used_record);
295                 ok1(!ntdb->io->twrite(ntdb, off, key.dptr, key.dsize));
296                 off += key.dsize;
297                 ok1(!ntdb->io->twrite(ntdb, off, dbuf.dptr, dbuf.dsize));
298                 ok1(add_to_hash(ntdb, &h, new_off) == 0);
299                 ok1(ntdb_unlock_hash(ntdb, h.h, F_WRLCK) == 0);
300
301                 /* Retrieve it and check. */
302                 ok1(find_and_lock(ntdb, key, F_WRLCK, &h, &rec, NULL) == new_off);
303                 /* Should have created correct hash. */
304                 ok1(h.h == ntdb_hash(ntdb, key.dptr, key.dsize));
305                 /* Should have appended to chain, bucket 2. */
306                 ok1(h.table > NTDB_HASH_OFFSET);
307                 ok1(h.table_size == 4);
308                 ok1(h.bucket == 3);
309
310                 /* Should have lock on bucket 0 */
311                 ok1((h.h & ((1 << ntdb->hash_bits)-1)) == 0);
312                 ok1((ntdb->flags & NTDB_NOLOCK) || ntdb->file->num_lockrecs == 1);
313                 ok1((ntdb->flags & NTDB_NOLOCK)
314                     || ntdb->file->lockrecs[0].off == NTDB_HASH_LOCK_START);
315                 ok1(ntdb_unlock_hash(ntdb, h.h, F_WRLCK) == 0);
316
317                 ntdb_close(ntdb);
318         }
319
320         ok1(tap_log_messages == 0);
321         return exit_status();
322 }