diff --git a/BUILD.gn b/BUILD.gn
index 26e58c0..6ef3c54 100644
--- a/BUILD.gn
+++ b/BUILD.gn
@@ -81,6 +81,7 @@
     "$dir_pw_assert:tests",
     "$dir_pw_base64:tests",
     "$dir_pw_checksum:tests",
+    "$dir_pw_containers:tests",
     "$dir_pw_log:tests",
     "$dir_pw_polyfill:tests",
     "$dir_pw_preprocessor:tests",
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 2c3c59d..f16ca06 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -21,6 +21,7 @@
 add_subdirectory(pw_assert)
 add_subdirectory(pw_base64)
 add_subdirectory(pw_checksum)
+add_subdirectory(pw_containers)
 add_subdirectory(pw_cpu_exception)
 add_subdirectory(pw_cpu_exception_armv7m)
 add_subdirectory(pw_dumb_io)
diff --git a/modules.gni b/modules.gni
index 9bf257b..6138f24 100644
--- a/modules.gni
+++ b/modules.gni
@@ -23,6 +23,7 @@
 dir_pw_boot_armv7m = "$dir_pigweed/pw_boot_armv7m"
 dir_pw_build = "$dir_pigweed/pw_build"
 dir_pw_checksum = "$dir_pigweed/pw_checksum"
+dir_pw_containers = "$dir_pigweed/pw_containers"
 dir_pw_cpu_exception = "$dir_pigweed/pw_cpu_exception"
 dir_pw_cpu_exception_armv7m = "$dir_pigweed/pw_cpu_exception_armv7m"
 dir_pw_docgen = "$dir_pigweed/pw_docgen"
