google_hash 0.6.2 → 0.7.0

data/ext/sparsehash-1.8.1/src/libc_allocator_with_realloc_test.cc

@@ -0,0 +1,129 @@
+// Copyright (c) 2010, 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.
+
+// ---
+// Author: Guilin Chen
+
+#include "config.h"
+#include <google/sparsehash/libc_allocator_with_realloc.h>
+#include <stdlib.h>
+#include <iostream>
+#include <string>
+#include <vector>
+
+using std::cerr;
+using std::string;
+using std::basic_string;
+using std::char_traits;
+using std::vector;
+using GOOGLE_NAMESPACE::libc_allocator_with_realloc;
+
+#define arraysize(a)  ( sizeof(a) / sizeof(*(a)) )
+
+#define EXPECT_EQ(a, b)  do {                                           \
+  if ((a) != (b)) {                                                     \
+    cerr << "Check failed: EXPECTED: " << #a << " == " << #b << ", "    \
+         << "ACTUAL: " << a << " != " << b << "\n";                     \
+    exit(1);                                                            \
+  }                                                                     \
+} while (0)
+
+namespace {
+
+typedef libc_allocator_with_realloc<int> int_alloc;
+typedef int_alloc::rebind<int*>::other intp_alloc;
+
+// cstring allocates from libc_allocator_with_realloc.
+typedef basic_string<char, char_traits<char>,
+                     libc_allocator_with_realloc<char> > cstring;
+typedef vector<cstring, libc_allocator_with_realloc<cstring> > cstring_vector;
+
+
+void TestAllocate() {
+  int_alloc alloc;
+  intp_alloc palloc;
+
+  int** parray = palloc.allocate(1024);
+  for (int i = 0; i < 16; ++i) {
+    parray[i] = alloc.allocate(i * 1024 + 1);
+  }
+  for (int i = 0; i < 16; ++i) {
+    alloc.deallocate(parray[i], i * 1024 + 1);
+  }
+  palloc.deallocate(parray, 1024);
+
+  int* p = alloc.allocate(4096);
+  p[0] = 1;
+  p[1023] = 2;
+  p[4095] = 3;
+  p = alloc.reallocate(p, 8192);
+  EXPECT_EQ(1, p[0]);
+  EXPECT_EQ(2, p[1023]);
+  EXPECT_EQ(3, p[4095]);
+  p = alloc.reallocate(p, 1024);
+  EXPECT_EQ(1, p[0]);
+  EXPECT_EQ(2, p[1023]);
+  alloc.deallocate(p, 1024);
+}
+
+void TestSTL() {
+  // Test strings copied from base/arena_unittest.cc
+  static const char* test_strings[] = {
+    "aback", "abaft", "abandon", "abandoned", "abandoning",
+    "abandonment", "abandons", "abase", "abased", "abasement",
+    "abasements", "abases", "abash", "abashed", "abashes", "abashing",
+    "abasing", "abate", "abated", "abatement", "abatements", "abater",
+    "abates", "abating", "abbe", "abbey", "abbeys", "abbot", "abbots",
+    "abbreviate", "abbreviated", "abbreviates", "abbreviating",
+    "abbreviation", "abbreviations", "abdomen", "abdomens", "abdominal",
+    "abduct", "abducted", "abduction", "abductions", "abductor", "abductors",
+    "abducts", "Abe", "abed", "Abel", "Abelian", "Abelson", "Aberdeen",
+    "Abernathy", "aberrant", "aberration", "aberrations", "abet", "abets",
+    "abetted", "abetter", "abetting", "abeyance", "abhor", "abhorred",
+    "abhorrent", "abhorrer", "abhorring", "abhors", "abide", "abided",
+    "abides", "abiding"};
+  cstring_vector v;
+  for (size_t i = 0; i < arraysize(test_strings); ++i) {
+    v.push_back(test_strings[i]);
+  }
+  for (size_t i = arraysize(test_strings); i > 0; --i) {
+    EXPECT_EQ(cstring(test_strings[i-1]), v.back());
+    v.pop_back();
+  }
+}
+
+}  // namespace
+
+int main() {
+  TestAllocate();
+  TestSTL();
+
+  cerr << "PASS\n";
+  return 0;
+}

