Groonga - fulltext search engine.

[Groonga-commit] groonga/groonga [master] correct the argument order of cppcut_assert_equal().

null+****@clear***** null+****@clear*****
2011年 11月 11日 (金) 11:16:06 JST

• 前の記事 [Groonga-commit] groonga/groonga [master] fix space alignment.
• 次の記事 [Groonga-commit] groonga/groonga [master] translate tutorial text of loading data.
• 記事の並び順: [ 日付 ] [ スレッド ] [ 件名 ] [ 著者 ]

Susumu Yata	2011-11-11 02:16:06 +0000 (Fri, 11 Nov 2011)

  New Revision: 73c278c2057dad158cc6370ed0c929949fa2bc57

  Log:
    correct the argument order of cppcut_assert_equal().

  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-id-cursor.cpp
    test/unit/core/dat/test-key-cursor.cpp
    test/unit/core/dat/test-key.cpp
    test/unit/core/dat/test-node.cpp
    test/unit/core/dat/test-predictive-cursor.cpp
    test/unit/core/dat/test-prefix-cursor.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 (+6 -6)
===================================================================
--- test/unit/core/dat/test-base.cpp    2011-11-11 01:47:12 +0000 (f08dfc2)
+++ test/unit/core/dat/test-base.cpp    2011-11-11 02:16:06 +0000 (e0a48cc)
@@ -28,8 +28,8 @@ namespace test_dat_base
   {
     grn::dat::Base base;
 
-    cppcut_assert_equal(base.is_linker(), false);
-    cppcut_assert_equal(base.offset(), grn::dat::UInt32(0));
+    cppcut_assert_equal(false, base.is_linker());
+    cppcut_assert_equal(grn::dat::UInt32(0), base.offset());
   }
 
   void test_linker(void)
@@ -37,8 +37,8 @@ namespace test_dat_base
     grn::dat::Base base;
 
     base.set_key_pos(100);
-    cppcut_assert_equal(base.is_linker(), true);
-    cppcut_assert_equal(base.key_pos(), grn::dat::UInt32(100));
+    cppcut_assert_equal(true, base.is_linker());
+    cppcut_assert_equal(grn::dat::UInt32(100), base.key_pos());
   }
 
   void test_nonlinker(void)
@@ -46,7 +46,7 @@ namespace test_dat_base
     grn::dat::Base base;
 
     base.set_offset(1000);
-    cppcut_assert_equal(base.is_linker(), false);
-    cppcut_assert_equal(base.offset(), grn::dat::UInt32(1000));
+    cppcut_assert_equal(false, base.is_linker());
+    cppcut_assert_equal(grn::dat::UInt32(1000), base.offset());
   }
 }

  Modified: test/unit/core/dat/test-block.cpp (+12 -12)
===================================================================
--- test/unit/core/dat/test-block.cpp    2011-11-11 01:47:12 +0000 (ab5a51f)
+++ test/unit/core/dat/test-block.cpp    2011-11-11 02:16:06 +0000 (4812552)
@@ -28,12 +28,12 @@ namespace test_dat_block
   {
     const grn::dat::Block block;
 
-    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));
+    cppcut_assert_equal(grn::dat::UInt32(0), block.next());
+    cppcut_assert_equal(grn::dat::UInt32(0), block.prev());
+    cppcut_assert_equal(grn::dat::UInt32(0), block.level());
+    cppcut_assert_equal(grn::dat::UInt32(0), block.failure_count());
+    cppcut_assert_equal(grn::dat::UInt32(0), block.first_phantom());
+    cppcut_assert_equal(grn::dat::UInt32(0), block.num_phantoms());
   }
 
   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(), grn::dat::UInt32(101));
-    cppcut_assert_equal(block.prev(), grn::dat::UInt32(99));
+    cppcut_assert_equal(grn::dat::UInt32(101), block.next());
+    cppcut_assert_equal(grn::dat::UInt32(99), block.prev());
   }
 
   void test_level_management(void)
@@ -52,8 +52,8 @@ namespace test_dat_block
 
     block.set_level(grn::dat::MAX_BLOCK_LEVEL);
     block.set_failure_count(grn::dat::MAX_FAILURE_COUNT);
-    cppcut_assert_equal(block.level(), grn::dat::MAX_BLOCK_LEVEL);
-    cppcut_assert_equal(block.failure_count(), grn::dat::MAX_FAILURE_COUNT);
+    cppcut_assert_equal(grn::dat::MAX_BLOCK_LEVEL, block.level());
+    cppcut_assert_equal(grn::dat::MAX_FAILURE_COUNT, block.failure_count());
   }
 
   void test_phantoms_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(), grn::dat::UInt32(37));
-    cppcut_assert_equal(block.num_phantoms(), grn::dat::UInt32(89));
+    cppcut_assert_equal(grn::dat::UInt32(37), block.first_phantom());
+    cppcut_assert_equal(grn::dat::UInt32(89), block.num_phantoms());
   }
 }

  Modified: test/unit/core/dat/test-check.cpp (+22 -22)
===================================================================
--- test/unit/core/dat/test-check.cpp    2011-11-11 01:47:12 +0000 (827a176)
+++ test/unit/core/dat/test-check.cpp    2011-11-11 02:16:06 +0000 (55032e3)
@@ -28,12 +28,12 @@ namespace test_dat_check
   {
     const grn::dat::Check check;
 
-    cppcut_assert_equal(check.is_offset(), false);
-    cppcut_assert_equal(check.except_is_offset(), grn::dat::UInt32(0));
-    cppcut_assert_equal(check.is_phantom(), false);
-    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));
+    cppcut_assert_equal(false, check.is_offset());
+    cppcut_assert_equal(grn::dat::UInt32(0), check.except_is_offset());
+    cppcut_assert_equal(false, check.is_phantom());
+    cppcut_assert_equal(grn::dat::UInt32(0), check.label());
+    cppcut_assert_equal(grn::dat::UInt32(0), check.child());
+    cppcut_assert_equal(grn::dat::UInt32(0), check.sibling());
   }
 
   void test_phantomize(void)
@@ -41,14 +41,14 @@ namespace test_dat_check
     grn::dat::Check check;
 
     check.set_is_phantom(true);
-    cppcut_assert_equal(check.is_phantom(), true);
-    cppcut_assert_equal(check.next(), grn::dat::UInt32(0));
-    cppcut_assert_equal(check.prev(), grn::dat::UInt32(0));
+    cppcut_assert_equal(true, check.is_phantom());
+    cppcut_assert_equal(grn::dat::UInt32(0), check.next());
+    cppcut_assert_equal(grn::dat::UInt32(0), check.prev());
 
     check.set_next(101);
     check.set_prev(99);
-    cppcut_assert_equal(check.next(), grn::dat::UInt32(101));
-    cppcut_assert_equal(check.prev(), grn::dat::UInt32(99));
+    cppcut_assert_equal(grn::dat::UInt32(101), check.next());
+    cppcut_assert_equal(grn::dat::UInt32(99), check.prev());
   }
 
   void test_unphantomize(void)
@@ -57,9 +57,9 @@ namespace test_dat_check
 
     check.set_is_phantom(true);
     check.set_is_phantom(false);
-    cppcut_assert_equal(check.is_phantom(), false);
-    cppcut_assert_equal(check.child(), grn::dat::INVALID_LABEL);
-    cppcut_assert_equal(check.sibling(), grn::dat::INVALID_LABEL);
+    cppcut_assert_equal(false, check.is_phantom());
+    cppcut_assert_equal(grn::dat::INVALID_LABEL, check.child());
+    cppcut_assert_equal(grn::dat::INVALID_LABEL, check.sibling());
   }
 
   void test_nonphantom(void)
@@ -67,20 +67,20 @@ namespace test_dat_check
     grn::dat::Check check;
 
     check.set_is_offset(true);
-    cppcut_assert_equal(check.is_offset(), true);
+    cppcut_assert_equal(true, check.is_offset());
 
     check.set_label('a');
-    cppcut_assert_equal(check.label(), grn::dat::UInt32('a'));
+    cppcut_assert_equal(grn::dat::UInt32('a'), check.label());
 
     check.set_child('b');
-    cppcut_assert_equal(check.child(), grn::dat::UInt32('b'));
+    cppcut_assert_equal(grn::dat::UInt32('b'), check.child());
 
     check.set_sibling('c');
-    cppcut_assert_equal(check.sibling(), grn::dat::UInt32('c'));
+    cppcut_assert_equal(grn::dat::UInt32('c'), check.sibling());
 
-    cppcut_assert_equal(check.is_offset(), true);
-    cppcut_assert_equal(check.except_is_offset(),
-                        'a' | grn::dat::UInt32('b' << 9) | grn::dat::UInt32('c' << 18));
-    cppcut_assert_equal(check.is_phantom(), false);
+    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());
+    cppcut_assert_equal(false, check.is_phantom());
   }
 }

  Modified: test/unit/core/dat/test-cursor-factory.cpp (+22 -22)
===================================================================
--- test/unit/core/dat/test-cursor-factory.cpp    2011-11-11 01:47:12 +0000 (9e16cb8)
+++ test/unit/core/dat/test-cursor-factory.cpp    2011-11-11 02:16:06 +0000 (b333ba9)
@@ -30,10 +30,10 @@ namespace
   void create_trie(grn::dat::Trie *trie)
   {
     trie->create();
-    cppcut_assert_equal(trie->insert("apple", 5), true);
-    cppcut_assert_equal(trie->insert("orange", 6), true);
-    cppcut_assert_equal(trie->insert("banana", 6), true);
-    cppcut_assert_equal(trie->insert("melon", 5), true);
+    cppcut_assert_equal(true, trie->insert("apple", 5));
+    cppcut_assert_equal(true, trie->insert("orange", 6));
+    cppcut_assert_equal(true, trie->insert("banana", 6));
+    cppcut_assert_equal(true, trie->insert("melon", 5));
   }
 }
 
@@ -50,11 +50,11 @@ 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(), 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);
+    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,
+                        cursor->flags());
   }
 
   void test_id_range_cursor(void)
@@ -67,10 +67,10 @@ 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(), 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);
+    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,
+                        cursor->flags());
   }
 
   void test_prefix_cursor(void)
@@ -83,10 +83,10 @@ 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(), 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);
+    cppcut_assert_equal(grn::dat::UInt32(0), cursor->offset());
+    cppcut_assert_equal(grn::dat::UInt32(1), cursor->limit());
+    cppcut_assert_equal(grn::dat::PREFIX_CURSOR | grn::dat::DESCENDING_CURSOR,
+                        cursor->flags());
   }
 
   void test_predictive_cursor(void)
@@ -99,10 +99,10 @@ 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(), 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);
+    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 | grn::dat::EXCEPT_EXACT_MATCH,
+                        cursor->flags());
   }
 }

  Modified: test/unit/core/dat/test-entry.cpp (+6 -6)
===================================================================
--- test/unit/core/dat/test-entry.cpp    2011-11-11 01:47:12 +0000 (fc23391)
+++ test/unit/core/dat/test-entry.cpp    2011-11-11 02:16:06 +0000 (1cc3d5e)
@@ -28,8 +28,8 @@ namespace test_dat_entry
   {
     const grn::dat::Entry entry;
 
-    cppcut_assert_equal(entry.is_valid(), false);
-    cppcut_assert_equal(entry.next(), grn::dat::UInt32(0));
+    cppcut_assert_equal(false, entry.is_valid());
+    cppcut_assert_equal(grn::dat::UInt32(0), entry.next());
   }
 
   void test_valid_entry(void)
@@ -37,8 +37,8 @@ namespace test_dat_entry
     grn::dat::Entry entry;
 
     entry.set_key_pos(100);
-    cppcut_assert_equal(entry.is_valid(), true);
-    cppcut_assert_equal(entry.key_pos(), grn::dat::UInt32(100));
+    cppcut_assert_equal(true, entry.is_valid());
+    cppcut_assert_equal(grn::dat::UInt32(100), entry.key_pos());
   }
 
   void test_invalid_entry(void)
@@ -46,7 +46,7 @@ namespace test_dat_entry
     grn::dat::Entry entry;
 
     entry.set_next(200);
-    cppcut_assert_equal(entry.is_valid(), false);
-    cppcut_assert_equal(entry.next(), grn::dat::UInt32(200));
+    cppcut_assert_equal(false, entry.is_valid());
+    cppcut_assert_equal(grn::dat::UInt32(200), entry.next());
   }
 }

  Modified: test/unit/core/dat/test-file.cpp (+13 -13)
===================================================================
--- test/unit/core/dat/test-file.cpp    2011-11-11 01:47:12 +0000 (8f1c317)
+++ test/unit/core/dat/test-file.cpp    2011-11-11 02:16:06 +0000 (ad57203)
@@ -46,8 +46,8 @@ namespace test_dat_file
   {
     const grn::dat::File file;
 
-    cppcut_assert_equal(file.ptr(), static_cast<void *>(NULL));
-    cppcut_assert_equal(file.size(), grn::dat::UInt64(0));
+    cppcut_assert_equal(static_cast<void *>(NULL), file.ptr());
+    cppcut_assert_equal(grn::dat::UInt64(0), file.size());
   }
 
   void test_create_without_path(void)
@@ -62,12 +62,12 @@ namespace test_dat_file
 
     file.create(NULL, 32);
     cut_assert(file.ptr() != NULL);
