зеркало из https://github.com/mozilla/gecko-dev.git
554 строки
13 KiB
C
554 строки
13 KiB
C
/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
|
|
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
/* use sequental numbers printed to strings
|
|
* to store lots and lots of entries in the
|
|
* database.
|
|
*
|
|
* Start with 100 entries, put them and then
|
|
* read them out. Then delete the first
|
|
* half and verify that all of the first half
|
|
* is gone and then verify that the second
|
|
* half is still there.
|
|
* Then add the first half back and verify
|
|
* again. Then delete the middle third
|
|
* and verify again.
|
|
* Then increase the size by 1000 and do
|
|
* the whole add delete thing again.
|
|
*
|
|
* The data for each object is the number string translated
|
|
* to hex and replicated a random number of times. The
|
|
* number of times that the data is replicated is the first
|
|
* int32 in the data.
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdlib.h>
|
|
#ifdef STDC_HEADERS
|
|
#include <stdarg.h>
|
|
#else
|
|
#include <varargs.h>
|
|
#endif
|
|
|
|
#ifdef HAVE_MEMORY_H
|
|
#include <memory.h>
|
|
#endif
|
|
#include <string.h>
|
|
#include <assert.h>
|
|
#include "mcom_db.h"
|
|
|
|
DB *database = 0;
|
|
int MsgPriority = 5;
|
|
|
|
#if defined(_WINDOWS) && !defined(WIN32)
|
|
#define int32 long
|
|
#define uint32 unsigned long
|
|
#else
|
|
#define int32 int
|
|
#define uint32 unsigned int
|
|
#endif
|
|
|
|
typedef enum {
|
|
USE_LARGE_KEY,
|
|
USE_SMALL_KEY
|
|
} key_type_enum;
|
|
|
|
#define TraceMe(priority, msg) \
|
|
do { \
|
|
if (priority <= MsgPriority) { \
|
|
ReportStatus msg; \
|
|
} \
|
|
} while (0)
|
|
|
|
int
|
|
ReportStatus(char *string, ...)
|
|
{
|
|
va_list args;
|
|
|
|
#ifdef STDC_HEADERS
|
|
va_start(args, string);
|
|
#else
|
|
va_start(args);
|
|
#endif
|
|
vfprintf(stderr, string, args);
|
|
va_end(args);
|
|
|
|
fprintf(stderr, "\n");
|
|
|
|
return (0);
|
|
}
|
|
|
|
int
|
|
ReportError(char *string, ...)
|
|
{
|
|
va_list args;
|
|
|
|
#ifdef STDC_HEADERS
|
|
va_start(args, string);
|
|
#else
|
|
va_start(args);
|
|
#endif
|
|
fprintf(stderr, "\n ");
|
|
vfprintf(stderr, string, args);
|
|
fprintf(stderr, "\n");
|
|
va_end(args);
|
|
|
|
return (0);
|
|
}
|
|
|
|
DBT *
|
|
MakeLargeKey(int32 num)
|
|
{
|
|
int32 low_bits;
|
|
static DBT rv;
|
|
static char *string_rv = 0;
|
|
int rep_char;
|
|
size_t size;
|
|
|
|
if (string_rv)
|
|
free(string_rv);
|
|
|
|
/* generate a really large text key derived from
|
|
* an int32
|
|
*/
|
|
low_bits = (num % 10000) + 1;
|
|
|
|
/* get the repeat char from the low 26 */
|
|
rep_char = (char)((low_bits % 26) + 'a');
|
|
|
|
/* malloc a string low_bits wide */
|
|
size = low_bits * sizeof(char);
|
|
string_rv = (char *)malloc(size);
|
|
|
|
memset(string_rv, rep_char, size);
|
|
|
|
rv.data = string_rv;
|
|
rv.size = size;
|
|
|
|
return (&rv);
|
|
}
|
|
|
|
DBT *
|
|
MakeSmallKey(int32 num)
|
|
{
|
|
static DBT rv;
|
|
static char data_string[64];
|
|
|
|
rv.data = data_string;
|
|
|
|
sprintf(data_string, "%ld", (long)num);
|
|
rv.size = strlen(data_string);
|
|
|
|
return (&rv);
|
|
}
|
|
|
|
DBT *
|
|
GenKey(int32 num, key_type_enum key_type)
|
|
{
|
|
DBT *key;
|
|
|
|
switch (key_type) {
|
|
case USE_LARGE_KEY:
|
|
key = MakeLargeKey(num);
|
|
break;
|
|
case USE_SMALL_KEY:
|
|
key = MakeSmallKey(num);
|
|
break;
|
|
default:
|
|
abort();
|
|
break;
|
|
}
|
|
|
|
return (key);
|
|
}
|
|
|
|
int
|
|
SeqDatabase()
|
|
{
|
|
int status;
|
|
DBT key, data;
|
|
|
|
ReportStatus("SEQuencing through database...");
|
|
|
|
/* seq through the whole database */
|
|
if (!(status = (*database->seq)(database, &key, &data, R_FIRST))) {
|
|
while (!(status = (database->seq)(database, &key, &data, R_NEXT)))
|
|
; /* null body */
|
|
}
|
|
|
|
if (status < 0)
|
|
ReportError("Error seq'ing database");
|
|
|
|
return (status);
|
|
}
|
|
|
|
int
|
|
VerifyData(DBT *data, int32 num, key_type_enum key_type)
|
|
{
|
|
int32 count, compare_num;
|
|
size_t size;
|
|
int32 *int32_array;
|
|
|
|
/* The first int32 is count
|
|
* The other n entries should
|
|
* all equal num
|
|
*/
|
|
if (data->size < sizeof(int32)) {
|
|
ReportError("Data size corrupted");
|
|
return -1;
|
|
}
|
|
|
|
memcpy(&count, data->data, sizeof(int32));
|
|
|
|
size = sizeof(int32) * (count + 1);
|
|
|
|
if (size != data->size) {
|
|
ReportError("Data size corrupted");
|
|
return -1;
|
|
}
|
|
|
|
int32_array = (int32 *)data->data;
|
|
|
|
for (; count > 0; count--) {
|
|
memcpy(&compare_num, &int32_array[count], sizeof(int32));
|
|
|
|
if (compare_num != num) {
|
|
ReportError("Data corrupted");
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
return (0);
|
|
}
|
|
|
|
/* verify that a range of number strings exist
|
|
* or don't exist. And that the data is valid
|
|
*/
|
|
#define SHOULD_EXIST 1
|
|
#define SHOULD_NOT_EXIST 0
|
|
int
|
|
VerifyRange(int32 low, int32 high, int32 should_exist, key_type_enum key_type)
|
|
{
|
|
DBT *key, data;
|
|
int32 num;
|
|
int status;
|
|
|
|
TraceMe(1, ("Verifying: %ld to %ld, using %s keys",
|
|
low, high, key_type == USE_SMALL_KEY ? "SMALL" : "LARGE"));
|
|
|
|
for (num = low; num <= high; num++) {
|
|
|
|
key = GenKey(num, key_type);
|
|
|
|
status = (*database->get)(database, key, &data, 0);
|
|
|
|
if (status == 0) {
|
|
/* got the item */
|
|
if (!should_exist) {
|
|
ReportError("Item exists but shouldn't: %ld", num);
|
|
} else {
|
|
/* else verify the data */
|
|
VerifyData(&data, num, key_type);
|
|
}
|
|
} else if (status > 0) {
|
|
/* item not found */
|
|
if (should_exist) {
|
|
ReportError("Item not found but should be: %ld", num);
|
|
}
|
|
} else {
|
|
/* database error */
|
|
ReportError("Database error");
|
|
return (-1);
|
|
}
|
|
}
|
|
|
|
TraceMe(1, ("Correctly verified: %ld to %ld", low, high));
|
|
|
|
return (0);
|
|
}
|
|
|
|
DBT *
|
|
GenData(int32 num)
|
|
{
|
|
int32 n;
|
|
static DBT *data = 0;
|
|
int32 *int32_array;
|
|
size_t size;
|
|
|
|
if (!data) {
|
|
data = (DBT *)malloc(sizeof(DBT));
|
|
data->size = 0;
|
|
data->data = 0;
|
|
} else if (data->data) {
|
|
free(data->data);
|
|
}
|
|
|
|
n = rand();
|
|
|
|
n = n % 512; /* bound to a 2K size */
|
|
|
|
size = sizeof(int32) * (n + 1);
|
|
int32_array = (int32 *)malloc(size);
|
|
|
|
memcpy(&int32_array[0], &n, sizeof(int32));
|
|
|
|
for (; n > 0; n--) {
|
|
memcpy(&int32_array[n], &num, sizeof(int32));
|
|
}
|
|
|
|
data->data = (void *)int32_array;
|
|
data->size = size;
|
|
|
|
return (data);
|
|
}
|
|
|
|
#define ADD_RANGE 1
|
|
#define DELETE_RANGE 2
|
|
|
|
int
|
|
AddOrDelRange(int32 low, int32 high, int action, key_type_enum key_type)
|
|
{
|
|
DBT *key, *data;
|
|
#if 0 /* only do this if your really analy checking the puts */
|
|
DBT tmp_data;
|
|
#endif
|
|
int32 num;
|
|
int status;
|
|
|
|
if (action != ADD_RANGE && action != DELETE_RANGE)
|
|
assert(0);
|
|
|
|
if (action == ADD_RANGE) {
|
|
TraceMe(1, ("Adding: %ld to %ld: %s keys", low, high,
|
|
key_type == USE_SMALL_KEY ? "SMALL" : "LARGE"));
|
|
} else {
|
|
TraceMe(1, ("Deleting: %ld to %ld: %s keys", low, high,
|
|
key_type == USE_SMALL_KEY ? "SMALL" : "LARGE"));
|
|
}
|
|
|
|
for (num = low; num <= high; num++) {
|
|
|
|
key = GenKey(num, key_type);
|
|
|
|
if (action == ADD_RANGE) {
|
|
data = GenData(num);
|
|
status = (*database->put)(database, key, data, 0);
|
|
} else {
|
|
status = (*database->del)(database, key, 0);
|
|
}
|
|
|
|
if (status < 0) {
|
|
ReportError("Database error %s item: %ld",
|
|
action == ADD_RANGE ? "ADDING" : "DELETING",
|
|
num);
|
|
} else if (status > 0) {
|
|
ReportError("Could not %s item: %ld",
|
|
action == ADD_RANGE ? "ADD" : "DELETE",
|
|
num);
|
|
} else if (action == ADD_RANGE) {
|
|
#define SYNC_EVERY_TIME
|
|
#ifdef SYNC_EVERY_TIME
|
|
status = (*database->sync)(database, 0);
|
|
if (status != 0)
|
|
ReportError("Database error syncing after add");
|
|
#endif
|
|
|
|
#if 0 /* only do this if your really analy checking the puts */
|
|
|
|
/* make sure we can still get it
|
|
*/
|
|
status = (*database->get)(database, key, &tmp_data, 0);
|
|
|
|
if(status != 0)
|
|
{
|
|
ReportError("Database error checking item just added: %d",
|
|
num);
|
|
}
|
|
else
|
|
{
|
|
/* now verify that none of the ones we already
|
|
* put in have disappeared
|
|
*/
|
|
VerifyRange(low, num, SHOULD_EXIST, key_type);
|
|
}
|
|
#endif
|
|
}
|
|
}
|
|
|
|
if (action == ADD_RANGE) {
|
|
TraceMe(1, ("Successfully added: %ld to %ld", low, high));
|
|
} else {
|
|
TraceMe(1, ("Successfully deleted: %ld to %ld", low, high));
|
|
}
|
|
|
|
return (0);
|
|
}
|
|
|
|
int
|
|
TestRange(int32 low, int32 range, key_type_enum key_type)
|
|
{
|
|
int status;
|
|
int32 low_of_range1, high_of_range1;
|
|
int32 low_of_range2, high_of_range2;
|
|
int32 low_of_range3, high_of_range3;
|
|
|
|
status = AddOrDelRange(low, low + range, ADD_RANGE, key_type);
|
|
status = VerifyRange(low, low + range, SHOULD_EXIST, key_type);
|
|
|
|
TraceMe(1, ("Finished with sub test 1"));
|
|
|
|
SeqDatabase();
|
|
|
|
low_of_range1 = low;
|
|
high_of_range1 = low + (range / 2);
|
|
low_of_range2 = high_of_range1 + 1;
|
|
high_of_range2 = low + range;
|
|
status = AddOrDelRange(low_of_range1, high_of_range1, DELETE_RANGE, key_type);
|
|
status = VerifyRange(low_of_range1, high_of_range1, SHOULD_NOT_EXIST, key_type);
|
|
status = VerifyRange(low_of_range2, low_of_range2, SHOULD_EXIST, key_type);
|
|
|
|
TraceMe(1, ("Finished with sub test 2"));
|
|
|
|
SeqDatabase();
|
|
|
|
status = AddOrDelRange(low_of_range1, high_of_range1, ADD_RANGE, key_type);
|
|
/* the whole thing should exist now */
|
|
status = VerifyRange(low, low + range, SHOULD_EXIST, key_type);
|
|
|
|
TraceMe(1, ("Finished with sub test 3"));
|
|
|
|
SeqDatabase();
|
|
|
|
status = AddOrDelRange(low_of_range2, high_of_range2, DELETE_RANGE, key_type);
|
|
status = VerifyRange(low_of_range1, high_of_range1, SHOULD_EXIST, key_type);
|
|
status = VerifyRange(low_of_range2, high_of_range2, SHOULD_NOT_EXIST, key_type);
|
|
|
|
TraceMe(1, ("Finished with sub test 4"));
|
|
|
|
SeqDatabase();
|
|
|
|
status = AddOrDelRange(low_of_range2, high_of_range2, ADD_RANGE, key_type);
|
|
/* the whole thing should exist now */
|
|
status = VerifyRange(low, low + range, SHOULD_EXIST, key_type);
|
|
|
|
TraceMe(1, ("Finished with sub test 5"));
|
|
|
|
SeqDatabase();
|
|
|
|
low_of_range1 = low;
|
|
high_of_range1 = low + (range / 3);
|
|
low_of_range2 = high_of_range1 + 1;
|
|
high_of_range2 = high_of_range1 + (range / 3);
|
|
low_of_range3 = high_of_range2 + 1;
|
|
high_of_range3 = low + range;
|
|
/* delete range 2 */
|
|
status = AddOrDelRange(low_of_range2, high_of_range2, DELETE_RANGE, key_type);
|
|
status = VerifyRange(low_of_range1, high_of_range1, SHOULD_EXIST, key_type);
|
|
status = VerifyRange(low_of_range2, low_of_range2, SHOULD_NOT_EXIST, key_type);
|
|
status = VerifyRange(low_of_range3, low_of_range2, SHOULD_EXIST, key_type);
|
|
|
|
TraceMe(1, ("Finished with sub test 6"));
|
|
|
|
SeqDatabase();
|
|
|
|
status = AddOrDelRange(low_of_range2, high_of_range2, ADD_RANGE, key_type);
|
|
/* the whole thing should exist now */
|
|
status = VerifyRange(low, low + range, SHOULD_EXIST, key_type);
|
|
|
|
TraceMe(1, ("Finished with sub test 7"));
|
|
|
|
return (0);
|
|
}
|
|
|
|
#define START_RANGE 109876
|
|
int
|
|
main(int argc, char **argv)
|
|
{
|
|
int32 i, j = 0;
|
|
int quick_exit = 0;
|
|
int large_keys = 0;
|
|
HASHINFO hash_info = {
|
|
16 * 1024,
|
|
0,
|
|
0,
|
|
0,
|
|
0,
|
|
0
|
|
};
|
|
|
|
if (argc > 1) {
|
|
while (argc > 1) {
|
|
if (!strcmp(argv[argc - 1], "-quick"))
|
|
quick_exit = 1;
|
|
else if (!strcmp(argv[argc - 1], "-large")) {
|
|
large_keys = 1;
|
|
}
|
|
argc--;
|
|
}
|
|
}
|
|
|
|
database = dbopen("test.db", O_RDWR | O_CREAT, 0644, DB_HASH, &hash_info);
|
|
|
|
if (!database) {
|
|
ReportError("Could not open database");
|
|
#ifdef unix
|
|
perror("");
|
|
#endif
|
|
exit(1);
|
|
}
|
|
|
|
if (quick_exit) {
|
|
if (large_keys)
|
|
TestRange(START_RANGE, 200, USE_LARGE_KEY);
|
|
else
|
|
TestRange(START_RANGE, 200, USE_SMALL_KEY);
|
|
|
|
(*database->sync)(database, 0);
|
|
(*database->close)(database);
|
|
exit(0);
|
|
}
|
|
|
|
for (i = 100; i < 10000000; i += 200) {
|
|
if (1 || j) {
|
|
TestRange(START_RANGE, i, USE_LARGE_KEY);
|
|
j = 0;
|
|
} else {
|
|
TestRange(START_RANGE, i, USE_SMALL_KEY);
|
|
j = 1;
|
|
}
|
|
|
|
if (1 == rand() % 3) {
|
|
(*database->sync)(database, 0);
|
|
}
|
|
|
|
if (1 == rand() % 3) {
|
|
/* close and reopen */
|
|
(*database->close)(database);
|
|
database = dbopen("test.db", O_RDWR | O_CREAT, 0644, DB_HASH, 0);
|
|
if (!database) {
|
|
ReportError("Could not reopen database");
|
|
#ifdef unix
|
|
perror("");
|
|
#endif
|
|
exit(1);
|
|
}
|
|
} else {
|
|
/* reopen database without closeing the other */
|
|
database = dbopen("test.db", O_RDWR | O_CREAT, 0644, DB_HASH, 0);
|
|
if (!database) {
|
|
ReportError("Could not reopen database "
|
|
"after not closing the other");
|
|
#ifdef unix
|
|
perror("");
|
|
#endif
|
|
exit(1);
|
|
}
|
|
}
|
|
}
|
|
|
|
return (0);
|
|
}
|