diff --git a/pw_containers/BUILD b/pw_containers/BUILD
new file mode 100644
index 0000000..ee0f194
--- /dev/null
+++ b/pw_containers/BUILD
@@ -0,0 +1,39 @@
+# 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.
+
+load(
+    "//pw_build:pigweed.bzl",
+    "pw_cc_library",
+    "pw_cc_test",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+licenses(["notice"])  # Apache License 2.0
+
+pw_cc_library(
+    name = "pw_containers",
+    hdrs = [
+        "public/pw_containers/vector.h",
+    ],
+    includes = ["public"],
+)
+
+pw_cc_test(
+    name = "vector_test",
+    srcs = [
+        "vector_test.cc",
+    ],
+    deps = ["//pw_containers"],
+)
diff --git a/pw_containers/BUILD.gn b/pw_containers/BUILD.gn
new file mode 100644
index 0000000..eefaa6d
--- /dev/null
+++ b/pw_containers/BUILD.gn
@@ -0,0 +1,40 @@
+# Copyright 2019 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.
+
+import("$dir_pw_unit_test/test.gni")
+
+config("default_config") {
+  include_dirs = [ "public" ]
+}
+
+source_set("pw_containers") {
+  public_configs = [ ":default_config" ]
+  public = [
+    "public/pw_containers/vector.h",
+  ]
+  sources = public
+}
+
+pw_test_group("tests") {
+  tests = [ ":vector_test" ]
+}
+
+pw_test("vector_test") {
+  deps = [
+    ":pw_containers",
+  ]
+  sources = [
+    "vector_test.cc",
+  ]
+}
diff --git a/pw_containers/CMakeLists.txt b/pw_containers/CMakeLists.txt
new file mode 100644
index 0000000..4ee6137
--- /dev/null
+++ b/pw_containers/CMakeLists.txt
@@ -0,0 +1,15 @@
+# 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.
+
+pw_auto_add_simple_module(pw_containers)
diff --git a/pw_containers/public/pw_containers/vector.h b/pw_containers/public/pw_containers/vector.h
new file mode 100644
index 0000000..57f5321
--- /dev/null
+++ b/pw_containers/public/pw_containers/vector.h
@@ -0,0 +1,432 @@
+// 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.
+#pragma once
+
+#include <algorithm>
+#include <cstddef>
+#include <initializer_list>
+#include <iterator>
+#include <new>
+#include <type_traits>
+#include <utility>
+
+namespace pw {
+namespace vector_impl {
+
+template <typename I>
+using IsIterator = std::negation<
+    std::is_same<typename std::iterator_traits<I>::value_type, void>>;
+
+// Used as kMaxSize in the generic-size Vector<T> interface.
+inline constexpr size_t kGeneric = size_t(-1);
+
+}  // namespace vector_impl
+
+// The Vector class is similar to std::vector, except it is backed by a
+// fixed-size buffer. Vectors must be declared with an explicit maximum size
+// (e.g. Vector<int, 10>) but vectors can be used and referred to without the
+// max size template parameter (e.g. Vector<int>).
+//
+// To allow referring to a pw::Vector without an explicit maximum size, all
+// Vector classes inherit from Vector<T, vector_impl::kGeneric>, which stores
+// the maximum size in a variable. This allows Vectors to be used without having
+// to know their maximum size at compile time. It also keeps code size small
+// since function implementations are shared for all maximum sizes.
+template <typename T, size_t kMaxSize = vector_impl::kGeneric>
+class Vector : public Vector<T, vector_impl::kGeneric> {
+ public:
+  using value_type = T;
+  using size_type = size_t;
+  using difference_type = ptrdiff_t;
+  using reference = value_type&;
+  using const_reference = const value_type&;
+  using pointer = T*;
+  using const_pointer = const T*;
+  using iterator = T*;
+  using const_iterator = const T*;
+  using reverse_iterator = std::reverse_iterator<iterator>;
+  using const_reverse_iterator = std::reverse_iterator<const_iterator>;
+
+  // Construct
+  Vector() noexcept : Vector<T, vector_impl::kGeneric>(kMaxSize) {}
+
+  Vector(size_type count, const T& value)
+      : Vector<T, vector_impl::kGeneric>(kMaxSize, count, value) {}
+
+  explicit Vector(size_type count)
+      : Vector<T, vector_impl::kGeneric>(kMaxSize, count, T()) {}
+
+  template <
+      typename Iterator,
+      typename...,
+      typename = std::enable_if_t<vector_impl::IsIterator<Iterator>::value>>
+  Vector(Iterator first, Iterator last)
+      : Vector<T, vector_impl::kGeneric>(kMaxSize, first, last) {}
+
+  template <size_t kOtherMaxSize>
+  Vector(const Vector<T, kOtherMaxSize>& other)
+      : Vector<T, vector_impl::kGeneric>(kMaxSize, other) {}
+
+  template <size_t kOtherMaxSize>
+  Vector(Vector<T, kOtherMaxSize>&& other) noexcept
+      : Vector<T, vector_impl::kGeneric>(kMaxSize, std::move(other)) {}
+
+  Vector(std::initializer_list<T> list)
+      : Vector<T, vector_impl::kGeneric>(kMaxSize, list) {}
+
+  Vector& operator=(const Vector& other) {
+    Vector<T>::assign(other.begin(), other.end());
+    return *this;
+  }
+
+  template <size_t kOtherMaxSize>
+  Vector& operator=(const Vector<T, kOtherMaxSize>& other) noexcept {
+    Vector<T>::assign(other.begin(), other.end());
+    return *this;
+  }
+
+  Vector& operator=(Vector&& other) noexcept {
+    Vector<T>::operator=(std::move(other));
+    return *this;
+  }
+
+  template <size_t kOtherMaxSize>
+  Vector& operator=(Vector<T, kOtherMaxSize>&& other) noexcept {
+    Vector<T>::operator=(std::move(other));
+    return *this;
+  }
+
+  Vector& operator=(std::initializer_list<T> list) {
+    this->assign(list.begin(), list.end());
+    return *this;
+  }
+
+  static constexpr size_type max_size() noexcept { return kMaxSize; }
+
+  // All other vector methods are implemented on the Vector<T> base class.
+
+ private:
+  friend class Vector<T, vector_impl::kGeneric>;
+
+  // Provides access to the underlying array as an array of T.
+  pointer array() { return std::launder(reinterpret_cast<T*>(&array_)); }
+  const_pointer array() const {
+    return std::launder(reinterpret_cast<const T*>(&array_));
+  }
+
+  // Vector entries are stored as uninitialized memory blocks aligned correctly
+  // for the type. Elements are initialized on demand with placement new.
+  std::aligned_storage_t<sizeof(T), alignof(T)> array_[kMaxSize];
+};
+
+// Defines the generic-sized Vector<T> specialization, which serves as the base
+// class for Vector<T> of any maximum size. Except for constructors, all Vector
+// methods are implemented on this class.
+template <typename T>
+class Vector<T, vector_impl::kGeneric> {
+ public:
+  using value_type = T;
+  using size_type = size_t;
+  using difference_type = ptrdiff_t;
+  using reference = value_type&;
+  using const_reference = const value_type&;
+  using pointer = T*;
+  using const_pointer = const T*;
+  using iterator = T*;
+  using const_iterator = const T*;
+  using reverse_iterator = std::reverse_iterator<iterator>;
+  using const_reverse_iterator = std::reverse_iterator<const_iterator>;
+
+  // A vector without an explicit maximum size (Vector<T>) cannot be constructed
+  // directly. Instead, construct a Vector<T, max_size>. Vectors of any max size
+  // can be used through a Vector<T> pointer or reference.
+
+  ~Vector() { clear(); }
+
+  // Assign
+
+  Vector& operator=(const Vector& other) {
+    assign(other.begin(), other.end());
+    return *this;
+  }
+
+  Vector& operator=(Vector&& other) noexcept {
+    clear();
+    MoveFrom(other);
+    return *this;
+  }
+
+  Vector& operator=(std::initializer_list<T> list) {
+    assign(list);
+    return *this;
+  }
+
+  void assign(size_type count, const T& value) {
+    clear();
+    Append(count, value);
+  }
+
+  template <
+      typename Iterator,
+      typename...,
+      typename = std::enable_if_t<vector_impl::IsIterator<Iterator>::value>>
+  void assign(Iterator first, Iterator last) {
+    clear();
+    CopyFrom(first, last);
+  }
+
+  void assign(std::initializer_list<T> list) {
+    assign(list.begin(), list.end());
+  }
+
+  // Access
+
+  // TODO(hepler): Add an assert for bounds checking in at.
+  reference at(size_type index) { return data()[index]; }
+  const_reference at(size_type index) const { return data()[index]; }
+
+  reference operator[](size_type index) { return data()[index]; }
+  const_reference operator[](size_type index) const { return data()[index]; }
+
+  reference front() { return data()[0]; }
+  const_reference front() const { return data()[0]; }
+
+  reference back() { return data()[size() - 1]; }
+  const_reference back() const { return data()[size() - 1]; }
+
+  // The underlying data is not part of the generic-length vector class. It is
+  // provided in the derived class from which this instance was constructed. To
+  // access the data, down-cast this to a Vector with a known max size, and
+  // return a pointer to the start of the array, which is the same for all
+  // vectors with explicit max size.
+  T* data() noexcept { return static_cast<Vector<T, 1>*>(this)->array(); }
+  const T* data() const noexcept {
+    return static_cast<const Vector<T, 1>*>(this)->array();
+  }
+
+  // Iterate
+
+  iterator begin() noexcept { return &data()[0]; }
+  const_iterator begin() const noexcept { return &data()[0]; }
+  const_iterator cbegin() const noexcept { return &data()[0]; }
+
+  iterator end() noexcept { return &data()[size()]; }
+  const_iterator end() const noexcept { return &data()[size()]; }
+  const_iterator cend() const noexcept { return &data()[size()]; }
+
+  reverse_iterator rbegin() noexcept { return reverse_iterator(end()); }
+  const_reverse_iterator rbegin() const { return reverse_iterator(end()); }
+  const_reverse_iterator crbegin() const noexcept {
+    return reverse_iterator(cend());
+  }
+
+  reverse_iterator rend() noexcept { return reverse_iterator(begin()); }
+  const_reverse_iterator rend() const { return reverse_iterator(begin()); }
+  const_reverse_iterator crend() const noexcept {
+    return reverse_iterator(cbegin());
+  }
+
+  // Size
+
+  [[nodiscard]] bool empty() const noexcept { return size() == 0u; }
+
+  [[nodiscard]] bool full() const noexcept { return size() == max_size(); }
+
+  size_type size() const noexcept { return size_; }
+
+  size_type max_size() const noexcept { return max_size_; }
+
+  size_type capacity() const noexcept { return max_size(); }
+
+  // Modify
+
+  void clear() noexcept;
+
+  // TODO(hepler): insert, emplace, and erase are not yet implemented.
+  //    Currently, items can only be added to or removed from the end.
+  iterator insert(const_iterator index, const T& value);
+
+  iterator insert(const_iterator index, T&& value);
+
+  iterator insert(const_iterator index, size_type count, const T& value);
+
+  template <typename Iterator>
+  iterator insert(const_iterator index, Iterator first, Iterator last);
+
+  iterator insert(const_iterator index, std::initializer_list<T> list);
+
+  template <typename... Args>
+  iterator emplace(const_iterator index, Args&&... args);
+
+  iterator erase(const_iterator index);
+
+  iterator erase(const_iterator first, const_iterator last);
+
+  void push_back(const T& value) { emplace_back(value); }
+
+  void push_back(T&& value) { emplace_back(std::move(value)); }
+
+  template <typename... Args>
+  void emplace_back(Args&&... args);
+
+  void pop_back();
+
+  void resize(size_type new_size) { resize(new_size, T()); }
+
+  void resize(size_type new_size, const T& value);
+
+ protected:
+  // Vectors without an explicit size cannot be constructed directly. Instead,
+  // the maximum size must be provided.
+  explicit Vector(size_type max_size) noexcept : max_size_(max_size) {}
+
+  Vector(size_type max_size, size_type count, const T& value)
+      : Vector(max_size) {
+    Append(count, value);
+  }
+
+  Vector(size_type max_size, size_type count) : Vector(max_size, count, T()) {}
+
+  template <
+      typename Iterator,
+      typename...,
+      typename = std::enable_if_t<vector_impl::IsIterator<Iterator>::value>>
+  Vector(size_type max_size, Iterator first, Iterator last) : Vector(max_size) {
+    CopyFrom(first, last);
+  }
+
+  Vector(size_type max_size, const Vector& other) : Vector(max_size) {
+    CopyFrom(other.begin(), other.end());
+  }
+
+  Vector(size_type max_size, Vector&& other) noexcept : Vector(max_size) {
+    MoveFrom(other);
+  }
+
+  Vector(size_type max_size, std::initializer_list<T> list) : Vector(max_size) {
+    CopyFrom(list.begin(), list.end());
+  }
+
+ private:
+  template <typename Iterator>
+  void CopyFrom(Iterator first, Iterator last);
+
+  void MoveFrom(Vector& other) noexcept;
+
+  void Append(size_type count, const T& value);
+
+  const size_type max_size_;
+  size_type size_ = 0;
+};
+
+// Compare
+
+template <typename T, size_t kLhsSize, size_t kRhsSize>
+bool operator==(const Vector<T, kLhsSize>& lhs,
+                const Vector<T, kRhsSize>& rhs) {
+  return std::equal(lhs.begin(), lhs.end(), rhs.begin(), rhs.end());
+}
+
+template <typename T, size_t kLhsSize, size_t kRhsSize>
+bool operator!=(const Vector<T, kLhsSize>& lhs,
+                const Vector<T, kRhsSize>& rhs) {
+  return !(lhs == rhs);
+}
+
+template <typename T, size_t kLhsSize, size_t kRhsSize>
+bool operator<(const Vector<T, kLhsSize>& lhs, const Vector<T, kRhsSize>& rhs) {
+  return std::lexicographical_compare(
+      lhs.begin(), lhs.end(), rhs.begin(), rhs.end());
+}
+
+template <typename T, size_t kLhsSize, size_t kRhsSize>
+bool operator<=(const Vector<T, kLhsSize>& lhs,
+                const Vector<T, kRhsSize>& rhs) {
+  return !(rhs < lhs);
+}
+
+template <typename T, size_t kLhsSize, size_t kRhsSize>
+bool operator>(const Vector<T, kLhsSize>& lhs, const Vector<T, kRhsSize>& rhs) {
+  return rhs < lhs;
+}
+
+template <typename T, size_t kLhsSize, size_t kRhsSize>
+bool operator>=(const Vector<T, kLhsSize>& lhs,
+                const Vector<T, kRhsSize>& rhs) {
+  return !(lhs < rhs);
+}
+
+// Function implementations
+
+template <typename T>
+void Vector<T, vector_impl::kGeneric>::clear() noexcept {
+  for (auto& item : *this) {
+    item.~T();
+  }
+  size_ = 0;
+}
+
+template <typename T>
+template <typename... Args>
+void Vector<T, vector_impl::kGeneric>::emplace_back(Args&&... args) {
+  if (!full()) {
+    new (&data()[size_]) T(std::forward<Args>(args)...);
+    size_ += 1;
+  }
+}
+
+template <typename T>
+void Vector<T, vector_impl::kGeneric>::pop_back() {
+  if (!empty()) {
+    back().~T();
+    size_ -= 1;
+  }
+}
+
+template <typename T>
+void Vector<T, vector_impl::kGeneric>::resize(size_type new_size,
+                                              const T& value) {
+  if (size() < new_size) {
+    Append(std::min(max_size(), new_size) - size(), value);
+  } else {
+    while (size() > new_size) {
+      pop_back();
+    }
+  }
+}
+
+template <typename T>
+template <typename Iterator>
+void Vector<T, vector_impl::kGeneric>::CopyFrom(Iterator first, Iterator last) {
+  while (first != last) {
+    push_back(*first++);
+  }
+}
+
+template <typename T>
+void Vector<T, vector_impl::kGeneric>::MoveFrom(Vector& other) noexcept {
+  for (auto&& item : other) {
+    emplace_back(std::move(item));
+  }
+  other.clear();
+}
+
+template <typename T>
+void Vector<T, vector_impl::kGeneric>::Append(size_type count, const T& value) {
+  for (size_t i = 0; i < count; ++i) {
+    push_back(value);
+  }
+}
+
+}  // namespace pw
diff --git a/pw_containers/vector_test.cc b/pw_containers/vector_test.cc
new file mode 100644
index 0000000..5e214d1
--- /dev/null
+++ b/pw_containers/vector_test.cc
@@ -0,0 +1,429 @@
+// 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