-    cppcut_assert_equal(file.size(), grn::dat::UInt64(32));
+    cppcut_assert_equal(grn::dat::UInt64(32), file.size());
 
     grn::dat::UInt8 * const buf = static_cast<grn::dat::UInt8 *>(file.ptr());
     for (grn::dat::UInt64 i = 0; i < file.size(); ++i) {
       buf[i] = static_cast<grn::dat::UInt8>(i);
-      cppcut_assert_equal(buf[i], static_cast<grn::dat::UInt8>(i));
+      cppcut_assert_equal(static_cast<grn::dat::UInt8>(i), buf[i]);
     }
   }
 
@@ -87,12 +87,12 @@ namespace test_dat_file
 
     file.create(path, 32);
     cut_assert(file.ptr() != NULL);
-    cppcut_assert_equal(file.size(), grn::dat::UInt64(32));
+    cppcut_assert_equal(grn::dat::UInt64(32), file.size());
 
     grn::dat::UInt8 * const buf = static_cast<grn::dat::UInt8 *>(file.ptr());
     for (grn::dat::UInt64 i = 0; i < file.size(); ++i) {
       buf[i] = static_cast<grn::dat::UInt8>(i);
-      cppcut_assert_equal(buf[i], static_cast<grn::dat::UInt8>(i));
+      cppcut_assert_equal(static_cast<grn::dat::UInt8>(i), buf[i]);
     }
   }
 
@@ -114,12 +114,12 @@ namespace test_dat_file
     std::strcpy(static_cast<char *>(file.ptr()), "This is a pen.");
 
     file.close();
-    cppcut_assert_equal(file.ptr(), static_cast<void *>(NULL));
-    cppcut_assert_equal(file.size(), grn::dat::UInt64(0));
+    cppcut_assert_equal(static_cast<void *>(NULL), file.ptr());
+    cppcut_assert_equal(grn::dat::UInt64(0), file.size());
 
     file.open(path);
     cut_assert(file.ptr() != NULL);
-    cppcut_assert_equal(file.size(), grn::dat::UInt64(32));
+    cppcut_assert_equal(grn::dat::UInt64(32), file.size());
     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(), grn::dat::UInt64(100));
+    cppcut_assert_equal(grn::dat::UInt64(100), file.size());
 
     grn::dat::File file_new;
     file_new.swap(&file);
 
-    cppcut_assert_equal(file.ptr(), static_cast<void *>(NULL));
-    cppcut_assert_equal(file.size(), grn::dat::UInt64(0));
+    cppcut_assert_equal(static_cast<void *>(NULL), file.ptr());
+    cppcut_assert_equal(grn::dat::UInt64(0), file.size());
 
     cut_assert(file_new.ptr() != NULL);
-    cppcut_assert_equal(file_new.size(), grn::dat::UInt64(100));
+    cppcut_assert_equal(grn::dat::UInt64(100), file_new.size());
   }
 }

  Modified: test/unit/core/dat/test-header.cpp (+32 -32)
===================================================================
--- test/unit/core/dat/test-header.cpp    2011-11-11 01:47:12 +0000 (f0e124c)
+++ test/unit/core/dat/test-header.cpp    2011-11-11 02:16:06 +0000 (0e5eb78)
@@ -28,23 +28,23 @@ namespace test_dat_header
   {
     const grn::dat::Header header;
 
-    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(), 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));
+    cppcut_assert_equal(grn::dat::UInt64(0), header.file_size());
+    cppcut_assert_equal(grn::dat::UInt32(0), header.total_key_length());
+    cppcut_assert_equal(grn::dat::MIN_KEY_ID, header.min_key_id());
+    cppcut_assert_equal(grn::dat::MIN_KEY_ID, header.next_key_id());
+    cppcut_assert_equal(grn::dat::UInt32(0), header.max_key_id());
+    cppcut_assert_equal(grn::dat::UInt32(0), header.num_keys());
+    cppcut_assert_equal(grn::dat::UInt32(0), header.max_num_keys());
+    cppcut_assert_equal(grn::dat::UInt32(0), header.num_nodes());
+    cppcut_assert_equal(grn::dat::UInt32(0), header.num_phantoms());
+    cppcut_assert_equal(grn::dat::UInt32(0), header.num_zombies());
+    cppcut_assert_equal(grn::dat::UInt32(0), header.max_num_nodes());
+    cppcut_assert_equal(grn::dat::UInt32(0), header.num_blocks());
+    cppcut_assert_equal(grn::dat::UInt32(0), header.max_num_blocks());
+    cppcut_assert_equal(grn::dat::UInt32(0), header.next_key_pos());
+    cppcut_assert_equal(grn::dat::UInt32(0), header.key_buf_size());
     for (grn::dat::UInt32 i = 0; i <= grn::dat::MAX_BLOCK_LEVEL; ++i) {
-      cppcut_assert_equal(header.ith_leader(i), grn::dat::INVALID_LEADER);
+      cppcut_assert_equal(grn::dat::INVALID_LEADER, header.ith_leader(i));
     }
   }
 
@@ -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(), 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(), grn::dat::UInt32(20));
-    cppcut_assert_equal(header.key_buf_size(), grn::dat::UInt32(800));
+    cppcut_assert_equal(grn::dat::UInt64(10000), header.file_size());
+    cppcut_assert_equal(grn::dat::UInt32(30), header.max_num_keys());
+    cppcut_assert_equal(grn::dat::BLOCK_SIZE * 20, header.max_num_nodes());
+    cppcut_assert_equal(grn::dat::UInt32(20), header.max_num_blocks());
+    cppcut_assert_equal(grn::dat::UInt32(800), header.key_buf_size());
   }
 
   void test_mutable_values(void)
@@ -82,23 +82,23 @@ namespace test_dat_header
     header.set_num_blocks(10);
     header.set_next_key_pos(400);
 
-    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(), 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(), 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));
+    cppcut_assert_equal(grn::dat::UInt32(500), header.total_key_length());
+    cppcut_assert_equal(grn::dat::MIN_KEY_ID, header.min_key_id());
+    cppcut_assert_equal(grn::dat::UInt32(15), header.next_key_id());
+    cppcut_assert_equal(grn::dat::UInt32(14), header.max_key_id());
+    cppcut_assert_equal(grn::dat::UInt32(20), header.num_keys());
+    cppcut_assert_equal(grn::dat::BLOCK_SIZE * 10, header.num_nodes());
+    cppcut_assert_equal(grn::dat::UInt32(200), header.num_phantoms());
+    cppcut_assert_equal(grn::dat::UInt32(300), header.num_zombies());
+    cppcut_assert_equal(grn::dat::UInt32(10), header.num_blocks());
+    cppcut_assert_equal(grn::dat::UInt32(400), header.next_key_pos());
 
     for (grn::dat::UInt32 i = 0; i <= grn::dat::MAX_BLOCK_LEVEL; ++i) {
       header.set_ith_leader(i, i + 1);
     }
 
     for (grn::dat::UInt32 i = 0; i <= grn::dat::MAX_BLOCK_LEVEL; ++i) {
-      cppcut_assert_equal(header.ith_leader(i), (i + 1));
+      cppcut_assert_equal((i + 1), header.ith_leader(i));
     }
   }
 }

  Modified: test/unit/core/dat/test-id-cursor.cpp (+74 -74)
===================================================================
--- test/unit/core/dat/test-id-cursor.cpp    2011-11-11 01:47:12 +0000 (c184e22)
+++ test/unit/core/dat/test-id-cursor.cpp    2011-11-11 02:16:06 +0000 (ff0ac2e)
@@ -52,10 +52,10 @@ namespace test_dat_id_cursor
     cursor.open(trie, grn::dat::String(), grn::dat::String());
     for (grn::dat::UInt32 i = trie.min_key_id(); i <= trie.max_key_id(); ++i) {
       const grn::dat::Key &key = cursor.next();
-      cppcut_assert_equal(key.is_valid(), true);
-      cppcut_assert_equal(key.id(), i);
+      cppcut_assert_equal(true, key.is_valid());
+      cppcut_assert_equal(i, key.id());
     }
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(false, cursor.next().is_valid());
   }
 
   void test_min_by_str(void)
@@ -71,10 +71,10 @@ namespace test_dat_id_cursor
     cursor.open(trie, grn::dat::String("スダチ"), grn::dat::String());
     for (grn::dat::UInt32 i = min_key_id; i <= trie.max_key_id(); ++i) {
       const grn::dat::Key &key = cursor.next();
-      cppcut_assert_equal(key.is_valid(), true);
-      cppcut_assert_equal(key.id(), i);
+      cppcut_assert_equal(true, key.is_valid());
+      cppcut_assert_equal(i, key.id());
     }
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(false, cursor.next().is_valid());
   }
 
   void test_max_by_str(void)
@@ -90,10 +90,10 @@ namespace test_dat_id_cursor
     cursor.open(trie, grn::dat::String(), grn::dat::String("オレンジ"));
     for (grn::dat::UInt32 i = trie.min_key_id(); i <= max_key_id; ++i) {
       const grn::dat::Key &key = cursor.next();
-      cppcut_assert_equal(key.is_valid(), true);
-      cppcut_assert_equal(key.id(), i);
+      cppcut_assert_equal(true, key.is_valid());
+      cppcut_assert_equal(i, key.id());
     }
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(false, cursor.next().is_valid());
   }
 
   void test_min_max_by_str(void)
@@ -111,10 +111,10 @@ namespace test_dat_id_cursor
     cursor.open(trie, grn::dat::String("みかん"), grn::dat::String("八朔"));
     for (grn::dat::UInt32 i = min_key_id; i <= max_key_id; ++i) {
       const grn::dat::Key &key = cursor.next();
-      cppcut_assert_equal(key.is_valid(), true);
-      cppcut_assert_equal(key.id(), i);
+      cppcut_assert_equal(true, key.is_valid());
+      cppcut_assert_equal(i, key.id());
     }
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(false, cursor.next().is_valid());
   }
 
   void test_invalid_id(void)
@@ -126,10 +126,10 @@ namespace test_dat_id_cursor
     cursor.open(trie, grn::dat::INVALID_KEY_ID, grn::dat::INVALID_KEY_ID);
     for (grn::dat::UInt32 i = trie.min_key_id(); i <= trie.max_key_id(); ++i) {
       const grn::dat::Key &key = cursor.next();
-      cppcut_assert_equal(key.is_valid(), true);
-      cppcut_assert_equal(key.id(), i);
+      cppcut_assert_equal(true, key.is_valid());
+      cppcut_assert_equal(i, key.id());
     }
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(false, cursor.next().is_valid());
   }
 
   void test_min_by_id(void)
@@ -145,10 +145,10 @@ namespace test_dat_id_cursor
     cursor.open(trie, min_key_id, grn::dat::INVALID_KEY_ID);
     for (grn::dat::UInt32 i = min_key_id; i <= trie.max_key_id(); ++i) {
       const grn::dat::Key &key = cursor.next();
-      cppcut_assert_equal(key.is_valid(), true);
-      cppcut_assert_equal(key.id(), i);
+      cppcut_assert_equal(true, key.is_valid());
+      cppcut_assert_equal(i, key.id());
     }
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(false, cursor.next().is_valid());
   }
 
   void test_max_by_id(void)
@@ -164,10 +164,10 @@ namespace test_dat_id_cursor
     cursor.open(trie, grn::dat::INVALID_KEY_ID, max_key_id);
     for (grn::dat::UInt32 i = trie.min_key_id(); i <= max_key_id; ++i) {
       const grn::dat::Key &key = cursor.next();
-      cppcut_assert_equal(key.is_valid(), true);
-      cppcut_assert_equal(key.id(), i);
+      cppcut_assert_equal(true, key.is_valid());
+      cppcut_assert_equal(i, key.id());
     }
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(false, cursor.next().is_valid());
   }
 
   void test_min_max_by_id(void)
@@ -185,10 +185,10 @@ namespace test_dat_id_cursor
     cursor.open(trie, min_key_id, max_key_id);
     for (grn::dat::UInt32 i = min_key_id; i <= max_key_id; ++i) {
       const grn::dat::Key &key = cursor.next();
-      cppcut_assert_equal(key.is_valid(), true);
-      cppcut_assert_equal(key.id(), i);
+      cppcut_assert_equal(true, key.is_valid());
+      cppcut_assert_equal(i, key.id());
     }
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(false, cursor.next().is_valid());
   }
 
   void test_offset(void)
@@ -201,29 +201,29 @@ namespace test_dat_id_cursor
     cursor.open(trie, 2, 5, 0);
     for (grn::dat::UInt32 i = 2; i <= 5; ++i) {
       const grn::dat::Key &key = cursor.next();
-      cppcut_assert_equal(key.is_valid(), true);
-      cppcut_assert_equal(key.id(), i);
+      cppcut_assert_equal(true, key.is_valid());
+      cppcut_assert_equal(i, key.id());
     }
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    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) {
       const grn::dat::Key &key = cursor.next();
-      cppcut_assert_equal(key.is_valid(), true);
-      cppcut_assert_equal(key.id(), i);
+      cppcut_assert_equal(true, key.is_valid());
+      cppcut_assert_equal(i, key.id());
     }
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(false, cursor.next().is_valid());
 
     cursor.open(trie, 3, 7, 2);
     for (grn::dat::UInt32 i = 3 + 2; i <= 7; ++i) {
       const grn::dat::Key &key = cursor.next();
-      cppcut_assert_equal(key.is_valid(), true);
-      cppcut_assert_equal(key.id(), i);
+      cppcut_assert_equal(true, key.is_valid());
+      cppcut_assert_equal(i, key.id());
     }
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(false, cursor.next().is_valid());
 
     cursor.open(trie, 2, 5, 100);
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(false, cursor.next().is_valid());
   }
 
   void test_limit(void)
