google_hash 0.8.1 → 0.8.2

data/ext/sparsehash-2.0.2/src/sparsehash/template_util.h

@@ -0,0 +1,134 @@
+// Copyright 2005 Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// ----
+//
+// Template metaprogramming utility functions.
+//
+// This code is compiled directly on many platforms, including client
+// platforms like Windows, Mac, and embedded systems.  Before making
+// any changes here, make sure that you're not breaking any platforms.
+//
+//
+// The names choosen here reflect those used in tr1 and the boost::mpl
+// library, there are similar operations used in the Loki library as
+// well.  I prefer the boost names for 2 reasons:
+// 1.  I think that portions of the Boost libraries are more likely to
+// be included in the c++ standard.
+// 2.  It is not impossible that some of the boost libraries will be
+// included in our own build in the future.
+// Both of these outcomes means that we may be able to directly replace
+// some of these with boost equivalents.
+//
+#ifndef BASE_TEMPLATE_UTIL_H_
+#define BASE_TEMPLATE_UTIL_H_
+
+#include <sparsehash/internal/sparseconfig.h>
+_START_GOOGLE_NAMESPACE_
+
+// Types small_ and big_ are guaranteed such that sizeof(small_) <
+// sizeof(big_)
+typedef char small_;
+
+struct big_ {
+  char dummy[2];
+};
+
+// Identity metafunction.
+template <class T>
+struct identity_ {
+  typedef T type;
+};
+
+// integral_constant, defined in tr1, is a wrapper for an integer
+// value. We don't really need this generality; we could get away
+// with hardcoding the integer type to bool. We use the fully
+// general integer_constant for compatibility with tr1.
+
+template<class T, T v>
+struct integral_constant {
+  static const T value = v;
+  typedef T value_type;
+  typedef integral_constant<T, v> type;
+};
+
+template <class T, T v> const T integral_constant<T, v>::value;
+
+
+// Abbreviations: true_type and false_type are structs that represent boolean
+// true and false values. Also define the boost::mpl versions of those names,
+// true_ and false_.
+typedef integral_constant<bool, true>  true_type;
+typedef integral_constant<bool, false> false_type;
+typedef true_type  true_;
+typedef false_type false_;
+
+// if_ is a templatized conditional statement.
+// if_<cond, A, B> is a compile time evaluation of cond.
+// if_<>::type contains A if cond is true, B otherwise.
+template<bool cond, typename A, typename B>
+struct if_{
+  typedef A type;
+};
+
+template<typename A, typename B>
+struct if_<false, A, B> {
+  typedef B type;
+};
+
+
+// type_equals_ is a template type comparator, similar to Loki IsSameType.
+// type_equals_<A, B>::value is true iff "A" is the same type as "B".
+//
+// New code should prefer base::is_same, defined in base/type_traits.h.
+// It is functionally identical, but is_same is the standard spelling.
+template<typename A, typename B>
+struct type_equals_ : public false_ {
+};
+
+template<typename A>
+struct type_equals_<A, A> : public true_ {
+};
+
+// and_ is a template && operator.
+// and_<A, B>::value evaluates "A::value && B::value".
+template<typename A, typename B>
+struct and_ : public integral_constant<bool, (A::value && B::value)> {
+};
+
+// or_ is a template || operator.
+// or_<A, B>::value evaluates "A::value || B::value".
+template<typename A, typename B>
+struct or_ : public integral_constant<bool, (A::value || B::value)> {
+};
+
+
+_END_GOOGLE_NAMESPACE_
+
+#endif  // BASE_TEMPLATE_UTIL_H_

data/ext/{sparsehash-1.8.1/src/google → sparsehash-2.0.2/src/sparsehash}/type_traits.h

@@ -28,12 +28,16 @@
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 // ----
-// Author: Matt Austern
+//
+// This code is compiled directly on many platforms, including client
+// platforms like Windows, Mac, and embedded systems.  Before making
+// any changes here, make sure that you're not breaking any platforms.
 //
 // Define a small subset of tr1 type traits. The traits we define are:
 //   is_integral
 //   is_floating_point
 //   is_pointer
