[Groonga-commit] groonga/groonga [master] Rename grn::dat::UINT*_MAX to grn::dat::MAX_UINT*.

Back to archive index

susumu.yata null+****@clear*****
Fri Aug 31 16:59:40 JST 2012


susumu.yata	2012-08-31 16:59:40 +0900 (Fri, 31 Aug 2012)

  New Revision: d5deea5687fec64ff58fc47e8503ca897d3a54a7
  https://github.com/groonga/groonga/commit/d5deea5687fec64ff58fc47e8503ca897d3a54a7

  Log:
    Rename grn::dat::UINT*_MAX to grn::dat::MAX_UINT*.

  Modified files:
    lib/dat/cursor-factory.hpp
    lib/dat/dat.hpp
    lib/dat/id-cursor.cpp
    lib/dat/id-cursor.hpp
    lib/dat/key-cursor.cpp
    lib/dat/key-cursor.hpp
    lib/dat/predictive-cursor.cpp
    lib/dat/predictive-cursor.hpp
    lib/dat/prefix-cursor.cpp
    lib/dat/prefix-cursor.hpp
    lib/dat/vector.hpp
    test/unit/core/dat/test-id-cursor.cpp
    test/unit/core/dat/test-key-cursor.cpp
    test/unit/core/dat/test-predictive-cursor.cpp
    test/unit/core/dat/test-prefix-cursor.cpp
    test/unit/core/dat/test-trie.cpp

  Modified: lib/dat/cursor-factory.hpp (+1 -1)
===================================================================
--- lib/dat/cursor-factory.hpp    2012-08-29 16:47:43 +0900 (ea7824d)
+++ lib/dat/cursor-factory.hpp    2012-08-31 16:59:40 +0900 (c79ac4e)
@@ -31,7 +31,7 @@ class GRN_DAT_API CursorFactory {
                       const void *min_ptr, UInt32 min_length,
                       const void *max_ptr, UInt32 max_length,
                       UInt32 offset = 0,
-                      UInt32 limit = UINT32_MAX,
+                      UInt32 limit = MAX_UINT32,
                       UInt32 flags = 0);
 
  private:

  Modified: lib/dat/dat.hpp (+4 -15)
===================================================================
--- lib/dat/dat.hpp    2012-08-29 16:47:43 +0900 (9961de8)
+++ lib/dat/dat.hpp    2012-08-31 16:59:40 +0900 (a2b225a)
@@ -57,21 +57,10 @@ typedef ::uint32_t UInt32;
 typedef ::uint64_t UInt64;
 #endif  // _MSC_VER
 
-#ifndef UINT8_MAX
-const UInt8 UINT8_MAX = static_cast<UInt8>(0xFFU);
-#endif  // UINT8_MAX
-
-#ifndef UINT16_MAX
-const UInt16 UINT16_MAX = static_cast<UInt16>(0xFFFFU);
-#endif  // UINT16_MAX
-
-#ifndef UINT32_MAX
-const UInt32 UINT32_MAX = static_cast<UInt32>(0xFFFFFFFFU);
-#endif  // UINT32_MAX
-
-#ifndef UINT64_MAX
-const UInt64 UINT64_MAX = static_cast<UInt64>(0xFFFFFFFFFFFFFFFFULL);
-#endif  // UINT64_MAX
+const UInt8  MAX_UINT8  = static_cast<UInt8>(0xFFU);
+const UInt16 MAX_UINT16 = static_cast<UInt16>(0xFFFFU);
+const UInt32 MAX_UINT32 = static_cast<UInt32>(0xFFFFFFFFU);
+const UInt64 MAX_UINT64 = static_cast<UInt64>(0xFFFFFFFFFFFFFFFFULL);
 
 // If a key is a prefix of another key, such a key is associated with a special
 // terminal node which has TERMINAL_LABEL.

  Modified: lib/dat/id-cursor.cpp (+1 -1)
