pw_containers/vector_test.cc - platform/external/pigweed - Gitiles

 // Copyright 2020 The Pigweed Authors
 //
 // 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
 //
 //     https://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 "pw_containers/vector.h"

 #include <vector>

 #include "gtest/gtest.h"

 namespace pw {
 namespace {

 struct CopyOnly {
   explicit CopyOnly(int value) : value(value) {}

   CopyOnly(const CopyOnly& other) { value = other.value; }

   CopyOnly& operator=(const CopyOnly& other) {
     value = other.value;
     return *this;
   }

   CopyOnly(CopyOnly&&) = delete;

   int value;
 };

 struct MoveOnly {
   explicit MoveOnly(int value) : value(value) {}

   MoveOnly(const MoveOnly&) = delete;

   MoveOnly(MoveOnly&& other) {
     value = other.value;
     other.value = kDeleted;
   }

   static constexpr int kDeleted = -1138;

   int value;
 };

 struct Counter {
   static int created;
   static int destroyed;
   static int moved;

   static void Reset() { created = destroyed = moved = 0; }

   Counter() : value(0) { created += 1; }

   Counter(int val) : value(val) { created += 1; }

   Counter(const Counter& other) : value(other.value) { created += 1; }

   Counter(Counter&& other) : value(other.value) {
     other.value = 0;
     moved += 1;
   }

   ~Counter() { destroyed += 1; }

   int value;
 };

 int Counter::created = 0;
 int Counter::destroyed = 0;
 int Counter::moved = 0;

 TEST(Vector, Construct_NoArg) {
   Vector<int, 3> vector;
   EXPECT_TRUE(vector.empty());
 }

 TEST(Vector, Construct_MultipleCopies) {
   Vector<int, 3> vector(3, 123);

   EXPECT_EQ(vector.size(), 3u);
   EXPECT_EQ(vector[0], 123);
   EXPECT_EQ(vector[1], 123);
   EXPECT_EQ(vector[2], 123);
 }

 TEST(Vector, Construct_DefaultSize) {
   Vector<int, 3> vector(3);

   EXPECT_EQ(vector.size(), 3u);
   EXPECT_EQ(vector[0], 0);
   EXPECT_EQ(vector[1], 0);
   EXPECT_EQ(vector[2], 0);
 }

 TEST(Vector, Construct_Iterators) {
   std::array array{1, 2, 3, 4, 5};

   Vector<int, 64> vector(array.begin(), array.end());

   EXPECT_EQ(vector.size(), array.size());
   for (size_t i = 0; i < array.size(); ++i) {
     EXPECT_EQ(vector[i], array[i]);
   }
 }

 TEST(Vector, Construct_Copy) {
   CopyOnly origin(5);
   Vector<CopyOnly, 10> origin_vector(3, origin);

   Vector<CopyOnly, 100> vector(origin_vector);

   EXPECT_EQ(3u, vector.size());

   for (size_t i = 0; i < vector.size(); ++i) {
     EXPECT_EQ(vector[i].value, origin.value);
   }
 }

 TEST(Vector, Construct_Move) {
   Vector<MoveOnly, 10> origin_vector;

   for (int i = 0; i < 5; ++i) {
     origin_vector.emplace_back(421);
   }

   Vector<MoveOnly, 100> vector(std::move(origin_vector));

   EXPECT_EQ(5u, vector.size());

   for (size_t i = 0; i < vector.size(); ++i) {
     EXPECT_EQ(vector[i].value, 421);
   }

   for (size_t i = 0; i < origin_vector.size(); ++i) {
     EXPECT_EQ(origin_vector[i].value, MoveOnly::kDeleted);
   }
 }

 TEST(Vector, Construct_InitializerList) {
   Vector<int, 3> vector{100, 200};
   EXPECT_EQ(vector.size(), 2u);
   EXPECT_EQ(vector[0], 100);
   EXPECT_EQ(vector[1], 200);
 }

 TEST(Vector, Destruct_ZeroLength) {
   Counter::Reset();

   { Vector<Counter, 0> destroyed; }
   EXPECT_EQ(Counter::created, 0);
   EXPECT_EQ(Counter::destroyed, 0);
 }

 TEST(Vector, Destruct_Empty) {
   Counter::Reset();

   { Vector<Counter, 128> destroyed; }
   EXPECT_EQ(Counter::created, 0);
   EXPECT_EQ(Counter::destroyed, 0);
 }

 TEST(Vector, Destruct_MultpileEntries) {
   Counter value;
   Counter::Reset();

   { Vector<Counter, 128> destroyed(100, value); }

   EXPECT_EQ(Counter::created, 100);
   EXPECT_EQ(Counter::destroyed, 100);
 }

 TEST(Vector, Assign_Copy_SmallerToLarger) {
   CopyOnly origin(5);
   Vector<CopyOnly, 3> origin_vector(3, origin);

   Vector<CopyOnly, 2> vector;
   vector = origin_vector;

   EXPECT_EQ(2u, vector.size());

   for (size_t i = 0; i < vector.size(); ++i) {
     EXPECT_EQ(vector[i].value, origin.value);
   }
 }

 TEST(Vector, Assign_DifferentMaxSize_Copy) {
   const Vector<int, 10> origin_vector = {1, 1, 2, 3};

   Vector<int, 100> vector;
   vector = origin_vector;

   ASSERT_EQ(4u, vector.size());
   EXPECT_EQ(1, vector[0]);
   EXPECT_EQ(1, vector[1]);
   EXPECT_EQ(2, vector[2]);
   EXPECT_EQ(3, vector[3]);
 }

 TEST(Vector, Assign_SameMaxSize_Copy) {
   const Vector<int, 10> origin_vector = {1, 1, 2, 3};

   Vector<int, 10> vector;
   vector = origin_vector;

   ASSERT_EQ(4u, vector.size());
   EXPECT_EQ(1, vector[0]);
   EXPECT_EQ(1, vector[1]);
   EXPECT_EQ(2, vector[2]);
   EXPECT_EQ(3, vector[3]);
 }

 TEST(Vector, Assign_Generic_Copy) {
   const Vector<int, 10> origin_vector = {1, 1, 2, 3};

   Vector<int, 10> vector;
   Vector<int>& ref = vector;
   ref = static_cast<const Vector<int>&>(origin_vector);

   ASSERT_EQ(4u, vector.size());
   EXPECT_EQ(1, vector[0]);
   EXPECT_EQ(1, vector[1]);
   EXPECT_EQ(2, vector[2]);
   EXPECT_EQ(3, vector[3]);
 }

 TEST(Vector, Assign_Move) {
   Vector<MoveOnly, 10> origin_vector;

   for (int i = 0; i < 5; ++i) {
     origin_vector.emplace_back(421);
   }

   Vector<MoveOnly, 10> vector;
   vector = std::move(origin_vector);

   EXPECT_EQ(5u, vector.size());

   for (size_t i = 0; i < vector.size(); ++i) {
     EXPECT_EQ(vector[i].value, 421);
   }

   for (size_t i = 0; i < origin_vector.size(); ++i) {
     EXPECT_EQ(origin_vector[i].value, MoveOnly::kDeleted);
   }
 }

 TEST(Vector, Assign_InitializerList) {
   Vector<int, 4> vector;
   vector = {1, 3, 5, 7, 9};

   EXPECT_EQ(4u, vector.size());

   EXPECT_EQ(1, vector[0]);
   EXPECT_EQ(3, vector[1]);
   EXPECT_EQ(5, vector[2]);
   EXPECT_EQ(7, vector[3]);
 }

 TEST(Vector, Access_ZeroLength) {
   Vector<Counter, 0> vector;

   EXPECT_EQ(0u, vector.size());
   EXPECT_EQ(0u, vector.max_size());
   EXPECT_TRUE(vector.empty());
   EXPECT_TRUE(vector.full());

   for (auto& item : vector) {
     (void)item;
     FAIL();
   }
 }

 TEST(Vector, Access_Data_ArrayLocationIsIndependentOfMaxSize) {
   Vector<int, 10> vector;
   Vector<int>& base = static_cast<Vector<int>&>(vector);

   EXPECT_EQ(vector.data(), base.data());
   EXPECT_EQ(vector.data(), (static_cast<Vector<int, 0>&>(base).data()));
   EXPECT_EQ(vector.data(), (static_cast<Vector<int, 1>&>(base).data()));
   EXPECT_EQ(vector.data(), (static_cast<Vector<int, 100>&>(base).data()));
   EXPECT_EQ(vector.data(), (static_cast<Vector<int, 999>&>(base).data()));
 }

 TEST(Vector, Modify_Clear) {
   Counter::Reset();

   Vector<Counter, 100> vector;
   vector.emplace_back();
   vector.emplace_back();
   vector.emplace_back();

   vector.clear();

   EXPECT_EQ(3, Counter::created);
   EXPECT_EQ(3, Counter::destroyed);
 }

 TEST(Vector, Modify_PushBack_Copy) {
   Counter value(99);
   Counter::Reset();

   {
     Vector<Counter, 10> vector;
     vector.push_back(value);

     EXPECT_EQ(vector.size(), 1u);
     EXPECT_EQ(vector.front().value, 99);
   }

   EXPECT_EQ(Counter::created, 1);
   EXPECT_EQ(Counter::destroyed, 1);
 }

 TEST(Vector, Modify_PushBack_Move) {
   Counter::Reset();

   {
     Counter value(99);
     Vector<Counter, 10> vector;
     vector.push_back(std::move(value));

     EXPECT_EQ(vector.size(), 1u);
     EXPECT_EQ(vector.front().value, 99);
     EXPECT_EQ(value.value, 0);
   }

   EXPECT_EQ(Counter::created, 1);
   EXPECT_EQ(Counter::destroyed, 2);
   EXPECT_EQ(Counter::moved, 1);
 }

 TEST(Vector, Modify_EmplaceBack) {
   Counter::Reset();

   {
     Vector<Counter, 10> vector;
     vector.emplace_back(314);

     EXPECT_EQ(vector.size(), 1u);
     EXPECT_EQ(vector.front().value, 314);
   }

   EXPECT_EQ(Counter::created, 1);
   EXPECT_EQ(Counter::destroyed, 1);
 }

 TEST(Vector, Modify_Resize_Larger) {
   Vector<CopyOnly, 10> vector(1, CopyOnly(123));
   vector.resize(3, CopyOnly(123));

   EXPECT_EQ(vector.size(), 3u);
   for (auto& i : vector) {
     EXPECT_EQ(i.value, 123);
   }
 }

 TEST(Vector, Modify_Resize_LargerThanMax) {
   Vector<CopyOnly, 10> vector;
   vector.resize(1000, CopyOnly(123));

   EXPECT_EQ(vector.size(), 10u);
   for (auto& i : vector) {
     EXPECT_EQ(i.value, 123);
   }
 }

 TEST(Vector, Modify_Resize_Smaller) {
   Vector<CopyOnly, 10> vector(9, CopyOnly(123));
   vector.resize(3, CopyOnly(123));

   EXPECT_EQ(vector.size(), 3u);
   for (auto& i : vector) {
     EXPECT_EQ(i.value, 123);
   }
 }

 TEST(Vector, Modify_PopBack) {
   Vector<Counter, 10> vector({Counter(1), Counter(2), Counter(3)});
   Counter::Reset();

   vector.pop_back();

   EXPECT_EQ(vector.size(), 2u);
   EXPECT_EQ(vector[0].value, 1);
   EXPECT_EQ(vector[1].value, 2);

   EXPECT_EQ(Counter::created, 0);
   EXPECT_EQ(Counter::destroyed, 1);
 }

 TEST(Vector, Modify_Resize_Zero) {
   Vector<CopyOnly, 10> vector(10, CopyOnly(123));
   vector.resize(0, CopyOnly(123));

   EXPECT_EQ(vector.size(), 0u);
 }

 TEST(Vector, Generic) {
   Vector<int, 10> vector{1, 2, 3, 4, 5};

   Vector<int>& generic_vector(vector);

   EXPECT_EQ(generic_vector.size(), vector.size());
   EXPECT_EQ(generic_vector.max_size(), vector.max_size());

   int i = 0;
   for (int value : vector) {
     EXPECT_EQ(value, generic_vector[i]);
     i += 1;
   }

   i = 0;
   for (int value : generic_vector) {
     EXPECT_EQ(vector[i], value);
     i += 1;
   }
 }

 }  // namespace
 }  // namespace pw
	// Copyright 2020 The Pigweed Authors
	//
	// 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
	//
	// https://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 "pw_containers/vector.h"

	#include <vector>

	#include "gtest/gtest.h"

	namespace pw {
	namespace {

	struct CopyOnly {
	explicit CopyOnly(int value) : value(value) {}

	CopyOnly(const CopyOnly& other) { value = other.value; }

	CopyOnly& operator=(const CopyOnly& other) {
	value = other.value;
	return *this;
	}

	CopyOnly(CopyOnly&&) = delete;

	int value;
	};

	struct MoveOnly {
	explicit MoveOnly(int value) : value(value) {}

	MoveOnly(const MoveOnly&) = delete;

	MoveOnly(MoveOnly&& other) {
	value = other.value;
	other.value = kDeleted;
	}

	static constexpr int kDeleted = -1138;

	int value;
	};

	struct Counter {
	static int created;
	static int destroyed;
	static int moved;

	static void Reset() { created = destroyed = moved = 0; }

	Counter() : value(0) { created += 1; }

	Counter(int val) : value(val) { created += 1; }

	Counter(const Counter& other) : value(other.value) { created += 1; }

	Counter(Counter&& other) : value(other.value) {
	other.value = 0;
	moved += 1;
	}

	~Counter() { destroyed += 1; }

	int value;
	};

	int Counter::created = 0;
	int Counter::destroyed = 0;
	int Counter::moved = 0;

	TEST(Vector, Construct_NoArg) {
	Vector<int, 3> vector;
	EXPECT_TRUE(vector.empty());
	}

	TEST(Vector, Construct_MultipleCopies) {
	Vector<int, 3> vector(3, 123);

	EXPECT_EQ(vector.size(), 3u);
	EXPECT_EQ(vector[0], 123);
	EXPECT_EQ(vector[1], 123);
	EXPECT_EQ(vector[2], 123);
	}

	TEST(Vector, Construct_DefaultSize) {
	Vector<int, 3> vector(3);

	EXPECT_EQ(vector.size(), 3u);
	EXPECT_EQ(vector[0], 0);
	EXPECT_EQ(vector[1], 0);
	EXPECT_EQ(vector[2], 0);
	}

	TEST(Vector, Construct_Iterators) {
	std::array array{1, 2, 3, 4, 5};

	Vector<int, 64> vector(array.begin(), array.end());

	EXPECT_EQ(vector.size(), array.size());
	for (size_t i = 0; i < array.size(); ++i) {
	EXPECT_EQ(vector[i], array[i]);
	}
	}

	TEST(Vector, Construct_Copy) {
	CopyOnly origin(5);
	Vector<CopyOnly, 10> origin_vector(3, origin);

	Vector<CopyOnly, 100> vector(origin_vector);

	EXPECT_EQ(3u, vector.size());

	for (size_t i = 0; i < vector.size(); ++i) {
	EXPECT_EQ(vector[i].value, origin.value);
	}
	}

	TEST(Vector, Construct_Move) {
	Vector<MoveOnly, 10> origin_vector;

	for (int i = 0; i < 5; ++i) {
	origin_vector.emplace_back(421);
	}

	Vector<MoveOnly, 100> vector(std::move(origin_vector));

	EXPECT_EQ(5u, vector.size());

	for (size_t i = 0; i < vector.size(); ++i) {
	EXPECT_EQ(vector[i].value, 421);
	}

	for (size_t i = 0; i < origin_vector.size(); ++i) {
	EXPECT_EQ(origin_vector[i].value, MoveOnly::kDeleted);
	}
	}

	TEST(Vector, Construct_InitializerList) {
	Vector<int, 3> vector{100, 200};
	EXPECT_EQ(vector.size(), 2u);
	EXPECT_EQ(vector[0], 100);
	EXPECT_EQ(vector[1], 200);
	}

	TEST(Vector, Destruct_ZeroLength) {
	Counter::Reset();

	{ Vector<Counter, 0> destroyed; }
	EXPECT_EQ(Counter::created, 0);
	EXPECT_EQ(Counter::destroyed, 0);
	}

	TEST(Vector, Destruct_Empty) {
	Counter::Reset();

	{ Vector<Counter, 128> destroyed; }
	EXPECT_EQ(Counter::created, 0);
	EXPECT_EQ(Counter::destroyed, 0);
	}

	TEST(Vector, Destruct_MultpileEntries) {
	Counter value;
	Counter::Reset();

	{ Vector<Counter, 128> destroyed(100, value); }

	EXPECT_EQ(Counter::created, 100);
	EXPECT_EQ(Counter::destroyed, 100);
	}

	TEST(Vector, Assign_Copy_SmallerToLarger) {
	CopyOnly origin(5);
	Vector<CopyOnly, 3> origin_vector(3, origin);

	Vector<CopyOnly, 2> vector;
	vector = origin_vector;

	EXPECT_EQ(2u, vector.size());

	for (size_t i = 0; i < vector.size(); ++i) {
	EXPECT_EQ(vector[i].value, origin.value);
	}
	}

	TEST(Vector, Assign_DifferentMaxSize_Copy) {
	const Vector<int, 10> origin_vector = {1, 1, 2, 3};

	Vector<int, 100> vector;
	vector = origin_vector;

	ASSERT_EQ(4u, vector.size());
	EXPECT_EQ(1, vector[0]);
	EXPECT_EQ(1, vector[1]);
	EXPECT_EQ(2, vector[2]);
	EXPECT_EQ(3, vector[3]);
	}

	TEST(Vector, Assign_SameMaxSize_Copy) {
	const Vector<int, 10> origin_vector = {1, 1, 2, 3};

	Vector<int, 10> vector;
	vector = origin_vector;

	ASSERT_EQ(4u, vector.size());
	EXPECT_EQ(1, vector[0]);
	EXPECT_EQ(1, vector[1]);
	EXPECT_EQ(2, vector[2]);
	EXPECT_EQ(3, vector[3]);
	}

	TEST(Vector, Assign_Generic_Copy) {
	const Vector<int, 10> origin_vector = {1, 1, 2, 3};

	Vector<int, 10> vector;
	Vector<int>& ref = vector;
	ref = static_cast<const Vector<int>&>(origin_vector);

	ASSERT_EQ(4u, vector.size());
	EXPECT_EQ(1, vector[0]);
	EXPECT_EQ(1, vector[1]);
	EXPECT_EQ(2, vector[2]);
	EXPECT_EQ(3, vector[3]);
	}

	TEST(Vector, Assign_Move) {
	Vector<MoveOnly, 10> origin_vector;

	for (int i = 0; i < 5; ++i) {
	origin_vector.emplace_back(421);
	}

	Vector<MoveOnly, 10> vector;
	vector = std::move(origin_vector);

	EXPECT_EQ(5u, vector.size());

	for (size_t i = 0; i < vector.size(); ++i) {
	EXPECT_EQ(vector[i].value, 421);
	}

	for (size_t i = 0; i < origin_vector.size(); ++i) {
	EXPECT_EQ(origin_vector[i].value, MoveOnly::kDeleted);
	}
	}

	TEST(Vector, Assign_InitializerList) {
	Vector<int, 4> vector;
	vector = {1, 3, 5, 7, 9};

	EXPECT_EQ(4u, vector.size());

	EXPECT_EQ(1, vector[0]);
	EXPECT_EQ(3, vector[1]);
	EXPECT_EQ(5, vector[2]);
	EXPECT_EQ(7, vector[3]);
	}

	TEST(Vector, Access_ZeroLength) {
	Vector<Counter, 0> vector;

	EXPECT_EQ(0u, vector.size());
	EXPECT_EQ(0u, vector.max_size());
	EXPECT_TRUE(vector.empty());
	EXPECT_TRUE(vector.full());

	for (auto& item : vector) {
	(void)item;
	FAIL();
	}
	}

	TEST(Vector, Access_Data_ArrayLocationIsIndependentOfMaxSize) {
	Vector<int, 10> vector;
	Vector<int>& base = static_cast<Vector<int>&>(vector);

	EXPECT_EQ(vector.data(), base.data());
	EXPECT_EQ(vector.data(), (static_cast<Vector<int, 0>&>(base).data()));
	EXPECT_EQ(vector.data(), (static_cast<Vector<int, 1>&>(base).data()));
	EXPECT_EQ(vector.data(), (static_cast<Vector<int, 100>&>(base).data()));
	EXPECT_EQ(vector.data(), (static_cast<Vector<int, 999>&>(base).data()));
	}

	TEST(Vector, Modify_Clear) {
	Counter::Reset();

	Vector<Counter, 100> vector;
	vector.emplace_back();
	vector.emplace_back();
	vector.emplace_back();

	vector.clear();

	EXPECT_EQ(3, Counter::created);
	EXPECT_EQ(3, Counter::destroyed);
	}

	TEST(Vector, Modify_PushBack_Copy) {
	Counter value(99);
	Counter::Reset();

	{
	Vector<Counter, 10> vector;
	vector.push_back(value);

	EXPECT_EQ(vector.size(), 1u);
	EXPECT_EQ(vector.front().value, 99);
	}

	EXPECT_EQ(Counter::created, 1);
	EXPECT_EQ(Counter::destroyed, 1);
	}

	TEST(Vector, Modify_PushBack_Move) {
	Counter::Reset();

	{
	Counter value(99);
	Vector<Counter, 10> vector;
	vector.push_back(std::move(value));

	EXPECT_EQ(vector.size(), 1u);
	EXPECT_EQ(vector.front().value, 99);
	EXPECT_EQ(value.value, 0);
	}

	EXPECT_EQ(Counter::created, 1);
	EXPECT_EQ(Counter::destroyed, 2);
	EXPECT_EQ(Counter::moved, 1);
	}

	TEST(Vector, Modify_EmplaceBack) {
	Counter::Reset();

	{
	Vector<Counter, 10> vector;
	vector.emplace_back(314);

	EXPECT_EQ(vector.size(), 1u);
	EXPECT_EQ(vector.front().value, 314);
	}

	EXPECT_EQ(Counter::created, 1);
	EXPECT_EQ(Counter::destroyed, 1);
	}

	TEST(Vector, Modify_Resize_Larger) {
	Vector<CopyOnly, 10> vector(1, CopyOnly(123));
	vector.resize(3, CopyOnly(123));

	EXPECT_EQ(vector.size(), 3u);
	for (auto& i : vector) {
	EXPECT_EQ(i.value, 123);
	}
	}

	TEST(Vector, Modify_Resize_LargerThanMax) {
	Vector<CopyOnly, 10> vector;
	vector.resize(1000, CopyOnly(123));

	EXPECT_EQ(vector.size(), 10u);
	for (auto& i : vector) {
	EXPECT_EQ(i.value, 123);
	}
	}

	TEST(Vector, Modify_Resize_Smaller) {
	Vector<CopyOnly, 10> vector(9, CopyOnly(123));
	vector.resize(3, CopyOnly(123));

	EXPECT_EQ(vector.size(), 3u);
	for (auto& i : vector) {
	EXPECT_EQ(i.value, 123);
	}
	}

	TEST(Vector, Modify_PopBack) {
	Vector<Counter, 10> vector({Counter(1), Counter(2), Counter(3)});
	Counter::Reset();

	vector.pop_back();

	EXPECT_EQ(vector.size(), 2u);
	EXPECT_EQ(vector[0].value, 1);
	EXPECT_EQ(vector[1].value, 2);

	EXPECT_EQ(Counter::created, 0);
	EXPECT_EQ(Counter::destroyed, 1);
	}

	TEST(Vector, Modify_Resize_Zero) {
	Vector<CopyOnly, 10> vector(10, CopyOnly(123));
	vector.resize(0, CopyOnly(123));

	EXPECT_EQ(vector.size(), 0u);
	}

	TEST(Vector, Generic) {
	Vector<int, 10> vector{1, 2, 3, 4, 5};

	Vector<int>& generic_vector(vector);

	EXPECT_EQ(generic_vector.size(), vector.size());
	EXPECT_EQ(generic_vector.max_size(), vector.max_size());

	int i = 0;
	for (int value : vector) {
	EXPECT_EQ(value, generic_vector[i]);
	i += 1;
	}

	i = 0;
	for (int value : generic_vector) {
	EXPECT_EQ(vector[i], value);
	i += 1;
	}
	}

	} // namespace
	} // namespace pw