null+****@clear*****
null+****@clear*****
2012年 2月 1日 (水) 13:08:03 JST
Susumu Yata 2012-02-01 13:08:03 +0900 (Wed, 01 Feb 2012)
New Revision: b4fdd466ba3aaa68021a9dc231a8e2a9e8cf762a
Log:
updated tests for grn_dat.
Modified files:
test/unit/core/dat/test-array.cpp
test/unit/core/dat/test-check.cpp
test/unit/core/dat/test-cursor-factory.cpp
test/unit/core/dat/test-dat-cursor.cpp
test/unit/core/dat/test-dat-pat.cpp
test/unit/core/dat/test-dat.cpp
test/unit/core/dat/test-file.cpp
test/unit/core/dat/test-id-cursor.cpp
test/unit/core/dat/test-key-cursor.cpp
test/unit/core/dat/test-key.cpp
test/unit/core/dat/test-predictive-cursor.cpp
test/unit/core/dat/test-prefix-cursor.cpp
test/unit/core/dat/test-trie.cpp
test/unit/core/dat/test-vector.cpp
Modified: test/unit/core/dat/test-array.cpp (+5 -4)
===================================================================
--- test/unit/core/dat/test-array.cpp 2012-02-01 10:57:14 +0900 (62600bb)
+++ test/unit/core/dat/test-array.cpp 2012-02-01 13:08:03 +0900 (1999c33)
@@ -1,6 +1,6 @@
/* -*- c-basic-offset: 2; coding: utf-8 -*- */
/*
- Copyright (C) 2011 Brazil
+ Copyright (C) 2011-2012 Brazil
Copyright (C) 2011 Kouhei Sutou <kou****@clear*****>
This library is free software; you can redistribute it and/or
@@ -37,14 +37,15 @@ namespace test_dat_array
for (std::size_t i = 0; i < sizeof(buf); ++i) {
cppcut_assert_equal(buf[i], array[i]);
- cppcut_assert_equal(buf[i], static_cast<const grn::dat::Array<char> &>(array)[i]);
+ cppcut_assert_equal(buf[i],
+ static_cast<const grn::dat::Array<char> &>(array)[i]);
}
cppcut_assert_equal(buf, array.begin());
cppcut_assert_equal(buf,
- static_cast<const grn::dat::Array<char> &>(array).begin());
+ static_cast<const grn::dat::Array<char> &>(array).begin());
cppcut_assert_equal((buf + sizeof(buf)), array.end());
cppcut_assert_equal((buf + sizeof(buf)),
- static_cast<const grn::dat::Array<char> &>(array).end());
+ static_cast<const grn::dat::Array<char> &>(array).end());
}
void test_assign_without_length(void)
Modified: test/unit/core/dat/test-check.cpp (+4 -3)
===================================================================
--- test/unit/core/dat/test-check.cpp 2012-02-01 10:57:14 +0900 (55032e3)
+++ test/unit/core/dat/test-check.cpp 2012-02-01 13:08:03 +0900 (b1b7524)
@@ -1,6 +1,6 @@
/* -*- c-basic-offset: 2; coding: utf-8 -*- */
/*
- Copyright (C) 2011 Brazil
+ Copyright (C) 2011-2012 Brazil
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
@@ -79,8 +79,9 @@ namespace test_dat_check
cppcut_assert_equal(grn::dat::UInt32('c'), check.sibling());
cppcut_assert_equal(true, check.is_offset());
- cppcut_assert_equal('a' | grn::dat::UInt32('b' << 9) | grn::dat::UInt32('c' << 18),
- check.except_is_offset());
+ const grn::dat::UInt32 expected_except_is_offset =
+ 'a' | grn::dat::UInt32('b' << 9) | grn::dat::UInt32('c' << 18);
+ cppcut_assert_equal(expected_except_is_offset, check.except_is_offset());
cppcut_assert_equal(false, check.is_phantom());
}
}
Modified: test/unit/core/dat/test-cursor-factory.cpp (+9 -5)
===================================================================
--- test/unit/core/dat/test-cursor-factory.cpp 2012-02-01 10:57:14 +0900 (4063a18)
+++ test/unit/core/dat/test-cursor-factory.cpp 2012-02-01 13:08:03 +0900 (9e3815a)
@@ -1,6 +1,6 @@
/* -*- c-basic-offset: 2; coding: utf-8 -*- */
/*
- Copyright (C) 2011 Brazil
+ Copyright (C) 2011-2012 Brazil
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
@@ -52,8 +52,10 @@ namespace test_dat_cursor_factory
cppcut_assert_equal(grn::dat::UInt32(1), cursor->offset());
cppcut_assert_equal(grn::dat::UInt32(2), cursor->limit());
- cppcut_assert_equal(grn::dat::KEY_RANGE_CURSOR | grn::dat::ASCENDING_CURSOR |
- grn::dat::EXCEPT_LOWER_BOUND | grn::dat::EXCEPT_UPPER_BOUND,
+ cppcut_assert_equal(grn::dat::KEY_RANGE_CURSOR |
+ grn::dat::ASCENDING_CURSOR |
+ grn::dat::EXCEPT_LOWER_BOUND |
+ grn::dat::EXCEPT_UPPER_BOUND,
cursor->flags());
}
@@ -69,7 +71,8 @@ namespace test_dat_cursor_factory
cppcut_assert_equal(grn::dat::UInt32(1), cursor->offset());
cppcut_assert_equal(grn::dat::UInt32(2), cursor->limit());
- cppcut_assert_equal(grn::dat::ID_RANGE_CURSOR | grn::dat::ASCENDING_CURSOR,
+ cppcut_assert_equal(grn::dat::ID_RANGE_CURSOR |
+ grn::dat::ASCENDING_CURSOR,
cursor->flags());
}
@@ -101,7 +104,8 @@ namespace test_dat_cursor_factory
cppcut_assert_equal(grn::dat::UInt32(1), cursor->offset());
cppcut_assert_equal(grn::dat::UInt32(2), cursor->limit());
- cppcut_assert_equal(grn::dat::PREDICTIVE_CURSOR | grn::dat::ASCENDING_CURSOR |
+ cppcut_assert_equal(grn::dat::PREDICTIVE_CURSOR |
+ grn::dat::ASCENDING_CURSOR |
grn::dat::EXCEPT_EXACT_MATCH,
cursor->flags());
}
Modified: test/unit/core/dat/test-dat-cursor.cpp (+291 -165)
===================================================================
--- test/unit/core/dat/test-dat-cursor.cpp 2012-02-01 10:57:14 +0900 (3a3675f)
+++ test/unit/core/dat/test-dat-cursor.cpp 2012-02-01 13:08:03 +0900 (c1b69b3)
@@ -1,6 +1,6 @@
/* -*- c-basic-offset: 2; coding: utf-8 -*- */
/*
- Copyright (C) 2011 Brazil
+ Copyright (C) 2011-2012 Brazil
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
@@ -35,7 +35,8 @@
namespace
{
- void create_key(std::string *key, std::size_t min_length, std::size_t max_length)
+ void create_key(std::string *key, std::size_t min_length,
+ std::size_t max_length)
{
key->resize(min_length + (std::rand() % (max_length - min_length + 1)));
for (std::size_t i = 0; i < key->size(); ++i) {
@@ -74,7 +75,8 @@ namespace test_dat_cursor
}
grn_dat *create_trie(const std::vector<std::string> &keys) {
- grn_dat * const dat = grn_dat_create(&ctx, NULL, 0, 0, GRN_OBJ_KEY_VAR_SIZE);
+ grn_dat * const dat = grn_dat_create(&ctx, NULL, 0, 0,
+ GRN_OBJ_KEY_VAR_SIZE);
cppcut_assert_not_null(dat);
for (std::size_t i = 0; i < keys.size(); ++i) {
const char * const ptr = keys[i].c_str();
@@ -89,19 +91,20 @@ namespace test_dat_cursor
{
grn_dat *dat = grn_dat_create(&ctx, NULL, 0, 0, 0);
cppcut_assert_not_null(dat);
- grn_dat_cursor *cursor =
- grn_dat_cursor_open(&ctx, dat, "ABC", 0, "XYZ", 0, 0, -1, GRN_CURSOR_BY_ID);
+ grn_dat_cursor *cursor = grn_dat_cursor_open(
+ &ctx, dat, "ABC", 0, "XYZ", 0, 0, -1, GRN_CURSOR_BY_ID);
cppcut_assert_not_null(cursor);
grn_dat_cursor_close(&ctx, cursor);
- cppcut_assert_equal(GRN_SUCCESS, grn_dat_close(&ctx, dat));
+ grn_test_assert_equal_rc(GRN_SUCCESS, grn_dat_close(&ctx, dat));
std::vector<std::string> keys;
create_keys(&keys, 100, 3, 5);
dat = create_trie(keys);
- cursor = grn_dat_cursor_open(&ctx, dat, "ABC", 0, "XYZ", 0, 0, -1, GRN_CURSOR_BY_KEY);
+ cursor = grn_dat_cursor_open(
+ &ctx, dat, "ABC", 0, "XYZ", 0, 0, -1, GRN_CURSOR_BY_KEY);
cppcut_assert_not_null(cursor);
grn_dat_cursor_close(&ctx, cursor);
- cppcut_assert_equal(GRN_SUCCESS, grn_dat_close(&ctx, dat));
+ grn_test_assert_equal_rc(GRN_SUCCESS, grn_dat_close(&ctx, dat));
}
void test_cursor_next(void)
@@ -110,16 +113,18 @@ namespace test_dat_cursor
create_keys(&keys, 1000, 3, 5);
grn_dat * const dat = create_trie(keys);
- grn_dat_cursor * const cursor =
- grn_dat_cursor_open(&ctx, dat, NULL, 0, NULL, 0, 0, -1, GRN_CURSOR_BY_ID);
+ grn_dat_cursor * const cursor = grn_dat_cursor_open(
+ &ctx, dat, NULL, 0, NULL, 0, 0, -1, GRN_CURSOR_BY_ID);
cppcut_assert_not_null(cursor);
for (std::size_t i = 1; i <= keys.size(); ++i) {
- cppcut_assert_equal(static_cast<grn_id>(i), grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(i),
+ grn_dat_cursor_next(&ctx, cursor));
}
- cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL), grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL),
+ grn_dat_cursor_next(&ctx, cursor));
grn_dat_cursor_close(&ctx, cursor);
- cppcut_assert_equal(GRN_SUCCESS, grn_dat_close(&ctx, dat));
+ grn_test_assert_equal_rc(GRN_SUCCESS, grn_dat_close(&ctx, dat));
}
void test_cursor_get_key(void)
@@ -128,23 +133,25 @@ namespace test_dat_cursor
create_keys(&keys, 1000, 3, 5);
grn_dat * const dat = create_trie(keys);
- grn_dat_cursor * const cursor =
- grn_dat_cursor_open(&ctx, dat, NULL, 0, NULL, 0, 0, -1, GRN_CURSOR_BY_ID);
+ grn_dat_cursor * const cursor = grn_dat_cursor_open(
+ &ctx, dat, NULL, 0, NULL, 0, 0, -1, GRN_CURSOR_BY_ID);
cppcut_assert_not_null(cursor);
for (std::size_t i = 0; i < keys.size(); ++i) {
const grn_id key_id = static_cast<grn_id>(i + 1);
const int length = static_cast<int>(keys[i].length());
cppcut_assert_equal(key_id, grn_dat_cursor_next(&ctx, cursor));
const void *key_ptr;
- cppcut_assert_equal(length, grn_dat_cursor_get_key(&ctx, cursor, &key_ptr));
+ cppcut_assert_equal(length,
+ grn_dat_cursor_get_key(&ctx, cursor, &key_ptr));
uint32_t key_length;
cppcut_assert_equal(_grn_dat_key(&ctx, dat, key_id, &key_length),
static_cast<const char *>(key_ptr));
}
- cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL), grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL),
+ grn_dat_cursor_next(&ctx, cursor));
grn_dat_cursor_close(&ctx, cursor);
- cppcut_assert_equal(GRN_SUCCESS, grn_dat_close(&ctx, dat));
+ grn_test_assert_equal_rc(GRN_SUCCESS, grn_dat_close(&ctx, dat));
}
void test_cursor_delete(void)
@@ -153,27 +160,33 @@ namespace test_dat_cursor
create_keys(&keys, 1000, 3, 5);
grn_dat * const dat = create_trie(keys);
- grn_dat_cursor *cursor =
- grn_dat_cursor_open(&ctx, dat, NULL, 0, NULL, 0, 0, -1, GRN_CURSOR_BY_ID);
+ grn_dat_cursor *cursor = grn_dat_cursor_open(
+ &ctx, dat, NULL, 0, NULL, 0, 0, -1, GRN_CURSOR_BY_ID);
cppcut_assert_not_null(cursor);
for (std::size_t i = 1; i <= keys.size(); ++i) {
- cppcut_assert_equal(static_cast<grn_id>(i), grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(i),
+ grn_dat_cursor_next(&ctx, cursor));
if (i & 1) {
- cppcut_assert_equal(GRN_SUCCESS, grn_dat_cursor_delete(&ctx, cursor, NULL));
+ grn_test_assert_equal_rc(GRN_SUCCESS,
+ grn_dat_cursor_delete(&ctx, cursor, NULL));
}
}
- cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL), grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL),
+ grn_dat_cursor_next(&ctx, cursor));
grn_dat_cursor_close(&ctx, cursor);
- cursor = grn_dat_cursor_open(&ctx, dat, NULL, 0, NULL, 0, 0, -1, GRN_CURSOR_BY_ID);
+ cursor = grn_dat_cursor_open(&ctx, dat, NULL, 0, NULL, 0, 0, -1,
+ GRN_CURSOR_BY_ID);
cppcut_assert_not_null(cursor);
for (std::size_t i = 1; i <= (keys.size() / 2); ++i) {
- cppcut_assert_equal(static_cast<grn_id>(i * 2), grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(i * 2),
+ grn_dat_cursor_next(&ctx, cursor));
}
- cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL), grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL),
+ grn_dat_cursor_next(&ctx, cursor));
grn_dat_cursor_close(&ctx, cursor);
- cppcut_assert_equal(GRN_SUCCESS, grn_dat_close(&ctx, dat));
+ grn_test_assert_equal_rc(GRN_SUCCESS, grn_dat_close(&ctx, dat));
}
void test_cursor_by_id(void)
@@ -188,70 +201,94 @@ namespace test_dat_cursor
grn_dat_cursor *cursor = grn_dat_cursor_open(&ctx, dat, NULL, 0, NULL, 0,
0, -1, GRN_CURSOR_BY_ID);
cppcut_assert_not_null(cursor);
- cppcut_assert_equal(static_cast<grn_id>(1), grn_dat_cursor_next(&ctx, cursor));
- cppcut_assert_equal(static_cast<grn_id>(2), grn_dat_cursor_next(&ctx, cursor));
- cppcut_assert_equal(static_cast<grn_id>(3), grn_dat_cursor_next(&ctx, cursor));
- cppcut_assert_equal(static_cast<grn_id>(4), grn_dat_cursor_next(&ctx, cursor));
- cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL), grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(1),
+ grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(2),
+ grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(3),
+ grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(4),
+ grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL),
+ grn_dat_cursor_next(&ctx, cursor));
grn_dat_cursor_close(&ctx, cursor);
cursor = grn_dat_cursor_open(&ctx, dat, keys[2].c_str(), keys[2].length(),
NULL, 0, 0, -1, GRN_CURSOR_BY_ID);
cppcut_assert_not_null(cursor);
- cppcut_assert_equal(static_cast<grn_id>(3), grn_dat_cursor_next(&ctx, cursor));
- cppcut_assert_equal(static_cast<grn_id>(4), grn_dat_cursor_next(&ctx, cursor));
- cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL), grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(3),
+ grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(4),
+ grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL),
+ grn_dat_cursor_next(&ctx, cursor));
grn_dat_cursor_close(&ctx, cursor);
- cursor = grn_dat_cursor_open(&ctx, dat, NULL, 0, keys[1].c_str(), keys[1].length(),
- 0, -1, GRN_CURSOR_BY_ID);
+ cursor = grn_dat_cursor_open(&ctx, dat, NULL, 0, keys[1].c_str(),
+ keys[1].length(), 0, -1, GRN_CURSOR_BY_ID);
cppcut_assert_not_null(cursor);
- cppcut_assert_equal(static_cast<grn_id>(1), grn_dat_cursor_next(&ctx, cursor));
- cppcut_assert_equal(static_cast<grn_id>(2), grn_dat_cursor_next(&ctx, cursor));
- cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL), grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(1),
+ grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(2),
+ grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL),
+ grn_dat_cursor_next(&ctx, cursor));
grn_dat_cursor_close(&ctx, cursor);
cursor = grn_dat_cursor_open(&ctx, dat, NULL, 0, NULL, 0,
1, 2, GRN_CURSOR_BY_ID);
cppcut_assert_not_null(cursor);
- cppcut_assert_equal(static_cast<grn_id>(2), grn_dat_cursor_next(&ctx, cursor));
- cppcut_assert_equal(static_cast<grn_id>(3), grn_dat_cursor_next(&ctx, cursor));
- cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL), grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(2),
+ grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(3),
+ grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL),
+ grn_dat_cursor_next(&ctx, cursor));
grn_dat_cursor_close(&ctx, cursor);
- cursor = grn_dat_cursor_open(&ctx, dat, NULL, 0, NULL, 0,
- 1, 2, GRN_CURSOR_BY_ID | GRN_CURSOR_ASCENDING);
+ cursor = grn_dat_cursor_open(&ctx, dat, NULL, 0, NULL, 0, 1, 2,
+ GRN_CURSOR_BY_ID | GRN_CURSOR_ASCENDING);
cppcut_assert_not_null(cursor);
- cppcut_assert_equal(static_cast<grn_id>(2), grn_dat_cursor_next(&ctx, cursor));
- cppcut_assert_equal(static_cast<grn_id>(3), grn_dat_cursor_next(&ctx, cursor));
- cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL), grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(2),
+ grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(3),
+ grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL),
+ grn_dat_cursor_next(&ctx, cursor));
grn_dat_cursor_close(&ctx, cursor);
- cursor = grn_dat_cursor_open(&ctx, dat, NULL, 0, NULL, 0,
- 1, 2, GRN_CURSOR_BY_ID | GRN_CURSOR_DESCENDING);
+ cursor = grn_dat_cursor_open(&ctx, dat, NULL, 0, NULL, 0, 1, 2,
+ GRN_CURSOR_BY_ID | GRN_CURSOR_DESCENDING);
cppcut_assert_not_null(cursor);
- cppcut_assert_equal(static_cast<grn_id>(3), grn_dat_cursor_next(&ctx, cursor));
- cppcut_assert_equal(static_cast<grn_id>(2), grn_dat_cursor_next(&ctx, cursor));
- cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL), grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(3),
+ grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(2),
+ grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL),
+ grn_dat_cursor_next(&ctx, cursor));
grn_dat_cursor_close(&ctx, cursor);
cursor = grn_dat_cursor_open(&ctx, dat, keys[1].c_str(), keys[1].length(),
keys[2].c_str(), keys[2].length(),
0, -1, GRN_CURSOR_BY_ID | GRN_CURSOR_LT);
cppcut_assert_not_null(cursor);
- cppcut_assert_equal(static_cast<grn_id>(2), grn_dat_cursor_next(&ctx, cursor));
- cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL), grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(2),
+ grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL),
+ grn_dat_cursor_next(&ctx, cursor));
grn_dat_cursor_close(&ctx, cursor);
cursor = grn_dat_cursor_open(&ctx, dat, keys[1].c_str(), keys[1].length(),
keys[2].c_str(), keys[2].length(),
0, -1, GRN_CURSOR_BY_ID | GRN_CURSOR_GT);
cppcut_assert_not_null(cursor);
- cppcut_assert_equal(static_cast<grn_id>(3), grn_dat_cursor_next(&ctx, cursor));
- cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL), grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(3),
+ grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL),
+ grn_dat_cursor_next(&ctx, cursor));
grn_dat_cursor_close(&ctx, cursor);
- cppcut_assert_equal(GRN_SUCCESS, grn_dat_close(&ctx, dat));
+ grn_test_assert_equal_rc(GRN_SUCCESS, grn_dat_close(&ctx, dat));
}
void test_cursor_by_key(void)
@@ -266,70 +303,94 @@ namespace test_dat_cursor
grn_dat_cursor *cursor = grn_dat_cursor_open(&ctx, dat, NULL, 0, NULL, 0,
0, -1, GRN_CURSOR_BY_KEY);
cppcut_assert_not_null(cursor);
- cppcut_assert_equal(static_cast<grn_id>(4), grn_dat_cursor_next(&ctx, cursor));
- cppcut_assert_equal(static_cast<grn_id>(2), grn_dat_cursor_next(&ctx, cursor));
- cppcut_assert_equal(static_cast<grn_id>(1), grn_dat_cursor_next(&ctx, cursor));
- cppcut_assert_equal(static_cast<grn_id>(3), grn_dat_cursor_next(&ctx, cursor));
- cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL), grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(4),
+ grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(2),
+ grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(1),
+ grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(3),
+ grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL),
+ grn_dat_cursor_next(&ctx, cursor));
grn_dat_cursor_close(&ctx, cursor);
cursor = grn_dat_cursor_open(&ctx, dat, keys[0].c_str(), keys[0].length(),
NULL, 0, 0, -1, GRN_CURSOR_BY_KEY);
cppcut_assert_not_null(cursor);
- cppcut_assert_equal(static_cast<grn_id>(1), grn_dat_cursor_next(&ctx, cursor));
- cppcut_assert_equal(static_cast<grn_id>(3), grn_dat_cursor_next(&ctx, cursor));
- cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL), grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(1),
+ grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(3),
+ grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL),
+ grn_dat_cursor_next(&ctx, cursor));
grn_dat_cursor_close(&ctx, cursor);
- cursor = grn_dat_cursor_open(&ctx, dat, NULL, 0, keys[1].c_str(), keys[1].length(),
- 0, -1, GRN_CURSOR_BY_KEY);
+ cursor = grn_dat_cursor_open(&ctx, dat, NULL, 0, keys[1].c_str(),
+ keys[1].length(), 0, -1, GRN_CURSOR_BY_KEY);
cppcut_assert_not_null(cursor);
- cppcut_assert_equal(static_cast<grn_id>(4), grn_dat_cursor_next(&ctx, cursor));
- cppcut_assert_equal(static_cast<grn_id>(2), grn_dat_cursor_next(&ctx, cursor));
- cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL), grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(4),
+ grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(2),
+ grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL),
+ grn_dat_cursor_next(&ctx, cursor));
grn_dat_cursor_close(&ctx, cursor);
cursor = grn_dat_cursor_open(&ctx, dat, NULL, 0, NULL, 0,
1, 2, GRN_CURSOR_BY_KEY);
cppcut_assert_not_null(cursor);
- cppcut_assert_equal(static_cast<grn_id>(2), grn_dat_cursor_next(&ctx, cursor));
- cppcut_assert_equal(static_cast<grn_id>(1), grn_dat_cursor_next(&ctx, cursor));
- cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL), grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(2),
+ grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(1),
+ grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL),
+ grn_dat_cursor_next(&ctx, cursor));
grn_dat_cursor_close(&ctx, cursor);
- cursor = grn_dat_cursor_open(&ctx, dat, NULL, 0, NULL, 0,
- 1, 2, GRN_CURSOR_BY_KEY | GRN_CURSOR_ASCENDING);
+ cursor = grn_dat_cursor_open(&ctx, dat, NULL, 0, NULL, 0, 1, 2,
+ GRN_CURSOR_BY_KEY | GRN_CURSOR_ASCENDING);
cppcut_assert_not_null(cursor);
- cppcut_assert_equal(static_cast<grn_id>(2), grn_dat_cursor_next(&ctx, cursor));
- cppcut_assert_equal(static_cast<grn_id>(1), grn_dat_cursor_next(&ctx, cursor));
- cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL), grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(2),
+ grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(1),
+ grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL),
+ grn_dat_cursor_next(&ctx, cursor));
grn_dat_cursor_close(&ctx, cursor);
- cursor = grn_dat_cursor_open(&ctx, dat, NULL, 0, NULL, 0,
- 1, 2, GRN_CURSOR_BY_KEY | GRN_CURSOR_DESCENDING);
+ cursor = grn_dat_cursor_open(&ctx, dat, NULL, 0, NULL, 0, 1, 2,
+ GRN_CURSOR_BY_KEY | GRN_CURSOR_DESCENDING);
cppcut_assert_not_null(cursor);
- cppcut_assert_equal(static_cast<grn_id>(1), grn_dat_cursor_next(&ctx, cursor));
- cppcut_assert_equal(static_cast<grn_id>(2), grn_dat_cursor_next(&ctx, cursor));
- cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL), grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(1),
+ grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(2),
+ grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL),
+ grn_dat_cursor_next(&ctx, cursor));
grn_dat_cursor_close(&ctx, cursor);
cursor = grn_dat_cursor_open(&ctx, dat, keys[1].c_str(), keys[1].length(),
keys[0].c_str(), keys[0].length(),
0, -1, GRN_CURSOR_BY_KEY | GRN_CURSOR_LT);
cppcut_assert_not_null(cursor);
- cppcut_assert_equal(static_cast<grn_id>(2), grn_dat_cursor_next(&ctx, cursor));
- cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL), grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(2),
+ grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL),
+ grn_dat_cursor_next(&ctx, cursor));
grn_dat_cursor_close(&ctx, cursor);
cursor = grn_dat_cursor_open(&ctx, dat, keys[1].c_str(), keys[1].length(),
keys[0].c_str(), keys[0].length(),
0, -1, GRN_CURSOR_BY_KEY | GRN_CURSOR_GT);
cppcut_assert_not_null(cursor);
- cppcut_assert_equal(static_cast<grn_id>(1), grn_dat_cursor_next(&ctx, cursor));
- cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL), grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(1),
+ grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL),
+ grn_dat_cursor_next(&ctx, cursor));
grn_dat_cursor_close(&ctx, cursor);
- cppcut_assert_equal(GRN_SUCCESS, grn_dat_close(&ctx, dat));
+ grn_test_assert_equal_rc(GRN_SUCCESS, grn_dat_close(&ctx, dat));
}
void test_cursor_prefix_without_max(void)
@@ -345,63 +406,88 @@ namespace test_dat_cursor
0, -1, GRN_CURSOR_PREFIX);
cut_assert_null(cursor);
- cursor = grn_dat_cursor_open(&ctx, dat, "", 0, NULL, 0, 0, -1, GRN_CURSOR_PREFIX);
+ cursor = grn_dat_cursor_open(&ctx, dat, "", 0, NULL, 0, 0, -1,
+ GRN_CURSOR_PREFIX);
cut_assert_null(cursor);
- cursor = grn_dat_cursor_open(&ctx, dat, "m", 1, NULL, 0, 0, -1, GRN_CURSOR_PREFIX);
+ cursor = grn_dat_cursor_open(&ctx, dat, "m", 1, NULL, 0, 0, -1,
+ GRN_CURSOR_PREFIX);
cppcut_assert_not_null(cursor);
- cppcut_assert_equal(static_cast<grn_id>(4), grn_dat_cursor_next(&ctx, cursor));
- cppcut_assert_equal(static_cast<grn_id>(2), grn_dat_cursor_next(&ctx, cursor));
- cppcut_assert_equal(static_cast<grn_id>(1), grn_dat_cursor_next(&ctx, cursor));
- cppcut_assert_equal(static_cast<grn_id>(3), grn_dat_cursor_next(&ctx, cursor));
- cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL), grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(4),
+ grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(2),
+ grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(1),
+ grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(3),
+ grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL),
+ grn_dat_cursor_next(&ctx, cursor));
grn_dat_cursor_close(&ctx, cursor);
- cursor = grn_dat_cursor_open(&ctx, dat, "min", 3, NULL, 0, 0, -1, GRN_CURSOR_PREFIX);
+ cursor = grn_dat_cursor_open(&ctx, dat, "min", 3, NULL, 0, 0, -1,
+ GRN_CURSOR_PREFIX);
cppcut_assert_not_null(cursor);
- cppcut_assert_equal(static_cast<grn_id>(2), grn_dat_cursor_next(&ctx, cursor));
- cppcut_assert_equal(static_cast<grn_id>(1), grn_dat_cursor_next(&ctx, cursor));
- cppcut_assert_equal(static_cast<grn_id>(3), grn_dat_cursor_next(&ctx, cursor));
- cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL), grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(2),
+ grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(1),
+ grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(3),
+ grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL),
+ grn_dat_cursor_next(&ctx, cursor));
grn_dat_cursor_close(&ctx, cursor);
- cursor = grn_dat_cursor_open(&ctx, dat, "m", 1, NULL, 0, 1, 2, GRN_CURSOR_PREFIX);
+ cursor = grn_dat_cursor_open(&ctx, dat, "m", 1, NULL, 0, 1, 2,
+ GRN_CURSOR_PREFIX);
cppcut_assert_not_null(cursor);
- cppcut_assert_equal(static_cast<grn_id>(2), grn_dat_cursor_next(&ctx, cursor));
- cppcut_assert_equal(static_cast<grn_id>(1), grn_dat_cursor_next(&ctx, cursor));
- cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL), grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(2),
+ grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(1),
+ grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL),
+ grn_dat_cursor_next(&ctx, cursor));
grn_dat_cursor_close(&ctx, cursor);
- cursor = grn_dat_cursor_open(&ctx, dat, "m", 1, NULL, 0,
- 1, 2, GRN_CURSOR_PREFIX | GRN_CURSOR_ASCENDING);
+ cursor = grn_dat_cursor_open(&ctx, dat, "m", 1, NULL, 0, 1, 2,
+ GRN_CURSOR_PREFIX | GRN_CURSOR_ASCENDING);
cppcut_assert_not_null(cursor);
- cppcut_assert_equal(static_cast<grn_id>(2), grn_dat_cursor_next(&ctx, cursor));
- cppcut_assert_equal(static_cast<grn_id>(1), grn_dat_cursor_next(&ctx, cursor));
- cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL), grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(2),
+ grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(1),
+ grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL),
+ grn_dat_cursor_next(&ctx, cursor));
grn_dat_cursor_close(&ctx, cursor);
- cursor = grn_dat_cursor_open(&ctx, dat, "m", 1, NULL, 0,
- 1, 2, GRN_CURSOR_PREFIX | GRN_CURSOR_DESCENDING);
+ cursor = grn_dat_cursor_open(&ctx, dat, "m", 1, NULL, 0, 1, 2,
+ GRN_CURSOR_PREFIX | GRN_CURSOR_DESCENDING);
cppcut_assert_not_null(cursor);
- cppcut_assert_equal(static_cast<grn_id>(1), grn_dat_cursor_next(&ctx, cursor));
- cppcut_assert_equal(static_cast<grn_id>(2), grn_dat_cursor_next(&ctx, cursor));
- cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL), grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(1),
+ grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(2),
+ grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL),
+ grn_dat_cursor_next(&ctx, cursor));
grn_dat_cursor_close(&ctx, cursor);
cursor = grn_dat_cursor_open(&ctx, dat, "mind", 4, NULL, 0,
0, -1, GRN_CURSOR_PREFIX | GRN_CURSOR_LT);
cppcut_assert_not_null(cursor);
- cppcut_assert_equal(static_cast<grn_id>(2), grn_dat_cursor_next(&ctx, cursor));
- cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL), grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(2),
+ grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL),
+ grn_dat_cursor_next(&ctx, cursor));
grn_dat_cursor_close(&ctx, cursor);
cursor = grn_dat_cursor_open(&ctx, dat, "mind", 4, NULL, 0,
0, -1, GRN_CURSOR_PREFIX | GRN_CURSOR_GT);
cppcut_assert_not_null(cursor);
- cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL), grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL),
+ grn_dat_cursor_next(&ctx, cursor));
grn_dat_cursor_close(&ctx, cursor);
- cppcut_assert_equal(GRN_SUCCESS, grn_dat_close(&ctx, dat));
+ grn_test_assert_equal_rc(GRN_SUCCESS, grn_dat_close(&ctx, dat));
}
void test_cursor_prefix_with_max(void)
@@ -417,86 +503,126 @@ namespace test_dat_cursor
0, -1, GRN_CURSOR_PREFIX);
cut_assert_null(cursor);
- cursor = grn_dat_cursor_open(&ctx, dat, NULL, 0, "", 0, 0, -1, GRN_CURSOR_PREFIX);
-
+ cursor = grn_dat_cursor_open(&ctx, dat, NULL, 0, "", 0, 0, -1,
+ GRN_CURSOR_PREFIX);
+ cut_assert_null(cursor);
- cursor = grn_dat_cursor_open(&ctx, dat, NULL, 0, "note", 4, 0, -1, GRN_CURSOR_PREFIX);
+ cursor = grn_dat_cursor_open(&ctx, dat, NULL, 0, "note", 4, 0, -1,
+ GRN_CURSOR_PREFIX);
cppcut_assert_not_null(cursor);
- cppcut_assert_equal(static_cast<grn_id>(3), grn_dat_cursor_next(&ctx, cursor));
- cppcut_assert_equal(static_cast<grn_id>(1), grn_dat_cursor_next(&ctx, cursor));
- cppcut_assert_equal(static_cast<grn_id>(2), grn_dat_cursor_next(&ctx, cursor));
- cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL), grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(3),
+ grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(1),
+ grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(2),
+ grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL),
+ grn_dat_cursor_next(&ctx, cursor));
grn_dat_cursor_close(&ctx, cursor);
- cursor = grn_dat_cursor_open(&ctx, dat, NULL, 0, "not", 3, 0, -1, GRN_CURSOR_PREFIX);
+ cursor = grn_dat_cursor_open(&ctx, dat, NULL, 0, "not", 3, 0, -1,
+ GRN_CURSOR_PREFIX);
cppcut_assert_not_null(cursor);
- cppcut_assert_equal(static_cast<grn_id>(1), grn_dat_cursor_next(&ctx, cursor));
- cppcut_assert_equal(static_cast<grn_id>(2), grn_dat_cursor_next(&ctx, cursor));
- cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL), grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(1),
+ grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(2),
+ grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL),
+ grn_dat_cursor_next(&ctx, cursor));
grn_dat_cursor_close(&ctx, cursor);
- cursor = grn_dat_cursor_open(&ctx, dat, NULL, 3, "note", 4, 0, -1, GRN_CURSOR_PREFIX);
+ cursor = grn_dat_cursor_open(&ctx, dat, NULL, 3, "note", 4, 0, -1,
+ GRN_CURSOR_PREFIX);
cppcut_assert_not_null(cursor);
- cppcut_assert_equal(static_cast<grn_id>(3), grn_dat_cursor_next(&ctx, cursor));
- cppcut_assert_equal(static_cast<grn_id>(1), grn_dat_cursor_next(&ctx, cursor));
- cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL), grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(3),
+ grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(1),
+ grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL),
+ grn_dat_cursor_next(&ctx, cursor));
grn_dat_cursor_close(&ctx, cursor);
- cursor = grn_dat_cursor_open(&ctx, dat, "XYZ", 3, "note", 4, 0, -1, GRN_CURSOR_PREFIX);
+ cursor = grn_dat_cursor_open(&ctx, dat, "XYZ", 3, "note", 4, 0, -1,
+ GRN_CURSOR_PREFIX);
cppcut_assert_not_null(cursor);
- cppcut_assert_equal(static_cast<grn_id>(3), grn_dat_cursor_next(&ctx, cursor));
- cppcut_assert_equal(static_cast<grn_id>(1), grn_dat_cursor_next(&ctx, cursor));
- cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL), grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(3),
+ grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(1),
+ grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL),
+ grn_dat_cursor_next(&ctx, cursor));
grn_dat_cursor_close(&ctx, cursor);
- cursor = grn_dat_cursor_open(&ctx, dat, NULL, 0, "note", 4, 1, -1, GRN_CURSOR_PREFIX);
+ cursor = grn_dat_cursor_open(&ctx, dat, NULL, 0, "note", 4, 1, -1,
+ GRN_CURSOR_PREFIX);
cppcut_assert_not_null(cursor);
- cppcut_assert_equal(static_cast<grn_id>(1), grn_dat_cursor_next(&ctx, cursor));
- cppcut_assert_equal(static_cast<grn_id>(2), grn_dat_cursor_next(&ctx, cursor));
- cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL), grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(1),
+ grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(2),
+ grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL),
+ grn_dat_cursor_next(&ctx, cursor));
grn_dat_cursor_close(&ctx, cursor);
- cursor = grn_dat_cursor_open(&ctx, dat, NULL, 0, "note", 4, 0, 2, GRN_CURSOR_PREFIX);
+ cursor = grn_dat_cursor_open(&ctx, dat, NULL, 0, "note", 4, 0, 2,
+ GRN_CURSOR_PREFIX);
cppcut_assert_not_null(cursor);
- cppcut_assert_equal(static_cast<grn_id>(3), grn_dat_cursor_next(&ctx, cursor));
- cppcut_assert_equal(static_cast<grn_id>(1), grn_dat_cursor_next(&ctx, cursor));
- cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL), grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(3),
+ grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(1),
+ grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL),
+ grn_dat_cursor_next(&ctx, cursor));
grn_dat_cursor_close(&ctx, cursor);
- cursor = grn_dat_cursor_open(&ctx, dat, NULL, 0, "note", 4,
- 0, 2, GRN_CURSOR_PREFIX | GRN_CURSOR_ASCENDING);
+ cursor = grn_dat_cursor_open(&ctx, dat, NULL, 0, "note", 4, 0, 2,
+ GRN_CURSOR_PREFIX | GRN_CURSOR_ASCENDING);
cppcut_assert_not_null(cursor);
- cppcut_assert_equal(static_cast<grn_id>(3), grn_dat_cursor_next(&ctx, cursor));
- cppcut_assert_equal(static_cast<grn_id>(1), grn_dat_cursor_next(&ctx, cursor));
- cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL), grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(3),
+ grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(1),
+ grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL),
+ grn_dat_cursor_next(&ctx, cursor));
grn_dat_cursor_close(&ctx, cursor);
- cursor = grn_dat_cursor_open(&ctx, dat, NULL, 0, "note", 4,
- 0, 2, GRN_CURSOR_PREFIX | GRN_CURSOR_DESCENDING);
+ cursor = grn_dat_cursor_open(&ctx, dat, NULL, 0, "note", 4, 0, 2,
+ GRN_CURSOR_PREFIX | GRN_CURSOR_DESCENDING);
cppcut_assert_not_null(cursor);
- cppcut_assert_equal(static_cast<grn_id>(3), grn_dat_cursor_next(&ctx, cursor));
- cppcut_assert_equal(static_cast<grn_id>(1), grn_dat_cursor_next(&ctx, cursor));
- cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL), grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(3),
+ grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(1),
+ grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL),
+ grn_dat_cursor_next(&ctx, cursor));
grn_dat_cursor_close(&ctx, cursor);
cursor = grn_dat_cursor_open(&ctx, dat, NULL, 2, "note", 4,
0, -1, GRN_CURSOR_PREFIX | GRN_CURSOR_LT);
cppcut_assert_not_null(cursor);
- cppcut_assert_equal(static_cast<grn_id>(3), grn_dat_cursor_next(&ctx, cursor));
- cppcut_assert_equal(static_cast<grn_id>(1), grn_dat_cursor_next(&ctx, cursor));
- cppcut_assert_equal(static_cast<grn_id>(2), grn_dat_cursor_next(&ctx, cursor));
- cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL), grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(3),
+ grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(1),
+ grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(2),
+ grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL),
+ grn_dat_cursor_next(&ctx, cursor));
grn_dat_cursor_close(&ctx, cursor);
cursor = grn_dat_cursor_open(&ctx, dat, NULL, 2, "note", 4,
0, -1, GRN_CURSOR_PREFIX | GRN_CURSOR_GT);
cppcut_assert_not_null(cursor);
- cppcut_assert_equal(static_cast<grn_id>(3), grn_dat_cursor_next(&ctx, cursor));
- cppcut_assert_equal(static_cast<grn_id>(1), grn_dat_cursor_next(&ctx, cursor));
- cppcut_assert_equal(static_cast<grn_id>(2), grn_dat_cursor_next(&ctx, cursor));
- cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL), grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(3),
+ grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(1),
+ grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(2),
+ grn_dat_cursor_next(&ctx, cursor));
+ cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL),
+ grn_dat_cursor_next(&ctx, cursor));
grn_dat_cursor_close(&ctx, cursor);
- cppcut_assert_equal(GRN_SUCCESS, grn_dat_close(&ctx, dat));
+ grn_test_assert_equal_rc(GRN_SUCCESS, grn_dat_close(&ctx, dat));
}
}
Modified: test/unit/core/dat/test-dat-pat.cpp (+164 -87)
===================================================================
--- test/unit/core/dat/test-dat-pat.cpp 2012-02-01 10:57:14 +0900 (b663d02)
+++ test/unit/core/dat/test-dat-pat.cpp 2012-02-01 13:08:03 +0900 (44d84cd)
@@ -36,7 +36,8 @@
namespace
{
- void create_key(std::string *key, std::size_t min_length, std::size_t max_length)
+ void create_key(std::string *key, std::size_t min_length,
+ std::size_t max_length)
{
key->resize(min_length + (std::rand() % (max_length - min_length + 1)));
for (std::size_t i = 0; i < key->size(); ++i) {
@@ -93,12 +94,13 @@ namespace test_dat_pat
std::sprintf(path, "%s/%s.dat", base_dir, filename);
}
- grn_pat *create_pat(const char *filename, const std::vector<std::string> &keys)
+ grn_pat *create_pat(const char *filename,
+ const std::vector<std::string> &keys)
{
char pat_path[PATH_MAX];
generate_pat_path(filename, pat_path);
- grn_pat * const pat = grn_pat_create(&ctx, pat_path,
- 1024, 0, GRN_OBJ_KEY_VAR_SIZE);
+ grn_pat * const pat =
+ grn_pat_create(&ctx, pat_path, 1024, 0, GRN_OBJ_KEY_VAR_SIZE);
cppcut_assert_not_null(pat);
for (std::size_t i = 0; i < keys.size(); ++i) {
@@ -107,12 +109,13 @@ namespace test_dat_pat
return pat;
}
- grn_dat *create_dat(const char *filename, const std::vector<std::string> &keys)
+ grn_dat *create_dat(const char *filename,
+ const std::vector<std::string> &keys)
{
char dat_path[PATH_MAX];
generate_dat_path(filename, dat_path);
- grn_dat * const dat = grn_dat_create(&ctx, dat_path,
- 1024, 0, GRN_OBJ_KEY_VAR_SIZE);
+ grn_dat * const dat =
+ grn_dat_create(&ctx, dat_path, 1024, 0, GRN_OBJ_KEY_VAR_SIZE);
cppcut_assert_not_null(dat);
for (std::size_t i = 0; i < keys.size(); ++i) {
@@ -145,8 +148,8 @@ namespace test_dat_pat
pat = create_pat(filename, keys);
dat = create_dat(filename, keys);
- cppcut_assert_equal(GRN_SUCCESS, grn_pat_close(&ctx, pat));
- cppcut_assert_equal(GRN_SUCCESS, grn_dat_close(&ctx, dat));
+ grn_test_assert_equal_rc(GRN_SUCCESS, grn_pat_close(&ctx, pat));
+ grn_test_assert_equal_rc(GRN_SUCCESS, grn_dat_close(&ctx, dat));
cut_assert_exist_path(pat_path);
cut_assert_exist_path(dat_path);
@@ -157,8 +160,8 @@ namespace test_dat_pat
cppcut_assert_not_null(pat);
cppcut_assert_not_null(dat);
- cppcut_assert_equal(GRN_SUCCESS, grn_pat_close(&ctx, pat));
- cppcut_assert_equal(GRN_SUCCESS, grn_dat_close(&ctx, dat));
+ grn_test_assert_equal_rc(GRN_SUCCESS, grn_pat_close(&ctx, pat));
+ grn_test_assert_equal_rc(GRN_SUCCESS, grn_dat_close(&ctx, dat));
}
void test_remove(void)
@@ -169,8 +172,8 @@ namespace test_dat_pat
grn_pat * const pat = create_pat(filename, keys);
grn_dat * const dat = create_dat(filename, keys);
- cppcut_assert_equal(GRN_SUCCESS, grn_pat_close(&ctx, pat));
- cppcut_assert_equal(GRN_SUCCESS, grn_dat_close(&ctx, dat));
+ grn_test_assert_equal_rc(GRN_SUCCESS, grn_pat_close(&ctx, pat));
+ grn_test_assert_equal_rc(GRN_SUCCESS, grn_dat_close(&ctx, dat));
char pat_path[PATH_MAX];
char dat_path[PATH_MAX];
@@ -204,20 +207,24 @@ namespace test_dat_pat
for (int i = 0; i < 1000; ++i) {
create_key(&key, 3, 5);
- const grn_id pat_id = grn_pat_get(&ctx, pat, key.c_str(), key.length(), NULL);
- const grn_id dat_id = grn_dat_get(&ctx, dat, key.c_str(), key.length(), NULL);
+ const grn_id pat_id =
+ grn_pat_get(&ctx, pat, key.c_str(), key.length(), NULL);
+ const grn_id dat_id =
+ grn_dat_get(&ctx, dat, key.c_str(), key.length(), NULL);
cppcut_assert_equal(pat_id, dat_id);
if (pat_id != GRN_ID_NIL) {
char pat_key[1024];
- int pat_length = grn_pat_get_key(&ctx, pat, pat_id, pat_key, sizeof(pat_key));
+ const int pat_length =
+ grn_pat_get_key(&ctx, pat, pat_id, pat_key, sizeof(pat_key));
char dat_key[1024];
- int dat_length = grn_dat_get_key(&ctx, dat, dat_id, dat_key, sizeof(dat_key));
+ const int dat_length =
+ grn_dat_get_key(&ctx, dat, dat_id, dat_key, sizeof(dat_key));
cut_assert_equal_memory(pat_key, pat_length, dat_key, dat_length);
}
}
- cppcut_assert_equal(GRN_SUCCESS, grn_pat_close(&ctx, pat));
- cppcut_assert_equal(GRN_SUCCESS, grn_dat_close(&ctx, dat));
+ grn_test_assert_equal_rc(GRN_SUCCESS, grn_pat_close(&ctx, pat));
+ grn_test_assert_equal_rc(GRN_SUCCESS, grn_dat_close(&ctx, dat));
}
void test_add(void)
@@ -233,108 +240,176 @@ namespace test_dat_pat
for (int i = 0; i < 1000; ++i) {
create_key(&key, 3, 5);
int pat_added = -1;
- const grn_id pat_id = grn_pat_add(&ctx, pat, key.c_str(),
- key.length(), NULL, &pat_added);
+ const grn_id pat_id =
+ grn_pat_add(&ctx, pat, key.c_str(), key.length(), NULL, &pat_added);
int dat_added = -2;
- const grn_id dat_id = grn_dat_add(&ctx, dat, key.c_str(),
- key.length(), NULL, &dat_added);
+ const grn_id dat_id =
+ grn_dat_add(&ctx, dat, key.c_str(), key.length(), NULL, &dat_added);
cppcut_assert_equal(pat_id, dat_id);
cppcut_assert_equal(pat_added, dat_added);
- cppcut_assert_equal(grn_pat_size(&ctx, pat), grn_dat_size(&ctx, dat));
- cppcut_assert_equal(grn_pat_curr_id(&ctx, pat), grn_dat_curr_id(&ctx, dat));
+ cppcut_assert_equal(grn_pat_size(&ctx, pat),
+ grn_dat_size(&ctx, dat));
+ cppcut_assert_equal(grn_pat_curr_id(&ctx, pat),
+ grn_dat_curr_id(&ctx, dat));
}
- cppcut_assert_equal(GRN_SUCCESS, grn_pat_close(&ctx, pat));
- cppcut_assert_equal(GRN_SUCCESS, grn_dat_close(&ctx, dat));
+ grn_test_assert_equal_rc(GRN_SUCCESS, grn_pat_close(&ctx, pat));
+ grn_test_assert_equal_rc(GRN_SUCCESS, grn_dat_close(&ctx, dat));
}
void test_delete_by_id(void)
{
const char * const filename = "test_delete_by_id";
- cppcut_assert_equal(GRN_INVALID_ARGUMENT,
- grn_pat_delete_by_id(&ctx, NULL, 1, NULL));
-// cppcut_assert_equal(GRN_INVALID_ARGUMENT,
-// grn_dat_delete_by_id(&ctx, NULL, 1, NULL));
+ grn_test_assert_equal_rc(GRN_INVALID_ARGUMENT,
+ grn_pat_delete_by_id(&ctx, NULL, 1, NULL));
+ grn_test_assert_equal_rc(GRN_INVALID_ARGUMENT,
+ grn_dat_delete_by_id(&ctx, NULL, 1, NULL));
std::vector<std::string> keys;
create_keys(&keys, 1000, 3, 5);
grn_pat * const pat = create_pat(filename, keys);
grn_dat * const dat = create_dat(filename, keys);
- cppcut_assert_equal(GRN_INVALID_ARGUMENT,
- grn_pat_delete_by_id(&ctx, pat, GRN_ID_NIL, NULL));
- cppcut_assert_equal(GRN_INVALID_ARGUMENT,
- grn_dat_delete_by_id(&ctx, dat, GRN_ID_NIL, NULL));
+ grn_test_assert_equal_rc(GRN_INVALID_ARGUMENT,
+ grn_pat_delete_by_id(&ctx, pat, GRN_ID_NIL, NULL));
+ grn_test_assert_equal_rc(GRN_INVALID_ARGUMENT,
+ grn_dat_delete_by_id(&ctx, dat, GRN_ID_NIL, NULL));
for (std::size_t i = 0; i < keys.size(); i += 2) {
const grn_id key_id = static_cast<grn_id>(i + 1);
- cppcut_assert_equal(GRN_SUCCESS,
- grn_pat_delete_by_id(&ctx, pat, key_id, NULL));
- cppcut_assert_equal(GRN_SUCCESS,
- grn_dat_delete_by_id(&ctx, dat, key_id, NULL));
+ grn_test_assert_equal_rc(GRN_SUCCESS,
+ grn_pat_delete_by_id(&ctx, pat, key_id, NULL));
+ grn_test_assert_equal_rc(GRN_SUCCESS,
+ grn_dat_delete_by_id(&ctx, dat, key_id, NULL));
}
- cppcut_assert_equal(GRN_INVALID_ARGUMENT,
- grn_pat_delete_by_id(&ctx, pat, 1, NULL));
- cppcut_assert_equal(GRN_INVALID_ARGUMENT,
- grn_dat_delete_by_id(&ctx, dat, 1, NULL));
+ grn_test_assert_equal_rc(GRN_INVALID_ARGUMENT,
+ grn_pat_delete_by_id(&ctx, pat, 1, NULL));
+ grn_test_assert_equal_rc(GRN_INVALID_ARGUMENT,
+ grn_dat_delete_by_id(&ctx, dat, 1, NULL));
for (std::size_t i = 0; i < keys.size(); ++i) {
const grn_id key_id = static_cast<grn_id>(i + 1);
const grn_rc rc = (i & 1) ? GRN_SUCCESS : GRN_INVALID_ARGUMENT;
- cppcut_assert_equal(rc, grn_pat_delete_by_id(&ctx, pat, key_id, NULL));
- cppcut_assert_equal(rc, grn_dat_delete_by_id(&ctx, dat, key_id, NULL));
+ grn_test_assert_equal_rc(rc,
+ grn_pat_delete_by_id(&ctx, pat, key_id, NULL));
+ grn_test_assert_equal_rc(rc,
+ grn_dat_delete_by_id(&ctx, dat, key_id, NULL));
}
- cppcut_assert_equal(GRN_SUCCESS, grn_pat_close(&ctx, pat));
- cppcut_assert_equal(GRN_SUCCESS, grn_dat_close(&ctx, dat));
+ grn_test_assert_equal_rc(GRN_SUCCESS, grn_pat_close(&ctx, pat));
+ grn_test_assert_equal_rc(GRN_SUCCESS, grn_dat_close(&ctx, dat));
}
void test_delete(void)
{
const char * const filename = "test_delete";
- cppcut_assert_equal(GRN_INVALID_ARGUMENT,
- grn_pat_delete(&ctx, NULL, "XYZ", 3, NULL));
-// cppcut_assert_equal(GRN_INVALID_ARGUMENT,
-// grn_dat_delete(&ctx, NULL, "XYZ", 3, NULL));
+ grn_test_assert_equal_rc(GRN_INVALID_ARGUMENT,
+ grn_pat_delete(&ctx, NULL, "XYZ", 3, NULL));
+ grn_test_assert_equal_rc(GRN_INVALID_ARGUMENT,
+ grn_dat_delete(&ctx, NULL, "XYZ", 3, NULL));
std::vector<std::string> keys;
create_keys(&keys, 1000, 3, 5);
grn_pat * const pat = create_pat(filename, keys);
grn_dat * const dat = create_dat(filename, keys);
- cppcut_assert_equal(GRN_INVALID_ARGUMENT,
- grn_pat_delete(&ctx, pat, NULL, 1, NULL));
- cppcut_assert_equal(GRN_INVALID_ARGUMENT,
- grn_dat_delete(&ctx, dat, NULL, 1, NULL));
+ grn_test_assert_equal_rc(GRN_INVALID_ARGUMENT,
+ grn_pat_delete(&ctx, pat, NULL, 1, NULL));
+ grn_test_assert_equal_rc(GRN_INVALID_ARGUMENT,
+ grn_dat_delete(&ctx, dat, NULL, 1, NULL));
- cppcut_assert_equal(GRN_INVALID_ARGUMENT,
- grn_pat_delete(&ctx, pat, "XYZ", 0, NULL));
- cppcut_assert_equal(GRN_INVALID_ARGUMENT,
- grn_dat_delete(&ctx, dat, "XYZ", 0, NULL));
+ grn_test_assert_equal_rc(GRN_INVALID_ARGUMENT,
+ grn_pat_delete(&ctx, pat, "XYZ", 0, NULL));
+ grn_test_assert_equal_rc(GRN_INVALID_ARGUMENT,
+ grn_dat_delete(&ctx, dat, "XYZ", 0, NULL));
for (std::size_t i = 0; i < keys.size(); i += 2) {
const char * const ptr = keys[i].c_str();
const uint32_t length = static_cast<uint32_t>(keys[i].length());
- cppcut_assert_equal(GRN_SUCCESS,
- grn_pat_delete(&ctx, pat, ptr, length, NULL));
- cppcut_assert_equal(GRN_SUCCESS,
- grn_dat_delete(&ctx, dat, ptr, length, NULL));
+ grn_test_assert_equal_rc(GRN_SUCCESS,
+ grn_pat_delete(&ctx, pat, ptr, length, NULL));
+ grn_test_assert_equal_rc(GRN_SUCCESS,
+ grn_dat_delete(&ctx, dat, ptr, length, NULL));
}
for (std::size_t i = 0; i < keys.size(); ++i) {
const char * const ptr = keys[i].c_str();
const uint32_t length = static_cast<uint32_t>(keys[i].length());
const grn_rc rc = (i & 1) ? GRN_SUCCESS : GRN_INVALID_ARGUMENT;
- cppcut_assert_equal(rc, grn_pat_delete(&ctx, pat, ptr, length, NULL));
- cppcut_assert_equal(rc, grn_dat_delete(&ctx, dat, ptr, length, NULL));
+ grn_test_assert_equal_rc(rc,
+ grn_pat_delete(&ctx, pat, ptr, length, NULL));
+ grn_test_assert_equal_rc(rc,
+ grn_dat_delete(&ctx, dat, ptr, length, NULL));
}
- cppcut_assert_equal(GRN_SUCCESS, grn_pat_close(&ctx, pat));
- cppcut_assert_equal(GRN_SUCCESS, grn_dat_close(&ctx, dat));
+ grn_test_assert_equal_rc(GRN_SUCCESS, grn_pat_close(&ctx, pat));
+ grn_test_assert_equal_rc(GRN_SUCCESS, grn_dat_close(&ctx, dat));
+ }
+
+ void test_scan(void)
+ {
+ const char * const filename = "test_scan";
+
+ std::vector<std::string> keys;
+ create_keys(&keys, 1000, 3, 5);
+ grn_pat * const pat = create_pat(filename, keys);
+ grn_dat * const dat = create_dat(filename, keys);
+
+ std::string query;
+ for (int i = 0; i < 1000; ++i) {
+ create_key(&query, 8, 16);
+
+ grn_pat_scan_hit pat_hits[4];
+ const char *pat_rest;
+ const int pat_num_hits =
+ grn_pat_scan(&ctx, pat, query.c_str(), query.length(),
+ pat_hits, 4, &pat_rest);
+
+ grn_dat_scan_hit dat_hits[4];
+ const char *dat_rest;
+ const int dat_num_hits =
+ grn_dat_scan(&ctx, dat, query.c_str(), query.length(),
+ dat_hits, 4, &dat_rest);
+
+ cppcut_assert_equal(pat_num_hits, dat_num_hits);
+ for (int j = 0; j < pat_num_hits; ++j) {
+ cppcut_assert_equal(pat_hits[j].id, dat_hits[j].id);
+ cppcut_assert_equal(pat_hits[j].offset, dat_hits[j].offset);
+ cppcut_assert_equal(pat_hits[j].length, dat_hits[j].length);
+ }
+ cppcut_assert_equal(pat_rest, dat_rest);
+ }
+
+ grn_test_assert_equal_rc(GRN_SUCCESS, grn_pat_close(&ctx, pat));
+ grn_test_assert_equal_rc(GRN_SUCCESS, grn_dat_close(&ctx, dat));
+ }
+
+ void test_lcp_search(void)
+ {
+ const char * const filename = "test_lcp_search";
+
+ std::vector<std::string> keys;
+ create_keys(&keys, 1000, 3, 5);
+ grn_pat * const pat = create_pat(filename, keys);
+ grn_dat * const dat = create_dat(filename, keys);
+
+ std::string query;
+ for (int i = 0; i < 1000; ++i) {
+ create_key(&query, 3, 6);
+
+ const grn_id pat_id =
+ grn_pat_lcp_search(&ctx, pat, query.c_str(), query.length());
+ const grn_id dat_id =
+ grn_dat_lcp_search(&ctx, dat, query.c_str(), query.length());
+ cppcut_assert_equal(pat_id, dat_id);
+ }
+
+ grn_test_assert_equal_rc(GRN_SUCCESS, grn_pat_close(&ctx, pat));
+ grn_test_assert_equal_rc(GRN_SUCCESS, grn_dat_close(&ctx, dat));
}
void test_id_cursor(void)
@@ -363,10 +438,12 @@ namespace test_dat_pat
const char * const min_key =
(min_id != GRN_ID_NIL) ? keys[min_id - 1].c_str() : NULL;
- const int min_length = min_key ? static_cast<int>(keys[min_id - 1].length()) : 0;
+ const int min_length =
+ min_key ? static_cast<int>(keys[min_id - 1].length()) : 0;
const char * const max_key =
(max_id != GRN_ID_NIL) ? keys[max_id - 1].c_str() : NULL;
- const int max_length = max_key ? static_cast<int>(keys[max_id - 1].length()) : 0;
+ const int max_length =
+ max_key ? static_cast<int>(keys[max_id - 1].length()) : 0;
const int temp = std::rand();
const int offset = temp & 0x0F;
@@ -377,14 +454,14 @@ namespace test_dat_pat
(((temp & 0x400) == 0x400) ?
GRN_CURSOR_DESCENDING : GRN_CURSOR_ASCENDING);
- grn_pat_cursor * const pat_cursor =
- grn_pat_cursor_open(&ctx, pat, min_key, min_length, max_key, max_length,
- offset, limit, flags);
+ grn_pat_cursor * const pat_cursor = grn_pat_cursor_open(
+ &ctx, pat, min_key, min_length, max_key, max_length,
+ offset, limit, flags);
cppcut_assert_not_null(pat_cursor);
- grn_dat_cursor * const dat_cursor =
- grn_dat_cursor_open(&ctx, dat, min_key, min_length, max_key, max_length,
- offset, limit, flags);
+ grn_dat_cursor * const dat_cursor = grn_dat_cursor_open(
+ &ctx, dat, min_key, min_length, max_key, max_length,
+ offset, limit, flags);
cppcut_assert_not_null(dat_cursor);
grn_id pat_id;
@@ -399,8 +476,8 @@ namespace test_dat_pat
grn_dat_cursor_close(&ctx, dat_cursor);
}
- cppcut_assert_equal(GRN_SUCCESS, grn_pat_close(&ctx, pat));
- cppcut_assert_equal(GRN_SUCCESS, grn_dat_close(&ctx, dat));
+ grn_test_assert_equal_rc(GRN_SUCCESS, grn_pat_close(&ctx, pat));
+ grn_test_assert_equal_rc(GRN_SUCCESS, grn_dat_close(&ctx, dat));
}
void test_key_cursor(void)
@@ -461,8 +538,8 @@ namespace test_dat_pat
grn_dat_cursor_close(&ctx, dat_cursor);
}
- cppcut_assert_equal(GRN_SUCCESS, grn_pat_close(&ctx, pat));
- cppcut_assert_equal(GRN_SUCCESS, grn_dat_close(&ctx, dat));
+ grn_test_assert_equal_rc(GRN_SUCCESS, grn_pat_close(&ctx, pat));
+ grn_test_assert_equal_rc(GRN_SUCCESS, grn_dat_close(&ctx, dat));
}
void test_prefix_cursor(void)
@@ -511,8 +588,8 @@ namespace test_dat_pat
grn_dat_cursor_close(&ctx, dat_cursor);
}
- cppcut_assert_equal(GRN_SUCCESS, grn_pat_close(&ctx, pat));
- cppcut_assert_equal(GRN_SUCCESS, grn_dat_close(&ctx, dat));
+ grn_test_assert_equal_rc(GRN_SUCCESS, grn_pat_close(&ctx, pat));
+ grn_test_assert_equal_rc(GRN_SUCCESS, grn_dat_close(&ctx, dat));
}
void test_predictive_cursor(void)
@@ -559,8 +636,8 @@ namespace test_dat_pat
grn_dat_cursor_close(&ctx, dat_cursor);
}
- cppcut_assert_equal(GRN_SUCCESS, grn_pat_close(&ctx, pat));
- cppcut_assert_equal(GRN_SUCCESS, grn_dat_close(&ctx, dat));
+ grn_test_assert_equal_rc(GRN_SUCCESS, grn_pat_close(&ctx, pat));
+ grn_test_assert_equal_rc(GRN_SUCCESS, grn_dat_close(&ctx, dat));
}
void test_truncate(void)
@@ -572,8 +649,8 @@ namespace test_dat_pat
grn_pat * const pat = create_pat(filename, keys);
grn_dat * const dat = create_dat(filename, keys);
- cppcut_assert_equal(GRN_SUCCESS, grn_pat_truncate(&ctx, pat));
- cppcut_assert_equal(GRN_SUCCESS, grn_dat_truncate(&ctx, dat));
+ grn_test_assert_equal_rc(GRN_SUCCESS, grn_pat_truncate(&ctx, pat));
+ grn_test_assert_equal_rc(GRN_SUCCESS, grn_dat_truncate(&ctx, dat));
cppcut_assert_equal(static_cast<unsigned int>(0), grn_pat_size(&ctx, pat));
cppcut_assert_equal(static_cast<unsigned int>(0), grn_dat_size(&ctx, dat));
@@ -587,7 +664,7 @@ namespace test_dat_pat
grn_dat_get(&ctx, dat, ptr, length, NULL));
}
- cppcut_assert_equal(GRN_SUCCESS, grn_pat_close(&ctx, pat));
- cppcut_assert_equal(GRN_SUCCESS, grn_dat_close(&ctx, dat));
+ grn_test_assert_equal_rc(GRN_SUCCESS, grn_pat_close(&ctx, pat));
+ grn_test_assert_equal_rc(GRN_SUCCESS, grn_dat_close(&ctx, dat));
}
}
Modified: test/unit/core/dat/test-dat.cpp (+147 -124)
===================================================================
--- test/unit/core/dat/test-dat.cpp 2012-02-01 10:57:14 +0900 (b880b3d)
+++ test/unit/core/dat/test-dat.cpp 2012-02-01 13:08:03 +0900 (1dce81d)
@@ -43,7 +43,8 @@ namespace
GRN_API_RETURN(0);
}
- void create_key(std::string *key, std::size_t min_length, std::size_t max_length)
+ void create_key(std::string *key, std::size_t min_length,
+ std::size_t max_length)
{
key->resize(min_length + (std::rand() % (max_length - min_length + 1)));
for (std::size_t i = 0; i < key->size(); ++i) {
@@ -117,10 +118,10 @@ namespace test_dat
create_keys(&keys, 1000, 6, 15);
grn_dat *dat = create_trie(keys, NULL);
- cppcut_assert_equal(GRN_SUCCESS, grn_dat_close(&ctx, dat));
+ grn_test_assert_equal_rc(GRN_SUCCESS, grn_dat_close(&ctx, dat));
dat = create_trie(keys, "");
- cppcut_assert_equal(GRN_SUCCESS, grn_dat_close(&ctx, dat));
+ grn_test_assert_equal_rc(GRN_SUCCESS, grn_dat_close(&ctx, dat));
}
void test_create_with_path(void)
@@ -132,7 +133,7 @@ namespace test_dat
create_keys(&keys, 1000, 6, 15);
grn_dat * const dat = create_trie(keys, dat_path);
- cppcut_assert_equal(GRN_SUCCESS, grn_dat_close(&ctx, dat));
+ grn_test_assert_equal_rc(GRN_SUCCESS, grn_dat_close(&ctx, dat));
}
void test_open(void)
@@ -152,8 +153,8 @@ namespace test_dat
cppcut_assert_equal(static_cast<grn_id>(i + 1),
grn_dat_get(&ctx, dat2, ptr, length, NULL));
}
- cppcut_assert_equal(GRN_SUCCESS, grn_dat_close(&ctx, dat));
- cppcut_assert_equal(GRN_SUCCESS, grn_dat_close(&ctx, dat2));
+ grn_test_assert_equal_rc(GRN_SUCCESS, grn_dat_close(&ctx, dat));
+ grn_test_assert_equal_rc(GRN_SUCCESS, grn_dat_close(&ctx, dat2));
cppcut_assert_null(grn_dat_open(&ctx, NULL));
cppcut_assert_null(grn_dat_open(&ctx, ""));
@@ -164,32 +165,33 @@ namespace test_dat
char dat_path[PATH_MAX];
std::sprintf(dat_path, "%s/%s", base_dir, "test_remove.tmp");
- cppcut_assert_equal(GRN_NO_SUCH_FILE_OR_DIRECTORY,
- grn_dat_remove(&ctx, dat_path));
- cppcut_assert_equal(GRN_NO_SUCH_FILE_OR_DIRECTORY, ctx.rc);
+ grn_test_assert_equal_rc(GRN_NO_SUCH_FILE_OR_DIRECTORY,
+ grn_dat_remove(&ctx, dat_path));
+ grn_test_assert_equal_rc(GRN_NO_SUCH_FILE_OR_DIRECTORY, ctx.rc);
ctx.rc = GRN_SUCCESS;
std::vector<std::string> keys;
create_keys(&keys, 1000, 6, 15);
grn_dat * const dat = create_trie(keys, dat_path);
- cppcut_assert_equal(GRN_SUCCESS, grn_dat_repair(&ctx, dat));
- cppcut_assert_equal(GRN_SUCCESS, grn_dat_repair(&ctx, dat));
- cppcut_assert_equal(GRN_SUCCESS, grn_dat_repair(&ctx, dat));
+ grn_test_assert_equal_rc(GRN_SUCCESS, grn_dat_repair(&ctx, dat));
+ grn_test_assert_equal_rc(GRN_SUCCESS, grn_dat_repair(&ctx, dat));
+ grn_test_assert_equal_rc(GRN_SUCCESS, grn_dat_repair(&ctx, dat));
const uint32_t last_file_id = dat->file_id;
cppcut_assert_equal(static_cast<uint32_t>(4), last_file_id);
- cppcut_assert_equal(GRN_SUCCESS, grn_dat_close(&ctx, dat));
+ grn_test_assert_equal_rc(GRN_SUCCESS, grn_dat_close(&ctx, dat));
- cppcut_assert_equal(GRN_SUCCESS, grn_dat_remove(&ctx, dat_path));
+ grn_test_assert_equal_rc(GRN_SUCCESS, grn_dat_remove(&ctx, dat_path));
cut_assert_not_exist_path(dat_path);
char trie_path[PATH_MAX];
for (uint32_t i = 1; i <= last_file_id; ++i) {
std::sprintf(trie_path, "%s.%03d", dat_path, i);
cut_assert_not_exist_path(trie_path);
}
- cppcut_assert_equal(GRN_SUCCESS, ctx.rc);
+ grn_test_assert_equal_rc(GRN_SUCCESS, ctx.rc);
- cppcut_assert_equal(GRN_INVALID_ARGUMENT, grn_dat_remove(&ctx, NULL));
+ grn_test_assert_equal_rc(GRN_INVALID_ARGUMENT,
+ grn_dat_remove(&ctx, NULL));
}
void test_get(void)
@@ -204,7 +206,7 @@ namespace test_dat
cppcut_assert_equal(static_cast<grn_id>(i + 1),
grn_dat_get(&ctx, dat, ptr, length, NULL));
}
- cppcut_assert_equal(GRN_SUCCESS, grn_dat_close(&ctx, dat));
+ grn_test_assert_equal_rc(GRN_SUCCESS, grn_dat_close(&ctx, dat));
}
void test_add(void)
@@ -216,7 +218,7 @@ namespace test_dat
cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL),
grn_dat_add(&ctx, dat, "", 0, NULL, NULL));
- cppcut_assert_equal(GRN_SUCCESS, grn_dat_close(&ctx, dat));
+ grn_test_assert_equal_rc(GRN_SUCCESS, grn_dat_close(&ctx, dat));
}
void test_get_key(void)
@@ -230,12 +232,13 @@ namespace test_dat
const int length = static_cast<int>(keys[i].length());
cppcut_assert_equal(length, grn_dat_get_key(&ctx, dat, key_id, NULL, 0));
char key_buf[16];
- const int key_length = grn_dat_get_key(&ctx, dat, key_id, key_buf, sizeof(key_buf));
+ const int key_length =
+ grn_dat_get_key(&ctx, dat, key_id, key_buf, sizeof(key_buf));
cppcut_assert_equal(length, key_length);
cppcut_assert_equal(keys[i], std::string(key_buf, key_length));
}
cppcut_assert_equal(0, grn_dat_get_key(&ctx, dat, GRN_ID_NIL, NULL, 0));
- cppcut_assert_equal(GRN_SUCCESS, grn_dat_close(&ctx, dat));
+ grn_test_assert_equal_rc(GRN_SUCCESS, grn_dat_close(&ctx, dat));
}
void test_get_key2_with_refer(void)
@@ -252,16 +255,18 @@ namespace test_dat
const int length = static_cast<int>(keys[i].length());
uint32_t key_length;
- const char * const key_ptr = _grn_dat_key(&ctx, dat, key_id, &key_length);
+ const char * const key_ptr =
+ _grn_dat_key(&ctx, dat, key_id, &key_length);
cppcut_assert_not_null(key_ptr);
cppcut_assert_equal(length, static_cast<int>(key_length));
cppcut_assert_equal(length, grn_dat_get_key2(&ctx, dat, key_id, &bulk));
cppcut_assert_equal(key_ptr, bulk.u.b.head);
- cppcut_assert_equal(length, static_cast<int>(bulk.u.b.curr - bulk.u.b.head));
+ cppcut_assert_equal(length,
+ static_cast<int>(bulk.u.b.curr - bulk.u.b.head));
}
cppcut_assert_equal(0, grn_dat_get_key2(&ctx, dat, GRN_ID_NIL, &bulk));
- cppcut_assert_equal(GRN_SUCCESS, grn_dat_close(&ctx, dat));
+ grn_test_assert_equal_rc(GRN_SUCCESS, grn_dat_close(&ctx, dat));
GRN_OBJ_FIN(&ctx, &bulk);
}
@@ -280,17 +285,19 @@ namespace test_dat
const int length = static_cast<int>(keys[i].length());
uint32_t key_length;
- const char * const key_ptr = _grn_dat_key(&ctx, dat, key_id, &key_length);
+ const char * const key_ptr =
+ _grn_dat_key(&ctx, dat, key_id, &key_length);
cppcut_assert_not_null(key_ptr);
cppcut_assert_equal(length, static_cast<int>(key_length));
GRN_BULK_REWIND(&bulk);
cppcut_assert_equal(length, grn_dat_get_key2(&ctx, dat, key_id, &bulk));
cppcut_assert_equal(length, static_cast<int>(GRN_TEXT_LEN(&bulk)));
- cppcut_assert_equal(keys[i], std::string(GRN_TEXT_VALUE(&bulk), GRN_TEXT_LEN(&bulk)));
+ cppcut_assert_equal(keys[i],
+ std::string(GRN_TEXT_VALUE(&bulk), GRN_TEXT_LEN(&bulk)));
}
cppcut_assert_equal(0, grn_dat_get_key2(&ctx, dat, GRN_ID_NIL, &bulk));
- cppcut_assert_equal(GRN_SUCCESS, grn_dat_close(&ctx, dat));
+ grn_test_assert_equal_rc(GRN_SUCCESS, grn_dat_close(&ctx, dat));
GRN_OBJ_FIN(&ctx, &bulk);
}
@@ -303,10 +310,10 @@ namespace test_dat
grn_dat * const dat = create_trie(keys, NULL);
for (std::size_t i = 0; i < keys.size(); ++i) {
const grn_id key_id = static_cast<grn_id>(i + 1);
- cppcut_assert_equal(GRN_SUCCESS,
- grn_dat_delete_by_id(&ctx, dat, key_id, NULL));
- cppcut_assert_equal(GRN_INVALID_ARGUMENT,
- grn_dat_delete_by_id(&ctx, dat, key_id, NULL));
+ grn_test_assert_equal_rc(GRN_SUCCESS,
+ grn_dat_delete_by_id(&ctx, dat, key_id, NULL));
+ grn_test_assert_equal_rc(GRN_INVALID_ARGUMENT,
+ grn_dat_delete_by_id(&ctx, dat, key_id, NULL));
}
for (std::size_t i = 0; i < keys.size(); ++i) {
const char * const ptr = keys[i].c_str();
@@ -318,12 +325,12 @@ namespace test_dat
}
for (std::size_t i = 0; i < keys.size(); ++i) {
const grn_id key_id = static_cast<grn_id>(i + 1);
- cppcut_assert_equal(GRN_SUCCESS,
- grn_dat_delete_by_id(&ctx, dat, key_id, NULL));
- cppcut_assert_equal(GRN_INVALID_ARGUMENT,
- grn_dat_delete_by_id(&ctx, dat, key_id, NULL));
+ grn_test_assert_equal_rc(GRN_SUCCESS,
+ grn_dat_delete_by_id(&ctx, dat, key_id, NULL));
+ grn_test_assert_equal_rc(GRN_INVALID_ARGUMENT,
+ grn_dat_delete_by_id(&ctx, dat, key_id, NULL));
}
- cppcut_assert_equal(GRN_SUCCESS, grn_dat_close(&ctx, dat));
+ grn_test_assert_equal_rc(GRN_SUCCESS, grn_dat_close(&ctx, dat));
}
void test_delete(void)
@@ -335,10 +342,10 @@ namespace test_dat
for (std::size_t i = 0; i < keys.size(); ++i) {
const char * const ptr = keys[i].c_str();
const uint32_t length = static_cast<uint32_t>(keys[i].length());
- cppcut_assert_equal(GRN_SUCCESS,
- grn_dat_delete(&ctx, dat, ptr, length, NULL));
- cppcut_assert_equal(GRN_INVALID_ARGUMENT,
- grn_dat_delete(&ctx, dat, ptr, length, NULL));
+ grn_test_assert_equal_rc(GRN_SUCCESS,
+ grn_dat_delete(&ctx, dat, ptr, length, NULL));
+ grn_test_assert_equal_rc(GRN_INVALID_ARGUMENT,
+ grn_dat_delete(&ctx, dat, ptr, length, NULL));
}
for (std::size_t i = 0; i < keys.size(); ++i) {
const char * const ptr = keys[i].c_str();
@@ -351,12 +358,12 @@ namespace test_dat
for (std::size_t i = 0; i < keys.size(); ++i) {
const char * const ptr = keys[i].c_str();
const uint32_t length = static_cast<uint32_t>(keys[i].length());
- cppcut_assert_equal(GRN_SUCCESS,
- grn_dat_delete(&ctx, dat, ptr, length, NULL));
- cppcut_assert_equal(GRN_INVALID_ARGUMENT,
- grn_dat_delete(&ctx, dat, ptr, length, NULL));
+ grn_test_assert_equal_rc(GRN_SUCCESS,
+ grn_dat_delete(&ctx, dat, ptr, length, NULL));
+ grn_test_assert_equal_rc(GRN_INVALID_ARGUMENT,
+ grn_dat_delete(&ctx, dat, ptr, length, NULL));
}
- cppcut_assert_equal(GRN_SUCCESS, grn_dat_close(&ctx, dat));
+ grn_test_assert_equal_rc(GRN_SUCCESS, grn_dat_close(&ctx, dat));
}
void test_update_by_id(void)
@@ -364,7 +371,8 @@ namespace test_dat
std::vector<std::string> keys;
create_keys(&keys, 1000, 6, 15);
- grn_dat * const dat = grn_dat_create(&ctx, NULL, 0, 0, GRN_OBJ_KEY_VAR_SIZE);
+ grn_dat * const dat =
+ grn_dat_create(&ctx, NULL, 0, 0, GRN_OBJ_KEY_VAR_SIZE);
cppcut_assert_not_null(dat);
for (std::size_t i = 0; i < (keys.size() / 2); ++i) {
const char * const ptr = keys[i].c_str();
@@ -377,34 +385,36 @@ namespace test_dat
for (std::size_t i = (keys.size() / 2); i < keys.size(); ++i) {
const grn_id key_id = static_cast<grn_id>(i + 1 - (keys.size() / 2));
const char * const src_ptr = keys[i - (keys.size() / 2)].c_str();
- const uint32_t src_length = static_cast<uint32_t>(keys[i - (keys.size() / 2)].length());
+ const uint32_t src_length =
+ static_cast<uint32_t>(keys[i - (keys.size() / 2)].length());
const char * const dest_ptr = keys[i].c_str();
const uint32_t dest_length = static_cast<uint32_t>(keys[i].length());
- cppcut_assert_equal(GRN_SUCCESS,
- grn_dat_update_by_id(&ctx, dat, key_id, dest_ptr, dest_length));
+ grn_test_assert_equal_rc(GRN_SUCCESS,
+ grn_dat_update_by_id(&ctx, dat, key_id, dest_ptr, dest_length));
cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL),
- grn_dat_get(&ctx, dat, src_ptr, src_length, NULL));
+ grn_dat_get(&ctx, dat, src_ptr, src_length, NULL));
cppcut_assert_equal(key_id,
- grn_dat_get(&ctx, dat, dest_ptr, dest_length, NULL));
- cppcut_assert_equal(GRN_INVALID_ARGUMENT,
- grn_dat_update_by_id(&ctx, dat, key_id, dest_ptr, dest_length));
+ grn_dat_get(&ctx, dat, dest_ptr, dest_length, NULL));
+ grn_test_assert_equal_rc(GRN_INVALID_ARGUMENT,
+ grn_dat_update_by_id(&ctx, dat, key_id, dest_ptr, dest_length));
}
for (std::size_t i = 0; i < (keys.size() / 2); ++i) {
const grn_id key_id = static_cast<grn_id>(i + 1);
const char *src_ptr = keys[i + (keys.size() / 2)].c_str();
- const uint32_t src_length = static_cast<uint32_t>(keys[i + (keys.size() / 2)].length());
+ const uint32_t src_length =
+ static_cast<uint32_t>(keys[i + (keys.size() / 2)].length());
const char * const dest_ptr = keys[i].c_str();
const uint32_t dest_length = static_cast<uint32_t>(keys[i].length());
- cppcut_assert_equal(GRN_SUCCESS,
- grn_dat_update_by_id(&ctx, dat, key_id, dest_ptr, dest_length));
+ grn_test_assert_equal_rc(GRN_SUCCESS,
+ grn_dat_update_by_id(&ctx, dat, key_id, dest_ptr, dest_length));
cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL),
- grn_dat_get(&ctx, dat, src_ptr, src_length, NULL));
+ grn_dat_get(&ctx, dat, src_ptr, src_length, NULL));
cppcut_assert_equal(key_id,
- grn_dat_get(&ctx, dat, dest_ptr, dest_length, NULL));
- cppcut_assert_equal(GRN_INVALID_ARGUMENT,
- grn_dat_update_by_id(&ctx, dat, key_id, dest_ptr, dest_length));
+ grn_dat_get(&ctx, dat, dest_ptr, dest_length, NULL));
+ grn_test_assert_equal_rc(GRN_INVALID_ARGUMENT,
+ grn_dat_update_by_id(&ctx, dat, key_id, dest_ptr, dest_length));
}
- cppcut_assert_equal(GRN_SUCCESS, grn_dat_close(&ctx, dat));
+ grn_test_assert_equal_rc(GRN_SUCCESS, grn_dat_close(&ctx, dat));
}
void test_update(void)
@@ -412,7 +422,8 @@ namespace test_dat
std::vector<std::string> keys;
create_keys(&keys, 1000, 6, 15);
- grn_dat * const dat = grn_dat_create(&ctx, NULL, 0, 0, GRN_OBJ_KEY_VAR_SIZE);
+ grn_dat * const dat =
+ grn_dat_create(&ctx, NULL, 0, 0, GRN_OBJ_KEY_VAR_SIZE);
cppcut_assert_not_null(dat);
for (std::size_t i = 0; i < (keys.size() / 2); ++i) {
const char * const ptr = keys[i].c_str();
@@ -421,39 +432,44 @@ namespace test_dat
grn_dat_add(&ctx, dat, ptr, length, NULL, NULL));
}
grn_test_assert_equal_rc(GRN_INVALID_ARGUMENT,
- grn_dat_update(&ctx, dat, keys[1].c_str(),
- keys[1].length(), "", 0));
+ grn_dat_update(&ctx, dat, keys[1].c_str(), keys[1].length(), "", 0));
for (std::size_t i = (keys.size() / 2); i < keys.size(); ++i) {
const grn_id key_id = static_cast<grn_id>(i + 1 - (keys.size() / 2));
const char * const src_ptr = keys[i - (keys.size() / 2)].c_str();
- const uint32_t src_length = static_cast<uint32_t>(keys[i - (keys.size() / 2)].length());
+ const uint32_t src_length =
+ static_cast<uint32_t>(keys[i - (keys.size() / 2)].length());
const char * const dest_ptr = keys[i].c_str();
const uint32_t dest_length = static_cast<uint32_t>(keys[i].length());
- cppcut_assert_equal(GRN_SUCCESS,
- grn_dat_update(&ctx, dat, src_ptr, src_length, dest_ptr, dest_length));
+ grn_test_assert_equal_rc(GRN_SUCCESS,
+ grn_dat_update(&ctx, dat, src_ptr, src_length,
+ dest_ptr, dest_length));
cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL),
- grn_dat_get(&ctx, dat, src_ptr, src_length, NULL));
+ grn_dat_get(&ctx, dat, src_ptr, src_length, NULL));
cppcut_assert_equal(key_id,
- grn_dat_get(&ctx, dat, dest_ptr, dest_length, NULL));
- cppcut_assert_equal(GRN_INVALID_ARGUMENT,
- grn_dat_update(&ctx, dat, src_ptr, src_length, dest_ptr, dest_length));
+ grn_dat_get(&ctx, dat, dest_ptr, dest_length, NULL));
+ grn_test_assert_equal_rc(GRN_INVALID_ARGUMENT,
+ grn_dat_update(&ctx, dat, src_ptr, src_length,
+ dest_ptr, dest_length));
}
for (std::size_t i = 0; i < (keys.size() / 2); ++i) {
const grn_id key_id = static_cast<grn_id>(i + 1);
const char *src_ptr = keys[i + (keys.size() / 2)].c_str();
- const uint32_t src_length = static_cast<uint32_t>(keys[i + (keys.size() / 2)].length());
+ const uint32_t src_length =
+ static_cast<uint32_t>(keys[i + (keys.size() / 2)].length());
const char * const dest_ptr = keys[i].c_str();
const uint32_t dest_length = static_cast<uint32_t>(keys[i].length());
- cppcut_assert_equal(GRN_SUCCESS,
- grn_dat_update(&ctx, dat, src_ptr, src_length, dest_ptr, dest_length));
+ grn_test_assert_equal_rc(GRN_SUCCESS,
+ grn_dat_update(&ctx, dat, src_ptr, src_length,
+ dest_ptr, dest_length));
cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL),
- grn_dat_get(&ctx, dat, src_ptr, src_length, NULL));
+ grn_dat_get(&ctx, dat, src_ptr, src_length, NULL));
cppcut_assert_equal(key_id,
- grn_dat_get(&ctx, dat, dest_ptr, dest_length, NULL));
- cppcut_assert_equal(GRN_INVALID_ARGUMENT,
- grn_dat_update(&ctx, dat, src_ptr, src_length, dest_ptr, dest_length));
+ grn_dat_get(&ctx, dat, dest_ptr, dest_length, NULL));
+ grn_test_assert_equal_rc(GRN_INVALID_ARGUMENT,
+ grn_dat_update(&ctx, dat, src_ptr, src_length,
+ dest_ptr, dest_length));
}
- cppcut_assert_equal(GRN_SUCCESS, grn_dat_close(&ctx, dat));
+ grn_test_assert_equal_rc(GRN_SUCCESS, grn_dat_close(&ctx, dat));
}
void test_scan(void)
@@ -468,7 +484,8 @@ namespace test_dat
const char text[] = "0123456789X";
const unsigned int text_size = sizeof(text) - 1;
grn_dat_scan_hit scan_hits[4];
- const unsigned int max_num_scan_hits = sizeof(scan_hits) / sizeof(scan_hits[0]);
+ const unsigned int max_num_scan_hits =
+ sizeof(scan_hits) / sizeof(scan_hits[0]);
grn_dat * const dat = create_trie(keys, NULL);
@@ -488,22 +505,21 @@ namespace test_dat
cppcut_assert_equal(3U, scan_hits[2].length);
cppcut_assert_equal(1,
- grn_dat_scan(&ctx, dat, text, text_size,
- scan_hits, 1, &text_rest));
+ grn_dat_scan(&ctx, dat, text, text_size, scan_hits, 1, &text_rest));
cppcut_assert_equal(static_cast<std::ptrdiff_t>(3), text_rest - text);
cppcut_assert_equal(1,
- grn_dat_scan(&ctx, dat, text_rest, text_size - (text_rest - text),
- scan_hits, 1, &text_rest));
+ grn_dat_scan(&ctx, dat, text_rest, text_size - (text_rest - text),
+ scan_hits, 1, &text_rest));
cppcut_assert_equal(static_cast<std::ptrdiff_t>(6), text_rest - text);
cppcut_assert_equal(1,
- grn_dat_scan(&ctx, dat, text_rest, text_size - (text_rest - text),
- scan_hits, 1, &text_rest));
+ grn_dat_scan(&ctx, dat, text_rest, text_size - (text_rest - text),
+ scan_hits, 1, &text_rest));
cppcut_assert_equal(static_cast<std::ptrdiff_t>(10), text_rest - text);
cppcut_assert_equal(0,
- grn_dat_scan(&ctx, dat, text_rest, text_size - (text_rest - text),
- scan_hits, 1, &text_rest));
+ grn_dat_scan(&ctx, dat, text_rest, text_size - (text_rest - text),
+ scan_hits, 1, &text_rest));
- cppcut_assert_equal(GRN_SUCCESS, grn_dat_close(&ctx, dat));
+ grn_test_assert_equal_rc(GRN_SUCCESS, grn_dat_close(&ctx, dat));
}
{
@@ -514,14 +530,15 @@ namespace test_dat
const char text[] = "ユニ㌘…ハ゛イク゛ラム";
const unsigned int text_size = sizeof(text) - 1;
grn_dat_scan_hit scan_hits[4];
- const unsigned int max_num_scan_hits = sizeof(scan_hits) / sizeof(scan_hits[0]);
+ const unsigned int max_num_scan_hits =
+ sizeof(scan_hits) / sizeof(scan_hits[0]);
grn_dat * const dat = create_trie(keys, NULL, GRN_OBJ_KEY_NORMALIZE);
const char *text_rest;
cppcut_assert_equal(2,
- grn_dat_scan(&ctx, dat, text, text_size,
- scan_hits, max_num_scan_hits, &text_rest));
+ grn_dat_scan(&ctx, dat, text, text_size,
+ scan_hits, max_num_scan_hits, &text_rest));
cppcut_assert_equal(text + text_size, text_rest);
cppcut_assert_equal(static_cast<grn_id>(1), scan_hits[0].id);
cppcut_assert_equal(0U, scan_hits[0].offset);
@@ -531,18 +548,17 @@ namespace test_dat
cppcut_assert_equal(12U, scan_hits[1].length);
cppcut_assert_equal(1,
- grn_dat_scan(&ctx, dat, text, text_size,
- scan_hits, 1, &text_rest));
+ grn_dat_scan(&ctx, dat, text, text_size, scan_hits, 1, &text_rest));
cppcut_assert_equal(static_cast<std::ptrdiff_t>(9), text_rest - text);
cppcut_assert_equal(1,
- grn_dat_scan(&ctx, dat, text_rest, text_size - (text_rest - text),
- scan_hits, 1, &text_rest));
+ grn_dat_scan(&ctx, dat, text_rest, text_size - (text_rest - text),
+ scan_hits, 1, &text_rest));
cppcut_assert_equal(static_cast<std::ptrdiff_t>(33), text_rest - text);
cppcut_assert_equal(0,
- grn_dat_scan(&ctx, dat, text_rest, text_size - (text_rest - text),
- scan_hits, 1, &text_rest));
+ grn_dat_scan(&ctx, dat, text_rest, text_size - (text_rest - text),
+ scan_hits, 1, &text_rest));
- cppcut_assert_equal(GRN_SUCCESS, grn_dat_close(&ctx, dat));
+ grn_test_assert_equal_rc(GRN_SUCCESS, grn_dat_close(&ctx, dat));
}
{
@@ -555,12 +571,13 @@ namespace test_dat
const char * const ptr = keys[i].c_str();
const uint32_t length = static_cast<uint32_t>(keys[i].length());
grn_dat_scan_hit scan_hits[2];
- cppcut_assert_equal(1, grn_dat_scan(&ctx, dat, ptr, length, scan_hits, 2, NULL));
+ cppcut_assert_equal(1,
+ grn_dat_scan(&ctx, dat, ptr, length, scan_hits, 2, NULL));
cppcut_assert_equal(key_id, scan_hits[0].id);
cppcut_assert_equal(0U, scan_hits[0].offset);
cppcut_assert_equal(length, scan_hits[0].length);
}
- cppcut_assert_equal(GRN_SUCCESS, grn_dat_close(&ctx, dat));
+ grn_test_assert_equal_rc(GRN_SUCCESS, grn_dat_close(&ctx, dat));
}
}
@@ -600,9 +617,10 @@ namespace test_dat
const grn_id key_id = static_cast<grn_id>(i + 1);
const char * const ptr = keys[i].c_str();
const uint32_t length = static_cast<uint32_t>(keys[i].length());
- cppcut_assert_equal(key_id, grn_dat_lcp_search(&ctx, dat, ptr, length));
+ cppcut_assert_equal(key_id,
+ grn_dat_lcp_search(&ctx, dat, ptr, length));
}
- cppcut_assert_equal(GRN_SUCCESS, grn_dat_close(&ctx, dat));
+ grn_test_assert_equal_rc(GRN_SUCCESS, grn_dat_close(&ctx, dat));
}
}
@@ -612,13 +630,15 @@ namespace test_dat
create_keys(&keys, 1000, 6, 15);
grn_dat * const dat = create_trie(keys, NULL);
- cppcut_assert_equal(static_cast<unsigned int>(keys.size()), grn_dat_size(&ctx, dat));
- cppcut_assert_equal(GRN_SUCCESS, grn_dat_close(&ctx, dat));
+ cppcut_assert_equal(static_cast<unsigned int>(keys.size()),
+ grn_dat_size(&ctx, dat));
+ grn_test_assert_equal_rc(GRN_SUCCESS, grn_dat_close(&ctx, dat));
}
void test_curr_id(void)
{
- grn_dat * const dat = grn_dat_create(&ctx, NULL, 0, 0, GRN_OBJ_KEY_VAR_SIZE);
+ grn_dat * const dat =
+ grn_dat_create(&ctx, NULL, 0, 0, GRN_OBJ_KEY_VAR_SIZE);
cppcut_assert_not_null(dat);
grn_id max_key_id = 0;
@@ -627,12 +647,14 @@ namespace test_dat
cppcut_assert_equal(max_key_id, grn_dat_curr_id(&ctx, dat));
create_key(&key, 1, 3);
int added;
- const grn_id key_id = grn_dat_add(&ctx, dat, key.c_str(), key.length(), NULL, &added);
+ const grn_id key_id =
+ grn_dat_add(&ctx, dat, key.c_str(), key.length(), NULL, &added);
if (added) {
- cppcut_assert_equal(++max_key_id, key_id);
+ ++max_key_id;
+ cppcut_assert_equal(max_key_id, key_id);
}
}
- cppcut_assert_equal(GRN_SUCCESS, grn_dat_close(&ctx, dat));
+ grn_test_assert_equal_rc(GRN_SUCCESS, grn_dat_close(&ctx, dat));
}
void test_truncate(void)
@@ -644,7 +666,7 @@ namespace test_dat
create_keys(&keys, 1000, 6, 15);
grn_dat * const dat = create_trie(keys, dat_path);
- cppcut_assert_equal(GRN_SUCCESS, grn_dat_truncate(&ctx, dat));
+ grn_test_assert_equal_rc(GRN_SUCCESS, grn_dat_truncate(&ctx, dat));
cppcut_assert_equal(static_cast<unsigned int>(0), grn_dat_size(&ctx, dat));
cppcut_assert_equal(static_cast<grn_id>(0), grn_dat_curr_id(&ctx, dat));
for (std::size_t i = 0; i < keys.size(); ++i) {
@@ -653,7 +675,7 @@ namespace test_dat
cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL),
grn_dat_get(&ctx, dat, ptr, length, NULL));
}
- cppcut_assert_equal(GRN_SUCCESS, grn_dat_close(&ctx, dat));
+ grn_test_assert_equal_rc(GRN_SUCCESS, grn_dat_close(&ctx, dat));
}
void test_key(void)
@@ -666,13 +688,14 @@ namespace test_dat
const grn_id key_id = static_cast<grn_id>(i + 1);
const uint32_t length = static_cast<uint32_t>(keys[i].length());
uint32_t key_length;
- const char * const key_ptr = _grn_dat_key(&ctx, dat, key_id, &key_length);
+ const char * const key_ptr =
+ _grn_dat_key(&ctx, dat, key_id, &key_length);
cppcut_assert_not_null(key_ptr);
cppcut_assert_equal(length, key_length);
cppcut_assert_equal(keys[i], std::string(key_ptr, key_length));
}
cppcut_assert_null(_grn_dat_key(&ctx, dat, GRN_ID_NIL, NULL));
- cppcut_assert_equal(GRN_SUCCESS, grn_dat_close(&ctx, dat));
+ grn_test_assert_equal_rc(GRN_SUCCESS, grn_dat_close(&ctx, dat));
}
void test_next(void)
@@ -683,8 +706,8 @@ namespace test_dat
grn_dat * const dat = create_trie(keys, NULL);
for (std::size_t i = 0; i < keys.size(); i += 2) {
const grn_id key_id = static_cast<grn_id>(i + 1);
- cppcut_assert_equal(GRN_SUCCESS,
- grn_dat_delete_by_id(&ctx, dat, key_id, NULL));
+ grn_test_assert_equal_rc(GRN_SUCCESS,
+ grn_dat_delete_by_id(&ctx, dat, key_id, NULL));
}
for (std::size_t i = 0; i < (keys.size() - 1); ++i) {
const grn_id key_id = static_cast<grn_id>(i + 1);
@@ -696,7 +719,7 @@ namespace test_dat
}
cppcut_assert_equal(static_cast<grn_id>(GRN_ID_NIL),
grn_dat_next(&ctx, dat, keys.size()));
- cppcut_assert_equal(GRN_SUCCESS, grn_dat_close(&ctx, dat));
+ grn_test_assert_equal_rc(GRN_SUCCESS, grn_dat_close(&ctx, dat));
}
void test_at(void)
@@ -707,8 +730,8 @@ namespace test_dat
grn_dat * const dat = create_trie(keys, NULL);
for (std::size_t i = 0; i < keys.size(); i += 2) {
const grn_id key_id = static_cast<grn_id>(i + 1);
- cppcut_assert_equal(GRN_SUCCESS,
- grn_dat_delete_by_id(&ctx, dat, key_id, NULL));
+ grn_test_assert_equal_rc(GRN_SUCCESS,
+ grn_dat_delete_by_id(&ctx, dat, key_id, NULL));
}
for (std::size_t i = 0; i < keys.size(); ++i) {
const grn_id key_id = static_cast<grn_id>(i + 1);
@@ -719,7 +742,7 @@ namespace test_dat
cppcut_assert_equal(key_id, grn_dat_at(&ctx, dat, key_id));
}
}
- cppcut_assert_equal(GRN_SUCCESS, grn_dat_close(&ctx, dat));
+ grn_test_assert_equal_rc(GRN_SUCCESS, grn_dat_close(&ctx, dat));
}
void test_repair(void)
@@ -732,7 +755,7 @@ namespace test_dat
grn_dat * const dat = create_trie(keys, dat_path);
- cppcut_assert_equal(GRN_SUCCESS, grn_dat_repair(&ctx, dat));
+ grn_test_assert_equal_rc(GRN_SUCCESS, grn_dat_repair(&ctx, dat));
cppcut_assert_equal(static_cast<unsigned int>(keys.size()),
grn_dat_size(&ctx, dat));
cppcut_assert_equal(static_cast<grn_id>(keys.size()),
@@ -746,10 +769,10 @@ namespace test_dat
}
for (std::size_t i = 0; i < keys.size(); i += 2) {
- cppcut_assert_equal(GRN_SUCCESS,
- grn_dat_delete_by_id(&ctx, dat, i + 1, NULL));
+ grn_test_assert_equal_rc(GRN_SUCCESS,
+ grn_dat_delete_by_id(&ctx, dat, i + 1, NULL));
}
- cppcut_assert_equal(GRN_SUCCESS, grn_dat_repair(&ctx, dat));
+ grn_test_assert_equal_rc(GRN_SUCCESS, grn_dat_repair(&ctx, dat));
cppcut_assert_equal(static_cast<unsigned int>(keys.size() / 2),
grn_dat_size(&ctx, dat));
@@ -761,7 +784,7 @@ namespace test_dat
grn_dat_add(&ctx, dat, ptr, length, NULL, &added));
cppcut_assert_equal(1, added);
}
- cppcut_assert_equal(GRN_SUCCESS, grn_dat_repair(&ctx, dat));
+ grn_test_assert_equal_rc(GRN_SUCCESS, grn_dat_repair(&ctx, dat));
cppcut_assert_equal(static_cast<unsigned int>(keys.size()),
grn_dat_size(&ctx, dat));
@@ -772,6 +795,6 @@ namespace test_dat
grn_dat_get(&ctx, dat, ptr, length, NULL));
}
- cppcut_assert_equal(GRN_SUCCESS, grn_dat_close(&ctx, dat));
+ grn_test_assert_equal_rc(GRN_SUCCESS, grn_dat_close(&ctx, dat));
}
}
Modified: test/unit/core/dat/test-file.cpp (+3 -2)
===================================================================
--- test/unit/core/dat/test-file.cpp 2012-02-01 10:57:14 +0900 (667e50d)
+++ test/unit/core/dat/test-file.cpp 2012-02-01 13:08:03 +0900 (92868ef)
@@ -1,6 +1,6 @@
/* -*- c-basic-offset: 2; coding: utf-8 -*- */
/*
- Copyright (C) 2011 Brazil
+ Copyright (C) 2011-2012 Brazil
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
@@ -120,7 +120,8 @@ namespace test_dat_file
file.open(path);
cppcut_assert_not_null(file.ptr());
cppcut_assert_equal(grn::dat::UInt64(32), file.size());
- cppcut_assert_equal(0, std::strcmp(static_cast<char *>(file.ptr()), "This is a pen."));
+ cppcut_assert_equal(0, std::strcmp(static_cast<char *>(file.ptr()),
+ "This is a pen."));
}
void test_swap(void)
Modified: test/unit/core/dat/test-id-cursor.cpp (+25 -13)
===================================================================
--- test/unit/core/dat/test-id-cursor.cpp 2012-02-01 10:57:14 +0900 (7c4fb2a)
+++ test/unit/core/dat/test-id-cursor.cpp 2012-02-01 13:08:03 +0900 (3636fcb)
@@ -1,6 +1,6 @@
/* -*- c-basic-offset: 2; coding: utf-8 -*- */
/*
- Copyright (C) 2011 Brazil
+ Copyright (C) 2011-2012 Brazil
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
@@ -64,7 +64,8 @@ namespace test_dat_id_cursor
create_trie(&trie);
grn::dat::UInt32 key_pos;
- cppcut_assert_equal(true, trie.search("スダチ", std::strlen("スダチ"), &key_pos));
+ cppcut_assert_equal(true,
+ trie.search("スダチ", std::strlen("スダチ"), &key_pos));
const grn::dat::UInt32 min_key_id = trie.get_key(key_pos).id();
grn::dat::IdCursor cursor;
@@ -83,7 +84,8 @@ namespace test_dat_id_cursor
create_trie(&trie);
grn::dat::UInt32 key_pos;
- cppcut_assert_equal(true, trie.search("オレンジ", std::strlen("オレンジ"), &key_pos));
+ cppcut_assert_equal(true,
+ trie.search("オレンジ", std::strlen("オレンジ"), &key_pos));
const grn::dat::UInt32 max_key_id = trie.get_key(key_pos).id();
grn::dat::IdCursor cursor;
@@ -102,9 +104,11 @@ namespace test_dat_id_cursor
create_trie(&trie);
grn::dat::UInt32 key_pos;
- cppcut_assert_equal(true, trie.search("みかん", std::strlen("みかん"), &key_pos));
+ cppcut_assert_equal(true,
+ trie.search("みかん", std::strlen("みかん"), &key_pos));
const grn::dat::UInt32 min_key_id = trie.get_key(key_pos).id();
- cppcut_assert_equal(true, trie.search("八朔", std::strlen("八朔"), &key_pos));
+ cppcut_assert_equal(true,
+ trie.search("八朔", std::strlen("八朔"), &key_pos));
const grn::dat::UInt32 max_key_id = trie.get_key(key_pos).id();
grn::dat::IdCursor cursor;
@@ -138,7 +142,8 @@ namespace test_dat_id_cursor
create_trie(&trie);
grn::dat::UInt32 key_pos;
- cppcut_assert_equal(true, trie.search("伊予柑", std::strlen("伊予柑"), &key_pos));
+ cppcut_assert_equal(true,
+ trie.search("伊予柑", std::strlen("伊予柑"), &key_pos));
const grn::dat::UInt32 min_key_id = trie.get_key(key_pos).id();
grn::dat::IdCursor cursor;
@@ -157,7 +162,8 @@ namespace test_dat_id_cursor
create_trie(&trie);
grn::dat::UInt32 key_pos;
- cppcut_assert_equal(true, trie.search("柚子", std::strlen("柚子"), &key_pos));
+ cppcut_assert_equal(true,
+ trie.search("柚子", std::strlen("柚子"), &key_pos));
const grn::dat::UInt32 max_key_id = trie.get_key(key_pos).id();
grn::dat::IdCursor cursor;
@@ -176,9 +182,11 @@ namespace test_dat_id_cursor
create_trie(&trie);
grn::dat::UInt32 key_pos;
- cppcut_assert_equal(true, trie.search("グレープフルーツ", std::strlen("グレープフルーツ"), &key_pos));
+ cppcut_assert_equal(true,
+ trie.search("グレープフルーツ", std::strlen("グレープフルーツ"), &key_pos));
const grn::dat::UInt32 min_key_id = trie.get_key(key_pos).id();
- cppcut_assert_equal(true, trie.search("文旦", std::strlen("文旦"), &key_pos));
+ cppcut_assert_equal(true,
+ trie.search("文旦", std::strlen("文旦"), &key_pos));
const grn::dat::UInt32 max_key_id = trie.get_key(key_pos).id();
grn::dat::IdCursor cursor;
@@ -207,7 +215,8 @@ namespace test_dat_id_cursor
cppcut_assert_equal(false, cursor.next().is_valid());
cursor.open(trie, grn::dat::INVALID_KEY_ID, grn::dat::INVALID_KEY_ID, 5);
- for (grn::dat::UInt32 i = trie.min_key_id() + 5; i <= trie.max_key_id(); ++i) {
+ for (grn::dat::UInt32 i = trie.min_key_id() + 5;
+ i <= trie.max_key_id(); ++i) {
const grn::dat::Key &key = cursor.next();
cppcut_assert_equal(true, key.is_valid());
cppcut_assert_equal(i, key.id());
@@ -241,8 +250,10 @@ namespace test_dat_id_cursor
}
cppcut_assert_equal(false, cursor.next().is_valid());
- cursor.open(trie, grn::dat::INVALID_KEY_ID, grn::dat::INVALID_KEY_ID, 0, 3);
- for (grn::dat::UInt32 i = trie.min_key_id(); i < (trie.min_key_id() + 3); ++i) {
+ cursor.open(trie, grn::dat::INVALID_KEY_ID,
+ grn::dat::INVALID_KEY_ID, 0, 3);
+ for (grn::dat::UInt32 i = trie.min_key_id();
+ i < (trie.min_key_id() + 3); ++i) {
const grn::dat::Key &key = cursor.next();
cppcut_assert_equal(true, key.is_valid());
cppcut_assert_equal(i, key.id());
@@ -349,7 +360,8 @@ namespace test_dat_id_cursor
cursor.open(trie, trie.min_key_id(), trie.max_key_id(),
0, grn::dat::UINT32_MAX,
grn::dat::EXCEPT_LOWER_BOUND | grn::dat::EXCEPT_UPPER_BOUND);
- for (grn::dat::UInt32 i = trie.min_key_id() + 1; i <= (trie.max_key_id() - 1); ++i) {
+ for (grn::dat::UInt32 i = trie.min_key_id() + 1;
+ i <= (trie.max_key_id() - 1); ++i) {
const grn::dat::Key &key = cursor.next();
cppcut_assert_equal(true, key.is_valid());
cppcut_assert_equal(i, key.id());
Modified: test/unit/core/dat/test-key-cursor.cpp (+14 -11)
===================================================================
--- test/unit/core/dat/test-key-cursor.cpp 2012-02-01 10:57:14 +0900 (33ee367)
+++ test/unit/core/dat/test-key-cursor.cpp 2012-02-01 13:08:03 +0900 (8f1fd85)
@@ -1,6 +1,6 @@
/* -*- c-basic-offset: 2; coding: utf-8 -*- */
/*
- Copyright (C) 2011 Brazil
+ Copyright (C) 2011-2012 Brazil
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
@@ -30,13 +30,13 @@ namespace
void create_trie(grn::dat::Trie *trie)
{
trie->create();
- trie->insert("Werdna", std::strlen("Werdna")); // ID: 1, 7th
- trie->insert("Trebor", std::strlen("Trebor")); // ID: 2, 6th
- trie->insert("Human", std::strlen("Human")); // ID: 3, 5th
- trie->insert("Elf", std::strlen("Elf")); // ID: 4, 2nd
- trie->insert("Dwarf", std::strlen("Dward")); // ID: 5, 1st
- trie->insert("Gnome", std::strlen("Gnome")); // ID: 6, 3rd
- trie->insert("Hobbit", std::strlen("Hobbit")); // ID: 7, 4th
+ trie->insert("Werdna", std::strlen("Werdna")); // 7th
+ trie->insert("Trebor", std::strlen("Trebor")); // 6th
+ trie->insert("Human", std::strlen("Human")); // 5th
+ trie->insert("Elf", std::strlen("Elf")); // 2nd
+ trie->insert("Dwarf", std::strlen("Dward")); // 1st
+ trie->insert("Gnome", std::strlen("Gnome")); // 3rd
+ trie->insert("Hobbit", std::strlen("Hobbit")); // 4th
}
}
@@ -124,7 +124,8 @@ namespace test_dat_key_cursor
grn::dat::KeyCursor cursor;
- cursor.open(trie, grn::dat::String("Hobbit"), grn::dat::String("Trebor"), 0);
+ cursor.open(trie, grn::dat::String("Hobbit"),
+ grn::dat::String("Trebor"), 0);
cppcut_assert_equal(grn::dat::UInt32(7), cursor.next().id());
cppcut_assert_equal(grn::dat::UInt32(3), cursor.next().id());
cppcut_assert_equal(grn::dat::UInt32(2), cursor.next().id());
@@ -135,12 +136,14 @@ namespace test_dat_key_cursor
cppcut_assert_equal(grn::dat::UInt32(1), cursor.next().id());
cppcut_assert_equal(false, cursor.next().is_valid());
- cursor.open(trie, grn::dat::String("Gnome"), grn::dat::String("Trebor"), 2);
+ cursor.open(trie, grn::dat::String("Gnome"),
+ grn::dat::String("Trebor"), 2);
cppcut_assert_equal(grn::dat::UInt32(3), cursor.next().id());
cppcut_assert_equal(grn::dat::UInt32(2), cursor.next().id());
cppcut_assert_equal(false, cursor.next().is_valid());
- cursor.open(trie, grn::dat::String("Gnome"), grn::dat::String("Trebor"), 100);
+ cursor.open(trie, grn::dat::String("Gnome"),
+ grn::dat::String("Trebor"), 100);
cppcut_assert_equal(false, cursor.next().is_valid());
}
Modified: test/unit/core/dat/test-key.cpp (+3 -3)
===================================================================
--- test/unit/core/dat/test-key.cpp 2012-02-01 10:57:14 +0900 (a5da561)
+++ test/unit/core/dat/test-key.cpp 2012-02-01 13:08:03 +0900 (d9cf6c8)
@@ -1,6 +1,6 @@
/* -*- c-basic-offset: 2; coding: utf-8 -*- */
/*
- Copyright (C) 2011 Brazil
+ Copyright (C) 2011-2012 Brazil
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
@@ -56,7 +56,7 @@ namespace test_dat_key
cppcut_assert_equal(grn::dat::UInt32(123), key.id());
cppcut_assert_equal(grn::dat::UInt32(7), key.length());
cppcut_assert_equal(0, std::memcmp(key.ptr(), "groonga", 7));
- cppcut_assert_equal(static_cast<const void *>(reinterpret_cast<char *>(buf) + 5),
- key.ptr());
+ cppcut_assert_equal(reinterpret_cast<const char *>(buf) + 5,
+ static_cast<const char *>(key.ptr()));
}
}
Modified: test/unit/core/dat/test-predictive-cursor.cpp (+11 -11)
===================================================================
--- test/unit/core/dat/test-predictive-cursor.cpp 2012-02-01 10:57:14 +0900 (79aeca0)
+++ test/unit/core/dat/test-predictive-cursor.cpp 2012-02-01 13:08:03 +0900 (8aceee2)
@@ -1,6 +1,6 @@
/* -*- c-basic-offset: 2; coding: utf-8 -*- */
/*
- Copyright (C) 2011 Brazil
+ Copyright (C) 2011-2012 Brazil
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
@@ -30,12 +30,12 @@ namespace
void create_trie(grn::dat::Trie *trie)
{
trie->create();
- trie->insert("北斗", std::strlen("北斗")); // ID: 1, 2nd
- trie->insert("北斗神拳", std::strlen("北斗神拳")); // ID: 2, 3rd
- trie->insert("北斗神拳伝承者", std::strlen("北斗神拳伝承者")); // ID: 3, 4th
- trie->insert("南斗聖拳", std::strlen("南斗聖拳")); // ID: 4, 6th
- trie->insert("南斗孤鷲拳", std::strlen("南斗孤鷲拳")); // ID: 5, 5th
- trie->insert("元斗皇拳", std::strlen("元斗皇拳")); // ID: 6, 1st
+ trie->insert("北斗", std::strlen("北斗")); // 2nd
+ trie->insert("北斗神拳", std::strlen("北斗神拳")); // 3rd
+ trie->insert("北斗神拳伝承者", std::strlen("北斗神拳伝承者")); // 4th
+ trie->insert("南斗聖拳", std::strlen("南斗聖拳")); // 6th
+ trie->insert("南斗孤鷲拳", std::strlen("南斗孤鷲拳")); // 5th
+ trie->insert("元斗皇拳", std::strlen("元斗皇拳")); // 1st
}
}
@@ -308,13 +308,13 @@ namespace test_dat_predictive_cursor
cppcut_assert_equal(grn::dat::UInt32(3), cursor.next().id());
cppcut_assert_equal(false, cursor.next().is_valid());
- cursor.open(trie, grn::dat::String("北斗神拳伝承"), 0, grn::dat::UINT32_MAX,
- grn::dat::EXCEPT_EXACT_MATCH);
+ cursor.open(trie, grn::dat::String("北斗神拳伝承"), 0,
+ grn::dat::UINT32_MAX, grn::dat::EXCEPT_EXACT_MATCH);
cppcut_assert_equal(grn::dat::UInt32(3), cursor.next().id());
cppcut_assert_equal(false, cursor.next().is_valid());
- cursor.open(trie, grn::dat::String("北斗神拳伝承者"), 0, grn::dat::UINT32_MAX,
- grn::dat::EXCEPT_EXACT_MATCH);
+ cursor.open(trie, grn::dat::String("北斗神拳伝承者"), 0,
+ grn::dat::UINT32_MAX, grn::dat::EXCEPT_EXACT_MATCH);
cppcut_assert_equal(false, cursor.next().is_valid());
cursor.open(trie, grn::dat::String("北斗"), 1, grn::dat::UINT32_MAX,
Modified: test/unit/core/dat/test-prefix-cursor.cpp (+12 -9)
===================================================================
--- test/unit/core/dat/test-prefix-cursor.cpp 2012-02-01 10:57:14 +0900 (d87273b)
+++ test/unit/core/dat/test-prefix-cursor.cpp 2012-02-01 13:08:03 +0900 (31403d0)
@@ -1,6 +1,6 @@
/* -*- c-basic-offset: 2; coding: utf-8 -*- */
/*
- Copyright (C) 2011 Brazil
+ Copyright (C) 2011-2012 Brazil
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
@@ -30,11 +30,11 @@ namespace
void create_trie(grn::dat::Trie *trie)
{
trie->create();
- trie->insert("東京", std::strlen("東京")); // ID: 1, 3rd
- trie->insert("京都", std::strlen("京都")); // ID: 2, 1st
- trie->insert("東京都", std::strlen("東京都")); // ID: 3, 4th
- trie->insert("京都府", std::strlen("京都府")); // ID: 4, 2nd
- trie->insert("東京都庁", std::strlen("東京都庁")); // ID: 5, 5th
+ trie->insert("東京", std::strlen("東京")); // 3rd
+ trie->insert("京都", std::strlen("京都")); // 1st
+ trie->insert("東京都", std::strlen("東京都")); // 4th
+ trie->insert("京都府", std::strlen("京都府")); // 2nd
+ trie->insert("東京都庁", std::strlen("東京都庁")); // 5th
}
}
@@ -117,11 +117,13 @@ namespace test_dat_prefix_cursor
cppcut_assert_equal(grn::dat::UInt32(5), cursor.next().id());
cppcut_assert_equal(false, cursor.next().is_valid());
- cursor.open(trie, grn::dat::String("東京都庁ビル"), std::strlen("東京都庁"));
+ cursor.open(trie, grn::dat::String("東京都庁ビル"),
+ std::strlen("東京都庁"));
cppcut_assert_equal(grn::dat::UInt32(5), cursor.next().id());
cppcut_assert_equal(false, cursor.next().is_valid());
- cursor.open(trie, grn::dat::String("東京都庁ビル"), std::strlen("東京都庁ビル"));
+ cursor.open(trie, grn::dat::String("東京都庁ビル"),
+ std::strlen("東京都庁ビル"));
cppcut_assert_equal(false, cursor.next().is_valid());
}
@@ -158,7 +160,8 @@ namespace test_dat_prefix_cursor
grn::dat::PrefixCursor cursor;
- cursor.open(trie, grn::dat::String("東京都庁ビル"), 0, 0, grn::dat::UINT32_MAX);
+ cursor.open(trie, grn::dat::String("東京都庁ビル"), 0, 0,
+ grn::dat::UINT32_MAX);
cppcut_assert_equal(grn::dat::UInt32(1), cursor.next().id());
cppcut_assert_equal(grn::dat::UInt32(3), cursor.next().id());
cppcut_assert_equal(grn::dat::UInt32(5), cursor.next().id());
Modified: test/unit/core/dat/test-trie.cpp (+79 -42)
===================================================================
--- test/unit/core/dat/test-trie.cpp 2012-02-01 10:57:14 +0900 (944f178)
+++ test/unit/core/dat/test-trie.cpp 2012-02-01 13:08:03 +0900 (9ffabea)
@@ -74,7 +74,8 @@ namespace
bool continue_flag;
};
- void create_key(std::string *key, std::size_t min_length, std::size_t max_length)
+ void create_key(std::string *key, std::size_t min_length,
+ std::size_t max_length)
{
key->resize(min_length + (std::rand() % (max_length - min_length + 1)));
for (std::size_t i = 0; i < key->size(); ++i) {
@@ -149,8 +150,10 @@ namespace test_dat_trie
trie.create();
for (std::size_t i = 0; i < keys.size(); ++i) {
- cppcut_assert_equal(true, trie.insert(keys[i].c_str(), keys[i].length()));
- cppcut_assert_equal(true, trie.search(keys[i].c_str(), keys[i].length()));
+ cppcut_assert_equal(true,
+ trie.insert(keys[i].c_str(), keys[i].length()));
+ cppcut_assert_equal(true,
+ trie.search(keys[i].c_str(), keys[i].length()));
}
}
@@ -167,16 +170,20 @@ namespace test_dat_trie
trie.create(trie_path);
for (std::size_t i = 0; i < keys.size(); ++i) {
- cppcut_assert_equal(true, trie.insert(keys[i].c_str(), keys[i].length()));
- cppcut_assert_equal(true, trie.search(keys[i].c_str(), keys[i].length()));
+ cppcut_assert_equal(true,
+ trie.insert(keys[i].c_str(), keys[i].length()));
+ cppcut_assert_equal(true,
+ trie.search(keys[i].c_str(), keys[i].length()));
}
grn::dat::Trie new_trie;
new_trie.open(trie_path);
for (std::size_t i = 0; i < keys.size(); ++i) {
- cppcut_assert_equal(false, new_trie.insert(keys[i].c_str(), keys[i].length()));
- cppcut_assert_equal(true, new_trie.search(keys[i].c_str(), keys[i].length()));
+ cppcut_assert_equal(false,
+ new_trie.insert(keys[i].c_str(), keys[i].length()));
+ cppcut_assert_equal(true,
+ new_trie.search(keys[i].c_str(), keys[i].length()));
}
}
@@ -192,21 +199,24 @@ namespace test_dat_trie
for (std::size_t i = 0; i < keys.size(); ++i) {
grn::dat::UInt32 key_pos;
cppcut_assert_equal(true,
- trie.insert(keys[i].c_str(), keys[i].length(), &key_pos));
+ trie.insert(keys[i].c_str(), keys[i].length(), &key_pos));
const grn::dat::Key &key = trie.get_key(key_pos);
cppcut_assert_equal(true, key.is_valid());
cppcut_assert_equal(static_cast<grn::dat::UInt32>(i + 1), key.id());
- cppcut_assert_equal(static_cast<grn::dat::UInt32>(keys[i].length()), key.length());
- cppcut_assert_equal(0, std::memcmp(key.ptr(), keys[i].c_str(), key.length()));
+ cppcut_assert_equal(static_cast<grn::dat::UInt32>(keys[i].length()),
+ key.length());
+ cppcut_assert_equal(0,
+ std::memcmp(key.ptr(), keys[i].c_str(), key.length()));
grn::dat::UInt32 key_pos_again;
cppcut_assert_equal(false,
- trie.insert(keys[i].c_str(), keys[i].length(), &key_pos_again));
+ trie.insert(keys[i].c_str(), keys[i].length(), &key_pos_again));
cppcut_assert_equal(key_pos, key_pos_again);
total_key_length += keys[i].length();
- cppcut_assert_equal(total_key_length, static_cast<std::size_t>(trie.total_key_length()));
+ cppcut_assert_equal(total_key_length,
+ static_cast<std::size_t>(trie.total_key_length()));
}
}
@@ -222,7 +232,8 @@ namespace test_dat_trie
cppcut_assert_equal(false, trie.ith_key(i + 1).is_valid());
grn::dat::UInt32 key_pos;
- cppcut_assert_equal(true, trie.insert(keys[i].c_str(), keys[i].length(), &key_pos));
+ cppcut_assert_equal(true,
+ trie.insert(keys[i].c_str(), keys[i].length(), &key_pos));
const grn::dat::Key &key_by_pos = trie.get_key(key_pos);
const grn::dat::Key &key_by_id = trie.ith_key(i + 1);
@@ -239,15 +250,16 @@ namespace test_dat_trie
trie.create();
for (std::size_t i = 0; i < keys.size(); ++i) {
- cppcut_assert_equal(false, trie.search(keys[i].c_str(), keys[i].length()));
+ cppcut_assert_equal(false,
+ trie.search(keys[i].c_str(), keys[i].length()));
grn::dat::UInt32 key_pos_inserted;
cppcut_assert_equal(true,
- trie.insert(keys[i].c_str(), keys[i].length(), &key_pos_inserted));
+ trie.insert(keys[i].c_str(), keys[i].length(), &key_pos_inserted));
grn::dat::UInt32 key_pos_found;
cppcut_assert_equal(true,
- trie.search(keys[i].c_str(), keys[i].length(), &key_pos_found));
+ trie.search(keys[i].c_str(), keys[i].length(), &key_pos_found));
cppcut_assert_equal(key_pos_inserted, key_pos_found);
}
}
@@ -312,7 +324,8 @@ namespace test_dat_trie
std::size_t total_key_length = 0;
for (std::size_t i = 0; i < keys.size(); ++i) {
- cppcut_assert_equal(true, trie.insert(keys[i].c_str(), keys[i].length()));
+ cppcut_assert_equal(true,
+ trie.insert(keys[i].c_str(), keys[i].length()));
total_key_length += keys[i].length();
}
for (std::size_t i = 0; i < keys.size(); ++i) {
@@ -320,7 +333,8 @@ namespace test_dat_trie
trie.num_keys());
cppcut_assert_equal(true, trie.remove(i + 1));
cppcut_assert_equal(false, trie.ith_key(i + 1).is_valid());
- cppcut_assert_equal(false, trie.search(keys[i].c_str(), keys[i].length()));
+ cppcut_assert_equal(false,
+ trie.search(keys[i].c_str(), keys[i].length()));
cppcut_assert_equal(false, trie.remove(i + 1));
total_key_length -= keys[i].length();
@@ -328,13 +342,17 @@ namespace test_dat_trie
}
for (std::size_t i = 0; i < keys.size(); ++i) {
- cppcut_assert_equal(true, trie.insert(keys[i].c_str(), keys[i].length()));
+ cppcut_assert_equal(true,
+ trie.insert(keys[i].c_str(), keys[i].length()));
}
for (std::size_t i = 0; i < keys.size(); ++i) {
- cppcut_assert_equal(true, trie.remove(keys[i].c_str(), keys[i].length()));
+ cppcut_assert_equal(true,
+ trie.remove(keys[i].c_str(), keys[i].length()));
cppcut_assert_equal(false, trie.ith_key(keys.size() - i).is_valid());
- cppcut_assert_equal(false, trie.search(keys[i].c_str(), keys[i].length()));
- cppcut_assert_equal(false, trie.remove(keys[i].c_str(), keys[i].length()));
+ cppcut_assert_equal(false,
+ trie.search(keys[i].c_str(), keys[i].length()));
+ cppcut_assert_equal(false,
+ trie.remove(keys[i].c_str(), keys[i].length()));
}
}
@@ -348,30 +366,38 @@ namespace test_dat_trie
std::size_t total_key_length = 0;
for (std::size_t i = 0; i < (keys.size() / 2); ++i) {
- cppcut_assert_equal(true, trie.insert(keys[i].c_str(), keys[i].length()));
+ cppcut_assert_equal(true,
+ trie.insert(keys[i].c_str(), keys[i].length()));
total_key_length += keys[i].length();
}
for (std::size_t i = (keys.size() / 2); i < keys.size(); ++i) {
const grn::dat::UInt32 key_id = i + 1 - (keys.size() / 2);
const std::string &src_key = keys[i - (keys.size() / 2)];
- cppcut_assert_equal(true, trie.update(key_id, keys[i].c_str(), keys[i].length()));
+ cppcut_assert_equal(true,
+ trie.update(key_id, keys[i].c_str(), keys[i].length()));
cppcut_assert_equal(true, trie.ith_key(key_id).is_valid());
- cppcut_assert_equal(true, trie.search(keys[i].c_str(), keys[i].length()));
- cppcut_assert_equal(false, trie.search(src_key.c_str(), src_key.length()));
+ cppcut_assert_equal(true,
+ trie.search(keys[i].c_str(), keys[i].length()));
+ cppcut_assert_equal(false,
+ trie.search(src_key.c_str(), src_key.length()));
total_key_length += keys[i].length() - src_key.length();
cppcut_assert_equal(total_key_length, static_cast<std::size_t>(trie.total_key_length()));
}
for (std::size_t i = 0; i < (keys.size() / 2); ++i) {
const std::string &src_key = keys[i + (keys.size() / 2)];
- cppcut_assert_equal(true, trie.update(src_key.c_str(), src_key.length(),
- keys[i].c_str(), keys[i].length()));
+ cppcut_assert_equal(true,
+ trie.update(src_key.c_str(), src_key.length(),
+ keys[i].c_str(), keys[i].length()));
cppcut_assert_equal(true, trie.ith_key(i + 1).is_valid());
- cppcut_assert_equal(true, trie.search(keys[i].c_str(), keys[i].length()));
- cppcut_assert_equal(false, trie.search(src_key.c_str(), src_key.length()));
+ cppcut_assert_equal(true,
+ trie.search(keys[i].c_str(), keys[i].length()));
+ cppcut_assert_equal(false,
+ trie.search(src_key.c_str(), src_key.length()));
total_key_length += keys[i].length() - src_key.length();
- cppcut_assert_equal(total_key_length, static_cast<std::size_t>(trie.total_key_length()));
+ cppcut_assert_equal(total_key_length,
+ static_cast<std::size_t>(trie.total_key_length()));
}
}
@@ -384,18 +410,21 @@ namespace test_dat_trie
src_trie.create();
for (std::size_t i = 0; i < keys.size(); ++i) {
- cppcut_assert_equal(true, src_trie.insert(keys[i].c_str(), keys[i].length()));
+ cppcut_assert_equal(true,
+ src_trie.insert(keys[i].c_str(), keys[i].length()));
}
grn::dat::Trie dest_trie;
dest_trie.create(src_trie);
for (std::size_t i = 0; i < keys.size(); ++i) {
- cppcut_assert_equal(true, dest_trie.search(keys[i].c_str(), keys[i].length()));
+ cppcut_assert_equal(true,
+ dest_trie.search(keys[i].c_str(), keys[i].length()));
}
cppcut_assert_equal(src_trie.file_size(), dest_trie.file_size());
- cppcut_assert_equal(src_trie.total_key_length(), dest_trie.total_key_length());
+ cppcut_assert_equal(src_trie.total_key_length(),
+ dest_trie.total_key_length());
cppcut_assert_equal(src_trie.min_key_id(), dest_trie.min_key_id());
cppcut_assert_equal(src_trie.next_key_id(), dest_trie.next_key_id());
cppcut_assert_equal(src_trie.max_key_id(), dest_trie.max_key_id());
@@ -425,7 +454,8 @@ namespace test_dat_trie
const Keyset::const_iterator it = keyset.find(str);
const bool to_be_found = (it != keyset.end());
grn::dat::UInt32 key_pos;
- const bool is_found = trie.search(str.c_str(), str.length(), &key_pos);
+ const bool is_found =
+ trie.search(str.c_str(), str.length(), &key_pos);
cppcut_assert_equal(to_be_found, is_found);
if (is_found) {
const grn::dat::Key &key = trie.get_key(key_pos);
@@ -485,10 +515,12 @@ namespace test_dat_trie
grn::dat::UInt32 key_pos;
bool is_updated = !to_be_updated;
try {
- is_updated = trie.update(key_id, str.c_str(), str.length(), &key_pos);
+ is_updated = trie.update(key_id, str.c_str(), str.length(),
+ &key_pos);
} catch (const grn::dat::SizeError &ex) {
trie.create(trie, NULL, trie.file_size() * 2);
- is_updated = trie.update(key_id, str.c_str(), str.length(), &key_pos);
+ is_updated = trie.update(key_id, str.c_str(), str.length(),
+ &key_pos);
}
cppcut_assert_equal(to_be_updated, is_updated);
if (is_updated) {
@@ -517,8 +549,10 @@ namespace test_dat_trie
grn::dat::UInt32 key_pos;
if (trie->search(str.c_str(), str.length(), &key_pos)) {
const grn::dat::Key &key = trie->get_key(key_pos);
- cppcut_assert_equal(str.length(), static_cast<std::size_t>(key.length()));
- cppcut_assert_equal(grn::dat::String(str.c_str(), str.length()), key.str());
+ cppcut_assert_equal(str.length(),
+ static_cast<std::size_t>(key.length()));
+ cppcut_assert_equal(grn::dat::String(str.c_str(), str.length()),
+ key.str());
}
} catch (...) {
cut_fail("sub_test_multi_threaded_random_queries() failed.");
@@ -555,7 +589,8 @@ namespace test_dat_trie
const Keyset::const_iterator it = keyset.find(str);
const bool to_be_found = (it != keyset.end());
grn::dat::UInt32 key_pos;
- const bool is_found = trie->search(str.c_str(), str.length(), &key_pos);
+ const bool is_found =
+ trie->search(str.c_str(), str.length(), &key_pos);
cppcut_assert_equal(to_be_found, is_found);
if (is_found) {
const grn::dat::Key &key = trie->get_key(key_pos);
@@ -616,11 +651,13 @@ namespace test_dat_trie
grn::dat::UInt32 key_pos;
bool is_updated = !to_be_updated;
try {
- is_updated = trie->update(key_id, str.c_str(), str.length(), &key_pos);
+ is_updated = trie->update(key_id, str.c_str(), str.length(),
+ &key_pos);
} catch (const grn::dat::SizeError &ex) {
(trie + 1)->create(*trie, NULL, trie->file_size() * 2);
context.trie = ++trie;
- is_updated = trie->update(key_id, str.c_str(), str.length(), &key_pos);
+ is_updated = trie->update(key_id, str.c_str(), str.length(),
+ &key_pos);
}
cppcut_assert_equal(to_be_updated, is_updated);
if (is_updated) {
Modified: test/unit/core/dat/test-vector.cpp (+3 -2)
===================================================================
--- test/unit/core/dat/test-vector.cpp 2012-02-01 10:57:14 +0900 (b8bb66b)
+++ test/unit/core/dat/test-vector.cpp 2012-02-01 13:08:03 +0900 (ee39728)
@@ -1,6 +1,6 @@
/* -*- c-basic-offset: 2; coding: utf-8 -*- */
/*
- Copyright (C) 2011 Brazil
+ Copyright (C) 2011-2012 Brazil
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
@@ -189,7 +189,8 @@ namespace test_dat_vector
}
for (grn::dat::UInt32 i = 0; i < vec.size(); ++i) {
cppcut_assert_equal(i, vec[i]);
- cppcut_assert_equal(i, const_cast<const grn::dat::Vector<grn::dat::UInt32> &>(vec)[i]);
+ cppcut_assert_equal(i,
+ const_cast<const grn::dat::Vector<grn::dat::UInt32> &>(vec)[i]);
cppcut_assert_equal(vec.begin() + i, &vec[i]);
cppcut_assert_equal(vec.end() - vec.size() + i, &vec[i]);
}