@@ -236,29 +236,29 @@ namespace test_dat_id_cursor
     cursor.open(trie, 3, 6, 0, grn::dat::UINT32_MAX);
     for (grn::dat::UInt32 i = 3; i <= 6; ++i) {
       const grn::dat::Key &key = cursor.next();
-      cppcut_assert_equal(key.is_valid(), true);
-      cppcut_assert_equal(key.id(), i);
+      cppcut_assert_equal(true, key.is_valid());
+      cppcut_assert_equal(i, key.id());
     }
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    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) {
       const grn::dat::Key &key = cursor.next();
-      cppcut_assert_equal(key.is_valid(), true);
-      cppcut_assert_equal(key.id(), i);
+      cppcut_assert_equal(true, key.is_valid());
+      cppcut_assert_equal(i, key.id());
     }
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(false, cursor.next().is_valid());
 
     cursor.open(trie, 3, 7, 1, 2);
     for (grn::dat::UInt32 i = 3 + 1; i < (3 + 1 + 2); ++i) {
       const grn::dat::Key &key = cursor.next();
-      cppcut_assert_equal(key.is_valid(), true);
-      cppcut_assert_equal(key.id(), i);
+      cppcut_assert_equal(true, key.is_valid());
+      cppcut_assert_equal(i, key.id());
     }
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(false, cursor.next().is_valid());
 
     cursor.open(trie, 2, 5, 0, 0);
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(false, cursor.next().is_valid());
   }
 
   void test_ascending_cursor(void)
@@ -272,27 +272,27 @@ namespace test_dat_id_cursor
                 0, grn::dat::UINT32_MAX, grn::dat::ASCENDING_CURSOR);
     for (grn::dat::UInt32 i = trie.min_key_id(); i <= trie.max_key_id(); ++i) {
       const grn::dat::Key &key = cursor.next();
-      cppcut_assert_equal(key.is_valid(), true);
-      cppcut_assert_equal(key.id(), i);
+      cppcut_assert_equal(true, key.is_valid());
+      cppcut_assert_equal(i, key.id());
     }
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(false, cursor.next().is_valid());
 
     cursor.open(trie, 2, 7, 0, grn::dat::UINT32_MAX,
                 grn::dat::ASCENDING_CURSOR);
     for (grn::dat::UInt32 i = 2; i <= 7; ++i) {
       const grn::dat::Key &key = cursor.next();
-      cppcut_assert_equal(key.is_valid(), true);
-      cppcut_assert_equal(key.id(), i);
+      cppcut_assert_equal(true, key.is_valid());
+      cppcut_assert_equal(i, key.id());
     }
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(false, cursor.next().is_valid());
 
     cursor.open(trie, 3, 6, 1, 5, grn::dat::ASCENDING_CURSOR);
     for (grn::dat::UInt32 i = 3 + 1; i <= 6; ++i) {
       const grn::dat::Key &key = cursor.next();
-      cppcut_assert_equal(key.is_valid(), true);
-      cppcut_assert_equal(key.id(), i);
+      cppcut_assert_equal(true, key.is_valid());
+      cppcut_assert_equal(i, key.id());
     }
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(false, cursor.next().is_valid());
   }
 
   void test_descending_cursor(void)
@@ -306,27 +306,27 @@ namespace test_dat_id_cursor
                 0, grn::dat::UINT32_MAX, grn::dat::DESCENDING_CURSOR);
     for (grn::dat::UInt32 i = trie.max_key_id(); i >= trie.min_key_id(); --i) {
       const grn::dat::Key &key = cursor.next();
-      cppcut_assert_equal(key.is_valid(), true);
-      cppcut_assert_equal(key.id(), i);
+      cppcut_assert_equal(true, key.is_valid());
+      cppcut_assert_equal(i, key.id());
     }
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(false, cursor.next().is_valid());
 
     cursor.open(trie, 2, 7, 0, grn::dat::UINT32_MAX,
                 grn::dat::DESCENDING_CURSOR);
     for (grn::dat::UInt32 i = 7; i >= 2; --i) {
       const grn::dat::Key &key = cursor.next();
-      cppcut_assert_equal(key.is_valid(), true);
-      cppcut_assert_equal(key.id(), i);
+      cppcut_assert_equal(true, key.is_valid());
+      cppcut_assert_equal(i, key.id());
     }
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(false, cursor.next().is_valid());
 
     cursor.open(trie, 2, 8, 2, 3, grn::dat::DESCENDING_CURSOR);
     for (grn::dat::UInt32 i = 8 - 2; i > (8 - 2 - 3); --i) {
       const grn::dat::Key &key = cursor.next();
-      cppcut_assert_equal(key.is_valid(), true);
-      cppcut_assert_equal(key.id(), i);
+      cppcut_assert_equal(true, key.is_valid());
+      cppcut_assert_equal(i, key.id());
     }
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(false, cursor.next().is_valid());
   }
 
   void test_except_boundary(void)
@@ -341,35 +341,35 @@ namespace test_dat_id_cursor
                 grn::dat::EXCEPT_LOWER_BOUND | grn::dat::EXCEPT_UPPER_BOUND);
     for (grn::dat::UInt32 i = trie.min_key_id(); i <= trie.max_key_id(); ++i) {
       const grn::dat::Key &key = cursor.next();
-      cppcut_assert_equal(key.is_valid(), true);
-      cppcut_assert_equal(key.id(), i);
+      cppcut_assert_equal(true, key.is_valid());
+      cppcut_assert_equal(i, key.id());
     }
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(false, cursor.next().is_valid());
 
     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) {
       const grn::dat::Key &key = cursor.next();
-      cppcut_assert_equal(key.is_valid(), true);
-      cppcut_assert_equal(key.id(), i);
+      cppcut_assert_equal(true, key.is_valid());
+      cppcut_assert_equal(i, key.id());
     }
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(false, cursor.next().is_valid());
 
     cursor.open(trie, 2, 7, 1, 100, grn::dat::EXCEPT_LOWER_BOUND);
     for (grn::dat::UInt32 i = 2 + 1 + 1; i <= 7; ++i) {
       const grn::dat::Key &key = cursor.next();
-      cppcut_assert_equal(key.is_valid(), true);
-      cppcut_assert_equal(key.id(), i);
+      cppcut_assert_equal(true, key.is_valid());
+      cppcut_assert_equal(i, key.id());
     }
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(false, cursor.next().is_valid());
 
     cursor.open(trie, 2, 7, 1, 100, grn::dat::EXCEPT_UPPER_BOUND);
     for (grn::dat::UInt32 i = 2 + 1; i <= (7 - 1); ++i) {
       const grn::dat::Key &key = cursor.next();
-      cppcut_assert_equal(key.is_valid(), true);
-      cppcut_assert_equal(key.id(), i);
+      cppcut_assert_equal(true, key.is_valid());
+      cppcut_assert_equal(i, key.id());
     }
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(false, cursor.next().is_valid());
   }
 }

  Modified: test/unit/core/dat/test-key-cursor.cpp (+110 -110)
===================================================================
--- test/unit/core/dat/test-key-cursor.cpp    2011-11-11 01:47:12 +0000 (c3081be)
+++ test/unit/core/dat/test-key-cursor.cpp    2011-11-11 02:16:06 +0000 (33ee367)
@@ -49,14 +49,14 @@ namespace test_dat_key_cursor
 
     grn::dat::KeyCursor cursor;
     cursor.open(trie, grn::dat::String(), grn::dat::String());
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(5));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(4));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(6));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(7));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(3));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(2));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(1));
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(grn::dat::UInt32(5), cursor.next().id());
+    cppcut_assert_equal(grn::dat::UInt32(4), cursor.next().id());
+    cppcut_assert_equal(grn::dat::UInt32(6), cursor.next().id());
+    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());
+    cppcut_assert_equal(grn::dat::UInt32(1), cursor.next().id());
+    cppcut_assert_equal(false, cursor.next().is_valid());
   }
 
   void test_min(void)
@@ -67,19 +67,19 @@ namespace test_dat_key_cursor
     grn::dat::KeyCursor cursor;
 
     cursor.open(trie, grn::dat::String("Hobbit"), grn::dat::String());
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(7));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(3));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(2));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(1));
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    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());
+    cppcut_assert_equal(grn::dat::UInt32(1), cursor.next().id());
+    cppcut_assert_equal(false, cursor.next().is_valid());
 
     cursor.open(trie, grn::dat::String("T"), grn::dat::String());
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(2));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(1));
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(grn::dat::UInt32(2), cursor.next().id());
+    cppcut_assert_equal(grn::dat::UInt32(1), cursor.next().id());
+    cppcut_assert_equal(false, cursor.next().is_valid());
 
     cursor.open(trie, grn::dat::String("Z"), grn::dat::String());
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(false, cursor.next().is_valid());
   }
 
   void test_max_by_str(void)
@@ -90,17 +90,17 @@ namespace test_dat_key_cursor
     grn::dat::KeyCursor cursor;
 
     cursor.open(trie, grn::dat::String(), grn::dat::String("Elf"));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(5));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(4));
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(grn::dat::UInt32(5), cursor.next().id());
+    cppcut_assert_equal(grn::dat::UInt32(4), cursor.next().id());
+    cppcut_assert_equal(false, cursor.next().is_valid());
 
     cursor.open(trie, grn::dat::String(), grn::dat::String("F"));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(5));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(4));
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(grn::dat::UInt32(5), cursor.next().id());
+    cppcut_assert_equal(grn::dat::UInt32(4), cursor.next().id());
+    cppcut_assert_equal(false, cursor.next().is_valid());
 
     cursor.open(trie, grn::dat::String(), grn::dat::String("A"));
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(false, cursor.next().is_valid());
   }
 
   void test_min_max(void)
@@ -110,11 +110,11 @@ namespace test_dat_key_cursor
 
     grn::dat::KeyCursor cursor;
     cursor.open(trie, grn::dat::String("Gnome"), grn::dat::String("Trebor"));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(6));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(7));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(3));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(2));
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(grn::dat::UInt32(6), cursor.next().id());
+    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());
+    cppcut_assert_equal(false, cursor.next().is_valid());
   }
 
   void test_offset(void)
@@ -125,23 +125,23 @@ namespace test_dat_key_cursor
     grn::dat::KeyCursor cursor;
 
     cursor.open(trie, grn::dat::String("Hobbit"), grn::dat::String("Trebor"), 0);
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(7));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(3));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(2));
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    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());
+    cppcut_assert_equal(false, cursor.next().is_valid());
 
     cursor.open(trie, grn::dat::String(), grn::dat::String(), 5);
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(2));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(1));
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(grn::dat::UInt32(2), cursor.next().id());
+    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);
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(3));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(2));
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    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);
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(false, cursor.next().is_valid());
   }
 
   void test_limit(void)
@@ -153,27 +153,27 @@ namespace test_dat_key_cursor
 
     cursor.open(trie, grn::dat::String("Gnome"), grn::dat::String("Werdna"),
                 0, grn::dat::UINT32_MAX);
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(6));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(7));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(3));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(2));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(1));
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(grn::dat::UInt32(6), cursor.next().id());
+    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());
+    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("Werdna"),
                 0, 3);
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(6));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(7));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(3));
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(grn::dat::UInt32(6), cursor.next().id());
+    cppcut_assert_equal(grn::dat::UInt32(7), cursor.next().id());
+    cppcut_assert_equal(grn::dat::UInt32(3), cursor.next().id());
+    cppcut_assert_equal(false, cursor.next().is_valid());
 
     cursor.open(trie, grn::dat::String("A"), grn::dat::String("Z"), 3, 2);
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(7));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(3));
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(grn::dat::UInt32(7), cursor.next().id());
+    cppcut_assert_equal(grn::dat::UInt32(3), cursor.next().id());
+    cppcut_assert_equal(false, cursor.next().is_valid());
 
     cursor.open(trie, grn::dat::String("A"), grn::dat::String("Z"), 0, 0);
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(false, cursor.next().is_valid());
   }
 
   void test_ascending_cursor(void)
@@ -185,28 +185,28 @@ namespace test_dat_key_cursor
 
     cursor.open(trie, grn::dat::String(), grn::dat::String(),
                 0, grn::dat::UINT32_MAX, grn::dat::ASCENDING_CURSOR);
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(5));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(4));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(6));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(7));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(3));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(2));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(1));
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(grn::dat::UInt32(5), cursor.next().id());
+    cppcut_assert_equal(grn::dat::UInt32(4), cursor.next().id());
+    cppcut_assert_equal(grn::dat::UInt32(6), cursor.next().id());
+    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());
+    cppcut_assert_equal(grn::dat::UInt32(1), cursor.next().id());
+    cppcut_assert_equal(false, cursor.next().is_valid());
 
     cursor.open(trie, grn::dat::String("Elf"), grn::dat::String("Human"),
                 0, grn::dat::UINT32_MAX, grn::dat::ASCENDING_CURSOR);
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(4));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(6));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(7));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(3));
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(grn::dat::UInt32(4), cursor.next().id());
+    cppcut_assert_equal(grn::dat::UInt32(6), cursor.next().id());
+    cppcut_assert_equal(grn::dat::UInt32(7), cursor.next().id());
+    cppcut_assert_equal(grn::dat::UInt32(3), cursor.next().id());
+    cppcut_assert_equal(false, cursor.next().is_valid());
 
     cursor.open(trie, grn::dat::String("Dwarf"), grn::dat::String("Trebor"),
                 3, 2, grn::dat::ASCENDING_CURSOR);
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(7));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(3));
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(grn::dat::UInt32(7), cursor.next().id());
+    cppcut_assert_equal(grn::dat::UInt32(3), cursor.next().id());
+    cppcut_assert_equal(false, cursor.next().is_valid());
   }
 
   void test_descending_cursor(void)