===================================================================
--- lib/dat/id-cursor.cpp    2012-08-29 16:47:43 +0900 (074eab6)
+++ lib/dat/id-cursor.cpp    2012-08-31 16:59:40 +0900 (24d82c7)
@@ -27,7 +27,7 @@ namespace dat {
 IdCursor::IdCursor()
     : trie_(NULL),
       offset_(0),
-      limit_(UINT32_MAX),
+      limit_(MAX_UINT32),
       flags_(ID_RANGE_CURSOR),
       cur_(INVALID_KEY_ID),
       end_(INVALID_KEY_ID) {}

  Modified: lib/dat/id-cursor.hpp (+2 -2)
===================================================================
--- lib/dat/id-cursor.hpp    2012-08-29 16:47:43 +0900 (885aef3)
+++ lib/dat/id-cursor.hpp    2012-08-31 16:59:40 +0900 (9bcebbd)
@@ -34,14 +34,14 @@ class GRN_DAT_API IdCursor : public Cursor {
             const String &min_str,
             const String &max_str,
             UInt32 offset = 0,
-            UInt32 limit = UINT32_MAX,
+            UInt32 limit = MAX_UINT32,
             UInt32 flags = 0);
 
   void open(const Trie &trie,
             UInt32 min_id,
             UInt32 max_id,
             UInt32 offset = 0,
-            UInt32 limit = UINT32_MAX,
+            UInt32 limit = MAX_UINT32,
             UInt32 flags = 0);
 
   void close();

  Modified: lib/dat/key-cursor.cpp (+3 -3)
===================================================================
--- lib/dat/key-cursor.cpp    2012-08-29 16:47:43 +0900 (676f64a)
+++ lib/dat/key-cursor.cpp    2012-08-31 16:59:40 +0900 (90ba25e)
@@ -28,7 +28,7 @@ namespace dat {
 KeyCursor::KeyCursor()
     : trie_(NULL),
       offset_(0),
-      limit_(UINT32_MAX),
+      limit_(MAX_UINT32),
       flags_(KEY_RANGE_CURSOR),
       buf_(),
       count_(0),
@@ -112,8 +112,8 @@ UInt32 KeyCursor::fix_flags(UInt32 flags) const {
 }
 
 void KeyCursor::init(const String &min_str, const String &max_str) {
-  if (offset_ > (UINT32_MAX - limit_)) {
-    max_count_ = UINT32_MAX;
+  if (offset_ > (MAX_UINT32 - limit_)) {
+    max_count_ = MAX_UINT32;
   } else {
     max_count_ = offset_ + limit_;
   }

  Modified: lib/dat/key-cursor.hpp (+1 -1)
===================================================================
--- lib/dat/key-cursor.hpp    2012-08-29 16:47:43 +0900 (82882a1)
+++ lib/dat/key-cursor.hpp    2012-08-31 16:59:40 +0900 (adce41c)
@@ -35,7 +35,7 @@ class GRN_DAT_API KeyCursor : public Cursor {
             const String &min_str,
             const String &max_str,
             UInt32 offset = 0,
-            UInt32 limit = UINT32_MAX,
+            UInt32 limit = MAX_UINT32,
             UInt32 flags = 0);
 
   void close();

  Modified: lib/dat/predictive-cursor.cpp (+2 -2)
===================================================================
--- lib/dat/predictive-cursor.cpp    2012-08-29 16:47:43 +0900 (c272c85)
+++ lib/dat/predictive-cursor.cpp    2012-08-31 16:59:40 +0900 (4737d84)
@@ -28,7 +28,7 @@ namespace dat {
 PredictiveCursor::PredictiveCursor()
     : trie_(NULL),
       offset_(0),
-      limit_(UINT32_MAX),
+      limit_(MAX_UINT32),
       flags_(PREDICTIVE_CURSOR),
       buf_(),
       cur_(0),
@@ -107,7 +107,7 @@ void PredictiveCursor::init(const String &str) {
   if ((flags_ & EXCEPT_EXACT_MATCH) == EXCEPT_EXACT_MATCH) {
     ++min_length_;
   }
-  end_ = (offset_ > (UINT32_MAX - limit_)) ? UINT32_MAX : (offset_ + limit_);
+  end_ = (offset_ > (MAX_UINT32 - limit_)) ? MAX_UINT32 : (offset_ + limit_);
 
   UInt32 node_id = ROOT_NODE_ID;
   for (UInt32 i = 0; i < str.length(); ++i) {

  Modified: lib/dat/predictive-cursor.hpp (+1 -1)
===================================================================
--- lib/dat/predictive-cursor.hpp    2012-08-29 16:47:43 +0900 (ac25bd5)
+++ lib/dat/predictive-cursor.hpp    2012-08-31 16:59:40 +0900 (e4041ff)
@@ -34,7 +34,7 @@ class GRN_DAT_API PredictiveCursor : public Cursor {
   void open(const Trie &trie,
             const String &str,
             UInt32 offset = 0,
-            UInt32 limit = UINT32_MAX,
+            UInt32 limit = MAX_UINT32,
             UInt32 flags = 0);
 
   void close();

  Modified: lib/dat/prefix-cursor.cpp (+1 -1)
===================================================================
--- lib/dat/prefix-cursor.cpp    2012-08-29 16:47:43 +0900 (8188982)
+++ lib/dat/prefix-cursor.cpp    2012-08-31 16:59:40 +0900 (7f994b5)
@@ -27,7 +27,7 @@ namespace dat {
 PrefixCursor::PrefixCursor()
     : trie_(NULL),
       offset_(0),
-      limit_(UINT32_MAX),
+      limit_(MAX_UINT32),
       flags_(PREFIX_CURSOR),
       buf_(),
       cur_(0),

  Modified: lib/dat/prefix-cursor.hpp (+1 -1)
===================================================================
--- lib/dat/prefix-cursor.hpp    2012-08-29 16:47:43 +0900 (57e3183)
+++ lib/dat/prefix-cursor.hpp    2012-08-31 16:59:40 +0900 (7a84228)
@@ -35,7 +35,7 @@ class GRN_DAT_API PrefixCursor : public Cursor {
             const String &str,
             UInt32 min_length = 0,
             UInt32 offset = 0,
-            UInt32 limit = UINT32_MAX,
+            UInt32 limit = MAX_UINT32,
             UInt32 flags = 0);
 
   void close();

  Modified: lib/dat/vector.hpp (+2 -2)
===================================================================
--- lib/dat/vector.hpp    2012-08-29 16:47:43 +0900 (93c1744)
+++ lib/dat/vector.hpp    2012-08-31 16:59:40 +0900 (80c8a1a)
@@ -128,10 +128,10 @@ class Vector {
     if (new_capacity <= capacity()) {
       return;
     } else if ((new_capacity / 2) < capacity()) {
-      if (capacity() < (UINT32_MAX / 2)) {
+      if (capacity() < (MAX_UINT32 / 2)) {
         new_capacity = capacity() * 2;
       } else {
-        new_capacity = UINT32_MAX;
+        new_capacity = MAX_UINT32;
       }
     }
 

  Modified: test/unit/core/dat/test-id-cursor.cpp (+7 -7)
===================================================================
--- test/unit/core/dat/test-id-cursor.cpp    2012-08-29 16:47:43 +0900 (55b0c94)
+++ test/unit/core/dat/test-id-cursor.cpp    2012-08-31 16:59:40 +0900 (bc82890)
@@ -242,7 +242,7 @@ namespace test_dat_id_cursor
 
     grn::dat::IdCursor cursor;
 
-    cursor.open(trie, 3, 6, 0, grn::dat::UINT32_MAX);
+    cursor.open(trie, 3, 6, 0, grn::dat::MAX_UINT32);
     for (grn::dat::UInt32 i = 3; i <= 6; ++i) {
       const grn::dat::Key &key = cursor.next();
       cppcut_assert_equal(true, key.is_valid());
@@ -280,7 +280,7 @@ namespace test_dat_id_cursor
     grn::dat::IdCursor cursor;
 
     cursor.open(trie, grn::dat::INVALID_KEY_ID, grn::dat::INVALID_KEY_ID,
-                0, grn::dat::UINT32_MAX, grn::dat::ASCENDING_CURSOR);
+                0, grn::dat::MAX_UINT32, 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(true, key.is_valid());
@@ -288,7 +288,7 @@ namespace test_dat_id_cursor
     }
     cppcut_assert_equal(false, cursor.next().is_valid());
 
-    cursor.open(trie, 2, 7, 0, grn::dat::UINT32_MAX,
+    cursor.open(trie, 2, 7, 0, grn::dat::MAX_UINT32,
                 grn::dat::ASCENDING_CURSOR);
     for (grn::dat::UInt32 i = 2; i <= 7; ++i) {
       const grn::dat::Key &key = cursor.next();
@@ -314,7 +314,7 @@ namespace test_dat_id_cursor
     grn::dat::IdCursor cursor;
 
     cursor.open(trie, grn::dat::INVALID_KEY_ID, grn::dat::INVALID_KEY_ID,
-                0, grn::dat::UINT32_MAX, grn::dat::DESCENDING_CURSOR);
+                0, grn::dat::MAX_UINT32, 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(true, key.is_valid());
@@ -322,7 +322,7 @@ namespace test_dat_id_cursor
     }
     cppcut_assert_equal(false, cursor.next().is_valid());
 
-    cursor.open(trie, 2, 7, 0, grn::dat::UINT32_MAX,
+    cursor.open(trie, 2, 7, 0, grn::dat::MAX_UINT32,
                 grn::dat::DESCENDING_CURSOR);
     for (grn::dat::UInt32 i = 7; i >= 2; --i) {
       const grn::dat::Key &key = cursor.next();
@@ -348,7 +348,7 @@ namespace test_dat_id_cursor
     grn::dat::IdCursor cursor;
 
     cursor.open(trie, grn::dat::INVALID_KEY_ID, grn::dat::INVALID_KEY_ID,
-                0, grn::dat::UINT32_MAX,
+                0, grn::dat::MAX_UINT32,
                 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();
@@ -358,7 +358,7 @@ namespace test_dat_id_cursor
     cppcut_assert_equal(false, cursor.next().is_valid());
 
     cursor.open(trie, trie.min_key_id(), trie.max_key_id(),
-                0, grn::dat::UINT32_MAX,
+                0, grn::dat::MAX_UINT32,
                 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) {

  Modified: test/unit/core/dat/test-key-cursor.cpp (+8 -8)
===================================================================
--- test/unit/core/dat/test-key-cursor.cpp    2012-08-29 16:47:43 +0900 (f9abc38)
+++ test/unit/core/dat/test-key-cursor.cpp    2012-08-31 16:59:40 +0900 (584f54e)
@@ -155,7 +155,7 @@ namespace test_dat_key_cursor
     grn::dat::KeyCursor cursor;
 
     cursor.open(trie, grn::dat::String("Gnome"), grn::dat::String("Werdna"),
-                0, grn::dat::UINT32_MAX);
+                0, grn::dat::MAX_UINT32);
     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());
@@ -187,7 +187,7 @@ namespace test_dat_key_cursor
     grn::dat::KeyCursor cursor;
 
     cursor.open(trie, grn::dat::String(), grn::dat::String(),
-                0, grn::dat::UINT32_MAX, grn::dat::ASCENDING_CURSOR);
+                0, grn::dat::MAX_UINT32, grn::dat::ASCENDING_CURSOR);
     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());
@@ -198,7 +198,7 @@ namespace test_dat_key_cursor
     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);
+                0, grn::dat::MAX_UINT32, grn::dat::ASCENDING_CURSOR);
     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());
@@ -220,7 +220,7 @@ namespace test_dat_key_cursor
     grn::dat::KeyCursor cursor;
 
     cursor.open(trie, grn::dat::String(), grn::dat::String(),
-                0, grn::dat::UINT32_MAX, grn::dat::DESCENDING_CURSOR);
+                0, grn::dat::MAX_UINT32, grn::dat::DESCENDING_CURSOR);
     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());
@@ -231,7 +231,7 @@ namespace test_dat_key_cursor
     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);
+                0, grn::dat::MAX_UINT32, grn::dat::DESCENDING_CURSOR);
     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());
@@ -253,7 +253,7 @@ namespace test_dat_key_cursor
     grn::dat::KeyCursor cursor;
 
     cursor.open(trie, grn::dat::String(), grn::dat::String(),
-                0, grn::dat::UINT32_MAX,
+                0, grn::dat::MAX_UINT32,
                 grn::dat::EXCEPT_LOWER_BOUND | grn::dat::EXCEPT_UPPER_BOUND);
     cppcut_assert_equal(grn::dat::UInt32(5), cursor.next().id());
     cppcut_assert_equal(grn::dat::UInt32(4), cursor.next().id());
@@ -265,7 +265,7 @@ namespace test_dat_key_cursor
     cppcut_assert_equal(false, cursor.next().is_valid());
 
     cursor.open(trie, grn::dat::String("Dwarf"), grn::dat::String("Werdna"),
-                0, grn::dat::UINT32_MAX,
+                0, grn::dat::MAX_UINT32,
                 grn::dat::EXCEPT_LOWER_BOUND | grn::dat::EXCEPT_UPPER_BOUND);
     cppcut_assert_equal(grn::dat::UInt32(4), cursor.next().id());
     cppcut_assert_equal(grn::dat::UInt32(6), cursor.next().id());
@@ -287,7 +287,7 @@ namespace test_dat_key_cursor
     cppcut_assert_equal(false, cursor.next().is_valid());
 
     cursor.open(trie, grn::dat::String("Fighter"), grn::dat::String("Samurai"),
-                0, grn::dat::UINT32_MAX,
+                0, grn::dat::MAX_UINT32,
                 grn::dat::EXCEPT_LOWER_BOUND | grn::dat::EXCEPT_UPPER_BOUND);
     cppcut_assert_equal(grn::dat::UInt32(6), cursor.next().id());
     cppcut_assert_equal(grn::dat::UInt32(7), cursor.next().id());

  Modified: test/unit/core/dat/test-predictive-cursor.cpp (+17 -17)
===================================================================
--- test/unit/core/dat/test-predictive-cursor.cpp    2012-08-29 16:47:43 +0900 (3b1020e)
+++ test/unit/core/dat/test-predictive-cursor.cpp    2012-08-31 16:59:40 +0900 (1fcea6e)
@@ -133,7 +133,7 @@ namespace test_dat_predictive_cursor
 
     grn::dat::PredictiveCursor cursor;
 
-    cursor.open(trie, grn::dat::String(), 0, grn::dat::UINT32_MAX);
+    cursor.open(trie, grn::dat::String(), 0, grn::dat::MAX_UINT32);
     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());
@@ -180,7 +180,7 @@ namespace test_dat_predictive_cursor
 
     grn::dat::PredictiveCursor cursor;
 
-    cursor.open(trie, grn::dat::String(), 0, grn::dat::UINT32_MAX,
+    cursor.open(trie, grn::dat::String(), 0, grn::dat::MAX_UINT32,
                 grn::dat::ASCENDING_CURSOR);
     cppcut_assert_equal(grn::dat::UInt32(6), cursor.next().id());
     cppcut_assert_equal(grn::dat::UInt32(1), cursor.next().id());
@@ -190,7 +190,7 @@ namespace test_dat_predictive_cursor
     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,
+    cursor.open(trie, grn::dat::String(), 3, grn::dat::MAX_UINT32,
                 grn::dat::ASCENDING_CURSOR);
     cppcut_assert_equal(grn::dat::UInt32(3), cursor.next().id());
     cppcut_assert_equal(grn::dat::UInt32(5), cursor.next().id());
@@ -203,7 +203,7 @@ namespace test_dat_predictive_cursor
     cppcut_assert_equal(grn::dat::UInt32(5), cursor.next().id());
     cppcut_assert_equal(false, cursor.next().is_valid());
 
-    cursor.open(trie, grn::dat::String("北斗"), 0, grn::dat::UINT32_MAX,
+    cursor.open(trie, grn::dat::String("北斗"), 0, grn::dat::MAX_UINT32,
                 grn::dat::ASCENDING_CURSOR);
     cppcut_assert_equal(grn::dat::UInt32(1), cursor.next().id());
     cppcut_assert_equal(grn::dat::UInt32(2), cursor.next().id());
@@ -218,7 +218,7 @@ namespace test_dat_predictive_cursor
 
     grn::dat::PredictiveCursor cursor;
 
-    cursor.open(trie, grn::dat::String(), 0, grn::dat::UINT32_MAX,
+    cursor.open(trie, grn::dat::String(), 0, grn::dat::MAX_UINT32,
                 grn::dat::DESCENDING_CURSOR);
     cppcut_assert_equal(grn::dat::UInt32(4), cursor.next().id());
     cppcut_assert_equal(grn::dat::UInt32(5), cursor.next().id());
@@ -228,7 +228,7 @@ namespace test_dat_predictive_cursor
     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,
+    cursor.open(trie, grn::dat::String(), 3, grn::dat::MAX_UINT32,
                 grn::dat::DESCENDING_CURSOR);
     cppcut_assert_equal(grn::dat::UInt32(2), cursor.next().id());
     cppcut_assert_equal(grn::dat::UInt32(1), cursor.next().id());
@@ -241,14 +241,14 @@ namespace test_dat_predictive_cursor
     cppcut_assert_equal(grn::dat::UInt32(1), cursor.next().id());
     cppcut_assert_equal(false, cursor.next().is_valid());
 
-    cursor.open(trie, grn::dat::String("北斗"), 0, grn::dat::UINT32_MAX,
+    cursor.open(trie, grn::dat::String("北斗"), 0, grn::dat::MAX_UINT32,
                 grn::dat::DESCENDING_CURSOR);
     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,
+    cursor.open(trie, grn::dat::String("北斗"), 2, grn::dat::MAX_UINT32,
                 grn::dat::DESCENDING_CURSOR);
     cppcut_assert_equal(grn::dat::UInt32(1), cursor.next().id());
     cppcut_assert_equal(false, cursor.next().is_valid());
@@ -258,7 +258,7 @@ namespace test_dat_predictive_cursor
     cppcut_assert_equal(grn::dat::UInt32(3), cursor.next().id());
     cppcut_assert_equal(false, cursor.next().is_valid());
 
-    cursor.open(trie, grn::dat::String("北斗"), 3, grn::dat::UINT32_MAX,
+    cursor.open(trie, grn::dat::String("北斗"), 3, grn::dat::MAX_UINT32,
                 grn::dat::DESCENDING_CURSOR);
     cppcut_assert_equal(false, cursor.next().is_valid());
 
@@ -274,7 +274,7 @@ namespace test_dat_predictive_cursor
 
     grn::dat::PredictiveCursor cursor;
 
-    cursor.open(trie, grn::dat::String(), 0, grn::dat::UINT32_MAX,
+    cursor.open(trie, grn::dat::String(), 0, grn::dat::MAX_UINT32,
                 grn::dat::EXCEPT_EXACT_MATCH);
     cppcut_assert_equal(grn::dat::UInt32(6), cursor.next().id());
     cppcut_assert_equal(grn::dat::UInt32(1), cursor.next().id());
@@ -284,40 +284,40 @@ namespace test_dat_predictive_cursor
     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,
+    cursor.open(trie, grn::dat::String("北"), 0, grn::dat::MAX_UINT32,
                 grn::dat::EXCEPT_EXACT_MATCH);
     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,
+    cursor.open(trie, grn::dat::String("北斗"), 0, grn::dat::MAX_UINT32,
                 grn::dat::EXCEPT_EXACT_MATCH);
     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,
+    cursor.open(trie, grn::dat::String("北斗神"), 0, grn::dat::MAX_UINT32,
                 grn::dat::EXCEPT_EXACT_MATCH);
     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,
+    cursor.open(trie, grn::dat::String("北斗神拳"), 0, grn::dat::MAX_UINT32,
                 grn::dat::EXCEPT_EXACT_MATCH);
     cppcut_assert_equal(grn::dat::UInt32(3), cursor.next().id());
     cppcut_assert_equal(false, cursor.next().is_valid());
 
     cursor.open(trie, grn::dat::String("北斗神拳伝承"), 0,
-                grn::dat::UINT32_MAX, grn::dat::EXCEPT_EXACT_MATCH);
+                grn::dat::MAX_UINT32, grn::dat::EXCEPT_EXACT_MATCH);
     cppcut_assert_equal(grn::dat::UInt32(3), cursor.next().id());
     cppcut_assert_equal(false, cursor.next().is_valid());
 
     cursor.open(trie, grn::dat::String("北斗神拳伝承者"), 0,
-                grn::dat::UINT32_MAX, grn::dat::EXCEPT_EXACT_MATCH);
+                grn::dat::MAX_UINT32, grn::dat::EXCEPT_EXACT_MATCH);
     cppcut_assert_equal(false, cursor.next().is_valid());
 
-    cursor.open(trie, grn::dat::String("北斗"), 1, grn::dat::UINT32_MAX,
+    cursor.open(trie, grn::dat::String("北斗"), 1, grn::dat::MAX_UINT32,
                 grn::dat::EXCEPT_EXACT_MATCH);
     cppcut_assert_equal(grn::dat::UInt32(3), cursor.next().id());
     cppcut_assert_equal(false, cursor.next().is_valid());

  Modified: test/unit/core/dat/test-prefix-cursor.cpp (+12 -12)
===================================================================
--- test/unit/core/dat/test-prefix-cursor.cpp    2012-08-29 16:47:43 +0900 (f15684b)
+++ test/unit/core/dat/test-prefix-cursor.cpp    2012-08-31 16:59:40 +0900 (c190f64)
@@ -161,7 +161,7 @@ namespace test_dat_prefix_cursor
     grn::dat::PrefixCursor cursor;
 
     cursor.open(trie, grn::dat::String("東京都庁ビル"), 0, 0,
-                grn::dat::UINT32_MAX);
+                grn::dat::MAX_UINT32);
     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());
@@ -202,19 +202,19 @@ namespace test_dat_prefix_cursor
     grn::dat::PrefixCursor cursor;
 
     cursor.open(trie, grn::dat::String("京都府"), 0,
-                0, grn::dat::UINT32_MAX, grn::dat::ASCENDING_CURSOR);
+                0, grn::dat::MAX_UINT32, grn::dat::ASCENDING_CURSOR);
     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);
+                0, grn::dat::MAX_UINT32, grn::dat::ASCENDING_CURSOR);
     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);
+                1, grn::dat::MAX_UINT32, grn::dat::ASCENDING_CURSOR);
     cppcut_assert_equal(grn::dat::UInt32(4), cursor.next().id());
     cppcut_assert_equal(false, cursor.next().is_valid());
 
@@ -232,20 +232,20 @@ namespace test_dat_prefix_cursor
     grn::dat::PrefixCursor cursor;
 
     cursor.open(trie, grn::dat::String("東京都庁"), 0,
-                0, grn::dat::UINT32_MAX, grn::dat::DESCENDING_CURSOR);
+                0, grn::dat::MAX_UINT32, grn::dat::DESCENDING_CURSOR);
     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);
