FTL: Configure clang-format
Bug: 160012986
Test: ftl_test
Change-Id: Iab01c967b9318afecb21107a6c25bebc4178edcd
diff --git a/libs/ftl/.clang-format b/libs/ftl/.clang-format
new file mode 120000
index 0000000..86b1593
--- /dev/null
+++ b/libs/ftl/.clang-format
@@ -0,0 +1 @@
+../../../../build/soong/scripts/system-clang-format-2
\ No newline at end of file
diff --git a/libs/ftl/small_map_test.cpp b/libs/ftl/small_map_test.cpp
index 4e7662b..323b9f9 100644
--- a/libs/ftl/small_map_test.cpp
+++ b/libs/ftl/small_map_test.cpp
@@ -25,107 +25,107 @@
// Keep in sync with example usage in header file.
TEST(SmallMap, Example) {
- ftl::SmallMap<int, std::string, 3> map;
- EXPECT_TRUE(map.empty());
- EXPECT_FALSE(map.dynamic());
+ ftl::SmallMap<int, std::string, 3> map;
+ EXPECT_TRUE(map.empty());
+ EXPECT_FALSE(map.dynamic());
- map = ftl::init::map<int, std::string>(123, "abc")(-1)(42, 3u, '?');
- EXPECT_EQ(map.size(), 3u);
- EXPECT_FALSE(map.dynamic());
+ map = ftl::init::map<int, std::string>(123, "abc")(-1)(42, 3u, '?');
+ EXPECT_EQ(map.size(), 3u);
+ EXPECT_FALSE(map.dynamic());
- EXPECT_TRUE(map.contains(123));
+ EXPECT_TRUE(map.contains(123));
- EXPECT_EQ(map.find(42, [](const std::string& s) { return s.size(); }), 3u);
+ EXPECT_EQ(map.find(42, [](const std::string& s) { return s.size(); }), 3u);
- const auto opt = map.find(-1);
- ASSERT_TRUE(opt);
+ const auto opt = map.find(-1);
+ ASSERT_TRUE(opt);
- std::string& ref = *opt;
- EXPECT_TRUE(ref.empty());
- ref = "xyz";
+ std::string& ref = *opt;
+ EXPECT_TRUE(ref.empty());
+ ref = "xyz";
- EXPECT_EQ(map, SmallMap(ftl::init::map(-1, "xyz")(42, "???")(123, "abc")));
+ EXPECT_EQ(map, SmallMap(ftl::init::map(-1, "xyz")(42, "???")(123, "abc")));
}
TEST(SmallMap, Construct) {
- {
- // Default constructor.
- SmallMap<int, std::string, 2> map;
+ {
+ // Default constructor.
+ SmallMap<int, std::string, 2> map;
- EXPECT_TRUE(map.empty());
- EXPECT_FALSE(map.dynamic());
- }
- {
- // In-place constructor with same types.
- SmallMap<int, std::string, 5> map =
- ftl::init::map<int, std::string>(123, "abc")(456, "def")(789, "ghi");
+ EXPECT_TRUE(map.empty());
+ EXPECT_FALSE(map.dynamic());
+ }
+ {
+ // In-place constructor with same types.
+ SmallMap<int, std::string, 5> map =
+ ftl::init::map<int, std::string>(123, "abc")(456, "def")(789, "ghi");
- EXPECT_EQ(map.size(), 3u);
- EXPECT_EQ(map.max_size(), 5u);
- EXPECT_FALSE(map.dynamic());
+ EXPECT_EQ(map.size(), 3u);
+ EXPECT_EQ(map.max_size(), 5u);
+ EXPECT_FALSE(map.dynamic());
- EXPECT_EQ(map, SmallMap(ftl::init::map(123, "abc")(456, "def")(789, "ghi")));
- }
- {
- // In-place constructor with different types.
- SmallMap<int, std::string, 5> map =
- ftl::init::map<int, std::string>(123, "abc")(-1)(42, 3u, '?');
+ EXPECT_EQ(map, SmallMap(ftl::init::map(123, "abc")(456, "def")(789, "ghi")));
+ }
+ {
+ // In-place constructor with different types.
+ SmallMap<int, std::string, 5> map =
+ ftl::init::map<int, std::string>(123, "abc")(-1)(42, 3u, '?');
- EXPECT_EQ(map.size(), 3u);
- EXPECT_EQ(map.max_size(), 5u);
- EXPECT_FALSE(map.dynamic());
+ EXPECT_EQ(map.size(), 3u);
+ EXPECT_EQ(map.max_size(), 5u);
+ EXPECT_FALSE(map.dynamic());
- EXPECT_EQ(map, SmallMap(ftl::init::map(42, "???")(123, "abc")(-1, "\0\0\0")));
- }
- {
- // In-place constructor with implicit size.
- SmallMap map = ftl::init::map<int, std::string>(123, "abc")(-1)(42, 3u, '?');
+ EXPECT_EQ(map, SmallMap(ftl::init::map(42, "???")(123, "abc")(-1, "\0\0\0")));
+ }
+ {
+ // In-place constructor with implicit size.
+ SmallMap map = ftl::init::map<int, std::string>(123, "abc")(-1)(42, 3u, '?');
- static_assert(std::is_same_v<decltype(map), SmallMap<int, std::string, 3>>);
- EXPECT_EQ(map.size(), 3u);
- EXPECT_EQ(map.max_size(), 3u);
- EXPECT_FALSE(map.dynamic());
+ static_assert(std::is_same_v<decltype(map), SmallMap<int, std::string, 3>>);
+ EXPECT_EQ(map.size(), 3u);
+ EXPECT_EQ(map.max_size(), 3u);
+ EXPECT_FALSE(map.dynamic());
- EXPECT_EQ(map, SmallMap(ftl::init::map(-1, "\0\0\0")(42, "???")(123, "abc")));
- }
+ EXPECT_EQ(map, SmallMap(ftl::init::map(-1, "\0\0\0")(42, "???")(123, "abc")));
+ }
}
TEST(SmallMap, Find) {
- {
- // Constant reference.
- const ftl::SmallMap map = ftl::init::map('a', 'A')('b', 'B')('c', 'C');
+ {
+ // Constant reference.
+ const ftl::SmallMap map = ftl::init::map('a', 'A')('b', 'B')('c', 'C');
- const auto opt = map.find('b');
- EXPECT_EQ(opt, 'B');
+ const auto opt = map.find('b');
+ EXPECT_EQ(opt, 'B');
- const char d = 'D';
- const auto ref = map.find('d').value_or(std::cref(d));
- EXPECT_EQ(ref.get(), 'D');
- }
- {
- // Mutable reference.
- ftl::SmallMap map = ftl::init::map('a', 'A')('b', 'B')('c', 'C');
+ const char d = 'D';
+ const auto ref = map.find('d').value_or(std::cref(d));
+ EXPECT_EQ(ref.get(), 'D');
+ }
+ {
+ // Mutable reference.
+ ftl::SmallMap map = ftl::init::map('a', 'A')('b', 'B')('c', 'C');
- const auto opt = map.find('c');
- EXPECT_EQ(opt, 'C');
+ const auto opt = map.find('c');
+ EXPECT_EQ(opt, 'C');
- char d = 'd';
- const auto ref = map.find('d').value_or(std::ref(d));
- ref.get() = 'D';
- EXPECT_EQ(d, 'D');
- }
- {
- // Constant unary operation.
- const ftl::SmallMap map = ftl::init::map('a', 'x')('b', 'y')('c', 'z');
- EXPECT_EQ(map.find('c', [](char c) { return std::toupper(c); }), 'Z');
- }
- {
- // Mutable unary operation.
- ftl::SmallMap map = ftl::init::map('a', 'x')('b', 'y')('c', 'z');
- EXPECT_TRUE(map.find('c', [](char& c) { c = std::toupper(c); }));
+ char d = 'd';
+ const auto ref = map.find('d').value_or(std::ref(d));
+ ref.get() = 'D';
+ EXPECT_EQ(d, 'D');
+ }
+ {
+ // Constant unary operation.
+ const ftl::SmallMap map = ftl::init::map('a', 'x')('b', 'y')('c', 'z');
+ EXPECT_EQ(map.find('c', [](char c) { return std::toupper(c); }), 'Z');
+ }
+ {
+ // Mutable unary operation.
+ ftl::SmallMap map = ftl::init::map('a', 'x')('b', 'y')('c', 'z');
+ EXPECT_TRUE(map.find('c', [](char& c) { c = std::toupper(c); }));
- EXPECT_EQ(map, SmallMap(ftl::init::map('c', 'Z')('b', 'y')('a', 'x')));
- }
+ EXPECT_EQ(map, SmallMap(ftl::init::map('c', 'Z')('b', 'y')('a', 'x')));
+ }
}
-} // namespace android::test
+} // namespace android::test
diff --git a/libs/ftl/small_vector_test.cpp b/libs/ftl/small_vector_test.cpp
index dbb2d4f..3a03e69 100644
--- a/libs/ftl/small_vector_test.cpp
+++ b/libs/ftl/small_vector_test.cpp
@@ -30,436 +30,434 @@
// Keep in sync with example usage in header file.
TEST(SmallVector, Example) {
- ftl::SmallVector<char, 3> vector;
- EXPECT_TRUE(vector.empty());
- EXPECT_FALSE(vector.dynamic());
+ ftl::SmallVector<char, 3> vector;
+ EXPECT_TRUE(vector.empty());
+ EXPECT_FALSE(vector.dynamic());
- vector = {'a', 'b', 'c'};
- EXPECT_EQ(vector.size(), 3u);
- EXPECT_FALSE(vector.dynamic());
+ vector = {'a', 'b', 'c'};
+ EXPECT_EQ(vector.size(), 3u);
+ EXPECT_FALSE(vector.dynamic());
- vector.push_back('d');
- EXPECT_TRUE(vector.dynamic());
+ vector.push_back('d');
+ EXPECT_TRUE(vector.dynamic());
- vector.unstable_erase(vector.begin());
- EXPECT_EQ(vector, (ftl::SmallVector{'d', 'b', 'c'}));
+ vector.unstable_erase(vector.begin());
+ EXPECT_EQ(vector, (ftl::SmallVector{'d', 'b', 'c'}));
- vector.pop_back();
- EXPECT_EQ(vector.back(), 'b');
- EXPECT_TRUE(vector.dynamic());
+ vector.pop_back();
+ EXPECT_EQ(vector.back(), 'b');
+ EXPECT_TRUE(vector.dynamic());
- const char array[] = "hi";
- vector = ftl::SmallVector(array);
- EXPECT_EQ(vector, (ftl::SmallVector{'h', 'i', '\0'}));
- EXPECT_FALSE(vector.dynamic());
+ const char array[] = "hi";
+ vector = ftl::SmallVector(array);
+ EXPECT_EQ(vector, (ftl::SmallVector{'h', 'i', '\0'}));
+ EXPECT_FALSE(vector.dynamic());
- ftl::SmallVector strings = ftl::init::list<std::string>("abc")("123456", 3u)(3u, '?');
- ASSERT_EQ(strings.size(), 3u);
- EXPECT_FALSE(strings.dynamic());
+ ftl::SmallVector strings = ftl::init::list<std::string>("abc")("123456", 3u)(3u, '?');
+ ASSERT_EQ(strings.size(), 3u);
+ EXPECT_FALSE(strings.dynamic());
- EXPECT_EQ(strings[0], "abc");
- EXPECT_EQ(strings[1], "123");
- EXPECT_EQ(strings[2], "???");
+ EXPECT_EQ(strings[0], "abc");
+ EXPECT_EQ(strings[1], "123");
+ EXPECT_EQ(strings[2], "???");
}
TEST(SmallVector, Construct) {
- {
- // Default constructor.
- SmallVector<std::string, 2> vector;
+ {
+ // Default constructor.
+ SmallVector<std::string, 2> vector;
- EXPECT_TRUE(vector.empty());
- EXPECT_FALSE(vector.dynamic());
- }
- {
- // Array constructor.
- const float floats[] = {.1f, .2f, .3f};
- SmallVector vector(floats);
+ EXPECT_TRUE(vector.empty());
+ EXPECT_FALSE(vector.dynamic());
+ }
+ {
+ // Array constructor.
+ const float floats[] = {.1f, .2f, .3f};
+ SmallVector vector(floats);
- EXPECT_EQ(vector, (SmallVector{.1f, .2f, .3f}));
- EXPECT_FALSE(vector.dynamic());
- }
- {
- // Iterator constructor.
- const char chars[] = "abcdef";
- std::string string(chars);
- SmallVector<char, sizeof(chars)> vector(string.begin(), string.end());
+ EXPECT_EQ(vector, (SmallVector{.1f, .2f, .3f}));
+ EXPECT_FALSE(vector.dynamic());
+ }
+ {
+ // Iterator constructor.
+ const char chars[] = "abcdef";
+ std::string string(chars);
+ SmallVector<char, sizeof(chars)> vector(string.begin(), string.end());
- EXPECT_STREQ(vector.begin(), chars);
- EXPECT_FALSE(vector.dynamic());
- }
- {
- // Variadic constructor with same types.
- SmallVector vector = {1, 2, 3};
+ EXPECT_STREQ(vector.begin(), chars);
+ EXPECT_FALSE(vector.dynamic());
+ }
+ {
+ // Variadic constructor with same types.
+ SmallVector vector = {1, 2, 3};
- static_assert(std::is_same_v<decltype(vector), SmallVector<int, 3>>);
- EXPECT_EQ(vector, (SmallVector{1, 2, 3}));
- EXPECT_FALSE(vector.dynamic());
- }
- {
- // Variadic constructor with different types.
- const auto copy = "quince"s;
- auto move = "tart"s;
- SmallVector vector = {copy, std::move(move)};
+ static_assert(std::is_same_v<decltype(vector), SmallVector<int, 3>>);
+ EXPECT_EQ(vector, (SmallVector{1, 2, 3}));
+ EXPECT_FALSE(vector.dynamic());
+ }
+ {
+ // Variadic constructor with different types.
+ const auto copy = "quince"s;
+ auto move = "tart"s;
+ SmallVector vector = {copy, std::move(move)};
- static_assert(std::is_same_v<decltype(vector), SmallVector<std::string, 2>>);
- EXPECT_EQ(vector, (SmallVector{"quince"s, "tart"s}));
- EXPECT_FALSE(vector.dynamic());
- }
- {
- // In-place constructor with same types.
- SmallVector vector =
- ftl::init::list<std::string>("redolent", 3u)("velveteen", 6u)("cakewalk", 4u);
+ static_assert(std::is_same_v<decltype(vector), SmallVector<std::string, 2>>);
+ EXPECT_EQ(vector, (SmallVector{"quince"s, "tart"s}));
+ EXPECT_FALSE(vector.dynamic());
+ }
+ {
+ // In-place constructor with same types.
+ SmallVector vector =
+ ftl::init::list<std::string>("redolent", 3u)("velveteen", 6u)("cakewalk", 4u);
- static_assert(std::is_same_v<decltype(vector), SmallVector<std::string, 3>>);
- EXPECT_EQ(vector, (SmallVector{"red"s, "velvet"s, "cake"s}));
- EXPECT_FALSE(vector.dynamic());
- }
- {
- // In-place constructor with different types.
- const auto copy = "red"s;
- auto move = "velvet"s;
- std::initializer_list<char> list = {'c', 'a', 'k', 'e'};
- SmallVector vector = ftl::init::list<std::string>(copy.c_str())(std::move(move))(list);
+ static_assert(std::is_same_v<decltype(vector), SmallVector<std::string, 3>>);
+ EXPECT_EQ(vector, (SmallVector{"red"s, "velvet"s, "cake"s}));
+ EXPECT_FALSE(vector.dynamic());
+ }
+ {
+ // In-place constructor with different types.
+ const auto copy = "red"s;
+ auto move = "velvet"s;
+ std::initializer_list<char> list = {'c', 'a', 'k', 'e'};
+ SmallVector vector = ftl::init::list<std::string>(copy.c_str())(std::move(move))(list);
- static_assert(std::is_same_v<decltype(vector), SmallVector<std::string, 3>>);
- EXPECT_TRUE(move.empty());
- EXPECT_EQ(vector, (SmallVector{"red"s, "velvet"s, "cake"s}));
- EXPECT_FALSE(vector.dynamic());
- }
- {
- // Conversion from StaticVector.
- ftl::StaticVector doubles = {.1, .2, .3};
- SmallVector vector = std::move(doubles);
- EXPECT_TRUE(doubles.empty());
+ static_assert(std::is_same_v<decltype(vector), SmallVector<std::string, 3>>);
+ EXPECT_TRUE(move.empty());
+ EXPECT_EQ(vector, (SmallVector{"red"s, "velvet"s, "cake"s}));
+ EXPECT_FALSE(vector.dynamic());
+ }
+ {
+ // Conversion from StaticVector.
+ ftl::StaticVector doubles = {.1, .2, .3};
+ SmallVector vector = std::move(doubles);
+ EXPECT_TRUE(doubles.empty());
- static_assert(std::is_same_v<decltype(vector), SmallVector<double, 3>>);
- EXPECT_EQ(vector, (SmallVector{.1, .2, .3}));
- EXPECT_FALSE(vector.dynamic());
- }
+ static_assert(std::is_same_v<decltype(vector), SmallVector<double, 3>>);
+ EXPECT_EQ(vector, (SmallVector{.1, .2, .3}));
+ EXPECT_FALSE(vector.dynamic());
+ }
}
TEST(SmallVector, String) {
- SmallVector<char, 10> chars;
- char c = 'a';
- std::generate_n(std::back_inserter(chars), chars.max_size(), [&c] { return c++; });
- chars.push_back('\0');
+ SmallVector<char, 10> chars;
+ char c = 'a';
+ std::generate_n(std::back_inserter(chars), chars.max_size(), [&c] { return c++; });
+ chars.push_back('\0');
- EXPECT_TRUE(chars.dynamic());
- EXPECT_EQ(chars.size(), 11u);
- EXPECT_STREQ(chars.begin(), "abcdefghij");
+ EXPECT_TRUE(chars.dynamic());
+ EXPECT_EQ(chars.size(), 11u);
+ EXPECT_STREQ(chars.begin(), "abcdefghij");
- // Constructor takes iterator range.
- const char numbers[] = "123456";
- SmallVector<char, 10> string(std::begin(numbers), std::end(numbers));
+ // Constructor takes iterator range.
+ const char numbers[] = "123456";
+ SmallVector<char, 10> string(std::begin(numbers), std::end(numbers));
- EXPECT_FALSE(string.dynamic());
- EXPECT_STREQ(string.begin(), "123456");
- EXPECT_EQ(string.size(), 7u);
+ EXPECT_FALSE(string.dynamic());
+ EXPECT_STREQ(string.begin(), "123456");
+ EXPECT_EQ(string.size(), 7u);
- // Similar to emplace, but replaces rather than inserts.
- string.replace(string.begin() + 5, '\0');
- EXPECT_STREQ(string.begin(), "12345");
+ // Similar to emplace, but replaces rather than inserts.
+ string.replace(string.begin() + 5, '\0');
+ EXPECT_STREQ(string.begin(), "12345");
- swap(chars, string);
+ swap(chars, string);
- EXPECT_STREQ(chars.begin(), "12345");
- EXPECT_STREQ(string.begin(), "abcdefghij");
+ EXPECT_STREQ(chars.begin(), "12345");
+ EXPECT_STREQ(string.begin(), "abcdefghij");
- EXPECT_FALSE(chars.dynamic());
- EXPECT_TRUE(string.dynamic());
+ EXPECT_FALSE(chars.dynamic());
+ EXPECT_TRUE(string.dynamic());
}
TEST(SmallVector, CopyableElement) {
- struct Pair {
- // Needed because std::vector does not use list initialization to emplace.
- Pair(int a, int b) : a(a), b(b) {}
+ struct Pair {
+ // Needed because std::vector does not use list initialization to emplace.
+ Pair(int a, int b) : a(a), b(b) {}
- const int a, b;
- bool operator==(Pair p) const { return p.a == a && p.b == b; }
- };
+ const int a, b;
+ bool operator==(Pair p) const { return p.a == a && p.b == b; }
+ };
- SmallVector<Pair, 5> pairs;
+ SmallVector<Pair, 5> pairs;
- EXPECT_TRUE(pairs.empty());
- EXPECT_EQ(pairs.max_size(), 5u);
+ EXPECT_TRUE(pairs.empty());
+ EXPECT_EQ(pairs.max_size(), 5u);
- for (size_t i = 0; i < pairs.max_size(); ++i) {
- EXPECT_EQ(pairs.size(), i);
+ for (size_t i = 0; i < pairs.max_size(); ++i) {
+ EXPECT_EQ(pairs.size(), i);
- const int a = static_cast<int>(i) * 2;
- EXPECT_EQ(pairs.emplace_back(a, a + 1), Pair(a, a + 1));
- }
+ const int a = static_cast<int>(i) * 2;
+ EXPECT_EQ(pairs.emplace_back(a, a + 1), Pair(a, a + 1));
+ }
- EXPECT_EQ(pairs.size(), 5u);
- EXPECT_FALSE(pairs.dynamic());
+ EXPECT_EQ(pairs.size(), 5u);
+ EXPECT_FALSE(pairs.dynamic());
- // The vector is promoted when full.
- EXPECT_EQ(pairs.emplace_back(10, 11), Pair(10, 11));
- EXPECT_TRUE(pairs.dynamic());
+ // The vector is promoted when full.
+ EXPECT_EQ(pairs.emplace_back(10, 11), Pair(10, 11));
+ EXPECT_TRUE(pairs.dynamic());
- EXPECT_EQ(pairs,
- (SmallVector{Pair{0, 1}, Pair{2, 3}, Pair{4, 5}, Pair{6, 7}, Pair{8, 9},
- Pair{10, 11}}));
+ EXPECT_EQ(pairs, (SmallVector{Pair{0, 1}, Pair{2, 3}, Pair{4, 5}, Pair{6, 7}, Pair{8, 9},
+ Pair{10, 11}}));
- // Constructor takes at most N elements.
- SmallVector<int, 6> sums = {0, 0, 0, 0, 0, 0};
- EXPECT_FALSE(sums.dynamic());
+ // Constructor takes at most N elements.
+ SmallVector<int, 6> sums = {0, 0, 0, 0, 0, 0};
+ EXPECT_FALSE(sums.dynamic());
- // Random-access iterators comply with standard.
- std::transform(pairs.begin(), pairs.end(), sums.begin(), [](Pair p) { return p.a + p.b; });
- EXPECT_EQ(sums, (SmallVector{1, 5, 9, 13, 17, 21}));
+ // Random-access iterators comply with standard.
+ std::transform(pairs.begin(), pairs.end(), sums.begin(), [](Pair p) { return p.a + p.b; });
+ EXPECT_EQ(sums, (SmallVector{1, 5, 9, 13, 17, 21}));
- sums.pop_back();
- std::reverse(sums.begin(), sums.end());
+ sums.pop_back();
+ std::reverse(sums.begin(), sums.end());
- EXPECT_EQ(sums, (SmallVector{17, 13, 9, 5, 1}));
+ EXPECT_EQ(sums, (SmallVector{17, 13, 9, 5, 1}));
}
TEST(SmallVector, MovableElement) {
- // Construct std::string elements in place from per-element arguments.
- SmallVector strings = ftl::init::list<std::string>()()()("cake")("velvet")("red")();
- strings.pop_back();
+ // Construct std::string elements in place from per-element arguments.
+ SmallVector strings = ftl::init::list<std::string>()()()("cake")("velvet")("red")();
+ strings.pop_back();
- EXPECT_EQ(strings.max_size(), 7u);
- EXPECT_EQ(strings.size(), 6u);
+ EXPECT_EQ(strings.max_size(), 7u);
+ EXPECT_EQ(strings.size(), 6u);
- // Erase "cake" and append a substring copy.
- {
- const auto it = std::find_if(strings.begin(), strings.end(),
- [](const auto& s) { return !s.empty(); });
- ASSERT_FALSE(it == strings.end());
- EXPECT_EQ(*it, "cake");
+ // Erase "cake" and append a substring copy.
+ {
+ const auto it =
+ std::find_if(strings.begin(), strings.end(), [](const auto& s) { return !s.empty(); });
+ ASSERT_FALSE(it == strings.end());
+ EXPECT_EQ(*it, "cake");
- // Construct std::string from first 4 characters of string literal.
- strings.unstable_erase(it);
- EXPECT_EQ(strings.emplace_back("cakewalk", 4u), "cake"s);
- }
+ // Construct std::string from first 4 characters of string literal.
+ strings.unstable_erase(it);
+ EXPECT_EQ(strings.emplace_back("cakewalk", 4u), "cake"s);
+ }
- strings[1] = "quince"s;
+ strings[1] = "quince"s;
- // Replace last empty string with "tart".
- {
- const auto rit = std::find(strings.rbegin(), strings.rend(), std::string());
- ASSERT_FALSE(rit == strings.rend());
+ // Replace last empty string with "tart".
+ {
+ const auto rit = std::find(strings.rbegin(), strings.rend(), std::string());
+ ASSERT_FALSE(rit == strings.rend());
- std::initializer_list<char> list = {'t', 'a', 'r', 't'};
- strings.replace(rit.base() - 1, list);
- }
+ std::initializer_list<char> list = {'t', 'a', 'r', 't'};
+ strings.replace(rit.base() - 1, list);
+ }
- strings.front().assign("pie");
+ strings.front().assign("pie");
- EXPECT_EQ(strings, (SmallVector{"pie"s, "quince"s, "tart"s, "red"s, "velvet"s, "cake"s}));
+ EXPECT_EQ(strings, (SmallVector{"pie"s, "quince"s, "tart"s, "red"s, "velvet"s, "cake"s}));
- strings.push_back("nougat");
- strings.push_back("oreo");
- EXPECT_TRUE(strings.dynamic());
+ strings.push_back("nougat");
+ strings.push_back("oreo");
+ EXPECT_TRUE(strings.dynamic());
- std::rotate(strings.begin(), strings.end() - 2, strings.end());
+ std::rotate(strings.begin(), strings.end() - 2, strings.end());
- EXPECT_EQ(strings,
- (SmallVector{"nougat"s, "oreo"s, "pie"s, "quince"s, "tart"s, "red"s, "velvet"s,
- "cake"s}));
+ EXPECT_EQ(strings, (SmallVector{"nougat"s, "oreo"s, "pie"s, "quince"s, "tart"s, "red"s, "velvet"s,
+ "cake"s}));
}
TEST(SmallVector, Replace) {
- // Replacing does not require a copy/move assignment operator.
- struct Word {
- explicit Word(std::string str) : str(std::move(str)) {}
- const std::string str;
+ // Replacing does not require a copy/move assignment operator.
+ struct Word {
+ explicit Word(std::string str) : str(std::move(str)) {}
+ const std::string str;
- bool operator==(const Word& other) const { return other.str == str; }
- };
+ bool operator==(const Word& other) const { return other.str == str; }
+ };
- SmallVector words = ftl::init::list<Word>("colored")("velour");
+ SmallVector words = ftl::init::list<Word>("colored")("velour");
- // The replaced element can be referenced by the replacement.
- {
- const Word& word = words.replace(words.last(), words.back().str.substr(0, 3) + "vet");
- EXPECT_EQ(word, Word("velvet"));
- }
+ // The replaced element can be referenced by the replacement.
+ {
+ const Word& word = words.replace(words.last(), words.back().str.substr(0, 3) + "vet");
+ EXPECT_EQ(word, Word("velvet"));
+ }
- // The vector is not promoted if replacing while full.
- EXPECT_FALSE(words.dynamic());
+ // The vector is not promoted if replacing while full.
+ EXPECT_FALSE(words.dynamic());
- words.emplace_back("cake");
- EXPECT_TRUE(words.dynamic());
+ words.emplace_back("cake");
+ EXPECT_TRUE(words.dynamic());
- {
- const Word& word = words.replace(words.begin(), words.front().str.substr(4));
- EXPECT_EQ(word, Word("red"));
- }
+ {
+ const Word& word = words.replace(words.begin(), words.front().str.substr(4));
+ EXPECT_EQ(word, Word("red"));
+ }
- EXPECT_EQ(words, (SmallVector{Word("red"), Word("velvet"), Word("cake")}));
+ EXPECT_EQ(words, (SmallVector{Word("red"), Word("velvet"), Word("cake")}));
}
TEST(SmallVector, ReverseAppend) {
- SmallVector strings = {"red"s, "velvet"s, "cake"s};
- EXPECT_FALSE(strings.dynamic());
+ SmallVector strings = {"red"s, "velvet"s, "cake"s};
+ EXPECT_FALSE(strings.dynamic());
- auto rit = strings.rbegin();
- while (rit != strings.rend()) {
- // Iterator and reference are invalidated on insertion.
- const auto i = std::distance(strings.begin(), rit.base());
- std::string s = *rit;
+ auto rit = strings.rbegin();
+ while (rit != strings.rend()) {
+ // Iterator and reference are invalidated on insertion.
+ const auto i = std::distance(strings.begin(), rit.base());
+ std::string s = *rit;
- strings.push_back(std::move(s));
- rit = std::make_reverse_iterator(strings.begin() + i) + 1;
- }
+ strings.push_back(std::move(s));
+ rit = std::make_reverse_iterator(strings.begin() + i) + 1;
+ }
- EXPECT_EQ(strings, (SmallVector{"red"s, "velvet"s, "cake"s, "cake"s, "velvet"s, "red"s}));
- EXPECT_TRUE(strings.dynamic());
+ EXPECT_EQ(strings, (SmallVector{"red"s, "velvet"s, "cake"s, "cake"s, "velvet"s, "red"s}));
+ EXPECT_TRUE(strings.dynamic());
}
TEST(SmallVector, Sort) {
- SmallVector strings = ftl::init::list<std::string>("pie")("quince")("tart")("red")("velvet");
- strings.push_back("cake"s);
+ SmallVector strings = ftl::init::list<std::string>("pie")("quince")("tart")("red")("velvet");
+ strings.push_back("cake"s);
- auto sorted = std::move(strings);
- EXPECT_TRUE(strings.empty());
+ auto sorted = std::move(strings);
+ EXPECT_TRUE(strings.empty());
- EXPECT_TRUE(sorted.dynamic());
- EXPECT_TRUE(strings.dynamic());
+ EXPECT_TRUE(sorted.dynamic());
+ EXPECT_TRUE(strings.dynamic());
- std::sort(sorted.begin(), sorted.end());
- EXPECT_EQ(sorted, (SmallVector{"cake"s, "pie"s, "quince"s, "red"s, "tart"s, "velvet"s}));
+ std::sort(sorted.begin(), sorted.end());
+ EXPECT_EQ(sorted, (SmallVector{"cake"s, "pie"s, "quince"s, "red"s, "tart"s, "velvet"s}));
- // Constructor takes array reference.
- {
- const char* array[] = {"cake", "lie"};
- strings = SmallVector(array);
- EXPECT_FALSE(strings.dynamic());
- }
+ // Constructor takes array reference.
+ {
+ const char* array[] = {"cake", "lie"};
+ strings = SmallVector(array);
+ EXPECT_FALSE(strings.dynamic());
+ }
- EXPECT_GT(sorted, strings);
- swap(sorted, strings);
- EXPECT_LT(sorted, strings);
+ EXPECT_GT(sorted, strings);
+ swap(sorted, strings);
+ EXPECT_LT(sorted, strings);
- EXPECT_FALSE(sorted.dynamic());
- EXPECT_TRUE(strings.dynamic());
+ EXPECT_FALSE(sorted.dynamic());
+ EXPECT_TRUE(strings.dynamic());
- // Append remaining elements, such that "pie" is the only difference.
- for (const char* str : {"quince", "red", "tart", "velvet"}) {
- sorted.emplace_back(str);
- }
- EXPECT_TRUE(sorted.dynamic());
+ // Append remaining elements, such that "pie" is the only difference.
+ for (const char* str : {"quince", "red", "tart", "velvet"}) {
+ sorted.emplace_back(str);
+ }
+ EXPECT_TRUE(sorted.dynamic());
- EXPECT_NE(sorted, strings);
+ EXPECT_NE(sorted, strings);
- // Replace second element with "pie".
- const auto it = sorted.begin() + 1;
- EXPECT_EQ(sorted.replace(it, 'p' + it->substr(1)), "pie");
+ // Replace second element with "pie".
+ const auto it = sorted.begin() + 1;
+ EXPECT_EQ(sorted.replace(it, 'p' + it->substr(1)), "pie");
- EXPECT_EQ(sorted, strings);
+ EXPECT_EQ(sorted, strings);
}
namespace {
struct DestroyCounts {
- DestroyCounts(int& live, int& dead) : counts{live, dead} {}
- DestroyCounts(const DestroyCounts& other) : counts(other.counts) {}
- DestroyCounts(DestroyCounts&& other) : counts(other.counts) { other.alive = false; }
- ~DestroyCounts() { ++(alive ? counts.live : counts.dead); }
+ DestroyCounts(int& live, int& dead) : counts{live, dead} {}
+ DestroyCounts(const DestroyCounts& other) : counts(other.counts) {}
+ DestroyCounts(DestroyCounts&& other) : counts(other.counts) { other.alive = false; }
+ ~DestroyCounts() { ++(alive ? counts.live : counts.dead); }
- struct {
- int& live;
- int& dead;
- } counts;
+ struct {
+ int& live;
+ int& dead;
+ } counts;
- bool alive = true;
+ bool alive = true;
};
void swap(DestroyCounts& lhs, DestroyCounts& rhs) {
- std::swap(lhs.alive, rhs.alive);
+ std::swap(lhs.alive, rhs.alive);
}
-} // namespace
+} // namespace
TEST(SmallVector, Destroy) {
- int live = 0;
- int dead = 0;
+ int live = 0;
+ int dead = 0;
- { SmallVector<DestroyCounts, 3> counts; }
+ { SmallVector<DestroyCounts, 3> counts; }
+ EXPECT_EQ(0, live);
+ EXPECT_EQ(0, dead);
+
+ {
+ SmallVector<DestroyCounts, 3> counts;
+ counts.emplace_back(live, dead);
+ counts.emplace_back(live, dead);
+ counts.emplace_back(live, dead);
+
+ EXPECT_FALSE(counts.dynamic());
+ }
+ EXPECT_EQ(3, live);
+ EXPECT_EQ(0, dead);
+
+ live = 0;
+ {
+ SmallVector<DestroyCounts, 3> counts;
+ counts.emplace_back(live, dead);
+ counts.emplace_back(live, dead);
+ counts.emplace_back(live, dead);
+ counts.emplace_back(live, dead);
+
+ EXPECT_TRUE(counts.dynamic());
+ }
+ EXPECT_EQ(4, live);
+ EXPECT_EQ(3, dead);
+
+ live = dead = 0;
+ {
+ SmallVector<DestroyCounts, 2> counts;
+ counts.emplace_back(live, dead);
+ counts.emplace_back(live, dead);
+ counts.emplace_back(live, dead);
+
+ auto copy = counts;
+ EXPECT_TRUE(copy.dynamic());
+ }
+ EXPECT_EQ(6, live);
+ EXPECT_EQ(2, dead);
+
+ live = dead = 0;
+ {
+ SmallVector<DestroyCounts, 2> counts;
+ counts.emplace_back(live, dead);
+ counts.emplace_back(live, dead);
+ counts.emplace_back(live, dead);
+
+ auto move = std::move(counts);
+ EXPECT_TRUE(move.dynamic());
+ }
+ EXPECT_EQ(3, live);
+ EXPECT_EQ(2, dead);
+
+ live = dead = 0;
+ {
+ SmallVector<DestroyCounts, 2> counts1;
+ counts1.emplace_back(live, dead);
+ counts1.emplace_back(live, dead);
+ counts1.emplace_back(live, dead);
+
+ EXPECT_TRUE(counts1.dynamic());
+ EXPECT_EQ(2, dead);
+ dead = 0;
+
+ SmallVector<DestroyCounts, 2> counts2;
+ counts2.emplace_back(live, dead);
+
+ EXPECT_FALSE(counts2.dynamic());
+
+ swap(counts1, counts2);
+
+ EXPECT_FALSE(counts1.dynamic());
+ EXPECT_TRUE(counts2.dynamic());
+
EXPECT_EQ(0, live);
- EXPECT_EQ(0, dead);
+ EXPECT_EQ(1, dead);
- {
- SmallVector<DestroyCounts, 3> counts;
- counts.emplace_back(live, dead);
- counts.emplace_back(live, dead);
- counts.emplace_back(live, dead);
-
- EXPECT_FALSE(counts.dynamic());
- }
- EXPECT_EQ(3, live);
- EXPECT_EQ(0, dead);
-
- live = 0;
- {
- SmallVector<DestroyCounts, 3> counts;
- counts.emplace_back(live, dead);
- counts.emplace_back(live, dead);
- counts.emplace_back(live, dead);
- counts.emplace_back(live, dead);
-
- EXPECT_TRUE(counts.dynamic());
- }
- EXPECT_EQ(4, live);
- EXPECT_EQ(3, dead);
-
- live = dead = 0;
- {
- SmallVector<DestroyCounts, 2> counts;
- counts.emplace_back(live, dead);
- counts.emplace_back(live, dead);
- counts.emplace_back(live, dead);
-
- auto copy = counts;
- EXPECT_TRUE(copy.dynamic());
- }
- EXPECT_EQ(6, live);
- EXPECT_EQ(2, dead);
-
- live = dead = 0;
- {
- SmallVector<DestroyCounts, 2> counts;
- counts.emplace_back(live, dead);
- counts.emplace_back(live, dead);
- counts.emplace_back(live, dead);
-
- auto move = std::move(counts);
- EXPECT_TRUE(move.dynamic());
- }
- EXPECT_EQ(3, live);
- EXPECT_EQ(2, dead);
-
- live = dead = 0;
- {
- SmallVector<DestroyCounts, 2> counts1;
- counts1.emplace_back(live, dead);
- counts1.emplace_back(live, dead);
- counts1.emplace_back(live, dead);
-
- EXPECT_TRUE(counts1.dynamic());
- EXPECT_EQ(2, dead);
- dead = 0;
-
- SmallVector<DestroyCounts, 2> counts2;
- counts2.emplace_back(live, dead);
-
- EXPECT_FALSE(counts2.dynamic());
-
- swap(counts1, counts2);
-
- EXPECT_FALSE(counts1.dynamic());
- EXPECT_TRUE(counts2.dynamic());
-
- EXPECT_EQ(0, live);
- EXPECT_EQ(1, dead);
-
- dead = 0;
- }
- EXPECT_EQ(4, live);
- EXPECT_EQ(0, dead);
+ dead = 0;
+ }
+ EXPECT_EQ(4, live);
+ EXPECT_EQ(0, dead);
}
-} // namespace android::test
+} // namespace android::test
diff --git a/libs/ftl/static_vector_test.cpp b/libs/ftl/static_vector_test.cpp
index 3e66282..cbe8dff 100644
--- a/libs/ftl/static_vector_test.cpp
+++ b/libs/ftl/static_vector_test.cpp
@@ -30,370 +30,370 @@
// Keep in sync with example usage in header file.
TEST(StaticVector, Example) {
- ftl::StaticVector<char, 3> vector;
- EXPECT_TRUE(vector.empty());
+ ftl::StaticVector<char, 3> vector;
+ EXPECT_TRUE(vector.empty());
- vector = {'a', 'b'};
- EXPECT_EQ(vector.size(), 2u);
+ vector = {'a', 'b'};
+ EXPECT_EQ(vector.size(), 2u);
- vector.push_back('c');
- EXPECT_TRUE(vector.full());
+ vector.push_back('c');
+ EXPECT_TRUE(vector.full());
- EXPECT_FALSE(vector.push_back('d'));
- EXPECT_EQ(vector.size(), 3u);
+ EXPECT_FALSE(vector.push_back('d'));
+ EXPECT_EQ(vector.size(), 3u);
- vector.unstable_erase(vector.begin());
- EXPECT_EQ(vector, (ftl::StaticVector{'c', 'b'}));
+ vector.unstable_erase(vector.begin());
+ EXPECT_EQ(vector, (ftl::StaticVector{'c', 'b'}));
- vector.pop_back();
- EXPECT_EQ(vector.back(), 'c');
+ vector.pop_back();
+ EXPECT_EQ(vector.back(), 'c');
- const char array[] = "hi";
- vector = ftl::StaticVector(array);
- EXPECT_EQ(vector, (ftl::StaticVector{'h', 'i', '\0'}));
+ const char array[] = "hi";
+ vector = ftl::StaticVector(array);
+ EXPECT_EQ(vector, (ftl::StaticVector{'h', 'i', '\0'}));
- ftl::StaticVector strings = ftl::init::list<std::string>("abc")("123456", 3u)(3u, '?');
- ASSERT_EQ(strings.size(), 3u);
+ ftl::StaticVector strings = ftl::init::list<std::string>("abc")("123456", 3u)(3u, '?');
+ ASSERT_EQ(strings.size(), 3u);
- EXPECT_EQ(strings[0], "abc");
- EXPECT_EQ(strings[1], "123");
- EXPECT_EQ(strings[2], "???");
+ EXPECT_EQ(strings[0], "abc");
+ EXPECT_EQ(strings[1], "123");
+ EXPECT_EQ(strings[2], "???");
}
TEST(StaticVector, Construct) {
+ {
+ // Default constructor.
+ StaticVector<std::string, 2> vector;
+ EXPECT_TRUE(vector.empty());
+ }
+ {
+ // Array constructor.
+ const float floats[] = {.1f, .2f, .3f};
+ StaticVector vector(floats);
+ EXPECT_EQ(vector, (StaticVector{.1f, .2f, .3f}));
+ }
+ {
+ // Iterator constructor.
+ const char chars[] = "abcdef";
+ std::string string(chars);
+ StaticVector<char, sizeof(chars)> vector(string.begin(), string.end());
+
+ EXPECT_STREQ(vector.begin(), chars);
+ }
+ {
+ // Variadic constructor with same types.
+ StaticVector vector = {1, 2, 3};
+
+ static_assert(std::is_same_v<decltype(vector), StaticVector<int, 3>>);
+ EXPECT_EQ(vector, (StaticVector{1, 2, 3}));
+ }
+ {
+ // Variadic constructor with different types.
+ const auto copy = "quince"s;
+ auto move = "tart"s;
+ StaticVector vector = {copy, std::move(move)};
+
+ static_assert(std::is_same_v<decltype(vector), StaticVector<std::string, 2>>);
+ EXPECT_EQ(vector, (StaticVector{"quince"s, "tart"s}));
+ }
+ {
+ // In-place constructor with same types.
+ StaticVector vector =
+ ftl::init::list<std::string>("redolent", 3u)("velveteen", 6u)("cakewalk", 4u);
+
+ static_assert(std::is_same_v<decltype(vector), StaticVector<std::string, 3>>);
+ EXPECT_EQ(vector, (StaticVector{"red"s, "velvet"s, "cake"s}));
+ }
+ {
+ // In-place constructor with different types.
+ const auto copy = "red"s;
+ auto move = "velvet"s;
+ std::initializer_list<char> list = {'c', 'a', 'k', 'e'};
+ StaticVector vector = ftl::init::list<std::string>(copy.c_str())(std::move(move))(list);
+
+ static_assert(std::is_same_v<decltype(vector), StaticVector<std::string, 3>>);
+ EXPECT_TRUE(move.empty());
+ EXPECT_EQ(vector, (StaticVector{"red"s, "velvet"s, "cake"s}));
+ }
+ {
+ struct String {
+ explicit String(const char* str) : str(str) {}
+ explicit String(const char** ptr) : str(*ptr) {}
+ const char* str;
+ };
+
+ const char* strings[] = {"a", "b", "c", "d"};
+
{
- // Default constructor.
- StaticVector<std::string, 2> vector;
- EXPECT_TRUE(vector.empty());
+ // Two iterator-like elements.
+ StaticVector<String, 3> vector(strings, strings + 3);
+ ASSERT_EQ(vector.size(), 2u);
+
+ EXPECT_STREQ(vector[0].str, "a");
+ EXPECT_STREQ(vector[1].str, "d");
}
{
- // Array constructor.
- const float floats[] = {.1f, .2f, .3f};
- StaticVector vector(floats);
- EXPECT_EQ(vector, (StaticVector{.1f, .2f, .3f}));
+ // Disambiguating iterator constructor.
+ StaticVector<String, 3> vector(ftl::kIteratorRange, strings, strings + 3);
+ ASSERT_EQ(vector.size(), 3u);
+
+ EXPECT_STREQ(vector[0].str, "a");
+ EXPECT_STREQ(vector[1].str, "b");
+ EXPECT_STREQ(vector[2].str, "c");
}
- {
- // Iterator constructor.
- const char chars[] = "abcdef";
- std::string string(chars);
- StaticVector<char, sizeof(chars)> vector(string.begin(), string.end());
-
- EXPECT_STREQ(vector.begin(), chars);
- }
- {
- // Variadic constructor with same types.
- StaticVector vector = {1, 2, 3};
-
- static_assert(std::is_same_v<decltype(vector), StaticVector<int, 3>>);
- EXPECT_EQ(vector, (StaticVector{1, 2, 3}));
- }
- {
- // Variadic constructor with different types.
- const auto copy = "quince"s;
- auto move = "tart"s;
- StaticVector vector = {copy, std::move(move)};
-
- static_assert(std::is_same_v<decltype(vector), StaticVector<std::string, 2>>);
- EXPECT_EQ(vector, (StaticVector{"quince"s, "tart"s}));
- }
- {
- // In-place constructor with same types.
- StaticVector vector =
- ftl::init::list<std::string>("redolent", 3u)("velveteen", 6u)("cakewalk", 4u);
-
- static_assert(std::is_same_v<decltype(vector), StaticVector<std::string, 3>>);
- EXPECT_EQ(vector, (StaticVector{"red"s, "velvet"s, "cake"s}));
- }
- {
- // In-place constructor with different types.
- const auto copy = "red"s;
- auto move = "velvet"s;
- std::initializer_list<char> list = {'c', 'a', 'k', 'e'};
- StaticVector vector = ftl::init::list<std::string>(copy.c_str())(std::move(move))(list);
-
- static_assert(std::is_same_v<decltype(vector), StaticVector<std::string, 3>>);
- EXPECT_TRUE(move.empty());
- EXPECT_EQ(vector, (StaticVector{"red"s, "velvet"s, "cake"s}));
- }
- {
- struct String {
- explicit String(const char* str) : str(str) {}
- explicit String(const char** ptr) : str(*ptr) {}
- const char* str;
- };
-
- const char* strings[] = {"a", "b", "c", "d"};
-
- {
- // Two iterator-like elements.
- StaticVector<String, 3> vector(strings, strings + 3);
- ASSERT_EQ(vector.size(), 2u);
-
- EXPECT_STREQ(vector[0].str, "a");
- EXPECT_STREQ(vector[1].str, "d");
- }
- {
- // Disambiguating iterator constructor.
- StaticVector<String, 3> vector(ftl::kIteratorRange, strings, strings + 3);
- ASSERT_EQ(vector.size(), 3u);
-
- EXPECT_STREQ(vector[0].str, "a");
- EXPECT_STREQ(vector[1].str, "b");
- EXPECT_STREQ(vector[2].str, "c");
- }
- }
+ }
}
TEST(StaticVector, String) {
- StaticVector<char, 10> chars;
- char c = 'a';
- std::generate_n(std::back_inserter(chars), chars.max_size(), [&c] { return c++; });
- chars.back() = '\0';
+ StaticVector<char, 10> chars;
+ char c = 'a';
+ std::generate_n(std::back_inserter(chars), chars.max_size(), [&c] { return c++; });
+ chars.back() = '\0';
- EXPECT_STREQ(chars.begin(), "abcdefghi");
+ EXPECT_STREQ(chars.begin(), "abcdefghi");
- // Constructor takes iterator range.
- const char numbers[] = "123456";
- StaticVector<char, 10> string(std::begin(numbers), std::end(numbers));
+ // Constructor takes iterator range.
+ const char numbers[] = "123456";
+ StaticVector<char, 10> string(std::begin(numbers), std::end(numbers));
- EXPECT_STREQ(string.begin(), "123456");
- EXPECT_EQ(string.size(), 7u);
+ EXPECT_STREQ(string.begin(), "123456");
+ EXPECT_EQ(string.size(), 7u);
- // Similar to emplace, but replaces rather than inserts.
- string.replace(string.begin() + 5, '\0');
- EXPECT_STREQ(string.begin(), "12345");
+ // Similar to emplace, but replaces rather than inserts.
+ string.replace(string.begin() + 5, '\0');
+ EXPECT_STREQ(string.begin(), "12345");
- swap(chars, string);
+ swap(chars, string);
- EXPECT_STREQ(chars.begin(), "12345");
- EXPECT_STREQ(string.begin(), "abcdefghi");
+ EXPECT_STREQ(chars.begin(), "12345");
+ EXPECT_STREQ(string.begin(), "abcdefghi");
}
TEST(StaticVector, CopyableElement) {
- struct Pair {
- const int a, b;
- bool operator==(Pair p) const { return p.a == a && p.b == b; }
- };
+ struct Pair {
+ const int a, b;
+ bool operator==(Pair p) const { return p.a == a && p.b == b; }
+ };
- StaticVector<Pair, 5> pairs;
+ StaticVector<Pair, 5> pairs;
- EXPECT_TRUE(pairs.empty());
- EXPECT_EQ(pairs.max_size(), 5u);
+ EXPECT_TRUE(pairs.empty());
+ EXPECT_EQ(pairs.max_size(), 5u);
- for (size_t i = 0; i < pairs.max_size(); ++i) {
- EXPECT_EQ(pairs.size(), i);
+ for (size_t i = 0; i < pairs.max_size(); ++i) {
+ EXPECT_EQ(pairs.size(), i);
- const int a = static_cast<int>(i) * 2;
- const auto it = pairs.emplace_back(a, a + 1);
- ASSERT_NE(it, pairs.end());
- EXPECT_EQ(*it, (Pair{a, a + 1}));
- }
+ const int a = static_cast<int>(i) * 2;
+ const auto it = pairs.emplace_back(a, a + 1);
+ ASSERT_NE(it, pairs.end());
+ EXPECT_EQ(*it, (Pair{a, a + 1}));
+ }
- EXPECT_TRUE(pairs.full());
- EXPECT_EQ(pairs.size(), 5u);
+ EXPECT_TRUE(pairs.full());
+ EXPECT_EQ(pairs.size(), 5u);
- // Insertion fails if the vector is full.
- const auto it = pairs.emplace_back(10, 11);
- EXPECT_EQ(it, pairs.end());
+ // Insertion fails if the vector is full.
+ const auto it = pairs.emplace_back(10, 11);
+ EXPECT_EQ(it, pairs.end());
- EXPECT_EQ(pairs, (StaticVector{Pair{0, 1}, Pair{2, 3}, Pair{4, 5}, Pair{6, 7}, Pair{8, 9}}));
+ EXPECT_EQ(pairs, (StaticVector{Pair{0, 1}, Pair{2, 3}, Pair{4, 5}, Pair{6, 7}, Pair{8, 9}}));
- // Constructor takes at most N elements.
- StaticVector<int, 6> sums = {0, 0, 0, 0, 0, -1};
- EXPECT_TRUE(sums.full());
+ // Constructor takes at most N elements.
+ StaticVector<int, 6> sums = {0, 0, 0, 0, 0, -1};
+ EXPECT_TRUE(sums.full());
- // Random-access iterators comply with standard.
- std::transform(pairs.begin(), pairs.end(), sums.begin(), [](Pair p) { return p.a + p.b; });
- EXPECT_EQ(sums, (StaticVector{1, 5, 9, 13, 17, -1}));
+ // Random-access iterators comply with standard.
+ std::transform(pairs.begin(), pairs.end(), sums.begin(), [](Pair p) { return p.a + p.b; });
+ EXPECT_EQ(sums, (StaticVector{1, 5, 9, 13, 17, -1}));
- sums.pop_back();
- std::reverse(sums.begin(), sums.end());
+ sums.pop_back();
+ std::reverse(sums.begin(), sums.end());
- EXPECT_EQ(sums, (StaticVector{17, 13, 9, 5, 1}));
+ EXPECT_EQ(sums, (StaticVector{17, 13, 9, 5, 1}));
}
TEST(StaticVector, MovableElement) {
- // Construct std::string elements in place from per-element arguments.
- StaticVector strings = ftl::init::list<std::string>()()()("cake")("velvet")("red")();
- strings.pop_back();
+ // Construct std::string elements in place from per-element arguments.
+ StaticVector strings = ftl::init::list<std::string>()()()("cake")("velvet")("red")();
+ strings.pop_back();
- EXPECT_EQ(strings.max_size(), 7u);
- EXPECT_EQ(strings.size(), 6u);
+ EXPECT_EQ(strings.max_size(), 7u);
+ EXPECT_EQ(strings.size(), 6u);
- // Erase "cake" and append a substring copy.
- {
- auto it = std::find_if(strings.begin(), strings.end(),
- [](const auto& s) { return !s.empty(); });
- ASSERT_FALSE(it == strings.end());
- EXPECT_EQ(*it, "cake");
+ // Erase "cake" and append a substring copy.
+ {
+ auto it =
+ std::find_if(strings.begin(), strings.end(), [](const auto& s) { return !s.empty(); });
+ ASSERT_FALSE(it == strings.end());
+ EXPECT_EQ(*it, "cake");
- strings.unstable_erase(it);
+ strings.unstable_erase(it);
- // Construct std::string from first 4 characters of string literal.
- it = strings.emplace_back("cakewalk", 4u);
- ASSERT_NE(it, strings.end());
- EXPECT_EQ(*it, "cake"s);
- }
+ // Construct std::string from first 4 characters of string literal.
+ it = strings.emplace_back("cakewalk", 4u);
+ ASSERT_NE(it, strings.end());
+ EXPECT_EQ(*it, "cake"s);
+ }
- strings[1] = "quince"s;
+ strings[1] = "quince"s;
- // Replace last empty string with "tart".
- {
- const auto rit = std::find(strings.rbegin(), strings.rend(), std::string());
- ASSERT_FALSE(rit == strings.rend());
+ // Replace last empty string with "tart".
+ {
+ const auto rit = std::find(strings.rbegin(), strings.rend(), std::string());
+ ASSERT_FALSE(rit == strings.rend());
- std::initializer_list<char> list = {'t', 'a', 'r', 't'};
- strings.replace(rit.base() - 1, list);
- }
+ std::initializer_list<char> list = {'t', 'a', 'r', 't'};
+ strings.replace(rit.base() - 1, list);
+ }
- strings.front().assign("pie");
+ strings.front().assign("pie");
- EXPECT_EQ(strings, (StaticVector{"pie"s, "quince"s, "tart"s, "red"s, "velvet"s, "cake"s}));
+ EXPECT_EQ(strings, (StaticVector{"pie"s, "quince"s, "tart"s, "red"s, "velvet"s, "cake"s}));
}
TEST(StaticVector, Replace) {
- // Replacing does not require a copy/move assignment operator.
- struct Word {
- explicit Word(std::string str) : str(std::move(str)) {}
- const std::string str;
- };
+ // Replacing does not require a copy/move assignment operator.
+ struct Word {
+ explicit Word(std::string str) : str(std::move(str)) {}
+ const std::string str;
+ };
- StaticVector words = ftl::init::list<Word>("red")("velour")("cake");
+ StaticVector words = ftl::init::list<Word>("red")("velour")("cake");
- // The replaced element can be referenced by the replacement.
- const auto it = words.begin() + 1;
- const Word& word = words.replace(it, it->str.substr(0, 3) + "vet");
- EXPECT_EQ(word.str, "velvet");
+ // The replaced element can be referenced by the replacement.
+ const auto it = words.begin() + 1;
+ const Word& word = words.replace(it, it->str.substr(0, 3) + "vet");
+ EXPECT_EQ(word.str, "velvet");
}
TEST(StaticVector, ReverseTruncate) {
- StaticVector<std::string, 10> strings("pie", "quince", "tart", "red", "velvet", "cake");
- EXPECT_FALSE(strings.full());
+ StaticVector<std::string, 10> strings("pie", "quince", "tart", "red", "velvet", "cake");
+ EXPECT_FALSE(strings.full());
- for (auto it = strings.begin(); it != strings.end(); ++it) {
- strings.replace(it, strings.back());
- strings.pop_back();
- }
+ for (auto it = strings.begin(); it != strings.end(); ++it) {
+ strings.replace(it, strings.back());
+ strings.pop_back();
+ }
- EXPECT_EQ(strings, (StaticVector{"cake"s, "velvet"s, "red"s}));
+ EXPECT_EQ(strings, (StaticVector{"cake"s, "velvet"s, "red"s}));
}
TEST(StaticVector, Sort) {
- StaticVector<std::string, 7> strings("pie", "quince", "tart", "red", "velvet", "cake");
- EXPECT_FALSE(strings.full());
+ StaticVector<std::string, 7> strings("pie", "quince", "tart", "red", "velvet", "cake");
+ EXPECT_FALSE(strings.full());
- auto sorted = std::move(strings);
- EXPECT_TRUE(strings.empty());
+ auto sorted = std::move(strings);
+ EXPECT_TRUE(strings.empty());
- std::sort(sorted.begin(), sorted.end());
- EXPECT_EQ(sorted, (StaticVector{"cake"s, "pie"s, "quince"s, "red"s, "tart"s, "velvet"s}));
+ std::sort(sorted.begin(), sorted.end());
+ EXPECT_EQ(sorted, (StaticVector{"cake"s, "pie"s, "quince"s, "red"s, "tart"s, "velvet"s}));
- // Constructor takes array reference.
- {
- const char* array[] = {"cake", "lie"};
- strings = StaticVector(array);
- }
+ // Constructor takes array reference.
+ {
+ const char* array[] = {"cake", "lie"};
+ strings = StaticVector(array);
+ }
- EXPECT_GT(sorted, strings);
- swap(sorted, strings);
- EXPECT_LT(sorted, strings);
+ EXPECT_GT(sorted, strings);
+ swap(sorted, strings);
+ EXPECT_LT(sorted, strings);
- // Append remaining elements, such that "pie" is the only difference.
- for (const char* str : {"quince", "red", "tart", "velvet"}) {
- sorted.emplace_back(str);
- }
+ // Append remaining elements, such that "pie" is the only difference.
+ for (const char* str : {"quince", "red", "tart", "velvet"}) {
+ sorted.emplace_back(str);
+ }
- EXPECT_NE(sorted, strings);
+ EXPECT_NE(sorted, strings);
- // Replace second element with "pie".
- const auto it = sorted.begin() + 1;
- EXPECT_EQ(sorted.replace(it, 'p' + it->substr(1)), "pie");
+ // Replace second element with "pie".
+ const auto it = sorted.begin() + 1;
+ EXPECT_EQ(sorted.replace(it, 'p' + it->substr(1)), "pie");
- EXPECT_EQ(sorted, strings);
+ EXPECT_EQ(sorted, strings);
}
namespace {
struct DestroyCounts {
- DestroyCounts(int& live, int& dead) : counts{live, dead} {}
- DestroyCounts(const DestroyCounts& other) : counts(other.counts) {}
- DestroyCounts(DestroyCounts&& other) : counts(other.counts) { other.alive = false; }
- ~DestroyCounts() { ++(alive ? counts.live : counts.dead); }
+ DestroyCounts(int& live, int& dead) : counts{live, dead} {}
+ DestroyCounts(const DestroyCounts& other) : counts(other.counts) {}
+ DestroyCounts(DestroyCounts&& other) : counts(other.counts) { other.alive = false; }
+ ~DestroyCounts() { ++(alive ? counts.live : counts.dead); }
- struct {
- int& live;
- int& dead;
- } counts;
+ struct {
+ int& live;
+ int& dead;
+ } counts;
- bool alive = true;
+ bool alive = true;
};
void swap(DestroyCounts& lhs, DestroyCounts& rhs) {
- std::swap(lhs.alive, rhs.alive);
+ std::swap(lhs.alive, rhs.alive);
}
-} // namespace
+} // namespace
TEST(StaticVector, Destroy) {
- int live = 0;
- int dead = 0;
+ int live = 0;
+ int dead = 0;
- { StaticVector<DestroyCounts, 5> counts; }
+ { StaticVector<DestroyCounts, 5> counts; }
+ EXPECT_EQ(0, live);
+ EXPECT_EQ(0, dead);
+
+ {
+ StaticVector<DestroyCounts, 5> counts;
+ counts.emplace_back(live, dead);
+ counts.emplace_back(live, dead);
+ counts.emplace_back(live, dead);
+ }
+ EXPECT_EQ(3, live);
+ EXPECT_EQ(0, dead);
+
+ live = 0;
+ {
+ StaticVector<DestroyCounts, 5> counts;
+ counts.emplace_back(live, dead);
+ counts.emplace_back(live, dead);
+ counts.emplace_back(live, dead);
+
+ auto copy = counts;
+ }
+ EXPECT_EQ(6, live);
+ EXPECT_EQ(0, dead);
+
+ live = 0;
+ {
+ StaticVector<DestroyCounts, 5> counts;
+ counts.emplace_back(live, dead);
+ counts.emplace_back(live, dead);
+ counts.emplace_back(live, dead);
+
+ auto move = std::move(counts);
+ }
+ EXPECT_EQ(3, live);
+ EXPECT_EQ(3, dead);
+
+ live = dead = 0;
+ {
+ StaticVector<DestroyCounts, 5> counts1;
+ counts1.emplace_back(live, dead);
+ counts1.emplace_back(live, dead);
+ counts1.emplace_back(live, dead);
+
+ StaticVector<DestroyCounts, 5> counts2;
+ counts2.emplace_back(live, dead);
+
+ swap(counts1, counts2);
+
EXPECT_EQ(0, live);
- EXPECT_EQ(0, dead);
+ EXPECT_EQ(2, dead);
- {
- StaticVector<DestroyCounts, 5> counts;
- counts.emplace_back(live, dead);
- counts.emplace_back(live, dead);
- counts.emplace_back(live, dead);
- }
- EXPECT_EQ(3, live);
- EXPECT_EQ(0, dead);
-
- live = 0;
- {
- StaticVector<DestroyCounts, 5> counts;
- counts.emplace_back(live, dead);
- counts.emplace_back(live, dead);
- counts.emplace_back(live, dead);
-
- auto copy = counts;
- }
- EXPECT_EQ(6, live);
- EXPECT_EQ(0, dead);
-
- live = 0;
- {
- StaticVector<DestroyCounts, 5> counts;
- counts.emplace_back(live, dead);
- counts.emplace_back(live, dead);
- counts.emplace_back(live, dead);
-
- auto move = std::move(counts);
- }
- EXPECT_EQ(3, live);
- EXPECT_EQ(3, dead);
-
- live = dead = 0;
- {
- StaticVector<DestroyCounts, 5> counts1;
- counts1.emplace_back(live, dead);
- counts1.emplace_back(live, dead);
- counts1.emplace_back(live, dead);
-
- StaticVector<DestroyCounts, 5> counts2;
- counts2.emplace_back(live, dead);
-
- swap(counts1, counts2);
-
- EXPECT_EQ(0, live);
- EXPECT_EQ(2, dead);
-
- dead = 0;
- }
- EXPECT_EQ(4, live);
- EXPECT_EQ(0, dead);
+ dead = 0;
+ }
+ EXPECT_EQ(4, live);
+ EXPECT_EQ(0, dead);
}
-} // namespace android::test
+} // namespace android::test