google_hash 0.0.0

data/ext/sparsehash-1.5.2/src/google/type_traits.h

@@ -0,0 +1,250 @@
+// Copyright (c) 2006, 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: Matt Austern
+//
+// Define a small subset of tr1 type traits. The traits we define are:
+//   is_integral
+//   is_floating_point
+//   is_pointer
+//   is_reference
+//   is_pod
+//   has_trivial_constructor
+//   has_trivial_copy
+//   has_trivial_assign
+//   has_trivial_destructor
+//   remove_const
+//   remove_volatile
+//   remove_cv
+//   remove_reference
+//   remove_pointer
+//   is_convertible
+// We can add more type traits as required.
+
+#ifndef BASE_TYPE_TRAITS_H_
+#define BASE_TYPE_TRAITS_H_
+
+#include <google/sparsehash/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;
+
+// Types small_ and big_ are guaranteed such that sizeof(small_) <
+// sizeof(big_)
+typedef char small_;
+
+struct big_ {
+  char dummy[2];
+};
+
+// is_integral is false except for the built-in integer types.
+template <class T> struct is_integral : false_type { };
+template<> struct is_integral<bool> : true_type { };
+template<> struct is_integral<char> : true_type { };
+template<> struct is_integral<unsigned char> : true_type { };
+template<> struct is_integral<signed char> : true_type { };
+#if defined(_MSC_VER)
+// wchar_t is not by default a distinct type from unsigned short in
+// Microsoft C.
+// See http://msdn2.microsoft.com/en-us/library/dh8che7s(VS.80).aspx
+template<> struct is_integral<__wchar_t> : true_type { };
+#else
+template<> struct is_integral<wchar_t> : true_type { };
+#endif
+template<> struct is_integral<short> : true_type { };
+template<> struct is_integral<unsigned short> : true_type { };
+template<> struct is_integral<int> : true_type { };
+template<> struct is_integral<unsigned int> : true_type { };
+template<> struct is_integral<long> : true_type { };
+template<> struct is_integral<unsigned long> : true_type { };
+#ifdef HAVE_LONG_LONG
+template<> struct is_integral<long long> : true_type { };
+template<> struct is_integral<unsigned long long> : true_type { };
+#endif
+
+
+// is_floating_point is false except for the built-in floating-point types.
+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 { };
+
+
+// is_pointer is false except for pointer types.
+template <class T> struct is_pointer : false_type { };
+template <class T> struct is_pointer<T*> : true_type { };
+
+
+// is_reference is false except for reference types.
+template<typename T> struct is_reference : false_type {};
+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.
+template <class T> struct is_pod
+ : integral_constant<bool, (is_integral<T>::value ||
+                            is_floating_point<T>::value ||
+                            is_pointer<T>::value)> { };
+template <class T> struct is_pod<const T> : is_pod<T> { };
+
+
+// We can't get has_trivial_constructor right without compiler help, so
+// fail conservatively. We will assume it's false except for: (1) types
+// for which is_pod is true. (2) std::pair of types with trivial
+// constructors. (3) array of a type with a trivial constructor.
+// (4) const versions thereof.
+template <class T> struct has_trivial_constructor : is_pod<T> { };
+template <class T, class U> struct has_trivial_constructor<std::pair<T, U> >
+  : integral_constant<bool,
+                      (has_trivial_constructor<T>::value &&
+                       has_trivial_constructor<U>::value)> { };
+template <class A, int N> struct has_trivial_constructor<A[N]>
+  : has_trivial_constructor<A> { };
+template <class T> struct has_trivial_constructor<const T>
+  : has_trivial_constructor<T> { };
+
+// We can't get has_trivial_copy right without compiler help, so fail
+// conservatively. We will assume it's false except for: (1) types
+// for which is_pod is true. (2) std::pair of types with trivial copy
+// constructors. (3) array of a type with a trivial copy constructor.
+// (4) const versions thereof.
+template <class T> struct has_trivial_copy : is_pod<T> { };
+template <class T, class U> struct has_trivial_copy<std::pair<T, U> >
+  : integral_constant<bool,
+                      (has_trivial_copy<T>::value &&
+                       has_trivial_copy<U>::value)> { };
+template <class A, int N> struct has_trivial_copy<A[N]>
+  : has_trivial_copy<A> { };
+template <class T> struct has_trivial_copy<const T> : has_trivial_copy<T> { };
+
+// We can't get has_trivial_assign right without compiler help, so fail
+// conservatively. We will assume it's false except for: (1) types
+// for which is_pod is true. (2) std::pair of types with trivial copy
+// constructors. (3) array of a type with a trivial assign constructor.
+template <class T> struct has_trivial_assign : is_pod<T> { };
+template <class T, class U> struct has_trivial_assign<std::pair<T, U> >
+  : integral_constant<bool,
+                      (has_trivial_assign<T>::value &&
+                       has_trivial_assign<U>::value)> { };
+template <class A, int N> struct has_trivial_assign<A[N]>
+  : has_trivial_assign<A> { };
+
+// We can't get has_trivial_destructor right without compiler help, so
+// fail conservatively. We will assume it's false except for: (1) types
+// for which is_pod is true. (2) std::pair of types with trivial
+// destructors. (3) array of a type with a trivial destructor.
+// (4) const versions thereof.
+template <class T> struct has_trivial_destructor : is_pod<T> { };
+template <class T, class U> struct has_trivial_destructor<std::pair<T, U> >
+  : integral_constant<bool,
+                      (has_trivial_destructor<T>::value &&
+                       has_trivial_destructor<U>::value)> { };
+template <class A, int N> struct has_trivial_destructor<A[N]>
+  : has_trivial_destructor<A> { };
+template <class T> struct has_trivial_destructor<const T>
+  : has_trivial_destructor<T> { };
+
+// Specified by TR1 [4.7.1]
+template<typename T> struct remove_const { typedef T type; };
+template<typename T> struct remove_const<T const> { typedef T type; };
+template<typename T> struct remove_volatile { typedef T type; };
+template<typename T> struct remove_volatile<T volatile> { typedef T type; };
+template<typename T> struct remove_cv {
+  typedef typename remove_const<typename remove_volatile<T>::type>::type type;
+};
+
+
+// Specified by TR1 [4.7.2]
+template<typename T> struct remove_reference { typedef T type; };
+template<typename T> struct remove_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; };
+template<typename T> struct remove_pointer<T* const> { typedef T type; };
+template<typename T> struct remove_pointer<T* volatile> { typedef T type; };
+template<typename T> struct remove_pointer<T* const volatile> {
+  typedef T type; };
+
+// Specified by TR1 [4.6] Relationships between types
+#ifndef _MSC_VER
+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_
+
+#endif  // BASE_TYPE_TRAITS_H_

data/ext/sparsehash-1.5.2/src/hashtable_unittest.cc

