google_hash 0.8.1 → 0.8.2

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

@@ -0,0 +1,34 @@
+// Copyright (c) 2012, 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.
+
+// Header files have moved from the google directory to the sparsehash
+// directory.  This forwarding file is provided only for backwards
+// compatibility.  Use <sparsehash/*> in all new code.
+
+#include <sparsehash/template_util.h>

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

@@ -0,0 +1,34 @@
+// Copyright (c) 2012, 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.
+
+// Header files have moved from the google directory to the sparsehash
+// directory.  This forwarding file is provided only for backwards
+// compatibility.  Use <sparsehash/*> in all new code.
+
+#include <sparsehash/type_traits.h>

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

@@ -27,8 +27,7 @@
 // (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 implements a uniform interface for all 6 hash implementations:
 //    dense_hashtable, dense_hash_map, dense_hash_set
@@ -46,15 +45,15 @@
 #ifndef UTIL_GTL_HASH_TEST_INTERFACE_H_
 #define UTIL_GTL_HASH_TEST_INTERFACE_H_
 
-#include "config.h"
-#include HASH_MAP_H    // for hash<>
-#include <functional>  // for equal_to<>
-#include <google/sparsehash/sparsehashtable.h>
-#include <google/sparse_hash_map>
-#include <google/sparse_hash_set>
-#include <google/sparsehash/densehashtable.h>
-#include <google/dense_hash_map>
-#include <google/dense_hash_set>
+#include <sparsehash/internal/sparseconfig.h>
+#include <functional>          // for equal_to<>
+#include <sparsehash/internal/sparsehashtable.h>
+#include <sparsehash/sparse_hash_map>
+#include <sparsehash/sparse_hash_set>
+#include <sparsehash/internal/densehashtable.h>
+#include <sparsehash/dense_hash_map>
+#include <sparsehash/dense_hash_set>
+#include HASH_FUN_H    // for hash<>
 
 _START_GOOGLE_NAMESPACE_
 