@@ -218,28 +218,28 @@ namespace test_dat_key_cursor
 
     cursor.open(trie, grn::dat::String(), grn::dat::String(),
                 0, grn::dat::UINT32_MAX, grn::dat::DESCENDING_CURSOR);
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(1));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(2));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(3));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(7));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(6));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(4));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(5));
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(grn::dat::UInt32(1), cursor.next().id());
+    cppcut_assert_equal(grn::dat::UInt32(2), cursor.next().id());
+    cppcut_assert_equal(grn::dat::UInt32(3), cursor.next().id());
+    cppcut_assert_equal(grn::dat::UInt32(7), cursor.next().id());
+    cppcut_assert_equal(grn::dat::UInt32(6), cursor.next().id());
+    cppcut_assert_equal(grn::dat::UInt32(4), cursor.next().id());
+    cppcut_assert_equal(grn::dat::UInt32(5), cursor.next().id());
+    cppcut_assert_equal(false, cursor.next().is_valid());
 
     cursor.open(trie, grn::dat::String("Elf"), grn::dat::String("Human"),
                 0, grn::dat::UINT32_MAX, grn::dat::DESCENDING_CURSOR);
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(3));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(7));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(6));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(4));
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(grn::dat::UInt32(3), cursor.next().id());
+    cppcut_assert_equal(grn::dat::UInt32(7), cursor.next().id());
+    cppcut_assert_equal(grn::dat::UInt32(6), cursor.next().id());
+    cppcut_assert_equal(grn::dat::UInt32(4), cursor.next().id());
+    cppcut_assert_equal(false, cursor.next().is_valid());
 
     cursor.open(trie, grn::dat::String("Dwarf"), grn::dat::String("Trebor"),
                 3, 2, grn::dat::DESCENDING_CURSOR);
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(6));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(4));
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(grn::dat::UInt32(6), cursor.next().id());
+    cppcut_assert_equal(grn::dat::UInt32(4), cursor.next().id());
+    cppcut_assert_equal(false, cursor.next().is_valid());
   }
 
   void test_except_boundary(void)
@@ -252,43 +252,43 @@ namespace test_dat_key_cursor
     cursor.open(trie, grn::dat::String(), grn::dat::String(),
                 0, grn::dat::UINT32_MAX,
                 grn::dat::EXCEPT_LOWER_BOUND | grn::dat::EXCEPT_UPPER_BOUND);
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(5));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(4));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(6));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(7));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(3));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(2));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(1));
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(grn::dat::UInt32(5), cursor.next().id());
+    cppcut_assert_equal(grn::dat::UInt32(4), cursor.next().id());
+    cppcut_assert_equal(grn::dat::UInt32(6), cursor.next().id());
+    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());
+    cppcut_assert_equal(grn::dat::UInt32(1), cursor.next().id());
+    cppcut_assert_equal(false, cursor.next().is_valid());
 
     cursor.open(trie, grn::dat::String("Dwarf"), grn::dat::String("Werdna"),
                 0, grn::dat::UINT32_MAX,
                 grn::dat::EXCEPT_LOWER_BOUND | grn::dat::EXCEPT_UPPER_BOUND);
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(4));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(6));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(7));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(3));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(2));
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(grn::dat::UInt32(4), cursor.next().id());
+    cppcut_assert_equal(grn::dat::UInt32(6), cursor.next().id());
+    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());
+    cppcut_assert_equal(false, cursor.next().is_valid());
 
     cursor.open(trie, grn::dat::String("Elf"), grn::dat::String("Trebor"),
                 2, 100, grn::dat::EXCEPT_LOWER_BOUND);
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(3));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(2));
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    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("Elf"), grn::dat::String("Trebor"),
                 2, 100, grn::dat::EXCEPT_UPPER_BOUND);
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(7));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(3));
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(grn::dat::UInt32(7), cursor.next().id());
+    cppcut_assert_equal(grn::dat::UInt32(3), cursor.next().id());
+    cppcut_assert_equal(false, cursor.next().is_valid());
 
     cursor.open(trie, grn::dat::String("Fighter"), grn::dat::String("Samurai"),
                 0, grn::dat::UINT32_MAX,
                 grn::dat::EXCEPT_LOWER_BOUND | grn::dat::EXCEPT_UPPER_BOUND);
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(6));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(7));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(3));
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(grn::dat::UInt32(6), cursor.next().id());
+    cppcut_assert_equal(grn::dat::UInt32(7), cursor.next().id());
+    cppcut_assert_equal(grn::dat::UInt32(3), cursor.next().id());
+    cppcut_assert_equal(false, cursor.next().is_valid());
   }
 }

  Modified: test/unit/core/dat/test-key.cpp (+12 -12)
===================================================================
--- test/unit/core/dat/test-key.cpp    2011-11-11 01:47:12 +0000 (d0c54a9)
+++ test/unit/core/dat/test-key.cpp    2011-11-11 02:16:06 +0000 (ac2e399)
@@ -37,19 +37,19 @@ namespace test_dat_key
 {
   void test_size_estimation(void)
   {
-    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::UInt32(2), grn::dat::Key::estimate_size(0));
+    cppcut_assert_equal(grn::dat::UInt32(2), grn::dat::Key::estimate_size(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));
+    cppcut_assert_equal(grn::dat::UInt32(3), grn::dat::Key::estimate_size(4));
+    cppcut_assert_equal(grn::dat::UInt32(3), grn::dat::Key::estimate_size(7));
   }
 
   void test_invalid_key(void)
   {
     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(), grn::dat::UInt32(0));
+    cppcut_assert_equal(grn::dat::INVALID_KEY_ID, key.id());
+    cppcut_assert_equal(grn::dat::UInt32(0), key.length());
     cut_assert(key.ptr() != static_cast<const void *>(NULL));
   }
 
@@ -58,11 +58,11 @@ namespace test_dat_key
     grn::dat::UInt32 buf[16];
     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(), 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(grn::dat::String("groonga"), key.str());
+    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());
   }
 }

  Modified: test/unit/core/dat/test-node.cpp (+22 -22)
===================================================================
--- test/unit/core/dat/test-node.cpp    2011-11-11 01:47:12 +0000 (0c10efa)
+++ test/unit/core/dat/test-node.cpp    2011-11-11 02:16:06 +0000 (95711d2)
@@ -61,19 +61,19 @@ namespace test_dat_node
     grn::dat::Node node;
     grn::dat::Base base;
 
-    cppcut_assert_equal(node.base(), base);
+    cppcut_assert_equal(base, node.base());
 
     node.set_key_pos(100);
     base.set_key_pos(100);
-    cppcut_assert_equal(node.base(), base);
-    cppcut_assert_equal(node.is_linker(), base.is_linker());
-    cppcut_assert_equal(node.key_pos(), base.key_pos());
+    cppcut_assert_equal(base, node.base());
+    cppcut_assert_equal(base.is_linker(), node.is_linker());
+    cppcut_assert_equal(base.key_pos(), node.key_pos());
 
     node.set_offset(1000);
     base.set_offset(1000);
-    cppcut_assert_equal(node.base(), base);
-    cppcut_assert_equal(node.is_linker(), base.is_linker());
-    cppcut_assert_equal(node.offset(), base.offset());
+    cppcut_assert_equal(base, node.base());
+    cppcut_assert_equal(base.is_linker(), node.is_linker());
+    cppcut_assert_equal(base.offset(), node.offset());
   }
 
   void test_check(void)
@@ -81,39 +81,39 @@ namespace test_dat_node
     grn::dat::Node node;
     grn::dat::Check check;
 
-    cppcut_assert_equal(node.check(), check);
+    cppcut_assert_equal(check, node.check());
 
     node.set_is_offset(true);
     check.set_is_offset(true);
-    cppcut_assert_equal(node.check(), check);
-    cppcut_assert_equal(node.is_offset(), check.is_offset());
+    cppcut_assert_equal(check, node.check());
+    cppcut_assert_equal(check.is_offset(), node.is_offset());
 
     node.set_offset(grn::dat::INVALID_OFFSET);
 
     node.set_is_phantom(true);
     check.set_is_phantom(true);
-    cppcut_assert_equal(node.check(), check);
-    cppcut_assert_equal(node.is_phantom(), check.is_phantom());
+    cppcut_assert_equal(check, node.check());
+    cppcut_assert_equal(check.is_phantom(), node.is_phantom());
 
     node.set_next(101);
     node.set_prev(99);
     check.set_next(101);
     check.set_prev(99);
-    cppcut_assert_equal(node.check(), check);
-    cppcut_assert_equal(node.next(), check.next());
-    cppcut_assert_equal(node.prev(), check.prev());
+    cppcut_assert_equal(check, node.check());
+    cppcut_assert_equal(check.next(), node.next());
+    cppcut_assert_equal(check.prev(), node.prev());
 
     node.set_is_phantom(false);
     check.set_is_phantom(false);
-    cppcut_assert_equal(node.check(), check);
-    cppcut_assert_equal(node.is_phantom(), check.is_phantom());
-    cppcut_assert_equal(node.label(), check.label());
-    cppcut_assert_equal(node.child(), check.child());
-    cppcut_assert_equal(node.sibling(), check.sibling());
+    cppcut_assert_equal(check, node.check());
+    cppcut_assert_equal(check.is_phantom(), node.is_phantom());
+    cppcut_assert_equal(check.label(), node.label());
+    cppcut_assert_equal(check.child(), node.child());
+    cppcut_assert_equal(check.sibling(), node.sibling());
 
     node.set_label('a');
     check.set_label('a');
-    cppcut_assert_equal(node.check(), check);
-    cppcut_assert_equal(node.label(), check.label());
+    cppcut_assert_equal(check, node.check());
+    cppcut_assert_equal(check.label(), node.label());
   }
 }

  Modified: test/unit/core/dat/test-predictive-cursor.cpp (+131 -131)
===================================================================
--- test/unit/core/dat/test-predictive-cursor.cpp    2011-11-11 01:47:12 +0000 (805a059)
+++ test/unit/core/dat/test-predictive-cursor.cpp    2011-11-11 02:16:06 +0000 (79aeca0)
@@ -48,13 +48,13 @@ namespace test_dat_predictive_cursor
 
     grn::dat::PredictiveCursor cursor;
     cursor.open(trie, grn::dat::String());
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(6));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(1));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(2));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(3));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(5));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(4));
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(grn::dat::UInt32(6), cursor.next().id());
+    cppcut_assert_equal(grn::dat::UInt32(1), cursor.next().id());
+    cppcut_assert_equal(grn::dat::UInt32(2), cursor.next().id());
+    cppcut_assert_equal(grn::dat::UInt32(3), cursor.next().id());
+    cppcut_assert_equal(grn::dat::UInt32(5), cursor.next().id());
+    cppcut_assert_equal(grn::dat::UInt32(4), cursor.next().id());
+    cppcut_assert_equal(false, cursor.next().is_valid());
   }
 
   void test_str(void)
@@ -65,35 +65,35 @@ namespace test_dat_predictive_cursor
     grn::dat::PredictiveCursor cursor;
 
     cursor.open(trie, grn::dat::String("北斗"));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(1));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(2));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(3));
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(grn::dat::UInt32(1), cursor.next().id());
+    cppcut_assert_equal(grn::dat::UInt32(2), cursor.next().id());
+    cppcut_assert_equal(grn::dat::UInt32(3), cursor.next().id());
+    cppcut_assert_equal(false, cursor.next().is_valid());
 
     cursor.open(trie, grn::dat::String("北斗神拳"));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(2));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(3));
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(grn::dat::UInt32(2), cursor.next().id());
+    cppcut_assert_equal(grn::dat::UInt32(3), cursor.next().id());
+    cppcut_assert_equal(false, cursor.next().is_valid());
 
     cursor.open(trie, grn::dat::String("北斗神拳伝承者"));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(3));
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(grn::dat::UInt32(3), cursor.next().id());
+    cppcut_assert_equal(false, cursor.next().is_valid());
 
     cursor.open(trie, grn::dat::String("南斗"));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(5));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(4));
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(grn::dat::UInt32(5), cursor.next().id());
+    cppcut_assert_equal(grn::dat::UInt32(4), cursor.next().id());
+    cppcut_assert_equal(false, cursor.next().is_valid());
 
     cursor.open(trie, grn::dat::String("南斗聖拳"));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(4));
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(grn::dat::UInt32(4), cursor.next().id());
+    cppcut_assert_equal(false, cursor.next().is_valid());
 
     cursor.open(trie, grn::dat::String("南斗水鳥拳"));
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(false, cursor.next().is_valid());
 
     cursor.open(trie, grn::dat::String("元斗"));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(6));
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(grn::dat::UInt32(6), cursor.next().id());
+    cppcut_assert_equal(false, cursor.next().is_valid());
   }
 
   void test_offset(void)
