null+****@clear*****
null+****@clear*****
2011年 11月 11日 (金) 09:42:35 JST
Susumu Yata 2011-11-11 00:42:35 +0000 (Fri, 11 Nov 2011)
New Revision: 7982daa8c55cb11cf5864ea28ce6f810e73e8368
Log:
replace static_casts by constructors.
Modified files:
test/unit/core/dat/test-base.cpp
test/unit/core/dat/test-block.cpp
test/unit/core/dat/test-check.cpp
test/unit/core/dat/test-cursor-factory.cpp
test/unit/core/dat/test-entry.cpp
test/unit/core/dat/test-file.cpp
test/unit/core/dat/test-header.cpp
test/unit/core/dat/test-key.cpp
test/unit/core/dat/test-string.cpp
test/unit/core/dat/test-trie.cpp
test/unit/core/dat/test-vector.cpp
Modified: test/unit/core/dat/test-base.cpp (+3 -3)
===================================================================
--- test/unit/core/dat/test-base.cpp 2011-11-11 00:27:50 +0000 (84b8b4c)
+++ test/unit/core/dat/test-base.cpp 2011-11-11 00:42:35 +0000 (f08dfc2)
@@ -29,7 +29,7 @@ namespace test_dat_base
grn::dat::Base base;
cppcut_assert_equal(base.is_linker(), false);
- cppcut_assert_equal(base.offset(), static_cast<grn::dat::UInt32>(0));
+ cppcut_assert_equal(base.offset(), grn::dat::UInt32(0));
}
void test_linker(void)
@@ -38,7 +38,7 @@ namespace test_dat_base
base.set_key_pos(100);
cppcut_assert_equal(base.is_linker(), true);
- cppcut_assert_equal(base.key_pos(), static_cast<grn::dat::UInt32>(100));
+ cppcut_assert_equal(base.key_pos(), grn::dat::UInt32(100));
}
void test_nonlinker(void)
@@ -47,6 +47,6 @@ namespace test_dat_base
base.set_offset(1000);
cppcut_assert_equal(base.is_linker(), false);
- cppcut_assert_equal(base.offset(), static_cast<grn::dat::UInt32>(1000));
+ cppcut_assert_equal(base.offset(), grn::dat::UInt32(1000));
}
}
Modified: test/unit/core/dat/test-block.cpp (+10 -10)
===================================================================
--- test/unit/core/dat/test-block.cpp 2011-11-11 00:27:50 +0000 (a95ec99)
+++ test/unit/core/dat/test-block.cpp 2011-11-11 00:42:35 +0000 (ab5a51f)
@@ -28,12 +28,12 @@ namespace test_dat_block
{
const grn::dat::Block block;
- cppcut_assert_equal(block.next(), static_cast<grn::dat::UInt32>(0));
- cppcut_assert_equal(block.prev(), static_cast<grn::dat::UInt32>(0));
- cppcut_assert_equal(block.level(), static_cast<grn::dat::UInt32>(0));
- cppcut_assert_equal(block.failure_count(), static_cast<grn::dat::UInt32>(0));
- cppcut_assert_equal(block.first_phantom(), static_cast<grn::dat::UInt32>(0));
- cppcut_assert_equal(block.num_phantoms(), static_cast<grn::dat::UInt32>(0));
+ cppcut_assert_equal(block.next(), grn::dat::UInt32(0));
+ cppcut_assert_equal(block.prev(), grn::dat::UInt32(0));
+ cppcut_assert_equal(block.level(), grn::dat::UInt32(0));
+ cppcut_assert_equal(block.failure_count(), grn::dat::UInt32(0));
+ cppcut_assert_equal(block.first_phantom(), grn::dat::UInt32(0));
+ cppcut_assert_equal(block.num_phantoms(), grn::dat::UInt32(0));
}
void test_link_management(void)
@@ -42,8 +42,8 @@ namespace test_dat_block
block.set_next(101);
block.set_prev(99);
- cppcut_assert_equal(block.next(), static_cast<grn::dat::UInt32>(101));
- cppcut_assert_equal(block.prev(), static_cast<grn::dat::UInt32>(99));
+ cppcut_assert_equal(block.next(), grn::dat::UInt32(101));
+ cppcut_assert_equal(block.prev(), grn::dat::UInt32(99));
}
void test_level_management(void)
@@ -62,7 +62,7 @@ namespace test_dat_block
block.set_first_phantom(37);
block.set_num_phantoms(89);
- cppcut_assert_equal(block.first_phantom(), static_cast<grn::dat::UInt32>(37));
- cppcut_assert_equal(block.num_phantoms(), static_cast<grn::dat::UInt32>(89));
+ cppcut_assert_equal(block.first_phantom(), grn::dat::UInt32(37));
+ cppcut_assert_equal(block.num_phantoms(), grn::dat::UInt32(89));
}
}
Modified: test/unit/core/dat/test-check.cpp (+12 -12)
===================================================================
--- test/unit/core/dat/test-check.cpp 2011-11-11 00:27:50 +0000 (8145906)
+++ test/unit/core/dat/test-check.cpp 2011-11-11 00:42:35 +0000 (827a176)
@@ -29,11 +29,11 @@ namespace test_dat_check
const grn::dat::Check check;
cppcut_assert_equal(check.is_offset(), false);
- cppcut_assert_equal(check.except_is_offset(), static_cast<grn::dat::UInt32>(0));
+ cppcut_assert_equal(check.except_is_offset(), grn::dat::UInt32(0));
cppcut_assert_equal(check.is_phantom(), false);
- cppcut_assert_equal(check.label(), static_cast<grn::dat::UInt32>(0));
- cppcut_assert_equal(check.child(), static_cast<grn::dat::UInt32>(0));
- cppcut_assert_equal(check.sibling(), static_cast<grn::dat::UInt32>(0));
+ cppcut_assert_equal(check.label(), grn::dat::UInt32(0));
+ cppcut_assert_equal(check.child(), grn::dat::UInt32(0));
+ cppcut_assert_equal(check.sibling(), grn::dat::UInt32(0));
}
void test_phantomize(void)
@@ -42,13 +42,13 @@ namespace test_dat_check
check.set_is_phantom(true);
cppcut_assert_equal(check.is_phantom(), true);
- cppcut_assert_equal(check.next(), static_cast<grn::dat::UInt32>(0));
- cppcut_assert_equal(check.prev(), static_cast<grn::dat::UInt32>(0));
+ cppcut_assert_equal(check.next(), grn::dat::UInt32(0));
+ cppcut_assert_equal(check.prev(), grn::dat::UInt32(0));
check.set_next(101);
check.set_prev(99);
- cppcut_assert_equal(check.next(), static_cast<grn::dat::UInt32>(101));
- cppcut_assert_equal(check.prev(), static_cast<grn::dat::UInt32>(99));
+ cppcut_assert_equal(check.next(), grn::dat::UInt32(101));
+ cppcut_assert_equal(check.prev(), grn::dat::UInt32(99));
}
void test_unphantomize(void)
@@ -70,17 +70,17 @@ namespace test_dat_check
cppcut_assert_equal(check.is_offset(), true);
check.set_label('a');
- cppcut_assert_equal(check.label(), static_cast<grn::dat::UInt32>('a'));
+ cppcut_assert_equal(check.label(), grn::dat::UInt32('a'));
check.set_child('b');
- cppcut_assert_equal(check.child(), static_cast<grn::dat::UInt32>('b'));
+ cppcut_assert_equal(check.child(), grn::dat::UInt32('b'));
check.set_sibling('c');
- cppcut_assert_equal(check.sibling(), static_cast<grn::dat::UInt32>('c'));
+ cppcut_assert_equal(check.sibling(), grn::dat::UInt32('c'));
cppcut_assert_equal(check.is_offset(), true);
cppcut_assert_equal(check.except_is_offset(),
- 'a' | (static_cast<grn::dat::UInt32>('b' << 9)) | (static_cast<grn::dat::UInt32>('c' << 18)));
+ 'a' | grn::dat::UInt32('b' << 9) | grn::dat::UInt32('c' << 18));
cppcut_assert_equal(check.is_phantom(), false);
}
}
Modified: test/unit/core/dat/test-cursor-factory.cpp (+8 -8)
===================================================================
--- test/unit/core/dat/test-cursor-factory.cpp 2011-11-11 00:27:50 +0000 (a831dff)
+++ test/unit/core/dat/test-cursor-factory.cpp 2011-11-11 00:42:35 +0000 (9e16cb8)
@@ -50,8 +50,8 @@ namespace test_dat_cursor_factory
grn::dat::EXCEPT_UPPER_BOUND));
cut_assert(cursor.get() != static_cast<grn::dat::Cursor *>(NULL));
- cppcut_assert_equal(cursor->offset(), static_cast<grn::dat::UInt32>(1));
- cppcut_assert_equal(cursor->limit(), static_cast<grn::dat::UInt32>(2));
+ cppcut_assert_equal(cursor->offset(), grn::dat::UInt32(1));
+ cppcut_assert_equal(cursor->limit(), grn::dat::UInt32(2));
cppcut_assert_equal(cursor->flags(),
grn::dat::KEY_RANGE_CURSOR | grn::dat::ASCENDING_CURSOR |
grn::dat::EXCEPT_LOWER_BOUND | grn::dat::EXCEPT_UPPER_BOUND);
@@ -67,8 +67,8 @@ namespace test_dat_cursor_factory
grn::dat::ID_RANGE_CURSOR | grn::dat::ASCENDING_CURSOR));
cut_assert(cursor.get() != static_cast<grn::dat::Cursor *>(NULL));
- cppcut_assert_equal(cursor->offset(), static_cast<grn::dat::UInt32>(1));
- cppcut_assert_equal(cursor->limit(), static_cast<grn::dat::UInt32>(2));
+ cppcut_assert_equal(cursor->offset(), grn::dat::UInt32(1));
+ cppcut_assert_equal(cursor->limit(), grn::dat::UInt32(2));
cppcut_assert_equal(cursor->flags(),
grn::dat::ID_RANGE_CURSOR | grn::dat::ASCENDING_CURSOR);
}
@@ -83,8 +83,8 @@ namespace test_dat_cursor_factory
grn::dat::PREFIX_CURSOR | grn::dat::DESCENDING_CURSOR));
cut_assert(cursor.get() != static_cast<grn::dat::Cursor *>(NULL));
- cppcut_assert_equal(cursor->offset(), static_cast<grn::dat::UInt32>(0));
- cppcut_assert_equal(cursor->limit(), static_cast<grn::dat::UInt32>(1));
+ cppcut_assert_equal(cursor->offset(), grn::dat::UInt32(0));
+ cppcut_assert_equal(cursor->limit(), grn::dat::UInt32(1));
cppcut_assert_equal(cursor->flags(),
grn::dat::PREFIX_CURSOR | grn::dat::DESCENDING_CURSOR);
}
@@ -99,8 +99,8 @@ namespace test_dat_cursor_factory
grn::dat::PREDICTIVE_CURSOR | grn::dat::EXCEPT_EXACT_MATCH));
cut_assert(cursor.get() != static_cast<grn::dat::Cursor *>(NULL));
- cppcut_assert_equal(cursor->offset(), static_cast<grn::dat::UInt32>(1));
- cppcut_assert_equal(cursor->limit(), static_cast<grn::dat::UInt32>(2));
+ cppcut_assert_equal(cursor->offset(), grn::dat::UInt32(1));
+ cppcut_assert_equal(cursor->limit(), grn::dat::UInt32(2));
cppcut_assert_equal(cursor->flags(),
grn::dat::PREDICTIVE_CURSOR |
grn::dat::ASCENDING_CURSOR | grn::dat::EXCEPT_EXACT_MATCH);
Modified: test/unit/core/dat/test-entry.cpp (+3 -3)
===================================================================
--- test/unit/core/dat/test-entry.cpp 2011-11-11 00:27:50 +0000 (c33c125)
+++ test/unit/core/dat/test-entry.cpp 2011-11-11 00:42:35 +0000 (fc23391)
@@ -29,7 +29,7 @@ namespace test_dat_entry
const grn::dat::Entry entry;
cppcut_assert_equal(entry.is_valid(), false);
- cppcut_assert_equal(entry.next(), static_cast<grn::dat::UInt32>(0));
+ cppcut_assert_equal(entry.next(), grn::dat::UInt32(0));
}
void test_valid_entry(void)
@@ -38,7 +38,7 @@ namespace test_dat_entry
entry.set_key_pos(100);
cppcut_assert_equal(entry.is_valid(), true);
- cppcut_assert_equal(entry.key_pos(), static_cast<grn::dat::UInt32>(100));
+ cppcut_assert_equal(entry.key_pos(), grn::dat::UInt32(100));
}
void test_invalid_entry(void)
@@ -47,6 +47,6 @@ namespace test_dat_entry
entry.set_next(200);
cppcut_assert_equal(entry.is_valid(), false);
- cppcut_assert_equal(entry.next(), static_cast<grn::dat::UInt32>(200));
+ cppcut_assert_equal(entry.next(), grn::dat::UInt32(200));
}
}
Modified: test/unit/core/dat/test-file.cpp (+8 -8)
===================================================================
--- test/unit/core/dat/test-file.cpp 2011-11-11 00:27:50 +0000 (507e529)
+++ test/unit/core/dat/test-file.cpp 2011-11-11 00:42:35 +0000 (8f1c317)
@@ -47,7 +47,7 @@ namespace test_dat_file
const grn::dat::File file;
cppcut_assert_equal(file.ptr(), static_cast<void *>(NULL));
- cppcut_assert_equal(file.size(), static_cast<grn::dat::UInt64>(0));
+ cppcut_assert_equal(file.size(), grn::dat::UInt64(0));
}
void test_create_without_path(void)
@@ -62,7 +62,7 @@ namespace test_dat_file
file.create(NULL, 32);
cut_assert(file.ptr() != NULL);
- cppcut_assert_equal(file.size(), static_cast<grn::dat::UInt64>(32));
+ cppcut_assert_equal(file.size(), grn::dat::UInt64(32));
grn::dat::UInt8 * const buf = static_cast<grn::dat::UInt8 *>(file.ptr());
for (grn::dat::UInt64 i = 0; i < file.size(); ++i) {
@@ -87,7 +87,7 @@ namespace test_dat_file
file.create(path, 32);
cut_assert(file.ptr() != NULL);
- cppcut_assert_equal(file.size(), static_cast<grn::dat::UInt64>(32));
+ cppcut_assert_equal(file.size(), grn::dat::UInt64(32));
grn::dat::UInt8 * const buf = static_cast<grn::dat::UInt8 *>(file.ptr());
for (grn::dat::UInt64 i = 0; i < file.size(); ++i) {
@@ -115,11 +115,11 @@ namespace test_dat_file
file.close();
cppcut_assert_equal(file.ptr(), static_cast<void *>(NULL));
- cppcut_assert_equal(file.size(), static_cast<grn::dat::UInt64>(0));
+ cppcut_assert_equal(file.size(), grn::dat::UInt64(0));
file.open(path);
cut_assert(file.ptr() != NULL);
- cppcut_assert_equal(file.size(), static_cast<grn::dat::UInt64>(32));
+ cppcut_assert_equal(file.size(), grn::dat::UInt64(32));
cut_assert(!std::strcmp(static_cast<char *>(file.ptr()), "This is a pen."));
}
@@ -129,15 +129,15 @@ namespace test_dat_file
file.create(NULL, 100);
cut_assert(file.ptr() != NULL);
- cppcut_assert_equal(file.size(), static_cast<grn::dat::UInt64>(100));
+ cppcut_assert_equal(file.size(), grn::dat::UInt64(100));
grn::dat::File file_new;
file_new.swap(&file);
cppcut_assert_equal(file.ptr(), static_cast<void *>(NULL));
- cppcut_assert_equal(file.size(), static_cast<grn::dat::UInt64>(0));
+ cppcut_assert_equal(file.size(), grn::dat::UInt64(0));
cut_assert(file_new.ptr() != NULL);
- cppcut_assert_equal(file_new.size(), static_cast<grn::dat::UInt64>(100));
+ cppcut_assert_equal(file_new.size(), grn::dat::UInt64(100));
}
}
Modified: test/unit/core/dat/test-header.cpp (+25 -25)
===================================================================
--- test/unit/core/dat/test-header.cpp 2011-11-11 00:27:50 +0000 (0f1872e)
+++ test/unit/core/dat/test-header.cpp 2011-11-11 00:42:35 +0000 (f0e124c)
@@ -28,21 +28,21 @@ namespace test_dat_header
{
const grn::dat::Header header;
- cppcut_assert_equal(header.file_size(), static_cast<grn::dat::UInt64>(0));
- cppcut_assert_equal(header.total_key_length(), static_cast<grn::dat::UInt32>(0));
+ cppcut_assert_equal(header.file_size(), grn::dat::UInt64(0));
+ cppcut_assert_equal(header.total_key_length(), grn::dat::UInt32(0));
cppcut_assert_equal(header.min_key_id(), grn::dat::MIN_KEY_ID);
cppcut_assert_equal(header.next_key_id(), grn::dat::MIN_KEY_ID);
- cppcut_assert_equal(header.max_key_id(), static_cast<grn::dat::UInt32>(0));
- cppcut_assert_equal(header.num_keys(), static_cast<grn::dat::UInt32>(0));
- cppcut_assert_equal(header.max_num_keys(), static_cast<grn::dat::UInt32>(0));
- cppcut_assert_equal(header.num_nodes(), static_cast<grn::dat::UInt32>(0));
- cppcut_assert_equal(header.num_phantoms(), static_cast<grn::dat::UInt32>(0));
- cppcut_assert_equal(header.num_zombies(), static_cast<grn::dat::UInt32>(0));
- cppcut_assert_equal(header.max_num_nodes(), static_cast<grn::dat::UInt32>(0));
- cppcut_assert_equal(header.num_blocks(), static_cast<grn::dat::UInt32>(0));
- cppcut_assert_equal(header.max_num_blocks(), static_cast<grn::dat::UInt32>(0));
- cppcut_assert_equal(header.next_key_pos(), static_cast<grn::dat::UInt32>(0));
- cppcut_assert_equal(header.key_buf_size(), static_cast<grn::dat::UInt32>(0));
+ cppcut_assert_equal(header.max_key_id(), grn::dat::UInt32(0));
+ cppcut_assert_equal(header.num_keys(), grn::dat::UInt32(0));
+ cppcut_assert_equal(header.max_num_keys(), grn::dat::UInt32(0));
+ cppcut_assert_equal(header.num_nodes(), grn::dat::UInt32(0));
+ cppcut_assert_equal(header.num_phantoms(), grn::dat::UInt32(0));
+ cppcut_assert_equal(header.num_zombies(), grn::dat::UInt32(0));
+ cppcut_assert_equal(header.max_num_nodes(), grn::dat::UInt32(0));
+ cppcut_assert_equal(header.num_blocks(), grn::dat::UInt32(0));
+ cppcut_assert_equal(header.max_num_blocks(), grn::dat::UInt32(0));
+ cppcut_assert_equal(header.next_key_pos(), grn::dat::UInt32(0));
+ cppcut_assert_equal(header.key_buf_size(), grn::dat::UInt32(0));
for (grn::dat::UInt32 i = 0; i <= grn::dat::MAX_BLOCK_LEVEL; ++i) {
cppcut_assert_equal(header.ith_leader(i), grn::dat::INVALID_LEADER);
}
@@ -57,11 +57,11 @@ namespace test_dat_header
header.set_max_num_blocks(20);
header.set_key_buf_size(800);
- cppcut_assert_equal(header.file_size(), static_cast<grn::dat::UInt64>(10000));
- cppcut_assert_equal(header.max_num_keys(), static_cast<grn::dat::UInt32>(30));
+ cppcut_assert_equal(header.file_size(), grn::dat::UInt64(10000));
+ cppcut_assert_equal(header.max_num_keys(), grn::dat::UInt32(30));
cppcut_assert_equal(header.max_num_nodes(), (grn::dat::BLOCK_SIZE * 20));
- cppcut_assert_equal(header.max_num_blocks(), static_cast<grn::dat::UInt32>(20));
- cppcut_assert_equal(header.key_buf_size(), static_cast<grn::dat::UInt32>(800));
+ cppcut_assert_equal(header.max_num_blocks(), grn::dat::UInt32(20));
+ cppcut_assert_equal(header.key_buf_size(), grn::dat::UInt32(800));
}
void test_mutable_values(void)
@@ -82,16 +82,16 @@ namespace test_dat_header
header.set_num_blocks(10);
header.set_next_key_pos(400);
- cppcut_assert_equal(header.total_key_length(), static_cast<grn::dat::UInt32>(500));
+ cppcut_assert_equal(header.total_key_length(), grn::dat::UInt32(500));
cppcut_assert_equal(header.min_key_id(), grn::dat::MIN_KEY_ID);
- cppcut_assert_equal(header.next_key_id(), static_cast<grn::dat::UInt32>(15));
- cppcut_assert_equal(header.max_key_id(), static_cast<grn::dat::UInt32>(14));
- cppcut_assert_equal(header.num_keys(), static_cast<grn::dat::UInt32>(20));
+ cppcut_assert_equal(header.next_key_id(), grn::dat::UInt32(15));
+ cppcut_assert_equal(header.max_key_id(), grn::dat::UInt32(14));
+ cppcut_assert_equal(header.num_keys(), grn::dat::UInt32(20));
cppcut_assert_equal(header.num_nodes(), (grn::dat::BLOCK_SIZE * 10));
- cppcut_assert_equal(header.num_phantoms(), static_cast<grn::dat::UInt32>(200));
- cppcut_assert_equal(header.num_zombies(), static_cast<grn::dat::UInt32>(300));
- cppcut_assert_equal(header.num_blocks(), static_cast<grn::dat::UInt32>(10));
- cppcut_assert_equal(header.next_key_pos(), static_cast<grn::dat::UInt32>(400));
+ cppcut_assert_equal(header.num_phantoms(), grn::dat::UInt32(200));
+ cppcut_assert_equal(header.num_zombies(), grn::dat::UInt32(300));
+ cppcut_assert_equal(header.num_blocks(), grn::dat::UInt32(10));
+ cppcut_assert_equal(header.next_key_pos(), grn::dat::UInt32(400));
for (grn::dat::UInt32 i = 0; i <= grn::dat::MAX_BLOCK_LEVEL; ++i) {
header.set_ith_leader(i, i + 1);
Modified: test/unit/core/dat/test-key.cpp (+9 -12)
===================================================================
--- test/unit/core/dat/test-key.cpp 2011-11-11 00:27:50 +0000 (57c0aae)
+++ test/unit/core/dat/test-key.cpp 2011-11-11 00:42:35 +0000 (d0c54a9)
@@ -37,15 +37,11 @@ namespace test_dat_key
{
void test_size_estimation(void)
{
- cppcut_assert_equal(grn::dat::Key::estimate_size(0),
- static_cast<grn::dat::UInt32>(2));
- cppcut_assert_equal(grn::dat::Key::estimate_size(3),
- static_cast<grn::dat::UInt32>(2));
+ cppcut_assert_equal(grn::dat::Key::estimate_size(0), grn::dat::UInt32(2));
+ cppcut_assert_equal(grn::dat::Key::estimate_size(3), grn::dat::UInt32(2));
- cppcut_assert_equal(grn::dat::Key::estimate_size(4),
- static_cast<grn::dat::UInt32>(3));
- cppcut_assert_equal(grn::dat::Key::estimate_size(7),
- static_cast<grn::dat::UInt32>(3));
+ cppcut_assert_equal(grn::dat::Key::estimate_size(4), grn::dat::UInt32(3));
+ cppcut_assert_equal(grn::dat::Key::estimate_size(7), grn::dat::UInt32(3));
}
void test_invalid_key(void)
@@ -53,7 +49,7 @@ namespace test_dat_key
const grn::dat::Key &key = grn::dat::Key::invalid_key();
cppcut_assert_equal(key.id(), grn::dat::INVALID_KEY_ID);
- cppcut_assert_equal(key.length(), static_cast<grn::dat::UInt32>(0));
+ cppcut_assert_equal(key.length(), grn::dat::UInt32(0));
cut_assert(key.ptr() != static_cast<const void *>(NULL));
}
@@ -63,9 +59,10 @@ namespace test_dat_key
const grn::dat::Key &key = grn::dat::Key::create(buf, 123, "groonga", 7);
cppcut_assert_equal(key.str(), grn::dat::String("groonga"));
- cppcut_assert_equal(key.id(), static_cast<grn::dat::UInt32>(123));
- cppcut_assert_equal(key.length(), static_cast<grn::dat::UInt32>(7));
+ cppcut_assert_equal(key.id(), grn::dat::UInt32(123));
+ cppcut_assert_equal(key.length(), grn::dat::UInt32(7));
cppcut_assert_equal(std::memcmp(key.ptr(), "groonga", 7), 0);
- cppcut_assert_equal(key.ptr(), static_cast<const void *>(reinterpret_cast<char *>(buf) + 5));
+ cppcut_assert_equal(key.ptr(),
+ static_cast<const void *>(reinterpret_cast<char *>(buf) + 5));
}
}
Modified: test/unit/core/dat/test-string.cpp (+7 -4)
===================================================================
--- test/unit/core/dat/test-string.cpp 2011-11-11 00:27:50 +0000 (b5fe8bb)
+++ test/unit/core/dat/test-string.cpp 2011-11-11 00:42:35 +0000 (a6a6995)
@@ -37,7 +37,7 @@ namespace test_dat_string
const grn::dat::String str;
cppcut_assert_equal(str.ptr(), static_cast<const void *>(NULL));
- cppcut_assert_equal(str.length(), static_cast<grn::dat::UInt32>(0));
+ cppcut_assert_equal(str.length(), grn::dat::UInt32(0));
}
void test_constructor_with_length(void)
@@ -46,7 +46,8 @@ namespace test_dat_string
const grn::dat::String str(str_buf, sizeof(str_buf) - 1);
cppcut_assert_equal(str.ptr(), static_cast<const void *>(str_buf));
- cppcut_assert_equal(str.length(), static_cast<grn::dat::UInt32>(sizeof(str_buf) - 1));
+ cppcut_assert_equal(str.length(),
+ static_cast<grn::dat::UInt32>(sizeof(str_buf) - 1));
}
void test_constructor_without_length(void)
@@ -55,7 +56,8 @@ namespace test_dat_string
const grn::dat::String str(str_buf);
cppcut_assert_equal(str.ptr(), static_cast<const void *>(str_buf));
- cppcut_assert_equal(str.length(), static_cast<grn::dat::UInt32>(sizeof(str_buf) - 1));
+ cppcut_assert_equal(str.length(),
+ static_cast<grn::dat::UInt32>(sizeof(str_buf) - 1));
}
void test_copy_constructor(void)
@@ -86,7 +88,8 @@ namespace test_dat_string
str.assign(str_buf, sizeof(str_buf) - 1);
cppcut_assert_equal(str.ptr(), static_cast<const void *>(str_buf));
- cppcut_assert_equal(str.length(), static_cast<grn::dat::UInt32>(sizeof(str_buf) - 1));
+ cppcut_assert_equal(str.length(),
+ static_cast<grn::dat::UInt32>(sizeof(str_buf) - 1));
}
void test_substr(void)
Modified: test/unit/core/dat/test-trie.cpp (+17 -17)
===================================================================
--- test/unit/core/dat/test-trie.cpp 2011-11-11 00:27:50 +0000 (f6e5522)
+++ test/unit/core/dat/test-trie.cpp 2011-11-11 00:42:35 +0000 (e723c99)
@@ -75,22 +75,22 @@ namespace test_dat_trie
trie.create();
cppcut_assert_equal(trie.file_size(), grn::dat::DEFAULT_FILE_SIZE);
- cppcut_assert_equal(trie.virtual_size(), static_cast<grn::dat::UInt64>(4236));
- cppcut_assert_equal(trie.total_key_length(), static_cast<grn::dat::UInt32>(0));
- cppcut_assert_equal(trie.num_keys(), static_cast<grn::dat::UInt32>(0));
- cppcut_assert_equal(trie.min_key_id(), static_cast<grn::dat::UInt32>(1));
- cppcut_assert_equal(trie.next_key_id(), static_cast<grn::dat::UInt32>(1));
- cppcut_assert_equal(trie.max_key_id(), static_cast<grn::dat::UInt32>(0));
- cppcut_assert_equal(trie.num_keys(), static_cast<grn::dat::UInt32>(0));
- cppcut_assert_equal(trie.max_num_keys(), static_cast<grn::dat::UInt32>(17893));
- cppcut_assert_equal(trie.num_nodes(), static_cast<grn::dat::UInt32>(512));
- cppcut_assert_equal(trie.num_phantoms(), static_cast<grn::dat::UInt32>(511));
- cppcut_assert_equal(trie.num_zombies(), static_cast<grn::dat::UInt32>(0));
- cppcut_assert_equal(trie.max_num_nodes(), static_cast<grn::dat::UInt32>(71680));
- cppcut_assert_equal(trie.num_blocks(), static_cast<grn::dat::UInt32>(1));
- cppcut_assert_equal(trie.max_num_blocks(), static_cast<grn::dat::UInt32>(140));
- cppcut_assert_equal(trie.next_key_pos(), static_cast<grn::dat::UInt32>(0));
- cppcut_assert_equal(trie.key_buf_size(), static_cast<grn::dat::UInt32>(100439));
+ cppcut_assert_equal(trie.virtual_size(), grn::dat::UInt64(4236));
+ cppcut_assert_equal(trie.total_key_length(), grn::dat::UInt32(0));
+ cppcut_assert_equal(trie.num_keys(), grn::dat::UInt32(0));
+ cppcut_assert_equal(trie.min_key_id(), grn::dat::UInt32(1));
+ cppcut_assert_equal(trie.next_key_id(), grn::dat::UInt32(1));
+ cppcut_assert_equal(trie.max_key_id(), grn::dat::UInt32(0));
+ cppcut_assert_equal(trie.num_keys(), grn::dat::UInt32(0));
+ cppcut_assert_equal(trie.max_num_keys(), grn::dat::UInt32(17893));
+ cppcut_assert_equal(trie.num_nodes(), grn::dat::UInt32(512));
+ cppcut_assert_equal(trie.num_phantoms(), grn::dat::UInt32(511));
+ cppcut_assert_equal(trie.num_zombies(), grn::dat::UInt32(0));
+ cppcut_assert_equal(trie.max_num_nodes(), grn::dat::UInt32(71680));
+ cppcut_assert_equal(trie.num_blocks(), grn::dat::UInt32(1));
+ cppcut_assert_equal(trie.max_num_blocks(), grn::dat::UInt32(140));
+ cppcut_assert_equal(trie.next_key_pos(), grn::dat::UInt32(0));
+ cppcut_assert_equal(trie.key_buf_size(), grn::dat::UInt32(100439));
}
void test_trie_on_memory(void)
@@ -313,7 +313,7 @@ namespace test_dat_trie
cppcut_assert_equal(dest_trie.next_key_pos(), src_trie.next_key_pos());
cut_assert(dest_trie.num_nodes() < src_trie.num_nodes());
- cppcut_assert_equal(dest_trie.num_zombies(), static_cast<grn::dat::UInt32>(0));
+ cppcut_assert_equal(dest_trie.num_zombies(), grn::dat::UInt32(0));
cut_assert(dest_trie.num_blocks() < src_trie.num_nodes());
}
}
Modified: test/unit/core/dat/test-vector.cpp (+42 -42)
===================================================================
--- test/unit/core/dat/test-vector.cpp 2011-11-11 00:27:50 +0000 (59ad073)
+++ test/unit/core/dat/test-vector.cpp 2011-11-11 00:42:35 +0000 (e0fa7a8)
@@ -53,8 +53,8 @@ namespace test_dat_vector
const grn::dat::Vector<grn::dat::UInt32> vec;
cppcut_assert_equal(vec.empty(), true);
- cppcut_assert_equal(vec.size(), static_cast<grn::dat::UInt32>(0));
- cppcut_assert_equal(vec.capacity(), static_cast<grn::dat::UInt32>(0));
+ cppcut_assert_equal(vec.size(), grn::dat::UInt32(0));
+ cppcut_assert_equal(vec.capacity(), grn::dat::UInt32(0));
}
void test_reserve(void)
@@ -63,33 +63,33 @@ namespace test_dat_vector
vec.reserve(1);
cppcut_assert_equal(vec.empty(), true);
- cppcut_assert_equal(vec.size(), static_cast<grn::dat::UInt32>(0));
- cppcut_assert_equal(vec.capacity(), static_cast<grn::dat::UInt32>(1));
+ cppcut_assert_equal(vec.size(), grn::dat::UInt32(0));
+ cppcut_assert_equal(vec.capacity(), grn::dat::UInt32(1));
vec.reserve(2);
cppcut_assert_equal(vec.empty(), true);
- cppcut_assert_equal(vec.size(), static_cast<grn::dat::UInt32>(0));
- cppcut_assert_equal(vec.capacity(), static_cast<grn::dat::UInt32>(2));
+ cppcut_assert_equal(vec.size(), grn::dat::UInt32(0));
+ cppcut_assert_equal(vec.capacity(), grn::dat::UInt32(2));
vec.reserve(3);
cppcut_assert_equal(vec.empty(), true);
- cppcut_assert_equal(vec.size(), static_cast<grn::dat::UInt32>(0));
- cppcut_assert_equal(vec.capacity(), static_cast<grn::dat::UInt32>(4));
+ cppcut_assert_equal(vec.size(), grn::dat::UInt32(0));
+ cppcut_assert_equal(vec.capacity(), grn::dat::UInt32(4));
vec.reserve(100);
cppcut_assert_equal(vec.empty(), true);
- cppcut_assert_equal(vec.size(), static_cast<grn::dat::UInt32>(0));
- cppcut_assert_equal(vec.capacity(), static_cast<grn::dat::UInt32>(100));
+ cppcut_assert_equal(vec.size(), grn::dat::UInt32(0));
+ cppcut_assert_equal(vec.capacity(), grn::dat::UInt32(100));
vec.reserve(101);
cppcut_assert_equal(vec.empty(), true);
- cppcut_assert_equal(vec.size(), static_cast<grn::dat::UInt32>(0));
- cppcut_assert_equal(vec.capacity(), static_cast<grn::dat::UInt32>(200));
+ cppcut_assert_equal(vec.size(), grn::dat::UInt32(0));
+ cppcut_assert_equal(vec.capacity(), grn::dat::UInt32(200));
vec.reserve(0);
cppcut_assert_equal(vec.empty(), true);
- cppcut_assert_equal(vec.size(), static_cast<grn::dat::UInt32>(0));
- cppcut_assert_equal(vec.capacity(), static_cast<grn::dat::UInt32>(200));
+ cppcut_assert_equal(vec.size(), grn::dat::UInt32(0));
+ cppcut_assert_equal(vec.capacity(), grn::dat::UInt32(200));
}
void test_resize(void)
@@ -98,33 +98,33 @@ namespace test_dat_vector
vec.resize(1);
cppcut_assert_equal(vec.empty(), false);
- cppcut_assert_equal(vec.size(), static_cast<grn::dat::UInt32>(1));
- cppcut_assert_equal(vec.capacity(), static_cast<grn::dat::UInt32>(1));
+ cppcut_assert_equal(vec.size(), grn::dat::UInt32(1));
+ cppcut_assert_equal(vec.capacity(), grn::dat::UInt32(1));
vec.resize(2);
cppcut_assert_equal(vec.empty(), false);
- cppcut_assert_equal(vec.size(), static_cast<grn::dat::UInt32>(2));
- cppcut_assert_equal(vec.capacity(), static_cast<grn::dat::UInt32>(2));
+ cppcut_assert_equal(vec.size(), grn::dat::UInt32(2));
+ cppcut_assert_equal(vec.capacity(), grn::dat::UInt32(2));
vec.resize(3);
cppcut_assert_equal(vec.empty(), false);
- cppcut_assert_equal(vec.size(), static_cast<grn::dat::UInt32>(3));
- cppcut_assert_equal(vec.capacity(), static_cast<grn::dat::UInt32>(4));
+ cppcut_assert_equal(vec.size(), grn::dat::UInt32(3));
+ cppcut_assert_equal(vec.capacity(), grn::dat::UInt32(4));
vec.resize(100);
cppcut_assert_equal(vec.empty(), false);
- cppcut_assert_equal(vec.size(), static_cast<grn::dat::UInt32>(100));
- cppcut_assert_equal(vec.capacity(), static_cast<grn::dat::UInt32>(100));
+ cppcut_assert_equal(vec.size(), grn::dat::UInt32(100));
+ cppcut_assert_equal(vec.capacity(), grn::dat::UInt32(100));
vec.resize(101);
cppcut_assert_equal(vec.empty(), false);
- cppcut_assert_equal(vec.size(), static_cast<grn::dat::UInt32>(101));
- cppcut_assert_equal(vec.capacity(), static_cast<grn::dat::UInt32>(200));
+ cppcut_assert_equal(vec.size(), grn::dat::UInt32(101));
+ cppcut_assert_equal(vec.capacity(), grn::dat::UInt32(200));
vec.resize(0);
cppcut_assert_equal(vec.empty(), true);
- cppcut_assert_equal(vec.size(), static_cast<grn::dat::UInt32>(0));
- cppcut_assert_equal(vec.capacity(), static_cast<grn::dat::UInt32>(200));
+ cppcut_assert_equal(vec.size(), grn::dat::UInt32(0));
+ cppcut_assert_equal(vec.capacity(), grn::dat::UInt32(200));
}
void test_push_pop(void)
@@ -133,37 +133,37 @@ namespace test_dat_vector
vec.push_back();
cppcut_assert_equal(vec.empty(), false);
- cppcut_assert_equal(vec.size(), static_cast<grn::dat::UInt32>(1));
- cppcut_assert_equal(vec.capacity(), static_cast<grn::dat::UInt32>(1));
+ cppcut_assert_equal(vec.size(), grn::dat::UInt32(1));
+ cppcut_assert_equal(vec.capacity(), grn::dat::UInt32(1));
vec.pop_back();
cppcut_assert_equal(vec.empty(), true);
- cppcut_assert_equal(vec.size(), static_cast<grn::dat::UInt32>(0));
- cppcut_assert_equal(vec.capacity(), static_cast<grn::dat::UInt32>(1));
+ cppcut_assert_equal(vec.size(), grn::dat::UInt32(0));
+ cppcut_assert_equal(vec.capacity(), grn::dat::UInt32(1));
vec.push_back(5);
cppcut_assert_equal(vec.empty(), false);
- cppcut_assert_equal(vec.size(), static_cast<grn::dat::UInt32>(1));
- cppcut_assert_equal(vec.capacity(), static_cast<grn::dat::UInt32>(1));
+ cppcut_assert_equal(vec.size(), grn::dat::UInt32(1));
+ cppcut_assert_equal(vec.capacity(), grn::dat::UInt32(1));
- cppcut_assert_equal(vec.front(), static_cast<grn::dat::UInt32>(5));
- cppcut_assert_equal(vec.back(), static_cast<grn::dat::UInt32>(5));
+ cppcut_assert_equal(vec.front(), grn::dat::UInt32(5));
+ cppcut_assert_equal(vec.back(), grn::dat::UInt32(5));
vec.push_back(123);
cppcut_assert_equal(vec.empty(), false);
- cppcut_assert_equal(vec.size(), static_cast<grn::dat::UInt32>(2));
- cppcut_assert_equal(vec.capacity(), static_cast<grn::dat::UInt32>(2));
+ cppcut_assert_equal(vec.size(), grn::dat::UInt32(2));
+ cppcut_assert_equal(vec.capacity(), grn::dat::UInt32(2));
- cppcut_assert_equal(vec.front(), static_cast<grn::dat::UInt32>(5));
- cppcut_assert_equal(vec.back(), static_cast<grn::dat::UInt32>(123));
+ cppcut_assert_equal(vec.front(), grn::dat::UInt32(5));
+ cppcut_assert_equal(vec.back(), grn::dat::UInt32(123));
vec.pop_back();
cppcut_assert_equal(vec.empty(), false);
- cppcut_assert_equal(vec.size(), static_cast<grn::dat::UInt32>(1));
- cppcut_assert_equal(vec.capacity(), static_cast<grn::dat::UInt32>(2));
+ cppcut_assert_equal(vec.size(), grn::dat::UInt32(1));
+ cppcut_assert_equal(vec.capacity(), grn::dat::UInt32(2));
- cppcut_assert_equal(vec.front(), static_cast<grn::dat::UInt32>(5));
- cppcut_assert_equal(vec.back(), static_cast<grn::dat::UInt32>(5));
+ cppcut_assert_equal(vec.front(), grn::dat::UInt32(5));
+ cppcut_assert_equal(vec.back(), grn::dat::UInt32(5));
vec.clear();