diff --git a/src/butil/bit_array.h b/src/butil/bit_array.h
index 54beb39862..3bcc694844 100644
--- a/src/butil/bit_array.h
+++ b/src/butil/bit_array.h
@@ -28,18 +28,22 @@
 
 namespace butil {
 
+#define BIT_ARRAY_LEN(nbit) (((nbit) + 63 ) / 64 * 8)
+
 // Create an array with at least |nbit| bits. The array is not cleared.
-inline uint64_t* bit_array_malloc(size_t nbit)
-{
+inline uint64_t* bit_array_malloc(size_t nbit) {
     if (!nbit) {
         return NULL;
     }
-    return (uint64_t*)malloc((nbit + 63 ) / 64 * 8/*different from /8*/);
+    return (uint64_t*)malloc(BIT_ARRAY_LEN(nbit)/*different from /8*/);
+}
+
+inline void bit_array_free(uint64_t* array) {
+    free(array);
 }
 
 // Set bit 0 ~ nbit-1 of |array| to be 0
-inline void bit_array_clear(uint64_t* array, size_t nbit)
-{
+inline void bit_array_clear(uint64_t* array, size_t nbit) {
     const size_t off = (nbit >> 6);
     memset(array, 0, off * 8);
     const size_t last = (off << 6);
@@ -49,22 +53,19 @@ inline void bit_array_clear(uint64_t* array, size_t nbit)
 }
 
 // Set i-th bit (from left, counting from 0) of |array| to be 1
-inline void bit_array_set(uint64_t* array, size_t i)
-{
+inline void bit_array_set(uint64_t* array, size_t i) {
     const size_t off = (i >> 6);
     array[off] |= (((uint64_t)1) << (i - (off << 6)));
 }
 
 // Set i-th bit (from left, counting from 0) of |array| to be 0
-inline void bit_array_unset(uint64_t* array, size_t i)
-{
+inline void bit_array_unset(uint64_t* array, size_t i) {
     const size_t off = (i >> 6);
     array[off] &= ~(((uint64_t)1) << (i - (off << 6)));
 }
 
 // Get i-th bit (from left, counting from 0) of |array|
-inline uint64_t bit_array_get(const uint64_t* array, size_t i)
-{
+inline uint64_t bit_array_get(const uint64_t* array, size_t i) {
     const size_t off = (i >> 6);
     return (array[off] & (((uint64_t)1) << (i - (off << 6))));
 }
@@ -72,8 +73,7 @@ inline uint64_t bit_array_get(const uint64_t* array, size_t i)
 // Find index of first 1-bit from bit |begin| to |end| in |array|.
 // Returns |end| if all bits are 0.
 // This function is of O(nbit) complexity.
-inline size_t bit_array_first1(const uint64_t* array, size_t begin, size_t end)
-{
+inline size_t bit_array_first1(const uint64_t* array, size_t begin, size_t end) {
     size_t off1 = (begin >> 6);
     const size_t first = (off1 << 6);
     if (first != begin) {
diff --git a/src/butil/containers/flat_map.h b/src/butil/containers/flat_map.h
index f0d1d1ca2f..6d7286ff57 100644
--- a/src/butil/containers/flat_map.h
+++ b/src/butil/containers/flat_map.h
@@ -104,6 +104,7 @@
 #include "butil/containers/hash_tables.h"          // hash<>
 #include "butil/bit_array.h"                       // bit_array_*
 #include "butil/strings/string_piece.h"            // StringPiece
+#include "butil/memory/scope_guard.h"
 
 namespace butil {
 
@@ -156,13 +157,13 @@ class FlatMap {
     explicit FlatMap(const hasher& hashfn = hasher(),
                      const key_equal& eql = key_equal(),
                      const allocator_type& alloc = allocator_type());
-    ~FlatMap();
     FlatMap(const FlatMap& rhs);
+    ~FlatMap();
+
     FlatMap& operator=(const FlatMap& rhs);
     void swap(FlatMap & rhs);
 
-    // Must be called to initialize this map, otherwise insert/operator[]
-    // crashes, and seek/erase fails.
+    // FlatMap will be automatically initialized, so no need to call this function.
     // `nbucket' is the initial number of buckets. `load_factor' is the 
     // maximum value of size()*100/nbucket, if the value is reached, nbucket
     // will be doubled and all items stored will be rehashed which is costly.
@@ -214,7 +215,7 @@ class FlatMap {
     // Resize this map. This is optional because resizing will be triggered by
     // insert() or operator[] if there're too many items.
     // Returns successful or not.
-    bool resize(size_t nbucket);
+    bool resize(size_t new_nbucket);
     
     // Iterators
     iterator begin();
@@ -252,7 +253,7 @@ class FlatMap {
     void save_iterator(const const_iterator&, PositionHint*) const;
     const_iterator restore_iterator(const PositionHint&) const;
 
-    // True if init() was successfully called.
+    // Always returns true.
     bool initialized() const { return _buckets != NULL; }
 
     bool empty() const { return _size == 0; }
@@ -279,12 +280,39 @@ class FlatMap {
             const void* spaces = &element_spaces;
             return *reinterpret_cast<const Element*>(spaces);
         }
+        void swap(Bucket& rhs) {
+            if (is_valid() && rhs.is_valid()) {
+                // Element temp(element().first_ref(), element().second_movable_ref());
+                // element().~Element();
+                // new (&element_spaces) Element(rhs.element().first_ref(), rhs.element().second_movable_ref());
+                // rhs.element().~Element();
+                // new (&rhs.element_spaces) Element(temp.first_ref(), temp.second_movable_ref());
+
+                element().swap(rhs.element());
+
+                std::swap(next, rhs.next);
+            } else if (is_valid() && !rhs.is_valid()) {
+                new (&rhs.element_spaces) Element(movable_element());
+                element().~Element();
+                std::swap(next, rhs.next);
+            } else if (!is_valid() && rhs.is_valid()) {
+                new (&element_spaces) Element(rhs.movable_element());
+                rhs.element().~Element();
+                std::swap(next, rhs.next);
+            }
+        }
+
+        typedef typename std::aligned_storage<
+            sizeof(Element), alignof(Element)>::type element_spaces_type;
         Bucket *next;
-        typename std::aligned_storage<sizeof(Element), alignof(Element)>::type
-            element_spaces;
-    };
+        element_spaces_type element_spaces;
 
-    allocator_type& get_allocator() { return _pool.get_allocator(); }
+    private:
+        Element&& movable_element() {
+            void* spaces = &element_spaces; // Suppress strict-aliasing
+            return std::move(*reinterpret_cast<Element*>(spaces));
+        }
+    };
 
 private:
 template <typename _Map, typename _Element> friend class FlatMapIterator;
@@ -298,15 +326,70 @@ template <typename _Map, typename _Element> friend class SparseFlatMapIterator;
     template<bool Multi = _Multi>
     typename std::enable_if<Multi, mapped_type&>::type operator[](const key_type& key);
 
+    struct NewBucketsInfo {
+        NewBucketsInfo()
+        : buckets(NULL), thumbnail(NULL), nbucket(0) {}
+        NewBucketsInfo(Bucket* b, uint64_t* t, size_t n)
+            : buckets(b), thumbnail(t), nbucket(n) {}
+        Bucket* buckets;
+        uint64_t* thumbnail;
+        size_t nbucket;
+    };
+    NewBucketsInfo new_buckets(size_t size, size_t new_nbucket,
+                               bool ignore_same_nbucket);
+
+    allocator_type& get_allocator() { return _pool.get_allocator(); }
+    allocator_type get_allocator() const { return _pool.get_allocator(); }
+
     // True if buckets need to be resized before holding `size' elements.
-    inline bool is_too_crowded(size_t size) const
-    { return size * 100 >= _nbucket * _load_factor; }
-        
+    bool is_too_crowded(size_t size) const {
+        return is_too_crowded(size, _nbucket, _load_factor);
+    }
+
+    static bool is_too_crowded(size_t size, size_t nbucket, u_int load_factor) {
+        return size * 100 >= nbucket * load_factor;
+    }
+
+    void init_load_factor(u_int load_factor) {
+        if (_is_default_load_factor) {
+            _is_default_load_factor = false;
+            _load_factor = load_factor;
+        }
+    }
+
+    // True if using default buckets which is for small map optimization.
+    bool is_default_buckets() const {
+        return _buckets == (Bucket*)(&_default_buckets_spaces);
+    }
+
+    static void init_buckets(Bucket* buckets, uint64_t* thumbnail, size_t nbucket) {
+        for (size_t i = 0; i < nbucket; ++i) {
+            buckets[i].set_invalid();
+        }
+        buckets[nbucket].next = NULL;
+        if (_Sparse) {
+            bit_array_clear(thumbnail, nbucket);
+        }
+    }
+
+#ifdef FLAT_MAP_ROUND_BUCKET_BY_USE_NEXT_PRIME
+    static const size_t default_nbucket = 29;
+#else
+    static const size_t default_nbucket = 16;
+#endif
+    static const size_t default_nthumbnail = BIT_ARRAY_LEN(default_nbucket);
+    // Small map optimization.
+    typedef typename std::aligned_storage<sizeof(Bucket), alignof(Bucket)>::type
+            buckets_spaces_type;
+    // Note: need an extra bucket to let iterator know where buckets end.
+    buckets_spaces_type _default_buckets_spaces[default_nbucket + 1];
+    uint64_t _default_thumbnail[default_nthumbnail];
     size_t _size;
     size_t _nbucket;
     Bucket* _buckets;
     uint64_t* _thumbnail;
     u_int _load_factor;
+    bool _is_default_load_factor;
     hasher _hashfn;
     key_equal _eql;
     SingleThreadedPool<sizeof(Bucket), 1024, 16, allocator_type> _pool;
@@ -400,6 +483,14 @@ class FlatMapElement {
     // POD) which is wrong generally.
     explicit FlatMapElement(const K& k) : _key(k), _value(T()) {}
     //                                             ^^^^^^^^^^^
+    FlatMapElement(const K& k, T&& t) : _key(k), _value(std::move(t)) {}
+
+    FlatMapElement(const FlatMapElement& rhs)
+        : _key(rhs._key), _value(rhs._value) {}
+
+    FlatMapElement(FlatMapElement&& rhs)  noexcept
+        : _key(std::move(rhs._key)), _value(std::move(rhs._value)) {}
+
     const K& first_ref() const { return _key; }
     T& second_ref() { return _value; }
     T&& second_movable_ref() { return std::move(_value); }
@@ -411,8 +502,13 @@ class FlatMapElement {
     inline static T&& second_movable_ref_from_value(value_type& v)
     { return std::move(v.second); }
 
+    void swap(FlatMapElement& rhs) {
+        std::swap(_key, rhs._key);
+        std::swap(_value, rhs._value);
+    }
+
 private:
-    const K _key;
+    K _key;
     T _value;
 };
 
diff --git a/src/butil/containers/flat_map_inl.h b/src/butil/containers/flat_map_inl.h
index 5218fab9b7..d03f353532 100644
--- a/src/butil/containers/flat_map_inl.h
+++ b/src/butil/containers/flat_map_inl.h
@@ -90,17 +90,12 @@ template <typename Map, typename Value> class FlatMapIterator {
     
     FlatMapIterator() : _node(NULL), _entry(NULL) {}    
     FlatMapIterator(const Map* map, size_t pos) {
-        if (map->initialized()) {
-            _entry = map->_buckets + pos;
-            find_and_set_valid_node();
-        } else {
-            _node = NULL;
-            _entry = NULL;
-        }
+        _entry = map->_buckets + pos;
+        find_and_set_valid_node();
     }
     FlatMapIterator(const FlatMapIterator<Map, NonConstValue>& rhs)
         : _node(rhs._node), _entry(rhs._entry) {}
-    ~FlatMapIterator() {}  // required by style-checker
+    ~FlatMapIterator() = default;  // required by style-checker
     
     // *this == rhs
     bool operator==(const FlatMapIterator& rhs) const
@@ -163,20 +158,14 @@ template <typename Map, typename Value> class SparseFlatMapIterator {
     
     SparseFlatMapIterator() : _node(NULL), _pos(0), _map(NULL) {}
     SparseFlatMapIterator(const Map* map, size_t pos) {
-        if (map->initialized()) {
-            _map = map;
-            _pos = pos;
-            find_and_set_valid_node();
-        } else {
-            _node = NULL;
-            _map = NULL;
-            _pos = 0;
-        }
+        _map = map;
+        _pos = pos;
+        find_and_set_valid_node();
     }
     SparseFlatMapIterator(const SparseFlatMapIterator<Map, NonConstValue>& rhs)
         : _node(rhs._node), _pos(rhs._pos), _map(rhs._map)
     {}
-    ~SparseFlatMapIterator() {}  // required by style-checker
+    ~SparseFlatMapIterator() = default;  // required by style-checker
     
     // *this == rhs
     bool operator==(const SparseFlatMapIterator& rhs) const
@@ -226,90 +215,72 @@ friend class SparseFlatMapIterator<Map, ConstValue>;
  
 
 template <typename _K, typename _T, typename _H, typename _E, bool _S, typename _A, bool _M>
-FlatMap<_K, _T, _H, _E, _S, _A, _M>::FlatMap(const hasher& hashfn, const key_equal& eql, const allocator_type& alloc)
+FlatMap<_K, _T, _H, _E, _S, _A, _M>::FlatMap(const hasher& hashfn,
+                                             const key_equal& eql,
+                                             const allocator_type& alloc)
     : _size(0)
-    , _nbucket(0)
-    , _buckets(NULL)
-    , _thumbnail(NULL)
-    , _load_factor(0)
+    , _nbucket(default_nbucket)
+    , _buckets((Bucket*)(&_default_buckets_spaces))
+    , _thumbnail(_S ? _default_thumbnail : NULL)
+    , _load_factor(80)
+    , _is_default_load_factor(true)
     , _hashfn(hashfn)
     , _eql(eql)
-    , _pool(alloc)
-{}
+    , _pool(alloc) {
+    init_buckets(_buckets, _thumbnail, _nbucket);
+}
+
+template <typename _K, typename _T, typename _H, typename _E, bool _S, typename _A, bool _M>
+FlatMap<_K, _T, _H, _E, _S, _A, _M>::FlatMap(const FlatMap& rhs)
+    : FlatMap(rhs._hashfn, rhs._eql, rhs.get_allocator()) {
+    init_buckets(_buckets, _thumbnail, _nbucket);
+    if (!rhs.empty()) {
+        operator=(rhs);
+    }
+}
 
 template <typename _K, typename _T, typename _H, typename _E, bool _S, typename _A, bool _M>
 FlatMap<_K, _T, _H, _E, _S, _A, _M>::~FlatMap() {
     clear();
-    get_allocator().Free(_buckets);
-    _buckets = NULL;
-    free(_thumbnail);
-    _thumbnail = NULL;
+    if (!is_default_buckets()) {
+        get_allocator().Free(_buckets);
+        _buckets = NULL;
+        bit_array_free(_thumbnail);
+        _thumbnail = NULL;
+    }
     _nbucket = 0;
     _load_factor = 0;
 }
 
-template <typename _K, typename _T, typename _H, typename _E, bool _S, typename _A, bool _M>
-FlatMap<_K, _T, _H, _E, _S, _A, _M>::FlatMap(const FlatMap& rhs)
-    : _size(0)
-    , _nbucket(0)
-    , _buckets(NULL)
-    , _thumbnail(NULL)
-    , _load_factor(rhs._load_factor)
-    , _hashfn(rhs._hashfn)
-    , _eql(rhs._eql) {
-    operator=(rhs);
-}
-
 template <typename _K, typename _T, typename _H, typename _E, bool _S, typename _A, bool _M>
 FlatMap<_K, _T, _H, _E, _S, _A, _M>&
 FlatMap<_K, _T, _H, _E, _S, _A, _M>::operator=(const FlatMap<_K, _T, _H, _E, _S, _A, _M>& rhs) {
     if (this == &rhs) {
         return *this;
     }
-    // NOTE: assignment does not change _load_factor/_hashfn/_eql if |this| is
-    // initialized
     clear();
-    if (!rhs.initialized()) {
+    if (rhs.empty()) {
         return *this;
     }
-    bool need_copy = !rhs.empty();
-    _load_factor = rhs._load_factor;
-    if (_buckets == NULL || is_too_crowded(rhs._size)) {
-        get_allocator().Free(_buckets);
-        _nbucket = rhs._nbucket;
-        // note: need an extra bucket to let iterator know where buckets end
-        _buckets = (Bucket*)get_allocator().Alloc(sizeof(Bucket) * (_nbucket + 1/*note*/));
-        if (NULL == _buckets) {
-            LOG(ERROR) << "Fail to new _buckets";
-            return *this;
-        }
-        // If no need to copy, set buckets invalid.
-        if (!need_copy) {
-            for (size_t i = 0; i < _nbucket; ++i) {
-                _buckets[i].set_invalid();
-            }
-            _buckets[_nbucket].next = NULL;
-        }
-        if (_S) {
-            free(_thumbnail);
-            _thumbnail = bit_array_malloc(_nbucket);
-            if (NULL == _thumbnail) {
-                LOG(ERROR) << "Fail to new _thumbnail";
-                return *this;
+    // NOTE: assignment only changes _load_factor when it is default.
+    init_load_factor(rhs._load_factor);
+    if (is_too_crowded(rhs._size)) {
+        NewBucketsInfo info = new_buckets(rhs._size, rhs._nbucket, false);
+        _nbucket = info.nbucket;
+        if (!is_default_buckets()) {
+            get_allocator().Free(_buckets);
+            if (_S) {
+                bit_array_free(_thumbnail);
             }
-            bit_array_clear(_thumbnail, _nbucket);
         }
-    }
-    if (!need_copy) {
-        return *this;
+        _buckets = info.buckets;
+        _thumbnail = info.thumbnail;
     }
     if (_nbucket == rhs._nbucket) {
         // For equivalent _nbucket, walking through _buckets instead of using
         // iterators is more efficient.
         for (size_t i = 0; i < rhs._nbucket; ++i) {
-            if (!rhs._buckets[i].is_valid()) {
-                _buckets[i].set_invalid();
-            } else {
+            if (rhs._buckets[i].is_valid()) {
                 if (_S) {
                     bit_array_set(_thumbnail, i);
                 }
@@ -336,49 +307,62 @@ FlatMap<_K, _T, _H, _E, _S, _A, _M>::operator=(const FlatMap<_K, _T, _H, _E, _S,
 
 template <typename _K, typename _T, typename _H, typename _E, bool _S, typename _A, bool _M>
 int FlatMap<_K, _T, _H, _E, _S, _A, _M>::init(size_t nbucket, u_int load_factor) {
-    if (initialized()) {
-        LOG(ERROR) << "Already initialized";
-        return -1;
-    }
-    if (nbucket == 0) {
-        LOG(WARNING) << "Fail to init FlatMap, nbucket=" << nbucket; 
-        return -1;
-    }
-    if (load_factor < 10 || load_factor > 100) {
-        LOG(ERROR) << "Invalid load_factor=" << load_factor;
-        return -1;
-    }
-    _size = 0;
-    _nbucket = flatmap_round(nbucket);
-    _load_factor = load_factor;
-                                
-    _buckets = (Bucket*)get_allocator().Alloc(sizeof(Bucket) * (_nbucket + 1));
-    if (NULL == _buckets) {
-        LOG(ERROR) << "Fail to new _buckets";
-        return -1;
-    }
-    for (size_t i = 0; i < _nbucket; ++i) {
-        _buckets[i].set_invalid();
+    if (nbucket <= _nbucket || load_factor < 10 || load_factor > 100 ||
+        !_is_default_load_factor || !empty() || !is_default_buckets()) {
+        return 0;
     }
-    _buckets[_nbucket].next = NULL;
 
-    if (_S) {
-        _thumbnail = bit_array_malloc(_nbucket);
-        if (NULL == _thumbnail) {
-            LOG(ERROR) << "Fail to new _thumbnail";
-            return -1;
-        }
-        bit_array_clear(_thumbnail, _nbucket);
+    init_load_factor(load_factor);
+    if (!resize(nbucket)) {
+        LOG(ERROR) << "Fail to init";
+        return -1;
     }
     return 0;
 }
 
+// static inline void swap_array(uint8_t* array1, uint8_t* array2, size_t size) {
+//     for (size_t i = 0; i < size; ++i) {
+//         std::swap(array1[i], array2[i]);
+//     }
+// }
+
 template <typename _K, typename _T, typename _H, typename _E, bool _S, typename _A, bool _M>
-void FlatMap<_K, _T, _H, _E, _S, _A, _M>::swap(FlatMap<_K, _T, _H, _E, _S, _A, _M> & rhs) {
+void FlatMap<_K, _T, _H, _E, _S, _A, _M>::swap(FlatMap<_K, _T, _H, _E, _S, _A, _M>& rhs) {
+    // todo 还需要确定正确性
+    if (!is_default_buckets() && !rhs.is_default_buckets()) {
+        std::swap(rhs._buckets, _buckets);
+        std::swap(rhs._thumbnail, _thumbnail);
+    } else if (!is_default_buckets() && rhs.is_default_buckets()) {
+        Bucket* this_buckets = _buckets;
+        uint64_t* this_thumbnail = _thumbnail;
+        _buckets = (Bucket*)&_default_buckets_spaces;
+        _thumbnail = _default_thumbnail;
+        rhs._buckets = this_buckets;
+        rhs._thumbnail = this_thumbnail;
+    } else if (is_default_buckets() && !rhs.is_default_buckets()) {
+        Bucket* rhs_buckets = rhs._buckets;
+        uint64_t* rhs_thumbnail = rhs._thumbnail;
+        _buckets = rhs_buckets;
+        _thumbnail = rhs_thumbnail;
+        rhs._buckets = (Bucket*)&rhs._default_buckets_spaces;
+        rhs._thumbnail = rhs._thumbnail;
+    } else {
+        for (size_t i = 0; i < default_nbucket; ++i) {
+            ((Bucket*)&_default_buckets_spaces)[i].swap(((Bucket*)&rhs._default_buckets_spaces)[i]);
+        }
+        if (_S) {
+            for (size_t i = 0; i < default_nthumbnail; ++i) {
+                std::swap(_default_thumbnail[i], rhs._default_thumbnail[i]);
+            }
+        }
+    }
+    // No need to swap `_buckets' and `_thumbnail'.
+
+    // swap_array(rhs._default_buckets_spaces, _default_buckets_spaces, default_nbucket);
+    // swap_array(rhs._default_thumbnail, _default_thumbnail, default_nbucket);
     std::swap(rhs._size, _size);
     std::swap(rhs._nbucket, _nbucket);
-    std::swap(rhs._buckets, _buckets);
-    std::swap(rhs._thumbnail, _thumbnail);
+    std::swap(rhs._is_default_load_factor, _is_default_load_factor);
     std::swap(rhs._load_factor, _load_factor);
     std::swap(rhs._hashfn, _hashfn);
     std::swap(rhs._eql, _eql);
@@ -389,7 +373,7 @@ template <typename _K, typename _T, typename _H,
           typename _E, bool _S, typename _A, bool _M>
 _T* FlatMap<_K, _T, _H, _E, _S, _A, _M>::insert(const key_type& key,
                                                 const mapped_type& value) {
-    mapped_type *p = &operator[]<_M>(key);
+    mapped_type *p = &operator[](key);
     *p = value;
     return p;
 }
@@ -404,9 +388,6 @@ template <typename _K, typename _T, typename _H, typename _E, bool _S, typename
 template <typename K2, bool Multi>
 typename std::enable_if<!Multi, size_t >::type
 FlatMap<_K, _T, _H, _E, _S, _A, _M>::erase(const K2& key, _T* old_value) {
-    if (!initialized()) {
-        return 0;
-    }
     // TODO: Do we need auto collapsing here?
     const size_t index = flatmap_mod(_hashfn(key), _nbucket);
     Bucket& first_node = _buckets[index];
@@ -472,9 +453,6 @@ template <typename K2, bool Multi>
 typename std::enable_if<Multi, size_t >::type
 FlatMap<_K, _T, _H, _E, _S, _A, _M>::erase(const K2& key,
                                            std::vector<mapped_type>* old_values) {
-    if (!initialized()) {
-        return 0;
-    }
     // TODO: Do we need auto collapsing here?
     const size_t index = flatmap_mod(_hashfn(key), _nbucket);
     Bucket& first_node = _buckets[index];
@@ -566,9 +544,6 @@ void FlatMap<_K, _T, _H, _E, _S, _A, _M>::clear_and_reset_pool() {
 template <typename _K, typename _T, typename _H, typename _E, bool _S, typename _A, bool _M>
 template <typename K2>
 _T* FlatMap<_K, _T, _H, _E, _S, _A, _M>::seek(const K2& key) const {
-    if (!initialized()) {
-        return NULL;
-    }
     Bucket& first_node = _buckets[flatmap_mod(_hashfn(key), _nbucket)];
     if (!first_node.is_valid()) {
         return NULL;
@@ -590,9 +565,6 @@ template <typename _K, typename _T, typename _H, typename _E, bool _S, typename
 template <typename K2>
 std::vector<_T*> FlatMap<_K, _T, _H, _E, _S, _A, _M>::seek_all(const K2& key) const {
     std::vector<_T*> v;
-    if (!initialized()) {
-        return v;
-    }
     Bucket& first_node = _buckets[flatmap_mod(_hashfn(key), _nbucket)];
     if (!first_node.is_valid()) {
         return v;
@@ -625,17 +597,15 @@ FlatMap<_K, _T, _H, _E, _S, _A, _M>::operator[](const key_type& key) {
         return first_node.element().second_ref();
     }
     Bucket *p = &first_node;
-    while (1) {
+    while (true) {
         if (_eql(p->element().first_ref(), key)) {
             return p->element().second_ref();
         }
         if (NULL == p->next) {
-            if (is_too_crowded(_size)) {
-                if (resize(_nbucket + 1)) {
-                    return operator[](key);
-                }
-                // fail to resize is OK
+            if (is_too_crowded(_size) && resize(_nbucket + 1)) {
+                return operator[](key);
             }
+            // Fail to resize is OK.
             ++_size;
             Bucket* newp = new (_pool.get()) Bucket(key);
             p->next = newp;
@@ -714,27 +684,84 @@ FlatMap<_K, _T, _H, _E, _S, _A, _M>::restore_iterator(const PositionHint& hint)
 }
 
 template <typename _K, typename _T, typename _H, typename _E, bool _S, typename _A, bool _M>
-bool FlatMap<_K, _T, _H, _E, _S, _A, _M>::resize(size_t nbucket2) {
-    nbucket2 = flatmap_round(nbucket2);
-    if (_nbucket == nbucket2) {
+bool FlatMap<_K, _T, _H, _E, _S, _A, _M>::resize(size_t new_nbucket) {
+    NewBucketsInfo info = new_buckets(_size, new_nbucket, true);
+    if (NULL == info.buckets ||
+        (_S && NULL == info.thumbnail) ||
+        _nbucket == info.nbucket) {
         return false;
     }
 
-    // NOTE: following functors must be kept after resizing otherwise the 
-    // internal state is lost.
-    FlatMap new_map(_hashfn, _eql, get_allocator());
-    if (new_map.init(nbucket2, _load_factor) != 0) {
-        LOG(ERROR) << "Fail to init new_map, nbucket=" << nbucket2;
-        return false;
-    }
     for (iterator it = begin(); it != end(); ++it) {
-        new_map[Element::first_ref_from_value(*it)] = 
-            Element::second_movable_ref_from_value(*it);
+        const key_type& key = Element::first_ref_from_value(*it);
+        const size_t index = flatmap_mod(_hashfn(key), info.nbucket);
+        Bucket& first_node = info.buckets[index];
+        if (!first_node.is_valid()) {
+            if (_S) {
+                bit_array_set(info.thumbnail, index);
+            }
+            new (&first_node) Bucket(key);
+            first_node.element().second_ref() =
+                Element::second_movable_ref_from_value(*it);
+        } else {
+            Bucket* newp = new (_pool.get()) Bucket(key);
+            newp->element().second_ref() =
+                Element::second_movable_ref_from_value(*it);
+            newp->next = first_node.next;
+            first_node.next = newp;
+        }
+    }
+    size_t saved_size = _size;
+    clear();
+    if (!is_default_buckets()) {
+        get_allocator().Free(_buckets);
+        if (_S) {
+            bit_array_free(_thumbnail);
+        }
     }
-    new_map.swap(*this);
+    _nbucket = info.nbucket;
+    _buckets = info.buckets;
+    _thumbnail = info.thumbnail;
+    _size = saved_size;
+
     return true;
 }
 
+template <typename _K, typename _T, typename _H, typename _E, bool _S, typename _A, bool _M>
+typename FlatMap<_K, _T, _H, _E, _S, _A, _M>::NewBucketsInfo
+FlatMap<_K, _T, _H, _E, _S, _A, _M>::new_buckets(
+    size_t size, size_t new_nbucket, bool ignore_same_nbucket) {
+    do {
+        new_nbucket = flatmap_round(new_nbucket);
+    } while (is_too_crowded(size, new_nbucket, _load_factor));
+    if (_nbucket == new_nbucket && !ignore_same_nbucket) {
+        return {};
+    }
+    // Note: need an extra bucket to let iterator know where buckets end.
+    auto buckets = (Bucket*)get_allocator().Alloc(sizeof(Bucket) * (
+        new_nbucket + 1/*note*/));
+    auto guard = MakeScopeGuard([buckets, this]() {
+        get_allocator().Free(buckets);
+    });
+    if (NULL == buckets) {
+        LOG(FATAL) << "Fail to new Buckets";
+        return {};
+    }
+
+    uint64_t* thumbnail = NULL;
+    if (_S) {
+        thumbnail = bit_array_malloc(new_nbucket);
+        if (NULL == thumbnail) {
+            LOG(FATAL) << "Fail to new thumbnail";
+            return {};
+        }
+    }
+
+    guard.dismiss();
+    init_buckets(buckets, thumbnail, new_nbucket);
+    return { buckets, thumbnail, new_nbucket };
+}
+
 template <typename _K, typename _T, typename _H, typename _E, bool _S, typename _A, bool _M>
 BucketInfo FlatMap<_K, _T, _H, _E, _S, _A, _M>::bucket_info() const {
     size_t max_n = 0;
diff --git a/src/butil/single_threaded_pool.h b/src/butil/single_threaded_pool.h
index 591e423f10..7f34b93ccb 100644
--- a/src/butil/single_threaded_pool.h
+++ b/src/butil/single_threaded_pool.h
@@ -61,10 +61,12 @@ class SingleThreadedPool {
     static const size_t NITEM = Block::NITEM;
     static const size_t ITEM_SIZE = ITEM_SIZE_IN;
     
-    SingleThreadedPool(const Allocator& alloc = Allocator()) 
+    explicit SingleThreadedPool(const Allocator& alloc = Allocator())
         : _free_nodes(NULL), _blocks(NULL), _allocator(alloc) {}
     ~SingleThreadedPool() { reset(); }
 
+    DISALLOW_COPY_AND_ASSIGN(SingleThreadedPool);
+
     void swap(SingleThreadedPool & other) {
         std::swap(_free_nodes, other._free_nodes);
         std::swap(_blocks, other._blocks);
@@ -132,12 +134,9 @@ class SingleThreadedPool {
     }
 
     Allocator& get_allocator() { return _allocator; }
+    Allocator get_allocator() const { return _allocator; }
 
 private:
-    // You should not copy a pool.
-    SingleThreadedPool(const SingleThreadedPool&);
-    void operator=(const SingleThreadedPool&);
-
     Node* _free_nodes;
     Block* _blocks;
     Allocator _allocator;
diff --git a/test/Makefile b/test/Makefile
index 97bde8f534..e5f2fcd229 100644
--- a/test/Makefile
+++ b/test/Makefile
@@ -46,107 +46,108 @@ ifeq ($(SYSTEM),Darwin)
     SOEXT = dylib
 endif
 
-TEST_BUTIL_SOURCES = \
-    at_exit_unittest.cc \
-    atomicops_unittest.cc \
-    base64_unittest.cc \
-    base64url_unittest.cc \
-    big_endian_unittest.cc \
-    bits_unittest.cc \
-    hash_tables_unittest.cc \
-    linked_list_unittest.cc \
-    mru_cache_unittest.cc \
-    small_map_unittest.cc \
-    stack_container_unittest.cc \
-    mpsc_queue_unittest.cc \
-    cpu_unittest.cc \
-    crash_logging_unittest.cc \
-    leak_tracker_unittest.cc \
-    stack_trace_unittest.cc \
-    environment_unittest.cc \
-    file_util_unittest.cc \
-    dir_reader_posix_unittest.cc \
-    file_path_unittest.cc \
-    file_unittest.cc \
-    scoped_temp_dir_unittest.cc \
-    guid_unittest.cc \
-    hash_unittest.cc \
-    lazy_instance_unittest.cc \
-    aligned_memory_unittest.cc \
-    linked_ptr_unittest.cc \
-    ref_counted_memory_unittest.cc \
-    ref_counted_unittest.cc \
-    scoped_ptr_unittest.cc \
-    scoped_vector_unittest.cc \
-    singleton_unittest.cc \
-    weak_ptr_unittest.cc \
-    observer_list_unittest.cc \
-    file_descriptor_shuffle_unittest.cc \
-    rand_util_unittest.cc \
-    safe_numerics_unittest.cc \
-    scoped_clear_errno_unittest.cc \
-    scoped_generic_unittest.cc \
-    security_unittest.cc \
-    sha1_unittest.cc \
-    stl_util_unittest.cc \
-    nullable_string16_unittest.cc \
-    safe_sprintf_unittest.cc \
-    string16_unittest.cc \
-    stringprintf_unittest.cc \
-    string_number_conversions_unittest.cc \
-    string_piece_unittest.cc \
-    string_split_unittest.cc \
-    string_tokenizer_unittest.cc \
-    string_util_unittest.cc \
-    stringize_macros_unittest.cc \
-    sys_string_conversions_unittest.cc \
-    utf_offset_string_conversions_unittest.cc \
-    utf_string_conversions_unittest.cc \
-    cancellation_flag_unittest.cc \
-    condition_variable_unittest.cc \
-    lock_unittest.cc \
-    waitable_event_unittest.cc \
-    type_traits_unittest.cc \
-    non_thread_safe_unittest.cc \
-    platform_thread_unittest.cc \
-    simple_thread_unittest.cc \
-    thread_checker_unittest.cc \
-    thread_collision_warner_unittest.cc \
-    thread_id_name_manager_unittest.cc \
-    thread_local_storage_unittest.cc \
-    thread_local_unittest.cc \
-    watchdog_unittest.cc \
-    time_unittest.cc \
-    version_unittest.cc \
-    logging_unittest.cc \
-    cacheline_unittest.cpp \
-    class_name_unittest.cpp \
-    endpoint_unittest.cpp \
-    unique_ptr_unittest.cpp \
-    errno_unittest.cpp \
-    fd_guard_unittest.cpp \
-    file_watcher_unittest.cpp \
-    find_cstr_unittest.cpp \
-    scoped_lock_unittest.cpp \
-    status_unittest.cpp \
-    string_printf_unittest.cpp \
-    string_splitter_unittest.cpp \
-    synchronous_event_unittest.cpp \
-    temp_file_unittest.cpp \
-    baidu_thread_local_unittest.cpp \
-    thread_key_unittest.cpp \
-    baidu_time_unittest.cpp \
-    flat_map_unittest.cpp \
-    crc32c_unittest.cc \
-    iobuf_unittest.cpp \
-    object_pool_unittest.cpp \
-    recordio_unittest.cpp \
-    test_switches.cc \
-    scoped_locale.cc \
-    popen_unittest.cpp \
-    bounded_queue_unittest.cc \
-    butil_unittest_main.cpp \
-    scope_guard_unittest.cc
+TEST_BUTIL_SOURCES = flat_map_unittest.cpp
+#TEST_BUTIL_SOURCES = \
+#    at_exit_unittest.cc \
+#    atomicops_unittest.cc \
+#    base64_unittest.cc \
+#    base64url_unittest.cc \
+#    big_endian_unittest.cc \
+#    bits_unittest.cc \
+#    hash_tables_unittest.cc \
+#    linked_list_unittest.cc \
+#    mru_cache_unittest.cc \
+#    small_map_unittest.cc \
+#    stack_container_unittest.cc \
+#    mpsc_queue_unittest.cc \
+#    cpu_unittest.cc \
+#    crash_logging_unittest.cc \
+#    leak_tracker_unittest.cc \
+#    stack_trace_unittest.cc \
+#    environment_unittest.cc \
+#    file_util_unittest.cc \
+#    dir_reader_posix_unittest.cc \
+#    file_path_unittest.cc \
+#    file_unittest.cc \
+#    scoped_temp_dir_unittest.cc \
+#    guid_unittest.cc \
+#    hash_unittest.cc \
+#    lazy_instance_unittest.cc \
+#    aligned_memory_unittest.cc \
+#    linked_ptr_unittest.cc \
+#    ref_counted_memory_unittest.cc \
+#    ref_counted_unittest.cc \
+#    scoped_ptr_unittest.cc \
+#    scoped_vector_unittest.cc \
+#    singleton_unittest.cc \
+#    weak_ptr_unittest.cc \
+#    observer_list_unittest.cc \
+#    file_descriptor_shuffle_unittest.cc \
+#    rand_util_unittest.cc \
+#    safe_numerics_unittest.cc \
+#    scoped_clear_errno_unittest.cc \
+#    scoped_generic_unittest.cc \
+#    security_unittest.cc \
+#    sha1_unittest.cc \
+#    stl_util_unittest.cc \
+#    nullable_string16_unittest.cc \
+#    safe_sprintf_unittest.cc \
+#    string16_unittest.cc \
+#    stringprintf_unittest.cc \
+#    string_number_conversions_unittest.cc \
+#    string_piece_unittest.cc \
+#    string_split_unittest.cc \
+#    string_tokenizer_unittest.cc \
+#    string_util_unittest.cc \
+#    stringize_macros_unittest.cc \
+#    sys_string_conversions_unittest.cc \
+#    utf_offset_string_conversions_unittest.cc \
+#    utf_string_conversions_unittest.cc \
+#    cancellation_flag_unittest.cc \
+#    condition_variable_unittest.cc \
+#    lock_unittest.cc \
+#    waitable_event_unittest.cc \
+#    type_traits_unittest.cc \
+#    non_thread_safe_unittest.cc \
+#    platform_thread_unittest.cc \
+#    simple_thread_unittest.cc \
+#    thread_checker_unittest.cc \
+#    thread_collision_warner_unittest.cc \
+#    thread_id_name_manager_unittest.cc \
+#    thread_local_storage_unittest.cc \
+#    thread_local_unittest.cc \
+#    watchdog_unittest.cc \
+#    time_unittest.cc \
+#    version_unittest.cc \
+#    logging_unittest.cc \
+#    cacheline_unittest.cpp \
+#    class_name_unittest.cpp \
+#    endpoint_unittest.cpp \
+#    unique_ptr_unittest.cpp \
+#    errno_unittest.cpp \
+#    fd_guard_unittest.cpp \
+#    file_watcher_unittest.cpp \
+#    find_cstr_unittest.cpp \
+#    scoped_lock_unittest.cpp \
+#    status_unittest.cpp \
+#    string_printf_unittest.cpp \
+#    string_splitter_unittest.cpp \
+#    synchronous_event_unittest.cpp \
+#    temp_file_unittest.cpp \
+#    baidu_thread_local_unittest.cpp \
+#    thread_key_unittest.cpp \
+#    baidu_time_unittest.cpp \
+#    flat_map_unittest.cpp \
+#    crc32c_unittest.cc \
+#    iobuf_unittest.cpp \
+#    object_pool_unittest.cpp \
+#    recordio_unittest.cpp \
+#    test_switches.cc \
+#    scoped_locale.cc \
+#    popen_unittest.cpp \
+#    bounded_queue_unittest.cc \
+#    butil_unittest_main.cpp \
+#    scope_guard_unittest.cc
 
 ifeq ($(SYSTEM), Linux)
     TEST_BUTIL_SOURCES += test_file_util_linux.cc \
diff --git a/test/brpc_controller_unittest.cpp b/test/brpc_controller_unittest.cpp
index f73332818f..3f410a2599 100644
--- a/test/brpc_controller_unittest.cpp
+++ b/test/brpc_controller_unittest.cpp
@@ -130,7 +130,7 @@ TEST_F(ControllerTest, SessionKV) {
 
         FLAGS_log_as_json = true;
     }
-    ASSERT_TRUE(endsWith(sink1, R"(,"@rid":"abcdEFG-456","M":"Session ends.","Baidu":"NewStuff","Cisco":"33.330000","Apple":"1234567"})")) << sink1;
+    ASSERT_TRUE(endsWith(sink1, R"(,"@rid":"abcdEFG-456","M":"Session ends.","Cisco":"33.330000","Apple":"1234567","Baidu":"NewStuff"})")) << sink1;
     ASSERT_TRUE(startsWith(sink1, R"({"L":"I",)")) << sink1;
 
     logging::SetLogSink(oldSink);
diff --git a/test/flat_map_unittest.cpp b/test/flat_map_unittest.cpp
index 5d9850d718..0ac8867472 100644
--- a/test/flat_map_unittest.cpp
+++ b/test/flat_map_unittest.cpp
@@ -95,31 +95,50 @@ TEST_F(FlatMapTest, swap_pooled_allocator) {
 
 TEST_F(FlatMapTest, copy_flat_map) {
     typedef butil::FlatMap<std::string, std::string> Map;
-    Map uninit_m1;
-    ASSERT_FALSE(uninit_m1.initialized());
-    ASSERT_TRUE(uninit_m1.empty());
+    const size_t default_nbucket = Map::default_nbucket;
+    Map default_init_m1;
+    ASSERT_TRUE(default_init_m1.initialized());
+    ASSERT_TRUE(default_init_m1.empty());
+    ASSERT_EQ(default_nbucket, default_init_m1.bucket_count());
     // self assignment does nothing.
-    uninit_m1 = uninit_m1;
-    ASSERT_FALSE(uninit_m1.initialized());
-    ASSERT_TRUE(uninit_m1.empty());
-    // Copy construct from uninitialized map.
-    Map uninit_m2 = uninit_m1;
-    ASSERT_FALSE(uninit_m2.initialized());
-    ASSERT_TRUE(uninit_m2.empty());
-    // assign uninitialized map to uninitialized map.
-    Map uninit_m3;
-    uninit_m3 = uninit_m1;
-    ASSERT_FALSE(uninit_m3.initialized());
-    ASSERT_TRUE(uninit_m3.empty());
-    // assign uninitialized map to initialized map.
+    default_init_m1 = default_init_m1;
+    ASSERT_TRUE(default_init_m1.initialized());
+    ASSERT_TRUE(default_init_m1.empty());
+    ASSERT_EQ(default_nbucket, default_init_m1.bucket_count());
+
+    Map default_init_m2 = default_init_m1;
+    ASSERT_TRUE(default_init_m2.initialized());
+    ASSERT_TRUE(default_init_m2.empty());
+    ASSERT_EQ(default_nbucket, default_init_m1.bucket_count());
+
+    Map init_m3;
+    ASSERT_TRUE(init_m3.initialized());
+    // smaller than the default value, and the default buckets
+    // is continued to be used.
+    ASSERT_EQ(0, init_m3.init(8));
+    ASSERT_TRUE(init_m3.initialized());
+    ASSERT_EQ(default_nbucket, init_m3.bucket_count());
+    ASSERT_EQ((Map::Bucket*)init_m3._default_buckets_spaces,
+              init_m3._buckets);
+    init_m3["hello"] = "world";
+    ASSERT_EQ(1u, init_m3.size());
+    init_m3 = default_init_m1;
+    ASSERT_TRUE(init_m3.initialized());
+    ASSERT_TRUE(init_m3.empty());
+
     Map init_m4;
-    ASSERT_EQ(0, init_m4.init(16));
     ASSERT_TRUE(init_m4.initialized());
+    // Resize to a larger buckets, and then not using the default buckets.
+    ASSERT_EQ(0, init_m4.init(default_nbucket + 1));
+    ASSERT_EQ(butil::flatmap_round(default_nbucket + 1), init_m4.bucket_count());
+    ASSERT_NE((Map::Bucket*)init_m4._default_buckets_spaces,
+              init_m4._buckets);
     init_m4["hello"] = "world";
     ASSERT_EQ(1u, init_m4.size());
-    init_m4 = uninit_m1;
+    init_m4 = default_init_m1;
     ASSERT_TRUE(init_m4.initialized());
     ASSERT_TRUE(init_m4.empty());
+    ASSERT_EQ(butil::flatmap_round(default_nbucket + 1), init_m4.bucket_count());
 
     Map m1;
     ASSERT_EQ(0, m1.init(16));
@@ -146,7 +165,7 @@ TEST_F(FlatMapTest, copy_flat_map) {
     // Copy construct from initialized map.
     Map m2 = m1;
     ASSERT_TRUE(m2.initialized());
-    ASSERT_EQ(expected_count, m2.size());
+    ASSERT_EQ(expected_count, m2.size()) << m1.size();
     ASSERT_EQ("world", m2["hello"]);
     ASSERT_EQ("bar", m2["foo"]);
     ASSERT_EQ("bob", m2["owner"]);
@@ -173,7 +192,7 @@ TEST_F(FlatMapTest, copy_flat_map) {
     const void* old_buckets4 = m4._buckets;
     m4 = m1;
     ASSERT_EQ(m1.bucket_count(), m4.bucket_count());
-    ASSERT_NE(old_buckets4, m4._buckets);
+    ASSERT_EQ(old_buckets4, m4._buckets);
     ASSERT_EQ(expected_count, m4.size());
     ASSERT_EQ("world", m4["hello"]);
     ASSERT_EQ("bar", m4["foo"]);
@@ -226,7 +245,7 @@ TEST_F(FlatMapTest, to_lower) {
     for (int c = -128; c < 128; ++c) {
         ASSERT_EQ((char)::tolower(c), butil::ascii_tolower(c)) << "c=" << c;
     }
-    
+
     const size_t input_len = 102;
     char input[input_len + 1];
     char input2[input_len + 1];
@@ -379,7 +398,7 @@ TEST_F(FlatMapTest, flat_map_of_string) {
     for (size_t i = 0; i < N; ++i) {
         keys.push_back(butil::string_printf("up_latency_as_key_%lu", i));
     }
-    
+
     tm1.start();
     for (size_t i = 0; i < N; ++i) {
         m1[keys[i]] += i;
@@ -441,12 +460,27 @@ TEST_F(FlatMapTest, flat_map_of_string) {
     LOG(INFO) << "finding c_strings takes " << tm1.n_elapsed()/N
               << " " << tm2.n_elapsed()/N << " " << tm3.n_elapsed()/N
               << " " << tm1_2.n_elapsed()/N << " sum=" << sum;
-    
+
     for (size_t i = 0; i < N; ++i) {
         ASSERT_EQ(i, m1[keys[i]]) << "i=" << i;
         ASSERT_EQ(i, m2[keys[i]]);
         ASSERT_EQ(i, m3[keys[i]]);
     }
+
+    butil::FlatMap<std::string, std::string> m4;
+    m4["111"] = "222";
+    ASSERT_EQ("222", m4["111"]);
+    ASSERT_EQ(1UL, m4.size());
+    butil::FlatMap<std::string, std::string> m5;
+    m5["333"] = "444";
+    ASSERT_EQ(1UL, m5.size());
+    ASSERT_EQ("444", m5["333"]);
+    m4.swap(m5);
+    ASSERT_EQ("444", m4["333"]) << m4.size();
+    ASSERT_EQ("222", m5["111"]) << m5.size();
+    ASSERT_EQ(1UL, m4.size());
+    ASSERT_EQ(1UL, m5.size());
+
 }
 
 TEST_F(FlatMapTest, fast_iterator) {
@@ -457,7 +491,7 @@ TEST_F(FlatMapTest, fast_iterator) {
     M2 m2;
 
     ASSERT_EQ(0, m1.init(16384));
-    ASSERT_EQ(-1, m1.init(1));
+    ASSERT_EQ(0, m1.init(1));
     ASSERT_EQ(0, m2.init(16384));
 
     ASSERT_EQ(NULL, m1._thumbnail);
@@ -537,11 +571,11 @@ typedef butil::FlatMap<uint64_t, uint64_t> PositionHintMap;
 static void fill_position_hint_map(PositionHintMap* map,
                                    std::vector<uint64_t>* keys) {
     srand(time(NULL));
-    const size_t N = 170;
+    const size_t N = 5;
     if (!map->initialized()) {
         ASSERT_EQ(0, map->init(N * 3 / 2, 80));
     }
-    
+
     keys->reserve(N);
     keys->clear();
     map->clear();
@@ -553,7 +587,7 @@ static void fill_position_hint_map(PositionHintMap* map,
         keys->push_back(key);
         (*map)[key] = i;
     }
-    LOG(INFO) << map->bucket_info();
+    LOG(INFO) << map->bucket_info() << ", size=" << map->size();
 }
 
 struct CountOnPause {
@@ -601,7 +635,7 @@ struct RemoveInsertVisitedOnPause {
             removed_keys.insert(removed_key);
             break;
         } while (true);
-        
+
         // Insert one
         uint64_t inserted_key =
             ((rand() % hint.offset) + rand() * hint.nbucket);
@@ -845,13 +879,13 @@ struct Value {
     Value(int x) : x_(x) { ++ n_con; }
     Value (const Value& rhs) : x_(rhs.x_) { ++ n_cp_con; }
     ~Value() { ++ n_des; }
-    
+
     Value& operator= (const Value& rhs) {
         x_ = rhs.x_;
         ++ n_cp;
         return *this;
     }
-    
+
     bool operator== (const Value& rhs) const { return x_ == rhs.x_; }
     bool operator!= (const Value& rhs) const { return x_ != rhs.x_; }
 
@@ -900,16 +934,42 @@ TEST_F(FlatMapTest, key_value_are_not_constructed_before_first_insertion) {
 
 TEST_F(FlatMapTest, manipulate_uninitialized_map) {
     butil::FlatMap<int, int> m;
-    ASSERT_FALSE(m.initialized());
-    for (butil::FlatMap<int,int>::iterator it = m.begin(); it != m.end(); ++it) {
-        LOG(INFO) << "nothing";
-    }
+    ASSERT_TRUE(m.initialized());
     ASSERT_EQ(NULL, m.seek(1));
     ASSERT_EQ(0u, m.erase(1));
     ASSERT_EQ(0u, m.size());
     ASSERT_TRUE(m.empty());
-    ASSERT_EQ(0u, m.bucket_count());
-    ASSERT_EQ(0u, m.load_factor());
+    const size_t default_nbucket = butil::FlatMap<int, int>::default_nbucket;
+    ASSERT_EQ(default_nbucket, m.bucket_count());
+    ASSERT_EQ(80u, m.load_factor());
+    m[1] = 1;
+    ASSERT_EQ(1UL, m.size());
+    auto one = m.seek(1);
+    ASSERT_NE(nullptr, one);
+    ASSERT_EQ(1, *one);
+
+    butil::FlatMap<int, int> m2 = m;
+    one = m2.seek(1);
+    ASSERT_NE(nullptr, one);
+    ASSERT_EQ(1, *one);
+    m2[2] = 2;
+    ASSERT_EQ(2UL, m2.size());
+
+    m.swap(m2);
+    ASSERT_EQ(2UL, m.size());
+    ASSERT_EQ(1UL, m2.size());
+    auto two = m.seek(2);
+    ASSERT_NE(nullptr, two);
+    ASSERT_EQ(2, *two);
+
+    ASSERT_EQ(1UL, m2.erase(1));
+    ASSERT_EQ(0, m.init(32));
+    one = m.seek(1);
+    ASSERT_NE(nullptr, one);
+    ASSERT_EQ(1, *one);
+    two = m.seek(2);
+    ASSERT_NE(nullptr, two);
+    ASSERT_EQ(2, *two);
 }
 
 TEST_F(FlatMapTest, perf_small_string_map) {
@@ -948,7 +1008,7 @@ TEST_F(FlatMapTest, perf_small_string_map) {
         m2["Request-Id"] = "true";
         m2["Status-Code"] = "200";
         tm2.stop();
-    
+
         LOG(INFO) << "flatmap=" << tm1.n_elapsed()
                   << " ci_flatmap=" << tm4.n_elapsed()
                   << " map=" << tm2.n_elapsed()
@@ -956,12 +1016,10 @@ TEST_F(FlatMapTest, perf_small_string_map) {
     }
 }
 
-
 TEST_F(FlatMapTest, sanity) {
     typedef butil::FlatMap<uint64_t, long> Map;
     Map m;
-
-    ASSERT_FALSE(m.initialized());
+    ASSERT_TRUE(m.initialized());
     m.init(1000, 70);
     ASSERT_TRUE(m.initialized());
     ASSERT_EQ(0UL, m.size());
@@ -981,7 +1039,7 @@ TEST_F(FlatMapTest, sanity) {
     long* p = m.seek(k1);
     ASSERT_TRUE(p && *p == 10);
     ASSERT_EQ(0UL, m._pool.count_allocated());
-    
+
     ASSERT_EQ(NULL, m.seek(k2));
 
     // Override
@@ -990,7 +1048,7 @@ TEST_F(FlatMapTest, sanity) {
     ASSERT_FALSE(m.empty());
     p = m.seek(k1);
     ASSERT_TRUE(p && *p == 100);
-    
+
     // Insert another
     m[k3] = 20;
     ASSERT_EQ(2UL, m.size());
@@ -1006,7 +1064,7 @@ TEST_F(FlatMapTest, sanity) {
     ASSERT_FALSE(m.empty());
     p = m.seek(k2);
     ASSERT_TRUE(p && *p == 30);
-    
+
     ASSERT_EQ(NULL, m.seek(2049));
 
     Map::iterator it = m.begin();
@@ -1052,7 +1110,7 @@ TEST_F(FlatMapTest, random_insert_erase) {
         Map ht[2];
         ht[0].init (40);
         ht[1] = ht[0];
-    
+
         for (int j = 0; j < 30; ++j) {
             // Make snapshot
             ht[1] = ht[0];
@@ -1072,7 +1130,7 @@ TEST_F(FlatMapTest, random_insert_erase) {
                     ref[0].clear();
                 }
             }
-            
+
             LOG(INFO) << "Check j=" << j;
             // bi-check
             for (int i=0; i<2; ++i) {
@@ -1082,7 +1140,7 @@ TEST_F(FlatMapTest, random_insert_erase) {
                     ASSERT_TRUE (it2 != ref[i].end());
                     ASSERT_EQ (it2->second, it->second);
                 }
-        
+
                 for (butil::hash_map<uint64_t, Value>::iterator it = ref[i].begin();
                      it != ref[i].end(); ++it)
                 {
@@ -1095,17 +1153,15 @@ TEST_F(FlatMapTest, random_insert_erase) {
         }
 
     }
-    // cout << "ht[0] = " << show(ht[0]) << endl
-    //      << "ht[1] = " << show(ht[1]) << endl;
 
-    //ASSERT_EQ (ht[0]._pool->alloc_num(), 0ul);
-    ASSERT_EQ (n_con + n_cp_con, n_des);
+    ASSERT_EQ (n_con + n_cp_con, n_des)
+        << "n_con=" << n_con << " n_cp_con=" << n_cp_con << " n_des=" << n_des;
 
     LOG(INFO) << "n_con:" << n_con << std::endl
               << "n_cp_con:" << n_cp_con << std::endl
               << "n_con+n_cp_con:" <<  n_con+n_cp_con <<  std::endl
               << "n_des:" << n_des << std::endl
-              << "n_cp:" << n_cp;    
+              << "n_cp:" << n_cp;
 }
 
 template <typename T>
@@ -1123,7 +1179,7 @@ void perf_insert_erase(bool random, const T& value) {
     butil::hash_map<uint64_t, T> hash_map;
     butil::Timer id_tm, multi_id_tm, std_tm, pooled_tm,
                  std_unordered_tm, std_unordered_multi_tm, hash_tm;
-    
+
     size_t max_nkeys = 0;
     for (size_t i = 0; i < NPASS; ++i) {
         max_nkeys = std::max(max_nkeys, nkeys[i]);
@@ -1156,8 +1212,8 @@ void perf_insert_erase(bool random, const T& value) {
         if (random) {
             random_shuffle(keys.begin(), keys.end());
         }
-        
-        id_map.clear();        
+
+        id_map.clear();
         id_tm.start();
         for (size_t i = 0; i < keys.size(); ++i) {
             id_map[keys[i]] = value;
@@ -1205,7 +1261,7 @@ void perf_insert_erase(bool random, const T& value) {
             hash_map[keys[i]] = value;
         }
         hash_tm.stop();
-        
+
         LOG(INFO) << (random ? "Randomly" : "Sequentially")
                   << " inserting " << keys.size()
                   << " into FlatMap/MultiFlatMap/std::map/butil::PooledMap/"
@@ -1217,11 +1273,11 @@ void perf_insert_erase(bool random, const T& value) {
                   << "/" << std_unordered_tm.n_elapsed() / keys.size()
                   << "/" << std_unordered_multi_tm.n_elapsed() / keys.size()
                   << "/" << hash_tm.n_elapsed() / keys.size();
-        
+
         if (random) {
             random_shuffle(keys.begin(), keys.end());
         }
-        
+
         id_tm.start();
         for (size_t i = 0; i < keys.size(); ++i) {
             id_map.erase(keys[i]);
@@ -1263,7 +1319,7 @@ void perf_insert_erase(bool random, const T& value) {
             hash_map.erase(keys[i]);
         }
         hash_tm.stop();
-        
+
         LOG(INFO) << (random ? "Randomly" : "Sequentially")
                   << " erasing " << keys.size()
                   << " from FlatMap/MultiFlatMap/std::map/butil::PooledMap/"
@@ -1293,7 +1349,7 @@ void perf_seek(const T& value) {
     butil::hash_map<uint64_t, T> hash_map;
     butil::Timer id_tm, multi_id_tm, std_tm, pooled_tm,
                  std_unordered_tm, std_unordered_multi_tm, hash_tm;
-    
+
     id_map.init((size_t)(nkeys[NPASS-1] * 1.5));
     multi_id_map.init((size_t)(nkeys[NPASS-1] * 1.5));
     LOG(INFO) << "[ value = " << sizeof(T) << " bytes ]";
@@ -1303,8 +1359,8 @@ void perf_seek(const T& value) {
         for (size_t i = 0; i < nkeys[pass]; ++i) {
             keys.push_back(start + i);
         }
-        
-        id_map.clear();        
+
+        id_map.clear();
         for (size_t i = 0; i < keys.size(); ++i) {
             id_map[keys[i]] = value;
         }
@@ -1318,7 +1374,7 @@ void perf_seek(const T& value) {
         for (size_t i = 0; i < keys.size(); ++i) {
             std_map[keys[i]] = value;
         }
-        
+
         pooled_map.clear();
         for (size_t i = 0; i < keys.size(); ++i) {
             pooled_map[keys[i]] = value;
@@ -1338,9 +1394,9 @@ void perf_seek(const T& value) {
         for (size_t i = 0; i < keys.size(); ++i) {
             hash_map[keys[i]] = value;
         }
-        
+
         random_shuffle(keys.begin(), keys.end());
-        
+
         long sum = 0;
         id_tm.start();
         for (size_t i = 0; i < keys.size(); ++i) {
@@ -1383,7 +1439,7 @@ void perf_seek(const T& value) {
             sum += (long&)hash_map.find(keys[i])->second;
         }
         hash_tm.stop();
-        
+
         LOG(INFO) << "Seeking " << keys.size()
                   << " from FlatMap/MultiFlatMap/std::map/butil::PooledMap/"
                      "std::unordered_map/std::unordered_multimap/butil::hash_map takes "
@@ -1428,21 +1484,6 @@ TEST_F(FlatMapTest, copy) {
     m2 = m1;
     ASSERT_FALSE(m1.is_too_crowded(m1.size()));
     ASSERT_FALSE(m2.is_too_crowded(m1.size()));
-
-    butil::FlatMap<int, int> m3;
-    ASSERT_FALSE(m3.initialized());
-    m1 = m3;
-    ASSERT_TRUE(m1.empty());
-    ASSERT_TRUE(m1.initialized());
-
-    m3 = m2;
-    ASSERT_TRUE(m3.initialized());
-    m3.clear();
-    ASSERT_TRUE(m3.initialized());
-    ASSERT_TRUE(m3.empty());
-    butil::FlatMap<int, int> m4 = m3;
-    ASSERT_TRUE(m4.initialized());
-    ASSERT_TRUE(m4.empty());
 }
 
 TEST_F(FlatMapTest, multi) {
@@ -1451,7 +1492,7 @@ TEST_F(FlatMapTest, multi) {
     g_foo_copy_ctor = 0;
     g_foo_assign = 0;
     butil::MultiFlatMap<int, Foo> map;
-    int bucket_count = 32;
+    size_t bucket_count = 32;
     ASSERT_EQ(0, map.init(bucket_count));
     ASSERT_EQ(0, g_foo_ctor);
     ASSERT_EQ(0, g_foo_copy_ctor);
@@ -1480,7 +1521,7 @@ TEST_F(FlatMapTest, multi) {
     butil::DefaultHasher<int> hasher;
     ASSERT_EQ(butil::flatmap_mod(hasher(1), bucket_count),
               butil::flatmap_mod(hasher(same_bucket_key), bucket_count));
-    ASSERT_EQ(0, map.erase(same_bucket_key));
+    ASSERT_EQ(0UL, map.erase(same_bucket_key));
     Foo& f5 = map[same_bucket_key];
     ASSERT_EQ(&f5, map.seek(same_bucket_key));
     ASSERT_EQ(1UL, map.seek_all(same_bucket_key).size());
diff --git a/test/run_tests.sh b/test/run_tests.sh
index ebd648402a..d318e25487 100755
--- a/test/run_tests.sh
+++ b/test/run_tests.sh
@@ -22,7 +22,7 @@ rm core.*
 test_num=0
 failed_test=""
 rc=0
-test_bins="test_butil test_bvar bthread*unittest brpc*unittest"
+test_bins="test_butil"
 for test_bin in $test_bins; do
     test_num=$((test_num + 1))
     >&2 echo "[runtest] $test_bin"