@@ -104,26 +104,26 @@ namespace test_dat_predictive_cursor
     grn::dat::PredictiveCursor cursor;
 
     cursor.open(trie, grn::dat::String(), 0);
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(6));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(1));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(2));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(3));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(5));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(4));
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(grn::dat::UInt32(6), cursor.next().id());
+    cppcut_assert_equal(grn::dat::UInt32(1), cursor.next().id());
+    cppcut_assert_equal(grn::dat::UInt32(2), cursor.next().id());
+    cppcut_assert_equal(grn::dat::UInt32(3), cursor.next().id());
+    cppcut_assert_equal(grn::dat::UInt32(5), cursor.next().id());
+    cppcut_assert_equal(grn::dat::UInt32(4), cursor.next().id());
+    cppcut_assert_equal(false, cursor.next().is_valid());
 
     cursor.open(trie, grn::dat::String(), 3);
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(3));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(5));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(4));
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(grn::dat::UInt32(3), cursor.next().id());
+    cppcut_assert_equal(grn::dat::UInt32(5), cursor.next().id());
+    cppcut_assert_equal(grn::dat::UInt32(4), cursor.next().id());
+    cppcut_assert_equal(false, cursor.next().is_valid());
 
     cursor.open(trie, grn::dat::String("北斗"), 2);
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(3));
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(grn::dat::UInt32(3), cursor.next().id());
+    cppcut_assert_equal(false, cursor.next().is_valid());
 
     cursor.open(trie, grn::dat::String("北斗"), 5);
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(false, cursor.next().is_valid());
   }
 
   void test_limit(void)
@@ -134,43 +134,43 @@ namespace test_dat_predictive_cursor
     grn::dat::PredictiveCursor cursor;
 
     cursor.open(trie, grn::dat::String(), 0, grn::dat::UINT32_MAX);
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(6));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(1));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(2));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(3));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(5));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(4));
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(grn::dat::UInt32(6), cursor.next().id());
+    cppcut_assert_equal(grn::dat::UInt32(1), cursor.next().id());
+    cppcut_assert_equal(grn::dat::UInt32(2), cursor.next().id());
+    cppcut_assert_equal(grn::dat::UInt32(3), cursor.next().id());
+    cppcut_assert_equal(grn::dat::UInt32(5), cursor.next().id());
+    cppcut_assert_equal(grn::dat::UInt32(4), cursor.next().id());
+    cppcut_assert_equal(false, cursor.next().is_valid());
 
     cursor.open(trie, grn::dat::String(), 0, 4);
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(6));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(1));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(2));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(3));
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(grn::dat::UInt32(6), cursor.next().id());
+    cppcut_assert_equal(grn::dat::UInt32(1), cursor.next().id());
+    cppcut_assert_equal(grn::dat::UInt32(2), cursor.next().id());
+    cppcut_assert_equal(grn::dat::UInt32(3), cursor.next().id());
+    cppcut_assert_equal(false, cursor.next().is_valid());
 
     cursor.open(trie, grn::dat::String(), 2, 3);
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(2));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(3));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(5));
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(grn::dat::UInt32(2), cursor.next().id());
+    cppcut_assert_equal(grn::dat::UInt32(3), cursor.next().id());
+    cppcut_assert_equal(grn::dat::UInt32(5), cursor.next().id());
+    cppcut_assert_equal(false, cursor.next().is_valid());
 
     cursor.open(trie, grn::dat::String("北斗"), 0, 2);
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(1));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(2));
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(grn::dat::UInt32(1), 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("北斗"), 1, 1);
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(2));
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(grn::dat::UInt32(2), cursor.next().id());
+    cppcut_assert_equal(false, cursor.next().is_valid());
 
     cursor.open(trie, grn::dat::String("南斗"), 0, 0);
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(false, cursor.next().is_valid());
 
     cursor.open(trie, grn::dat::String("北斗"), 1, 100);
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(2));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(3));
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(grn::dat::UInt32(2), cursor.next().id());
+    cppcut_assert_equal(grn::dat::UInt32(3), cursor.next().id());
+    cppcut_assert_equal(false, cursor.next().is_valid());
   }
 
   void test_ascending_cursor(void)
@@ -182,33 +182,33 @@ namespace test_dat_predictive_cursor
 
     cursor.open(trie, grn::dat::String(), 0, grn::dat::UINT32_MAX,
                 grn::dat::ASCENDING_CURSOR);
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(6));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(1));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(2));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(3));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(5));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(4));
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(grn::dat::UInt32(6), cursor.next().id());
+    cppcut_assert_equal(grn::dat::UInt32(1), cursor.next().id());
+    cppcut_assert_equal(grn::dat::UInt32(2), cursor.next().id());
+    cppcut_assert_equal(grn::dat::UInt32(3), cursor.next().id());
+    cppcut_assert_equal(grn::dat::UInt32(5), cursor.next().id());
+    cppcut_assert_equal(grn::dat::UInt32(4), cursor.next().id());
+    cppcut_assert_equal(false, cursor.next().is_valid());
 
     cursor.open(trie, grn::dat::String(), 3, grn::dat::UINT32_MAX,
                 grn::dat::ASCENDING_CURSOR);
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(3));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(5));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(4));
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(grn::dat::UInt32(3), cursor.next().id());
+    cppcut_assert_equal(grn::dat::UInt32(5), cursor.next().id());
+    cppcut_assert_equal(grn::dat::UInt32(4), cursor.next().id());
+    cppcut_assert_equal(false, cursor.next().is_valid());
 
     cursor.open(trie, grn::dat::String(), 3, 2,
                 grn::dat::ASCENDING_CURSOR);
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(3));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(5));
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(grn::dat::UInt32(3), cursor.next().id());
+    cppcut_assert_equal(grn::dat::UInt32(5), cursor.next().id());
+    cppcut_assert_equal(false, cursor.next().is_valid());
 
     cursor.open(trie, grn::dat::String("北斗"), 0, grn::dat::UINT32_MAX,
                 grn::dat::ASCENDING_CURSOR);
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(1));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(2));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(3));
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(grn::dat::UInt32(1), cursor.next().id());
+    cppcut_assert_equal(grn::dat::UInt32(2), cursor.next().id());
+    cppcut_assert_equal(grn::dat::UInt32(3), cursor.next().id());
+    cppcut_assert_equal(false, cursor.next().is_valid());
   }
 
   void test_descending_cursor(void)
@@ -220,51 +220,51 @@ namespace test_dat_predictive_cursor
 
     cursor.open(trie, grn::dat::String(), 0, grn::dat::UINT32_MAX,
                 grn::dat::DESCENDING_CURSOR);
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(4));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(5));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(3));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(2));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(1));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(6));
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(grn::dat::UInt32(4), cursor.next().id());
+    cppcut_assert_equal(grn::dat::UInt32(5), cursor.next().id());
+    cppcut_assert_equal(grn::dat::UInt32(3), cursor.next().id());
+    cppcut_assert_equal(grn::dat::UInt32(2), cursor.next().id());
+    cppcut_assert_equal(grn::dat::UInt32(1), cursor.next().id());
+    cppcut_assert_equal(grn::dat::UInt32(6), cursor.next().id());
+    cppcut_assert_equal(false, cursor.next().is_valid());
 
     cursor.open(trie, grn::dat::String(), 3, grn::dat::UINT32_MAX,
                 grn::dat::DESCENDING_CURSOR);
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(2));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(1));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(6));
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(grn::dat::UInt32(2), cursor.next().id());
+    cppcut_assert_equal(grn::dat::UInt32(1), cursor.next().id());
+    cppcut_assert_equal(grn::dat::UInt32(6), cursor.next().id());
+    cppcut_assert_equal(false, cursor.next().is_valid());
 
     cursor.open(trie, grn::dat::String(), 3, 2,
                 grn::dat::DESCENDING_CURSOR);
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(2));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(1));
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(grn::dat::UInt32(2), cursor.next().id());
+    cppcut_assert_equal(grn::dat::UInt32(1), cursor.next().id());
+    cppcut_assert_equal(false, cursor.next().is_valid());
 
     cursor.open(trie, grn::dat::String("北斗"), 0, grn::dat::UINT32_MAX,
                 grn::dat::DESCENDING_CURSOR);
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(3));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(2));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(1));
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(grn::dat::UInt32(3), cursor.next().id());
+    cppcut_assert_equal(grn::dat::UInt32(2), cursor.next().id());
+    cppcut_assert_equal(grn::dat::UInt32(1), cursor.next().id());
+    cppcut_assert_equal(false, cursor.next().is_valid());
 
     cursor.open(trie, grn::dat::String("北斗"), 2, grn::dat::UINT32_MAX,
                 grn::dat::DESCENDING_CURSOR);
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(1));
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(grn::dat::UInt32(1), cursor.next().id());
+    cppcut_assert_equal(false, cursor.next().is_valid());
 
     cursor.open(trie, grn::dat::String("北斗"), 0, 1,
                 grn::dat::DESCENDING_CURSOR);
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(3));
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(grn::dat::UInt32(3), cursor.next().id());
+    cppcut_assert_equal(false, cursor.next().is_valid());
 
     cursor.open(trie, grn::dat::String("北斗"), 3, grn::dat::UINT32_MAX,
                 grn::dat::DESCENDING_CURSOR);
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(false, cursor.next().is_valid());
 
     cursor.open(trie, grn::dat::String("北斗"), 0, 0,
                 grn::dat::DESCENDING_CURSOR);
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(false, cursor.next().is_valid());
   }
 
   void test_except_boundary(void)
@@ -276,55 +276,55 @@ namespace test_dat_predictive_cursor
 
     cursor.open(trie, grn::dat::String(), 0, grn::dat::UINT32_MAX,
                 grn::dat::EXCEPT_EXACT_MATCH);
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(6));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(1));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(2));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(3));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(5));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(4));
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(grn::dat::UInt32(6), cursor.next().id());
+    cppcut_assert_equal(grn::dat::UInt32(1), cursor.next().id());
+    cppcut_assert_equal(grn::dat::UInt32(2), cursor.next().id());
+    cppcut_assert_equal(grn::dat::UInt32(3), cursor.next().id());
+    cppcut_assert_equal(grn::dat::UInt32(5), cursor.next().id());
+    cppcut_assert_equal(grn::dat::UInt32(4), 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);
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(1));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(2));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(3));
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(grn::dat::UInt32(1), cursor.next().id());
+    cppcut_assert_equal(grn::dat::UInt32(2), cursor.next().id());
+    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);
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(2));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(3));
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(grn::dat::UInt32(2), cursor.next().id());
+    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);
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(2));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(3));
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(grn::dat::UInt32(2), cursor.next().id());
+    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);
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(3));
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    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);
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(3));
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    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);
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(false, cursor.next().is_valid());
 
     cursor.open(trie, grn::dat::String("北斗"), 1, grn::dat::UINT32_MAX,
                 grn::dat::EXCEPT_EXACT_MATCH);
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(3));
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    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, 1,
                 grn::dat::EXCEPT_EXACT_MATCH);
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(2));
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(grn::dat::UInt32(2), cursor.next().id());
+    cppcut_assert_equal(false, cursor.next().is_valid());
   }
 }

  Modified: test/unit/core/dat/test-prefix-cursor.cpp (+104 -104)
===================================================================
--- test/unit/core/dat/test-prefix-cursor.cpp    2011-11-11 01:47:12 +0000 (f02debc)
+++ test/unit/core/dat/test-prefix-cursor.cpp    2011-11-11 02:16:06 +0000 (d87273b)
@@ -47,7 +47,7 @@ namespace test_dat_prefix_cursor
 
     grn::dat::PrefixCursor cursor;
     cursor.open(trie, grn::dat::String());
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(false, cursor.next().is_valid());
   }
 
   void test_str(void)
@@ -58,33 +58,33 @@ namespace test_dat_prefix_cursor
     grn::dat::PrefixCursor cursor;
 
     cursor.open(trie, grn::dat::String("京都"));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(2));
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(grn::dat::UInt32(2), cursor.next().id());
+    cppcut_assert_equal(false, cursor.next().is_valid());
 
     cursor.open(trie, grn::dat::String("京都府"));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(2));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(4));
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(grn::dat::UInt32(2), cursor.next().id());
+    cppcut_assert_equal(grn::dat::UInt32(4), cursor.next().id());
+    cppcut_assert_equal(false, cursor.next().is_valid());
 
     cursor.open(trie, grn::dat::String("東京"));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(1));
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(grn::dat::UInt32(1), cursor.next().id());
+    cppcut_assert_equal(false, cursor.next().is_valid());
 
     cursor.open(trie, grn::dat::String("東京都"));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(1));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(3));
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(grn::dat::UInt32(1), cursor.next().id());
+    cppcut_assert_equal(grn::dat::UInt32(3), cursor.next().id());
+    cppcut_assert_equal(false, cursor.next().is_valid());
 
     cursor.open(trie, grn::dat::String("東京都庁"));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(1));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(3));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(5));
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    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());
+    cppcut_assert_equal(false, cursor.next().is_valid());
 
     cursor.open(trie, grn::dat::String("東京都議会"));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(1));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(3));
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(grn::dat::UInt32(1), cursor.next().id());
+    cppcut_assert_equal(grn::dat::UInt32(3), cursor.next().id());
+    cppcut_assert_equal(false, cursor.next().is_valid());
   }
 
   void test_min_length(void)
