void
test_open_invalid_chunk_file(void)
{
grn_io *io;
gchar *id_string;
const gchar *expected_error_message =
cut_take_printf("[column][index] file type must be 0x48: <%#04x>", 0);
io = grn_io_create(context, path, 10, 10, 10, grn_io_auto, GRN_IO_EXPIRE_SEGMENT);
cut_assert_not_null(io);
id_string = grn_io_header(io);
strcpy(id_string, "WRONG-ID");
grn_io_close(context, io);
io = grn_io_create(context, cut_take_printf("%s.c", path),
10, 10, 10, grn_io_auto, GRN_IO_EXPIRE_SEGMENT);
cut_assert_not_null(io);
grn_io_close(context, io);
clear_messages();
inverted_index = grn_ii_open(context, path, lexicon);
cut_assert_null(inverted_index);
cut_assert_equal_substring(expected_error_message,
messages()->data,
strlen(expected_error_message));
}
static grn_ra *
_grn_ra_create(grn_ctx *ctx, grn_ra *ra, const char *path, unsigned int element_size)
{
grn_io *io;
int max_segments, n_elm, w_elm;
struct grn_ra_header *header;
unsigned int actual_size;
if (element_size > GRN_RA_SEGMENT_SIZE) {
GRN_LOG(ctx, GRN_LOG_ERROR, "element_size too large (%d)", element_size);
return NULL;
}
for (actual_size = 1; actual_size < element_size; actual_size *= 2) ;
max_segments = ((GRN_ID_MAX + 1) / GRN_RA_SEGMENT_SIZE) * actual_size;
io = grn_io_create(ctx, path, sizeof(struct grn_ra_header),
GRN_RA_SEGMENT_SIZE, max_segments, grn_io_auto,
GRN_IO_EXPIRE_SEGMENT);
if (!io) { return NULL; }
header = grn_io_header(io);
grn_io_set_type(io, GRN_COLUMN_FIX_SIZE);
header->element_size = actual_size;
n_elm = GRN_RA_SEGMENT_SIZE / header->element_size;
for (w_elm = 22; (1 << w_elm) > n_elm; w_elm--);
ra->io = io;
ra->header = header;
ra->element_mask = n_elm - 1;
ra->element_width = w_elm;
return ra;
}
grn_ja *
grn_ja_create(grn_ctx *ctx, const char *path, unsigned int max_element_size, uint32_t flags)
{
int i;
grn_io *io;
grn_ja *ja = NULL;
struct grn_ja_header *header;
io = grn_io_create(ctx, path, sizeof(struct grn_ja_header),
JA_SEGMENT_SIZE, JA_N_DSEGMENTS, grn_io_auto,
GRN_IO_EXPIRE_SEGMENT);
if (!io) { return NULL; }
grn_io_set_type(io, GRN_COLUMN_VAR_SIZE);
header = grn_io_header(io);
header->curr_pos = JA_SEGMENT_SIZE;
header->flags = flags;
for (i = 0; i < JA_N_ESEGMENTS; i++) { header->esegs[i] = JA_ESEG_VOID; }
if (!(ja = GRN_GMALLOC(sizeof(grn_ja)))) {
grn_io_close(ctx, io);
return NULL;
}
GRN_DB_OBJ_SET_TYPE(ja, GRN_COLUMN_VAR_SIZE);
ja->io = io;
ja->header = header;
header->max_element_size = max_element_size;
SEGMENTS_EINFO_ON(ja, 0, 0);
header->esegs[0] = 0;
return ja;
}
void
test_open_invalid_chunk_file(void)
{
grn_io *io;
gchar *id_string;
io = grn_io_create(context, path, 10, 10, 10, grn_io_auto, GRN_IO_EXPIRE_SEGMENT);
cut_assert_not_null(io);
id_string = grn_io_header(io);
strcpy(id_string, "WRONG-ID");
grn_io_close(context, io);
io = grn_io_create(context, cut_take_printf("%s.c", path),
10, 10, 10, grn_io_auto, GRN_IO_EXPIRE_SEGMENT);
cut_assert_not_null(io);
grn_io_close(context, io);
inverted_index = grn_ii_open(context, path, lexicon);
cut_assert_null(inverted_index);
expected_messages = gcut_list_string_new("file type unmatch", NULL);
cut_assert_not_null(strstr(g_list_nth_data((GList *)messages(), 1), "file type unmatch"));
}
void
test_open_invalid_segment_file(void)
{
grn_io *io;
gchar *id_string;
io = grn_io_create(context, path, 10, 10, 10, grn_io_auto, GRN_IO_EXPIRE_SEGMENT);
cut_assert_not_null(io);
id_string = grn_io_header(io);
strcpy(id_string, "WRONG-ID");
grn_io_close(context, io);
inverted_index = grn_ii_open(context, path, lexicon);
cut_assert_null(inverted_index);
cut_assert_not_null(strstr(g_list_nth_data((GList *)messages(), 1), "syscall error"));
}
grn_dat *
grn_dat_create(grn_ctx *ctx, const char *path, uint32_t,
uint32_t, uint32_t flags)
{
if (path) {
if (path[0] == '\0') {
path = NULL;
} else if (std::strlen(path) >= (PATH_MAX - (FILE_ID_LENGTH + 1))) {
ERR(GRN_FILENAME_TOO_LONG, "too long path");
return NULL;
}
}
grn_dat * const dat = static_cast<grn_dat *>(GRN_MALLOC(sizeof(grn_dat)));
if (!dat) {
return NULL;
}
grn_dat_init(ctx, dat);
dat->obj.header.flags = flags;
dat->io = grn_io_create(ctx, path, sizeof(struct grn_dat_header),
4096, 0, grn_io_auto, GRN_IO_EXPIRE_SEGMENT);
if (!dat->io) {
GRN_FREE(dat);
return NULL;
}
grn_io_set_type(dat->io, GRN_TABLE_DAT_KEY);
dat->header = static_cast<struct grn_dat_header *>(grn_io_header(dat->io));
if (!dat->header) {
grn_io_close(ctx, dat->io);
grn_dat_remove_file(ctx, path);
GRN_FREE(dat);
return NULL;
}
const grn_encoding encoding = (ctx->encoding != GRN_ENC_DEFAULT) ?
ctx->encoding : grn_gctx.encoding;
dat->header->flags = flags;
dat->header->encoding = encoding;
dat->header->tokenizer = GRN_ID_NIL;
dat->header->file_id = 0;
dat->encoding = encoding;
dat->tokenizer = NULL;
return dat;
}
void
test_open_invalid_segment_file(void)
{
grn_io *io;
gchar *id_string;
const gchar *expected_error_message = "system call error";
io = grn_io_create(context, path, 10, 10, 10,
grn_io_auto, GRN_IO_EXPIRE_SEGMENT);
cut_assert_not_null(io);
id_string = grn_io_header(io);
strcpy(id_string, "WRONG-ID");
grn_io_close(context, io);
clear_messages();
inverted_index = grn_ii_open(context, path, lexicon);
cut_assert_null(inverted_index);
cut_assert_equal_substring(expected_error_message,
messages()->data,
strlen(expected_error_message));
}