+//   is_enum
 //   is_reference
 //   is_pod
 //   has_trivial_constructor
@@ -44,6 +48,7 @@
 //   remove_volatile
 //   remove_cv
 //   remove_reference
+//   add_reference
 //   remove_pointer
 //   is_same
 //   is_convertible
@@ -52,39 +57,40 @@
 #ifndef BASE_TYPE_TRAITS_H_
 #define BASE_TYPE_TRAITS_H_
 
-#include <google/sparsehash/sparseconfig.h>
+#include <sparsehash/internal/sparseconfig.h>
 #include <utility>                  // For pair
 
-_START_GOOGLE_NAMESPACE_
-
-// integral_constant, defined in tr1, is a wrapper for an integer
-// value. We don't really need this generality; we could get away
-// with hardcoding the integer type to bool. We use the fully
-// general integer_constant for compatibility with tr1.
-
-template<class T, T v>
-struct integral_constant {
-  static const T value = v;
-  typedef T value_type;
-  typedef integral_constant<T, v> type;
-};
-
-template <class T, T v> const T integral_constant<T, v>::value;
-
-// Abbreviations: true_type and false_type are structs that represent
-// boolean true and false values.
-typedef integral_constant<bool, true>  true_type;
-typedef integral_constant<bool, false> false_type;
+#include <sparsehash/template_util.h>     // For true_type and false_type
 
-// Types small_ and big_ are guaranteed such that sizeof(small_) <
-// sizeof(big_)
-typedef char small_;
+_START_GOOGLE_NAMESPACE_
 
-struct big_ {
-  char dummy[2];
-};
+template <class T> struct is_integral;
+template <class T> struct is_floating_point;
+template <class T> struct is_pointer;
+// MSVC can't compile this correctly, and neither can gcc 3.3.5 (at least)
+#if !defined(_MSC_VER) && !(defined(__GNUC__) && __GNUC__ <= 3)
+// is_enum uses is_convertible, which is not available on MSVC.
+template <class T> struct is_enum;
+#endif
+template <class T> struct is_reference;
+template <class T> struct is_pod;
+template <class T> struct has_trivial_constructor;
+template <class T> struct has_trivial_copy;
+template <class T> struct has_trivial_assign;
+template <class T> struct has_trivial_destructor;
+template <class T> struct remove_const;
+template <class T> struct remove_volatile;
+template <class T> struct remove_cv;
+template <class T> struct remove_reference;
+template <class T> struct add_reference;
+template <class T> struct remove_pointer;
+template <class T, class U> struct is_same;
+#if !defined(_MSC_VER) && !(defined(__GNUC__) && __GNUC__ <= 3)
+template <class From, class To> struct is_convertible;
+#endif
 
-// is_integral is false except for the built-in integer types.
+// is_integral is false except for the built-in integer types. A
+// cv-qualified type is integral if and only if the underlying type is.
 template <class T> struct is_integral : false_type { };
 template<> struct is_integral<bool> : true_type { };
 template<> struct is_integral<char> : true_type { };
@@ -108,19 +114,80 @@ template<> struct is_integral<unsigned long> : true_type { };
 template<> struct is_integral<long long> : true_type { };
 template<> struct is_integral<unsigned long long> : true_type { };
 #endif
-
+template <class T> struct is_integral<const T> : is_integral<T> { };
+template <class T> struct is_integral<volatile T> : is_integral<T> { };
+template <class T> struct is_integral<const volatile T> : is_integral<T> { };
 
 // is_floating_point is false except for the built-in floating-point types.
+// A cv-qualified type is integral if and only if the underlying type is.
 template <class T> struct is_floating_point : false_type { };
 template<> struct is_floating_point<float> : true_type { };
 template<> struct is_floating_point<double> : true_type { };
 template<> struct is_floating_point<long double> : true_type { };