@@ -95,34 +95,34 @@ namespace test_dat_prefix_cursor
     grn::dat::PrefixCursor cursor;
 
     cursor.open(trie, grn::dat::String("東京都庁ビル"), std::strlen(""));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(1));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(3));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(5));
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    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());
+    cppcut_assert_equal(false, cursor.next().is_valid());
 
     cursor.open(trie, grn::dat::String("東京都庁ビル"), std::strlen("東"));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(1));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(3));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(5));
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    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());
+    cppcut_assert_equal(false, cursor.next().is_valid());
 
     cursor.open(trie, grn::dat::String("東京都庁ビル"), std::strlen("東京"));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(1));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(3));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(5));
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    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());
+    cppcut_assert_equal(false, cursor.next().is_valid());
 
     cursor.open(trie, grn::dat::String("東京都庁ビル"), std::strlen("東京都"));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(3));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(5));
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(grn::dat::UInt32(3), cursor.next().id());
+    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("東京都庁"));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(5));
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    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("東京都庁ビル"));
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(false, cursor.next().is_valid());
   }
 
   void test_offset(void)
@@ -133,22 +133,22 @@ namespace test_dat_prefix_cursor
     grn::dat::PrefixCursor cursor;
 
     cursor.open(trie, grn::dat::String("東京都庁ビル"), 0, 0);
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(1));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(3));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(5));
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    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());
+    cppcut_assert_equal(false, cursor.next().is_valid());
 
     cursor.open(trie, grn::dat::String("東京都庁ビル"), 0, 1);
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(3));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(5));
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(grn::dat::UInt32(3), cursor.next().id());
+    cppcut_assert_equal(grn::dat::UInt32(5), cursor.next().id());
+    cppcut_assert_equal(false, cursor.next().is_valid());
 
     cursor.open(trie, grn::dat::String("東京都庁ビル"), 0, 2);
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(5));
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(grn::dat::UInt32(5), cursor.next().id());
+    cppcut_assert_equal(false, cursor.next().is_valid());
 
     cursor.open(trie, grn::dat::String("東京都庁ビル"), 0, 3);
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(false, cursor.next().is_valid());
   }
 
   void test_limit(void)
@@ -159,36 +159,36 @@ namespace test_dat_prefix_cursor
     grn::dat::PrefixCursor cursor;
 
     cursor.open(trie, grn::dat::String("東京都庁ビル"), 0, 0, grn::dat::UINT32_MAX);
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(1));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(3));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(5));
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    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());
+    cppcut_assert_equal(false, cursor.next().is_valid());
 
     cursor.open(trie, grn::dat::String("東京都庁ビル"), 0, 0, 3);
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(1));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(3));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(5));
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    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());
+    cppcut_assert_equal(false, cursor.next().is_valid());
 
     cursor.open(trie, grn::dat::String("東京都庁ビル"), 0, 0, 2);
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(1));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(3));
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(grn::dat::UInt32(1), cursor.next().id());
+    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, 0, 1);
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(1));
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(grn::dat::UInt32(1), cursor.next().id());
+    cppcut_assert_equal(false, cursor.next().is_valid());
 
     cursor.open(trie, grn::dat::String("東京都庁ビル"), 0, 0, 0);
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(false, cursor.next().is_valid());
 
     cursor.open(trie, grn::dat::String("東京都庁ビル"), 0, 2, 100);
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(5));
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(grn::dat::UInt32(5), cursor.next().id());
+    cppcut_assert_equal(false, cursor.next().is_valid());
 
     cursor.open(trie, grn::dat::String("東京都庁ビル"), 0, 1, 1);
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(3));
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(grn::dat::UInt32(3), cursor.next().id());
+    cppcut_assert_equal(false, cursor.next().is_valid());
   }
 
   void test_ascending_cursor(void)
@@ -200,25 +200,25 @@ namespace test_dat_prefix_cursor
 
     cursor.open(trie, grn::dat::String("京都府"), 0,
                 0, grn::dat::UINT32_MAX, grn::dat::ASCENDING_CURSOR);
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(2));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(4));
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(grn::dat::UInt32(2), cursor.next().id());
+    cppcut_assert_equal(grn::dat::UInt32(4), cursor.next().id());
+    cppcut_assert_equal(false, cursor.next().is_valid());
 
     cursor.open(trie, grn::dat::String("京都府"), std::strlen("京都"),
                 0, grn::dat::UINT32_MAX, grn::dat::ASCENDING_CURSOR);
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(2));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(4));
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(grn::dat::UInt32(2), cursor.next().id());
+    cppcut_assert_equal(grn::dat::UInt32(4), cursor.next().id());
+    cppcut_assert_equal(false, cursor.next().is_valid());
 
     cursor.open(trie, grn::dat::String("京都府"), 0,
                 1, grn::dat::UINT32_MAX, grn::dat::ASCENDING_CURSOR);
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(4));
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(grn::dat::UInt32(4), cursor.next().id());
+    cppcut_assert_equal(false, cursor.next().is_valid());
 
     cursor.open(trie, grn::dat::String("京都府"), 0,
                 0, 1, grn::dat::ASCENDING_CURSOR);
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(2));
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(grn::dat::UInt32(2), cursor.next().id());
+    cppcut_assert_equal(false, cursor.next().is_valid());
   }
 
   void test_descending_cursor(void)
@@ -230,38 +230,38 @@ namespace test_dat_prefix_cursor
 
     cursor.open(trie, grn::dat::String("東京都庁"), 0,
                 0, grn::dat::UINT32_MAX, grn::dat::DESCENDING_CURSOR);
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(5));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(3));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(1));
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(grn::dat::UInt32(5), cursor.next().id());
+    cppcut_assert_equal(grn::dat::UInt32(3), cursor.next().id());
+    cppcut_assert_equal(grn::dat::UInt32(1), cursor.next().id());
+    cppcut_assert_equal(false, cursor.next().is_valid());
 
     cursor.open(trie, grn::dat::String("東京都庁"), std::strlen("東京都"),
                 0, grn::dat::UINT32_MAX, grn::dat::DESCENDING_CURSOR);
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(5));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(3));
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(grn::dat::UInt32(5), cursor.next().id());
+    cppcut_assert_equal(grn::dat::UInt32(3), cursor.next().id());
+    cppcut_assert_equal(false, cursor.next().is_valid());
 
     cursor.open(trie, grn::dat::String("東京都庁"), std::strlen("東京都"),
                 1, grn::dat::UINT32_MAX, grn::dat::DESCENDING_CURSOR);
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(3));
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(grn::dat::UInt32(3), cursor.next().id());
+    cppcut_assert_equal(false, cursor.next().is_valid());
 
     cursor.open(trie, grn::dat::String("東京都庁"), std::strlen("東京都"),
                 0, 1, grn::dat::DESCENDING_CURSOR);
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(5));
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(grn::dat::UInt32(5), cursor.next().id());
+    cppcut_assert_equal(false, cursor.next().is_valid());
 
     cursor.open(trie, grn::dat::String("東京都庁"), 0,
                 1, grn::dat::UINT32_MAX, grn::dat::DESCENDING_CURSOR);
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(3));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(1));
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(grn::dat::UInt32(3), cursor.next().id());
+    cppcut_assert_equal(grn::dat::UInt32(1), cursor.next().id());
+    cppcut_assert_equal(false, cursor.next().is_valid());
 
     cursor.open(trie, grn::dat::String("東京都庁"), 0,
                 0, 2, grn::dat::DESCENDING_CURSOR);
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(5));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(3));
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(grn::dat::UInt32(5), cursor.next().id());
+    cppcut_assert_equal(grn::dat::UInt32(3), cursor.next().id());
+    cppcut_assert_equal(false, cursor.next().is_valid());
   }
 
   void test_except_boundary(void)
@@ -273,27 +273,27 @@ namespace test_dat_prefix_cursor
 
     cursor.open(trie, grn::dat::String("東京都庁ビル"), 0,
                 0, grn::dat::UINT32_MAX, grn::dat::EXCEPT_EXACT_MATCH);
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(1));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(3));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(5));
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    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());
+    cppcut_assert_equal(false, cursor.next().is_valid());
 
     cursor.open(trie, grn::dat::String("東京都庁ビル"), std::strlen("東京"),
                 0, grn::dat::UINT32_MAX, grn::dat::EXCEPT_EXACT_MATCH);
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(1));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(3));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(5));
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    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());
+    cppcut_assert_equal(false, cursor.next().is_valid());
 
     cursor.open(trie, grn::dat::String("東京都庁"), std::strlen("東京"),
                 0, grn::dat::UINT32_MAX, grn::dat::EXCEPT_EXACT_MATCH);
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(1));
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(3));
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(grn::dat::UInt32(1), cursor.next().id());
+    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,
                 0, grn::dat::UINT32_MAX, grn::dat::EXCEPT_EXACT_MATCH);
-    cppcut_assert_equal(cursor.next().id(), grn::dat::UInt32(2));
-    cppcut_assert_equal(cursor.next().is_valid(), false);
+    cppcut_assert_equal(grn::dat::UInt32(2), cursor.next().id());
+    cppcut_assert_equal(false, cursor.next().is_valid());
   }
 }

  Modified: test/unit/core/dat/test-string.cpp (+26 -26)
===================================================================
--- test/unit/core/dat/test-string.cpp    2011-11-11 01:47:12 +0000 (a6a6995)
+++ test/unit/core/dat/test-string.cpp    2011-11-11 02:16:06 +0000 (b0a5c83)
@@ -36,8 +36,8 @@ namespace test_dat_string
   {
     const grn::dat::String str;
 
-    cppcut_assert_equal(str.ptr(), static_cast<const void *>(NULL));
-    cppcut_assert_equal(str.length(), grn::dat::UInt32(0));
+    cppcut_assert_equal(static_cast<const void *>(NULL), str.ptr());
+    cppcut_assert_equal(grn::dat::UInt32(0), str.length());
   }
 
   void test_constructor_with_length(void)
@@ -45,9 +45,9 @@ namespace test_dat_string
     const char str_buf[] = "日本語";
     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(static_cast<const void *>(str_buf), str.ptr());
+    cppcut_assert_equal(static_cast<grn::dat::UInt32>(sizeof(str_buf) - 1),
+                        str.length());
   }
 
   void test_constructor_without_length(void)
@@ -55,9 +55,9 @@ namespace test_dat_string
     const char str_buf[] = "日本語";
     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(static_cast<const void *>(str_buf), str.ptr());
+    cppcut_assert_equal(static_cast<grn::dat::UInt32>(sizeof(str_buf) - 1),
+                        str.length());
   }
 
   void test_copy_constructor(void)
@@ -66,8 +66,8 @@ namespace test_dat_string
     const grn::dat::String str_origin(str_buf);
     const grn::dat::String str_copy(str_origin);
 
-    cppcut_assert_equal(str_origin.ptr(), str_copy.ptr());
-    cppcut_assert_equal(str_origin.length(), str_copy.length());
+    cppcut_assert_equal(str_copy.ptr(), str_origin.ptr());
+    cppcut_assert_equal(str_copy.length(), str_origin.length());
   }
 
   void test_index_access(void)
@@ -76,7 +76,7 @@ namespace test_dat_string
     const grn::dat::String str(str_buf);
 
     for (grn::dat::UInt32 i = 0; i < str.length(); ++i) {
-      cppcut_assert_equal(str[i], static_cast<grn::dat::UInt8>(str_buf[i]));
+      cppcut_assert_equal(static_cast<grn::dat::UInt8>(str_buf[i]), str[i]);
     }
   }
 
@@ -87,25 +87,25 @@ namespace test_dat_string
     grn::dat::String str;
     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(static_cast<const void *>(str_buf), str.ptr());
+    cppcut_assert_equal(static_cast<grn::dat::UInt32>(sizeof(str_buf) - 1),
+                        str.length());
   }
 
   void test_substr(void)
   {
     const grn::dat::String str("apple");
 
-    cppcut_assert_equal(str.substr(3), grn::dat::String("le"));
-    cppcut_assert_equal(str.substr(0, 3), grn::dat::String("app"));
-    cppcut_assert_equal(str.substr(1, 3), grn::dat::String("ppl"));
+    cppcut_assert_equal(grn::dat::String("le"), str.substr(3));
+    cppcut_assert_equal(grn::dat::String("app"), str.substr(0, 3));
+    cppcut_assert_equal(grn::dat::String("ppl"), str.substr(1, 3));
   }
 
   void test_compare(void)
   {
     const grn::dat::String str("apple");
 
-    cppcut_assert_equal(str.compare(grn::dat::String("apple")), 0);
+    cppcut_assert_equal(0, str.compare(grn::dat::String("apple")));
     cut_assert(str.compare(grn::dat::String("appl")) > 0);
     cut_assert(str.compare(grn::dat::String("appleX")) < 0);
     cut_assert(str.compare(grn::dat::String("banana")) < 0);
@@ -116,19 +116,19 @@ namespace test_dat_string
   {
     const grn::dat::String str("apple");
 
-    cppcut_assert_equal(str.starts_with(grn::dat::String("")), true);
-    cppcut_assert_equal(str.starts_with(grn::dat::String("app")), true);
-    cppcut_assert_equal(str.starts_with(grn::dat::String("apple")), true);
-    cppcut_assert_equal(str.starts_with(grn::dat::String("X")), false);
+    cppcut_assert_equal(true, str.starts_with(grn::dat::String("")));
+    cppcut_assert_equal(true, str.starts_with(grn::dat::String("app")));
+    cppcut_assert_equal(true, str.starts_with(grn::dat::String("apple")));
+    cppcut_assert_equal(false, str.starts_with(grn::dat::String("X")));
   }
 
   void test_ends_with(void)
   {
     const grn::dat::String str("apple");
 
-    cppcut_assert_equal(str.ends_with(grn::dat::String("")), true);
-    cppcut_assert_equal(str.ends_with(grn::dat::String("ple")), true);
-    cppcut_assert_equal(str.ends_with(grn::dat::String("apple")), true);
-    cppcut_assert_equal(str.ends_with(grn::dat::String("X")), false);
+    cppcut_assert_equal(true, str.ends_with(grn::dat::String("")));
+    cppcut_assert_equal(true, str.ends_with(grn::dat::String("ple")));
+    cppcut_assert_equal(true, str.ends_with(grn::dat::String("apple")));
+    cppcut_assert_equal(false, str.ends_with(grn::dat::String("X")));
   }
 }

  Modified: test/unit/core/dat/test-trie.cpp (+75 -82)