+                0, grn::dat::MAX_UINT32, grn::dat::DESCENDING_CURSOR);
     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);
+                1, grn::dat::MAX_UINT32, grn::dat::DESCENDING_CURSOR);
     cppcut_assert_equal(grn::dat::UInt32(3), cursor.next().id());
     cppcut_assert_equal(false, cursor.next().is_valid());
 
@@ -255,7 +255,7 @@ namespace test_dat_prefix_cursor
     cppcut_assert_equal(false, cursor.next().is_valid());
 
     cursor.open(trie, grn::dat::String("東京都庁"), 0,
-                1, grn::dat::UINT32_MAX, grn::dat::DESCENDING_CURSOR);
+                1, grn::dat::MAX_UINT32, grn::dat::DESCENDING_CURSOR);
     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());
@@ -275,27 +275,27 @@ namespace test_dat_prefix_cursor
     grn::dat::PrefixCursor cursor;
 
     cursor.open(trie, grn::dat::String("東京都庁ビル"), 0,
-                0, grn::dat::UINT32_MAX, grn::dat::EXCEPT_EXACT_MATCH);
+                0, grn::dat::MAX_UINT32, grn::dat::EXCEPT_EXACT_MATCH);
     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);
+                0, grn::dat::MAX_UINT32, grn::dat::EXCEPT_EXACT_MATCH);
     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);