+template <class T> struct is_floating_point<const T>
+    : is_floating_point<T> { };
+template <class T> struct is_floating_point<volatile T>
+    : is_floating_point<T> { };
+template <class T> struct is_floating_point<const volatile T>
+    : is_floating_point<T> { };
 
-
-// is_pointer is false except for pointer types.
+// is_pointer is false except for pointer types. A cv-qualified type (e.g.
+// "int* const", as opposed to "int const*") is cv-qualified if and only if
+// the underlying type is.
 template <class T> struct is_pointer : false_type { };
 template <class T> struct is_pointer<T*> : true_type { };
+template <class T> struct is_pointer<const T> : is_pointer<T> { };
+template <class T> struct is_pointer<volatile T> : is_pointer<T> { };
+template <class T> struct is_pointer<const volatile T> : is_pointer<T> { };
+
+#if !defined(_MSC_VER) && !(defined(__GNUC__) && __GNUC__ <= 3)
+
+namespace internal {
+
+template <class T> struct is_class_or_union {
+  template <class U> static small_ tester(void (U::*)());
+  template <class U> static big_ tester(...);
+  static const bool value = sizeof(tester<T>(0)) == sizeof(small_);
+};
+
+// is_convertible chokes if the first argument is an array. That's why
+// we use add_reference here.
+template <bool NotUnum, class T> struct is_enum_impl
+    : is_convertible<typename add_reference<T>::type, int> { };
+
+template <class T> struct is_enum_impl<true, T> : false_type { };
 
+}  // namespace internal
+
+// Specified by TR1 [4.5.1] primary type categories.
+
+// Implementation note:
+//
+// Each type is either void, integral, floating point, array, pointer,
+// reference, member object pointer, member function pointer, enum,
+// union or class. Out of these, only integral, floating point, reference,
+// class and enum types are potentially convertible to int. Therefore,
+// if a type is not a reference, integral, floating point or class and
+// is convertible to int, it's a enum. Adding cv-qualification to a type
+// does not change whether it's an enum.
+//
+// Is-convertible-to-int check is done only if all other checks pass,
+// because it can't be used with some types (e.g. void or classes with
+// inaccessible conversion operators).
+template <class T> struct is_enum
+    : internal::is_enum_impl<
+          is_same<T, void>::value ||
+              is_integral<T>::value ||
+              is_floating_point<T>::value ||
+              is_reference<T>::value ||
+              internal::is_class_or_union<T>::value,
+          T> { };
+
+template <class T> struct is_enum<const T> : is_enum<T> { };
+template <class T> struct is_enum<volatile T> : is_enum<T> { };
+template <class T> struct is_enum<const volatile T> : is_enum<T> { };
+
+#endif
 
 // is_reference is false except for reference types.
 template<typename T> struct is_reference : false_type {};
@@ -128,13 +195,20 @@ template<typename T> struct is_reference<T&> : true_type {};
 
 
 // We can't get is_pod right without compiler help, so fail conservatively.
-// We will assume it's false except for arithmetic types and pointers,
-// and const versions thereof. Note that std::pair is not a POD.
+// We will assume it's false except for arithmetic types, enumerations,
+// pointers and cv-qualified versions thereof. Note that std::pair<T,U>
+// is not a POD even if T and U are PODs.
 template <class T> struct is_pod
  : integral_constant<bool, (is_integral<T>::value ||
                             is_floating_point<T>::value ||
+#if !defined(_MSC_VER) && !(defined(__GNUC__) && __GNUC__ <= 3)
+                            // is_enum is not available on MSVC.
+                            is_enum<T>::value ||
+#endif
                             is_pointer<T>::value)> { };
 template <class T> struct is_pod<const T> : is_pod<T> { };
+template <class T> struct is_pod<volatile T> : is_pod<T> { };
+template <class T> struct is_pod<const volatile T> : is_pod<T> { };
 
 
 // We can't get has_trivial_constructor right without compiler help, so
@@ -203,10 +277,13 @@ template<typename T> struct remove_cv {
 };
 
 
