libs/ftl/static_vector_test.cpp - LeafOS-Project/android_frameworks_native - Gitiles

 /*
  * Copyright 2020 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 #include <ftl/static_vector.h>
 #include <gtest/gtest.h>

 #include <algorithm>
 #include <iterator>
 #include <string>
 #include <utility>

 using namespace std::string_literals;

 namespace android::test {

 using ftl::StaticVector;

 // Keep in sync with example usage in header file.
 TEST(StaticVector, Example) {
   ftl::StaticVector<char, 3> vector;
   EXPECT_TRUE(vector.empty());

   vector = {'a', 'b'};
   EXPECT_EQ(vector.size(), 2u);

   vector.push_back('c');
   EXPECT_TRUE(vector.full());

   EXPECT_FALSE(vector.push_back('d'));
   EXPECT_EQ(vector.size(), 3u);

   vector.unstable_erase(vector.begin());
   EXPECT_EQ(vector, (ftl::StaticVector{'c', 'b'}));

   vector.pop_back();
   EXPECT_EQ(vector.back(), 'c');

   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);

   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"};

     {
       // 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, Copy) {
   {
     // Same capacity.
     const StaticVector vector = {"snow"s, "cone"s};

     StaticVector<const std::string, 2> copy(vector);
     EXPECT_EQ(copy, vector);

     // The vector is assignable even if T is const.
     const StaticVector<std::string, 2> other = {"tiramisu"s};
     copy = other;
     EXPECT_EQ(copy, other);
   }
   {
     // From smaller capacity.
     const StaticVector vector = {"snow"s, "cone"s};

     StaticVector<const std::string, 3> copy(vector);
     EXPECT_EQ(copy, vector);

     // The vector is assignable even if T is const.
     const StaticVector other = {"tiramisu"s};
     copy = other;
     EXPECT_EQ(copy, other);
   }
 }

 TEST(StaticVector, Move) {
   {
     // Same capacity.
     StaticVector vector = {"snow"s, "cone"s};

     StaticVector<const std::string, 2> move(std::move(vector));
     EXPECT_TRUE(vector.empty());
     EXPECT_EQ(move, (StaticVector{"snow"s, "cone"s}));

     // The vector is assignable even if T is const.
     StaticVector<std::string, 2> other = {"tiramisu"s};
     move = std::move(other);
     EXPECT_TRUE(other.empty());
     EXPECT_EQ(move, (StaticVector{"tiramisu"s}));
   }
   {
     // From smaller capacity.
     StaticVector vector = {"snow"s, "cone"s};

     StaticVector<const std::string, 3> move(std::move(vector));
     EXPECT_TRUE(vector.empty());
     EXPECT_EQ(move, (StaticVector{"snow"s, "cone"s}));

     // The vector is assignable even if T is const.
     StaticVector other = {"tiramisu"s};
     move = std::move(other);
     EXPECT_TRUE(other.empty());
     EXPECT_EQ(move, (StaticVector{"tiramisu"s}));
   }
 }

 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';

   EXPECT_STREQ(chars.begin(), "abcdefghi");

   // 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);

   // Similar to emplace, but replaces rather than inserts.
   string.replace(string.begin() + 5, '\0');
   EXPECT_STREQ(string.begin(), "12345");

   swap(chars, string);

   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; }
   };

   StaticVector<Pair, 5> pairs;

   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);

     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);

   // 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}}));

   // 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}));

   sums.pop_back();
   std::reverse(sums.begin(), sums.end());

   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();

   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");

     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);
   }

   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());

     std::initializer_list<char> list = {'t', 'a', 'r', 't'};
     strings.replace(rit.base() - 1, list);
   }

   strings.front().assign("pie");

   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;
   };

   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");
 }

 TEST(StaticVector, ReverseTruncate) {
   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();
   }

   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());

   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}));

   // Constructor takes array reference.
   {
     const char* array[] = {"cake", "lie"};
     strings = StaticVector(array);
   }

   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);
   }

   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");

   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); }

   struct {
     int& live;
     int& dead;
   } counts;

   bool alive = true;
 };

 }  // namespace

 TEST(StaticVector, Destroy) {
   int live = 0;
   int dead = 0;
   {
     // Empty.
     StaticVector<DestroyCounts, 5> counts;
   }
   EXPECT_EQ(0, live);
   EXPECT_EQ(0, dead);

   {
     // Non-empty.
     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;
   {
     // Copy.
     StaticVector<DestroyCounts, 5> counts;
     counts.emplace_back(live, dead);
     counts.emplace_back(live, dead);
     counts.emplace_back(live, dead);

     const auto copy = counts;
   }
   EXPECT_EQ(6, live);
   EXPECT_EQ(0, dead);

   live = 0;
   {
     // Move.
     StaticVector<DestroyCounts, 5> counts;
     counts.emplace_back(live, dead);
     counts.emplace_back(live, dead);
     counts.emplace_back(live, dead);

     const auto move = std::move(counts);
   }
   EXPECT_EQ(3, live);
   EXPECT_EQ(3, dead);

   live = dead = 0;
   {
     // Swap.
     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);
     counts2.emplace_back(live, dead);

     swap(counts1, counts2);

     EXPECT_EQ(2u, counts1.size());
     EXPECT_EQ(3u, counts2.size());

     EXPECT_EQ(0, live);
     EXPECT_EQ(7, dead);  // 3 moves per swap, plus 1 move.

     dead = 0;
   }
   EXPECT_EQ(5, live);
   EXPECT_EQ(0, dead);
 }

 TEST(StaticVector, Clear) {
   int live = 0;
   int dead = 0;
   {
     StaticVector<DestroyCounts, 5> counts;
     counts.emplace_back(live, dead);
     counts.emplace_back(live, dead);

     counts.clear();

     EXPECT_TRUE(counts.empty());
   }
   EXPECT_EQ(2, live);
   EXPECT_EQ(0, dead);
 }

 }  // namespace android::test
	/*
	* Copyright 2020 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#include <ftl/static_vector.h>
	#include <gtest/gtest.h>

	#include <algorithm>
	#include <iterator>
	#include <string>
	#include <utility>

	using namespace std::string_literals;

	namespace android::test {

	using ftl::StaticVector;

	// Keep in sync with example usage in header file.
	TEST(StaticVector, Example) {
	ftl::StaticVector<char, 3> vector;
	EXPECT_TRUE(vector.empty());

	vector = {'a', 'b'};
	EXPECT_EQ(vector.size(), 2u);

	vector.push_back('c');
	EXPECT_TRUE(vector.full());

	EXPECT_FALSE(vector.push_back('d'));
	EXPECT_EQ(vector.size(), 3u);

	vector.unstable_erase(vector.begin());
	EXPECT_EQ(vector, (ftl::StaticVector{'c', 'b'}));

	vector.pop_back();
	EXPECT_EQ(vector.back(), 'c');

	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);

	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"};

	{
	// 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, Copy) {
	{
	// Same capacity.
	const StaticVector vector = {"snow"s, "cone"s};

	StaticVector<const std::string, 2> copy(vector);
	EXPECT_EQ(copy, vector);

	// The vector is assignable even if T is const.
	const StaticVector<std::string, 2> other = {"tiramisu"s};
	copy = other;
	EXPECT_EQ(copy, other);
	}
	{
	// From smaller capacity.
	const StaticVector vector = {"snow"s, "cone"s};

	StaticVector<const std::string, 3> copy(vector);
	EXPECT_EQ(copy, vector);

	// The vector is assignable even if T is const.
	const StaticVector other = {"tiramisu"s};
	copy = other;
	EXPECT_EQ(copy, other);
	}
	}

	TEST(StaticVector, Move) {
	{
	// Same capacity.
	StaticVector vector = {"snow"s, "cone"s};

	StaticVector<const std::string, 2> move(std::move(vector));
	EXPECT_TRUE(vector.empty());
	EXPECT_EQ(move, (StaticVector{"snow"s, "cone"s}));

	// The vector is assignable even if T is const.
	StaticVector<std::string, 2> other = {"tiramisu"s};
	move = std::move(other);
	EXPECT_TRUE(other.empty());
	EXPECT_EQ(move, (StaticVector{"tiramisu"s}));
	}
	{
	// From smaller capacity.
	StaticVector vector = {"snow"s, "cone"s};

	StaticVector<const std::string, 3> move(std::move(vector));
	EXPECT_TRUE(vector.empty());
	EXPECT_EQ(move, (StaticVector{"snow"s, "cone"s}));

	// The vector is assignable even if T is const.
	StaticVector other = {"tiramisu"s};
	move = std::move(other);
	EXPECT_TRUE(other.empty());
	EXPECT_EQ(move, (StaticVector{"tiramisu"s}));
	}
	}

	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';

	EXPECT_STREQ(chars.begin(), "abcdefghi");

	// 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);

	// Similar to emplace, but replaces rather than inserts.
	string.replace(string.begin() + 5, '\0');
	EXPECT_STREQ(string.begin(), "12345");

	swap(chars, string);

	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; }
	};

	StaticVector<Pair, 5> pairs;

	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);

	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);

	// 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}}));

	// 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}));

	sums.pop_back();
	std::reverse(sums.begin(), sums.end());

	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();

	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");

	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);
	}

	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());

	std::initializer_list<char> list = {'t', 'a', 'r', 't'};
	strings.replace(rit.base() - 1, list);
	}

	strings.front().assign("pie");

	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;
	};

	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");
	}

	TEST(StaticVector, ReverseTruncate) {
	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();
	}

	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());

	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}));

	// Constructor takes array reference.
	{
	const char* array[] = {"cake", "lie"};
	strings = StaticVector(array);
	}

	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);
	}

	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");

	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); }

	struct {
	int& live;
	int& dead;
	} counts;

	bool alive = true;
	};

	} // namespace

	TEST(StaticVector, Destroy) {
	int live = 0;
	int dead = 0;
	{
	// Empty.
	StaticVector<DestroyCounts, 5> counts;
	}
	EXPECT_EQ(0, live);
	EXPECT_EQ(0, dead);

	{
	// Non-empty.
	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;
	{
	// Copy.
	StaticVector<DestroyCounts, 5> counts;
	counts.emplace_back(live, dead);
	counts.emplace_back(live, dead);
	counts.emplace_back(live, dead);

	const auto copy = counts;
	}
	EXPECT_EQ(6, live);
	EXPECT_EQ(0, dead);

	live = 0;
	{
	// Move.
	StaticVector<DestroyCounts, 5> counts;
	counts.emplace_back(live, dead);
	counts.emplace_back(live, dead);
	counts.emplace_back(live, dead);

	const auto move = std::move(counts);
	}
	EXPECT_EQ(3, live);
	EXPECT_EQ(3, dead);

	live = dead = 0;
	{
	// Swap.
	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);
	counts2.emplace_back(live, dead);

	swap(counts1, counts2);

	EXPECT_EQ(2u, counts1.size());
	EXPECT_EQ(3u, counts2.size());

	EXPECT_EQ(0, live);
	EXPECT_EQ(7, dead); // 3 moves per swap, plus 1 move.

	dead = 0;
	}
	EXPECT_EQ(5, live);
	EXPECT_EQ(0, dead);
	}

	TEST(StaticVector, Clear) {
	int live = 0;
	int dead = 0;
	{
	StaticVector<DestroyCounts, 5> counts;
	counts.emplace_back(live, dead);
	counts.emplace_back(live, dead);

	counts.clear();

	EXPECT_TRUE(counts.empty());
	}
	EXPECT_EQ(2, live);
	EXPECT_EQ(0, dead);
	}

	} // namespace android::test