===================================================================
--- test/unit/core/dat/test-trie.cpp    2011-11-11 01:47:12 +0000 (e723c99)
+++ test/unit/core/dat/test-trie.cpp    2011-11-11 02:16:06 +0000 (f395ec5)
@@ -74,23 +74,23 @@ namespace test_dat_trie
     grn::dat::Trie trie;
     trie.create();
 
-    cppcut_assert_equal(trie.file_size(), grn::dat::DEFAULT_FILE_SIZE);
-    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));
+    cppcut_assert_equal(grn::dat::DEFAULT_FILE_SIZE, trie.file_size());
+    cppcut_assert_equal(grn::dat::UInt64(4236), trie.virtual_size());
+    cppcut_assert_equal(grn::dat::UInt32(0), trie.total_key_length());
+    cppcut_assert_equal(grn::dat::UInt32(0), trie.num_keys());
+    cppcut_assert_equal(grn::dat::UInt32(1), trie.min_key_id());
+    cppcut_assert_equal(grn::dat::UInt32(1), trie.next_key_id());
+    cppcut_assert_equal(grn::dat::UInt32(0), trie.max_key_id());
+    cppcut_assert_equal(grn::dat::UInt32(0), trie.num_keys());
+    cppcut_assert_equal(grn::dat::UInt32(17893), trie.max_num_keys());
+    cppcut_assert_equal(grn::dat::UInt32(512), trie.num_nodes());
+    cppcut_assert_equal(grn::dat::UInt32(511), trie.num_phantoms());
+    cppcut_assert_equal(grn::dat::UInt32(0), trie.num_zombies());
+    cppcut_assert_equal(grn::dat::UInt32(71680), trie.max_num_nodes());
+    cppcut_assert_equal(grn::dat::UInt32(1), trie.num_blocks());
+    cppcut_assert_equal(grn::dat::UInt32(140), trie.max_num_blocks());
+    cppcut_assert_equal(grn::dat::UInt32(0), trie.next_key_pos());
+    cppcut_assert_equal(grn::dat::UInt32(100439), trie.key_buf_size());
   }
 
   void test_trie_on_memory(void)
@@ -102,8 +102,8 @@ namespace test_dat_trie
     trie.create();
 
     for (std::size_t i = 0; i < keys.size(); ++i) {
-      cppcut_assert_equal(trie.insert(keys[i].c_str(), keys[i].length()), true);
-      cppcut_assert_equal(trie.search(keys[i].c_str(), keys[i].length()), true);
+      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()));
     }
   }
 
@@ -120,16 +120,16 @@ namespace test_dat_trie
     trie.create(trie_path);
 
     for (std::size_t i = 0; i < keys.size(); ++i) {
-      cppcut_assert_equal(trie.insert(keys[i].c_str(), keys[i].length()), true);
-      cppcut_assert_equal(trie.search(keys[i].c_str(), keys[i].length()), true);
+      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(new_trie.insert(keys[i].c_str(), keys[i].length()), false);
-      cppcut_assert_equal(new_trie.search(keys[i].c_str(), keys[i].length()), true);
+      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()));
     }
   }
 
@@ -144,23 +144,22 @@ namespace test_dat_trie
     std::size_t total_key_length = 0;
     for (std::size_t i = 0; i < keys.size(); ++i) {
       grn::dat::UInt32 key_pos;
-      cppcut_assert_equal(trie.insert(keys[i].c_str(), keys[i].length(), &key_pos),
-                          true);
+      cppcut_assert_equal(true,
+                          trie.insert(keys[i].c_str(), keys[i].length(), &key_pos));
 
       const grn::dat::Key &key = trie.get_key(key_pos);
-      cppcut_assert_equal(key.is_valid(), true);
-      cppcut_assert_equal(key.id(), static_cast<grn::dat::UInt32>(i + 1));
-      cppcut_assert_equal(key.length(), static_cast<grn::dat::UInt32>(keys[i].length()));
-      cppcut_assert_equal(std::memcmp(key.ptr(), keys[i].c_str(), key.length()), 0);
+      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()));
 
       grn::dat::UInt32 key_pos_again;
-      cppcut_assert_equal(trie.insert(keys[i].c_str(), keys[i].length(), &key_pos_again),
-                          false);
+      cppcut_assert_equal(false,
+                          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()));
     }
   }
 
@@ -173,15 +172,14 @@ namespace test_dat_trie
     trie.create();
 
     for (std::size_t i = 0; i < keys.size(); ++i) {
-      cppcut_assert_equal(trie.ith_key(i + 1).is_valid(), false);
+      cppcut_assert_equal(false, trie.ith_key(i + 1).is_valid());
 
       grn::dat::UInt32 key_pos;
-      cppcut_assert_equal(trie.insert(keys[i].c_str(), keys[i].length(), &key_pos),
-                          true);
+      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);
-      cppcut_assert_equal(&key_by_pos, &key_by_id);
+      cppcut_assert_equal(&key_by_id, &key_by_pos);
     }
   }
 
@@ -194,15 +192,15 @@ namespace test_dat_trie
     trie.create();
 
     for (std::size_t i = 0; i < keys.size(); ++i) {
-      cppcut_assert_equal(trie.search(keys[i].c_str(), keys[i].length()), false);
+      cppcut_assert_equal(false, trie.search(keys[i].c_str(), keys[i].length()));
 
       grn::dat::UInt32 key_pos_inserted;
-      cppcut_assert_equal(trie.insert(keys[i].c_str(), keys[i].length(), &key_pos_inserted),
-                          true);
+      cppcut_assert_equal(true,
+                          trie.insert(keys[i].c_str(), keys[i].length(), &key_pos_inserted));
 
       grn::dat::UInt32 key_pos_found;
-      cppcut_assert_equal(trie.search(keys[i].c_str(), keys[i].length(), &key_pos_found),
-                          true);
+      cppcut_assert_equal(true,
+                          trie.search(keys[i].c_str(), keys[i].length(), &key_pos_found));
       cppcut_assert_equal(key_pos_inserted, key_pos_found);
     }
   }
@@ -217,30 +215,29 @@ namespace test_dat_trie
 
     std::size_t total_key_length = 0;
     for (std::size_t i = 0; i < keys.size(); ++i) {
-      cppcut_assert_equal(trie.insert(keys[i].c_str(), keys[i].length()), true);
+      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) {
-      cppcut_assert_equal(trie.num_keys(),
-                          static_cast<grn::dat::UInt32>(keys.size() - i));
-      cppcut_assert_equal(trie.remove(i + 1), true);
-      cppcut_assert_equal(trie.ith_key(i + 1).is_valid(), false);
-      cppcut_assert_equal(trie.search(keys[i].c_str(), keys[i].length()), false);
-      cppcut_assert_equal(trie.remove(i + 1), false);
+      cppcut_assert_equal(static_cast<grn::dat::UInt32>(keys.size() - i),
+                          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.remove(i + 1));
 
       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()));
     }
 
     for (std::size_t i = 0; i < keys.size(); ++i) {
-      cppcut_assert_equal(trie.insert(keys[i].c_str(), keys[i].length()), true);
+      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(trie.remove(keys[i].c_str(), keys[i].length()), true);
-      cppcut_assert_equal(trie.ith_key(keys.size() - i).is_valid(), false);
-      cppcut_assert_equal(trie.search(keys[i].c_str(), keys[i].length()), false);
-      cppcut_assert_equal(trie.remove(keys[i].c_str(), keys[i].length()), false);
+      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()));
     }
   }
 
@@ -254,34 +251,30 @@ 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(trie.insert(keys[i].c_str(), keys[i].length()), true);
+      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(trie.update(key_id, keys[i].c_str(), keys[i].length()),
-                          true);
-      cppcut_assert_equal(trie.ith_key(key_id).is_valid(), true);
-      cppcut_assert_equal(trie.search(keys[i].c_str(), keys[i].length()), true);
-      cppcut_assert_equal(trie.search(src_key.c_str(), src_key.length()), false);
+      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()));
 
       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()));
     }
     for (std::size_t i = 0; i < (keys.size() / 2); ++i) {
       const std::string &src_key = keys[i + (keys.size() / 2)];
-      cppcut_assert_equal(trie.update(src_key.c_str(), src_key.length(),
-                                      keys[i].c_str(), keys[i].length()),
-                          true);
-      cppcut_assert_equal(trie.ith_key(i + 1).is_valid(), true);
-      cppcut_assert_equal(trie.search(keys[i].c_str(), keys[i].length()), true);
-      cppcut_assert_equal(trie.search(src_key.c_str(), src_key.length()), false);
+      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()));
 
       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()));
     }
   }
 
@@ -294,26 +287,26 @@ namespace test_dat_trie
     src_trie.create();
 
     for (std::size_t i = 0; i < keys.size(); ++i) {
-      cppcut_assert_equal(src_trie.insert(keys[i].c_str(), keys[i].length()), true);
+      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(dest_trie.search(keys[i].c_str(), keys[i].length()), true);
+      cppcut_assert_equal(true, dest_trie.search(keys[i].c_str(), keys[i].length()));
     }
 
-    cppcut_assert_equal(dest_trie.file_size(), src_trie.file_size());
-    cppcut_assert_equal(dest_trie.total_key_length(), src_trie.total_key_length());
-    cppcut_assert_equal(dest_trie.min_key_id(), src_trie.min_key_id());
-    cppcut_assert_equal(dest_trie.next_key_id(), src_trie.next_key_id());
-    cppcut_assert_equal(dest_trie.max_key_id(), src_trie.max_key_id());
-    cppcut_assert_equal(dest_trie.num_keys(), src_trie.num_keys());
-    cppcut_assert_equal(dest_trie.next_key_pos(), src_trie.next_key_pos());
+    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.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());
+    cppcut_assert_equal(src_trie.num_keys(), dest_trie.num_keys());
+    cppcut_assert_equal(src_trie.next_key_pos(), dest_trie.next_key_pos());
 
     cut_assert(dest_trie.num_nodes() < src_trie.num_nodes());
-    cppcut_assert_equal(dest_trie.num_zombies(), grn::dat::UInt32(0));
+    cppcut_assert_equal(grn::dat::UInt32(0), dest_trie.num_zombies());
     cut_assert(dest_trie.num_blocks() < src_trie.num_nodes());
   }
 }

  Modified: test/unit/core/dat/test-vector.cpp (+89 -89)
===================================================================
--- test/unit/core/dat/test-vector.cpp    2011-11-11 01:47:12 +0000 (e0fa7a8)
+++ test/unit/core/dat/test-vector.cpp    2011-11-11 02:16:06 +0000 (b8bb66b)
@@ -52,9 +52,9 @@ namespace test_dat_vector
   {
     const grn::dat::Vector<grn::dat::UInt32> vec;
 
-    cppcut_assert_equal(vec.empty(), true);
-    cppcut_assert_equal(vec.size(), grn::dat::UInt32(0));
-    cppcut_assert_equal(vec.capacity(), grn::dat::UInt32(0));
+    cppcut_assert_equal(true, vec.empty());
+    cppcut_assert_equal(grn::dat::UInt32(0), vec.size());
+    cppcut_assert_equal(grn::dat::UInt32(0), vec.capacity());
   }
 
   void test_reserve(void)
@@ -62,34 +62,34 @@ namespace test_dat_vector
     grn::dat::Vector<grn::dat::UInt32> vec;
 
     vec.reserve(1);
-    cppcut_assert_equal(vec.empty(), true);
-    cppcut_assert_equal(vec.size(), grn::dat::UInt32(0));
-    cppcut_assert_equal(vec.capacity(), grn::dat::UInt32(1));
+    cppcut_assert_equal(true, vec.empty());
+    cppcut_assert_equal(grn::dat::UInt32(0), vec.size());
+    cppcut_assert_equal(grn::dat::UInt32(1), vec.capacity());
 
     vec.reserve(2);