+                0, grn::dat::MAX_UINT32, grn::dat::EXCEPT_EXACT_MATCH);
     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);
+                0, grn::dat::MAX_UINT32, grn::dat::EXCEPT_EXACT_MATCH);
     cppcut_assert_equal(grn::dat::UInt32(2), cursor.next().id());
     cppcut_assert_equal(false, cursor.next().is_valid());
   }

  Modified: test/unit/core/dat/test-trie.cpp (+2 -6)
===================================================================
--- test/unit/core/dat/test-trie.cpp    2012-08-29 16:47:43 +0900 (cedc5a9)
+++ test/unit/core/dat/test-trie.cpp    2012-08-31 16:59:40 +0900 (dca1fe2)
@@ -20,10 +20,6 @@
 #include <glib/gstdio.h>
 #include <cppcutter.h>
 
-#ifdef UINT32_MAX
- #undef UINT32_MAX
-#endif  // UINT32_MAX
-
 #include <grn-assertions.h>
 #include <dat/trie.hpp>
 
@@ -282,10 +278,10 @@ namespace test_dat_trie
     cppcut_assert_equal(true, trie.lcp_search("0123", 4));
     cppcut_assert_equal(false, trie.lcp_search("12345", 5));
 
-    grn::dat::UInt32 key_pos = grn::dat::UINT32_MAX;
+    grn::dat::UInt32 key_pos = grn::dat::MAX_UINT32;
 
     cppcut_assert_equal(false, trie.lcp_search("01", 2, &key_pos));
-    cppcut_assert_equal(grn::dat::UINT32_MAX, key_pos);
+    cppcut_assert_equal(grn::dat::MAX_UINT32, key_pos);
 
     cppcut_assert_equal(true, trie.lcp_search("012", 3, &key_pos));
     cppcut_assert_equal(true, trie.get_key(key_pos).is_valid());
-------------- next part --------------
HTML����������������������������...
Download 



More information about the Groonga-commit mailing list
Back to archive index