@@ -271,17 +270,18 @@ class BaseHashtableInterface {
 
   size_type count(const key_type& key) const { return ht_.count(key); }
 
-  pair<iterator, iterator> equal_range(const key_type& key) {
-    pair<typename HT::iterator, typename HT::iterator> r
+  std::pair<iterator, iterator> equal_range(const key_type& key) {
+    std::pair<typename HT::iterator, typename HT::iterator> r
         = ht_.equal_range(key);
-    return pair<iterator, iterator>(iterator(r.first, this),
+    return std::pair<iterator, iterator>(iterator(r.first, this),
                                     iterator(r.second, this));
   }
-  pair<const_iterator, const_iterator> equal_range(const key_type& key) const {
-    pair<typename HT::const_iterator, typename HT::const_iterator> r
+  std::pair<const_iterator, const_iterator> equal_range(const key_type& key)
+      const {
+    std::pair<typename HT::const_iterator, typename HT::const_iterator> r
         = ht_.equal_range(key);
-    return pair<const_iterator, const_iterator>(const_iterator(r.first, this),
-                                                const_iterator(r.second, this));
+    return std::pair<const_iterator, const_iterator>(
+        const_iterator(r.first, this), const_iterator(r.second, this));
   }
 
   const_iterator random_element(class ACMRandom* r) const {
@@ -291,9 +291,9 @@ class BaseHashtableInterface {
     return iterator(ht_.random_element(r), this);
   }
 
-  pair<iterator, bool> insert(const value_type& obj) {
-    pair<typename HT::iterator, bool> r = ht_.insert(obj);
-    return pair<iterator, bool>(iterator(r.first, this), r.second);
+  std::pair<iterator, bool> insert(const value_type& obj) {
+    std::pair<typename HT::iterator, bool> r = ht_.insert(obj);
+    return std::pair<iterator, bool>(iterator(r.first, this), r.second);
   }
   template <class InputIterator>
   void insert(InputIterator f, InputIterator l) {
@@ -328,6 +328,15 @@ class BaseHashtableInterface {
     return ht_ != other.ht_;
   }
 
+  template <typename ValueSerializer, typename OUTPUT>
+  bool serialize(ValueSerializer serializer, OUTPUT *fp) {
+    return ht_.serialize(serializer, fp);
+  }
+  template <typename ValueSerializer, typename INPUT>
+  bool unserialize(ValueSerializer serializer, INPUT *fp) {
+    return ht_.unserialize(serializer, fp);
+  }
+
   template <typename OUTPUT>
   bool write_metadata(OUTPUT *fp) {
     return ht_.write_metadata(fp);
@@ -364,6 +373,7 @@ class BaseHashtableInterface {
   virtual bool supports_brackets() const = 0;     // has a 'real' operator[]
   virtual bool supports_readwrite() const = 0;
   virtual bool supports_num_table_copies() const = 0;
+  virtual bool supports_serialization() const = 0;
 
  protected:
   HT ht_;
@@ -378,9 +388,9 @@ class BaseHashtableInterface {
 // ---------------------------------------------------------------------
 
 template <class Key, class T,
-          class HashFcn = HASH_NAMESPACE::hash<Key>,
-          class EqualKey = STL_NAMESPACE::equal_to<Key>,
-          class Alloc = libc_allocator_with_realloc<pair<const Key, T> > >
+          class HashFcn = SPARSEHASH_HASH<Key>,
+          class EqualKey = std::equal_to<Key>,
+          class Alloc = libc_allocator_with_realloc<std::pair<const Key, T> > >
 class HashtableInterface_SparseHashMap
     : public BaseHashtableInterface< sparse_hash_map<Key, T, HashFcn,
                                                      EqualKey, Alloc> > {
@@ -421,12 +431,16 @@ class HashtableInterface_SparseHashMap
   bool supports_brackets() const { return true; }
   bool supports_readwrite() const { return true; }
   bool supports_num_table_copies() const { return false; }
+  bool supports_serialization() const { return true; }
 
   void set_empty_key(const typename p::key_type& k) { }
   void clear_empty_key() { }
   typename p::key_type empty_key() const { return typename p::key_type(); }
+
   int num_table_copies() const { return 0; }
 
+  typedef typename ht::NopointerSerializer NopointerSerializer;
+
  protected:
   template <class K2, class T2, class H2, class E2, class A2>
   friend void swap(HashtableInterface_SparseHashMap<K2,T2,H2,E2,A2>& a,
@@ -456,8 +470,8 @@ void swap(HashtableInterface_SparseHashMap<K,T,H,E,A>& a,
 // ---------------------------------------------------------------------
 
 template <class Value,
-          class HashFcn = HASH_NAMESPACE::hash<Value>,
-          class EqualKey = STL_NAMESPACE::equal_to<Value>,
+          class HashFcn = SPARSEHASH_HASH<Value>,
+          class EqualKey = std::equal_to<Value>,
           class Alloc = libc_allocator_with_realloc<Value> >
 class HashtableInterface_SparseHashSet
     : public BaseHashtableInterface< sparse_hash_set<Value, HashFcn,
@@ -524,12 +538,16 @@ class HashtableInterface_SparseHashSet
   bool supports_brackets() const { return false; }
   bool supports_readwrite() const { return true; }
   bool supports_num_table_copies() const { return false; }
+  bool supports_serialization() const { return true; }
 
   void set_empty_key(const typename p::key_type& k) { }
   void clear_empty_key() { }
   typename p::key_type empty_key() const { return typename p::key_type(); }
+
   int num_table_copies() const { return 0; }
 
+  typedef typename ht::NopointerSerializer NopointerSerializer;
+
  protected:
   template <class K2, class H2, class E2, class A2>
   friend void swap(HashtableInterface_SparseHashSet<K2,H2,E2,A2>& a,
@@ -636,6 +654,7 @@ class HashtableInterface_SparseHashtable
   bool supports_brackets() const { return false; }
   bool supports_readwrite() const { return true; }
   bool supports_num_table_copies() const { return true; }
+  bool supports_serialization() const { return true; }
 
   void set_empty_key(const typename p::key_type& k) { }
   void clear_empty_key() { }
@@ -647,6 +666,8 @@ class HashtableInterface_SparseHashtable
 
   // TODO(csilvers): also support/test destructive_begin()/destructive_end()?
 
+  typedef typename ht::NopointerSerializer NopointerSerializer;
+
  protected:
   template <class V2, class K2, class HF2, class EK2, class SK2, class Eq2,
             class A2>
@@ -684,9 +705,9 @@ void swap(HashtableInterface_SparseHashtable<V,K,HF,EK,SK,Eq,A>& a,
 // value saying what the empty key is.
 
 template <class Key, class T, const Key& EMPTY_KEY,
-          class HashFcn = HASH_NAMESPACE::hash<Key>,
-          class EqualKey = STL_NAMESPACE::equal_to<Key>,
-          class Alloc = libc_allocator_with_realloc<pair<const Key, T> > >
+          class HashFcn = SPARSEHASH_HASH<Key>,
+          class EqualKey = std::equal_to<Key>,
+          class Alloc = libc_allocator_with_realloc<std::pair<const Key, T> > >
 class HashtableInterface_DenseHashMap
     : public BaseHashtableInterface< dense_hash_map<Key, T, HashFcn,
                                                     EqualKey, Alloc> > {
@@ -733,9 +754,11 @@ class HashtableInterface_DenseHashMap
   bool supports_brackets() const { return true; }
   bool supports_readwrite() const { return false; }
   bool supports_num_table_copies() const { return false; }
+  bool supports_serialization() const { return true; }
 
-  template <typename OUTPUT> bool write_metadata(OUTPUT *fp) { return false; }
-  template <typename INPUT> bool read_metadata(INPUT *fp) { return false; }
+  typedef typename ht::NopointerSerializer NopointerSerializer;
+  template <typename OUTPUT> bool write_metadata(OUTPUT *) { return false; }
+  template <typename INPUT> bool read_metadata(INPUT *) { return false; }
   template <typename OUTPUT> bool write_nopointer_data(OUTPUT *) {
     return false;
   }
@@ -776,8 +799,8 @@ void swap(HashtableInterface_DenseHashMap<K,T,Empty,H,E,A>& a,
 // value saying what the empty key is.
 
 template <class Value, const Value& EMPTY_KEY,
-          class HashFcn = HASH_NAMESPACE::hash<Value>,
-          class EqualKey = STL_NAMESPACE::equal_to<Value>,
+          class HashFcn = SPARSEHASH_HASH<Value>,
+          class EqualKey = std::equal_to<Value>,
           class Alloc = libc_allocator_with_realloc<Value> >
 class HashtableInterface_DenseHashSet
     : public BaseHashtableInterface< dense_hash_set<Value, HashFcn,
@@ -835,9 +858,11 @@ class HashtableInterface_DenseHashSet
   bool supports_brackets() const { return false; }
   bool supports_readwrite() const { return false; }
   bool supports_num_table_copies() const { return false; }
+  bool supports_serialization() const { return true; }
 
-  template <typename OUTPUT> bool write_metadata(OUTPUT *fp) { return false; }
-  template <typename INPUT> bool read_metadata(INPUT *fp) { return false; }
+  typedef typename ht::NopointerSerializer NopointerSerializer;
+  template <typename OUTPUT> bool write_metadata(OUTPUT *) { return false; }
+  template <typename INPUT> bool read_metadata(INPUT *) { return false; }
   template <typename OUTPUT> bool write_nopointer_data(OUTPUT *) {
     return false;
   }
@@ -960,9 +985,11 @@ class HashtableInterface_DenseHashtable
   bool supports_brackets() const { return false; }
   bool supports_readwrite() const { return false; }
   bool supports_num_table_copies() const { return true; }
+  bool supports_serialization() const { return true; }
 
-  template <typename OUTPUT> bool write_metadata(OUTPUT *fp) { return false; }
-  template <typename INPUT> bool read_metadata(INPUT *fp) { return false; }
+  typedef typename ht::NopointerSerializer NopointerSerializer;
+  template <typename OUTPUT> bool write_metadata(OUTPUT *) { return false; }
+  template <typename INPUT> bool read_metadata(INPUT *) { return false; }
   template <typename OUTPUT> bool write_nopointer_data(OUTPUT *) {
     return false;
   }

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

@@ -27,71 +27,86 @@
 // (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 common/densehashtable.h
-// This tests common/dense_hash_set.h
-// This tests common/dense_hash_map.h
-// This tests common/sparsehashtable.h
-// This tests common/sparse_hash_set.h
-// This tests common/sparse_hash_map.h
+// This tests densehashtable
+// This tests dense_hash_set
+// This tests dense_hash_map
+// This tests sparsehashtable
+// This tests sparse_hash_set
+// This tests sparse_hash_map
 //
-// This test replacess hashtable_unittest.cc, which was becoming
-// unreadable.
+// This test replaces hashtable_unittest.cc, which was becoming
+// unreadable.  This file is opaque but hopefully not unreadable -- at
+// least, not the tests!
 //
 // Note that since all these classes are templatized, it's important
 // to call every public method on the class: not just to make sure
 // they work, but to make sure they even compile.
 
-#ifdef _MSC_VER
-// Below, we purposefully test having a very small allocator size.
-// This causes some "type conversion too small" errors when using this
-// allocator with sparsetable buckets.  We're testing to make sure we
-// handle that situation ok, so we don't need the compiler warnings.
-#pragma warning(disable:4244)
-#endif
-
-#include "config.h"
+#include <sparsehash/internal/sparseconfig.h>
+#include <config.h>
 #include <math.h>
+#include <stddef.h>   // for size_t
 #include <stdlib.h>
 #include <string.h>
+#ifdef HAVE_STDINT_H
+# include <stdint.h>
+#endif   // for uintptr_t
 #include <iostream>
 #include <set>
+#include <sstream>
+#include <typeinfo>   // for class typeinfo (returned by typeid)
 #include <vector>
-#include <google/type_traits.h>
-#include <google/sparsetable>
+#include <sparsehash/type_traits.h>
+#include <sparsehash/sparsetable>
 #include "hash_test_interface.h"
 #include "testutil.h"
+namespace testing = GOOGLE_NAMESPACE::testing;
 
-using GOOGLE_NAMESPACE::sparsetable;
-using GOOGLE_NAMESPACE::sparse_hash_map;
-using GOOGLE_NAMESPACE::sparse_hash_set;
+using std::cout;
+using std::pair;
+using std::set;
+using std::string;
+using std::vector;
 using GOOGLE_NAMESPACE::dense_hash_map;
 using GOOGLE_NAMESPACE::dense_hash_set;
+using GOOGLE_NAMESPACE::sparse_hash_map;
+using GOOGLE_NAMESPACE::sparse_hash_set;
+using GOOGLE_NAMESPACE::sparsetable;
 using GOOGLE_NAMESPACE::HashtableInterface_SparseHashMap;
 using GOOGLE_NAMESPACE::HashtableInterface_SparseHashSet;
 using GOOGLE_NAMESPACE::HashtableInterface_SparseHashtable;
 using GOOGLE_NAMESPACE::HashtableInterface_DenseHashMap;
 using GOOGLE_NAMESPACE::HashtableInterface_DenseHashSet;
 using GOOGLE_NAMESPACE::HashtableInterface_DenseHashtable;
-namespace testing = GOOGLE_NAMESPACE::testing;
-using STL_NAMESPACE::cout;
-using STL_NAMESPACE::pair;
-using STL_NAMESPACE::set;
-using STL_NAMESPACE::string;
-using STL_NAMESPACE::vector;
+namespace sparsehash_internal = GOOGLE_NAMESPACE::sparsehash_internal;
+
+typedef unsigned char uint8;
+
+#ifdef _MSC_VER
+// Below, we purposefully test having a very small allocator size.
+// This causes some "type conversion too small" errors when using this
+// allocator with sparsetable buckets.  We're testing to make sure we
+// handle that situation ok, so we don't need the compiler warnings.
+#pragma warning(disable:4244)
+#endif
 
 namespace {
 
 #ifndef _MSC_VER   // windows defines its own version
+# ifdef __MINGW32__ // mingw has trouble writing to /tmp
+static string TmpFile(const char* basename) {
+  return string("./#") + basename;
+}
+# else
 static string TmpFile(const char* basename) {
-  return string("/tmp/") + basename;
+  string kTmpdir = "/tmp";
+  return kTmpdir + "/" + basename;
 }
+# endif
 #endif
 
-typedef unsigned char uint8;
-
 // Used as a value in some of the hashtable tests.  It's just some
 // arbitrary user-defined type with non-trivial memory management.
 struct ValueType {
@@ -161,6 +176,10 @@ struct Hasher {
       hash = 33 * hash + a[i];
     return hash;
   }
+  size_t operator()(const int* a) const {
+    num_hashes_++;
+    return static_cast<size_t>(reinterpret_cast<uintptr_t>(a));
+  }
   bool operator()(int a, int b) const {
     num_compares_++;
     return a == b;
@@ -257,11 +276,13 @@ struct Alloc {
 // be their own inverse: f(f(x)) == x.
 template<class Value>
 struct Negation {
+  typedef Value result_type;
   Value operator()(Value& v) { return -v; }
   const Value operator()(const Value& v) const { return -v; }
 };
 
 struct Capital {
+  typedef string result_type;
   string operator()(string& s) {
     return string(1, s[0] ^ 32) + s.substr(1);
   }
@@ -271,6 +292,7 @@ struct Capital {
 };
 
 struct Identity {   // lame, I know, but an important case to test.
+  typedef const char* result_type;
   const char* operator()(const char* s) const {
     return s;
   }
@@ -328,8 +350,67 @@ template<> pair<const char* const,ValueType> UniqueObjectHelper(int index) {
       UniqueObjectHelper<char*>(index), UniqueObjectHelper<ValueType>(index+1));
 }
 
+class ValueSerializer {
+ public:
+  bool operator()(FILE* fp, const int& value) {
+    return fwrite(&value, sizeof(value), 1, fp) == 1;
+  }
+  bool operator()(FILE* fp, int* value) {
+    return fread(value, sizeof(*value), 1, fp) == 1;
+  }
+  bool operator()(FILE* fp, const string& value) {
+    const int size = value.size();
+    return (*this)(fp, size) && fwrite(value.c_str(), size, 1, fp) == 1;
+  }
+  bool operator()(FILE* fp, string* value) {
+    int size;
+    if (!(*this)(fp, &size)) return false;
+    char* buf = new char[size];
+    if (fread(buf, size, 1, fp) != 1) {
+      delete[] buf;
+      return false;
+    }
+    new(value) string(buf, size);
+    delete[] buf;
+    return true;
+  }
+  template <typename OUTPUT>
+  bool operator()(OUTPUT* fp, const ValueType& v) {
+    return (*this)(fp, string(v.s()));
+  }
+  template <typename INPUT>
+  bool operator()(INPUT* fp, ValueType* v) {
+    string data;
+    if (!(*this)(fp, &data)) return false;
+    new(v) ValueType(data.c_str());
+    return true;
+  }
+  template <typename OUTPUT>
+  bool operator()(OUTPUT* fp, const char* const& value) {
+    // Just store the index.
+    return (*this)(fp, atoi(value));
+  }
+  template <typename INPUT>
+  bool operator()(INPUT* fp, const char** value) {
+    // Look up via index.
+    int index;
+    if (!(*this)(fp, &index)) return false;
+    *value = UniqueObjectHelper<char*>(index);
+    return true;
+  }
+  template <typename OUTPUT, typename First, typename Second>
+  bool operator()(OUTPUT* fp, std::pair<const First, Second>* value) {
+    return (*this)(fp, const_cast<First*>(&value->first))
+        && (*this)(fp, &value->second);
+  }
+  template <typename INPUT, typename First, typename Second>
+  bool operator()(INPUT* fp, const std::pair<const First, Second>& value) {
+    return (*this)(fp, value.first) && (*this)(fp, value.second);
+  }
+};
+
 template <typename HashtableType>
-class HashtableTest {
+class HashtableTest : public ::testing::Test {
  public:
   HashtableTest() : ht_() { }
   // Give syntactically-prettier access to UniqueObjectHelper.
@@ -419,27 +500,58 @@ namespace {
 // We need to define the same class 4 times due to limitations in the
 // testing framework.  Basically, we associate each class below with
 // the set of types we want to run tests on it with.
-typedef testing::TypeList6<INT_HASHTABLES> IntHashtables;
 template <typename HashtableType> class HashtableIntTest
     : public HashtableTest<HashtableType> { };
-TYPED_TEST_CASE_6(HashtableIntTest, IntHashtables);
-
-typedef testing::TypeList6<STRING_HASHTABLES> StringHashtables;
 template <typename HashtableType> class HashtableStringTest
     : public HashtableTest<HashtableType> { };
-TYPED_TEST_CASE_6(HashtableStringTest, StringHashtables);
-
-typedef testing::TypeList6<CHARSTAR_HASHTABLES> CharStarHashtables;
 template <typename HashtableType> class HashtableCharStarTest
     : public HashtableTest<HashtableType> { };
-TYPED_TEST_CASE_6(HashtableCharStarTest, CharStarHashtables);
+template <typename HashtableType> class HashtableAllTest
+    : public HashtableTest<HashtableType> { };
 
+typedef testing::TypeList6<INT_HASHTABLES> IntHashtables;
+typedef testing::TypeList6<STRING_HASHTABLES> StringHashtables;
+typedef testing::TypeList6<CHARSTAR_HASHTABLES> CharStarHashtables;
 typedef testing::TypeList18<INT_HASHTABLES, STRING_HASHTABLES,
                             CHARSTAR_HASHTABLES> AllHashtables;
-template <typename HashtableType> class HashtableAllTest
-    : public HashtableTest<HashtableType> { };
+
+TYPED_TEST_CASE_6(HashtableIntTest, IntHashtables);
+TYPED_TEST_CASE_6(HashtableStringTest, StringHashtables);
+TYPED_TEST_CASE_6(HashtableCharStarTest, CharStarHashtables);
 TYPED_TEST_CASE_18(HashtableAllTest, AllHashtables);
 
+// ------------------------------------------------------------------------
+// First, some testing of the underlying infrastructure.
+
+TEST(HashtableCommonTest, HashMunging) {
+  const Hasher hasher;
+
+  // We don't munge the hash value on non-pointer template types.
+  {
+    const sparsehash_internal::sh_hashtable_settings<int, Hasher, size_t, 1>
+        settings(hasher, 0.0, 0.0);
+    const int v = 1000;
+    EXPECT_EQ(hasher(v), settings.hash(v));
+  }
+
+  {
+    // We do munge the hash value on pointer template types.
+    const sparsehash_internal::sh_hashtable_settings<int*, Hasher, size_t, 1>
+        settings(hasher, 0.0, 0.0);
+    int* v = NULL;
+    v += 0x10000;    // get a non-trivial pointer value
+    EXPECT_NE(hasher(v), settings.hash(v));
+  }
+  {
+    const sparsehash_internal::sh_hashtable_settings<const int*, Hasher,
+                                                     size_t, 1>
+        settings(hasher, 0.0, 0.0);
+    const int* v = NULL;
+    v += 0x10000;    // get a non-trivial pointer value
+    EXPECT_NE(hasher(v), settings.hash(v));
+  }
+}
+
 // ------------------------------------------------------------------------
 // If the first arg to TYPED_TEST is HashtableIntTest, it will run
 // this test on all the hashtable types, with key=int and value=int.
@@ -624,18 +736,20 @@ TYPED_TEST(HashtableIntTest, Constructors) {
   EXPECT_LE(1, alloc_count);
   int old_alloc_count = alloc_count;
 
-  vector<typename TypeParam::value_type> input(4);
-  // We have to use placement-new because value_type may be const.
-  new(&input[0]) typename TypeParam::value_type(this->UniqueObject(1));
-  new(&input[1]) typename TypeParam::value_type(this->UniqueObject(2));
-  new(&input[2]) typename TypeParam::value_type(this->UniqueObject(4));
-  new(&input[3]) typename TypeParam::value_type(this->UniqueObject(8));
-  TypeParam ht_iter_noarg(input.begin(), input.end());
-  TypeParam ht_iter_onearg(input.begin(), input.end(), 100);
-  TypeParam ht_iter_twoarg(input.begin(), input.end(), 100, hasher);
-  TypeParam ht_iter_threearg(input.begin(), input.end(), 100, hasher, hasher);
-  TypeParam ht_iter_fourarg(input.begin(), input.end(), 100, hasher, hasher,
-                            alloc);
+  const typename TypeParam::value_type input[] = {
+    this->UniqueObject(1),
+    this->UniqueObject(2),
+    this->UniqueObject(4),
+    this->UniqueObject(8)
+  };
+  const int num_inputs = sizeof(input) / sizeof(input[0]);
+  const typename TypeParam::value_type *begin = &input[0];
+  const typename TypeParam::value_type *end = begin + num_inputs;
+  TypeParam ht_iter_noarg(begin, end);
+  TypeParam ht_iter_onearg(begin, end, 100);
+  TypeParam ht_iter_twoarg(begin, end, 100, hasher);
+  TypeParam ht_iter_threearg(begin, end, 100, hasher, hasher);
+  TypeParam ht_iter_fourarg(begin, end, 100, hasher, hasher, alloc);
   // Now the allocator should have been called more.
   EXPECT_GT(alloc_count, old_alloc_count);
   old_alloc_count = alloc_count;
@@ -781,7 +895,7 @@ TYPED_TEST(HashtableAllTest, Swap) {
 
   // We purposefully don't swap allocs -- they're not necessarily swappable.
 
-  // Now swap back, using the free-function swap.
+  // Now swap back, using the free-function swap
   // NOTE: MSVC seems to have trouble with this free swap, not quite
   // sure why.  I've given up trying to fix it though.
 #ifdef _MSC_VER
@@ -798,6 +912,20 @@ TYPED_TEST(HashtableAllTest, Swap) {
   EXPECT_EQ(1u, other_ht.size());
   EXPECT_EQ(1u, this->ht_.count(this->UniqueKey(111)));
   EXPECT_EQ(0u, other_ht.count(this->UniqueKey(111)));
+
+  // A user reported a crash with this code using swap to clear.
+  // We've since fixed the bug; this prevents a regression.
+  TypeParam swap_to_clear_ht;
+  swap_to_clear_ht.set_deleted_key(this->UniqueKey(1));
+  for (int i = 2; i < 10000; ++i) {
+    swap_to_clear_ht.insert(this->UniqueObject(i));
+  }
+  TypeParam empty_ht;
+  empty_ht.swap(swap_to_clear_ht);
+  swap_to_clear_ht.set_deleted_key(this->UniqueKey(1));
+  for (int i = 2; i < 10000; ++i) {
+    swap_to_clear_ht.insert(this->UniqueObject(i));
+  }
 }
 
 TYPED_TEST(HashtableAllTest, Size) {
@@ -1073,6 +1201,7 @@ TYPED_TEST(HashtableAllTest, BracketInsert) {
   EXPECT_EQ(2, ht.hash_funct().num_hashes());
 }
 
+
 TYPED_TEST(HashtableAllTest, InsertValue) {
   // First, try some straightforward insertions.
   EXPECT_TRUE(this->ht_.empty());
@@ -1111,13 +1240,13 @@ TYPED_TEST(HashtableIntTest, InsertRange) {
   ht_source.insert(this->UniqueObject(100000));
   ht_source.insert(this->UniqueObject(1000000));
 
-  vector<typename TypeParam::value_type> input(4);
-  // We have to use placement-new because value_type may be const.
-  // This is a copy of the first element in ht_source.
-  new(&input[0]) typename TypeParam::value_type(*ht_source.begin());
-  new(&input[1]) typename TypeParam::value_type(this->UniqueObject(2));
-  new(&input[2]) typename TypeParam::value_type(this->UniqueObject(4));
-  new(&input[3]) typename TypeParam::value_type(this->UniqueObject(8));
+  const typename TypeParam::value_type input[] = {
+    // This is a copy of the first element in ht_source.
+    *ht_source.begin(),
+    this->UniqueObject(2),
+    this->UniqueObject(4),
+    this->UniqueObject(8)
+  };
 
   set<typename TypeParam::value_type> set_input;
   set_input.insert(this->UniqueObject(1111111));
@@ -1152,7 +1281,7 @@ TYPED_TEST(HashtableIntTest, InsertRange) {
   // Insert from input as well, a separate, random-access iterator.
   // The first element of input overlaps with an existing element
   // of ht_, so this should only up the size by 2.
-  this->ht_.insert(input.begin(), input.begin() + 3);
+  this->ht_.insert(&input[0], &input[3]);
   EXPECT_EQ(8u, this->ht_.size());
 }
 
@@ -1298,10 +1427,9 @@ TYPED_TEST(HashtableAllTest, Equals) {
 }
 
 TEST(HashtableTest, IntIO) {
-  // Since dense_hash_* doesn't support IO yet, and the set case is
-  // just a special (easier) case than the map case, I just test on
-  // sparse_hash_map.  This handles the easy case where we can use the
-  // standard reader and writer.
+  // Since the set case is just a special (easier) case than the map case, I
+  // just test on sparse_hash_map.  This handles the easy case where we can
+  // use the standard reader and writer.
   sparse_hash_map<int, int> ht_out;
   ht_out.set_deleted_key(0);
   for (int i = 1; i < 1000; i++) {
@@ -1310,7 +1438,7 @@ TEST(HashtableTest, IntIO) {
   ht_out.erase(563);   // just to test having some erased keys when we write.
   ht_out.erase(22);
 
-  string file(TmpFile("/intio"));
+  string file(TmpFile("intio"));
   FILE* fp = fopen(file.c_str(), "wb");
   EXPECT_TRUE(fp != NULL);
   EXPECT_TRUE(ht_out.write_metadata(fp));
@@ -1333,10 +1461,9 @@ TEST(HashtableTest, IntIO) {
 }
 
 TEST(HashtableTest, StringIO) {
-  // Since dense_hash_* doesn't support IO yet, and the set case is
-  // just a special (easier) case than the map case, I just test on
-  // sparse_hash_map.  This handles the difficult case where we have
-  // to write our own custom reader/writer for the data.
+  // Since the set case is just a special (easier) case than the map case,
+  // I just test on sparse_hash_map.  This handles the difficult case where
+  // we have to write our own custom reader/writer for the data.
   sparse_hash_map<string, string, Hasher, Hasher> ht_out;
   ht_out.set_deleted_key(string(""));
   for (int i = 32; i < 128; i++) {
@@ -1346,7 +1473,7 @@ TEST(HashtableTest, StringIO) {
   ht_out.erase("c");   // just to test having some erased keys when we write.
   ht_out.erase("y");
 
-  string file(TmpFile("/stringio"));
+  string file(TmpFile("stringio"));
   FILE* fp = fopen(file.c_str(), "wb");
   EXPECT_TRUE(fp != NULL);
   EXPECT_TRUE(ht_out.write_metadata(fp));
@@ -1369,14 +1496,14 @@ TEST(HashtableTest, StringIO) {
   for (sparse_hash_map<string, string, Hasher, Hasher>::iterator
            it = ht_in.begin(); it != ht_in.end(); ++it) {
     string::size_type first_size;
-    fread(&first_size, sizeof(first_size), 1, fp);
+    EXPECT_EQ(1u, fread(&first_size, sizeof(first_size), 1, fp));
     char* first = new char[first_size];
-    fread(first, first_size, 1, fp);
+    EXPECT_EQ(1u, fread(first, first_size, 1, fp));
 
     string::size_type second_size;
-    fread(&second_size, sizeof(second_size), 1, fp);
+    EXPECT_EQ(1u, fread(&second_size, sizeof(second_size), 1, fp));
     char* second = new char[second_size];
-    fread(second, second_size, 1, fp);
+    EXPECT_EQ(1u, fread(second, second_size, 1, fp));
 
     // it points to garbage, so we have to use placement-new to initialize.
     // We also have to use const-cast since it->first is const.
@@ -1393,6 +1520,195 @@ TEST(HashtableTest, StringIO) {
   EXPECT_EQ(string(""), ht_in["y"]);
 }
 
+TYPED_TEST(HashtableAllTest, Serialization) {
+  if (!this->ht_.supports_serialization()) return;
+  TypeParam ht_out;
+  ht_out.set_deleted_key(this->UniqueKey(2000));
+  for (int i = 1; i < 100; i++) {
+    ht_out.insert(this->UniqueObject(i));
+  }
+  // just to test having some erased keys when we write.
+  ht_out.erase(this->UniqueKey(56));
+  ht_out.erase(this->UniqueKey(22));
+
+  string file(TmpFile("serialization"));
+  FILE* fp = fopen(file.c_str(), "wb");
+  EXPECT_TRUE(fp != NULL);
+  EXPECT_TRUE(ht_out.serialize(ValueSerializer(), fp));
+  fclose(fp);
+
+  TypeParam ht_in;
+  fp = fopen(file.c_str(), "rb");
+  EXPECT_TRUE(fp != NULL);
+  EXPECT_TRUE(ht_in.unserialize(ValueSerializer(), fp));
+  fclose(fp);
+
+  EXPECT_EQ(this->UniqueObject(1), *ht_in.find(this->UniqueKey(1)));
+  EXPECT_EQ(this->UniqueObject(99), *ht_in.find(this->UniqueKey(99)));
+  EXPECT_FALSE(ht_in.count(this->UniqueKey(100)));
+  EXPECT_EQ(this->UniqueObject(21), *ht_in.find(this->UniqueKey(21)));
+  // should not have been saved
+  EXPECT_FALSE(ht_in.count(this->UniqueKey(22)));
+  EXPECT_FALSE(ht_in.count(this->UniqueKey(56)));
+}
+
+TYPED_TEST(HashtableIntTest, NopointerSerialization) {
+  if (!this->ht_.supports_serialization()) return;
+  TypeParam ht_out;
+  ht_out.set_deleted_key(this->UniqueKey(2000));
+  for (int i = 1; i < 100; i++) {
+    ht_out.insert(this->UniqueObject(i));
+  }
+  // just to test having some erased keys when we write.
+  ht_out.erase(this->UniqueKey(56));
+  ht_out.erase(this->UniqueKey(22));
+
+  string file(TmpFile("nopointer_serialization"));
+  FILE* fp = fopen(file.c_str(), "wb");
+  EXPECT_TRUE(fp != NULL);
+  EXPECT_TRUE(ht_out.serialize(typename TypeParam::NopointerSerializer(), fp));
+  fclose(fp);
+
+  TypeParam ht_in;
+  fp = fopen(file.c_str(), "rb");
+  EXPECT_TRUE(fp != NULL);
+  EXPECT_TRUE(ht_in.unserialize(typename TypeParam::NopointerSerializer(), fp));
+  fclose(fp);
+
+  EXPECT_EQ(this->UniqueObject(1), *ht_in.find(this->UniqueKey(1)));
+  EXPECT_EQ(this->UniqueObject(99), *ht_in.find(this->UniqueKey(99)));
+  EXPECT_FALSE(ht_in.count(this->UniqueKey(100)));
+  EXPECT_EQ(this->UniqueObject(21), *ht_in.find(this->UniqueKey(21)));
+  // should not have been saved
+  EXPECT_FALSE(ht_in.count(this->UniqueKey(22)));
+  EXPECT_FALSE(ht_in.count(this->UniqueKey(56)));
+}
+
+// We don't support serializing to a string by default, but you can do
+// it by writing your own custom input/output class.
+class StringIO {
+ public:
+  explicit StringIO(string* s) : s_(s) {}
+  size_t Write(const void* buf, size_t len) {
+    s_->append(reinterpret_cast<const char*>(buf), len);
+    return len;
+  }
+  size_t Read(void* buf, size_t len) {
+    if (s_->length() < len)
+      len = s_->length();
+    memcpy(reinterpret_cast<char*>(buf), s_->data(), len);
+    s_->erase(0, len);
+    return len;
+  }
+ private:
+  string* const s_;
+};
+
+TYPED_TEST(HashtableIntTest, SerializingToString) {
+  if (!this->ht_.supports_serialization()) return;
+  TypeParam ht_out;
+  ht_out.set_deleted_key(this->UniqueKey(2000));
+  for (int i = 1; i < 100; i++) {
+    ht_out.insert(this->UniqueObject(i));
+  }
+  // just to test having some erased keys when we write.
+  ht_out.erase(this->UniqueKey(56));
+  ht_out.erase(this->UniqueKey(22));
+
+  string stringbuf;
+  StringIO stringio(&stringbuf);
+  EXPECT_TRUE(ht_out.serialize(typename TypeParam::NopointerSerializer(),
+                               &stringio));
+
+  TypeParam ht_in;
+  EXPECT_TRUE(ht_in.unserialize(typename TypeParam::NopointerSerializer(),
+                                &stringio));
+
+  EXPECT_EQ(this->UniqueObject(1), *ht_in.find(this->UniqueKey(1)));
+  EXPECT_EQ(this->UniqueObject(99), *ht_in.find(this->UniqueKey(99)));
+  EXPECT_FALSE(ht_in.count(this->UniqueKey(100)));
+  EXPECT_EQ(this->UniqueObject(21), *ht_in.find(this->UniqueKey(21)));
+  // should not have been saved
+  EXPECT_FALSE(ht_in.count(this->UniqueKey(22)));
+  EXPECT_FALSE(ht_in.count(this->UniqueKey(56)));
+}
+
+// An easier way to do the above would be to use the existing stream methods.
+TYPED_TEST(HashtableIntTest, SerializingToStringStream) {
+  if (!this->ht_.supports_serialization()) return;
+  TypeParam ht_out;
+  ht_out.set_deleted_key(this->UniqueKey(2000));
+  for (int i = 1; i < 100; i++) {
+    ht_out.insert(this->UniqueObject(i));
+  }
+  // just to test having some erased keys when we write.
+  ht_out.erase(this->UniqueKey(56));
+  ht_out.erase(this->UniqueKey(22));
+
+  std::stringstream string_buffer;
+  EXPECT_TRUE(ht_out.serialize(typename TypeParam::NopointerSerializer(),
+                               &string_buffer));
+
+  TypeParam ht_in;
+  EXPECT_TRUE(ht_in.unserialize(typename TypeParam::NopointerSerializer(),
+                                &string_buffer));
+
+  EXPECT_EQ(this->UniqueObject(1), *ht_in.find(this->UniqueKey(1)));
+  EXPECT_EQ(this->UniqueObject(99), *ht_in.find(this->UniqueKey(99)));
+  EXPECT_FALSE(ht_in.count(this->UniqueKey(100)));
+  EXPECT_EQ(this->UniqueObject(21), *ht_in.find(this->UniqueKey(21)));
+  // should not have been saved
+  EXPECT_FALSE(ht_in.count(this->UniqueKey(22)));
+  EXPECT_FALSE(ht_in.count(this->UniqueKey(56)));
+}
+
+// Verify that the metadata serialization is endianness and word size
+// agnostic.
+TYPED_TEST(HashtableAllTest, MetadataSerializationAndEndianness) {
+  TypeParam ht_out;
+  string kExpectedDense("\x13W\x86""B\0\0\0\0\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\0",
+                        24);
+  string kExpectedSparse("$hu1\0\0\0 \0\0\0\0\0\0\0\0\0\0\0\0", 20);
+
+  if (ht_out.supports_readwrite()) {
+    string file(TmpFile("metadata_serialization"));
+    FILE* fp = fopen(file.c_str(), "wb");
+    EXPECT_TRUE(fp != NULL);
+
+    EXPECT_TRUE(ht_out.write_metadata(fp));
+    EXPECT_TRUE(ht_out.write_nopointer_data(fp));
+
+    const size_t num_bytes = ftell(fp);
+    fclose(fp);
+    fp = fopen(file.c_str(), "rb");
+    EXPECT_LE(num_bytes, static_cast<size_t>(24));
+    char contents[24];
+    EXPECT_EQ(num_bytes, fread(contents, 1, num_bytes, fp));
+    EXPECT_EQ(EOF, fgetc(fp));       // check we're *exactly* the right size
+    fclose(fp);
+    // TODO(csilvers): check type of ht_out instead of looking at the 1st byte.
+    if (contents[0] == kExpectedDense[0]) {
+      EXPECT_EQ(kExpectedDense, string(contents, num_bytes));
+    } else {
+      EXPECT_EQ(kExpectedSparse, string(contents, num_bytes));
+    }
+  }
+
+  // Do it again with new-style serialization.  Here we can use StringIO.
+  if (ht_out.supports_serialization()) {
+    string stringbuf;
+    StringIO stringio(&stringbuf);
+    EXPECT_TRUE(ht_out.serialize(typename TypeParam::NopointerSerializer(),
+                                 &stringio));
+    if (stringbuf[0] == kExpectedDense[0]) {
+      EXPECT_EQ(kExpectedDense, stringbuf);
+    } else {
+      EXPECT_EQ(kExpectedSparse, stringbuf);
+    }
+  }
+}
+
+
 // ------------------------------------------------------------------------
 // The above tests test the general API for correctness.  These tests
 // test a few corner cases that have tripped us up in the past, and
@@ -1594,20 +1910,12 @@ TEST(HashtableTest, NestedHashtables) {
 
 TEST(HashtableDeathTest, ResizeOverflow) {
   dense_hash_map<int, int> ht;
-  try {
-    ht.resize(static_cast<size_t>(-1));
-    EXPECT_TRUE(false && "dense_hash_map reszie should have failed");
-  } catch (const STL_NAMESPACE::length_error&) {
-    // Good, the resize failed.
-  }
+  EXPECT_DEATH(ht.resize(static_cast<size_t>(-1)),
+               "overflows size_type");
 
   sparse_hash_map<int, int> ht2;
-  try {
-    ht2.resize(static_cast<size_t>(-1));
-    EXPECT_TRUE(false && "sparse_hash_map reszie should have failed");
-  } catch (const STL_NAMESPACE::length_error&) {
-    // Good, the resize failed.
-  }
+  EXPECT_DEATH(ht2.resize(static_cast<size_t>(-1)),
+               "overflows size_type");
 }
 
 TEST(HashtableDeathTest, InsertSizeTypeOverflow) {
@@ -1626,18 +1934,10 @@ TEST(HashtableDeathTest, InsertSizeTypeOverflow) {
   EXPECT_TRUE(dhs.get_allocator().is_custom_alloc());
 
   // Test size_type overflow in insert(it, it)
-  try {
-    dhs.insert(test_data.begin(), test_data.end());
-    EXPECT_TRUE(false && "dense_hash_map::insert(it,it) should have overflown");
-  } catch (const STL_NAMESPACE::length_error&) {
-    // Good, the operation failed.
-  }
-  try {
-    shs.insert(test_data.begin(), test_data.end());
-    EXPECT_TRUE(false && "sparse_hash_map::insert(it,it) should have overflown");
-  } catch (const STL_NAMESPACE::length_error&) {
-    // Good, the operation failed.
-  }
+  EXPECT_DEATH(dhs.insert(test_data.begin(), test_data.end()),
+               "overflows size_type");
+  EXPECT_DEATH(shs.insert(test_data.begin(), test_data.end()),
+               "overflows size_type");
 }
 
 TEST(HashtableDeathTest, InsertMaxSizeOverflow) {
@@ -1652,18 +1952,10 @@ TEST(HashtableDeathTest, InsertMaxSizeOverflow) {
   dhs.set_empty_key(-1);
 
   // Test max_size overflow
-  try {
-    dhs.insert(test_data.begin(), test_data.begin() + 11);
-    EXPECT_TRUE(false && "dense_hash_map max_size check should have failed");
-  } catch (const STL_NAMESPACE::length_error&) {
-    // Good, the operation failed.
-  }
-  try {
-    shs.insert(test_data.begin(), test_data.begin() + 11);
-    EXPECT_TRUE(false && "sparse_hash_map max_size check should have failed");
-  } catch (const STL_NAMESPACE::length_error&) {
-    // Good, the operation failed.
-  }
+  EXPECT_DEATH(dhs.insert(test_data.begin(), test_data.begin() + 11),
+               "exceed max_size");
+  EXPECT_DEATH(shs.insert(test_data.begin(), test_data.begin() + 11),
+               "exceed max_size");
 }
 
 TEST(HashtableDeathTest, ResizeSizeTypeOverflow) {
@@ -1672,18 +1964,8 @@ TEST(HashtableDeathTest, ResizeSizeTypeOverflow) {
   dense_hash_set<int, Hasher, Hasher, Alloc<int, uint8, 10> > dhs;
   dhs.set_empty_key(-1);
 
-  try {
-    dhs.resize(250);  // 9+250 > 25
-    EXPECT_TRUE(false && "dense_hash_map resize should have seen overflow");
-  } catch (const STL_NAMESPACE::length_error&) {
-    // Good, the operation failed.
-  }
-  try {
-    shs.resize(250);
-    EXPECT_TRUE(false && "sparse_hash_map resize should have seen overflow");
-  } catch (const STL_NAMESPACE::length_error&) {
-    // Good, the operation failed.
-  }
+  EXPECT_DEATH(dhs.resize(250), "overflows size_type");  // 9+250 > 256
+  EXPECT_DEATH(shs.resize(250), "overflows size_type");
 }
 
 TEST(HashtableDeathTest, ResizeDeltaOverflow) {
@@ -1700,18 +1982,10 @@ TEST(HashtableDeathTest, ResizeDeltaOverflow) {
     dhs.insert(i);
     shs.insert(i);
   }
-  try {
-    dhs.insert(test_data.begin(), test_data.begin() + 250);
-    EXPECT_TRUE(false && "dense_hash_map big insert should have overflowed");
-  } catch (const STL_NAMESPACE::length_error&) {
-    // Good, the operation failed.
-  }
-  try {
-    shs.insert(test_data.begin(), test_data.begin() + 250);
-    EXPECT_TRUE(false && "sparse_hash_map big insert should have overflowed");
-  } catch (const STL_NAMESPACE::length_error&) {
-    // Good, the operation failed.
-  }
+  EXPECT_DEATH(dhs.insert(test_data.begin(), test_data.begin() + 250),
+               "overflows size_type");              // 9+250 > 256
+  EXPECT_DEATH(shs.insert(test_data.begin(), test_data.begin() + 250),
+               "overflows size_type");
 }
 
 // ------------------------------------------------------------------------
@@ -1719,8 +1993,8 @@ TEST(HashtableDeathTest, ResizeDeltaOverflow) {
 // Also, benchmarks.
 
 TYPED_TEST(HashtableAllTest, ClassSizes) {
-  cout << "sizeof(" << typeid(TypeParam).name() << "): "
-       << sizeof(this->ht_) << "\n";
+  std::cout << "sizeof(" << typeid(TypeParam).name() << "): "
+            << sizeof(this->ht_) << "\n";
 }
 
 }  // unnamed namespace