-    cppcut_assert_equal(vec.empty(), true);
-    cppcut_assert_equal(vec.size(), grn::dat::UInt32(0));
-    cppcut_assert_equal(vec.capacity(), grn::dat::UInt32(2));
+    cppcut_assert_equal(true, vec.empty());
+    cppcut_assert_equal(grn::dat::UInt32(0), vec.size());
+    cppcut_assert_equal(grn::dat::UInt32(2), vec.capacity());
 
     vec.reserve(3);
-    cppcut_assert_equal(vec.empty(), true);
-    cppcut_assert_equal(vec.size(), grn::dat::UInt32(0));
-    cppcut_assert_equal(vec.capacity(), grn::dat::UInt32(4));
+    cppcut_assert_equal(true, vec.empty());
+    cppcut_assert_equal(grn::dat::UInt32(0), vec.size());
+    cppcut_assert_equal(grn::dat::UInt32(4), vec.capacity());
 
     vec.reserve(100);
-    cppcut_assert_equal(vec.empty(), true);
-    cppcut_assert_equal(vec.size(), grn::dat::UInt32(0));
-    cppcut_assert_equal(vec.capacity(), grn::dat::UInt32(100));
+    cppcut_assert_equal(true, vec.empty());
+    cppcut_assert_equal(grn::dat::UInt32(0), vec.size());
+    cppcut_assert_equal(grn::dat::UInt32(100), vec.capacity());
 
     vec.reserve(101);
-    cppcut_assert_equal(vec.empty(), true);
-    cppcut_assert_equal(vec.size(), grn::dat::UInt32(0));
-    cppcut_assert_equal(vec.capacity(), grn::dat::UInt32(200));
+    cppcut_assert_equal(true, vec.empty());
+    cppcut_assert_equal(grn::dat::UInt32(0), vec.size());
+    cppcut_assert_equal(grn::dat::UInt32(200), vec.capacity());
 
     vec.reserve(0);
-    cppcut_assert_equal(vec.empty(), true);
-    cppcut_assert_equal(vec.size(), grn::dat::UInt32(0));
-    cppcut_assert_equal(vec.capacity(), grn::dat::UInt32(200));
+    cppcut_assert_equal(true, vec.empty());
+    cppcut_assert_equal(grn::dat::UInt32(0), vec.size());
+    cppcut_assert_equal(grn::dat::UInt32(200), vec.capacity());
   }
 
   void test_resize(void)
@@ -97,34 +97,34 @@ namespace test_dat_vector
     grn::dat::Vector<grn::dat::UInt32> vec;
 
     vec.resize(1);
-    cppcut_assert_equal(vec.empty(), false);
-    cppcut_assert_equal(vec.size(), grn::dat::UInt32(1));
-    cppcut_assert_equal(vec.capacity(), grn::dat::UInt32(1));
+    cppcut_assert_equal(false, vec.empty());
+    cppcut_assert_equal(grn::dat::UInt32(1), vec.size());
+    cppcut_assert_equal(grn::dat::UInt32(1), vec.capacity());
 
     vec.resize(2);
-    cppcut_assert_equal(vec.empty(), false);
-    cppcut_assert_equal(vec.size(), grn::dat::UInt32(2));
-    cppcut_assert_equal(vec.capacity(), grn::dat::UInt32(2));
+    cppcut_assert_equal(false, vec.empty());
+    cppcut_assert_equal(grn::dat::UInt32(2), vec.size());
+    cppcut_assert_equal(grn::dat::UInt32(2), vec.capacity());
 
     vec.resize(3);
-    cppcut_assert_equal(vec.empty(), false);
-    cppcut_assert_equal(vec.size(), grn::dat::UInt32(3));
-    cppcut_assert_equal(vec.capacity(), grn::dat::UInt32(4));
+    cppcut_assert_equal(false, vec.empty());
+    cppcut_assert_equal(grn::dat::UInt32(3), vec.size());
+    cppcut_assert_equal(grn::dat::UInt32(4), vec.capacity());
 
     vec.resize(100);
-    cppcut_assert_equal(vec.empty(), false);
-    cppcut_assert_equal(vec.size(), grn::dat::UInt32(100));
-    cppcut_assert_equal(vec.capacity(), grn::dat::UInt32(100));
+    cppcut_assert_equal(false, vec.empty());
+    cppcut_assert_equal(grn::dat::UInt32(100), vec.size());
+    cppcut_assert_equal(grn::dat::UInt32(100), vec.capacity());
 
     vec.resize(101);
-    cppcut_assert_equal(vec.empty(), false);
-    cppcut_assert_equal(vec.size(), grn::dat::UInt32(101));
-    cppcut_assert_equal(vec.capacity(), grn::dat::UInt32(200));
+    cppcut_assert_equal(false, vec.empty());
+    cppcut_assert_equal(grn::dat::UInt32(101), vec.size());
+    cppcut_assert_equal(grn::dat::UInt32(200), vec.capacity());
 
     vec.resize(0);
-    cppcut_assert_equal(vec.empty(), true);
-    cppcut_assert_equal(vec.size(), grn::dat::UInt32(0));
-    cppcut_assert_equal(vec.capacity(), grn::dat::UInt32(200));
+    cppcut_assert_equal(true, vec.empty());
+    cppcut_assert_equal(grn::dat::UInt32(0), vec.size());
+    cppcut_assert_equal(grn::dat::UInt32(200), vec.capacity());
   }
 
   void test_push_pop(void)
@@ -132,49 +132,49 @@ namespace test_dat_vector
     grn::dat::Vector<grn::dat::UInt32> vec;
 
     vec.push_back();
-    cppcut_assert_equal(vec.empty(), false);
-    cppcut_assert_equal(vec.size(), grn::dat::UInt32(1));
-    cppcut_assert_equal(vec.capacity(), grn::dat::UInt32(1));
+    cppcut_assert_equal(false, vec.empty());
+    cppcut_assert_equal(grn::dat::UInt32(1), vec.size());
+    cppcut_assert_equal(grn::dat::UInt32(1), vec.capacity());
 
     vec.pop_back();
-    cppcut_assert_equal(vec.empty(), true);
-    cppcut_assert_equal(vec.size(), grn::dat::UInt32(0));
-    cppcut_assert_equal(vec.capacity(), grn::dat::UInt32(1));
+    cppcut_assert_equal(true, vec.empty());
+    cppcut_assert_equal(grn::dat::UInt32(0), vec.size());
+    cppcut_assert_equal(grn::dat::UInt32(1), vec.capacity());
 
     vec.push_back(5);
-    cppcut_assert_equal(vec.empty(), false);
-    cppcut_assert_equal(vec.size(), grn::dat::UInt32(1));
-    cppcut_assert_equal(vec.capacity(), grn::dat::UInt32(1));
+    cppcut_assert_equal(false, vec.empty());
+    cppcut_assert_equal(grn::dat::UInt32(1), vec.size());
+    cppcut_assert_equal(grn::dat::UInt32(1), vec.capacity());
 
-    cppcut_assert_equal(vec.front(), grn::dat::UInt32(5));
-    cppcut_assert_equal(vec.back(), grn::dat::UInt32(5));
+    cppcut_assert_equal(grn::dat::UInt32(5), vec.front());
+    cppcut_assert_equal(grn::dat::UInt32(5), vec.back());
 
     vec.push_back(123);
-    cppcut_assert_equal(vec.empty(), false);
-    cppcut_assert_equal(vec.size(), grn::dat::UInt32(2));
-    cppcut_assert_equal(vec.capacity(), grn::dat::UInt32(2));
+    cppcut_assert_equal(false, vec.empty());
+    cppcut_assert_equal(grn::dat::UInt32(2), vec.size());
+    cppcut_assert_equal(grn::dat::UInt32(2), vec.capacity());
 
-    cppcut_assert_equal(vec.front(), grn::dat::UInt32(5));
-    cppcut_assert_equal(vec.back(), grn::dat::UInt32(123));
+    cppcut_assert_equal(grn::dat::UInt32(5), vec.front());
+    cppcut_assert_equal(grn::dat::UInt32(123), vec.back());
 
     vec.pop_back();
-    cppcut_assert_equal(vec.empty(), false);
-    cppcut_assert_equal(vec.size(), grn::dat::UInt32(1));
-    cppcut_assert_equal(vec.capacity(), grn::dat::UInt32(2));
+    cppcut_assert_equal(false, vec.empty());
+    cppcut_assert_equal(grn::dat::UInt32(1), vec.size());
+    cppcut_assert_equal(grn::dat::UInt32(2), vec.capacity());
 
-    cppcut_assert_equal(vec.front(), grn::dat::UInt32(5));
-    cppcut_assert_equal(vec.back(), grn::dat::UInt32(5));
+    cppcut_assert_equal(grn::dat::UInt32(5), vec.front());
+    cppcut_assert_equal(grn::dat::UInt32(5), vec.back());
 
     vec.clear();
 
     for (grn::dat::UInt32 i = 0; i < 1000; ++i) {
       vec.push_back(i);
-      cppcut_assert_equal(vec.back(), i);
-      cppcut_assert_equal(vec.size(), i + 1);
+      cppcut_assert_equal(i, vec.back());
+      cppcut_assert_equal(i + 1, vec.size());
     }
     for (grn::dat::UInt32 i = 0; i < 1000; ++i) {
-      cppcut_assert_equal(vec.size(), 1000 - i);
-      cppcut_assert_equal(vec.back(), 999 - i);
+      cppcut_assert_equal(1000 - i, vec.size());
+      cppcut_assert_equal(999 - i, vec.back());
       vec.pop_back();
     }
   }
@@ -188,10 +188,10 @@ namespace test_dat_vector
       vec[i] = i;
     }
     for (grn::dat::UInt32 i = 0; i < vec.size(); ++i) {
-      cppcut_assert_equal(vec[i], i);
-      cppcut_assert_equal(const_cast<const grn::dat::Vector<grn::dat::UInt32> &>(vec)[i], i);
-      cppcut_assert_equal(&vec[i], vec.begin() + i);
-      cppcut_assert_equal(&vec[i], vec.end() - 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(vec.begin() + i, &vec[i]);
+      cppcut_assert_equal(vec.end() - vec.size() + i, &vec[i]);
     }
   }
 
@@ -199,44 +199,44 @@ namespace test_dat_vector
   {
     grn::dat::Vector<Counter> vec;
 
-    cppcut_assert_equal(Counter::constructor_count, 0);
-    cppcut_assert_equal(Counter::copy_count, 0);
-    cppcut_assert_equal(Counter::destructor_count, 0);
+    cppcut_assert_equal(0, Counter::constructor_count);
+    cppcut_assert_equal(0, Counter::copy_count);
+    cppcut_assert_equal(0, Counter::destructor_count);
 
     vec.push_back();
 
-    cppcut_assert_equal(Counter::constructor_count, 1);
-    cppcut_assert_equal(Counter::copy_count, 0);
-    cppcut_assert_equal(Counter::destructor_count, 0);
+    cppcut_assert_equal(1, Counter::constructor_count);
+    cppcut_assert_equal(0, Counter::copy_count);
+    cppcut_assert_equal(0, Counter::destructor_count);
 
     vec.pop_back();
 
-    cppcut_assert_equal(Counter::constructor_count, 1);
-    cppcut_assert_equal(Counter::copy_count, 0);
-    cppcut_assert_equal(Counter::destructor_count, 1);
+    cppcut_assert_equal(1, Counter::constructor_count);
+    cppcut_assert_equal(0, Counter::copy_count);
+    cppcut_assert_equal(1, Counter::destructor_count);
 
     vec.resize(10);
 
-    cppcut_assert_equal(Counter::constructor_count, 11);
-    cppcut_assert_equal(Counter::copy_count, 0);
-    cppcut_assert_equal(Counter::destructor_count, 1);
+    cppcut_assert_equal(11, Counter::constructor_count);
+    cppcut_assert_equal(0, Counter::copy_count);
+    cppcut_assert_equal(1, Counter::destructor_count);
 
     vec.pop_back();
 
-    cppcut_assert_equal(Counter::constructor_count, 11);
-    cppcut_assert_equal(Counter::copy_count, 0);
-    cppcut_assert_equal(Counter::destructor_count, 2);
+    cppcut_assert_equal(11, Counter::constructor_count);
+    cppcut_assert_equal(0, Counter::copy_count);
+    cppcut_assert_equal(2, Counter::destructor_count);
 
     vec.resize(11);
 
-    cppcut_assert_equal(Counter::constructor_count, 13);
-    cppcut_assert_equal(Counter::copy_count, 9);
-    cppcut_assert_equal(Counter::destructor_count, 11);
+    cppcut_assert_equal(13, Counter::constructor_count);
+    cppcut_assert_equal(9, Counter::copy_count);
+    cppcut_assert_equal(11, Counter::destructor_count);
 
     vec.clear();
 
-    cppcut_assert_equal(Counter::constructor_count, 13);
-    cppcut_assert_equal(Counter::copy_count, 9);
-    cppcut_assert_equal(Counter::destructor_count, 22);
+    cppcut_assert_equal(13, Counter::constructor_count);
+    cppcut_assert_equal(9, Counter::copy_count);
+    cppcut_assert_equal(22, Counter::destructor_count);
   }
 }

• 前の記事 [Groonga-commit] groonga/groonga [master] fix space alignment.
• 次の記事 [Groonga-commit] groonga/groonga [master] translate tutorial text of loading data.
• 記事の並び順: [ 日付 ] [ スレッド ] [ 件名 ] [ 著者 ]