data/ext/{sparsehash-1.5.2 → sparsehash-1.8.1}/src/simple_test.cc

@@ -55,7 +55,7 @@
   }                                                                     \
 } while (0)
 
-int main(int argc, char** argv) {
+int main(int argc, char**) {
   // Run with an argument to get verbose output
   const bool verbose = argc > 1;
 

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

@@ -45,11 +45,14 @@
 #include <unistd.h>         // for unlink()
 #include <sys/types.h>      // for size_t
 #include <string>
+#include <memory>           // for allocator
 #endif
 #include <google/sparsetable>
 
 using STL_NAMESPACE::string;
+using STL_NAMESPACE::allocator;
 using GOOGLE_NAMESPACE::sparsetable;
+using GOOGLE_NAMESPACE::DEFAULT_SPARSEGROUP_SIZE;
 
 // Many sparsetable operations return a size_t.  Rather than have to
 // use PRIuS everywhere, we'll just cast to a "big enough" value.
@@ -320,12 +323,12 @@ void TestInt() {
 
   // ----------------------------------------------------------------------
   // Test I/O
-  string filestr = "/tmp/#sparsetable.test";
+  string filestr = "/tmp/.sparsetable.test";
   const char *file = filestr.c_str();
   FILE *fp = fopen(file, "wb");
   if ( fp == NULL ) {
     // maybe we can't write to /tmp/.  Try the current directory
-    file = "#sparsetable.test";
+    file = ".sparsetable.test";
     fp = fopen(file, "wb");
   }
   if ( fp == NULL ) {
@@ -443,7 +446,182 @@ void TestString() {
     out += snprintf(out, LEFT, "y[??] = %s\n", (*--it).c_str());
 }
 
-// The expected output from all of the above: TestInt() and TestString()
+// An instrumented allocator that keeps track of all calls to
+// allocate/deallocate/construct/destroy. It stores the number of times
+// they were called and the values they were called with. Such information is
+// stored in the following global variables.
+
+static size_t sum_allocate_bytes;
+static size_t sum_deallocate_bytes;
+
+void ResetAllocatorCounters() {
+  sum_allocate_bytes = 0;
+  sum_deallocate_bytes = 0;
+}
+
+template <class T> class instrumented_allocator {
+ public:
+  typedef T value_type;
+  typedef u_int16_t size_type;
+  typedef ptrdiff_t difference_type;
+
+  typedef T* pointer;
+  typedef const T* const_pointer;
+  typedef T& reference;
+  typedef const T& const_reference;
+
+  instrumented_allocator() {}
+  instrumented_allocator(const instrumented_allocator&) {}
+  ~instrumented_allocator() {}
+
+  pointer address(reference r) const  { return &r; }
+  const_pointer address(const_reference r) const  { return &r; }
+
+  pointer allocate(size_type n, const_pointer = 0) {
+    sum_allocate_bytes += n * sizeof(value_type);
+    return static_cast<pointer>(malloc(n * sizeof(value_type)));
+  }
+  void deallocate(pointer p, size_type n) {
+    sum_deallocate_bytes += n * sizeof(value_type);
+    free(p);
+  }
+
+  size_type max_size() const  {
+    return static_cast<size_type>(-1) / sizeof(value_type);
+  }
+
+  void construct(pointer p, const value_type& val) {
+    new(p) value_type(val);
+  }
+  void destroy(pointer p) {
+    p->~value_type();
+  }
+
+  template <class U>
+  explicit instrumented_allocator(const instrumented_allocator<U>&) {}
+
+  template<class U>
+  struct rebind {
+    typedef instrumented_allocator<U> other;
+  };
+
+ private:
+  void operator=(const instrumented_allocator&);
+};
+
+template<class T>
+inline bool operator==(const instrumented_allocator<T>&,
+                       const instrumented_allocator<T>&) {
+  return true;
+}
+
+template<class T>
+inline bool operator!=(const instrumented_allocator<T>&,
+                       const instrumented_allocator<T>&) {
+  return false;
+}
+
+// Test sparsetable with instrumented_allocator.
+void TestAllocator() {
+  out += snprintf(out, LEFT, "allocator test\n");
+
+  ResetAllocatorCounters();
+
+  // POD (int32) with instrumented_allocator.
+  typedef sparsetable<int, DEFAULT_SPARSEGROUP_SIZE,
+                      instrumented_allocator<int> > IntSparseTable;
+
+  IntSparseTable* s1 = new IntSparseTable(10000);
+  TEST(sum_allocate_bytes > 0);
+  for (int i = 0; i < 10000; ++i) {
+    s1->set(i, 0);
+  }
+  TEST(sum_allocate_bytes >= 10000 * sizeof(int));
+  ResetAllocatorCounters();
+  delete s1;
+  TEST(sum_deallocate_bytes >= 10000 * sizeof(int));
+
+  IntSparseTable* s2 = new IntSparseTable(1000);
+  IntSparseTable* s3 = new IntSparseTable(1000);
+
+  for (int i = 0; i < 1000; ++i) {
+    s2->set(i, 0);
+    s3->set(i, 0);
+  }
+  TEST(sum_allocate_bytes >= 2000 * sizeof(int));
+
+  ResetAllocatorCounters();
+  s3->clear();
+  TEST(sum_deallocate_bytes >= 1000 * sizeof(int));
+
+  ResetAllocatorCounters();
+  s2->swap(*s3);  // s2 is empty after the swap
+  s2->clear();
+  TEST(sum_deallocate_bytes < 1000 * sizeof(int));
+  for (int i = 0; i < s3->size(); ++i) {
+    s3->erase(i);
+  }
+  TEST(sum_deallocate_bytes >= 1000 * sizeof(int));
+  delete s2;
+  delete s3;
+
+  // POD (int) with default allocator.
+  sparsetable<int> x, y;
+  for (int s = 1000; s <= 40000; s += 1000) {
+    x.resize(s);
+    for (int i = 0; i < s; ++i) {
+      x.set(i, i + 1);
+    }
+    y = x;
+    for (int i = 0; i < s; ++i) {
+      y.erase(i);
+    }
+    y.swap(x);
+  }
+  TEST(x.num_nonempty() == 0);
+  out += snprintf(out, LEFT, "y[0]: %d\n", int(y[0]));
+  out += snprintf(out, LEFT, "y[39999]: %d\n", int(y[39999]));
+  y.clear();
+
+  // POD (int) with std allocator.
+  sparsetable<int, DEFAULT_SPARSEGROUP_SIZE, allocator<int> > u, v;
+  for (int s = 1000; s <= 40000; s += 1000) {
+    u.resize(s);
+    for (int i = 0; i < s; ++i) {
+      u.set(i, i + 1);
+    }
+    v = u;
+    for (int i = 0; i < s; ++i) {
+      v.erase(i);
+    }
+    v.swap(u);
+  }
+  TEST(u.num_nonempty() == 0);
+  out += snprintf(out, LEFT, "v[0]: %d\n", int(v[0]));
+  out += snprintf(out, LEFT, "v[39999]: %d\n", int(v[39999]));
+  v.clear();
+
+  // Non-POD (string) with default allocator.
+  sparsetable<string> a, b;
+  for (int s = 1000; s <= 40000; s += 1000) {
+    a.resize(s);
+    for (int i = 0; i < s; ++i) {
+      a.set(i, "aa");
+    }
+    b = a;
+    for (int i = 0; i < s; ++i) {
+      b.erase(i);
+    }
+    b.swap(a);
+  }
+  TEST(a.num_nonempty() == 0);
+  out += snprintf(out, LEFT, "b[0]: %s\n", b.get(0).c_str());
+  out += snprintf(out, LEFT, "b[39999]: %s\n", b.get(39999).c_str());
+  b.clear();
+}
+
+// The expected output from all of the above: TestInt(), TestString() and
+// TestAllocator().
 static const char g_expected[] = (
     "int test\n"
     "x[0]: 0\n"
@@ -675,17 +853,35 @@ static const char g_expected[] = (
     "y[??] = -13\n"
     "y[??] = -11\n"
     "y[??] = -10\n"
+    "allocator test\n"
+    "sum_allocate_bytes > 0? yes\n"
+    "sum_allocate_bytes >= 10000 * sizeof(int)? yes\n"
+    "sum_deallocate_bytes >= 10000 * sizeof(int)? yes\n"
+    "sum_allocate_bytes >= 2000 * sizeof(int)? yes\n"
+    "sum_deallocate_bytes >= 1000 * sizeof(int)? yes\n"
+    "sum_deallocate_bytes < 1000 * sizeof(int)? yes\n"
+    "sum_deallocate_bytes >= 1000 * sizeof(int)? yes\n"
+    "x.num_nonempty() == 0? yes\n"
+    "y[0]: 1\n"
+    "y[39999]: 40000\n"
+    "u.num_nonempty() == 0? yes\n"
+    "v[0]: 1\n"
+    "v[39999]: 40000\n"
+    "a.num_nonempty() == 0? yes\n"
+    "b[0]: aa\n"
+    "b[39999]: aa\n"
     );
 
 // defined at bottom of file for ease of maintainence
-int main(int argc, char **argv) {          // though we ignore the args
+int main(int /*argc*/, char ** /*argv*/) {
   TestInt();
   TestString();
+  TestAllocator();
 
   // Finally, check to see if our output (in out) is what it's supposed to be.
   const size_t r = sizeof(g_expected) - 1;
-  if ( r != out - outbuf ||               // output not the same size
-       memcmp(outbuf, g_expected, r) ) {  // or bytes differed
+  if ( r != static_cast<size_t>(out - outbuf) ||   // output not the same size
+       memcmp(outbuf, g_expected, r) ) {           // or bytes differed
     fprintf(stderr, "TESTS FAILED\n\nEXPECTED:\n\n%s\n\nACTUAL:\n\n%s\n\n",
             g_expected, outbuf);
     return 1;

data/ext/sparsehash-1.8.1/src/testutil.h

@@ -0,0 +1,251 @@
+// Copyright (c) 2010, 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.
+
+// ---
+// Author: Craig Silverstein
+
+// This macro mimics a unittest framework, but is a bit less flexible
+// than most.  It requires a superclass to derive from, and does all
+// work in global constructors.  The tricky part is implementing
+// TYPED_TEST.
+
+#ifndef SPARSEHASH_TEST_UTIL_H_
+#define SPARSEHASH_TEST_UTIL_H_
+
+#include "config.h"
+#include <stdio.h>
+
+_START_GOOGLE_NAMESPACE_
+
+namespace testing {
+
+#define EXPECT_TRUE(cond)  do {                         \
+  if (!(cond)) {                                        \
+    ::fputs("Test failed: " #cond "\n", stderr);        \
+    ::exit(1);                                          \
+  }                                                     \
+} while (0)
+
+#define EXPECT_FALSE(a)  EXPECT_TRUE(!(a))
+#define EXPECT_EQ(a, b)  EXPECT_TRUE((a) == (b))
+#define EXPECT_LT(a, b)  EXPECT_TRUE((a) < (b))
+#define EXPECT_GT(a, b)  EXPECT_TRUE((a) > (b))
+#define EXPECT_LE(a, b)  EXPECT_TRUE((a) <= (b))
+#define EXPECT_GE(a, b)  EXPECT_TRUE((a) >= (b))
+
+#define TEST(suitename, testname)                                       \
+  class TEST_##suitename##_##testname {                                 \
+   public:                                                              \
+    TEST_##suitename##_##testname() {                                   \
+      ::fputs("Running " #suitename "." #testname "\n", stderr);        \
+      Run();                                                            \
+    }                                                                   \
+    void Run();                                                         \
+  };                                                                    \
+  static TEST_##suitename##_##testname                                  \
+      test_instance_##suitename##_##testname;                           \
+  void TEST_##suitename##_##testname::Run()
+
+
+template<typename C1, typename C2, typename C3, typename C4, typename C5,
+         typename C6> struct TypeList6 {
+  typedef C1 type1;
+  typedef C2 type2;
+  typedef C3 type3;
+  typedef C4 type4;
+  typedef C5 type5;
+  typedef C6 type6;
+};
+
+// I need to list 18 types here, for code below to compile, though
+// only the first 6 are ever used.
+#define TYPED_TEST_CASE_6(classname, typelist)  \
+  typedef typelist::type1 classname##_type1;    \
+  typedef typelist::type2 classname##_type2;    \
+  typedef typelist::type3 classname##_type3;    \
+  typedef typelist::type4 classname##_type4;    \
+  typedef typelist::type5 classname##_type5;    \
+  typedef typelist::type6 classname##_type6;    \
+  static const int classname##_numtypes = 6;    \
+  typedef typelist::type1 classname##_type7;    \
+  typedef typelist::type1 classname##_type8;    \
+  typedef typelist::type1 classname##_type9;    \
+  typedef typelist::type1 classname##_type10;   \
+  typedef typelist::type1 classname##_type11;   \
+  typedef typelist::type1 classname##_type12;   \
+  typedef typelist::type1 classname##_type13;   \
+  typedef typelist::type1 classname##_type14;   \
+  typedef typelist::type1 classname##_type15;   \
+  typedef typelist::type1 classname##_type16;   \
+  typedef typelist::type1 classname##_type17;   \
+  typedef typelist::type1 classname##_type18;
+
+template<typename C1, typename C2, typename C3, typename C4, typename C5,
+         typename C6, typename C7, typename C8, typename C9, typename C10,
+         typename C11, typename C12, typename C13, typename C14, typename C15,
+         typename C16, typename C17, typename C18> struct TypeList18 {
+  typedef C1 type1;
+  typedef C2 type2;
+  typedef C3 type3;
+  typedef C4 type4;
+  typedef C5 type5;
+  typedef C6 type6;
+  typedef C7 type7;
+  typedef C8 type8;
+  typedef C9 type9;
+  typedef C10 type10;
+  typedef C11 type11;
+  typedef C12 type12;
+  typedef C13 type13;
+  typedef C14 type14;
+  typedef C15 type15;
+  typedef C16 type16;
+  typedef C17 type17;
+  typedef C18 type18;
+};
+
+#define TYPED_TEST_CASE_18(classname, typelist)  \
+  typedef typelist::type1 classname##_type1;    \
+  typedef typelist::type2 classname##_type2;    \
+  typedef typelist::type3 classname##_type3;    \
+  typedef typelist::type4 classname##_type4;    \
+  typedef typelist::type5 classname##_type5;    \
+  typedef typelist::type6 classname##_type6;    \
+  typedef typelist::type7 classname##_type7;    \
+  typedef typelist::type8 classname##_type8;    \
+  typedef typelist::type9 classname##_type9;    \
+  typedef typelist::type10 classname##_type10;    \
+  typedef typelist::type11 classname##_type11;    \
+  typedef typelist::type12 classname##_type12;    \
+  typedef typelist::type13 classname##_type13;    \
+  typedef typelist::type14 classname##_type14;    \
+  typedef typelist::type15 classname##_type15;    \
+  typedef typelist::type16 classname##_type16;    \
+  typedef typelist::type17 classname##_type17;    \
+  typedef typelist::type18 classname##_type18;    \
+  static const int classname##_numtypes = 18;
+
+#define TYPED_TEST(superclass, testname)                                \
+  template<typename TypeParam>                                          \
+  class TEST_onetype_##superclass##_##testname :                        \
+      public superclass<TypeParam> {                                    \
+   public:                                                              \
+    TEST_onetype_##superclass##_##testname() {                          \
+      Run();                                                            \
+    }                                                                   \
+   private:                                                             \
+    void Run();                                                         \
+  };                                                                    \
+  class TEST_typed_##superclass##_##testname {                          \
+   public:                                                              \
+    explicit TEST_typed_##superclass##_##testname() {                   \
+      if (superclass##_numtypes >= 1) {                                 \
+        ::fputs("Running " #superclass "." #testname ".1\n", stderr);   \
+        TEST_onetype_##superclass##_##testname<superclass##_type1> t;   \
+      }                                                                 \
+      if (superclass##_numtypes >= 2) {                                 \
+        ::fputs("Running " #superclass "." #testname ".2\n", stderr);   \
+        TEST_onetype_##superclass##_##testname<superclass##_type2> t;   \
+      }                                                                 \
+      if (superclass##_numtypes >= 3) {                                 \
+        ::fputs("Running " #superclass "." #testname ".3\n", stderr);   \
+        TEST_onetype_##superclass##_##testname<superclass##_type3> t;   \
+      }                                                                 \
+      if (superclass##_numtypes >= 4) {                                 \
+        ::fputs("Running " #superclass "." #testname ".4\n", stderr);   \
+        TEST_onetype_##superclass##_##testname<superclass##_type4> t;   \
+      }                                                                 \
+      if (superclass##_numtypes >= 5) {                                 \
+        ::fputs("Running " #superclass "." #testname ".5\n", stderr);   \
+        TEST_onetype_##superclass##_##testname<superclass##_type5> t;   \
+      }                                                                 \
+      if (superclass##_numtypes >= 6) {                                 \
+        ::fputs("Running " #superclass "." #testname ".6\n", stderr);   \
+        TEST_onetype_##superclass##_##testname<superclass##_type6> t;   \
+      }                                                                 \
+      if (superclass##_numtypes >= 7) {                                 \
+        ::fputs("Running " #superclass "." #testname ".7\n", stderr);   \
+        TEST_onetype_##superclass##_##testname<superclass##_type7> t;   \
+      }                                                                 \
+      if (superclass##_numtypes >= 8) {                                 \
+        ::fputs("Running " #superclass "." #testname ".8\n", stderr);   \
+        TEST_onetype_##superclass##_##testname<superclass##_type8> t;   \
+      }                                                                 \
+      if (superclass##_numtypes >= 9) {                                 \
+        ::fputs("Running " #superclass "." #testname ".9\n", stderr);   \
+        TEST_onetype_##superclass##_##testname<superclass##_type9> t;   \
+      }                                                                 \
+      if (superclass##_numtypes >= 10) {                                \
+        ::fputs("Running " #superclass "." #testname ".10\n", stderr);  \
+        TEST_onetype_##superclass##_##testname<superclass##_type10> t;  \
+      }                                                                 \
+      if (superclass##_numtypes >= 11) {                                \
+        ::fputs("Running " #superclass "." #testname ".11\n", stderr);  \
+        TEST_onetype_##superclass##_##testname<superclass##_type11> t;  \
+      }                                                                 \
+      if (superclass##_numtypes >= 12) {                                \
+        ::fputs("Running " #superclass "." #testname ".12\n", stderr);  \
+        TEST_onetype_##superclass##_##testname<superclass##_type12> t;  \
+      }                                                                 \
+      if (superclass##_numtypes >= 13) {                                \
+        ::fputs("Running " #superclass "." #testname ".13\n", stderr);  \
+        TEST_onetype_##superclass##_##testname<superclass##_type13> t;  \
+      }                                                                 \
+      if (superclass##_numtypes >= 14) {                                \
+        ::fputs("Running " #superclass "." #testname ".14\n", stderr);  \
+        TEST_onetype_##superclass##_##testname<superclass##_type14> t;  \
+      }                                                                 \
+      if (superclass##_numtypes >= 15) {                                \
+        ::fputs("Running " #superclass "." #testname ".15\n", stderr);  \
+        TEST_onetype_##superclass##_##testname<superclass##_type15> t;  \
+      }                                                                 \
+      if (superclass##_numtypes >= 16) {                                \
+        ::fputs("Running " #superclass "." #testname ".16\n", stderr);  \
+        TEST_onetype_##superclass##_##testname<superclass##_type16> t;  \
+      }                                                                 \
+      if (superclass##_numtypes >= 17) {                                \
+        ::fputs("Running " #superclass "." #testname ".17\n", stderr);  \
+        TEST_onetype_##superclass##_##testname<superclass##_type17> t;  \
+      }                                                                 \
+      if (superclass##_numtypes >= 18) {                                \
+        ::fputs("Running " #superclass "." #testname ".18\n", stderr);  \
+        TEST_onetype_##superclass##_##testname<superclass##_type18> t;  \
+      }                                                                 \
+    }                                                                   \
+  };                                                                    \
+  static TEST_typed_##superclass##_##testname                           \
+      test_instance_typed_##superclass##_##testname;                    \
+  template<class TypeParam>                                             \
+  void TEST_onetype_##superclass##_##testname<TypeParam>::Run()
+
+} // namespace testing
+
+_END_GOOGLE_NAMESPACE_
+
+#endif  // SPARSEHASH_TEST_UTIL_H_