Fix SimpleBarrier

[folly.git] / folly / test / sorted_vector_test.cpp

diff --git a/folly/test/sorted_vector_test.cpp b/folly/test/sorted_vector_test.cpp
index 2ad5fd8c765c8f96ef5e0c90ddd06500d9df7e1a..2c7160ea4e426ec049319779dd74cac9fd3815c6 100644 (file)
--- a/folly/test/sorted_vector_test.cpp
+++ b/folly/test/sorted_vector_test.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright 2013 Facebook, Inc.
+ * Copyright 2016 Facebook, Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,17 +14,20 @@
  * limitations under the License.
  */
 
-#include "folly/sorted_vector_types.h"
-#include <gtest/gtest.h>
+#include <folly/sorted_vector_types.h>
+
 #include <list>
+#include <memory>
+
+#include <folly/portability/GTest.h>
 
 using folly::sorted_vector_set;
 using folly::sorted_vector_map;
 
 namespace {
 
-template<class T>
-struct less_invert : std::binary_function<T,T,bool> {
+template <class T>
+struct less_invert {
   bool operator()(const T& a, const T& b) const {
     return b < a;
   }
@@ -149,10 +152,12 @@ TEST(SortedVectorTypes, SimpleMapTest) {
   m[32] = 100.0;
   check_invariant(m);
   EXPECT_TRUE(m.count(32) == 1);
+  EXPECT_DOUBLE_EQ(100.0, m.at(32));
   EXPECT_FALSE(m.find(32) == m.end());
   m.erase(32);
   EXPECT_TRUE(m.find(32) == m.end());
   check_invariant(m);
+  EXPECT_THROW(m.at(32), std::out_of_range);
 
   sorted_vector_map<int,float> m2 = m;
   EXPECT_TRUE(m2 == m);
@@ -207,12 +212,42 @@ TEST(SortedVectorTypes, Sizes) {
   typedef sorted_vector_set<int,std::less<int>,
     std::allocator<int>,OneAtATimePolicy> SetT;
   typedef sorted_vector_map<int,int,std::less<int>,
-    std::allocator<int>,OneAtATimePolicy> MapT;
+    std::allocator<std::pair<int,int>>,OneAtATimePolicy> MapT;
 
   EXPECT_EQ(sizeof(SetT), sizeof(std::vector<int>));
   EXPECT_EQ(sizeof(MapT), sizeof(std::vector<std::pair<int,int> >));
 }
 
+TEST(SortedVectorTypes, InitializerLists) {
+  sorted_vector_set<int> empty_initialized_set{};
+  EXPECT_TRUE(empty_initialized_set.empty());
+
+  sorted_vector_set<int> singleton_initialized_set{1};
+  EXPECT_EQ(1, singleton_initialized_set.size());
+  EXPECT_EQ(1, *singleton_initialized_set.begin());
+
+  sorted_vector_set<int> forward_initialized_set{1, 2};
+  sorted_vector_set<int> backward_initialized_set{2, 1};
+  EXPECT_EQ(2, forward_initialized_set.size());
+  EXPECT_EQ(1, *forward_initialized_set.begin());
+  EXPECT_EQ(2, *forward_initialized_set.rbegin());
+  EXPECT_TRUE(forward_initialized_set == backward_initialized_set);
+
+  sorted_vector_map<int,int> empty_initialized_map{};
+  EXPECT_TRUE(empty_initialized_map.empty());
+
+  sorted_vector_map<int,int> singleton_initialized_map{{1,10}};
+  EXPECT_EQ(1, singleton_initialized_map.size());
+  EXPECT_EQ(10, singleton_initialized_map[1]);
+
+  sorted_vector_map<int,int> forward_initialized_map{{1,10}, {2,20}};
+  sorted_vector_map<int,int> backward_initialized_map{{2,20}, {1,10}};
+  EXPECT_EQ(2, forward_initialized_map.size());
+  EXPECT_EQ(10, forward_initialized_map[1]);
+  EXPECT_EQ(20, forward_initialized_map[2]);
+  EXPECT_TRUE(forward_initialized_map == backward_initialized_map);
+}
+
 TEST(SortedVectorTypes, CustomCompare) {
   sorted_vector_set<int,less_invert<int> > s;
   for (int i = 0; i < 200; ++i)
@@ -248,7 +283,7 @@ TEST(SortedVectorTypes, GrowthPolicy) {
 
   std::list<CountCopyCtor> v;
   for (int i = 0; i < 20; ++i) {
-    v.push_back(CountCopyCtor(20 + i));
+    v.emplace_back(20 + i);
   }
   a.insert(v.begin(), v.end());
   check_invariant(a);
@@ -270,4 +305,45 @@ TEST(SortedVectorTest, EmptyTest) {
   sorted_vector_map<int,int> emptyMap;
   EXPECT_TRUE(emptyMap.lower_bound(10) == emptyMap.end());
   EXPECT_TRUE(emptyMap.find(10) == emptyMap.end());
+  EXPECT_THROW(emptyMap.at(10), std::out_of_range);
+}
+
+TEST(SortedVectorTest, MoveTest) {
+  sorted_vector_set<std::unique_ptr<int>> s;
+  s.insert(std::unique_ptr<int>(new int(5)));
+  s.insert(s.end(), std::unique_ptr<int>(new int(10)));
+  EXPECT_EQ(s.size(), 2);
+
+  for (const auto& p : s) {
+    EXPECT_TRUE(*p == 5 || *p == 10);
+  }
+
+  sorted_vector_map<int, std::unique_ptr<int>> m;
+  m.insert(std::make_pair(5, std::unique_ptr<int>(new int(5))));
+  m.insert(m.end(), std::make_pair(10, std::unique_ptr<int>(new int(10))));
+
+  EXPECT_EQ(*m[5], 5);
+  EXPECT_EQ(*m[10], 10);
+}
+
+TEST(SortedVectorTest, ShrinkTest) {
+  sorted_vector_set<int> s;
+  int i = 0;
+  // Hopefully your resize policy doubles when capacity is full, or this will
+  // hang forever :(
+  while (s.capacity() == s.size()) {
+    s.insert(i++);
+  }
+  s.shrink_to_fit();
+  // The standard does not actually enforce that this be true, but assume that
+  // vector::shrink_to_fit respects the caller.
+  EXPECT_EQ(s.capacity(), s.size());
+}
+
+TEST(SortedVectorTypes, EraseTest) {
+  sorted_vector_set<int> s1;
+  s1.insert(1);
+  sorted_vector_set<int> s2(s1);
+  EXPECT_EQ(0, s1.erase(0));
+  EXPECT_EQ(s2, s1);
 }