-// Specified by TR1 [4.7.2]
+// Specified by TR1 [4.7.2] Reference modifications.
 template<typename T> struct remove_reference { typedef T type; };
 template<typename T> struct remove_reference<T&> { typedef T type; };
 
+template <typename T> struct add_reference { typedef T& type; };
+template <typename T> struct add_reference<T&> { typedef T& type; };
+
 // Specified by TR1 [4.7.4] Pointer modifications.
 template<typename T> struct remove_pointer { typedef T type; };
 template<typename T> struct remove_pointer<T*> { typedef T type; };
@@ -219,6 +296,47 @@ template<typename T> struct remove_pointer<T* const volatile> {
 template<typename T, typename U> struct is_same : public false_type { };
 template<typename T> struct is_same<T, T> : public true_type { };
 
+// Specified by TR1 [4.6] Relationships between types
+#if !defined(_MSC_VER) && !(defined(__GNUC__) && __GNUC__ <= 3)
+namespace internal {
+
+// This class is an implementation detail for is_convertible, and you
+// don't need to know how it works to use is_convertible. For those
+// who care: we declare two different functions, one whose argument is
+// of type To and one with a variadic argument list. We give them
+// return types of different size, so we can use sizeof to trick the
+// compiler into telling us which function it would have chosen if we
+// had called it with an argument of type From.  See Alexandrescu's
+// _Modern C++ Design_ for more details on this sort of trick.
+
+template <typename From, typename To>
+struct ConvertHelper {
+  static small_ Test(To);
+  static big_ Test(...);
+  static From Create();
+};
+}  // namespace internal
+
+// Inherits from true_type if From is convertible to To, false_type otherwise.
+template <typename From, typename To>
+struct is_convertible
+    : integral_constant<bool,
+                        sizeof(internal::ConvertHelper<From, To>::Test(
+                                  internal::ConvertHelper<From, To>::Create()))
+                        == sizeof(small_)> {
+};
+#endif
+
 _END_GOOGLE_NAMESPACE_
 
+// Right now these macros are no-ops, and mostly just document the fact
+// these types are PODs, for human use.  They may be made more contentful
+// later.  The typedef is just to make it legal to put a semicolon after
+// these macros.
+#define DECLARE_POD(TypeName) typedef int Dummy_Type_For_DECLARE_POD
+#define DECLARE_NESTED_POD(TypeName) DECLARE_POD(TypeName)
+#define PROPAGATE_POD_FROM_TEMPLATE_ARGUMENT(TemplateName)             \
+    typedef int Dummy_Type_For_PROPAGATE_POD_FROM_TEMPLATE_ARGUMENT
+#define ENFORCE_POD(TypeName) typedef int Dummy_Type_For_ENFORCE_POD
+
 #endif  // BASE_TYPE_TRAITS_H_

data/ext/{sparsehash-1.8.1 → sparsehash-2.0.2}/src/sparsetable_unittest.cc

@@ -1,10 +1,10 @@
 // Copyright (c) 2005, Google Inc.
 // All rights reserved.
-// 
+//
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
-// 
+//
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
@@ -14,7 +14,7 @@
 //     * Neither the name of Google Inc. nor the names of its
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
-// 
+//
 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
@@ -28,32 +28,31 @@
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 // ---
-// Author: Craig Silverstein
-//
-// This tests <google/sparsetable>
 //
 // Since sparsetable is templatized, it's important that we test every
 // function in every class in this file -- not just to see if it
 // works, but even if it compiles.
 
-#include "config.h"
-#include <string>
+#include <sparsehash/internal/sparseconfig.h>
+#include <config.h>
 #include <stdio.h>
-#include <string.h>         // for memcmp()
+#include <string.h>
+#include <sys/types.h>      // for size_t
 #include <stdlib.h>         // defines unlink() on some windows platforms(?)
 #ifdef HAVE_UNISTD_H
-#include <unistd.h>         // for unlink()
-#include <sys/types.h>      // for size_t
-#include <string>
+# include <unistd.h>
+#endif         // for unlink()
 #include <memory>           // for allocator
-#endif
-#include <google/sparsetable>
-
-using STL_NAMESPACE::string;
-using STL_NAMESPACE::allocator;
+#include <string>
+#include <sparsehash/sparsetable>
+using std::string;
+using std::allocator;
 using GOOGLE_NAMESPACE::sparsetable;
 using GOOGLE_NAMESPACE::DEFAULT_SPARSEGROUP_SIZE;
 
+typedef u_int16_t uint16;
+string FLAGS_test_tmpdir = "/tmp/";
+
 // Many sparsetable operations return a size_t.  Rather than have to
 // use PRIuS everywhere, we'll just cast to a "big enough" value.
 #define UL(x)    ( static_cast<unsigned long>(x) )
@@ -273,6 +272,28 @@ void TestInt() {
   TEST(x.begin() == x.begin() + 1 - 1);
   TEST(z.begin() != z.end());
 
+  // ----------------------------------------------------------------------
+  // Test the non-empty iterators get_pos function
+
+  sparsetable<unsigned int> gp(100);
+  for (int i = 0; i < 100; i += 9) {
+    gp.set(i,i);
+  }
+
+  for (sparsetable<unsigned int>::const_nonempty_iterator
+           it = gp.nonempty_begin(); it != gp.nonempty_end(); ++it) {
+    out += snprintf(out, LEFT,
+                    "get_pos() for const nonempty_iterator: %u == %lu\n",
+                    *it, UL(gp.get_pos(it)));
+  }
+
+  for (sparsetable<unsigned int>::nonempty_iterator
+           it = gp.nonempty_begin(); it != gp.nonempty_end(); ++it) {
+    out += snprintf(out, LEFT,
+                    "get_pos() for nonempty_iterator: %u == %lu\n",
+                    *it, UL(gp.get_pos(it)));
+  }
+
   // ----------------------------------------------------------------------
   // Test sparsetable functions
   out += snprintf(out, LEFT, "x has %lu/%lu buckets, "
@@ -280,7 +301,7 @@ void TestInt() {
                   UL(x.num_nonempty()), UL(x.size()),
                   UL(y.num_nonempty()), UL(y.size()),
                   UL(z.num_nonempty()), UL(z.size()));
-  
+
   y.resize(48);              // should get rid of 48 and 49
   y.resize(70);              // 48 and 49 should still be gone
   out += snprintf(out, LEFT, "y shrank and grew: it's now %lu/%lu\n",
@@ -322,8 +343,8 @@ void TestInt() {
     out += snprintf(out, LEFT, "y[??] = %d\n", *--it);
 
   // ----------------------------------------------------------------------
-  // Test I/O
-  string filestr = "/tmp/.sparsetable.test";
+  // Test I/O using deprecated read/write_metadata
+  string filestr = FLAGS_test_tmpdir + "/.sparsetable.test";
   const char *file = filestr.c_str();
   FILE *fp = fopen(file, "wb");
   if ( fp == NULL ) {
@@ -354,6 +375,31 @@ void TestInt() {
     out += snprintf(out, LEFT, "That's %lu set buckets\n", UL(y2.num_nonempty()));
   }
   unlink(file);
+
+  // ----------------------------------------------------------------------
+  // Also test I/O using serialize()/unserialize()
+  fp = fopen(file, "wb");
+  if ( fp == NULL ) {
+    out += snprintf(out, LEFT, "Can't open %s, skipping disk write...\n", file);
+  } else {
+    y.serialize(sparsetable<int>::NopointerSerializer(), fp);
+    fclose(fp);
+  }
+  fp = fopen(file, "rb");
+  if ( fp == NULL ) {
+    out += snprintf(out, LEFT, "Can't open %s, skipping disk read...\n", file);
+  } else {
+    sparsetable<int> y2;
+    y2.unserialize(sparsetable<int>::NopointerSerializer(), fp);
+    fclose(fp);
+
+    for ( sparsetable<int>::const_iterator it = y2.begin(); it != y2.end(); ++it ) {
+      if ( y2.test(it) )
+        out += snprintf(out, LEFT, "y2[%lu] is %d\n", UL(it - y2.begin()), *it);
+    }
+    out += snprintf(out, LEFT, "That's %lu set buckets\n", UL(y2.num_nonempty()));
+  }
+  unlink(file);
 }
 
 // Test sparsetable with a non-POD type, std::string
@@ -462,7 +508,7 @@ void ResetAllocatorCounters() {
 template <class T> class instrumented_allocator {
  public:
   typedef T value_type;
-  typedef u_int16_t size_type;
+  typedef uint16 size_type;
   typedef ptrdiff_t difference_type;
 
   typedef T* pointer;
@@ -758,6 +804,30 @@ static const char g_expected[] = (
     "first non-empty x: 10\n"
     "x.begin() == x.begin() + 1 - 1? yes\n"
     "z.begin() != z.end()? no\n"
+    "get_pos() for const nonempty_iterator: 0 == 0\n"
+    "get_pos() for const nonempty_iterator: 9 == 9\n"
+    "get_pos() for const nonempty_iterator: 18 == 18\n"
+    "get_pos() for const nonempty_iterator: 27 == 27\n"
+    "get_pos() for const nonempty_iterator: 36 == 36\n"
+    "get_pos() for const nonempty_iterator: 45 == 45\n"
+    "get_pos() for const nonempty_iterator: 54 == 54\n"
+    "get_pos() for const nonempty_iterator: 63 == 63\n"
+    "get_pos() for const nonempty_iterator: 72 == 72\n"
+    "get_pos() for const nonempty_iterator: 81 == 81\n"
+    "get_pos() for const nonempty_iterator: 90 == 90\n"
+    "get_pos() for const nonempty_iterator: 99 == 99\n"
+    "get_pos() for nonempty_iterator: 0 == 0\n"
+    "get_pos() for nonempty_iterator: 9 == 9\n"
+    "get_pos() for nonempty_iterator: 18 == 18\n"
+    "get_pos() for nonempty_iterator: 27 == 27\n"
+    "get_pos() for nonempty_iterator: 36 == 36\n"
+    "get_pos() for nonempty_iterator: 45 == 45\n"
+    "get_pos() for nonempty_iterator: 54 == 54\n"
+    "get_pos() for nonempty_iterator: 63 == 63\n"
+    "get_pos() for nonempty_iterator: 72 == 72\n"
+    "get_pos() for nonempty_iterator: 81 == 81\n"
+    "get_pos() for nonempty_iterator: 90 == 90\n"
+    "get_pos() for nonempty_iterator: 99 == 99\n"
     "x has 3/7 buckets, y 4/70, z 0/0\n"
     "y shrank and grew: it's now 2/70\n"
     "y[12] = -12, y.get(12) = -12\n"
@@ -803,6 +873,19 @@ static const char g_expected[] = (
     "y2[37] is -37\n"
     "y2[9898] is -9898\n"
     "That's 12 set buckets\n"
+    "y2[10] is -10\n"
+    "y2[11] is -11\n"
+    "y2[13] is -13\n"
+    "y2[14] is -14\n"
+    "y2[30] is -30\n"
+    "y2[31] is -31\n"
+    "y2[32] is -32\n"
+    "y2[33] is -33\n"
+    "y2[35] is -35\n"
+    "y2[36] is -36\n"
+    "y2[37] is -37\n"
+    "y2[9898] is -9898\n"
+    "That's 12 set buckets\n"
     "string test\n"
     "x[0]: \n"
     "x[1]: \n"
@@ -873,7 +956,10 @@ static const char g_expected[] = (
     );
 
 // defined at bottom of file for ease of maintainence
-int main(int /*argc*/, char ** /*argv*/) {
+int main(int argc, char **argv) {          // though we ignore the args
+  (void)argc;
+  (void)argv;
+
   TestInt();
   TestString();
   TestAllocator();