@@ -0,0 +1,1375 @@
+// 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
+// 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 tests <google/sparsehash/densehashtable.h>
+// This tests <google/dense_hash_set>
+// This tests <google/dense_hash_map>
+// This tests <google/sparsehash/sparsehashtable.h>
+// This tests <google/sparse_hash_set>
+// This tests <google/sparse_hash_map>
+
+// Since {dense,sparse}hashtable 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 <stdio.h>
+#include <sys/stat.h>          // for stat()
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>            // for unlink()
+#endif
+#include <string.h>
+#include <time.h>              // for silly random-number-seed generator
+#include <math.h>              // for sqrt()
+#include <map>
+#include <set>
+#include <iterator>            // for insert_iterator
+#include <iostream>
+#include <iomanip>             // for setprecision()
+#include <string>
+#include HASH_FUN_H            // defined in config.h
+#include <google/type_traits.h>
+#include <google/dense_hash_map>
+#include <google/dense_hash_set>
+#include <google/sparsehash/densehashtable.h>
+#include <google/sparse_hash_map>
+#include <google/sparse_hash_set>
+#include <google/sparsehash/sparsehashtable.h>
+
+// Otherwise, VC++7 warns about size_t -> int in the cout logging lines
+#ifdef _MSC_VER
+#pragma warning(disable:4267)
+#endif
+
+using GOOGLE_NAMESPACE::sparse_hash_map;
+using GOOGLE_NAMESPACE::dense_hash_map;
+using GOOGLE_NAMESPACE::sparse_hash_set;
+using GOOGLE_NAMESPACE::dense_hash_set;
+using GOOGLE_NAMESPACE::sparse_hashtable;
+using GOOGLE_NAMESPACE::dense_hashtable;
+using STL_NAMESPACE::map;
+using STL_NAMESPACE::set;
+using STL_NAMESPACE::pair;
+using STL_NAMESPACE::make_pair;
+using STL_NAMESPACE::string;
+using STL_NAMESPACE::insert_iterator;
+using STL_NAMESPACE::allocator;
+using STL_NAMESPACE::equal_to;
+using STL_NAMESPACE::ostream;
+
+#define LOGF  STL_NAMESPACE::cout   // where we log to; LOGF is a historical name
+
+#define CHECK(cond)  do {                       \
+  if (!(cond)) {                                \
+    LOGF << "Test failed: " #cond "\n";         \
+    exit(1);                                    \
+  }                                             \
+} while (0)
+
+#define CHECK_EQ(a, b)  CHECK((a) == (b))
+#define CHECK_LT(a, b)  CHECK((a) < (b))
+#define CHECK_GE(a, b)  CHECK((a) >= (b))
+
+#ifndef _MSC_VER
+static string TmpFile(const char* basename) {
+  return string("/tmp/") + basename;
+}
+#endif
+
+const char *words[] = {"Baffin\n",        // in /usr/dict/words
+                       "Boffin\n",        // not in
+                       "baffin\n",        // not in
+                       "genial\n",        // last word in
+                       "Aarhus\n",        // first word alphabetically
+                       "Zurich\n",        // last word alphabetically
+                       "Getty\n",
+};
+
+const char *nwords[] = {"Boffin\n",
+                        "baffin\n",
+};
+
+const char *default_dict[] = {"Aarhus\n",
+                              "aback\n",
+                              "abandon\n",
+                              "Baffin\n",
+                              "baffle\n",
+                              "bagged\n",
+                              "congenial\n",
+                              "genial\n",
+                              "Getty\n",
+                              "indiscreet\n",
+                              "linens\n",
+                              "pence\n",
+                              "reassure\n",
+                              "sequel\n",
+                              "zoning\n",
+                              "zoo\n",
+                              "Zurich\n",
+};
+
+// Apparently identity is not stl-standard, so we define our own
+template<class Value>
+struct Identity {
+  Value& operator()(Value& v) const { return v; }
+  const Value& operator()(const Value& v) const { return v; }
+};
+
+// Likewise, it's not standard to hash a string pre-tr1.  Luckily, it is a char*
+#ifdef HAVE_UNORDERED_MAP
+typedef SPARSEHASH_HASH<string> StrHash;
+struct CharStarHash {
+  size_t operator()(const char* s) const {
+    return StrHash()(string(s));
+  }
+};
+#else
+typedef SPARSEHASH_HASH<const char*> CharStarHash;
+struct StrHash {
+  size_t operator()(const string& s) const {
+    return SPARSEHASH_HASH<const char*>()(s.c_str());
+  }
+};
+#endif
+
+// Let us log the pairs that make up a hash_map
+template<class P1, class P2>
+ostream& operator<<(ostream& s, const pair<P1, P2>& p) {
+  s << "pair(" << p.first << ", " << p.second << ")";
+  return s;
+}
+
+struct strcmp_fnc {
+  bool operator()(const char* s1, const char* s2) const {
+    return ((s1 == 0 && s2 == 0) ||
+            (s1 && s2 && *s1 == *s2 && strcmp(s1, s2) == 0));
+  }
+};
+
+namespace {
+
+template <class T, class H, class I, class S, class C, class A>
+void set_empty_key(sparse_hashtable<T,T,H,I,S,C,A> *ht, T val) {
+}
+
+template <class T, class H, class C>
+void set_empty_key(sparse_hash_set<T,H,C> *ht, T val) {
+}
+
+template <class K, class V, class H, class C>
+void set_empty_key(sparse_hash_map<K,V,H,C> *ht, K val) {
+}
+
+template <class T, class H, class I, class S, class C, class A>
+void set_empty_key(dense_hashtable<T,T,H,I,S,C,A> *ht, T val) {
+  ht->set_empty_key(val);
+}
+
+template <class T, class H, class C>
+void set_empty_key(dense_hash_set<T,H,C> *ht, T val) {
+  ht->set_empty_key(val);
+}
+
+template <class K, class V, class H, class C>
+void set_empty_key(dense_hash_map<K,V,H,C> *ht, K val) {
+  ht->set_empty_key(val);
+}
+
+template <class T, class H, class I, class S, class C, class A>
+bool clear_no_resize(sparse_hashtable<T,T,H,I,S,C,A> *ht) {
+  return false;
+}
+
+template <class T, class H, class C>
+bool clear_no_resize(sparse_hash_set<T,H,C> *ht) {
+  return false;
+}
+
+template <class K, class V, class H, class C>
+bool clear_no_resize(sparse_hash_map<K,V,H,C> *ht) {
+  return false;
+}
+
+template <class T, class H, class I, class S, class C, class A>
+bool clear_no_resize(dense_hashtable<T,T,H,I,S,C,A> *ht) {
+  ht->clear_no_resize();
+  return true;
+}
+
+template <class T, class H, class C>
+bool clear_no_resize(dense_hash_set<T,H,C> *ht) {
+  ht->clear_no_resize();
+  return true;
+}
+
+template <class K, class V, class H, class C>
+bool clear_no_resize(dense_hash_map<K,V,H,C> *ht) {
+  ht->clear_no_resize();
+  return true;
+}
+
+template <class T, class H, class I, class S, class C, class A>
+void insert(dense_hashtable<T,T,H,I,S,C,A> *ht, T val) {
+  ht->insert(val);
+}
+
+template <class T, class H, class C>
+void insert(dense_hash_set<T,H,C> *ht, T val) {
+  ht->insert(val);
+}
+
+template <class K, class V, class H, class C>
+void insert(dense_hash_map<K,V,H,C> *ht, K val) {
+  ht->insert(pair<K,V>(val,V()));
+}
+
+template <class T, class H, class I, class S, class C, class A>
+void insert(sparse_hashtable<T,T,H,I,S,C,A> *ht, T val) {
+  ht->insert(val);
+}
+
+template <class T, class H, class C>
+void insert(sparse_hash_set<T,H,C> *ht, T val) {
+  ht->insert(val);
+}
+
+template <class K, class V, class H, class C>
+void insert(sparse_hash_map<K,V,H,C> *ht, K val) {
+  ht->insert(pair<K,V>(val,V()));
+}
+
+template <class HT, class Iterator>
+void insert(HT *ht, Iterator begin, Iterator end) {
+  ht->insert(begin, end);
+}
+
+// For hashtable's and hash_set's, the iterator insert works fine (and
+// is used). But for the hash_map's, the iterator insert expects the
+// iterators to point to pair's. So by looping over and calling insert
+// on each element individually, the code below automatically expands
+// into inserting a pair.
+template <class K, class V, class H, class C, class Iterator>
+void insert(dense_hash_map<K,V,H,C> *ht, Iterator begin, Iterator end) {
+  while (begin != end) {
+    insert(ht, *begin);
+    ++begin;
+  }
+}
+
+template <class K, class V, class H, class C, class Iterator>
+void insert(sparse_hash_map<K,V,H,C> *ht, Iterator begin, Iterator end) {
+  while (begin != end) {
+    insert(ht, *begin);
+    ++begin;
+  }
+}
+
+// A version of insert that uses the insert_iterator.  But insert_iterator
+// isn't defined for the low level hashtable classes, so we just punt to insert.
+
+template <class T, class H, class I, class S, class C, class A>
+void iterator_insert(dense_hashtable<T,T,H,I,S,C,A>* ht, T val,
+                     insert_iterator<dense_hashtable<T,T,H,I,S,C,A> >* ) {
+  ht->insert(val);
+}
+
+template <class T, class H, class C>
+void iterator_insert(dense_hash_set<T,H,C>* , T val,
+                     insert_iterator<dense_hash_set<T,H,C> >* ii) {
+  *(*ii)++ = val;
+}
+
+template <class K, class V, class H, class C>
+void iterator_insert(dense_hash_map<K,V,H,C>* , K val,
+                     insert_iterator<dense_hash_map<K,V,H,C> >* ii) {
+  *(*ii)++ = pair<K,V>(val,V());
+}
+
+template <class T, class H, class I, class S, class C, class A>
+void iterator_insert(sparse_hashtable<T,T,H,I,S,C,A>* ht, T val,
+                     insert_iterator<sparse_hashtable<T,T,H,I,S,C,A> >* ) {
+  ht->insert(val);
+}
+
+template <class T, class H, class C>
+void iterator_insert(sparse_hash_set<T,H,C>* , T val,
+                     insert_iterator<sparse_hash_set<T,H,C> >* ii) {
+  *(*ii)++ = val;
+}
+
+template <class K, class V, class H, class C>
+void iterator_insert(sparse_hash_map<K,V,H,C> *, K val,
+                     insert_iterator<sparse_hash_map<K,V,H,C> >* ii) {
+  *(*ii)++ = pair<K,V>(val,V());
+}
+
+
+void write_item(FILE *fp, const char *val) {
+  fwrite(val, strlen(val), 1, fp);   // \n serves to separate
+}
+
+// The weird 'const' declarations are desired by the compiler. Yucko.
+void write_item(FILE *fp, const pair<char*const,int> &val) {
+  fwrite(val.first, strlen(val.first), 1, fp);
+}
+
+void write_item(FILE *fp, const string &val) {
+  fwrite(val.data(), val.length(), 1, fp);   // \n serves to separate
+}
+
+// The weird 'const' declarations are desired by the compiler. Yucko.
+void write_item(FILE *fp, const pair<const string,int> &val) {
+  fwrite(val.first.data(), val.first.length(), 1, fp);
+}
+
+char* read_line(FILE* fp, char* line, int linesize) {
+  if ( fgets(line, linesize, fp) == NULL )
+    return NULL;
+  // normalize windows files :-(
+  const size_t linelen = strlen(line);
+  if ( linelen >= 2 && line[linelen-2] == '\r' && line[linelen-1] == '\n' ) {
+    line[linelen-2] = '\n';
+    line[linelen-1] = '\0';
+  }
+  return line;
+}
+
+void read_item(FILE *fp, char*const* val) {
+  char line[1024];
+  read_line(fp, line, sizeof(line));
+  char **p = const_cast<char**>(val);
+  *p = strdup(line);
+}
+
+void read_item(FILE *fp, pair<char*const,int> *val) {
+  char line[1024];
+  read_line(fp, line, sizeof(line));
+  char **p = const_cast<char**>(&val->first);
+  *p = strdup(line);
+}
+
+void read_item(FILE *fp, const string* val) {
+  char line[1024];
+  read_line(fp, line, sizeof(line));
+  new(const_cast<string*>(val)) string(line);   // need to use placement new
+}
+
+void read_item(FILE *fp, pair<const string,int> *val) {
+  char line[1024];
+  read_line(fp, line, sizeof(line));
+  new(const_cast<string*>(&val->first)) string(line);
+}
+
+void free_item(char*const* val) {
+  free(*val);
+}
+
+void free_item(pair<char*const,int> *val) {
+  free(val->first);
+}
+
+int get_int_item(int int_item) {
+  return int_item;
+}
+
+int get_int_item(pair<int, int> val) {
+  return val.first;
+}
+
+int getintkey(int i) { return i; }
+
+int getintkey(const pair<int, int> &p) { return p.first; }
+
+}   // end anonymous namespace
+
+// Performs tests where the hashtable's value type is assumed to be int.
+template <class htint>
+void test_int() {
+  htint x;
+  htint y(1000);
+  htint z(64);
+  set_empty_key(&x, 0xefefef);
+  set_empty_key(&y, 0xefefef);
+  set_empty_key(&z, 0xefefef);
+
+  CHECK(y.empty());
+  insert(&y, 1);
+  CHECK(!y.empty());
+  insert(&y, 11);
+  insert(&y, 111);
+  insert(&y, 1111);
+  insert(&y, 11111);
+  insert(&y, 111111);
+  insert(&y, 1111111);     // 1M, more or less
+  insert(&y, 11111111);
+  insert(&y, 111111111);
+  insert(&y, 1111111111);  // 1B, more or less
+  for ( int i = 0; i < 64; ++i )
+    insert(&z, i);
+  // test the second half of the insert with an insert_iterator
+  insert_iterator<htint> insert_iter(z, z.begin());
+  for ( int i = 32; i < 64; ++i )
+    iterator_insert(&z, i, &insert_iter);
+
+  // only perform the following CHECKs for
+  // dense{hashtable, _hash_set, _hash_map}
+  if (clear_no_resize(&x)) {
+    // make sure x has to increase its number of buckets
+    typename htint::size_type empty_bucket_count = x.bucket_count();
+    int last_element = 0;
+    while (x.bucket_count() == empty_bucket_count) {
+      insert(&x, last_element);
+      ++last_element;
+    }
+    // if clear_no_resize is supported (i.e. htint is a
+    // dense{hashtable,_hash_set,_hash_map}), it should leave the bucket_count
+    // as is.
+    typename htint::size_type last_bucket_count = x.bucket_count();
+    clear_no_resize(&x);
+    CHECK(last_bucket_count == x.bucket_count());
+    CHECK(x.empty());
+    LOGF << "x has " << x.bucket_count() << " buckets\n";
+    LOGF << "x size " << x.size() << "\n";
+    // when inserting the same number of elements again, no resize should be
+    // necessary
+    for (int i = 0; i < last_element; ++i) {
+      insert(&x, i);
+      CHECK(x.bucket_count() == last_bucket_count);
+    }
+  }
+
+  for ( typename htint::const_iterator it = y.begin(); it != y.end(); ++it )
+    LOGF << "y: " << get_int_item(*it) << "\n";
+  z.insert(y.begin(), y.end());
+  swap(y,z);
+  for ( typename htint::iterator it = y.begin(); it != y.end(); ++it )
+    LOGF << "y+z: " << get_int_item(*it) << "\n";
+  LOGF << "z has " << z.bucket_count() << " buckets\n";
+  LOGF << "y has " << y.bucket_count() << " buckets\n";
+  LOGF << "z size: " << z.size() << "\n";
+
+  for (int i = 0; i < 64; ++i)
+    CHECK(y.find(i) != y.end());
+
+  CHECK(z.size() == 10);
+  z.set_deleted_key(1010101010);      // an unused value
+  z.erase(11111);
+  CHECK(z.size() == 9);
+  insert(&z, 11111);                  // should retake deleted value
+  CHECK(z.size() == 10);
+  // Do the delete/insert again.  Last time we probably resized; this time no
+  z.erase(11111);
+  insert(&z, 11111);                  // should retake deleted value
+  CHECK(z.size() == 10);
+
+  z.erase(-11111);                    // shouldn't do anything
+  CHECK(z.size() == 10);
+  z.erase(1);
+  CHECK(z.size() == 9);
+
+  typename htint::iterator itdel = z.find(1111);
+  pair<typename htint::iterator,typename htint::iterator> itdel2
+      = z.equal_range(1111);
+  CHECK(itdel2.first != z.end());
+  CHECK(&*itdel2.first == &*itdel);   // while we're here, check equal_range()
+  CHECK(itdel2.second == ++itdel2.first);
+  pair<typename htint::const_iterator,typename htint::const_iterator> itdel3
+      = const_cast<const htint*>(&z)->equal_range(1111);
+  CHECK(itdel3.first != z.end());
+  CHECK(&*itdel3.first == &*itdel);
+  CHECK(itdel3.second == ++itdel3.first);
+
+  z.erase(itdel);
+  CHECK(z.size() == 8);
+  itdel2 = z.equal_range(1111);
+  CHECK(itdel2.first == z.end());
+  CHECK(itdel2.second == itdel2.first);
+  itdel3 = const_cast<const htint*>(&z)->equal_range(1111);
+  CHECK(itdel3.first == z.end());
+  CHECK(itdel3.second == itdel3.first);
+
+  itdel = z.find(2222);               // should be end()
+  z.erase(itdel);                     // shouldn't do anything
+  CHECK(z.size() == 8);
+  for ( typename htint::const_iterator it = z.begin(); it != z.end(); ++it )
+    LOGF << "y: " << get_int_item(*it) << "\n";
+  z.set_deleted_key(1010101011);      // a different unused value
+  for ( typename htint::const_iterator it = z.begin(); it != z.end(); ++it )
+    LOGF << "y: " << get_int_item(*it) << "\n";
+  LOGF << "That's " << z.size() << " elements\n";
+  z.erase(z.begin(), z.end());
+  CHECK(z.empty());
+
+  y.clear();
+  CHECK(y.empty());
+  LOGF << "y has " << y.bucket_count() << " buckets\n";
+}
+
+// Performs tests where the hashtable's value type is assumed to be char*.
+// The read_write parameters specifies whether the read/write tests
+// should be performed. Note that densehashtable::write_metdata is not
+// implemented, so we only do the read/write tests for the
+// sparsehashtable varieties.
+template <class ht>
+void test_charptr(bool read_write) {
+  ht w;
+  set_empty_key(&w, (char*) NULL);
+  insert(&w, const_cast<char **>(nwords),
+         const_cast<char **>(nwords) + sizeof(nwords) / sizeof(*nwords));
+  LOGF << "w has " << w.size() << " items\n";
+  CHECK(w.size() == 2);
+  CHECK(w == w);
+
+  ht x;
+  set_empty_key(&x, (char*) NULL);
+  long dict_size = 1;        // for size stats -- can't be 0 'cause of division
+
+  map<string, int> counts;
+  // Hash the dictionary
+  {
+    // automake says 'look for all data files in $srcdir.'  OK.
+    string filestr = (string(getenv("srcdir") ? getenv("srcdir") : ".") +
+                      "/src/words");
+    const char* file = filestr.c_str();
+    FILE *fp = fopen(file, "rb");
+    if ( fp == NULL ) {
+      LOGF << "Can't open " << file << ", using small, built-in dict...\n";
+      for (int i = 0; i < sizeof(default_dict)/sizeof(*default_dict); ++i) {
+        insert(&x, strdup(default_dict[i]));
+        counts[default_dict[i]] = 0;
+      }
+    } else {
+      char line[1024];
+      while ( read_line(fp, line, sizeof(line)) ) {
+        insert(&x, strdup(line));
+        counts[line] = 0;
+      }
+      LOGF << "Read " << x.size() << " words from " << file << "\n";
+      fclose(fp);
+      struct stat buf;
+      stat(file, &buf);
+      dict_size = buf.st_size;
+      LOGF << "Size of " << file << ": " << buf.st_size << " bytes\n";
+    }
+    for (char **word = const_cast<char **>(words);
+          word < const_cast<char **>(words) + sizeof(words) / sizeof(*words);
+          ++word ) {
+      if (x.find(*word) == x.end()) {
+        CHECK(w.find(*word) != w.end());
+      } else {
+        CHECK(w.find(*word) == w.end());
+      }
+    }
+  }
+  CHECK(counts.size() == x.size());
+
+  // Save the hashtable.
+  if (read_write) {
+    const string file_string = TmpFile("#hashtable_unittest_dicthash");
+    const char* file = file_string.c_str();
+    FILE *fp = fopen(file, "wb");
+    if ( fp == NULL ) {
+      // maybe we can't write to /tmp/.  Try the current directory
+      file = "#hashtable_unittest_dicthash";
+      fp = fopen(file, "wb");
+    }
+    if ( fp == NULL ) {
+      LOGF << "Can't open " << file << " skipping hashtable save...\n";
+    } else {
+      x.write_metadata(fp);        // this only writes meta-information
+      int write_count = 0;
+      for ( typename ht::iterator it = x.begin(); it != x.end(); ++it ) {
+        write_item(fp, *it);
+        free_item(&(*it));
+        ++write_count;
+      }
+      LOGF << "Wrote " << write_count << " words to " << file << "\n";
+      fclose(fp);
+      struct stat buf;
+      stat(file, &buf);
+      LOGF << "Size of " << file << ": " << buf.st_size << " bytes\n";
+      LOGF << STL_NAMESPACE::setprecision(3)
+           << "Hashtable overhead "
+           << (buf.st_size - dict_size) * 100.0 / dict_size
+           << "% ("
+           << (buf.st_size - dict_size) * 8.0 / write_count
+           << " bits/entry)\n";
+      x.clear();
+
+      // Load the hashtable
+      fp = fopen(file, "rb");
+      if ( fp == NULL ) {
+        LOGF << "Can't open " << file << " skipping hashtable reload...\n";
+      } else {
+        x.read_metadata(fp);      // reads metainformation
+        LOGF << "Hashtable size: " << x.size() << "\n";
+        int read_count = 0;
+        for ( typename ht::iterator it = x.begin(); it != x.end(); ++it ) {
+          read_item(fp, &(*it));
+          ++read_count;
+        }
+        LOGF << "Read " << read_count << " words from " << file << "\n";
+        fclose(fp);
+        unlink(file);
+        for ( char **word = const_cast<char **>(words);
+              word < const_cast<char **>(words) + sizeof(words) / sizeof(*words);
+              ++word ) {
+          if (x.find(*word) == x.end()) {
+            CHECK(w.find(*word) != w.end());
+          } else {
+            CHECK(w.find(*word) == w.end());
+          }
+        }
+      }
+    }
+  }
+  for ( typename ht::iterator it = x.begin(); it != x.end(); ++it ) {
+    free_item(&(*it));
+  }
+}
+
+// Perform tests where the hashtable's value type is assumed to
+// be string.
+// TODO(austern): factor out the bulk of test_charptr and test_string
+// into a common function.
+template <class ht>
+void test_string(bool read_write) {
+  ht w;
+  set_empty_key(&w, string("-*- empty key -*-"));
+  const int N = sizeof(nwords) / sizeof(*nwords);
+  string* nwords1 = new string[N];
+  for (int i = 0; i < N; ++i)
+    nwords1[i] = nwords[i];
+  insert(&w, nwords1, nwords1 + N);
+  delete[] nwords1;
+  LOGF << "w has " << w.size() << " items\n";
+  CHECK(w.size() == 2);
+  CHECK(w == w);
+
+  ht x;
+  set_empty_key(&x, string("-*- empty key -*-"));
+  long dict_size = 1;        // for size stats -- can't be 0 'cause of division
+
+  map<string, int> counts;
+  // Hash the dictionary
+  {
+    // automake says 'look for all data files in $srcdir.'  OK.
+    string filestr = (string(getenv("srcdir") ? getenv("srcdir") : ".") +
+                      "/src/words");
+    const char* file = filestr.c_str();
+    FILE *fp = fopen(file, "rb");
+    if ( fp == NULL ) {
+      LOGF << "Can't open " << file << ", using small, built-in dict...\n";
+      for (int i = 0; i < sizeof(default_dict)/sizeof(*default_dict); ++i) {
+        insert(&x, string(default_dict[i]));
+        counts[default_dict[i]] = 0;
+      }
+    } else {
+      char line[1024];
+      while ( fgets(line, sizeof(line), fp) ) {
+        insert(&x, string(line));
+        counts[line] = 0;
+      }
+      LOGF << "Read " << x.size() << " words from " << file << "\n";
+      fclose(fp);
+      struct stat buf;
+      stat(file, &buf);
+      dict_size = buf.st_size;
+      LOGF << "Size of " << file << ": " << buf.st_size << " bytes\n";
+    }
+    for ( const char* const* word = words;
+          word < words + sizeof(words) / sizeof(*words);
+          ++word ) {
+      if (x.find(*word) == x.end()) {
+        CHECK(w.find(*word) != w.end());
+      } else {
+        CHECK(w.find(*word) == w.end());
+      }
+    }
+  }
+  CHECK(counts.size() == x.size());
+  {
+    // verify that size() works correctly
+    int xcount = 0;
+    for ( typename ht::iterator it = x.begin(); it != x.end(); ++it ) {
+      ++xcount;
+    }
+    CHECK(x.size() == xcount);
+  }
+
+  // Save the hashtable.
+  if (read_write) {
+    const string file_string = TmpFile("#hashtable_unittest_dicthash_str");
+    const char* file = file_string.c_str();
+    FILE *fp = fopen(file, "wb");
+    if ( fp == NULL ) {
+      // maybe we can't write to /tmp/.  Try the current directory
+      file = "#hashtable_unittest_dicthash_str";
+      fp = fopen(file, "wb");
+    }
+    if ( fp == NULL ) {
+      LOGF << "Can't open " << file << " skipping hashtable save...\n";
+    } else {
+      x.write_metadata(fp);        // this only writes meta-information
+      int write_count = 0;
+      for ( typename ht::iterator it = x.begin(); it != x.end(); ++it ) {
+        write_item(fp, *it);
+        ++write_count;
+      }
+      LOGF << "Wrote " << write_count << " words to " << file << "\n";
+      fclose(fp);
+      struct stat buf;
+      stat(file, &buf);
+      LOGF << "Size of " << file << ": " << buf.st_size << " bytes\n";
+      LOGF << STL_NAMESPACE::setprecision(3)
+           << "Hashtable overhead "
+           << (buf.st_size - dict_size) * 100.0 / dict_size
+           << "% ("
+           << (buf.st_size - dict_size) * 8.0 / write_count
+           << " bits/entry)\n";
+      x.clear();
+
+      // Load the hashtable
+      fp = fopen(file, "rb");
+      if ( fp == NULL ) {
+        LOGF << "Can't open " << file << " skipping hashtable reload...\n";
+      } else {
+        x.read_metadata(fp);      // reads metainformation
+        LOGF << "Hashtable size: " << x.size() << "\n";
+        int count = 0;
+        for ( typename ht::iterator it = x.begin(); it != x.end(); ++it ) {
+          read_item(fp, &(*it));
+          ++count;
+        }
+        LOGF << "Read " << count << " words from " << file << "\n";
+        fclose(fp);
+        unlink(file);
+        for ( const char* const* word = words;
+              word < words + sizeof(words) / sizeof(*words);
+              ++word ) {
+          if (x.find(*word) == x.end()) {
+            CHECK(w.find(*word) != w.end());
+          } else {
+            CHECK(w.find(*word) == w.end());
+          }
+        }
+      }
+    }
+  }
+
+  // ensure that destruction is done properly in clear_no_resize()
+  if (!clear_no_resize(&w)) w.clear();
+}
+
+// The read_write parameters specifies whether the read/write tests
+// should be performed. Note that densehashtable::write_metdata is not
+// implemented, so we only do the read/write tests for the
+// sparsehashtable varieties.
+template<class ht, class htstr, class htint>
+void test(bool read_write) {
+  test_int<htint>();
+  test_string<htstr>(read_write);
+  test_charptr<ht>(read_write);
+}
+
+// For data types with trivial copy-constructors and destructors, we
+// should use an optimized routine for data-copying, that involves
+// memmove.  We test this by keeping count of how many times the
+// copy-constructor is called; it should be much less with the
+// optimized code.
+
+class Memmove {
+ public:
+  Memmove(): i_(0) {}
+  explicit Memmove(int i): i_(i) {}
+  Memmove(const Memmove& that) {
+    this->i_ = that.i_;
+    num_copies_++;
+  }
+
+  int i_;
+  static int num_copies_;
+};
+int Memmove::num_copies_ = 0;
+
+
+// This is what tells the hashtable code it can use memmove for this class:
+_START_GOOGLE_NAMESPACE_
+template<> struct has_trivial_copy<Memmove> : true_type { };
+template<> struct has_trivial_destructor<Memmove> : true_type { };
+_END_GOOGLE_NAMESPACE_
+
+class NoMemmove {
+ public:
+  NoMemmove(): i_(0) {}
+  explicit NoMemmove(int i): i_(i) {}
+  NoMemmove(const NoMemmove& that) {
+    this->i_ = that.i_;
+    num_copies_++;
+  }
+
+  int i_;
+  static int num_copies_;
+};
+int NoMemmove::num_copies_ = 0;
+
+void TestSimpleDataTypeOptimizations() {
+  {
+    sparse_hash_map<int, Memmove> memmove;
+    sparse_hash_map<int, NoMemmove> nomemmove;
+
+    Memmove::num_copies_ = 0;  // reset
+    NoMemmove::num_copies_ = 0;  // reset
+    for (int i = 10000; i > 0; i--) {
+      memmove[i] = Memmove(i);
+    }
+    for (int i = 10000; i > 0; i--) {
+      nomemmove[i] = NoMemmove(i);
+    }
+    LOGF << "sparse_hash_map copies for unoptimized/optimized cases: "
+         << NoMemmove::num_copies_ << "/" << Memmove::num_copies_ << "\n";
+    CHECK(NoMemmove::num_copies_ > Memmove::num_copies_);
+  }
+  // Same should hold true for dense_hash_map
+  {
+    dense_hash_map<int, Memmove> memmove;
+    dense_hash_map<int, NoMemmove> nomemmove;
+    memmove.set_empty_key(0);
+    nomemmove.set_empty_key(0);
+
+    Memmove::num_copies_ = 0;  // reset
+    NoMemmove::num_copies_ = 0;  // reset
+    for (int i = 10000; i > 0; i--) {
+      memmove[i] = Memmove(i);
+    }
+    for (int i = 10000; i > 0; i--) {
+      nomemmove[i] = NoMemmove(i);
+    }
+    LOGF << "dense_hash_map copies for unoptimized/optimized cases: "
+         << NoMemmove::num_copies_ << "/" << Memmove::num_copies_ << "\n";
+    CHECK(NoMemmove::num_copies_ > Memmove::num_copies_);
+  }
+}
+
+void TestShrinking() {
+  // We want to make sure that when we create a hashtable, and then
+  // add and delete one element, the size of the hashtable doesn't
+  // change.
+  {
+    sparse_hash_set<int> s;
+    s.set_deleted_key(0);
+    const int old_bucket_count = s.bucket_count();
+    s.insert(4);
+    s.erase(4);
+    s.insert(4);
+    s.erase(4);
+    CHECK_EQ(old_bucket_count, s.bucket_count());
+  }
+  {
+    dense_hash_set<int> s;
+    s.set_deleted_key(0);
+    s.set_empty_key(1);
+    const int old_bucket_count = s.bucket_count();
+    s.insert(4);
+    s.erase(4);
+    s.insert(4);
+    s.erase(4);
+    CHECK_EQ(old_bucket_count, s.bucket_count());
+  }
+  {
+    sparse_hash_set<int> s(2);        // start small: only expects 2 items
+    CHECK_LT(s.bucket_count(), 32);   // verify we actually do start small
+    s.set_deleted_key(0);
+    const int old_bucket_count = s.bucket_count();
+    s.insert(4);
+    s.erase(4);
+    s.insert(4);
+    s.erase(4);
+    CHECK_EQ(old_bucket_count, s.bucket_count());
+  }
+  {
+    dense_hash_set<int> s(2);   // start small: only expects 2 items
+    CHECK_LT(s.bucket_count(), 32);   // verify we actually do start small
+    s.set_deleted_key(0);
+    s.set_empty_key(1);
+    const int old_bucket_count = s.bucket_count();
+    s.insert(4);
+    s.erase(4);
+    s.insert(4);
+    s.erase(4);
+    CHECK_EQ(old_bucket_count, s.bucket_count());
+  }
+}
+
+class TestHashFcn : public SPARSEHASH_HASH<int> {
+ public:
+  explicit TestHashFcn(int i)
+      : id_(i) {
+  }
+
+  int id() const {
+    return id_;
+  }
+
+ private:
+  int id_;
+};
+
+class TestEqualTo : public equal_to<int> {
+ public:
+  explicit TestEqualTo(int i)
+      : id_(i) {
+  }
+
+  int id() const {
+    return id_;
+  }
+
+ private:
+  int id_;
+};
+
+template <template <class V, class H, class E, class A> class Hash>
+void TestHash() {
+  typedef Hash<int, TestHashFcn, TestEqualTo, allocator<int> > TheHash;
+  const TestHashFcn fcn(1);
+  const TestEqualTo eqt(2);
+  {
+    const TheHash simple(0, fcn, eqt);
+    CHECK(fcn.id() == simple.hash_funct().id());
+    CHECK(eqt.id() == simple.key_eq().id());
+  }
+  {
+    const set<int> input;
+    const TheHash iterated(input.begin(), input.end(), 0, fcn, eqt);
+    CHECK(fcn.id() == iterated.hash_funct().id());
+    CHECK(eqt.id() == iterated.key_eq().id());
+  }
+}
+
+static void TestHashes() {
+  TestHash<sparse_hash_set>();
+  TestHash<dense_hash_set>();
+}
+
+template <template <class K, class T, class H, class E, class A> class Map>
+void TestMap() {
+  typedef Map<int, int, TestHashFcn, TestEqualTo, allocator<int> > TheMap;
+  const TestHashFcn fcn(1);
+  const TestEqualTo eqt(2);
+  {
+    const TheMap simple(0, fcn, eqt);
+    CHECK(fcn.id() == simple.hash_funct().id());
+    CHECK(eqt.id() == simple.key_eq().id());
+  }
+  {
+    const map<int, int> input;
+    const TheMap iterated(input.begin(), input.end(), 0, fcn, eqt);
+    CHECK(fcn.id() == iterated.hash_funct().id());
+    CHECK(eqt.id() == iterated.key_eq().id());
+  }
+}
+
+static void TestMaps() {
+  TestMap<sparse_hash_map>();
+  TestMap<dense_hash_map>();
+}
+
+static void TestOperatorEquals() {
+  {
+    dense_hash_set<int> sa, sb;
+    sa.set_empty_key(-1);
+    sb.set_empty_key(-1);
+    sa.set_deleted_key(-2);
+    sb.set_deleted_key(-2);
+    CHECK(sa == sb);
+    sa.insert(1);
+    CHECK(sa != sb);
+    sa.insert(2);
+    CHECK(sa != sb);
+    sb.insert(2);
+    CHECK(sa != sb);
+    sb.insert(1);
+    CHECK(sa == sb);
+    sb.erase(1);
+    CHECK(sa != sb);
+  }
+  {
+    dense_hash_map<int, string> sa, sb;
+    sa.set_empty_key(-1);
+    sb.set_empty_key(-1);
+    sa.set_deleted_key(-2);
+    sb.set_deleted_key(-2);
+    CHECK(sa == sb);
+    sa.insert(make_pair(1, "a"));
+    CHECK(sa != sb);
+    sa.insert(make_pair(2, "b"));
+    CHECK(sa != sb);
+    sb.insert(make_pair(2, "b"));
+    CHECK(sa != sb);
+    sb.insert(make_pair(1, "a"));
+    CHECK(sa == sb);
+    sa[1] = "goodbye";
+    CHECK(sa != sb);
+    sb.erase(1);
+    CHECK(sa != sb);
+  }
+}
+
+// Test the interface for setting the resize parameters in a
+// sparse_hash_set or dense_hash_set.  If use_tr1_api is true,
+// we use the newer tr1-inspired functions to set resize_parameters,
+// rather than my old, home-grown API
+template<class HS, bool USE_TR1_API>
+static void TestResizingParameters() {
+  const int kSize = 16536;
+  // Check growing past various thresholds and then shrinking below
+  // them.
+  for (float grow_threshold = 0.2f;
+       grow_threshold <= 0.8f;
+       grow_threshold += 0.2f) {
+    HS hs;
+    hs.set_deleted_key(-1);
+    set_empty_key(&hs, -2);
+    if (USE_TR1_API) {
+      hs.max_load_factor(grow_threshold);
+      hs.min_load_factor(0.0);
+    } else {
+      hs.set_resizing_parameters(0.0, grow_threshold);
+    }
+    hs.resize(kSize);
+    size_t bucket_count = hs.bucket_count();
+    // Erase and insert an element to set consider_shrink = true,
+    // which should not cause a shrink because the threshold is 0.0.
+    insert(&hs, 1);
+    hs.erase(1);
+    for (int i = 0;; ++i) {
+      insert(&hs, i);
+      if (static_cast<float>(hs.size())/bucket_count < grow_threshold) {
+        CHECK(hs.bucket_count() == bucket_count);
+      } else {
+        CHECK(hs.bucket_count() > bucket_count);
+        break;
+      }
+    }
+    // Now set a shrink threshold 1% below the current size and remove
+    // items until the size falls below that.
+    const float shrink_threshold = static_cast<float>(hs.size()) /
+        hs.bucket_count() - 0.01f;
+    if (USE_TR1_API) {
+      hs.max_load_factor(1.0);
+      hs.min_load_factor(shrink_threshold);
+    } else {
+      hs.set_resizing_parameters(shrink_threshold, 1.0);
+    }
+    bucket_count = hs.bucket_count();
+    for (int i = 0;; ++i) {
+      hs.erase(i);
+      // A resize is only triggered by an insert, so add and remove a
+      // value every iteration to trigger the shrink as soon as the
+      // threshold is passed.
+      hs.erase(i+1);
+      insert(&hs, i+1);
+      if (static_cast<float>(hs.size())/bucket_count > shrink_threshold) {
+        CHECK(hs.bucket_count() == bucket_count);
+      } else {
+        CHECK(hs.bucket_count() < bucket_count);
+        break;
+      }
+    }
+  }
+}
+
+// Tests the some of the tr1-inspired API features.
+template<class HS>
+static void TestTR1API() {
+    HS hs;
+    hs.set_deleted_key(-1);
+    set_empty_key(&hs, -2);
+
+    typename HS::size_type expected_bucknum = hs.bucket(1);
+    insert(&hs, 1);
+    typename HS::size_type bucknum = hs.bucket(1);
+    CHECK(expected_bucknum == bucknum);
+    typename HS::const_local_iterator b = hs.begin(bucknum);
+    typename HS::const_local_iterator e = hs.end(bucknum);
+    CHECK(b != e);
+    CHECK(getintkey(*b) == 1);
+    b++;
+    CHECK(b == e);
+
+    hs.erase(1);
+    bucknum = hs.bucket(1);
+    CHECK(expected_bucknum == bucknum);
+    b = hs.begin(bucknum);
+    e = hs.end(bucknum);
+    CHECK(b == e);
+
+    // For very small sets, the min-bucket-size gets in the way, so
+    // let's make our hash_set bigger.
+    for (int i = 0; i < 10000; i++)
+      insert(&hs, i);
+    float f = hs.load_factor();
+    CHECK(f >= hs.min_load_factor());
+    CHECK(f <= hs.max_load_factor());
+}
+
+class MemUsingKey {
+ public:
+  // TODO(csilvers): nix this when requirement for zero-arg keys goes away
+  MemUsingKey() : data_(new int) {
+    net_allocations_++;
+  }
+  MemUsingKey(int i) : data_(new int(i)) {
+    net_allocations_++;
+  }
+  MemUsingKey(const MemUsingKey& that) : data_(new int(*that.data_)) {
+    net_allocations_++;
+  }
+  ~MemUsingKey() {
+    delete data_;
+    net_allocations_--;
+    CHECK_GE(net_allocations_, 0);
+  }
+  MemUsingKey& operator=(const MemUsingKey& that) {
+    delete data_;
+    data_ = new int(*that.data_);
+    return *this;
+  }
+  struct Hash {
+    size_t operator()(const MemUsingKey& x) const { return *x.data_; }
+  };
+  struct Equal {
+    bool operator()(const MemUsingKey& x, const MemUsingKey& y) const {
+      return *x.data_ == *y.data_;
+    }
+  };
+  static int net_allocations() { return net_allocations_; }
+ private:
+  int* data_;
+  static int net_allocations_;
+};
+
+class MemUsingValue {
+ public:
+  // This also tests that value does not need to have a zero-arg constructor
+  explicit MemUsingValue(const char* data) : data_(NULL) {
+    Strcpy(data);
+  }
+  MemUsingValue(const MemUsingValue& that) : data_(NULL) {
+    Strcpy(that.data_);
+  }
+  ~MemUsingValue() {
+    if (data_) {
+      free(data_);
+      net_allocations_--;
+      CHECK_GE(net_allocations_, 0);
+    }
+  }
+  MemUsingValue& operator=(const MemUsingValue& that) {
+    if (data_) {
+      free(data_);
+      net_allocations_--;
+      CHECK_GE(net_allocations_, 0);
+    }
+    Strcpy(that.data_);
+    return *this;
+  }
+  static int net_allocations() { return net_allocations_; }
+ private:
+  void Strcpy(const char* data) {
+    if (data) {
+      data_ = (char*)malloc(strlen(data) + 1);  // use malloc this time
+      strcpy(data_, data);                      // strdup isn't so portable
+      net_allocations_++;
+    } else {
+      data_ = NULL;
+    }
+  }
+  char* data_;
+  static int net_allocations_;
+};
+
+// TODO(csilvers): nix this when set_empty_key doesn't require zero-arg value
+class MemUsingValueWithZeroArgConstructor : public MemUsingValue {
+ public:
+  MemUsingValueWithZeroArgConstructor(const char* data=NULL)
+      : MemUsingValue(data) { }
+  MemUsingValueWithZeroArgConstructor(
+      const MemUsingValueWithZeroArgConstructor& that)
+      : MemUsingValue(that) { }
+  MemUsingValueWithZeroArgConstructor& operator=(
+      const MemUsingValueWithZeroArgConstructor& that) {
+    *static_cast<MemUsingValue*>(this)
+        = *static_cast<const MemUsingValue*>(&that);
+    return *this;
+  }
+};
+
+int MemUsingKey::net_allocations_ = 0;
+int MemUsingValue::net_allocations_ = 0;
+
+
+void TestMemoryManagement() {
+  MemUsingKey deleted_key(-1);
+  MemUsingKey empty_key(-2);
+
+  {
+    // TODO(csilvers): fix sparsetable to allow missing zero-arg value ctor
+    sparse_hash_map<MemUsingKey, MemUsingValueWithZeroArgConstructor,
+                    MemUsingKey::Hash, MemUsingKey::Equal> ht;
+    ht.set_deleted_key(deleted_key);
+    for (int i = 0; i < 1000; i++) {
+      ht.insert(pair<MemUsingKey,MemUsingValueWithZeroArgConstructor>(
+                    i, MemUsingValueWithZeroArgConstructor("hello!")));
+      ht.erase(i);
+      CHECK_EQ(0, MemUsingValue::net_allocations());
+    }
+  }
+  // Various copies of deleted_key will be hanging around until the
+  // hashtable is destroyed, so it's only safe to do this test now.
+  CHECK_EQ(2, MemUsingKey::net_allocations());  // for deleted+empty_key
+
+  {
+    dense_hash_map<MemUsingKey, MemUsingValueWithZeroArgConstructor,
+                   MemUsingKey::Hash, MemUsingKey::Equal> ht;
+    ht.set_empty_key(empty_key);
+    ht.set_deleted_key(deleted_key);
+    for (int i = 0; i < 1000; i++) {
+      // As long as we have a zero-arg constructor for the value anyway,
+      // use operator[] rather than the more verbose insert().
+      ht[i] = MemUsingValueWithZeroArgConstructor("hello!");
+      ht.erase(i);
+      CHECK_EQ(0, MemUsingValue::net_allocations());
+    }
+  }
+  CHECK_EQ(2, MemUsingKey::net_allocations());  // for deleted+empty_key
+}
+
+template<class Key>
+struct SetKey {
+  void operator()(Key* key, const Key& new_key) const {
+    *key = new_key;
+  }
+};
+
+int main(int argc, char **argv) {
+  TestOperatorEquals();
+
+  // SPARSEHASH_HASH is defined in sparseconfig.h.  It resolves to the
+  // system hash function (usually, but not always, named "hash") on
+  // whatever system we're on.
+
+  // First try with the low-level hashtable interface
+  LOGF << "\n\nTEST WITH DENSE_HASHTABLE\n\n";
+  test<dense_hashtable<char *, char *, CharStarHash,
+                       Identity<char *>, SetKey<char *>, strcmp_fnc,
+		       allocator<char *> >,
+       dense_hashtable<string, string, StrHash,
+                       Identity<string>, SetKey<string>,
+		       equal_to<string>,
+		       allocator<string> >,
+       dense_hashtable<int, int, SPARSEHASH_HASH<int>,
+                       Identity<int>, SetKey<int>, equal_to<int>,
+		       allocator<int> > >(
+                         false);
+
+  // Now try with hash_set, which should be equivalent
+  LOGF << "\n\nTEST WITH DENSE_HASH_SET\n\n";
+  test<dense_hash_set<char *, CharStarHash, strcmp_fnc>,
+       dense_hash_set<string, StrHash>,
+       dense_hash_set<int> >(false);
+
+  TestResizingParameters<dense_hash_set<int>, true>();    // use tr1 API
+  TestResizingParameters<dense_hash_set<int>, false>();   // use older API
+
+  // Now try with hash_map, which differs only in insert()
+  LOGF << "\n\nTEST WITH DENSE_HASH_MAP\n\n";
+  test<dense_hash_map<char *, int, CharStarHash, strcmp_fnc>,
+       dense_hash_map<string, int, StrHash>,
+       dense_hash_map<int, int> >(false);
+
+  // First try with the low-level hashtable interface
+  LOGF << "\n\nTEST WITH SPARSE_HASHTABLE\n\n";
+  test<sparse_hashtable<char *, char *, CharStarHash,
+                       Identity<char *>, SetKey<char *>, strcmp_fnc,
+		       allocator<char *> >,
+       sparse_hashtable<string, string, StrHash,
+                       Identity<string>, SetKey<string>, equal_to<string>,
+		       allocator<string> >,
+       sparse_hashtable<int, int, SPARSEHASH_HASH<int>,
+                       Identity<int>, SetKey<int>, equal_to<int>,
+		       allocator<int> > >(
+                         true);
+
+  // Now try with hash_set, which should be equivalent
+  LOGF << "\n\nTEST WITH SPARSE_HASH_SET\n\n";
+  test<sparse_hash_set<char *, CharStarHash, strcmp_fnc>,
+       sparse_hash_set<string, StrHash>,
+       sparse_hash_set<int> >(true);
+
+  TestResizingParameters<sparse_hash_set<int>, true>();
+  TestResizingParameters<sparse_hash_set<int>, false>();
+
+  // Now try with hash_map, which differs only in insert()
+  LOGF << "\n\nTEST WITH SPARSE_HASH_MAP\n\n";
+  test<sparse_hash_map<char *, int, CharStarHash, strcmp_fnc>,
+       sparse_hash_map<string, int, StrHash>,
+       sparse_hash_map<int, int> >(true);
+
+  // Test that we use the optimized routines for simple data types
+  LOGF << "\n\nTesting simple-data-type optimizations\n";
+  TestSimpleDataTypeOptimizations();
+
+  // Test shrinking to very small sizes
+  LOGF << "\n\nTesting shrinking behavior";
+  TestShrinking();
+
+  // Test that the hashers and key_equals are used properly in hash tables and
+  // hash maps.
+  LOGF << "\n\nTesting hashers and key_equals\n";
+  TestHashes();
+  TestMaps();
+
+  LOGF << "\n\nTesting tr1 API\n";
+  TestTR1API<sparse_hash_map<int, int> >();
+  TestTR1API<dense_hash_map<int, int> >();
+  TestTR1API<sparse_hash_set<int> >();
+  TestTR1API<dense_hash_set<int> >();
+
+  // Test memory management when the keys and values are non-trivial
+  LOGF << "\n\nTesting memory management\n";
+  TestMemoryManagement();
+
+  LOGF << "\nAll tests pass.\n";
+  return 0;
+}